队列——顺序存储的循环队列（自定义模板）

队列模板（MyQueue.h）

#pragma 
template<typename E>
class MyQueue
{
public:
    MyQueue(int queueCapacity);//InitQueue(&Q)  创建队列
    virtual ~MyQueue();   //DestroyQueue(&Q)销毁队列
    void ClearQueue();    //ClearQueue(&Q)清空队列
    bool QueueEmpty() const;  //QueueEmpty(Q) 判空
    bool QueueFull() const;    //判断队满操作
    int QueueLength() const;   //QueueLength(Q)队列长度
    bool EnQueue(E element);
    bool DeQueue(E &element);
    void QueueTraverse();    //QueueTraverse(Q,visit())遍历队列

private:
    E *m_pQueue;  //队列数组指针
    int m_iQueueLen;   //队列元素个数
    int m_iQueueCapacity;  //队列数组容量
    int m_iHead;
    int m_Tail;
};

template<typename E>
MyQueue<E>::MyQueue(int queueCapacity)
{
    m_pQueue = new E[queueCapacity];
    m_iQueueCapacity = queueCapacity;
    ClearQueue();
}

template<typename E>
MyQueue<E>::~MyQueue()
{
    delete[] m_pQueue;
    m_pQueue = NULL;
}

template<typename E>
void MyQueue<E>::ClearQueue()
{
    m_iQueueLen = 0;
    m_iHead = 0;
    m_Tail = 0;
}

template<typename E>
bool MyQueue<E>::QueueEmpty() const
{
    return (m_iQueueLen == 0 ? true : false);
}
template<typename E>
bool MyQueue<E>::QueueFull() const
{
    return m_iQueueCapacity == m_iQueueLen ? true : false;
}

template<typename E>
int MyQueue<E>::QueueLength() const
{
    return m_iQueueLen;
}

template<typename E>
bool MyQueue<E>::EnQueue(E element)
{
    if (QueueFull())
    {
        return false;
    }
    else
    {
        m_pQueue[m_Tail++] = element;
        m_Tail = m_Tail % m_iQueueCapacity;
        m_iQueueLen++;
        return true;
    }
}
template<typename E>
bool MyQueue<E>::DeQueue(E &element)
{
    if (QueueEmpty())
    {
        return false;
    }
    else
    {
        element = m_pQueue[m_iHead++];
        m_iHead = m_iHead % m_iQueueCapacity;
        m_iQueueLen--;
        return true;
    }
}
template<typename E>
void MyQueue<E>::QueueTraverse()
{
    for (int i = m_iHead;i < m_iQueueLen + m_iHead;i++)
    {
        cout<<m_pQueue[i%m_iQueueCapacity]<<endl;
    }
}

我们可以看出，这次将队列头文件的实现也放在头文件中，大家有没有想到这是为什么呢？
在《C++ primer》中文版第16章”模板与泛型编程“582页中提到：
当编译器遇到一个模板定义时，它并不生成代码。只有当我们实例化出模板的一个特定版本时，编译器才会生成模板。当我们使用模板（而非定义）模板时，编译器才会生成代码。
通常，我们调用一个函数时，编译器只需要掌握函数的声明。类似的，当我们使用一个类类型时，类定义必须是可用的，但是成员函数的定义不必出现。所以我们可以将头文件和类的实现文件分开。
模板则不同，为了生成一个实例化版本，编译器需要掌握函数模板或者类模板成员函数的定义。因此，与非模板代码不同，模板的头文件通常包括声明也包括定义。
结论：函数模板和类模板成员函数的定义通常放在头文件中。

自定义类（Customer.h）

#pragma once
#include<string>
using namespace std;

class Customer
{
public:
    Customer(string name="", int age=0);
    //重载输出运算符
    friend  ostream& operator<<(ostream& out, const Customer& obj);
private:
    string m_strName;
    int m_iAge;
};

因为队列要变成模板类，所以其遍历程序要符合大多数程序。一般而言，均是采用cout输出。则对自定类需要重载输出运算符，故做了简单的修改。

自定义类的实现（MyCustomer.cpp）

#include<iostream>
#include"Customer.h"

Customer::Customer(string name, int age)
{
    m_strName = name;
    m_iAge = age;
}

ostream & operator<<(ostream & out, const Customer & obj)
{
    out << obj.m_strName << " " << obj.m_iAge << " " <<endl;
    return out;
}

测试函数

#include<iostream>
#include "Customer.h"
#include "Queue.h"

using namespace std;

//循环队列
int main()
{
    //测试Customer类
    MyQueue<Customer> cur(4);
    Customer c1("jack", 10);
    Customer c2("sva", 20);
    Customer c3("greqrg", 30);
    Customer c4("javfdck", 40);
    cur.EnQueue(c1);
    cur.EnQueue(c2);
    cur.EnQueue(c3);
    cur.EnQueue(c4);
    cur.QueueTraverse();

    cout << endl;

    Customer c5;
    cur.DeQueue(c5);
    cout << c5 << endl;

    Customer c6;
    cur.DeQueue(c6);
    cout << c6 << endl;

    cout << endl;
    cur.QueueTraverse();
    cur.ClearQueue();

    cout << endl;
    Customer c7("vavdf", 90);
    Customer c8("wefer", 40);
    cur.EnQueue(c7);
    cur.EnQueue(c8);
    cur.QueueTraverse();

    //测试int类
    MyQueue<int> curOne(4);
    curOne.EnQueue(1);
    curOne.EnQueue(2);
    curOne.EnQueue(3);
    curOne.EnQueue(4);
    curOne.QueueTraverse();

    cout << endl;

    int valueOne=0;
    curOne.DeQueue(valueOne);
    cout << valueOne << endl;

    int valueTwo = 0;
    curOne.DeQueue(valueTwo);
    cout << valueTwo << endl;

    cout << endl;
    curOne.QueueTraverse();
    curOne.ClearQueue();

    cout << endl;
    curOne.EnQueue(11);
    curOne.EnQueue(12);
    curOne.QueueTraverse();

    system("pause");

    return 0;
}