C++——模板的作用2：特例化

模板的形式：

一.模板的多参数应用：

例：

错误使用1：使用不标准的模板形参表

编辑

错误使用2：使用变量作为实参传递给函数模板

二.模板的特例化：

类模板：

针对模板的特化步骤：

类模板的全特化：

类模板的半特化:

半特化的扩展：

三. 模板总结

在之前，我介绍过一篇关于C++模板的作用，它的出现解决了C语言对多种不同类型的但是有着相同作用函数的难题，举个例子：想要作用于两个整型变量的交换，那么使用C语言可以写出整型交换的函数，但是又出现了char型、double型、short型变量的交换，那么就需要再写出这三个类型的交换函数，而这几个函数写出来后唯一的不同点就是返回值和形参的不同，造成了代码的冗余，可读性变差。

模板的形式：

template <模板形参表>

返回值类型函数体（模板函数形参表）

{

}

而模板的出现使得交换函数只需要写一个就够，极大的缩减了代码，增加了函数的复用性，为泛型编程打下了坚实的基础！

(478条消息) C++基础——模板讲解_橙予清的zzz~的博客-CSDN博客https://blog.csdn.net/weixin_69283129/article/details/127845086

感兴趣的朋友门可以来看看这篇文章，它会加深你对模板的理解。

而接下来我要讲的是模板的另外几个作用：

一.模板的多参数应用：

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

1.类型形参即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。

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

在上面的那篇博客中，我所列举的模板例子中用到的全都是类型形参。

 // 定义一个模板类型的静态数组
 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 0 == _size;
            }
 
     private:
         T _array[N];
         size_t _size;
         }；

通过上图代码可知：模板形参列表中出现了非类型形参。该参数可以是变量，但其类型只能是整型，这个整型包括：char、int、size_t等类型！而使用自定义类型、浮点类型的变量是不被允许的！会报编译错误！

例：

运行结果：

错误使用1：使用不标准的模板形参表

错误使用2：使用变量作为实参传递给函数模板

二.模板的特例化：

类模板：

函数模板是对函数进行泛型的使用，让函数能够对多种类型的变量做相应的操作；

而类模板就算对类进行泛型的使用，让类中的成员变量或者函数做相应的复杂操作。

//类模板样例1：
template<class T1,class T2>
class Date {
public:
	Date() {
		cout << "模板：Date(T1,T2)" << endl;
	}
private:
	T1 _a1;
	T2 _b1;

};

针对模板的特化步骤：

1. 必须要先有一个基础的函数模板或者类模板

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

3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型

4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

类模板的全特化：

全特化即是将模板参数列表中所有的参数都确定化。

//类模板的特殊化处理——全部参数特殊化处理
template<>
class Date<double,double>{
public:
	Date() {
		cout << "全特化：Date(double, double)" << endl;
	}
private:
	double _a1;
	double _b1;
};

//类模板的特殊化处理——全部参数特殊化处理2
template<>
class Date<short,char> {
public:
	Date() {
		cout << "全特化：Date(short, char)" << endl;
	}
private:
	short _a1;
	char _b1;
};

如上，全特化的类模板所使用的模板形参列表相比较普通的类模板，类型是全部确定的。全特化的作用就是：在一般的情况下，普通的对象被创建时使用普通类模板即可，做着普通的工作。而在某种特殊情况下，我们可以让对象被创建时使用专门的经过特殊化处理的类模板，做一些特殊的操作。

类模板的半特化:

针对模版参数进一步进行条件限制设计的特化，即部分特化模板参数列表。

//半参数特殊化处理——案例1：
template<class T2>
class Date<double, T2> {
public:
	Date() {
		cout << "半特化：Date(double, T2)" << endl;
	}
private:
	double _a1;
	T2 _b1;
};

//半参数特殊化处理——案例2：
template<class T1>
class Date<T1, char> {
public:
	Date() {
		cout << " 半特化：Date(T1, char)" << endl;
	}
private:
	T1 _a1;
	char _b1;
};

类模板原本是T1,T2两个类型的参数，使用半特化就是将T1具体化成double类型作为模板参数。

int main(){
    Date<int, int> d1;
	Date<double, double>d2;	
	Date<short,char>d3;	
	Date<double, int> d4;	
	Date<int, char> d5;		
    return 0;
    }

接着，我们在main函数中使用类创建几个对象，看编译器会进入哪些类模板中！

运行结果:

代码解析:

通过结果可知：d1的创建是调用了类模板T1,T2的构造函数，d2,d3是调用了全特化的类模板构造函数，d4,d5调用了半特化的类模板构造函数。

将这些比作生活的例子：当时间到了吃中午饭的时候，编译器饿了，在它面前有三种吃法：1.自己拿食材做(炒,炸,烧,爆,煎,煮)；2.做省时省力的半成品饭；3.点外卖。而T1,T2类型的类模板好比是从超市买回来的新鲜食材，需要编译器自己去做才能吃；半特化的类模板好比是半成品，例如：方便面、自热饭、昨晚的剩饭剩菜，需要编译器进行小小的加工就可以吃了；而全特化的类模板好比是外卖，是现成的热乎的香喷喷的饭菜。在不考虑金钱和健不健康的情况下，我们的做法肯定是选择好吃美味而且省时省力的外卖，编译器的思想也和我们一样——有现成的就不会自己动手再去做。

所以编译器在对d1对象的调用时，发现没有完美符合<int,int>的类模板，那么只能去自己做(使用T1,T2模板的构造函数)；

而对于d2对象的调用，发现double,double的构造函数选项有两种，一种是选择<T1,T2>的类，另一种是选择<double,double>的类，那编译器肯定是选择后者。

......

半特化的扩展：

半特化还可以应用于指针、引用的类型上！

template<class T1,class T2>
class Date<T1*,T2*> {
public:
	Date() {
		cout << "半特化：Date(T1*,T2*)" << endl;
	}
private:
	T1* _a1;
	T2* _b1;
};

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

private:
	const T1 & _d1;
	const T2 & _d2;
};