Déduction automatique du type d'argument et fonctions lambda anonymes

Question

Disons que j'ai ces lignes de code ;

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

Cependant, je ne veux pas spécifier le type d'argument dans mes fonctions lambda, c'est-à-dire que je veux écrire quelque chose comme ceci ;

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

Y a-t-il un moyen d'y parvenir ?

(boost::lambda n'a pas besoin que les types soient spécifiés...)

---

Mise à jour :

Pour l'instant, j'utilise une macro : #define _A(container) decltype(*std::begin(container)) pour que je puisse le faire :

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

Answer 1

Non. "Lambdas polymorphes" est le nom donné à cette fonctionnalité lors des discussions du comité C++, et elle n'a pas été normalisée. Les types de paramètres d'un lambda doivent être spécifiés.

Vous pouvez utiliser decltype cependant :

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

Answer 2

La syntaxe que vous préférez est légale à partir de C++14, et est appelée lambda générique ou lambda polymorphe.

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}));

À partir de C++20, nous pouvons également utiliser cette syntaxe pour les fonctions régulières :

auto f(auto x) { return x; }

Answer 3

Si vous avez un conteneur, vous pouvez essayer quelque chose comme ceci

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

Answer 4

Essayez ça :

#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;
}

Vous pourriez également être en mesure de faire des choses amusantes avec des lambdas qui ne retournent pas void et aussi avec des modèles variadiques pour passer plusieurs paramètres à la lambda.