实现一个高效C++委托类(多分派)

乱七八糟，有空再整理。

---

1、暂命名为Functor，因为没考虑返回值的情况，这在多分派委托处理中，算是个麻烦事，以后类名可能改为Delegate。
2、根据i_like_cpp翻译的技术文章《 成员函数指针与高性能的C++委托》提供的思路做成的，不过原文所提到的FastDelegate实现太复杂，所以自己做了一个，可能不完善，不过初步测试基本功能达到了，而且实现要简单一些。
3、原本vector遍历用的是迭代器，不过测试发现速度比用下标访问慢10倍以上，改成下标访问，测试表明速度已经和直接调用差不多。实际测试结果非常相近，用GetTickCount获取的结果，有时是直接调用要快一些，有时是使用Functor要快一些，当然Functor不可能比直接调用还快。
4、实现没有写完，先写了3个版本做测试用，成型以后会实现更多版本(支持更多参数)。下午一时心血来潮写成的，离成型还很远，不过从效率测试来看值得做。

#include  < vector >  
#include  < functional >  
#include  < iostream >  
#include  < string >  
#include  < windows.h >  
using   namespace  std; 

struct  Test 
{ 
    int n; 
    Test () : n(3) {} 
    void test0() 
    { 
        //cout << "Test::test0: " << n << endl; 
    } 

    void test1(int i) 
    { 
        //cout << "Test::test1: " << i << endl; 
    } 

    void test2(const string& a, int b) 
    { 
        //cout << "Test::test2: " << a << "|" << b << endl; 
    } 
} ; 

void  test0 () 
{ 
    //cout << "test0" << endl; 
}  

void  test1 ( int  i) 
{ 
    //cout << "test1: " << i << endl; 
}  

void  test2( const   string &  a,  int  b) 
{ 
    //cout << "test2: " << a << "|" << b << endl; 
}  

struct  NullType  {} ; 

template  < typename R, typename A = NullType, typename B = NullType, typename C = NullType, 
typename D = NullType, typename E = NullType, typename F = NullType, typename G = NullType, 
typename H = NullType, typename I = NullType, typename J = NullType, typename K = NullType, 
typename L = NullType, typename M = NullType, typename N = NullType, typename O = NullType >  
class  Functor 
{ 
} ; 

template  < typename R >  
struct  Functor  < R >  
{ 
    vector <pair<void*, void*> > _handlers; 
    typedef R(*F)(); 

    void add (F f) 
    { 
        _handlers.push_back (make_pair ((void*)0, (void*)f)); 
    } 

    template <typename T> 
    void add (const pair<T*, typename R(T::*)()>& f) 
    { 
        typedef R(T::*P)(); 
        struct Pointer {P p;}; 
        Pointer ptr = {f.second}; 
        _handlers.push_back (make_pair ((void*)f.first, *(void**)&ptr)); 
    } 

    void call () 
    { 
        for (size_t i=0; i<_handlers.size (); i++) 
        { 
            void* p = _handlers[i].first; 
            if (p) // member function 
            { 
                void* mem_fun = _handlers[i].second; 
                __asm{ 
                    mov ecx, p 
                    call mem_fun 
                } 
            } 
            else 
            { 
                (*(F)_handlers[i].second)(); 
            } 
        } 
    } 
} ; 

template  < typename R, typename A >  
struct  Functor  < R, A >  
{ 
    vector <pair<void*, void*> > _handlers; 
    typedef R(*F)(A); 

    void add (F f) 
    { 
        _handlers.push_back (make_pair ((void*)0, (void*)f)); 
    } 

    template <typename T> 
    void add (const pair<T*, typename R(T::*)(A)>& f) 
    { 
        typedef R(T::*P)(A); 
        struct Pointer {P p;}; 
        Pointer ptr = {f.second}; 
        _handlers.push_back (make_pair ((void*)f.first, *(void**)&ptr)); 
    } 

    void call (A a) 
    { 
        for (size_t i=0; i<_handlers.size (); i++) 
        { 
            void* p = _handlers[i].first; 
            if (p) // member function 
            { 
                void* mem_fun = _handlers[i].second; 
                __asm{ 
                    push a 
                    mov ecx, p 
                    call mem_fun 
                } 
            } 
            else 
            { 
                (*(F)_handlers[i].second)(a); 
            } 
        } 
    } 
} ; 

template  < typename R, typename A, typename B >  
struct  Functor  < R, A, B >  
{ 
    vector <pair<void*, void*> > _handlers; 
    typedef R(*F)(A, B); 

    void add (F f) 
    { 
        _handlers.push_back (make_pair ((void*)0, (void*)f)); 
    } 

    template <typename T> 
    void add (const pair<T*, typename R(T::*)(A, B)>& f) 
    { 
        typedef R(T::*P)(A, B); 
        struct Pointer {P p;}; 
        Pointer ptr = {f.second}; 
        _handlers.push_back (make_pair ((void*)f.first, *(void**)&ptr)); 
    } 

    void call (A a, B b) 
    { 
        for (size_t i=0; i<_handlers.size (); i++) 
        { 
            void* p = _handlers[i].first; 
            if (p) // member function 
            { 
                void* mem_fun = _handlers[i].second; 
                __asm{ 
                    push b 
                    push a 
                    mov ecx, p 
                    call mem_fun 
                } 
            } 
            else 
            { 
                (*(F)_handlers[i].second)(a, b); 
            } 
        } 
    } 
} ; 


int  main( int  argc,  char *  argv[]) 
{ 
    Test t; 
    DWORD cur = GetTickCount (); 
    for (int i=0; i<10000000; i++) 
    { 
        t.test0(); 
    } 
    cout << (GetTickCount() - cur) << endl; 

    Functor <void> f; 
    f.add (make_pair(&t, &Test::test0)); 
    f.add (test0); 
    cur = GetTickCount (); 
    for (int i=0; i<1000000; i++) 
    { 
        f.call(); 
    } 
    cout << (GetTickCount() - cur) << endl; 

    f.call ();

    Functor<void, int> f1; 
    f1.add (test1); 
    f1.add (make_pair (&t, &Test::test1)); 
    f1.add (test1); 
    f1.add (test1); 
    f1.call (93); 

    Functor<void, const string&, int> f2; 
    f2.add (test2); 
    f2.add (make_pair (&t, &Test::test2)); 
    f2.add (test2); 
    f2.add (test2); 
    f2.call (string("hello"), 5); 
    return 0; 
}  

转载于:https://www.cnblogs.com/cpunion/archive/2005/07/22/198288.html