STL——string、vector、deque容器

STL的基本概念以及vector简单用法

STL大体分为六大组件，分别是:容器、算法、迭代器、仿函数、适配器(配接器)、空间配置器
1.容器:各种数据结构，如vector、list、deque、set、map等,用来存放数据。
2.算法:各种常用的算法，如sort、find、copy、for_each等
3.迭代器:扮演了容器与算法之间的胶合剂。
4.仿函数:行为类似函数，可作为算法的某种策略。
5.适配器:一种用来修饰容器或者仿函数或迭代器接口的东西。
6.空间配置器:负责空间的配置与管理。
容器:置物之所也
STL容器就是将运用最广泛的一些数据结构实现出来常用的数据结构:数组,链表,树,栈,队列,集合,映射表等
这些容器分为序列式容器和关联式溶容器两种:
序列式容器:强调值的排序，序列式容器中的每个元素均有固定的位置。
关联式容器:二叉树结构，各元素之间没有严格的物理上的顺序关系
算法:问题之解法也
有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法(Algorithms)算法分为:
质变算法和非质变算法。
质变算法:是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等等
非质变算法∶是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等等
迭代器:容器和算法之间粘合剂
提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。
每个容器都有自己专属的迭代器，迭代器使用非常类似于指针，初学阶段我们可以先理解迭代器为指针
算法必须要通过迭代器来访问容器中的元素

常用的容器中迭代器种类为双向迭代器和随机访问迭代器

vector容器存放内置数据类型

STL中最常用的容器为Vector，可以理解为数组，利用这个容器中可以实现插入数据、并遍历这个容器

iterator是迭代器的名称，是在vector类型下的

//#define _CRT_SECURE_NO_WARNINGS
//#include 
//using namespace std;
//int main()
//{
//	system("pause");
//	return EXIT_SUCCESS;
//}

#define _CRT_SECURE_NO_WARNINGS
#include 
using namespace std;
#include 
#include //标准算法的头文件
//vector容器存放内置数据类型

void myPrint(int val)
{
	cout << val << endl;
}

void test01()
{
	//创建了一个vector容器，数组
	vector<int>v;

	//像容器中插入数据
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);

	通过迭代器访问容器中的数据
	//vector::iterator itBegin = v.begin();//起始迭代器 指向容器中第一个元素
	//vector::iterator itEnd = v.end();//结束迭代器 指向的是最后一个元素的下一个位置
	//
	第一种遍历方式
	//while (itBegin != itEnd)
	//{
	//	cout << *itBegin << endl;
	//	itBegin++;
	//}

	第二种遍历方式
	//for (vector::iterator it = v.begin(); it != v.end(); it++)
	//{
	//	cout << *it << endl;
	//}

	//第三种遍历方式  利用STL提供的遍历算法
	for_each(v.begin(), v.end(), myPrint);//这里写一个函数名 利用了回调的技术
	//在遍历的期间  调用了函数
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

第三种函数的源码:
这里是用了回调函数还有一个for循环来实现的
这里的迭代器可以看成指针，而解引用就是解这个指针，然后把解引用的元素放入到回调函数进行调用
解引用是解这个迭代器，也就是传入数组中的数

vector容器中存放自定义数据类型

#define _CRT_SECURE_NO_WARNINGS
#include 
using namespace std;
#include 
#include 

//vector存放自定义的数据类型
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};

void test01()
{
	vector<Person>v;
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	Person p5("eee", 50);

	//向容器中添加数据
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);
	
	//遍历容器中的数据
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << "姓名:" << (*it).m_Name << " 年龄:" << (*it).m_Age << endl;
		//cout << "姓名:" << it->m_Name << " 年龄:" << it->m_Age << endl;
	}
}

//存放自定义数据类型的指针
void test02()
{
	vector<Person*>v;
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	Person p5("eee", 50);

	//向容器中添加数据
	v.push_back(&p1);
	v.push_back(&p2);
	v.push_back(&p3);
	v.push_back(&p4);
	v.push_back(&p5);

	//遍历容器
	//此时的it可以理解为二级指针
	for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << "姓名:" << (*it)->m_Name << " 年龄:" << (*it)->m_Age << endl;
	}
}

int main()
{
	//test01();
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

vector容器嵌套vector容器

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

//容器嵌套容器
void test01()
{
	vector<vector<int>>v;
	
	//创建小容器
	vector<int>v1;
	vector<int>v2;
	vector<int>v3;
	vector<int>v4;

	//向小容器中添加数据
	for (int i = 0; i < 4; i++)
	{
		v1.push_back(i + 1);
		v2.push_back(i + 2);
		v3.push_back(i + 3);
		v4.push_back(i + 4);
	}

	//将小容器插入到大容器中
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);
	v.push_back(v4);

	//通过大容器,把所有数据遍历一边
	for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++)
	{
		//(*it)------容器 vector
		for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
		{
			cout << *vit << " ";
		}
		cout << endl;
	}
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

string容器

string容器——构造函数

string本质:
string是C++风格的字符串，而string本质上是一个类string和char区别:
char是一个指针
string是一个类，类内部封装了char，管理这个字符串，是一个char型的容器。
特点:
string类内部封装了很多成员方法
例如︰查找find，拷贝copy，删除delete替换replace，插入insertstring管理char所分配的内存，不用担心复制越界和取值越界等由类内部进行负责*

#define _CRT_SECURE_NO_WARNINGS
#include 
using namespace std;
#include 

//string的构造函数
void test01()
{
	string s1;//默认构造

	const char * str = "hello world";
	string s2(str);
	cout << "s2=" << s2 << endl;

	string s3(s2);
	cout << "s3=" << s3 << endl;

	string s4(10, 'a');
	cout << "s4=" << s4 << endl;
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

string容器——赋值操作

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

void test01()
{
	string str1;
	str1 = "hello world";
	cout << "str1=" << str1 << endl;

	string str2;
	str2 = str1;
	cout << "str2=" << str1 << endl;

	string str3;
	str3 = 'a';
	cout << "str3=" << str3 << endl;

	string str4;
	str4.assign("hello C++");
	cout << "str4=" << str4 << endl;

	string str5;
	str5.assign("hello C++", 5);
	cout << "str5=" << str5 << endl;

	string str6;
	str6.assign(str5);
	cout << "str6=" << str6 << endl;

	string str7;
	str7.assign(10, 'w');
	cout << "str7=" << str7 << endl;
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

string容器——字符串拼接

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

//string字符凭借

void test01()
{
	string str1 = "我";
	str1 += "爱玩游戏";
	cout << "str1=" << str1 << endl;
	str1 += ':';
	cout << "str1=" << str1 << endl;

	string str2 = " LOL DNF";
	str1 += str2;
	cout << "str1=" << str1 << endl;

	string str3 = "I";
	str3.append(" love ");//append中文是增加
	cout << "str3=" << str3 << endl;

	str3.append("game abcde", 4);
	cout << "str3=" << str3 << endl;

	/*str3.append(str2);
	cout << "str3=" << str3 << endl;*/

	/*str3.append(str2,0,4);
	cout << "str3=" << str3 << endl;*/

	str3.append(str2, 4, 4);
	cout << "str3=" << str3 << endl;
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

string容器——字符串的查找和替换

第一个函数原型：查找的是数组的下标，查找不到就输出-1

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

//string 字符串的查找和替换

//1、查找 find
void test01()
{
	string str1 = "abcdefgde";
	int pos = str1.find("de");
	cout << "pos=" << pos << endl;
	int abc = str1.find("df");
	cout << "abc=" << abc << endl;
	
//1、查找 rfind
	pos = str1.rfind("de");
	cout << "pos=" << pos << endl;

	//rfind和find区别
	//rfind从右往左查  find从左往右查
}

//2、替换
void test02()
{
	string str1 = "abcdefg";
	//从1号位置起3个字符替换为"1111"
	str1.replace(1, 3, "1111"); //把bcd换成1111 
	cout << "str1=" << str1 << endl;
}

int main()
{
	test01();
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

string容器——字符串比较

#define _CRT_SECURE_NO_WARNINGS
#include 
using namespace std;

//string 字符串比较
void test01()
{
	string str1 = "hello";
	string str2 = "hello";

	if (str1.compare(str2) == 0)
	{
		cout << "str1 等于 str2" << endl;
	}
	else if (str1.compare(str2) > 0)
	{
		cout << "str1 大于 str2" << endl;
	}
	else if (str1.compare(str2) < 0)
	{
		cout << "str1 小于 str2" << endl;
	}
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

总结:字符串对比主要是用于比较两个字符串是否相等，判断谁大谁小的意义并不是很大

string容器——字符存取

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

//string 字符存取
//底层是字符数组

void test01()
{
	string str = "hello";
	//cout << "str=" << str << endl;
	
	//1、通过[]访问单个字符
	for (unsigned int i = 0; i < str.size(); i++)
	{
		cout << str[i] <<" ";
	}
	cout << endl;
	//2、通过at方式访问你单个字符
	for (unsigned int i = 0; i < str.size(); i++)
	{
		cout << str.at(i) << " ";
	}
	cout << endl;

	//修改单个字符
	str[0] = 's';
	cout << "str=" << str << endl;

	str.at(1) = 'b';
	cout << "str=" << str << endl;
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

string容器——字符串的插入和删除

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

//string 字符串的插入和删除
void test01()
{
	string str = "hello";

	//插入
	str.insert(1, "111");
	cout << "str=" << str << endl;

	//删除
	str.erase(1, 3);
	cout << "str=" << str << endl;
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

string容器——字串获取

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

//string 字串获取
void test01()
{
	string str = "abcdef";
	//数组下标为1往后数三个
	string subStr = str.substr(1, 3);
	cout << "subStr=" << subStr << endl;
}

//实用操作
void test02()
{
	string email = "[email protected]";
	//从邮件的地址中  获取  用户名的信息
	int pos = email.find("@");
	cout << pos << endl;
	string userName = email.substr(0, pos);//从email数组下标为0的元素开始截取8哥字符
	cout << userName << endl;
}

int main()
{
	//test01();
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

这里find找到@的位置为8是数组下标，我们要截取的zhangsan这个字符串长度也是8，直接把pos传进去就行了

总结:灵活的运用求子串功能，可以在实际开发中获取有效的信息

vector容器

vector容器——构造函数

功能:
vector数据结构和数组非常相似，也称为单端数组
vector与普通数组区别:
不同之处在于数组是静态空间，而vector可以动态扩展
动态拓展:
并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间

vector的迭代器是支持随机访问的迭代器
这里的begin()是闭区间，end()是开区间

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

void printVector(vector<int>&v)
{
	//vector容器可以看成数组
	//迭代器可以看成指针
	//在C++中，vector是一个动态数组，可以根据需要自动扩展或缩小。
	//v.begin()是vector容器的一个成员函数，它返回一个指向容器中第一个元素的迭代器。
	//所以创建了一个名为v的vector容器，v.begin()将返回一个指向v中第一个元素的迭代器
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//vector容器
void test01()
{
	vector<int>v1;

	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}

	printVector(v1);

	//通过区间方式进行构造
	//这里调用了构造函数
	vector<int>v2(v1.begin(), v1.end());
	printVector(v2);

	//n个elem方式构造
	//第一个参数是个数  第二个是赋值
	vector<int>v3(10, 100);
	printVector(v3);

	//拷贝构造
	vector<int>v4(v3);
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

这里打印函数为什么要加入引用的原因是：
不加引用程序就需要重新构建一个vector，这会浪费很多的计算机资源，加引用就是为了避免这个的

vector容器——赋值操作

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

void printVector(vector<int>&v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//vector赋值
void test01()
{
	vector<int>v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector(v1);
	//赋值 operator=
	vector<int>v2;
	v2 = v1;
	printVector(v2);

	//assign
	vector<int>v3;
	//前闭后开
	v3.assign(v1.begin(), v1.end());
	printVector(v3);

	//n个elem方式赋值
	vector<int>v4;
	v4.assign(10, 100);
	printVector(v4);
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

vector容器——容量和大小

判断是否为空— empty
返回元素个数— size
返回容器容量— capacity
重新指定大小 — resize

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

void printVector(vector<int>&v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//vector容器的容量和大小操作
void test01()
{
	vector<int>v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector(v1);

	if (v1.empty())//为真 代表容器为空
	{
		cout << "v1为空" << endl;
	}
	else
	{
		cout << "v1不为空" << endl;
		cout << "v1的容量为:" << v1.capacity() << endl;
		cout << "v1的大小为:" << v1.size() << endl;
	}
	//重新指定大小
	v1.resize(15,100);//利用重载版本，可以指定默认的填充值
	printVector(v1);//如果重新指定的比原来长了 默认用0填充

	v1.resize(5);
	printVector(v1);//如果重新指定的比原来短了 超出部分会删除掉
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

vector容器——插入和删除

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

void printVector(vector<int>&v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//vector插入和删除
void test01()
{
	vector<int>v1;
	//尾插
	v1.push_back(10);
	v1.push_back(20);
	v1.push_back(30);
	v1.push_back(40);
	v1.push_back(50);

	//遍历
	printVector(v1);

	//尾删
	v1.pop_back();
	printVector(v1);

	//插入
	v1.insert(v1.begin(), 100);//传入参数是一个迭代器进行插入
	printVector(v1);

	v1.insert(v1.begin(), 2, 1000);
	printVector(v1);

	//删除 参数也是迭代器
	v1.erase(v1.begin());
	printVector(v1);

	//类似于情况的操作
	//v1.erase(v1.begin(), v1.end());
	v1.clear();
	printVector(v1);
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

vector容器——数据存取

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

//vector容器  数据存取

void test01()
{
	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;

	//获取第一个元素
	cout << "第一个元素为:" << v1.front() << endl;

	//获取最后一个元素
	cout << "第一个元素为:" << v1.back() << endl;
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

总结:
除了用迭代器获取vector容器中元素，[]和l也可以
front返回容器第一个元素
back返回容器最后一个元素

vector容器——互换容器

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

//vector容器互换

void printVector(vector<int>&v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//1、基本使用
void test01()
{
	vector<int>v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	cout << "交换前:" << endl;
	printVector(v1);

	vector<int>v2;
	for (int i = 10; i > 0; i--)
	{
		v2.push_back(i);
	}
	printVector(v2);

	cout << "交换后:" << endl;
	v1.swap(v2);
	printVector(v1);	
	printVector(v2);
}

//2、实际用途
//可以巧用swap可以收缩内存空间
void test02()
{
	vector<int>v;
	for (int i = 0; i < 100000; i++)
	{
		v.push_back(i);
	}
	cout << "v的容量: " << v.capacity() << endl;
	cout << "v的大小: " << v.size() << endl;

	v.resize(3);//重新指定大小
	cout << "v的容量: " << v.capacity() << endl;
	cout << "v的大小: " << v.size() << endl;

	//巧用swap收缩内存
	//vector(v)//匿名对象  调用了一次拷贝构造函数
	//用v所用的内存空间来初始化x的内存空间
	//.swap(v)相当于容器之间的交换
	//匿名对象的特点 执行完就会回收空间
	vector<int>(v).swap(v);
	cout << "v的容量: " << v.capacity() << endl;
	cout << "v的大小: " << v.size() << endl;
}

int main()
{
	//test01();
	test02();
	system("pause");
	return EXIT_SUCCESS;
}

vector容器——预留空间

功能：
减少vector在动态扩展容量时的扩展次数

没有设置预留空间：

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

//vector容器  预留空间
void test01()
{
	int num = 0;//统计开辟次数
	int *p = NULL;
	vector<int>v;
	for (int i = 0; i < 100000; i++)
	{
		v.push_back(i);

		if (p!=&v[0])
		{
			p = &v[0];
			num++;
		}
	}
	cout << "num=" << num << endl;
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

设置了预留空间：

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

//vector容器  预留空间
void test01()
{
	int num = 0;//统计开辟次数
	int *p = NULL;
	vector<int>v;
	//利用reserve来预留空间
	v.reserve(100000);
	for (int i = 0; i < 100000; i++)
	{
		v.push_back(i);

		if (p!=&v[0])
		{
			p = &v[0];
			num++;
		}
	}
	cout << "num=" << num << endl;
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

deque容器

deque容器——构造函数

功能:双端数组，可以对头端进行插入删除操作
理解为双端队列
deque与vector区别:
vector对于头部的插入删除效率低，数据量越大，效率越低.
deque相对而言，对头部的插入删除速度回比vector快
vector访问元素时的速度会比deque快,这和两者内部实现有关
1. 内部实现方式不同：vector是使用连续的内存空间存储数据，而deque则是使用一段连续的内存空间存储指向另一段内存空间的指针，这样就可以实现在两端高效地插入和删除元素。
2. 访问元素的方式不同：vector可以使用下标访问元素，而deque则需要使用迭代器访问元素。
3. 内存分配方式不同：vector在内存不足时会重新分配一块更大的内存空间，并将原有数据复制到新的内存空间中，这样会导致内存的浪费；而deque则会在需要时分配新的内存空间，不会浪费内存。
4. 其实，deque可以使用数组下标来访问元素。但是需要注意的是，deque是一个双端队列，支持在队列的两端进行插入和删除操作，因此使用数组下标访问元素时需要考虑队列的头尾位置，以及队列是否为空的情况。另外，使用数组下标访问元素时，需要保证下标的合法性，否则可能会导致访问越界的错误。因此，建议在使用deque时，优先使用其提供的成员函数来进行元素的访问和操作。


deque内部工作原理:
deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据
中控器维护的是每个缓冲区的地址，使得使用deque时象一片连续的内存空间
deque容器的迭代器也是支持随机访问的

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

void printDeque(const deque<int>&d)
{
	for(deque<int>::const_iterator it=d.begin();it!=d.end();it++)
	{
		//加上const防止修改代码
		//容器中的数据不可以修改了
		//*it = 100; err
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	deque<int>d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	printDeque(d1);

	deque<int>d2(d1.begin(), d1.end());
	printDeque(d2);

	deque<int>d3(10, 100);
	printDeque(d3);

	deque<int>d4(d3);
	printDeque(d4);
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

deque容器——赋值操作

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

void printDeque(const deque<int>&d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//deque容器赋值操作
void test01()
{
	deque<int>d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	printDeque(d1);

	//operator=赋值
	deque<int>d2;
	d2 = d1;
	printDeque(d2);

	//assign 赋值
	deque<int>d3;
	d3.assign(d1.begin(), d1.end());
	printDeque(d3);

	deque<int>d4;
	d4.assign(10, 100);
	printDeque(d4);

}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

deque容器——大小操作

deque相较于vector少了容量操作，也就是说容量没有限制

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

void printDeque(const deque<int>&d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	deque<int>d1;
	for (int i = 0; i < 10; i++)
	{
		d1.push_back(i);
	}
	printDeque(d1);

	if (d1.empty())
	{
		cout << "d1为空" << endl;
	}
	else
	{
		cout << "d1不为空" << endl;
		cout << "d1的大小为:" << d1.size() << endl;
		//deque容器没有容量概念
	}

	//重新指定大小
	//d1.resize(15);
	d1.resize(15, 1);
	printDeque(d1);

	d1.resize(5);
	printDeque(d1);
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

deque容器——插入和删除

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

//deque容器的插入和删除

void printDeque(const deque<int>&d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//两端操作
void test01()
{
	deque<int>d1;

	//尾插
	d1.push_back(10);
	d1.push_back(20);

	//头插
	d1.push_front(100);
	d1.push_front(200);
	printDeque(d1);

	//尾删
	d1.pop_back();
	printDeque(d1);

	//头删
	d1.pop_front();
	printDeque(d1);
}

void test02()
{
	deque<int>d1;
	d1.push_back(10);
	d1.push_back(20);
	d1.push_front(100);
	d1.push_front(200);
	printDeque(d1);

	//insert插入
	d1.insert(d1.begin(), 1000);
	printDeque(d1);

	d1.insert(d1.begin(), 2, 10000);
	printDeque(d1);

	//按照区间进行插入
	deque<int>d2;
	d2.push_back(1);
	d2.push_back(2);
	d2.push_back(3);
	
	//插入d2.begin()到d2.end()的区间的数
	d1.insert(d1.begin(), d2.begin(), d2.end());
	printDeque(d1);
}

void test03()
{
	deque<int>d1;
	d1.push_back(10);
	d1.push_back(20);
	d1.push_front(100);
	d1.push_front(200);

	//删除
	deque<int>::iterator it = d1.begin();
	it++;
	d1.erase(it);
	printDeque(d1);
	//d1.erase(d1.begin() + 1);
	//printDeque(d1);

	//按照区间的方式删除
	d1.erase(d1.begin(), d1.end());
	printDeque(d1);

	//清空
	d1.clear();
	printDeque(d1);
}

int main()
{
	test01();
	cout << "------------------------------" << endl;
	test02();
	cout << "------------------------------" << endl;
	test03();
	system("pause");
	return EXIT_SUCCESS;
}

deque容器——数据存储

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

void test01()
{
	deque<int>d;
	d.push_back(10);
	d.push_back(20);
	d.push_back(30);
	d.push_front(100);
	d.push_front(200);
	d.push_front(300);
	//利用[]方式访问数组中元素
	for (int i = 0; i < d.size(); i++)
	{
		cout << d[i] << " ";
	}
	cout << endl;

	//利用at方式访问元素
	for (int i = 0; i < d.size(); i++)
	{
		cout << d.at(i) << " ";
	}
	cout << endl;

	//获取第一个元素
	cout << "第一个元素为:" << d.front() << endl;

	//获取最后一个元素
	cout << "第一个元素为:" << d.back() << endl;
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

deque容器——排序操作

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
using namespace std;

void printDeque(const deque<int>&d)
{
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

//deque容器 排序操作

void test01()
{
	deque<int>d;
	d.push_back(10);
	d.push_back(20);
	d.push_back(30);
	d.push_front(100);
	d.push_front(200);
	d.push_front(300);
	// 300 200 100 10 20 30

	printDeque(d);

	//排序
	//sort算法默认的排序规则 从小到大 升序
	//对于支持随机访问的迭代器的容器，都可以利用sort算法直接对其进行排序
	//vector容器佝可以利用sort讲行排序
	sort(d.begin(),d.end());
}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

STL案例

评委打分

有5名选手:选手ABCDE，10个评委分别对每1名选手打分，去除最高分，去除评委中最低分，取平均分。
1.创建五名选手，放到vector中
2.遍历vector容器，取出来每一个选手，执行for循环，可以把10个评委打分存到deque容器中
3.sort算法对deque容器中分数排序，去除最高和最低分
4.deque容器遍历一遍，累加总分
5.获取平均分

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

//选手类
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)
{
	for (int i = 0; i < 5; i++)
	{
		string nameSeed = "ABCDE";
		string name = "选手";
		name += nameSeed[i];

		int score = 0;

		Person p(name, score);
		//将创建的person对象 放入到容器中
		v.push_back(p);
	}
}

void setScore(vector<Person>&v)
{
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
	{
		//将评委的分数 放入到deque容器中
		deque<int>d;
		for (int i = 0; i < 10; i++)
		{
			int score = rand() % 41 + 60;//60 ~ 100
			d.push_back(score);
		}

		//cout << "选手: " << it->m_Name << " 打分: " << endl;
		//for (deque::iterator dit1 = d.begin(); dit1 != d.end(); dit1++)
		//{
		//	cout << *dit1 << " ";
		//}
		//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));

	//1、创建5名选手
	vector<Person>v;//存放选手容器
	createPerson(v);
	//测试
	//for (vector::iterator it = v.begin(); it != v.end(); it++)
	//{
	//	cout << "姓名: " << (*it).m_Name << " 分数: " << (*it).m_Score << endl;
	//}

	//2、给5名选手打分
	setScore(v);
	//3、显示最后得分
	showScore(v);

	system("pause");
	return EXIT_SUCCESS;
}