高质量C++编程指南：标准模板库（STL）

第八章、标准模板库（STL）8．１基本概念

C++在1991年引入了模板技术，此后C++的编程概念和风格都发生了很大的变化，原先用宏来实现的代码纷纷都用模板来重新实现。模板在C++的重要应用就是开发泛型库，包括泛型容器和泛型算法。模板技术和运算符重载成为C++实现泛型编程的两大支柱。

泛型编程技术与面向对象编程并无直接的联系，甚至是背道而驰的：面向对象倡导把数据和操作绑定在一起，而泛型容器和算法则将数据和操作分离开来。实现泛型编程的方法不外乎下面几种：**使用带参数的宏。过去的通用函数就是用宏来编写的。比如：MAX、MIN等。**使用void*。过去许多泛型算法就是使用它来实现的。**使用通用的根类和虚函数，比如：Java的Object。**使用模板技术。

宏的缺点是显然的；void*是无类型的；通用根类很好，但是限制太死，而且动态决议的开销也是很可观的，不能强制C++程序都使用它。只有模板最适合实现泛型编程，它不仅直观，而且是类型安全的，也不会带来任何额外的运行开销。

模板通过把数据类型参数化实现了类型无关，从而可以提高程序的可重用性和可移植性。

STL支持多种容器类型，这些容器的类型分为序列式容器和结合容器。指示器对象类似于C++的指针，它的层次结构管理了对容器的访问，指示器指向容器中的对象并允许程序以各种方法在容器中用指示器提取对象。

所有的容器都有通用的管理成员函数，如insert()、erase()、begin()、end()等。模板定义中定义了这些成员函数。容器类型是用模板实现的，当程序实例化容器对象时所给出模板参数确定了容器所包含的对象模型。8.2序列容器

STL用如下的模板类和适配器实现序列容器：std::vector:一种随机访问的数组类型，它提供了对数组元素的快速、随机访问，以及在序列尾部快速、随机的插入和删除操作。std::vector

对象可在需要的时候修改其自身大小。std::deque:一种随机访问的数组类型，它提供了在序列两端快速的插入和删除操作。std::deque对象可在需要的时候修改其自身大小。std::list:一种不支持随机访问的数组类型，因为STL以双向链表的方式实现std::list

对象。所以访问链表元素要用指针从链表的某个端点开始。插入和删除操作所花的时间是固定的。也就是说std::list

对象插入和删除一个元素所花的时间与元素在链表中的位置无关。std::queue:适配器容器类型，它用std::deque或std::list

对象创建一个排队序列。一、向量模板类：1、构造向量模板类对象：

std::vector对象提供对序列中元素随机访问，也可以顺序访问。类似于数组，但不同于数组,std::vector对象在运行时可以动态改变自身的大小以便容纳任何数目的元素。

std::vector对象可以快速地在序列尾部插入和删除元素，但在序列其它地方插入和删除效率有所降低。这是因为std::vector对象必须移动元素位置以容纳新的元素。

使用std::vector对象必须包含其头文件vector，其对象的构造有下面几种：

vector<type>name;//创建空对象vector<type>name(size);//创建一个大小为size对象vector<type>name(size,value);//创建一个大小为size，初值为value对象vector<type>name(mvector);//拷贝构造函数vector<type>name(first,last);//构造一个元素在某个范围内的向量。该范围用first及last指示器来说明。2、使用向量模板类对象：例：#include<iostream.h>#include<vector>voidmain(void){usingnamespacestd;vector<int>mvector(10,1);//定义一个int型mvector对象

vector<int>::iterator

iter;//定义一个int容器指示器指针

for(iter=mvector.begin();iter!=mvector.end();iter++)

cout<<*iter<<“;”;//遍历对象mvector

}

容器指示器就是指向容器中元素的指针，通过它来访问容器中的元素。3、向量模板类对象的其他操作push_back(x):把值x插入到向量尾部。pop_back():删除向量中的最后一个元素。insert(i,x):把值x插入到指示器i指向的位置insert(i,start,end):把指示器start和end所指定范围的值插入到向量指示器i所指定的位置。erase(i):删除指示器i所指的向量元素。begin():返回指向向量中第一个元素的指示器

