Lambda-Ausdrücke in C++Lambda Expressions in C++

In c++ 11 und höher ist ein Lambda Ausdruck –, der häufig als Lambdabezeichnet wird – eine bequeme Methode zum Definieren eines anonymen Funktions Objekts ( Closure) direkt an der Stelle, an der es aufgerufen oder als Argument an eine Funktion weitergeleitet wird.In C++11 and later, a lambda expression—often called a lambda—is a convenient way of defining an anonymous function object (a closure) right at the location where it is invoked or passed as an argument to a function. Lambda-Ausdrücke werden in der Regel verwendet, um ein paar Codezeilen zu kapseln, die an Algorithmen oder asynchrone Methoden übergeben werden.Typically lambdas are used to encapsulate a few lines of code that are passed to algorithms or asynchronous methods. Dieser Artikel definiert, was Lambdas sind, vergleicht sie mit anderen Programmierverfahren, beschreibt ihre Vorteile und bietet ein grundlegendes Beispiel.This article defines what lambdas are, compares them to other programming techniques, describes their advantages, and provides a basic example.

Bestandteile eines Lambda-AusdrucksParts of a Lambda Expression

Der ISO C++-Standard zeigt einen einfachen Lambda-Ausdruck, der als drittes Argument an die std::sort()-Funktion übergeben wird:The ISO C++ Standard shows a simple lambda that is passed as the third argument to the std::sort() function:

#include <algorithm>
#include <cmath>

void abssort(float* x, unsigned n) {
    std::sort(x, x + n,
        // Lambda expression begins
        [](float a, float b) {
            return (std::abs(a) < std::abs(b));
        } // end of lambda expression
    );
}

In dieser Abbildung werden die Bestandteile eines Lambda-Ausdrucks dargestellt:This illustration shows the parts of a lambda:

Strukturelle Elemente eines Lambda-AusdrucksStructural elements of a lambda expression

  1. Capture-Klausel (auch bekannt als Lambda-Introducer in der C++ Spezifikation)capture clause (Also known as the lambda-introducer in the C++ specification.)

  2. Parameterliste Optionale.parameter list Optional. (Auch als Lambda Deklaratorbezeichnet)(Also known as the lambda declarator)

  3. änderbare Spezifikation Optionale.mutable specification Optional.

  4. Exception-Spezifikation Optionale.exception-specification Optional.

  5. Trailing-Rückgabetyp Optionale.trailing-return-type Optional.

  6. Lambda-Text.lambda body.

ErfassungsklauselCapture Clause

Ein Lambda-Ausdruck kann neue Variablen in seinen Text einfügen (in c++ 14), und er kann auch auf Variablen aus dem umgebenden Bereich zugreifen oder diese erfassen.A lambda can introduce new variables in its body (in C++14), and it can also access, or capture, variables from the surrounding scope. Ein Lambda-Ausdruck beginnt mit der Capture -Klausel (Lambda-Introduction in der Standard Syntax), die angibt, welche Variablen aufgezeichnet werden und ob es sich um einen Wert oder einen Verweis handelt.A lambda begins with the capture clause (lambda-introducer in the Standard syntax), which specifies which variables are captured, and whether the capture is by value or by reference. Auf Variablen mit dem kaufmännischen Und-Zeichen (&) als Präfix erfolgt der Zugriff nach Verweis, und auf Variablen ohne dieses Präfix wird nach Wert zugegriffen.Variables that have the ampersand (&) prefix are accessed by reference and variables that do not have it are accessed by value.

Eine leere Erfassungsklausel ([ ]) gibt an, dass der Lambda-Text auf keine Variablen im einschließenden Bereich zugreift.An empty capture clause, [ ], indicates that the body of the lambda expression accesses no variables in the enclosing scope.

Sie können den Standard Erfassungs Modus (Capture-default in der Standard Syntax) verwenden, um anzugeben, wie externe Variablen aufgezeichnet werden sollen, auf die im Lambda verwiesen wird: [&] bedeutet, dass alle Variablen, auf die Sie verweisen, als Verweis aufgezeichnet werden, und [=] bedeutet, dass Sie nach Wert aufgezeichnet werden.You can use the default capture mode (capture-default in the Standard syntax) to indicate how to capture any outside variables that are referenced in the lambda: [&] means all variables that you refer to are captured by reference, and [=] means they are captured by value. Sie können einen Standarderfassungsmodus verwenden, und dann den entgegengesetzten Modus explizit für bestimmte Variablen angeben.You can use a default capture mode, and then specify the opposite mode explicitly for specific variables. Wenn beispielsweise der Lambda-Text auf die externe Variable total nach Wert zugreift und auf die externe Variable factor nach Wert, dann sind die folgenden Erfassungsklauseln gleichwertig:For example, if a lambda body accesses the external variable total by reference and the external variable factor by value, then the following capture clauses are equivalent:

