C++ STL轻松导学

　　 

---

　　做为C++标准不可缺乏的一部分，STL应该是渗透在C++程序的角角落落里的。STL不是实验室里的宠儿，也不是程序员桌上的摆设，她的激动人心并不是昙花一现。本教程旨在传播和普及STL的基础知识，若能借此机会为STL的推广作些力所能及的事情，到也是件让人愉快的事情。

---

1 初识STL：解答一些疑问

1.1 一个最关心的问题：什么是STL

　　"什么是STL？"，假如你对STL还知之甚少，那么我想，你必定很想知道这个问题的答案，坦率地讲，要期望用短短数言将这个问题阐述清楚，也决非易事。所以，若是你在看完本节以后仍是以为似懂非懂，大可没必要着急，在阅读了后续内容以后，相信你对STL的认识，将会越发清晰、准确和完整。不过，上述这番话听起来是否有点像是在为本身糟糕的表达能力开脱罪责呢？

　　不知道你是否有过这样的经历。在你准备着手完成数据结构老师所布置的家庭做业时，或者在你为你所负责的某个软件项目中添加一项新功能时，你发现须要用到一个链表(List)或者是映射表（Map）之类的东西，可是手头并无现成的代码。因而在你开始正式考虑程序功能以前，手工实现List或者Map是不可避免的。因而……，最终你顺利完成了任务。或许此时，做为一个具备较高素养的程序员的你还不愿罢休（或者是一个喜欢偷懒的优等生:），由于你会想到，若是之后还遇到这样的状况怎么办？没有必要再作一遍一样的事情吧！

　　若是说上述这种情形天天都在发生，或许有点夸张。可是，若是说整个软件领域里，数十年来确实都在为了一个目标而奋斗--可复用性（reusability），这看起来彷佛并不夸张。从最先的面向过程的函数库，到面向对象的程序设计思想，到各类组件技术（如：COM、EJB），到设计模式（design pattern）等等。而STL也在作着相似的事情，同时在它背后蕴涵着一种新的程序设计思想--泛型化设计（generic programming）。

　　继续上面提到的那个例子，假如你把List或者map无缺的保留了下来，正在暗自得意。且慢，若是下一回的List里放的不是浮点数而是整数呢？若是你所实现的Map在效率上老是令你不太满意而且有时还会出些bug呢？你该如何面对这些问题？使用STL是一个不错的选择，确实如此，STL能够漂亮地解决上面提到的这些问题，尽管你还能够寻求其余方法。

说了半天，到底STL是什么东西呢？

　　STL（Standard Template Library），即标准模板库，是一个具备工业强度的，高效的C++程序库。它被容纳于C++标准程序库（C++ Standard Library）中，是ANSI/ISO C++标准中最新的也是极具革命性的一部分。该库包含了诸多在计算机科学领域里所经常使用的基本数据结构和基本算法。为广大C++程序员们提供了一个可扩展的应用框架，高度体现了软件的可复用性。这种现象有些相似于Microsoft Visual C++中的MFC（Microsoft Foundation Class Library），或者是Borland C++ Builder中的VCL(Visual Component Library)，对于此两者，你们必定不会陌生吧。

　　从逻辑层次来看，在STL中体现了泛型化程序设计的思想（generic programming），引入了诸多新的名词，好比像需求（requirements），概念（concept），模型（model），容器（container），算法（algorithmn），迭代子（iterator）等。与OOP（object-oriented programming）中的多态（polymorphism）同样，泛型也是一种软件的复用技术。

　　从实现层次看，整个STL是以一种类型参数化（type parameterized）的方式实现的，这种方式基于一个在早先C++标准中没有出现的语言特性--模板（template）。若是查阅任何一个版本的STL源代码，你就会发现，模板做为构成整个STL的基石是一件千真万确的事情。除此以外，还有许多C++的新特性为STL的实现提供了方便。

　　不知你对这里一会儿冒出这么多术语作何感想，但愿不会另你不愉快。假如你对它们之中的大多数不甚了解，敬请放心，在后续内容中将会对这些名词逐一论述。正如开头所提到的。

　　有趣的是，对于STL还有另一种解释--STepanov & Lee，前者是指Alexander Stepanov，STL的创始人；然后者是Meng Lee，她也是使STL得以推行的功臣，第一个STL成品就是他们合做完成的。这一提法源自1995年3月，Dr.Dobb's Journal特约记者, 著名技术书籍做家Al Stevens对Alexander Stepanov的一篇专访。

1.2 追根溯源：STL的历史

　　在结识新朋友的时候，大多数人老是忍不住想了解对方的过去。本节将带您简单回顾一下STL的过去。

　　被誉为STL之父的Alexander Stepanov，出生于苏联莫斯科，早在20世纪70年代后半期，他便已经开始考虑，在保证效率的前提下，将算法从诸多具体应用之中抽象出来的可能性，这即是后来泛型化思想的雏形。为了验证本身的思想，他和纽约州立大学教授Deepak Kapur，伦塞里尔技术学院教授David Musser共同开发了一种叫作Tecton的语言。尽管此次尝试最终没有取得实用性的成果，但却给了Stepanov很大的启示。

　　在随后的几年中，他又和David Musser等人前后用Schema语言（一种Lisp语言的变种）和Ada语言创建了一些大型程序库。这其间，Alexander Stepanov开始意识到，在当时的面向对象程序设计思想中所存在的一些问题，好比抽象数据类型概念所存在的缺陷。Stepanov但愿经过对软件领域中各组成部分的分类，逐渐造成一种软件设计的概念性框架。

　　1987年左右，在贝尔实验室工做的Alexander Stepanov开始首次采用C++语言进行泛型软件库的研究。但遗憾的是，当时的C++语言尚未引入模板（template）的语法，如今咱们能够清楚的看到，模板概念之于STL实现，是何等重要。是时使然，采用继承机制是别无选择的。尽管如此，Stepanov仍是开发出了一个庞大的算法库。与此同时，在与Andrew Koenig（前ISO C++标准化委员会主席）和Bjarne Stroustrup（C++语言的创始人）等顶级大师们的共事过程当中，Stepanov开始注意到C/C++语言在实现其泛型思想方面所具备的潜在优点。就拿C/C++中的指针而言，它的灵活与高效运用，使后来的STL在实现泛型化的同时更是保持了高效率。另外，在STL中占据极其重要地位的迭代子概念即是源自于C/C++中原生指针（ native pointer）的抽象。

　　1988年，Alexander Stepanov开始进入惠普的Palo Alto实验室工做，在随后的4年中，他从事的是有关磁盘驱动器方面的工做。直到1992年，因为参加并主持了实验室主任Bill Worley所创建的一个有关算法的研究项目，才使他从新回到了泛型化算法的研究工做上来。项目自创建以后，参与者从最初的8人逐渐减小，最后只剩下两我的--Stepanove本人和Meng Lee。通过长时间的努力，最终，信念与汗水所换来的是一个包含有大量数据结构和算法部件的庞大运行库。这即是如今的STL的雏形（同时也是STL的一个实现版本--HP STL）。

　　1993年，当时在贝尔实验室的Andrew Koenig看到了Stepanove的研究成果，非常兴奋。在他的鼓励与帮助下，Stepanove因而年9月的圣何塞为ANSI/ISO C++标准委员会作了一个相关演讲（题为"The Science of C++ Programming"），向委员们讲述了其观念。而后又于次年3月，在圣迭戈会议上，向委员会提交了一份建议书，以期使STL成为C++标准库的一部分。尽管这一建议十分庞大，以致于下降了被经过的可能性，但因为其所包含的新思想，投票结果以压倒多数的意见认为推迟对该建议的决定。

　　随后，在众人的帮助之下，包括Bjarne Stroustrup在内，Stepanove又对STL进行了改进。同时加入了一个封装内存模式信息的抽象模块，也就是如今STL中的allocator，它使STL的大部分实现均可以独立于具体的内存模式，从而独立于具体平台。在同年夏季的滑铁卢会议上，委员们以80%同意，20%反对，最终经过了提案，决定将STL正式归入C++标准化进程之中，随后STL便被放进了会议的工做文件中。自此，STL终于成为了C++家族中的重要一员。

　　此后，随着C++标准的不断改进，STL也在不断地做着相应的演化。直至1998年，ANSI/ISO C++标准正式定案，STL始终是C++标准中不可或缺的一大部件。

1.3 千丝万缕的联系

　　在你了解了STL的过去以后，一些名词开始不断在你的大脑中浮现，STL、C++、C++标准函数库、泛型程序设计、面向对象程序设计……，这些概念意味着什么？他们之间的关系又是什么？若是你想了解某些细节，这里也许有你但愿获得的答案。

1.3.1 STL和C++

　　没有C++语言就没有STL，这么说绝不为过。通常而言，STL做为一个泛型化的数据结构和算法库，并不牵涉具体语言（固然，在C++里，它被称为STL）。也就是说，若是条件容许，用其余语言也能够实现之。这里所说的条件，主要是指相似于"模板"这样的语法机制。若是你没有略过前一节内容的话，应该能够看到，Alexander Stepanov在选择C++语言做为实现工具以前，早以采用过多种程序设计语言。可是，为何最终仍是C++幸运的承担了这个历史性任务呢？缘由不只在于前述那个条件，还在于C++在某些方面所表现出来的优越特性，好比：高效而灵活的指针。可是若是把C++做为一种OOP（Object-Oriented Programming，面向对象程序设计）语言来看待的话（事实上咱们通常都是这么认为的，不是吗？），其功能强大的继承机制却没有给STL的实现帮上多大的忙。在STL的源代码里，并无太多太复杂的继承关系。继承的思想，甚而面向对象的思想，还不足以实现相似STL这样的泛型库。C++只有在引入了"模板"以后，才直接致使了STL的诞生。这也正是为何，用其余比C++更纯的面向对象语言没法实现泛型思想的一个重要缘由。固然，事情老是在变化之中，像Java在这方面，就是一个很好的例子，jdk1.4中已经加入了泛型的特性。

　　此外，STL对于C++的发展，尤为是模板机制，也起到了促进做用。好比：模板函数的偏特化（template function partial specialization），它被用于在特定应用场合，为通常模板函数提供一系列特殊化版本。这一特性是继STL被ANSI/ISO C++标准委员会经过以后，在Bjarne和Stepanov共同商讨之下并由Bjarne向委员会提出建议的，最终该项建议被经过。这使得STL中的一些算法在处理特殊情形时能够选择非通常化的方式，从而保证了执行的效率。

