C++常见容器一网打尽

Posted 2023-04-09 头发够用的程序员

1.概述

C++容器属于STL（标准模板库）中的一部分（六大组件之一），从字面意思理解，生活中的容器用来存放（容纳）水或者食物，东西，而C++中的容器用来存放各种各样的数据，不同的容器具有不同的特性，下图（思维导图）中列举除了常见的几种C++容器，而这部分C++的容器与python中的序列有很多相似之处，也许这也很好地印证了江湖上“C生万物”的说法。因本人是学完python后才学C++的，突然有种：“山重水复疑无路，柳暗花明又一村”的感觉。因为python是偏向于顶层的语言，那时候什么迭代器，生成器之类的东西都不是非常清楚，然后在C++中又遇到了类似内容，便有了更好的理解，也许这就是很多人不建议初学者学习python的原因吧。

2.容器详解

2.1vector（向量）

从这个命名就可以很好地理解，在线性代数中，向量是一维的结构，而在容器中，向量也是看似一维的存储形式。可以理解为长度可变的数组。只不过在尾部增删数据的时候效率最高，其他位置增删数据则效率较低。举个例子（开胃菜）：

#include <iostream> 
#include <vector> 
using namespace std;
// 程序的主函数
int main()

	vector<int> V;
	V.push_back(1);
	V.push_back(2);
	V.push_back(1);
	V.push_back(2);
	cout << V[0] << endl;
	system("pause");
	return 0;

打印输出：1。
从上面的例子可以看出，向量和数组的用法极其类似。当然，容器还有一个极其好用的功能，就是容器的嵌套使用。

#include <iostream> 
#include <vector> 
using namespace std;
// 程序的主函数
int main()

	vector<vector<int>> V;
	vector<int> sub_V;
	sub_V.push_back(1);
	sub_V.push_back(2);
	sub_V.push_back(1);
	V.push_back(sub_V);
	cout << V[0][1] << endl;
	system("pause");
	return 0;

打印输出2这个时候的向量可以看作是一个二维数组，当然比二维数组更加灵活、强大。
当然向量容器还有其他更加丰富的操作。比如：

    int size = vec1.size();         //元素个数
 
    bool isEmpty = vec1.empty();    //判断是否为空
 
    vec1.insert(vec1.end(),5,3);    //从vec1.back位置插入5个值为3的元素
 
    vec1.pop_back();              //删除末尾元素
 
    vec1.erase(vec1.begin(),vec1.end());//删除之间的元素，其他元素前移
 
    cout<<(vec1==vec2)?true:false;  //判断是否相等==、！=、>=、<=...
 
    vector<int>::iterator iter = vec1.begin();    //获取迭代器首地址
 
    vector<int>::const_iterator c_iter = vec1.begin();   //获取const类型迭代器
 
    vec1.clear();                 //清空元素

举个最常见的例子：

#include <iostream> 
#include <vector> 
using namespace std;
// 程序的主函数
int main()

	vector<int> V;
	V.push_back(1);
	V.push_back(2);
	V.push_back(3);
	for (vector<int>::iterator it = V.begin(); it != V.end(); it++)
		cout << *it << " ";
	cout << endl;
	cout << "==========================" << endl;
	V.insert(V.begin() + 2,10);
	for (vector<int>::iterator it = V.begin(); it != V.end(); it++)
		cout << *it << " ";
	system("pause");
	return 0;

注意如果不是在其尾部插入数据，要传入插入位置的迭代器。
打印输出：

2.2deque（双端队列）

deque，顾名思义，从前后两端都可以进行数据的插入和删除操作，同时支持数据的快速随机访问。举个例子：

