笑看风云淡

宠辱不惊,看庭前花开花落;去留无意,望天空云卷云舒
posts - 96, comments - 48, trackbacks - 0, articles - 0
  C++博客 :: 首页 :: 新随笔 ::  :: 聚合  :: 管理

vector容器与iterator迭代器

Posted on 2009-09-01 11:23 天之骄子 阅读(69860) 评论(5)  编辑 收藏 引用

        
                        vector容器
vector
是同一种类型的对象的集合,每个对象都有一个对应的整数索引值。和string对象一样,标准库负责管理存储元素的相关内存。我们把vector称为容器,是因为它可以包含其他对象。一个容器中的所有对象都必须是同一种类型的。

使用vector之前,必须包含相应的头文件。
#include <vector>

using std::vector;

vector是一个类模板class template)。模板允许程序员编写单个类或函数定义,这个类和函数定义可用于不同的数据类型上。因此,我们可以定义保存string对象的vector,或保存int值的vector,又或是保存自定义的类类型对象(如Sales_item对象)的vector
声明从类模板产生的某种类型的对象,需要提供附加信息,信息的种类取决于模板。以vector为例,必须说明vector保存何种对象的类型,通过将类型放在类模板名称后面的尖括号中来指定类型:

vector<int> ivec;                 // ivec holds objects of type int

vector<Sales_item> Sales_vec;  // holds Sales_items

和其他变量定义一样,定义vector对象要指定类型和一个变量的列表。上面的第一个定义,类型是vector<int>,该类型即是含有若干int类型对象的vector,变量名为ivec。第二个定义的变量名是Sales_vec,它所保存的元素是Sales_item类型的对象。

vector不是一种数据类型,而只是一个类模板,可用来定义任意多种数据类型。vector类型的每一种都指定了其保存元素的类型。因此,vector<int>vector <string>都是数据类型。

vector对象的定义和初始化

vector类定义了好几种构造函数,用来定义和初始化vector对象。下表3-4列出了这些构造函数:

vector<Tv1;

vector保存类型为T的对象。默认构造函数v1为空。

vector<T> v2(v1);

v2v1的一个副本。

vector<T> v3(n, i);

v3包含n个值为i的元素。

vector<T> v4(n);

v4含有值初始化的元素的n个副本。

 创建确定个数的元素

若要创建非空的vector对象,必须给出初始化元素的值。当把一个vector对象复制到另一个vector对象时,新复制的vector中每一个元素都初始化为原vector中相应元素的副本。但这两个vector对象必须保存同一种元素类型:

vector<int> ivec1;                // ivec1 holds objects of type int

vector<int> ivec2(ivec1);       // ok: copy elements of ivec1 into ivec2

vector<string> svec(ivec1);    // error: svec holds strings, not ints

可以用元素个数和元素值对vector对象进行初始化。构造函数用元素个数来决定vector对象保存元素的个数,元素值指定每个元素的初始值:

vector<int> ivec4(10, -1);     // 10 elements, each initialized to -1

vector<string> svec(10, "hi!"); // 10 strings, each initialized to "hi!"

关键概念:vector对象动态增长                                                       

vector对象(以及其他标准库容器对象)的重要属性就在于可以在运行时高效地添加元素。因为vector增长的效率高,在元素值已知的情况下,最好是动态地添加元素。这种增长方式不同于C语言中的内置数据类型,也不同于大多数其他编程语言的数据类型。特别地,如果读者习惯了CJava的风格,由于vector元素连续存储,可能希望最好是预先分配合适的空间。但事实上,为了达到连续性,C++的做法恰好相反

虽然可以对给定元素个数的vector对象预先分配内存,但更有效的方法是先初始化一个空vector对象,然后再动态地增加元素。

 

值初始化

如果没有给出元素的初始化式,那么标准库将提供一个值初始化的value initialized)元素初始化式。这个由库生成的初始值用于初始化容器中的每个元素。而元素初始化式的值取决于存储在vector中元素的数据类型。

如果vector保存内置类型(如int类型)的元素,那么标准库将用0值创建元素初始化值:

vector<string> fvec(10); // 10 elements, each initialized to 0

如果向量保存类类型(如string)的元素,标准库将用该类型的默认构造函数创建元素初始值:

vector<string> svec(10); // 10 elements, each an empty string

对于有自定义构造函数但没有默认构造函数的类,在初始化这种类型的Vector对象时,程序员就不能仅提供元素个数,还需要提供元素初始值。

元素类型可能是没有定义任何构造函数的类类型。这种情况下,标准库仍产生一个带初始值的对象,这个对象的每个成员进行了值初始化。

vector的操作

vector标准库提供许多类似于string对象的操作,下表列出了几种最重要的vector操作。

v.empty()

如果v为空,则返回true,否则返回false

v.size()

返回v中元素的个数。