1.3.2 STL和C++标准函数库

　　STL是最新的C++标准函数库中的一个子集，这个庞大的子集占据了整个库的大约80%的份量。而做为在实现STL过程当中扮演关键角色的模板则充斥了几乎整个C++标准函数库。在这里，咱们有必要看一看C++标准函数库里包含了哪些内容，其中又有哪些是属于标准模板库（即STL）的。

　　C++标准函数库为C++程序员们提供了一个可扩展的基础性框架。咱们从中能够得到极大的便利，同时也能够经过继承现有类，本身编制符合接口规范的容器、算法、迭代子等方式对之进行扩展。它大体包含了以下几个组件：

　　C标准函数库，基本保持了与原有C语言程序库的良好兼容，尽管有些微变化。人们总会忍不住留恋过去的美好岁月，若是你曾经是一个C程序员，对这一点必定体会颇深。或许有一点会让你以为奇怪，那就是在C++标准库中存在两套C的函数库，一套是带有.h扩展名的（好比<stdio.h>），而另外一套则没有（好比<cstdio>）。它们确实没有太大的不一样。

　　语言支持（language support）部分，包含了一些标准类型的定义以及其余特性的定义，这些内容，被用于标准库的其余地方或是具体的应用程序中。

　　诊断（diagnostics）部分，提供了用于程序诊断和报错的功能，包含了异常处理（exception handling），断言（assertions），错误代码（error number codes）三种方式。

　　通用工具（general utilities）部分，这部份内容为C++标准库的其余部分提供支持，固然你也能够在本身的程序中调用相应功能。好比：动态内存管理工具，日期/时间处理工具。记住，这里的内容也已经被泛化了（即采用了模板机制）。

　　字符串（string）部分，用来表明和处理文本。它提供了足够丰富的功能。事实上，文本是一个string对象，它能够被看做是一个字符序列，字符类型多是char，或者wchar_t等等。string能够被转换成char*类型，这样即可以和之前所写的C/C++代码和平共处了。由于那时侯除了char*，没有别的。

　　国际化（internationalization）部分，做为OOP特性之一的封装机制在这里扮演着消除文化和地域差别的角色，采用locale和facet能够为程序提供众多国际化支持，包括对各类字符集的支持，日期和时间的表示，数值和货币的处理等等。毕竟，在中国和在美国，人们表示日期的习惯是不一样的。

　　容器（containers）部分，STL的一个重要组成部分，涵盖了许多数据结构，好比前面曾经提到的链表，还有：vector（相似于大小可动态增长的数组）、queue（队列）、stack（堆栈）……。string也能够看做是一个容器，适用于容器的方法一样也适用于string。如今你能够轻松的完成数据结构课程的家庭做业了。

　　算法（algorithms）部分，STL的一个重要组成部分，包含了大约70个通用算法，用于操控各类容器，同时也能够操控内建数组。好比：find用于在容器中查找等于某个特定值的元素，for_each用于将某个函数应用到容器中的各个元素上，sort用于对容器中的元素排序。全部这些操做都是在保证执行效率的前提下进行的，因此，若是在你使用了这些算法以后程序变得效率底下，首先必定不要怀疑这些算法自己，仔细检查一下程序的其余地方。

　　迭代器（iterators）部分，STL的一个重要组成部分，若是没有迭代器的撮合，容器和算法便没法结合的如此完美。事实上，每一个容器都有本身的迭代器，只有容器本身才知道如何访问本身的元素。它有点像指针，算法经过迭代器来定位和操控容器中的元素。

　　数值（numerics）部分，包含了一些数学运算功能，提供了复数运算的支持。

　　输入/输出（input/output）部分，就是通过模板化了的原有标准库中的iostream部分，它提供了对C++程序输入输出的基本支持。在功能上保持了与原有iostream的兼容，而且增长了异常处理的机制，并支持国际化（internationalization）。

　　整体上，在C++标准函数库中，STL主要包含了容器、算法、迭代器。string也能够算作是STL的一部分。

 

图1：STL和C++标准函数库

1.3.3 STL和GP，GP和OOP

　　正如前面所提到的，在STL的背后蕴含着泛型化程序设计（GP）的思想，在这种思想里，大部分基本算法被抽象，被泛化，独立于与之对应的数据结构，用于以相同或相近的方式处理各类不一样情形。这一思想和面向对象的程序设计思想（OOP）不尽相同，由于，在OOP中更注重的是对数据的抽象，即所谓抽象数据类型（Abstract Data Type），而算法则一般被附属于数据类型之中。几乎全部的事情均可以被看做类或者对象（即类的实例），一般，咱们所看到的算法被做为成员函数（member function）包含在类（class）中，类和类则构成了错综复杂的继承体系。