end():返回指向向量中最后一个元素的指示器

at(n):返回向量中位置n处的元素值。size():返回向量的大小（元素的个数）。clear():删除向量的所有元素。empty():如果向量为空，则返回TRUE。reverse():反转元素顺序。

capacity():返回向量当前所能容纳的最多元素个数。例：利用向量模板类写出求大数阶乘精确值得代码：#include<iostream.h>#include<vector>#include<windows.h>

voidmain(void){usingnamespacestd;vector<int>intvector(1,1);vector<int>::iterator

iter;

intm=0,n,s;//格式化输出计数,for循环计数用

intcarry=0;//进位值

cout<<"请输入一个整数::n="; cin>>n;DWORDTime1=GetTickCount();

for(s=1;s<=n;s++) {carry=0;

for(iter=intvector.begin();iter!=intvector.end();iter++){*iter=*iter*s+carry;carry=*iter/10;*iter=*iter%10;}

while(carry>0){m=carry%10; carry=carry/10;intvector.push_back(m);}

if(carry>0)intvector.push_back(carry); }n=0;//控制格式化输出每行60个字符

for(m=intvector.size()-1;m>=0;m--) {cout<<intvector.at(m);n++; if(n%60==0)cout<<endl;}DWORDTime=GetTickCount()-Time1;

cout<<endl<<Time<<“ms”<<endl;}//统计计算的时间为毫秒4、两个向量的比较：模板类std::vector定义了一组完整的运算符，这些运算符可以比较std::vector对象，当两个向量有相同个数的元素时，且元素值也相同时，这两个向量就是相等的，也可以判定一个向量小于或大于另一个向量。例如：voidmain(){usingnamespacestd;vector<char>vector1;vector<char>vector2;for(inti=0;i<10;i++){vector1.push_back(65+i);

//写入：ABCDEFGHIJ

vector2.push_back(68+i);}

//写入：DEFGHIJKLMif(vector1==vector2)

//比较2个向量的大小cout<<“vector1==vector2”<<endl;elseif(vector1>vector2)cout<<“vector1>vector2”<<endl;elseif(vector1<vector2)cout<<“vector1<vector2”<<endl;}//结果为：vector1<vector2二、双端队列模板类1、构造双端队列模板类对象：对象std::deque类似于向量，但双端队列对象可以在序列的两端放置元素和删除元素，并且是高效的。std::deque对象提供了对其元素的随机访问，也能在需要的时候动态改变自身大小，但在向量中的插入和删除操作不那么有效。构造std::deque对象必须包含头文件<deque>,构造方式有下面几种：std::deque<type>name;//创建空对象std::deque<type>name(size);//创建一个大小为size对象std::deque<type>name(size,value);//创建一个大小为size，初值为value对象std::deque<type>name(mydeque);//拷贝构造函数std::deque<type>name(first,last);//构造一个元素在某个范围内的向量。该范围用first及last指示器来说明。2、双端队列对象的使用：例：

#include<iostream.h>

#include<deque>voidmain(void){usingnamespacestd;

deque<int>mdeque(10,1);

//定义一个int型mdeque对象

deque<int>::iterator

iter;

//定义一个int容器指示器指针

for(iter=mdeque.begin();iter!=mdeque.end();iter++)

cout<<*iter<<“;”;

//遍历对象mdeque

}

程序创建了有10个元素的std::deque对象，所有元素都被初始化为1，

程序开始包含了头文件#include<deque>，最后遍历显示每个元素。3、双端队列模板类对象的其他操作push_back(x):把值x插入到双端队列尾部。push_front(x):把值x插入到双端队列头部。pop_back():删除双端队列的最后一个元素。pop_front():删除双端队列的第一个元素。insert(i,x):把值x插入到指示器i指向的位置insert(i,start,end):把指示器start和end所指定范围的值插入到指示器i所指定的位置。erase(i):删除指示器i所指的双端队列元素。begin():返回指向双端队列第一个元素的指示器

