Question

我正在编写简单的实验代码来测试将一个类的成员函数分配给作为另一个类的成员的函数指针。我的示例代码没有编译。编译器发出错误说：＆＃39;＆amp;＆＃39 ;:对绑定成员函数表达式的非法操作。

我看到有些人在将指针传递给成员函数时会这样做（＆amp; 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

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

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

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::bind和std::placholder作为参数：

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，您可以考虑使用抽象基类的解决方案。您需要一个带有抽象回调方法的基类，并且您需要两个派生类来覆盖抽象回调方法。回调方法的实现将回调委托给函数或类方法。

抽象方法使用抽象方法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 ++之前的版本）中努力实现这样的事情：

checked

在类中分配函数指针

2 个答案:

答案的延伸：不使用STL的解决方案