[&total, factor]
[factor, &total]
[&, factor]
[factor, &]
[=, &total]
[&total, =]

Nur Variablen, die im Lambda-Ausdruck erwähnt werden, werden aufgezeichnet, wenn eine Capture-Default-Einstellung verwendet wird.Only variables that are mentioned in the lambda are captured when a capture-default is used.

Wenn eine Capture-Klausel eine Capture-default-&enthält, kann kein identifier in einer capture dieser Erfassungs Klausel das Formular & identifierhaben.If a capture clause includes a capture-default &, then no identifier in a capture of that capture clause can have the form & identifier. Wenn die Capture-Klausel eine Capture-default-=enthält, kann auch keine capture dieser Erfassungs Klausel die Form = identifierhaben.Likewise, if the capture clause includes a capture-default =, then no capture of that capture clause can have the form = identifier. Ein Bezeichner kann nicht mehr als einmal in einer Capture-Klausel vorkommen.An identifier or this cannot appear more than once in a capture clause. Der folgende Codeausschnitt veranschaulicht einige Beispiele.The following code snippet illustrates some examples.

struct S { void f(int i); };

void S::f(int i) {
    [&, i]{};      // OK
    [&, &i]{};     // ERROR: i preceded by & when & is the default
    [=, this]{};   // ERROR: this when = is the default
    [=, *this]{ }; // OK: captures this by value. See below.
    [i, i]{};      // ERROR: i repeated
}

Eine Erfassung, gefolgt von einem Ellipsen, ist eine Paket Erweiterung, wie in diesem Beispiel für eine Variadic-Vorlage gezeigt:A capture followed by an ellipsis is a pack expansion, as shown in this variadic template example:

template<class... Args>
void f(Args... args) {
    auto x = [args...] { return g(args...); };
    x();
}

Um Lambda-Ausdrücke im Text einer Klassenmethode zu verwenden, übergeben Sie den this -Zeiger an die Capture-Klausel, um den Zugriff auf die Methoden und Datenmember der einschließenden Klasse bereitzustellen.To use lambda expressions in the body of a class method, pass the this pointer to the capture clause to provide access to the methods and data members of the enclosing class.

Visual Studio 2017 Version 15,3 und höher (verfügbar mit /Std: c++ 17): der this -Zeiger kann nach Wert aufgezeichnet werden, indem *this in der Erfassungs Klausel angegeben wird.Visual Studio 2017 version 15.3 and later (available with /std:c++17): The this pointer may be captured by value by specifying *this in the capture clause. Die Erfassung nach Wert bedeutet, dass der gesamte Abschluss, bei dem es sich um das anonyme Funktions Objekt handelt, das den Lambda-Ausdruck einschließt, an jede Aufruf Site kopiert wird, in der der Lambda-Ausdruck aufgerufen wird.Capture by value means that the entire closure, which is the anonymous function object that encapulates the lambda expression, is copied to every call site where the lambda is invoked. Die Erfassung nach Wert ist nützlich, wenn der Lambda-Ausdruck in parallelen oder asynchronen Vorgängen ausgeführt wird, insbesondere bei bestimmten Hardwarearchitekturen, z. b. NUMA.Capture by value is useful when the lambda will execute in parallel or asynchronous operations, especially on certain hardware architectures such as NUMA.

Ein Beispiel für die Verwendung von Lambda-Ausdrücken mit Klassen Methoden finden Sie unter "Beispiel: Verwenden eines Lambda-Ausdrucks in einer Methode" unter Beispiele für Lambda-Ausdrücke.For an example that shows how to use lambda expressions with class methods, see "Example: Using a Lambda Expression in a Method" in Examples of Lambda Expressions.

