模板是泛型编程思想的一个具体实例，在STL容器中被广泛运用。它可以控制容器的数据类型
也可以控制某种设计逻辑，使同一个逻辑适应不同情景，是C++中一个非常强大的功能。
它可以对具有相同特性的函数或类进行再抽象，是一种参数化的多态性工具。所谓参数化多态性，是指将程序所处理的对象的类型参数化，使一段程序代码可以用于处理多种不同类型的对象。
模板的语法是什么？模板的应用场景有哪些？模板有什么特性？......等一系列问题将在下文中一一解答。
目录
引、泛型编程
泛型编程是程序设计语言的一种风格或范式，允许程序员在编写代码时使用一些以后才指定的类型，在实例化时作为参数指明这些类型。
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;
}
void Swap(char& left, char& right)
{
char temp = left;
left = right;
right = temp;
}以上代码中，三个交换函数的返回类型相同，函数名相同，实现交换功能的代码逻辑类似，唯独参数类型不同，那么，是否可以基于它们的共性，实现一个通用的交换函数呢？
三个交换函数的函数名相同、参数类型不同，满足了函数重载。在实际交换时，编译器会根据交换参数的类型去匹配相应的交换函数，这似乎已经实现了“一个”通用的交换函数，但实际还有一些问题。首先，重载的函数仅仅是类型不同，一旦有新类型出现时，就需要用户自己增加对应的函数，代码复用率比较低；其次，一个函数出错可能导致所有的重载函数都会出错，代码的可维护性比较低。
有没有一个办法，给予编译器一个摸具，让编译器根据不同的类型利用这个摸具来生成代码？就像工厂里为了批量生产同一个外形的物件，事先就做好了一个摸具，可以将不同的材料，如钢水、塑料液等，倒进摸具，从而获得了质地不同但外形相同的物件。
于是，C++提出了模板（template)来作为泛型编程的基础，使程序员能够编写与类型无关的通用代码，实现代码复用，适配不同情景下的功能需求。
模板由模板的声明和定义两部分组成，通常情况下定义紧跟随声明，但也可以分离。模板的定义，涉及到一个新的关键字“ template ”，其后紧跟模板的参数（一般用“ T ”表示）。它既可以定义一个函数的模板，也可以定义一个类的模板。
模板声明的语法格式基本为：
模板声明：template<class T>
声明其后跟上定义的相应函数或相应类即可。
注意，这里的“ class ”是用来定义模板参数关键字，也可以使用typename。且一般来说，声明和定义是捆绑的，不论函数模板的定义还是类模板的定义都要有一个与之相应的声明，每当新定义一个模板，都要重新声明一次。
一、模板的分类
模板基本分为两类，一类是函数模板，一类是类模板。
● 函数模板
函数模板与具体类型无关，在使用时被实例化，根据实参类型产生函数的特定类型版本，代表了一个函数家族。它的语法格式为：
template<class T1,class T2,...,class Tn>
返回值类型 函数名(T1 参数名1,...Tn 参数名n)
{ 函数体 }
例如上文中的交换函数，通过模板来书写：
//可以通过模板来让多种参数类型都可以调用这个Swap交换函数
template<typename T> //模板参数 - 类型
void Swap(T& x1, T& x2)
{
T tmp = x1;
x1 = x2;
x2 = tmp;
}
int main()
{
int a = 0, b = 1;
double c = 1.1, d = 2.2;
int* p1 = &a, * p2 = &b;
Swap(a, b);
Swap(c, d);
swap(p1, p2);
}
（Swap模板的汇编）
从汇编代码中可以看到，前后调用函数的地址并不相同，所以，不同的参数类型调用的其实不是同一个函数，这涉及模板的实例化。参数实际去调用的是模板，然后由模板去生成相应参数类型的函数。
函数模板其实也是一个蓝图，本身并不是函数，是编译器产生特定具体类型函数的模具。所以，声明和定义一个模板就相当于将原本该由程序员来做的，重复的事情交给了编译器去做。
在编译阶段，编译器需要根据传入的实参类型，去推断和生成相应类型的函数以供调用。例如，当用double类型使用函数模板时，编译器通过对该实参类型的推演，将T确定为double类型，然后，产生一份专门处理double类型的代码。对于图中的int类型、char类型的处理也是如此。而这个过程，就是函数模板的实例化。
函数模板的实例化是指，通过不同类型的参数使用函数模板。跟据编译器针对模板参数的处理方式，它可以分为隐式实例化和显式实例化。
- 隐式实例化：让编译器根据实参自行推断模板参数的实际类型
- 显式实例化：在函数名后的<>中指定模板参数的实际类型
//隐式实例化：编译器自行推断类型
//显示实例化：手动将类型提示给编译器
template<class T>
T Add(const T& left, const T& right) //此处不加const代码无法编译通过。因为若出现类型转换，会生成临时变量（具有常性，不能传给普通引用），涉及权限的放大
{
return left + right;
}
template<class T>
T* Alloc(int n) //返回类型无法推导，只能由参数类型来推得
{
return new T[n];
}
int main()
{
int a1 = 10, a2 = 20;
double d1 = 10.1, d2 = 20.2;
// 实参传递的类型，推导T的类型
cout << Add(a1, a2) << endl;
cout << Add(d1, d2) << endl;
// 当模板的参数均为T类型，T类型无法同时转化为不同的两个类型（发生歧义），故参数类型不同时，需使其类型相同
//法1 强制类型转换为相同类型
cout << Add(a1, (int)d1) << endl;
cout << Add((double)a1, d1) << endl;
//法2 通过显示实例化的方式，指定类型去实例化
cout << Add<int>(a1, d1) << endl;
cout << Add<double>(a1, d1) << endl;
// 部分函数没有T类型的参数，故无法自动推导类型，只能通过显示实例化
double* p1 = Alloc<double>(10);
return 0;
}而关于函数模板、非模板的函数、模板参数，又有如下的匹配规则：
- 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数；
- 对于非模板函数和同名函数模板，当其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例，但如果模板可以产生一个更优选的函数， 那么将选择模板；
- 函数模板不允许自动类型转换，但普通函数可以进行自动类型转换。
// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
}
// 通用的加法函数模板
template<class T>
T Add(T left, T right)
{
return left + right;
}
void Test()
{
Add(1, 2); // 会与非模板函数匹配，编译器不需要特化
Add<int>(1, 2); // 会调用编译器特化的Add版本（特化的说明见下文）
}
// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
}
// 通用的加法函数模板
template<class T>
T Add(T left, T right)
{
return left + right;
}
void Test()
{
Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
Add(1, 2.0); // 函数模板可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
}
● 类模板
类同样有模板，它的泛型具体体现在相应的成员变量或成员函数上。它的语法格式为：
template<class T1, class T2, ..., class Tn>
class 类模板名
{
//类体
};
// 场景引入：
// 需求：一个栈存int，一个栈存double
typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 3)
{
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}
_capacity = capacity;
_size = 0;
}
void Push(DataType data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
// 其他方法...
~Stack()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
DataType* _array;
int _capacity;
int _size;
};
int main()
{
//无法做到s1存int，而s2存double
Stack s1;
Stack s2;
return 0;
}//改进：
typedef int DataType;
class StackInt
{
public:
StackInt(size_t capacity = 3)
{
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}
_capacity = capacity;
_size = 0;
}
void Push(DataType data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
// 其他方法...
~StackInt()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
DataType* _array;
int _capacity;
int _size;
};
typedef double DataType;
class StackDouble
{
public:
StackDouble(size_t capacity = 3)
{
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}
_capacity = capacity;
_size = 0;
}
void Push(DataType data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
// 其他方法...
~StackDouble()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
DataType* _array;
int _capacity;
int _size;
};
int main()
{
StackInt s1; // 存int
StackDouble s2; // 存double
return 0;
}//引入类模板：
template<class T>
class Stack
{
public:
Stack(size_t capacity = 3)
{
_array = new T[capacity];
_capacity = capacity;
_size = 0;
}
void Push(const T& data)
{
_array[_size] = data;
_size++;
}
~Stack()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
T* _array;
int _capacity;
int _size;
};
int main()
{
//类模板都是显示实例化。
//类模板实例化与函数模板实例化不同，
//类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，
//类模板名字不是真正的类，而实例化的结果才是真正的类。
Stack<int>s1; //存int
Stack<double>s2; //存double
Stack<char>s3; //存char
return 0;
}类的成员函数也可以通过类模板实现声明和定义的分离。对于普通类而言，类名和类型是一致的；而对于类模板而言，类名和类型并不一致。
template<class T>
class Stack
{
public:
Stack(size_t capacity = 3); //构造函数，在类模板中声明，在类模板外定义
void Push(const T& data); //尾插，同样在类模板中声明，在类模板外定义
~Stack()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
T* _array;
int _capacity;
int _size;
};
// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template<class T> //模板参数类型是专门为相应函数定制的，作用范围就在相应函数内，故需和相应函数绑定来写
Stack<T>::Stack(size_t capacity) //类名是Stack，类型是Stack<T>
{
_array = new T[capacity];
_capacity = capacity;
_size = 0;
}
template<class T>
void Stack<T>::Push(const T& data) //类名是Stack，类型是void Stack<T>
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
二、非类型的模板参数
模板参数分为类型形参与非类型形参。
- 类型形参：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
- 非类型形参：就是用一个常量作为函数/类模板的一个参数，在函数/类模板中可将该参数当成常量来使用。
【Tips】非类型的模板参数的特性
- 非类型模板参数必须是整型的常量，浮点数、类对象以及字符串是不允许作为非类型模板参数的；
- 非类型的模板参数必须在编译阶段就能确认结果。
// 定义一个模板类型的静态数组
namespace byte
{
template<class T, size_t N = 10> //N是一个非类型的模板参数
class array
{
public:
T& operator[](size_t index){return _array[index];}
const T& operator[](size_t index)const{return _array[index];}
size_t size()const{return _size;}
bool empty()const{return 0 == _size;}
private:
T _array[N]; //N在编译阶段就能确认结果
size_t _size;
}；
}
//实现一个静态栈
template<class T,size_t N>
class Stack
{
public:
void func()
{
//常量 不能修改
N = 0;
}
private:
T _a[N];
int _top;
};
int main()
{
Stack<int,10> st1;
Stack<int,10> st2;
//st1.func(); //按需实例化(也就是说，只有当调用时才会实例化)
return 0;
}
三、模板的特化
模板的特化是指，针对某些类型进行特殊化的处理。通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，例如实现一个专门用来进行小于比较的函数模板，此时就需要对其特殊处理。
// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right)
{
return left < right;
}
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
cout << Less(1, 2) << endl; // 可以比较，结果正确
Date d1(2022, 7, 7);
Date d2(2022, 7, 8);
cout << Less(d1, d2) << endl; // 可以比较，结果正确
Date* p1 = &d1;
Date* p2 = &d2;
cout << Less(p1, p2) << endl; // 可以比较，但结果错误
return 0;
}以上代码中，Less函数模板在多数情况下都可以正常进行比较，但是在特殊场景下就得到了错误的结果。在得到错误结果的特殊场景中，p1指向的d1显然小于p2指向的d2对象，但是Less内部并没有比较p1和p2指向的对象内容，而比较的是p1和p2指针的地址，就无法实现预期且引发了错误。 此时，对模板进行特化，在原模板类的基础上针对特殊类型所进行特殊处理，就可以解决这个问题。
template<class T>
bool Less(T left, T right)
{
return left < right;
}
// 对Less函数模板进行特化
template<>
bool Less<Date*>(Date* left, Date* right)
{
return *left < *right;
}
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date* p1 = &d1;
Date* p2 = &d2;
cout << Less(p1, p2) << endl; // 调用特化之后的版本，而不走模板生成了
return 0;
}
● 函数模板的特化
- 必须要先有一个基础的函数模板；
- 关键字 template 后面接一对空的尖括号<> ；
- 函数名后也要跟一对尖括号<>，尖括号<>中指定需要特化的类型；
- 函数形参表必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。
//函数模板的特化
template<class T>
bool Less(T left, T right)
{
return left < right;
}
template<>
bool Less<int*>(int* left, int* right)
{
return *left < *right;
}
//一般情况下如果函数模板遇到不能处理或者处理有误的类型，
//为了实现简单通常都是将该函数直接给出。
//template<class T>
//bool Less(T* left, T* right) //或以此构成函数重载，效果也是一致的
//{
// return *left < *right;
//}
int main()
{
cout << Less(1, 2) << endl;
int a = 2, b = 1;
cout << Less(&a, &b) << endl;
double c = 1.1, d = 2.2;
cout << Less(&c, &d) << endl;
return 0;
}因为特化时参数的类型都需要特别给出，所以，对于一些参数类型复杂的函数模板，不太推荐特化，而更推荐将特殊情景下的函数直接给出。
//[补]
//void Print(const vector<int>& v)
//{
// vector<int>::const_iterator it = v.begin();
// while (it != v.end())
// {
// cout << *it << " ";
// ++it;
// }
// cout << endl;
//}
template<class Container>
void Print(const Container& v)
{
// 编译不确定Container::const_iterator是类型还是对象
// typename就是明确告诉编译器这里是类型，等模板实例化再去找
typename Container::const_iterator it = v.begin();
// 也可以简化为：auto it = v.begin();
while (it != v.end())
{
cout << *it << " ";
++it;
}
cout << endl;
}
● 类模板的特化
类模板的特化分为全特化和偏特化两种情况。
全特化指的是，将模板参数列表中所有的参数都确定化。
template<class T1, class T2>
class Data
{
public:
Data() {cout<<"Data<T1, T2>" <<endl;}
private:
T1 _d1;
T2 _d2;
};
template<>
class Data<int, char>
{
public:
Data() {cout<<"Data<int, char>" <<endl;}
private:
int _d1;
char _d2;
};偏特化指的是，任何针对模版参数进一步进行条件限制设计的特化版本。
template<class T1, class T2>
class Data
{
public:
Data() {cout<<"Data<T1, T2>" <<endl;}
private:
T1 _d1;
T2 _d2;
};
偏特化又有两种表现方式，一种是部分特化，即将模板参数类表中的一部分参数特化。
// 将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
public:
Data() {cout<<"Data<T1, int>" <<endl;}
private:
T1 _d1;
int _d2;
}; 另一种是对参数做更进一步的限制。
//两个参数偏特化为指针类型
template <typename T1, typename T2>
class Data <T1*, T2*>
{
public:
Data() {cout<<"Data<T1*, T2*>" <<endl;}
private:
T1 _d1;
T2 _d2;
};
//两个参数偏特化为引用类型
template <typename T1, typename T2>
class Data <T1&，T2&>
{
public:
Data(const T1& d1, const T2& d2)
:_d1(d1)
,_d2(d2)
{
cout<<"Data<T1&，T2&>"<<endl;
}
private:
const T1 &_d1;
const T2 & d2;
};
//类模板的特化
//正常情况下对类是直接调用的
template<class T1, class T2>
class Data
{
public:
Data() { cout << "Data<T1, T2>" << endl; }
private:
T1 _d1;
T2 _d2;
};
// 假设接下来要针对int double进行特殊处理
// 全特化
template<>
class Data<int, double>
{
public:
Data() { cout << "Data<int,double>" << endl; }
private:
};
// 偏特化 ： 特化部分参数
template<class T1>
class Data<T1, double>
{
public:
Data() { cout << "Data<T1, double>" << endl; }
private:
};
// 偏特化 ： 可能是对某些类型的进一步限制
template<class T1, class T2>
class Data<T1*, T2*>//指针
{
public:
Data() { cout << "Data<T1*, T2*>" << endl; }
private:
};
template<class T1, class T2>
class Data<T1&, T2&>//引用
{
public:
Data() { cout << "Data<T1&, T2&>" << endl; }
private:
};
int main()
{
Data<int, int> d1;
Data<int, double> d2;
Data<int*, double> d3;
Data<double, double> d4;
Data<double*, double*> d5;
Data<void*, int*> d6;
Data<int&, double&> d7;
return 0;
}
//特化的类相当于是一个全新的类
//在调用时是按需调用相应的特化类的
四、关于模板的分离编译
一个程序（一个项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来，形成单一的可执行文件，这个过程被称为分离编译模式。
例如，以下场景，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义：
// a.h
#include<iostream>
using namespace std;
template<class T>
T Add(const T& left, const T& right);
// a.cpp
#include"a.h"
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
// main.cpp
#include"a.h"
int main()
{
Add(1, 2);
Add(1.0, 2.0);
return 0;
}
又例如，以下场景：
//Stack.h
#pragma once
#include<iostream>
using namespace std;
#include<deque>
namespace bit
{
template<class T, class Container = std::deque<T>>
class stack
{
public:
void push(const T& x);
void pop();
T& top()
{
return _con.back();
}
size_t size()
{
return _con.size();
}
bool empty()
{
return _con.empty();
}
private:
Container _con;
};
class A
{
public:
void func1(int i);
void func2();
};
template<class T, class Container>
void stack<T, Container>::push(const T& x)
{
_con.push_back(x);
}
template<class T, class Container>
void stack<T, Container>::pop()
{
_con.pop_back();
}
}//Stack.cpp
#include"Stack.h"
namespace bit
{
/*template<class T, class Container>
void stack<T, Container>::push(const T& x)
{
_con.push_back(x);
}
template<class T, class Container>
void stack<T, Container>::pop()
{
_con.pop_back();
}*/
void A::func1(int i)
{}
//void func2();
template
class stack<int>;
template
class stack<double>;
}//Test.cpp
#include"Stack.h"
int main()
{
bit::stack<int> st; // call xxstackxx(0x324242)
st.push(1); // call xxpushi(?)
st.pop();
st.size(); // call xxsizexx(0xdadada)
st.top();
bit::A aa;
aa.func1(1); // call xxfunc1xx(?)
//aa.func2(); // call xxfunc2xx(?)
bit::stack<double> st1; // call xxstackxx(0x324242)
st1.push(1); // call xxpushi(?)
st1.pop();
return 0;
}
所以，建议将模板的声明和定义放到一个文件 "xxx.cpp" 或 "xxx.h" 中。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
