ACM入门及STL简介

1.       ACM 国际大学生程序设计竞赛简介

1)       背景与历史

1970 年在美国TexasA&M 大学举办了首次区域竞赛，从而拉开了国际大学生程序设计竞赛的序幕。1977 年，该项竞赛被分为两个级别：区域赛和总决赛，这便是现代ACM 竞赛的开始。在亚洲、美国、欧洲、太平洋地区均设有区域赛点。1995 至1996 年，来自世界各地的一千多支s 代表队参加了ACM 区域竞赛。ACM 大学生程序设计竞赛由美国计算机协会（ACM ）举办，旨在向全世界的大学生提供一个展示和锻炼其解决问题和运用计算机能力的机会，现已成为全世界范围内历史最悠久、规模最大的大学生程序设计竞赛。

2)         竞赛组织

竞赛在由各高等院校派出的3 人一组的队伍间进行，分两个级别。参赛队应首先参加每年9 月至11 月在世界各地举行的“ 区域竞赛(Regional Contest)” 。各区域竞赛得分最高的队伍自动进入第二年3 月在美国举行的“ 总决赛(Final Contest)” ，其它的高分队伍也有可能被邀请参加决赛。每个学校有一名教师主管队伍，称为“ 领队”(faculty advisor) ，他负责选手的资格认定并指定或自己担任该队的教练(coach) 。每支队伍最多由三名选手(contestant) 组成，每个选手必须是正在主管学校攻读学位的学生。每支队伍最多允许有一名选手具有学士学位，已经参加两次决赛的选手不得再参加区域竞赛。

3)       竞赛形式与评分办法

竞赛进行5 个小时，一般有6~8 道试题，由同队的三名选手使用同一台计算机协作完成。当解决了一道试题之后，将其提交给评委，由评委判断其是否正确。若提交的程序运行不正确，则该程序将被退回给参赛队，参赛队可以进行修改后再一次提交该问题。

程序运行不正确是指出现以下4 种情况之一：
　　(1) 运行出错(run-time error) ；

(2) 运行超时〔time-limit exceeded 〕；

(3) 运行结果错误(wrong answer) ；

(4) 运行结果输出格式错误(presentation error) 。

竞赛结束后，参赛各队以解出问题的多少进行排名，若解出问题数相同，按照总用时的长短排名。总用时为每个解决了的问题所用时间之和。一个解决了的问题所用的时间是竞赛开始到提交被接受的时间加上该问题的罚时( 每次提交通不过，罚时20 分钟) 。没有解决的问题不记时。美国英语为竞赛的工作语言。竞赛的所有书面材料( 包括试题) 将用美国英语写出，区域竞赛中可以使用其它语言。总决赛可以使用的程序设计语言包括PASCAL ，C ，C++ 及Java ，也可以使用其它语言。具体的操作系统及语言版本各年有所不同。

4)       竞赛奖励情况

总决赛前十名的队伍将得到高额奖学金：第一名奖金为12000 美元，第二名奖金为
6000 美元，第三名奖金为3000 美元，第四名至第十名将各得到l500 美元。除此之外还将
承认北美冠军、欧洲冠军、南太平洋冠军及亚洲冠军。

 

2.       ACM 竞赛需要的知识

ü        语言是最重要的基本功

无论侧重于什么方面，只要是通过计算机程序去最终实现的竞赛，语言都是大家要过的第一道关。亚洲赛区的比赛支持的语言包括C/C++ 与JAVA 。首先说说JAVA ，众所周知，作为面向对象的王牌语言，JAVA 在大型工程的组织与安全性方面有着自己独特的优势，但是对于信息学比赛的具体场合，JAVA 则显得不那么合适，它对于输入输出流的操作相比于C++ 要繁杂很多，更为重要的是JAVA 程序的运行速度要比C++ 慢10 倍以上，而竞赛中对于JAVA 程序的运行时限却往往得不到同等比例的放宽，这无疑对算法设计提出了更高的要求，是相当不利的。其实，并不主张大家在这种场合过多地运用面向对象的程序设计思维，因为对于小程序来说这不但需要花费更多的时间去编写代码，也会降低程序的执行效率。

接着说C 和C++ 。在赛场上使用纯C 的选手还是大有人在的，它们主要是看重了纯C 在效率上的优势，所以这部分同学如果时间有限，并不需要急着去学习新的语言，只要提高了自己在算法设计上的造诣，纯C 一样能发挥巨大的威力。

而C++ 相对于C ，在输入输出流上的封装大大方便了我们的操作，同时降低了出错的可能性，并且能够很好地实现标准流与文件流的切换，方便了调试的工作。如果有些同学比较在意这点，可以尝试C 和C++ 的混编，毕竟仅仅学习C++ 的流操作还是不花什么时间的。

C++ 的另一个支持来源于标准模版库（STL ），库中提供的对于基本数据结构的统一接口操作和基本算法的实现可以缩减我们编写代码的长度，这可以节省一些时间。但是，与此相对的，使用STL 要在效率上做出一些牺牲，对于输入规模很大的题目，有时候必须放弃STL ，这意味着我们不能存在“有了STL 就可以不去管基本算法的实现”的想法；另外，熟练和恰当地使用STL 必须经过一定时间的积累，准确地了解各种操作的时间复杂度，切忌对STL 中不熟悉的部分滥用，因为这其中蕴涵着许多初学者不易发现的陷阱。

通过以上的分析，我们可以看出仅就信息学竞赛而言，对语言的掌握并不要求十分全面，但是对于经常用到的部分，必须十分熟练，不允许有半点不清楚的地方.

ü        以数学为主的基础知识十分重要

虽然被定性为程序设计竞赛，但是参赛选手所遇到的问题更多的是没有解决问题的思路，而不是有了思路却死活不能实现，这就是平时积累的基础知识不够。今年World Final 的总冠军是波兰华沙大学，其成员出自于数学系而非计算机系，这就是一个鲜活的例子。竞赛中对于基础学科的涉及主要集中于数学，此外对于物理、电路等等也可能有一定应用，但是不多。因此，大一的同学也不必为自己还没学数据结构而感到不知从何入手提高，把数学捡起来吧！下面我来谈谈在竞赛中应用的数学的主要分支。

Ø        离散数学

离散数学作为计算机学科的基础是竞赛中涉及最多的数学分支，重中之重又在于图论和组合数学，尤其是图论。图论之所以运用最多是因为它的变化最多，而且可以轻易地结合基本数据结构和许多算法的基本思想，较多用到的知识包括连通性判断、DFS 和BFS ，关节点和关键路径、欧拉回路、最小生成树、最短路径、二部图匹配和网络流等等。虽然这部分的比重很大，但是往往也是竞赛中的难题所在，如果有初学者对于这部分的某些具体内容暂时感到力不从心，也不必着急，可以慢慢积累。

