STL基本范例

C++标准库与STL的关系

1.STL入门

STL的代码从广义上讲分为三类：algorithm（算法）、container（容器）和iterator（迭代器），几乎所有的代码都采用了模板类和模版函数的方式，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。

在C++标准中，STL被组织为下面的13个头文件：<algorithm>、<deque>、<functional>、<iterator>、<vector>、<list>、<map>、

<memory>、<numeric>、<queue>、<set>、<stack>和<utility>。

例1

[cpp] view plaincopyprint?

1. #include<vector>   //包含头文件   
2. #include<iostream>  
3. using namespace std;  
4. int main()  
5. {  
6.     vector<double> a;  //定义数据变量   
7.     vector<double>::const_iterator i; //定义变量   
8.     a.push_back(1);                     //调用STL中函数   
9.     a.push_back(2);  
10.     a.push_back(3);  
11.     a.push_back(4);  
12.     a.push_back(5);  
13.     for(i=a.begin();i!=a.end();i++)//循环输出   
14.     {  
15.         cout<<(*i)<<endl;  
16.     }  
17.     system("pause");  
18. }  

结果：

上述代码中，使用了push_back()、begin()和end()函数，而这些函数在程序中并没有被定义过，却可以使用，这是因为这些函数已经被头文件vector.h所包含，如果strcpy()被string.h包含一样。

例2.

[cpp] view plaincopyprint?

1. #include<vector>  
2. #include<cstdlib>  
3. #include<algorithm>  
4. #include<iostream>  
5. using namespace std;  
6.   
7. template<class T>  
8. struct Print  
9. {  
10.        void operator()(T& x) const//const说明此成员函数不修改类的数据成员  
11.        {  
12.             if(0==x%2)  
13.             {  
14.                cout<<x<<' ';  
15.                       }  
16.             }   
17.        };  
18.          
19. int main(int argc, char *argv[])  
20. {  
21.     vector<int> vcInts;  
22.     for(int i=0;i<10;i++)  
23.     {  
24.        vcInts.push_back(i);  
25.      }  
26.     vector<int>::iterator iterBegin,iterEnd;//定义两个迭代器，分别用来撒向容器的开始和结尾  
27.     iterBegin = vcInts.begin();  
28.     iterEnd = vcInts.end();  
29.     cout<<"输出所有元素： "<<endl;  
30.     for(;iterBegin!=iterEnd;++iterBegin)//遍历   
31.     {cout<<*iterBegin<<" ";}//输出   
32.     cout<<endl;  
33.     cout<<"输出偶数元素： "<<endl;  
34.     iterBegin=vcInts.begin();//重定向开始位置   
35.     for_each(iterBegin,iterEnd,Print<int>());//通过算法for_each和函数对象Print输出容器中的元素   
36.     cout<<endl;  
37.     system("pause");   
38.     return 0;  
39.     }  

结果
上述代码重载了括号运算符"()"，所以可以当做一个函数对象使用。两个迭代器iterBegin和iterEnd分别指向容器的开始和结尾。可以利用这两个迭代器遍历整个容器。最后调用了for_each算法，并结合使用函数对象Print。for_each的行为类似for循环。

2.算法

STL中的算法部分主要由头文件<algorithm>、<numeric>和<functional>组成。例：

[cpp] view plaincopyprint?

1. #include<iostream>  
2. #include<algorithm>  
3. #include<functional>  
4. #include<vector>  
5. using namespace std;  
6.   
7. class myclass  
8. {  
9.       public:  
10.              myclass(int a,int b):first(a),second(b){}  
11.              int first;  
12.              int second;  
13.              bool operator < (const myclass &m)const //重载运算符<   
14.              {  
15.                   return first < m.first;  
16.                   }       
17.       };   
18. bool less_second(const myclass &m1,const myclass &m2) //根据第2个元素比大小   
19. {  
20.      return m1.second<m2.second;  
21.      }  
22.   
23. int main()  
24. {  
25.     int i=0;  
26.     vector<myclass> vct;  
27.     for(i=0;i<10;i++)  
28.     {  
29.             myclass my(10-i,i*3);  
30.             vct.push_back(my);  
31.     }  
32.     for(i=0;i<vct.size();i++)  
33.         cout<<"("<<vct[i].first<<","<<vct[i].second<<")"<<endl;                   
34.     sort(vct.begin(),vct.end()); //按第1个值排序   
35.     cout<<"after sorted by the  first: "<<endl;  
36.     for(i=0;i<vct.size();i++)  
37.         cout<<"("<<vct[i].first<<","<<vct[i].second<<")"<<endl;//输出按第1个值排序结果   
38.     sort(vct.begin(),vct.end(),less_second);//按第2个值排序   
39.     cout<<"after sorted by the  second: "<<endl;  
40.     for(i=0;i<vct.size();i++)  
41.         cout<<"("<<vct[i].first<<","<<vct[i].second<<")"<<endl; //输出按第2个值排序结果     
42.     system("pause");             
43.     return 0;  
44. }  

