functions declaring c++ lambda c++11

declaring - lambda function c++ 11



Deducción automática del tipo de argumento y funciones lambda anónimas (4)

No. "Lambdas polimórficas" es a lo que se refirió esta característica durante las discusiones del comité de C ++, y no fue estandarizada. Los tipos de parámetros de una lambda deben ser especificados.

Puedes usar decltype aunque:

std::for_each(ints.begin(), ints.end(), [](decltype(*ints.begin())& val){ val = 7; });

Digamos que tengo estas líneas de código;

std::vector<int> ints; std::for_each(ints.begin(), ints.end(), [](int& val){ val = 7; });

Sin embargo, no quiero especificar el tipo de argumento en mis funciones lambda, es decir, quiero escribir algo como esto;

std::for_each(ints.begin(), ints.end(), [](auto& val){ val = 7; });

¿Hay alguna manera de que esto se pueda lograr?

(boost :: lambda no necesita tipos para ser especificados ...)

Actualizar:

Por ahora uso una macro: #define _A(container) decltype(*std::begin(container)) para que pueda:

std::for_each(ints.begin(), ints.end(), [](_A(ints)& val){ val = 7; });


Prueba esto:

#include <functional> #include <algorithm> #include <iostream> template <typename ValTy> std::function<void(ValTy&)> polymorphicLambda () { return std::function<void(ValTy&)> ([](ValTy& val) -> void { val = 7; } ); } int main() { std::vector<int> ints(5); std::generate_n(ints.begin(), 5, []() { return 0; }); std::for_each(ints.begin(), ints.end(), [](int& val) { std::cout << val << "/t"; }); std::cout << std::endl; std::for_each(ints.begin(), ints.end(), polymorphicLambda<int>()); std::for_each(ints.begin(), ints.end(), [](int& val) { std::cout << val << "/t"; }); std::cout << std::endl; std::vector<double> doubles(5); std::generate_n(doubles.begin(), 5, []() { return 0; }); std::for_each(doubles.begin(), doubles.end(), [](double& val) { std::cout << val << "/t"; }); std::cout << std::endl; std::for_each(doubles.begin(), doubles.end(), polymorphicLambda<double>()); std::for_each(doubles.begin(), doubles.end(), [](double& val) { std::cout.precision(2); std::cout << std::fixed << val << "/t"; }); std::cout << std::endl; return 0; }

También es posible que puedas hacer algunas cosas funky con lambdas que no vuelvan vacías y también con plantillas variadic para pasar múltiples params a la lambda.


Si tienes un contenedor puedes probar algo como esto

template<typename Container> void reset(Container c) { for_each(c.begin(),c.end(),[](typename Container::reference val) { val=7; }); }


Su sintaxis preferida es legal a partir de C ++ 14, y se conoce como lambda genérica o lambda polimórfica.

http://isocpp.org/blog/2013/04/n3649-generic-polymorphic-lambda-expressions-r3

auto lambda = [](auto x) { return x; }; lambda(5); lambda("hello"); lambda(std::vector<int>({5, 4, 3}));

Supongo que ahora la pregunta es, ¿por qué no podemos usar esta sintaxis para funciones regulares?

auto && f (auto && x) {return x; }