Ø        组合数学

竞赛中设计的组合计数问题大都需要用组合数学来解决，组合数学中的知识相比于图论要简单一些，很多知识对于小学上过奥校的同学来说已经十分熟悉，但是也有一些部分需要先对代数结构中的群论有初步了解才能进行学习。组合数学在竞赛中很少以难题的形式出现，但是如果积累不够，任何一道这方面的题目却都有可能成为难题。

Ø        数论

以素数判断和同余为模型构造出来的题目往往需要较多的数论知识来解决，这部分在竞赛中的比重并不大，但只要来上一道，也足以使知识不足的人冥思苦想上一阵时间。素数判断和同余最常见的是在以密码学为背景的题目中出现，在运用密码学常识确定大概的过程之后，核心算法往往要涉及数论的内容。

Ø        计算几何

计算几何相比于其它部分来说是比较独立的，就是说它和其它的知识点很少有过多的结合，较常用到的部分包括— 线段相交的判断、多边形面积的计算、内点外点的判断、凸包等等。计算几何的题目难度不会很大，但也永远不会成为最弱的题。

Ø        线性代数

对线性代数的应用都是围绕矩阵展开的，一些表面上是模拟的题目往往可以借助于矩阵来找到更好的算法。

ü        计算机专业知识

虽然数学十分十分重要，但是如果让三个只会数学的人参加比赛，我相信多数情况下会比三个只会数据结构与算法的人得到更为悲惨的结局。

数据结构

掌握队列、堆栈和图的基本表达与操作是必需的，至于树，我个人觉得需要建树的问题有但是并不多。（但是树往往是很重要的分析工具）除此之外，排序和查找并不需要对所有方式都能很熟练的掌握，但你必须保证自己对于各种情况都有一个在时间复杂度上满足最低要求的解决方案。说到时间复杂度，就又该说说哈希表了，竞赛时对时间的限制远远多于对空间的限制，这要求大家尽快掌握“以空间换时间”的原则策略，能用哈希表来存储的数据一定不要到时候再去查找，如果实在不能建哈希表，再看看能否建二叉查找树等等— 这都是争取时间的策略，掌握这些技巧需要大家对数据结构尤其是算法复杂度有比较全面的理性和感性认识。

算法

算法中最基本和常用的是搜索，主要是回溯和分支限界法的使用。这里要说的是，有些初学者在学习这些搜索基本算法是不太注意剪枝，这是十分不可取的，因为所有搜索的题目给你的测试用例都不会有很大的规模，你往往察觉不出程序运行的时间问题，但是真正的测试数据一定能过滤出那些没有剪枝的算法。实际上参赛选手基本上都会使用常用的搜索算法，题目的区分度往往就是建立在诸如剪枝之类的优化上了。

常用算法中的另一类是以“相似或相同子问题”为核心的，包括递推、递归、贪心法和动态规划。这其中比较难于掌握的就是动态规划（DP ），如何抽象出重复的子问题是很多题目的难点所在，笔者建议初学者仔细理解图论中一些以动态规划为基本思想所建立起来的基本算法（比如Floyd-Warshall 算法），并且多阅读一些定理的证明，这虽然不能有什么直接的帮助，但是长期坚持就会对思维很有帮助。

 

3.       对新手的一些建议

首先要看一些基础的算法书籍，把基本的算法搞懂。像递归、二分、宽搜、深搜、简单的图论、数论、简单的组合数学。重点根据书上的例题理解算法的实质、思想，能做到有一定领悟。这时需要做一些题目来巩固了。

先可以做搜索题，搜索是博大精深的，诸多细节技巧都需要靠平时的积累领悟，根据自己练习的目的挑一些题练习。然后可以做简单的数学题，对组合数学、数论有个大致的概念。

再然后可以做DP 类题目了。DP 也是非一日之功，练好DP 就像练好了内功，这时可以做一些DP 的基础题，体会一下，然后做一些提高题，如果不会做，一定要自己想通为什么别人这样设定状态数组，他的技巧在哪里。oibh 上很多的国家集训队关于DP 的论文是必看的。

图论里有很多基础的东西需要学习，先把图论里面基本的定义看懂，然后把经典的算法看懂，比如最短路、生成树、割点、连通分量等等。如果不会做，一定要好好看书。

很多新手会问碰到不会做的题目怎么办。首先应该考察一下为什么不会做这题，如果是书本上的知识点没掌握，那要赶紧把书本找来，仔细理解之后再来想这题。如果知识点基本都掌握了，那么可以利用网络的资源，多搜索一下关于这题的讨论，看看别人是怎么想的，看是否可以给自己提供思路。总之一条，要自己多开动脑子。重在理解这一题的算法，而不是只知道算法，自己把它编程实现了就算了。对待算法和程序要用严谨的态度，没有搞懂的地方要花力气把它搞懂，这样才能不断提高。

看书是必须的，而且也是迅速提高的最好方法，不要等到做题时才去理解书上的知识点，而要对知识点有了充分的理解后再去做题，这样才能事半功倍，否则看到难题，从哪方面下手的思路都没有。

高级的贪心，300 行的宽搜，A* ，STL ，诸多的剪枝技巧，统计，查找，treap ，对DP 状态的优化，带集合的DP ，平面图，计算几何，数论...... 要学的东西很多。但我相信只要努力你们肯定会取得不错的成绩。和别人比赛，其实是和自己比赛，考场上完全是实力的体现，会就是会，不会就是做不出来。训练时间每个人情况不一样，长短不一，但重在看个人悟性，水平达到一定程度之后会发现有质的变化，理解算法简直是小菜。

这里强调的还是个思维能力的问题，不是为了做题而做题，做题其实是为了训练自己的思维能力和编程能力，从训练中能得到的最大的收获就是提升了思维，套用比较流行的一个词就是“ 脑力” 。这也是为什么说进省队是个标志，进了省队说明你前期有了一定的积累，和那里的一些高手一接触自然自己的思路就大大开阔了，对于算法会有一个更深层次的理解。就算只参加了省队的选拔赛，对自己的帮助也是很大的。用一牛人的话说，没进过省队就等于没见过世面。