Wenn Sie die Erfassungsklausel verwenden, sollten Sie diese wichtigen Punkte beachten, insbesondere wenn Sie Lambdas mit Multithreading verwenden:When you use the capture clause, we recommend that you keep these points in mind, particularly when you use lambdas with multithreading:

  • Verweiserfassungen können im Gegensatz zu Werterfassungen dazu verwendet werden, um Variablen outside zu ändern.Reference captures can be used to modify variables outside, but value captures cannot. (änderbar ermöglicht, dass Kopien geändert werden, aber keine Originale.)(mutable allows copies to be modified, but not originals.)

  • Verweiserfassungen können im Gegensatz zu Werterfassungen Änderungen von Variablen outside wiederspiegeln.Reference captures reflect updates to variables outside, but value captures do not.

  • Verweiserfassungen führen eine Lebenszeitabhängigkeit ein, während Werterfassungen keine Lebenszeitabhängigkeiten haben.Reference captures introduce a lifetime dependency, but value captures have no lifetime dependencies. Dies ist besonders beim asynchronen Ausführen von Lambda-Ausdrücken von Bedeutung.This is especially important when the lambda runs asynchronously. Beim Erfassen einer lokalen Variablen in einem asynchronem Lambda-Ausdruck ist die Variable höchstwahrscheinlich beim Ausführen des Lambdas nicht verfügbar und es tritt eine Zugriffsverletzung zur Laufzeit auf.If you capture a local by reference in an async lambda, that local will very possibly be gone by the time the lambda runs, resulting in an access violation at run time.

Generalisierte Erfassung (C++14)Generalized capture (C++ 14)

Neue Variablen können in C++14 in der Erfassungsklausel eingeführt und initialisiert werden, ohne dass diese Variablen im Bereich der Lambdafunktion vorhanden sein müssen.In C++14, you can introduce and initialize new variables in the capture clause, without the need to have those variables exist in the lambda function’s enclosing scope. Die Initialisierung kann mit einem beliebigen Ausdruck ausgedrückt werden; der Typ der neuen Variablen wird von dem durch den Ausdruck genierten Typ abgeleitet.The initialization can be expressed as any arbitrary expression; the type of the new variable is deduced from the type produced by the expression. Ein Vorteil dieser Funktion ist, dass Sie in C++14 Variablen, die nur verschoben werden können, (z. B. std::unique_ptr) aus dem umgebenden Bereich erfassen und in einem Lambda-Ausdruck verwenden können.One benefit of this feature is that in C++14 you can capture move-only variables (such as std::unique_ptr) from the surrounding scope and use them in a lambda.

pNums = make_unique<vector<int>>(nums);
//...
      auto a = [ptr = move(pNums)]()
        {
           // use ptr
        };

ParameterlisteParameter List

Neben dem Erfassen von Variablen werden in einem Lambda-Ausdruck Eingabeparameter akzeptiert.In addition to capturing variables, a lambda can accept input parameters. Eine Parameterliste (Lambda Deklarator in der Standard Syntax) ist optional und ähnelt in den meisten Aspekten der Parameterliste für eine Funktion.A parameter list (lambda declarator in the Standard syntax) is optional and in most aspects resembles the parameter list for a function.

auto y = [] (int first, int second)
{
    return first + second;
};

Wenn in C++ 14der Parametertyp generisch ist, können Sie das Schlüsselwort "Auto" als Typspezifizierer verwenden.In C++ 14, if the parameter type is generic, you can use the auto keyword as the type specifier. Das weist den Compiler an, den Funktionsaufrufoperator als Vorlage zu erstellen.This tells the compiler to create the function call operator as a template. Jede Instanz des auto-Schlüsselworts in einer Parameterliste entspricht einem Typparameter.Each instance of auto in a parameter list is equivalent to a distinct type parameter.

auto y = [] (auto first, auto second)
{
    return first + second;
};

Ein Lambdaausdruck kann einen anderen Lambdaausdruck als Argument übernehmen.A lambda expression can take another lambda expression as its argument. Weitere Informationen finden Sie unter "Lambda-Ausdrücke höherer Ordnung" im Thema Beispiele für Lambda-Ausdrücke.For more information, see "Higher-Order Lambda Expressions" in the topic Examples of Lambda Expressions.

Da eine Parameterliste optional ist, können Sie die leeren Klammern weglassen, wenn Sie keine Argumente an den Lambda-Ausdruck übergeben und der Lambda-Deklarator keine Exception-Specification, Trailing-Return-Typeoder änderbareenthält.Because a parameter list is optional, you can omit the empty parentheses if you do not pass arguments to the lambda expression and its lambda-declarator does not contain exception-specification, trailing-return-type, or mutable.

Änderbare SpezifikationMutable Specification