结果

3.容器

容器部分主要由头文件<vector>、<list>、<deque>、<set>、<map>、<stack>和<queue>组成。

3.1容器——向量(vector)

例1

[cpp] view plaincopyprint?

1. #include<iostream>  
2. #include<vector>  
3. using namespace std;  
4.   
5. char* szHW = "Hello World";  
6. int main(int argc,char* argv[])  
7. {  
8.     vector <char> vct;//声明一个字符向量 vector   
9.     vector <char> :: iterator vi;//为字符数组字义一个游标iterator   
10.     char* cptr = szHW;  
11.     while(*cptr!='\0')//初始化字符向量，对整个字符串进行循环，用来把数据填放到字符向量中，直到遇到'\0'时结束   
12.     {vct.push_back(*cptr);cptr++;}//push_back将数据放在向量的尾部   
13.     for(vi=vct.begin();vi!=vct.end();vi++)//将向量中的字符一个个地显示在控制台，这是STL循环的规范化开始，通常是"!="，而不是"<"，因为"<"在一些容器中没有定义   
14.     cout<<*vi;//使用运算符"*"将数据从游标指针中提取出来   
15.     cout<<endl;  
16.     system("pause");  
17.     return 0;  
18.     }  

上例中使用了向量<vector>容器类。STL容器中大约有一半是基于向量的。事实上，vector是一种动态数组，是基本数组的类模板。其内部定义了很多基本操作。既然这是一个类，那么它就会有自己的构造函数。预编译头文件为#include<vector>。

例2.也可以像数组一样访问vector元素，如下：

[cpp] view plaincopyprint?

1. #include<vector>  
2. #include<iostream>  
3. using namespace std;  
4. int main()  
5. {  
6.     vector<int> a;  
7.     for(int i=0;i<10;i++)//这里的i是int型数据，不是迭代器   
8.      a.push_back(i*i);  
9.     for(int i=0;i<a.size();i++)//用函数size()取容器a的大小   
10.      cout<<a[i]<<" ";//用数组方式访问vector元素   
11.     cout<<endl;  
12.     system("pause");  
13.     return 0;      
14. }  

例3 在容器中查找特定值的元素，并显示下标位置

[cpp] view plaincopyprint?

1. #include<vector>  
2. #include<string>  
3. #include<iostream>  
4. using namespace std;  
5. int main()  
6. {  
7.     vector<int> a(10);  
8.     vector<int>::iterator i;  
9.     a[5]=100;//把a[5]设为100   
10.     for(i=a.begin();i!=a.end();i++)  
11.       cout<<*i<<" ";  
12.      cout<<endl;  
13.     vector<int>::iterator intIter=find(a.begin(),a.end(),100);//查找值为100的迭代器   
14.     if(intIter!=a.end())//end 返回的 不是最后一个位置的元素的指针。是最后一个元素指针+1  
15.      {  
16.      cout<<"找到："<<*intIter<<endl;  
17.      cout<<"位置是："<<intIter-a.begin()<<endl; // 下标位置：迭代器当前位置前去初始位置。   
18.      }  
19.     else  
20.      cout<<"没找到"<<endl;   
21.     system("pause");  
22.     return 0;      
23. }  

vector中定义了以下4种构造函数

1）默认构造函数

构造一个初始长度为0的空向量，其调用格式如:

vector<int> v1;

2）带有单位整形参数的构造函数

此参数描述了向量的初始大小，该构造函数还有一个可选的参数，这是一个类型为T的实例，描述了各个向量中各成员的初始值，其调用如（此时的T为int）：

vector<int> v2(init_size,0);//要事先定义init_size,表示向量的初始大小，其成员都被初始化为0

3）带有两个常量参数的构造函数

产生初始值为一个区间的向量。区间由一个半开区间[first,last)来指定,其调用格式如下：

vector<int> v3(firs,last);

