C中STL用法超详细总结（收藏级）

开通VIP，畅享免费电子书等14项超值服

首页

好书

留言交流

下载APP

联系客服

2023.02.26贵州

STL（StandardTemplateLibrary），即标准模板库，是一个具有工业强度的，高效的C++程序库。它被容纳于C++标准程序库（C++StandardLibrary）中，是ANSI/ISOC++标准中最新的也是极具革命性的一部分。该库包含了诸多在计算机科学领域里所常用的基本数据结构和基本算法。为广大C++程序员们提供了一个可扩展的应用框架，高度体现了软件的可复用性。

STL的一个重要特点是数据结构和算法的分离。尽管这是个简单的概念，但这种分离确实使得STL变得非常通用。例如，由于STL的sort()函数是完全通用的，你可以用它来操作几乎任何数据集合，包括链表，容器和数组；

STL另一个重要特性是它不是面向对象的。为了具有足够通用性，STL主要依赖于模板而不是封装，继承和虚函数（多态性）——OOP的三个要素。你在STL中找不到任何明显的类继承关系。这好像是一种倒退，但这正好是使得STL的组件具有广泛通用性的底层特征。另外，由于STL是基于模板，内联函数的使用使得生成的代码短小高效；

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

从实现层次看，整个STL是以一种类型参数化的方式实现的，这种方式基于一个在早先C++标准中没有出现的语言特性--模板（template）。

STL中六大组件：

容器（Container），是一种数据结构，如list，vector，和deques，以模板类的方法提供。为了访问容器中的数据，可以使用由容器类输出的迭代器；

迭代器（Iterator），提供了访问容器中对象的方法。例如，可以使用一对迭代器指定list或vector中的一定范围的对象。迭代器就如同一个指针。事实上，C++的指针也是一种迭代器。但是，迭代器也可以是那些定义了operator*()以及其他类似于指针的操作符地方法的类对象；

算法（Algorithm），是用来操作容器中的数据的模板函数。例如，STL用sort()来对一个vector中的数据进行排序，用find()来搜索一个list中的对象，函数本身与他们操作的数据的结构和类型无关，因此他们可以在从简单数组到高度复杂容器的任何数据结构上使用；

仿函数（Functor）

适配器（Adaptor）

分配器（allocator）

STL中的容器有队列容器和关联容器，容器适配器（congtaineradapters：stack,queue，priorityqueue），位集（bit_set），串包(string_package)等等。

（1）序列式容器（Sequencecontainers），每个元素都有固定位置－－取决于插入时机和地点，和元素值无关，vector、deque、list；

Vector：将元素置于一个动态数组中加以管理，可以随机存取元素（用索引直接存取），数组尾部添加或移除元素非常快速。但是在中部或头部安插元素比较费时；

Deque：是“double-endedqueue”的缩写，可以随机存取元素（用索引直接存取），数组头部和尾部添加或移除元素都非常快速。但是在中部或头部安插元素比较费时；

List：双向链表，不提供随机存取（按顺序走到需存取的元素，O(n)），在任何位置上执行插入或删除动作都非常迅速，内部只需调整一下指针；

（2）关联式容器（Associatedcontainers），元素位置取决于特定的排序准则，和插入顺序无关，set、multiset、map、multimap等。

Set/Multiset：内部的元素依据其值自动排序，Set内的相同数值的元素只能出现一次，Multisets内可包含多个数值相同的元素，内部由二叉树实现，便于查找；

Map/Multimap：Map的元素是成对的键值/实值，内部的元素依据其值自动排序，Map内的相同数值的元素只能出现一次，Multimaps内可包含多个数值相同的元素，内部由二叉树实现，便于查找；

容器类自动申请和释放内存，无需new和delete操作。

Iterator（迭代器）模式又称Cursor（游标）模式，用于提供一种方法顺序访问一个聚合对象中各个元素,而又不需暴露该对象的内部表示。或者这样说可能更容易理解：Iterator模式是运用于聚合对象的一种模式，通过运用该模式，使得我们可以在不知道对象内部表示的情况下，按照一定顺序（由iterator提供的方法）访问聚合对象中的各个元素。

迭代器的作用：能够让迭代器与算法不干扰的相互发展，最后又能无间隙的粘合起来，重载了*，＋＋，＝＝，！＝，＝运算符。用以操作复杂的数据结构，容器提供迭代器，算法使用迭代器；常见的一些迭代器类型：iterator、const_iterator、reverse_iterator和const_reverse_iterator.

函数库对数据类型的选择对其可重用性起着至关重要的作用。举例来说，一个求方根的函数，在使用浮点数作为其参数类型的情况下的可重用性肯定比使用整型作为它的参数类性要高。而C++通过模板的机制允许推迟对某些类型的选择，直到真正想使用模板或者说对模板进行特化的时候，STL就利用了这一点提供了相当多的有用算法。它是在一个有效的框架中完成这些算法的——你可以将所有的类型划分为少数的几类，然后就可以在模版的参数中使用一种类型替换掉同一种类中的其他类型。

STL提供了大约100个实现算法的模版函数，比如算法for_each将为指定序列中的每一个元素调用指定的函数，stable_sort以你所指定的规则对序列进行稳定性排序等等。只要我们熟悉了STL之后，许多代码可以被大大的化简，只需要通过调用一两个算法模板，就可以完成所需要的功能并大大地提升效率。

算法部分主要由头文件，和组成。

是所有STL头文件中最大的一个（尽管它很好理解），它是由一大堆模版函数组成的，可以认为每个函数在很大程度上都是独立的，其中常用到的功能范围涉及到比较、交换、查找、遍历操作、复制、修改、移除、反转、排序、合并等等。

体积很小，只包括几个在序列上面进行简单数学运算的模板函数，包括加法和乘法在序列上的一些操作。

STL中算法大致分为四类：

以下对所有算法进行细致分类并标明功能：

<一>查找算法(13个)：判断容器中是否包含某个值

adjacent_find:在iterator对标识元素范围内，查找一对相邻重复元素，找到则返回指向这对元素的第一个元素的ForwardIterator。否则返回last。重载版本使用输入的二元操作符代替相等的判断。

binary_search:在有序序列中查找value，找到返回true。重载的版本实用指定的比较函数对象或函数指针来判断相等。

count:利用等于操作符，把标志范围内的元素与输入值比较，返回相等元素个数。

count_if:利用输入的操作符，对标志范围内的元素进行操作，返回结果为true的个数。

equal_range:功能类似equal，返回一对iterator，第一个表示lower_bound，第二个表示upper_bound。

find:利用底层元素的等于操作符，对指定范围内的元素与输入值进行比较。当匹配时，结束搜索，返回该元素的一个InputIterator。

find_end:在指定范围内查找'由输入的另外一对iterator标志的第二个序列'的最后一次出现。找到则返回最后一对的第一个ForwardIterator，否则返回输入的'另外一对'的第一个ForwardIterator。重载版本使用用户输入的操作符代替等于操作。

find_first_of:在指定范围内查找'由输入的另外一对iterator标志的第二个序列'中任意一个元素的第一次出现。重载版本中使用了用户自定义操作符。

find_if:使用输入的函数代替等于操作符执行find。

lower_bound:返回一个ForwardIterator，指向在有序序列范围内的可以插入指定值而不破坏容器顺序的第一个位置。重载函数使用自定义比较操作。

upper_bound:返回一个ForwardIterator，指向在有序序列范围内插入value而不破坏容器顺序的最后一个位置，该位置标志一个大于value的值。重载函数使用自定义比较操作。

search:给出两个范围，返回一个ForwardIterator，查找成功指向第一个范围内第一次出现子序列(第二个范围)的位置，查找失败指向last1。重载版本使用自定义的比较操作。

