目录

1，模板的概念

2，函数模板

2.1函数模板语法

2.2函数模板注意事项

2.3普通函数与函数模板的区别

2.4普通函数和函数模板的调用规则

2.5模板的局限性

3，类模板

3.1类模板语法             

3.2类模板与函数模板的区别

3.3类模板中成员函数创建时机

3.4类模板对象做函数参数

3.5类模板与继承

3.6类模板成员函数类外实现

3.7类模板分文件编写

3.8类模板与友元

1，模板的概念

模板就是建立通用的模具，大大提高复用性

特点：

• 模板不可以直接使用，他只是一个框架
• 模板的通用并不是万能的

2，函数模板

• C++的另一种编程思想称为泛型编程，主要利用的技术就是模板
• C++模板两种模式机制：函数模板和类模板

2.1函数模板语法

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

语法：

template <typename  T>         （显示T的类型可以用：typid(T).name来表示）

template     声明创建模板

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

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

交换值函数

void change(T &a, T &b)
{
    T c = a;
    a = b;
    b = c;
}

使用 ： change(a, b);   //自动类型推导；系统根据a，b的类型自动推导出T的类型
             change<double>(a, b);  //显式指定类型；直接表示出引用类型

2.2函数模板注意事项

注意事项：

• 自动类型推导，必须推导出一致的数据类型T，才可以使用  （传入的参数需要是相同的数据类型）

    double a = 10.12, b = 20.32;
    int c=30;
    change(a, b);   //自动类型推导；参数需要推导出一致的T的数据类型
    //change(a, c);      //错误，因为a，c的数据类型不一样，不能推导出一致的数据类型

• 模板必须要确定出T的数据类型，才可以使用（就是函数模板接下来的函数调用，需要指明T的数据类型）

template <typename T>
void show()   {}

此时用show();已经无法调用该函数

如果想调用，则需要用显式指定类型：  show<int>();

2.3普通函数与函数模板的区别

区别：

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

#include<iostream>
using namespace std;

template <typename T>
void add_1(T a, T b)
{
	cout << a + b << endl;
}

void add_2(int a, int b)
{
	cout << a + b << endl;
}

int main()
{
	double a = 10.12, b = 20.32;
	int c=10;
	//add_1(a, b);   //自动类型推导,不会发生隐式转换
	add_1<int>(a, c);      //显式指定类型的方式，可以发生隐式转换

	add_2(a, c);
	system("pause");
	return 0;
}

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

2.4普通函数和函数模板的调用规则

调用规则：

1. 如果函数模板和普通函数都可以实现，优先调用普通函数
2. 可以通过空模板参数列表来强制调用参数模板
3. 函数模板也可以发生重载
4. 如果函数模板可以产生更好的匹配，优先调用函数模板

    add_1(a, b);         //两个都可以使用，优先调用普通
    add_1<>(a, b);       //通过空模板参数列表，强制调用函数模板
    add_1(a, b, 10.12);  //模板函数重载
    add_1(a, c);         //如果可以产生更好匹配，优先调用函数模板

#include<iostream>
using namespace std;

template <typename T>
void add_1(T a, T b)
{
	cout <<"函数模板"<< a + b << endl;
}

template <typename T>
void add_1(T a, T b, T c)
{
	cout << "函数重载模板" << a + b + c << endl;
}

void add_1(int a, int b)
{
	cout <<"普通模板："<< a + b << endl;
}

int main()
{
	int a = 10, b = 20;
	double c = 10.11, d = 11.22;
	add_1(a, b);         //两个都可以使用，优先调用普通
	add_1<>(a, b);       //通过空模板参数列表，强制调用函数模板
	add_1(a, b, 30);  //模板函数重载
	add_1(c, d);         //如果可以产生更好匹配，优先调用函数模板
	system("pause");
	return 0;
}

总结：如果提供了函数模板，最好就不要提供普通函数，否则容易产生二义性

2.5模板的局限性

