让我们考虑一个用 C++11 编写的模板函数，它遍历一个容器。 请排除范围循环语法，因为我正在使用的编译器尚不支持它。

template <typename Container>
void DoSomething(const Container& i_container)
  {
  // Option #1
  for (auto it = std::begin(i_container); it != std::end(i_container); ++it)
    {
    // do something with *it
    }

  // Option #2
  std::for_each(std::begin(i_container), std::end(i_container), 
    [] (typename Container::const_reference element)
    {
    // do something with element
    });
  }

for 循环与 std::for_each 在以下方面的优缺点是什么:

a) 性能？ (我不希望有任何区别)

b) 可读性和可维护性？

在这里我看到了 for_each 的许多缺点。它不会接受 c 风格的数组，而循环会。 lambda 形式参数的声明非常冗长，无法在此处使用 auto。无法突破for_each。

在 C++11 之前的日子里，反对 for 的论点是需要指定迭代器的类型(不再保留)并且很容易错误输入循环条件(我10 年来从未犯过这样的错误)。

作为结论，我对 for_each 的看法与普遍观点相矛盾。我在这里错过了什么？

最佳答案

我认为到目前为止，答案还没有涵盖其他一些差异。

1. 一个 for_each 可以接受 any 适当的可调用对象，允许为不同的 for 循环“回收”循环体。例如(伪代码)

   for( range_1 ) { lengthy_loop_body }    // many lines of code
   for( range_2 ) { lengthy_loop_body }    // the same many lines of code again
   

   变成

   auto loop_body = some_lambda;           // many lines of code here only
   std::for_each( range_1 , loop_body );   // a single line of code
   std::for_each( range_2 , loop_body );   // another single line of code
   

   从而避免重复并简化代码维护。 (当然，在有趣的混合样式中，也可以使用类似的方法来处理 for 循环。)

2. 另一个区别在于跳出循环(在 for 循环中使用 break 或 return)。据我所知，在 for_each 循环中，这只能通过抛出异常来完成。例如

   for( range )
   {
     some code;
     if(condition_1) return x; // or break
     more code;
     if(condition_2) continue;
     yet more code;
   }
   

   变成

   try {
     std::for_each( range , [] (const_reference x)
                   {
                     some code;
                     if(condition_1) throw x;
                     more code;
                     if(condition_2) return;
                     yet more code;
                   } );
   } catch(const_reference r) { return r; }
   

   对于具有循环体和函数体(循环周围)范围的对象调用析构函数具有相同的效果。

3. for_each 的主要好处是，恕我直言，当普通迭代效率不高时，可以为某些容器类型重载它。例如，考虑一个包含数据 block 链表的容器，每个 block 包含一个连续的元素数组，类似于(省略不相关的代码)

   namespace my {
     template<typename data_type, unsigned block_size>
     struct Container
     {
       struct block
       {
         const block*NEXT;
         data_type DATA[block_size];
         block() : NEXT(0) {}
       } *HEAD;
     };
   }
   

   那么对于这种类型的适当前向迭代器将需要在每次递增时检查 block 的结尾，并且比较运算符需要比较 block 指针和每个 block 内的索引(省略不相关的代码):

   namespace my {
     template<typename data_type, unsigned block_size>
     struct Container
     {
       struct iterator
       {
         const block*B;
         unsigned I;
         iterator() = default;
         iterator&operator=(iterator const&) = default;
         iterator(const block*b, unsigned i) : B(b), I(i) {}
         iterator& operator++()
         {
           if(++I==block_size) { B=B->NEXT; I=0; }    // one comparison and branch
           return*this;
         }
         bool operator==(const iterator&i) const
         { return B==i.B && I==i.I; }                 // one or two comparisons
         bool operator!=(const iterator&i) const
         { return B!=i.B || I!=i.I; }                 // one or two comparisons
         const data_type& operator*() const
         { return B->DATA[I]; }
       };
       iterator begin() const
       { return iterator(HEAD,0); }
       iterator end() const
       { return iterator(0,0); }
     };
   }
   

   这种类型的迭代器可以与 for 和 for_each 一起正常工作，例如

   my::Container<int,5> C;
   for(auto i=C.begin();
       i!=C.end();              // one or two comparisons here
       ++i)                     // one comparison here and a branch
     f(*i);
   

   但每次迭代需要两到三个比较以及一个分支。更有效的方法是重载 for_each() 函数，分别循环 block 指针和索引:

   namespace my {
     template<typename data_type, int block_size, typename FuncOfDataType>
     FuncOfDataType&&
     for_each(typename my::Container<data_type,block_size>::iterator i,
              typename my::Container<data_type,block_size>::iterator const&e,
              FuncOfDataType f)
     {
       for(; i.B != e.B; i.B++,i.I=0)
         for(; i.I != block_size; i.I++)
           f(*i);
       for(; i.I != e.I; i.I++)
         f(*i);
       return std::move(f);
     }
   }
   using my::for_each;     // ensures that the appropriate
   using std::for_each;    // version of for_each() is used
   

   对于大多数迭代只需要一次比较并且没有分支(请注意，分支可能会对性能产生严重影响)。请注意，我们不需要在命名空间 std 中定义它(这可能是非法的)，但可以确保适当的 using 指令使用正确的版本。这等价于 使用 std::swap; 将 swap() 专门用于某些用户定义的类型。

关于c++ - for 循环与带有 lambda 的 std::for_each，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/11956374/