C++之STL（一）

今天药忘吃喽~ 2022-01-09 19:57 197阅读 0赞

**目录**

1、STL概论

1.1 STL基本概念

1.2 STL六大组件简介

1.3 STL优点

2、STL三大组件

2.1 容器

2.2 算法

2.3 迭代器

3、常用容器

3.1 string容器

3.2 vector容器

3.3 deque容器

--------------------

## 1、STL概论 ##

### 1.1 STL基本概念 ###

STL(Standard Template Library,标准模板库)，是惠普实验室开发的一系列软件的统称。现在主要出现在 c++中。  
STL 从广义上分为: 容器(container) 算法(algorithm) 迭代器(iterator),容器和算法之间通过迭代器进行无缝连接。STL 几乎所有的代码都采用了模板类或者模板函数，这相比传统的由函数和类组成的库来说提供了更好的代码重用机会。STL(Standard Template Library)标准模板库,在我们 c++标准程序库中隶属于 STL 的占到了 80%以上。

### 1.2 STL六大组件简介 ###

STL提供了六大组件，彼此之间可以组合套用，这六大组件分别是:容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器。

**容器：**各种数据结构，如vector、list、deque、set、map等,用来存放数据，从实现角度来看，STL容器是一种class template。

**算法：**各种常用的算法，如sort、find、copy、for\_each。从实现的角度来看，STL算法是一种function template.

**迭代器：**扮演了容器与算法之间的胶合剂，共有五种类型，从实现角度来看，迭代器是一种将operator\* , operator-> , operator++,operator--等指针相关操作予以重载的class template. 所有STL容器都附带有自己专属的迭代器，只有容器的设计者才知道如何遍历自己的元素。原生指针(native pointer)也是一种迭代器。

**仿函数：**行为类似函数，可作为算法的某种策略。从实现角度来看，仿函数是一种重载了operator()的class 或者class template

**适配器：**一种用来修饰容器或者仿函数或迭代器接口的东西。

**空间配置器：**负责空间的配置与管理。从实现角度看，配置器是一个实现了动态空间配置、空间管理、空间释放的class tempalte.

STL六大组件的交互关系，容器通过空间配置器取得数据存储空间，算法通过迭代器存储容器中的内容，仿函数可以协助算法完成不同的策略的变化，适配器可以修饰仿函数。

### 1.3 STL优点 ###

1.  STL 是 C++的一部分，因此不用额外安装什么，它被内建在你的编译器之内。
2.  STL 的一个重要特性是将数据和操作分离。数据由容器类别加以管理，操作则由可定制的算法定义。迭代器在两者之间充当“粘合剂”,以使算法可以和容器交互运作
3.  程序员可以不用思考 STL 具体的实现过程，只要能够熟练使用 STL 就 OK 了。这样他们就可以把精力放在程序开发的别的方面。

STL 具有高可重用性，高性能，高移植性，跨平台的优点。

*  高可重用性：STL 中几乎所有的代码都采用了模板类和模版函数的方式实现，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。关于模板的知识，已经给大家介绍了。
 *  高性能：如 map 可以高效地从十万条记录里面查找出指定的记录，因为 map 是采用红黑树的变体实现的。
 *  高移植性：如在项目 A 上用 STL 编写的模块，可以直接移植到项目 B 上。

## 2、STL三大组件 ##

### 2.1 容器 ###

STL容器就是将运用最广泛的一些数据结构实现出来。

常用的数据结构：数组(array),链表(list),tree(树)，栈(stack),队列(queue),集合(set),映射表(map),根据数据在容器中的排列特性，这些数据分为**序列式容器**和**关联式容器**两种。

*  序列式容器强调值的排序，序列式容器中的每个元素均有固定的位置，除非用删除或插入的操作改变这个位置。Vector容器、Deque容器、List容器等。
 *  关联式容器是非线性的树结构，更准确的说是二叉树结构。各元素之间没有严格的物理上的顺序关系，也就是说元素在容器中并没有保存元素置入容器时的逻辑顺序。关联式容器另一个显著特点是：在值中选择一个值作为关键字key，这个关键字对值起到索引的作用，方便查找。Set/multiset容器 Map/multimap容器

### 2.2 算法 ###

算法，问题之解法也。

算法分为:**质变算法**和**非质变算法**。

*  质变算法：是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等。
 *  非质变算法：是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等。

![20190620182507900.png][]

### 2.3 迭代器 ###

迭代器(iterator)是一种抽象的设计概念，现实程序语言中并没有直接对应于这个概念的实物。**iterator模式定义如下：提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。**