那大家一定达不到那些现今强人的水平吗？当然不是。强人不是天生就强的，也是从菜鸟做起的，成功地原因只有一个- ——勤奋。他们的思维能力或者脑力不是天生就这样的。但随便提现今的一个牛人，题量都是上千。他们默默地积累和严谨的态度才取得了现在的成绩。有人说上千题，太恐怖了啊，我做一个题都得花几小时，有些想几天还做不出。一开始自然是这样，知识点众多，考查范围广大，对这些现成的知识要慢慢消化，每个知识点都掌握后，做只考这些知识点的题自然就快了。积累到一定程度后就会发现做题的乐趣，以前很崇拜那些说“ 今天上课太累了，做几道题休息一下” 的人，不知不觉，做题对我来说也成了最大的乐趣。有些题只考查单一的知识点，有些题把几个知识点结合起来考查。比如先用平面图里面的几个知识点，然后凸包求一下，然后DP 一下，或者线性方程组解一下再搞个匹配等等，这些题看上去很复杂，但若这些知识点都不折不扣地掌握的话，做这些题自然就像切菜了。题目也是人出的，如果只看现成的这些知识点的话，出题者的思维也是有限的。

参加这个比赛对编程能力的提高也是大有好处的，十分钟上百行无错代码，快速实现逻辑较复杂的算法，debug 技巧...... 而且对语言的理解也能上好几个台阶。我们还没有迎来下一次的编程技术革命，编程仍旧是有局限的，它强迫我们像计算机一样思考，而不是令计算机像我们的大脑一样思考，这是我们需要花巨大的努力去克服的。很多人对我说的这句话可能不太理解，至少感受不深。如果Debug 的时间超过写程序时间的1/2 ，那就是失败的。一切都要慢慢训练，持之以恒之后，拥有良好的编程习惯和风格应该是每个人所追求的。编程的境界永无止境！

以前人们常说看书可以升级大脑，对于计算机及其相关专业的同学来说，参加acm 比赛是最好的升级大脑的方法，思维能力的提升可以让我们受益无穷，而编程的能力和技巧则会因为编写大量的代码而大幅提高。或许今后再也没有这样一个机会能让你计算机水平飞速增长。对算法和数据结构理解深入后研究计算机专业的其他课程有如“ 会当凌绝顶，一览众山小” 。所以低年级的同学全身心的投入进来是绝对有好处的。有一年多的积累就能小有成绩了。只要坚持下来，踏踏实实，努力提升自身水平，一定可以实现自己的目标！

做acm 看似是枯燥的，但一旦入了门，就会发现其中有无穷的乐趣，即使训练了不参加比赛，对自己也是一个很好的提高。

知识的积累固然重要，但是信息学终究不是看出来的，而是练出来的，这是多少前人最深的一点体会，只有通过具体题目的分析和实践，才能真正掌握数学的使用和算法的应用，并在不断的练习中增加编程经验和技巧，提高对时间复杂度的感性认识，优化时间的分配，加强团队的配合。总之，在这里光有纸上谈兵是绝对不行的，必须要通过实战来锻炼自己。

练习站点推荐：

（1 ）[acm.pku.edu.cn/JudegOnline] POJ 收集了大量比赛真题，其中不乏简单题；POJ 的服务器性能良好，响应速度快；POJ 经常举办网上练习赛，练习赛是增长比赛经验的最好途径。

（2 ）[acm.zju.edu.cn] ZOJ 是国内最早出现的OJ ，有一定的权威性。ZOJ 的论坛是最好的资源，提供了“题目分类”，可以进行专题练习。

（3 ）[acm.sgu.ru] SGU 是俄罗斯的。比较注重算法和数学。OI 的顶尖高手都在这里做题。

学习资料推荐：

算法导论（英文版）Introduction to Alogrithms.

算法艺术与信息学竞赛 刘汝佳 黄亮 著

历年信息学奥赛中国国家队论文

ACM 国际大学生程序设计竞赛试题与解析

组合数学的算法与程序设计

图论的算法与程序设计

实用算法的分析与程序设计

计算几何基础知识

 

第二章 STL 简介

1.       STL 是什么

作为一个C++ 程序设计者，STL 是一种不可忽视的技术。

Standard Template Library (STL) ：标准模板库, 更准确的说是 C++ 程序设计语言标准模板库。STL 是所有C++ 编译器和所有操作系统平台都支持的一种库，说它是一种库是因为，虽然STL 是一种标准，也就是说对所有的编译器来说，提供给C++ 程序设计者的接口都是一样的。也就是说同一段STL 代码在不同编译器和操作系统平台上运行的结果都是相同的，但是底层实现可以是不同的。 令人兴奋的是，STL 的使用者并不需要了解它的底层实现。 试想一下，如果我们有一把能打开所有锁的钥匙，那将是多么令人疯狂啊。

STL 的目的是标准化组件，这样你就不用重新开发它们了。你可以仅仅使用这些现成的组件。STL 现在是C++ 的一部分，因此不用额外安装什么。它被内建在你的编译器之内。

2.       为什么我们需要学习 STL

STL 是 C++ 的ANSI/ISO 标准的一部分, 可以用于所有C++ 语言编译器和所有平台(Windows/Unix/Linux..) 。STL 的同一版本在任意硬件配置下都是可用的；

STL 提供了大量的可复用软件组织。例如，程序员再也不用自己设计排序，搜索算法了，这些都已经是STL 的一部分了。嘎嘎，有意思吧。

使用STL 的应用程序保证了得到的实现在处理速度和内存利用方面都是高效的，因为STL 设计者们已经为我们考虑好了。

使用STL 编写的代码更容易修改和阅读，这是当然的啦。因为代码更短了，很多基础工作代码已经被组件化了；

使用简单，虽然内部实现很复杂。

虽然，STL 的优点甚多，但是STL 的语法实在令初学者人头疼，许多人望而却步。可是STL 是每个C++ 程序设计者迟早都要啃的一块骨头。

3.       初识 STL

下面让我们来看几段代码吧：

#include <iostream>

int main(void)

{

    double a[] = {1, 2, 3, 4, 5};

    std::cout<<mean(a, 5)<<std::endl;    // will print 3

    return 0;

}

好懂吧，除了那个std 有点让人不舒服以外，这是一段普通的没有使用STL 的C++ 代码。

再看下面一段：

#include <vector>

#include <iostream>

int main()

{

    std::vector<double> a;

    a.push_back(1);

    a.push_back(2);

    a.push_back(3);

    a.push_back(4);

    a.push_back(5);

    for(int i = 0; i < a.size(); ++i)

{

        std::cout<<a[i]<<std::endl;

    }

    return 0;

}

如果你真的没有接触过STL 的话，你会问，呀， vector 是啥呀？这是一段纯种的STL 代码，看到尖括号了吧，知道那是模板了吧。看到 a.push_back(5) 、a.size() 你不感觉奇怪么？可是我们并没有定义这些函数啊。

#include <vector>

#include <iostream>

 

int main()

{

    std::vector< int > q;

    q.push_back(10);

    q.push_back(11);

    q.push_back(12);

    std::vector< int > v;

    for(int i=0; i<5; ++i){

        v.push_back(i);

    }

    std::vector<int>::iterator it = v.begin() + 1;

    it = v.insert(it, 33);

    v.insert(it, q.begin(), q.end());

    it = v.begin() + 3;

    v.insert(it, 3, -1);

    it = v.begin() + 4;

    v.erase(it);

    it = v.begin() + 1;

    v.erase(it, it + 4);

    v.clear();

    return 0;

}

