STL之deque

写在前面

双向队列deque, 支持快速随机访问, 可在队头队尾执行插入删除操作.

	//需导入头文件
	#include <deque>

构造

	deque<string> dq;	//默认构造, 构造一个空的deque

	deque<int> dq1{ 1, 2,3 };	//构造有三个整数的deque
	//deque<int> dq1 = { 1, 2, 3 };	//同上

	deque<int> dq2(10, 6);	//构造一个10个元素大小的deque, 10个元素值均为6

	deque<int> dq3(dq1);	//拷贝构造

	deque<int> dq4 = dq3;	//赋值构造

	deque<int> dq5(dq4.begin(), dq4.end());	//拷贝指定范围的值来构造dq5

赋值

	deque<int> dq{1, 2, 3};
	deque<int> dq1(10, 6);
	
	//赋值
	deque<int> dq2 = dq;	//重载的=运算符

	//assign成员函数的三个重载版本示例
	deque<int> dq3;
	dq3.assign(initializer_list<int>{1, 2, 3, 4, 5});
	dq3.assign(6, 2);
	dq3.assign(dq1.begin(), dq1.end());

	//swap成员函数: 交换两个deque元素
	dq3.swap(dq2);

deque只有一个size成员, 而不会像vector那样还有一个capacity容量成员.

访问

下标运算符[]

	deque<int> dq = { 1, 2, 3 };
	int nVal = dq[1];	//返回2, 因为已经知道类型为int, 因此这里可以使用int型变量接收
	deque<int>::value_type nVal = dq[0];	//声明时需要指定类型, 岂不是脱裤子放屁?

at成员函数

返回对 deque 中指定位置的元素的引用.

唯一的一个参数为要引用 deque的元素的下标.

deque<string> dq{ "1", "12", "123" };
string sVal = dq.at(2);	//返回字符串"123"

front成员函数

返回对 deque 中第一个元素的引用.

如果为 deque 空，则返回为未定义, 成员抛出异常终止.

	deque<int> dq{ 1, 2, 3};
	int nVal = dq.front();	//返回1

back成员函数

返回对 deque 中最后一个元素的引用.

同front, 如果为 deque 空，则返回值未定义.

	deque<int> dq{ 1, 2, 3};
	int nVal = dq.back();	//返回3

大小操作

size, empty, resize成员函数

	deque<int> dq{1, 2, 3};
	deque<int> dq1(10, 6);
	
	//size成员函数, 返回当前deque容器大小, 返回类型依旧是deque<T>::size_type
	deque<int> dq{ 1, 2, 3 };
	deque<int> dq1(10, 6);

	deque<int>::size_type nSize = dq.size();
	
	//empty成员函数
	if ( dq1.empty() )
	{
		//dq1容器为空
	}
	else
	{
		//dq1容器不为空
	}

	//resize成员函数
	dq.resize(10);
	dq1.resize(5, 1);

插入删除

deque只能在队头队尾进行插入删除操作.

push_back, pop_back成员函数

队尾增删

	deque<int> dq{ 1, 2, 3 };
	dq.push_back(4);	//{ 1, 2, 3, 4 }
	dq.pop_back();		//{ 1, 2, 3 }, 对空deque调用pop_back会抛出异常终止

push_front, pop_front成员函数

	deque<string> dq{ "1", "12", "123" };
	dq.push_front("0");
	dq.pop_front();			//对空deque调用pop_front会抛出异常终止

erase成员函数

从指定位置删除 deque 中一个或一系列元素.

需要注意的是该函数的参数和返回值均为迭代器.

函数原型如下:

	iterator erase(iterator _Where);
	
	iterator erase(iterator first, iterator last);
	
	//参数
	//_Where: 要从中 deque移除的元素的位置。
	//first: 从中删除 deque的第一个元素的位置。
	//last: 位置刚好超出从中删除的最后一 deque个元素, 即最后一个删除元素的后一个位置。
	//返回值: 一个随机访问迭代器，指定除删除的任何元素之外剩余的第一个元素，或者指定指向不存在此类元素的末尾的 deque 指针。

	deque<int> dq{ 1, 2, 3, 4, 5 };
	deque<int>::iterator it = dq.erase(dq.begin(), dq.begin() + 4);		//it指向5
	deque<int>::iterator it2 = dq.erase(dq.begin(), dq.end());	//it == dq.end()

insert成员函数

将一个元素或多个元素或一系列元素插入 deque 到指定位置.

注意的是该函数的位置参数和返回值均为迭代器.

函数原型:

	iterator insert(
	    const_iterator Where,
	    const Type& Val);
	
	iterator insert(
		iterator Where, 
		initializer_list<Type>IList);
		
	void insert(
	    iterator Where,
	    size_type Count,
	    const Type& Val);
	
	//参数
	//Where: 插入第一个元素的目标 deque 位置
	//Count: 要插入到的 deque元素数
	//Val: 插入到 deque 中的元素的值
	//IList: 插入的初始化列表对象
	//返回值: 前两个插入函数返回一个迭代器，该迭代器指向插入新元素 deque的位置

	deque<int> dq;
	deque<int>::iterator it = dq.insert(dq.begin(), 1);		//it指向第一个元素
	deque<int>::iterator it2 = dq.insert(dq.begin() + 1, 2, 6);	//it2指向第二个元素
	deque<int>::iterator it3 = dq.insert(dq.begin() + 3, initializer_list<int>{5, 5, 5}); //it3指向第四个元素

clear成员函数

清除 deque 的所有元素。

	deque<int> dq{ 6, 6, 6 };
	dq.clear();
	deque<int>::size_type nSize = dq.size();		//返回0

遍历

	//普通for循环
	cout << "-----普通for循环-----\n";
	for (deque<int>::size_type i = 0; i < dq.size(); i++)
	{
		cout << dq[i] << endl;
	}
	cout << "-----End 普通for循环-----\n\n";

	//范围for循环
	cout << "-----范围for循环-----\n";
	for (auto val : dq)
	{
		cout << val << endl;
	}
	cout << "-----End 范围for循环-----\n\n";

	//迭代器遍历
	cout << "-----迭代器遍历-----\n";
	for (deque<int>::iterator it = dq.begin(); it != dq.end(); it++)
	{
		cout << *it << endl;
	}
	cout << "-----End 迭代器遍历-----\n\n";