fork(1) download

copy

#include <memory>
#include <iostream>
#include <functional>
 
template<class... Args>
class DelegateTemplate;
 
class Delegate
{
    std::unique_ptr<Delegate> mPtr;
public:
    virtual ~Delegate() { }
 
    template<class R, class T, class... Args>
    void RegisterFunction(R(*target)(Args...), T(*callback)(R), Args... args)
    {
        mPtr.reset(new DelegateTemplate<R(Args...), T(R)>(target, callback, args...));
    }
 
    template<class R, class S, class T, class... Args>
    void RegisterFunction(R(S::*target)(Args...), S* obj, T(*callback)(R), Args... args)
    {
        mPtr.reset(new DelegateTemplate<R(Args...), T(R)>(target, obj, callback, args...));
    }
 
    virtual void CallFunction()
    {
        mPtr->CallFunction();
    }
};
 
template<class R, class T, class... Args>
class DelegateTemplate<R(Args...), T(R)> : public Delegate
{
    std::function<R()> mTarget;
    std::function<T(R)> mCallback;
public:
    DelegateTemplate(R(*target)(Args...), T(*callback)(R), Args... args)
    : mTarget(std::bind(target, args...))
    , mCallback(callback)
    {
    }
 
    template<class S>
    DelegateTemplate(R(S::*target)(Args...), S* obj, T(*callback)(R), Args... args)
    : mTarget(std::bind(target, obj, args...))
    , mCallback(callback)
    {
    }
 
    ~DelegateTemplate() { }
 
    void CallFunction() override
    {
        mCallback(mTarget());
    }
};
 
int Foo1(int i)
{
    std::cout << "Foo1.i = " << i << std::endl;
    return i;
}
 
void Callback1(int i)
{
    std::cout << "Callback1.i = " << i << std::endl;
}
 
const char* Foo2(double r)
{
    std::cout << "Foo2.r = " << r << std::endl;
    return "hello world";
}
 
void Callback2(const char* str)
{
    std::cout << "Callback1.str = " << str << std::endl;
}
 
class Test
{
public:
    int Foo3(const char* str)
    {
        std::cout << "Test::Foo3.str = " << str << std::endl;
        return 4;
    }
};
 
 
int RefFoo(int &value) {
	std::cout << "RefFoo.value = " << value << std::endl;
	++value;
	return value;
}
 
 
int main()
{
	int source_value_for_direct_call = 5;
	std::cout << "source_value_for_direct_call before direct call = " << 
	source_value_for_direct_call << std::endl;
	RefFoo(source_value_for_direct_call);
	std::cout << "source_value_for_direct_call after direct call = " << 
	source_value_for_direct_call << std::endl;
 
	int source_value_for_delegate_call = 5; 
	Delegate d;
	d.RegisterFunction(&RefFoo,&Callback1, source_value_for_delegate_call);
 
    std::cout << "source_value_for_delegate_call before delegate call = " <<
    source_value_for_delegate_call << std::endl;
    d.CallFunction();
    std::cout << "source_value_for_delegate_call after delegate call = " <<
    source_value_for_delegate_call << std::endl;
}
 

prog.cpp: In function ‘int main()’:
prog.cpp:110:71: error: no matching function for call to ‘Delegate::RegisterFunction(int (*)(int&), void (*)(int), int&)’
  d.RegisterFunction(&RefFoo,&Callback1, source_value_for_delegate_call);
                                                                       ^
prog.cpp:110:71: note: candidates are:
prog.cpp:15:10: note: template<class R, class T, class ... Args> void Delegate::RegisterFunction(R (*)(Args ...), T (*)(R), Args ...)
     void RegisterFunction(R(*target)(Args...), T(*callback)(R), Args... args)
          ^
prog.cpp:15:10: note:   template argument deduction/substitution failed:
prog.cpp:110:71: note:   inconsistent parameter pack deduction with ‘int&’ and ‘int’
  d.RegisterFunction(&RefFoo,&Callback1, source_value_for_delegate_call);
                                                                       ^
prog.cpp:21:10: note: template<class R, class S, class T, class ... Args> void Delegate::RegisterFunction(R (S::*)(Args ...), S*, T (*)(R), Args ...)
     void RegisterFunction(R(S::*target)(Args...), S* obj, T(*callback)(R), Args... args)
          ^
prog.cpp:21:10: note:   template argument deduction/substitution failed:
prog.cpp:110:71: note:   mismatched types ‘R (S::*)(Args ...)’ and ‘int (*)(int&)’
  d.RegisterFunction(&RefFoo,&Callback1, source_value_for_delegate_call);
                                                                       ^

Standard output is empty