这一段你又看到了新东西了吧： iterator 、insert 、erase 、clear 。不罗嗦了，等你看完这篇文章，回头再看就简单了。

关于模板的其他细节，读者可以参阅《C++ Templates 中文版》在这里，简单的介绍一下模板类和函数模板的概念。

模板是C++ 中实现代码重用机制的一种工具，可以实现类型参数化，把类型定义为参数。函数模板和类模板允许用户构造模板函数和模板类。

图 1

下面我们来看一段函数模板的例子：

#include<iostream>

#include<string>

using namespace std;

// 定义函数模板

template<class T>   //template 是关键字，T 表示一种待实例化的类型

                    //template<typename T>  也是对的

T MAX(T a, T b)// 函数模板，函数名为 max ，此函数有2 个T 类型的参数，返回类型为T

{

  return (a>b)?a:b; 

}

// 在此例实例化的时候，T 可以是多种类型的，int,char,string …

int main()

{

int x=2,y=6;

    double x1=9.123,y1=12.6543;

    cout<<" 把T 实例化为int:"<<MAX(x,y)<<endl;// 实例化函数模板，把T 实例化为int

    cout<<" 把T 实例化为double:"<<MAX(x1,y1)<<endl;  // 把T 实例化为double

}

下面再看看，类模板：

#include<iostream>

using namespace std;

// 定义名为ex_class 的类模板

template < typename T>  class ex_class

{

    T value;

public:

    ex_class(T v) { value=v; }

    void set_value(T v) { value=v; }

    T get_value(void) {return value;}

};

//main() 函数中测试ex_class 类模板

int main()

{

    // 测试int 类型数据

    ex_class <int> a(5),b(10);

    cout<<"a.value:"<<a.get_value()<<endl;

    cout<<"b.value:"<<b.get_value()<<endl;

    // 测试char 类型数据

    ex_class <char> ch('A');

    cout<<"ch.value:"<<ch.get_value()<<endl;

    ch.set_value('a');

    cout<<"ch.value:"<<ch.get_value()<<endl;

    // 测试double 类型数据

    ex_class <double> x(5.5);

    cout<<"x.value:"<<x.get_value()<<endl;

    x.set_value(7.5);

    cout<<"x.value:"<<x.get_value()<<endl;

}

4.       STL 的组成

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

容器：装东西的东西，装水的杯子，装咸水的大海，装人的教室……STL 里的容器是可容纳一些数据的模板类。

算法：就是往杯子里倒水，往大海里排污，从教室里撵人……STL 里的算法，就是处理容器里面数据的方法、操作。

迭代器：往杯子里倒水的水壶，排污的管道，撵人的那个物业管理人员……STL 里的迭代器：遍历容器中数据的对象。对存储于容器中的数据进行处理时，迭代器能从一个成员移向另一个成员。他能按预先定义的顺序在某些容器中的成员间移动。对普通的一维数组、向量、双端队列和列表来说，迭代器是一种指针。

下面让我们来看看专家是怎么说的：

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

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

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

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

1.        容器

STL 中的容器有队列容器和关联容器，容器适配器（congtainer adapters ：stack,queue ，priority queue ），位集（bit_set ），串包(string_package) 等等。
　　在本文中，我将介绍list,vector ，deque 等队列容器，和set 和multisets,map 和multimaps 等关联容器，一共7 种基本容器类。
　　队列容器（顺序容器）：队列容器按照线性排列来存储T 类型值的集合，队列的每个成员都有自己的特有的位置。顺序容器有向量类型、双端队列类型、列表类型三种。

u      基本容器—— 向量

向量（vector 容器类）： ＃include <vector> ， vector 是一种动态数组，是基本数组的类模板。其内部定义了很多基本操作。既然这是一个类，那么它就会有自己的构造函数。vector 类中定义了4 中种构造函数：

·   默认构造函数，构造一个初始长度为0 的空向量，如： vector<int> v1 ;

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

·   复制构造函数，构造一个新的向量，作为已存在的向量的完全复制，如： vector<int> v3(v2) ;

