是否可以将 C++0x lambda 转换为 clang 块？

发布于 2024-10-02 11:53:40 字数 418 浏览 4 评论 0原文

我想知道是否可以将 C++0x lambda 转换为 clang 块。到目前为止，我所看到的一切都涉及到他们之间差异的讨论。我研究这个的主要原因是为 libdispatch 制作一个最终的包装器，虽然我非常了解 dispatch_*_f 函数，但有关其使用的任何信息都有与他们的区块相比，这是相当缺乏的。

到目前为止，我已经能够找到有关将 C++ lambda 转换为函数指针，但这更多的是相反的领域。

如果有人知道与此相关的任何信息，并且可以提供链接，或者至少为我指出正确的方向，我将非常感激。（即使是“目前不可能”的答案就足够了）

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

云柯 2024-10-09 11:53:41

我建议使用 libdispatch 函数的 *_f 版本。所有的块版本都是根据底层的函数版本来实现的，编写一个生成调用 lambda 对象的函数的 C++ 模板比编写一个生成调用 lambda 的块的模板要容易得多一个 lambda 对象。

然而，目前 Clang 缺乏对 C++ lambda 的支持可能会给整个事情带来阻碍。

回复收藏 0 原文

挖个坑埋了你 2024-10-09 11:53:40

隐式启用此转换的补丁刚刚添加到 clang trunk 中。

回复收藏 0 原文

七禾 2024-10-09 11:53:40

一般来说，当 lambda 用于“向下”闭包时，可以通过 conversion:

[&](int i) { return i; }

to:

^(int i) { return i; }

将 c++ lambda 转换为 clang 块，但仍然存在一些细微的差异。 Clang 的块仅通过 const 捕获 C++ 类。我不知道这是否也包括 C++ POD 类型。

最后，如果需要“向上”闭合，那么两者就会出现巨大分歧。 Clang 的块需要捕获的变量用 __block 注释，编译器将在堆上分配它。而在 C++ 中，lambda 捕获的方式需要根据对象的生命周期来决定（即通过值进行复制或通过引用）。

同样在 C++ 中，复制闭包是由 C++ 中的复制构造函数机制自动处理的。然而，对于clang的块，需要调用Block_copy和Block_release来处理块的复制。可以用 C++ 编写一个简单的包装器来处理这个问题。例如：

typedef void (^simple_block)(void);
class block_wrapper 
{
  simple_block block;

public:
  block_wrapper (const simple_block& x)
  : block(Block_copy(x)) {}

  void operator() () const
  {
    block();
  }

  block_wrapper(const block_wrapper& rhs) 
  : block(Block_copy(rhs.block)) 
  {}

  block_wrapper& operator=(const block_wrapper& rhs)
  {
    if (this != &rhs)
    {
      Block_release(this->block);
      this->block = Block_copy(rhs.block);
    }
    return *this;
  }

  ~block_wrapper () 
  {
    Block_release(this->block);
  }
};

Generally, when lambda is used for "downward" closure, you can convert a c++ lambda to a clang block by converting:

[&](int i) { return i; }

to:

^(int i) { return i; }

There is still some subtle differences. Clang's blocks only capture C++ classes by const. I don't know if this includes C++ POD types too.

Finally, if "upward" closure is needed, then the two diverge drastically. Clang's blocks require variables captured to be annotated with __block, which the compiler will allocate it on the heap. Whereas, in C++, the way the lambda captures, needs to be decided based on the lifetime of the object.(That is by value making a copy or by reference).

Also in C++, copying the closure is handle automatically by the copy-constructor mechanism in C++. However, with clang's block, Block_copy and Block_release need to be called to handle the copying of the block. A simple wrapper can be written in C++ to handle this. For example:

typedef void (^simple_block)(void);
class block_wrapper 
{
  simple_block block;

public:
  block_wrapper (const simple_block& x)
  : block(Block_copy(x)) {}

  void operator() () const
  {
    block();
  }

  block_wrapper(const block_wrapper& rhs) 
  : block(Block_copy(rhs.block)) 
  {}

  block_wrapper& operator=(const block_wrapper& rhs)
  {
    if (this != &rhs)
    {
      Block_release(this->block);
      this->block = Block_copy(rhs.block);
    }
    return *this;
  }

  ~block_wrapper () 
  {
    Block_release(this->block);
  }
};

回复收藏 0 原文

梦幻的味道 2024-10-09 11:53:40

我认为实际的转变是不可能的。与相反的情况不同，摆脱原来的 clang 块会产生一些无法恢复的副作用。虽然 C++0x lambda 可以通过引用捕获变量，但当您实际打算使用 lambda 时，没有执行任何特殊操作来确保原始变量仍然存在。另一方面，块可以与使用 __block 存储限定符声明的变量进行交互，在这种情况下，这些变量将保留在内存中（即使这意味着从堆栈复制到堆），只要该块存在（包括由 Block_copy 制作的副本）：