search_n:在指定范围内查找val出现n次的子序列。重载版本使用自定义的比较操作。

<二>排序和通用算法(14个)：提供元素排序策略

inplace_merge:合并两个有序序列，结果序列覆盖两端范围。重载版本使用输入的操作进行排序。

merge:合并两个有序序列，存放到另一个序列。重载版本使用自定义的比较。

nth_element:将范围内的序列重新排序，使所有小于第n个元素的元素都出现在它前面，而大于它的都出现在后面。重载版本使用自定义的比较操作。

partial_sort:对序列做部分排序，被排序元素个数正好可以被放到范围内。重载版本使用自定义的比较操作。

partial_sort_copy:与partial_sort类似，不过将经过排序的序列复制到另一个容器。

partition:对指定范围内元素重新排序，使用输入的函数，把结果为true的元素放在结果为false的元素之前。

random_shuffle:对指定范围内的元素随机调整次序。重载版本输入一个随机数产生操作。

reverse:将指定范围内元素重新反序排序。

reverse_copy:与reverse类似，不过将结果写入另一个容器。

rotate:将指定范围内元素移到容器末尾，由middle指向的元素成为容器第一个元素。

rotate_copy:与rotate类似，不过将结果写入另一个容器。

sort:以升序重新排列指定范围内的元素。重载版本使用自定义的比较操作。

stable_sort:与sort类似，不过保留相等元素之间的顺序关系。

stable_partition:与partition类似，不过不保证保留容器中的相对顺序。

<三>删除和替换算法(15个)

copy:复制序列

copy_backward:与copy相同，不过元素是以相反顺序被拷贝。

iter_swap:交换两个ForwardIterator的值。

remove:删除指定范围内所有等于指定元素的元素。注意，该函数不是真正删除函数。内置函数不适合使用remove和remove_if函数。

remove_copy:将所有不匹配元素复制到一个制定容器，返回OutputIterator指向被拷贝的末元素的下一个位置。

remove_if:删除指定范围内输入操作结果为true的所有元素。

remove_copy_if:将所有不匹配元素拷贝到一个指定容器。

replace:将指定范围内所有等于vold的元素都用vnew代替。

replace_copy:与replace类似，不过将结果写入另一个容器。

replace_if:将指定范围内所有操作结果为true的元素用新值代替。

replace_copy_if:与replace_if，不过将结果写入另一个容器。

swap:交换存储在两个对象中的值。

swap_range:将指定范围内的元素与另一个序列元素值进行交换。

unique:清除序列中重复元素，和remove类似，它也不能真正删除元素。重载版本使用自定义比较操作。

unique_copy:与unique类似，不过把结果输出到另一个容器。

<四>排列组合算法(2个)：提供计算给定集合按一定顺序的所有可能排列组合

next_permutation:取出当前范围内的排列，并重新排序为下一个排列。重载版本使用自定义的比较操作。

prev_permutation:取出指定范围内的序列并将它重新排序为上一个序列。如果不存在上一个序列则返回false。重载版本使用自定义的比较操作。

<五>算术算法(4个)

accumulate:iterator对标识的序列段元素之和，加到一个由val指定的初始值上。重载版本不再做加法，而是传进来的二元操作符被应用到元素上。

partial_sum:创建一个新序列，其中每个元素值代表指定范围内该位置前所有元素之和。重载版本使用自定义操作代替加法。

inner_product:对两个序列做内积(对应元素相乘，再求和)并将内积加到一个输入的初始值上。重载版本使用用户定义的操作。

adjacent_difference:创建一个新序列，新序列中每个新值代表当前元素与上一个元素的差。重载版本用指定二元操作计算相邻元素的差。

<六>生成和异变算法(6个)

fill:将输入值赋给标志范围内的所有元素。

fill_n:将输入值赋给first到first+n范围内的所有元素。