In der Regel ist der Funktions Aufrufoperator eines Lambda-Werts konstant, aber mit der Verwendung des änderbare -Schlüssel Worts wird dies abgebrochen. Er erzeugt keine änderbaren Datenmember.Typically, a lambda's function call operator is const-by-value, but use of the mutable keyword cancels this out. It does not produce mutable data members. Die änderbare Spezifikation aktiviert den Text eines Lambdaausdrucks, um Variablen zu ändern, die als Wert erfasst werden.The mutable specification enables the body of a lambda expression to modify variables that are captured by value. Einige der Beispiele weiter unten in diesem Artikel zeigen, wie Sie änderbarverwenden können.Some of the examples later in this article show how to use mutable.

AusnahmespezifikationException Specification

Sie können die noexcept-Ausnahmespezifikation verwenden, um anzugeben, dass der Lambdaausdruck keine Ausnahmen auslöst.You can use the noexcept exception specification to indicate that the lambda expression does not throw any exceptions. Wie bei normalen Funktionen generiert der Microsoft C++ -Compiler eine Warnung C4297 wenn ein Lambda-Ausdruck die noexcept Exception-Spezifikation deklariert und der Lambda-Text eine Ausnahme auslöst, wie hier gezeigt:As with ordinary functions, the Microsoft C++ compiler generates warning C4297 if a lambda expression declares the noexcept exception specification and the lambda body throws an exception, as shown here:

// throw_lambda_expression.cpp
// compile with: /W4 /EHsc
int main() // C4297 expected
{
   []() noexcept { throw 5; }();
}

Weitere Informationen finden Sie unter Ausnahme Spezifikationen (Throw).For more information, see Exception Specifications (throw).

RückgabetypReturn Type

Der Rückgabetyp von Lambda-Ausdrücken wird automatisch hergeleitet.The return type of a lambda expression is automatically deduced. Sie müssen das Schlüsselwort " Auto " nur verwenden, wenn Sie einen nachfolgenden Rückgabetypangeben.You don't have to use the auto keyword unless you specify a trailing-return-type. Der nachfolgende-Rückgabetyp ähnelt dem Rückgabetyp Teil einer normalen Methode oder Funktion.The trailing-return-type resembles the return-type part of an ordinary method or function. Der Rückgabetyp folgt jedoch auf die Parameterliste, und das Schlüsselwort „trailing-return-type ->“ muss vor dem Rückgabetyp angegeben werden.However, the return type must follow the parameter list, and you must include the trailing-return-type keyword -> before the return type.

Sie können den Rückgabetyp eines Lambda-Ausdrucks weglassen, wenn der Lambda-Text nur eine einzelne Return-Anweisung enthält oder der Lambda-Ausdruck keinen Wert zurückgibt.You can omit the return-type part of a lambda expression if the lambda body contains just one return statement or the expression does not return a value. Wenn der Lambda-Text aus einer einzelnen Rückgabeanweisung besteht, leitet der Compiler den Rückgabetyp vom Typ des Rückgabeausdrucks ab.If the lambda body contains one return statement, the compiler deduces the return type from the type of the return expression. Andernfalls leitet der Compiler den Rückgabetyp so ab, dass er leerist.Otherwise, the compiler deduces the return type to be void. Betrachten Sie die folgenden Beispiele von Codeausschnitten, die dieses Prinzip veranschaulichen.Consider the following example code snippets that illustrate this principle.

auto x1 = [](int i){ return i; }; // OK: return type is int
auto x2 = []{ return{ 1, 2 }; };  // ERROR: return type is void, deducing
                                  // return type from braced-init-list is not valid

Ein Lambdaausdruck kann einen anderen Lambdaausdruck als Rückgabewert erzeugen.A lambda expression can produce another lambda expression as its return value. Weitere Informationen finden Sie unter "Lambda-Ausdrücke höherer Ordnung" unter Beispiele für Lambda-Ausdrücke.For more information, see "Higher-Order Lambda Expressions" in Examples of Lambda Expressions.

Lambda-TextLambda Body

Der Lambda-Text (Verbund Anweisung in der Standard Syntax) eines Lambda-Ausdrucks kann alles enthalten, was der Text einer gewöhnlichen Methode oder Funktion enthalten kann.The lambda body (compound-statement in the Standard syntax) of a lambda expression can contain anything that the body of an ordinary method or function can contain. Der Text einer gewöhnlichen Funktion und eines Lambdaausdrucks kann auf die folgenden Variablenarten zugreifen:The body of both an ordinary function and a lambda expression can access these kinds of variables:

  • Aus dem einschließenden Bereich erfasste Variablen, wie zuvor beschrieben.Captured variables from the enclosing scope, as described previously.

  • ParametersParameters

  • Lokal deklarierte VariablenLocally-declared variables

  • Klassendatenmember, wenn Sie in einer Klasse deklariert werden und diese aufgezeichnet wirdClass data members, when declared inside a class and this is captured

  • Jede beliebige Variable mit statischer Speicherdauer (z. B. globale Variablen)Any variable that has static storage duration—for example, global variables