注意：stl体系中，所有用到一对迭代器的，都是左闭右开，[ begin(), end() )。end 返回的不是最后一个位置的元素的指针，是最后一个元素指针+1。

4）复制构造函数

构造一个新的向量，作为已存在的向量的完全复制，其调用如下：

vector<int> v4(v3);

此外，在实际程序中使用较多的是向量类的成员函数，其常用的成员函数如下。

begin()、end()、push_back()、insert()、assign()、front()、back()、erase()、empty()、at()、size()。

3.2容器——列表 

列表也是容器类的一种，其所控制的长度为N的序列是以一个有着N个节点的双向链表来存储的，支持双向迭代器，其预编译头文件为#include<list>

模板list的另一个特点是在异常处理方面，对任何容器来说，容器成员函数在执行中抛出的异常，使容器本身处于一种一致状态，可以被销毁，并且容器没有对所分配的存储空间失去控制。但对大部分操作尤其是那些能够影响多个元素的操作，当抛出异常时，并没有制定容器的精确状态，但list保证对于大部分成员函数抛出异常时，容器能够恢复到操作前的状态。列表类的定义如下：

list<T,allocator<T> > ls;//使用默认模板参数，可以省略第2个参数。

成员函数如下：resize()  clear()  front()  back()  push_back()  push_front()  pop_back()  pop_front()  assign()  insert()  erase()  splice()  remove()  remove_if()  unique()  sort()  merge()  reverse()。

[cpp] view plaincopyprint?

1. #include<list>  
2. #include<iostream>  
3.   
4.   
5. int main()  
6. {  
7.     using namespace std;  
8.     list<int> c1;  
9.     list<int>:: iterator c1_iter;  
10.     c1.push_back(20);  
11.     c1.push_back(10);  
12.     c1.push_back(30);  
13.     cout<<"Before sorting c1 = ";  
14.     for(c1_iter = c1.begin();c1_iter!=c1.end();c1_iter++)//输出列表内容   
15.                 cout<<" "<<*c1_iter;  
16.     cout<<endl;  
17.     c1.sort();//调用列表排序函数   
18.     cout<<"After sorting c1 = ";  
19.     for(c1_iter = c1.begin();c1_iter!=c1.end();c1_iter++)//输出排序后内容   
20.                 cout<<" "<<*c1_iter;  
21.     cout<<endl;  
22.     c1.sort(greater<int>());//调用降序排序函数   
23.     cout<<"After sorting with 'greater than' operation, c1 = ";  
24.     for(c1_iter = c1.begin();c1_iter!=c1.end();c1_iter++)//输出降序排列后内容   
25.                 cout<<" "<<*c1_iter;  
26.     cout<<endl;  
27.     system("pause");  
28.     return 0;          
29.     }   

结果

3.3容器——集合

集合(set)也是容器的一种，它的特点在集合中的元素值是唯一的。在集合中，所有成员都是排列好的。如果先后往一个集合中插入：4，3，2，5，则输出该集合时为:2,3,4,5。

[cpp] view plaincopyprint?

1. #include<iostream>  
2. #include<set>  
3. #include<string>  
4. using namespace std;  
5. int main()  
6. {  
7.     set <string> strset;  
8.     set <string> ::iterator si;  
9.     strset.insert("Apple");  
10.     strset.insert("Bnana");  
11.     strset.insert("Orange");  
12.     strset.insert("Plate");  
13.     strset.insert("Grapes");  
14.     strset.insert("Grapes");  
15.     for(si=strset.begin();si!=strset.end();si++)  
16.        cout<<*si<<" ";  
17.     cout<<endl;  
18.     system("pause");  
19.     return 0;  
20.     }  

上例中，Grapes虽然插入了两次，但同样的元素只出现一次。

3.4容器——双端队列

双端队列是一个queue容器类（即队列容器），其定义在头文件deque中（即double queue）。在使用该容器时，需在头文件中加上如下语句：#include<deque>

与vector相同点：支持随机访问和快速插入删除，它在窗口中某一位置上的操作所花费的是线性时间。

与vector不同点：deque还支持从开始端插入数据，因为其包含在开始端插入数据的函数push_front()。此外deque也不支持与vector类似的capacity()，reserve()类似的操作。例1：

[cpp] view plaincopyprint?

