【C++】模板进阶

不吃肉的Humble

已于 2024-06-16 14:22:12 修改

阅读量965

点赞数 17

分类专栏：走进C++的世界文章标签： c++ 开发语言

于 2024-06-05 15:10:41 首次发布

本文链接：https://blog.csdn.net/2301_79345909/article/details/139470306

版权

走进C++的世界专栏收录该内容

17 篇文章 0 订阅

订阅专栏

一.非类型模板参数

二.模板的特化

三.模板的分离编译

欢迎来到C++初阶的最后一课——模板进阶

下面就开始今天的学习吧~

一.非类型模板参数

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

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

#define N 10;
//静态数组
template <class T>
class Array
{
public:
    //....
private:
    T _a[N];
}

int main()
{
    Array<int> a1;
    Array<int> a2;
    return 0;
}

但是这样的话，如果我们需要让它去初始化一个大小为10的数组和一个大小为100的数组，它就做不到了，即我们无法去灵活控制大小，所以我们需要非类型形参

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

//非类型模板参数
template<class T,size_t N = 10>//传一个缺省值
class Array
{
private:
    T _a[N];
}

int main()
{
    Array<int,10> a1;
    Array<int,100>a2;
    return 0;
}

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

二.模板的特化

模板特化的含义就是：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。

模板特化中分为函数模板特化与类模板特化

函数模板特化

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理，即需要对模板进行特化

比如：在日期类中，实现了一个专门用来进行小于比较的函数模板

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

int main()
{
	Date d1(2024, 6, 6);
	Date d2(2024, 6, 7);

	cout << Less(d1, d2) << endl;//结果正确

	Date* p1 = &d1;
	Date* p2 = &d2;

	cout << Less(p1, p2) << endl; //结果错误


	return 0;
}

可以看到，Less在特殊场景下就得到错误的结果。

上述示例中，p1指向的d1显然小于p2指向的d2对象，但是Less内部并没有比较p1和p2指向的对象内容，而比较的是p1和p2指针的地址，这就无法达到预期而错误

所以我们要去对Date*进行特殊化处理

函数模板的特化步骤：
1. 必须要先有一个基础的函数模板
2. 关键字template后面接一对空的尖括号< >
3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
4. 函数形参表: 必须要和模板函数的基础参数类型完全相同

//针对特殊场景进行特殊处理——Date*
template<>
bool Less<Date*>(Date* left, Date* right)
{
	return *left < *right;
}

简单说了一下函数模板特化，再来看一下类模板特化

因为函数模板支持重载，所以函数模板也可以不写成模板，直接写成函数也是可以

那么下面的类模板特化则用处大了，我们来看一下

类模板特化

1.全特化

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

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


int main()
{
	Data<int, int> d1;
	Data<int, char> d2;

	return 0;
}

2.偏特化
偏特化：任何针对模版参数进一步进行条件限制设计的特化版本

偏特化有以下两种表现方式：

a.部分特化
将模板参数类表中的一部分参数特化

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

// 将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
public:
	Data() { cout << "Data<T1, int>" << endl; }
private:
	T1 _d1;
	int _d2;
};

int main()
{
    Data<int, char> d1;
	Data<int, int> d2;
	

	return 0;
}

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

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


int main()
{
	Data<int, double> d1; // 调用基础的模板
	Data<int*, int*> d2; // 调用特化的指针版本

	return 0;
}

当然除了针对指针，也可以针对引用

三.模板的分离编译

我们之前就知道，c++在写模版函数时（template<class T>之类的），.h声明不能与cpp文件定义分离，下面我们就来分析一下为什么是这样~

模板的分离编译
假如有以下场景，模板的声明与定义分离开，在.h中进行声明，.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;
}


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

下面我们来分析：

我们知道，C++程序要运行，一般要经历以下步骤：预处理-->编译--->汇编----->链接

预处理：去注释，宏替换，头文件展开，条件编译（a.i, test.i）

编译：生成汇编代码(a.s, test.s)、符号汇总

汇编：把汇编变成二进制目标文件(a.o , test.o)，形成符号表

链接：符号表的合并与重定位，将多个obj文件合并成一个，形成可执行程序

在a.cpp中，编译器没有看到这个Add模板函数的实例化，因此不会生成具体的加法函数

在main.o调用Add<int> 与Add<double>，这时还没有链接，而编译器只有在链接时才会找其地址，但是这2个函数没有实例化,不会生成具体的代码，因此在链接时会报错