棧(stack)是一種常見資料結構，以後進先出(LIFO)著稱。比如編譯器用棧處理函式呼叫，儲存被呼叫函式的引數和區域性變數。當一個函式呼叫另一個函式時候，新的函式引數和區域性變數被入棧。呼叫結束，佔用的資源從棧釋放。

用陣列實現：

class vector{
private:
  T *ele;
int size;
int cap;
public:
	vector<T>(){size=0;cap=16;ele=new T[cap];}
	void sure(){if(size>cap) {T*old=ele;
	cap=2*size;
	ele=new T[cap];
	for(int i=0;i<size;i++)
	  ele[i]=old[i];
	delete old;}
	}
void push_back(T x);
void pop_back();
int size1();
T at(int index);  
bool empty();
void clear();
void swap(vector<T> &v1);};
template<typename T>
void vector<T>::push_back(T x){
sure();
ele[size++]=x;}
template<typename T>
void vector<T>::pop_back(){
if(empty()) throw runtime_error("empty");
--size;}
template<typename T>
int vector<T>::size1(){
return size;}
template<typename T>
T vector<T>::at(int index){
if(empty()||index>cap) throw runtime_error("empty");
return ele[index];}
template<typename T>
bool vector<T>::empty(){
if(size==0) return true;
else return false;}
template<typename T>
void vector<T>::clear(){
	while(!empty()){
	pop_back();}
}
template<typename T>
void vector<T>::swap(vector<T> &v1){
	int len=v1.size1();
	if(len>=size){
		T *p=new T[len];
for(int i=0;i<size;i++)
{p[i]=ele[i];}
clear();
for(int i=0;i<len;i++)
	push_back(v1.at(i));
	v1.clear();
for(int i=0;i<len;i++)
{v1.push_back(p[i]);}}
	else{
	T *p=new T[size];
for(int i=0;i<size;i++)
{p[i]=ele[i];}
clear();
for(int i=0;i<len;i++)
{ele[i]=v1.at(i);}
v1.clear();
for(int i=0;i<size;i++)
{v1.push_back(p[i]);}
	}
}
 

#include"15.h"//包含linklist類定義
using namespace std;
template<typename T>
class stack1{
private:
   linklist<T> li;
public:
stack1();
bool isempty();
T peek();
void push(T val);
T pop();
int getsize1();};

//define
template<typename T>
stack1::stack1(){}
template<typename T>
bool stack1<T>::isempty(){
return li.empty();}
template<typename T>
T satck1<T>::peek(){
if(isempty()) throw runtime_error("empty");
return li.getlast();}
template<typename T>
void stack1<T>::push(T val){
li.addlast(val);}
template<typename T>
T stack1<T>::pop(){
	return li.removelast();}
template<typename T>
int stack1<T>::getsize1(){
return li.getsize();}
 

由此可以得到啟發，用連結串列實現隊的實現，與stack的LIFO不同，queue是FIFO機制，根據此類機制實現：

template<typename T>
class queue{
private:
  linklist<T> list;
public:
	queue(){}
    void enqueue(T val);
    T dequeue();
int getsize();};
template<typename T>
void queue<T>::enqueue(T val){
	list.addlast(val);}
template<typename T>
T queue<T>::dequeue(){
return list.removefirst();}
template<typename T>
int queue<T>::getsize(){
	return list.getsize();}