c++提高编程 模板 （一）

• c++另一种编程思想为泛性编程，主要利用的技术就是模板
• c++提供两种模板机制：函数模板和类模板

一 函数模板 

（1）基本语法

函数模板的作用：

建立起一个通用的函数，其函数返回类型和形参类型可以不具体制定，用一个来虚拟的类型代表。

语法：

template<typename T>
函数声明的定义

解释：

template —— 声明创建模板

typename —— 表明其后面的符号是一种数据类型，可以用class代替

T —— 通用的数据类型，名称可以替换，通常为大写字母

 

//交换两个int类型的数据
void swapInt(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;

}

//交换两个double类型的变量
void swapDouble(double& a, double& b)
{
	double tmp = a;
	a = b;
	b = tmp;

}

//利用模板提供通用的交换函数
template<typename T>
void mySwap(T& a, T& b)
{
	T tmp = a;
	a = b;
	b = tmp;
}

void text()
{
	int a = 1;
	int b = 2;
	//利用模板实现交换
	//1.自动类型推导
	mySwap(a, b);

	//2.显示特定类型
	mySwap<int>(a, b);
}
int main()
{
	text();

	system("pause");
	return 0;
}

总结：

• 函数模板利用关键字template
• 使用函数模板有两种方式：自动类型推导，显示指定类型
• 模板的目的是为了提供复用性，将类型参数化

（2）注意事项

• 自动类型推导，必须推导出一致的数据类型才可以使用
• 模板必须要确定出T的数据类型，才可以使用

 

//利用模板提供通用的交换函数
template <class T>
void mySwap(T& a, T& b)
{
	T& tmp = a;
	a = b;
	b = tmp;
}

//1. 自动类型推导，必须推导出一致的数据类型T才能使用
void text()
{
	int a = 10;
	int b = 20;
	char c = 'c';

	mySwap(a, b);//正确，可以推导出一致的T
	//mySwap(a, c);//(int , char)未能推导出一致的数据类型
}

//2.模板需要推导出一致的数据类型才能使用
template <class T>
void Func()
{
	cout << "Func的调用" << endl;
}
void text1()
{
	//Func();//错误，模板不能独立使用，必须确定出T的类型
	Func<int>();//正确，利用显示指定方式的方式，给T一个类型，才能使用该模板
}

int main()
{
	text();
	text1();
	system("pause");
	return 0;
}

• 总结：使用模板时必须给出通用数据类型T，并且能够推导出一致的数据类型

（3）普通函数与函数模板

<1> 普通函数与函数模板的区别：

• 普通函数调用可以发生自动类型转换（隐式类型转换）
• 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
• 如果利用显示指定类型的方法，可以发生隐式类型转换

//普通函数
int myAdd1(int a, int b)
{
	return a + b;
}

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

void text()
{
	int a = 10;
	int b = 20;
	char c = 'c';
	myAdd1(a, c);//根据c的ASCII码值将c隐式转换成int类型进行运算

	//myAdd2(a, c);//报错使用自动类型推导时，不会发生自动类型转换
	myAdd2<int>(a, c);//正确，如果使用指定类型，可以发生隐式类型转换
}

int main()
{
	text();

	system("pause");
}

•  总结：建议使用显示指定类型的方式，调用函数模板，因为可以自己确定通用类型T

<2> 普通函数与函数模板的调用规则

• 如果函数模板和普通函数都可以调用，优先调用函数模板
• 可以通过空模板参数列表，强制调用函数模板
• 函数模板可以发生函数重载
• 如果函数模板可以产生更好的匹配，优先调用函数模板

//普通函数与函数模板的调用规则
void myprint(int a, int b)
{
	cout << "普通函数的调用" << endl;
}

template<class T>
void myprint(T a, T b)
{
	cout << "函数模板的调用" << endl;
}

template<class T>
void myprint(T a, T b,T c)
{
	cout << "函数模板重载的调用" << endl;
}

void text()
{
	int a = 10;
	int b = 20;
	int c = 30;
	//1.如果普通函数和函数模板都可以实现，优先调用普通函数
	myprint(a, b);//调用普通函数

	//2.可以通过空模板参数列表，强制调用函数模板
	myprint<>(a, b);//调用函数模板

	//3.函数模板可以发生函数重载
	myprint(a, b, c);//调用函数重载模板

	//4.如果函数模板可以产生更好的匹配，优先调用函数模板
	char d = 'a';
	char e = 'b';
	myprint(d, e);//调用函数模板

}

int main()
{
	text();

	system("pause");
	return 0;
}

• 总结：既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性

二 类模板

（1）基本语法：

类模板的作用：

建立起一个通用的类，其中类的成员类型可以不具体制定，用一个虚构的类型来代表

 语法：

template<typename T>
类

解释：

template —— 声明创建模板

typename —— 表明其后面的符号是一种数据类型，可以用class代替

T —— 通用的数据类型，名称可以替换，通常为大写字母

 

 

template <class nameType,class ageType>
class person
{
public:
	person(nameType name,ageType age )
	{
		this->mName = name;
		this->mAge = age;
	}
	void showPerson()
	{
		cout << this->mName << endl;
		cout << this->mAge << endl;
	}
public:
	nameType mName;
	ageType mAge;
};

void text()
{
	//直接指定nameType为string类型，ageType为int类型
	person <string, int>p1("克莱恩", 18);
	p1.showPerson();
}

int main()
{
	text();

	system("pause");
	return 0;
}

• 总结：类模板与函数模板语法类似，在声明模板template后面加上类，此类称为类模板

（2）类模板与函数模板的区别 

• 类模板没有自动类型推导的使用方式
• 类模板在模板参数列表中可以有默认参数

 （3）类模板中成员函数的创建时机

• 普通类中的成员函数可以一开始就创建
• 类模板中的成员函数在调用时才创建

（4）类模板作函数传入参数

三种方式：

•  指定传入的类型  ——直接显示对象的数据类型
• 参数模板化          ——将对象中的参数变为模板进行传递
• 整个类模板化       ——将这个对象类型模板化进行传递

//类模板
template <class nameType, class ageType>
class person
{
public:
	person(nameType name, ageType age)
	{
		this->mName = name;
		this->mAge = age;
	}
	void showPerson()
	{
		cout << this->mName << endl;
		cout << this->mAge << endl;
	}
public:
	nameType mName;
	ageType mAge;
};

//1.指定传入参数的类型
void printperson1(person<string, int>& p1)
{
	p1.showPerson();
}

//2.参数模板化
template<class T1,class T2>
void printperson2(person<T1, T2>& p2)
{
	p2.showPerson();
}

//3.整个类模板化
template<class T3>
void printperson3(T3& p3)
{
	T3.showperson();
}

 总结：

• 通过类模板创建的对象，都有三种方式向函数进行传参
• 使用比较广泛的是第一种：指定传入的类型

（5）类模板与继承

 当类模板碰到继承时，需要注意几点：

• 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
• 如果不指定，编译器无法给子类分配内存
• 如果想要灵活的指定父类中T的类型，子类也需要变为类模板

template <class T>
class father
{
	T t;
};
//class son: public father//错误，c++编译器需要给子类分配内存，必须知道父类中T的类型才可以向下继承
class son1 :public father<int>
{

};

//类模板继承类模板，可以用T2来指定父类中的T类型
template <class T1,class T2>
class son2:public father<T2>
{

};

 

总结：

•  如果父类是类模板，子类需要指定出父类中T的类型