迭代器的设计思维是STL的关键所在，STL的中心思想在于将容器(container)和算法(algorithms)分开，彼此独立设计，最后再一贴胶着剂(迭代器)将他们撮合在一起。从技术角度来看，容器和算法的泛型化并不困难，c++的class template和function template可分别达到目标，如何设计出这两个之间的良好的胶着剂，才是大难题。

<table>  迭代器的种类  
 <tbody> 
  <tr> 
   <td style="text-align:center;vertical-align:middle;">输入迭代器</td> 
   <td style="text-align:center;vertical-align:middle;width:254px;">提供对数据的只读访问</td> 
   <td style="text-align:center;vertical-align:middle;width:227px;">只读，支持++、==、！=</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;vertical-align:middle;">输出迭代器</td> 
   <td style="text-align:center;vertical-align:middle;width:254px;">提供对数据的只写访问</td> 
   <td style="text-align:center;vertical-align:middle;width:227px;">只写，支持++</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;vertical-align:middle;">前向迭代器</td> 
   <td style="text-align:center;vertical-align:middle;width:254px;">提供读写操作，并能向前推进迭代器</td> 
   <td style="text-align:center;vertical-align:middle;width:227px;">读写，支持++、==、！=</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;vertical-align:middle;">双向迭代器</td> 
   <td style="text-align:center;vertical-align:middle;width:254px;">提供读写操作，并能向前和向后操作</td> 
   <td style="text-align:center;vertical-align:middle;width:227px;">读写，支持++、--，</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;vertical-align:middle;">随机访问迭代器</td> 
   <td style="text-align:center;vertical-align:middle;width:254px;">提供读写操作，并能以跳跃的方式访问容器的任意数据，是功能最强的迭代器</td> 
   <td style="text-align:center;vertical-align:middle;width:227px;">读写，支持++、--、[n]、-n、&lt;、&lt;=、&gt;、&gt;=</td> 
  </tr> 
 </tbody> 
</table>

#define _CRT_SECURE_NO_WARNINGS
    #include<iostream>
    #include<string>
    using namespace std;
    
    //容器 vector
    #include<vector>
    
    //使用系统算法的头文件
    #include<algorithm>
    
    
    
    //迭代器  遍历功能  用指针理解
    //普通指针也算是一种迭代器
    void test01()
    {
    	int array[5] = { 1, 3, 5, 6, 8 };
    	int *p = array;   //指针指向数组首地址  &array[0]
    	
    	for (int i = 0; i < 5; i++)
    	{
    		//cout << array[i] << endl;
    		cout << *(p++) << endl;
    	}
    }
    
    void myPrint(int v)
    {
    	cout << v << endl;
    }
    
    void test02()
    {
    	//声明容器
    	vector<int> v;  //声明一个容器  这个容器中存放int类型数据  对象名称v
    	//向容器中加入数据
    
    	v.push_back(10);
    	v.push_back(20);
    	v.push_back(30);
    	v.push_back(40);
    
    	//遍历容器中的数据
    	//利用迭代器
    
    	vector<int>::iterator itBegin = v.begin();   //itBegin指向的是v容器中的起始位置
    	vector<int>::iterator itEnd = v.end();  //itEnd指向v容器中最后一个位置的下一个地址
    
            //第一种遍历方式	
            /*while (itBegin != itEnd)
    	{
    		cout << *itBegin << endl;
    
    		itBegin++;
    	}*/
    
    	//第二种遍历方式
    	/*for (vector<int>::iterator it = v.begin(); it != v.end();it++)
    	{
    		cout << *it << endl;
    	}*/
    
    	//第三种方式  利用算法
    	for_each(v.begin(), v.end(), myPrint);
    }
    
    class Person
    {
    public:
    	Person(string name, int age)
    	{
    		this->m_Name = name;
    		this->m_Age = age;
    	}
    
    	string m_Name;
    	int m_Age;
    };
    
    void test03()
    {
    	vector<Person> v;
    	Person p1("大头儿子", 10);
    	Person p2("小头爸爸", 25);
    	Person p3("老王", 25);
    	Person p4("围裙妈妈", 28);
    	v.push_back(p1);
    	v.push_back(p2);
    	v.push_back(p3);
    	v.push_back(p4);
    
    	//遍历
    	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
    	{
    		//说明：*it表示的就是<>中的内容Person
    		cout << "姓名：" << (*it).m_Name << "   年龄：" << (*it).m_Age << endl;  
    	}
    }
    
    //存放自定义数据类型的指针
    void test04()
    {
    	vector<Person *> v;
    	Person p1("大头儿子", 10);
    	Person p2("小头爸爸", 25);
    	Person p3("老王", 25);
    	Person p4("围裙妈妈", 28);
    	v.push_back(&p1);
    	v.push_back(&p2);
    	v.push_back(&p3);
    	v.push_back(&p4);
    
    	for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++)
    	{
    		//说明：*it表示的就是<>中的内容Person*
    		cout << "姓名：" << (*it)->m_Name << "年龄：" << (*it)->m_Age << endl;
    	}
    }
    
    //容器嵌套容器
    void test05()
    {
    	vector<vector<int>> v;
    	vector<int>v1;
    	vector<int>v2;
    	vector<int>v3;
    
    	for (int i = 0; i < 5; i++)
    	{
    		v1.push_back(i);
    		v2.push_back(i + 10);
    		v3.push_back(i + 1000);
    	}
    	//将小容器中的内容放到大容器中
    	v.push_back(v1);
    	v.push_back(v2);
    	v.push_back(v3);
    
    	//遍历所有数据
    	for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++)
    	{
    		//说明：*it还是个容器 所以需要循环
    		for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
    		{
    			cout << *vit << " ";
    		}
    		cout << endl;
    	}
    }
    
    int main()
    {
    	//test01();
    	//test02();
    	//test03();
    	//test04();
    	test05();
    	system("pause");
    	return 0;
    }

