【C++】函数模板和类模版

目录

前言

模板参数

类型模板参数

非类型模板参数

模板的特化

函数模板的特化

类模板的特化

全特化

偏特化

模板的分离编译

模板总结

---

前言

函数模板和类模板是C++模板编程中的两个核心概念，它们允许程序员编写泛型代码，这些代码可以在多种数据类型上工作，而无需为每个数据类型编写单独的实现。这提高了代码的可复用性和灵活性。所以说，模板还是很重要的。

模板参数

模板参数分为类型形参和非类型形参。

类型模板参数

出现在模板参数列表中，跟在class或者typename之后的参数类型名称。

//T可以是int、double等任何类型
template <class T>
T Add(T& a, T& b)
{
	return a + b;
}

非类型模板参数

非类型模板参数，就是用一个常量作为类（函数）模板的一个参数，在类（函数）模板中可将该参数当成常量来使用。

非类型模板参数不一定是整形常量，也可以是double等类型。需要注意的是，非类型模板参数必须在编译期就能确定结果。

//N就是非类型模板参数
template <class T, size_t N = 10>
class array
{
public:
	T& operator[](size_t index)
	{
		return _array[index];
	}
	const T& operator[](size_t index) const
	{
		return _array[index];
	}
	size_t size() const
	{
		return _size;
	}
	bool empty() const
	{
		return _size == 0;
	}
private:
	T _array[N];
	size_t _size;
};

模板的特化

特化的概念：特化是一种技术，当模板参数为某些特殊类型时，开发者可以为其定义特定的实现。这种技术允许开发者在需要时覆盖模板的默认行为，为特定类型或类型组合提供优化或特定的功能。

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型可能会产生错误的结果，需要特殊处理。例如，实现一个专门用来进行小于比较的函数模板。

template <class T>
bool less(T left, T right)
{
	return left < right;
}

int main()
{
	cout << less(1, 2) << endl;//可以正确比较

	Date d1(2024, 6, 8);
	Date d2(2024, 6, 9);

	cout << less(d1, d2);//可以正确比较

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

	return 0;
}

可以看到，对于最后的特殊场景，比较结果是错误的。原因在于，比较的是p1和p2指针的地址，而不是比较它们指向的内容。

此时，就需要对函数模板进行特化了。模板特化，就是在原模板的基础上，针对特殊类型进行特殊化的实现方式。模板特化分为类模板特化和函数模板特化。

函数模板的特化

步骤：

1）必须要先有一个基础的函数模板

2）关键字template后面接一对空的尖括号<>

3）函数名后跟一对尖括号<>,尖括号中指定需要特化的类型

template <class T>
bool less(T left, T right)
{
	return left < right;
}

//函数模板的特化
template <>
bool less<Date*>(Date* left, Date* right)
{
	return *left < *right;
}

int main()
{
	cout << less(1, 2) << endl;//可以正确比较

	Date d1(2024, 6, 8);
	Date d2(2024, 6, 9);

	cout << less(d1, d2);//可以正确比较

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

	return 0;
}

但是，一般情况下，如果函数模板遇到不能处理或者处理有误的类型，为了实现简单，通常都是将该函数直接给出。

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 _d1;
	T2 _d2;
};

//全特化
template<>
class Data<int, char>
{
public:
	Data() { cout << "Data<int, char>" << endl; }
private:
	int _d1;
	char _d2;
};

偏特化

• 偏特化是指为模板类或模板函数提供一份基于原始模板定义但针对部分模板参数进行条件限制或更具体实现的定义。
• 将模板参数列表中的一部分参数特化
• 参数更进一步的限制，例如限定参数的类型

将模板参数列表中的一部分参数特化

template <class T1, class T2>
class Data
{
public:
	Data() { cout << "Data<T1, T2>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};

//将模板参数列表中的一部分参数特化
template <class T1>
class Data<T1, int>
{
public:
	Data() { cout << "Data<T1, int>" << endl; }
private:
	T1 _d1;
	int _d2;
};

参数类型更进一步的限制

1）两个参数偏特化为指针类型

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

如果都是指针类型，就会走上面的这个偏特化。

2）两个参数偏特化为引用类型

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(const T1& d1, const T2& d2)
		:_d1(d1)
		, _d2(d2)
	{
		cout << "Data<T1&, T2&>" << endl;
	}
private:
	const T1& _d1;
	const T2& _d2;
};

如果都是引用类型，那么将走这个偏特化。

模板的分离编译

分离编译的概念：

一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有的目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。

模板在C++中并不直接支持传统意义上的分离编译，即声明和定义放在不同的文件中。这是因为模板的实例化是在编译时进行的，编译器需要看到模板的定义才能对模板进行实例化。

请看一下的场景：.h放声明，一个.cpp文件放定义，然后在另一个.cpp文件中调用。

//a.h
template <class T>
T Add(const T& left, const T& right);

//a.cpp
template <class T>
T Add(const T& left, const T& right)
{
	return left + right;
}

//main.cpp
#include "a.h"
int main()
{
	Add(1, 2);
	return 0;
}

这就会导致链接错误。原因如下：

首先，每个源文件（加上其包含的头文件）通常被视为独立的编译单元，编译器会单独编译每个编译单元，这些编译单元在编译期间不会进行交互。因为main.cpp包含了头文件，所以头文件会插入该源文件中并在编译时被考虑，但是在编译main.cpp的过程中，函数模板Add只有声明，没有定义，因此它没有被实例化。在编译a.cpp的过程中，编译器没有看到对Add函数的实例化，因此不会生成具体的加法函数。在main.cpp中调用Add<int>，编译器在链接时才会找其地址，但是这个函数并没有实例化生成具体的代码，因此链接错误。

解决方法：

1）将声明和定义放到一个.hpp或.h文件中。

2）模板定义的位置显示实例化。

显示实例化：

//a.h
template <class T>
T Add(const T& left, const T& right);

//a.cpp
template <class T>
T Add(const T& left, const T& right)
{
	return left + right;
}

//显示实例化
template
int Add(const int& left, const int& right);


//main.cpp
#include "a.h"
int main()
{
	Add(1, 2);
	return 0;
}

模板总结

【优点】

1）复用了代码，更快的迭代开发，C++标准模板库STL因此产生。

2）增强了代码的灵活性。

【缺点】

1）模板会导致代码膨胀问题，也会导致编译时间变长。

2）出现模板编译错误时，错误信息非常凌乱，不易定位错误。

【模板导致编译时间变长的几个原因】

1）类型推导

模板在编译阶段需要进行类型推导。当编译器遇到模板是，它需要根据模板参数的类型生成相应的代码。这个过程需要编译器进行额外的分析和计算，因此消耗更多的编译时间。

2）代码膨胀

模板的使用可能导致代码膨胀。由于模板在编译时回生成实际的代码，这可能导致生成的代码量远大于原始代码，大量的代码需要编译器进行解析和处理，从而导致编译时间变长。

---

完~