函数模板和类模板——郭炜_函数模版多个类型-CSDN博客

本文链接：https://blog.csdn.net/qq_28912319/article/details/105698862

提高代码可重用性：
继承
范式程序设计————函数模板

1.函数模板

1.1结构体

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

template < class T1，class T2>
void Swap(T1 & x,T2 & y){//在调用的时候根据传进来实参的类型来确定T的类型
	cout<<x<<y;
}

1.2函数模板实例化

由模板生成函数的过程称为模板的实例化
	通过传递参数实例化
	不通过传递参数实例化————用尖括号<数据类型>

template <class T>
T Inc(T n){
	return 1 + n;
}
int main() {
	cout << Inc<double>(4)/2; //意味着将T换成double
	return 0;//输出 2.5，否则直接穿进去4的话，T就是int类型了
}

1.3函数模板重载

函数模板可以重载，只要它们的形参表 或 类型参数表不同即可

以下函数全都可以重载
template<class T1, class T2>
void print(T1 arg1, T2 arg2) { 
	cout<< arg1 << " "<< arg2<<endl; 
}

template<class T>
void print(T arg1, T arg2) { 
	cout<< arg1 << " "<< arg2<<endl; 
}

template<class T,class T2>
void print(T arg1, T arg2) { 
	cout<< arg1 << " "<< arg2<<endl; 
}

1.4模板函数和普通函数调用顺序

模板函数和函数的次序————在有多个函数和函数模板名字相同的情况下调用顺序
	1) 先找参数完全匹配的普通函数(非由模板实例化而得的函数)。
	2) 再找参数完全匹配的模板函数。
	3) 再找实参数经过自动类型转换后能够匹配的普通函数。
	4) 上面的都找不到，则报错——即模板函数不能进行自动的类型转换

template <class T> 
T Max( T a, T b) {
	cout << "TemplateMax" <<endl; return 0;
}

template <class T,class T2> 
T Max( T a, T2 b) {
	cout << "TemplateMax2" <<endl; return 0;
}
double Max(double a, double b){//普通函数
	cout << "MyMax" << endl;
	return 0;
}
int main() {
	int i=4, j=5;
	Max( 1.2,3.4); // 输出MyMax
	Max(i, j); //输出TemplateMax——注意！这里优先调用了TemplateMax
	Max( 1.2, 3); //输出TemplateMax2
	return 0; 
}

1.5匹配模板函数时，不进行类型自动转换

template<class T>
T myFunction( T arg1, T arg2){ 
	cout<<arg1<<" "<<arg2<<"\n"; 
	return arg1;
};

myFunction( 5, 7); //ok：replace T with int
myFunction( 5.8, 8.4); //ok： replace T with double
myFunction( 5, 8.4); //error——不会将8.4自动转换成int类型!

1.6经典函数模板——Map

将类似数组的容器的某个区间的元素OP一下放到另一个区间上

#include <iostream>
using namespace std;
template<class T,class Pred>
void Map(T s, T e, T x, Pred op) {//op为指向函数的指针或函数对象
	for(; s != e; ++s,++x) {
		*x = op(*s);//函数类型参数的调用
	} 
}
int Cube(int x) { return x * x * x; }
double Square(double x) { return x * x; }
int a[5] = {1,2,3,4,5}, b[5];
double d[5] = { 1.1,2.1,3.1,4.1,5.1} , c[5];
int main() {
	Map(a,a+5,b,Square);
	for(int i = 0;i < 5; ++i) cout << b[i] << ",";
	cout << endl;
	Map(a,a+5,b,Cube);
	for(int i = 0;i < 5; ++i) cout << b[i] << ",";
	cout << endl;
	Map(d,d+5,c,Square);
	for(int i = 0;i < 5; ++i) cout << c[i] << ",";
	cout << endl;
	return 0; 
}
int a[5] = {1,2,3,4,5}, b[5];
Map(a,a+5,b,Square); //实例化出以下函数:
void Map(int * s, int * e, int * x, double ( *op)(double)) {//还是这个！
	for(; s != e; ++s,++x) {
		*x = op(*s);
	} 
}

2.类模板

