First, let’s look at how lambdas are implemented in C++. <\/p>\n
It is similar in flavor to the way lambdas are implemented in C#<\/a>, but the details are all different. <\/p>\n When the C++ compiler encounters a lambda expression, it generates a new anonymous class. Each captured variable becomes a member of that anonymous class, and the member is initialized from the variable in the outer scope. Finally, the anonymous class is given an I am simplifying here. You can read the C++ language specification for gory details. The purpose of this discussion is just to give a conceptual model for how lambdas work so we can get to answering the question. The language also provides for syntactic sugar to infer the lambda return type and capture variables implicitly. Let’s assume all the sugar has been applied so that everything is explicit. <\/p>\n Here’s a basic example: <\/p>\n The compiler internally converts this to something like this: <\/p>\n We are closer to answering the original question. but we’re not there yet. <\/p>\n As a special bonus: If there are no captured variables, then there is an additional conversion operator that can convert the lambda to a pointer to a nonmember function. This is possible only in the case of no captured variables because captured variables would require an Here’s a lambda with no captured variables. <\/p>\n The above code gets transformed to <\/p>\n Okay, now we can get to the actual question: How can I specify the calling convention for this implicit conversion to a pointer to nonmember function<\/a>? <\/p>\n (Note that calling conventions are not part of the C++ standard, so this question is necessarily a platform-specific question.) <\/p>\noperator()<\/code> implementation whose parameter list is the parameter list of the lambda, whose body is the lambda body, and whose return value is the lambda return value. <\/p>\n\nvoid ContainingClass::SomeMethod()\n{\n int i = 0, j = 1;\n auto f = [this, i, &j](int k) -> int\n { return this->calc(i + j + k); };\n ...\n}\n<\/pre>\n\nvoid ContainingClass::SomeMethod()\n{\n int i = 0, j = 1;\n\n \/\/ Autogenerated by the compiler\n class AnonymousClass$0\n {\n public:\n AnonymousClass$0(ContainingClass* this$, int i$, int& j$) :\n this$0(this$), i$0(i$), j$0(j$) { }\n int operator<\/font>(int k) const<\/font>\n { return this$0->calc(i$0 + j$0 + k); }\n private:\n ContainingClass* this$0; \/\/ this captured by value\n int i$0; \/\/ i captured by value\n int& j$0; \/\/ j captured by reference\n };<\/font>\n\n auto f = AnonymousClass$0<\/font>(this, i, j);\n ...\n}\n<\/pre>\nAnonymousClass$0<\/code> instance parameter, but there is nowhere to pass it. <\/p>\n\nvoid ContainingClass::SomeMethod()\n{\n auto f = [](int k) -> int { return calc(k + 42); };\n ...\n}\n<\/pre>\n\nvoid ContainingClass::SomeMethod()\n{\n class AnonymousClass$0\n {\n public:\n AnonymousClass$0() { }\n operator int (*)(int k) { return static_function; }<\/font>\n int operator(int k) const<\/font> { return calc(k + 42); }\n private:\n static int static_function(int k) { return calc(k + 42); }\n };\n\n auto f = AnonymousClass$0();\n ...\n}\n<\/pre>\n