Вариант универсального указателя., C++ (gcc)

Вариант универсального указателя.

/******************************************************************************
*   Kartonagnick©                                                             *
*   Пример простейшего делегата.                                              *
******************************************************************************/

#include <iostream>

//--- для тестов ----
void freeFunc() { std::cout<<"freeFunc();\n"; }

struct rabbit1
{
    void foo(){ std::cout<<"rabbit1::foo();\n"; }
};
struct rabbit2
{
    void foo()const{ std::cout<<"rabbit2::foo()const;\n"; }
};
struct rabbit3
{
    void foo()     { std::cout<<"rabbit3::foo();\n"; }
    void foo()const{ std::cout<<"rabbit3::foo()const;\n"; }
};

struct functor1
{
    void operator()(){ std::cout<<"functor1();\n"; }
};

struct functor2
{
    void operator()()const{ std::cout<<"functor2()const;\n"; }
};

struct functor3
{
    void operator()()     { std::cout<<"functor3();\n"; }
    void operator()()const{ std::cout<<"functor3()const;\n"; }
};

//---------------------------------------------------------------

//--- детали реализации простейшего делегата
namespace detail{

struct empty;
    
    struct icaller
    {
        virtual ~icaller(){}
        virtual void operator()()const = 0;
        
        virtual icaller* clone()const = 0;
    };
    
    template<class F,class O = empty>
    struct tcaller: icaller
    {
        tcaller(O o, const F& f) : mObj(o), mMethod(f)
        {}
            
        void operator()()const { (mObj.*mMethod)(); }
        
        
        virtual tcaller* clone()const 
            { return new tcaller(mObj, mMethod); }
        
        mutable O mObj;
        mutable F mMethod;
    };
    
    template<class F>
    struct tcaller<F, empty>: icaller
    {
        tcaller(const F& f) : mFunctor(f) {} 
        void operator()()const { mFunctor(); }
        
        virtual tcaller* clone()const 
            { return new tcaller(mFunctor); }

mutable F mFunctor;
    };
    
}//namespace detail

// --- собственно сам делегат
// синтаксис: 
//     connector con = функция;
//     connector con = функор;
//     connector con(объект, указатель_на_метод);

struct connector
{
   ~connector() { delete caller; }

template<class F> connector(const F& f)
        : caller( new detail::tcaller<F>(f) )    
    {}
    
    template<class O, class F> connector(O& o, const F& f)
        : caller( new detail::tcaller<F, O&>(o, f) )    
    {}
    template<class O, class F> connector(const O& o, const F& f)
        : caller( new detail::tcaller<F, const O&>(o, f) )    
    {}
    
    void operator()()const { (*caller)(); }
    
    
    connector(const connector& src)
        :caller( src.caller->clone() )
    {}
    
    const connector& operator=(const connector& src)
    { 
        caller = src.caller->clone();
        return *this;
    }
    
    detail::icaller* 
        caller;
    
};

// --- использование:

int main()
{   setlocale(LC_CTYPE, "rus");

std::cout << "Hello, world!\n";
    
        std::cout<<"запускаем свободную функцию\n";
    connector conFree = &freeFunc; 
        conFree();
    
        std::cout<<"запускаем функтор, у которого нет константной версии метода\n";
        functor1 f1;
    connector conFunctor1 = f1; 
        conFunctor1();
    
        std::cout<<"запускаем функтор, у которого нет не константной версии метода\n";
        functor2 f2;
    connector conFunctor2 = f2; 
        conFunctor2();
    
        std::cout<<"запускаем функтор, у которого есть оби версии методов\n";
        functor3 f3;
    connector conFunctor3 = f3; 
        conFunctor3();
    
        std::cout<<"запускаем не константный метод класса\n";
        rabbit1 r1;
    connector conRabbit1(r1, &rabbit1::foo);
        conRabbit1();
    
        std::cout<<"запускаем константный метод класса\n";
        rabbit2 r2;
    connector conRabbit2(r2, &rabbit2::foo);
        conRabbit2();
    
        std::cout<<"запускаем не константный метод класса\n";
        rabbit3 r3;
        typedef void(rabbit3::*method)();
    connector conRabbit3(r3,  (method) &rabbit3::foo);
        conRabbit3();
    
        std::cout<<"запускаем константный метод класса\n";
        rabbit3 r4;
        typedef void(rabbit3::*cmethod)()const;
    connector conRabbit4(r4,  (cmethod) &rabbit3::foo);
        conRabbit4();
    
    
        std::cout<<"запускаем метод константного объекта\n";
        const rabbit3 r5;
    connector conRabbit5(r5, (cmethod) &rabbit3::foo);
        conRabbit5();
        
        using namespace std;
        cout<<"\n\nСобсно здесь работает сам энтот указатель\n\
opsooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo\n";
        connector p[] =
            {   conFree,
                conFunctor1,
                conFunctor2,
                conFunctor3,
                conRabbit1,
                conRabbit2,
                conRabbit3,
                conRabbit4
            };
        
        for(unsigned i = 0; i < sizeof(p)/sizeof(p[0]); ++i)
           cout << i << " --- ", p[i]();

//system("pause");
}


run \| edit \| history \| help	0