避免非类类型的指向成员函数

Question

I am writing a kind of container class, for which I would like to offer an apply method which evaluates a function on the content of the container.

template<typename T>
struct Foo
{
    T val;

    /** apply a free function */
    template<typename U> Foo<U> apply(U(*fun)(const T&))
    {
        return Foo<U>(fun(val));
    }

    /** apply a member function */
    template<typename U> Foo<U> apply(U (T::*fun)() const)
    {
        return Foo<U>((val.*fun)());
    }
};

struct Bar{};
template class Foo<Bar>; // this compiles
//template class Foo<int>; // this produces an error

The last line yields error: creating pointer to member function of non-class type 'const int' . Even though I only instantiated Foo and not used apply at all . So my question is: How can I effectively remove the second overload whenever T is a non-class type?

Note: I also tried having only one overload taking a std::function<U(const T&)> . This kinda works, because both function-pointers and member-function-pointers can be converted to std::function , but this approach effectively disables template deduction for U which makes user-code less readable.

Answer 1

Using std::invoke instead helps, it is much easier to implement and read

template<typename T>
struct Foo
{
    T val;

    template<typename U> auto apply(U&& fun)
    {
        return Foo<std::invoke_result_t<U, T>>{std::invoke(std::forward<U>(fun), val)};
    }
};

struct Bar{};
template class Foo<Bar>;
template class Foo<int>;

However, this won't compile if the functions are overloaded

int f();
double f(const Bar&);
Foo<Bar>{}.apply(f);  // Doesn't compile

The way around that is to use functors instead

Foo<Bar>{}.apply([](auto&& bar) -> decltype(auto) { return f(decltype(bar)(bar)); });

Which also makes it more consistent with member function calls

Foo<Bar>{}.apply([](auto&& bar) -> decltype(auto) { return decltype(bar)(bar).f(); });

Answer 2

In order to remove the second overload you'd need to make it a template and let SFINAE work, eg like this:

template<typename T>
struct Foo
{
    T val;

    //...

    /** apply a member function */
    template<typename U, typename ObjT>
    Foo<U> apply(U (ObjT::*fun)() const)
    {
        return Foo<U>((val.*fun)());
    }
};

Alternatively, you could remove the second overload altogether, and use lambda or std::bind:

#include <functional> // for std::bind

template<typename T>
struct Foo
{
    T val;

    /** apply a member function */
    template<typename U, typename FuncT>
    Foo<U> apply(FuncT&& f)
    {
        return {f(val)};
    }
};

struct SomeType
{
    int getFive() { return 5; }
};

int main()
{
    Foo<SomeType> obj;

    obj.apply<int>(std::bind(&SomeType::getFive, std::placeholders::_1));
    obj.apply<int>([](SomeType& obj) { return obj.getFive(); });
}

Answer 3

How can I effectively remove the second overload whenever T is a non-class type?

If you can use at least C++11 (and if you tried std::function I suppose you can use it), you can use SFINAE with std::enable_if

   template <typename U, typename V>
   typename std::enable_if<std::is_class<V>{}
                        && std::is_same<V, T>{}, Foo<U>>::type
      apply(U (V::*fun)() const)
    { return Foo<U>((val.*fun)()); }

to impose that T is a class.

Observe that you can't check directly T , that is a template parameter of the class, but you have to pass through a V type, a template type of the specific method.

But you can also impose that T and V are the same type ( && std::is_same<V, T>{} ).