C++ 单个函数指针能否指向多个类成员函数

以下是我的申请提出的要求。我有一个类a，它接受一个函数指针，比如cFunc，基本上在我的a实现中，我让它多次调用cFunc

cFunc指针本身应根据应用程序指向不同的函数。因此，对于每个应用程序，我创建了一个与cFunc具有相同函数定义的类，但是我无法将该类的成员函数分配给该指针

class A {
    typedef double (*Def_CFunc)(std::vector<double>);
    A(Def_CFunc _cFunc) { // Some implementation}
    // Other Functions
};

class B { double someFunc(std::vector<double> b); };
class C { double someOtherFunc(std::vector<double> a); };

int main () {
    B firstObj;
    C secondObj;

    // Depending upon the situation, I want to select class B or C
    double (*funcPointer)(std::vector<double>) = firstObj.someFunc; // Error in this line of code

    A finalObj(funcPointer);
}

A类{
typedef double（*Def_CFunc）（标准：：向量）；
A（Def_CFunc{//Some implementation}
//其他职能
};
类B{double someFunc（std:：vector B）；}；
类C{double someOtherFunc（std:：vector a）；}；
int main（）{
B第一目标；
C第二目标；
//根据情况，我想选择B类或C类
double（*funcPointer）（std:：vector）=firstObj.someFunc；//这行代码中有错误
A finalObj（funcPointer）；
}

---

那么，如何使具有给定格式的成员函数的任何类都可以用来初始化类a？

的语法与指向普通函数的指针不同，并且只能指向一个给定类的方法。要能够指向不同类中的方法，请使用或如果C++11可用，请使用。它们可以保存给定签名的任何方法或函数。

您需要的是

std:：function

以及

std:：bind

或lambda表达式（或前两个的Boost等效表达式），因为成员函数指针不允许您这样做。

我不确定您的具体要求是什么，但是看起来你想要一个（或者C++ C++中的抽象基类）。 如果

B

和

C

都继承自公共基类，则可以传递指向该基类的指针并调用其上的函数：

class I { virtual double func(std::vector<double> a) = 0; }
class B : public I { double func(std::vector<double> a); };
class C : public I { double func(std::vector<double> a); };

类I{virtual double func（std:：vector a）=0；} B类：公共I{double func（std:：vector a）；}； 类C：公共I{double func（std:：vector a）；}；

---

您可以将

I*

指针传递到

A

，只需使用

I->func

即可使用std:：bind+std:：function完成。让我们编写一些模板类包装器，它接受任何静态类型作为输入。然后在自由函数switch_obj中使用此包装器。用法很简单

typedef std::function<double(std::vector<double>)> my_foo;

template<class C>
struct switcher
{
    static my_foo convert(C* obj)
    {
        return my_foo( std::bind(&C::someFunc,obj,std::placeholders::_1) );
    }
};

template<class T>
my_foo switch_obj(T* obj)
{
    return switcher<T>::convert(obj);
}

void main()
{
    B firstObj;
    C secondObj;

    auto f =  switch_obj(&firstObj);
    A a(f);
}

typedef std:：function my_foo；
模板
结构切换器
{
静态my_foo转换（C*obj）
{
返回my_foo（std:：bind（&C:：someFunc、obj、std:：placeholder:：_1））；
}
};
模板
my_foo开关_obj（T*obj）
{
返回开关：：转换（obj）；
}
void main（）
{
B第一目标；
C第二目标；
自动f=开关_obj（&firstObj）；
A（f）；
}

您真的需要函数成为成员函数吗？不需要，但函数将与类变量紧密集成，因此这似乎是最好的方法。我不同意您的看法。有时您只需要静态多态性。@innochenti：这和使用全局函数一样好。我只是建议使用接口，因为OP采用了面向对象的方式。