Das folgende Beispiel enthält einen Lambdaausdruck, welcher explizit die Variable n nach ihrem Wert erfasst und implizit die Variable m als Verweis erfasst:The following example contains a lambda expression that explicitly captures the variable n by value and implicitly captures the variable m by reference:

// captures_lambda_expression.cpp
// compile with: /W4 /EHsc
#include <iostream>
using namespace std;

int main()
{
   int m = 0;
   int n = 0;
   [&, n] (int a) mutable { m = ++n + a; }(4);
   cout << m << endl << n << endl;
}
5
0

Da die Variable n als Wert erfasst wird, bleibt der Wert 0 nach dem Aufruf des Lambda-Ausdrucks erhalten.Because the variable n is captured by value, its value remains 0 after the call to the lambda expression. Die änderbare Spezifikation ermöglicht die Änderung n innerhalb des Lambda-Ausdrucks.The mutable specification allows n to be modified within the lambda.

Obwohl ein Lambdaausdruck nur Variablen mit automatischer Speicherdauer aufzeichnen kann, können Sie Variablen verwenden, die eine statische Speicherdauer im Text eines Lambdaausdrucks aufweisen.Although a lambda expression can only capture variables that have automatic storage duration, you can use variables that have static storage duration in the body of a lambda expression. Im folgenden Beispiel wird die Funktion generate und ein Lambdaausdruck verwendet, um jedem Element in einem vector-Objekt einen Wert zuzuweisen.The following example uses the generate function and a lambda expression to assign a value to each element in a vector object. Der Lambda-Ausdruck ändert die statische Variable, um den Wert des nächsten Elements zu generieren.The lambda expression modifies the static variable to generate the value of the next element.

void fillVector(vector<int>& v)
{
    // A local static variable.
    static int nextValue = 1;

    // The lambda expression that appears in the following call to
    // the generate function modifies and uses the local static
    // variable nextValue.
    generate(v.begin(), v.end(), [] { return nextValue++; });
    //WARNING: this is not thread-safe and is shown for illustration only
}

Weitere Informationen finden Sie unter generierenvon.For more information, see generate.

Im folgenden Codebeispiel wird die-Funktion aus dem vorherigen Beispiel verwendet, und es wird ein Beispiel eines Lambda-Ausdrucks C++ hinzugefügt, der den generate_nder Standard Bibliothek verwendet.The following code example uses the function from the previous example, and adds an example of a lambda expression that uses the C++ Standard Library algorithm generate_n. Dieser Lambdaausdruck weist ein Element eines vector-Objekts der Summe der vorangehenden zwei Elemente zu.This lambda expression assigns an element of a vector object to the sum of the previous two elements. Das änderbare -Schlüsselwort wird verwendet, sodass der Text des Lambda-Ausdrucks seine Kopien der externen Variablen x und yändern kann, die vom Lambda-Ausdruck als Wert erfasst werden.The mutable keyword is used so that the body of the lambda expression can modify its copies of the external variables x and y, which the lambda expression captures by value. Da der Lambdaausdruck die originalen Variablen x und y als Wert erfasst, bleiben die Werte 1, nachdem das Lambda ausgeführt wird.Because the lambda expression captures the original variables x and y by value, their values remain 1 after the lambda executes.

// compile with: /W4 /EHsc
#include <algorithm>
#include <iostream>
#include <vector>
#include <string>

using namespace std;

template <typename C> void print(const string& s, const C& c) {
    cout << s;

    for (const auto& e : c) {
        cout << e << " ";
    }

    cout << endl;
}

void fillVector(vector<int>& v)
{
    // A local static variable.
    static int nextValue = 1;

    // The lambda expression that appears in the following call to
    // the generate function modifies and uses the local static
    // variable nextValue.
    generate(v.begin(), v.end(), [] { return nextValue++; });
    //WARNING: this is not thread-safe and is shown for illustration only
}

