循环队列

#include "SqQueue.h"
#include <iostream>
using namespace std;

void main()
{
	SqQueue<int> a;
	a.InQueue(5);
	int elem;
	a.GetHead(elem);
	cout<<elem<<endl;
	a.InQueue(6);
	cout<<a.Length()<<endl;
	a.OutQueue(elem);
	cout<<elem<<endl;
	a.OutQueue(elem);
	cout<<elem<<endl;
}

#ifndef _SQQUEUE_H_
#define _SQQUEUE_H_

#include <iostream>
using namespace std;

const int DEFAULT_NUMBER=10;
enum StatusCode{UNDER_FLOW,OVER_FLOW,SUCCESS};

template<class ElemType>
class SqQueue
{
    protected:
        int front,rear;
        ElemType *elem;
        int maxSize;
        
        void Init(int size);
    public:
        SqQueue(int size=DEFAULT_NUMBER);
        virtual ~SqQueue();

        int Length()const;
        bool Empty()const;
        void Clear();

        StatusCode InQueue(const ElemType &e);
        StatusCode OutQueue(ElemType &e);
        StatusCode GetHead(ElemType &e)const;

        SqQueue(const SqQueue<ElemType> &copy);
        SqQueue<ElemType>& operator = (const SqQueue<ElemType> &copy);
        
};

template<class ElemType>
SqQueue<ElemType>::SqQueue(int size)
{
    maxSize=size;
    elem=NULL;
    Init(size);
}

template<class ElemType>
SqQueue<ElemType>::~SqQueue()
{
    Clear();
    
}

template<class ElemType>
void SqQueue<ElemType>::Init(int size)
{
    if(elem!=NULL)
        delete []elem;
    else
        elem=new ElemType[size];
    front=0;
    rear=0;
}

template<class ElemType>
void SqQueue<ElemType>::Clear()
{
    if(elem!=NULL)
        delete []elem;
    front=0;
    rear=0;
}

template<class ElemType>
StatusCode SqQueue<ElemType>::InQueue(const ElemType &e)
{
    if(front%maxSize==(rear+1)%maxSize)
        return OVER_FLOW;
    else
    {
        elem[rear%maxSize]=e;
        ++rear;
        return SUCCESS;
    }
}

template<class ElemType>
StatusCode SqQueue<ElemType>::OutQueue(ElemType &e)
{
    if(Empty())
        return UNDER_FLOW;
    else
    {
        
        e=elem[front%maxSize];
        front++;
        return SUCCESS;
    }
}

template<class ElemType>
StatusCode SqQueue<ElemType>::GetHead(ElemType &e)const
{
    if(Empty())
        return UNDER_FLOW;
    else
    {
        e=elem[front%maxSize];
        return SUCCESS;
    }
}    

template<class ElemType>
int SqQueue<ElemType>::Length()const
{
    return ((rear%maxSize)-(front%maxSize));
}

template<class ElemType>
bool SqQueue<ElemType>::Empty()const
{
    return (rear%maxSize)==(front%maxSize);
}

template<class ElemType>
SqQueue<ElemType>::SqQueue(const SqQueue<ElemType> &copy)
{
    Init(copy.maxSize);
    front=copy.front;
    rear=copy.rear;

    for(int curPosition=front;curPosition<=rear;curPosition++)
        elem[curPosition%maxSize]=copy.elem[curPosition%maxSize];
}

template<class ElemType>
SqQueue<ElemType>& SqQueue<ElemType>::operator = (const SqQueue<ElemType> &copy)
{
    if(&copy!=this)
    {
        if(elem!=NULL)
            delete []elem;
        Init(copy.maxSize);
        front=copy.front;
        rear=copy.rear;

        for(int curPosition=front;curPosition<=rear;curPosition++)
            elem[curPosition%maxSize]=copy.elem[curPosition%maxSize];
    }
    return *this;
}
#endif