SO 上有几个问题解决了将函数指针作为参数/实参传递的问题(here、here、here 等)。其实我问了一个related question另一天。但是，这个问题有点不同。

我的问题是我正在编写一个非常灵活的类。

我现在拥有的适用于非成员函数。下面贴出来

template <typename T>
class MyClass
{
    private:
        typedef double (*firstFunctionPtr) (const T &var);

        typedef bool (*secondFunctionPtr)(const T &var);

        // Function pointers as member variables
        firstFunctionPtr _firstFunc;
        secondFunctionPtr _secondFunc;

    public:
        inline MyClass(firstFunctionPtr firstFunc, 
            secondFunctionPtr secondFunc);
};

template<typename T>
MyClass<T>::MyClass(firstFunctionPtr firstFunc, secondFunctionPtr secondFunc) :
    _firstFunc(firstFunc),
    _secondFunc(secondFunc),
    {}

但是，当我需要使用指向某个其他任意类的成员函数的指针进行初始化时，这种方法就会崩溃，不幸的是，对于我来说，这恰好是我的目的的常见用例。

This answer建议

In a proper C++ interface you might want to have a look at having your function take templated argument for function objects to use arbitrary class types.

但是，我无法编译。我试过模板化我的 typedef(使用 C++11 别名方法)，并且我试过向类添加第二个模板参数来处理那些成员函数的调用类，但是这两种方法都没有用。

This Q/A似乎正在朝着我想要做的事情发展，但我无法弄清楚它的正面或反面。

1. 有人可以解释我如何修改我的类以处理传入的任意成员函数指针吗？
2. 此外，是否可以让它既可以处理任意成员函数，也可以处理非成员函数？
3. 最后，是否可以使用模板来做到这一点？

郑重声明，我试图避免使用 functional header ，但不使用它可能是愚蠢的差事。

最佳答案

如果你想要MyClass成为一个可以同时拥有自由功能的模板 类型指针:

double (*)(const T &var);
bool (*)(const T &var);

对于某些参数类型 T , 或者成员函数 类型指针:

double (C::*)(const T &var);
bool (C::*)(const T &var);

对于某些参数类型 C和 T然后，MyClass必须参数化 由两者T和 C并且您需要两个专业:

1. 在哪里C是一些非类类型
2. 在哪里C是任何类类型

在情况(1)中，非类类型 C不可能有成员函数， 以便实现自由函数指针特化。

在情况 (2) 中，类 C可以是一个有成员函数的，这样一个 将实现成员函数指针特化。

非类类型的明显选择 C是void .所以我们可以制作C 默认为 void :

主模板

template<typename T, typename C = void>
struct MyClass;

这样:

MyClass<T>

将是 T 的自由函数指针特化, 和:

MyClass<T,C>

对于任何C除了void , 将是成员函数指针特化。

如您所知，您可以使用 std::enable_if 和 SFINAE 使编译器 选择类模板的一种特化或另一种特化，取决于是否 它的模板参数 U满足一些编译时测试。你可以拿 这里的方法，但另一种不需要该设备的方法可用:

从主模板开始，我们只想拥有:

免费函数特化

template<typename T>
struct MyClass<T>
{
    ... for free function pointers ...
};

和:

成员函数特化

template<typename T, typename C>
struct MyClass<T,C>
{
    ... for member function pointers ...
};

但我们不能只拥有它，因为成员函数“specialization”恰好有 与主模板相同的模板参数。这意味着它不是 特化，编译器不允许。

但是，您可以轻松地解决这个问题，只需提供主要的 template 一个它不需要的默认模板参数，但是它的 存在使这两个专业都能站稳脚跟。

新主模板

template <typename T, typename C = void, typename Default = void> 
struct MyClass;

所以这是一个说明性的解决方案:

// Primary template
template <typename T, typename C = void, typename Default = void> 
struct MyClass;