int main()
{
    // The number of elements in the vector.
    const int elementCount = 9;

    // Create a vector object with each element set to 1.
    vector<int> v(elementCount, 1);

    // These variables hold the previous two elements of the vector.
    int x = 1;
    int y = 1;

    // Sets each element in the vector to the sum of the
    // previous two elements.
    generate_n(v.begin() + 2,
        elementCount - 2,
        [=]() mutable throw() -> int { // lambda is the 3rd parameter
        // Generate current value.
        int n = x + y;
        // Update previous two values.
        x = y;
        y = n;
        return n;
    });
    print("vector v after call to generate_n() with lambda: ", v);

    // Print the local variables x and y.
    // The values of x and y hold their initial values because
    // they are captured by value.
    cout << "x: " << x << " y: " << y << endl;

    // Fill the vector with a sequence of numbers
    fillVector(v);
    print("vector v after 1st call to fillVector(): ", v);
    // Fill the vector with the next sequence of numbers
    fillVector(v);
    print("vector v after 2nd call to fillVector(): ", v);
}
vector v after call to generate_n() with lambda: 1 1 2 3 5 8 13 21 34
x: 1 y: 1
vector v after 1st call to fillVector(): 1 2 3 4 5 6 7 8 9
vector v after 2nd call to fillVector(): 10 11 12 13 14 15 16 17 18

Weitere Informationen finden Sie unter generate_n.For more information, see generate_n.

constexpr-Lambdaausdrückeconstexpr lambda expressions

Visual Studio 2017 Version 15,3 und höher (verfügbar mit /Std: c++ 17): ein Lambda-Ausdruck kann als constexpr deklariert oder in einem konstanten Ausdruck verwendet werden, wenn die Initialisierung jedes Datenmembers, den es erfasst oder einführt, innerhalb eines konstanten Ausdrucks zulässig ist.Visual Studio 2017 version 15.3 and later (available with /std:c++17): A lambda expression may be declared as constexpr or used in a constant expression when the initialization of each data member that it captures or introduces is allowed within a constant expression.

    int y = 32;
    auto answer = [y]() constexpr
    {
        int x = 10;
        return y + x;
    };

    constexpr int Increment(int n)
    {
        return [n] { return n + 1; }();
    }

Ein Lambda wird implizit constexpr, wenn das Ergebnis die Anforderungen einer constexpr-Funktion erfüllt:A lambda is implicitly constexpr if its result satisfies the requirements of a constexpr function:

    auto answer = [](int n)
    {
        return 32 + n;
    };

    constexpr int response = answer(10);

Wenn ein Lambda implizit oder explizit constexprist, erzeugt die Konvertierung in einen Funktionszeiger eine constexpr Funktion:If a lambda is implicitly or explicitly constexpr, conversion to a function pointer produces a constexpr function:

    auto Increment = [](int n)
    {
        return n + 1;
    };

    constexpr int(*inc)(int) = Increment;

Microsoft-spezifischMicrosoft-specific

Lambdas werden in den folgenden Common Language Runtime (CLR) verwalteten Entitäten nicht unterstützt: Verweis Klasse, Verweis Struktur, Wert Klasseoder Wert Struktur.Lambdas are not supported in the following common language runtime (CLR) managed entities: ref class, ref struct, value class, or value struct.

Wenn Sie einen Microsoft-spezifischen Modifizierer, z. b. __declspec, verwenden, können Sie ihn direkt nach dem parameter-declaration-clausein einen Lambda Ausdruck einfügen – beispielsweise:If you are using a Microsoft-specific modifier such as __declspec, you can insert it into a lambda expression immediately after the parameter-declaration-clause—for example:

auto Sqr = [](int t) __declspec(code_seg("PagedMem")) -> int { return t*t; };

Informationen dazu, ob ein Modifizierer von Lambdas unterstützt wird, finden Sie im Artikel über den Microsoft-spezifischen Modifizierer der- Dokumentation.To determine whether a modifier is supported by lambdas, see the article about it in the Microsoft-Specific Modifiers section of the documentation.

Zusätzlich zu den Standard mäßigen Lambda-Funktionen von c++ 11 unterstützt Visual Studio Zustands lose Lambdas, die zu Funktions Zeigern konvertiert werden können, die beliebige Aufruf Konventionen verwenden.In addition to C++11 Standard lambda functionality, Visual Studio supports stateless lambdas, which are omni-convertible to function pointers that use arbitrary calling conventions.

Siehe auchSee also

C++-ProgrammiersprachenreferenzC++ Language Reference
Funktionsobjekte in der C++-StandardbibliothekFunction Objects in the C++ Standard Library
FunktionsaufrufFunction Call
for_eachfor_each