1. #include <iostream>  
2. #include <deque>  
3. using namespace std;  
4. typedef deque<int> INTDEQUE;  
5.   
6. void put_deque(INTDEQUE deque,char* name)//从前向后显示deque的全部元素   
7. {  
8.      INTDEQUE::iterator pdeque;  
9.      cout <<"The contents of "<<name<<" : ";  
10.      for(pdeque=deque.begin();pdeque!=deque.end();pdeque++)  
11.         cout<<*pdeque<<" ";  
12.      cout<<endl;  
13.      }  
14.   
15. int main()  
16. {  
17.     INTDEQUE deq1;  
18.     INTDEQUE deq2(10,6);  
19.     put_deque(deq1,"deq1");  
20.     put_deque(deq2,"deq2");  
21.       
22.     deq1.push_back(2);//在deq1序列后面添加元素   
23.     deq1.push_back(4);  
24.     cout<<"deq1.push_back(2) and deq1.push_back(4) : "<<endl;  
25.     put_deque(deq1,"deq1");  
26.       
27.     deq1.push_front(5);//在deq1序列前面添加元素   
28.     deq1.push_front(7);  
29.     cout<<"deq1.push_front(5) and deq1.push_front(7) : "<<endl;  
30.     put_deque(deq1,"deq1");  
31.       
32.     deq1.insert(deq1.begin()+1,3,9);//在deq1中间插入数据   
33.     cout<<"deq1.insert(deq1.begin()+1,3,9): "<<endl;  
34.     put_deque(deq1,"deq1");  
35.       
36.     cout<<"deq1.at(4) = "<<deq1.at(4)<<endl;//测试引用类函数   
37.     cout<<"deq1[4] = "<<deq1[4]<<endl;  
38.       
39.     deq1.at(1)=10;  
40.     deq1[2]=20;  
41.     cout<<"deq1.at(1)=10 and deq1[2]=20 :"<<endl;  
42.     put_deque(deq1,"deq1");  
43.       
44.     deq1.pop_front();//从deq1序列的前后各移去一个元素  
45.     deq1.pop_back();  
46.     cout<<"deq1.pop_front() and deq1.pop_back(): "<<endl;  
47.     put_deque(deq1,"deq1");  
48.       
49.     deq1.erase(deq1.begin()+1);//清除deq1中的第2个元素   
50.     cout<<"deq1.erase(deq1.begin()+1) : "<<endl;  
51.     put_deque(deq1,"deq1");  
52.       
53.     deq2.assign(8,1);//对deq2赋值并显示  
54.     cout<<"deq2.assign(8,1) : "<<endl;  
55.     put_deque(deq2,"deq2");  
56.       
57.     system("pause");  
58.     return 0;    
59.     }  

例2

[cpp] view plaincopyprint?

1. #include<deque>  
2. #include<string>  
3. #include<iostream>  
4. using namespace std;  
5. int main()  
6. {  
7.     deque<string> a;  
8.     string word;  
9.     for(int i=0;i<5;i++)  
10.     {  
11.      cin>>word;  
12.      a.push_back(word);  
13.      }  
14.      a.pop_front();//从前面删除一个元素   
15.      a.pop_back();//从后面删除一个元素   
16.     for(int i=0;i<a.size();i++)//用函数size()取deque容器a的大小   
17.      cout<<a[i]<<" ";//用数组方式访问deque元素   
18.     cout<<endl;  
19.     system("pause");  
20.     return 0;      
21. }  

3.5容器——栈

容器栈(stack)是一种特殊的容器，其特征是后进先出。支持以下5种操作：

empty():如果栈空，返回true，否则返回false。

size():返回栈中元素的个数。

pop():删除，但不返回栈顶元素。

top():返回，但不删除栈顶元素。

push():放入新的栈顶元素。

[cpp] view plaincopyprint?

1. #include<stack>   
2. #include<iostream>  
3. using namespace std;  
4. int main()  
5. {  
6.     const int ia_size = 10;  
7.     int ia[ia_size]={0,1,2,3,4,5,6,7,8,9};  
8.     int ix = 0;  
9.     stack<int> intStack;  
10.     for(;ix<ia_size;++ix)  
11.      intStack.push(ia[ix]); //压栈   
12.     if(intStack.size()!= ia_size)  
13.     {cout<<"ERROR"<<endl;return -1;}  
14.     int value;  
15.     while(!intStack.empty())  
16.     {  
17.      value = intStack.top();//取栈顶元素   
18.      cout<<value<<endl;  
19.      intStack.pop();//删除栈顶元素      
20.     }  
21.     system("pause");  
22.     return 0;  
23. }  
24.       

3.6容器——映射和多重映射

