文章目录
非类型模版参数
模板参数分类类型形参与非类型形参。
类型形参即:出现在模板参数列表中,跟在class或者typename之类的参数类型名称。
非类型形参,就是用一个常量作为类(函数)模板的一个参数,在类(函数)模板中可将该参数当成常量来使用。
注意:1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的。只有整形可以(int, long long, char…)
2. 非类型的模板参数必须在编译期就能确认结果。
// 类型模版参数
#define N 10
template<class T>
class Array
{
public:
Array()
{cout << "Array()" << endl;}
private:
T _arr[N];
};
// 非类型模版参数
template<class T, size_t N2 = 10>
class Array2
{
public:
Array2()
{cout << "Array2()" << endl;}
private:
T _arr[N2];
};
模版的特化
引入
对于下面的代码
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
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 (_year > d._year) ||
(_year == d._year && _month > d._month) ||
(_year == d._year && _month == d._month && _day > d._day);
}
friend ostream& operator<<(ostream&, const Date&);
private:
int _year;
int _month;
int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
_cout << d._year << "-" << d._month << "-" << d._day;
return _cout;
}
template<class T>
bool Less(T left, T right)
{
return left < right;
}
int main()
{
Date d1(2024, 4, 15);
Date d2(2024, 4, 1);
cout << Less<Date>(d2, d1) << endl;
cout << Less<Date*>(&d2, &d1) << endl; // 这一行可能会WA,因为比较的是指针的地址
}
函数模版的特化
步骤
- 必须要先有一个基础的函数模板
- 关键字template后面接一对空的尖括号<>
- 函数名后跟一对尖括号,尖括号中指定需要特化的类型
- 函数形参表: 必须要和模板函数的基础参数类型完全相同,如果不同编译器可能会报一些奇怪的错误。
上面的代码添加下面的特化代码就不会报错了
template<>
bool Less<Date*>(Date* left, Date* right)
{
return *left < *right;
}
当然,也可以写成函数重载的形式,这样更易读
bool Less(Date* left, Date* right)
{
return *left < *right;
}
所以函数模版的特化意义不大
类模版的特化
全特化
全特化即是将模板参数列表中所有的参数都确定化
template<class T1, class T2>
class Data
{
public:
Data() { cout << "Data<T1,T2>" << endl; }
private:
T1 _a;
T2 _b;
};
// 全特化
template<>
class Data<int, char>
{
public:
Data() { cout << "Data<int,char>" << endl; }
private:
int _a;
char _b;
};
int main()
{
Data<int, int> d1;
Data<int, char> d2;
return 0;
}
偏特化:任何针对模版参数进一步进行条件限制设计的特化版本。
对于上述的Data类,有两种偏特化表现形式
部分特化:将模板参数类表中的一部分参数特化
// 偏特化(部分特化),将第二个参数转化为int template<class T> class Data<T, int> { public: Data() { cout << "Data<T,char>" << endl; } private: T _a; char _b; };
参数更进一步的限制
不仅仅是特化部分参数,而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。
// 将两个参数偏特化为指针类型 template<class T1, class T2> class Data<T1*, T2*> { public: Data() { cout << "Data<T1*,T2*>" << endl; } private: T1* _a; T2* _b; }; // 将两个参数偏特化为引用类型 template<class T1, class T2> class Data<T1&, T2&> { public: Data(const T1& d1, const T2& d2) :_a(d1),_b(d2) { cout << "Data<T1&, T2&>" << endl; } private: const T1& _a; const T2& _b; };
应用
// 专门用来小于比较的类模板Less
template<class T>
struct Less
{
bool operator()(T left, T right) const
{
return left < right;
}
};
int main()
{
Date d1(2024, 4, 16);
Date d2(2024, 4, 13);
Date d3(2024, 4, 15);
vector<Date> v1;
v1.push_back(d1);
v1.push_back(d2);
v1.push_back(d3);
// 结果正确
sort(v1.begin(), v1.end(), Less<Date>());
for (auto& e : v1)
cout << e << endl;
// 结果错误,因为Less<Date*>比较的是地址
v2.push_back(&d1);
v2.push_back(&d2);
v2.push_back(&d3);
sort(v2.begin(), v2.end(), Less<Date*>());
return 0;
}
解决办法,进行全特化
template<>
struct Less<Date*>
{
bool operator()(const Date* left, const Date* right) const
{
return *left < *right;
}
};
也可以写成偏特化
template<class T>
struct Less<T*>
{
bool operator()(const Date* left, const Date* right) const
{
return *left < *right;
}
};
当然也可以再写一个比较函数
struct PDateLess
{
bool operator()(const Date* x, const Date* y)
{
return *x < *y;
}
};
模版的分离编译
// add.h
template<class T>
T add(T x, T y);
void func();
// add.cpp
#include "add.h"
template<class T>
T add(T x, T y)
{
return x + y;
}
void func()
{
cout << "func()" << endl;
}
// main.cpp
int main()
{
func();
add(1, 2);
return 0;
}
main函数在经过预处理,编译,汇编后,生成的main.o中会有func()函数的地址,但是没有add的地址,因为add没有实例化,没办法确定T
解决办法1:显示实例化(调用一种类型,进行一种类型显示实例化的声明)
// add.h
template<class T>
T add(T x, T y);
template
int add<int>(int x, int y);
void func();
解决方法2,将声明和定义放在一起
// add.hpp
template<class T>
T add(T x, T y);
template<class T>
T add(T x, T y)
{
return x + y;
}
地址,因为add没有实例化,没办法确定T
解决办法1:显示实例化(调用一种类型,进行一种类型显示实例化的声明)
// add.h
template<class T>
T add(T x, T y);
template
int add<int>(int x, int y);
void func();
解决方法2,将声明和定义放在一起
// add.hpp
template<class T>
T add(T x, T y);
template<class T>
T add(T x, T y)
{
return x + y;
}