c++中的模板进阶

目录

非类型的模板参数

模板参数的定义：

非类型的模板参数定义：

验证非类型的模板参数是个常量：

类模板的参数可以是缺省值：

模板的特化

函数模板的特化

类模板的特化

模板的分离定义

分离定义：

解决方法：

模板的优点和缺点

优点

缺点

---

非类型的模板参数

模板参数的定义：

模板参数分为类型模板参数和非类型的模板参数

类型模板参数：class或typename后面接的参数类型名称

非类型的模板参数：用一个常量来作为模板的参数(只能传常量)，在模板中可将这个参数当做常量来使用

非类型的模板参数定义：

template<typename T,size_t N>	//size_t N为非类型的模板参数
class A
{
public:
	T _a = N;//N是一个常数，不可以修改
};

注： 非类型的模板参数只能是整数类型，不能是浮点型等其他类型

验证非类型的模板参数是个常量：

#include<iostream>
using namespace std;
template<typename T,size_t N>	//size_t N为非类型的模板参数
class A
{
public:
	T _a = N;
	void f()
	{
		N = 2;    //N是一个常数，不可以修改
	}
};
int main()
{
	return 0;
}

当我们进行编译的时候发现编译通过了

这是为什么呢？

这是因为类模板中的成员函数在没有调用的时候不会实例化出对象

#include<iostream>
using namespace std;

template<typename T, size_t N>	//size_t N为非类型的模板参数
class A
{
public:
	T _a = N;
	void f()
	{
		N = 2;    //N是一个常数，不可以修改
	}
};
int main()
{
	A<int, 10> a;	//实例化出类对象
	a.f();	//用这个对象调用函数
	return 0;
}

当我们用创建出的对象调用f()的时候，编译器就会报错

类模板的参数可以是缺省值：

#include<iostream>
using namespace std;

template<typename T = int, size_t N = 10>	//size_t N为非类型的模板参数
class A
{
public:
	T _a = N;//N是一个常数，不可以修改
};
int main()
{
	A<> a;	//这个时候我们不写，T默认是int，N默认是10
	return 0;
}

模板的特化

概念：有时候编译器无法正确的处理我们想要的逻辑，这个时候需要进行模板的特化，通过特化的模板来正确处理我们想要的逻辑

函数模板的特化

假如我们想将p1,p2和p3,p4的字符串进行比较

#include<iostream>
using namespace std;

template<typename T>
bool isequal(T a, T b)
{
	return a == b;
}

int main()
{
	char p1[] = "hello";
	char p2[] = "hello";
	const char* p3 = "hello";
	const char* p4 = "hello";
	cout << isequal(p1, p2) << endl;
	cout << isequal(p3, p4) << endl;
	return 0;
}

我们发现p1和p2不相等，p3和p4想等，这是因为模板默认进行了地址的比较，p1和p2的地址不同，p3和p4存的字符串在常量区，所以指向同一个地址，所以p3和p4相等

这个时候函数模板就不能正确的表示出我们想要的逻辑，我们需要进行函数模板的特化

函数模板的特化步骤：
1. 必须要先有一个基础的函数模板
2. 关键字template后面接一对空的尖括号<>
3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
4. 函数形参表: 必须要和函数模板的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误

#include<iostream>
using namespace std;

template<typename T>
bool isequal(T a, T b)
{
	return a == b;
}
template<>
bool isequal<char*>(char* a, char* b)
{
	if (strcmp(a, b) == 0)
	{
		return 1;
	}
	return 0;
}
int main()
{
	char p1[] = "hello";
	char p2[] = "hello";
	const char* p3 = "hello";
	const char* p4 = "hello";
	cout << isequal(p1, p2) << endl;
	cout << isequal(p3, p4) << endl;
	return 0;
}

这个时候使用的就是特化后的函数， 所以结果为1

注:除了使用函数模板特化，我们还可以显示给出函数的类型，这样调用时候就不会调用函数模板

类模板的特化

全特化

#include<iostream>
using namespace std;

template<typename T1, typename T2>
class A
{
public:
	A() { cout << "(T1,T2)" << endl; }
private:
	T1 _a;
	T2 _b;
};

template<>
class A<int,char>	//将类模板后面<>中填写要特化的类型
{
public:
	A() { cout << "(int,char)" << endl; }
private:
	int _a;	//参数需要修改成自己想要的类型
	char _b;
};

int main()
{
	A<int, int> a1;
	A<int, char> a2;
	return 0;
}

这个时候a1使用的就是类模板实例化出的对象，a2使用的是特化后的类模板对象

偏特化（半特化）

偏特化(半特化)顾名思义就是将模板参数列表中的一部分参数特化

#include<iostream>
using namespace std;

template<typename T1, typename T2>
class A
{
public:
	A() { cout << "(T1,T2)" << endl; }
private:
	T1 _a;
	T2 _b;
};

template<typename T1>	//需要写出一部分类型模板参数类型
class A<T1,char>	//将类模板后面<>中填写要特化的类型
{
public:
	A() { cout << "(T,char)" << endl; }
private:
	T1 _a;	//没有特化的地方继续使用模板参数类型
	char _b;	//参数需要修改成自己想要的类型
};

int main()
{
	A<int, int> a1;
	A<char, char> a2;
	return 0;
}

偏特化的一种

template<class T1, class T2>
class A
{
public:
};

template<class T1, class T2>
class A<T1*, T2*>	//指针
{
public:
	A()
	{
		cout << "T1* T2*" << endl;
	}
};

template<class T1, class T2>
class A<T1&, T2&>	//引用
{
public:
	A()
	{
		cout << "T1* T2*" << endl;
	}
};

template<class T1, class T2>
class A<T1&, T2*>	//一半指针一半引用
{
public:
	A()
	{
		cout << "T1* T2*" << endl;
	}
};

注：函数特化可以直接创建一个我们想要参数列表的函数，但是类模板特化必须遵循规范的特化原则

模板的分离定义

分离定义：

声明在.cpp文件中，定义在另一个.cpp文件中

 当我们运行的时候，程序就会报错

发生的是链接错误

为什么？

1、当main.cpp使用了add之后，因为引用了头文件，在预处理阶段头文件会展开，里面有函数模板的声明，编译器会默认认为有这个函数

2、编译器创建了一个符号，但是这个符号没有地址，这个时候就要链接器去寻找，链接器默认在其他文件中去寻找（只有声明没有定义，编译器会在链接阶段去寻找）

3、因为模板必须在使用的时候才会进行实例化，所以链接器找不到函数的地址，这个时候就会出现链接错误（main.cpp（test.h）实例化了函数，test,cpp没有进行实例化）

解决方法：

1、在test.cpp中定义的时候显示实例化(函数模板的特化)

显示实例化出的函数模板拥有地址，在链接时候可以找到

注：不推荐这样使用，否则会导致，使用一个类型，就需要实例化一份函数模板 

2、不分离编译，将分离和定义放在一个文件中（推荐使用）

模板的优点和缺点

优点

1、提供了泛型编程，提高了代码的复用率

2、增加了代码灵活性

缺点

1、会导致代码膨胀，影响编译效率

2、出错时候不容易查找，可能会出现一堆莫名其妙的错误

(建议：先关注最上面的错误信息，下面错误信息可能是因为上面错误信息引发的连锁反应)