Funções Lambda em C++

As funções lambda, também conhecidas como lambdas, são uma característica poderosa introduzida no C++11 para permitir a definição de funções anônimas no próprio local onde são necessárias. Essas funções são úteis em situações em que é necessário passar uma função como argumento para outra função, como em algoritmos de ordenação, filtragem de dados ou funções de callback.

Uma função lambda pode ser definida utilizando a sintaxe especial [], seguida de parâmetros opcionais entre parênteses, e depois do operador (), que indica o início do corpo da função. Por exemplo:

cppCopy code
[] (int a, int b) { return a + b; }

Neste exemplo, a função lambda recebe dois parâmetros a e b e retorna a soma deles. A parte [] é conhecida como “captura”, e é usada para capturar variáveis do escopo circundante. Se nenhum valor for capturado, os colchetes podem ser deixados vazios.

As funções lambdas podem ser atribuídas a variáveis ou passadas diretamente como argumentos para outras funções. Por exemplo:

cppCopy code
auto soma = [] (int a, int b) { return a + b; };
int resultado = soma(3, 4); // resultado será 7

Além disso, as funções lambda podem ser usadas em conjunto com algoritmos da STL (Standard Template Library) do C++, como std::sort, std::find_if, entre outros. Por exemplo:

cppCopy code
#include 
#include 
#include 

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

    // Ordena os números usando uma função lambda
    std::sort(numeros.begin(), numeros.end(), [] (int a, int b) {
        return a < b;
    });

    // Imprime os números ordenados
    for (int num : numeros) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

Neste exemplo, uma função lambda é usada como terceiro argumento da função std::sort, especificando o critério de ordenação. A função lambda compara dois números e retorna verdadeiro se o primeiro for menor que o segundo.

Além disso, as funções lambda podem capturar variáveis do escopo externo por valor ou por referência, permitindo que a função lambda acesse e modifique essas variáveis. Por exemplo:

cppCopy code
#include 

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

    // Captura x por valor e y por referência
    auto lambda = [x, &y] () {
        std::cout << "x: " << x << std::endl; // Acessa x por valor
        std::cout << "y: " << y << std::endl; // Acessa y por referência
        y++; // Modifica y
    };

    lambda(); // Chama a função lambda

    std::cout << "Novo valor de y: " << y << std::endl;

    return 0;
}

Neste exemplo, a variável x é capturada por valor, o que significa que a função lambda terá uma cópia do valor atual de x no momento em que a função lambda é criada. A variável y é capturada por referência, permitindo que a função lambda acesse e modifique o valor original de y.

As funções lambda são uma ferramenta poderosa e flexível em C++, permitindo escrever código mais conciso e expressivo, especialmente em situações que exigem o uso de funções anônimas. No entanto, é importante usá-las com moderação e garantir que seu uso não torne o código menos legível ou mais complicado do que necessário.

Claro, vou fornecer mais informações detalhadas sobre as funções lambda em C++.

Captura de Variáveis

Ao criar uma função lambda, você pode capturar variáveis do escopo externo para uso dentro da função lambda. Existem três maneiras de capturar variáveis:

1. Captura por valor: Isso cria uma cópia da variável capturada dentro da função lambda.

   cppCopy code
   int x = 10;
   auto lambda = [x] () { std::cout << "x: " << x << std::endl; };
   

2. Captura por referência: Isso permite que a função lambda acesse e modifique a variável original.

   cppCopy code
   int y = 20;
   auto lambda = [&y] () { y++; };
   

3. Captura por valor, por referência e mista: Você pode capturar algumas variáveis por valor e outras por referência na mesma função lambda.

   cppCopy code
   int x = 10, y = 20;
   auto lambda = [x, &y] () { std::cout << "x: " << x << ", y: " << y << std::endl; };
   

Especificação do Tipo de Retorno

Em funções lambda que contêm apenas uma instrução de retorno, o tipo de retorno pode ser deduzido automaticamente pelo compilador. No entanto, se a função lambda contiver múltiplas instruções ou se você desejar especificar explicitamente o tipo de retorno, você pode fazê-lo utilizando a notação -> tipo no final da lista de parâmetros.

cppCopy code
auto lambda = [] (int a, int b) -> int { return a + b; };

Uso com Algoritmos da STL

As funções lambda são frequentemente utilizadas em conjunto com algoritmos da STL para processar contêineres de dados. Por exemplo, o algoritmo std::for_each pode ser usado com uma função lambda para realizar uma operação em cada elemento de um contêiner:

cppCopy code
#include 
#include 
#include 

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5};
    std::for_each(nums.begin(), nums.end(), [] (int num) { std::cout << num << " "; });
    std::cout << std::endl;
    return 0;
}

Outros algoritmos, como std::sort, std::transform, std::find_if, entre outros, também podem ser utilizados com funções lambda para personalizar o comportamento deles.

Captura por Mover

Além das capturas por valor e por referência, é possível capturar variáveis por mover, utilizando o operador de movimento std::move. Isso é útil quando você deseja transferir a propriedade de um objeto para a função lambda.

cppCopy code
#include 
#include 
#include 

int main() {
    std::vector<int> original = {1, 2, 3};
    auto lambda = [vec = std::move(original)] () mutable {
        vec.push_back(4);
        std::cout << "Tamanho de vec dentro da lambda: " << vec.size() << std::endl;
    };
    lambda();
    std::cout << "Tamanho de original após a lambda: " << original.size() << std::endl;
    return 0;
}

Neste exemplo, original é movido para dentro da função lambda e modificado lá dentro. Após a execução da função lambda, o vetor original permanece vazio.

Funções Lambda e Templates

As funções lambda também podem ser usadas com modelos (templates) em C++. Isso permite que você escreva funções genéricas que podem aceitar funções lambda como argumentos.

cppCopy code
#include 

template <typename Func>
void executar_funcao(Func func) {
    func();
}

int main() {
    auto lambda = [] () { std::cout << "Função lambda executada!" << std::endl; };
    executar_funcao(lambda);
    return 0;
}

Neste exemplo, a função executar_funcao é um modelo que aceita qualquer tipo de função como argumento. Quando chamamos executar_funcao com uma função lambda, ela é executada dentro da função executar_funcao.

As funções lambda são uma adição poderosa ao C++, proporcionando uma maneira concisa e flexível de escrever código mais expressivo. Elas são amplamente utilizadas em toda a comunidade de desenvolvedores C++ para tornar o código mais legível, eficiente e fácil de manter.