#include <iostream> 
#include <deque> 
using namespace std;
// 程序的主函数
int main()

	deque<int> D;
	D.push_back(1);
	D.push_back(2);
	D.push_back(3);
	for (deque<int>::iterator it = D.begin(); it != D.end(); it++)
		cout << *it << " ";
	cout << endl;
	cout << "============在其索引2的位置插入10：" << endl;
	D.insert(D.begin() + 2,10);
	for (deque<int>::iterator it = D.begin(); it != D.end(); it++)
		cout << *it << " ";
	cout << endl;
	cout << "============在其头部插入0：" << endl;
	D.push_front(0);
	for (deque<int>::iterator it = D.begin(); it != D.end(); it++)
		cout << *it << " ";
	cout << endl;
	cout << "============在其头部弹出0：" << endl;
	D.pop_front();
	for (deque<int>::iterator it = D.begin(); it != D.end(); it++)
		cout << *it << " ";
	system("pause");
	return 0;

打印输出：

2.3list（列表）

列表是用双向链表实现的，所谓的双向链表，指的是既可以从链表的头部开始搜索找到链表的尾部，也可以进行反向搜索，从尾部到头部。这使得list在任何位置插入和删除元素都变得非常高效，但是随机访问速度变得非常慢，因为保存的地址是不连续的，所以list没有重载[]运算符，也就是说，访问list元素的时候，再也不像向量和双端队列那么方便，不可以像我们以前在C语言的时候，访问数组那样对其元素进行访问。
一起来看个例子：

#include <iostream> 
#include <list> 
using namespace std;
// 程序的主函数
int main()

	//list的创建和初始化
	list<int> lst1;          //创建空list


	list<int> lst2(3);       //创建含有三个元素的list


	list<int> lst3(3, 2); //创建含有三个元素的值为2的list


	list<int> lst4(lst3);    //使用lst3初始化lst4


	list<int> lst5(lst3.begin(), lst3.end());  //同lst4
	cout << "lst4中的元素有：" << endl;
	for (list<int>::iterator it = lst4.begin(); it != lst4.end(); it++)
		cout << *it << " ";
	cout << endl;
	cout << "lst5中的元素有：" << endl;
	for (list<int>::iterator it = lst5.begin(); it != lst5.end(); it++)
		cout << *it << " ";
	cout << endl;
	system("pause");
	return 0;

运行，打印输出：

然后再来看一个元素的添加，排序的例子。

#include <iostream> 
#include <list> 
#include <vector> 
using namespace std;
// 程序的主函数
int main()

	//list的创建和初始化
	list<int> lst1;          //创建空list

	for(int i = 0; i < 10; i++)
		lst1.push_back(9-i);                    //添加值
	cout << "lst1中的元素有：" << endl;
	for (list<int>::iterator it = lst1.begin(); it != lst1.end(); it++)
		cout << *it << " ";
	cout << endl;
	cout << "对lst1中的元素进行排序：" << endl;
	lst1.sort();
	for (list<int>::iterator it = lst1.begin(); it != lst1.end(); it++)
		cout << *it << " ";
	cout << endl;
	cout << "在索引为5的地方插入999：" << endl;
	list<int>::iterator insert_it = lst1.begin();
	for (int i = 0; i < 5; i++)
		insert_it++;
	lst1.insert(insert_it, 3, 999);
	for (list<int>::iterator it = lst1.begin(); it != lst1.end(); it++)
		cout << *it << " ";
	cout << endl;
	cout << "删除相邻重复元素后：" << endl;
	lst1.unique();                         //删除相邻重复元素
	for (list<int>::iterator it = lst1.begin(); it != lst1.end(); it++)
		cout << *it << " ";
	cout << endl;
	system("pause");
	return 0;

运行后，打印输出：

特别注意，由于list的底层是双向链表，因此insert操作无法直接像向量和双端队列一样直接插入数据，只能通过迭代器的自加移动到相应位置，再插入数据。

2.4 array（数组）

array和C语言中的数组没有太大的区别，建立后只能存储一种类型的数据，且不能改变大小。比较简单，举个例子：

#include <iostream> 
#include <string>
#include <array>
using namespace std;
// 程序的主函数
int main()

	array<int, 4> arr = 1, 3, 2;
	cout << "arr values:" << std::endl;
	for (array<int, 4>::iterator it = arr.begin(); it != arr.end(); it++) 
		cout << *it << " ";
	
	cout << endl;
	cout << "sizeof(arr) = " << sizeof(arr) << endl;
	cout << "size of arr = " << arr.size() << endl;
	cout << "max size arr = " << arr.max_size() << endl;
	cout << "empty = " << (arr.empty() ? "no" : "yes") << endl;
	system("pause");
	return 0;