end():返回指向双端队列最后一个元素的指示器

at(n):返回双端队列中位置n处的元素值。size():返回双端队列的大小（元素的个数）。clear():删除双端队列的所有元素。empty():如果双端队列为空，则返回TRUE。swap(deque):交换2个双端队列的内容。

例：利用双端队列模板类写出求大数阶乘精确值得代码：#include<iostream.h>#include<windows.h>#include<deque>

voidmain(void){usingnamespacestd;

deque<int>intdeque(1,1);

deque<int>::iterator

iter;

intm=0,n,s;//格式化输出计数,for循环计数用

intcarry=0;//进位值

cout<<"请输入一个整数::n="; cin>>n;DWORDTime1=GetTickCount();

for(s=1;s<=n;s++) {carry=0;for(iter=intdeque.begin();iter!=intdeque.end();iter++){*iter=*iter*s+carry;carry=*iter/10;*iter=*iter%10;}

while(carry>0){m=carry%10; carry=carry/10;intdeque.push_back(m);}

if(carry>0)intdeque.push_back(carry); }

n=0;//控制格式化输出每行60个字符for(iter=intdeque.end()-1;iter!=intdeque.begin();iter--) {

cout<<*iter;n++; if(n%60==0)cout<<endl;}cout<<*iter;

DWORDTime=GetTickCount()-Time1;

cout<<endl<<Time<<"ms"<<endl;}//统计计算的时间为毫秒4、两个双端队列的比较：模板类std::deque定义了一组完整的运算符，这些运算符可以比较std::deque对象，当两个双端队列有相同个数的元素时，且元素值也相同时，这两个双端队列就是相等的，也可以判定一个双端队列小于或大于另一个双端队列。例如：voidmain(){usingnamespacestd;deque<char>deque1;deque<char>deque2;for(inti=0;i<10;i++){deque1.push_back(65+i);

//写入：ABCDEFGHIJ

deque2.push_back(68+i);}

//写入：DEFGHIJKLMif(deque1==deque2)

//比较2个双端队列的大小cout<<“deque1==deque2”<<endl;elseif(deque1>deque2)cout<<“deque1>deque2”<<endl;elseif(deque1<deque2)cout<<“deque1<deque2”<<endl;}//结果为：deque1<deque2三、链表模板类1、构造链表模板类对象：对象std::list类似于向量和双端队列，只不过链表对象提供了对元素的随机访问。但是std::list对象在序列中的任何位置放置元素和删除元素都是高效的。std::list对象也能在需要的时候动态改变自身大小。构造std::list对象必须包含头文件<list>,构造方式有下面几种：std::list<type>name;//创建空对象std::list<type>name(size);//创建一个大小为size对象std::list<type>name(size,value);//创建一个大小为size，初值为value对象std::list<type>name(mydeque);//拷贝构造函数std::list<type>name(first,last);//构造一个元素在某个范围内的向量。该范围用first及last指示器来说明。2、链表对象的使用：例：

#include<iostream.h>

#include<list>voidmain(void){usingnamespacestd;

list<int>mlist(10,1);

//定义一个int型mlist对象

list<int>::iterator

iter;

//定义一个int容器指示器指针

for(iter=mlist.begin();iter!=mlist.end();iter++)

cout<<*iter<<“;”;

//遍历对象mdeque

}

程序创建了有10个元素的std::list对象，所有元素都被初始化为1，

程序开始包含了头文件#include<list>，最后遍历显示每个元素。3、链表类模板对象的其他操作push_back(x):把值x插入到链表尾部。push_front(x):把值x插入到链表头部。pop_back():删除链表的最后一个元素。pop_front():删除链表的第一个元素。insert(i,x):把值x插入到指示器i指向的位置insert(i,start,end):把指示器start和end所指定范围的值插入到指示器i所指定的位置。erase(start,end):删除指示器start和end所指范围的链表元素。erase(i):删除指示器i所指的链表元素。begin():返回指向链表第一个元素的指示器

