C++之STL（标准模板库）介绍

一、C++ STL概述

1994 年，STL 被正式纳入 C++ 标准中。STL 是“Standard Template Library”（标准模板库）的缩写。STL 是 C++ 标准库的一部分，不用单独安装。

 

C++ 对模板（Template）支持得很好，STL 就是借助模板把常用的数据结构及其算法都实现了一遍，并且做到了数据结构和算法的分离。例如，vector 的底层为顺序表（数组），list 的底层为双向链表，deque 的底层为循环队列，set 的底层为红黑树，hash_set 的底层为哈希表。

标准模板库（STL），它的基本概念就是把数据和操作分离，含有容器（Container）、算法（Algorithm）、迭代器（Iterator）等组件。

通常认为，STL 是由容器、算法、迭代器、函数对象、适配器、内存分配器这 6 部分构成，其中后面 4 部分是为前 2 部分服务的，它们各自的含义如下表：

STL的组成	含义
容器	一些封装数据结构的模板类，例如 vector 向量容器、list 列表容器等。
算法	STL 提供了非常多（大约 100 个）的数据结构算法，它们都被设计成一个个的模板函数，这些算法在 std 命名空间中定义，其中大部分算法都包含在头文件 <algorithm> 中，少部分位于头文件 <numeric> 中。
迭代器	在 C++ STL 中，对容器中数据的读和写，是通过迭代器完成的，扮演着容器和算法之间的胶合剂。
函数对象（又称仿函数）	如果一个类将 () 运算符重载为成员函数，这个类就称为函数对象类，这个类的对象就是函数对象（又称仿函数）。
适配器	可以使一个类的接口（模板的参数）适配成用户指定的形式，从而让原本不能在一起工作的两个类工作在一起。值得一提的是，容器、迭代器和函数都有适配器。
内存分配器	为容器类模板提供自定义的内存申请和释放功能，由于往往只有高级用户才有改变内存分配策略的需求，因此内存分配器对于一般用户来说，并不常用。

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

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

从逻辑层次来看，在STL中体现了泛型（generic）化程序设计的思想，引入了诸多新的名词，比如像需求（requirements），概念（concept），模型（model），容器（container），算法（algorithmn），迭代器（iterator）等。与OOP（object-oriented programming）中的多态（polymorphism）一样，泛型也是一种软件的复用技术；泛型编程(Generic Programming) 指在多种数据类型上皆可操作，泛型算法是建立在语法一致性上。

从实现层次看，整个STL是以一种类型参数化的方式实现的，这种方式基于一个在早先C++标准中没有出现的语言特性——模板（template）。从根本上说，STL 是一些容器、算法和其他一些组件的集合，所有容器和算法都是总结了几十年来算法和数据结构的研究成果，汇集了许多计算机专家学者经验的基础上实现的，因此可以说，STL 基本上达到了各种存储方法和相关算法的高度优化。