v.push_back(t)

v的末尾增加一个值为t的元素。

v[n]

返回v中位置为n的元素。

v1 = v2

v1的元素替换为v2中元素的副本。

v1 == v2

如果v1v2相等,则返回true

!=, <, <=, >, >=

保持这些操作符惯有的含义。

 vector对象的size

emptysize操作类似于string类型的相关操作。成员函数size返回相应vector类定义的size_type的值。

使用size_type类型时,必须指出该类型是在哪里定义的。vector类型总是包括vector的元素类型:

vector<int>::size_type        // ok

vector::size_type          // error

 vector添加元素

push_back()操作接受一个元素值,并将它作为一个新的元素添加到vector对象的后面,也就是“插入push)”vector对象的后面(back)

// read words from the standard input and store them as elements in a vector

string word;

vector<string> text;        // empty vector

while (cin >> word) {

    text.push_back(word);  // append word to text

}

该循环从标准输入读取一系列string对象,逐一追加到vector对象的后面。首先定义一个空的vector对象text。每循环一次就添加一个新元素到vector对象,并将从输入读取的word值赋予该元素。当循环结束时,text就包含了所有读入的元素。

vector的下标操作

vector中的对象是没有命名的,可以按vector中对象的位置来访问它们。通常使用下标操作符来获取元素。vector的下标操作类似于string类型的下标操作

vector的下标操作符接受一个值,并返回vector中该对应位置的元素。vector元素的位置从0开始。下例使用for循环把vector中的每个元素值都重置为0:

// reset the elements in the vector to zero

for (vector<int>::size_type ix = 0; ix != ivec.size(); ++ix)

    ivec[ix] = 0;

string类型的下标操作符一样,vector下标操作的结果为左值,因此可以像循环体中所做的那样实现写入。另外,和string对象的下标操作类似,这里用size_type类型作为vector下标的类型。

在上例中,即使ivec为空,for循环也会正确执行。ivec为空则调用size返回0,并且for中的测试比较ix0。第一次循环时,由于ix本身就是0,则条件测试失败,for循环体一次也不执行。

关键概念:安全的泛型编程                                                       

习惯于CJava编程的C++程序员可能会觉得难以理解,for循环的判断条件用!=而不是用<来测试vector下标值是否越界。C程序员难以理解的还有,上例中没有在for循环之前就调用size成员函数并保存其返回的值,而是在for语句头中调用size成员函数。C++程序员习惯于优先选用!=而不是<来编写循环判断条件。
调用size成员函数而不保存它返回的值,在这个例子中同样不是必需的,但这反映了一个良好的编程习惯。在C++中,有些数据结构(如vector)可以动态增长。上例中循环仅需要读取元素,而不需要增加新的元素。但是,循环可以容易地增加新元素,如果确实增加了新元素的话,那么测试已保存的size值作为循环的结束条件就会有问题,因为没有将新加入的元素计算在内。所以我们倾向于在每次循环中测试size的当前值,而不是在进入循环时,存储size值的副本。

我们知道C++中有些函数可以声明为内联(inline)函数。编译器遇到内联函数时就会直接扩展相应代码,而不是进行实际的函数调用。像size这样的小库函数几乎都定义为内联函数,所以每次循环过程中调用它的运行时代价是比较小的。

 

下标操作不添加元素

初学C++的程序员可能会认为vector的下标操作可以添加元素,其实不然:

vector<int> ivec;   // empty vector

for (vector<int>::size_type ix = 0; ix != 10; ++ix)

     ivec[ix] = ix; // disaster: ivec has no elements

上述程序试图在ivec中插入10个新元素,元素值依次为09的整数。但是,这里ivec是空的vector对象,而且下标只能用于获取已存在的元素。

这个循环的正确写法应该是:

for (vector<int>::size_type ix = 0; ix != 10; ++ix)

     ivec.push_back(ix);  // ok: adds new element with value ix

必须是已存在的元素才能用下标操作符进行索引。通过下标操作进行赋值时,不会添加任何元素。

警告:仅能对确知已存在的元素进行下标操作                                           

对于下标操作符([]操作符)的使用有一点非常重要,就是仅能提取确实已存在的元素,例如:

vector<int> ivec;      // empty vector

cout << ivec[0];        // Error: ivec has no elements!

 

vector<int> ivec2(10); // vector with 10 elements

cout << ivec[10];      // Error: ivec has elements 0...9

试图获取不存在的元素必然产生运行时错误。和大多数同类错误一样,不能确保执行过程可以捕捉到这类错误,运行程序的结果是不确定的。由于取不存在的元素的结果是未定义的,因而不同的实现会导致不同的结果,但程序运行时几乎肯定会以某种有趣的方式失败。

本警告适用于任何使用下标操作的时候,如string类型的下标操作,以及将要简要介绍的内置数组的下标操作。

