模板是泛型编程思想的一个具体实例,在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" 中。