·   带两个常量参数的构造函数，产生初始值为一个区间的向量。区间由一个半开区间 [ first,last ) 来指定。如： vector<int> v4(first,last ）

下面一个例子用的是第四种构造方法，其它的方法读者可以自己试试。

// 程序：初始化演示

#include <cstring> 

#include <vector>

#include <iostream>

using namespace std;

 

int ar[10] = {  12, 45, 234, 64, 12, 35, 63, 23, 12, 55  };

char* str = "Hello World";

 

int main()

{

    vector <int> vec1(ar, ar+10);   // first=ar,last=ar+10, 不包括ar+10

    vector < char > vec2(str,str+strlen(str)); // first=str,last= str+strlen(str),

    cout<<"vec1:"<<endl;  

    // 打印vec1 和vec2 ，const_iterator 是迭代器，后面会讲到

    // 当然，也可以用for (int i=0; i<vec1.size(); i++)cout << vec[i]; 输出

    //size() 是vector 的一个成员函数

    for(vector<int>::const_iterator p=vec1.begin();p!=vec1.end(); ++p)

        cout<<*p;

        cout<<'/n'<<"vec2:"<<endl;

    for(vector< char >::const_iterator p1=vec2.begin();p1!=vec2.end(); ++p1)

        cout<<*p1;

    cout<<'/n';

    return 0;

}     

为了帮助理解向量的概念，这里写了一个小例子，其中用到了vector 的成员函数：begin() ，end() ，push_back() ，assign() ，front() ，back() ，erase() ，empty() ，at() ，size() 。

 

#include <iostream>

#include <vector>

using namespace std;

 

typedef vector<int> INTVECTOR;// 自定义类型INTVECTOR

// 测试vector 容器的功能

 

int main()

{

    //vec1 对象初始为空

    INTVECTOR vec1;  

    //vec2 对象最初有10 个值为6 的元素  

    INTVECTOR vec2(10,6); 

    //vec3 对象最初有3 个值为6 的元素，拷贝构造

    INTVECTOR vec3(vec2.begin(),vec2.begin()+3); 

    // 声明一个名为i 的双向迭代器

    INTVECTOR::iterator i;

    // 从前向后显示vec1 中的数据

    cout<<"vec1.begin()--vec1.end():"<<endl;

    for (i =vec1.begin(); i !=vec1.end(); ++i)

        cout << *i << " ";

    cout << endl;

    // 从前向后显示vec2 中的数据

    cout<<"vec2.begin()--vec2.end():"<<endl;

    for (i =vec2.begin(); i !=vec2.end(); ++i)

        cout << *i << " ";

    cout << endl;

    // 从前向后显示vec3 中的数据

    cout<<"vec3.begin()--vec3.end():"<<endl;

    for (i =vec3.begin(); i !=vec3.end(); ++i)

        cout << *i << " ";

    cout << endl;

    // 测试添加和插入成员函数，vector 不支持从前插入

    vec1.push_back(2);// 从后面添加一个成员

    vec1.push_back(4);

    vec1.insert(vec1.begin()+1,5);// 在vec1 第一个的位置上插入成员5

    // 从vec1 第一的位置开始插入vec3 的所有成员

    vec1.insert(vec1.begin()+1,vec3.begin(),vec3.end());

    cout<<"after push() and insert() now the vec1 is:" <<endl;

    for (i =vec1.begin(); i !=vec1.end(); ++i)

        cout << *i << " ";

    cout << endl;

    // 测试赋值成员函数

    vec2.assign(8,1);   // 重新给vec2 赋值，8 个成员的初始值都为1

    cout<<"vec2.assign(8,1):" <<endl;

    for (i =vec2.begin(); i !=vec2.end(); ++i)

        cout << *i << " ";

    cout << endl;

    // 测试引用类函数

    cout<<"vec1.front()="<<vec1.front()<<endl;// vec1 第零个成员

    cout<<"vec1.back()="<<vec1.back()<<endl;// vec1 的最后一个成员

    cout<<"vec1.at(4)="<<vec1.at(4)<<endl;// vec1 的第五个成员

    cout<<"vec1[4]="<<vec1[4]<<endl;

    // 测试移出和删除

    vec1.pop_back();// 将最后一个成员移出vec1

    vec1.erase(vec1.begin()+1,vec1.end()-2);// 删除成员

    cout<<"vec1.pop_back() and vec1.erase():" <<endl;

    for (i =vec1.begin(); i !=vec1.end(); ++i)

        cout << *i << " ";

    cout << endl;

    // 显示序列的状态信息

    cout<<"vec1.size(): "<<vec1.size()<<endl;// 打印成员个数

    cout<<"vec1.empty(): "<<vec1.empty()<<endl;// 清空

}

push_back() 是将数据放入 vector （向量）或 deque （双端队列）的标准函数。 Insert() 是一个与之类似的函数，然而它在所有容器中都可以使用，但是用法更加复杂。 end() 实际上是取末尾加一，以便让循环正确运行-- 它返回的指针指向最靠近数组界限的数据。

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

 

u      双端队列（qeque 容器类）：

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

#include <iostream>

#include <deque>

using namespace std;

 

typedef deque<int> INTDEQUE;// 有些人很讨厌这种定义法，呵呵

 

// 从前向后显示deque 队列的全部元素

void put_deque(INTDEQUE deque, char *name)

{

    INTDEQUE::iterator pdeque;// 仍然使用迭代器输出

    cout << "The contents of " << name << " : ";

    for(pdeque = deque.begin(); pdeque != deque.end(); pdeque++)

        cout << *pdeque << " ";// 注意有 "*" 号哦，没有"*" 号的话会报错

    cout<<endl;

}

 

// 测试deqtor 容器的功能

int main()

{

    //deq1 对象初始为空

    INTDEQUE deq1;  

    //deq2 对象最初有10 个值为6 的元素 

    INTDEQUE deq2(10,6); 

    // 声明一个名为i 的双向迭代器变量

    INTDEQUE::iterator i;

    // 从前向后显示deq1 中的数据

    put_deque(deq1,"deq1");

    // 从前向后显示deq2 中的数据

    put_deque(deq2,"deq2");

    // 从deq1 序列后面添加两个元素

    deq1.push_back(2);

    deq1.push_back(4);

    cout<<"deq1.push_back(2) and deq1.push_back(4):"<<endl;

    put_deque(deq1,"deq1");

    // 从deq1 序列前面添加两个元素

    deq1.push_front(5);

    deq1.push_front(7);

    cout<<"deq1.push_front(5) and deq1.push_front(7):"<<endl;

    put_deque(deq1,"deq1");

    // 在deq1 序列中间插入数据

    deq1.insert(deq1.begin()+1,3,9);

    cout<<"deq1.insert(deq1.begin()+1,3,9):"<<endl;

    put_deque(deq1,"deq1");

    // 测试引用类函数

    cout<<"deq1.at(4)="<<deq1.at(4)<<endl;

    cout<<"deq1[4]="<<deq1[4]<<endl;

    deq1.at(1)=10;

    deq1[2]=12;

    cout<<"deq1.at(1)=10 and deq1[2]=12 :"<<endl;

    put_deque(deq1,"deq1");

    // 从deq1 序列的前后各移去一个元素

    deq1.pop_front();

    deq1.pop_back();

    cout<<"deq1.pop_front() and deq1.pop_back():"<<endl;

    put_deque(deq1,"deq1");

    // 清除deq1 中的第2 个元素

    deq1.erase(deq1.begin()+1);

    cout<<"deq1.erase(deq1.begin()+1):"<<endl;

    put_deque(deq1,"deq1");

    // 对deq2 赋值并显示

    deq2.assign(8,1);

    cout<<"deq2.assign(8,1):"<<endl;

    put_deque(deq2,"deq2");

}

上面我们演示了deque 如何进行插入删除等操作，像erase(),assign() 是大多数容器都有的操作。关于deque 的其他操作请参阅其他书籍。

u      表（List 容器类）

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

 

图 2
　　同时，list 仍然包涵了erase(),begin(),end(),insert(),push_back(),push_front() 这些基本函数，下面我们来演示一下list 的其他函数功能。merge() ：合并两个排序列表；splice() ：拼接两个列表；sort() ：列表的排序。

#include <iostream>

#include <string>

#include <list>

using namespace std;

 

void PrintIt(list<int> n)

{

    for(list<int>::iterator iter=n.begin(); iter!=n.end(); ++iter)

      cout<<*iter<<" ";// 用迭代器进行输出循环

}

   

int main()

{

    list<int> listn1,listn2;    // 给listn1,listn2 初始化

    listn1.push_back(123);

    listn1.push_back(0);

    listn1.push_back(34);

    listn1.push_back(1123);    // now listn1:123,0,34,1123

    listn2.push_back(100);

    listn2.push_back(12);    // now listn2:12,100

    listn1.sort();

    listn2.sort();    // 给listn1 和listn2 排序

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

    PrintIt(listn1);

    cout<<endl;

    PrintIt(listn2);

    listn1.merge(listn2);    // 合并两个排序列表后,listn1:0 ，12 ，34 ，100 ，123 ，1123

    cout<<endl;

    PrintIt(listn1);

}

上面并没有演示 splice() 函数的用法，这是一个拗口的函数。用起来有点麻烦。图3 所示是 splice 函数的功能。将一个列表插入到另一个列表当中。 list 容器类定义了 splice() 函数的3 个版本：

splice(position,list_value);

splice(position,list_value,ptr);

splice(position,list_value,first,last);

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

                                   图3

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 等等。

u      集和多集（set 和multiset 容器类）：

一个集合（ #include<set> ）是一个容器，它其中所包含的元素的值是唯一的。这在收集一个数据的具体值的时候是有用的。集合中的元素按一定的顺序排列，并被作为集合中的实例。如果你需要一个键/ 值对（ pair ）来存储数据， map （也是一个关联容器，后面将马上要讲到）是一个更好的选择。一个集合通过一个链表来组织，在插入操作和删除操作上比向量（ vector ）快，但查找或添加末尾的元素时会有些慢。

在集中，所有的成员都是排列好的。如果先后往一个集中插入：12 ，2 ，3 ，123 ，5 ，65 　　则输出该集时为：2 ，3 ，5 ，12 ，65 ，123

集和多集的区别是： set 支持唯一键值， set 中的值都是特定的，而且只出现一次；而 multiset 中可以出现副本键，同一值可以出现多次。

Set 和multiset 的模板参数：

template<class key, class compare, class Allocator=allocator>

第一个参数 key 是所存储的键的类型，第二个参数是为排序值而定义的比较函数的类型，第三个参数是被实现的存储分配符的类型。在有些编译器的具体实现中，第三个参数可以省略。第二个参数使用了合适形式的迭代器为键定义了特定的关系操作符，并用来在容器中遍历值时建立顺序。集的迭代器是双向，同时也是常量的，所以迭代器在使用的时候不能修改元素的值。

Set 定义了三个构造函数：
默认构造函数：

explicit set(const Compare&=compare());

如：set<int,less<int> > set1;

less<int> 是一个标准类，用于形成降序排列函数对象。升序排列是用 greater<int> 。通过指定某一预先定义的区间来初始化 set 对象的构造函数：

template<class InputIterator> set(InputIterator, InputIterator,/ const Compare&=compare());

如：set<int ,less<int> >set2(vector1.begin(),vector1.end());

复制构造函数：

set （const set<Key,Compare&> ）;

如：set<int ,less<int> >set3(set2);

下面我们来看一个简单的集和多集的插入例程：

#include <iostream>

#include <set>

using namespace std;

 

int main()

{

    set<int> set1;

    for(int i=0; i<10; ++i)

        set1.insert(i);

    for(set<int>::iterator p=set1.begin();p!=set1.end();++p)

        cout<<*p<<"";

    if(set1.insert(3).second)// 把3 插入到set1 中

// 插入成功则set1.insert(3).second 返回1 ，否则返回0

// 此例中，集中已经有3 这个元素了，所以插入将失败

        cout<<"set insert success";

    else

        cout<<"set insert failed";

    int a[] = {4, 1, 1, 1, 1, 1, 0, 5, 1, 0};

    multiset<int> A;

    A.insert(set1.begin(),set1.end());

    A.insert(a,a+10);

    cout<<endl;

    for(multiset<int>::iterator p=A.begin();p!=A.end();++p)

    cout<<*p<<" ";

    return 0;

}

u      映射和多重映射（map 和multimap ）

映射和多重映射( #include<map> ) 基于某一类型 Key 的键集的存在，提供对T 类型的数据进行快速和高效的检索。对 map 而言，键只是指存储在容器中的某一成员。 Map 不支持副本键， multimap 支持副本键。 Map 和 multimap 对象包涵了键和各个键有关的值，键和值的数据类型是不相同的，这与 set 不同。 set 中的 key 和 value 是 Key 类型的，而 map 中的 key 和 value 是一个 pair 结构中的两个分量。 Map 支持下表运算符 operator[] , 用访问普通数组的方式访问 map ，不过下标为 map 的键。在 multimap 中一个键可以对应多个不同的值。

下面的例程说明了 ma p 中键与值的关系。

#include <iostream>

#include <map>

using namespace std;

 

int main()

{

    map<char,int,less<char> > map1;

    map<char,int,less<char> >::iterator mapIter;

    //char 是键的类型，int 是值的类型

    // 下面是初始化，与数组类似

    // 也可以用map1.insert(map<char,int,less<char> >::value_type(''c'',3));

    map1['c']=3;

    map1['d']=4;

    map1['a']=1;

    map1['b']=2;

    for(mapIter=map1.begin();mapIter!=map1.end();++mapIter)

        cout<<" "<<(*mapIter).first<<": "<<(*mapIter).second;

    //first 对应定义中的char 键，second 对应定义中的int 值 

    // 检索对应于d 键的值是这样做的：

    map<char,int,less<char> >::const_iterator ptr;

    ptr=map1.find('d');

    cout<<'/n'<<" "<<(*ptr).first<<" 键对应于值："<<(*ptr).second;

    return 0;

}

　　从以上例程中，我们可以看到 map 对象的行为和一般数组的行为类似。 Map 允许两个或多个值使用比较操作符。下面我们再看看 multimap :

#include <iostream>

#include <map>

#include <string>

using namespace std;

 

int main()

{

    multimap<string,string,less<string> >mulmap;

    multimap<string,string,less<string> >::iterator p;

    // 初始化多重映射mulmap:

    typedef multimap<string,string,less<string> >::value_type vt;

    typedef string s;

    mulmap.insert(vt(s("Tom "),s("is a student")));

    mulmap.insert(vt(s("Tom "),s("is a boy")));

    mulmap.insert(vt(s("Tom "),s("is a bad boy of blue!")));

    mulmap.insert(vt(s("Jerry "),s("is a student")));

    mulmap.insert(vt(s("Jerry "),s("is a beatutiful girl")));

    mulmap.insert(vt(s("DJ "),s("is a student")));

    // 输出初始化以后的多重映射mulmap:

    for(p=mulmap.begin();p!=mulmap.end();++p)

        cout<<(*p).first<<(*p).second<<endl;

    // 检索并输出Jerry 键所对应的所有的值

    cout<<"find Jerry :"<<endl;

    p=mulmap.find(s("Jerry "));

    while((*p).first=="Jerry ")

    {

        cout<<(*p).first<<(*p).second<<endl;

        ++p;

    }   

    return 0;

}  

在 map 中是不允许一个键对应多个值的，在 multimap 中，不支持 operator[] , 也就是说不支持 map 中允许的下标操作。

2.        算法 （ algorithm ）：

#inlcude <algorithm>

STL 中算法的大部分都不作为某些特定容器类的成员函数，他们是泛型的，每个算法都有处理大量不同容器类中数据的使用。值得注意的是，STL 中的算法大多有多种版本，用户可以依照具体的情况选择合适版本。中在STL 的泛型算法中有4 类基本的算法：

变序型队列算法 ：可以改变容器内的数据；

非变序型队列算法 ：处理容器内的数据而不改变他们；

排序值算法： 包涵对容器中的值进行排序和合并的算法，还有二叉搜索算法、通用数值算法。（注：STL 的算法并不只是针对STL 容器，对一般容器也是适用的。）

变序型队列算法： 又叫可修改的序列算法。这类算法有复制（ copy ）算法、交换（ swap ）算法、替代（ replace ）算法、删除（clear ）算法，移动（ remove ）算法、翻转（ reverse ）算法等等。这些算法可以改变容器中的数据（数据值和值在容器中的位置）。

下面介绍2 个比较常用的算法 reverse() 和 copy() 。

#include <iostream>

#include <algorithm>

#include <iterator>

// 下面用到了输出迭代器ostream_iterator

using namespace std;

 

int main()

{

    int arr[6]={1,12,3,2,1215,90};

    int arr1[7];

    int arr2[6]={2,5,6,9,0,-56};

    copy(arr,(arr+6),arr1);// 将数组aar 复制到arr1

    cout<<"arr[6] copy to arr1[7],now arr1: "<<endl;

    for(int i=0;i<7;i++)

        cout<<" "<<arr1[i];

    reverse(arr,arr+6);// 将排好序的arr 翻转

    cout<<'/n'<<"arr reversed ,now arr:"<<endl;

    copy(arr,arr+6,ostream_iterator<int>(cout, " "));// 复制到输出迭代器

    swap_ranges(arr,arr+6,arr2);// 交换arr 和arr2 序列

    cout<<'/n'<<"arr swaped to arr2,now arr:"<<endl;

    copy(arr,arr+6,ostream_iterator<int>(cout, " "));

    cout<<'/n'<<"arr2:"<<endl;

    copy(arr2,arr2+6,ostream_iterator<int>(cout, " "));

    return 0;

}

revese() 的功能是将一个容器内的数据顺序翻转过来，它的原型是：

template<class Bidirectional>

void reverse(Bidirectional first, Bidirectional last);

将 first 和 last 之间的元素翻转过来，上例中你也可以只将 arr 中的一部分进行翻转：

reverse(arr+3,arr+6); 这也是有效的。First 和last 需要指定一个操作区间。

Copy() 是要将一个容器内的数据复制到另一个容器内，它的原型是：

  Template<class InputIterator ，class OutputIterator>

  OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result);

它把[first,last －1] 内的队列成员复制到区间[result,result+(last-first)-1] 中。泛型交换算法：

 

Swap() 操作的是单值交换，它的原型是：

template<class T>

void swap(T& a,T& b);

 

swap_ranges() 操作的是两个相等大小区间中的值，它的原型是：

  template<class ForwardIterator1, class ForwardIterator2>

  ForwardIterator2swap_ranges(ForwardIterator1 first1,ForwardIterator1 last1, ForwardIterator1 first2);

交换区间[first1,last1-1] 和[first2, first2+(last1-first1)-1] 之间的值，并假设这两个区间是不重叠的。

非变序型队列算法，又叫不可修改的序列算法。这一类算法操作不影响其操作的容器的内容，包括搜索队列成员算法，等价性检查算法，计算队列成员个数的算法。我将用下面的例子介绍其中的 find() , search() , count() ：

#include <iostream>

#include <vector>

#include <algorithm>

using namespace std;

 

int main()

{

    int a[10]={12,31,5,2,23,121,0,89,34,66};

    vector<int> v1(a,a+10);

    vector<int>::iterator result1,result2;// result1 和result2 是随机访问迭代器

    result1=find(v1.begin(),v1.end(),2);

    // 在v1 中找到2 ，result1 指向v1 中的2

    result2=find(v1.begin(),v1.end(),8);

    // 在v1 中没有找到8 ，result2 指向的是v1.end()

    cout<<result1-v1.begin()<<endl; // 3 －0 ＝3 或4 －1 ＝3 ，屏幕结果是3

    cout<<result2-v1.end()<<endl;   

    int b[9]={5,2,23,54,5,5,5,2,2};

    vector<int> v2(a+2,a+8);

    vector<int> v3(b,b+4);

    result1=search(v1.begin(),v1.end(),v2.begin(),v2.end());

    cout<<*result1<<endl;

    // 在v1 中找到了序列v2 ，result1 指向v2 在v1 中开始的位置

     result1=search(v1.begin(),v1.end(),v3.begin(),v3.end());

     cout<<*(result1-1)<<endl;

    // 在v1 中没有找到序列v3 ，result 指向v1.end(), 屏幕打印出v1 的最后一个元素66   

     vector<int> v4(b,b+9);

     int i=count(v4.begin(),v4.end(),5);

     int j=count(v4.begin(),v4.end(),2);

     cout<<"there are "<<i<<" members in v4 equel to 5"<<endl;

     cout<<"there are "<<j<<" members in v4 equel to 2"<<endl;

     // 计算v4 中有多少个成员等于 5,2

     return 0;        

}

find() 的原型是：

template<class InputIterator ，class EqualityComparable>

InputIterator find(InputIterator first, InputIterator last, const EqualityComparable& value);

其功能是在序列[ first,last-1 ] 中查找 value 值，如果找到，就返回一个指向 value 在序列中第一次出现的迭代，如果没有找到，就返回一个指向 last 的迭代（ last 并不属于序列）。

search() 的原型是：

template <class ForwardIterator1, class ForwardIterator2>

ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,                        ForwardIterator2 first2, ForwardIterator2 last2);

