是否可以覆盖 C++11 lambda/closure 析构函数？

Question

我正在使用 C++11 的 lambda/closure 功能，尝试编写一个半协程（生成器）函数。

以下代码是我的实验。它们按预期工作（GCC 4.9/Linux）。

看了几篇介绍 C++ lambda/closure 的网上文章，现在我把 lambda 函数理解为函子或函数对象。

我的问题是：我可以将闭包对象的析构函数代码放在哪里？如何覆盖默认析构函数？

我需要这个函数，因为当我调用构造和返回闭包对象（代表协程）的函数时，某些协程可能会请求某些系统资源。但是如果调用者函数决定取消/终止操作，应该有一种机制来通知协程对象采取一些行动。放置代码的理想位置是在析构函数中，但我找不到如何。

有什么建议吗？

#include <iostream>
#include <functional>
#include <time.h>

#define CONCAT01(a, b)                      a##b
#define CONCAT02(a, b)                      CONCAT01(a, b)
#define YIELD()                             \
  do {                                      \
    CONCAT02(ENTRY, __LINE__):              \
    if (EP == && CONCAT02(ENTRY, __LINE__)) \
      EP = 0;                               \
    else                                    \
    {                                       \
      EP = && CONCAT02(ENTRY, __LINE__);    \
      return true;                          \
    }                                       \
  } while (0)

using namespace std;

typedef std::function<bool(void)> coroutine;

coroutine add(int a, int b, int * ret)
{
  timespec start;
  clock_gettime(CLOCK_REALTIME, &start);

  return [=]() mutable -> bool
  {
    timespec now;
    while(1) {
      clock_gettime(CLOCK_REALTIME, &now);
      if (now.tv_sec - start.tv_sec > 1)
        break;

      return true;
    }
    * ret = a + b;
    cout << "add " << a << " " << b << " equals: " << a + b << endl;
    return false;
  };
}

coroutine sum(int a, int b, int c, int * ret)
{
  void* EP = 0;
  coroutine co = 0;
  int tmp = 0;

  return [=] () mutable -> bool
  {
    if (EP) goto *EP;

    co = add(a, b, &tmp);
    while(co())
      YIELD();

    co = add(tmp, c, ret);
    while(co())
      YIELD();

    return false;
  };
}

int main()
{
  int ret;
  coroutine c = sum(1, 2, 4, &ret);
  while (c())
    {
      sleep(1);
      cout << "wakeup" << endl;
    }

  cout << "final: " << ret << endl;

  return 0;
}

Answer 1

这是一个带有任务和销毁任务的对象：

template<class F, class D>
struct coroutine {
  F f;
  D d;
  template<class...Args>
  std::result_of_t<F&(Args...)>
  operator()(Args&&...args){
    return f(std::forward<Args>(args)...);
  }
  ~coroutine() {
    d();
  }
};

它的工厂函数：

template<class F, class D>
coroutine< std::decay_t<F>, std::decay_t<D> >
make_coroutine( F&& f, D&& d ) {
  return {std::forward<F>(f), std::forward<D>(d)};
}

一些辅助宏：

#define COROUTINE_STATE ED=(void*)0
#define START_COROUTINE if (ED) goto *ED
#define FINISH_COROUTINE return false

auto add(int a, int b, int * ret) {
  timespec start;
  clock_gettime(CLOCK_REALTIME, &start);

  return make_coroutine([=]() mutable
  {
    timespec now;
    while(true) {
      clock_gettime(CLOCK_REALTIME, &now);
      if (now.tv_sec - start.tv_sec > 1)
        break;

      return true;
    }
    *ret = a + b;
    cout << "add " << a << " " << b << " equals: " << a + b << endl;
    return false;
  },
  []{
    cout << "adder destroyed\n";
  });
}
auto sum(int a, int b, int c, int * ret)
{
  std::function<bool()> co;
  int tmp = 0;

  return make_coroutine([=,COROUTINE_STATE] () mutable
    {
      START_COROUTINE;
      co = add(a, b, &tmp);
      while(co())
        YIELD();

      co = add(tmp, c, ret);
      while(co())
        YIELD();

      FINISH_COROUTINE;
    },
    []{
      std::cout << "winter is coming\n";
    }
  );
}

请注意，在此设计中，析构函数无法访问“主体”中的任何状态更改，例如 ED。

您捕获COROUTINE_STATE 以获取ED 指针。然后START_COROUTINE; 进行自动分支，YIELD() 插入跳转点，FINISH_COROUTINE; 结束协程。

这里缺少共享状态是一个严重的问题。主体可以访问的co 与驱逐舰在执行= 时可以访问的co 完全不同。

我们可以通过在您的协程中添加一个新状态来解决这个问题，该状态发生在FINISH_COROUTINE; 或类似的“之后”。注入访问的能力是很棘手的——一种方法是将ED 移出 lambda 捕获本身：

template<class F>
struct coroutine {
  void** ED = nullptr;
  F f;
  template<class...Args>
  std::result_of_t< F&(void**,Args...) >
  operator()(Args&&...args){
    return f(ED, std::forward<Args>(args)...);
  }
  ~coroutine() {
    void* end = 0;
    f(&end);
  }
};
template<class F>
coroutine<std::decay_t<F>>
make_coroutine(F&& f){return {std::forward<F>{f}};}
#define START_COROUTINE [=](void** ED)mutable{\
  if (ED){if (*ED)goto *ED;\
  else goto Cleanup;}
#define END_COROUTINE_BODY return false; Cleanup:
#define END_COROUTINE_CLEANUP }
#define END_COROUTINE END_COROUTINE_BODY; END_COROUTINE_CLEANUP

auto sum(int a, int b, int c, int * ret)
{
  std::function<bool()> co = 0;
  int tmp = 0;

  return
  START_COROUTINE
    co = add(a, b, &tmp);
    while(co())
      YIELD();

    co = add(tmp, c, ret);
    while(co())
      YIELD();
  END_COROUTINE_BODY
    std::cout << "winter is coming\n";
  END_COROUTINE_CLEANUP;
}

或类似的东西。我们明确地传递ED，如果它指向一个nullptr，我们认为它意味着“跳转到清理代码”。这会将清理代码与正文放在同一范围内。

我现在看到你的类型擦除到std::function 可能有用。请注意，这种类型擦除需要内存分配开销（实际上），这是不幸的，并且每次调用都会产生虚函数开销。

遗憾的是，在我想通之前，我重用了你的 coroutine 类型名，所以直接开始使用 std::function<bool()。我很抱歉。