发信人: netiscpu (沉默是金), 信区: Linux
标 题: STL简介，标准模板库
发信站: 哈工大紫丁香 (Tue May 4 09:41:29 1999), 转信
发信人: xian (我想用心来点亮希望), 信区: Linux
标 题: STL简介，标准模板库
发信站: 紫 丁 香 (Sun May 2 16:21:15 1999), 转信
网络工作室--知识库:编程技术:Unix编程:
STL简介，标准模板库
STL简介，标准模板库
作者：ScottField
这篇文章是关于C++语言的一个新的扩展——标准模板库的（StandardTemplateLibrar
y），也叫STL。
当我第一次打算写一篇关于STL的文章的时候，我不得不承认我当时低估了这个话题的
深度和广度。有很多内容要含盖，也有很多详细描述STL的书。因此我重新考虑了一下
我原来的想法。我为什么要写这篇文章，又为什么要投稿呢？这会有什麽用呢？有再来
一篇关于STL的文章的必要吗？
当我翻开Musserand
Saini的页时，我看到了编程时代在我面前消融。我能看到深夜消失了，目标软件工程
出现了。我看到了可维护的代码。一年过去了，我使用STL写的软件仍然很容易维护。
让人吃惊的是其他人可以没有我而维护的很好！
然而，我也记得在一开始的时候很难弄懂那些技术术语。一次，我买了Musser&Saini，
每件事都依次出现，但是在那以前我最渴望得到的东西是一些好的例子。
当我开始的时候，作为C++一部分的Stroustrup还没出来，它覆盖了STL。
因此我想写一篇关于一个STL程序员的真实生活的文章可能会有用。如果我手上有一些
好的例子的话，特别是象这样的新题目，我会学的更快。
另外一件事是STL应该很好用。因此，理论上说，我们应该可以马上开始使用STL。
什麽是STL呢？STL就是StandardTemplate
Library，标准模板库。这可能是一个历史上最令人兴奋的工具的最无聊的术语。从根
本上说，STL是一些“容器”的集合，这些“容器”有list,vector,set,map等，STL也
是算法和其他一些组件的集合。这里的“容器”和算法的集合指的是世界上很多聪明人
很多年的杰作。
STL的目的是标准化组件，这样你就不用重新开发它们了。你可以仅仅使用这些现成的
组件。STL现在是C++的一部分，因此不用额外安装什麽。它被内建在你的编译器之内。
因为STL的list是一个简单的容器，所以我打算从它开始介绍STL如何使用。如果你懂得
了这个概念，其他的就都没有问题了。另外，list容器是相当简单的，我们会看到这一
点。
这篇文章中我们将会看到如何定义和初始化一个list，计算它的元素的数量，从一个l
ist里查找元素，删除元素，和一些其他的操作。要作到这些，我们将会讨论两个不同
的算法，STL通用算法都是可以操作不止一个容器的，而list的成员函数是list容器专
有的操作。
这是三类主要的STL组件的简明纲要。STL容器可以保存对象，内建对象和类对象。它们
会安全的保存对象，并定义我们能够操作的这个对象的接口。放在蛋架上的鸡蛋不会滚
到桌上。它们很安全。因此，在STL容器中的对象也很安全。我知道这个比喻听起来很
老土，但是它很正确。
STL算法是标准算法，我们可以把它们应用在那些容器中的对象上。这些算法都有很著
名的执行特性。它们可以给对象排序，删除它们，给它们记数，比较，找出特殊的对象
，把它们合并到另一个容器中，以及执行其他有用的操作。
STL
iterator就象是容器中指向对象的指针。STL的算法使用iterator在容器上进行操作。
Iterator设置算法的边界，容器的长度，和其他一些事情。举个例子，有些iterator仅
让算法读元素，有一些让算法写元素，有一些则两者都行。
Iterator也决定在容器中处理的方向。
你可以通过调用容器的成员函数begin()来得到一个指向一个容器起始位置的iterator
。你可以调用一个容器的end()
函数来得到过去的最后一个值（就是处理停在那的那个值）。
这就是STL所有的东西，容器、算法、和允许算法工作在容器中的元素上的iterator。
算法以合适、标准的方法操作对象，并可通过iterator得到容器精确的长度。一旦做了
这些，它们就在也不会“跑出边界”。还有一些其他的对这些核心组件类型有功能性增
强的组件，例如函数对象。我们将会看到有关这些的例子，现在，我们先来看一看STL
的list。
定义一个list
我们可以象这样来定义一个STL的list：
#include<string>
#include<list>
intmain(void){
list<string>Milkshakes;
}
这就行了，你已经定义了一个list。简单吗？list<string>Milkshakes这句是你声明了
list<string>模板类的一个实例，然后就是实例化这个类的一个对象。但是我们别急着
做这个。在这一步其实你只需要知道你定义了一个字符串的list。你需要包含提供STL
list类的头文件。我用gcc2.7.2在我的Linux上编译这个测试程序，例如：
g++test1.cpp-otest1
注意iostream.h这个头文件已经被STL的头文件放弃了。这就是为什么这个例子中没有
它的原因。
现在我们有了一个list，我们可以看实使用它来装东西了。我们将把一个字符串加到这
个list里。有一个非常重要的东西叫做list的值类型。值类型就是list中的对象的类型
。在这个例子中,这个list的值类型就是字符串,string，这是因为这个list用来放字符
串。
I使用list的成员函数push_back和push_front插入一个元素到list中
#include<string>
#include<list>
#
intmain(void){
list<string>Milkshakes;
Milkshakes.push_back("Chocolate");
Milkshakes.push_back("Strawberry");
Milkshakes.push_front("Lime");
Milkshakes.push_front("Vanilla");
}
Wenowhavealistwithfourstringsinit.Thelistmemberfunctionpush_back()
placesanobjectontothebackofthelist.Thelistmemberfunction
push_front()putsoneonthefront.Ioftenpush_back()someerrormessagesonto
alist,andthenpush_front()atitleonthelistsoitprintsbeforetheerror
messages.我们现在有个4个字符串在list中。list的成员函数push_back()把一个对象
放到一个list的后面，而push_front()把对象放到前面。我通常把一些错误信息push_
back()到一个list中去，然后push_front()一个标题到list中，这样它就会在这个错误
消息以前打印它了。
Thelistmemberfunctionempty()list的成员函数empty()
知道一个list是否为空很重要。如果list为空，empty()这个成员函数返回真。我通常
会这样使用它。通篇程序我都用push_back()来把错误消息放到list中去。然后，通过
调用empty()我就可以说出这个程序是否报告了错误。如果我定义了一个list来放信息
，一个放警告，一个放严重错误，我就可以通过使用empty()轻易的说出到底有那种类
型的错误发生了。
我可以整理这些list，然后在打印它们之前，用标题来整理它们，或者把它们排序成类
。这是我的意思：
/*
||Usingalisttotrackandreportprogrammessagesandstatus
*/
#include<iostream.h>
#include<string>
#include<list>
#
intmain(void){
#defineOK0
#defineINFO1
#defineWARNING2
#
intreturn_code;
#
list<string>InfoMessages;
list<:string>WarningMessages;
#
//duringaprogramthesemessagesareloadedatvariouspoints
InfoMessages.push_back("Info:Programstarted");
//dowork...
WarningMessages.push_back("Warning:NoCustomerrecordshavebeenfound");
//dowork...
#
return_code=OK;
#
if(!InfoMessages.empty()){//therewereinfomessages
InfoMessages.push_front("InformationalMessages:");
//...printtheinfomessageslist,we'llseehowlater
return_code=INFO;
}
#
if(!WarningMessages.empty()){//therewerewarningmessages
WarningMessages.push_front("WarningMessages:");
//...printthewarningmessageslist,we'llseehowlater
return_code=WARNING;
}
#
//Iftherewerenomessagessayso.
if(InfoMessages.empty()&&WarningMessages.empty()){
cout<<"Therewerenomessages"<<endl;
}
#
returnreturn_code;
}
用for循环来处理list中的元素
我们想要遍历一个list，比如打印一个中的所有对象来看看list上不同操作的结果。要
一个元素一个元素的遍历一个list，我们可以这样做：
/*
||HowtoprintthecontentsofasimpleSTLlist.Whew!
*/
#include<iostream.h>
#include<string>
#include<list>
#
intmain(void){
list<string>Milkshakes;
list<string>::iteratorMilkshakeIterator;
#
Milkshakes.push_back("Chocolate");
Milkshakes.push_back("Strawberry");
Milkshakes.push_front("Lime");
Milkshakes.push_front("Vanilla");
#
//printthemilkshakes
Milkshakes.push_front("TheMilkshakeMenu");
Milkshakes.push_back("***Thatstheend***");
for(MilkshakeIterator=Milkshakes.begin();
MilkshakeIterator!=Milkshakes.end();
++MilkshakeIterator){
//dereferencetheiteratortogettheelement
cout<<*MilkshakeIterator<<endl;
}
}
这个程序定义了一个iterator，MilkshakeIterator。我们把它指向了这个list的第一
个元素。这可以调用Milkshakes.begin()来作到，它会返回一个指向list开头的itera
tor。然后我们把它和Milkshakes.end()的返回值来做比较，当我们到了那儿的时候就
停下来。
容器的end()函数会返回一个指向容器的最后一个位置的iterator。当我们到了那里，
就停止操作。我们不能不理容器的end()函数的返回值。我们仅知道它意味着已经处理
到了这个容器的末尾，应该停止处理了。所有的STL容器都要这样做。
在上面的例子中，每一次执行for循环，我们就重复引用iterator来得到我们打印的字
符串。
在STL编程中，我们在每个算法中都使用一个或多个iterator。我们使用它们来存取容
器中的对象。要存取一个给定的对象，我们把一个iterator指向它，然后间接引用这个
iterator。
这个list容器，就象你所想的，它不支持在iterator加一个数来指向隔一个的对象。就
是说，我们不能用Milkshakes.begin()+2来指向list中的第三个对象，因为STL的list
是以双链的list来实现的，它不支持随机存取。vector和deque(向量和双端队列)和一
些其他的STL的容器可以支持随机存取。
上面的程序打印出了list中的内容。任何人读了它都能马上明白它是怎麽工作的。它使
用标准的iterator和标准的list容器。没有多少程序员依赖它里面装的东西，
仅仅是标准的C++。这是一个向前的重要步骤。这个例子使用STL使我们的软件更加标准
。
用STL的通用算法for_each来处理list中的元素
使用STLlist和iterator，我们要初始化、比较和给iterator增量来遍历这个容器。ST
L通用的for_each算法能够减轻我们的工作。
/*
||HowtoprintasimpleSTLlistMkII
*/
#include<iostream.h>
#include<string>
#include<list>
#include<algorithm>
#
PrintIt(string&StringToPrint){
cout<<StringToPrint<<endl;
}
#
intmain(void){
list<string>FruitAndVegetables;
FruitAndVegetables.push_back("carrot");
FruitAndVegetables.push_back("pumpkin");
FruitAndVegetables.push_back("potato");
FruitAndVegetables.push_front("apple");
FruitAndVegetables.push_front("pineapple");
#
for_each(FruitAndVegetables.begin(),FruitAndVegetables.end(),PrintIt);
}
在这个程序中我们使用STL的通用算法for_each()来遍历一个iterator的范围，然后调
用PrintIt()来处理每个对象。我们不需要初始化、比较和给iterator增量。for_each
()为我们漂亮的完成了这些工作。我们执行于对象上的操作被很好的打包在这个函数以
外了，我们不用再做那样的循环了，我们的代码更加清晰了。
for_each算法引用了iterator范围的概念，这是一个由起始iterator和一个末尾itera
tor指出的范围。起始iterator指出操作由哪里开始，末尾iterator指明到哪结束，但
是它不包括在这个范围内。
用STL的通用算法count()来统计list中的元素个数。
STL的通用算法count()和count_it()用来给容器中的对象记数。就象for_each()一样，
count()和count_if()算法也是在iterator范围内来做的。
让我们在一个学生测验成绩的list中来数一数满分的个数。这是一个整型的List。
/*
||HowtocountobjectsinanSTLlist
*/
#include<list>
#include<algorithm>
#
intmain(void){
list<int>Scores;
#
Scores.push_back(100);Scores.push_back(80);
Scores.push_back(45);Scores.push_back(75);
Scores.push_back(99);Scores.push_back(100);
#
intNumberOf100Scores(0);
count(Scores.begin(),Scores.end(),100,NumberOf100Scores);
#
cout<<"Therewere"<<NumberOf100Scores<<"scoresof100"<<endl;
}
Thecount()algorithmcountsthenumberofobjectsequaltoacertainvalue.In
theaboveexampleitcheckseachintegerobjectinalistagainst100.It
incrementsthevariableNumberOf100Scoreseachtimeacontainerobjectequals
100.Theoutputoftheprogramis
count()算法统计等于某个值的对象的个数。上面的例子它检查list中的每个整型对象
是不是100。每次容器中的对象等于100，它就给NumberOf100Scores加1。这是程序的输
出：
Therewere2scoresof100
用STL的通用算法count_if()来统计list中的元素个数
count_if()是count()的一个更有趣的版本。他采用了STL的一个新组件，函数对象。c
ount_if()带一个函数对象的参数。函数对象是一个至少带有一个operator()方法的类
。有些STL算法作为参数接收函数对象并调用这个函数对象的operator()方法。
函数对象被约定为STL算法调用operator时返回true或false。它们根据这个来判定这个
函数。举个例子会说的更清楚些。count_if()通过传递一个函数对象来作出比count()
更加复杂的评估以确定一个对象是否应该被记数。在这个例子里我们将数一数牙刷的销
售数量。我们将提交包含四个字符的销售码和产品说明的销售记录。
/*
||Usingafunctionobjecttohelpcountthings
*/
#include<string>
#include<list>
#include<algorithm>
#
conststringToothbrushCode("0003");
#
classIsAToothbrush{
public:
booloperator()(string&SalesRecord){
returnSalesRecord.substr(0,4)==ToothbrushCode;
}
};
#
intmain(void){
list<string>SalesRecords;
#
SalesRecords.push_back("0001Soap");
SalesRecords.push_back("0002Shampoo");
SalesRecords.push_back("0003Toothbrush");
SalesRecords.push_back("0004Toothpaste");
SalesRecords.push_back("0003Toothbrush");
#
intNumberOfToothbrushes(0);
count_if(SalesRecords.begin(),SalesRecords.end(),
IsAToothbrush(),NumberOfToothbrushes);
#
cout<<"Therewere"
<<NumberOfToothbrushes
<<"toothbrushessold"<<endl;
}
这是这个程序的输出：
Therewere2toothbrushessold（一共卖了两把牙刷）
这个程序是这样工作的：定义一个函数对象类IsAToothbrush，这个类的对象能判断出
卖出的是否是牙刷。如果这个记录是卖出牙刷的记录的话，函数调用operator()返回一
个true，否则返回false。
count_if()算法由第一和第二两个iterator参数指出的范围来处理容器对象。它将对每
个IsAToothbrush()返回true的容器中的对象增加NumberOfToothbrushes的值。
最后的结果是NumberOfToothbrushes这个变量保存了产品代码域为"0003"的记录的个数
，也就是牙刷的个数。
注意count_if()的第三个参数IsAToothbrush()，它是由它的构造函数临时构造的一个
对象。你可以把IsAToothbrush类的一个临时对象传递给count_if()函数。count_if()
将对该容器的每个对象调用这个函数。
使用count_if()的一个更加复杂的函数对象。
我们可以更进一步的研究一下函数对象。假设我们需要传递更多的信息给一个函数对象
。我们不能通过调用operator来作到这点，因为必须定义为一个list的中的对象的类型
。然而我们通过为IsAToothbrush指出一个非缺省的构造函数就可以用任何我们所需要
的信息来初始化它了。例如，我们可能需要每个牙刷有一个不定的代码。我们可以把这
个信息加到下面的函数对象中：
/*
||Usingamorecomplexfunctionobject
*/
#include<iostream.h>
#include<string>
#include<list>
#include<algorithm>
#
classIsAToothbrush{
public:
IsAToothbrush(string&InToothbrushCode):
ToothbrushCode(InToothbrushCode){}
booloperator()(string&SalesRecord){
returnSalesRecord.substr(0,4)==ToothbrushCode;
}
private:
stringToothbrushCode;
};
#
intmain(void){
list<string>SalesRecords;
#
SalesRecords.push_back("0001Soap");
SalesRecords.push_back("0002Shampoo");
SalesRecords.push_back("0003Toothbrush");
SalesRecords.push_back("0004Toothpaste");
SalesRecords.push_back("0003Toothbrush");
#
stringVariableToothbrushCode("0003");
#
intNumberOfToothbrushes(0);
count_if(SalesRecords.begin(),SalesRecords.end(),
IsAToothbrush(VariableToothbrushCode),
NumberOfToothbrushes);
cout<<"Therewere"
<<NumberOfToothbrushes
<<"toothbrushesmatchingcode"
<<VariableToothbrushCode
<<"sold"
<<endl;
}
程序的输出是：
Therewere2toothbrushesmatchingcode0003sold
这个例子演示了如何向函数对象传递信息。你可以定义任意你想要的构造函数，你可以
再函数对象中做任何你想做的处理，都可以合法编译通过。
你可以看到函数对象真的扩展了基本记数算法。
到现在为止，我们都学习了：
定义一个list
向list中加入元素
如何知道list是否为空
如何使用for循环来遍历一个list
如何使用STL的通用算法for_each来遍历list
list成员函数begin()和end()以及它们的意义
iterator范围的概念和一个范围的最后一个位置实际上并不被处理这一事实
如何使用STL通用算法count()和count_if()来对一个list中的对象记数
如何定义一个函数对象
我选用这些例子来演示list的一般操作。如果你懂了这些基本原理，你就可以毫无疑问
的使用STL了建议你作一些练习。我们现在用一些更加复杂的操作来扩展我们的知识，
包括list成员函数和STL通用算法。
使用STL通用算法find()在list中查找对象
我们如何在list中查找东西呢？STL的通用算法find()和find_if()可以做这些。就象f
or_each(),count(),count_if()
一样，这些算法也使用iterator范围，这个范围指出一个list或任意其他容器中的一部
分来处理。通常首iterator指着开始的位置，次iterator指着停止处理的地方。由次i
terator指出的元素不被处理。
这是find()如何工作：
/*
||HowtofindthingsinanSTLlist
*/
#include<string>
#include<list>
#include<algorithm>
#
intmain(void){
list<string>Fruit;
list<string>::iteratorFruitIterator;
#
Fruit.push_back("Apple");
Fruit.push_back("Pineapple");
Fruit.push_back("StarApple");
#
FruitIterator=find(Fruit.begin(),Fruit.end(),"Pineapple");
#
if(FruitIterator==Fruit.end()){
cout<<"Fruitnotfoundinlist"<<endl;
}
else{
cout<<*FruitIterator<<endl;
}
}
输出是：
Pineapple
如果没有找到指出的对象，就会返回Fruit.end()的值，要是找到了就返回一个指着找
到的对象的iterator
使用STL通用算法find_if()在list中搜索对象
这是find()的一个更强大的版本。这个例子演示了find_if()，它接收一个函数对象的
参数作为参数，并使用它来做更复杂的评价对象是否和给出的查找条件相付。
假设我们的list中有一些按年代排列的包含了事件和日期的记录。我们希望找出发生在
1997年的事件。
/*
||HowtofindthingsinanSTLlistMkII
*/
#include<string>
#include<list>
#include<algorithm>
#
classEventIsIn1997{
public:
booloperator()(string&EventRecord){
//yearfieldisatposition12for4charactersinEventRecord
returnEventRecord.substr(12,4)=="1997";
}
};
#
intmain(void){
list<string>Events;
#
//stringpositions0123456789012345678901234567890123456789012345
Events.push_back("07January1995Draftplanofhouseprepared");
Events.push_back("07February1996Detailedplanofhouseprepared");
Events.push_back("10January1997Clientagreestojob");
Events.push_back("15January1997Builderstartsworkonbedroom");
Events.push_back("30April1997Builderfinisheswork");
#
list<string>::iteratorEventIterator=
find_if(Events.begin(),Events.end(),EventIsIn1997());
#
//find_ifcompletesthefirsttimeEventIsIn1997()()returnstrue
//foranyobject.Itreturnsaniteratortothatobjectwhichwe
//candereferencetogettheobject,orifEventIsIn1997()()never
//returnedtrue,find_ifreturnsend()
if(EventIterator==Events.end()){
cout<<"Eventnotfoundinlist"<<endl;
}
else{
cout<<*EventIterator<<endl;
}
}
这是程序的输出：
10January1997Clientagreestojob
使用STL通用算法search在list中找一个序列
一些字符在STL容器中很好处理，让我们看一看一个难处理的字符序列。我们将定义一
个list来放字符。list<char>Characters;
现在我们有了一个字符序列，它不用任何帮助就知道然后管理内存。它知道它是从哪里
开始、到哪里结束。它非常有用。我不知道我是否说过以null结尾的字符数组。
让我们加入一些我们喜欢的字符到这个list中：
Characters.push_back('\0');
Characters.push_back('\0');
Characters.push_back('1');
Characters.push_back('2');
我们将得到多少个空字符呢？
intNumberOfNullCharacters(0);
count(Characters.begin(),Characters.end(),'\0',NumberOfNullCharacters);
cout<<"Wehave"<<NumberOfNullCharacters<<endl;
让我们找字符'1'
list<char>::iteratorIter;
Iter=find(Characters.begin(),Characters.end(),'1');
cout<<"Wefound"<<*Iter<<endl;
这个例子演示了STL容器允许你以更标准的方法来处理空字符。现在让我们用STL的sea
rch算法来搜索容器中的两个null。
就象你猜的一样，STL通用算法search()用来搜索一个容器，但是是搜索一个元素串，
不象find()和find_if()只搜索单个的元素。
/*
||HowtousethesearchalgorithminanSTLlist
*/
#include<string>
#include<list>
#include<algorithm>
#
intmain(void){
#
list<char>TargetCharacters;
list<char>ListOfCharacters;
#
TargetCharacters.push_back('\0');
TargetCharacters.push_back('\0');
#
ListOfCharacters.push_back('1');
ListOfCharacters.push_back('2');
ListOfCharacters.push_back('\0');
ListOfCharacters.push_back('\0');
#
list<char>::iteratorPositionOfNulls=
search(ListOfCharacters.begin(),ListOfCharacters.end(),
TargetCharacters.begin(),TargetCharacters.end());
#
if(PositionOfNulls!=ListOfCharacters.end())
cout<<"Wefoundthenulls"<<endl;
}
Theoutputoftheprogramwillbe这是程序的输出：
Wefoundthenulls
search算法在一个序列中找另一个序列的第一次出现的位置。在这个例子里我们在Lis
tOfCharacters中找TargetCharacters这个序列的第一次出现，TargetCharacters是包
含两个null字符的序列。
search的参数是两个指着查找目标的iterator和两个指着搜索范围的iterators。因此
我们我们在整个的ListOfCharacters的范围内查找TargetCharacters这个list的整个序
列。
如果TargetCharacters被发现，search就会返回一个指着ListOfCharacters中序列匹配
的第一个字符的iterator。如果没有找到匹配项，search返回ListOfCharacters.end(
)的值。
使用list的成员函数sort()排序一个list。
要排序一个list，我们要用list的成员函数sort()，而不是通用算法sort()。所有我们
用过的算法都是通用算法。然而，在STL中有时容器支持它自己对一个特殊算法的实现
，这通常是为了提高性能。
在这个例子中，list容器有它自己的sort算法，这是因为通用算法仅能为那些提供随机
存取里面元素的容器排序，而由于list是作为一个连接的链表实现的，它不支持对它里
面的元素随机存取。所以就需要一个特殊的sort()成员函数来排序list。
由于各种原因，容器在性能需要较高或有特殊效果需求的场合支持外部函数(extrafun
ctions)，这通过利用构造函数的结构特性可以作到。
/*
||HowtosortanSTLlist
*/
#include<string>
#include<list>
#include<algorithm>
#
PrintIt(string&StringToPrint){cout<<StringToPrint<<endl;}
#
intmain(void){
list<string>Staff;
list<string>::iteratorPeopleIterator;
#
Staff.push_back("John");
Staff.push_back("Bill");
Staff.push_back("Tony");
Staff.push_back("Fidel");
Staff.push_back("Nelson");
#
cout<<"Theunsortedlist"<<endl;
for_each(Staff.begin(),Staff.end(),PrintIt);
#
Staff.sort();
#
cout<<"Thesortedlist"<<endl;
for_each(Staff.begin(),Staff.end(),PrintIt);
}
输出是：
Theunsortedlist
John
Bill
Tony
Fidel
Nelson
Thesortedlist
Bill
Fidel
John
Nelson
Tony
用list的成员函数插入元素到list中
list的成员函数push_front()和push_back()分别把元素加入到list的前面和后面。你
可以使用insert()把对象插入到list中的任何地方。
insert()可以加入一个对象，一个对象的若干份拷贝，或者一个范围以内的对象。这里
是一些插入对象到list中的例子：
/*
||Usinginserttoinsertelementsintoalist.
*/
#include<list>
#
intmain(void){
list<int>list1;
#
/*
||Putintegers0to9inthelist
*/
for(inti=0;i<10;++i)list1.push_back(i);
#
/*
||Insert-1usingtheinsertmemberfunction
||Ourlistwillcontain-1,0,1,2,3,4,5,6,7,8,9
*/
list1.insert(list1.begin(),-1);
#
/*
||Insertanelementattheendusinginsert
||Ourlistwillcontain-1,0,1,2,3,4,5,6,7,8,9,10
*/
list1.insert(list1.end(),10);
#
/*
||Insertingarangefromanothercontainer
||Ourlistwillcontain-1,0,1,2,3,4,5,6,7,8,9,10,11,12
*/
intIntArray[2]={11,12};
list1.insert(list1.end(),&IntArray[0],&IntArray[2]);
#
/*
||Asanexerciseputthecodeinheretoprintthelists!
||Hint:usePrintItandacceptaninterger
*/
}
注意，insert()函数把一个或若干个元素插入到你指出的iterator的位置。你的元素将
出现在iterator指出的位置以前。
List构造函数
我们已经象这样定义了list：
list<int>Fred;
你也可以象这样定义一个list，并同时初始化它的元素：
//definealistof10elementsandinitialisethemallto0
list<int>Fred(10,0);
//listnowcontains0,0,0,0,0,0,0,0,0,0
或者你可以定义一个list并用另一个STL容器的一个范围来初始化它，这个STL容器不一
定是一个list，仅仅需要是元素类型相同的的容器就可以。
vector<int>Harry;
Harry.push_back(1);
Harry.push_back(2);
#
//definealistandinitialiseitwiththeelementsinHarry
list<int>Bill(Harry.begin(),Harry.end());
//Billnowcontains1,2
使用list成员函数从list中删除元素
list成员函数pop_front()删掉list中的第一个元素，pop_back()删掉最后一个元素。
函数erase()删掉由一个iterator指出的元素。还有另一个erase()函数可以删掉一个范
围的元素。
/*
||Erasingobjectsfromalist
*/
#include<list>
#
intmain(void){
list<int>list1;//definealistofintegers
#
/*
||Putsomenumbersinthelist
||Itnowcontains0,1,2,3,4,5,6,7,8,9
*/
for(inti=0;i<10;++i)list1.push_back(i);
#
list1.pop_front();//erasethefirstelement0
#
list1.pop_back();//erasethelastelement9
#
list1.erase(list1.begin());//erasethefirstelement(1)usinganiterator
#
list1.erase(list1.begin(),list1.end());//erasealltheremainingelements
#
cout<<"listcontains"<<list1.size()<<"elements"<<endl;
}
输出是：
listcontains0elements
用list成员函数remove()从list中删除元素。
list的成员函数remove()用来从list中删除元素。
/*
||Usingthelistmemberfunctionremovetoremoveelements
*/
#include<string>
#include<list>
#include<algorithm>
#
PrintIt(conststring&StringToPrint){
cout<<StringToPrint<<endl;
}
#
intmain(void){
list<string>Birds;
#
Birds.push_back("cockatoo");
Birds.push_back("galah");
Birds.push_back("cockatoo");
Birds.push_back("rosella");
Birds.push_back("corella");
#
cout<<"Originallistwithcockatoos"<<endl;
for_each(Birds.begin(),Birds.end(),PrintIt);
#
Birds.remove("cockatoo");
#
cout<<"Nownocockatoos"<<endl;
for_each(Birds.begin(),Birds.end(),PrintIt);
}
输出是：
Originallistwithcockatoos
cockatoo
galah
cockatoo
rosella
corella
Nownocockatoos
galah
rosella
corella
使用STL通用算法remove()从list中删除元素
通用算法remove()使用和list的成员函数不同的方式工作。一般情况下不改变容器的大
小。
/*
||Usingthegenericremovealgorithmtoremovelistelements
*/
#include<string>
#include<list>
#include<algorithm>
#
PrintIt(string&AString){cout<<AString<<endl;}
#
intmain(void){
list<string>Birds;
list<string>::iteratorNewEnd;
#
Birds.push_back("cockatoo");
Birds.push_back("galah");
Birds.push_back("cockatoo");
Birds.push_back("rosella");
Birds.push_back("kingparrot");
#
cout<<"Originallist"<<endl;
for_each(Birds.begin(),Birds.end(),PrintIt);
#
NewEnd=remove(Birds.begin(),Birds.end(),"cockatoo");
#
cout<<endl<<"Listaccordingtonewpasttheenditerator"<<endl;
for_each(Birds.begin(),NewEnd,PrintIt);
#
cout<<endl<<"Originallistnow.Carerequired!"<<endl;
for_each(Birds.begin(),Birds.end(),PrintIt);
}
Theoutputwillbe
Originallist
cockatoo
galah
cockatoo
rosella
kingparrot
Listaccordingtonewpasttheenditerator
galah
rosella
kingparrot
Originallistnow.Carerequired!
galah
rosella
kingparrot
rosella
kingparrot
通用remove()算法返回一个指向新的list的结尾的iterator。从开始到这个新的结尾（
不含新结尾元素）的范围包含了remove后剩下所有元素。你可以用list成员函数erase
函数来删除从新结尾到老结尾的部分。
使用STL通用算法stable_partition()和list成员函数splice()来划分一个list
我们将完成一个稍微有点复杂的例子。它演示STL通用算法stable_partition()算法和
一个list成员函数splice()的变化。注意函数对象的使用和没有使用循环。通过简单的
语句调用STL算法来控制。stable_partition()是一个有趣的函数。它重新排列元素，
使得满足指定条件的元素排在不满足条件的元素前面。它维持着两组元素的顺序关系。
splice把另一个list中的元素结合到一个list中。它从源list中删除元素。
在这个例子中，我们想从命令行接收一些标志和四个文件名。文件名必须’按顺序出现
。通过使用stable_partition()
我们可以接收和文件名混为任何位置的标志，并且不打乱文件名的顺序就把它们放到一
起。由于记数和查找算法都很易用，我们调用这些算法来决定哪个标志被设置而哪个标
志未被设置。我发现容器用来管理少量的象这样的动态数据。
/*
||UsingtheSTLstable_partitionalgorithm
||Takesanynumberofflagsonthecommandlineand
||fourfilenamesinorder.
*/
#include<string>
#include<list>
#include<algorithm>
#
PrintIt(string&AString){cout<<AString<<endl;}
#
classIsAFlag{
public:
booloperator()(string&PossibleFlag){
returnPossibleFlag.substr(0,1)=="-";
}
};
#
classIsAFileName{
public:
booloperator()(string&StringToCheck){
return!IsAFlag()(StringToCheck);
}
};
#
classIsHelpFlag{
public:
booloperator()(string&PossibleHelpFlag){
returnPossibleHelpFlag=="-h";
}
};
#
intmain(intargc,char*argv[]){
#
list<string>CmdLineParameters;//thecommandlineparameters
list<string>::iteratorStartOfFiles;//startoffilenames
list<string>Flags;//listofflags
list<string>FileNames;//listoffilenames
#
for(inti=0;i<argc;++i)CmdLineParameters.push_back(argv[i]);
#
CmdLineParameters.pop_front();//wedon'twanttheprogramname
#
//makesurewehavethefourmandatoryfilenames
intNumberOfFiles(0);
count_if(CmdLineParameters.begin(),CmdLineParameters.end(),
IsAFileName(),NumberOfFiles);
#
cout<<"The"
<<(NumberOfFiles==4?"correct":"wrong")
<<"number("
<<NumberOfFiles
<<")offilenameswerespecified"<<endl;
#
//moveanyflagstothebeginning
StartOfFiles=
stable_partition(CmdLineParameters.begin(),CmdLineParameters.end(),
IsAFlag());
#
cout<<"Commandlineparametersafterstablepartition"<<endl;
for_each(CmdLineParameters.begin(),CmdLineParameters.end(),PrintIt);
#
//SpliceanyflagsfromtheoriginalCmdLineParameterslistintoFlagslist.
Flags.splice(Flags.begin(),CmdLineParameters,
CmdLineParameters.begin(),StartOfFiles);
#
if(!Flags.empty()){
cout<<"Flagsspecifiedwere:"<<endl;
for_each(Flags.begin(),Flags.end(),PrintIt);
}
else{
cout<<"Noflagswerespecified"<<endl;
}
#
//parameterslistnowcontainsonlyfilenames.SplicethemintoFileNameslist.
FileNames.splice(FileNames.begin(),CmdLineParameters,
CmdLineParameters.begin(),CmdLineParameters.end());
#
if(!FileNames.empty()){
cout<<"Filesspecified(inorder)were:"<<endl;
for_each(FileNames.begin(),FileNames.end(),PrintIt);
}
else{
cout<<"Nofileswerespecified"<<endl;
}
#
//checkifthehelpflagwasspecified
if(find_if(Flags.begin(),Flags.end(),IsHelpFlag())!=Flags.end()){
cout<<"Thehelpflagwasspecified"<<endl;
}
#
//openthefilesanddowhateveryoudo
#
}
给出这样的命令行：
test17-wlinux-ois-wgreat
输出是：
Thewrongnumber(3)offilenameswerespecified
Commandlineparametersafterstablepartition
-w
-o
-w
linux
is
great
Flagsspecifiedwere:
-w
-o
-w
Filesspecified(inorder)were:
linux
is
great
结论
我们仅仅简单的谈了谈你可以用list做的事情。我们没有说明一个对象的用户定义类，
虽然这个不难。如果你懂了刚才说的这些算法背后的概念，那么你使用剩下的那些算法
就应该没有问题了。使用STL最重要的东西就是得到基本理论。
STL的关键实际上是iterator。STL算法作为参数使用iterato
admin@studio.openunix.org
他们指出一个范围，有时是一个范围，有时是两
个。STL容器支持iterator，这就是为什么我们说
list<int>::iterator,或list<char>::iterator,或list<string>::iterator.
iterator有很好的定义继承性。它们非常有用。某些iterator仅支持对一个容器只读，
某些仅支持写，还有一些仅能向前指，有一些是双向的。有一些iterator支持对一个容
器的随机存取。
STL算法需要某个iterator作为“动力”如果一个容器不提供iterator作为“动力”，
那么这个算法将无法编译。例如，list容器仅提供双向的
iterator。通常的sort()算法需要随机存取的iterator。这就是为什么我们需要一个特
别的list成员函数sort()。
要合适的实际使用STL，你需要仔细学习各种不同的iterator。你需要知道每种容器都
支持那类iterator。你还需要知道算法需要那种iterator，你当然也需要懂得你可以有
那种iterator。
在field中使用STL
去年，我曾用STL写过几个商业程序。它在很多方面减少了我的工作量，也排除了很多
逻辑错误。
最大的一个程序有大约5000行。可能最惊人的事情就是它的速度。它读入并处理一个1
-2兆的报告文件仅花大约20秒。我是在linux上用gcc2.7.2开发的，现在运行在HP-UX机
器上。它一共用了大约50和函数对象和很多容器，这些容器的大小从小list到一个有1
4,000个元素的map都有。
一个程序中的函数对象是处于一个继承树中，顶层的函数对象调用低层的函数对象。我
大量的使用STL算法for_each()
,find(),find_if(),count()和count_if()，我尽量减少使用程序内部的函数，而使用
STL的算法调用。STL倾向于自动的把代码组织成清晰的控制和支持模块。通过小心使用
函数对象并给它们起有意义的名字，我使它们在我的软件的控制流中流动。
还有很多关于STL编程要知道的东西，我希望你通过这些例子可以愉快的工作。
参考数目中的两本书在web上都有勘误表，你可以自己改正它们。
Stroustrup在每一章后面都有个建议栏，特别是对于出学者有用。正本书比早期的版本
更加健谈。它也更大了。书店里还可以找到其他几本关于STL的教科书。去看看，也许
你能发现什么。
参考书目
TheSTLTutorialandReferenceGuide,DavidMusserandAtulSaini.Addison
Wesley1996.《STL教程和参考手册》
TheC++ProgrammingLanguage3e,BjarneStroustrup.AddisonWesley1997.
admin@studio.openunix.org
--
※ 来源:．紫 丁 香 bbs.hit.edu.cn．[FROM: 202.118.239.115]
--
※ 转寄:．紫 丁 香 bbs.hit.edu.cn．[FROM: dns.mtlab.hit.ed]
--
☆ 来源:．哈工大紫丁香 bbs.hit.edu.cn．[FROM: bin@mtlab.hit.edu.cn]