初识C++ · 模板进阶

目录

前言：

1 非类型模板参数

2 按需实例化

3 模板特化

4 模板的分离编译

前言：

前面模板我们会了简单的使用，这里带来模板的进阶，当然，也就那么几个知识点，并不太难。

1 非类型模板参数

先来看这样一段代码：

#define N 100
template<class T>
class Arr
{
public:

private:
	T _arr[N];
};

如果我们想要创建一个整型数组，可以使用这个类来创建，但是我们面临一个问题就是该数组的大小是固定的，我们想要简单控制这个数组的大小，可以使用宏，但是还是不够简便，因为宏不方便调试不说，实际上也是指定了大小，那么我们想要使用一个类，来创建不同大小的数组该怎么办？
这里使用到的就是非类型模板参数，如下：

template<class T,size_t N = 100>
class Arr
{
public:

private:
	T _arr[N];
};
int main()
{
	Arr<int,10> a1;
	Arr<int,1000> a2;
	Arr<int> a3;
	return 0;
}

这里就得到了我们想要的不同大小的数组，那么，来个问题，编译器一共实现了几个类？

答：编译器这里一共实现了3个类，编译器根据模板参数的不同，就实现了不同的类。这里的非类型模板参数，我们可以理解为常量，如这里的N，但是在C++11只支持整型，连浮点数都不可以，只支持整型，比如int size_t char一类的，在C++ 20之后才可以支持其他类型。

这里涉及到了数组，那么引入一个小的知识点就是对于越界来说，array 数组 vector有着不同的反应：

int main()
{
	int arr[10];
	arr[10];
	arr[15] = 1;
	return 0;
}

对于普通数组来说，普通的越界只读来说，比如arr[10]是检查不来错误的，越界写来说，也是很多抽查不出来的，比如这段代码在vs2019上就不会报错。

那么对于array来说：

int main()
{
	std::array<int,10> array;
	array[10];
	return 0;
}

任何读写越界都会报错，但是呢，这是c++委员会后面加的，但是挺鸡肋的，因为我们有vector。

int main()
{
	std::vector<int> v;
	v.reserve(1000);
	return 0;
}

vector对越界的读写都会报错，这是一方面，其次是array是静态的数组，也就是大小定了，并且，它所属的空间是栈，栈的空间相对堆来说就会小很多，所以面临开大空间的时候，array就不吃香了，vector没事，因为可以动态开辟。

2 按需实例化

先看这样一段代码：

template<class T,size_t N = 100>
class Arr
{
public:
	T& operator[](size_t i)
	{
		size(1);
		return _arr[i];
	}
	size_t size()
	{
		return _size;
	}
	bool empty()
	{
		return _size == 0;
	}
private:
	T _arr[N];
	size_t _size = 0;
};
int main()
{
	Arr<int> a1;
	a1.empty();

	return 0;
}

从语法层面来说，size()函数没有参数，那么我们传参数的话就会导致报错对吧？可是，实际上：

代码是没有报错，也就是说size()传参数是对的吗？

不，这是因为按需实例化。

在主函数里面，我们实例化了a1,并且调用了empty函数，但是我们没有调用operator[]函数，那么编译器就不会实例化operator函数，因为我们没有调用，既然没有实例化size函数，那么传什么都不会报错，这就是按需实例化。

再细节一点来说，编译器会根据模板实例化->实例化一个半成品模板->再实例化为一个具体的类或者函数->最后才是语法编译,所以没有语法报错。

3 模板特化

特化我们可以理解为特殊化处理，比如我们在栈和队列的时候实现的日期类的比较，就可以不用仿函数来实现比较，可以用特化来处理。

日期类：

class Date
{
public:
	friend ostream& operator<<(ostream& _cout, const Date& d);

	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);
	}
private:
	size_t _year;	
	size_t _month;
	size_t _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}

template<class T>
bool less(const T& a,const T& b)
{
	return a < b;
}
int main()
{
	Date d1(2024, 5, 20);
	Date d2(2024, 5, 21);
	cout << (d1 < d2) << endl;
	return 0;
}

比如，使用函数模板，对于重载了比较符号的比较是没问题的，如果使用指针就会报错，因为默认是按照指针比较的，这里就可以使用特化：

int main()
{
	Date* p1 = new Date(2020, 1, 1);
	Date* p2 = new Date(2020, 1, 2);
	cout << (p1 < p2) << endl;
	return 0;
}

这段代码是有问题的是不用多说的，下面是解决方案：

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

template<>
bool Less<Date*>(Date* p1,Date* p2)
{
	return *p1 < *p2;
}

int main()
{
	Date d1(2022, 7, 7);
	Date d2(2022, 7, 8);
	Date* p1 = &d1;
	Date* p2 = &d2;
	cout << Less(p1, p2) << endl;
	return 0;
}

这里的语法就比较怪了，现在使用的是函数模板，有点像函数重载的感觉，当然，我们也可以直接重载一个出来：

bool Less(Date* left, Date* right)
{
	return *left < *right;
}

那么，调用是怎么调用的呢？

这里就和半成品，成品是一个道理，重载的函数就相当于成品，特化的函数快成品了，模板就是个半成品，调用的顺序也就说的通了。

以上是函数模板的特化，看起来就像是函数重载，接着是类中的模板特化：

//普通
template<class T1,class T2>
class Data
{
public:
	Data() { cout << "Data<T1, T2>" << endl; }

};

//全特化
template<>
class Data<int, char>
{
public:
	Data() { cout << "Data<int, char>" << endl; }
};

//偏特化
template<class T1>
class Data<T1, char>
{
public:
	Data() { cout << "Data<T1, char>" << endl; }
};

使用方式和函数模板其实是差不多的，在特化这里分为全特化和偏特化，特化也不是什么特别的东西，其实就是对参数的进一步限制而已。

4 模板的分离编译

使用模板的时候，定义和声明最好放在一个文件，.h和.c文件分离会报错的，这里简单举个例子：

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

在调用这个函数的时候就会报错，只需要想清楚一个简单的问题就可以了，两个T是不是一样的T，能否用.h文件里面的T去平替.cpp里面的T，当然是不可以的，所以这里，就会报错，报的是链接错误，.h文件编译成功后，.cpp里面的文件是没有编译好的，因为T不知道是什么类型，调用的时候就会报错。

在链接阶段，编译器按照修饰好之后的函数名在符号表里面寻找函数，不知道类型就没有生成修饰好的函数名，那么就会报如下类似的错：

感谢阅读！