　　尽管在象C++这样的程序设计语言中，你还能够用全局函数来表示算法，可是在相似于Java这样的纯面向对象的语言中，全局函数已经被"勒令禁止"了。所以，用Java来模拟GP思想是颇为困难的。若是你对前述的STL历史还有印象的话，应该记得Alexander Stepanove也曾用基于OOP的语言尝试过实现GP思想，可是效果并很差，包括没有引入模板以前的C++语言。站在巨人的肩膀上，咱们能够得出这样的结论，在OOP中所体现的思想与GP的思想确实是相异的。C++并非一种纯面向对象的程序设计语言，它的绝妙之处，就在于既知足了OOP，又成全了GP。对于后者，模板立下了汗马功劳。另外，须要指出的是，尽管GP和OOP有诸多不一样，但这种不一样还不至于到"水火不容"的地步。而且，在实际运用的时候，二者的结合使用每每能够使问题的解决更为有效。做为GP思想实例的STL自己即是一个很好的范例，若是没有继承，不知道STL会是什么样子，彷佛没有人作过这样的试验。

1.4 STL的不一样实现版本

　　相信你对STL的感性认识应该有所提升了，是该作一些实际的工做了，那么咱们首先来了解一下STL的不一样实现版本。ANSI/ISO C++文件中的STL是一个仅被描述在纸上的标准，对于诸多C++编译器而言，须要有各自实际的STL，它们或多或少的实现了标准中所描述的内容，这样才可以为咱们所用。之因此有不一样的实现版本，则存在诸多缘由，有历史的缘由，也有各自编译器生产厂商的缘由。如下是几个常见的STL实现版本。　　

1.4.1 HP STL

　　HP STL是全部其它STL实现版本的根源。它是STL之父Alexander Stepanov在惠普的Palo Alto实验室工做时，和Meng Lee共同完成的，是第一个STL的实现版本（参见1.2节）。这个STL是开放源码的，因此它容许任何人无偿使用、复制、修改、发布和销售该软件和相关文档，前提是必须在全部相关文件中加入HP STL的版本信息和受权信息。如今已经不多直接使用这个版本的STL了。

1.4.2 P.J. Plauger STL

　　　　P. J. Plauger STL属于我的做品，由P. J. Plauger本人实现，是HP STL的一个继承版本，所以在其全部头文件中都含有HP STL的相关声明，同时还有P. J. Plauger本人的版权声明。P. J. Plauger是标准C中stdio库的早期实现者，如今是C/C++ User's Journal的主编，与Microsoft保持着良好的关系。P. J. Plauger STL即是被用于Microsoft的Visual C++中的。在Windows平台下的同类版本中，其性能不错，可是queue组件（队列，一种容器）的效率不理想，同时因为Visual C++对C++语言标准的支持不是很好（至少直到VC6.0为止，仍是如此），所以必定程度上影响了P. J. Plauger STL的性能。此外，该版本的源代码可读性较差，你能够在VC的Include子目录下找到全部源文件（好比：C:\Program Files\Microsoft Visual Studio\VC98\Include）。由于不是开放源码的（open source），因此这些源代码是不能修改和销售的，目前P.J. Plauger STL由Dinkumware公司提供相关服务，详情请见http://www.dinkumware.com。据称Visual Studio.NET中的Visual C++.NET（即VC7.0），对C++标准的支持有所提升，而且多了以哈希表（hash table）为基础而实现的map容器，multimap容器和set容器。

1.4.3 Rouge Wave STL

Rouge Wave STL是由Rouge Wave公司实现的，也是HP STL的一个继承版本，除了HP STL的相关声明以外，还有Rouge Wave公司的版权声明。同时，它也不是开放源码的，所以没法修改和销售。该版本被Borland C++ Builder所采用，你能够在C++ Builder的Include子目录下找到全部头文件（好比：C:\Program Files\Borland\Cbuilder5\Include）。尽管Rouge Wave STL的性能不是很好，但因为C++ Builder对C++语言标准的支持还算不错，使其表如今必定程度上得以改善。此外，其源代码的可读性较好。能够从以下网站获得更详细的状况介绍：http://www.rougewave.com。遗憾的是该版本已有一段时间没有更新且不彻底符合标准。所以在Borland C++ Builder 6.0中，它的地位被另外一个STL的实现版本--STLport（见后）取代了。可是考虑到与之前版本的兼容，C++ Builder 6.0仍是保留了Rouge Wave STL，只是若是你想查看它的源代码的话，须要在别的目录中才能找到（好比：C:\Program Files\Borland\Cbuilder6\Include\oldstl）。

1.4.4 STLport

　　STLport最初源于俄国人Boris Fomitchev的一个开发项目，主要用于将SGI STL的基本代码移植到其余诸如C++Builder或者是Visual C++这样的主流编译器上。由于SGI STL属于开放源码，因此STLport才有权这样作。目前STLport的最新版本是4.5。能够从以下网站获得更详细的状况介绍：http://www.stlport.org，能够免费下载其源代码。STLport已经被C/C++技术委员会接受成为工业标准，且在许多平台上都支持。根据测试STLport的效率比VC中的STL要快。比Rouge Wave STL更符合标准，也更容易移植。Borland C++ Builder已经在其6.0版中加入了对STLport的支持，它使用的STLport就是4.5版的，C++ Builder 6.0同时还提供了STLport的使用说明。你能够在C++ Builder的Include\Stlport子目录下找到全部头文件（好比：C:\Program Files\Borland\Cbuilder6\Include\Stlport）。