// Free function specialization
template <typename T>
struct MyClass<T>
{
    using firstFunctor_t = double(*)(T const &);
    using secondFunctor_t = bool(*)(T const &);

    MyClass(firstFunctor_t firstFunc, secondFunctor_t secondFunc)
    :   _firstFunc(firstFunc),
        _secondFunc(secondFunc)
    {}

    double callFirst(T const & var) {
        return _firstFunc(var);
    }

    bool callSecond(T const & var) {
        return _secondFunc(var);
    }

private:

    firstFunctor_t _firstFunc;
    secondFunctor_t _secondFunc;
};

// Member function specialization
template <typename T, typename C>
struct MyClass<T,C>
{
    using firstFunctor_t = double(C::*)(T const &);
    using secondFunctor_t = bool(C::*)(T const &) const;

    MyClass(firstFunctor_t firstFunc, secondFunctor_t secondFunc)
    :   _firstFunc(firstFunc),
        _secondFunc(secondFunc)
    {}

    double callFirst(C & obj, T const & var) {
        return (obj.*_firstFunc)(var);
    }

    double callFirst(C const & obj, T const & var) {
        auto & o = const_cast<C&>(obj);
        return (o.*_firstFunc)(var);
    }

    bool callSecond(C & obj, T const & var) {
        return (obj.*_secondFunc)(var);
    }

    bool callSecond(C const & obj, T const & var) {
        auto & o = const_cast<C&>(obj);
        return (o.*_secondFunc)(var);
    }

private:

    firstFunctor_t _firstFunc;
    secondFunctor_t _secondFunc;
};

在成员函数特化中，注意两点你可能 没有考虑过:-

我决定要存储的第二个成员函数应该是 const 成员函数。 C 的成员函数很可能是 需要 T const &参数和返回 bool 将是 const成员 功能，不是吗？如果是这样，那么const-ness必须是的一部分 我在特化中使用的成员函数类型定义:

using secondFunctor_t = bool(C::*)(T const &) const;

或尝试用任何 bool (C::*)(T const &) const 实例化特化 将无法编译。

另外，我为每个 MyClass<T,C>::callFirst 提供了两个重载 和 MyClass<T,C>::callSecond , 一个带参数:

C & obj, T const & var

还有一个带参数的:

C const & obj, T const & var

没有第二个，尝试调用 MyClass<T,C>::callFirst 或 MyClass<T,C>::callSecond用obj那是 const 将失败 编译。

对于演示此解决方案的程序，您可以附加:

#include <iostream>
#include <string>

double foo(std::string const & s)
{
    return std::stod(s);
}

bool bar(std::string const & s)
{
    return s.size() > 0;
}

struct SomeClass
{
    SomeClass(){};
    double foo(std::string const & s) {
        return ::foo(s);
    }

    bool bar(std::string const & s) const {
        return ::bar(s);
    }
};

int main()
{
    MyClass<std::string> my0{foo,bar};
    std::cout << std::boolalpha;
    std::cout << my0.callFirst("1.11") << std::endl;
    std::cout << my0.callSecond("Hello World") << std::endl;

    MyClass<std::string,SomeClass> my1{&SomeClass::foo,&SomeClass::bar};
    SomeClass thing;
    std::cout << my1.callFirst(thing,"2.22") << std::endl;
    std::cout << my1.callSecond(thing,"Hello World") << std::endl;

    SomeClass const constThing;
    std::cout << my1.callFirst(constThing,"3.33") << std::endl;
    std::cout << my1.callSecond(constThing,"Hello World") << std::endl;
    return 0;
}

See it live

您说您希望此模板“极其灵活”。这 图示解决方案适合您的示例，但您可能 有兴趣知道它几乎没有您所能得到的那么灵活。 对于自由函数和成员函数，附加 variadic template 参数，您的模板可以存储和调用 [member] 函数 任意返回类型和任意类型参数的任意数量。 参见 this question和 回答。

关于c++ - 将任意类的成员函数指针存储为类实例变量，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/42182980/