std::vector 的迭代：无符号与有符号索引变量

Question

在 C++ 中迭代向量的正确方法是什么？

考虑这两个代码片段，这个工作正常：

for (unsigned i=0; i < polygon.size(); i++) {
    sum += polygon[i];
}

而这个：

for (int i=0; i < polygon.size(); i++) {
    sum += polygon[i];
}

生成警告：有符号和无符号整数表达式之间的比较。

unsigned 变量对我来说看起来有点可怕，我知道 unsigned 变量如果使用不当可能会很危险，所以 - 这是正确的吗？

Answer 1

对于向后迭代，请参阅此答案。

向前迭代几乎是相同的。 只需通过增量更改迭代器/交换减量即可。 你应该更喜欢迭代器。 有些人告诉您使用 std::size_t 作为索引变量类型。 然而，那是不可移植的。 始终使用容器的 size_type typedef （虽然在前向迭代的情况下您可以只进行转换，但在使用 std 时，在后向迭代的情况下实际上可能会一直出错::size_t，如果 std::size_t 比 size_type 的 typedef 宽）：

---

使用 std::vector

使用迭代器

for(std::vector<T>::iterator it = v.begin(); it != v.end(); ++it) {
    /* std::cout << *it; ... */
}

重要的是，始终对于您不知道其定义的迭代器，请使用前缀增量形式。 这将确保您的代码尽可能通用地运行。

使用 Range C++11

