C++另外一种编程思维为泛型编程，其主要技术就是模板。
C++提供了两种模板机制： 函数模板 和 类模板
函数模板语法
函数模板作用：建立一个通用函数，其函数返回值类型和形参类型可以不确定，用一个虚拟的类型来代表。
语法：
template<typename T> //T就是下面用来代表的，T可以为任意数据类型
函数声明或者定义
//使用案例 template<typename T>//用T来代表类型 void math(T a, T b) { //执行的程序 }template 声明创建模板
typename 表示其后面的符号是一种数据类型，可以用class代替
//例程：输入两个数，分别求出最大值、最小值、加、减、乘、除结果，用模板实现
#include <iostream>
using namespace std;
template<typename T>
void math(T a, T b)
{
cout << "最大值 = " << (a > b ? a : b) << endl;
cout << "最小值 = " << (a > b ? b : a) << endl;
cout << "加 = " << a+b << endl;
cout << "减 = " << a-b << endl;
cout << "乘 = " << a*b << endl;
cout << "除 = " << a/b << endl;
};
int main()
{
int a=0, b=0;
double c=0, d=0;
cin >> a >> b >> c >> d;
cout << "int结果:" << endl;
math(a,b);
cout << "double结果:" << endl;
math(c, d);
return 0;
}在使用函数模板时有两种方式：
1、自动类型推导 2、显示指定类型
如 math(a,b)就是自动类型推导 math<int>(a,b)就是显示指定类型
（模板使用）注意事项：
1、自动类型推导，必须推导出一致的数据类型T，才可以使用。
（传入模板的参数，必须一致，也就是同种数据类型）
2、模板必须要确定出T的数据类型，才能使用。
（如果遇见不需要传入参数，则使用显示指定类型，将数据类型确定，就可以了）
普通函数与函数模板的区别
- 普通函数调用时可以发生自动类型转换（隐式类型转换）
（int a=10; char b='c'; math(a,b)可以实现，b会自动转成int在相加）
- 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换。
（同样的上面一样，使用math(a,b)会报错）
- 如果利用显示指定类型的方式，可以发生隐式类型转换。
（如果使用math<int>(a,b)则可以实现相加，只不过把char型转换为前面指定的int）
总结：建议使用显示指定类型方式，调用模板，这样自己可以确定通用类型T
普通函数与函数模板的调用规则
- 如果函数模板和普通函数都可以实现，有限调用普通函数。(系统优先调取普通函数)
- 可以通过空模板参数列表来强调函数模板。（如果函数没有功能，函数模板可以这样写 math<>(a,b) ）
- 函数模板可以发生重载
- 如果函数模板可以产生更好的匹配，优先调用函数模板。(数据类型与普通函数不匹配，则先使用函数模板)
总结：有了函数模板，就不要用普通函数。
模板的局限性
模板的通用性并不是万能的，如果传入的数据是数组或者对象，则不知道里面选取那个参数，如果出现特殊数据类型，需要用具体化方式做特殊实现。
就是在重写（把函数重写）一个需要的具体化方式的模板
类模板
类模板作用：建立一个通用类，类中的成员 数据类型可以不具体确定，用虚拟的类型来代表
类模板的语法：
template<typename T>
类
例程：
#include <iostream> #include <string> using namespace std; template<class Myname, class Myage> class Person { public: Person(Myname Name, Myage Age) { this->m_Name = Name; this->m_Age = Age; } void show() { cout << "name:" << this->m_Name << " age:" << this->m_Age << endl; } Myname m_Name; Myage m_Age; }; int main() { Person<string, int>p1("孙悟空", 20); p1.show(); return 0; }
类模板和函数模板的区别
- 类模板没有自动类型推导的使用方式
- 类模板在模板参数列表中可以有默认参数
默认参数相当于实在使模板时就确定类型
如template<class Myname, class Myage = int > 然后在下面使用时，可以不填前面的参数。Person<string>p1("孙悟空", 20);
类模板中成员函数创建时机
类模板中成员函数和普通类成员函数创建时机：
- 普通类中的成员函数一开始就可以创建
- 类模板中的成员函数在调用时才创建
类模板对象做函数参数
类模板实例化出的对象，向函数传参方式。一个有三种传入方式
- 指定传入的类型 直接显示对象的数据类型（使用最广泛）
- 参数模块化 将对象的参数变为模板进行传递
- 整个类模板化 将这个对象类型 模块化进行传递
#include <iostream> #include <string> using namespace std; template<class Myname, class Myage> class Person { public: Person(Myname Name, Myage Age) { this->m_Name = Name; this->m_Age = Age; } void show() { cout << "name:" << this->m_Name << " age:" << this->m_Age << endl; } Myname m_Name; Myage m_Age; }; //指定传入参数 void printPerson1(Person<string,int> &p) { p.show(); } //参数模块化 templat<class T1, class T2> void printPerson2(Person<T1,T2> &p) { p.show(); } //整个类模块化 templat<class T> void printPerson3(T &p) { p.show(); } int main() { Person<string,int>p("孙悟空"，20)； printPerson1(p); printPerson2(p); printPerson3(p); return 0; };如果想要获取虚拟的类型是什么，就需要用到typeid关键字
cout << "T1类型" << typeid(T1).name() << endl; cout << "T2类型" << typeid(T2).name() << endl;
类模板与继承
当类模板碰到继承时，需要注意以下几点：
- 当子类继承的父类时是一个类模板时，子类在声明的时候，要指定出父类中T的类型。
- 如果不指定，编译器无法给子类分配内存（将报错）。
- 如果想灵活指定出父类中T的类型，子类也需变成类模板。
template<class T> class Base { T m; }; //普通用法 class Son1 : public Base<int> { }; //如果想要灵活指定父类中T类型，子类也变成类模板 template<class T1, class T2> class Son2 :public Base<T2> { T1 m_1; }; int main() { Son1 s1; Son2<int,char>s2; return 0; }
类模板成员函数类外实现
#include <iostream> #include <string> using namespace std; template<class T1, class T2> class Person { public: Person(T1 Name,T2 Age); void show(); T1 m_Name; T2m_Age; }; //类外实现函数,需要加上模板参数列表。例如template<class T1,class T2> template<class T1,class T2> Person<T1,T2>::Person(T1 Name, T2 Age) { this->m_Name = Name; this->m_Age = Age; } template<class T1,class T2> void Person<T1,T2>::showPerson(); { cout << "name:" << this->m_Name << " age:" << this->m_Age << endl; } int main() { Person<string,int>p("Tom",22); p.showPerson(0; return 0; };
类模板分文件编写
问题：类模板中成员函数创建时机实在调用的时候，导致文件编写时链接不到。
解决：
解决方式1：直接包含 .cpp源文件
解决方式2：将声明和实现写到同一个文件中，并更改后缀名为 .hpp，.hpp是约定的名称，并不是强制。（既将 .h 和 .cpp中的内容写到一起，将后缀名改为 .hpp文件）
person.hpp内容
#pragma once #include <iostream> #include <string> using namespace std; template<class T1, class T2> class Person { public: Person(T1 Name,T2 Age); void show(); T1 m_Name; T2m_Age; }; template<class T1,class T2> Person<T1,T2>::Person(T1 Name, T2 Age) { this->m_Name = Name; this->m_Age = Age; } template<class T1,class T2> void Person<T1,T2>::showPerson(); { cout << "name:" << this->m_Name << " age:" << this->m_Age << endl; }person.cpp内容
#include <iostream> using namespace std; #include "person.hpp" int main() { Person<string,int>p("Tom",22); p.showPerson(0; return 0; };总结：主流的还是第二种方式，将模板成员函数写道一起，并将后缀名改成.hpp
类模板与友元
就是类模板配合友元函数的类内和类外实现
全局函数类内实现 直接在类内声明友元既可
template<class T1, class T2> class Person { friend void printPerson(Person<T1,T2>p) { cout << p.m_Name << p.m_Age << endl; } public: Person(T1 Name,T2 Age) { this->m_Name = Name; this->m_Age = Age; } private: T1 m_Name; T2 m_Age; }; int main(0 { Person<string,int>p("Tom",20); printPerson(p); return 0; }全局函数类外实现 需要提前让编译器知道全局函数的存在
template<class T1, class T2>//让编译器提前知道 class Person； //全局函数实现类外 template<class T1, class T2> void printPerson2(Person<T1,T2>p) { cout << p.m_Name << p.m_Age << endl; } template<class T1, class T2> class Person { friend void printPerson2(Person<T1,T2>p); public: Person(T1 Name,T2 Age) { this->m_Name = Name; this->m_Age = Age; } private: T1 m_Name; T2 m_Age; }; int main(0 { Person<string,int>p("Tom",20); printPerson(p); return 0; }
277
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
