目录标题
1.模板的概念
模板就是建立通用的摸具，大大提高复用性。其特点：
1）模板不可以直接使用，它只是一个框架。
2）模板的通用并不是万能的
2.函数模板
C++另一种编程思想称为泛型编程，主要利用的技术就是模板。
C++提供两种给模板机制：函数模板和类模板
2.1 函数模板语法
函数模板作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。
语法：template
template：声明创建模板；typename：声明其后面的符号是一种数据类型，可以用class替代；T：通用的数据类型，名称可以替换，通常为大写字母。
#include<iostream>
#include<fstream>
#include<string>
using namespace std;
template<typename T>
void Swap(T& a, T& b) {
T c = a;
a = b;
b = c;
}
int main() {
//1.自动类型推导
int a = 10;
int b = 20;
Swap(a, b);
cout << a << " " << b << endl;
//2.显示指定类型
Swap<int>(a, b);
cout << a << " " << b << endl;
return 0;
}
2.2 函数模板的注意事项
注意事项：
1）自动类型推导，必须推导出一致的数据类型T，才可以使用
#include<iostream>
#include<fstream>
#include<string>
using namespace std;
template<class T>
void Swap(T& a, T& b) {
T c = a;
a = b;
b = c;
}
int main() {
int a = 10;
int b = 20;
char c = 'd';
//Swap(a, c);//错误，必须推导出一致的数据类型T，才可以使用
cout << a << " " << c << endl;
return 0;
}
2）模板必须要确定出T的数据类型，才可以使用。
#include<iostream>
#include<fstream>
#include<string>
using namespace std;
template<class T>
void fun() {
cout << "zhinen" << endl;
}
int main() {
//func();//错误，模板必须要确定出T的数据类型，才可以使用。
fun<int>();
return 0;
}
2.3 普通函数与函数模板的区别
区别：
1）普通函数调用时可以发生自动类型转换（隐式类型转换）
2）函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
3）如果利用显示制定类型的方式，可以发生隐式类型转换
#include<iostream>
#include<fstream>
#include<string>
using namespace std;
int fun(int a, int b) {
return a + b;
}
template<class T>
T fun1(T a, T b) {
return a + b;
}
int main() {
int a = 18, b = 18;
char c = 'c';
cout << fun(a, b) << endl;
cout << fun(a, c) << endl;//字符变量自动转换成ASCII码，可以发生隐式转换。
cout << fun1(a, b) << endl;
//自动类型推导，不会发生隐式类型转换
//cout << fun1(a, c) << endl;//错误，没有与参数列表匹配的参数类型
//显示指定类型，可以发生隐式类型转换
cout << fun1<int>(a, c) << endl;
return 0;
}
2.4 普通函数与函数模板的调用规则
规则如下：
1）如果函数模板和普通函数都可以实现，优先调用普通函数；
2）可以通过空模板参数列表来强制调用函数模板；
3）函数模板可以发生重载
4）如果函数模板可以产生更好的匹配，优先调用函数模板
#include<iostream>
#include<fstream>
#include<string>
using namespace std;
void fun(int a, int b) {
cout << "普通函数" << endl;
}
template<class T>
void fun(T a, T b) {
cout << "函数模板fun(T a, T b)" << endl;
}
template<class T>
void fun(T a, T b, T c) {
cout << "函数模板fun(T a, T b，T c)" << endl;
}
int main() {
int a = 1, b = 1;
fun(a, b);//优先选择普通函数
fun<>(a, b);//空模板参数列表，强制调用函数模板
fun(a, b, 10);
fun('a', 'b');//更好的匹配
return 0;
}
2.5 模板的局限性
局限性：模板的通用性并不是万能的。
#include<iostream>
#include<fstream>
#include<string>
using namespace std;
template<class T>
void fun(T &a, T &b) {
a = b;
}
int main() {
int a[5], b[5];
fun(a, b);//错误
return 0;
}
对于自定以的类型，需要具体化
#include<iostream>
#include<string>
using namespace std;
class person {
public:
person(string name, int age) {
this->name = name;
this->age = age;
}
string name;
int age;
};
template<class T>
bool fun(T &a, T &b) {
if (a == b) {
return true;
}else
return false;
}
template<> bool fun(person &a, person &b) {
if (a.name == b.name && a.age == b.age)
return true;
else
return false;
}
int main() {
person p1("zhinen", 20);
person p2("zhinen", 20);
if (fun(p1, p2)) {
cout << "p1==p2" << endl;
}
else {
cout << "p1!=p2" << endl;
}
return 0;
}
3.类模板
3.1 类模板语法
类模板的作用：建立一个通用类，类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表。
语法：template 类
解释：template—声明创建模板；typename–表明其后面的符号是一种数据类型，可以用class代替；T–通用的数据类型，名称可以替换，通常为大写字母
#include<iostream>
#include<string>
using namespace std;
template<class N,class A>
class person {
public:
person(N name, A age) {
this->name = name;
this->age = age;
}
N name;
A age;
};
int main() {
person<string, int> p("zhinen", 20);
cout << p.name << " " << p.age << endl;
return 0;
}
3.2 类模板与函数模板区别
区别主要有两点：
1）类模板没有自动类型推导的使用方式
2）类模板在模板参数列表中可以有默认参数
#include<iostream>
#include<string>
using namespace std;
template<class N, class A = int>
class person {
public:
person(N name, A age) {
this->name = name;
this->age = age;
}
N name;
A age;
};
int main() {
//person p("zhinen", 20);//错误，无法自动类型推导
person<string, int> p("zhinen", 20);//显示指定类型
cout << p.name << " " << p.age << endl;
person<string> p1("zhinen", 20);//默认参数int
cout << p1.name << " " << p1.age << endl;
return 0;
}
3.3 类模板中成员函数创建时机
类模板中成员函数和普通类中成员函数创建时机是有区别的：
1）普通类中的成员一开始就可以创建
2）类模板中的成员函数在调用时才创建
3.4 类模板对象做函数参数
目标：类模板实例化的对象，向函数传参的方式。
三种传入方式
1）指定传入的类型—直接显示对象的数据类型
2）参数模板化----将对象中的参数变为模板进行传递
3）整个类模板化----将这个对象类型模板化进行传递
#include<iostream>
#include<string>
using namespace std;
template<class N, class A = int>
class person {
public:
person(N name, A age) {
this->name = name;
this->age = age;
}
N name;
A age;
};
//1.指定传入类型
void fun(person<string, int>& p) {
cout << p.name << " " << p.age << endl;
}
//2.参数模板化
template<class N,class A>
void fun2(person<N, A>& p) {
cout << p.name << " " << p.age << endl;
cout << "N：" << typeid(N).name() << endl;
cout << "A：" << typeid(A).name() << endl;
}
//3.整个类模板化
template<class T>
void fun3(T& p) {
cout << p.name << " " << p.age << endl;
cout << "T：" << typeid(T).name() << endl;
}
int main() {
person<string, int> p("zhinen", 20);
fun(p);
fun2(p);
fun3(p);
return 0;
}
3.5 类模板与继承
注意的点：
1）当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型。
2）如果不指定，编程器无法给子类分配内存。
#include<iostream>
#include<string>
using namespace std;
template<class N, class A = int>
class person {
public:
person(N name, A age) {
this->name = name;
this->age = age;
}
N name;
A age;
};
//class person1 :public person {};//错误，必须要知道父类中的N和A类型，才能继承给子类
class person1 :public person<string, int> {
};
int main() {
return 0;
}
3）如果想灵活指定出父类中T的类型，子类也需要变为类模板。
#include<iostream>
#include<string>
using namespace std;
template<class N, class A = int>
class person {
public:
person(N name, A age) {
this->name = name;
this->age = age;
}
N name;
A age;
};
template<class T,class N,class A>
class person1 :public person<N,A> {
T a;
};
int main() {
return 0;
}
3.6 类模板成员函数类外实现
#include<iostream>
#include<string>
using namespace std;
template<class N, class A = int>
class person {
public:
person(N name, A age);
/*{
this->name = name;
this->age = age;
}*/
void printNA();
N name;
A age;
};
//构造函数的类外实现
template<class N,class A>
person<N,A>::person(N name, A age) {
this->name = name;
this->age = age;
}
//成员函数的类外实现
template<class N, class A>
void person<N, A>::printNA() {
cout << this->name << " " << this->age << endl;
}
int main() {
person<string, int> p("zhinen", 20);
p.printNA();
return 0;
}
3.7 类模板分文件编写
问题：类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到
解决：
1）直接包含.cpp源文件
//person.h文件
#pragma once
#include<iostream>
#include<string>
using namespace std;
template<class N, class A = int>
class person {
public:
person(N name, A age);
/*{
this->name = name;
this->age = age;
}*/
void printNA();
N name;
A age;
};
//person.cpp文件
#include"person.h"
//构造函数的类外实现
template<class N, class A>
person<N, A>::person(N name, A age) {
this->name = name;
this->age = age;
}
//成员函数的类外实现
template<class N, class A>
void person<N, A>::printNA() {
cout << this->name << " " << this->age << endl;
}
//main文件
#include<iostream>
#include"person.cpp"//直接包含.cpp源文件
using namespace std;
int main() {
person<string, int> p("zhinen", 20);
p.printNA();
return 0;
}
2）将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制。（主流做法）
//person.hpp文件
#pragma once
#include<iostream>
#include<string>
using namespace std;
template<class N, class A = int>
class person {
public:
person(N name, A age);
/*{
this->name = name;
this->age = age;
}*/
void printNA();
N name;
A age;
};
//构造函数的类外实现
template<class N, class A>
person<N, A>::person(N name, A age) {
this->name = name;
this->age = age;
}
//成员函数的类外实现
template<class N, class A>
void person<N, A>::printNA() {
cout << this->name << " " << this->age << endl;
}
//main文件
#include<iostream>
#include"person.hpp"
using namespace std;
int main() {
person<string, int> p("zhinen", 20);
p.printNA();
return 0;
}
3.8 类模板与友元
全局函数类内实现：直接在类内声明友元即可
#include<iostream>
#include<string>
using namespace std;
template<class N, class A = int>
class person {
//类内实现
friend void showNA(person<N,A> p) {
cout << p.name << " " << p.age << endl;
}
public:
person(N name, A age);
/*{
this->name = name;
this->age = age;
}*/
private:
N name;
A age;
};
//构造函数的类外实现
template<class N,class A>
person<N,A>::person(N name, A age) {
this->name = name;
this->age = age;
}
int main() {
person<string, int> p("zhinen", 20);
showNA(p);
return 0;
}
全局函数类外实现：需要提前让编译器知道全局函数的存在
#include<iostream>
#include<string>
using namespace std;
//提前知道person类
template<class N, class A>
class person;
template<class N, class A>
void showNA(person<N, A> p) {
cout << p.name << " " << p.age << endl;
}
template<class N, class A = int>
class person {
//类外实现，需要加空的参数列表
friend void showNA<>(person<N, A> p);
public:
person(N name, A age);
/*{
this->name = name;
this->age = age;
}*/
private:
N name;
A age;
};
//构造函数的类外实现
template<class N,class A>
person<N,A>::person(N name, A age) {
this->name = name;
this->age = age;
}
int main() {
person<string, int> p("zhinen", 20);
showNA(p);
return 0;
}