1.4.5 SGI STL

　　　　SGI STL是由Silicon Graphics Computer System, Inc公司实现的，其设计者和编写者包括Alexander Stepanov和Matt Austern，一样它也是HP STL的一个继承版本。它属于开放源码，所以你能够修改和销售它。SGI STL被GCC（linux下的C++编译器）所采用，你能够在GCC的Include子目录下找到全部头文件（好比：C:\cygnus\cygwin-b20\include\g++\include）。因为GCC对C++语言标准的支持很好，SGI STL在linux平台上的性能至关出色。此外，其源代码的可读性也很好。能够从以下网站获得更详细的状况介绍：http://www.sgi.com，能够免费下载其源代码。目前的最新版本是3.3。

 

图2：STL家族的谱系

 

2 牛刀小试：且看一个简单例程

2.1 引子

　　若是你是一个纯粹的实用主义者，也许一开始就能够从这里开始看起，由于此处提供了一个示例程序，它能够带给你有关使用STL的最直接的感觉。是的，与其纸上谈兵，不如单刀直入，实际操做一番。可是，须要提醒的是，假如你在兴致昂然地细细品味本章内容的时候，可以同时结合前面章节做为佐餐，那将是再好不过的。你会发现，前面所提到的有关STL的那些优势，在此处获得了确切的应证。本章的后半部分，将为你演示在一些主流C++编译器上，运行上述示例程序的具体操做方法，和须要注意的事项。

2.2 例程实做

　　很是遗憾，我不得不舍弃"Hello World"这个经典的范例，尽管它不仅一次的被各类介绍计算机语言的教科书所引用，几乎成为了一个默认的“标准”。其缘由在于它太过简单了，以致于不具有表明性，没法展示STL的巨大魅力。我选用了一个稍稍复杂一点的例子，它的大体功能是：从标准输入设备（通常是键盘）读入一些整型数据，而后对它们进行排序，最终将结果输出到标准输出设备（通常是显示器屏幕）。这是一种典型的处理方式，程序自己具有了一个系统所应该具备的几乎全部的基本特征：输入 + 处理 + 输出。你将会看到三个不一样版本的程序。第一个是没有使用STL的普通C++程序，你将会看到完成这样看似简单的事情，须要花多大的力气，并且还未必没有一点问题（真是吃力不讨好）。第二个程序的主体部分使用了STL特性，此时在第一个程序中所遇到的问题就基本能够解决了。同时，你会发现采用了STL以后，程序变得简洁明快，清晰易读。第三个程序则将STL的功能发挥到了及至，你能够看到程序里几乎每一行代码都是和STL相关的。这样的机会并不老是随处可见的，它展示了STL中的几乎全部的基本组成部分，尽管这看起来彷佛有点过度了。

　　有几点是须要说明的：

　　这个例程的目的，在于向你演示如何在C++程序中使用STL，同时但愿经过实践，证实STL所带给你的确确实实的好处。程序中用到的一些STL基本组件，好比：vector（一种容器）、sort（一种排序算法），你只须要有一个大体的概念就能够了，这并不影响阅读代码和理解程序的含义。

　　不少人对GUI（图形用户界面）的运行方式很感兴趣，这也难怪，漂亮的界面老是会使人赏心悦目的。可是很惋惜，在这里没有加入这些功能。这很容易解释，对于所提供的这个简单示例程序而言，加入GUI特性，是有点本末倒置的。这将会使程序的代码量骤然间急剧膨胀，而真正能够说明问题的核心部分确被淹没在诸多可有可无的代码中间（你须要花去极大的精力来处理键盘或者鼠标的消息响应这些繁琐而又较为规范的事情）。即便你有像Borland C++ Builder这样的基于IDE（集成化开发环境）的工具，界面的处理变得较为简单了（框架代码是自动生成的）。请注意，咱们这里所谈及的是属于C++标准的一部分（STL的第一个字母说明了这一点），它不涉及具体的某个开发工具，它是几乎在任何C++编译器上都能编译经过的代码。毕竟，在Microsoft Visual C++和Borland C++ Builder里，有关GUI的处理代码是不同的。若是你想了解这些GUI的细节，这里恐怕没有你但愿获得的答案，你能够寻找其它相关书籍。

2.2.1 初版：史前时代--转木取火

在STL尚未降生的"黑暗时代"，C++程序员要完成前面所提到的那些功能，须要作不少事情（不过这比起C程序来，彷佛好一点），程序大体是以下这个样子的：

 

 1 // name:example2_1.cpp
 2 // alias:Rubish
 3 
 4 #include <stdlib.h>
 5 #include <iostream.h>
 6 
 7 int compare(const void *arg1, const void *arg2);
 8 
 9 void main(void)