其功能是在源序列[ first1 , last1-1 ] 查找目标序列[ first2 ，last2-1 ] 如果查找成功，就返回一个指向源序列中目标序列出现的首位置的迭代。查找失败则返回一个指向 last 的迭代。

Count() 的原型是：

template <class InputIterator, class EqualityComparable>

iterator_traits<InputIterator>::difference_type count(InputIterator first,

InputIterator last, const EqualityComparable& value);

其功能是在序列[ first,last-1 ] 中查找出等于 value 的成员，返回等于 value 得成员的个数。

排序算法（sort algorithm ）：这一类算法很多，功能强大同时也相对复杂一些。这些算法依赖的是关系运算。在这里我只介绍其中比较简单的几种排序算法：s ort(),merge(),includes()

#include <iostream>

#include <algorithm>

using namespace std;

 

int main()

{

    int a[10]={12,0,5,3,6,8,9,34,32,18};

    int b[5]={5,3,6,8,9};

    int d[15];

    sort(a,a+10);

    for(int i=0;i<10;i++)

      cout<<" "<<a[i];

    sort(b,b+5);

    if(includes(a,a+10,b,b+5))

       cout<<'/n'<<"sorted b members are included in a."<<endl;

    else

       cout<<"sorted a dosn`t contain sorted b!";

    merge(a,a+10,b,b+5,d);

    for(int j=0;j<15;j++)

       cout<<" "<<d[j];

    return 0;

}

