在类内分配函数指针

Assign function pointer inside class

本文关键字：函数 指针 分配      更新时间：2023-10-16

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

我看到有些人在传递指向成员函数的指针时会这样做(&ClassB：:p rintFun(。它对我不起作用，因为 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;
}

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

指向 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 库。我想知道是否有另一种方法可以做到这一点。

如果你不想使用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;
}

我还没有编译过这个，所以不确定它有多准确，但我会在现代编译器中朝着这样的事情努力(仍然在 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;
}
相关文章：