目录
泛型编程
如下述代码，有需求要对int和double不同类型的数据进行交换。对同类型的问题重载了对应函数进行处理。
#include <iostream>
using namespace std;
void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}
void Swap(double& left, double& right)
{
double temp = left;
left = right;
right = temp;
}
int main()
{
int a1 = 10, a2 = 20;
double b1 = 13.14, b2 = 5.2;
cout << "交换前:a1 = " << a1 << ", a2 = " << a2 << endl;
cout << "交换前:b1 = " << b1 << ", b2 = " << b2 << endl;
cout << "-------------------------------" << endl;
Swap(a1,a2);
Swap(b1,b2);
cout << "交换后:a1 = " << a1 << ",a2 = " << a2 << endl;
cout << "交换后:b1 = " << b1 << ",b2 = " << b2 << endl;
return 0;
}
上述代码重载的函数仅仅是类型不同，代码的复用率较低。只要有新的类型出现，例如有新的需要要交换char类型的数据，就要增添对应的函数。
泛型编程的思想就是编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。对于上述的场景可以使用模板来解决，根据不同的类型通过模板生成具体类型的代码。
函数模板
函数模板与类型无关，在使用时根据实参类型产生函数的特定类型版本，生成具体类型的代码。
函数模板语法
写法1：
template <class T1,class T2.....>
返回值类型 函数名 （）{}写法2：
template <typename T1,typename T2.....>
返回值类型 函数名（）{}上述用typename或者class来定义模板参数的写法都是可以的。
模板使用
对文章开头的问题用模板实现：
template<class T>
void Swap(T& left,T& right)
{
T temp = left;
left = right;
right = temp;
}
int main()
{
int a1 = 10, a2 = 20;
double b1 = 13.14, b2 = 5.2;
cout << "交换前:a1 = " << a1 << ", a2 = " << a2 << endl;
cout << "交换前:b1 = " << b1 << ", b2 = " << b2 << endl;
cout << "-------------------------------" << endl;
Swap(a1,a2);
Swap(b1,b2);
cout << "交换后:a1 = " << a1 << ",a2 = " << a2 << endl;
cout << "交换后:b1 = " << b1 << ",b2 = " << b2 << endl;
return 0;
}
使用了模板以后，当要处理其他类型的数据时也不用增添新的代码，直接通过模板就可以生成一份处理新类型数据的代码。
函数模板原理
函数模板本身并不是函数，是编译器通过特定的方式产生具体类型函数的“模具”。所以模板就是将本来需要我们完成的任务交给了编译器。
在编译器编译阶段，编译器根据传入的实参类型推演生成对应类型的函数，供用户调用。
通过观察汇编代码可以发现，对于不同类型数据通过函数模板推演后，会生成不同的具体类型的函数代码。
函数模板的实例化
注意不要将函数模板的实例化和对象实例化联想在一起，对象实例化是根据类的大小开辟一块空间，再通过构造函数初始化。而函数模板的实例化是用不同类型的参数推演出具体类型的函数。
隐式实例化
让编译器根据实参推演模板参数的实际类型
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a1 = 10, a2 = 20;
double b1 = 1.1, b2 = 2.2;
cout << Add(a1, a2) << endl;
cout << Add(b1,b2) <<endl;
return 0;
}需要注意的是，在模板中，编译器一般不会进行类型转换操作，如下述示例，在推演阶段就会报错:
template<class T>
T add(const T& left,const T& right)
{
return left + right;
}
int main()
{
int a = 10;
double b = 1.1;
add(10,1.1);
return 0;
}
对于这个错误的解决，一般有两种处理方法，第一种就是在传参阶段用户做强制类型转换：
template<class T>
T add(const T& left,const T& right)
{
return left + right;
}
int main()
{
int a = 10;
double b = 1.1;
add(10,(int)1.1);
add((double)10, 1.1);
return 0;
}第二种解决方法就是显示实例化。
显示实例化
在函数名后的<>指定模板参数的类型。
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a = 10;
double b = 13.14;
Add<int>(a,b);
return 0;
}模板参数的匹配原则
非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。
template<class T>
T Add(T left,T right)
{
cout << "T,模板函数" << endl;
return left + right;
}
int Add(int left, int right)
{
cout << "非模板函数" << endl;
return left + right;
}
int main()
{
Add(1,2);
Add(1.1 , 2.2);
return 0;
}
对于非模板函数和同名函数模板，如果在其他条件都相同。会优先调用非模板函数，因为编译器也很“懒”，已经有的非模板函数则不会在从模板生成一个。
template<class T>
T Add(T left,T right)
{
cout << "T,模板函数" << endl;
return left + right;
}
int Add(int left, int right)
{
cout << "非模板函数" << endl;
return left + right;
}
int main()
{
Add(1,2);
Add(3, 4);
return 0;
}
总结：对于模板而言，如果已经有“现成”得非模板函数，就用现成的。如果需要模板产生一个更匹配的函数，会选择模板。
类模板
类模板的定义语法
template <class T>
class Stack
{
public:
void PushBack(const T& data){}
private:
T* _arr;
};在上述代码中，Stack不是具体的类。是编译器根据被实例化的类型生成具体类的模具。
如果将成员函数定义在类外，也要加上模板参数列表，如：
template <class T>
class Stack
{
public:
void Fun1(const T& x);
private:
T* _arr;
};
template <class T>
void Stack<T>::Fun1(const T& x) {}类模板的实例化
类模板的实例化与函数模板实例化不同，类模板实例化需要在类模板名后跟<>,显示的将要实例化的类型放在<>中，类模板名字不是真正的类，实例化的结果才是真正的类。如上述代码中，Stack不是真正的类，Statck<int>、Stack<char>、Stack<double>......才是真正的类。
非类型模板参数
非类型模板参数，通常是用一个常量作为类（函数）模板的一个参数，在类（函数）模板中，可以将该参数当成常量来使用。
template <class T,size_t N>
class Array
{
private:
T _array[N];
size_t _size;
};需要注意的是，像浮点数、类对象、以及字符串是不允许作为非类型模板参数的。一般都是整数。非类型的模板参数必须在编译期间就能确认结果。
针对上述N的用法，在没介绍模板以前，用typedef好像也可以解决，如：
#define N 10
typedef int T;
class Array
{
private:
T _array[N];
size_t _size;
};上述写法的弊端在于，当我们同时需要Array处理不同的数据，需要N不同大小的时候，就要手动的定义多份重复的代码。而模板会帮我们完成这样的工作，只需要我们给定类型和非类型模板参数就可以了。
类模板的特化
特化，就是对于一些特殊类型特殊处理。因为模板可以实现与类型无关的代码。可能对于部分类型的处理会产生错误的结果，基于这种场景就需要模板的特化。
全特化
class Date
{
public:
Date(int year,int month,int day)
:_year(year)
,_month(month)
,_day(day)
{}
bool operator>(const Date& d1)const
{
if (_year > d1._year)
{
return true;
}
else if (_year == d1._year)
{
if (_month > d1._month)
{
return true;
}
}
else if (_year == d1._year && _month == d1._month)
{
if (_day > d1._day)
{
return true;
}
}
return false;
}
private:
int _year;
int _month;
int _day;
};
template<class T>
struct A
{
bool operator()(const T& x, const T& y)
{
return x > y;
}
};
int main()
{
A<int> a;
cout << a(3, 2) << endl;
Date d1(2001, 10, 3);
Date d2(2023, 3, 2);
A<Date> dd1;
cout << dd1(d1, d2) << endl;
A<Date*> dd2;
cout << dd2(&d1, &d2) << endl;
return 0;
}
针对Date*类型进行特化：
template<>
struct A<Date*>
{
bool operator()(const Date* x, const Date* y)
{
return *x > *y;
}
};
半特化（部分特化）
将模板参数类表中的一部分参数特化：
template <class T1,class T2>
class Data
{
public:
Data() { cout << "<T1,T2>" << endl; }
private:
T1 _d1;
T2 _d2;
};
template <class T1>
class Data<T1, int>
{
public:
Data() { cout << "Date<T1,int>" << endl; }
private:
T1 _d1;
int _d2;
};
int main()
{
Data<double, int> d1;
Data<char, int> d2;
Data<double, char> d3;
return 0;
}
通过测试结果我们可以发现，编译器也是很“懒”的，只要第二个参数匹配了int就走半特化的模板。
两个参数偏特化
template <class T1, class T2>
class Data
{
public:
Data() { cout << "<T1,T2>" << endl; }
private:
T1 _d1;
T2 _d2;
};
template <class T1,class T2>
class Data<T1*, T2*>
{
public:
Data() { cout << "<T1*,T2*>" << endl; }
private:
T1 _d1;
T2 _d2;
};
int main()
{
Data<double, char> d1;
Data<int*,int*> d2;
return 0;
}
模板的分离编译
一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。
程序翻译图解
模板分离编译问题分析
代码：
main.cpp
#include "Add.h"
int main()
{
Add(1,2);
Add(1.1, 2.2);
return 0;
}Add.h
#pragma once
template<class T>
T Add(const T& left, const T& right);Add.cpp
#define _CRT_SECURE_NO_WARNINGS 1
#include "Add.h"
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}链接报错：
分析：
在预处理阶段，会将Add.h在main.c中展开，main.c中有了Add函数的声明。汇编后链接前，main.o和Add.o都形成了各自的符号表。在最后链接过程中，main.o要根据Add函数名去Add.o中找到Add函数的地址。但是，问题出现了，在Add.cpp中，编译器没有看到对Add模板函数的实例化，因此没有生成具体的Add函数。所以上述代码会在链接时报错。
解决方法：
●将声明和定义放在一个文件下。
main.cpp
#include "Add.hpp"
int main()
{
Add(1,2);
Add(1.1, 2.2);
return 0;
}Add.hpp
#pragma once
template<class T>
T Add(const T& left, const T& right);
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}模板总结
模板优点：
●模板复用了代码，节省了资源，更快的迭代开发，在模板的基础上，C++的标准模板库STL因此而生。
●增强了代码的灵活性
模板缺点：
●可能带来代码膨胀的问题，编译时间变长。
●出现模板编译错误的时候，错误信息非常凌乱，不易定位错误。
1327
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
