使用类模板封装数据结构—循环队列

模板

模板是泛型编程的基础

函数模板语法形式

template<class 形参,class 形参,...> //类型形参列表
返回值类型 函数名(形参列表)
{
	//函数体
}

//或者以下方式
template<typename 形参,typename 形参,...>
返回值类型 函数名(形参列表)
{
	//函数体
}

示例 用函数模板实现乘法

		//函数模板
		template <class T>
		T add(T &a,T &b) //引用类型传参
		{
			return a*b;
		}
		int main()
		{
			float a = 8.1;
			float b = 6.2;
			cout << add(a,b) << endl;

			int m = 2;
			int n = 5;
			cout << add(m,n) << endl;
			return 0;
		}

类模板语法形式

template<class 形参名,class 形参名,....>
class 类名
{
	......
};

示例 用类模板与函数模板实现封装循环队列

#include <iostream>
#include <cassert> //断言函数需要加的头文件

using namespace std;

template <class T>
struct Node{
    T *data;
    int front,rear;
};

template <class T,int len> //此为非类型模板参数
class Queue
{
    public:
        Queue() //构造函数
        {
            qu = new struct Node<T>;
            assert(qu != NULL); //断言函数
            qu->front = qu->rear = 0;
            qu->data = new T[len];
            assert(qu->data != NULL);
            cout << __func__ <<endl; //调用时，打印该函数的函数名
        }
        ~Queue() //析构函数
        {
            delete qu;
            delete [] qu->data;
            cout << __func__ << endl;
        }
    public:
        int empty(); //一般都是在类外面定义成员函数的
        int full();
        int getlen();
        void show() const;

        int insert(T);
        T out_queue();
    private:
        struct Node<T> *qu;
};

//队列判空
template <class T,int len>
int Queue<T,len>::empty()
{
    if(qu->front == qu->rear)
    {
        cout << "queue is empty" << endl;
        return 1;
    }
    else
        return -1;
}

template <class T,int len>
int Queue<T,len>::full()
{
    if((qu->rear + 1)%len == qu->front)
    {
        cout << "queue is full" << endl;
        return 1;
    }
    else
        return -1;
    
}

template <class T,int len>
int Queue<T,len>::getlen()
{
    int qu_len;
    qu_len = ((qu->rear - qu->front)+len)%len;
    return qu_len;
}

template <class T,int len>
void Queue<T,len>::show() const
{
    int i;
    for(i=qu->front;i != qu->rear;i = (i+1)%len)
        cout << qu->data[i] << " ";
    cout << endl;
}

//入队操作
template <class T,int len>
int Queue<T,len>::insert(T qu_data)
{
    if(full() == 1)
        return -1;
    qu->data[qu->rear] = qu_data;
    qu->rear = (qu->rear+1)%len;
    return 0;
}

//出队操作
template <class T,int len>
T Queue<T,len>::out_queue()
{
    if(empty() == 1)
        return -1;
    T temp = qu->data[qu->front];
    qu->front = (qu->front+1)%len;
    return temp;
}

int main()
{
    Queue<int,10> queu; //创建一个类对象
    for(int i = 0;i < 8;i++)
    {
        queu.insert(i+2);
    }
    queu.show();

    cout << queu.out_queue() << endl;;
    queu.show();
    
    cout << queu.getlen() << endl;
    return 0;
}