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; }