我们在之前的博客中讲述过模版的使用:【C++】模版初阶,但这只是模版最基本的使用,下面再深入模版,看看还有另外什么用法:
目录
一、非类型模板参数
我们知道模版可以传递类型参数,除此之外还可以传递非类型参数:
例如:
#define N 10
template<class T>
struct Static_sequence
{
T a[N];
};
上诉代码可以建立一个任意类型的静态顺序表,但是N值是确定的,我们如何建立我们想要的大小的静态顺序表呢?
再来看看下面的代码:
template<class T, size_t N = 10>
struct Static_sequence
{
T a[N];
};
我们在模版上再加一个非类型参数size_t N,这个参数可以传入我们需要的值来初始化静态顺序表:
int main()
{
Static_sequence<int, 20> q;
return 0;
}
在上述代码中我们传入了一个20,可以看到开辟了一个20个元素的静态数组:
对于该非类型模板参数,我们只能设定整型家族(int/char/short/...),对于其他类型是不支持的,例如:
对于设定的非类型模板参数,系统是将其作为常量看待的,所以它可以初始化数组元素个数
例如我们想要对传入的值做修改:
编译器是不能通过的
二、模板的特化
2.1 什么是模版的特化
通常情况下,使用模板可以实现一些与类型无关的代码,但对于一些特殊类型的可能会得到一些错误的结果,需要特殊处理,比如:指针类型的比较:
class Date
{
friend ostream& operator<<(ostream& out, const Date& d);
public:
Date(int year, int month, int day)//构造函数
{
if (month < 1 || month>12 || (day<1 || day>GetMonthDay(year, month)))//判断日期是否合法
{
cout << "Illegal date!" << endl;
}
else
{
_year = year;
_month = month;
_day = day;
}
}
int GetMonthDay(int year, int month) const//获取year年month月的天数
{
int MonthDay[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 };//用数组来依次存储平年1到12月的天数
if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))//判断是否为闰年的2月
{
return 29;
}
return MonthDay[month - 1];
}
//运算符重载
bool operator==(const Date& d) const//判断日期是否相同
{
return _year == d._year && _month == d._month && _day == d._day;
}
bool operator!=(const Date& d) const//判断日期是否不相同
{
return !(*this == d);
}
bool operator<(const Date& d) const//判断当前日期是否在传入日期之前
{
return _year < d._year || (_year == d._year && _month < d._month) || (_year == d._year && _month == d._month && _day < d._day);
}
bool operator<=(const Date& d) const//判断当前日期是否在传入日期之前或相同
{
return (*this < d) || (*this == d);
}
bool operator>(const Date& d) const//判断当前日期是否在传入日期之后
{
return !(*this <= d);
}
bool operator>=(const Date& d) const//判断当前日期是否在传入日期之后或相同
{
return !(*this < d);
}
private:
int _year;
int _month;
int _day;
};
ostream& operator<<(ostream& out, const Date& d)
{
out << d._year << "/" << d._month << "/" << d._day << endl;
return out;
}
// 函数模板 -- 参数匹配
template<class T>
bool Less(const T x, const T y)
{
return x < y;
}
int main()
{
std::cout << Less(Date(2022, 9, 27), Date(2022, 9, 25)) << endl;//Date类型比较
std::cout << Less(new Date(2022, 10, 27), new Date(2022, 10, 25)) << endl;//Date指针类型比较
return 0;
}
比较结果:
因为我们在Date类中运算符重载了<的比较方法,所以对于Date类可以直接调用该方法进行比较,但是对于Date*类型,模版找不到比较方法,只能默认比较地址空间的大小,导致了结果的错误
为了解决该问题,我们引入模版的特化:
2.2 函数模版的特化
函数模板的特化步骤:
1.必须要先有一个基础的函数模板
2.关键字template后面接一对空的尖括号<>
3.函数名后跟一对尖括号,尖括号中指定需要特化的类型
4.函数形参表: 必须要和模板函数的基础参数类型完全相同,如果不同编译器可能会报一些奇怪的错误
下面我们对上面的模版函数进行指针的特例化:
// 函数模板 -- 参数匹配
template<class T>
bool Less(const T x, const T y)
{
return x < y;
}
// 对Less函数模板进行特化
template<>
bool Less<Date*>(Date* x, Date* y)
{
return *x < *y;
}
这下结果就正确了:
该种实现简单明了,代码的可读性高,容易书写,因为对于一些参数类型复杂的函数模板,特化时要特别给出,因此函数模板不建议特化,平时我们使用实例化解决即可
2.3 类模版的特化
2.3.1 全特化
我们来设置一个类模版:
// 类模板 -- 参数匹配
template<class T>
class Less
{
bool operator()(T& x, T& y)
{
return x < y;
}
};
//全特化
template<>
class Less<Date*>
{
bool operator()(Date* x, Date* y)
{
return *x < *y;
}
};
全特化即是将模板参数列表中所有的参数都确定化,在上述代码中我们将T类型指明为Date*类型,这种将模板参数列表全部指明为一个确定的类型的操作就是全特化
2.3.2 偏特化
偏特化就是任何针对模版参数进一步进行条件限制设计的特化版本
如下:我们将类模板参数进一步限制为指针类型,但具体为上面类型的指针并未说明:
// 类模板 -- 参数匹配
template<class T>
class Less
{
bool operator()(T& x, T& y)
{
return x < y;
}
};
//偏特化,对模版参数进一步进行条件限制
template<class T>
class Less<T*>
{
bool operator()(T* x, T* y)
{
return *x < *y;
}
};
// 类模板 -- 参数匹配
template<class T1, class T2>
class Data
{
public:
Data() { cout << "Data<T1, T2>" << endl; }
private:
T1 _d1;
T2 _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 <typename T1, typename T2>
class Data <T1&, T2*>
{
public:
Data(const T1& d1, const T2* d2)//参数偏特化为引用类型时一定要初始化
: _d1(d1)
{
cout << "Data<T1&, T2*>" << endl;
}
private:
const T1& _d1;
T2* _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;
};
三、模板的分离编译
我们现在使用声明和实现分离的编译的方法来实现一个函数模版(将类模版的声明放在Func.h头文件中,实现代码放在Func.cpp中):
Func.h:
#pragma once
template<class T>
T Add(const T& left, const T& right);
Func.cpp:
#include"Func.h"
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
test.cpp:
#include"Func.h"
int main()
{
int x = 5, y = 10;
Add<int>(x, y);
return 0;
}
我们来编译一下:
咦,怎么编译通过不了?还报了一个链接错误?
下面我们来仔细分析一下:
一份C/C++程序要运行,一般要经历一下步骤:预处理—-->编译--->汇编―—-->链接,不熟悉的同学可以看到这里:C语言程序环境_c语言程序运行环境
但是在每个cpp文件经过预处理、编译、汇编,但没有进入链接阶段之前,都是单独被编译器所编译的。这样会导致由于模版参数没有实例化,Func.cpp文件在形成汇编指令时,并没有为Add函数开辟函数栈帧(因为没有参数的实例化,系统压根就不知道要开辟多大的空间来给Add函数用),但是由于头文件的展开,使汇编会形成call指令(这时的call指令并没有填上Add函数所在的栈帧地址),所以最终形成的obj文件进入链接时,会发现Func.cpp形成的obj文件中并没有上Add函数所在的栈帧地址,此时call指令中没有实际地址导致指令无法正常执行,最后报错
3.1 解决方法
知道了上面的原理后,我们就可以得出相应的解决办法了:
1. 将声明和定义放到一个文件 "xxx.hpp" 里面或者xxx.h其实也是可以的。推荐使用这种。
2. 模板定义的位置显式实例化。但我们不能给每个类型参数都实例化一份代码吧,这样要模版参数还有什么意义呢?所以这种方法不实用,不推荐使用