end():返回指向链表中最后一个元素的指示器

back():返回对链表尾部元素的引用。front():返回对链表起始元素的引用。size():返回链表的大小（元素的个数）。clear():删除链表中的所有元素。empty():如果链表为空，则返回TRUE。swap(deque):交换2个链表的内容。

例：利用链表模板类写出求大数阶乘精确值得代码：#include<iostream.h>#include<windows.h>#include<list>

voidmain(void){usingnamespacestd;list<int>intlist(1,1);list<int>::iterator

iter;

intm=0,n,s;//格式化输出计数,for循环计数用

intcarry=0;//进位值

cout<<"请输入一个整数::n="; cin>>n;DWORDTime1=GetTickCount();

for(s=1;s<=n;s++) {carry=0;for(iter=intlist.begin();iter!=intlist.end();iter++){*iter=*iter*s+carry;carry=*iter/10;*iter=*iter%10;}

while(carry>0){m=carry%10; carry=carry/10;intlist.push_back(m);}if(carry>0)intlist.push_back(carry); }

n=0;//控制格式化输出每行60个字符intlist.reverse();for(iter=intlist.begin();iter!=intlist.end();iter++) {cout<<*iter;n++; if(n%60==0)cout<<endl;}//cout<<*iter;

DWORDTime=GetTickCount()-Time1;

cout<<endl<<Time/1000.0<<"s"<<endl;}

//统计计算的时间为毫秒4、两个链表的比较：类模板std::list定义了一组完整的运算符，这些运算符可以比较std::list对象，当两个双端队列有相同个数的元素时，且元素值也相同时，这两个链表就是相等的，也可以判定一个链表小于或大于另一个链表。例如：voidmain(){usingnamespacestd;list<char>list1;list<char>list2;for(inti=0;i<10;i++){list1.push_back(65+i);

//写入：ABCDEFGHIJ

list2.push_back(68+i);}

//写入：DEFGHIJKLMif(list1==list2)

//比较2个链表的大小cout<<“list1==list2”<<endl;elseif(list1>list2)cout<<“list1>list2”<<endl;elseif(list1<list2)cout<<“list1<list2”<<endl;}//结果为：list1<list2四、容器适配器std::stack1、容器适配器std::stack的构造：

堆栈是一种序列，它实现了对元素的先进后出的操作，因为堆栈是一种通用的数据结构，所以STL实现了堆栈。在STL中的堆栈不是用类模板实现的，而是用名为std::stack的容器适配器实现的，容器适配器std::stack可以从std::vector、std::deque、std::list对象创建一个堆栈。构造一个std::stack对象的方法为：

std::stack<type,container>name;

参数type是堆栈所操作的数据类型，container参数是实现堆栈所用的容器类型（std::vector、std::deque或std::list）。例如，基于std::list对象为整数数据类型创建std::stack对象的方法是：

std::stack<int,std::list<int>

>intstack;2、容器适配器std::stack的操作：因为堆栈是一种简单的数据结构，所以它只需要一些简单操作。因此std::stack容器适配器只定义了函数：empty():

堆栈清空。size():

获得堆栈大小。top():

取堆栈顶数据。push():

数据压栈。pop():

数据弹出堆栈。使用堆栈必须包含相应头文件<stack>。例子：#include<list>#include<stack>voidmain(void){usingnamespacestd;stack<int,list<int>>intstack;for(inti=1;i<8;i++){intstack.push(i*10);cout<<10*i<<“;”;}//10;20;30;40;50;60;70cout<<endl;intsize=intstack.size();//获得堆栈的大小for(i=0;i<size;i++){cout<<intstack.top()<<“;”;//70;60;50;40;30;20;10

intstack.pop();}}五、容器适配器std::queue1、容器适配器std::queue的构造：

