对std :: vector的迭代:unsigned vs signed index变量
题
在C ++中迭代向量的正确方法是什么?
考虑这两个代码片段,这个可以正常工作:
for (unsigned i=0; i < polygon.size(); i++) {
sum += polygon[i];
}
和这一个:
for (int i=0; i < polygon.size(); i++) {
sum += polygon[i];
}
生成warning: comparison between signed and unsigned integer expressions
。
我是C ++世界的新手,所以unsigned
变量对我来说有点可怕,我知道如果使用不正确,<=>变量会很危险,所以 - 这是正确的吗?
解决方案
向后迭代
请参阅此答案一>。
迭代前锋
这几乎完全相同。只需按增量更改迭代器/交换减量。你应该更喜欢迭代器。有人告诉你使用std::size_t
作为索引变量类型。但是,这不便携。始终使用容器的size_type
typedef(虽然在前向迭代的情况下只能进行转换,但在使用sizeof
时,在向后迭代的情况下,它实际上可能会出错),以防<=>比<=>的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(std::size_t i = 0; i != (sizeof a / sizeof *a); i++) {
/* std::cout << a[i]; ... */
}
使用索引
<*>在向后的迭代回答中读取<=>方法可以产生什么问题。
其他提示
四年过去了, Google 给了我这个答案。使用标准 C ++ 11 (又名 C ++ 0x) )实际上有一种新的愉快方式(以破坏向后兼容性为代价):新的auto
关键字。它可以省去显式指定要使用的迭代器类型(再次重复矢量类型)的痛苦,当显而易见(对编译器)时,使用哪种类型。 v
成为您的vector
后,您可以执行以下操作:
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 ++ 进行编译时,通常需要通过提供额外标记来将其设置为使用新标准:
g++ -std=c++0x -o auto auto.cpp
现在您可以运行示例:
$ ./auto
17
12
23
42
请注意编译和运行的说明特定于 Linux 上的 gnu c ++ 编译器,程序应该是平台(和编译器) )独立。
在您的示例中的特定情况下,我将使用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 );
关于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) {
...
对vector<T>::size()
的调用返回类型为std::vector<T>::size_type
的值,而不是int,unsigned int或其他。
通常使用 iterators 来完成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
等等)。
使用size_t
:
for (size_t i=0; i < polygon.size(); i++)
引用维基百科:
stdlib.h和stddef.h头文件定义了一个名为<=>的数据类型,用于表示对象的大小。采用大小的库函数期望它们的类型为<=>,而sizeof运算符的计算结果为<=>。
<=>的实际类型取决于平台;一个常见的错误是假设<=>与unsigned int相同,这可能导致编程错误,特别是当64位架构变得更加普遍时。
我通常使用BOOST_FOREACH:
#include <boost/foreach.hpp>
BOOST_FOREACH( vector_type::value_type& value, v ) {
// do something with 'value'
}
它适用于STL容器,数组,C风格的字符串等。
一点历史:
要表示数字是否为负数,请使用“符号”位。 int
是签名数据类型,意味着它可以保存正值和负值(大约-2亿到20亿)。 Unsigned
只能存储正数(因为它不会浪费一些元数据,它可以存储更多:0到大约40亿)。
std::vector::size()
返回unsigned
,因为矢量如何具有负长度?
警告告诉你,不等式语句的右操作数可以容纳更多的数据,然后是左边。
基本上如果你有一个包含超过20亿个条目的向量并且你使用一个整数来索引你会遇到溢出问题(int会回绕到负20亿)。
要完成,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
}
在C ++ 11中
我会使用像for_each
这样的通用算法来避免搜索正确类型的迭代器和lambda表达式,以避免额外命名的函数/对象。
短<!>;漂亮<!>您的特定情况的示例(假设多边形是整数的向量):
for_each(polygon.begin(), polygon.end(), [&sum](int i){ sum += i; });
不要忘记包含:算法,当然还有矢量:)
微软实际上也有一个很好的例子:
来源: http://msdn.microsoft.com/en -us /库/ 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;
}
for (vector<int>::iterator it = polygon.begin(); it != polygon.end(); it++)
sum += *it;
第一种类型是正确的,并且在严格意义上是正确的。 (如果你想的是,大小永远不会小于零。)尽管如此,这个警告对我来说是一个被忽视的好候选人。
考虑是否需要迭代
<algorithm>
标准标题为我们提供了以下功能:
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);
算法库中的其他功能执行常见任务 - 如果您想省力,请确保知道可用的内容。
模糊但重要的细节:如果你说<!> quot; for(auto it)<!> quot;如下所示,您获得了对象的副本,而不是实际元素:
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)
如果您的编译器支持它,您可以使用基于范围来访问向量元素:
vector<float> vertices{ 1.0, 2.0, 3.0 };
for(float vertex: vertices){
std::cout << vertex << " ";
}
打印:1 2 3。注意,您不能使用此技术来更改向量的元素。
两个代码段的工作方式相同。但是,unsigned int <!> quot;路线是正确的。使用unsigned int类型可以更好地使用您使用它的实例中的向量。在向量上调用size()成员函数会返回无符号整数值,因此您希望比较变量<!> quot; i <!> quot;到它自己类型的值。
另外,如果你仍然对<!> quot; unsigned int <!>的感觉有点不安查看代码,尝试<!> quot; uint <!> quot;。这基本上是<!> quot; unsigned int <!>的缩短版本。它的工作方式完全相同。您也不需要包含其他标题来使用它。