Перевести на стандартный С++

class TActivator;
typedef void (__closure *TTriggerProc)(TActivator *Sender);
struct TRecepient{
      TTriggerProc OnProc;
      TTriggerProc OffProc;
 
};
class TTrigger(){
....
    std::vector<TRecepient> Rcepients;
....
    void On(TActivator *Activator){
           for (int i=0;i<Recepients.size();i++){
                 if (Recepients[i].OnProc) Recepients[i].OnProc(Activator);
          }
     void Off(TActivator *Activator){
           for (int i=0;i<Recepients.size();i++){
                 if (Recepients[i].OffProc) Recepients[i].OffProc(Activator);
          }
}

class TActivator;
typedef void (*TTriggerProc)(void *Object,TActivator *Sender);
struct TRecepient{
      void *Object
      TTriggerProc OnProc;
      TTriggerProc OffProc;
 
};
class TTrigger(){
....
    std::vector<TRecepient> Rcepients;
....
    void On(TActivator *Activator){
           for (int i=0;i<Recepients.size();i++){
                 if (Recepients[i].OnProc) Recepients[i].OnProc(Recepients[i].Object,Activator);
          }
     }
     void Off(TActivator *Activator){
           for (int i=0;i<Recepients.size();i++){
                 if (Recepients[i].OffProc) Recepients[i].OffProc(Recepients[i],Activator);
          }
      }
}

typedef void (__closure *TTriggerProc)(TActivator *Sender);
class Foo{
        void On(TActivator *Sender);
        void Off(TActivator *Sender);
}
void main(){
      Foo Bar;
      TTriggerProc OnProc=Bar.On;
      TTriggerProc OffProc=Bar.Off;
      OnProc(nullptr);
      OffProc(nullptr);
}

#include <functional>
 
//....
typedef std::function<void(TActivator*)> TTriggerProc;
//...
class Object {
public:
    void func(TActivator*);
//...
};
using namespace std::placeholders;
Object* o;
TTriggerProc f1 = std::bind(&Object::func, o, _1);
TTriggerProc f2 = [o](TActivator* x)->void {
    //...
    o->func(x);
};

struct __closure{
   void *Data;
   void *Code;
}

void main(){
      Foo Bar;
      Foo Bar2;
      TTriggerProc OnProc=Bar.On;
      TTriggerProc OffProc=Bar2.Off;
      OnProc(nullptr);
      OffProc(nullptr);
}

class A{
        AOn(TActivator *Activator);
};
class B{
        BOn(TActivator *Activator);
};
A a;
B b;
TTrigger Proc=a.Aon; // будет работать;
Proc=b.Bon;//тоже будет;
Proc=b.Aon;  //ошибка будет.

#include <iostream>
#include <boost/signals2.hpp>
#include <boost/bind.hpp>
 
class Archivator
{
   public:
     Archivator(const std::string& name):name_(name){};
     std::string name()const {return name_;}
     
   private:
     std::string name_;    
};
 
enum class State{ on,off };
 
class Recepient
{
  public:
     Recepient(const std::string& name):name_(name){};
     
     void onArchivatorStateChanged(Archivator* archivator,State state)
     {
       std::cout<<name_<<" "
                <<archivator->name()<<" "
                <<(state==State::on?"on":"off")<<std::endl; 
     }
   
   private:
     std::string name_;       
};
 
class Trigger
{
   public:
     boost::signals2::signal<void(Archivator*,State)> onChangeState;      
 
     void changeState(Archivator* archivator,State state)
     {
       onChangeState(archivator,state);
     }
};
//----------------------------------------------------------
int main()
{
Archivator a1("a1"); 
Archivator a2("a2");
 
Recepient r1("r1");
Recepient r2("r2");
 
Trigger t;
// Подписка
t.onChangeState.connect(boost::bind(&Recepient::onArchivatorStateChanged,r1,_1,_2));
t.onChangeState.connect(boost::bind(&Recepient::onArchivatorStateChanged,r2,_1,_2));
// Вызов события/сигнала
t.changeState(&a1,State::on);
t.changeState(&a2,State::on);
 
t.changeState(&a1,State::off);
 
return 0;
}
//----------------------------------------------------------

typedef std::function<void(TCharacter * Character)> TTriggerProc;
class TTrigger : public TControlledObject {
...
void AddReceiver(TControlledObject* Object, TTriggerProc OnProc,
            TTriggerProc OffProc);
...
}
TDoor::TDoor()      
    {
                 //...
        Trigger->AddReceiver(this, [this](TCharacter * aCharacter)->void {this->Open(aCharacter);}, 
                                                      [this](TCharacter * aCharacter)->void{this->Close(aCharacter);});
    };

if(!f.empty()) 
  f();

f.сlear();

f= 0;

Trigger->AddReceiver(this, [this](TCharacter * aCharacter)->{this->Open(aCharacter);}, 
                                                      [this](TCharacter * aCharacter)->{this->Close(aCharacter);});

void DoorOpen(TControlledObject *Object, TCharacter *Activator){
        ((TDoor *)Object)->Open(Activator);
    }
    void DoorClose(TControlledObject *Object, TCharacter *Activator){
        ((TDoor *)Object)->Close(Activator);
    }
 
    TDoor::TDoor(TGame * aGame, T3DCoordf aPosition, T3DCoordf aDimensions,
        T3DCoordf aDirection, float aSpeed, TMesh * aMesh)
        : TControlledObject(aGame, aPosition, aDimensions, aDirection, 0, aMesh)
    {
            //......
                Trigger->AddReceiver(this, DoorOpen,DoorClose);
    };

struct example: receive<some>
{
    void ReadMessage(const some&){ ... }
};
 
int main()
{
    // в момент своего создания, 
    // автоматически подписывается на получение сообщений
    example obj; 
 
    // запустит obj.ReadMessage(some_object);
    // для всех объектов-подписчиков,
    // у которых есть метод ReadMessage(some)
    // или аналогичные, но работающие с ссылками.
    SendMessage( some(param) );
 
    // проверки на ошибки, 
    // детект необходимых функций-членов,
    // регистрация класса-подписчика,
    // генерация транспортной магистрали 
    // происходит автоматически
    // времени компиляции
 
    // что делает статическую систему сообщений
    // чрезвычайно быстрой по скорости работы в рантайме
 
    // в рантайме есть только одна возможная ошибка
    // от которой не существует защиты:
    // если объект будет перемещен по новому адресу
    // при помощи memcpy, например
    // то сообщение будет отправленно по невалидному адресу
 
    // std::function, boost::signals - все  они страдают от этой проблемы
}