当然，最常见的，array也支持嵌套，可以采用这样的方式来构建二维（多维）数组，由于比较简单，就不举例了。

2.5 string（字符串）

与vector相似的容器。专门用于保存字符。随机访问快。尾部插入删除快。在部分说法中，string不算是STL容器，但是为了内容的完整性，我们还是将其一并学习。

#include <iostream> 
#include <string>
using namespace std;
// 程序的主函数
int main()

	string s1 = "Bob:";
	string s2("hellow world!");
	for (int i = 0; i < s1.size(); i++)
	
		cout << s1[i];
	
	cout << endl;
	for (int i = 0; i < s2.size(); i++)
	
		cout << s2[i];
	
	cout << endl;

	cout << s1 + s2 << endl;
	s1.insert(s1.size(),"you say ");
	cout << s1 + s2 << endl;
	system("pause");
	return 0;

运行，打印输出如下：

通过以上例子可以发现，与我们在C语言中学习的string并没有多少区别，其实本身区别也不是很大，只是在创建了之后还可以添加元素（盲猜是新创建了一个同名的string，仅此而已），且添加元素的方式也很简单，直接通过insert(插入位置，需要添加的字符串)这样的格式添加即可。上面一个例子是从末尾添加的，所以索引肯定是s1.size()。当然还有字符串的相加，字符串的比较等，都是属于更为基础的内容，没有添加到例子当中去，感兴趣的同学可以自己找资料去学习。

2.6 map（映射）

map容器和python中的字典非常类似，或者说一模一样。都是通过键值对的方式来存储和访问数据的，底层是通过红黑树来实现的。先来看个map的创建以及初始化的例子。

#include <iostream> 
#include <map> 
#include <string>
using namespace std;
// 程序的主函数
int main()

	//map的创建和初始化
	//第一种：用insert函数插入pair数据：
	map<int, string> my_map;
	my_map.insert(pair<int, string>(1, "first"));
	my_map.insert(pair<int, string>(2, "second"));
	//第二种：用insert函数插入value_type数据：
	my_map.insert(map<int, string>::value_type(3, "first"));
	my_map.insert(map<int, string>::value_type(4, "second"));
	//第三种：用数组的方式直接赋值：
	my_map[5] = "first";
	my_map[6] = "second";
	map<int, string>::iterator it;           //迭代器遍历
	for (it = my_map.begin(); it != my_map.end(); it++)
		cout << it->first << "->" <<it->second << endl;
	system("pause");
	return 0;

运行，打印输出如下结果：

从以上结果可以看出，其中数组直接赋值的方法最简单直接，最容易理解。当然map保存的是键值对，所以前面的int类型数据（key）并不代表其位置。比方说，我们将其中的int修改为float也是可以的。代码如下：

#include <iostream> 
#include <map> 
#include <string>
using namespace std;
// 程序的主函数
int main()

	//map的创建和初始化
	//第一种：用insert函数插入pair数据：
	map<float, string> my_map;
	my_map.insert(pair<float, string>(1, "first"));
	my_map.insert(pair<float, string>(2, "second"));
	//第二种：用insert函数插入value_type数据：
	my_map.
        
                

                    
首先我们分别画图来看看，BIO、NIO、AIO，分别是什么？
 
 
 
BIO：传统的网络通讯模型，就是BIO，同步阻塞IO
 
 
 
它其实就是服务端创建一个ServerSocket， 然后就是客户端用一个Socket去连接服务端的那个ServerSocket， ServerSocket接收到了一个的连接请求就创建一个Socket和一个线程去跟那个Socket进行通讯。
 
 
 
接着客户端和服务端就进行阻塞式的通信，客户端发送一个请求，服务端Socket进行处理后返回响应。
 
 
 
在响应返回前，客户端那边就阻塞等待，上门事情也做不了。
 
 
 
