stack和queue的模拟实现和实现中遇见的一问题C++

1.适配器

1.什么是适配器

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

对于stack我们可以使用适配器使得其中的val可以为任何值
例如：

vector
string
list

2.缺省值

引入：
我们在正常调用stack时，我们是：

stack<int> s;

但是我们实现的是：

template<class T, class Container>

需要两个参数，所以我们需要使用缺省值

解决：

template<class T, class Container = deque<T>>
//deque双端队列

3.当第二个参数是一些别的容器的时候

例如：
forward_list单链表
尾插尾删是没有的，所以不能适配

即：
给的容器必须支持这些函数才能使用，否则，，，

4.简单介绍deque

deque:双端队列
不是队列。因为队列是要有先进先出的，所以他不是传统队列
双端：双端开口，他想融和list和vector的一个全新容器，并有一种替代他们两个的趋势

deque和别的容器进行相比的优点：
vector:扩容代价不大，不需要拷贝数据浪费空间少
list：cpu告诉cache命中，其次不会频繁申请小块空间，申请和释放空间次数少代价低
queue：cpu告诉cache命中，其次不会频繁申请小块空间，申请和释放空间次数少代价低
所以:deque作为stack和queue的默认容器是完胜的

总结：
deque适合头尾插入删除，但是中间插入删除，和随机访问效率都不是很好，所以要高频随机访问还是需要vector，任意位置的插入和删除还是需要list

5.代码：

queue.h

#pragma once
#include<vector>
#include<list>

namespace sakeww
{
	// stack<int, vector<int>> s;
	// stack<int, list<int>> s;

	template<class T, class Container = deque<T>>
	class queue
	{
	public:
		bool empty() const
		{
			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& x)
		{
			_con.push_back(x);
		}

		void pop()
		{
			_con.pop_front();
		}
	private:
		Container _con;
	};

	void test_queue()
	{
		//queue<int, vector<int>> q; //不支持pop和front
		//queue<int, list<int>> q;
		queue<int> q;
		q.push(1);
		q.push(2);
		q.push(3);
		q.push(4);

		while (!q.empty())
		{
			cout << q.front() << " ";
			q.pop();
		}
		cout << endl;
	}
}

stack.h

#pragma once
#include<vector>
#include<list>
#include<forward_list>//单链表 


// 适配器模式
namespace sakeww
{
	// stack<int, vector<int>> s;
	// stack<int, list<int>> s;

	//Container容器
	template<class T, class Container = deque<T>>
	class stack
	{
	public:
		bool empty() const
		{
			return _con.empty();
		}

		size_t size() const
		{
			return _con.size();
		}

		const T& top() const
		{
			return _con.back();
		}

		void push(const T& x)
		{
			_con.push_back(x);
		}

		void pop()
		{
			_con.pop_back();
		}
	private:
		//vector<T> _v;
		Container _con;
	};

	void test_stack()
	{
		// 后进先出 -- 不支持迭代器
		//stack<int, std::vector<int>> s;
		//stack<int, std::list<int>> s;
		stack<int> s;

		//stack<int, std::forward_list<int>> s;
		//stack<int, string> s;
		//stack<string, string> st;
		//st.push("11111");

		s.push(1);
		s.push(2);
		s.push(3);
		s.push(400);

		while (!s.empty())
		{
			cout << s.top() << " ";
			s.pop();
		}
		cout << endl;
	}
}