Реализация аналога делегатов из C#

template <typename ResultType, typename ...ArgumentTypes>
class Delegate
{
public:
    typedef ResultType (*SignatureType)(ArgumentTypes...);
 
    Delegate() {}
 
    Delegate(SignatureType func)
    {
        functions.push_back(func);
    }
 
    ResultType operator()(ArgumentTypes... args)
    {
        for (size_t i = 0; i < functions.size() - 1; i++)
            functions[i](args...);
        return functions[functions.size() - 1](args...);
    }
 
    SignatureType operator=(SignatureType func)
    {
        functions.push_back(func);
        return func;
    }
 
    SignatureType operator+=(SignatureType func)
    {
        functions.push_back(func);
        return func;
    }
 
    SignatureType operator-=(SignatureType func)
    {
        functions.remove(func);
        return func;
    }
 
private:
    std::list<SignatureType> functions;
};

ResultType operator()(ArgumentTypes... args)
    {
        for (size_t i = 0; i < functions.size() - 1; i++)
            functions[i](args...);
        return functions[functions.size() - 1](args...);
    }

ResultType operator()(ArgumentTypes... args)
    {
        auto end = functions.cend(); --e;
        for (const auto current = functions.cbegin(); current!=end; ++i)
            (*current)(args...);
        return (*end)(args...);
    }

ResultType rv; 
for(auto fptr: functions)
    rv = fptr(std::forward<ArgumentTypes>(args)...);
return rv;

ResultType operator()(ArgumentTypes... args)
    {
        for (size_t i = 0; i < functions.size() - 1; i++)
            functions[i](args...);
        return functions[functions.size() - 1](args...);
    }

#include <iostream>
#include <memory>
#include <string>
 
template <class R, class... Args> struct ILauncher
{
    virtual ~ILauncher(){}
    virtual R operator()(Args&&...)const = 0;
};
 
template <class F, class R, class... Args> 
struct Function: public ILauncher<R, Args...>
{
    Function(F& f):mFunc(f){}
    
    R operator()(Args&&... args)const
        { return mFunc(std::forward<Args>(args)... ); }
private:
    F mFunc;
};
 
template <class O, class F, class R, class... Args> 
struct Method: public ILauncher<R, Args...>
{
    Method(O& o, F& f)
        :mObj(std::forward<O>(o))
        ,mFunc(f)
    {}
    
    R operator()(Args&&... args)const
        { return (mObj.*mFunc)(std::forward<Args>(args)... ); }
private:
    O mObj;
    F mFunc;
};
 
 
// --- главный шаблон не нуждается в туловище
template <class T> class Delegate;
    
    
// --- специализация для случая, когда делегат
// бал параметризирован типом функции    
template <class R, class... Args> 
class Delegate<R(Args...)>
{
    typedef ILauncher<R, Args...>
        ILauncher_;
    
    typedef std::shared_ptr<ILauncher_>
        SLauncher;
    
public:
    template<class F>
    Delegate(F&& f)
        : mLauncher(std::make_shared<Function<F, R, Args...> >(f) )
    {};
 
    template<class O, class F>
    Delegate(O&& o, F&& f)
        : mLauncher(std::make_shared<Method<O, F, R, Args...> >( std::forward<O>(o), f) )
    {};
    
    
    R operator()(Args&&... args)const
        { return (*mLauncher)(std::forward<Args>(args)... ); }
    
private:
    SLauncher mLauncher;
    
};    
 
// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
// -------------------------------------------------------------------------
 
#ifndef OUT_TO_STREAM
    #define OUT_TO_STREAM(type_)  \
        template<class T>friend   \
        ::std::basic_ostream<T>&  \
        operator<<(::std::basic_ostream<T>& os, const type_& obj )
#endif
 
 
int foo(int v) { 
    std::cout<<"[function foo("<<v<<"); was executed, and returned " << v*2<<']'; 
    return v*2; 
} 
 
struct sample
{
    OUT_TO_STREAM(sample)
    {
        return os << "name: " << obj.mName <<" : age: " << obj.mAge;
    }
    
    sample(){ std::cout<<"sample was build\n"; }
    sample(const sample&){ std::cout<<"sample was copied\n"; }
    sample(sample&&){ std::cout<<"sample was moved\n"; }
 
    int bar(const sample& v)const { 
        std::cout<<"[method sample::bar("<<v<<"); was executed, and returned " << mAge <<']'; 
        return mAge; 
    } 
    
    std::string mName="Volrajas";
    size_t      mAge=25;
};
 
int main()
{
    std::cout << "Hello, world!\n";
    
    Delegate<int(int)> call1 = foo;
    std::cout<<" response: "<< call1(10) << std::endl;
    
    sample s;
    Delegate<int(const sample&)> call2(s, &sample::bar);
    std::cout<<" response: "<< call2(s) << std::endl;
    
    Delegate<int(bool)> call3 = [](bool b)
    { 
        std::cout<< "[lambda("<< (b? "true":"false") <<"); was executed, and returned 10]"; 
        return 10;
    };
    std::cout<<" response: "<< call3(true) << std::endl;
    
}

sample foo();

type call(params);

sample foo(sample); //<--- одно копирование на результат, и ещё одно на приемку
 
...
 
std::function<sample(sample)> call = foo; //<--- параметризую тем же типом
         // что и тип функции, которую нужно запустить
 
sample obj1;
 
sample obj2 = call(obj1);  //<--- при запуске делегата
   // имею эффекты идентичные прямому вызову
   // то бишь не более одного копирование на результат
   // и не более одного копирования на входной аргумент