Is there a generic way to pass pointers of overloaded methods that requires less work (than my example)

问题

So I have a function where, using C++17, I'm able to apply any method from any object:

#include <functional>

template <typename Object, typename Method, typename ... Args>
void ApplyMethod (Object && object, Method && method, Args && ... args)
{
    std::invoke(method, object, args...);
}

What I ask: Is there a way to improve this to require less work for the caller of the function when the method is overloaded.

Example use with overloaded methods:

#include <iostream>

class Foo
{
    int bottles;

public:

    void Edit ()
    {
        bottles = 666;
    }

    void Edit (int number)
    {
        bottles = number;
    }

    void Talk () const
    {
        std::cout << bottles << " bottles of beer of the wall" << std::endl;
    }
};

class Bar
{
    Foo foo;

    void TrickEdit (int number)
    {
        // Because Foo::Edit is overloaded, we need to do some work:

        using Method = void (Foo::*)(int);

        Method ptr = &Foo::Edit;

        ApplyMethod(foo, ptr, number);
    }

    void TrickTalk () const
    {
        // it's a lot neater when the method isn't overloaded:

        ApplyMethod(foo, &Foo::Talk);
    }

public:

    void Trick ()
    {
        TrickEdit(900);
        TrickTalk();    
    }   
};


int main ()
{
    Bar().Trick();

    return 0;
}

I'm trying to perform the work at the function instead. The problem seems to lie in that &Foo::Edit has two different locations, depending on which Edit we're referring to.

In C++ FAQ - Pointers to member functions by Stroustrup and other reputable authors, I read:

Question: I need something like function-pointers, but with more flexibility and/or thread-safety; is there another way?

Answer: Use a functionoid.

Question: What the heck is a functionoid, and why would I use one?

Answer: Functionoids are functions on steroids. Functionoids are strictly more powerful than functions, and that extra power solves some (not all) of the challenges typically faced when you use function-pointers. [...] Functionoids don’t solve every problem encountered when making flexible software, but they are strictly more powerful than function-pointers and they are worth at least evaluating. In fact you can easily prove that functionoids don’t lose any power over function-pointers, since you can imagine that the old-fashioned approach of function-pointers is equivalent to having a global(!) functionoid object. Since you can always make a global functionoid object, you haven’t lost any ground. QED.

Given that the "power" of programming is basically the reduction of work duplication, and that with a normal function we would avoid the extra work at the call site that I've outlined in my problem, the FAQ answer implies that there should be a solution to this using functionoids. However, for the life of me, I can't see how functionoids would help in this case.

回答1:

You can write a variable template that specifies what Args... should be.

template <typename... Args>
struct Overload {
    template<typename R, typename O>
    operator R(O::*)(Args...) (R(O::*p)(Args...)) const { return p; }
    template<typename R, typename O>
    operator R(O::*)(Args...) const (R(O::*p)(Args...) const) const { return p; }
};

template <typename... Args>
Overload overload;

Which is used like

struct A
{   
    void Do() { std::cout << "Do no parm" << std::endl; }
    void Do(int) { std::cout << "Do 1 parm" << std::endl; }
    void Do(int,int) { std::cout << "Do 2 parms" << std::endl; }
};  

template <typename Object, typename Method, typename ... Args>
void ApplyMethod (Object && object, Method && method, Args && ... args)
{
    std::invoke(method, object, args...);
}

int main()
{   
    A a;
    ApplyMethod( a, overload<>(&A::Do));
    ApplyMethod( a, overload<int>(&A::Do), 1); 
    ApplyMethod( a, overload<int, int>(&A::Do),1,2);
}

This is what Qt does for it's modern signals and slots.

回答2:

Maybe you can use something like that:

struct A
{   
    void Do() { std::cout << "Do no parm" << std::endl; }
    void Do(int) { std::cout << "Do 1 parm" << std::endl; }
    void Do(int,int) { std::cout << "Do 2 parms" << std::endl; }
};  

template < typename OBJ_TYPE, typename ... ARGS >
auto Invoke( OBJ_TYPE&& obj, void( std::remove_reference<OBJ_TYPE>::type::* func)(ARGS...), ARGS&& ... args )
{   
    return std::invoke( func, obj, args... );
}   

int main()
{   
    A a;
    Invoke( a, &A::Do);
    Invoke( a, &A::Do, 1); 
    Invoke( a, &A::Do,1,2);
}

The idea is simply to fix the pointer type of the member function pointer to the given arguments in the parameter pack.

If someone has an idea how to automatically determine the return type, so that we also can use overloads with different return types, that would be very funny! I end up in a recursion :-)

If we simply specify the return type, we can use it as follows:

struct A
{   
    void Do() { std::cout << "Do no parm" << std::endl; }
    void Do(int) { std::cout << "Do 1 parm" << std::endl; }
    int Do(int,int) { std::cout << "Do 2 parms" << std::endl; return 42;}
};  


template < typename RETURN_TYPE, typename OBJ_TYPE, typename ... ARGS >
auto Invoke( OBJ_TYPE&& obj, RETURN_TYPE( std::remove_reference<OBJ_TYPE>::type::* func)(ARGS...), ARGS&& ... args )
{   
    return std::invoke( func, obj, args... );
}   

int main()
{   
    A a;
    Invoke<void>( a, &A::Do);
    Invoke<void>( a, &A::Do, 1); 
    int retval = Invoke<int>( a, &A::Do,1,2);
    std::cout << retval << std::endl;
}

来源：https://stackoverflow.com/questions/60575881/is-there-a-generic-way-to-pass-pointers-of-overloaded-methods-that-requires-less