c++链循环队列模板

/**//*******************************************************/
/**//*独奏者 2009-09-03
/*
/*说明:循环队列模板
/*
/*
/*******************************************************/
//模板声明
template <class T>
struct QueueNode
{
    T typeData;
    QueueNode *nextNode;
};

template <class T>
struct QueueHead
{
    QueueNode<T>*    QueueFront;    //队头
    QueueNode<T>*     QueueRear;    //队尾
    int        iQueueCount;    //队列元素个数
    int        iQueueLen;    //队列长度
};

template <class T>
class DZ_Queue
{
public:    
    DZ_Queue();
    DZ_Queue(int iLen);
    ~DZ_Queue();
    bool    IsEmpty();
    bool    IsFull();
    int    GetLength();
    int    GetCount();
    bool    Insert(const T& data);
    bool    Delete(T& data);
    bool    Front(T& data);
private:
    QueueHead<T> m_QueueHead;
};

template <class T>
DZ_Queue<T>::DZ_Queue()
{
    m_QueueHead.QueueFront=NULL;
    m_QueueHead.QueueRear=NULL;
    m_QueueHead.iQueueLen=64;
    m_QueueHead.iQueueCount=0;
}

template <class T>
DZ_Queue<T>::DZ_Queue(int iLen)
{
    m_QueueHead.QueueFront=NULL;
    m_QueueHead.QueueRear=NULL;
    m_QueueHead.iQueueLen=iLen;
    m_QueueHead.iQueueCount=0;
}

template <class T>
DZ_Queue<T>::~DZ_Queue()
{    
    T typeData;
    while (!IsEmpty())
    {        
        Delete(typeData);    
    }
}

template <class T>
bool DZ_Queue<T>::IsEmpty()
{
    if ( 0 == m_QueueHead.iQueueCount )
        return true;
    else
        return false;
}

template <class T>
bool DZ_Queue<T>::IsFull()
{
    if ( m_QueueHead.iQueueLen == m_QueueHead.iQueueCount )
        return true;
    else
        return false;
}

template <class T>
int DZ_Queue<T>::GetLength()
{
    return m_QueueHead.iQueueLen;
}

template <class T>
int DZ_Queue<T>::GetCount()
{
    return m_QueueHead.iQueueCount;
}

template <class T>
bool DZ_Queue<T>::Insert(const T& data)
{    
    if (IsFull())
        return false;
    
    QueueNode<T>* pQueueNode=new QueueNode<T>;
    if( NULL == pQueueNode)
        return false;
    if ( IsEmpty() )
    {
        m_QueueHead.QueueFront=pQueueNode;
    }

    pQueueNode->typeData=data;
    pQueueNode->nextNode=NULL;
    
    if ( NULL == m_QueueHead.QueueRear )
        m_QueueHead.QueueRear=pQueueNode;
    else
        m_QueueHead.QueueRear->nextNode=pQueueNode;
    
    m_QueueHead.QueueRear=pQueueNode;
    m_QueueHead.iQueueCount++;
    
    return true;
}    

template <class T>
bool DZ_Queue<T>::Delete(T& data)
{    
    if ( IsEmpty() )
        return false;
    
    QueueNode<T>* pQueueNode=NULL;    
    pQueueNode=m_QueueHead.QueueFront;
    data=m_QueueHead.QueueFront->typeData;
    m_QueueHead.QueueFront=m_QueueHead.QueueFront->nextNode;
    delete (pQueueNode);
    m_QueueHead.iQueueCount--;
    
    if (IsEmpty())
    {
        m_QueueHead.QueueFront=NULL;
        m_QueueHead.QueueRear=NULL;
    }
    
    return true;
}

template <class T>
bool DZ_Queue<T>::Front(T& data)
{    
    if ( IsEmpty() )
        return false;
    
    data=m_QueueHead.QueueFront->typeData;
    return true;
}