C++系列-模版

2024-09-30 07:18:07

????个人主页：羽晨同学

????个人格言:“成为自己未来的主人~”

非类型模版参数

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

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

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

int main()
{
	Stack<int> st1;     //10
	Stack<int,100> st1;     //100
	Stack<int,1000> st1;     //1000

	return 0;
}

首先，我们想在定义的类中实现这样的功能，很明显，这是不可能的，但是有了非类型模板参数之后，这就成为了可能，那应该怎么做呢？

#define _CRT_SECURE_NO_WARNINGS 
#include<stack>
#include<iostream>
using namespace std;
template<class T,size_t N=10>
class Stack
{
public:
	void func()
	{
		N++;
	}
private:
	int _a[N];
	int _top;
};
int main()
{
	Stack<int> st1;     //10
	Stack<int,100> st1;     //100
	Stack<int,1000> st1;     //1000

	return 0;
}

你看，这样的话，我们就可以通过改变传递的参数来改变N的值

需要注意的是，C++20之前，浮点数是不允许作为非类型模版参数的

但是在C++20当中，它是可以的。

template<double X,int*ptr>
class A
{};

但是类对象和字符串是不允许的

array

array相较于vector而言，其实它具备更严格的越界检查。

#include<array>
#include<vector>
int main()
{
	//严格越界检查
	array<int, 10> aa1;
	cout << sizeof(aa1) << endl;
	aa1[10];
	aa1[14] = 1;

	array不如用vector。鸡肋的设计
	//vector<int> v1(10, 1);
	//v1[14];
	//cout << sizeof(v1) << endl;

	return 0;
}

这里其实就体现出来了一部分array的特征

	int aa2[10];
	aa2[13];

你看，在这个代码中，就不会进行报错的，这是因为在静态变量中，执行的是随机抽样检测，所以后面是不会报错的。

我们再来看一下vector的越界部分，在vector当中，同样也会进行严格的越界检查，溢出也会进行报错。

但是，array所花费的内存比vector更大：

所以说，其实array是完全鸡肋的设计

你看，下面的这段代码是我们所实现的一个打印int的打印函数

void PrintVector(const vector<int>& v)
{
	vector<int>::const_iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

在这个代码中，我们所能打印的只是int类型的变量，但是我们想要打印其他的类型，我们应该怎么做呢，最简单的，引入模版的概念。

我们来看下面的这一段代码：

template<class T>
void PrintVector(const vector<T>& v)
{
	vector<T>::const_iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << endl;
		++it;
	}
	cout << endl;
}
int main()
{
	vector<double> v2{1.1, 2.2, 1.3, 6.6, 7.7, 8.8};
	PrintVector(v2);

	return 0;
}

但是很抱歉的是，这样代码是会进行报错的，这是为什么呢？

这是因为类模板在没有实例化之前，是不会去里面查具体的东西的，这就导致了编译器不知道这个是vector<T>::const_iterator it类型还是变量。

而在这个时候，我们就会在代码的前面加一个typename来告诉编译器这是一个类型

template<class T>
void PrintVector(const vector<T>& v)
{
	typename vector<T>::const_iterator it = v.begin();
	while (it != v.end())
	{
		cout << *it << endl;
		++it;
	}
	cout << endl;
}
int main()
{
	vector<double> v2{1.1, 2.2, 1.3, 6.6, 7.7, 8.8};
	PrintVector(v2);

	return 0;
}

特化

接下来，让我们看一下要实现的比较日期类的函数

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(const T& left, const T& right)
//{
//	return left < right;
//}
bool Less(Date* left, Date* right)
{
	return *left < *right;
}

你看，在这段代码中，我们实现了一个小于的比较，这里能够实现是因为我们对这个<进行的函数重载。

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

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, 6, 8);
	cout << Less(d1, d2) << endl;
	Date* p1 = &d1;
	Date* p2 = &d2;
	cout << Less(p1, p2) << endl;

	return 0;
}

在这个代码当中：

我们可以看到，第三个答案是错误的。因为这个是地址的比较

此时，我们就需要对模版进行特化，即：在原模板基础上，针对特殊类型进行特殊化的处理方式。模板特化中，分为类模板特化和函数模板特化

//类模板
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 << "class Data<int,char>-> 全特化 " << endl;
	}
};
template<class T1>
class Data<T1, int>
{
public:
	Data()
	{
		cout << "class 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;
		//T1* p1;
	}
};

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

好了，本次的文章就到这里了，我们下次再见。

码农公寓

非类型模版参数

array

特化

限定模版类型

相关文章