C ++将结构函数作为继承结构中函数的参数传递

Question

我有两个结构体，结构体 B 继承自结构体 A。我想将一个函数作为参数从结构体 B 传递给结构体 A 以供结构体 A 使用。

这是我想要实现的目标和遇到的问题的示例，完整的代码将是 TL;DR。

struct A
{
    int32 mynum;

    void Tick(float delta, bool doThis, void (funcparam)(float, bool, int32))
    {
        funcparam(delta, doThis, mynum);
    }
};

---

struct B : public A
{
    void RunThis(float deltaTime, bool doIt, int32 which)
    {
        // do something when called by Struct A
    };

    void DoSomething()
    {
        Tick(0.1f, true, &B::RunThis);
    };
};

问题在于这一行：Tick(0.1f, true, &B::RunThis); 来自函数 void DoSomething()，除非我从一开始就做错了，但我想我传递错了，因为它仍然在我的结构的标题中m 当前定义？

错误（我已经修改了错误以适合我的示例，我不认为我搞砸了..）：

error C2664: 'void A::Tick(float,bool,void (__cdecl *)(float,bool))': cannot convert argument 3 from 'void (__cdecl B::* )(float,bool)' to 'void (__cdecl *)(float,bool)'

从&B::RunThis 中省略B:: 当然不能解决任何问题。

Answer 1

第一种选择：改用虚函数。

如果每个派生类有 1 个且只有 1 个函数，效果最好。

struct A {
    virtual void RunThis(float deltaTime, bool doIt, int32 which) = 0;
    void Tick(float delta, bool doThis )
    {
        //...
        RunThis(delta, doThis, which);
        // ...
    }
    virtual ~A() // virtual destructor...
    {}
};

struct B : public A
{
    virtual void RunThis(float deltaTime, bool doIt, int32 which )
    {
    }
    void DoSomething(/*...*/) 
    {
        // ...
        Tick(/*...*/);
    }

};

第二个选项：std::function + lambda 或 struct B 中的成员函数

#include <functional>
struct A 
{
     void Tick(float delta, bool doit, std::function<void(float,bool,int32)> action )
     {
     }
};

struct B : public struct A
{
    void DoSomething( /*...*/ )
    {
         // you can use a lambda, if convenient...
         Tick(/*...*/,
             [this](float delta, bool doit, int32_t which) -> void {
                // ...
             });
   }

   // or you can also use a pointer to member:
   void RunThis(/*...*/) { /* ... */ }
   void DoSomething(/*...*/)
   {
        std::function<void(float,bool,int32)> f = std::bind( &B::RunThis, this, _1,_2,_3);
        Tick(/*...*/, f);
   }
 };

Answer 2

不幸的是，C++ 函数指针没有上下文......换句话说，一个指向接受整数的函数的指针

void (*f)(int x)

不允许将任何数据“绑定”到指针，并且只能访问参数和全局变量。 为某些编译器实现的解决方法是 "trampoline" libraries，它允许将自定义数据绑定到函数指针，但它们都依赖于运行时动态代码创建，这在标准 C++ 的边界内是不可能的。

标准 C++ 中的解决方案是使用

std::function<void(int)>

而不是

void (*)(int)

std::function 对象可以保持与函数关联的数据并允许创建闭包。它还向后兼容函数指针（即函数指针可以隐式转换为std::function 对象）。

使用你的代码可以成为例子

struct A {
    int32 mynum;
    void Tick(float delta, bool doThis,
              std::function<void(float, bool, int32)> funcparam) {
       funcparam(delta, doThis, mynum);
    }
};

struct B : public A {
    void RunThis(float deltaTime, bool doIt, int32 which) {
        // do something when called by Struct A
    };
    void DoSomething() {
        Tick(0.1f, true, [this](float dt, bool di, int32 w) {
            this->RunThis(dt, di, w);
        });
    }
};

使用 lambda 调用方法。

如果您无法更改接受函数指针的代码，则一种可移植的解决方法是为给定签名预先分配一组函数指针...例如

void *closure_data[10];
void (*closure_code[10])(void *, int);

void closure0(int x){ closure_code[0](closure_data[0], x); }
void closure1(int x){ closure_code[1](closure_data[1], x); }
void closure2(int x){ closure_code[2](closure_data[2], x); }
...
void closure9(int x){ closure_code[9](closure_data[9], x); }

void (*closures[10])(int) = {closure0,
                             closure1,
                             ...
                             closure9};

然后你需要“分配”一个闭包i，将你的上下文数据放入对应的closure_data[i]，代码在closure_code[i]中，并作为函数指针closures[i]传递。

通常体面的 C++03 代码或接受回调函数指针的 C 代码总是提供上下文参数...即接口具有形式

void Tick(void *context,
          void (*callback)(float, bool, int32, void *))

并将调用回调，同时传递由提供函数指针的调用者指定的不透明void *context。