✨                                              人生便如一首绝句，平平仄仄平平仄            🌏 

📃个人主页：island1314

🔥个人专栏：C++学习

🚀 欢迎关注：👍点赞 👂🏽留言 😍收藏  💞 💞 💞

目录

一、非类型模板参数

1、非类型模板参数的简单使用

2、非类型模板参数在STL中的应用–array类

3、array类与普通数组的优劣

二、vector类模板中的打印问题

三、模板的特化

1、概念

2、函数模板特化(不建议使用)

3、类模板特化

✨1.全特化

✨2.偏特化

✨测试代码：

四、模板分离编译

✨1，什么是分离编译

✨2、函数模板的分离编译

✨3、解决方法

五、模板总结

一、非类型模板参数

在初阶模板中，函数模板和类模板所传的参数前面都是class或者typename修饰的，是类类型形参，但是模板除了可以传递类类型形参之外还可以传递非类型形参

模板参数分类：类型形参和非类型形参

类型形参：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。非类型形参：用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

1、非类型模板参数的简单使用

比如定义一个静态数组栈，假设需要大小不同的栈，就可以使用非类型模板参数：

<code>#include <iostream>

using namespace std;

//#define N 10

//非类型模板参数/常量参数

//静态栈

template<class T,size_t N = 10>

class Stack

{

private:

int* _a[N];

int _top;

};

int main()

{

//本质是由编译器实例化出3个栈

Stack<int> st1;

Stack<int, 100> st2;

Stack<int, 1000> st3;

return 0;

}

注意：

浮点数、类对象以及字符串是不允许作为非类型模板参数的。非类型的模板参数必须在编译期就能确认结果。

非类型模板参数必须是整数类型、枚举类型或指向对象的指针或引用类型。这是因为在编译时，非类型模板参数需要在编译器确定其值，而浮点数、类对象以及字符串在编译时无法确定其值。

(1) C++20之前，只允许整形做非类型模板参数。

(2) C++20之后，可以支持double等其他内置类型,不支持自定义类型。

(3) 非类型模板参数一般都是用整形，它是不可改变的常量。

2、非类型模板参数在STL中的应用–array类

array类：就是用一个类封装静态数组。使用时要包含头文件< array >。

#include <iostream>

#include <array>

using namespace std;

int main()

{

array<int, 10> aa1;

cout << sizeof(aa1) << endl; //40

return 0;

}

3、array类与普通数组的优劣

(1) array类对越界的严格检查。

普通数组是一种设置标志位的越界抽查行为，并且只能抽查出越界写，无法查出越界读。

int a[10];

//以下两个在越界边缘写时可以检查出

a[10] = 1;//err

a[11] = 2;//err

//越界读，无法查出

cout << a[20] << endl;

   array类的越界读写都可以检查出来，并且不是抽查。因为重载了operator[]，有assert断言等。

(2) array开空间后也不进行初始化，并且开的空间在栈中，不在堆上，十分占空间。

(3) array其实是一种鸡肋的设计，因为有vector。vector的越界检查也十分严格，并且vector还能初始化。

二、vector类模板中的打印问题

有时要遍历vector中的数据时，会写一个打印函数，但是一个简单的打印函数只能打印一种类型的数据，否则就要使用模板。

代码如下：

#include <iostream>

#include<vector>

using namespace std;

void PrintVector(const vector<int>& v)

{

vector<int>::const_iterator it = v.begin();

while (it != v.end())

{

cout << *it << " ";

++it;

}

cout << endl;

}

int main()

{

vector<int> v1 = { 1,2,3,4,5,6,7 };

vector<double> v2 = { 1.1,2.2,3.3,4.4,5.5,6.6,7.7 };

//编译报错

PrintVector(v1);

PrintVector(v2);

return 0;

}

改成模板形式：

template<class T>

void PrintVector(const vector<T>& v)

{

typename vector<T>::const_iterator it = v.begin();

//auto it = v.begin(); //ok

while (it != v.end())

{

cout << *it << " ";

++it;

}

cout << endl;

}

int main()

{

vector<int> v1 = { 1,2,3,4,5,6,7 };

vector<double> v2 = { 1.1,2.2,3.3,4.4,5.5,6.6,7.7 };

PrintVector(v1);

PrintVector(v2);

return 0;

}

有人可能会注意到，在vector中取const_iterator 时在前面加上了typename ，这是为什么呢？

