Function taking pointer-to-method regardless of constness

user_10099283 0
Viewed 179

I want to implement a generic function that will take reference to object and pointer to its member function and invoke it. However I'm not able to do so when my class has both const and non-const methods as I need to provide two overloads:

template<typename Ret, typename Class, typename ...Us>
Ret callMethod(Class &object, Ret (Class::*method)(Us...))
{
    return (object.*method)(Us{}...);
}

template<typename Ret, typename Class, typename ...Us>
Ret callMethod(Class &object, Ret (Class::*method)(Us...) const)
{
    return (object.*method)(Us{}...);
}

Is there some way to write only 1 template function that will accept both const and non-const method pointers so I don't have to write my code twice? I'm using C++14.

For a broader picture, what I want to ultimately achieve is pass a 3rd parameter, a data buffer from which method arguments will be extracted - hence the template function to handle it as generically as possible.

c++14 templates c++
3 Answers

The short answer is, don't implement this yourself, it has already been done for you in the form of std::invoke:

#include <functional>

struct A {
    void foo(int x);
    void bar(int x) const;
};

void example() {
    A a;
    std::invoke(&A::foo, a, 3); 
    std::invoke(&A::bar, a, 3); 
}

Seeing that you have added a C++14 tag in retrospect, the documentation of std::invoke has a sample implementation which you can use in your project.

user_57404280

Here's a C++14 alternative without using std::function.

what I want to ultimately achieve is pass a 3rd parameter, a data buffer from which method arguments will be extracted - hence the template function to handle it as generically as possible

What you use at the call site will be perfectly forwarded here:

template<typename Class, typename Func, typename... Args>
decltype(auto) callMethod_impl(Class& object, Func method, Args&&... args) {
    return (object.*method)(std::forward<Args>(args)...);
}


template<typename Ret, typename Class, typename... Us, typename... Args>
Ret callMethod(Class& object, Ret(Class::*method)(Us...), Args&&... args) {
    return callMethod_impl(object, method, std::forward<Args>(args)...);
}

template<typename Ret, typename Class, typename... Us, typename... Args>
Ret callMethod(const Class& object, Ret(Class::*method)(Us...) const, Args&&... args) {
    return callMethod_impl(object, method, std::forward<Args>(args)...);
}

Demo

If you need Ret in callMethod_impl, just add it as a template parameter and call it like callMethod_impl<Ret>(...) from the callMethod overloads (Demo).

user_75822470

Without std::invoke, you can only do some more or less generic workarounds, based on type erasure. Using std::function allows you to create a proxy-function to treat your functions on an equal footing:

#include <iostream>
#include <functional>

template<typename Ret, typename ...Us>
Ret callMethod_impl(std::function<Ret(Us...)> f) {
    // common implementation here
    return f(Us{}...);
}

template<typename Ret, typename Class, typename ...Us>
Ret callMethod(Class &object, Ret (Class::*method)(Us...)) {
    return callMethod_impl(std::function<Ret(Us...)>(std::bind(method, object)));
}

template<typename Ret, typename Class, typename ...Us>
Ret callMethod(const Class &object, Ret (Class::*method)(Us...) const) {
    return callMethod_impl(std::function<Ret(Us...)>(std::bind(method, object)));
}

struct Foo {
    int bar() const { return 1; }
    float bar() { return 2.1f; };
};

int main() {
    Foo f;
    std::cout << callMethod(f, &Foo::bar) << std::endl;
}

Note that volatile functions (+ combinations) are not treated here, but maybe you don't need full generality but rather a pragmatic solution.

user_77035640
Related