std::for_each

`std::for_each` 是 C++ STL 中的标准函数之一，用于对指定的容器或序列中的元素执行指定的操作。该函数的头文件为 `<algorithm>`，定义在 `namespace std` 中，因此需要包含该头文件才能使用该函数。

`std::for_each` 函数是 C++ STL 中自 C++98 就开始提供的函数，因此在 C++98/03、C++11、C++14 等版本中都可用。由于 `std::for_each` 很常用，其定义已经稳定，因此在 C++17、C++20 等新版本中依然继续保留并使用。

需要注意的是，C++14 和 C++17 都对 `std::for_each` 进行过更改，新增了一个返回值，用于返回执行完毕后的第三个参数的值。因此，在使用 `for_each` 函数时，需要确保自己所用的 C++ 版本，以保证代码的正确性。

for_each第三个参数是迭代器问题

问题

按照常理，map的迭代器应该就是std::map<T1,T2>::iterator,但是为什么下面的代码时错误的。

for_each(m_m.begin(),m_m.end(),[](std::map<int,int>::iterator iter){
        std::cout<<iter->second<<std::endl;
	});

vector也一样：

for_each(v.begin(),v.end(),[](std::vector<int>::iterator iter){
		std::cout<<*iter<<std::endl;
	});

原因

for_each的第三个参数是一个函数指针，而for_each内部实现是：

1，获取迭代器的值；

2，将这个值以值传递的方式传递给for_each的第三个参数。

//for_each()的实现如下
template <typename Iterator, typename Operation>
    Operation for_each (Iterator beg, Iterator end, Operation op)
    {
        while(beg != end)
        {
            op(*beg);
            ++beg;
        }
        return op;
    }

代码来源

for_earch,for,范围for，while循环比较

1. 数据量小时， `for` 循环通常比算法更快。但是，当处理较大的数据集时，使用算法很容易并行化，从而获得更高的执行效率。对于 std::for_each 而言，其是一个 STL 算法，可以利用 CPU 的并行处理能力，在多核 CPU 上实现并行遍历，因此能够更快地遍历大型序列。

2. `for` 循环中的条件判断和计数器更新在每次迭代时都会发生，可能会造成 CPU 浪费。算法（如 `std::for_each`）使用迭代器来遍历序列，而迭代器的实现通常采用指针或者智能指针，可以进行优化。

3. 使用算法可以使代码更短、更简明。由于算法设计为通用，因此可以在不同的容器类型上使用，而无需进行任何修改。这种代码复用的实际效果通常可以提高代码的可维护性和可重用性。

总之，选择使用算法还是使用 `for` 循环取决于具体的应用场景。对于小型且简单的算法，使用 `for` 循环常常能够获得更快的性能。但对于更大的数据集以及需要在不同的数据集上重用的算法，使用算法通常是更好的选择。

for-----c++语法；

for_each---C++算法；

算法自然要有所优化。

遍历容器执行函数

#include <iostream>
#include <vector>
#include <algorithm>
 #include <chrono>

void print_element(int x)
{
    std::cout << "Element value: " << x << std::endl;
}
 
int main()
{
    std::vector<int> vec { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    auto start=std::chrono::steady_clock::now();
    for(int i=0;i<vec.size();++i) print_element(vec[i]);
    //for(int v:vec) print_element(v);
    //int i=0;
    //while(i++<vec.size()) print_element(vec[i]);
    //std::for_each(vec.begin(), vec.end(), print_element);
    auto end=std::chrono::steady_clock::now();
    std::cout<<"spend time is "<<(end-start).count()<<std::endl;

    return 0;
}

for

范围for

while

for_each

如果数据量很小(1000以下的)，for，范围for，while更快.

但是如果数据量很大(1000以上的)，for_earch更快；

一分钟

十多分种都没有执行完。

复杂数据类型一样

#include <iostream>
#include <vector>
#include <algorithm>
 #include <chrono>

void print_element(int x)
{
    std::cout << "Element value: " << x << std::endl;
}
 
class Test{
public:
    void print(){
        std::cout<<age<<std::endl;
        std::cout<<name<<std::endl;
        std::cout<<addr<<std::endl;
        std::cout<<country<<std::endl;
    }
private:
    int age{11};
    std::string name{"liming"};
    std::string addr{"gaoshan"};
    std::string country{"China"};
};

int main()
{
    std::vector<Test> vec;
    for(int i=1000;i>0;--i){
        Test t;
        vec.push_back(t);
    }
    auto start=std::chrono::steady_clock::now();
    //for(int i=0;i<vec.size();++i) print_element(vec[i]);
    for(Test t:vec) t.print();
    //int i=0;
    //while(i++<vec.size()) print_element(vec[i]);
    // std::for_each(vec.cbegin(), vec.cend(), [](Test t){
    //     t.print();
    // });
    auto end=std::chrono::steady_clock::now();
    std::cout<<"spend time is "<<(end-start).count()<<std::endl;

    return 0;
}
/500*******/
// for      spend time is 4725742
//for_each  spend time is 4818417

/1000********/
//for       spend time is 8444936
//for_each  spend time is 7425537

for_each中lambda参数--const,&

for_each第一个和第二个是const，则lambda形参可以直接值拷贝传递，也可以const&;

但是不可以引用传参&；因为引用和const矛盾。

如果需要引用传参，第一个和第二个参数就不要const传递。

lambda分装for_each

#include <iostream>
#include <vector>
#include <memory>
#include <chrono>
#include <numeric>
#include <algorithm>

template <typename CountT, typename FuncT>
inline void gForEachAtIntSeq(CountT count, FuncT &func){
  std::vector<size_t> indices(count);
  std::iota(indices.begin(), indices.end(), 0);
  std::for_each(indices.cbegin(), indices.cend(), func);
}

int main(){
   std::vector<int> vec;
   vec.resize(1000);
   std::iota(vec.begin(),vec.end(),1);

   auto start=std::chrono::steady_clock::now();
   //for(int i=0;i<1000;++i) std::cout<<vec[i]<<std::endl;
   auto lbd=[&vec](auto idx){
    std::cout<<vec[idx]<<std::endl;
   };
   gForEachAtIntSeq(1000,lbd);
   auto end=std::chrono::steady_clock::now();
   std::cout<<(end-start).count()<<std::endl;

    return 0;
}