STL之vector,list复习总结回顾

 vector和built-in数组类似,它拥有一段连续的内存空间,并且起始地址不变,因此它能非常好的支持随机存取,即[]操作符,即可以以数组下标的方式来访问或遍历。但由于它的内存空间是连续的,所以在中间进行插入和删除会造成内存块的拷贝,另外,当该数组后的内存空间不够时,需要重新申请一块足够大的内存并进行内存的拷贝。这些都大大影响了vector的效率。  
   
    list就是数据结构中的双向链表(根据sgi   stl源代码),因此它的内存空间可以是不连续的,通过指针来进行数据的访问,这个特点使得它的随机存取变的非常没有效率,因此它没有提供[]操作符的重载,所以不能以数组下标的方式来访问或遍历。但由于链表的特点,它可以以很好的效率支持任意地方的删除和插入  
   
    deque是一个double-ended queue,它的具体实现不太清楚,但知道它具有以下两个特点:它支持[]操作符,也就是支持随即存取,并且和vector的效率相差无几,它支持在两端的操作:push_back、push_front、pop_back、pop_front等,并且在两端操作上与list的效率也差不多。
  
   
    因此在实际使用时,如何选择这三个容器中哪一个,应根据你的需要而定,一般应遵循下面的原则:
  
    1、如果你需要高效的随即存取,而不在乎插入和删除的效率,使用
vector  
    2、如果你需要大量的插入和删除,而不关心随即存取,则应使用
list  
    3、如果你需要随即存取,而且关心两端数据的插入和删除,则应使用deque。

 

STL是 C++的ANSI/ISO 标准的一部分,可以用于所有C++语言编译器和所有平台。STL的同一版本在任意硬件配置下都是可用的;STL 提供了大量的可复用软件组织。例如,程序员再也不用自己设计排序,搜索算法了,这些都已经是STL的一部分了。使用STL编写的代码更容易修改和阅读,因为代码更短了,很多基础工作代码已经被组件化了。

STL 的组成
  STL有三大核心部分:容器(Container)、算法(Algorithms)、迭代器(Iterator),容器适配器(container adaptor),函数对象(functor),除此之外还有STL其他标准组件。

容器(container):

容器是数据在内存中组织的方法,例如,数组、堆栈、队列、链表或二叉树(不过这些都不是STL标准容器)。STL中的容器是一种存储T(Template)类型值的有限集合的数据结构,容器的内部实现一般是类。这些值可以是对象本身,如果数据类型T代表的是Class的话。

算法(algorithm):

算法是应用在容器上以各种方法处理其内容的行为或功能。例如,有对容器内容排序、复制、检索和合并的算法。在STL中,算法是由模板函数表现的。这些函数不是容器类的成员函数。相反,它们是独立的函数。令人吃惊的特点之一就是其算法如此通用。不仅可以将其用于 STL容器,而且可以用于普通的C++数组或任何其他应用程序指定的容器。
迭代器(iterator)

一旦选定一种容器类型和数据行为(算法),那么剩下唯一要他做的就是用迭代器使其相互作用。可以把迭代器看作一个指向容器中元素的普通指针。可以如递增一个指针那样递增迭代器,使其依次指向容器中每一个后继的元素。迭代器是STL的一个关键部分,因为它将算法和容器连在一起。

下面我将依次介绍STL的这三个主要组件

容器
  STL中的容器有队列容器关联容器容器适配器(congtainer adapters:stack,queue,priority queue),位集(bit_set),串包(string_package)等等。
  在本文中,我将介绍list,vector,deque等队列容器,和set和multisets,map和multimaps等关联容器,一共7种基本容器类。
队列容器(顺序容器):队列容器按照线性排列来存储T类型值的集合,队列的每个成员都有自己的特有的位置。顺序容器有向量类型双端队列类型列表类型三种。
基本容器——顺序容器
向量(vector容器类):#include <vector>,vector是一种动态数组,是基本数组的类模板。其内部定义了很多基本操作。既然这是一个类,那么它就会有自己的构造函数。vector类中定义了4种构造函数:

默认构造函数,构造一个初始长度为0的空向量
如:vector<int> v1;
带有单个整形参数的构造函数,此参数描述了向量的初始大小。这个构造函数还有一个可选的参数,这是一个类型为T的实例,描述了各个向量种各成员的初始值;
如:vector<int> v2(init_size,0); 如果预先定义了:int init_size;他的成员值都被初始化为0;