for_each:用指定函数依次对指定范围内所有元素进行迭代访问，返回所指定的函数类型。该函数不得修改序列中的元素。

generate:连续调用输入的函数来填充指定的范围。

generate_n:与generate函数类似，填充从指定iterator开始的n个元素。

transform:将输入的操作作用与指定范围内的每个元素，并产生一个新的序列。重载版本将操作作用在一对元素上，另外一个元素来自输入的另外一个序列。结果输出到指定容器。

<七>关系算法(8个)

equal:如果两个序列在标志范围内元素都相等，返回true。重载版本使用输入的操作符代替默认的等于操作符。

includes:判断第一个指定范围内的所有元素是否都被第二个范围包含，使用底层元素的<操作符，成功返回true。重载版本使用用户输入的函数。

lexicographical_compare:比较两个序列。重载版本使用用户自定义比较操作。

max:返回两个元素中较大一个。重载版本使用自定义比较操作。

max_element:返回一个ForwardIterator，指出序列中最大的元素。重载版本使用自定义比较操作。

min:返回两个元素中较小一个。重载版本使用自定义比较操作。

min_element:返回一个ForwardIterator，指出序列中最小的元素。重载版本使用自定义比较操作。

mismatch:并行比较两个序列，指出第一个不匹配的位置，返回一对iterator，标志第一个不匹配元素位置。如果都匹配，返回每个容器的last。重载版本使用自定义的比较操作。

<八>集合算法(4个)

set_union:构造一个有序序列，包含两个序列中所有的不重复元素。重载版本使用自定义的比较操作。

set_intersection:构造一个有序序列，其中元素在两个序列中都存在。重载版本使用自定义的比较操作。

set_difference:构造一个有序序列，该序列仅保留第一个序列中存在的而第二个中不存在的元素。重载版本使用自定义的比较操作。

set_symmetric_difference:构造一个有序序列，该序列取两个序列的对称差集(并集-交集)。

<九>堆算法(4个)

make_heap:把指定范围内的元素生成一个堆。重载版本使用自定义比较操作。

pop_heap:并不真正把最大元素从堆中弹出，而是重新排序堆。它把first和last-1交换，然后重新生成一个堆。可使用容器的back来访问被'弹出'的元素或者使用pop_back进行真正的删除。重载版本使用自定义的比较操作。

push_heap:假设first到last-1是一个有效堆，要被加入到堆的元素存放在位置last-1，重新生成堆。在指向该函数前，必须先把元素插入容器后。重载版本使用指定的比较操作。

sort_heap:对指定范围内的序列重新排序，它假设该序列是个有序堆。重载版本使用自定义比较操作。

2.4.1概述

仿函数(functor)，就是使一个类的使用看上去象一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了。

有些功能的的代码，会在不同的成员函数中用到，想复用这些代码。

1）公共的函数，可以，这是一个解决方法，不过函数用到的一些变量，就可能成为公共的全局变量，再说为了复用这么一片代码，就要单立出一个函数，也不是很好维护。

2）仿函数，写一个简单类，除了那些维护一个类的成员函数外，就只是实现一个operator()，在类实例化时，就将要用的，非参数的元素传入类中。

2.4.2仿函数(functor)在编程语言中的应用

1）C语言使用函数指针和回调函数来实现仿函数，例如一个用来排序的函数可以这样使用仿函数

2）在C++里，我们通过在一个类中重载括号运算符的方法使用一个函数对象而不是一个普通函数。

#include#includeusingnamespacestd;templateclassdisplay{public: voidoperator()(constT&x) { cout<()); system('pause'); return0;}2.4.3仿函数在STL中的定义

要使用STL内建的仿函数，必须包含头文件。而头文件中包含的仿函数分类包括

1）算术类仿函数

加：plus

减：minus

乘：multiplies

除：divides

模取：modulus

否定：negate

例子：

2）关系运算类仿函数

等于：equal_to

不等于：not_equal_to

大于：greater

大于等于：greater_equal

