El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Expressions Lambda

Següent ►
►

Les expressions lambda són una característica poderosa i flexible del C++ que permeten definir funcions anònimes de manera concisa. Aquestes funcions poden ser utilitzades en llocs on es necessiten funcions curtes i temporals, com ara en funcions d'ordre superior, algoritmes de la Biblioteca de Plantilles Estàndard (STL), i més.

Contingut

  1. Què és una Expressió Lambda?
  2. Sintaxi de les Expressions Lambda
  3. Captura de Variables
  4. Exemples Pràctics
  5. Exercicis Pràctics
  6. Conclusió

Què és una Expressió Lambda?

Una expressió lambda és una funció anònima que es pot definir en línia dins del codi. Les lambdes són útils per a funcions curtes que no necessiten ser reutilitzades en altres llocs del programa.

Sintaxi de les Expressions Lambda

La sintaxi bàsica d'una expressió lambda en C++ és la següent:

[captures](parameters) -> return_type {
    // cos de la funció
};
  • captures: Defineix les variables que la lambda captura del seu entorn.
  • parameters: Els paràmetres de la funció lambda.
  • return_type: El tipus de retorn de la funció lambda (opcional si es pot deduir automàticament).
  • cos de la funció: El bloc de codi que defineix el comportament de la lambda.

Exemple Bàsic

#include <iostream>

int main() {
    auto sum = [](int a, int b) -> int {
        return a + b;
    };

    std::cout << "La suma de 3 i 4 és: " << sum(3, 4) << std::endl;
    return 0;
}

Captura de Variables

Les lambdes poden capturar variables del seu entorn de diverses maneres:

  • Per valor ([=]): Captura totes les variables per valor.
  • Per referència ([&]): Captura totes les variables per referència.
  • Captura específica: Es poden capturar variables específiques per valor o referència.

Exemple de Captura

#include <iostream>

int main() {
    int x = 10;
    int y = 20;

    auto add = [x, &y](int a) -> int {
        y = y + a;
        return x + y;
    };

    std::cout << "Resultat: " << add(5) << std::endl; // Resultat: 35
    std::cout << "Valor de y: " << y << std::endl;    // Valor de y: 25
    return 0;
}

Exemples Pràctics

Ús amb Algoritmes STL

Les lambdes són especialment útils amb els algoritmes de la STL, com std::sort.

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

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

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

    for (int n : vec) {
        std::cout << n << " ";
    }
    std::cout << std::endl; // Sortida: 1 2 3 4 5

    return 0;
}

Lambda com a Funció de Callback

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

void applyFunction(const std::vector<int>& vec, const std::function<void(int)>& func) {
    for (int n : vec) {
        func(n);
    }
}

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

    applyFunction(vec, [](int n) {
        std::cout << n * n << " ";
    });
    std::cout << std::endl; // Sortida: 1 4 9 16 25

    return 0;
}

Exercicis Pràctics

Exercici 1: Filtrar Elements

Escriu una funció que utilitzi una lambda per filtrar els elements d'un vector d'enters, retornant només els elements que són parells.

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

std::vector<int> filterEven(const std::vector<int>& vec) {
    std::vector<int> result;
    std::copy_if(vec.begin(), vec.end(), std::back_inserter(result), [](int n) {
        return n % 2 == 0;
    });
    return result;
}

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

    for (int n : evenNumbers) {
        std::cout << n << " ";
    }
    std::cout << std::endl; // Sortida: 2 4 6 8 10

    return 0;
}

Exercici 2: Transformar Elements

Escriu una funció que utilitzi una lambda per transformar els elements d'un vector d'enters, multiplicant cada element per 3.

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

std::vector<int> transformTriple(const std::vector<int>& vec) {
    std::vector<int> result(vec.size());
    std::transform(vec.begin(), vec.end(), result.begin(), [](int n) {
        return n * 3;
    });
    return result;
}

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

    for (int n : tripledNumbers) {
        std::cout << n << " ";
    }
    std::cout << std::endl; // Sortida: 3 6 9 12 15

    return 0;
}

Conclusió

Les expressions lambda són una eina poderosa en C++ que permeten definir funcions anònimes de manera concisa i flexible. Són especialment útils en combinació amb els algoritmes de la STL i per a funcions de callback. Amb la pràctica, les lambdes poden simplificar i fer més llegible el teu codi.

En el següent tema, explorarem el Multifil en C++, una altra característica avançada que permet executar múltiples fils de manera concurrent.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats