C++ STL - 迭代序列中的所有内容

Question

我有一个序列，例如

std::vector< Foo > someVariable;

，我想要一个循环遍历其中的所有内容。

我可以这样做：

for (int i=0;i<someVariable.size();i++) {
    blah(someVariable[i].x,someVariable[i].y);
    woop(someVariable[i].z);
}

或者我可以这样做：

for (std::vector< Foo >::iterator i=someVariable.begin(); i!=someVariable.end(); i++) {
    blah(i->x,i->y);
    woop(i->z);
}

这两者似乎都涉及相当多的重复/过多的打字。在理想的语言中，我希望能够做这样的事情：

for (i in someVariable) {
    blah(i->x,i->y);
    woop(i->z);
}

似乎迭代序列中的所有内容将是一个非常常见的操作。有没有一种方法可以做到这一点，其中代码的长度不是应有的两倍？

Answer 1

您可以使用标准库中的 for_each 。您可以向其传递函子或函数。我喜欢的解决方案是 BOOST_FOREACH，它就像其他语言中的 foreach 一样。顺便说一句，C+0x 会有一个。

例如：

#include <iostream>
#include <vector>
#include <algorithm>
#include <boost/foreach.hpp>

#define foreach BOOST_FOREACH 

void print(int v)
{
    std::cout << v << std::endl;
}

int main()
{
    std::vector<int> array;

    for(int i = 0; i < 100; ++i)
    {
        array.push_back(i);
    }

    std::for_each(array.begin(), array.end(), print); // using STL

    foreach(int v, array) // using Boost
    {
        std::cout << v << std::endl;
    }
}

Answer 2

不包括 AraK 已经建议的 BOOST_FOREACH ，现在 C++ 中有以下两个选项：

void function(Foo& arg){
  blah(arg.x, arg.y);
  woop(arg.z);
}

std::for_each(someVariable.begin(), someVariable.end(), function); 

struct functor {
  void operator()(Foo& arg){
    blah(arg.x, arg.y);
    woop(arg.z);
  }
};

std::for_each(someVariable.begin(), someVariable.end(), functor());

两者都要求您在其他地方指定循环的“主体”，要么作为函数，要么作为函子（一个重载 operator( 的类） ））。这可能是一件好事（如果您需要在多个循环中执行相同的操作，则只需定义该函数一次），但它也可能有点乏味。函数版本的效率可能会稍低一些，因为编译器通常无法内联函数调用。 （函数指针作为第三个参数传递，编译器必须做一些更详细的分析才能确定它指向哪个函数）

函子版本基本上是零开销。由于 functor 类型的对象被传递给 for_each，编译器确切地知道要调用哪个函数：functor::operator()，等等它可以简单地内联，并且与原始循环一样高效。

C++0x 将引入 lambda 表达式，从而使第三种形式成为可能。

std::for_each(someVariable.begin(), someVariable.end(), [](Foo& arg){
  blah(arg.x, arg.y);
  woop(arg.z);
});

最后，它还将引入基于范围的 for 循环：

for(Foo& arg : my_someVariable)
{
  blah(arg.x, arg.y);
  woop(arg.z);
}

因此，如果您可以访问支持 C++0x 子集的编译器，您可能可以使用最后一种形式或两种形式。否则，惯用的解决方案（不使用 Boost）是使用 for_each 就像前两个示例之一一样。

Answer 3

顺便说一下，MSVS 2008 有一个“foreach”C++ 关键字。查看如何：使用 foreach 迭代 STL 集合< /a>.

int main() {
   int retval = 0;

   vector<int> col(3);
   col[0] = 10;
   col[1] = 20;
   col[2] = 30;

   for each( const int& c in col )
      retval += c;

   cout << "retval: " << retval << endl;
}

Answer 4

更喜欢算法调用而不是手写循环

有三个原因：

1）效率：算法通常比程序员生成的循环更有效

2）正确性：

3) 可维护性：算法调用通常会产生更清晰、更多的代码
比相应的显式循环简单。

Answer 5

更喜欢几乎所有其他算法而不是 for_each()

有两个原因：

1. for_each 非常通用，它不会告诉您真正正在做什么，只是告诉您正在对序列中的所有项目执行某些操作。
2. 更专业的算法通常会更简单、更直接

考虑一下之前回复中的一个例子：

void print(int v)
{
    std::cout << v << std::endl;
}
// ...
std::for_each(array.begin(), array.end(), print); // using STL

使用 std::copy 代替，整个事情变成：

std::copy(array.begin(), array.end(), std::ostream_iterator(std::cout, "\n"));

Answer 6

"struct functor {
  void operator()(Foo& arg){
    blah(arg.x, arg.y);
    woop(arg.z);
  }
};

std::for_each(someVariable.begin(), someVariable.end(), functor());"

我认为对于一个简单的问题来说，这样的方法通常是不必要的巴洛克式的。

do i=1,N
 call blah( X(i),Y(i) )
 call woop( Z(i) )
end do

非常清楚，即使它已经有 40 岁了（显然不是 C++）。

如果容器始终是一个向量（STL 名称），那么我认为索引没有任何问题，将该索引称为整数也没有问题。

在实践中，通常需要同时迭代多个相同大小的容器，并从每个容器中剥离一个数据，并对其中的大量容器执行某些操作。特别是在这种情况下，为什么不使用索引呢？

至于上面 SSS 的第 #2 点和第 #3 点，我想说对于复杂的情况可能如此，但通常迭代 1...N 通常与其他任何事情一样简单明了。

如果您必须在白板上解释算法，使用或不使用“i”您是否可以更快地完成？我认为如果你的物质空间解释通过索引更清晰，那么可以在代码空间中使用它。

把强大的 C++ 火力留给硬目标。