C++实验三 —— 模板

一、模板函数compare

1、一般函数模板

// 模板函数
#include<iostream>
using namespace std;

template<typename T>
int compare(const T& a, const T& b) {		//定义模板函数
	
	
	return a == b ? 0 : a > b ? 1 : -1;
	
}


int main() {

	int a = 10, b = 6;
	double c = 6.6, d = 7.7;


	cout  << compare(a, b) << endl;
	cout  << compare(c, d) << endl;
	}

结果显示：

函数模板的定义形式是：
template<模板参数表>
类型名 函数名(参数表)
{
函数体的定义
}

2、特化函数模板

template<>			//特化模板函数
int compare<const char*>(const char* const& str_a, const char* const& str_b)
{
	return strcmp(str_a, str_b);
}

int main(){
cout <<compare('abc', 'abcd') <<endl;
}

运行结果：

模板特化：实例化模板时，对特定类型的实参进行特殊处理，即实例化一个特殊的实例版本；特化模板前都需加上template<>的固定格式

二、模板类Stack

1、类模板

#include<iostream>
using namespace std;

const int length = 10;
template<class T >                     //模板声明，其中T为类型参数 
class Stack {
public:
	Stack():	top(-1){}							//赋初值为-1
	void push(T ob);
	T pop();
	void clear();
	~Stack() ;																			

private:
	T stack[length];
	int top;
};


template<class T>
void Stack<T>::push(T ob)		//入栈函数定义，判断是否栈满
{
	if (top == length - 1)
	{
		cout << "栈满" << endl;
		return;
	}
	stack[top] = ob;
	cout << "入栈 " << ob << endl;
	top++;
}


template<typename T>		//出栈函数定义，判断是否空栈
T Stack<T>::pop()
{
	if (top == -1)
	{
		cout << "栈空" << endl;
		return 0;
	}
	
	top--;
	cout << "出栈 " << stack[top]<< endl;
	
	return stack[top];

}

template<class T>				//清空栈函数定义
void Stack<T>::clear() {
	top = -1;
	cout << "清空栈" << endl;

}


int main() {
	
	Stack<int> s1;			//int类型
	s1.pop();
	s1.push(1);
	s1.push(2);
	s1.push(3);
	s1.pop();
	s1.clear();
	
	Stack<char> s2;				//字符类型
	s2.pop();
	s2.push('a');
	s2.push('b');
	s2.push('c');
	s2.pop();
	s2.clear();
	
	return 0;
}

运行结果：

栈的基本状态有：一般状态，栈满，栈空。当栈中没有元素时称为栈空；当栈中元素个数达到上限称为栈满；当有元素但为栈满称为一般状态。

使用类模板使用户可以为类定义一种模式，使得类中的某些数据成员，某些成员函数的参数、返回值或局部变量能取不同类型

类模板声明的语法形式是
：
template<模板参数表>
class 类名
{
类成员声明
}

如果需要在类模板以外定义其成员函数，则要采用以下形式
：
template<模板参数表>
类型名 类名<模板参数标识符列表>：：函数名(参数表)

2、类模板的特化

//类模板的特化
#include<iostream>
using namespace std;

template<typename T1,typename T2>
class Test										//模板类
{
public:
	Test(T1 a, T2 b) :x(a), y(b) {
	cout<<"模板类"<<endl };

private:
	T1 x;
	T2 y;
};


template<>									//模板类的全特化
class  Test<int ,char>
{
public:
	Test(int a, char b) :x(a), y(b) {
		cout << "全特化" << endl;
	};
	
private:
	int x;
	char y;
};


template<typename T1>				//模板类的偏特化
class  Test<T1, int>
{
public:
	Test(T1 a, char b) :x(a), y(b) {
		cout << "偏特化" << endl;
	};

private:
	T1 x;
	char y;
};

模板分为类模板与函数模板，特化分为全特化与偏特化。全特化就是限定死模板实现的具体类型，偏特化就是如果这个模板有多个类型，那么只限定其中的一部分；

函数模板只能全特化不能偏特化；

三、模板类AutoPtr

template<class  T>
class AutoPtr {

public:
	AutoPtr(T* pData);
	AutoPtr(const AutoPtr<T>& h);
	~AutoPtr();
	void decrUser();
	AutoPtr<T>& operator=(const AutoPtr<T>& h);
	T* operator->() {													//运算符重载
		return m_pData;
	}
	T& operator*() {
		return *m_pData;
	}
	const T& operator*() const {
		return *m_pData;
	}
	const T& operato->() const {
		return m_pData;
	}


private:
	T* pData;
	int* m_nUser;
};

template<class T>											//构造函数
AutoPtr<T>::AutoPtr(T* pData)
{
	m_pData = pData;
	m_nUser = new int(1);
}

template<class T>
AutoPtr<T>::AutoPtr(const AutoPtr<T>& h)
{
	m_pData = h.m_pData;
	m_nUser =  h.m_nUser;
	(*m_nUser)++;
}

template<class T>												//拷贝构造函数
AutoPtr<T>& AutoPtr<T>::operator=(const AutoPtr<T>& h)				
{
	decrUser();
	m_pData = h.m_pData;
	m_nUser = h.m_nUser;
	(*m_nUser)++;
}




template<class T>							//析构函数
AutoPtr<T>::~AutoPtr()
{
	decrUser();
}

template<class T>
void AutoPtr<T>::decrUser()														
{
	--(*m_nUser);
	if ((*m_nUser) == 0) {
		delete m_pData;
		m_pData = 0;
		delete m_nUser;
		m_nUser = 0;
	}

}