C++ lambda 函数的默认调用约定是什么？

Question

以下代码使用 VC++ 2012 编译：

void f1(void (__stdcall *)())
{}

void f2(void (__cdecl *)())
{}

void __cdecl h1()
{}

void __stdcall h2()
{}

int main()
{
    f1(h1); // error C2664
    f2(h2); // error C2664

    f1([](){}); // OK
    f2([](){}); // OK

    auto fn = [](){};

    f1(fn); // OK
    f2(fn); // OK
}

我认为错误是正常的，但 OK 是异常的。

所以，我的问题是：

1. C++ lambda 函数的调用约定是什么？

2. 如何指定 C++ lambda 函数的调用约定？

3. 如果没有定义调用约定，如何在调用lambda函数后正确回收堆栈空间？

4. 编译器会自动生成多个版本的 lambda 函数吗？即如下伪代码：

   [] __stdcall (){};

   [] __cdecl (){};等等

Answer 1

在 VC++ 2012 上，编译器选择自动调用无状态 lambda（没有捕获变量）的转换当您将“无状态 lambda 转换为函数指针”。

MSDN C++11 Features:

Lambdas

[...] 此外，在 Visual Studio 2012 的 Visual C++ 中，无状态 lambda 可转换为函数指针。 [...]（Visual Studio 2012 中的 Visual C++ 甚至比这更好，因为我们已将无状态 lambda 转换为具有任意调用约定的函数指针。当您使用期望像 @987654324 这样的 API 时，这一点很重要@函数指针。）

---

已编辑：

注意：调用转换超出C++标准，依赖于平台ABI（应用程序二进制接口）等其他规范。

以下答案基于带有/FAs compiler option 的输出汇编代码。 所以这只是一个猜测，请向微软询问更多细节;P

第一季度。 C++ lambda 函数的调用约定是什么？

第三季度。如果没有定义调用约定，在调用 lambda 函数后如何正确回收堆栈空间？

首先，C++ lambda(-expression) 不是函数（也不是函数指针），你可以像调用普通函数一样调用operator() 到lambda 对象。 并且输出汇编代码显示VC++ 2012 生成带有__thiscall 调用转换的lambda-body。

第二季度。如何指定 C++ lambda 函数的调用约定？

AFAIK，没有办法。 （可能只有__thiscall）

第四季度。编译器会自动生成多个版本的 lambda 函数吗？即作为以下伪代码：[...]

可能没有。 VC++ 2012 lambda-type 只提供了一种 lambda-body 实现（void operator()()），但为每次调用转换提供了多个“用户定义的函数指针转换”（操作符返回函数指针为void (__fastcall*)(void)、void (__stdcall*)(void) 和void (__cdecl*)(void) 类型）。

这是一个例子；

// input source code
auto lm = [](){ /*lambda-body*/ };

// reversed C++ code from VC++2012 output assembly code
class lambda_UNIQUE_HASH {
  void __thiscall operator()() {
    /* lambda-body */
  }
  // user-defined conversions
  typedef void (__fastcall * fp_fastcall_t)();
  typedef void (__stdcall * fp_stdcall_t)();
  typedef void (__cdecl * fp_cdecl_t)();
  operator fp_fastcall_t() { ... }
  operator fp_stdcall_t() { ... }
  operator fp_cdecl_t() { ... }
};
lambda_UNIQUE_HASH lm;

Answer 2

无状态的 lambda 函数仍然是一个类，但是一个可以隐式转换为函数指针的类。

C++ 标准不涵盖调用约定，但几乎没有理由说明为什么无状态 lambda 无法在任何调用约定中创建包装器，当 lambda 转换为函数指针时，该包装器转发到无状态 lambda。

例如，我们可以这样做：

#include <iostream>

void __cdecl h1() {}
void __stdcall h2(){}

// I'm lazy: 
typedef decltype(&h1) cdecl_nullary_ptr;
typedef decltype(&h2) stdcall_nullary_ptr;

template<typename StatelessNullaryFunctor>
struct make_cdecl {
  static void __cdecl do_it() {
    StatelessNullaryFunctor()();
  }
};
template<typename StatelessNullaryFunctor>
struct make_stdcall {
  static void __stdcall do_it() {
    StatelessNullaryFunctor()();
  }
};

struct test {
  void operator()() const { hidden_implementation(); }

  operator cdecl_nullary_ptr() const {
    return &make_cdecl<test>::do_it;
  }
  operator stdcall_nullary_ptr() const {
    return &make_stdcall<test>::do_it;
  }
};

我们的test 无状态空值类可以隐式转换为cdecl 和stdcall 函数指针。

其中重要的部分是调用约定是函数指针类型的一部分，因此operator function_type 知道正在请求什么调用约定。而通过完美转发，上述方法甚至可以是高效的。