复制构造函数,构造一个新的向量,作为已存在的向量的完全复制,
如:vector<int> v3(v2);
带两个常量参数的构造函数,产生初始值为一个区间的向量。区间由一个半开区间[first,last](MS word的显示可能会有问题,first前是一个左方括号,last后面是一个右圆括号)来指定。
如:vector<int> v4(first,last)
下面一个例子用的是第四种构造方法,其它的方法读者可以自己试试。

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. //stl_cpp_7.cpp  
  2. //程序:初始化演示  
  3. #include <cstring>   
  4. #include <vector>  
  5. #include <iostream>  
  6. using namespace std;  
  7. int ar[10] = {  12, 45, 234, 64, 12, 35, 63, 23, 12, 55  };  
  8. char* str = "Hello World";  
  9. int main(void)  
  10. {  
  11.     vector <int> vec1(ar, ar+10);                //first=ar,last=ar+10,不包括ar+10  
  12.     vector <char> vec2(str, str+strlen(str));    //first=str,last= str+strlen(str),不包括最后一个  
  13.     cout<<"vec1:"<<endl;    
  14.     //打印vec1和vec2,const_iterator是迭代器,后面会讲到  
  15.     //当然,也可以用for (int i=0; i<vec1.size(); i++)cout << vec[i];输出  
  16.     //size()是vector的一个成员函数  
  17.     for(vector<int>::const_iterator p=vec1.begin();p!=vec1.end(); ++p)  
  18.         cout<<*p;  
  19.     cout<<"\n"<<"vec2:"<<endl;  
  20.     for(vector<char>::const_iterator p1=vec2.begin();p1!=vec2.end(); ++p1)  
  21.         cout<<*p1;  
  22.     getchar();  
  23.     return 0;  
  24. }   
        为了帮助理解向量的概念,这里写了一个小例子,其中用到了vector的成员数:begin(),end(),push_back(),assign(),front(),back(),erase(),empty(),at(),
