Russian Qt Forum

class Base {
   typedef void (Base::*delegate)(SomeClass1 * obj1, SomeClass2 * obj2); //сигнатура делегата
   QHash<QString,delegate>  fdelegateHash;
protected:
  void registerDelegate(const QString & delegateId, delegate delegatePtr);
public:
void   executeDelegate(const QString & delegateName, SomeClass1 * obj, SomeClass2 * obj2);
};

#include <iostream>
#include <functional>
using namespace std;

//предположим у нас есть GUI библиотека 
//при помощи которой мы можем создавать кнопки
//однако такие библиотечные классы ничего не знают о классах целевого бизнес-приложения
struct Button
{
    typedef std::function<void()>
        EventClick;
    
    EventClick mEventClick;
    
    //имитируем "клик" на кнопке.
    void SimulationClick()const
    {
        cout<<"GUI: Click!\n";
        
        //когда кнопка впадает в состояние "меня кликнули", 
        //она должна испустить сигнал - предупредить о факте клика заинтересованные объекты бизнес-приложения.
        
        //делегат позволяет зделать это, без необходимости знать о точных типах получателей события
        if(mEventClick)
            mEventClick();
    }
    
};


//а этот класс - часть бизнес-модели приложения
//модель никак не связанна с GUI, и ничего не знает о её классах
//ровно, как и GUI ничего не знает о модели
struct Model
{
    //модель реализует поведение на нажатие кнопки.
    //точный тип кнопки при этом не имеет значение.
    //природа источника события не имеет значения.
    void OnClick()const 
    {
        cout<<"Model:button was click\n"; 
    }
};


//бизнес-приложение
int main()
{
    std::cout << "Hello, world!\n";
    
    //здесь мы создаем GUI, и модель.
    //И устанавливаем между ними связь.
    
    //Обратите внимание: 
    //изначально, ни модель ни GUI не подозревают о существовании друг друга.
    
    //Для организации взаимодействия между ними используется технология делегатов.
    
    Button button;
    Model model;
    
    
    //заряжаем делегат. 
    button.mEventClick = [&model](){ model.OnClick(); };
    
    //теперь, когда на кнопку нажмут, она дернет делегат, который дернет лямбду, которая дернет модель.
    
    
    // есть и другие способы передачи сигнала. Например:
    button.mEventClick = std::bind(&Model::OnClick, &model);
    
    //используя шаблонную магию, бинд генерирует функтор, по своему действию аналогичный лямбде.
    //суть проста: std::function это просто тонкая обертка над функторами, 
    //которые дергают функции или функции-члены получателей сообщения
    
    //теперь имитирует нажатие на кнопку:
    
    button.SimulationClick();
}

#include <iostream>
#include <functional>
using namespace std;


struct CustomFunctor
{
    bool operator()(int v)const { return v%2 == 0; }
};

int main()
{
    std::cout << "Hello, world!\n";
    
    
    //умеет запускать любые функции/функции-члены
    //которые возвращают тип bool
    //и принимают тип int
    typedef std::function<bool(int)>
        Executer;
    
    
    //инициализируем делегат кастомным функтором
    
    //ПРИМЕЧАНИЕ: operator() функтора 
    //должен соотвествовать типу функции bool(int)
    //проверка типов выполняется времени компиляции
    
    Executer ex = CustomFunctor();
    
    
    //теперь можно запускать
    const bool result1 = ex(10);
    const bool result2 = ex(11);
    
    if(result1)
        cout<<"ex(10) is true\n";
    else
        cout<<"ex(10) is false\n";
    
    if(result2)
        cout<<"ex(11) is true\n";
    else
        cout<<"ex(11) is false\n";
}

class CBaseClass {

 //приватные данные для этого класса
 int private_base_data;

 {virtual?} void click(ClassA * param)  = 0;//сигнатура обработчика

 QHash<QString,click> hash;

 void registerClick(QString name, click func) { hash[name]=func; }

 void callClick(QString name, ClassA * objectA) {
 click func = hash.value(name);
 if(func)
 func(objectA);
 }

};

class CDerivedClass : public CBaseClass 
{
 int private_derived_data;

 void click1(ClassA * param);
 void click2(ClassA * param);
 ...
 void clickN(ClassA * param);
};

class CDerivedClass2 : public CDerivedClass 
{
 int private_derived2_data;
 void click2_1(ClassA * param);
 ...
 void click2_N(ClassA * param);
};

gcc:QMAKE_CXXFLAGS += -std=c++11

class QRailItem; //графический элемент на сцене

class CBaseController {
   typedef  std::function<void(QRailItem*)> ClickHandlerFunc;
   QHash<QString,ClickHandlerFunc>                   fclickHahdlers;
protected:
   void    setClickHandlerForButton(const QString & role, ClickHandlerFunc handler);
private slots:
   void    handleViewItemClick();      //обработка нажатия на граф.объект
};

void CBaseController ::setClickHandlerForButton(const QString &role, CRailController::ClickHandlerFunc handler)
{
    fclickHahdlers[role] = handler;
}

void CRailController::handleViewItemClick()
{
    QRailItem       *   railItemView = qobject_cast<QRailItem*>(sender());  //получаем отправителя
    if(railItemView && railItemView->controllerLink())                      //если есть
    {
        try
        {
            ClickHandlerFunc func = fclickHahdlers.value(railItemView->referenceRole());
            if(func)
                func(railItemView);
        }
        catch(std::bad_function_call call)
        {
            qDebug("bad function call %s",call.what());
        }
    }
}

class CDerivedController : public CBaseController
{
    void    sendCommandI(QRailItem *eventSource);
    void    sendCommandOI(QRailItem *eventSource);
    void    sendCommandZP(QRailItem *eventSource);
}

CDerivedController::CDerivedController():CBaseController()
{
    ClickHandlerFunc    f = std::bind(&CRailCrossController::sendCommandI);//ругатется здесь
    setClickHandlerForButton(iBtnRole,f);
}

TConnector<R(int)> tcon(obj, &Some::Method);

//--- обратите внимание: динамический делегат не является продуктом шаблона
Connector con(obj, &Some::Method);