在类内部分配函数指针

Question

我正在编写简单的实验代码来测试将一个类的成员函数分配给另一个类的成员函数指针。我的示例代码没有编译。编译器给出了一个错误： “&”：对绑定成员函数表达式进行非法操作。

我看到有些人在将指针传递给成员函数时会执行 (&ClassB::printFun) 。它对我不起作用，因为 printFun 不是静态成员函数。我还看到有人使用 std::bind。但 std 库对我来说不是一个选择，因为我将使用它来编写内核模式代码。我一直在寻找正确的方法来做到这一点，有人可以帮助我吗？谢谢！

using namespace std;

class ClassA
{
public:
    ClassA(void(*callBack)(int));
    void (*funPtr)(int);
};

ClassA::ClassA(void(*callBack)(int))
{
    funPtr = callBack;
}

class ClassB
{
public:
    void printFun(int a)
    {
        cout << a << endl;
    }
};

int main()
{
    ClassB classB;
    ClassA classA(&classB->printFun);
    classA.funPtr(5);
    return 0;
}

Answer 1

函数指针和成员函数指针是不同的东西。您需要一个对象来调用成员函数。

指向成员函数的指针可以这样声明：

void (ClassB::*ptrPtrintFunc)(int) = &ClassB::printFun;

你可以这样称呼它：

ClassB classB;
(classB.*ptrPtrintFunc)(1);

或这个：

ClassB *ptrClassB = &classB;
(ptrClassB->*ptrPtrintFunc)(2);

您可以做的是使用std::function旧式函数指针来代替。您可以将 lambda 函数传递给std::function，在其中调用该类的方法：

#include <iostream>
#include <functional>   // std::function

struct ClassA
{
    using TFunc = std::function<void( int )>; // <-- std::function<void( int )> insted of void(*)(int)
    ClassA( TFunc func) : funPtr( func ) {}
    TFunc funPtr;
};

struct ClassB
{
    void printFun( int a ) { std::cout << a << std::endl; }
};

int main()
{
    ClassB classB;
    ClassA classA( [&classB]( int a ) { classB.printFun(a); } ); // <-- lambda function
    classA.funPtr(5);
    return 0;
}

除了 lambda 函数之外，您还可以使用std::binda std::placholderfor 参数：

ClassB classB;
ClassA classA( std::bind( &ClassB::printFun, &classB, std::placeholders::_1 ) );
classA.funPtr(5);

当然你也可以传递一个简单的函数std::function

void printFunc( int a ) { std::cout << a << std::endl; }

ClassA classA( printFunc ); 

答案的扩展：不使用STL的解决方案

感谢您的信息。我正在使用 std 库来打印实验代码。但我正在编写的实际代码是在内核模式下，所以我将无法访问 std 库。我想知道是否还有其他方法可以做到这一点。

如果你无论如何都不想使用STL，你可以考虑使用抽象基类的解决方案。您需要一个具有抽象回调方法的基类，并且需要 2 个重写抽象回调方法的派生类。回调方法的实现将回调委托给函数或类方法。

具有抽象方法的抽象类CallBack：

struct CCallBack
{
    virtual void CallBack( int ) = 0;
};

函数指针的实现。重写的方法CallBack将回调委托给函数指针：

struct CCallBackFunc : public CCallBack
{
    typedef void(*TFuncPtr)(int);
    TFuncPtr _funcPtr;
    CCallBackFunc( TFuncPtr funcPtr ) : _funcPtr( funcPtr ) {}
    virtual void CallBack( int a ) override { (*_funcPtr)( a ); }
};

方法函数指针的实现。重写的方法CallBack将回调委托给一个对象和一个方法函数指针：

template < class T >
struct CCallBackMethod : public CCallBack
{
    typedef void(T::*TMethodPtr)(int);
    T &_obj;
    TMethodPtr _methodPtr;
    CCallBackMethod( T &obj, TMethodPtr methodePtr ) : _obj( obj ), _methodPtr( methodePtr ) {}
    virtual void CallBack( int a ) override { (_obj.*_methodPtr)( a ); }
};

两种情况的使用示例：

struct ClassA
{
    ClassA( CCallBack *cb ) : _cb( cb ) {}
    virtual ~ClassA() { delete _cb; }
    CCallBack *_cb;
};

struct ClassB { void printFun( int a ) { std::cout << a << std::endl; } };
void printFun( int a ) { std::cout << a << std::endl; }

int main()
{
    ClassB classB;
    ClassA classA0( new CCallBackFunc( &printFun ) );
    ClassA classA1( new CCallBackMethod<ClassB>( classB, &ClassB::printFun ) );
    classA0._cb->CallBack( 6 );
    classA1._cb->CallBack( 7 );
    return 0;
}

Answer 2

我还没有编译过这个，所以不确定它有多准确，但我会在现代编译器中努力实现类似的目标（仍然是 C++17 之前的版本）：

#include <functional>

class A {
  public:
    A(std::function<void(int)> func)
        : func_( func )
    {}
    
    std::function<void(int)> func_;
}

class B {
  public:
    void printer(int val) { /* do something */ }
}

int main()
{
    B b{};
    A a([&](int val) { b.printer( val ); });

    a.func_(1);

    return 0;
}