STL通用容器之 队列与堆栈

队列和堆栈

队列和栈是常用和重要的数据结构。队列只允许在表的一端插入，在另一端删除，允许插入的一端叫做队尾，允许

除的一端叫做队头，是一种先进先出线性表。栈只允许在表的一端进行插入和删除操作，是一种后进先出的线性表

常用函数：

(1)构造函数

queue(class T, class Container=deque<T>);创建元素类型为T的空队列，默认容器是      deque

stack(class T, class Container=deque<T>);创建元素类型为T的空堆栈，默认容器是deque

(2)操作函数

队列和堆栈共有函数：

bool empty(); 如果队列(堆栈)为空返回true,否则返回false

int size();  返回队列（堆栈）中元素数量

void push(const T& t); 把t元素压入队尾（栈顶）

void pop(); 当队列（栈）非空情况下，删除队头（栈顶）元素  

队列独有函数：

T& front(); 当队列非空情况下，返回队头元素引用

T& back(); 当队列非空情况下，返回队尾元素引用

堆栈独有函数：

T& top(); 当栈非空情况下，返回栈顶元素的应用

容器适配器：

能成为queue基本容器类Container的条件是它应当支持size，empty，push_back，pop_front，front，back方法

可对数据的两端分别进行插入、删除操作，而deque、list都具有这些函数，所以它们可成为queue的基本容

类Container；能成为stack基本容器类Container的条件是它应当支持size，empty，push_back, pop_back，bac

方法，可对数据的一端进行插入、删除操作，而deque、list、vector都具有这些函数，所以它们可成为stack的

本容器类Container。注意：vector不能作为queue的基本容器类，因为vector没有pop_front方法。

#include<iostream>
#include<string>
#include<vector>
#include<list>
#include<stack>
using namespace std;
/*
void PrintStack(stack<int,vector<int> >obj)
{
     while(!obj.empty())
     {
          cout<<obj.top()<<"\t";
          obj.pop();
     }
     cout<<endl;
}
void PrintStack(stack<string,list<string> >obj)
{
     while(!obj.empty())
     {
          cout<<obj.top()<<"\t";
          obj.pop();
     }
     cout<<endl;
}*/
template<class T,class Container>  //模板
void PrintStack(stack<T,Container>obj)
{
     while(!obj.empty())
     {
          cout<<obj.top()<<"\t";
          obj.pop();
     }
     cout<<endl;
}
int main()
{
     stack<int,vector<int> >s;
     for(int i=0;i<4;i++)
     {
          s.push(i+1);
     }
     PrintStack(s);


     string str="a";
     stack<string,list<string> >t;
     for(int i=0;i<4;i++)
     {
          t.push(str);
          str+="a";
     }
     PrintStack(t);

     stack<float,deque<float> >u;
     for(int i=0;i<4;i++)
     {
          u.push(i+1);
     }
     PrintStack(u);
     return 0;
}

PrintStack函数参数是复制类型，不能写成引用类型，例如写成PrintStack（stack<int,vector<int> >&obj）

,则当该函数执行时实参和形参都指向形同的实体，函数指向完后堆栈变成空的了，相当与原来堆栈实体内容变了，因此是错误的。

Queue基本函数操作示例

#include<iostream>
#include<string>
#include<list>
#include<deque>
#include<queue>
using namespace std;
template<class T,class Container>
void PrintQueue(queue<T,Container>obj)
{
     while(!obj.empty())
     {
          cout<<obj.front()<<"\t";
          obj.pop();
     }
     cout<<endl;
}
int main()
{
     string str="a";
     queue<string,deque<string> >t;
     for(int i=0;i<4;i++)
     {
          t.push(str);;
          str+="a";
     }
     PrintQueue(t);

     queue<float,list<float> >u;
     for(int i=0;i<4;i++)
     {
          u.push(i+1);
     }
     PrintQueue(u);
     return 0;
}

编一个固定大小的堆栈类。

分析：标准模板库中stack中元素个数没有限制，与题意不符，那么如何既能用上stack固有功能，又能加

特有的限制呢，其实在这句话中已经体现出了具体思路：（1）从stack派生出自己定义的堆栈类mystack。

这样，mystack类就继承了stack的固有特性；（2）在mystack类中加入特有的功能，题意中要求限制

小，那么一方面要定义一个成员变量m_nMaxSize,通过构造函数传入堆栈大小，并赋给m_nMaxSize;另

方面要重载push函数，如果当前堆栈元素个数小于m_nMaxSize，则把新元素压入堆栈。

#include<iostream>
#include<deque>
#include<stack>
using namespace std;
template<class T,class Container=deque<T> >
class mystack:public stack<T,Container>
{
private:
     int MaxSize;
public:
     mystack(int Size)
     {
          MaxSize=Size;
     }
     void push(const T &t)
     {
          if(this->size()<MaxSize)
          {
               stack<T,Container>::push(t);
          }
          else
          {
               cout<<"stack is fill"<<endl;
          }
     }
};
int main()
{
     mystack<int,deque<int> >obj(2);
     obj.push(1);
     obj.push(2);
     obj.push(3);
     return 0;
}