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

Question

我正在编写一种容器类，我想提供一个apply方法来评估容器内容的函数。

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

最后一行产生error: creating pointer to member function of non-class type 'const int' 。 即使我只是实例化了Foo而没有使用apply 。 所以我的问题是：当T是非类型类型时，如何有效地删除第二个重载？

注意：我也试过只有一个重载采用std::function<U(const T&)> 。 这种方法有效，因为函数指针和成员函数指针都可以转换为std::function ，但是这种方法有效地禁用了U模板推导，这使得用户代码的可读性降低。

Answer 1

使用std::invoke有助于实现和阅读更容易

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>;

但是，如果函数重载，则无法编译

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

解决这个问题的方法是使用仿函数

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

这也使其与成员函数调用更加一致

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

Answer 2

为了消除第二次过载，您需要将其设为模板并让SFINAE工作，例如：

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)());
    }
};

或者，您可以完全删除第二个重载，并使用lambda或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

当T是非类型类型时，如何有效地删除第二个重载？

如果你至少可以使用C ++ 11（如果你试过std::function我想你可以使用它），你可以使用SFINAE和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)()); }

强加T是一个阶级。

注意，你不能直接检查T ，这是类的模板参数，但你必须通过V类型，即特定方法的模板类型。

但是你也可以强加T和V是相同的类型（ && std::is_same<V, T>{} ）。