小于：less

小于等于：less_equal

从大到小排序：

#include#include#include#includeusingnamespacestd;templateclassdisplay{public: voidoperator()(constT&x) { cout<iv(ia,ia+5); sort(iv.begin(),iv.end(),greater()); for_each(iv.begin(),iv.end(),display()); system('pause'); return0;}3）逻辑运算仿函数

逻辑与：logical_and

逻辑或：logical_or

逻辑否：logical_no

标准库提供了三种顺序容器适配器：queue(FIFO队列)、priority_queue(优先级队列)、stack(栈)

什么是容器适配器

适配器是使一种事物的行为类似于另外一种事物行为的一种机制”，适配器对容器进行包装，使其表现出另外一种行为。例如，stack>实现了栈的功能，但其内部使用顺序容器vector来存储数据。（相当于是vector表现出了栈的行为）。

容器适配器

要使用适配器，需要加入一下头文件：

#include//stack

#include//queue、priority_queue

1、初始化

stackstk(dep);

2、覆盖默认容器类型

stack>stk;

实例：括号匹配

#include#include#include#includeusingnamespacestd;intmain(){ strings; stackss; while(cin>>s) { boolflag=true; for(charc:s)//C++11新标准，即遍历一次字符串s { if(c=='('||c=='{'||c=='[') { ss.push(c); continue; } if(c=='}') { if(!ss.empty()&&ss.top()=='{') { ss.pop(); continue; } else { flag=false; break; } } if(!ss.empty()&&c==']') { if(ss.top()=='[') { ss.pop(); continue; } else { flag=false; break; } } if(!ss.empty()&&c==')') { if(ss.top()=='(') { ss.pop(); continue; } else { flag=false; break; } } } if(flag) cout<<'Match!'<

1.构造函数

2.增加函数

3.删除函数

4.遍历函数

5.判断函数

6.大小函数

7.其他函数

8.看着清楚

1.push_back在数组的最后添加一个数据

2.pop_back去掉数组的最后一个数据

.at-DomainParked得到编号位置的数据

4.begin得到数组头的指针

5.end得到数组的最后一个单元+1的指针

6．front得到数组头的引用

7.back得到数组的最后一个单元的引用

8.max_size得到vector最大可以是多大

9.capacity当前vector分配的大小

10.size当前使用数据的大小

11.resize改变当前使用数据的大小，如果它比当前使用的大，者填充默认值

12.reserve改变当前vecotr所分配空间的大小

13.erase删除指针指向的数据项

14.clear清空当前的vector

15.rbegin将vector反转后的开始指针返回(其实就是原来的end-1)

16.rend将vector反转构的结束指针返回(其实就是原来的begin-1)

17.empty判断vector是否为空

18.swap与另一个vector交换数据

3.1.2基本用法

#includeusingnamespacestd;3.1.3简单介绍

3.1.4实例

3.1.4.1pop_back()&push_back(elem)实例在容器最后移除和插入数据

输出结果为：

0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,3.1.4.2clear()清除容器中所有数据

0,1,2,3,4,5,6,7,8,9,3.1.4.3排序

从小到大:0,1,3,从大到小:3,1,0,1.注意sort需要头文件#include

2.如果想sort来降序，可重写sort

3.1.4.4访问（直接数组访问&迭代器访问）

3.1.4.5二维数组两种定义方法（结果一样）

方法一

#include#include#include#includeusingnamespacestd;intmain(){intN=5,M=6;vector>obj(N);//定义二维动态数组大小5行for(inti=0;i

0000000000000000000000000000003.2deque所谓的deque是”doubleendedqueue”的缩写，双端队列不论在尾部或头部插入元素，都十分迅速。而在中间插入元素则会比较费时，因为必须移动中间其他的元素。双端队列是一种随机访问的数据类型，提供了在序列两端快速插入和删除操作的功能，它可以在需要的时候改变自身大小，完成了标准的C++数据结构中队列的所有功能。

