c++模版进阶

非类型模版参数

模板参数分类类型形参与非类型形参。

类型形参即：出现在模板参数列表中，跟在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,因为比较的是指针的地址
}

函数模版的特化

步骤

1. 必须要先有一个基础的函数模板
2. 关键字template后面接一对空的尖括号<>
3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

上面的代码添加下面的特化代码就不会报错了

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;
}