包含的主要知识点
1.队列类的写法。
2.深拷贝函数,深拷贝构造函数。
3.operator=的深拷贝重载。
运行截图
队列类头文件
#pragma once
#include<iostream>
#include<ostream>
using namespace std;
#define MaxSize 100//规定100 个为最大容量。
using namespace std;
template<typename T>
class Queue;
template<typename T>
ostream& operator <<(ostream &out, Queue<T> a);
template<typename T>
struct Node;
template<typename T>
ostream& operator <<(ostream &out, Node<T> a);
//队列只要头尾的操作,没必要写成双链表。这里我写成双链表形式,只是为了展示双链表在应用中的写法罢了。
template<typename T>
struct Node
{
T Data;
Node<T> * Front;
Node<T> * Next;
friend ostream& operator << <>(ostream &out, Node<T> a);
};
//不带头结点的写法。
template<typename T>
class Queue
{
public:
Queue();//默认构造函数。
Queue(T a[], int length);//含参构造函数。
Queue(Queue<T> &a);//深拷贝构造函数。
~Queue();//析构函数。
private:
Node<T> *First;//有头指针,就可以不用头结点了。
Node<T> *Tail;//队尾。
int Size;//队长。
public:
void InitQueue();//初始化队列。
void DestroyQueue();//销毁队列。使之只剩下头结点。
void EnQueue(T Obj);//将 Obj 插入队列。
T DeQueue();//删除队首。
T GetFront();//获取队首元素。
bool IsEmpty();//判断队列是否为 空。
bool IsFull();//判断队列是否满。
int GetSize();//获取队列元素个数。
friend ostream& operator << <> (ostream &out, Queue<T> a);
Queue<T>& operator = (Queue<T> &a);
};
template<typename T>
ostream& operator << (ostream &out, Queue<T> a)
{
int count = a.Size;
Node<T> *p = a.First;
while (count-- > 0)
{
out << p->Data << " ";
p = p->Next;
}
out << endl;
return out;
}
template<typename T>
inline ostream& operator << (ostream &out, Node<T> &a)
{
out << a.Data;
}
队列类源文件
#include "stdafx.h"
#include "Queue.h"
template<typename T>//无参数构造函数
Queue<T>::Queue()
{
Node<T> *NewNode = new Node<T>;
Tail = First = NewNode;
NewNode->Front = NewNode->Next = NewNode;
Size = 0;
}
template<typename T>//含参数构造函数
Queue<T>::Queue(T a[], int length)
{
if (length > MaxSize || length<1)
{
throw "Too many or less nodes.\n";
}
Node<T> *NewNode = new Node<T>;
NewNode->Front = NewNode->Next = NewNode;
Tail = First = NewNode;//队首指针为此地址的下一个。
for (this->Size = 0; this->Size < length; this->Size++)
{
NewNode = new Node<T>;
NewNode->Data = a[this->Size];
NewNode->Front = Tail;
NewNode->Next = First;
Tail->Next = NewNode;
Tail = NewNode;
First->Front = NewNode;
}
First = First->Next;
};
template<typename T>//默认深拷贝构造函数
Queue<T>::Queue(Queue<T>& a)
{
Node<T> *cursor = a.First;
Node<T> *NewNode = new Node<T>;
Tail = First = NewNode;
NewNode->Front = NewNode->Next = NewNode;
for (this->Size = 0; this->Size < a.Size; this->Size++)
{
NewNode = new Node<T>;
NewNode->Data = cursor->Data;
NewNode->Front = Tail;
NewNode->Next = First;
Tail->Next = NewNode;
Tail = NewNode;
First->Front = NewNode;
cursor = cursor->Next;
}
First = First->Next;
};
template<typename T>
Queue<T>::~Queue()
{
Node<T> *cursor = First = First->Front;
while (Size-- >0)
{
First = cursor->Next;
delete cursor;
cursor = First;
}
delete cursor;
}
template<typename T>
inline void Queue<T>::InitQueue()
{
cout << "初始化队列,这个函数暂时用不到初始化的功能" << endl;
}
template<typename T>
void Queue<T>::DestroyQueue()
{
Node<T> *cursor = First;
while (Size-- > 0)
{
First = cursor->Next;
delete cursor;
cursor = First;
}
First->Next = First->Front = First;
}
template<typename T>
void Queue<T>::EnQueue(T Obj)
{
if (this->Size + 1 > MaxSize)
{
cout << "循环队列满了不能插入" << endl;
return;
}
Node<T> * NewNode = new Node<T>;
NewNode->Data = Obj;
NewNode->Front = Tail;
NewNode->Next = Tail->Next;
Tail->Next = NewNode;
Tail = NewNode;
Tail->Next->Front = NewNode;
Size++;
}
template<typename T>
T Queue<T>::DeQueue()
{
if (Size <= 0)
{
throw"there is too less data to be delete";
}
Node<T> *cursor = First;
T obj = First->Data;
First = First->Next;
cursor->Front->Next = cursor->Next;
cursor->Next->Front = cursor->Front;
delete cursor;
Size--;
return obj;
}
template<typename T>
T Queue<T>::GetFront()
{
return First->Data;
}
template<typename T>
bool Queue<T>::IsEmpty()
{
return Size > 0 ? false : true;
}
template<typename T>
bool Queue<T>::IsFull()
{
return Size >= 100 ? true : false;
}
template<typename T>
int Queue<T>::GetSize()
{
return Size;
}
template<typename T>
Queue<T>& Queue<T>::operator=(Queue<T>& a)
{
Queue<T> RETURN;
RETURN.First = RETURN.Tail = new Node<T>;
NewNode->Front = NewNode->Next = NewNode;
Node<T> *cursor = a.First;
Node<T> *NewNode;
for (RETURN.Size = 0; RETURN.Size<a.Size; RETURN.Size++)
{
NewNode = new Node<T>;
NewNode->Data = cursor->Data;
NewNode->Front = RETURN.Tail;
NewNode->Next = RETURN.Tail->Next;
RETURN.Tail->Next = NewNode;
RETURN.Tail = NewNode;
RETURN.Tail->Next->Front = NewNode;
cursor = cursor->Next;
}
RETURN.First = RETURN.First->Next;
return RETURN;
}
主函数验证
// 队列类.cpp : 定义控制台应用程序的入口点。
//
// 队列类.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include<iostream>
#include"Queue.cpp"
#include<ostream>
using namespace std;
int main()
{
int arr[3] = { 1,2,3 };
Queue<int> a(arr,3);
cout <<"原始队列a为: "<< a;
Queue<int> b(a);
cout << "拷贝构造函数b: "<<b;
a.EnQueue(4);
cout << "插入元素4 后: " << a;
a.EnQueue(5);
cout<< "插入元素5后: " << a;
a.DeQueue();
cout << "队首出队后:" << a;
Queue<int> c = a;
cout << "opeartor=函数c: " << c;
c.DestroyQueue();
getchar();
return 0;
}