不幸的是,试图对不存在的元素进行下标操作是程序设计过程中经常会犯的严重错误。所谓的“缓冲区溢出”错误就是对不存在的元素进行下标操作的结果。这样的缺陷往往导致PC机和其他应用中最常见的安全问题。

                        vector迭代器

除了使用下标来访问vector对象的元素外,标准库还提供了另一种检测元素的方法:使用迭代器iterator)。迭代器是一种允许程序员检查容器内元素,并实现元素遍历的数据类型。

标准库为每一种标准容器(包括vector)定义了一种迭代器类型。迭代器类型提供了比下标操作更一般化的方法:所有的标准库容器都定义了相应的迭代器类型,而只有少数的容器支持下标操作。因为迭代器对所有的容器都适用,现代C++程序更倾向于使用迭代器而不是下标操作访问容器元素,即使对支持下标操作的vector类型也这样。

容器的iterator
类型

每种容器类型都定义了自己的迭代器类型,如vector

vector<int>::iterator iter;

这条语句定义了一个名为iter的变量,它的数据类型是由vector<int>定义的iterator类型。每个标准库容器类型都定义了一个名为iterator的成员,这里的iterator与迭代器实际类型的含义相同。

不同的容器类定义了自己的iterator类型,用于访问容器内的元素。换句话说,每个容器定义了一种名为iterator的类型,而这种类型支持(概念上的)迭代器的各种行为。

 

begin和end操作

每种容器都定义了一对命名为beginend的函数,用于返回迭代器。如果容器中有元素的话,由begin返回的迭代器指向第一个元素:

vector<int>::iterator iter = ivec.begin();

上述语句把iter初始化为由名为beginvector操作返回的值。假设vector不空,初始化后,iter指该元素为ivec[0]

end操作返回的迭代器指向vector的“末端元素的下一个”。通常称为超出末端迭代器(off-the-end iterator),表明它指向了一个不存在的元素。如果vector为空,begin返回的迭代器与end返回的迭代器相同。

end操作返回的迭代器并不指向vector中任何实际的元素相反它只是起一个哨兵sentinel的作用表示我们已处理完vector中所有元素。

vector迭代器的自增和解引用运算

迭代器类型定义了一些操作来获取迭代器所指向的元素,并允许程序员将迭代器从一个元素移动到另一个元素。

迭代器类型可使用解引用操作符*操作符)来访问迭代器所指向r 元素:

*iter = 0;

解引用操作符返回迭代器当前所指向的元素。假设iter指向vector对象ivec的第一个元素,那么*iterivec[0]就是指向同一个元素。上面这个语句的效果就是把这个元素的值赋为0

迭代器使用自增操作符向前移动迭代器指向容器中下一个元素。从逻辑上说,迭代器的自增操作和int型对象的自增操作类似。对int对象来说,操作结果就是把int型值“加1”,而对迭代器对象则是把容器中的迭代器“向前移动一个位置”。因此,如果iter指向第一个元素,则++iter指向第二个元素。

由于end操作返回的迭代器不指向任何元素,因此不能对它进行解引用或自增操作。

 迭代器的其他运算

另一对可执行于迭代器的操作就是比较:用==!=操作符来比较两个迭代器,如果两个迭代器对象指向同一个元素,则它们相等,否则就不相等。

迭代器应用的程序示例

假设已声明了一个vector<int>型的ivec变量,要把它所有元素值重置为0,可以用下标操作来完成:

// reset all the elements in ivec to 0

for (vector<int>::size_type ix = 0; ix != ivec.size(); ++ix)

       ivec[ix] = 0;

上述程序用for循环遍历ivec的元素,for循环定义了一个索引ix,每循环迭代一次ix就自增1for循环体将ivec的每个元素赋值为0

更典型的做法是用迭代器来编写循环:

// equivalent loop using iterators to reset all the elements in ivec to 0

for (vector<int>::iterator iter = ivec.begin();

                         iter != ivec.end(); ++iter)

    *iter = 0;  // set element to which iter refers to 0

for循环首先定义了iter,并将它初始化为指向ivec的第一个元素。for循环的条件测试iter是否与end操作返回的迭代器不等。每次迭代iter都自增1,这个for循环的效果是从ivec第一个元素开始,顺序处理vector中的每一元素。最后,iter将指向ivec中的最后一个元素,处理完最后一个元素后,iter再增加1,就会与end操作的返回值相等,在这种情况下,循环终止。

for循环体内的语句用解引用操作符来访问当前元素的值。和下标操作符一样,解引用操作符的返回值是一个左值,因此可以对它进行赋值来改变它的值。上述循环的效果就是把ivec中所有元素都赋值为0

