18.Stack——queue（上）

底层

适配器模式：

栈只要支持一端插入删除就行，可以用vector list都可以，可以直接封装vector list 不用原生实现。

这样设计只能说是数组栈或者链式栈，

这样就是对container进行适配转换，构造就不用写了，他是自定义类型，默认调用它的构造

cpp 复制代码

#pragma once
#include<deque>
//
//template<class T>
//class stack
//{
//private:
//	T* _a;
//	size_t _top;
//	size_t _capacity;
//};
#include<vector>
#include<list>
namespace bit
{
	// Containerתstack
	template<class T, class Container = deque<T>>
	class stack
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}

		void pop()
		{
			_con.pop_back();
		}

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

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

		bool empty() const
		{
			return _con.empty();
		}

	private:
		Container _con;
	};

	/*void func()
	{
		cout << "void func()" << endl;
	}*/
}

底层形态已发生巨大改变。传布同容器就行。

库里面并没有传第二个模版参数，

因为模版参数跟函数参数类似，函数参数传的是值，对象，模版参数传的是类型，这可以给缺省值

可以用vector默认适配，等会用dequeue..

stack.h没有包头文件为什么能用，tect包了，编译器编译时候,预处理所有。h在。c或者。cpp展

开，，所以用vector可以过。

错误：

模版是在实例化之后才进行向上找。

展开后往上找，找不到std，因为这不是模版这是普通函数

以后把。h放后面

等主函数调用到了才报错，这叫按需实例化，模版实例化时候用到哪些函数实例化哪些，当不用pop就不实例化，细节不检查。

在写queue

queue要先进先出不能用vector，用list

cpp 复制代码

#pragma once
#include<deque>

namespace bit
{
	// ContainerÊÊÅä×ª>>>>³öqueue
	template<class T, class Container = list<T>>
	class queue
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}

		void pop()
		{
			_con.pop_front();
		}

		const T& front() const
		{
			return _con.front();
		}

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

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

		bool empty() const
		{
			return _con.empty();
		}

	private:
		Container _con;
	};
}

cpp 复制代码

text.cpp
#include<vector>
#include<list>
#include<stack>
#include<queue>
#include<algorithm>
using namespace std;

#include"Stack.h"
#include"Queue.h"
#include"PriorityQueue.h"

int main()
{
	//bit::stack<int, vector<int>> st;
	//bit::stack<int, list<int>> st;
	bit::stack<int, vector<int>> st;

	// 类模板实例化时，按需实例化，使用哪些成员函数就实例化哪些，不会全实例化
	st.push(1);
	st.push(2);
	st.push(3);
	st.push(4);

	cout << st.top() << endl;
	st.pop();

	//bit::queue<int, list<int>> q;
	bit::queue<int> q;
	q.push(1);
	q.push(2);
	q.push(3);
	q.push(4);

	cout << q.front() << endl;
	q.pop();

	return 0;
}

接下来看一下dequeue，把栈和队列第二个模版参数换成deque，虽然没包deque.h,但是没用缺省值，所以也不报错，也是按需实例化。

deque就是vector和list的缝合怪，vector只支持尾插尾删不支持头插头闪，list只支持各种插入删除不支持下标随机访问

list不支持下标随机访问就是很大问题，排序很慢访问大量数据

很互补。

如果头插，直接在前面开个buffer，指针指向这个buffer，尾插就在后面开个buffer让指针指向他，

也有扩容，但是扩容不需要拷贝全部数据，中控数组满了就要扩容，开一个更大中控数组，把数据拷贝下来，中控的指针数组需要扩容。

x是第几个buffer数组，y是这个数组第几个数据。

Node（二级指针）是当前指向那个buffer的中控，

主要靠迭代器管理，理解了迭代器就理解了

finish 的cur指向最后一个数据下一个位置，迭代器遍历是怎么走的

就算两个迭代器指向同一数组，我们用cur比较，不相等就不是==，start就是最开始的迭代器，

日常++迭代器就是++cur，buffer遍历结束，再找下一个buffer，Node+1就找到下一个位置数组了，解引用就是下一个buffer开始地址了，it是start拷贝给我的，把it里的start指向开始，last指向结束，cur指向第一个位置，Node指向下一个位置，迭代器就指向下一个位置了，*Node给first，buffer大小8，开始+8就是last，cur指向第一个数据位置，就可以开始访问了