Exemplos de expressões Lambda

Este tópico contém exemplos de como usar expressões lambda em seus programas.Para obter uma visão geral sobre expressões lambda, consulte Expressões lambda C++.Para obter mais informações sobre a estrutura de uma expressão lambda, consulte Sintaxe de expressões lambda.

Nesta seção

Exemplo: Declarando expressões Lambda

Exemplo: Expressões Lambda de chamada

Exemplo: Expressões Lambda de aninhamento

Exemplo: Funções de pedido superior Lambda

Exemplo: Usando uma expressão Lambda em um método

Exemplo: Usando expressões Lambda com modelos

Exemplo: Manipulando exceções

Exemplo: Usando expressões Lambda com tipos gerenciados

Exemplo: Declarando expressões Lambda

Descrição

Porque uma expressão lambda é digitada, você pode atribuí-lo a uma variável de auto ou um objeto de function , conforme mostrado no exemplo o seguir:

Código

// declaring_lambda_expressions1.cpp
#include <functional>

int main()
{
   // Assign the lambda expression that adds two numbers to an auto variable.
   auto f1 = [] (int x, int y) { return x + y; }; 

   // Assign the same lambda expression to a function object.
   function<int (int, int)> f2 = [] (int x, int y) { return x + y; };
}

Comentários

Para obter mais informações sobre a palavra-chave de auto , consulte palavra-chave (tipo de dedução) auto.Para obter mais informações sobre function class, consulte function Class.

Embora as expressões lambda são declaradas com mais freqüência no corpo de um método ou de uma função, você pode declará-las em qualquer lugar que você pode inicializar uma variável.

Descrição

O compilador do Visual C++ associa uma expressão lambda às variáveis capturados quando a expressão é declarada em vez de quando a expressão é chamada.O exemplo a seguir mostra uma expressão lambda que captura a variável local i por valor e a variável local j por referência.Porque a expressão lambda captura i por valor, a reatribuição de i posteriormente no programa não afeta o resultado da expressão.Em o entanto, como a expressão lambda captura j por referência, a reatribuição de j afeta o resultado da expressão.

Código

// declaring_lambda_expressions2.cpp
// compile with: /EHsc
#include <iostream>
#include <functional>

int main()
{
   using namespace std;

   int i = 3;
   int j = 5;

   // The following lambda expression captures i by value and
   // j by reference.
   function<int (void)> f = [i, &j] { return i + j; };

   // Change the values of i and j.
   i = 22;
   j = 44;

   // Call f and print its result.
   cout << f() << endl;
}

Saída

47

Comentários

[Nesta seção]

Exemplo: Expressões Lambda de chamada

Você pode chamar uma expressão lambda diretamente ou passe-o como um argumento para algoritmos padrão de (STL) de biblioteca de modelo como find_if.

Descrição

O exemplo a seguir declara uma expressão lambda que retorna a soma de dois inteiros e chame a expressão imediatamente com os argumentos 5 e 4:

Código

// calling_lambda_expressions1.cpp
// compile with: /EHsc
#include <iostream>

int main()
{
   using namespace std;
   int n = [] (int x, int y) { return x + y; }(5, 4);
   cout << n << endl;
}

Saída

9

Descrição

O exemplo passa uma expressão lambda como um argumento para a função de find_if .A expressão lambda retorna true se o parâmetro é mesmo um número.

Código

// calling_lambda_expressions2.cpp
// compile with: /EHsc
#include <list>
#include <algorithm>
#include <iostream>

int main()
{
   using namespace std;

   // Create a list of integers with a few initial elements.
   list<int> numbers;
   numbers.push_back(13);
   numbers.push_back(17);
   numbers.push_back(42);
   numbers.push_back(46);
   numbers.push_back(99);

   // Use the find_if function and a lambda expression to find the 
   // first even number in the list.
   const list<int>::const_iterator result =
      find_if(numbers.begin(), numbers.end(),
         [](int n) { return (n % 2) == 0; });

   // Print the result.
   if (result != numbers.end())
   {
       cout << "The first even number in the list is " 
            << (*result) 
            << "." 
            << endl;
   }
   else
   {
       cout << "The list contains no even numbers." 
            << endl;
   }
}

Saída

The first even number in the list is 42.

Comentários

Para obter mais informações sobre a função de find_if , consulte find_if.Para obter mais informações sobre funções de STL que executam algoritmos, consulte <algorithm>.