通过上述对代码的详细分析,可以看出这段程序与用下标操作符的版本达到相同的操作效果:从vector的第一个元素开始,把vector中每个元素都置为0
如果vector为空,程序是安全的。如果ivec为空,则begin返回的迭代器不指向任何元素,由于没有元素,所以它不能指向任何元素——在这种情况下,从begin操作返回的迭代器与从end操作返回的迭代器的值相同,因此for语句中的测试条件立即失败。

const_iterator

前面的程序用vector::iterator改变vector中的元素值。每种容器类型还定义了一种名为const_iterator的类型,该类型只能访问容器内元素,但不能改变其值。

当我们对普通iterator类型解引用时,得到对某个元素的非const引用。而如果我们对const_iterator类型解引用时,则可以得到一个指向const对象的引用,如同任何常量一样,该对象不能进行重写。

例如如果textvector<string>类型程序员想要遍历它输出每个元素,可以这样编写程序

// use const_iterator because we won't change the elements

for (vector<string>::const_iterator iter = text.begin();

                                    iter != text.end(); ++iter)

    cout << *iter << endl; // print each element in text

除了是从迭代器读取元素值而不是对它进行赋值之外,这个循环与前一个相似。由于这里只需要借助迭代器进行读,不需要写,这里把iter定义为const_iterator类型。当const_iterator类型解引用时,返回的是一个const值。不允许用const_iterator进行赋值:

for (vector<string>::const_iterator iter = text.begin();

                                   iter != text.end(); ++ iter)

    *iter = " ";     // error: *iter is const

使用const_iterator类型时我们可以得到一个迭代器它自身的值可以改变但不能用来改变其所指向的元素的值。可以对迭代器进行自增以及使用解引用操作符来读取值,但不能对该元素值赋值。

不要把const_iterator对象constiterator对象混淆起来声明一个const迭代器时,必须初始化迭代器。一旦被初始化后,就不能改变它的值:

vector<int> nums(10);  // nums is nonconst

const vector<int>::iterator cit = nums.begin();

*cit = 1;                 // ok: cit can change its underlying element

++cit;                    // error: can't change the value of cit

const vector<int> nines(10, 9);  // cannot change elements in nines

// error: cit2 could change the element it refers to and nines is const

const vector<int>::iterator cit2 = nines.begin();

// ok: it can't change an element value, so it can be used with a const vector<int>

vector<int>::const_iterator it = nines.begin();

*it = 10; // error: *it is const

++it;     // ok: it isn't const so we can change its value

// an iterator that cannot write elements

vector<int>::const_iterator

// an iterator whose value cannot change

const vector<int>::iterator

迭代器的算术操作

除了一次移动迭代器的一个元素的增量操作符外vector的迭代器(很少有其他标准库器迭代器也支持其他的算术操作。这些操作称为迭代器算术操作iterator arithmetic),包括:

l iter + n

  iter - n

可以对迭代器对象加上或减去一个整型值。这样做将产生一个新的迭代器,其位置在iter所指元素之前(加)或之后(减)n个元素的位置。加或减之后的结果必须指向iter所指vector中的某个元素,或者是vector末端的后一个元素。加上或减去的值的类型应该是vector的size_typedifference_type类型(参考下面的解释)。

l iter1 - iter2                                                      

该表达式用来计算两个迭代器对象的距离该距离是名为difference_typesigned整数类型的值这里的difference_type类型类似于size_type类型,也是由vector定义的。difference_type是signed类型,因为减法运算可能产生负数的结果。该类型可以保证足够大以存储任何两个迭代器对象间的距离。iter1iter2两者必须都指向同一vector中的元素,或者指向vector末端之后的下一个元素

可以用迭代器算术操作来移动迭代器直接指向某个元素,例如,下面语句直接定位于vector的中间元素:

vector<int>::iterator mid = vi.begin() + vi.size()/2;

上述代码用来初始化mid,使其指向vi中最靠近正中间的元素。这种直接计算迭代器的方法,与用迭代器逐个元素自增操作到达中间元素的方法是等价的,但前者的效率要高得多。

任何改变vector长度的操作都会使已存在的迭代器失效。例如,在调用push_back后,就不能再信赖指向vector的迭代器的值了。


Feedback

# re: vector容器与iterator迭代器  回复  更多评论   

2011-01-21 18:19 by dragoo1
学习了,
关于最后一句“在调用push_back之后,就不能再信赖指向vector的迭代器的值了
”,但是使用下标不会失效啊。
这是不是说下标比迭代器有优势啊,

# re: vector容器与iterator迭代器  回复  更多评论   

2011-01-25 10:24 by 天之骄子
@dragoo1
应该是这样

# re: vector容器与iterator迭代器  回复  更多评论   

2011-04-02 09:48 by kenny
@天之骄子
任何改变vector长度的操作都会使已存在的迭代器失效。, 这句话有问题,因为在erase之后,在删除元素之前的迭代器不会变为无效

只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理