El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Expresiones Lambda

Siguiente ►
►

Las expresiones lambda en C++ son una característica poderosa introducida en C++11 que permite definir funciones anónimas de manera concisa. Son útiles para operaciones que requieren funciones cortas y temporales, como las que se pasan a algoritmos de la Biblioteca Estándar de Plantillas (STL).

Conceptos Clave

  1. Sintaxis Básica:

    [captura](parametros) -> tipo_retorno { cuerpo }
    • Captura: Define qué variables externas están disponibles dentro de la lambda.
    • Parámetros: Lista de parámetros de la función.
    • Tipo de Retorno: (Opcional) Especifica el tipo de retorno de la función.
    • Cuerpo: El código que se ejecuta cuando se llama a la lambda.

  2. Captura por Valor y por Referencia:

    • Por Valor ([=]): Captura las variables externas por valor.
    • Por Referencia ([&]): Captura las variables externas por referencia.

  3. Ejemplo de Uso:

    auto lambda = [](int x, int y) -> int {
    return x + y;
};
std::cout << lambda(2, 3); // Salida: 5

Ejemplos Prácticos

Ejemplo 1: Captura por Valor

#include <iostream>

int main() {
    int a = 10;
    auto lambda = [=]() {
        std::cout << "Valor de a: " << a << std::endl;
    };
    lambda(); // Salida: Valor de a: 10
    return 0;
}

Explicación: La lambda captura a por valor, por lo que dentro de la lambda, a es una copia de la variable externa.

Ejemplo 2: Captura por Referencia

#include <iostream>

int main() {
    int a = 10;
    auto lambda = [&]() {
        a = 20;
    };
    lambda();
    std::cout << "Nuevo valor de a: " << a << std::endl; // Salida: Nuevo valor de a: 20
    return 0;
}

Explicación: La lambda captura a por referencia, permitiendo modificar la variable externa a.

Ejemplo 3: Uso en Algoritmos STL

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

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::for_each(vec.begin(), vec.end(), [](int &n) { n *= 2; });

    for (int n : vec) {
        std::cout << n << " "; // Salida: 2 4 6 8 10
    }
    return 0;
}

Explicación: La lambda se pasa a std::for_each para duplicar cada elemento del vector.

Ejercicios Prácticos

Ejercicio 1: Filtrar Números Pares

Escribe una lambda que filtre los números pares de un vector de enteros.

Código Inicial:

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

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::vector<int> even_numbers;

    // Tu código aquí

    for (int n : even_numbers) {
        std::cout << n << " ";
    }
    return 0;
}

Solución:

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

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::vector<int> even_numbers;

    std::copy_if(vec.begin(), vec.end(), std::back_inserter(even_numbers), [](int n) {
        return n % 2 == 0;
    });

    for (int n : even_numbers) {
        std::cout << n << " "; // Salida: 2 4 6 8 10
    }
    return 0;
}

Ejercicio 2: Ordenar una Lista de Pares

Escribe una lambda que ordene una lista de pares (int, int) por el segundo elemento.

Código Inicial:

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

int main() {
    std::vector<std::pair<int, int>> vec = {{1, 4}, {2, 3}, {3, 2}, {4, 1}};

    // Tu código aquí

    for (const auto &p : vec) {
        std::cout << "(" << p.first << ", " << p.second << ") ";
    }
    return 0;
}

Solución:

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

int main() {
    std::vector<std::pair<int, int>> vec = {{1, 4}, {2, 3}, {3, 2}, {4, 1}};

    std::sort(vec.begin(), vec.end(), [](const std::pair<int, int> &a, const std::pair<int, int> &b) {
        return a.second < b.second;
    });

    for (const auto &p : vec) {
        std::cout << "(" << p.first << ", " << p.second << ") "; // Salida: (4, 1) (3, 2) (2, 3) (1, 4)
    }
    return 0;
}

Conclusión

Las expresiones lambda en C++ son una herramienta poderosa para definir funciones anónimas de manera concisa y eficiente. Son especialmente útiles en combinación con algoritmos de la STL, permitiendo escribir código más limpio y legible. A través de los ejemplos y ejercicios, hemos explorado cómo capturar variables, modificar su comportamiento y aplicarlas en contextos prácticos.

En el siguiente tema, exploraremos el multihilo en C++, una técnica avanzada para ejecutar múltiples tareas simultáneamente, mejorando el rendimiento de nuestras aplicaciones.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados