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
附录、参考资料
https://blog.csdn.net/u010183728/article/details/81913729