映射和多重映射用于对数据进行快速和高效的检索。同样地，在程序中使用映射和多重映射容器需添加如下头文件：#include<map>

映射map支持下标运算符operator[]，可以用访问普通数据的方式访问map，或下标为map的键。而在mutimap中一个键可以对应多个不同的值。

[cpp] view plaincopyprint?

1. #include<map>  
2. #include<iostream>  
3. using namespace std;  
4. int main()  
5. {  
6.  map<char,int,less<char> > map1;  
7.  map<char,int,less<char> >::iterator mapIter;  
8.  map1['c']=3;//初始化，与数组类似。也可以用 map1.insert(map<char,int,less<char> >::value_type('c',3));  
9.  map1['d']=4;  
10.  map1['a']=1;  
11.  map1['b']=2;  
12.  for(mapIter = map1.begin();mapIter!=map1.end();mapIter++)  
13.    cout<<(*mapIter).first<<":"<<(*mapIter).second<<" ";  
14.  cout<<endl;  
15.  map<char,int,less<char> >::const_iterator ptr;  
16.  ptr=map1.find('d');//检索对应于d键的值   
17.  cout<<(*ptr).first<<"键对应于值: "<<(*ptr).second<<endl;  
18.  system("pause");  
19.  return 0;  
20. }  

4.迭代器

迭代器实际上是一种泛化指代指针，如果一个迭代器指向容器中的某个成员，那么迭代器将可以通过自增 自减来遍历容器中的所有成员。迭代器是联系容器和算法的媒介，是算法操作容器的接口。

STL中的迭代器主要是由头文件<utility>、<iterator>、<memory>组成。

<utility>包括了贯穿使用在STL中的几个模板声明。

<iterator>头文件中提供了迭代器使用的许多方法。

<memory>头文件中的主要部分是模板类allocator，它负责产生所有容器中的默认分配器。

例如：下面程序实现使用输入/输出迭代器完成了将一个文件里的内容输出到屏幕的功能。

[cpp] view plaincopyprint?

1. #include<iostream>  
2. #include<fstream>  
3. #include<iterator>  
4. #include<vector>  
5. #include<string>  
6. using namespace std;  
7.   
8. int main()  
9. {  
10.  vector<string> v1;  
11.  ifstream file("test.txt");  
12.  if(file.fail())  
13.  {cout<<"打开文件失败，请确定要打开的文件存在"<<endl;}  
14.  copy(istream_iterator<string>(file),istream_iterator<string>(),inserter(v1,v1.begin()));//如果没有#include<iterator>这里会报错   
15.  copy(v1.begin(),v1.end(),ostream_iterator<string>(cout," "));  
16.  cout<<endl;  
17.  system("pause");  
18.  return 0;  
19. }   

上述代码中，用到了输入迭代器istream_iterator，输出迭代器ostream_iterator。程序完成了将一个文件输出到屏幕的功能，先将文件读入，然后通过迭代器把文件内容复制到类型为字符串的向量容器内，最后输出迭代器输出。inserter是一个输入迭代器函数(迭代器适配器)，其使用方法是：

inserter(container ,pos);

综合范例：下面程序救出范围在2~N中的所有素数，其中N在程序运行时由键盘输入，实现代码如下。

[cpp] view plaincopyprint?

1. #include<iostream>  
2. #include<iomanip>//IO控制流头文件   
3. #include<vector>  
4. using namespace std;  
5. int main()  
6. {  
7.     vector<int> A(10);  
8.     int n;  
9.     int primecount = 0,i,j;  
10.     cout<<"Enter a value > 2 as upper limit: ";  
11.     cin>>n;  
12.     A[primecount++]=2;  
13.     for(i=3;i<n;i++)  
14.     {  
15.      if(primecount == A.size())//达到向量大小   
16.         A.resize(primecount+10);//调用函数重新设置向量大小   
17.      if(i%2 == 0)//不是素数   
18.         continue;  
19.     j=3;  
20.     while(j<=i/2&&i%j!=0)//循环判断是否为素数   
21.       j+=2;//变量递加2   
22.     if(j>i/2)//是素数   
23.       A[primecount++] = i;//写入向量   
24.     }  
25.     for(i=0;i<primecount;i++)  
26.     {  
27.      cout<<setw(5)<<A[i];//设置输出格式并输出   
28.      if(0==(i+1)%10)//第10行输出一个换行   
29.         cout<<endl;  
30.     }  
31.     cout<<endl;  
32.     system("pause");  
33.     return 0;  
34. }