Saltar a contenido

Última actualización：2026-10-12

Expresiones lambda de C++20 (parte 1)

Plantillas lambda en C++20

C++14 soporta expresiones lambda genéricas, lo que permite que una lambda acepte parámetros de cualquier tipo, por ejemplo:

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

Se expande a:

struct Func {
    template <typename T1, typename T2>
    auto operator()(T1 a, T2 b) const {
        return a + b;
    }
};

Pero no es capaz de lograr las siguientes expansiones:

Primera: el mismo tipo

template <class T>
auto operator()(T t1, T t2) const;

Segunda: solo std::array

template <class T, std::size_t N>
auto operator()(std::array<T, N> const &) const;

Tercera: sin deducción

template <class T>
auto operator()() const;

Las lambdas de C++14 están muy bien, pero C++20 nos permite implementar estos casos con facilidad. C++20 permite que las expresiones lambda usen parámetros de tipo plantilla en su definición; he aquí la sintaxis básica:

[]<typename T>(){}

A continuación, varios ejemplos ilustran sus ventajas.

1.Restricción de tipos

En un ejemplo como el siguiente, en C++14 podríamos escribir este código, pero lo que se pasa al usarlo no tiene por qué ser un vector, de modo que el comportamiento se desviaría de lo esperado y produciría errores.

auto print = [](auto vec) {
  for (auto x : vec) {
    std::cout << x << std::endl;
  }
};

A partir de C++20, podemos restringir su tipo:

auto print2 = []<typename T>(std::vector<T>& vec){
    //使用 std::vector<T> 执行操作
};

Entonces surge la pregunta, y con ella una pregunta de entrevista: ¿sabes cómo garantizar la seguridad en C++14 para restringir un vector?

2.Reenvío perfecto

En C++20 puedes usar el reenvío perfecto con mucha facilidad, por ejemplo:

auto lambdaFunc = []<typename T>(T&& number) {
  processFunction(std::forward<T>(number));
};

Entonces la pregunta es: frente a C++14, ¿qué ventaja tiene? Dicho de otro modo, ¿qué hacía falta para implementar el reenvío perfecto en C++14?

Fin de esta sección

Temas relacionados

Comentarios