C++ 参数类型自动推断和匿名lambda函数

假设我有这些代码行

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

这是否可以实现

（boost:：lambda不需要指定类型…）

---

更新：

现在我使用一个宏：

#define _a（container）decltype（*std:：begin（container））

，这样我就可以：

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

“多态LAMBDAS”是C++委员会讨论中提到的这一特征，但它并不规范。必须指定lambda的参数类型

您可以使用

decltype

，但：

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

---

如果你有一个容器，你可以试试这样的东西

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

模板
无效重置（容器c）
{
对于每个（c.begin（），c.end（），[]（typename容器：：reference val）{val=7；}）；
}

试试这个：

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

#包括
#包括
#包括
模板
std:：函数polymorphicLambda（）
{
返回std:：function（[]（ValTy&val）->void{val=7；}）；
}
int main（）
{
std：：向量整数（5）；
std:：generate_n（ints.begin（），5，[]（）{return 0；}）；
std:：for_each（ints.begin（）、ints.end（）、[]（int&val）{std:：cout从C++14开始，您首选的语法是合法的，被称为通用lambda或多态lambda


至少对于这一点，为什么不仅仅是
std:：fill（ints.begin（），ints.end（），7）；
？是的，在这种情况下可以使用std:：fill，但是，这不是我的问题。这就是为什么我输入它作为注释，而不是答案的原因……该死的，我已经尽可能经常地使用auto开发了一个相当好的流。typedef decltype（*beg（ints））类型；如果您认为decltype语法很难理解。不过，多态/泛型lambdas是C++14的一部分：我不明白？赢在哪里？赢在哪里？赢不必为每个参数类型重新声明lambda。这并不能解决您的问题，但我也不清楚您为什么要使用它而不是标准模板函数declarationIf您的函数不是一个模板函数，而是一个具体类型的函数（就像我的情况一样），您只需执行以下操作：
std:：for_each（ints.begin（），ints.end（），[]（ints:：reference val）{…}；
#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;
}

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

auto f(auto x) { return x; }