36

让我们考虑一个用 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
    });
  }

std::for_eachfor循环与以下方面的优缺点是什么：

一场表演？（我不希望有任何区别）

b) 可读性和可维护性？

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

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

作为结论，我的想法for_each与普遍观点相矛盾。我在这里想念什么？

4

5 回答 5

33

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

  1. afor_each可以接受任何适当的可调用对象，允许为不同的 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. 另一个不同之处在于跳出循环（在循环中break或return在for循环中）。据我所知，在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是，当普通迭代效率不高时，可以为某些容器类型重载它。例如，考虑一个包含数据块链表的容器，每个块包含一个连续的元素数组，类似于（省略不相关的代码）

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

    那么这种类型的适当前向迭代器将需要在每个增量处检查块的结尾，并且比较运算符需要比较块指针和每个块内的索引（省略不相关的代码）：

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

    这种类型的迭代器可以与forand一起正常工作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()函数以分别循环块指针和索引：

    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指令使用正确的版本。这相当于using std::swap;专门swap()针对某些用户定义的类型。

于 2012-08-15T08:30:22.497 回答
7

关于性能，您的for循环std::end反复调用，而std::for_each不会。这可能会也可能不会导致性能差异，具体取决于所使用的容器。

于 2012-08-14T16:20:29.087 回答
4

  • 该std::for_each版本将只访问每个元素一次。阅读代码的人一看到就知道，因为std::for_each在 lambda 中没有什么可以做的事情来弄乱迭代器。在传统的 for 循环中，您必须研究循环体中的异常控制流 ( continue, break, return) 并使用迭代器进行处理（例如，在这种情况下，使用 跳过下一个元素++it）。

  • 您可以简单地更改 lambda 解决方案中的算法。例如，您可以创建一个访问每个第 n 个元素的算法。在许多情况下，你并不真正想要一个 for 循环，而是一个不同的算法，比如copy_if. 使用算法+lambda，通常更易于更改并且更简洁。

  • 另一方面，程序员更习惯于传统的 for 循环，因此他们可能会发现 algorithm+lambda 更难阅读。

于 2012-08-14T18:05:35.707 回答
0

首先，我看不出这两者之间有多大区别，因为 for_each 是使用 for 循环实现的。但请注意 for_each 是一个有返回值的函数。

其次，在这种情况下，一旦可用，我将使用范围循环语法，因为无论如何这一天很快就会到来。

于 2012-08-14T16:17:19.043 回答
0

确实; 在使用 Lambda 表达式的情况下，您必须声明参数类型和名称，因此没有任何收获。

但是只要你想用这个调用一个（命名的）函数或函数对象，它就会很棒。（请记住，您可以通过 . 组合类似函数的东西std::bind。）

Scott Meyers 的书（我相信它是Effective STL）非常清楚地描述了这种编程风格。

于 2012-08-14T17:06:55.127 回答