队列数据结构对其元素实现了先进先出的操作，也就是说队列中的元素在一端插入，在另一端删除。STL用名为std::queue的容器实现了队列。容器适配器std::queue可用来从std::deque或std::list对象创建队列。

构造std::queue对象的方法：

std::queue<type,container>;

参数type是队列所操作的数据类型。container是用于实现队列的容器类型（std::deque或std::list），例如：基于std::list对象为整数数据类型创建std::queue对象的方法是：std::queue<int,std::list<int>>myque;1、容器适配器std::queue的操作：

队列也是一种简单的数据结构，所以只需要一些基本的操作。主要有：empty():清空队列。size():返回队列的大小。front():置队列首。back():置队列尾。push():压入队列。pop():弹出队列。下面的例子说明对列的使用。#include<list>#include<queue>voidmain(void){usingnamespacestd;queue<int,list<int>>intqueue;for(inti=1;i<8;i++){intqueue.push(i*10);cout<<10*i<<“;”;}//10;20;30;40;50;60;70cout<<endl;intsize=intqueue.size();//获得队列的大小for(i=0;i<size;i++){cout<<intqueue.front()<<“;”;//10;20;30;40;50;60;70

intqueue.pop();}}8.3

结合容器

结合容器不同于序列，在容器中每一个元素都有一个关键词，通过它可以找到相应元素。结合容器主要有：std::set

一种随机存取的容器。其关键词和数据元素时同一个值，也就是说它不能够包含重复的元素。std::multiset

与std::set相似，不同的是std::multiset容器可以包含重复的元素。std::map

这是一种包含成对数值的容器类型。其中一个值是实际数据值，另一个是用来寻找数据的关键值。一个特定的关键词只能与一个元素相联系。std::multimap

与std::map

类似，所不同的是一个关键词可以与多个数据元素向联系。一、std::set集合容器1、构造集合容器std::set

：std::set对象可以使程序按照次序来存储一组数值。在一个集合中，元素既作为被存储的数据又作为数据的关键值。本质上一个集合就是一个有序的排列。可以用下列的方法创建std::set对象：std::set<type,predicate>name;std::set<type,predicate>name(myset);std::set<type,predicate>name(first,last);默认的谓词是std::less<>，即从小到大排序。例如要给整数创建一个空的set对象：std::set<int,std::less<int>>myset;2、使用集合容器：例：#include<iostream.h>#include<set>voidmain(void){usingnamespacestd;

set<int>myset;//定义一个int型mvector对象

set<int>::iterator

iter;//定义一个int容器指示器指针

myset.insert(10);myset.insert(5);myset.insert(3);myset.insert(1);myset.insert(8);myset.insert(6);

for(iter=myset.begin();iter!=myset.end();iter++)

cout<<*iter<<“;”;//遍历对象mvector

}//输出1；3；5；6；8；103、集合容器的其它操作：begin():返回指向集合中第一个元素的指示器

clear():删除集合的所有元素。count(x):返回元素x在集合中出现的次数（0或1次）empty():如果集合为空，则返回TRUE。end():返回指向集合中最后一个元素的指示器erase(i):删除指示器i所指的集合元素。erase(x):删除集合元素x。find(x):返回指向x的指示器。如果x不存在，则返回指示器与end（）相等insert(i,x):把值x插入到指示器i指向的元素之前insert(start,end):把指示器start和end所指定范围的值插入到集合中insert(x):把值x插入到集合中size():返回集合的大小（元素的个数）。swap(set):交换2个集合的内容。

max_size():返回集合当前所能容纳的最多元素个数。二、std::multiset多重集合容器1、构造多重集合容器std::multiset

：

std::multiset对象可以使程序按照次序来存储一组数值。在一个多重集合中，元素既作为被存储的数据又作为数据的关键值。本质上一个多重集合就是一个有序的排列。多重集合可以包含重复的数据。用下列的方法可以创建std::multiset对象：std::multisetset<type,predicate>name;std::multisetset<type,predicate>name(myset);std::multisetset<type,predicate>name(first,last);