10 {
11     const int max_size = 10;        // 数组容许元素的最大个数
12     int num[max_size];            // 整型数组
13 
14     // 从标准输入设备读入整数，同时累计输入个数，
15     // 直到输入的是非整型数据为止
16     int n;
17     for (n = 0; cin >> num[n]; n ++);
18 
19     // C标准库中的快速排序（quick-sort）函数
20     qsort(num, n, sizeof(int), compare);
21 
22     // 将排序结果输出到标准输出设备
23     for (int i = 0; i < n; i ++)
24         cout << num[i] << "\n";
25 }
26 
27 // 比较两个数的大小，
28 // 若是*(int *)arg1比*(int *)arg2小，则返回-1
29 // 若是*(int *)arg1比*(int *)arg2大，则返回1
30 // 若是*(int *)arg1等于*(int *)arg2，则返回0
31 int compare(const void *arg1, const void *arg2)
32 {
33     return    (*(int *)arg1 < *(int *)arg2) ? -1 :
34             (*(int *)arg1 > *(int *)arg2) ? 1 : 0;
35 }

 

　　这是一个和STL没有丝毫关系的传统风格的C++程序。由于程序的注释已经很详尽了，因此不须要我再作更多的解释。总的说来，这个程序看起来并不十分复杂（原本就没有太多功能）。只是，那个compare函数，看起来有点费劲。指向它的函数指针被做为最后一个实参传入qsort函数，qsort是C程序库stdlib.h中的一个函数。如下是qsort的函数原型：

1 void qsort(void *base, size_t num, size_t width, int (__cdecl *compare )(const void *elem1, const void *elem2 ) );

 

　　看起来有点使人做呕，尤为是最后一个参数。大概的意思是，第一个参数指明了要排序的数组（好比：程序中的num），第二个参数给出了数组的大小（qsort没有足够的智力预知你传给它的数组的实际大小），第三个参数给出了数组中每一个元素以字节为单位的大小。最后那个长长的家伙，给出了排序时比较元素的方式（仍是由于qsort的智商问题）。

如下是某次运行的结果：

 输入：0 9 2 1 5
 输出：0 1 2 5 9      

 

　　有一个问题，这个程序并不像看起来那么健壮（Robust）。若是咱们输入的数字个数超过max_size所规定的上限，就会出现数组越界问题。若是你在Visual C++的IDE环境下以控制台方式运行这个程序时，会弹出非法内存访问的错误对话框。

这个问题很严重，严重到足以使你开始从新审视这个程序的代码。为了弥补程序中的这一缺陷。咱们不得不考虑采用以下三种方案中的一种：

• 采用大容量的静态数组分配。
• 限定输入的数据个数。
• 采用动态内存分配。

　　第一种方案比较简单，你所作的只是将max_size改大一点，好比：1000或者10000。可是，严格讲这并不能最终解决问题，隐患仍然存在。假若有人足够耐心，仍是能够使你的这个通过纠正后的程序崩溃的。此外，分配一个大数组，一般是在浪费空间，由于大多数状况下，数组中的一部分空间并无被利用。

　　再来看看第二种方案，经过在第一个for循环中加入一个限定条件，能够使问题获得解决。好比：for (int n = 0; cin >> num[n] && n < max_size; n ++); 可是这个方案一样不甚理想，尽管不会使程序崩溃，但失去了灵活性，你没法输入更多的数。

　　看来只有选择第三种方案了。是的，你能够利用指针，以及动态内存分配妥善的解决上述问题，而且使程序具备良好的灵活性。这须要用到new，delete操做符，或者古老的malloc()，realloc()和free()函数。可是为此，你将牺牲程序的简洁性，使程序代码陡增，代码的处理逻辑也再也不像原先看起来那么清晰了。一个compare函数或许就已经令你不耐烦了，更况且要实现这些复杂的处理机制呢？很难保证你不会在处理这个问题的时候出错，不少程序的bug每每就是这样产生的。同时，你还应该感谢stdlib.h，它为你提供了qsort函数，不然，你还须要本身实现排序算法。若是你用的是冒泡法排序，那效率就不会很理想。……，问题真是愈来愈让人头疼了！

　　关于第一个程序的讨论就到此为止，若是你对第三种方案感兴趣的话，能够尝试着本身编写一个程序，做为思考题。这里就不许备再浪费笔墨去实现这样一个让人不甚愉快的程序了。

2.2.2 第二版：工业时代--组件化大生产

　　咱们应该庆幸本身所生活的年代。工业时代，科技的发展所带来的巨大便利已经影响到了咱们生活中的每一个细节。若是你还在以原始人类的方式生活着，那我真该怀疑你是否属于某个生活在非洲或者南美丛林里的原始部落中的一员了，难道是玛雅文明又重现了？

　　STL即是这个时代的产物，正如其余科技成果同样，C++程序员也应该努力使本身适应并充分利用这个"高科技成果"。让咱们从新审视初版的那个破烂不堪的程序。试着使用一下STL，看看效果如何。

 

 1 // name:example2_2.cpp
 2 // alias:The first STL program
 3 
 4 #include <iostream>
 5 #include <vector>
 6 #include <algorithm>
 7 
 8 using namespace std;
 9 
10 void main(void)
11 {
12     vector<int> num;        // STL中的vector容器
13     int element;
14 
15     // 从标准输入设备读入整数， 
16     // 直到输入的是非整型数据为止
17     while (cin >> element)
18         num.push_back(element);
19 
20     // STL中的排序算法
21     sort(num.begin(), num.end());
22 
23     // 将排序结果输出到标准输出设备
24     for (int i = 0; i < num.size(); i ++)
25         cout << num[i] << "\n";
26 }
27      

 

