C++ 面向对象-容器适配器的实现

（1）栈的实现

以Vector为底部结构，定义新的接口，使之成为栈

#ifndef STACK_H
#define STACK_H
#include"Vector.h"
template<class T>
class Stack  
{
	//用向量类模板作为底部结构。
    /*************Begin*******************/
    typedef Vector<T> vec;
    vec data;
    /*************End*********************/
public:
	Stack(){}
	~Stack(){}
	//求数据元素个数
     /*************Begin*******************/
    int Size(){return data.Size();}
    
    /*************End*********************/
	//判断堆栈是否为空
    /*************Begin*******************/
    bool Empty(){return data.Empty();}
    
    /*************End*********************/
	//取栈顶元素的常量型引用
    /*************Begin*******************/
    const T& Top(){return data[Size()-1];}
    
    /*************End*********************/
	//弹栈
    /*************Begin*******************/
    T Pop()
    {
        T a=data.Back();
        data.Pop_back();
        return a;
    }
    /*************End*********************/
	//压栈
    /*************Begin*******************/
    void Push(T a){data.Push_back(a);}
    
    /*************End*********************/
	//清为空栈
    /*************Begin*******************/
    void Clear(){data.Clear();}
    
    /*************End*********************/
};

#endif

（2）队列的实现

以Vector为底部结构，定义新的接口，使之成为队列

#ifndef QUEUE_H
#define QUEUE_H

#include"Vector.h"
template<class T>
class Queue
{ 
	//用Vector作为底部结构
    /***************Begin**************/
    Vector<T> que;
    int head;
    /***************End****************/
public:
	Queue():head(0){}
	~Queue(){}
    //求元素个数
    /***************Begin**************/
    int Size(){return que.Size();}
    /***************End****************/
	//判空
	 /***************Begin**************/
    bool Empty(){return que.Empty();}
    /***************End****************/
	//取队头元素
    /***************Begin**************/
    T& Front(){return que[head];} 
    /***************End****************/	
 	//入队
	 /***************Begin**************/
    void Push(T a){que.Push_back(a);}
    /***************End****************/
   //出队
    /***************Begin**************/
    T Pop()
    {
        head++;
        que.Pop_back();
        return que[head-1];
    }
    /***************End****************/
  //置空队
	/***************Begin**************/
    void Clear(){que.Clear();}
    /***************End****************/
};

#endif

（3）优先级队列的实现

#pragma once
#include "Vector.h"

template<class T>
class PQueue
{
	//用Vector作为底部结构
    /****************Begin*********************/
private:
    Vector<T> pque;
    int size;
    int head;
    /****************End***********************/
public:
	PQueue():size(0),head(0){}
	~PQueue(){}
	
	//求元素的个数
    /****************Begin*********************/
    int Size(){return size;}
    /****************End***********************/
	//判断是否为空
    /****************Begin*********************/
    bool Empty()
    {
        return !size;
    }
    /****************End***********************/
	//取队头元素，返回常量型引用
    /****************Begin*********************/
    const T& Front()
    {
        return pque[head];
    }
    /****************End***********************/
	//入队
    /****************Begin*********************/
    void Push(T a)
    {
        pque.Push_back(a);
        size++;
    }
    /****************End***********************/
	//出队
    /****************Begin*********************/
    int GetMin()
    {
        int min=head;
        for(int i=head+1;i<size+head;i++)
        {
            if(pque[i]<pque[min])
                min=i;
        }
        return min;
    }
    T Pop()
    {
        int key=GetMin();
        T a=pque[key];
        for(int i=key;i>head;i--)
        {
            pque[i]=pque[i-1];
        }
        head++;
        size--;
        return a;
    }
    
    /****************End***********************/
	//置空队列
    /****************Begin*********************/
    void Clear()
    {
        size=0;
        head=0;
    }
    /****************End***********************/
};