C++模板(进阶)

非类型模板参数

模板参数分类型形参与非类型形参.
类型形参: 出现在模板参数列表中,跟在class,typename之类的参数类型名称.
非类型形参: 就是用一个常量作为类(函数)模板的一个参数,在类(函数)模板中可将该参数当成常量来使用.

例如:
我们希望定义一个能够随时定义多个数组大小的静态数组,此时便可以通过非类型模板参数实现:

class Array
{
private:
	T _a[N];
};
int main()
{
	Array<int> a0;     //定义一个大小为10的静态数组.
	Array<double, 100> a1;//定义一个大小为100的静态数组.
	Array<int, 1000> a2;//浮点数,类对象,字符串是不允许作为非类型模板参数的.
}

注意:
1:非类型模板参数只允许使用于整型,浮点型,类对象以及字}符串是不允许作为非类型模板参数的.
2:非类型模板参数在编译期就需要确认结果,因为编译器在编译阶段便根据非类型模板参数确定对应的类或者函数.

类模板的特化

类模板的概念

在原模版类的基础上,针对特殊类型所进行特殊化的实现方式,其中,模板特例化分为函数模板特化与类模板特化.
例如:
当我们不用类模板特化对日期类对象进行比较时会出现以下问题:

bool Less(T less, T right)
{
	return less < right;
}

struct Date
{
	Date(int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
	{}

	bool operator>(const Date& d) const
	{
		if ((_year > d._year)
			|| (_year == d._year && _month > d._month)
			|| (_year == d._year && _month == d._month && _day > d._day))
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	bool operator<(const Date& d) const
	{
		if ((_year < d._year)
			|| (_year == d._year && _month < d._month)
			|| (_year == d._year && _month == d._month && _day < d._day))
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	int _year;
	int _month;
	int _day;
};
int main()
{
	cout << Less(1, 2) << endl;    //结果正确. 1
	Date d1(2022, 7, 7);
	Date d2(2022, 7, 8);
	cout << Less(d1, d2) << endl;  //结果正确,1

	Date* p1 = &d1;
	Date* p2 = &d2;
	cout << Less(p1, p2) << endl;  //结果错误,0

	return 0;

}

Less对于绝大多数情况都可以正常比较,但是在特殊情况下就容易获得错误的答案,
p1指向的对象明显小于p2指向的对象,但是在Less内部中,并没有将p1指向的对象与p2指向的对象相比较,而是单纯的比较的是p1,p2指针的地址,而p1,p2的地址根据函数栈帧由高到低排布的,所以p1的地址比p2大,进而导致错误的结果.

函数模板特化

函数模板的特化步骤:
1: 必须要有一个基础的函数模板.

2: 关键字template后面要接一对尖括号,尖括号中指定需要特化的类型.

3: 函数形参表必须要与要模板函数的基础类型完全相同.

template<class T>
bool Less(T left, T right)
{
	return left < right;
}
//对Less函数模板进行特例化
template<>
//尖括号中需要指定特化的类型，且必须和模板函数的基础参数类型完全相同．
bool Less<Date*>(Date* left, Date* right)
{
//类模板特化将单纯指针的比较转换为Date对象的比较.
	return *left < *right;
}
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;
}

注意:
一般情况下,如果函数模板遇到不能处理或者处理有错误的类型,为了代码的可读性高,方便实现,对于一些复杂的函数模板,建议特化时特化给出.

template<class T>
bool Less(T left, T right)
{
	return left < right;
}
bool Less(Date* left, Date* right)
{
	return *left < *right;
}

类模板的特化

全特化

全特化时间模板参数列表中所有的参数都确定化.

指模板参数列表不写参数,在类名后面标注要传的类型,然后在定义中类型都用特例化的类型.
如果实参要传的类型与模板特例化的类型不一样,则在定义Date中会调用普通类模板.

template<class T1, class T2>
class Date
{
public:
	Date() 
	{ 
		cout << "Data" << endl;
	}
private:
	T1 _d1;
	T2 _d2;
};
template<>
class Date<int, char>
{
public:
	Date()
	{
		cout << "Data" << endl;
	}
private:
	int _d1;
	char _d2;
};
int main()
{
	Date<int, char>d1;  //走的是函数模板特例化.
	Date<int, int> d2;  //走的是函数模板.
}

偏特化

指的是将模板参数列表的一部分参数进行特化.

class Date
{
public:
	//构造函数
	Date()
	{
		cout << "Date" << endl;
	}
private:
	T1 _d1;
	T2 _d2;
};
template < class T1 >
class Date < T1, int >
{
public:
	Date()
	{
		cout << " Data < T1, int > " << endl;
	}
private:
	T1 _d1;
	int _d2;
};

int main()
{
	Date <int, int > d1;
	Date <int, char > d2;
	return 0;
}

参数的进一步限制

偏特化不仅仅是指特化部分参数,而是针对模板参数更进一步的条件限制所设计出来的一个特化版本.

template <typename T1, typename T2>
class Date <T1*, T2*>
{
public:
	Date()
	{ 
		cout << "Data" << endl;
	}
private:
	T1 _d1;
	T2 _d2;
};
//两个参数偏特化为引用类型
template <typename T1, typename T2>
class Date <T1&, T2&>
{
public:
	Date(const T1& d1, const T2& d2)
		: _d1(d1)
		, _d2(d2)
	{
		cout << "Data" << endl;
	}

private:
	const T1 _d1;
	const T2 _d2;
};
int main()
{
//	Data d1; // 调用特化的int版本
//	Data d2; // 调用基础的模板 
	Date<int*, int*> d3;
	Date<int&, int&> d4(1,2);
}

这,当实例化对象模板参数为指针类型或者引用类型时,编译器会根据模板参数最匹配的进行调用.

模板的分离编译

例如:
我们将v.push_back函数模板声明与定义分别放进.h和.cpp文件中,
而vector构造,operator[]等成员函数声明与定义放到vector.h文件中,
此时在编译阶段,这些成员函数就已经实例化了从而确定函数地址了.

可是,push_back函数模板声明与定义是分开的,导致在编译阶段就无法确定T的参数类型,也就说明只有函数声明没有函数定义了,那么函数地址只能从链接阶段去找,可是,没有函数定义,也就无法将函数地址放进符号表中,编译器无法在符号表中根据函数声明去寻找对应的函数地址了.

#include 
int main()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	return 0;
}

解救办法:
1:类模板以及类模板函数什么声明与定义不要分离编译.

2: 类模板显示实例化具体的类型:int,double(编译器就可以找编译中将函数模板实例化了)

模板的优缺点

注意:
我们不推荐显示显示类模板的具体类型,因为如果是别的数据类型又要重新显示实例化.

优点:
模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库（STL）因此而产生。(将重复的工作交给编译器做）,增强了代码的灵活性。
缺陷：
1：模板会导致代码膨胀问题（实例化多少就会有多少份代码），也会导致编译时间变长。
2：出现模板编译错误时，错误信息非常凌乱，不易定位错误。