• 模板的通用性并不是万能的

如 template <typename T>
    void add_1(T a, T b){}

如果传入的是一个数组，或者是自定义数据类型的成员，就无法正常运行

因此C++为了解决这种问题，提供了模板的重载，可以为这些特定的类型提供具体化的模板

通过用template来进行：

template <typename T>
void comper(T a, T b)
template<> void comper(Person p1, Person p2)

#include<iostream>
using namespace std;

class Person
{
public:
	Person(int a, int b) :a(a), b(b){}
	int a, b;
};

template <typename T>
void comper(T a, T b)
{
	if (a == b)
	{
		cout << "两者相等" << endl;
	}
	else
	{
		cout << "不相等" << endl;
	}
}

template<> void comper(Person p1, Person p2)
{
	if (p1.a == p2.a && p1.b==p2.b)
	{
		cout << "两者相等" << endl;
	}
	else
	{
		cout << "不相等" << endl;
	}
}

int main()
{
	Person p1(10, 20), p2(50, 20);
	comper(p1, p2);
	system("pause");
	return 0;
}

总结：

• 利用具体化的模板，可以解决自定义类型的通用化
• 学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

3，类模板

3.1类模板语法             

作用：建立一个通用类，类中的成员 数据类型可以不具体制定，用一个虚拟的类型来代替

语法：

template <typename  T>    

类

template     声明创建模板

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

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

#include<iostream>
using namespace std;

template<typename T_1,typename T_2>
class Person
{
public:
	Person(T_1 a, T_2 b) :a(a), b(b){}
	void show()
	{
		cout << "a=" << a << "  b=" << b << endl;
	}
	T_1 a;
	T_2 b;
};

int main()
{
	Person<int,int> p(10, 20);

	p.show();
	system("pause");
	return 0;
}

总结：类模板和函数模板用法相似，在生命template后面加类，因此称为类模板

3.2类模板与函数模板的区别

两点区别：

• 类模板没有自动类型推导的使用方式

template<typename T_1, typename T_2>
class Person
{
public:
    Person(T_1 a, T_2 b) :a(a), b(b){}
    T_1 a;
    T_2 b;
};
此时不能用：Person p(10, 20);的方式，初始化对象。因为类模板没有自动推导的使用方式

调用方式 ：  Person<数据类型，数据类型> p(10, 20);

• 类模板在模板参数列表中可以有默认参数

即：template<typename T_1=数据类型， typename T_2 = 数据类型>

此时初始化对象时， 可以写成Person<> p(10, 20);但是“<>”不能省去

3.3类模板中成员函数创建时机

类模板和普通类的成员函数创建时机是不一样的

• 普通类中的成员函数一开始就可以创建
• 类模板中的成员函数在调用时才创建（当一个类中有两个函数，则定义时，类型定义为哪个类则调用哪个类的函数）

#include<iostream>
using namespace std;

class Person_1
{
public:
	void show1()
	{
		cout << "Person_1" << endl;
	}
};

class Person_2
{
public:
	void show2()
	{
		cout << "Person_2" << endl;
	}
};

template<typename T_2>
class Person_3
{
public:
	T_2 P;
	void test1()
	{
		P.show1();
	}
	void test2()
	{
		P.show2();
	}
};

int main()
{
	Person_3<Person_1>  P;

	P.test1();
	//P.test2();         //无法调用，因为此时类型为Person_1;  说明函数调用时才回去创建该成员函数

	system("pause");
	return 0;
}

3.4类模板对象做函数参数

• 类模板实例化出的对象，向函数传参的方式

三种传入方式：

• 指定传入的类型：直接显示对象的数据类型   （该类型使用比较广泛）

void test1(Person<int, int> &P)
{
    P.show();
}

• 参数模板化：将对象中的参数变为模板进行传递

template<typename T_1,typename T_2>
void test2(Person<T_1, T_2> P)
{
    P.show();
}

• 整个类模板化：将这个对象类型模板化进行传递