for(auto const& value: a) {
     /* std::cout << value; ... */

使用索引

for(std::vector<int>::size_type i = 0; i != v.size(); i++) {
    /* std::cout << v[i]; ... */
}

---

使用数组

使用迭代器

for(element_type* it = a; it != (a + (sizeof a / sizeof *a)); it++) {
    /* std::cout << *it; ... */
}

使用 Range C++11

for(auto const& value: a) {
     /* std::cout << value; ... */

使用索引

for(std::size_t i = 0; i != (sizeof a / sizeof *a); i++) {
    /* std::cout << a[i]; ... */
}

阅读向后迭代的答案，但是 sizeof 方法可能会产生什么问题。

Answer 2

四年过去了，Google给了我这个答案。 使用标准C++11（又名C++0x ）实际上有一种新的令人愉快的方法可以做到这一点（以破坏向后兼容性为代价）：新的 auto 关键字。 当使用哪种类型（对编译器而言）显而易见时，它可以让您免去必须显式指定要使用的迭代器类型（再次重复向量类型）的痛苦。 使用 v 作为您的向量，您可以执行以下操作：

for ( auto i = v.begin(); i != v.end(); i++ ) {
    std::cout << *i << std::endl;
}

C++11 更进一步，为您提供了一种用于迭代的特殊语法像向量一样的集合。 它消除了编写始终相同的内容的必要性：

for ( auto &i : v ) {
    std::cout << i << std::endl;
}

要在工作程序中查看它，请构建一个文件 auto.cpp：

#include <vector>
#include <iostream>

int main(void) {
    std::vector<int> v = std::vector<int>();
    v.push_back(17);
    v.push_back(12);
    v.push_back(23);
    v.push_back(42);
    for ( auto &i : v ) {
        std::cout << i << std::endl;
    }
    return 0;
}

在编写本文时，当您使用 g++ 编译它时/em>，您通常需要通过提供额外的标志来将其设置为与新标准一起使用：

g++ -std=c++0x -o auto auto.cpp

现在您可以运行该示例：

$ ./auto
17
12
23
42

请注意有关编译和运行的说明特定于 Linux 上的 >gnu c++ 编译器，程序应该独立于平台（和编译器）。

Answer 3

在您的示例中的特定情况下，我将使用 STL 算法来完成此任务。

#include <numeric> 

sum = std::accumulate( polygon.begin(), polygon.end(), 0 );

对于更一般但仍然相当简单的情况，我会选择：

#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>

using namespace boost::lambda;
std::for_each( polygon.begin(), polygon.end(), sum += _1 );

Answer 4

关于 Johannes Schaub 的回答：

for(std::vector<T*>::iterator it = v.begin(); it != v.end(); ++it) { 
...
}

这可能适用于某些编译器，但不适用于 gcc。 这里的问题是 std::vector::iterator 是类型、变量（成员）还是函数（方法）的问题。 我们在 gcc 中遇到以下错误：

In member function ‘void MyClass<T>::myMethod()’:
error: expected `;' before ‘it’
error: ‘it’ was not declared in this scope
In member function ‘void MyClass<T>::sort() [with T = MyClass]’:
instantiated from ‘void MyClass<T>::run() [with T = MyClass]’
instantiated from here
dependent-name ‘std::vector<T*,std::allocator<T*> >::iterator’ is parsed as a non-type, but instantiation yields a type
note: say ‘typename std::vector<T*,std::allocator<T*> >::iterator’ if a type is meant

解决方案是使用关键字“typename”，如下所示：

typename std::vector<T*>::iterator it = v.begin();
for( ; it != v.end(); ++it) {
...

Answer 5

对 vector::size() 的调用返回 std::vector::size_type 类型的值，而不是 int、unsigned int 或其他类型。

通常，C++ 中的容器迭代是使用迭代器完成的，如下所示。

std::vector<T>::iterator i = polygon.begin();
std::vector<T>::iterator end = polygon.end();

for(; i != end; i++){
    sum += *i;
}

其中 T 是存储在向量中的数据类型。

或者使用不同的迭代算法（std::transform、std::copy、std::fill、std::for_each 等等）。

Answer 6

使用 size_t ：

for (size_t i=0; i < polygon.size(); i++)

引用 Wikipedia：

stdlib.h 和 stddef.h 头文件定义了一个名为 size_t 的数据类型，用于表示对象的大小。 接受大小的库函数期望它们的类型为 size_t，并且 sizeof 运算符的计算结果为 size_t。

size_t 的实际类型与平台相关； 一个常见的错误是假设 size_t 与 unsigned int 相同，这可能会导致编程错误，尤其是在 64 位架构变得更加流行的情况下。

Answer 7

一点历史：

为了表示一个数字是否为负数，计算机使用“符号”位。 int 是一种有符号数据类型，这意味着它可以保存正值和负值（大约 -20 亿到 20 亿）。 Unsigned 只能存储正数（并且由于它不会在元数据上浪费一点，所以可以存储更多：0 到大约 40 亿）。

std::vector::size() 返回一个无符号，因为向量怎么可能有负长度？

该警告告诉您，不等式语句的右操作数可以容纳比左操作数更多的数据。

本质上，如果您有一个包含超过 20 亿个条目的向量，并且您使用整数进行索引，则会遇到溢出问题（整数将回绕到负 20 亿）。

Answer 8

我通常使用 BOOST_FOREACH：

#include <boost/foreach.hpp>

BOOST_FOREACH( vector_type::value_type& value, v ) {
    // do something with 'value'
}

它适用于 STL 容器、数组、C 风格字符串等。

Answer 9

为了完整起见，C++11 语法仅启用迭代器的另一个版本 (ref ):

for(auto it=std::begin(polygon); it!=std::end(polygon); ++it) {
  // do something with *it
}

这也适合反向迭代

for(auto it=std::end(polygon)-1; it!=std::begin(polygon)-1; --it) {
  // do something with *it
}

Answer 10

在 C++11 中，

我会使用像 for_each 这样的通用算法来避免搜索正确类型的迭代器和 lambda 表达式，从而避免额外的命名函数/对象。

针对您的特定情况的简短“漂亮”示例（假设多边形是整数向量）：

for_each(polygon.begin(), polygon.end(), [&sum](int i){ sum += i; });

测试于：http:// /ideone.com/i6Ethd

不要忘记包括：算法，当然还有向量:)

微软实际上在这方面也有一个很好的例子：

来源：http://msdn.microsoft.com/en -us/library/dd293608.aspx

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

int main() 
{
   // Create a vector object that contains 10 elements.
   vector<int> v;
   for (int i = 1; i < 10; ++i) {
      v.push_back(i);
   }

   // Count the number of even numbers in the vector by 
   // using the for_each function and a lambda.
   int evenCount = 0;
   for_each(v.begin(), v.end(), [&evenCount] (int n) {
      cout << n;
      if (n % 2 == 0) {
         cout << " is even " << endl;
         ++evenCount;
      } else {
         cout << " is odd " << endl;
      }
   });

   // Print the count of even numbers to the console.
   cout << "There are " << evenCount 
        << " even numbers in the vector." << endl;
}

Answer 11

for (vector<int>::iterator it = polygon.begin(); it != polygon.end(); it++)
    sum += *it; 

Answer 12

第一个是类型正确的，并且在某种严格意义上是正确的。 （如果你考虑的是，大小永远不能小于零。） 不过，这个警告让我觉得是最容易被忽略的警告之一。

Answer 13

考虑是否需要迭代

标准标头为我们提供了执行此操作的工具：

using std::begin;  // allows argument-dependent lookup even
using std::end;    // if the container type is unknown here
auto sum = std::accumulate(begin(polygon), end(polygon), 0);

算法库中的其他函数执行常见任务 - 确保您知道如果要保存哪些函数可用自己努力。

Answer 14

晦涩但重要的细节：如果您如下说“for(auto it)”，您将获得对象的副本，而不是实际元素：

struct Xs{int i} x;
x.i = 0;
vector <Xs> v;
v.push_back(x);
for(auto it : v)
    it.i = 1;         // doesn't change the element v[0]

要修改向量的元素，您需要将迭代器定义为引用：

for(auto &it : v)

Answer 15

如果您的编译器支持它，您可以使用基于 for 的范围来访问向量元素：

vector<float> vertices{ 1.0, 2.0, 3.0 };

for(float vertex: vertices){
    std::cout << vertex << " ";
}

Prints: 1 2 3 。 请注意，您不能使用此技术来更改向量的元素。

Answer 16

添加此内容是因为我找不到任何答案中提到的内容：对于基于索引的迭代，我们可以使用 decltype(vec_name.size()) ，它将计算为 std::vector< T>::size_type

示例

for(decltype(v.size()) i{ 0 }; i < v.size(); i++) {
    /* std::cout << v[i]; ... */
}

Answer 17

两个代码段的工作原理相同。 但是，“unsigned int”路线是正确的。使用 unsigned int 类型将更好地与您使用它的实例中的向量配合使用。在向量上调用 size() 成员函数会返回一个无符号整数值，因此您需要比较该变量 。

另外，如果您对代码中“unsigned int”的外观仍然有点不安，请尝试“uint”，这基本上是“unsigned int”的缩写版本，它可以工作 您也不需要包含其他标头即可使用它。

Answer 18

auto polygonsize = polygon.size(), i=polygonsize;
for (i=0; i < polygonsize; i++) {
    sum += polygon[i];
}

这

• 使用 auto 来避免我们担心类型。
• 它将任何函数调用（例如 size() 函数调用）移出循环，以避免不必要的重复函数调用。
• 它使循环计数器可用。 纯粹主义者会想要在不知道 n 值的情况下使用第 n 个元素，并认为这很糟糕。
• 它似乎有一个不必要的语句i=polygonsize在声明时初始化循环变量，但是如果有一个不错的代码优化器，这应该消失，并且仅仅是为了确保i 具有正确的类型。

我并不是说任何人都应该像我刚才那样编写任何代码。

我只是将它作为另一种替代方案提供，它可以避免担心类型，将函数调用从循环中取出，并使循环计数器可用于实际的事情，例如在更复杂的场景中调试信息。