　　这个程序的主要部分改用了STL的部件，看起来要比第一个程序简洁一点，你已经找不到那个讨厌的compare函数了。它真的能很好的运行吗？你能够试试，由于程序的运行结果和前面的大体差很少，因此在此略去。我能够向你保证，这个程序是足够健壮的。不过，可能你尚未彻底看明白程序的代码，因此我须要为你解释一下。毕竟，这个戏法变得太快了，较之第一个程序，一眨眼的功夫，那些老的C++程序员所熟悉的代码都不见了，取而代之的是一些新鲜玩意儿。

　　程序的前三行是包含的头文件，它们提供了程序所要用到的全部C++特性（包括输入输出处理，STL中的容器和算法）。没必要在乎那个.h，并非个人疏忽，程序保证能够编译经过，只要你的C++编译器支持标准C++规范的相关部分。你只须要把它们看做是一些普通的C++头文件就能够了。事实上，也正是如此，若是你对这个变化细节感兴趣的化，能够留意一下你身旁的佐餐。

　　一样能够忽略第四行的存在。加入那个声明只是为了代表程序引用到了std这个标准名字空间（namespace），由于STL中的那些玩意儿全都包含在那里面。只有经过这行声明，编译器才能容许你使用那些有趣的特性。

　　程序中用到了vector，它是STL中的一个标准容器，能够用来存放一些元素。你能够把vector理解为int [?]，一个整型的数组。之因此大小未知是由于，vector是一个能够动态调整大小的容器，当容器已满时，若是再放入元素则vector会悄悄扩大本身的容量。push_back是vector容器的一个类属成员函数，用来在容器尾端插入一个元素。main函数中第一个while循环作的事情就是不断向vector容器尾端插入整型数据，同时自动维护容器空间的大小。

　　sort是STL中的标准算法，用来对容器中的元素进行排序。它须要两个参数用来决定容器中哪一个范围内的元素能够用来排序。这里用到了vector的另两个类属成员函数。begin()用以指向vector的首端，而end()则指向vector的末端。这里有两个问题，begin()和end()的返回值是什么？这涉及到STL的另外一个重要部件--迭代器（Iterator），不过这里并不须要对它作详细了解。你只须要把它看成是一个指针就能够了，一个指向整型数据的指针。相应的sort函数声明也能够看做是void 　　sort(int* first, int* last)，尽管这实际上很不精确。另外一个问题是和end()函数有关，尽管前面说它的返回值指向vector的末端，但这种说法不能算正确。事实上，它的返回值所指向的是vector中最末端元素的后面一个位置，即所谓pass-the-end value。这听起来有点费解，不过没必要在乎，这里只是稍带一提。总的来讲，sort函数所作的事情是对那个准整型数组中的元素进行排序，一如第一个程序中的那个qsort，不过比起qsort来，sort彷佛要简单了许多。

　　程序的最后是输出部分，在这里vector彻底能够以假乱真了，它所提供的对元素的访问方式简直和普通的C++内建数组如出一辙。那个size函数用来返回vector中的元素个数，就至关于第一个程序中的变量n。这两行代码直观的不用我再多解释了。

　　我想个人耐心讲解应该能够使你大体看懂上面的程序了，事实上STL的运用使程序的逻辑更加清晰，使代码更易于阅读。试问，有谁会不明白begin、end、size这样的字眼所表达的含义呢（除非他不懂英语）？试着运行一下，看看效果。再试着多输入几个数，看看是否会发生数组越界现象。实践证实，程序运行良好。是的，因为vector容器自行维护了自身的大小，C++程序员就不用操心动态内存分配了，指针的错误使用毕竟会带来不少麻烦，同时程序也会变得冗长无比。这正是前面第三种方案的缺点所在。

　　再仔细审视一下你的第一个STL版的C++程序，回顾一下第一章所提到的那些有关STL的优势：易于使用，具备工业强度……，再比较一下初版的程序，我想你应该有所体会了吧！

2.2.3 第三版：惟美主义的杰做

　　事态的发展有时候总会趋向极端，这在那些惟美主义者当中犹是如此。首先声明，我并非一个惟美主义者，提供第二版程序的改进版，彻底是为了让你更深入的感觉到STL的魅力所在。在看完第三版以后，你会强烈感觉到这一点。或许你也会变成一个惟美主义者了，至少在STL方面。这应该不是个人错，由于决定权在你手里。下面咱们来看看这个绝版的C++程序。

 

 1 // name:example2_3.cpp
 2 // alias:aesthetic version
 3 
 4 #include <iostream>
 5 #include <vector>
 6 #include <algorithm>
 7 #include <iterator>
 8 
 9 using namespace std;