Descrição

Você pode chamar uma expressão que é atribuído a uma variável usando o operador de chamada de função, operator()lambda.O exemplo a seguir atribui uma expressão lambda a uma variável de auto e usa o operador de chamada de função para chamar a expressão lambda:

Código

// calling_lambda_expressions3.cpp
// compile with: /EHsc
#include <iostream>

int main()
{
   using namespace std;

   // Assign the lambda expression that adds two numbers to an 
   // auto variable.
   auto f = [] (int x, int y) { return x + y; };

   // Invoke the function object and print its result.
   cout << f(21, 12) << endl;
}

Saída

33

Comentários

Para obter mais informações sobre o operador de chamada de função, consulte Chamada de função (C++).

[Nesta seção]

Exemplo: Expressões Lambda de aninhamento

Descrição

Você pode aninhar uma expressão lambda em outra.O exemplo a seguir mostra uma expressão lambda que contém uma outra expressão lambda.A expressão lambda interna em seu argumento por 2 e retorna o resultado.A expressão lambda externo chama a expressão lambda interna com seu argumento e adiciona 3 ao resultado.

Código

// nesting_lambda_expressions.cpp
// compile with: /EHsc
#include <iostream>

int main()
{
   using namespace std;

   // The following lambda expression contains a nested lambda
   // expression.
   int m = [](int x) 
      { return [](int y) { return y * 2; }(x) + 3; }(5);

   // Print the result.
   cout << m << endl;
}

Saída

13

Comentários

Em esse exemplo, [](int y) { return y * 2; } é a expressão lambda aninhada.

[Nesta seção]

Exemplo: Funções de pedido superior Lambda

Descrição

Muitas linguagens de programação suportam o conceito de uma função de pedido superior. Uma função de pedido superior é uma expressão lambda que tenham outra expressão lambda como seu argumento ou que retorna uma expressão lambda.Você pode usar a classe de function para permitir a expressão de C++ lambda comportar como uma função de pedido superior.O exemplo a seguir mostra uma expressão lambda que retorna um objeto de function e uma expressão lambda que recebe um objeto de function como seu argumento:

Código

// higher_order_lambda_expression.cpp
// compile with: /EHsc
#include <iostream>
#include <functional>

int main()
{
   using namespace std;

   // The following code declares a lambda expression that returns 
   // another lambda expression that adds two numbers. 
   // The returned lambda expression captures parameter x by value.
   auto g = [](int x) -> function<int (int)> 
      { return [=](int y) { return x + y; }; };

   // The following code declares a lambda expression that takes another
   // lambda expression as its argument.
   // The lambda expression applies the argument z to the function f
   // and adds 1.
   auto h = [](const function<int (int)>& f, int z) 
      { return f(z) + 1; };

   // Call the lambda expression that is bound to h. 
   auto a = h(g(7), 8);

   // Print the result.
   cout << a << endl;
}

Saída

16

Comentários

[Nesta seção]

Exemplo: Usando uma expressão Lambda em um método

Descrição

Você pode usar expressões lambda no corpo do método.A expressão lambda pode acessar qualquer método ou membro de dados que o método incluindo pode acessar.Você pode explícita ou implicitamente capturar o ponteiro de this para fornecer acesso a membros de dados dos métodos e da classe delimitador.

O exemplo a seguir mostra a classe de Scale , que encapsula um valor de escala.O método de ApplyScale usa uma expressão lambda para imprimir o produto de cada elemento em um objeto de vector e o valor de escala.A expressão lambda tratou explicitamente o ponteiro de this para que possa acessar o membro de _scale .

// method_lambda_expression.cpp
// compile with: /EHsc
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

class Scale
{
public:
   // The constructor.
   explicit Scale(int scale)
      : _scale(scale)
   {
   }

   // Prints the product of each element in a vector object 
   // and the scale value to the console.
   void ApplyScale(const vector<int>& v) const
   {
      for_each(v.begin(), v.end(), 
         [this](int n) { cout << n * _scale << endl; });
   }

private:
   int _scale;
};

int main()
{
   vector<int> values;
   values.push_back(3);
   values.push_back(6);
   values.push_back(9);

   // Create a Scale object that scales elements by 3 and apply
   // it to the vector object.
   Scale s(3);
   s.ApplyScale(values);
}

Saída

9
18
27

Comentários

Você pode usar o ponteiro de this explicitamente em um método, conforme mostrado no exemplo o seguir:

void ApplyScale(const vector<int>& v) const
{
   for_each(v.begin(), v.end(), 
      [this](int n) { cout << n * this->_scale << endl; });
}

Você também pode capturar o ponteiro de this implicitamente, conforme mostrado no exemplo o seguir:

void ApplyScale(const vector<int>& v) const
{
   for_each(v.begin(), v.end(), 
      [=](int n) { cout << n * _scale << endl; });
}

[Nesta seção]

Exemplo: Usando expressões Lambda com modelos

Descrição

Porque as expressões lambda são digitadas, você pode usá-las com modelos C++.O exemplo a seguir mostra as funções de negate_all e de print_all .A função de negate_all aplica operator- unário para cada elemento no objeto de vector .A função de print_all imprime cada elemento no objeto de vector no console.

Código

// template_lambda_expression.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>

using namespace std;

// Negates each element in the vector object.
template <typename T> 
void negate_all(vector<T>& v)
{
    for_each(v.begin(), v.end(), [] (T& n) { n = -n; } );
}

// Prints to the console each element in the vector object.
template <typename T> 
void print_all(const vector<T>& v)
{
   for_each(v.begin(), v.end(), [] (const T& n) { cout << n << endl; } );
}

int main()
{
   // Create a vector of integers with a few initial elements.
   vector<int> v;
   v.push_back(34);
   v.push_back(-43);
   v.push_back(56);

   // Negate each element in the vector.
   negate_all(v);

   // Print each element in the vector.
   print_all(v);
}

Saída

-34
43
-56

Comentários

Para obter mais informações sobre modelos de C++, consulte Modelos.

[Nesta seção]

Exemplo: Manipulando exceções

Descrição

O corpo de uma expressão lambda seguem as regras para ambos tratamento de exceção estruturada (SEH) e C++ manipulação de exceção.Você pode manipular uma exceção gerada no corpo de uma expressão lambda ou adiar a manipulação de exceção para o escopo delimitador.O exemplo a seguir usa a função de for_each e uma expressão lambda para preencher um objeto de vector com os valores de outro.Usa um bloco de try/catch para manipular o acesso inválido para o primeiro vetor.

Código

// eh_lambda_expression.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;

int main()
{
   // Create a vector that contains 3 elements.
   vector<int> elements(3);

   // Create another vector that contains index values.
   vector<int> indices(3);
   indices[0] = 0;
   indices[1] = -1; // This is not a subscript. It will trigger the exception.
   indices[2] = 2;

   // Use the values from the vector of index values to 
   // fill the elements vector. This example uses a 
   // try/catch block to handle invalid access to the 
   // elements vector.
   try
   {
       for_each(indices.begin(), indices.end(), 
           [&] (int index) { elements.at(index) = index; });
   }
   catch (const out_of_range& e) 
   {
       cerr << "Caught '" << e.what() << "'." << endl;
   };
}

Saída

Caught 'invalid vector<T> subscript'.

Comentários

Para obter mais informações sobre manipulação de exceção, consulte Tratamento de exceção no Visual C++.

[Nesta seção]

Exemplo: Usando expressões Lambda com tipos gerenciados

Descrição

A cláusula catch de uma expressão lambda não pode conter uma variável com um tipo gerenciado.Em o entanto, você pode passar um argumento para um tipo gerenciado para uma lista de parâmetros de expressões lambda.O exemplo a seguir contém uma expressão lambda que captura ch variável local não gerenciado por valor e recebe um objeto de System.String como seu parâmetro:

Código

// managed_lambda_expression.cpp
// compile with: /clr
using namespace System;

int main()
{
    char ch = '!'; // a local unmanaged variable
    
    // The following lambda expression captures local variables
    // by value and takes a managed String object as its parameter.
    [=] (String ^s) 
        { Console::WriteLine(s + Convert::ToChar(ch)); }("Hello");
}

Saída

Hello!

Comentários

Você também pode usar expressões lambda com a biblioteca de STL/CLR.Para obter mais informações sobre STL/CLR, consulte Referência da biblioteca STL/CLR..

[Nesta seção]

Consulte também

Referência

Expressões lambda C++

Sintaxe de expressões lambda

palavra-chave (tipo de dedução) auto

function Class

find_if

<algorithm>

Chamada de função (C++)

Tratamento de exceção no Visual C++

Outros recursos

Modelos

Referência da biblioteca STL/CLR.