虽然deque也提供RandomAccessIterator，但它的迭代器并不是普通指针，其复杂度和vector不可同日而语，这当然涉及到各个运算层面。因此，除非必要，我们应尽可能选择使用vector而非deque。对deque进行的排序操作，为了最高效率，可将deque先完整复制到一个vector身上，将vector排序后（利用STL的sort算法），再复制回deque。

deque是一种优化了的对序列两端元素进行添加和删除操作的基本序列容器。通常由一些独立的区块组成，第一区块朝某方向扩展，最后一个区块朝另一方向扩展。它允许较为快速地随机访问但它不像vector一样把所有对象保存在一个连续的内存块，而是多个连续的内存块。并且在一个映射结构中保存对这些块以及顺序的跟踪。

3.2.2deque的常用成员函数

dequedeq;3.2.3deque的一些特点

3.2.4实例

输出结果：

List是stl实现的双向链表，与向量(vectors)相比,它允许快速的插入和删除，但是随机访问却比较慢。使用时需要添加头文件

#include

listlst1;//创建空list

listlst2(5);//创建含有5个元素的list

listlst3(3,2);//创建含有3个元素的list

listlst4(lst2);//使用lst2初始化lst4

listlst5(lst2.begin(),lst2.end());//同lst4

3.3.3list常用操作函数

Lst1.assign()给list赋值

Lst1.back()返回最后一个元素

Lst1.begin()返回指向第一个元素的迭代器

Lst1.clear()删除所有元素

Lst1.empty()如果list是空的则返回true

Lst1.end()返回末尾的迭代器

Lst1.erase()删除一个元素

Lst1.front()返回第一个元素

Lst1.get_allocator()返回list的配置器

Lst1.insert()插入一个元素到list中

Lst1.max_size()返回list能容纳的最大元素数量

Lst1.merge()合并两个list

Lst1.pop_back()删除最后一个元素

Lst1.pop_front()删除第一个元素

Lst1.push_back()在list的末尾添加一个元素

Lst1.push_front()在list的头部添加一个元素

Lst1.rbegin()返回指向第一个元素的逆向迭代器

Lst1.remove()从list删除元素

Lst1.remove_if()按指定条件删除元素

Lst1.rend()指向list末尾的逆向迭代器

Lst1.resize()改变list的大小

Lst1.reverse()把list的元素倒转

Lst1.size()返回list中的元素个数

Lst1.sort()给list排序

Lst1.splice()合并两个list

Lst1.swap()交换两个list

Lst1.unique()删除list中相邻重复的元素

3.3.4.1迭代器遍历list

for(list::const_iteratoriter=lst1.begin();iter!=lst1.end();iter++){cout<<*iter;}cout<

输出结果

3.3.4.3综合实例2

map和multimap都需要#include

C++中map提供的是一种键值对容器，里面的数据都是成对出现的,如下图：每一对中的第一个值称之为关键字(key)，每个关键字只能在map中出现一次；第二个称之为该关键字的对应值。

Map是STL的一个关联容器，它提供一对一（其中第一个可以称为关键字，每个关键字只能在map中出现一次，第二个可能称为该关键字的值）的数据处理能力，由于这个特性，它完成有可能在我们处理一对一数据的时候，在编程上提供快速通道。这里说下map内部数据的组织，map内部自建一颗红黑树(一种非严格意义上的平衡二叉树)，这颗树具有对数据自动排序的功能，所以在map内部所有的数据都是有序的。

3.4.1基本操作函数

begin()返回指向map头部的迭代器

