C++实验3 模板

一.模板函数

定义：函数模板不是一个实在的函数，编译器不能为其生成可执行代码。定义函数模板后只是一个对函数功能框架的描述，当它具体执行时，将根据传递的实际参数决定其功能

为了交换两个整型变量的值，需要写下面的 Swap 函数：

void Swap(int & x, int & y)
{
    int tmp = x;
    x = y;
    y = tmp;
}

为了交换两个 double 型变量的值，还需要编写下面的 Swap 函数：

void Swap (double & xr double & y)
{
    double tmp = x;
    x = y;
    y = tmp;
}

如果还要交换两个 char 型变量的值需要再编写 Swap 函数。而这些 Swap 函数除了处理的数据类型不同外，形式上都是一样的。能否只写一遍 Swap 函数，就能用来交换各种类型的变量的值呢？继承和多态显然无法解决这个问题。因此，“模板”的概念就应运而生了。

1.1 一般模板函数

写法如下：

template <class 类型参数1, class类型参数2, ...>
返回值类型  模板名(形参表)
{
    函数体
}

class也可以换成typename，如下：

template <typename 类型参数1, typename 类型参数2, ...>

模板函数看上去就像函数，Swap函数如下：

template <class T>
void Swap(T & x, T & y)
{
    T tmp = x;
    x = y;
    y = tmp;
}

T 是类型参数，代表类型。编译器由模板自动生成函数时，会用具体的类型名对模板中所有的类型参数进行替换，其他部分则原封不动地保留。同一个类型参数只能替换为同一种类型。编译器在编译到调用函数模板的语句时，会根据实参的类型判断该如何替换模板中的类型参数。

1.2 特化模板函数

使用模板时会遇到一些特殊的类型需要特殊处理，不能直接使用当前的模板函数，所以此时我们就需要对该类型特化出一个模板函数（就是写出一个模板函数专门给该类型使用）

一个判断相等的函数：

template<class T>
bool Isequal(T& p1, T& p2){
	return p1 == p2;
}
 

但是该模板函数在对于字符串进行比较时就不能使用了，对于字符串我们不能直接比较，因此直接特化出一个专门供字符串使用的模板参数

template<> // 此处不添加类型模板，直接使用空即可
bool Isequal<char*>(char*& p1, char*& p2){
	return strcmp(p1, p2) == 0;
}

【注意】

• 使用模板特化时，必须要先有基础的模板函数（就是上面第一个模板函数）

• 使用特换模板函数时格式有要求：

  1.template 后直接跟<> 里面不用写类型
  2.函数名<特化类型>（特化类型 参数1， 特化类型 参数2 , …） 在函数名后跟<>其中写要特化的类型

• 特化的函数的函数名，参数列表要和原基础的模板函数想相同，避免不必要的错误

二.模板类Queue或Stack

1.1 模板类Queue

队列（queue）是先进先出的数据结构，存储方式可以是数组也可以是链表。如果用数组存储，一般采用循环队列的方式。

所以需记住几个关键点：

队头指针进1：front = (front+1)%maxsize

队尾指针进1：rear = (rear+1)%maxsize

判断队空：front = rear

判断队满：front = (rear+1)%maxsize，这里，队满的时候队尾和队头之间空有一个元素，以此来避免和front=rear混淆

定义头文件
 

/*队列用数组存储的一般用循环队列
  front = (front+1)%maxsize
  rear = (rear+1)%maxsize
  队头指向存储的第一个元素，而队尾指向的是存储的最后一个元素的下一个位置
  所以，在队列满的时候，队头和队尾之间是空有一个元素的，否则当front==rear时，
  会混淆满队和空队
  空队：front == rear
  满队：(rear+1)%maxsize ==front
*/
 
#include <assert.h>
#include<iostream>
using namespace std;
 
template<class T>
class SeqQueue{
public:
	SeqQueue(int sz=50);
	~SeqQueue();
	bool EnQueue(const T& x);
	bool DeQueue();
	T getFront(); //获取队头元素
	bool makeEmpty(){front = rear =0; return true;}
	bool isEmpty()const{return (front==rear)?true:false;}
	bool isFull()const{return ((rear+1)%maxsize==front)?true:false;}
	int getsize()const{return (rear-front+maxsize)%maxsize;}  //获取队列元素个数
private:
	int front,rear;
	T* element;
	int maxsize;
};
 

成员函数的实现

#include "queue.h"
 
template<class T>
SeqQueue<T>::SeqQueue(int sz):maxsize(sz):front(0):rear(0){
	element = new T[maxsize];
	assert(element!=NULL);
}
 
template<class T>
bool SeqQueue<T>::EnQueue(const T& x){
	if(isFull()==true)return false;
	element[rear]=x;
	rear = (rear+1)%maxsize;
	return true;
}
 
template<class T>
bool SeqQueue<T>::DeQueue(){
	if(isEmpty()==true)return false;
	T x = element[front];
	front = (front+1)%maxsize;
	delete x;
	return true;
}
 
