Ver código fonte para cpp/language/lambda

Não tem permissão para editar esta página, pelo seguinte motivo:
A operação solicitada está limitada a utilizadores de um dos seguintes grupos: Utilizadores, Administradores.
Pode ver e copiar o código fonte desta página.
{{tr note|index}}
{{title|Lambda functions {{mark since c++11}}}}
{{cpp/language/navbar}}

Constrói uma [[enwiki:Closure (computer science)|oclusão]]: uma função objeto anônima capaz de captar as variáveis no escopo.

===Sintaxe===
{{sdsc begin}}
{{sdsc | num=1 |
{{ttb|[}} {{spar|captures}} {{ttb|]}} {{spar|<tparams>}}{{mark optional}}{{mark|c++20}} {{ttb|(}} {{spar|params}} {{ttb|)}} {{spar|specifiers}} {{spar|exception}} {{spar|attr}} {{ttb|->}} {{spar|ret}} {{spar|requires}}{{mark optional}}{{mark|c++20}} {{ttb|{}} {{spar|body}} {{ttb|} }}
}}
{{sdsc | num=2 |
{{ttb|[}} {{spar|captures}} {{ttb|]}} {{ttb|(}} {{spar|params}} {{ttb|)}} {{ttb|->}} {{spar|ret}} {{ttb|{}} {{spar|body}} {{ttb|} }}
}}
{{sdsc | num=3 |
{{ttb|[}} {{spar|captures}} {{ttb|]}} {{ttb|(}} {{spar|params}} {{ttb|)}} {{ttb|{}} {{spar|body}} {{ttb|} }}
}}
{{sdsc | num=4 |
{{ttb|[}} {{spar|captures}} {{ttb|]}} {{ttb|{}} {{spar|body}} {{ttb|} }}
}}
{{sdsc end}}

1) Declaração completa.

2) Declaração de um ''const lambda'': os objetos capturados por cópia são tratados como ''const'' no corpo do lambda.

