在C ++中传递像std :: function这样的成员函数（例如在C＃中）

Question

I have a template class Delegate, with an overloaded += operator, that makes using delegates similar to C#.

// ... generalized version of the template omitted from code
template<typename... TArgs>
    class Delegate<void, TArgs...>
    {
        private:
            using Func = std::function<void(TArgs...)>;
            std::vector<Func> funcs;

        public:
            template<typename T> Delegate& operator+=(T mFunc) { funcs.push_back(Func(mFunc)); return *this; }
            void operator()(TArgs... mParams) { for (auto& f : funcs) f(mParams...); }
    };

This is what I'm trying to do:

struct s
{
    void test() { }
    void run()
    {
        Delegate<void> d;
        d += [] { /* do something */ ; };
        d += test; // does not compile
    }
};

Is there a way to allow d += test; to work?

Answer 1

void test(int x, int y) { return x - y; }

How can it compile? This function is supposed to return nothing. Its return type is void .

Also, I assume you have defined (or declared ) the primary template:

template<typename R, typename... TArgs>
class Delegate;

Also assuming that delegate is a typo, as the class template is Delegate .

Anyway, with test returning nothing, it compiles fine:

http://stacked-crooked.com/view?id=c56b7a2e758f8fbc361228834c90822b

---

As for member-function-pointers, your current implementation doesn't support it. Note that a non-static member function pointer takes the form of R (C::*MemPtr)(Args...) cv . Just work on it.

Answer 2

Member functions need an instance of an object to work on as well. You can give it as first parameter if you extract the function using std::mem_fn and you can also bind the current object to the function with std::bind

The code makes it clear:

struct s
{
    void test() { }
    void run()
    {
        Delegate<void> d;
        d += [] { /* do something */ ; };
        d += std::bind(std::mem_fn(&s::test), this); // does compile
    }
};

I don't really see a way for d += test . You really need to pass the actual object. This lambda version shows it even more clearly that you need the current object:

struct s
{
    void test() { }
    void run()
    {
        Delegate<void> d;
        d += [this] { test(); };
    }
};

Of course, you don't need to assign this in the operator+= line. You can modify the Delegate to take this in constructor like below ( runv1 ), or add a member function that gives a proxy object that can add the test function ( runv2 ): (I did not test these though)

struct s
{
    void test() { }
    void runv1()
    {
        Delegatev2<s, void> d(this);
        d += test;
    }
    void runv2()
    {
        Delegate<void> d;
        auto memd = d.getMemberDelegate(this);
        memd += test;
    }
};

Answer 3

As Nawaz said in edit, you use a member (non satic) function, it isn't compatible with void () signature of your std::function.

Two solution :

• Use something like std::function<void(s&)>
• bind your member function to an object, std::bind(&s::test,&s); (like K-ballo said, and Csq did)

Moreover, you should use rref and std::forward to achieve perfect forwarding.