template<class T>
T SeqQueue<T>::getFront(){
	if(isEmpty()==true)return -1;
	return element[front];
}
 

1.2 模板类Stack

头文件

#include<assert.h>
#include<iostream>
using namespace std;
 
const int stackIncreament=20;
template<class T>
class SeqStack{
public:
	SeqStack(int sz = 50);
	~SeqStack();
	bool push(const T& x);
	bool pop(const T& x);
	bool isFull()const{return (top == maxsize-1)?true:false;}
	bool isEmpty()const{return (top ==-1)?true:false;}
	int getsize(){return top+1;}
	T gettop();
	void makeEmpty(){top = -1;}
private:
	T * element;
	int maxsize;
	int top;
	void overflowProcess();
};

成员函数实现

#include "queue.h"
 
template<class T>
SeqQueue<T>::SeqQueue(int sz):maxsize(sz):front(0):rear(0){
	element = new T[maxsize];
	assert(element!=NULL);
}
 
template<class T>
bool SeqQueue<T>::EnQueue(const T& x){
	if(isFull()==true)return false;
	element[rear]=x;
	rear = (rear+1)%maxsize;
	return true;
}
 
template<class T>
bool SeqQueue<T>::DeQueue(){
	if(isEmpty()==true)return false;
	T x = element[front];
	front = (front+1)%maxsize;
	delete x;
	return true;
}
 
template<class T>
T SeqQueue<T>::getFront(){
	if(isEmpty()==true)return -1;
	return element[front];
}
 

1.3 模板特化

1.3.1.1 函数模板

template <class T>
void Swap(T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}

template <class T>
T add(T a, T b)
{
	return a + b;
}

template <class T1,class T2>
T2 Add(const T1& a, const T2& b)
{
	return a + b;
}

int Add(const int& a, const int& b)
{
	return a + b;
}

1.3.1.2 函数模板特化

函数模板
template <class T>
T Add(T& a, T& b)
{
	return a + b;
}

函数模板的特化
template <>
char* Add<char*>(char*& a, char*& b)
{
	strcat(a, b);
	return a;
}

普通函数
char* Add(char*& a, char*& b)
{
	strcat(a, b);
	return a;
}

 1.3.2 类模板及特化

  1.3.2.1 类模板

  

template <class T1, class T2, class T3>
class Date
{
public:
	Date(T1 year, T2 month, T3 day)
		:_year(year)
		, _month(month)
		, _day(day)
	{}

	void Display();
	/*{
		cout << _year << "-" << _month << "-" << _day << endl;
	}*/
private:
	T1 _year;
	T2 _month;
	T3 _day;
};

1.3.2.2 类模板特化

特化之前需要存在基础类模板
template <class T1, class T2>
class A
{
public:
	A()
	{
		cout << "A(T1, T2)" << endl;
	}
private:
	T1 _t1;
	T2 _t2;
};

全特化--> 所有的参数都为具体类型
template <>
class A<int, char>
{
public:
	A()
	{
		cout << "A(int, char)" << endl;
	}
private:
	int _t1;
	char _t2;
};



偏特化： a. 部分特化
template <class T1>
class A<T1, double>
{
public:
	A()
	{
		cout << "A(T1, double)" << endl;
	}
private:
	T1 _t1;
	double _t2;
};

template <class T1>
class A<T1, char>
{
public:
	A()
	{
		cout << "A(T1, char)" << endl;
	}
private:
	T1 _t1;
	double _t2;
};

b. 对模板参数做进一步的限制
template <class T1, class T2>
class A<T1&, T2&>
{
public:
	A()
	{
		cout << "A(T1&, T2&>" << endl;
	}
};

三.类模板模拟智能指针auto_ptr

#include <iostream>
using namespace std;
 
template <typename T>
class autoptr{
	T* p;
public:	
	autoptr(T* p=0):p(p){}
	~autoptr(){delete p;}
	autoptr(autoptr& a):p(0){operator=(a);}
	//autoptr(autoptr& a){operator=(a);}//错误的拷贝构造函数，p没有初始化，将是野指针，会delete出错
	autoptr& operator=(autoptr& a){
		if(this==&a) return *this;
		/*如果之前管理的内存不为空，释放之前管理的内存*/
		if(p!=NULL) {
			//cout << "free previous memory\n";
			delete p;
		}
		p = a.p;
		a.p = NULL;
		return *this;
	}
	/* *和->重载 */
	T& operator*()const{return *p;}
	T* operator->()const{return p;}
};
class A{
	int data;
public:
	A(int d):data(d){cout<<this<<"A("<<d<<")"<<endl;}
	~A(){cout<<this<<"~A()"<<data<<endl;}
	void show()const{cout<<this<<":"<<data<<endl;}
};
int main()
{
	autoptr<A> p(new A(10));
	p->show();
	autoptr<A> q(p);
	//p->show();出错，p已经没有动态内存的所有权了
	q->show();
	autoptr<A> r(new A(20));
	(*r).show();
	r = q;
	r->show();
	(*r).show();
	autoptr<A> x;
	x=r;
	(*x).show();
}
 

运行结果