C++环状数组队列模板类

类模板声明和定义都应放在.h文件。本文还是分别放在了h和cpp中，在使用的时候不能#include “CCircleQueue.h”，而是#include “CCircleQueue.cpp”。具体原因请看https://blog.csdn.net/u010273652/article/details/21568131

非线程安全
.H

#ifndef __CIRCLE_QUEUE_HH__
#define __CIRCLE_QUEUE_HH__
#include <stdlib.h>
#include <iostream>
typedef unsigned char uint8_t;
/*
1. 环状数组队列
2. 头出尾插。
3. 数组少用一个存储空间，用来判空和判满
4. 判空：d_front == d_rear为空
5. 判满：(d_rear + 1) % d_maxsize == d_front;
*/
template <class T>
class CircleQueue
{
private:
	//内部元素队列指针
	long d_rear, d_front;

	size_t d_size;
	size_t d_maxsize;
	T *d_arr;

public:
	//默认构造函数
	CircleQueue();

	//自定义构造函数
	CircleQueue(size_t);

	//析构函数
	~CircleQueue();

	//拷贝构造函数
	CircleQueue(const CircleQueue &) = delete;;

	//移动构造函数
	CircleQueue(CircleQueue &&) = delete;;

	//踢队操作
	T deque();

	//入队操作
	void enque(const T &);

	//获取尺寸
	size_t capacity() const;

	//查看队列首端元素
	T front() const;

	//查看队列末端元素
	T rear() const;

	//队列是否非空
	bool is_empty() const;

	//队列是否已满
	bool is_full() const;

	//返回队列已有数量
	const size_t size();

	//缓存
	const T *buffer();

	//打印队列
	template <class R>
	friend std::ostream &operator<<(std::ostream &, CircleQueue<R> &);
};
#endif

#include "CircleQueue.h"
#define DEFAULT_SIZE 15

template <class T>
CircleQueue<T>::CircleQueue()
{
	d_front = d_rear = 0;
	d_maxsize = DEFAULT_SIZE;
	d_size = 0;
	d_arr = new T[d_maxsize];
}

//构造函数
template <class T>
CircleQueue<T>::CircleQueue(size_t size)
{
	d_size = 0;
	d_maxsize = size;
	d_front = d_rear = 0;
	d_arr = new T[d_maxsize];
}

//析构函数
template <class T>
CircleQueue<T>::~CircleQueue()
{
	delete[] d_arr;
}

//检查环形队列是否为满载
template <class T>
bool CircleQueue<T>::is_full() const
{
	return (d_rear + 1) % d_maxsize == d_front;
}

//判断环形队列是否为空
template <class T>
bool CircleQueue<T>::is_empty() const
{
	return d_front == d_rear ? true : false;
}

//入队操作
template <class T>
void CircleQueue<T>::enque(const T &value)
{
	if (is_full())
	{
		std::cout << "环形队列已满" << std::endl;
		return;
	}
	else
	{
		d_rear = (d_rear + 1) % d_maxsize;
		d_arr[d_rear] = value;
		d_size++;
	}
}

template <class T>
size_t CircleQueue<T>::capacity() const
{
	return d_maxsize;
}
//踢队操作
template <class T>
T CircleQueue<T>::deque()
{
	if (is_empty())
	{
		std::cout << "环形队列为空!!" << std::endl;
		return T();
	}
	d_front = (d_front + 1) % d_maxsize;
	T data = d_arr[d_front];
	d_size--;
	return data;
}

//获取队头部元素
template <class T>
T CircleQueue<T>::front() const
{
	return d_arr[d_front];
}

//获取队尾元素
template <class T>
T CircleQueue<T>::rear() const
{
	return d_arr[d_rear];
}

//获取队列尺寸
template <class T>
const size_t CircleQueue<T>::size()
{
	return d_size;
}

//获取队列内部的缓存指针
template <class T>
const T *CircleQueue<T>::buffer()
{
	return d_arr;
}

//遍历
template <class R>
std::ostream &operator<<(std::ostream &os, CircleQueue<R> &q)
{

	const R *buf = q.d_arr;

	if (q.d_front == -1)
	{
		os << "CircleQueue为空" << std::endl;
	}
	else if (q.d_rear >= q.d_front)
	{
		for (auto i = q.d_front; i <= q.d_rear; i++)
		{
			os << buf[i] << ",";
		}
	}
	else
	{
		for (auto i = q.d_front; i < q.d_size; i++)
		{
			os << buf[i] << ",";
		}

		for (auto i = 0; i <= q.d_rear; i++)
		{
			os << buf[i] << ",";
		}
	}
	os << std::endl;
	return os;
}