在定义类的时候，加上一个/多个类型参数——<class T1,class T2.....>
在使用类模板时，指定类型参数应该如何替换成具体类型，编译器据此生成相应的模板类

//类型参数表——这里是class也可以————这里的类型参数可以有默认类型
template<typename 类型参数1，typename 类型参数2，……> 
class 类模板名{
	成员函数和成员变量
};

2.1成员函数在类外的写法：

也要带上类型参数表！

template <class 类型参数1，class 类型参数2，……> //类型参数表
返回值类型 类模板名<类型参数名列表>::成员函数名（参数表）{
	函数体
}
例：
template<class T1,class T2>//在类体外面也要带上这个
bool Pair<T1,T2>::operator < ( const Pair<T1,T2> & p) const{ //Pair的成员函数 operator <
	return key < p.key; 
}

2.2类模板的实例化

编译器由类模板生成类的过程叫类模板的实例化。
由类模板实例化得到的类，叫模板类。
同一个类模板的两个模板类是不兼容的————同一个类模板实例化出来得类是不一样的！

template <class T1,class T2>
class Pair//经典类！
{
	public:
	T1 key; //关键字
	T2 value; //值
	Pair(T1 k,T2 v):key(k),value(v) { };
	bool operator < ( const Pair<T1,T2> & p) const; 
};
template<class T1,class T2>//在类体外面也要带上这个
bool Pair<T1,T2>::operator < ( const Pair<T1,T2> & p) const{ //Pair的成员函数 operator <
	return key < p.key; 
}
int main()
{
	Pair<string,int> student("Tom",19); 
	//实例化出一个类 Pair<string,int>，尖括号里也可以是自定义的数据类型，可以使一个对象
	cout << student.key << " " << student.value; 
	return 0;
}

同一模板类实例化出来的类模板：
Pair<string,int> * p;
Pair<string,double> a;
p = & a; //wrong

2.3函数模版作为类模板成员

函数模板的声明和定义都必须放在类中！

template <class T>
class A{
	public:
	template<class T2> //类中也可以这样用！
	void Func( T2 t) { cout << t; } //成员函数模板
};
int main() {
	A<int> a;
	a.Func('K'); //成员函数模板 Func被实例化
	a.Func("hello"); //成员函数模板 Func再次被实例化
	return 0;
}

2.4类模板与非类型参数

类模板的“<类型参数表>”中可以出现非类型参数
同时也可以有默认的类型参数和默认的非类型参数

template <class T, int size>//非类型参数
class CArray{
	T array[size];
	public:
	void Print( ) {
		for( int i = 0;i < size; ++i)
		cout << array[i] << endl; 
	}
};
CArray<double,40> a2;
CArray<int,50> a3; //a2和a3属于不同的类

3类模板与派生

3.1类模板从类模板派生

template <class T1,class T2>
class A {
	T1 v1; T2 v2;
};
template <class T1,class T2>
class B:public A<T2,T1> { //A需要被实例化!
	T1 v3; T2 v4;
};
template <class T>
class C:public B<T,T> { //B需要被实例化!
	T v5;
};
int main() {
	B<int,double> obj1; //这里实例化了AB
	C<int> obj2; //这里实例化了BC
	return 0;
}

3.2类模板从模板类派生

template <class T1,class T2> 
class A { 
	T1 v1; T2 v2;
};
template <class T>
class B:public A<int,double> { //这里是模板类,实际上和普通类一样啦
	T v;
};
int main() {
	B<char> obj1; //自动生成两个模板类：A<int,double> 和 B<char>
	return 0; 
}

3.3类模板从普通类派生

class A { 
	int v1; 
};
template <class T>
class B:public A { //所有从B实例化得到的类，都以A为基类
	T v; 
};
int main() { 
	B<char> obj1; 
	return 0; 
}

3.4普通类从模板类派生

template <class T>
class A { 
	T v1; 
	int n; 
};
class B:public A<int> { 
	double v;
};
int main() { 
	B obj1; 
	return 0; 
}

4类模板与友员函数

函数模板在类中声明必须带上 类型参数表
类模板在其他类中声明必须带上 类型参数表

4.1函数、类、类的成员函数作为类模板的友元

注意：当ostream的成员函数声明为类的友元的时候必须把函数体放在类中！