STL容器

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

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

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

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

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

      Sets/Multisets：内部的元素依据其值自动排序，Set内的相同数值的元素只能出现一次，Multisets内可包含多个数值相同的元素，内部由二叉树实现（实际上基于红黑树(RB-tree）实现），便于查找；

      Maps/Multimaps：Map的元素是成对的键值/实值，内部的元素依据其值自动排序，Map内的相同数值的元素只能出现一次，Multimaps内可包含多个数值相同的元素，内部由二叉树实现（实际上基于红黑树(RB-tree）实现），便于查找；

另外有其他容器hash_map,hash_set,hash_multiset,hash_multimap。

  容器的比较：

	Vector	Deque	List	Set	MultiSet	Map	MultiMap
内部结构	dynamic array	array of arrays	double linked  list	binary tree	binary tree	binary tree	binary tree
随机存取	Yes	Yes	No	No	No	Yes(key)	No
搜索速度	慢	慢	很慢	快	快	快	快
快速插入移除	尾部	首尾	任何位置	--	--	--	--

 

【STL通用容器分三类：顺序性容器、关联式容器和容器适配器。

简单的理解，容器适配器其就是将不适用的序列式容器（包括 vector、deque 和 list）变得适用。

 容器适配器本质上还是容器，只不过此容器模板类的实现，利用了大量其它基础容器模板类中已经写好的成员函数。当然，如果必要的话，容器适配器中也可以自创新的成员函数。】

 

STL迭代器

无论是序列容器还是关联容器，最常做的操作无疑是遍历容器中存储的元素，而实现此操作，多数情况会选用“迭代器（iterator）”来实现。尽管不同容器的内部结构各异，但它们本质上都是用来存储大量数据的，换句话说，都是一串能存储多个数据的存储单元。因此，诸如数据的排序、查找、求和等需要对数据进行遍历的操作方法应该是类似的。

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

STL 标准库为每一种标准容器定义了一种迭代器类型，这意味着，不同容器的迭代器也不同，其功能强弱也有所不同。

容器的迭代器的功能强弱，决定了该容器是否支持 STL 中的某种算法。

常用的迭代器按功能强弱分为输入迭代器、输出迭代器、前向迭代器（forward iterator）、双向迭代器（bidirectional iterator）、随机访问迭代器 5 种。

迭代器类别	说明
输入	从容器中读取元素。输入迭代器只能一次读入一个元素向前移动， 输入迭代器只支持一遍算法，同一个输入迭代器不能两遍遍历一个序列
输出	向容器中写入元素。输出迭代器只能一次一个元素向前移动。 输出迭代器只支持一遍算法，统一输出迭代器不能两次遍历一个序列
正向	组合输入迭代器和输出迭代器的功能，并保留在容器中的位置
双向	组合正向迭代器和逆向迭代器的功能，支持多遍算法
随机访问	组合双向迭代器的功能与直接访问容器中任何元素的功能， 即可向前向后跳过任意个元素

迭代器遍历访问的大致思路是，创建容器的迭代器，让迭代器指向第一个元素，逐步向后移动并最终指向最后一个元素结束。

遍历示例代码：

vector<int> v(10,5);    //创建一个向量v，其已开辟10个元素的空间并全部赋值为5

vector<int>::iterator it;   //用迭代器（iterator）访问

for(it=v.begin();it!=v.end();it++){

    cout<<*it<<' ';

}

 

当然，遍历也可以直接使用下标访问：

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

        cout<<v[i]<<' ';

 }

 

算法

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

算法部分主要由头文件<algorithm>，<numeric>和<functional>组成。

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

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

<functional>中则定义了一些模板类，用以声明函数对象。

STL中算法大致分为四类：

非可变序列算法：指不直接修改其所操作的容器内容的算法。

可变序列算法：指可以修改它们所操作的容器内容的算法。

排序算法：对序列进行排序和合并的算法、搜索算法以及有序序列上的集合操作。

数值算法：对容器内容进行数值计算。

 

二、C++ STL几个常见容器的使用

★Vector（向量）容器

Vector是最简单的序列是容器，就像数组一样，向量使用连续的存储位置作为元素，这意味着它们的元素也可以使用常量指向其元素的偏移来访问，与数组一样有效。但与数组不同，它们的大小可以动态变化，其存储由容器自动处理。

 

Vector就是一个动态创建空间，且预先加载了常用的数组操作的数组。

相关文件

头文件：#include <vector>

格式为：vector<Data_Types> name;

如：

vector<int> v1;          //创建一个空的向量v1

vector<int> v2(10);      //创建一个向量v2，其已开辟10个元素的空间，相当于int v[10];

vector<int> v3(10,5);    //创建一个向量v3，其已开辟10个元素的空间并全部赋值为5

 

下面给出一个完整示例：

#include<iostream>
#include<vector>
using namespace std;
int main()
{
    vector<string> v1;
    //添加 2个值到向量中
    v1.push_back("一民");
    v1.push_back("，你好啊！");
    // 使用迭代器 iterator 访问值
    for(vector<string>::iterator itr=v1.begin();itr!=v1.end();++itr){
        cout<<*itr;
    }
    return 0; 
}

运行输出：
一民，你好啊！
 

vector的遍历有多种方式：

[]方式，如果越界或出现其他错误，不会抛出异常，可能会崩溃，可能数据随机出现；

at方式，如果越界或出现其他错误，会抛出异常，需要捕获异常并处理；

迭代器提供了逆向遍历，可以通过迭代器来实现逆向遍历，当然上面两种方式也可以。

如：

#include<iostream>
#include<vector>
using namespace std;
int main()
{
//创建vector
    vector<int> v1;
    
    //插入元素
    for (int i = 0; i < 10; i++) {
        v1.push_back(i);
    }
    
    //遍历-[]取值
    for (int i = 0; i < v1.size(); i++) {
        cout << v1[i] << " ";
    }
    cout << endl;
   
    //遍历-at取值
    for (int i = 0; i < v1.size(); i++) {
        cout << v1.at(i) << " ";
    }
    cout << endl;

    //遍历-迭代器遍历
    for (vector<int>::iterator it = v1.begin(); it != v1.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
    
    //遍历-迭代器逆向遍历
    for (vector<int>::reverse_iterator it = v1.rbegin(); it != v1.rend(); it++) {
        cout << *it << " ";
    }
    cout << endl;
    
    //测试越界
    cout << "[]越界:" << v1[20] << endl;      //不会抛出异常，可能会崩溃，可能会乱码
    cout << "at越界:" << v1.at(20) << endl;   //会抛出异常，需要捕获异常
    
    return 0;
}

运行输出：

0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3 2 1 0
[]越界:1596032
terminate called after throwing an instance of 'std::out_of_range'
  what():  vector::_M_range_check: __n (which is 20) >= this->size() (which is 10)
 

关于上面实例中所使用的begin() 、end()函数见下面。

 

C ++ Vector（向量）常见的成员函数：

函数  描述

at(idx)      传回索引idx所指的数据，如果idx越界，抛出out_of_range。

back()       返回最后一个原始，不检查这个数据是否存在。

front()      返回第一个元素。

swap()      交换两个Vector。

push_back()     在Vector最后添加一个元素。

pop_back()      它从向量中删除最后一个元素。

empty()    判断Vector是否为空（返回true时为空）

insert()     它将在指定位置插入新元素。

erase()     删除指定的元素。

resize()     它修改向量的大小。

clear()      它从向量中删除所有元素。

size()        返回Vector元素数量的大小。

capacity() 返回vector所能容纳的元素数量(在不重新分配内存的情况下）

assign()    它将新值分配给向量。

operator=()      它将新值分配给向量容器。

operator[]()     它访问指定的元素。

end()        返回最末元素的迭代器(实指向最末元素的下一个位置)

emplace()        它将在位置pos之前插入一个新元素。

emplace_back()      它在末尾插入一个新元素。

rend()       它指向向量的第一个元素之前的元素。

rbegin()    它指向向量的最后一个元素。

begin()     返回第一个元素的迭代器。

max_size()       返回Vector所能容纳元素的最大数量（上限）。

cend()      它指向量中的last-last-element。

cbegin()   它指向量的第一个元素。

crbegin()  它指的是向量的最后一个字符。

crend()     它指的是向量的第一个元素之前的元素。

data()       它将向量的数据写入数组。

shrink_to_fit() 它减少了容量并使它等于向量的大小。

 

★Deque（双端队列）

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

双端队列表示双端队列。它概括了队列数据结构，即可以从前端或后端的两端进行插入和删除。

 

 

相关文件

头文件：#include<deque>

创建语法格式为：deque<object_type> deque_name;

如：

deque<type> deq;  // 声明一个元素类型为type的双端队列que

deque<type> deq(size);  //声明一个类型为type、含有size个默认值初始化元素的的双端队列que

deque<type> deq(size, value);  //声明一个元素类型为type、含有size个value元素的双端队列que

deque<type> deq(mydeque);  // deq是mydeque的一个副本

deque<type> deq(first, last);  // 使用迭代器first、last范围内的元素初始化deq

 

实例

#include<iostream>
#include<deque>
using namespace std;
int main(void)
{
	int i;
	int a[10] = { 0,1,2,3,4,5,6,7,8,9 };
	deque<int> q;
	for (i = 0; i <= 9; i++)
	{
		if (i % 2 == 0)
			q.push_front(a[i]);
		else
			q.push_back(a[i]);
	}                   //此时队列里的内容是: {8,6,4,2,0,1,3,5,7,9}
	q.pop_front();
	cout << q.front()<< endl;   //清除第一个元素后输出第一个(6)
	q.pop_back();
	cout << q.back() << endl;   //清除最后一个元素后输出最后一个(7)
	deque<int>::iterator it;
	for (it = q.begin(); it != q.end(); it++) {
		cout << *it << '\t';
	}
	cout << endl;
	system("pause");
	return 0;
}

运行输出：

6
7
6       4       2       0       1       3       5       7

 

C ++ Deque（双端队列）常见的成员函数：

函数/方法       描述

assign()    它分配新内容并替换旧内容。

emplace()        它将在指定位置添加一个新元素。

emplace_back()      它在末尾添加一个新元素。

emplace_front()      它在双端队列的开头添加一个新元素。

insert()     它在指定位置之前添加一个新元素。

push_back()     它在容器的末尾添加一个新元素。

push_front()    它在容器的开头添加一个新元素。

pop_back()      它从双端队列中删除最后一个元素。

pop_front()      它从双端队列中删除第一个元素。

swap()      它交换两个双端队列的内容。

clear()      它将删除双端队列的所有内容。

empty()    它检查容器是否为空。

erase()     它删除元素。

max_size()       它确定双端队列的最大大小。

resize()     它改变了双端队列的大小。

shrink_to_fit() 它减少了内存以适合双端队列的大小。

size()        它返回元素数。

at()   它访问位置pos处的元素。

operator[]()     它访问位置pos处的元素。

operator=()      它将新的内容分配给容器。

back()       它访问最后一个元素。

begin()     它将迭代器返回到双端队列的开头。

cbegin()   它向双端队列的开头返回一个常量迭代器。

end()        它将迭代器返回到末尾。

cend()      它将常量迭代器返回到末尾。

rbegin()    它将反向迭代器返回到开头。

crbegin()  它将常量反向迭代器返回到开头。

rend()       它将反向迭代器返回到末尾。

crend()     它将常量反向迭代器返回到末尾。

front()      它访问最后一个元素。

 

★List（列表）容器

list是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的 。list支持双向，并为插入和删除操作提供了一种有效的方法。在列表中遍历速度很慢，因为列表元素是按顺序访问的。

相关文件

头文件：#include<list>

创建语法格式为：list <object_type> list _name;

如：

list<int> l1;           //创建一个空链表

list<int> l2(10);       //创建一个链表其有10个空元素

list<int> l3(5,20);     //创建一个链表其有5个元素内容为20

 

实例

#include<iostream>
#include<list>
using namespace std;
int cmp(const int &a,const int &b){ 
    //简单的自定义降序序列
    return a>b;
}
int main(){
    list<int> li;           //创建一个空链表
    for(int i=10;i>=6;i--){
        li.push_back(i);
    }
    li.push_front(3);
    li.push_back(20);
    list<int> li2(li);
    for(list<int>::iterator it=li.begin();it!=li.end();it++){
        cout<<*it<<' ';
    }
    cout<<endl;
//排序前3 10 9 8 7 6 20//
    li.sort();
  
    for(list<int>::iterator it=li.begin();it!=li.end();it++){
        cout<<*it<<' ';
    }
    cout<<endl;
//默认排序后 3 6 7 8 9 10 20//
    li2.sort(cmp);
    for(list<int>::iterator it=li2.begin();it!=li2.end();it++){
        cout<<*it<<' ';
    }
    cout<<endl;
//自定义排序后 20 10 9 8 7 6 3//
    return 0;
}

运行输出：

3 10 9 8 7 6 20

3 6 7 8 9 10 20

20 10 9 8 7 6 3

 

list容器具有如下特性：

可以在头部和尾部插入和删除元素；

不能随机访问元素，也就是迭代器只能只能++,不能一次性跳转。

如：

#include<iostream>
#include<list>
using namespace std;
int main()
{
	//创建list对象
    list<int> l;
    
    //尾部添加元素
    for (int i = 0; i < 10; i++) {
        l.push_back(i);
    }
    
    //头部添加元素
    l.push_front(22);
    
    //遍历
    for (list<int>::iterator it = l.begin(); it != l.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
    
    //list不能随机访问
    list<int>::iterator it = l.begin();
    it++;
    it++;
    cout << *it <<endl;

//    it = it + 5;  //编译报错，不能随机访问
        
    return 0;
}

运行输出：

22 0 1 2 3 4 5 6 7 8 9
1

 

List（列表）常见的成员函数：

函数/方法        描述

insert()     它将新元素插入到迭代器指向的位置之前。

push_back()      它在容器的末尾添加了一个新元素。

push_front()     它在前面增加了一个新元素。

pop_back()       删除最后一个元素。

pop_front()       删除第一个元素。

empty()    它检查列表是否为空。

size()         它查找列表中存在的元素数。

max_size()        它找到列表的最大大小。

front()       它返回列表的第一个元素。

back()       它返回列表的最后一个元素。

swap()      当两个列表的类型相同时，它将交换两个列表。

reverse()  它反转了列表的元素。

sort()         它以递增的顺序对列表中的元素进行排序。

merge()    它合并两个排序的列表。

splice()      它将新列表插入到调用列表中。

unique()   它从列表中删除所有重复的元素。

resize()     它更改列表容器的大小。

assign()     它将一个新元素分配给列表容器。

emplace()         它将在指定位置插入一个新元素。

emplace_back()        它将在容器的末尾插入一个新元素。

emplace_front()       它将在列表的开头插入一个新元素。

 

★set（集合）/multiset（多重集合）容器

set/multiset属于关联式容器，底层结构是用二叉树实现。

 

set和multiset区别：

set不允许容器中有重复的元素，其中每个键都是唯一的，可以插入或删除但不能更改。

multiset允许容器中有重复的元素。

 

相关文件

头文件：#include <set>

创建语法格式为：set| multiset <object_type> name;

如：

set<int> set1; //创建默认的从小到大的int类型的集合

set<int,less<int> > set2; //创建一个从小打到大的int类型的集合，注意> >之间有空格。

set<int,greater<int> > set3; //创建一个从大到小的int类型的集合，注意> >之间有空格。

特别提示：set/multiset容器是有序的集合，默认的顺序是从小到大的。

 

Set示例：

#include<iostream>
#include<set>
using namespace std;
int main()
{
    set<int> s;
    s.insert(1);
    s.insert(2);
    s.insert(3);
    s.insert(1);
    //输出结果按照从小到大的顺序排序
    for (set<int>::iterator x = s.begin(); x != s.end(); x++)
    {
    	cout << *x << endl;
	}
    cout << endl;
    s.erase(2);    //删除一个元素
    for (set<int>::iterator x = s.begin(); x != s.end(); x++)
    {
    	cout << *x << endl;
	}
    //判断一个元素是否存在
    if (s.count(1))
        cout << "存在\n";
    else
        cout << "不存在\n";
        
    return 0; 
}

运行输出：

1
2
3

1
3
存在

 

Multiset示例：

#include<iostream>
#include<set>
using namespace std;
int main()
{
    multiset<int> s;
    s.insert(1);
    s.insert(2);
    s.insert(3);
    s.insert(1);
    //输出结果按照从小到大的顺序排序
    for (multiset<int>::iterator x = s.begin(); x != s.end(); x++)
    {
    	cout << *x << endl;
	}
    cout << endl;
    s.erase(2);    //删除一个元素
    for (multiset<int>::iterator x = s.begin(); x != s.end(); x++)
    {
    	cout << *x << endl;
	}
    //判断一个元素是否存在
    if (s.count(1))
        cout << "存在\n";
    else
        cout << "不存在\n";
        
    return 0; 
}

运行输出：

1
1
2
3

1
1
3
存在

 

set（集合）/multiset（多重集合）常见成员函数的列表：

函数/方法       描述

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

clear()  清除所有元素

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

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

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

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

erase()  删除集合中的元素

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

get_allocator()  返回集合的分配器

insert()  在集合中插入元素

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

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

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

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

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

size()  集合中元素的数目

swap()  交换两个集合变量

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

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

 

★map（映射）/multimap（多重映射）容器

map和multimap都是键值对（key-value），每一个元素都有一个键，唯一的不同是，map的键值key不可重复，而multimap可以，也正是由于这种区别，map支持[ ]运算符，multimap不支持[ ]运算符。在用法上没什么区别。map和multimap都需要#include<map>。

相关文件

头文件：#include <map>

创建语法格式为：map| multimap <object_type> name;

如：

map<int, string> mapName;

 

map示例：

#include <iostream>
#include <map>  //map
using namespace std;   
int main()
{
    //创建并初始化 multimap 容器
    map<char, int>mymap{ {'a',10},{'b',20},{'b',15}, {'c',30} };
    //输出 mymap 容器存储键值对的数量
    cout << mymap.size() << endl;
    //输出 mymap 容器中存储键为 'b' 的键值对的数量
    cout << mymap.count('b') << endl;
    for (auto iter = mymap.begin(); iter != mymap.end(); ++iter) {
        cout << iter->first << " " << iter->second << endl;
    }
    return 0;
}

运行输出：

3
1
a 10
b 20
c 30

 

multimap示例：

#include <iostream>
#include <map>  //map
using namespace std;   
int main()
{
    //创建并初始化 multimap 容器
    multimap<char, int>mymultimap{ {'a',10},{'b',20},{'b',15}, {'c',30} };
    //输出 mymultimap 容器存储键值对的数量
    cout << mymultimap.size() << endl;
    //输出 mymultimap 容器中存储键为 'b' 的键值对的数量
    cout << mymultimap.count('b') << endl;
    for (auto iter = mymultimap.begin(); iter != mymultimap.end(); ++iter) {
        cout << iter->first << " " << iter->second << endl;
    }
    return 0;
}

运行输出：

4
2
a 10
b 20
b 15
c 30

 

Map（映射）/multimap（多重映射）常见成员函数的列表：

函数/方法       描述

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的函数

 

★array容器

array 容器是 C++ 11 标准中新增的序列容器，简单地理解，它就是在 C++ 普通数组的基础上，添加了一些成员函数和全局函数。在使用上，它比普通数组更安全。和其它容器不同，array 容器的大小是固定的，无法动态的扩展或收缩，这也就意味着，在使用该容器的过程无法借由增加或移除元素而改变其大小，它只允许访问或者替换存储的元素。

array 容器以类模板的形式定义在 <array> 头文件，并位于命名空间 std 中，因此，在使用该容器之前，代码中需引入 <array> 头文件，并默认使用 std 命令空间，如下所示：

#include <array>

using namespace std;

 

array 容器有多种初始化方式，如下代码展示了如何创建具有 10 个 double 类型元素的 array 容器：

std::array<double, 10> values;

【提示，如果程序中已经默认指定了 std 命令空间，这里可以省略 std::】

由此，就创建好了一个名为 values 的 array 容器，其包含 10 个浮点型元素。但是，由于未显式指定这 10 个元素的值，因此使用这种方式创建的容器中，各个元素的值是不确定的。

 

std::array<double, 10> values {};

使用该语句，容器中所有的元素都会被初始化为 0.0。

 

在创建 array 容器的实例时，也可以像创建常规数组那样对元素进行初始化：

std::array<double, 10> values {0.5,1.0,1.5,,2.0};

可以看到，这里只初始化了前 4 个元素，剩余的元素都会被初始化为 0.0。如下图所示：

 

array容器成员函数

成员函数        功能

begin()     返回指向容器中第一个元素的随机访问迭代器。

end()        返回指向容器最后一个元素之后一个位置的随机访问迭代器，通常和 begin() 结合使用。

rbegin()    返回指向最后一个元素的随机访问迭代器。

rend()       返回指向第一个元素之前一个位置的随机访问迭代器。

cbegin()   和 begin() 功能相同，只不过在其基础上增加了 const 属性，不能用于修改元素。

cend()      和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。

crbegin()  和 rbegin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。

crend()     和 rend() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。

size()        返回容器中当前元素的数量，其值始终等于初始化 array 类的第二个模板参数 N。

max_size()       返回容器可容纳元素的最大数量，其值始终等于初始化 array 类的第二个模板参数 N。

empty()    判断容器是否为空，和通过 size()==0 的判断条件功能相同，但其效率可能更快。

at(n) 返回容器中 n 位置处元素的引用，该函数自动检查 n 是否在有效的范围内，如果不是则抛出 out_of_range 异常。

front()      返回容器中第一个元素的直接引用，该函数不适用于空的 array 容器。

back()       返回容器中最后一个元素的直接应用，该函数同样不适用于空的 array 容器。

data()       返回一个指向容器首个元素的指针。利用该指针，可实现复制容器中所有元素等类似功能。

fill(val)      将 val 这个值赋值给容器中的每个元素。

array1.swap(array2)        交换 array1 和 array2 容器中的所有元素，但前提是它们具有相同的长度和类型。

 

示例：

#include <iostream>
//需要引入 array 头文件
#include <array>
using namespace std;
int main()
{
    std::array<int, 4> values{};
    //初始化 values 容器为 {0,1,2,3}
    for (int i = 0; i < values.size(); i++) {
        values.at(i) = i;
    }
    //使用 get() 重载函数输出指定位置元素
    cout << get<3>(values) << endl;
    //如果容器不为空，则输出容器中所有的元素
    if (!values.empty()) {
        for (auto val = values.begin(); val < values.end(); val++) {
            cout << *val << " ";
        }
    }
}

 

运行之输出结果为：

3
0 1 2 3