纪念逝去的岁月——C++实现一个队列（使用类模板）

1、代码

2、运行结果

---

 

1、代码

#include <stdio.h>
#include <string.h>

template <typename T> class ClsQueueData
{
    private :
        ClsQueueData * __m_next;
        T * __m_Data;

    protected :
        void _clear();

    public :
        ClsQueueData(T * pData);
        ClsQueueData();
        ~ClsQueueData();
        void destroy();

        ClsQueueData * getNext();
        int setNext(ClsQueueData * p);

        T * getData();
        int setData(T * pData);
};

template <typename T> ClsQueueData<T>::ClsQueueData()
{
    __m_next = NULL;
    __m_Data = NULL;
}

template <typename T> ClsQueueData<T>::ClsQueueData(T * p)
{
    __m_next = NULL;
    __m_Data = p;
}

template <typename T> ClsQueueData<T>::~ClsQueueData()
{
    _clear();
}

template <typename T> ClsQueueData<T> * ClsQueueData<T>::getNext()
{
    return __m_next;
}

template <typename T> int ClsQueueData<T>::setNext(ClsQueueData * p)
{
    if(NULL == p)
    {
        return -1;
    }
    p->__m_next = NULL;
    __m_next = p;
    
    return 0;
}

template <typename T> T * ClsQueueData<T>::getData()
{
    return __m_Data;
}

template <typename T> int ClsQueueData<T>::setData(T * pData)
{
    __m_Data = pData;
    return 0;
}

template <typename T> void ClsQueueData<T>::_clear()
{
    if(NULL != __m_Data)
    {
        delete __m_Data;
    }
    __m_next = NULL;
}

template <typename T> void ClsQueueData<T>::destroy()
{
    __m_Data = NULL;
    __m_next = NULL;
    delete this;
}

template <typename T> class ClsQueue
{
    private :
        ClsQueueData<T> * __m_head;
        ClsQueueData<T> * __m_tail;
        size_t  __m_size;

    public :
        ClsQueue();
        ~ClsQueue();

        int  push(T * pData);
        int  pop (T ** pData);
        void clear();
        size_t getSize();
};

template <typename T> ClsQueue<T>::ClsQueue()
{
    __m_head = NULL;
    __m_tail = NULL;
    __m_size = 0;
}

template <typename T> ClsQueue<T>::~ClsQueue()
{
    __m_size = 0;
    ClsQueueData<T> * p = __m_head;
    while(p != NULL)
    {
        ClsQueueData<T> * x = p;
        p = p->getNext();
        delete x;
    }
    __m_head = NULL;
    __m_tail = NULL;
}

template <typename T> int  ClsQueue<T>::push(T * pData)
{
    ClsQueueData<T> * pElm = new ClsQueueData<T>;
    if(NULL == pElm)
    {
        return -1;
    }
    pElm->setData(pData);
    if(NULL == __m_head)
    {
        __m_head = pElm;
        __m_tail = pElm;
    }
    else if(NULL == __m_tail)
    {
        ClsQueueData<T> * p = __m_head;
        while(p->getNext() != NULL)
        {
            p = p->getNext();
        }
        __m_tail = p;
    }
    else
    {
        __m_tail->setNext(pElm);
        __m_tail = pElm;
    }
    __m_size ++;

    return 0;
}

template <typename T> int  ClsQueue<T>::pop (T ** pData)
{
    if(NULL == __m_head || NULL == pData)
    {
        return -1;
    }
    ClsQueueData<T> * p = __m_head;

    if(__m_head == __m_tail)
    {
        __m_head = __m_tail = NULL;
    }
    else
    {
        __m_head = __m_head->getNext();
    }
    __m_size --;
    *pData = p->getData();
    p->destroy();

    return 0;
}

template <typename T> void ClsQueue<T>::clear()
{
    ClsQueueData<T> * p = __m_head;
    while(p != NULL)
    {
        ClsQueueData<T> * x = p;
        p = p->getNext();
        delete x;
    }
    __m_head = __m_tail = NULL;
    __m_size = 0;
}

template <typename T> size_t ClsQueue<T>::getSize()
{
    return __m_size;
}

int main()
{
    ClsQueue<int> objQ;
    int i = 0;
    for(i = 0; i < 10; i++)
    {
        int * x = new int;
        *x = i;
        objQ.push(x);
        printf("line : [%d]; queue size : [%u]\n", __LINE__, objQ.getSize());
    }
    for(i = 0; i < 11; i++)
    {
        int * x = NULL;
        int iRet = objQ.pop(&x);
        printf("line : [%d]; queue size : [%u]\n", __LINE__, objQ.getSize());
        if(-1 == iRet)
        {
            printf("get data faild\n");
            continue;
        }
        if(i == *x)
        {
            printf("RIGHT\n");
        }
        else
        {
            printf("WRONG\n");
        }
        delete x;
    }
    for(i = 0; i < 10; i++)
    {
        int * x = new int;
        *x = i;
        objQ.push(x);
    }
    printf("line : [%d]; queue size : [%u]\n", __LINE__, objQ.getSize());
    objQ.clear();
    printf("line : [%d]; queue size : [%u]\n", __LINE__, objQ.getSize());

    return 0;
}

2、运行结果

　　2.1）编译

g++ -g    -c -o queue.o queue.cpp
g++ -g -o queue queue.o

　　2.2）运行结果

$ ./queue 
line : [207]; queue size : [1]
line : [207]; queue size : [2]
line : [207]; queue size : [3]
line : [207]; queue size : [4]
line : [207]; queue size : [5]
line : [207]; queue size : [6]
line : [207]; queue size : [7]
line : [207]; queue size : [8]
line : [207]; queue size : [9]
line : [207]; queue size : [10]
line : [213]; queue size : [9]
RIGHT
line : [213]; queue size : [8]
RIGHT
line : [213]; queue size : [7]
RIGHT
line : [213]; queue size : [6]
RIGHT
line : [213]; queue size : [5]
RIGHT
line : [213]; queue size : [4]
RIGHT
line : [213]; queue size : [3]
RIGHT
line : [213]; queue size : [2]
RIGHT
line : [213]; queue size : [1]
RIGHT
line : [213]; queue size : [0]
RIGHT
line : [213]; queue size : [0]
get data faild
line : [235]; queue size : [10]
line : [237]; queue size : [0]