clear(）删除所有元素

count()返回指定元素出现的次数

empty()如果map为空则返回true

end()返回指向map末尾的迭代器

equal_range()返回特殊条目的迭代器对

erase()删除一个元素

find()查找一个元素

get_allocator()返回map的配置器

insert()插入元素

key_comp()返回比较元素key的函数

lower_bound()返回键值>=给定元素的第一个位置

max_size()返回可以容纳的最大元素个数

rbegin()返回一个指向map尾部的逆向迭代器

rend()返回一个指向map头部的逆向迭代器

size()返回map中元素的个数

swap()交换两个map

upper_bound()返回键值>给定元素的第一个位置

value_comp()返回比较元素value的函数

3.4.3迭代器

共有八个获取迭代器的函数：*begin,end,rbegin,rend*以及对应的*cbegin,cend,crbegin,crend*。

二者的区别在于，后者一定返回const_iterator，而前者则根据map的类型返回iterator或者const_iterator。const情况下，不允许对值进行修改。如下面代码所示：

map::iteratorit;mapmmap;constmapconst_mmap;it=mmap.begin();//iteratormmap.cbegin();//const_iteratorconst_mmap.begin();//const_iteratorconst_mmap.cbegin();//const_iterator返回的迭代器可以进行加减操作，此外，如果map为空，则begin=end。

3.4.4插入操作

3.4.4.1用insert插入pair数据

3.4.4.2用insert函数插入value_type数据

//第二种：用insert函数插入value_type数据，下面举例说明#include

insert共有4个重载函数：

下面是具体使用示例：

#include#include

以上三种用法，虽然都可以实现数据的插入，但是它们是有区别的，当然了第一种和第二种在效果上是完成一样的，用insert函数插入数据，在数据的插入上涉及到集合的唯一性这个概念，即当map中有这个关键字时，insert操作是插入数据不了的，但是用数组方式就不同了，它可以覆盖以前该关键字对应的值，用程序说明

mapStudent.insert(map::value_type(1,'student_one'));

mapStudent.insert(map::value_type(1,'student_two'));

上面这两条语句执行后，map中1这个关键字对应的值是“student_one”，第二条语句并没有生效，那么这就涉及到我们怎么知道insert语句是否插入成功的问题了，可以用pair来获得是否插入成功，程序如下

pair::iterator,bool>Insert_Pair;

Insert_Pair=mapStudent.insert(map::value_type(1,'student_one'));

我们通过pair的第二个变量来知道是否插入成功，它的第一个变量返回的是一个map的迭代器，如果插入成功的话Insert_Pair.second应该是true的，否则为false。

下面给出完成代码，演示插入成功与否问题

//验证插入函数的作用效果#include

查找

//关键字查询，找到则返回指向该关键字的迭代器，否则返回指向end的迭代器//根据map的类型，返回的迭代器为iterator或者const_iteratoriteratorfind(constkey_type&k);const_iteratorfind(constkey_type&k)const;删除

交换

//就是两个map的内容互换voidswap(map&other);3.4.6容量

3.4.7排序

map中的元素是自动按Key升序排序，所以不能对map用sort函数；

这里要讲的是一点比较高深的用法了,排序问题，STL中默认是采用小于号来排序的，以上代码在排序上是不存在任何问题的，因为上面的关键字是int型，它本身支持小于号运算，在一些特殊情况，比如关键字是一个结构体或者自定义类，涉及到排序就会出现问题，因为它没有小于号操作，insert等函数在编译的时候过不去，下面给出两个方法解决这个问题。

3.4.7.1小于号<重载

#include#include#include

3.4.8unordered_map

在c++11标准前，c++标准库中只有一种map，但是它的底层实现并不是适合所有的场景，如果我们需要其他适合的map实现就不得不使用比如boost库等三方的实现，在c++11中加了一种mapunordered_map,unordered_set,他们的实现有什么不同呢？

还有另外一点从占用内存上来说因为unordered_map才用hash结构会有一定的内存损失，它的内存占用回高于map。

最后就是她们的场景了，首先如果你需要对map中的数据排序，就首选map，他会把你的数据按照key的自然排序排序（由于它的底层实现红黑树机制所以会排序），如果不需要排序，就看你对内存和cpu的选择了，不过一般都会选择unordered_map，它的查找效率会更高。

至于使用方法和函数，两者差不多，由于篇幅限制这里不再赘述，unordered_multimap用法亦可类推。

std::set是关联容器，含有Key类型对象的已排序集。用比较函数compare进行排序。搜索、移除和插入拥有对数复杂度。set通常以红黑树实现。

set容器内的元素会被自动排序，set与map不同，set中的元素即是键值又是实值，set不允许两个元素有相同的键值。不能通过set的迭代器去修改set元素，原因是修改元素会破坏set组织。当对容器中的元素进行插入或者删除时，操作之前的所有迭代器在操作之后依然有效。

由于set元素是排好序的，且默认为升序，因此当set集合中的元素为结构体或自定义类时，该结构体或自定义类必须实现运算符'<’的重载。

multiset特性及用法和set完全相同，唯一的差别在于它允许键值重复。

set和multiset的底层实现是一种高效的平衡二叉树，即红黑树（Red-BlackTree）。

3.5.1set常用成员函数

1.begin()--返回指向第一个元素的迭代器

2.clear()--清除所有元素

3.count()--返回某个值元素的个数

4.empty()--如果集合为空，返回true

5.end()--返回指向最后一个元素的迭代器

6.equal_range()--返回集合中与给定值相等的上下限的两个迭代器

7.erase()--删除集合中的元素

8.find()--返回一个指向被查找到元素的迭代器

9.get_allocator()--返回集合的分配器

10.insert()--在集合中插入元素

11.lower_bound()--返回指向大于（或等于）某值的第一个元素的迭代器

12.key_comp()--返回一个用于元素间值比较的函数

13.max_size()--返回集合能容纳的元素的最大限值

14.rbegin()--返回指向集合中最后一个元素的反向迭代器

15.rend()--返回指向集合中第一个元素的反向迭代器

16.size()--集合中元素的数目

17.swap()--交换两个集合变量

18.upper_bound()--返回大于某个值元素的迭代器

19.value_comp()--返回一个用于比较元素间的值的函数

3.5.2代码示例

以下代码涉及的内容：

1、set容器中，元素类型为基本类型，如何让set按照用户意愿来排序？

2、set容器中，如何让元素类型为自定义类型？

3、set容器的insert函数的返回值为什么类型？

3.5.3unordered_set

C++11中出现了两种新的关联容器:unordered_set和unordered_map，其内部实现与set和map大有不同，set和map内部实现是基于RB-Tree，而unordered_set和unordered_map内部实现是基于哈希表(hashtable)，由于unordered_set和unordered_map内部实现的公共接口大致相同，所以本文以unordered_set为例。

unordered_set是基于哈希表，因此要了解unordered_set，就必须了解哈希表的机制。哈希表是根据关键码值而进行直接访问的数据结构，通过相应的哈希函数(也称散列函数)处理关键字得到相应的关键码值，关键码值对应着一个特定位置，用该位置来存取相应的信息，这样就能以较快的速度获取关键字的信息。比如：现有公司员工的个人信息（包括年龄），需要查询某个年龄的员工个数。由于人的年龄范围大约在[0，200]，所以可以开一个200大小的数组，然后通过哈希函数得到key对应的key-value，这样就能完成统计某个年龄的员工个数。而在这个例子中，也存在这样一个问题，两个员工的年龄相同，但其他信息（如：名字、身份证）不同，通过前面说的哈希函数，会发现其都位于数组的相同位置，这里，就涉及到“冲突”。准确来说，冲突是不可避免的，而解决冲突的方法常见的有：开发地址法、再散列法、链地址法(也称拉链法)。而unordered_set内部解决冲突采用的是----链地址法，当用冲突发生时把具有同一关键码的数据组成一个链表。下图展示了链地址法的使用:

使用unordered_set需要包含#include头文件，同unordered_map类似，用法没有什么太大的区别，参考set/multiset。