## 3、常用容器 ##

### 3.1 string容器 ###

关键问题：

*  **构造 赋值assign**
 *  **对字符存取 \[\] at区别：**\[\] 访问越界直接挂掉 ；at抛出异常 out\_of\_range
 *  **substr 配合find查找邮件用户名**
 *  **char \*和string互转**
 *  **char\* 隐式转换 string反之不可以**
 *  **转大写toupper 转小写tolower**
 *  **find如果找不到就返回-1，找到为第一次出现的位置**

#define _CRT_SECURE_NO_WARININGS
    #include<iostream>
    #include<string>
    #include<stdexcept>
    using namespace std;
    
    /*
    string 构造函数
    string();//创建一个空的字符串 例如: string str;
    string(const string& str);//使用一个string对象初始化另一个string对象
    string(const char* s);//使用字符串s初始化
    string(int n, char c);//使用n个字符c初始化
    
    string基本赋值操作
    string& operator=(const char* s);//char*类型字符串 赋值给当前的字符串
    string& operator=(const string &s);//把字符串s赋给当前的字符串
    string& operator=(char c);//字符赋值给当前的字符串
    string& assign(const char *s);//把字符串s赋给当前的字符串
    string& assign(const char *s, int n);//把字符串s的前n个字符赋给当前的字符串
    string& assign(const string &s);//把字符串s赋给当前字符串
    string& assign(int n, char c);//用n个字符c赋给当前字符串
    string& assign(const string &s, int start, int n);//将s从start开始n个字符赋值给字符串
    */
    
    void test01()
    {
    	string str;//默认构造
    	string str2(str); //拷贝构造
    	string str3 = str;
    
    	string str4 = "abcd";
    
    	string str5(10, 'v');
    
    	cout << str4 << endl;
    	cout << str5 << endl;
    
    	//基本赋值
    	str = "hello";
    	str2 = str4;
    
    	//string& assign(const char *s, int n);//把字符串s的前n个字符赋给当前的字符串
    	str3.assign("abcdef", 4);
    	cout << str3 << endl;
    
    	//string& assign(const string &s, int start, int n);//将s从start开始n个字符赋值给字符串
    	string str6;
    	str6.assign(str, 1, 3);  
    	cout << str6 << endl;  //ell  从0开始索引
    }
    
    /*
    string存取字符操作
    char& operator[](int n);//通过[]方式取字符
    char& at(int n);//通过at方法获取字符
    */
    void test02()
    {
    	string s = "hello world";
    
    	for (int i = 0; i < s.size(); i++)
    	{
    		//cout << s[i] << endl;
    		cout << s.at(i) << endl;
    	}
    	//[]和at区别？  []访问越界  直接挂掉  at会抛出异常
    	try
    	{
    		//cout << s[100] << endl;
    		cout << s.at(100) << endl;
    	}
    	catch (out_of_range & e)
    	{
    		cout << e.what() << endl;
    	}
    	catch (...)
    	{
    		cout << "越界异常" << endl;
    	}
    }
    
    /*
    string拼接操作
    string& operator+=(const string& str);//重载+=操作符
    string& operator+=(const char* str);//重载+=操作符
    string& operator+=(const char c);//重载+=操作符
    string& append(const char *s);//把字符串s连接到当前字符串结尾
    string& append(const char *s, int n);//把字符串s的前n个字符连接到当前字符串结尾
    string& append(const string &s);//同operator+=()
    string& append(const string &s, int pos, int n);//把字符串s中从pos开始的n个字符连接到当前字符串结尾
    string& append(int n, char c);//在当前字符串结尾添加n个字符c
    
    3.1.2.5 string查找和替换
    int find(const string& str, int pos = 0) const; //查找str第一次出现位置,从pos开始查找
    int find(const char* s, int pos = 0) const;  //查找s第一次出现位置,从pos开始查找
    int find(const char* s, int pos, int n) const;  //从pos位置查找s的前n个字符第一次位置
    int find(const char c, int pos = 0) const;  //查找字符c第一次出现位置
    int rfind(const string& str, int pos = npos) const;//查找str最后一次位置,从pos开始查找
    int rfind(const char* s, int pos = npos) const;//查找s最后一次出现位置,从pos开始查找
    int rfind(const char* s, int pos, int n) const;//从pos查找s的前n个字符最后一次位置
    int rfind(const char c, int pos = 0) const; //查找字符c最后一次出现位置
    string& replace(int pos, int n, const string& str); //替换从pos开始n个字符为字符串str
    string& replace(int pos, int n, const char* s); //替换从pos开始的n个字符为字符串s
    
    */
    
    void test03()
    {
    	//拼接
    	string s1 = "我";
    	string s2 = "爱北京";
    	s1 += s2;
    	cout << s1 << endl;
    
    	s1.append("天安门");
    	cout << s1 << endl;
    
    	//查找
    	string s = "abcdfg";
    	int pos = s.find("bc");  //注意如果找不到会返回-1
    
    	cout << "pos=" << pos << endl;
    
    	int pos2 = s.rfind("bc"); //rfind是从右向左找  但是与find的结果一致
    	cout << "pos2=" << pos2 << endl;
    
    
    	//替换  
    	string s3 = "hello";
    	s3.replace(1, 3, "1111");  //替换从pos开始n个字符为字符串str
    	cout << s3 << endl;  //h111o
    }
    
    /*
    string比较操作
    
    compare函数在>时返回 1，<时返回 -1，==时返回 0。
    比较区分大小写，比较时参考字典顺序，排越前面的越小。
    大写的A比小写的a小。
    
    int compare(const string &s) const;//与字符串s比较
    int compare(const char *s) const;//与字符串s比较
    */
    
    void test04()
    {
    	string s1 = "abc";
    	string s2 = "bc";
    
    	if (s1.compare(s2) == 0)
    	{
    		cout << "s1与s2相等" << endl;
    	}
    	else if (s1.compare(s2) == 1)
    	{
    		cout << "s1大于s2" << endl;
    	}
    	else
    	{
    		cout << "s1小于s2" << endl;
    	}
    
    }
    
    /*
    string子串
    string substr(int pos = 0, int n = npos) const;//返回由pos开始的n个字符组成的字符串
    */
    
    void test05()
    {
    	string s1 = "abcde";
    	string s2 = s1.substr(1, 3);
    	cout << "s2=" << s2 << endl;
    
    	//查找一个右键的 用户名
    	string email = "zt@sina.com";
    	int pos = email.find("@"); //
    	cout << "pos=" << pos << endl;   //2
    
    	string usrName = email.substr(0, pos);
    	cout << "用户名为：" << usrName << endl;
    }
    
    /*
    string插入和删除操作
    string& insert(int pos, const char* s); //插入字符串
    string& insert(int pos, const string& str); //插入字符串
    string& insert(int pos, int n, char c);//在指定位置插入n个字符c
    string& erase(int pos, int n = npos);//删除从Pos开始的n个字符
    
    */
    
    void test06()
    {
    	string s1 = "hello";
    	s1.insert(1, "111");
    	cout << s1 << endl;
    
    	//删除  111
    	s1.erase(1, 3);
    	cout << s1 << endl;
    }
    
    /*
    string和c-style字符串转换
    //string 转 char*
    string str = "itcast";
    const char* cstr = str.c_str();
    //char* 转 string
    char* s = "itcast";
    string str(s);
    */
    
    void func(string s)
    {
    	cout << s << endl;
    }
    
    void func(const char * s)
    {
    	cout << s << endl;
    }
    
    void test07()
    {
    	string s = "abc";
    	//string -> char *
    	const char * p = s.c_str();
    	func(p);  //const char * 隐式类型转换为string
    	//const char * -> string
    	string s2(p);
    	//func2(s2); //string 不能隐式类型转换为const char * 
    }
    
    void test08()
    {
    	string s = "abcdefg";
    	char& a = s[2];
    	char& b = s[3];
    
    	a = '1';
    	b = '2';
    
    	cout << s << endl;
    	cout << (int*)s.c_str() << endl; //打印地址
    
    	//s = "pppppppppppppppppppppppp"; //超过原始s的大小，需要重新分配内存
    
    	s = "ppp";  //无需重新分配内存
    	a = '1';
    	b = '2';
    
    	cout << s << endl;
    	cout << (int*)s.c_str() << endl;
    
    }
    
    /*
    小写字母转换成大写
    */
    
    void test09()
    {
    	string s = "abDNJfnvfjkv";
    	for (int i = 0; i < s.size(); i++)
    	{
    		//s[i] = toupper(s[i]);
    
    		//全变小写
    		s[i] = tolower(s[i]);
    	}
    	cout << s << endl;
    }
    
    int main()
    {
    	//test01();
    	//test02();
    	//test03();
    	//test04();
    	//test05();
    	//test06();
    	//test07();
    	//test08();
    	test09();
    	system("pause");
    	return 0;
    }

### 3.2 vector容器 ###

vector的数据安排以及操作方式，与array非常相似，两者的唯一差别在于空间的运用的灵活性。Array是静态空间，一旦配置了就不能改变，要换大一点或者小一点的空间，需要首先配置一块新的空间，然后将旧空间的数据搬往新空间，再释放原来的空间。Vector是动态空间，随着元素的加入，它的内部机制会自动扩充空间以容纳新元素。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzc1MzIxNQ_size_16_color_FFFFFF_t_70][]

Vector维护一个线性空间，所以不论元素的型别如何，普通指针都可以作为vector的迭代器，因为vector迭代器所需要的操作行为，如operaroe\*, operator->, operator++, operator--, operator+, operator-, operator+=, operator-=, 普通指针天生具备。Vector支持随机存取，而普通指针正有着这样的能力。所以vector提供的是随机访问迭代器(Random Access Iterators).

为了降低空间配置时的速度成本，vector实际配置的大小可能比客户端需求大一些，以备将来可能的扩充，这边是**容量**的概念。换句话说，**一个vector的容量永远大于或等于其大小，一旦容量等于大小，便是满载，下次再有新增元素，整个vector容器就得另觅居所。**

**注意：**所谓动态增加大小，并不是在原空间之后续接新空间(因为无法保证原空间之后尚有可配置的空间)，而是一块更大的内存空间，然后将原数据拷贝新空间，并释放原空间。因此，对vector的任何操作，一旦引起空间的重新配置，指向原vector的所有迭代器就都失效了。

关键问题：

*  构造、赋值
 *  大小size 重置大小 resize容量 capacity
 *  是否为空empty 交换 swap
 *  巧用swap收缩空间
 *  reverse预留空间
 *  insert 插入（迭代器） ease 删除（迭代器） clear(）清空
 *  pop\_back 尾删 front第一个数据 back最后一个数据
 *  逆序遍历 reverse\_iterator rbegin rend
 *  如何区分迭代器是否支持随机访问

#define _CRT_SECURE_NO_WARNINGS
    #include<iostream>
    #include<vector>
    #include<list>
    using namespace std;
    
    void test01()
    {
    	vector<int> v;
    	for (int i = 0; i < 10; i++)
    	{
    		v.push_back(i);
    		cout << v.capacity() << endl;  //v.capacity()容器的容量
    	}
    }
    
    /*
    3.2.4.1 vector构造函数
    vector<T> v; //采用模板实现类实现，默认构造函数
    vector(v.begin(), v.end());//将v[begin(), end())区间中的元素拷贝给本身。
    vector(n, elem);//构造函数将n个elem拷贝给本身。
    vector(const vector &vec);//拷贝构造函数。
    
    //例子 使用第二个构造函数 我们可以...
    int arr[] = {2,3,4,1,9};
    vector<int> v1(arr, arr + sizeof(arr) / sizeof(int));
    
    3.2.4.2 vector常用赋值操作
    assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
    assign(n, elem);//将n个elem拷贝赋值给本身。
    vector& operator=(const vector  &vec);//重载等号操作符
    swap(vec);// 将vec与本身的元素互换。
    
    3.2.4.3 vector大小操作
    size();//返回容器中元素的个数
    empty();//判断容器是否为空
    resize(int num);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
    resize(int num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长>度的元素被删除。
    capacity();//容器的容量
    reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。
    
    3.2.4.4 vector数据存取操作
    at(int idx); //返回索引idx所指的数据，如果idx越界，抛出out_of_range异常。
    operator[];//返回索引idx所指的数据，越界时，运行直接报错
    front();//返回容器中第一个数据元素
    back();//返回容器中最后一个数据元素
    
    3.2.4.5 vector插入和删除操作
    insert(const_iterator pos, int count,ele);//迭代器指向位置pos插入count个元素ele.
    push_back(ele); //尾部插入元素ele
    pop_back();//删除最后一个元素
    erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素
    erase(const_iterator pos);//删除迭代器指向的元素
    clear();//删除容器中所有元素
    */
    
    void printVector(vector<int>&v)
    {
    	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    	{
    		cout << *it << " ";
    	}
    	cout << endl;
    }
    
    void test02()
    {
    	vector<int> v;
    	int arr[] = { 2, 3, 4, 1, 9 };
    	vector<int> v1(arr, arr + sizeof(arr) / sizeof(int));
    	vector<int>v2(v1.begin(), v1.end());
    	printVector(v2);
    
    	vector<int>v3(10, 100);
    	printVector(v3);
    
    	//赋值使用
    	vector<int>v4;
    	v4.assign(v3.begin(), v3.end());
    	printVector(v4);
    
    	v4.swap(v2);
    	cout << "交换后的v4:" << endl;
    	printVector(v4);
    
    	cout << "v4容器的大小：" <<v4.size() << endl;
    
    	if (v4.empty())
    	{
    		cout << "v4空" << endl;
    	}
    	else
    	{
    		cout << "v4不空" << endl;  
    	}
    
    	//v4  23419
    	v4.resize(10);
    	printVector(v4); //v4  2341900000
    
    	v4.resize(10,-1); //注释掉上面两行代码即可得到23419-1-1-1-1-1，后面的-1是填入空值的数
    	printVector(v4); //v4  23419-1-1-1-1-1   
    
    	v4.resize(3);
    	printVector(v4);
    }
    
    //调用swap收缩空间
    void test03()
    {
    	vector<int>v;
    	for (int i = 0; i < 10000; i++)
    	{
    		v.push_back(i);
    	}
    
    	cout << "v的容量" << v.capacity() << endl; //12138
    	cout << "v的大小" << v.size() << endl;  //10000
    
    	v.resize(3);
    	cout << "v的容量" << v.capacity() << endl; //12138
    	cout << "v的大小" << v.size() << endl;  //3
    
    	//巧用swap
    	vector<int>(v).swap(v);
    
    	cout << "v的容量" << v.capacity() << endl; //3
    	cout << "v的大小" << v.size() << endl;  //3
    }
    
    //reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。
    void test04()
    {
    	vector<int> v;
    	v.reserve(100000); //预留出空间
    
    
    	int *p = NULL;
    	int num = 0;
    	for (int i = 0; i < 100000; i++)
    	{
    		v.push_back(i);
    		if (p != &v[0])
    		{
    			p = &v[0];
    			num++;
    		}
    	}
    	cout << num << endl;
    	//开辟100000个数据用了多少次
    }
    
    void test05()
    {
    	vector<int>v;
    	v.push_back(10);
    	v.push_back(30);
    	v.push_back(20);
    	v.push_back(50);
    
    	cout << "v的front:" << v.front() << endl;
    	cout << "v的back:" << v.back() << endl;
    
    	v.insert(v.begin(), 2, 100);  //参数1 迭代器  参数2 N  参数3 具体插入内容
    	printVector(v);
    
    	v.pop_back(); //尾删
    	printVector(v);
    
    	v.erase(v.begin()); //删除
    	printVector(v);
    
    	v.erase(v.begin(), v.end());
    	if (v.empty())
    	{
    		cout << "为空" << endl;
    	}
    
    	//v.clear();  //清空所有数据
    }
    
    
    //逆序遍历
    void test06()
    {
    	vector<int> v;
    	for (int i = 0; i < 10; i++)
    	{
    		v.push_back(i);
    	}
    	//printVector(v);
    	//reverse_iterator 逆序迭代器
    	for (vector<int>::reverse_iterator it = v.rbegin(); it != v.rend(); it++)
    	{
    		cout << *it << " ";
    	}
    	cout << endl;
    
    	//vector迭代器是随机访问的迭代器  支持跳跃式访问
    	vector<int>::iterator itBegin = v.begin();
    	itBegin = itBegin + 3;
    	//如果上述写法不报错，这个迭代器可以支持随机访问迭代器
    
    	list<int>l;
    	for (int i = 0; i < 10; i++)
    	{
    		l.push_back(i);
    	}
    	list<int>::iterator lIt = l.begin();
    	//lIt = lIt + 1;  //不支持随机访问
    }
    
    int main()
    {
    	//test01();
    	//test02();
    	//test03();
    	//test04();
    	//test05();
    	test06();
    	system("pause");
    	return 0;
    }

### 3.3 deque容器 ###

Vector容器是单向开口的连续内存空间，deque则是一种双向开口的连续线性空间。所谓的双向开口，意思是可以在头尾两端分别做元素的插入和删除操作，当然，vector容器也可以在头尾两端插入元素，但是在其头部操作效率奇差，无法被接受。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzc1MzIxNQ_size_16_color_FFFFFF_t_70 1][]

Deque容器和vector容器最大的差异，一在于deque允许使用**常数项时间**对头端进行元素的插入和删除操作。二在于deque没有容量的概念，因为它是动态的以分段连续空间组合而成，随时可以增加一段新的空间并链接起来 。

关键问题：

*  双端数组，没有容量
 *  API 赋值 构造 大小 交换 插入 删除
 *  头部删除 pop\_front
 *  头部插入 push\_front
 *  3种迭代器：iterator 普通 reverse\_iterator 逆序迭代器 const\_iterator 只读迭代器
 *  排序 sort 引用头文件 algorithm
 *  sort(d.begin(),d.end())

#define _CRT_SECURE_NO_WARNINGS
    #include<iostream>
    #include<deque>
    #include<algorithm>
    using namespace std;
    /*
    3.3.3.1 deque构造函数
    deque<T> deqT;//默认构造形式
    deque(beg, end);//构造函数将[beg, end)区间中的元素拷贝给本身。
    deque(n, elem);//构造函数将n个elem拷贝给本身。
    deque(const deque &deq);//拷贝构造函数。
    
    3.3.3.2 deque赋值操作
    assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
    assign(n, elem);//将n个elem拷贝赋值给本身。
    deque& operator=(const deque &deq); //重载等号操作符
    swap(deq);// 将deq与本身的元素互换
    
    3.3.3.3 deque大小操作
    deque.size();//返回容器中元素的个数
    deque.empty();//判断容器是否为空
    deque.resize(num);//重新指定容器的长度为num,若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
    deque.resize(num, elem); //重新指定容器的长度为num,若容器变长，则以elem值填充新位置,如果容器变短，则末尾超出容器长度的元素被删除。
    
    3.3.3.4 deque双端插入和删除操作
    push_back(elem);//在容器尾部添加一个数据
    push_front(elem);//在容器头部插入一个数据
    pop_back();//删除容器最后一个数据
    pop_front();//删除容器第一个数据
    
    3.3.3.5 deque数据存取
    at(idx);//返回索引idx所指的数据，如果idx越界，抛出out_of_range。
    operator[];//返回索引idx所指的数据，如果idx越界，不抛出异常，直接出错。
    front();//返回第一个数据。
    back();//返回最后一个数据
    3.3.3.6 deque插入操作
    insert(pos,elem);//在pos位置插入一个elem元素的拷贝，返回新数据的位置。
    insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。
    insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。
    3.3.3.7 deque删除操作
    clear();//移除容器的所有数据
    erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
    erase(pos);//删除pos位置的数据，返回下一个数据的位置。
    
    */
    
    void prinDeque(const deque<int>&d) //加const报错
    {
    	//iterator普通迭代器  reverse_iterator 逆序迭代器  const_iterator 只读迭代器
    	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
    	{
    		//*it = 100;  不可修改
    		cout << *it << " ";
    	}
    	cout << endl;
    }
    void test01()
    {
    	deque<int>d;
    	d.push_back(10);
    	d.push_back(40);
    	d.push_back(30);
    	d.push_back(10);
    
    	prinDeque(d);
    
    	deque<int>d2(d.begin(), d.end());
    	d2.push_back(10000);
    
    	//交换
    	d.swap(d2);
    
    	//d2 10 40 30 20
    	prinDeque(d);
    
    	if (d2.empty())
    	{
    		cout << "为空" << endl;
    	}
    	else
    	{
    		cout << "不为空，大小为" << d.size() << endl;
    	}
    }
    
    void test02()
    {
    	deque<int>d;
    	d.push_back(10);
    	d.push_back(30);
    	d.push_back(20);
    	d.push_front(100);
    	d.push_front(200);
    
    	prinDeque(d); //200 100 10 30 20
    
    	//删除  头删  尾删
    	d.pop_back();
    	d.pop_front();
    	prinDeque(d); 
    
    	cout << "front=" << d.front() << endl;
    	cout << "back=" << d.back() << endl;
    
    	//插入
    	deque<int>d2;
    	d2.push_back(50);
    	d2.push_back(60);
    	d2.insert(d2.begin(), d.begin(), d.end()); //100 10 30 50 60 
    	prinDeque(d2);
    }
    
    //排序规则
    bool myCompare(int v1, int v2)
    {
    	return v1 > v2;
    }
    
    //排序sort
    void test03()
    {
    	deque<int> d;
    	d.push_back(5);
    	d.push_back(15);
    	d.push_back(3);
    	d.push_back(40);
    	d.push_back(7);
    
    	prinDeque(d);	
    
    	//排序
    	sort(d.begin(), d.end());
    	prinDeque(d);
    
    	//从大到小
    	sort(d.begin(), d.end(), myCompare);
    	prinDeque(d);
    }
    
    int main()
    {
    	//test01();
    	//test02();
    	test03();
    	system("pause");
    	return 0;
    }

案例——评委打分

#define _CRT_SECURE_NO_WARNINGS
    #include<iostream>
    #include<vector>
    #include<string>
    #include<deque>
    #include<algorithm>
    #include<ctime>
    using namespace std;
    
    /*
    有5名选手：选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除评委中最低分，取平均分。
    //1. 创建五名选手，放到vector中
    //2. 遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque容器中
    //3. sort算法对deque容器中分数排序，pop_back pop_front去除最高和最低分
    //4. deque容器遍历一遍，累加分数，累加分数/d.size()
    //5. person.score = 平均分
    */
    
    class Person
    {
    public:
    	Person(string name, int score)
    	{
    		this->m_Name = name;
    		this->m_Score = score;
    	}
    
    	string m_Name;
    	int m_Score;
    };
    
    void createPerson(vector<Person>&v)
    {
    	string nameSeed = "ABCDE";
    	for (int i = 0; i < 5; i++)
    	{
    		string name = "选手";
    		name += nameSeed[i];
    
    		int score = 0;
    		Person p(name, score);
    
    		v.push_back(p);
    	}
    }
    
    void setScore(vector<Person>&v)
    {
    	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
    	{
    		//对5个人进行打分
    		deque<int>d;
    		for (int i = 0; i < 10; i++)
    		{
    			int score = rand() % 41 + 60;//60~100
    			d.push_back(score);
    		}
    
    		//先看下打分
    		for (deque<int>::iterator dit = d.begin(); dit != d.end(); dit++)
    		{
    			cout << *dit << " ";
    
    		}
    		cout << endl;
    
    		//排序  从小到大
    		sort(d.begin(), d.end());
    
    		//去除最高 和最低
    		d.pop_back();  //最高
    		d.pop_front();  //最低
    
    		int sum = 0;  //总分
    		for (deque<int>::iterator dit = d.begin(); dit != d.end(); dit++)
    		{
    			sum += *dit;
    		}
    
    		//平均分
    		int avg = sum / d.size();
    		it->m_Score = avg;
    	}
    }
    
    void showScore(vector<Person> &v)
    {
    	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
    	{
    		cout << "姓名：" << it->m_Name << "   最终的平均分为：" << it->m_Score << endl;
    	}
    }
    
    int main()
    {
    	//设置随机数种子
    	srand((unsigned int)time(NULL));
    	//创建容器，存放选手
    	vector<Person>v;
    
    	//创建5名选手
    	createPerson(v);
    
    	//打分
    	setScore(v);
    
    	//展示平均分
    	showScore(v);
    
    	测试
    	//for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
    	//{
    	//	cout << "姓名：" << (*it).m_Name << endl;
    	//}
    
    
    	system("pause");
    	return 0;
    }

[20190620182507900.png]: /images/20220109/21f4abe44a7c42e88e2a46c30283ac1a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzc1MzIxNQ_size_16_color_FFFFFF_t_70]: /images/20220109/eb3199a48bb045d89bafd1ea1c387ac9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzc1MzIxNQ_size_16_color_FFFFFF_t_70 1]: /images/20220109/b5493fa4245947519bd1d8340698d2fc.png