size()。
[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. //stl_cpp_8.cpp  
  2. #include <iostream>  
  3. #include <vector>  
  4. using namespace std;  
  5. typedef vector<int> INTVECTOR;//自定义类型INTVECTOR  
  6. //测试vector容器的功能  
  7. void main(void)  
  8. {  
  9.     //vec1对象初始为空  
  10.     INTVECTOR vec1;    
  11.     //vec2对象最初有10个值为6的元素   
  12.     INTVECTOR vec2(10,6);   
  13.     //vec3对象最初有3个值为6的元素,拷贝构造  
  14.     INTVECTOR vec3(vec2.begin(),vec2.begin()+3);   
  15.     //声明一个名为i的双向迭代器  
  16.     INTVECTOR::iterator i;  
  17.     //从前向后显示vec1中的数据  
  18.     cout<<"vec1.begin()--vec1.end():"<<endl;  
  19.     for (i =vec1.begin(); i !=vec1.end(); ++i)  
  20.         cout << *i << " ";  
  21.     cout << endl;  
  22.     //从前向后显示vec2中的数据  
  23.     cout<<"vec2.begin()--vec2.end():"<<endl;  
  24.     for (i =vec2.begin(); i !=vec2.end(); ++i)  
  25.         cout << *i << " ";  
  26.     cout << endl;  
  27.     //从前向后显示vec3中的数据  
  28.     cout<<"vec3.begin()--vec3.end():"<<endl;  
  29.     for (i =vec3.begin(); i !=vec3.end(); ++i)  
  30.         cout << *i << " ";  
  31.     cout << endl;  
  32.     //测试添加和插入成员函数,vector不支持从前插入  
  33.     vec1.push_back(2);//从后面添加一个成员  
  34.     vec1.push_back(4);  
  35.     vec1.insert(vec1.begin()+1,5);//在vec1第一个的位置上插入成员5  
  36.     //从vec1第一的位置开始插入vec3的所有成员  
  37.     vec1.insert(vec1.begin()+1,vec3.begin(),vec3.end());  
  38.     cout<<"after push() and insert() now the vec1 is:" <<endl;  
  39.     for (i =vec1.begin(); i !=vec1.end(); ++i)  
  40.         cout << *i << " ";  
  41.     cout << endl;  
  42.     //测试赋值成员函数  
  43.     vec2.assign(8,1);   // 重新给vec2赋值,8个成员的初始值都为1  
  44.     cout<<"vec2.assign(8,1):" <<endl;  
  45.     for (i =vec2.begin(); i !=vec2.end(); ++i)  
  46.         cout << *i << " ";  
  47.     cout << endl;  
  48.     //测试引用类函数  
  49.     cout<<"vec1.front()="<<vec1.front()<<endl;//vec1第零个成员  
  50.     cout<<"vec1.back()="<<vec1.back()<<endl;//vec1的最后一个成员  
  51.     cout<<"vec1.at(4)="<<vec1.at(4)<<endl;//vec1的第五个成员  
  52.     cout<<"vec1[4]="<<vec1[4]<<endl;  
  53.     //测试移出和删除  
  54.     vec1.pop_back();//将最后一个成员移出vec1  
  55.     vec1.erase(vec1.begin()+1,vec1.end()-2);//删除成员  
  56.     cout<<"vec1.pop_back() and vec1.erase():" <<endl;  
  57.     for (i =vec1.begin(); i !=vec1.end(); ++i)  
  58.         cout << *i << " ";  
  59.     cout << endl;  
  60.     //显示序列的状态信息  
  61.     cout<<"vec1.size(): "<<vec1.size()<<endl;//打印成员个数  
  62.     cout<<"vec1.empty(): "<<vec1.empty()<<endl;//清空  
  63. }  
push_back()是将数据放入vector(向量)或deque(双端队列)的标准函数。Insert()是一个与之类似的函数,然而它在所有容器中都可以使用,但是用法更加复杂。end()实际上是取末尾加一,以便让循环正确运行--它返回的指针指向最靠近数组界限的数据。

  在Java里面也有向量的概念。Java中的向量是对象的集合。其中,各元素可以不必同类型,元素可以增加和删除,不能直接加入原始数据类型。

双端队列(qeque容器类):#include <deque>
  deque(读音:deck,意即:double queue)容器类与vector类似,支持随机访问和快速插入删除,它在容器中某一位置上的操作所花费的是线性时间。与vector不同的是,deque还支持从开始端插入数据
push_front()。此外deque也不支持与vector的capacity()、reserve()类似的操作。

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. //stl_cpp_9.cpp  
  2. #include <iostream>  
  3. #include <deque>  
  4. using namespace std;  
  5. typedef deque<int> INTDEQUE;//有些人很讨厌这种定义法,呵呵  
  6. //从前向后显示deque队列的全部元素  
  7. void put_deque(INTDEQUE deque, char *name)  
  8. {  
  9.     INTDEQUE::iterator pdeque;//仍然使用迭代器输出  
  10.     cout << "The contents of " << name << " : ";  
  11.     for(pdeque = deque.begin(); pdeque != deque.end(); pdeque++)  
  12.         cout << *pdeque << " ";//注意有 "*"号哦,没有"*"号的话会报错  
  13.     cout<<endl;  
  14. }  
  15. //测试deqtor容器的功能  
  16. void main(void)  
  17. {  
  18.     //deq1对象初始为空  
  19.     INTDEQUE deq1;     
  20.     //deq2对象最初有10个值为6的元素    
  21.     INTDEQUE deq2(10,6);    
  22.     //deq3对象最初有3个值为6的元素    
  23.     //声明一个名为i的双向迭代器变量  
  24.     INTDEQUE::iterator i;  
  25.     //从前向后显示deq1中的数据  
  26.     put_deque(deq1,"deq1");  
  27.     //从前向后显示deq2中的数据  
  28.     put_deque(deq2,"deq2");  
  29.     //从deq1序列后面添加两个元素  
  30.     deq1.push_back(2);  
  31.     deq1.push_back(4);  
  32.     cout<<"deq1.push_back(2) and deq1.push_back(4):"<<endl;  
  33.     put_deque(deq1,"deq1");  
  34.     //从deq1序列前面添加两个元素  
  35.     deq1.push_front(5);  
  36.     deq1.push_front(7);  
  37.     cout<<"deq1.push_front(5) and deq1.push_front(7):"<<endl;  
  38.     put_deque(deq1,"deq1");  
  39.     //在deq1序列中间插入数据  
  40.     deq1.insert(deq1.begin()+1,3,9);  
  41.     cout<<"deq1.insert(deq1.begin()+1,3,9):"<<endl;  
  42.     put_deque(deq1,"deq1");  
  43.     //测试引用类函数  
  44.     cout<<"deq1.at(4)="<<deq1.at(4)<<endl;  
  45.     cout<<"deq1[4]="<<deq1[4]<<endl;  
  46.     deq1.at(1)=10;  
  47.     deq1[2]=12;  
  48.     cout<<"deq1.at(1)=10 and deq1[2]=12 :"<<endl;  
  49.     put_deque(deq1,"deq1");  
  50.     //从deq1序列的前后各移去一个元素  
  51.     deq1.pop_front();  
  52.     deq1.pop_back();  
  53.     cout<<"deq1.pop_front() and deq1.pop_back():"<<endl;  
  54.     put_deque(deq1,"deq1");  
  55.     //清除deq1中的第2个元素  
  56.     deq1.erase(deq1.begin()+1);  
  57.     cout<<"deq1.erase(deq1.begin()+1):"<<endl;  
  58.     put_deque(deq1,"deq1");  
  59.     //对deq2赋值并显示  
  60.     deq2.assign(8,1);  
  61.     cout<<"deq2.assign(8,1):"<<endl;  
  62.     put_deque(deq2,"deq2");  
  63. }  
上面我们演示了deque如何进行插入删除等操作,像erase(),assign()是大多数容器都有的操作。关于deque的其他操作请参阅附录。

表(List容器类):#include <list>
   List又叫链表,是一种双线性列表,只能顺序访问(从前向后或者从后向前),图2是list的数据组织形式。与前面两种容器类有一个明显的区别就是:它不支持随机访问。要访问表中某个下标处的项需要从表头或表尾处(接近该下标的一端)开始循环。而且缺少下标预算符:operator[]。

  同时,list仍然包涵了erase(),begin(),end(),insert(),push_back(),push_front()这些基本函数,下面我们来演示一下list的其他函数功能。

merge():合并两个排序列表;
splice():拼接两个列表;
sort():列表的排序;

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. //stl_cpp_10.cpp  
  2. #include <iostream>  
  3. #include <string>  
  4. #include <list>  
  5. using namespace std;  
  6. void PrintIt(list<int> n)  
  7. {  
  8.     for(list<int>::iterator iter=n.begin(); iter!=n.end(); ++iter)  
  9.         cout<<*iter<<" ";//用迭代器进行输出循环   
  10. }  
  11. void main(void)  
  12. {  
  13.     list<int> listn1,listn2;  
  14.     //给listn1,listn2初始化   
  15.     listn1.push_back(123);  
  16.     listn1.push_back(0);  
  17.     listn1.push_back(34);  
  18.     listn1.push_back(1123);  
  19.     //now listn1:123,0,34,1123   
  20.     listn2.push_back(100);  
  21.     listn2.push_back(12);  
  22.     //now listn2:12,100  
  23.     listn1.sort();  
  24.     listn2.sort();  
  25.     //给listn1和listn2排序  
  26.     //now listn1:0,34,123,1123         listn2:12,100   
  27.     PrintIt(listn1);  
  28.     cout<<endl;  
  29.     PrintIt(listn2);  
  30.     listn1.merge(listn2);  
  31.     //合并两个排序列表后,listn1:0,12,34,100,123,1123   
  32.     cout<<endl;  
  33.     PrintIt(listn1);  
  34.     cin.get();  
  35. }  
上面并没有演示splice()函数的用法,这是一个拗口的函数。用起来有点麻烦。图3所示是splice函数的功能。将一个列表插入到另一个列表当中。list容器类定义了splice()函数的3个版本: splice(position,list_value);
splice(position,list_value,ptr);
splice(position,list_value,first,last);

  list_value是一个已存在的列表,它将被插入到源列表中,position是一个迭代参数,他当前指向的是要进行拼接的列表中的特定位置。

listn1:123,0,34,1123   listn2:12,100

  执行listn1.splice(find(listn1.begin(),listn1.end(),0),listn2);之后,listn1将变为:123,12,100,34,1123。即把listn2插入到listn1的0这个元素之前。其中,find()函数找到0这个元素在listn1中的位置。值得注意的是,在执行splice之后,list_value将不复存在了。这个例子中是listn2将不再存在。
  第二个版本当中的ptr是一个迭代器参数,执行的结果是把ptr所指向的值直接插入到position当前指向的位置之前.这将只向源列表中插入一个元素。
  第三个版本的first和last也是迭代器参数,并不等于list_value.begin(),list_value.end()。First指的是要插入的列的第一个元素,last指的是要插入的列的最后一个元素。

如果listn1:123,0,34,1123 listn2:12,43,87,100 执行完以下函数之后listn1.splice(find(listn1.begin(),listn1.end(),0),++listn2.begin(),--listn2.end());
listn1:123,43,87,0,34,1123  listn2:12,100

  除了vector,deque,list三种基本顺序容器,其他的顺序容器还有:slist,bit_vector等等。
阅读更多
个人分类: STL
上一篇HTTP常见问题汇总
下一篇测试用用例设计
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