这种方式的缺点：每次一个客户端接入，都需要在服务端创建一个线程来服务这个客户端
 
 
 
这样大量客户端来的时候，就会造成服务端的线程数量可能达到了几千甚至几万，这样就可能会造成服务端过载过高，最后崩溃死掉。
 
 
 
BIO模型图：
 
 
 
 
Acceptor：
 
传统的IO模型的网络服务的设计模式中有俩种比较经典的设计模式：一个是多线程， 一种是依靠线程池来进行处理。
 
 
 
如果是基于多线程的模式来的话，就是这样的模式，这种也是Acceptor线程模型。
 
 
 
 
NIO：
 
NIO是一种同步非阻塞IO, 基于Reactor模型来实现的。
 
 
 
其实相当于就是一个线程处理大量的客户端的请求，通过一个线程轮询大量的channel，每次就获取一批有事件的channel，然后对每个请求启动一个线程处理即可。
 
 
 
这里的核心就是非阻塞，就那个selector一个线程就可以不停轮询channel，所有客户端请求都不会阻塞，直接就会进来，大不了就是等待一下排着队而已。
 
 
 
这里面优化BIO的核心就是，一个客户端并不是时时刻刻都有数据进行交互，没有必要死耗着一个线程不放，所以客户端选择了让线程歇一歇，只有客户端有相应的操作的时候才发起通知，创建一个线程来处理请求。
 
 
 
NIO：模型图
 
 
 
 
 
 
Reactor模型:
 
 
 
 
AIO
 
AIO：异步非阻塞IO，基于Proactor模型实现。
 
 
 
每个连接发送过来的请求，都会绑定一个Buffer，然后通知操作系统去完成异步的读，这个时间你就可以去做其他的事情
 
 
 
等到操作系统完成读之后，就会调用你的接口，给你操作系统异步读完的数据。这个时候你就可以拿到数据进行处理，将数据往回写
 
 
 
在往回写的过程，同样是给操作系统一个Buffer，让操作系统去完成写，写完了来通知你。
 
 
 
这俩个过程都有buffer存在，数据都是通过buffer来完成读写。
 
 
 
这里面的主要的区别在于将数据写入的缓冲区后，就不去管它，剩下的去交给操作系统去完成。
 
 
 
操作系统写回数据也是一样，写到Buffer里面，写完后通知客户端来进行读取数据。
 
 
 
AIO：模型图
 
 
 
 
 
 
聊完了BIO，NIO，AIO的区别之后，现在我们再结合这三个模型来说下同步和阻塞的一些问题。
 
 
 
同步阻塞
 
为什么说BIO是同步阻塞的呢？
 
 
 
其实这里说的不是针对网络通讯模型而言，而是针对磁盘文件读写IO操作来说的。
 
 
 
因为用BIO的流读写文件，例如FileInputStrem，是说你发起个IO请求直接hang死，卡在那里，必须等着搞完了这次IO才能返回。
 
 
 
同步非阻塞:
 
为什么说NIO为啥是同步非阻塞？
 
 
 
因为无论多少客户端都可以接入服务端，客户端接入并不会耗费一个线程，只会创建一个连接然后注册到selector上去，这样你就可以去干其他你想干的其他事情了
 
 
 
一个selector线程不断的轮询所有的socket连接，发现有事件了就通知你，然后你就启动一个线程处理一个请求即可，这个过程的话就是非阻塞的。
 
 
 
但是这个处理的过程中，你还是要先读取数据，处理，再返回的，这是个同步的过程。
 
 
 
异步非阻塞
 
为什么说AIO是异步非阻塞？
 
 
 
通过AIO发起个文件IO操作之后，你立马就返回可以干别的事儿了，接下来你也不用管了，操作系统自己干完了IO之后，告诉你说ok了
 
 
 
当你基于AIO的api去读写文件时， 当你发起一个请求之后，剩下的事情就是交给了操作系统
 
 
 
当读写完成后， 操作系统会来回调你的接口， 告诉你操作完成
 
 
 