10 
11 void main(void)
12 {
13     typedef vector<int>                int_vector;
14     typedef istream_iterator<int>                istream_itr;
15     typedef ostream_iterator<int>                ostream_itr;
16     typedef back_insert_iterator< int_vector >    back_ins_itr;
17 
18     // STL中的vector容器
19     int_vector num;
20 
21     // 从标准输入设备读入整数， 
22     // 直到输入的是非整型数据为止
23     copy(istream_itr(cin), istream_itr(), back_ins_itr(num));
24 
25     // STL中的排序算法
26     sort(num.begin(), num.end());
27 
28     // 将排序结果输出到标准输出设备
29     copy(num.begin(), num.end(), ostream_itr(cout, "\n"));
30 }

 

 　　在这个程序里几乎每行代码都是和STL有关的（除了main和那对花括号，固然还有注释），而且它包含了STL中几乎全部的各大部件（容器container，迭代器iterator, 算法algorithm, 适配器adaptor），惟一的遗憾是少了函数对象（functor）的身影。

　　还记得开头提到的一个典型系统所具备的基本特征吗？--输入+处理+输出。全部这些功能，在上面的程序里，仅仅是经过三行语句来实现的，其中每一行语句对应一种操做。对于数据的操做被高度的抽象化了，而算法和容器之间的组合，就像搭积木同样轻松自如，系统的耦合度被降到了极低点。这就是闪耀着泛型之光的STL的伟大力量。如此简洁，如此巧妙，如此神奇！就像魔术通常，以致于再一次让你摸不着头脑。怎么实现的？为何在看第二版程序的时候如此清晰的你，又坠入了五里雾中（窃喜）。

　　请留意此处的标题（惟美主义的杰做），在实际环境中，你未必要作到这样完美。毕竟美好愿望的破灭，在生活中时常会发生。过于理想化，并非一件好事，至少我是这么认为的。正如前面提到的，这个程序只是为了展现STL的独特魅力，你不得不为它的出色表现所折服，也许只有深谙STL之道的人才会想出这样的玩意儿来。若是你只是通常性的使用STL，作到第二版这样的程度也就能够了。

　　实在是由于这个程序太过"简单"，以致于我没法确定，在你尚未彻底掌握STL以前，经过个人讲解，是否可以领会这区区三行代码，我将尽个人最大努力。

　　前面提到的迭代器能够对容器内的任意元素进行定位和访问。在STL里，这种特性被加以推广了。一个cin表明了来自输入设备的一段数据流，从概念上讲它对数据流的访问功能相似于通常意义上的迭代器，可是C++中的cin在不少地方操做起来并不像是一个迭代器，缘由就在于其接口和迭代器的接口不一致（好比：不能对cin进行++运算，也不能对之进行取值运算--即*运算）。为了解决这个矛盾，就须要引入适配器的概念。istream_iterator即是一个适配器，它将cin进行包装，使之看起来像是一个普通的迭代器，这样咱们就能够将之做为实参传给一些算法了（好比这里的copy算法）。由于算法只认得迭代器，而不会接受cin。对于上面程序中的第一个copy函数而言，其第一个参数展开后的形式是：istream_iterator(cin)，其第二个参数展开后的形式是：istream_iterator()（若是你对typedef的语法不清楚，能够参考有关的c++语言书籍）。其效果是产生两个迭代器的临时对象，前一个指向整型输入数据流的开始，后一个则指向"pass-the-end value"。这个函数的做用就是将整型输入数据流从头到尾逐一"拷贝"到vector这个准整型数组里，第一个迭代器从开始位置每次累进，最后到达第二个迭代器所指向的位置。或许你要问，若是那个copy函数的行为真如我所说的那样，为何不写成以下这个样子呢？

 

1 copy(istream_iterator<int>(cin), istream_iterator<int>(), num.begin());

 

　　你确实能够这么作，可是有一个小小的麻烦。还记得初版程序里的那个数组越界问题吗？若是你这么写的话，就会遇到相似的麻烦。缘由在于copy函数在"拷贝"数据的时候，若是输入的数据个数超过了vector容器的范围时，数据将会拷贝到容器的外面。此时，容器不会自动增加容量，由于这只是简单地拷贝，并非从末端插入。为了解决这个问题，另外一个适配器back_insert_iterator登场了，它的做用就是引导copy算法每次在容器末端插入一个数据。程序中的那个back_ins_itr(num)展开后就是：back_insert_iterator<int_vector>(num)，其效果是生成一个这样的迭待器对象。

　　终于将讲完了三分之一（真不容易！），好在第二句和前一版程序没有差异，这里就略过了。至于第三句，ostream_itr(cout, "\n")展开后的形式是：ostream_iterator(cout, "\n")，其效果是产生一个处理输出数据流的迭待器对象，其位置指向数据流的起始处，而且以"\n"做为分割符。第二个copy函数将会从头到尾将vector中的内容"拷贝"到输出设备，第一个参数所表明的迭代器将会从开始位置每次累进，最后到达第二个参数所表明的迭代器所指向的位置。

　　这就是所有的内容。

2.3 历史的评价

　　历史的车轮老是滚滚向前的，工业时代的文明较之史前时代，固然是先进而且发达的。回顾那两个时代的C++程序，你会真切的感觉到这种差异。简洁易用，具备工业强度，较好的可移植性，高效率，加之第三个使人目眩的绝版程序所体现出来的高度抽象性，高度灵活性和组件化特性，使你对STL背后所蕴含的泛型化思想都有了些微的感觉。

　　真幸运，你能够横跨两个时代，有机会目击这种"文明"的差别。同时，这也应该使你越加坚决信念，使本身顺应时代的潮流。