Expresiones lambda generalizadas en C++14

Las expresiones lambda se introdujeron en C++11. Son básicamente fragmentos de código que se pueden anidar dentro de otras funciones e incluso declaraciones de llamadas a funciones. Al combinar una expresión lambda con la palabra clave auto, estas expresiones se pueden usar más adelante en el programa.

Hemos discutido las expresiones lambda en detalle en este artículo Expresiones lambda en C++ . Antes de continuar con este artículo, asegúrese de haber leído el artículo vinculado o conocer la semántica de la expresión lambda, como la captura de alcance, el valor de retorno.

C++ 14 mejoró aún más las expresiones lambda al introducir lo que se llama una lambda generalizada . Para comprender esta característica, tomemos un ejemplo general. Supongamos que creamos una función lambda para devolver la suma de dos enteros. Entonces nuestra función lambda se vería así

[](int a, int b) -> int { return a + b; }

Pero, ¿y si necesitáramos obtener la suma de dos valores de coma flotante más adelante? Entonces, necesitaríamos declarar otra expresión lambda que funcione solo para valores dobles. De manera similar, cada vez que nuestros parámetros de entrada cambiaban de tipo, era necesario reescribir la función lambda.

[](double a, double b) -> double { return a + b; }

Antes de C++ 14, había una forma de evitar este problema mediante el uso de parámetros de plantilla,

template<typename T>
[](T a, T b) -> T { return a + b };

C++ 14 elimina esto y nos permite usar la palabra clave auto en los parámetros de entrada de la expresión lambda. Por lo tanto, los compiladores ahora pueden deducir el tipo de parámetros durante el tiempo de compilación. Entonces, en nuestro ejemplo anterior, una expresión lambda que funcionaría tanto para valores enteros como de punto flotante sería

[](auto a, auto b) { return a + b; }

Una aplicación muy importante de esta característica es que mejora enormemente los algoritmos existentes. Tomemos por ejemplo la función sort() . El siguiente fragmento ordenará todos los tipos de datos (siempre que tengan operadores < sobrecargados) en orden descendente.

sort(container.begin(), container.end(), 
[](auto i, auto j) -> bool { return i > j; }

Aquí hay algunos programas de ejemplo que usan lambdas generalizadas:

Ejemplo 1

// Cpp program to demonstrate
// generalized lambda expressions
#include <iostream>
#include <string>
  
using namespace std;
int main()
{
  
    // Declare a generalized lambda and store it in sum
    auto sum = [](auto a, auto b) {
        return a + b;
    };
  
    // Find sum of two integers
    cout << sum(1, 6) << endl;
  
    // Find sum of two floating numbers
    cout << sum(1.0, 5.6) << endl;
  
    // Find sum of two strings
    cout << sum(string("Geeks"), string("ForGeeks")) << endl;
  
    return 0;
}

Producción:

7
6.6
GeeksForGeeks

Ejemplo 2:

// Cpp program to demonstrate
// how to sort integers, floats, strings
// floating data types using a 
// generalized lambda and sort function
  
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
  
using namespace std;
  
// Utility Function to print the elements of a collection
void printElements(auto& C)
{
  
    for (auto e : C)
        cout << e << " ";
  
    cout << endl;
}
  
int main()
{
  
    // Declare a generalized lambda and store it in greater
    auto greater = [](auto a, auto b) -> bool {
        return a > b;
    };
  
    // Initialize a vector of integers
    vector<int> vi = { 1, 4, 2, 1, 6, 62, 636 };
  
    // Initialize a vector of doubles
    vector<double> vd = { 4.62, 161.3, 62.26, 13.4, 235.5 };
  
    // Initialize a vector of strings
    vector<string> vs = { "Tom", "Harry", "Ram", "Shyam" };
  
    // Sort integers
    sort(vi.begin(), vi.end(), greater);
  
    // Sort doubles
    sort(vd.begin(), vd.end(), greater);
  
    // Sort strings
    sort(vs.begin(), vs.end(), greater);
  
    printElements(vi);
    printElements(vd);
    printElements(vs);
  
    return 0;
}

Producción:

636 62 6 4 2 1 1
235.5 161.3 62.26 13.4 4.62                                                                         
Tom Shyam Ram Harry  

Nota: las expresiones Lambda generalizadas solo funcionan para los estándares C++ 14 y posteriores. La lista de compiladores que admiten C++ 14 se proporciona en la sección de referencias.

Referencias:

• https://isocpp.org/wiki/faq/cpp14-language
• http://en.cppreference.com/w/cpp/compiler_support