template<typename T>
void test3(T &P)
{
    P.show();
}

#include<iostream>
using namespace std;

template<typename T_1, typename T_2>
class Person
{
public:
	Person(T_1 a, T_2 b) :a(a), b(b){}
	void show()
	{
		cout << "a=" << a << "  b=" << b << endl;
	}
	T_1 a;
	T_2 b;
};

void test1(Person<int, int> &P)
{
	P.show();
}

template<typename T_1,typename T_2>
void test2(Person<T_1, T_2> P)
{
	P.show();
}

template<typename T>
void test3(T &P)
{
	P.show();
}

int main()
{
	Person<int,int> P(10,20);
	test1(P);
	test2(P);
	test3(P);
	system("pause");
	return 0;
}

3.5类模板与继承

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

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

如：class Person_2 :public Person_1 {};   //错误，因为编译器无法确定继承的类的大小，从而无法分配空间

• 如果想灵活指定出父类中T的类型，子类也需变为类模板

调用方法：

1. class Person_2 :public Person_1<int,int>{}     （指定父类类型）
2. template<class T_1,class T_2>   （灵活的方法调用）
   class Person_3 :public Person_1<T_1, T_2>{};

#include<iostream>
using namespace std;

template<typename T_1, typename T_2>
class Person_1
{
public:
	void show()
	{
		cout << "a=" << a << "  b=" << b << endl;
	}
	T_1 a;
	T_2 b;
};

//class Person_2 :public Person_1 {};   //错误，因为编译器无法确定继承的类的大小，从而无法分配空间

class Person_2 :public Person_1<int,int>{};

template<class T_1,class T_2>
class Person_3 :public Person_1<T_1, T_2>{};

int main()
{
	Person_2 P_2;
	P_2.show();

	Person_3<int,int> P_3;
	P_3.show();
	system("pause");
	return 0;
}

3.6类模板成员函数类外实现

和正常类似，只不过这里需要指明为类模板函数，所以还需要加模板的参数列表

• 构造函数

template<typename T>
Person<T>::Person(T a)
{
    this->a = a;
}

• 成员函数

template<typename T>
void Person<T>::show()
{
    cout << "a=" << a << endl;
}

#include<iostream>
using namespace std;

template<typename T>
class Person
{
public:
	Person(T a);
	void show();
	T a;
};

template<typename T>
Person<T>::Person(T a)
{
	this->a = a;
}

template<typename T>
void Person<T>::show()
{
	cout << "a=" << a << endl;
}

int main()
{
	Person<int> P(10);
	P.show();
	system("pause");
	return 0;
}

3.7类模板分文件编写

按正常分文件编写会出现问题，原因：

• 类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

解决：（下面截图中的代码，就是上面3.6的代码）

• 方式一：直接包含.cpp文件

• 方式二：将声明和实现写道同一个文件中，并更改后缀名为.hpp（类模板）。hpp是约定的名称（流传下来的习惯），并不是强制的

3.8类模板与友元

• 全局函数类内实现：直接在类内声明友元即可
• 全局函数类外实现：需要提前

类外实现步骤：

1. 加空模板参数列表
2. 因为是全局参数，所以需要让编译器提前知道这个函数的存在
3. 因为函数中包含了类，所以还需要在函数前提前声明类

#include<iostream>
using namespace std;

template<class T1, class T2>
class Person;

template<class T1, class T2>
void show1(Person<T1, T2> p)
{
	cout << p.a << "   " << p.b << endl;
}


template<class T1,class T2>
class Person
{
	//类内实现
	friend void show(Person<T1, T2> p)
	{
		cout << p.a << "   " << p.b << endl;
	}

	//类外实现
	friend void show1<>(Person<T1, T2> p);

public:
	Person(T1 a, T2 b) :a(a), b(b){}
	T1 a;
	T2 b;
};

int main()
{
	Person<int,int> P(10,20);
	//show(P);
	show1(P);
	system("pause");
	return 0;
}