void Func1() { }
class A { };
class B
{
	public:
	void Func() { } 
};
template <class T>
class Tmpl 
{
	friend void Func1();
	friend class A;
	friend void B::Func();
}; //任何从Tmp1实例化来的类，都有以上三个友元

4.2函数模板作为类模板的友元

template <class T1,class T2>
class Pair{
private:
	T1 key; //关键字
	T2 value; //值
public:
	Pair(T1 k,T2 v):key(k),value(v) { };
	bool operator < ( const Pair<T1,T2> & p) const; 
	template <class T3,class T4>//必须带上这个！
	friend ostream & operator<< ( ostream & o, const Pair<T3,T4> & p);
};
template<class T1,class T2>
bool Pair<T1,T2>::operator < ( const Pair<T1,T2> & p) const{ //"小"的意思就是关键字小
	return key < p.key;
}
template <class T3,class T4>//函数模板！
ostream & operator<< (ostream & o,const Pair<T1,T2> & p){
	o << "(" << p.key << "," << p.value << ")" ;
	return o;
}
int main()
{
	Pair<string,int> student("Tom",29);
	Pair<int,double> obj(12,3.14);
	cout << student << " " << obj;//这里实际上是实例化了两个函数
	return 0;
}
//任意从 
template <class T1,class T2>
ostream & operator<< (ostream & o,const Pair<T1,T2> & p)
//生成的函数，都是任意Pair摸板类的友元

4.3函数模板作为类的友元

class A{
	int v;
	public:
	A(int n):v(n) { } 
	template <class T>//必须带上这个
	friend void Print(const T & p);
};
template <class T>
void Print(const T & p){
	cout << p.v;//这样可以访问私有成员
}
int main() {
	A a(4);
	Print(a);
	return 0;
}

4.4类模板作为类模板的友元

template <class T>
class B {
	T v;
	public:
	B(T n):v(n) { }
	template <class T2>//必须带上这个
	friend class A; 
};
template <class T>
class A {
	public:
	void Func( ) { 
		B<int> o(10);
		cout << o.v << endl; //访问了B中的私有属性
	}
};
int main()
{
	A< double > a; 
	a.Func ();
	return 0;
}

5类模板与静态成员变量

类模板中可以定义静态成员，那么从该类模板实例化得到的所有类，都包含同样的静态成员。
由这个类模板实例化出来的模板类的静态成员并不共享，存放在不同的内存中

#include <iostream>
using namespace std;
template <class T>
class A
{
	private:
	static int count;
	public:
	A() { count ++; }
	~A() { count -- ; };
	A( A & ) { count ++ ; }
	stati void PrintCount() { cout << count << endl; }
};
//这里的类型参数表省略啦！
template<> int A<int>::count = 0;//类中的静态成员变量要单独的拿出来声明一下的
template<> int A<double>::count = 0;
//这里声明的时候是不是已经指定了这两个count属于哪个类了？
int main()
{
	A<int> ia;
	A<double> da;
	ia.PrintCount();
	da.PrintCount();
	return 0;
}

6典型问题

template <class T1,class T2>
class Pair{
private:
	T1 key; //关键字
	T2 value; //值
public:
	Pair(T1 k,T2 v):key(k),value(v) { };
	bool operator < ( const Pair<T1,T2> & p) const; 
	template <class T3,class T4>//必须带上这个！
	friend ostream & operator<< ( ostream & o, const Pair<T3,T4> & p);
};
template<class T1,class T2>
bool Pair<T1,T2>::operator < ( const Pair<T1,T2> & p) const{ //"小"的意思就是关键字小
	return key < p.key;
}
template <class T1,class T2>//函数模板！
ostream & operator<< (ostream & o,const Pair<T1,T2> & p){//用自己的T1 T2实例化pair
	o << "(" << p.key << "," << p.value << ")" ;
	return o;
}
int main()
{
	Pair<string,int> student("Tom",29);
	Pair<int,double> obj(12,3.14);
	cout << student << " " << obj;//这里实际上是实例化了两个函数
	return 0;
}
//任意从 
template <class T1,class T2>
ostream & operator<< (ostream & o,const Pair<T1,T2> & p)
//生成的函数，都是任意Pair摸板类的友元