如何将 C++ lambda 传递给需要函数指针和上下文的 C 回调？

Question

我正在尝试在使用标准函数指针+上下文范例的 C-API 中注册回调。这是 api 的样子：

void register_callback(void(*callback)(void *), void * context);

我真正想做的是能够注册一个 C++ lambda 作为回调。此外，我希望 lambda 能够捕获变量（即不能转换为直接无状态 std::function）

我需要编写什么样的适配器代码才能将 lambda 注册为回调？

Answer 1

简单的方法是将 lambda 粘贴到 std::function<void()> 中，该 std::function<void()> 保存在某处。它可能是在堆上分配的，并且仅由注册到接受回调的实体的void* 引用。回调将只是这样的函数：

extern "C" void invoke_function(void* ptr) {
    (*static_cast<std::function<void()>*>(ptr))();
}

请注意，std::function<S> 可以保存具有状态的函数对象，例如具有非空捕获的 lambda 函数。你可以像这样注册一个回调：

register_callback(&invoke_function,
  new std::function<void()>([=](){ ... }));

Answer 2

最有效的方法是直接voidify lambda。

#include <iostream>
#include <tuple>
#include <memory>

template<class...Args>
struct callback {
  void(*function)(void*, Args...)=nullptr;
  std::unique_ptr<void, void(*)(void*)> state;
};
template<typename... Args, typename Lambda>
callback<Args...> voidify( Lambda&& l ) {
  using Func = typename std::decay<Lambda>::type;
  std::unique_ptr<void, void(*)(void*)> data(
    new Func(std::forward<Lambda>(l)),
    +[](void* ptr){ delete (Func*)ptr; }
  );
  return {
    +[](void* v, Args... args)->void {
      Func* f = static_cast< Func* >(v);
      (*f)(std::forward<Args>(args)...);
    },
    std::move(data)
  };
}

void register_callback( void(*function)(void*), void * p ) {
  function(p); // to test
}
void test() {
  int x = 0;
  auto closure = [&]()->void { ++x; };
  auto voidified = voidify(closure);
  register_callback( voidified.function, voidified.state.get() );
  register_callback( voidified.function, voidified.state.get() );
  std::cout << x << "\n";
}
int main() {
  test();
}

这里 voidify 接受一个 lambda 和（可选）一个参数列表，并生成一个传统的 C 样式回调-void* 对。 void* 由带有特殊删除器的 unique_ptr 拥有，因此其资源被正确清理。

与std::function 解决方案相比，它的优势在于效率——我消除了一级运行时间接。回调有效的生命周期也很清楚，因为它在voidify 返回的std::unique_ptr<void, void(*)(void*)> 中。

如果您想要更复杂的生命周期，unique_ptr<T,D>s 可以将 moved 转换为 shared_ptr<T>。

---

上面将生命周期与数据混合在一起，将类型擦除与实用程序混合在一起。我们可以拆分它：

template<class Lambda, class...Args>
struct callback {
  void(*function)(void*, Args...)=nullptr;
  Lambda state;
};

template<typename... Args, typename Lambda>
callback<typename std::decay<Lambda>::type, Args...> voidify( Lambda&& l ) {
  using Func = typename std::decay<Lambda>::type;
  return {
    +[](void* v, Args... args)->void {
      Func* f = static_cast< Func* >(v);
      (*f)(std::forward<Args>(args)...);
    },
    std::forward<Lambda>(l)
  };
}

现在voidify 没有分配。只需在回调的生命周期内存储您的 voidify，将指向second 的指针作为void* 与first 函数指针一起传递。

如果您需要将此构造存储在堆栈之外，将 lambda 转换为 std::function 可能会有所帮助。或者使用上面的第一个变体。

void test() {
  int x = 0;
  auto closure = [&]()->void { ++x; };
  auto voidified = voidify(closure);
  register_callback( voidified.function, &voidified.state );
  register_callback( voidified.function, &voidified.state );
  std::cout << x << "\n";
}

Answer 3

只要没有捕获变量，lambda 函数就与 C 回调函数兼容。
强迫用新的方式把新的东西放在旧的东西上是没有意义的。
走老路怎么样？

typedef struct
{
  int cap_num;
} Context_t;

int cap_num = 7;

Context_t* param = new Context_t;
param->cap_num = cap_num;   // pass capture variable
register_callback([](void* context) -> void {
    Context_t* param = (Context_t*)context;
    std::cout << "cap_num=" << param->cap_num << std::endl;
}, param);

Answer 4

将 lamda 函数用作 C 函数指针的一种非常简单的方法是：

auto fun=+[](){ //add code here }

请参阅此答案以获取示例。 https://stackoverflow.com/a/56145419/513481