原因：

       类模板没有实例化时，编译器不去类里面检查细节的东西，只是检查类的外壳，无法确认此时是类型还是静态变量，加上typename就是提前告诉编译器 vector< T>::const_iterator是类型。

三、模板的特化

1、概念

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

给定这样一个Date类

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& _cout, const Date& d);

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()

{

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;

}

上述示例中，p1指向的d1显然小于p2指向的d2对象，但是Less内部并没有比较p1和p2指向的对象内容，那么如果我们想要通过日期类的指针比较其所指向日期的大小时，就需要对它解引用再比较，而比较的是p1和p2指针的地址，这就无法达到预期而错误，这时上述的比较日期大小的函数模板就不适用了。

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

2、函数模板特化(不建议使用)

函数模板的特化步骤：

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

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

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

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

//函数模板

template<class T>

bool Less(T left, T right)

{

return left < right;

}

//函数模板特化版本

template<>

bool Less<Date*>( Date* left, Date* right)

{

return *left < *right;

}

但是我们在上述的函数模板传参时一般是如下传法：

const要放在 * 之后，特化要与原模板保持一致，修饰本身不改变。

// 函数模板 -- 参数匹配

template<class T>

bool Less(const T& left, const T& right)

{

return left < right;

}

template<>

bool Less<Date*>(Date* const & left, Date* const & right)

{

return *left < *right;

}

3、类模板特化

✨1.全特化

全特化即是将模板参数列表中所有的参数都确定化，模板的所有模板参数都提供具体的类型或值，使用特定的实现来处理特殊情况。

全模板的特化步骤：

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

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

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

//原模板

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;

};

✨2.偏特化

偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。比如对于以下模板类：

部分特化：将模板参数类表中的一部分参数特化。

template<class T1>

class Data<T1, int>

{

public:

Data() { cout << "Data<T1, int> - 偏特化" << endl; }

private:

T1 _d1;

int _d2;

};

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

//限定模板的类型

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

template <typename T1, typename T2>

class Data <T1*, T2*>

{

public:

Data() {

cout << typeid(T1).name() << endl;

cout << typeid(T2).name() << endl;

cout << "Data<T1*, T2*> - 偏特化" << endl << endl;

//T1 x1;

//T2* p1;

}

private:

};

//传引用

template <typename T1, typename T2>

class Data <T1&, T2&>

{

public:

Data() {

cout << typeid(T1).name() << endl;

cout << typeid(T2).name() << endl;

cout << "Data<T1&, T2&>" << endl << endl;

}

private:

};

template <typename T1, typename T2>

class Data <T1&, T2*>

{

public:

Data() {

cout << typeid(T1).name() << endl;

cout << typeid(T2).name() << endl;

cout << "Data<T1&, T2*>" << endl << endl;

}

private:

};

✨测试代码：

int main()

{

Data<int, int> d1;

Data<int, char> d2;

Data<int, double>d3;

Data<int*, double*>d4;

Data<int*, int**>d5;

Data<int&, int&>d6;

Data<int&, int*>d7;

return 0;

}

四、模板分离编译

✨1，什么是分离编译

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

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

}

// main.cpp

#include"a.h"

int main()

{

Add(1, 2);

Add(1.0, 2.0);

return 0;

}

编译后结果如下：

这是因为C/C++程序运行一般需要经历以下步骤：

预处理——编译——汇编——链接

预处理：在编译之前，预处理器对源文件进行处理，包括宏展开、头文件包含等操作。编译：对程序按照语言特性进行词法，语法，语义分析，检查无误之后生成汇编代码，注意头文件不参与编译，编译器对工程中的多个源文件是分离开单独编译的汇编：将汇编代码翻译成机器代码。链接：将编译后的目标文件与库文件进行链接，生成可执行文件。

✨3、解决方法

(1) 将声明和定义放到一个文件 “xxx.hpp” 里面或者xxx.h其实也是可以的。推荐使用这种。

(2) 模板定义的位置显式实例化。这种方法不实用，不推荐使用。

显式实例化代码如下：

<code>//a.cpp

#include"a.h"

template<class T>

T Add(const T& left, const T& right)

{

return left + right;

}

//显示实例化

template

int Add(const int& left, const int& right);

template

double Add(const double& left, const double& right);

五、模板总结

（1）优点

1、模板复用了代码，但本质上编译器会帮我们生成实例化的代码，只是减少了人工的消耗，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生

2、增强了代码的灵活性

（2）缺陷

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

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