在这期间不需要等待， 也不需要去轮询判断操作系统完成的状态，你可以去干其他的事情。
 
 
 
同步就是自己还得主动去轮询操作系统，异步就是操作系统反过来通知你。所以来说， AIO就是异步非阻塞的。
 
 
 
NIO核心组件详细讲解
 
 
 
学习NIO先来搞清楚一些相关的概念，NIO通讯有哪些相关组件，对应的作用都是什么，之间有哪些联系？
 
 
 
多路复用机制实现Selector
 
 
 
首先我们来了解下传统的Socket网络通讯模型。
 
 
 
传统Socket通讯原理图
 
 
 
 
为什么传统的socket不支持海量连接？
 
 
 
每次一个客户端接入，都是要在服务端创建一个线程来服务这个客户端的
 
 
 
这会导致大量的客户端的时候，服务端的线程数量可能达到几千甚至几万，几十万，这会导致服务器端程序负载过高，不堪重负，最终系统崩溃死掉。
 
 
 
接着来看下NIO是如何基于Selector实现多路复用机制支持的海量连接。
 
 
 
NIO原理图
 
 
 
 
多路复用机制是如何支持海量连接？
 
 
 
NIO的线程模型对Socket发起的连接不需要每个都创建一个线程，完全可以使用一个Selector来多路复用监听N多个Channel是否有请求，该请求是对应的连接请求，还是发送数据的请求
 
 
 
这里面是基于操作系统底层的Select通知机制的，一个Selector不断的轮询多个Channel，这样避免了创建多个线程
 
 
 
只有当莫个Channel有对应的请求的时候才会创建线程，可能说1000个请求， 只有100个请求是有数据交互的
 
 
 
这个时候可能server端就提供10个线程就能够处理这些请求。这样的话就可以避免了创建大量的线程。
 
 
 
NIO如何通过Buffer来缓冲数据的
 
NIO中的Buffer是个什么东西 ？
 
 
 
 
学习NIO，首当其冲就是要了解所谓的Buffer缓冲区，这个东西是NIO里比较核心的一个部分
 
 
 
一般来说，如果你要通过NIO写数据到文件或者网络，或者是从文件和网络读取数据出来此时就需要通过Buffer缓冲区来进行。Buffer的使用一般有如下几个步骤：
 
 
 
写入数据到Buffer，调用flip()方法，从Buffer中读取数据，调用clear()方法或者compact()方法。
 
 
 
Buffer中对应的Position， Mark， Capacity，Limit都啥？
 
 
 
 
 
capacity：缓冲区容量的大小，就是里面包含的数据大小。
 
 
 
 
limit：对buffer缓冲区使用的一个限制，从这个index开始就不能读取数据了。
 
 
 
 
position：代表着数组中可以开始读写的index， 不能大于limit。
 
 
 
 
mark：是类似路标的东西，在某个position的时候，设置一下mark，此时就可以设置一个标记
 
 
 
后续调用reset()方法可以把position复位到当时设置的那个mark上。去把position或limit调整为小于mark的值时，就丢弃这个mark
 
 
 
如果使用的是Direct模式创建的Buffer的话，就会减少中间缓冲直接使用DirectorBuffer来进行数据的存储。
 
 
 
如何通过Channel和FileChannel读取Buffer数据写入磁盘的
 
NIO中，Channel是什么？ 
 

 Channel是NIO中的数据通道，类似流，但是又有些不同
 
 
 
Channel既可从中读取数据，又可以从写数据到通道中，但是流的读写通常是单向的。
 
 
 
Channel可以异步的读写。Channel中的数据总是要先读到一个Buffer中，或者从缓冲区中将数据写到通道中。
 
 
FileChannel的作用是什么？
 

 Buffer有不同的类型，同样Channel也有好几个类型。
 
 
 
 
FileChannel
 
 
DatagramChannel
 
 
SocketChannel
 
 
ServerSocketChannel
 
 
 
这些通道涵盖了UDP 和 TCP 网络IO，以及文件IO。而FileChannel就是文件IO对应的管道， 在读取文件的时候会用到这个管道。