默认的谓词是std::less<>，即从小到大排序。例如要给整数创建一个空的multisetset对象：std::multisetset<int,std::less<int>>myset;2、使用多重集合容器：例：#include<iostream.h>#include<set>voidmain(void){usingnamespacestd;

multiset<int>myset;//定义一个int型mvector对象

multiset<int>::iterator

iter;//定义一个int容器指示器指针

myset.insert(10);myset.insert(5);myset.insert(3);myset.insert(1);myset.insert(5);myset.insert(8);myset.insert(6);myset.insert(8);

for(iter=myset.begin();iter!=myset.end();

iter++)

cout<<*iter<<“;”;//遍历对象mvector

}//输出1；3；5；5；6；8；8；103、多重集合容器的其它操作：begin():返回指向多重集合中第一个元素的指示器

clear():删除多重集合的所有元素。count(x):返回元素x在多重集合中出现的次数empty():如果多重集合为空，则返回TRUE。end():返回指向多重集合中最后一个元素的指示器erase(i):删除指示器i所指的多重集合元素。erase(x):删除多重集合元素x。find(x):返回指向x的指示器。如果x不存在，则返回指示器与end（）相等insert(i,x):把值x插入到指示器i指向的元素之前insert(start,end):把指示器start和end所指定范围的值插入到集合中insert(x):把值x插入到多重集合中size():返回多重集合的大小（元素的个数）。swap(set):交换2个多重集合的内容。

max_size():返回多重集合当前所能容纳的最多元素个数。三、std::map映射容器1、构造std::map映射容器

std::map对象可以使程序按照次序来存储一组数值。每一个元素都与一个查询关键值相关。可以使用下面方法来创建std::map对象：std::map<key,type,predicate>name;std::map<key,type,predicate>name(myset);std::map<key,type,predicate>name(first,last);

key参数是在映射中所使用的关键词类型。例如要构造一个整数的空std::map对象：std::map<int,int,std::less<int>>name;

std::less<int>默认谓词，不需要再声明中包含2、使用std::map映射容器例：#include<iostream.h>#include<map>voidmain(void){usingnamespacestd;map<int,char>mymap;//定义一个int型mvector对象

map<int,char>::iterator

iter;//定义一个int容器指示器指针

mymap.insert(map<int,char>::value_type(1,’X’));

mymap.insert(map<int,char>::value_type(2,’B’));

mymap.insert(map<int,char>::value_type(3,’E’));

mymap.insert(map<int,char>::value_type(4,’H’));

mymap.insert(map<int,char>::value_type(5,’F’));

for(iter=mymap.begin();iter!=mymap.end();

iter++){

cout<<(*iter).first<<“

”;

cout<<(*iter).second<<“;”;}//遍历对象mvector

}//输出1->X;2->B;3->E;4->H;5->F;3、对映射进行搜索iter=mymap.find(4);if(iter==mymap.end())cout<<“elementnotfound”<<endl;elsecout<<“element:”<<(*iter).second;//输出：

element:H4、映射成员函数begin():返回指向映射中第一个元素的指示器

clear():删除映射中的所有元素。count(x):返回元素x在映射中出现的次数（0或1）empty():如果映射为空，则返回TRUE。end():返回指向映射中最后一个元素的指示器erase(i):删除指示器i所指的映射元素。erase(x):删除映射元素x。find(x):返回指向x的指示器。如果x不存在，则返回指示器与end（）相等insert(i,x):把值x插入到指示器i指向的元素之前insert(start,end):把指示器start和end所指定范围的值插入到映射中insert(x):把值x插入到映射中size():返回映射的大小（元素的个数）。swap(set):交换2个映射的内容。

max_size():返回映射当前所能容纳的最多元素个数。四、std::multimap多重映射容器std::multimap对象可以使程序按照次序来存储一组数值。每一个元素都与一个查询关键值相关。与映射不同，多重映射可以包含重复的数据值。可以使用下面方法来创建std::multimap对象：std::multimap<key,type,predicate>name;std::multimap<key,type,predicate>name(myset);std::multimap<key,type,predicate>name(first,last);

