【C++】模版进阶

最新推荐文章于 2024-09-04 11:24:08 发布

1e-12

最新推荐文章于 2024-09-04 11:24:08 发布

阅读量218

点赞数 1

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

本文链接：https://blog.csdn.net/m0_70811813/article/details/134088255

版权

C++ 专栏收录该内容

24 篇文章 2 订阅

订阅专栏

我们在之前的博客中讲述过模版的使用：【C++】模版初阶，但这只是模版最基本的使用，下面再深入模版，看看还有另外什么用法：

一、非类型模板参数

我们知道模版可以传递类型参数，除此之外还可以传递非类型参数：

例如：

#define N 10
template<class T>
struct Static_sequence
{
	T a[N];
};

上诉代码可以建立一个任意类型的静态顺序表，但是N值是确定的，我们如何建立我们想要的大小的静态顺序表呢？

再来看看下面的代码：

template<class T, size_t N = 10>
struct Static_sequence
{
	T a[N];
};

我们在模版上再加一个非类型参数size_t N，这个参数可以传入我们需要的值来初始化静态顺序表：

int main()
{
	Static_sequence<int, 20> q;
	return 0;
}

在上述代码中我们传入了一个20，可以看到开辟了一个20个元素的静态数组：

对于该非类型模板参数，我们只能设定整型家族（int/char/short/...），对于其他类型是不支持的，例如：

对于设定的非类型模板参数，系统是将其作为常量看待的，所以它可以初始化数组元素个数

例如我们想要对传入的值做修改：

编译器是不能通过的

二、模板的特化

2.1 什么是模版的特化

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

class Date
{
	friend ostream& operator<<(ostream& out, const Date& d);
public:
	Date(int year, int month, int day)//构造函数
	{

		if (month < 1 || month>12 || (day<1 || day>GetMonthDay(year, month)))//判断日期是否合法
		{
			cout << "Illegal date!" << endl;
		}
		else
		{
			_year = year;
			_month = month;
			_day = day;
		}
	}

	int GetMonthDay(int year, int month) const//获取year年month月的天数
	{
		int MonthDay[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 };//用数组来依次存储平年1到12月的天数
		if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))//判断是否为闰年的2月
		{
			return 29;
		}
		return MonthDay[month - 1];
	}

	//运算符重载
	bool operator==(const Date& d) const//判断日期是否相同
	{
		return 	_year == d._year && _month == d._month && _day == d._day;
	}
	bool operator!=(const Date& d) const//判断日期是否不相同
	{
		return 	!(*this == d);
	}
	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 (*this < d) || (*this == d);
	}
	bool operator>(const Date& d) const//判断当前日期是否在传入日期之后
	{
		return !(*this <= d);
	}
	bool operator>=(const Date& d) const//判断当前日期是否在传入日期之后或相同
	{
		return !(*this < d);
	}

private:
	int _year;
	int _month;
	int _day;
};

ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "/" << d._month << "/" << d._day << endl;
	return out;
}

// 函数模板 -- 参数匹配
template<class T>
bool Less(const T x, const T y)
{
	return x < y;
}

int main()
{
	std::cout << Less(Date(2022, 9, 27), Date(2022, 9, 25)) << endl;//Date类型比较
	std::cout << Less(new Date(2022, 10, 27), new Date(2022, 10, 25)) << endl;//Date指针类型比较
	return 0;
}

比较结果：

因为我们在Date类中运算符重载了<的比较方法，所以对于Date类可以直接调用该方法进行比较，但是对于Date*类型，模版找不到比较方法，只能默认比较地址空间的大小，导致了结果的错误

为了解决该问题，我们引入模版的特化：

2.2 函数模版的特化

函数模板的特化步骤：

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

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

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

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

下面我们对上面的模版函数进行指针的特例化：

// 函数模板 -- 参数匹配
template<class T>
bool Less(const T x, const T y)
{
	return x < y;
}

// 对Less函数模板进行特化
template<>
bool Less<Date*>(Date* x, Date* y)
{
	return *x < *y;
}

这下结果就正确了：

该种实现简单明了，代码的可读性高，容易书写，因为对于一些参数类型复杂的函数模板，特化时要特别给出，因此函数模板不建议特化，平时我们使用实例化解决即可

2.3 类模版的特化

2.3.1 全特化

我们来设置一个类模版：

// 类模板 -- 参数匹配
template<class T>
class Less
{
	bool operator()(T& x, T& y)
	{
		return x < y;
	}
};

//全特化
template<>
class Less<Date*>
{
	bool operator()(Date* x, Date* y)
	{
		return *x < *y;
	}
};

全特化即是将模板参数列表中所有的参数都确定化，在上述代码中我们将T类型指明为Date*类型，这种将模板参数列表全部指明为一个确定的类型的操作就是全特化

2.3.2 偏特化

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

如下：我们将类模板参数进一步限制为指针类型，但具体为上面类型的指针并未说明：

// 类模板 -- 参数匹配
template<class T>
class Less
{
	bool operator()(T& x, T& y)
	{
		return x < y;
	}
};

//偏特化，对模版参数进一步进行条件限制
template<class T>
class Less<T*>
{
	bool operator()(T* x, T* y)
	{
		return *x < *y;
	}
};

// 类模板 -- 参数匹配
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;
};
//两个参数偏特化为引用类型
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;
};
//一个参数偏特化为引用类型,一个参数偏特化为指针类型
template <typename T1, typename T2>
class Data <T1&, T2*>
{
public:
	Data(const T1& d1, const T2* d2)//参数偏特化为引用类型时一定要初始化
		: _d1(d1)
	{
		cout << "Data<T1&, T2*>" << endl;
	}

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

注意：参数偏特化为引用类型时一定要初始化（使用初始化列表和缺省参数都可）

偏特化有还有另一种表现方式：当模版参数有多个时，部分特化一部分参数

例如：

// 类模板 -- 参数匹配
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;
};

三、模板的分离编译

我们现在使用声明和实现分离的编译的方法来实现一个函数模版（将类模版的声明放在Func.h头文件中，实现代码放在Func.cpp中）：

Func.h：

#pragma once

template<class T>
T Add(const T& left, const T& right);

Func.cpp：

#include"Func.h"

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

test.cpp：

#include"Func.h"
int main()
{
	int x = 5, y = 10;
	Add<int>(x, y);
	return 0;
}

我们来编译一下：

咦，怎么编译通过不了？还报了一个链接错误？

下面我们来仔细分析一下：

一份C/C++程序要运行，一般要经历一下步骤:预处理—-->编译--->汇编―—-->链接，不熟悉的同学可以看到这里：C语言程序环境_c语言程序运行环境

但是在每个cpp文件经过预处理、编译、汇编，但没有进入链接阶段之前，都是单独被编译器所编译的。这样会导致由于模版参数没有实例化，Func.cpp文件在形成汇编指令时，并没有为Add函数开辟函数栈帧（因为没有参数的实例化，系统压根就不知道要开辟多大的空间来给Add函数用），但是由于头文件的展开，使汇编会形成call指令（这时的call指令并没有填上Add函数所在的栈帧地址），所以最终形成的obj文件进入链接时，会发现Func.cpp形成的obj文件中并没有上Add函数所在的栈帧地址，此时call指令中没有实际地址导致指令无法正常执行，最后报错