C++之模板进阶

棠～

于 2024-08-02 20:45:45 发布

阅读量340

点赞数 15

分类专栏：知识总结 C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/qq_55958734/article/details/140876784

版权

知识总结同时被 2 个专栏收录

59 篇文章 2 订阅

订阅专栏

C++

18 篇文章 0 订阅

订阅专栏

非类型模板参数

在之前模板章节的学习时，我们知道模板参数其实就是一个类型，在实例化时可以被实例化成各种类型。其实还有一种模板参数就是非类型模板参数。

观察下述代码。

template<class T, size_t N = 20>
	class A
	{
	public:
		void fun1()
		{
			cout << "A<T,N>" << endl;
		}
    private:
		int arr[N];
	};

int main()
{
	yjd::A<int ,10> a;
	return 0;
}

上述代码仍然是可以编译通过的，第二个模板参数N就是非类型模板参数。需要注意的是，这个N并不是一个变量，而是一个常量，因为他可以作为定义数组时，表述数组的个数。且非模板参数只能为整型，不能为浮点型常量和string类型的常量。

模板的特化

在上期我们学习优先级队列时我们学习到了仿函数的概念，我们可以用仿函数比较两个对象的大小，当两个对象为内置类型时显然是可以比较的，为自定义类型时只要我们重载了对应的比较运算符也是可以比较的，但是有一种特殊的情况，就是我们只给了两个自定义类型的指针，我们用仿函数进行比较时，本来是要比较两个自定义类型指针所指向的对象，但是确无意间成为了两个指针大小的比较，这种比较是毫无意义的，所以此时我们就可以用到特化。

观看下列代码。

class Data
{
public:
	Data(int a, int b)
	{
		_num1 = a;
		_num2 = b;
	}
	bool operator>(const Data& d)
	{
		return _num1 > d._num1 && _num2 > d._num2;
	}

private:
	int _num1;
	double _num2;
};

template<class T >
struct Greater 
{
	bool operator()(const T& a,const T&b) const
	{
		return a > b;
	}
};

//特化
template<>
struct Greater<Data*>
{
	bool operator()( Data* a, Data* b)const
	{
		return *a > *b;
	}
};



int main()
{
	Data* d1 = new Data(10,20.1);
	Data* d2 = new Data(20,30.1);
	Greater<Data*> greater;
	cout << greater(d1, d2) << endl;
	return 0;

}

运行结果如下。

由运行结果可知，符合预期。

特化又分为全特化和偏特化。

全特化

全特化，顾名思义就是每个模板参数都指定了类型。

代码如下。

//全特化
template<>
class Fun<int,int> {
public:
	void fun()
	{
		cout << "Fun<int,int>，全特化" << endl;
	}

};

偏特化

偏特化，顾名思义就是只有部分模板参数指定了类型。

代码如下。

template<class T1>
class Fun<T1,int>
{
public:
	void fun()
	{
		cout << "Fun<T1,int>，偏特化" << endl;
	}
};

偏特化需要注意的是，在指定模板参数类型的时候，与参数缺省一样，必须从右往左依次进行缺省。

整体测试代码。

template<class T1,class T2>
class Fun {
public:
	void fun()
	{
		cout << "Fun<T1 ,T2>,啥也不是" << endl;
	}

};

//全特化
template<>
class Fun<int,int> {
public:
	void fun()
	{
		cout << "Fun<int,int>，全特化" << endl;
	}

};

template<class T1>
class Fun<T1,int>
{
public:
	void fun()
	{
		cout << "Fun<T1 ,int>，偏特化" << endl;
	}
};


int main()
{
	Fun<char,char> fun1;
	fun1.fun();
	
	Fun<char,int> fun2;
	fun2.fun();

	Fun<int, int> fun3;
	fun3.fun();
	return 0;
}

运行结果如下。

运行结果符合预期。

模板的分离编译

我们先提出一个问题？模板支持分离编译吗？我们先不进行解答，一起通过代码来测试一下。三个文件。

demo.h

namespace yjd
{
	template<class T>
	class A
	{
	public:
		void fun();
	};

}

demo.cpp

#include"demo.h"
#include<iostream>
using namespace std;



template<class T>
void yjd::A<T>::fun()
{
	cout << "fun()" << endl;
}

test.cpp

int main()
{
	yjd::A<int> a;
	a.fun();

	return 0;
}

运行结果如下。

编译器报出了LNK的错误这表示实在编译过程中链接这一步骤出了错，为什么会出错呢？

在之前我们学习编译器编译的过程时，我们知道编译的阶段分为四步。预处理，编译，汇编，链接。链接是编译的最后一步，链接其实就是当我们运用了某些函数时，会去指定的源文件或者汇编之后的.o文件里去找对应的函数的实现。既然链接这一步出了错，那么肯定是没有找到指定的函数定义。

在预处理阶段，编译器会展开头文件，去掉注释，进行宏替换。在编译阶段，编译器会检查代码的语法错误，在确认没有语法错误之后，会将c++代码转为汇编代码。在汇编阶段，会将汇编代码转为机器可识别的二进制代码，在链接阶段，会去链接动静态库找到对应函数的实现。

在整个步骤中，我们需要注意的就是汇编阶段。在执行a.fun()这个函数时，会转换为call(?)的指令，？为库中函数定义的地址，也可以是我们自己编写的源文件中对应的函数地址，这个地址是要在链接阶段去查找的。

在预处理阶段将头文件展开，然后进行编译，此时会将头文件中的模板进行实例化，一直到最后的链接阶段，只有头文件中的模板是进行了实例化的，当链接时，链接源文件时，源文件中的模板并没有实例化，所以找不到对应的fun()函数的地址，所以就会报链接错误。

如何解决这些问题呢？两个方法，一个实在定义的时候显示实例化，一个直接是将声明和定义放在一个文件里。

显示实例化

代码如下。demo.cpp


template<>
void  yjd::A<int>::fun()
{
	cout << "fun()" << endl;
}

运行结果如下。

运行结果符合预期。

声明定义放在一起

代码如下。demo.h

namespace yjd
{
	template<class T>
	class A
	{
	public:
		void fun()
		{
			cout << "fun()" << endl;
		}
	};

}

运行结果如下。

运行结果符合预期。

模板总结

优点

1.模板支持复用，一份代码可以实例化为各种类型。

2.增加了代码的灵活性。

缺点

1.在编译阶段，会产生大量的代码，一份代码会变成多分代码。有人会说，本来就要写这么多代码，确实是这样，但是单纯从大小而言，一份代码变成了多份代码确实是膨胀。同时编译时间变长，因为实例化是要浪费时间的，当时实例化多个类型时，时间自然会变长。

2.一旦报错，会报一大堆错误，而且不容易定位错误。

本期内容到此结束^_^