key参数是在映射中所使用的关键词类型。例如要构造一个整数的空std::map对象：std::multimap<int,int,std::less<int>>name;

std::less<int>默认谓词，不需要再声明中包含std::multimap的使用以及它的操作函数同std::map，这里不再叙述。8.4

通用算法STL提供了很多类型的容器，可以用来操纵不同数据类型的数值。为了能够更方便地操作这些容器的内容，STL提供了一整套通用算法，可以用来做从查找元素到对元素排序的任何事情，要使用这些算法需要包含头文件algorithm。一、非修正序列算法：即算法不修改容器的内容，STL定义了九个非修正序列算法。1、adjacent_find(first,last)返回指向一对邻近相等元素中的第一个元素的指示器。函数搜索指示器first及last所规定的范围。2、count(first,last,val)返回一个序列中具有某个特定值val的元素个数。函数搜索指示器first及last所规定的范围。3、equal(first,last,first2)如果指示器first及last所规定的范围的值与从指示器first2起始相同范围的值相等，函数返回真。4、find(first,last,val)返回指示器first及last所规定的范围里的第一个数值等于val的元素指示器。5、for_each(first,last，func)对范围first、last里的每一个元素执行由函数func所定义的操作。例：for_each函数的使用#include<set>#include<algorithm>voidshow(int

val){cout<<val<<““;}

voidmain(void){multiset<int,less<int>>samp;samp.insert(10);samp.insert(8);samp.insert(3);samp.insert(8);samp.insert(5);samp.insert(8);for_each(samp.begin(),samp.end(),show);}//13588810二、修正序列算法：某些种类的序列操作可能会修改容器的内容，STL修正序列算法提供了这样的操作。1、copy(first,last,first2)把指示器first及last所规定的范围中的元素复制到另一个由指示器first2指向的元素所开始的范围2、copy_backward(first,last,first2)把指示器first及last所规定的范围中的元素复制到另一个由指示器first2指向的元素所开始的范围。但是这个函数是从最后一个元素开始复制由后向前直到第一个元素。3、fill(first,last,val)把数值val赋值到由指示器first及last所规定的范围中的所有元素。4、generate(first,last,func)对每一个元素调用func函数，把函数结果复制到元素中。5、remove(first,last,val)在指示器first及last所规定的范围中删除所有等于val的元素。6、replace(first,last,val1,val2)在指示器first及last所规定的范围中用val2替代所有的val1。7、reverse(first,last)把指示器first及last所规定的范围中元素颠倒排列。8、swap(it1,it2)交换指示器it1和it2里的两个元素。9、unique(first,last)删除指示器first及last所规定的范围中重复的相邻元素。例：generate(first,last,func)使用#include<iostream.h>#include<vector>#include<algorithm>

int

sum(void){staticintm;for(ints=1;s<5;s++)m+=2*s;//m=2+4+6+8returnm;}

voidshow(int

val){cout<<val<<"";}

voidmain(void){usingnamespacestd;vector<int>myvector(6);//定义一个int型myector对象generate(myvector.begin(),myvector.end(),sum);for_each(myvector.begin(),myvector.end(),show);}//输出：20406080100120三、排序算法：STL提供了对容器内容进行排序的许多函数，其中主要的有：1、merge(first,last,first1,last1,result)把first,last规定的序列与first1,last1规定的序列中的元素一起进行排序，结果放到以result开始的序列中。2、partial_sort_copy(first,last,first1,last1)把指示器first及last规定的范围中的元素进行排序，并把排序的结果放到以first1开始到last1结束的序列中，并且不超过last1。3、sort(first,last)顺序排列指示器first及last规定的范围中的元素。例：

partial_sort_copy(first,last,first1,last1)函数#include<iostream>#include<algorithm>#include<vector>voidmain(){usingnamespacestd;vector<int>Numbers(8);vector<int>Result(5);vector<int>::iteratorstart,end,it;

Numbers[0]=4;Num