C ++에서 델리게이트를 달성하기위한 수많은 선택이 있습니다. 여기 내 마음에 온 것들이 있습니다.

옵션 1 : 펑터 :

함수 객체는 다음을 구현하여 만들 수 있습니다. operator()

struct Functor
{
     // Normal class/struct members

     int operator()(double d) // Arbitrary return types and parameter list
     {
          return (int) d + 1;
     }
};

// Use:
Functor f;
int i = f(3.14);

옵션 2 : 람다 식 ( C ++ 11 만 해당)

// Syntax is roughly: [capture](parameter list) -> return type {block}
// Some shortcuts exist
auto func = [](int i) -> double { return 2*i/1.15; };
double d = func(1);

옵션 3 : 함수 포인터

int f(double d) { ... }
typedef int (*MyFuncT) (double d);
MyFuncT fp = &f;
int a = fp(3.14);

옵션 4 : 멤버 함수에 대한 포인터 (가장 빠른 솔루션)

코드 프로젝트 에서 Fast C ++ Delegate를 참조하십시오 .

struct DelegateList
{
     int f1(double d) { }
     int f2(double d) { }
};

typedef int (DelegateList::* DelegateType)(double d);

DelegateType d = &DelegateList::f1;
DelegateList list;
int a = (list.*d)(3.14);

옵션 5 : 표준 :: 기능

(또는 boost::function표준 라이브러리가 지원하지 않는 경우). 느리지 만 가장 유연합니다.

#include <functional>
std::function<int(double)> f = [can be set to about anything in this answer]
// Usually more useful as a parameter to another functions

옵션 6 : 바인딩 ( std :: bind 사용 )

예를 들어 멤버 함수를 호출하는 데 편리한 일부 매개 변수를 미리 설정할 수 있습니다.

struct MyClass
{
    int DoStuff(double d); // actually a DoStuff(MyClass* this, double d)
};

std::function<int(double d)> f = std::bind(&MyClass::DoStuff, this, std::placeholders::_1);
// auto f = std::bind(...); in C++11

옵션 7 : 템플릿

인수 목록과 일치하는 한 아무 것도 허용하십시오.

template <class FunctionT>
int DoSomething(FunctionT func)
{
    return func(3.14);
}

답변

template <class T>
class CCallback
{
public:
    typedef void (T::*fn)( int anArg );

    CCallback(T& trg, fn op)
        : m_rTarget(trg)
        , m_Operation(op)
    {
    }

    void Execute( int in )
    {
        (m_rTarget.*m_Operation)( in );
    }

private:

    CCallback();
    CCallback( const CCallback& );

    T& m_rTarget;
    fn m_Operation;

};

class A
{
public:
    virtual void Fn( int i )
    {
    }
};


int main( int /*argc*/, char * /*argv*/ )
{
    A a;
    CCallback<A> cbk( a, &A::Fn );
    cbk.Execute( 3 );
}

class SomeClass
{
    in someMember;
    int SomeFunc( int);

    static void EventFunc( void* this__, int a, int b, int c)
    {
        SomeClass* this_ = static_cast< SomeClass*>( this__);

        this_->SomeFunc( a );
        this_->someMember = b + c;
    }
};

void ScheduleEvent( void (*delegateFunc)( void*, int, int, int), void* delegateContext);

    ...
    SomeClass* someObject = new SomeObject();
    ...
    ScheduleEvent( SomeClass::EventFunc, someObject);
    ...