C++ 将成员函数作为参数传递

我有一个运行回调的函数：

void run_callback(void(*callback)(uint32_t)) {
    callback(100);
}

这适用于静态函数

void global_callback(uint32_t);

int main() {
    run_callback(global_callback);
}

但不包括成员函数

class A {
    int x;
  public:
    void callback(uint32_t);
};

int main() {
    A foo;
    run_callback(foo.callback);
}

我使用一个静态包装函数来解决这个问题

void run_member_callback(void* obj, void(*callback)(void*,uint32_t)) {
    callback(obj, 100);
}

class B {
    int x;
  public:
    static void static_callback(void* obj, uint32_t value) {
        static_cast<B*>(obj)->callback(value);
    }
    void callback(uint32_t);
};

int main() {
    B foo;
    run_member_callback(&foo, foo.static_callback);
}

void run\u member\u回调（void*obj，void（*回调）（void*，uint32\u t））{
回调（obj，100）；
}
B类{
int x；
公众：
静态void静态回调（void*obj，uint32\u t值）{
静态_cast（obj）->回调（值）；
}
无效回拨（uint32_t）；
};
int main（）{
B foo；
运行成员回调（&foo，foo.static回调）；
}

有没有一种简单的方法可以将成员函数作为参数传递

编辑：

---

我试图避免STL，模板不是一个选项，因为我的

run\u callback

的实现是虚拟的。

你在做一些奇怪的、C风格的事情。使用C++的特点。我个人会使用

run\u callback

模板和lambda来传递成员函数：

template <class F>
void run_callback(F callback)
{
    callback(100);
}

class A
{
    int x;
  public:
    void callback(uint32_t);
};

int main()
{
    A foo{};
    run_callback([&](uint32_t a) { return foo.callback(a); });
}

模板
无效运行回调（F回调）
{
回收（100）；
}
甲级
{
int x；
公众：
无效回拨（uint32_t）；
};
int main（）
{
一个foo{}；
运行_callback（[&]（uint32_t a）{return foo.callback（a）；}）；
}

如果通过引用捕获对象，请注意它在

run\u回调

调用之后仍然存在。否则，通过值捕获它

---

---

可能的复制品非常接近，@Tim，但还不够接近。还有一个几乎是重复的：把它们放到gether中，你会得到一些。关于这个主题的一些好的通用阅读：这种代码可能很脆弱，特别是当你有多重继承的时候。最好用

B*

重新放置你的

void*

，并减少施法次数。也可以使用指向成员函数的指针。

run\u callback

是您编写并可以更改的函数，还是来自某个库或API，您必须按原样使用？在某些情况下，使用

std:：function

可能很有用，例如，如果

run\u callback

很复杂，并且与不同的参数类型一起使用，则可以使用

std:：function

，除非您确实需要类型擦除（如将函数存储在集合中）。它增加了相当大的开销，并对性能造成了显著的影响。@bolov这是我关心的问题。