class还原STL中阉割版的队列（闲得无聊）

闲得无聊，之前学了一波泛式编程，突发奇想用这个还原一下STL中的一些数据结构，于是就顺便手写一下栈了什么增加对它的理解：

直接上源码了，比较简单就不罗嗦了

//#pragma comment(linker, "/STACK:1024000000,1024000000") 

#include<stdio.h>
#include<string.h>  
#include<math.h>  
  
//#include<map>   
//#include<set>
#include<deque>  
#include<queue>  
#include<stack>  
#include<bitset> 
#include<string>  
#include<fstream>
#include<iostream>  
#include<algorithm>  
using namespace std;  

#define ll long long  
//#define max(a,b) (a)>(b)?(a):(b)
//#define min(a,b) (a)<(b)?(a):(b) 
#define clean(a,b) memset(a,b,sizeof(a))// 水印 
//std::ios::sync_with_stdio(false);
const int MAXN=1e5+10;
const int INF=0x3f3f3f3f;
const ll mod=1e9+7;

struct Edge{//我们要存入栈的元素，里面的东西随便改，毕竟结构体都能存了，什么int，char什么的都无所谓了 
	int data;
	Edge(int _data=0):
	data(_data){}
};
template<typename T>
class Queue{
	private:
		struct node{
			T data;
			node *nxt;
		}*head,*p;
		int length;
	public:
		Queue()
		{
			p=NULL;
			length=0;
		}
		void push(T u)
		{
			node *q=new node;
			q->data=u;
			if(p==NULL)
			{
				q->nxt=p;
				head=q;//结束 
				p=q;//队列头 
			}
			else
			{
				head->nxt=q;
				head=q;
			}
			length++;
		}
		void pop()
		{
			if(length<=0)
				abort();
			node *q;
			q=p;
			p=p->nxt;
			delete(q);
			length--;
		}
		T front()
		{
			return p->data;
		}
		int size()
		{
			return length;
		}
		bool Empty()
		{
			if(length>0)
				return 0;
			else
				return 1;
		}
		void clear()
		{
			while(length>0)
				pop();
		}
};

int main()
{
	//手写的阉割栈.... 
	Queue<Edge> q;
	for(int i=1;i<=10;++i)
		q.push(Edge(i));
	while(q.size()>2)
	{
		cout<<q.front().data<<" ";
		q.pop();
	}
	cout<<endl<<q.Empty()<<endl;
	q.clear();
	cout<<q.Empty()<<endl;
	
	//对比一下正常的STL中的栈 
	
	queue<Edge> que;
	for(int i=1;i<=10;++i)
		que.push(Edge(i));
	while(que.size()>2)
	{
		cout<<que.front().data<<" ";
		que.pop();
	}
	cout<<endl<<que.empty()<<endl;
	while(que.size())
		que.pop();
	cout<<que.empty()<<endl;
}

没什么去别啊，我的输出：

感觉舒服多了，高度还原STL