队列模板(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;
}