sort() 的原型是：

template <class RandomAccessIterator>

void sort(RandomAccessIterator first, RandomAccessIterator last);

功能是对[first,last-1] 区间内的元素进行排序操作。与之类似的操作还有：partial_sort(), stable_sort() ，partial_sort_copy() 等等。

merge() 的原型是：

template <class InputIterator1, class InputIterator2, class OutputIterator>

OutputIterator merge(InputIterator1 first1, InputIterator1 last1,InputIterator2  first2, InputIterator2 st2,OutputIterator result);

将有序区间[first1,last1-1] 和[first2,last2-1] 合并到[result, result + (last1 - first1) + (last2 - first2)-1] 区间内。

Includes() 的原型是：

template <class InputIterator1, class InputIterator2>

bool includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);

其功能是检查有序区间[ first2,last2-1 ] 内元素是否都在 [ first1,last1-1 ] 区间内，返回一个 bool 值。

通用数值算法（generalized numeric algorithms ）：这一类算法还不多，涉及到专业领域中有用的算术操作，独立包涵于头文件 <numeric> 中。
　　STL 中的算法大都有多种版本，常见的版本有以下4 中：

默认版本，假设给出了特定操作符；

一般版本，使用了成员提供的操作符；

复制版本，对原队列的副本进行操作，常带有 _copy 后缀；

