Lambda functions (dal C++11) - cppreference.com

Costruisce un chiusura: un oggetto funzione senza nome in grado di catturare le variabili in campo.

Dichiarazione completa

Dichiarazione di un const lambda: gli oggetti catturati dalla copia non può essere modificato.

Omesso trailing-return-type: il tipo restituito di operator() la chiusura è dedotto in base alle seguenti regole:

Elenco di parametri Omesso: funzione non ha argomenti, come se la lista dei parametri è stato ()

L'espressione lambda costruisce un oggetto senza nome temporaneo di unico senza nome non-unione non-aggregati di tipo, noto come tipo di chiusura, che ha i seguenti membri:

ClosureType ::

Original:

ClosureType::

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

operator()

<tbody> </tbody>

Executes the body of the lambda-expression, when invoked. When accessing a variable, accesses its captured copy (for the entities captured by copy), or the original object (for the entities captured by reference). Unless the keyword mutable was used in the lamda-expression, the objects that were captured by copy are non-modifiable from inside this operator().

Dangling references

If an entity is captured by reference, implicitly or explicitly, and the function call operator of the closure object is invoked after the entity's lifetime has ended, undefined behavior occurs. The C++ closures do not extend the lifetimes of the captured references.

ClosureType ::

Original:

ClosureType::

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

operator ret(*)(params)

<tbody> </tbody>

This member function is only defined if the capture list of the lambda-expression is empty.

The value returned by this conversion function is a function pointer that, when invoked, has the same effect as invoking the closure object's function call operator directly.

ClosureType ::

Original:

ClosureType::

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

ClosureType()

<tbody> </tbody>

Closure types are not DefaultConstructible. The copy constructor and the move constructor are implicitly-declared and may be implicitly-defined according to the usual rules for implicit copiare costruttori and spostare costruttori.

ClosureType ::

Original:

ClosureType::

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

operator=()

<tbody> </tbody>

Closure types are not CopyAssignable.

ClosureType ::

Original:

ClosureType::

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

~ClosureType()

<tbody> </tbody>

The destructor is implicitly-declared.

ClosureType ::

Original:

ClosureType::

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

CapturedParam

<tbody> </tbody>

If the lambda-expression captures anything by copy (either implicitly with capture clause [=] or explicitly with a capture that does not include the character &, e.g. [a, b, c]), the closure type includes unnamed non-static data members, declared in unspecified order, that hold copies of all entities that were so captured.

The type of each data member is the type of the corresponding captured entity, except if the entity has reference type (in that case, references to functions are captured as-is, and references to objects are captured as copies of the referenced objects).

For the entities that are captured by reference (with the default capture [&] or when using the character &, e.g. [&a, &b, &c]), it is unspecified if additional data members are declared in the closure type.

#include <vector>
#include <iostream>
#include <algorithm>
#include <functional>

int main()
{
    std::vector<int> c { 1,2,3,4,5,6,7 };
    int x = 5;
    c.erase(std::remove_if(c.begin(), c.end(), [x](int n) { return n < x; } ), c.end());

    std::cout << "c: ";
    for (auto i: c) {
        std::cout << i << ' ';
    }
    std::cout << '\n';

    std::function<int (int)> func = [](int i) { return i+4; };
    std::cout << "func: " << func(6) << '\n'; 
}

Output: