【C++ STL】容器适配器 Container adapter（stack & queue & priority_queue）

一、STL - stack

1.1 stack 的介绍

文档介绍：stack - C++ Reference (cplusplus.com)

// T: 容器中存储的元素的类型
template <class T, class Container = deque<T> > class stack;

1. stack 是一种「容器适配器」（container adapter），专门用在具有 LIFO (后进先出) 操作的上下文环境中，其中元素仅从容器的一端插入和提取。

2. stack 是作为容器适配器被实现的，「容器适配器」即是「对特定容器类封装」作为其底层的容器，并提供一组特定的成员函数来访问其元素，元素从特定容器的尾部(即栈顶)被压入和弹出，这被称为堆栈的顶部。

3. stack 的底层容器可以是任何标准容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作：

   • empty：判空操作

   • size：获取有效元素个数

   • back：获取尾部元素操作

   • push_back：尾部插入元素操作

   • pop_back：尾部删除元素操作

4. 标准容器类 vector、deque、list 均符合这些要求，默认情况下，如果没有为 stack 指定特定的底层容器类，则使用标准容器双端队列 deque。

容器适配器/配接器：不是直接实现的，封装其他容器，包装转换实现出来的。

---

1.2 stack 的使用

stack 没有迭代器，有了迭代器就可以随意访问元素了，不能保证「后进先出」的性质了。

成员函数	接口说明
stack()	构造一个堆栈容器适配器对象，构造空的栈。
empty	检查 stack 是否为空
size	返回 stack 中有有效元素的个数
top	返回栈顶元素的引用
push	压栈，将一个元素压入 stack 中
pop	出栈，将 stack 尾部元素弹出
swap（C++11）	交换两个容器的内容（该成员函数调用非成员函数 std::swap 来交换底层容器）

Example：

void test_stack1()
{
	stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);

	// 遍历堆栈中的元素
	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	}
}

---

1.3 stack 的模拟实现

不需要写构造函数，因为在默认构造函数的初始化列表阶段，自定义类型成员 _con 会自动调用它的默认构造函数

namespace winter
{
	/*
	* T: 堆栈中存储的数据的类型
	* Container: 适配堆栈的容器类型，默认为deque
	*/
	template<class T, class Container = std::deque<T>>
	class stack
	{
		// stack 是一个 Container 适配（封装转换）出来的
		// 把 Contariner 的尾部认为是栈顶

	public:
		bool empty() // 判空
		{
			return _con.empty();
		}

		size_t size() const // 获取有效元素的个数
		{
			return _con.size();
		}

		const T& top() const // 返回栈顶元素的引用
		{
			return _con.back();
		}

		void push(const T& val) // 压栈，尾插
		{
			_con.push_back(val);

			// 大家可能会有疑问，如果 _con 没有 push_back 接口怎么办呢？
			// 没有就报错呗，说明你不能适配我
		}

		void pop() // 出栈，尾删
		{
			_con.pop_back();
		}

		// C++11
		void swap(stack<T, Container>& st) // 交换两个容器的内容
		{
			// 注意：底层调用的是非成员函数 std::swap 来交换底层容器
			std::swap(_con, st._con);
		}

	private:
		Container _con; // 适配的容器
	};
    
    // 测试
    void test1()
	{
		//stack> st; // 用vector适配
		//stack> st;   // 用list适配
		stack<int> st; // 默认用deque适配
		st.push(1);
		st.push(2);
		st.push(3);

		// 遍历堆栈中的元素
		while (!st.empty())
		{
			cout << st.top() << " ";
			st.pop();
		}
		cout << endl;
	}
}

---

二、STL - queue 的介绍

2.1 queue 的介绍

文档介绍：queue - C++ Reference (cplusplus.com)

// T: 容器中存储的元素的类型
template <class T, class Container = deque<T> > class queue;

• 队列是一种「容器适配器」（container adapter），专门用于在 FIFO (先进先出) 操作的上下文环境中，其中从容器一端插入元素，另一端提取元素。

• 队列作为容器适配器实现，「容器适配器」即「对特定容器类封装」作为其底层容器类，queue 提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。

• 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作：

  • empty：检测队列是否为空

  • size：返回队列中有效元素的个数

  • front：返回队头元素的引用

  • back：返回队尾元素的引用

  • push_back：在队列尾部入队列

  • pop_front：在队列头部出队列

• 标准容器类双端队列 deque 和带头双向循环链表 list 满足了这些要求。默认情况下，如果没有为 queue 实例化指定容器类，则使用标准容器双端队列 deque。

---

2.2 queue 的使用

注意：queue 没有迭代器，有了迭代器就可以随意访问元素了，不能保证「先进先出」的性质了。

成员函数	接口说明
queue()	构造一个队列容器适配器对象。构造空的队列
empty	检测队列是否为空
size	返回队列中有效元素的个数
front	返回队头元素的引用
back	返回队尾元素的引用
push	入队，将一个元素从队尾入队列
pop	出队，将队头元素出队列
swap （C++11）	交换两个容器的内容（该成员函数调用非成员函数 std::swap 来交换底层容器）

Example：

void test_queue1()
{
	queue<int> q;
	q.push(1);
	q.push(2);
	q.push(3);

	// 遍历队列中的元素
	while (!q.empty())
	{
		cout << q.front() << " ";
		q.pop();
	}
}

---

2.3 queue 的模拟实现

不需要写构造函数，因为在默认构造函数的初始化列表阶段，自定义类型成员 _con 会自动调用它的默认构造函数

namespace winter
{
	/*
	* T: 队列中存储的数据的类型
	* Container: 适配队列的容器类型，默认为deque
	*/
	template<class T, class Container = std::deque<T>>
	class queue
	{
	public:
		bool empty() // 判空
		{
			return _con.empty();
		}

		size_t size() const // 获取有效元素的个数
		{
			return _con.size();
		}

		const T& front() const // 返回队头元素的引用
		{
			return _con.front();
		}

		const T& back() const // 返回队尾元素的引用
		{
			return _con.back();
		}

		void push(const T& val) // 入队，尾插
		{
			_con.push_back(val);
		}

		void pop() // 出队，头删
		{
			_con.pop_front();
		}

	private:
		Container _con; // 适配的容器
	};

    // 测试
	void test11()
	{
		//queue> q; // 用list适配
		queue<int> q; // 默认用deque适配
		q.push(1);
		q.push(2);
		q.push(3);

        // 遍历队列中的元素
		while (!q.empty())
		{
			cout << q.front() << " ";
			q.pop();
		}
		cout << endl;
	}
}

---

三、STL - priority_queue

3.1 priority_queue 的介绍

文档介绍：priority_queue - C++ Reference (cplusplus.com)

/*
* T: 优先级队列中存储的数据的类型
* Container: 适配优先级队列的容器类型，默认用vector
* Compare: 仿函数的类型，默认是less(<)，建大堆
*/
template <class T, class Container = vector<T>,
  class Compare = less<typename Container::value_type> > class priority_queue;

---

1. 优先队列是一种「容器适配器」（container adapter），根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的（默认为大堆）。

2. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。

3. 优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue 提供一组特定的成员函数来访问其元素。元素从特定容器的 “ 尾部 ” 弹出，其称为优先队列的顶部。

4. 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：

   • empty()：检测容器是否为空
   • size()：返回容器中有效元素个数
   • front()：返回容器中第一个元素的引用
   • push_back()：在容器尾部插入元素
   • pop_back()：删除容器尾部元素

5. 标准容器类 vector 和 deque 满足这些需求。默认情况下，如果没有为特定的 priority_queue 类实例化指定容器类，则使用 vector。

6. 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数 make_heap、push_heap 和 pop_heap 来自动完成此操作。

7. 需要包含头文件

---

3.2 priority_queue 的使用

注意：priority_queue 的所有元素，进出都一定的规则，只有顶端的元素（权值最高者），才有机会被外界取用。priority_queue 不提供走访功能，也不提供迭代器。

成员函数	接口说明
priority_queue() priority_queue(first, last)	构造一个 priority_queue 容器适配器对象。 构造一个空的优先级队列 / 或者用一段迭代器区间 [first, last) 来初始化
empty	检测优先级队列是否为空
size	返回有效元素个数
top	返回优先级队列中最大(最小元素)，即堆顶元素
push	向优先级队列中插入一个元素
pop	删除优先级队列中最大(最小)元素，即堆顶元素
swap （C++11）	交换两个容器的内容（该成员函数调用非成员函数 std::swap 来交换底层容器）

注意：

1. 默认情况下，priority_queue 是大堆。元素在底层按照小于符号 (<) 进行比较。

   #include
   #include
   #include
   
   void test_priority_queue1() {
   	priority_queue<int> pq; // 默认是大堆 -- 大的元素优先级高
   	pq.push(4);
   	pq.push(1);
   	pq.push(7);
   	pq.push(6);
   	pq.push(2);
   	pq.push(5);
   
   	// 遍历优先级队列中的元素
   	while (!pq.empty()) {
   		cout << pq.top() << " "; // 堆顶元素
   		pq.pop();
   	}
       // result: 7 6 5 4 2 1
   }
   

2. 如果要构造小堆，需要仿函数。元素在底层按照小于符号 (>) 进行比较。

   #include
   #include
   #include
   
   void test_priority_queue2()
   {
   	// 构造小堆，需要给第三个模板参数传仿函数类greater，包含头文件
   	priority_queue<int, vector<int>, greater<int>> pq; // 小堆 -- 小的元素优先级高
   	pq.push(4);
   	pq.push(1);
   	pq.push(7);
   	pq.push(6);
   	pq.push(2);
   	pq.push(5);
   }
   

3. 如果在 priority_queue 中存放自定义类型的元素：

   • 需要用户在自定义类型中提供 > 或者 < 运算符的重载。
   • 或者通过用户提供的针对比较自定义类型对象大小的仿函数类，控制比较方式。

   class Date
   {
   public:
   	Date(int year = 2020, int month = 1, int day = 1)
   		:_year(year)
   		,_month(month)
   		,_day(day)
   	{}
   
   	bool operator<(const Date& d) const // < 运算符重载
   	{
   		return (_year < d._year) ||
   			(_year == d._year && _month < d._month) ||
   			(_year == d._year && _month == d._month && _day < d._day);
   	}
   
   	bool operator>(const Date& d) const // > 运算符重载
   	{
   		return (_year > d._year) ||
   			(_year == d._year && _month > d._month) ||
   			(_year == d._year && _month == d._month && _day > d._day);
   	}
   
   	friend ostream& operator<<(ostream& _cout, const Date& d) // << 运算符重载
   	{
   		_cout << d._year << "-" << d._month << "-" << d._day;
   		return _cout;
   	}
   
       friend struct DateLess; // 仿函数类声明为友元
       
   private:
   	int _year;
   	int _month;
   	int _day;
   };
   
   void test_priority_queue1()
   {
   	// 大堆，需要用户在自定义类型Date中提供 < 的重载
   	priority_queue<Date> q1;
   	q1.push(Date(2017, 2, 28));
   	q1.push(Date(2019, 10, 28));
   	q1.push(Date(2019, 3, 3));
   	cout << q1.top() << endl; // 输出堆顶元素（最大日期）
   
   	// 小堆，需要用户在自定义类型Date中提供 > 的重载
   	priority_queue<Date, vector<Date>, greater<Date>> q2;
   	q2.push(Date(2017, 2, 28));
   	q2.push(Date(2019, 10, 28));
   	q2.push(Date(2019, 3, 3));
   	cout << q2.top() << endl; // 输出堆顶元素（最小日期）
   }
   
   // 定义按小于(<)比较自定义类型对象大小的仿函数类
   struct DateLess
   {
   	bool operator()(const Date& d1, const Date& d2)
   	{
   		return (d1._year < d2._year) ||
   			(d1._year == d2._year && d1._month < d2._month) ||
   			(d1._year == d2._year && d1._month == d2._month && d1._day < d2._day);
   	}
   };
   
   void test_priority_queue2()
   {
       // 大堆，第3个模板参数传针对比较自定义类型对象大小的仿函数类DateLess
       priority_queue<Date, vector<Date>, DateLess> q1;
   	q1.push(Date(2017, 2, 28));
   	q1.push(Date(2019, 10, 28));
   	q1.push(Date(2019, 3, 3));
   	cout << q1.top() << endl; // 输出堆顶元素（最大日期）
   }
   

---

3.3 仿函数（⭐重要）

① 什么是仿函数

仿函数（Functor）又称为函数对象（Function Object），使一个类的使用看上去像一个函数，其实就是 在类中重载了 operator() 运算符，这个类就有了类似函数的行为，就是一个仿函数类了。

仿函数的语法几乎和我们普通的函数调用一样，调用仿函数时，实际上就是通过 仿函数类对象 调用重载后的 operator() 运算符，这种行为类似函数调用。

Example：判断两个数谁大谁小

// 仿函数（函数对象） -- 自定义类型
// 该类型的对象，可以像函数一样去使用
struct Less
{
	bool operator()(const int& x, const int& y) // 重载()运算符
	{
		return x < y;
	}
};

void test_functor()
{
	// 仿函数的两种使用方式：

	// 方式1：
	Less less; // 构造函数对象
	cout << less(1, 2) << endl;  // 编译器会解释成: less.operator()(1, 2);

	// 方式2：
	cout << Less()(1, 2) << endl; // 构造一个匿名函数对象
}

仿函数类还可以写成类模板，适应更多的类型：

template<class T> // 用于小于（<）不等式比较的函数对象类
struct Less
{
	bool operator()(const T& x, const T& y)
	{
		return x < y;
	}
};

template<class T> // 用于大于（>）不等式比较的函数对象类
struct Greater
{
	bool operator()(const T& x, const T& y)
	{
		return x > y;
	}
};

void test_functor()
{
	Less<int> less;
	cout << less(1, 2) << endl; // true
	
    Greater<int> greater;
	cout << greater(1, 2) << endl; // false
}

像 less 和 greater 这种常见的仿函数类，在头文件 中也有定义

Comparison operations:	接口说明
greater	用于大于（>）不等式比较的函数对象类
less	用于小于（<）不等式比较的函数对象类
……

// 仿函数less和greater是继承的binary_function，可以看作是对于一类函数的总体声明，这是函数做不到的

template <class T> struct greater : binary_function <T,T,bool> {
  bool operator() (const T& x, const T& y) const {return x>y;}
};

template <class T> struct less : binary_function <T,T,bool> {
  bool operator() (const T& x, const T& y) const {return x<y;}
};

---

② 模板实例化时，仿函数的使用

类模板一般是显式实例化的，在 <> 中指定模板参数的实际类型，所以类模板是传类型。比如：priority_queue

// 第1个模板参数是：存储数据的类型
// 第2个模板参数是：基础容器的类型
// 第3个模板参数是：仿函数的类型
template <class T, class Container = vector<T>,
  class Compare = less<typename Container::value_type> > class priority_queue;

void test()
{
    // 建小堆
    priority_queue<int, vector<int>, greater<int>> pq; // 传仿函数greater类型
}

而函数模板一般是隐式实例化，让编译器根据实参推演模板参数的实际类型，所以函数模板是传对象。比如：sort

// 第1个模板参数：迭代器的类型
// 第2个模板参数是：仿函数的类型
template <class RandomAccessIterator, class Compare>
  void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);
// 函数的第1和第2个参数是：迭代器对象
// 函数的第3个参数是：仿函数类的对象

void test()
{
    vector<int> v { 5,3,2,4,1 };
    // 排降序(>)
    sort (v.begin(), b.end(), greater<int>()); // 传仿函数类greater的匿名对象
    for (const auto& x : v)
        cout << x << " ";
    cout << endl;
}

---

3.4 priority_queue 的模拟实现

#include
#include
#include
using namespace std;

namespace winter
{
	// 仿函数类 Less，按小于(<)进行比较，建大堆
	template<class T>
	struct Less
	{
		bool operator()(const T& x, const T& y)
		{
			return x < y;
		}
	};

	// 仿函数类 Greater，按大于(>)进行比较，建小堆
	template<class T>
	struct Greater
	{
		bool operator()(const T& x, const T& y)
		{
			return x > y;
		}
	};

	/* 模板参数
	* T: 优先级队列中存储的数据的类型
	* Container: 适配优先级队列的容器类型，默认为vector
	* Compare: 仿函数类型，默认是Less(<)，建大堆（也可以用库中的greater和less类模板）
	*/
	template<class T, class Container = vector<T>, class Compare = Less<T>>
	class priority_queue
	{
	public:
		// 默认构造函数
		priority_queue() {}

		// 用迭代器区间[first,last)构造初始化
		template<class InputIterator>
		priority_queue(InputIterator first, InputIterator last);

		// 向上调整，建大堆（小堆）
		void AdjustUp(size_t child);

		// 向下调整，建大堆（小堆）
		// 前提条件：左右子树都是大(小)堆
		void AdjustDown(size_t parent);

		// 向堆中插入一个元素
		void push(const T& val)
		{
			_con.push_back(val); // 尾插

			AdjustUp(_con.size() - 1); // 从最后一个元素开始，向上调整
		}

		// 删除堆顶元素
		void pop()
		{
			std::swap(_con[0], _con[_con.size() - 1]); // 堆顶元素交换到尾部

			_con.pop_back(); // 尾删

			AdjustDown(0);   // 从堆顶开始，向下调整
		}
		
        // 判空
		bool empty() { return _con.empty(); }
		
        // 返回有效元素个数
		size_t size() const { return _con.size(); }
		
        // 返回堆顶元素
		const T& top() const { return _con[0]; }

	private:
		Container _con; // 成员变量，基础容器
	};
}

默认成员函数：

实现了一个默认构造和构造函数模板，这样可以用一段迭代器区间 [first,last) 来初始化优先级队列，其它默认成员函数编译器会自动生成，在函数内会自动调用适配优先级队列的基础容器的对应函数。

// 默认构造函数
priority_queue()
{}

// 用迭代器区间[first,last)构造初始化
template<class InputIterator>
priority_queue(InputIterator first, InputIterator last)
{
    while (first != last)
    {
        // 插入数据
        _con.push_back(*first);
        first++;

        // 建堆，从倒数第一个非叶子节点开始向下调整
        int child = _con.size() - 1;
        int parent = (child - 1) / 2;
        for (int i = parent; i >= 0; i--)
        {
            AdjustDown(i);
        }
    }
}

push 和 pop 函数：

实现这两个函数，需要先实现向上调整和向下调整函数，为了让向上和向下调整函数，既可以调整成大堆也可以调整成小堆，还需要传仿函数：

// 向上调整，建大堆（小堆）
void AdjustUp(size_t child)
{
    Compare com; // 仿函数对象

    size_t parent = (child - 1) / 2; // 计算出父亲下标

    while (child) // 当孩子下标等于0时结束
    {
        if (com(_con[parent], _con[child])) // 如果父亲小于(大于)孩子，需要把孩子往上调
        {
            // 交换孩子与父亲
            std::swap(_con[child], _con[parent]);

            // 更新孩子和父亲的下标
            child = parent;
            parent = (child - 1) / 2;
        }
        else // 如果父亲大于(小于)孩子，说明已经是大(小)堆，不需要调整了
        {
            break;
        }
    }
}

// 向下调整，建大堆（小堆）
// 前提条件：左右子树都是大(小)堆
void AdjustDown(size_t parent)
{
    Compare com; // 仿函数对象

    size_t child = 2 * parent + 1; // 计算出左孩子下标，默认左孩子最大

    while (child < _con.size()) // 孩子下标超过数组范围时结束
    {
        // 1.选出左右孩子最小的那个，先判断右孩子是否存在
        if (child + 1 < _con.size() && com(_con[child], _con[child + 1])) // 左孩子小于(大于)右孩子
        {
            child++; // 右孩子最大
        }

        // 2. 最大的孩子与父亲比较
        if (com(_con[parent], _con[child])) // 父亲小于(大于)最大的孩子，需要把父亲往下调
        {
            // 交换父亲与孩子
            std::swap(_con[parent], _con[child]);

            // 更新父亲和孩子的下标
            parent = (child - 1) / 2;
            child = 2 * parent + 1;
        }
        else // 父亲大于(小于)最大的孩子，说明已经是大(小)堆，不需要调整了
        {
            break;
        }
    }
}

---

四、容器适配器

stack 和 queue 和 priority_queue 往往不被认为是一个容器，而是一个容器适配器（Container adapter）。

adapter 原意是插座、适配器、接合器的意思。

4.1 什么是容器适配器

适配器是一种设计模式（设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结），该种模式是将一个类的接口转换成客户希望的另外一个接口。

生活中的电源适配器：

4.2 STL 中容器适配器的种类

虽然 stack 和 queue 和 priority_queue 中也可以存放元素，但在 STL 中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为 stack 和 queue 和 priority_queue 只是对其他容器的接口进行了包装，STL 中 stack 和 queue 默认使用 deque，而 priority_queue 默认使用 vector。

容器适配器	基础容器筛选条件	默认使用的基础容器
stack	基础容器需包含以下成员函数： empty() size() back() push_back() pop_back() 满足条件的基础容器有 vector、deque、list	deque
queue	基础容器需包含以下成员函数： empty() size() front() back() push_back() pop_front() 满足条件的基础容器有 deque、list	deque
priority_queue	基础容器需包含以下成员函数： empty() size() front() push_back() pop_back() 满足条件的基础容器有 vector、deque	vector

---

五、STL - deque（了解）

5.1 deque 的介绍

文档介绍：deque - C++ Reference (cplusplus.com)

template < class T, class Alloc = allocator<T> > class deque;

deque（双端队列）：是一种双开口的 " 连续 " 空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为 O(1)，与 vector 比较，头插效率高，不需要搬移元素；与 list 比较，空间利用率比较高。

deque 支持很多操作，比如 vector 不支持头插头删（因为效率太低），deque 支持；list 不支持随机访问，deque 支持；看起来就像完美融合了 vector 和 list 的操作：

这样看来，deque 是一个很完美很优秀的容器，但在实际中 deque 并没有崭露头角，也没有取代 vector 和 list ，说明它还是有缺陷的。

这就需要来了解一下 deque 的底层实现了。

---

5.2 deque 的底层结构

首先看一下 vector 和 list 的优缺点对比，可以看到，它们的优缺点基本是反着来的：

vector 是一段连续的物理空间。

• 其优点是：

  • 支持随机访问
  • 空间利用率高，底层是连续空间，不容易造成内存碎片
  • CPU 高速缓存命中率很高

• 其缺点也非常明显：

  • 空间不够时需要增容，增容代价很大（需要经过重新配置空间、元素搬移、释放原空间等），同时还存在一定的空间浪费

  • 头部和中间插入删除，效率很低 O(n)

list 不是连续的物理空间，而是由一个个节点 “ 链接 ” 起来的。

• 其优点是：

  • 按需申请释放空间，不会浪费空间

  • 任意位置插入和删除数据都是 O(1)，因为不需要移动数据，插入删除效率高

• 其缺点也很明显：

  • 不支持随机访问
  • 空间利用率低，底层不是连续的空间，小节点容易造成内存碎片
  • CPU 高速缓存命中率很低

思考：那有没有一种折中的方案呢，既有 vector 的优点，也有 list 的优点。

deque 的底层结构：

deque 并不是真正连续的空间，而是由一段段 固定大小 的连续小空间 拼接 而成的，实际 deque 类似于一个动态的二维数组，其底层结构如下图所示：

当需要增容时，只需要经过重新配置空间、元素搬移、释放原空间等过程，而是新增一个 buffer，存入数据，然后让中控数组指向新增的 buffer，将其管理起来。

deque 的迭代器：

deque 底层是一段假象的连续空间，实际是分段连续的，为了维护其 “ 整体连续 ” 以及随机访问的假象，落在了deque 的迭代器身上，因此 deque 的迭代器设计是比较复杂的（包含4个指针），如下图所示：

deque 的中控器、缓冲区、迭代器的相互关系：

---

5.3 deque 的优点和缺陷

与 vector 比较，deque 的优势是：

• 头部插入和删除时，不需要搬移元素，效率特别高。
• 在扩容时，也不需要搬移大量的元素，因此其效率是必比 vector 高的。

与 list 比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段。

但是 deque 有一个致命缺陷：

• 不适合遍历，因为在遍历时，deque 的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑 vector 和 list，deque 的应用并不多，而目前能看到的一个应用就是，STL 用其作为 stack 和 queue 的底层数据结构。

• 同时 deque 在中间插入删除数据，非常麻烦，效率很低。

deque 是一种折中方案的（妥协）设计，不够极致，随机访问效率不及 vector，任意位置插入删除不及 list，所以它能替代 vector 和 list 吗？是不能的。

---

5.4 为什么选择 deque 作为 stack 和 queue 的底层默认容器

stack 是一种后进先出的特殊线性数据结构，因此只要具有 push_back() 和 pop_back() 操作的线性结构，都可以作为 stack 的底层容器，比如 vector 和 list 都可以。

queue 是先进先出的特殊线性数据结构，只要具有 push_back() 和 pop_front() 操作的线性结构，都可以作为 queue 的底层容器，比如 list。

但是 STL 中对 stack 和 queue 默认选择 deque 作为其底层容器，主要是因为：

1. stack 和 queue 不需要遍历 (因此 stack 和 queue 没有迭代器)，只需要在固定的一端或者两端进行操作；
2. 当 stack 中元素增长时，用 deque 比 vector 的效率高 (扩容时不需要搬移大量数据)；
3. 当 queue 中的元素增长时，用 deque 不仅效率高，而且内存使用率高。刚好结合了 deque 的优点，而完美的避开了其缺陷。

---

注：参考书籍《STL源码剖析》