谓词版本，只应用于满足给定谓词的队列成员，常带有 _if 后缀；

 

以上我们学习了STL 容器和算法的概念，以及一些简单的STL 容器和算法。在使用算法处理容器内的数据时，需要从一个数据成员移向另一个数据成员，迭代器恰好实现了这一功能。下面我们来学习STL 迭代器 。

3.        迭代器（ itertor ）：

#include<iterator>

迭代器实际上是一种泛化指针，如果一个迭代器指向了容器中的某一成员，那么迭代器将可以通过自增自减来遍历容器中的所有成员。迭代器是联系容器和算法的媒介，是算法操作容器的接口。在运用算法操作容器的时候，我们常常在不知不觉中已经使用了迭代器。
STL 中定义了6 种迭代器：

输入迭代器 ，在容器的连续区间内向前移动，可以读取容器内任意值；

输出迭代器 ，把值写进它所指向的队列成员中；

前向迭代器 ，读取队列中的值，并可以向前移动到下一位置（++p,p++ ）；

双向迭代器 ，读取队列中的值，并可以向前向后遍历容器；

随机访问迭代器, vector<T>::iterator ，list<T>::iterator 等都是这种迭代器 ；

流迭代器 ，可以直接输出、输入流中的值；

实际上，在前面的例子中，我们不停的在用迭代器。下面我们用几个例子来帮助理解这些迭代器的用法。
下面的例子用到了输入输出迭代器：

#include <iostream>

#include <fstream>

#include <iterator>

#include <vector>

#include <string>

using namespace std;

 

int main()

{

    vector<string> v1;

    ifstream file("Text1.txt");

    if(file.fail())

    {

        cout<<"open file Text1.txt failed"<<endl;

        return 1;

    }   

    copy(istream_iterator<string>(file),istream_iterator<string>(),inserter(v1,v1.begin()));

    copy(v1.begin(),v1.end(),ostream_iterator<string>(cout," "));

    cout<<endl;

    return 0;

}

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

inserter (container ,pos);

container 是将要用来存入数据的容器， pos 是容器存入数据的开始位置。上例中，是把文件内容存入（ copy() ）到向量 v1 中。

4.        STL 的其他标准组件

函数对象（ functor 或者 funtion objects ）

#include<functional>

函数对象又称之为仿函数。函数对象将函数封装在一个对象中，使得它可作为参数传递给合适的STL 算法，从而使算法的功能得以扩展。可以把它当作函数来使用。用户也可以定义自己的函数对象。下面让我们来定义一个自己的函数对象.

#include <iostream>

using namespace std;

 

struct int_max{

int operator()(int x,int y){return x>y?x:y; }

};//operator() 重载了" （）" ， (int x,int y) 是参数列表

 

int main()

{

    cout<<int_max()(3,4)<<endl;

    return 0;

}

这里的 int_max （） 就是一个函数对象， struct 关键字也可以用 class 来代替，只不过 struct 默认情况下是公有访问权限，而 class 定义的是默认私有访问权限。下面我们来定义一个STL 风格的函数对象：

#include <iostream>

#include <vector>

using namespace std;

 

struct adder : public unary_function<double, void>

{

    adder() : sum(0) {}

    double sum;

    void operator()(double x) { sum += x; }

};

 

int main()

{  

    double a[5]={0.5644,1.1,6.6,8.8,9.9};

    vector<double> V(a,a+5);

    adder result = for_each(V.begin(), V.end(), adder());

    cout << "The sum is " << result.sum << endl;

    return 0;

}

在这里，我们定义了一个函数对象 adder() ，这也是一个类，它的基类是 unary_function 函数对象。 unary_function 是一个空基类，不包涵任何操作或变量。只是一种格式说明，它有两个参数，第一个参数是函数对象的使用数据类型，第二个参数是它的返回类型。基于它所定义的函数对象是一元函数对象。（注：用关键字 struct 或者 class 定义的类型实际上都是" 类" ）

STL 内定义了各种函数对象，否定器、约束器、一元谓词、二元谓词都是常用的函数对象。函数对象对于编程来说很重要，因为他如同对象类型的抽象一样作用于操作。

适配器（ adapter ）

适配器是用来修改其他组件接口的STL 组件，是带有一个参数的类模板（这个参数是操作的值的数据类型）。STL 定义了3 种形式的适配器：容器适配器，迭代器适配器，函数适配器。

容器适配器： 包括栈（ stack ）、队列( queue ) 、优先( priority_queue ) 。使用容器适配器，stack 就可以被实现为基本容器类型（ vector,dequeue,list ）的适配。可以把stack 看作是某种特殊的 vctor 、deque 或者 list 容器，只是其操作仍然受到stack 本身属性的限制。queue 和priority_queue 与之类似。容器适配器的接口更为简单，只是受限比一般容器要多；

迭代器适配器： 修改为某些基本容器定义的迭代器的接口的一种STL 组件。反向迭代器和插入迭代器都属于迭代器适配器，迭代器适配器扩展了迭代器的功能；

函数适配器： 通过转换或者修改其他函数对象使其功能得到扩展。这一类适配器有否定器（相当于" 非" 操作）、帮定器、函数指针适配器。