3) ''Trailing-return-type'' omitido: o tipo de retorno do ''functor'', {{tt|operator()}}, da oclusão é {{rlp|template argument deduction|deduzido}} a partir da declaração do tipo de  {{ltt|cpp/language/return|retorno}} da mesma forma que uma função quando seu {{rlp|function#Return_type_deduction|tipo de retorno é declarado ''auto''}}.

4) Lista de parâmetros omitida: função sem argumentos, como se a lista de parâmetros fosse {{ttb|()}}. Essa forma apenas pode ser utilizada caso nenhum dos seguintes tipos de retorno forem usados: ''constexpr, mutable, exception specification, attributes ou trailing return type''.

===Explicação===
{{par begin}}
{{par | {{spar|mutable}} |{{tr| {{spar|body}} permite modificar os parâmetros capturados por cópia, e chamar suas funções não-membro const| allows {{spar|body}} to modify the parameters captured by copy, and to call their non-const member functions}}}}
{{par | {{spar|exception}} |{{tr| fornece o [[cpp/language/except_spec|especificação de exceção]] ou o [[cpp/language/noexcept_spec|noexcept cláusula]] de operador () do tipo de fecho| provides the [[cpp/language/except_spec|especificação de exceção]] or the [[cpp/language/noexcept_spec|noexcept cláusula]] for operator() of the closure type}}}}
{{par | {{spar|attribute}} |{{tr| fornece o [[cpp/language/attributes|especificação de atributo]] de operador () do tipo de fecho| provides the [[cpp/language/attributes|especificação de atributo]] for operator() of the closure type}}}}
{{par | capture |{{tr| especifica quais símbolos visíveis no âmbito em que a função é declarada será visível no interior do corpo da função.
Uma lista de símbolos pode ser passado como se segue:
* {{ttb|[a,&b]}} onde'' a'' é capturado por valor e'' b'' é capturado por referência.
* {{ttb|[this]}} capta o [[CPP / linguagem / isso| specifies which symbols visible in the scope where the function is declared will be visible inside the function body.
A list of symbols can be passed as follows: 
*{{ttb|[a,&b]}} where ''a'' is captured by value and ''b'' is captured by reference.
*{{ttb|[this]}} captures the [[cpp/language/this}}|{{ttb|this}} pointer]]
*{{ttb|[&]}} captures all symbols by reference
*{{ttb|[{{=}}]}} captures all by value
*{{ttb|[]}} captures nothing }}
{{par | params |{{tr| A lista de parâmetros, como no [[cpp/language/function|nomeado funções]]| The list of parameters, as in [[cpp/language/function|nomeado funções]]}}}}
{{par | ret |{{tr| Tipo de retorno. Se não estiver presente é implícitos nas declarações de função de retorno (ou nulo se não devolver qualquer valor)| Return type. If not present it's implied by the function return statements ( or void if it doesn't return any value)}}}}
{{par | body |{{tr| Corpo da função| Function body}}}}
{{par end}}


{{tr|A expressão lambda constrói um objeto não identificado temporária de única sem nome não-união tipo não-agregado, conhecido como'''' tipo de fechamento, que tem os seguintes membros:|The lambda expression constructs an unnamed temporary object of unique unnamed non-union non-aggregate type, known as ''closure type'', which has the following members:}}

{{member | {{small|{{tr|ClosureType ::|ClosureType::}}}}operator() | 2=
{{dcl begin}}
{{dcl | notes={{mark|a palavra-chave mutável não foi utilizado}} | 1=
ret operator()(params) const { body }
}}
{{dcl | notes={{mark|a palavra-chave foi usada mutável}} | 1=
ret operator()(params) { body }
}}
{{dcl end}}
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 {{c|mutable}} was used in the lamda-expression, the objects that were captured by copy are non-modifiable from inside this {{c|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.
}}

{{member | {{small|{{tr|ClosureType ::|ClosureType::}}}}operator ret(*)(params) | 2=

{{ddcl |1=
typedef ret(*F)(params);
operator F() const; 
}}

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.
}}

{{member | {{small|{{tr|ClosureType ::|ClosureType::}}}}ClosureType() | 2=
{{dcl begin}}
{{dcl | 1=
ClosureType() = delete;
}}
{{dcl | 1=
ClosureType(const ClosureType& ) = default;
}}
{{dcl | 1=
ClosureType(ClosureType&& ) = default;
}}
{{dcl end}}
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 [[cpp/language/copy_constructor|copiar construtores]] and [[cpp/language/move_constructor|mover construtores]].
}}

{{member | {{small|{{tr|ClosureType ::|ClosureType::}}}}operator{{=}}() | 2=
{{ddcl |1=
ClosureType& operator=(const ClosureType&) = delete;
}}
Closure types are not CopyAssignable.
}}

{{member | {{small|{{tr|ClosureType ::|ClosureType::}}}}~ClosureType() | 2=
{{ddcl |1=
~ClosureType() = default;
}}
The destructor is implicitly-declared.
}}

{{member | {{small|{{tr|ClosureType ::|ClosureType::}}}}CapturedParam | 2=
{{ddcl |1=
T1 a;
T2 b;
...
}}
If the lambda-expression captures anything by copy (either implicitly with capture clause {{ttb|[{{=}}]}} or explicitly with a capture that does not include the character &, e.g. {{ttb|[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 {{ttb|[&]}} or when using the character &, e.g. {{ttb|[&a, &b, &c]}}), it is unspecified if additional data members are declared in the closure type.
}}

{{todo|scope rules, capture list rules, nested lambdas, implicit capture vs odr use, decltype}}

===Exemplo===
{{example
 |{{tr| Este exemplo mostra como passar um lambda a um algoritmo genérico e que os objectos resultantes de uma declaração lambda, podem ser armazenados em objectos {{lc|std::function}} .
 | This example shows how to pass a lambda to a generic algorithm and that objects resulting from a lambda declaration, can be stored in {{lc|std::function}} objects.
 }}| code=
#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= 
c: 5 6 7
func: 10
}}

===Veja também===
{{dsc begin}}
{{dsc inc | cpp/language/dsc auto}}
{{dsc inc | cpp/utility/functional/dsc function}}
{{dsc end}}

[[de:cpp/language/lambda]]
[[en:cpp/language/lambda]]
[[es:cpp/language/lambda]]
[[fr:cpp/language/lambda]]
[[it:cpp/language/lambda]]
[[ja:cpp/language/lambda]]
[[ru:cpp/language/lambda]]
[[zh:cpp/language/lambda]]
Predefinições utilizadas nesta página:
Voltar para cpp/language/lambda.
cppreference.com

Procurar

Espaços nominais

Variantes

Visualizações

Ações

Ver código fonte para cpp/language/lambda

Navegação

Ferramentas
