目录
非类型模板参数
通常情况下,我们可以通过类型模板参数来使用容器存放不同类型的数据,但有时我们会用到非类型模板参数。
- 类型形参:出现在模板参数列表中,跟在class或者typename之类的参数类型名称。
- 非类型形参:用一个常量作为类(函数)模板的一个参数,在类(函数)模板中可将该参数当成常量来使用
// 定义一个模板类型的静态数组
template <typename T, size_t N = 16>
class stack
{
// ...
private:
T m_a[N];
size_t m_size;
};
注意:
1. 浮点数、类对象以及字符串不允许作为非类型模板参数,非类类型模板的形参只能是整型、指针和引用。
2.非类型模板形参如果是表达式,则必须是一个常量表达式,在编译时计算出结果。
3.非类类型模板形参和实参间允许类型转换
模板的特化
概念
通常情况下,使用模板可以实现一些不同类型的代码,但对于一些特殊类型可能会得到错误的结果,如下例:
#include<iostream>
using std::cout;
using std::cin;
using std::endl;
class Date
{
public:
Date(int year = 1970, int month = 1, int day = 1)
: m_year(year)
, m_month(month)
, m_day(day)
{}
~Date() {}
bool operator<(const Date& right) const
{
if (m_year < right.m_year)
return true;
else if (m_year == right.m_year)
{
if (m_month < right.m_month)
return true;
else if (m_month == right.m_month)
{
if (m_day < right.m_day)
return true;
}
}
return false;
}
private:
int m_year;
int m_month;
int m_day;
};
template<typename T>
bool Less(T left, T right)
{
return left < right;
}
int main()
{
// 结果正确
cout << Less(15, 25) << endl;
// 结果正确
cout << Less(Date(2001, 3, 4), Date(2001, 3, 5)) << endl;
Date d1(2019, 6, 1);
Date d2(2020, 6, 1);
// 比较的是地址,结果错误
cout << Less(&d1, &d2) << endl;
return 0;
}
上例中,Less 在绝大多数情况下都可以正常比较,但在特殊场景下就会出现错误,如 Less 的参数为需比较的对象的地址,上例中为 Date*,此时,模板将 Date*
推演为T,因此 Less 比较的就是两个 Date*
类型的变量的大小,这与我们预想的结果相差甚远。
此时,就需要对模板进行特化。即:在原模板类的基础上,针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。
函数模板特化
函数模板的特化步骤:
- 必须要先有一个基础的函数模板
- 关键字 template 后面接一对空的尖括号<>
- 函数名后跟一对尖括号,尖括号中指定需要特化的类型
- 函数形参表: 必须要和模板函数的基础参数类型完全相同,如果不同编译器可能会报一些奇怪的错误。
template<typename T>
bool Less(T left, T right)
{
return left < right;
}
// 函数模板特化
template<>
bool Less<Date*>(Date* left, Date* right)
{
return *left < *right;
}
类模板特化
全特化
全特化是将模板参数列表中所有的参数都确定化。
template<typename T1, typename T2>
class Date
{
public:
Date(const T1& v1, const T2& v2)
: m_v1(v1)
, m_v2(v2)
{
cout << "Date(const T1& v1, const T2& v2)" << endl;
}
private:
T1 m_v1;
T2 m_v2;
};
// 全特化
template<>
class Date<int, double>
{
public:
Date(int v1, double v2)
: m_v1(v1)
, m_v2(v2)
{
cout << "Date(int v1, double v2)" << endl;
}
private:
int m_v1;
double m_v2;
};
int main()
{
Date<int, char> d1(1, 'a'); // 调用基础类模板
Date<int, double> d2(10, 1.1); // 调用全特化的版本
return 0;
}
偏特化
偏特化是指任何针对模版参数进一步进行条件限制设计的特化版本。
// 偏特化
template<typename T1>
class Date<T1, double>
{
public:
Date(const T1& v1, double v2)
: m_v1(v1)
, m_v2(v2)
{
cout << "Date(const T1& v1, double v2)" << endl;
}
private:
T1 m_v1;
double m_v2;
};
// 进一步的偏特化
// 两个参数偏特化为指针类型
template<typename T1, typename T2>
class Date<T1*, T2*>
{
public:
Date(const T1* const v1, const T2* const v2)
: m_v1(*v1)
, m_v2(*v2)
{
cout << "Date(const T1* const v1, const T2* const v2)" << endl;
}
private:
T1 m_v1;
T2 m_v2;
};
// 两个参数偏特化为引用类型
template<typename T1, typename T2>
class Date<T1&, T2&>
{
public:
Date(const T1& v1, const T2& v2)
: m_v1(v1)
, m_v2(v2)
{
cout << "Date(const T1& v1, const T2& v2)" << endl;
}
private:
const T1& m_v1;
const T2& m_v2;
};
int main()
{
Date<int, int> d1(1, 2); // 调用基础类模板
Date<int, double> d2(1, 2.2); // 调用偏特化第二个参数的版本
int x = 10;
char y = 'y';
Date<int*, char*> d3(&x, &y); // 调用偏特化为指针的版本
Date<int&, char&> d4(x, y); // 调用偏特化为引用的版本
return 0;
}
模板分离编译
问题
通常情况下,我们会把函数和类的声明放在一个.h头文件里,在另一个.cpp文件里实现,但如果模板也采用这种策略,则会出现错误,如下例:
// less.h
template<typename T>
bool Less(const T& left, const T& right);
// less.cpp
#include"less.h"
template<typename T>
bool Less(const T& left, const T& right)
{
return left < right;
}
// main.cpp
#include<iostream>
#include"less.h"
int main()
{
std::cout << Less(1, 2) << std::endl;
std::cout << Less(1.1, 2.2) << std::endl;
return 0;
}
C/C++程序的运行需要经历以下步骤:
预处理 ---> 编译 ---> 汇编 ---> 链接
预处理:a.头文件展开;b.去注释;c.宏替换;d.条件编译
编译:对程序按照语言特性进行词法、语法、语义分析,检查无误后生成汇编代码,编译器对工程中的多个源文件是分离开单独编译的。
汇编:将编译好的汇编代码转化为.obj二进制文件
链接:将多个.obj文件合并为一个
上例中,在Less.cpp文件里没有Less函数的实例化,不会生成对应的函数,也就没有函数地址,但main.obj在链接时才会寻找Less的地址,而Less函数没有实例化,没有生成具体函数,因此链接时报错。
解决方案
- main.cpp 里 #include "less.cpp",但是会减慢编译速度。
- 在模板函数或模板类定义的文件里添加显式实例化的内容,上例中可在 less.cpp 里添加如下代码:
template bool Less<int>(const int&, const int&); template bool Less<double>(const double&, const double&);
- 模板函数或模板类的声明和定义直接写在头文件里(实际工作中常用)。
总结
优点
- 模板复用了代码,节省资源,更快的迭代开发,C++的标准模板库(STL)因此而产生。
- 增强了代码的灵活性。
缺点
- 模板会导致代码膨胀问题,也会导致编译时间变长。
- 出现模板编译错误时,错误信息非常凌乱,不易定位错误。