c++初阶-------模板

作者前言

🎂 ✨✨✨✨✨✨🍧🍧🍧🍧🍧🍧🍧🎂
​🎂 作者介绍： 🎂🎂
🎂 🎉🎉🎉🎉🎉🎉🎉 🎂
🎂作者id：老秦包你会， 🎂
简单介绍：🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂
喜欢学习C语言、C++和python等编程语言，是一位爱分享的博主，有兴趣的小可爱可以来互讨 🎂🎂🎂🎂🎂🎂🎂🎂
🎂个人主页::小小页面🎂
🎂gitee页面:秦大大🎂
🎂🎂🎂🎂🎂🎂🎂🎂
🎂 一个爱分享的小博主 欢迎小可爱们前来借鉴🎂

---

类型分类

模板参数分类类型形参与非类型形参。
类型形参即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。
类型形参，这里就不过多介绍了

非类型模板

这个参数只能是整形常量

#include<iostream>
#include<vector>
#define N 10;
using namespace std;
namespace bit
{
	template<class T, size_t n>//之前的只能传类型,非类型只能传整形
	class AA {

	public:
		AA()
		{
			num = n;
		}
		void prit()
		{
			cout << num << endl;
		}
	private:
		size_t num;
	};
}
int main()

{
	bit::AA<int,10> a;
	a.prit();
	return 0;
}

类型模板的只能传类型，而非类型模板可以传类型也可以传整形变量

array

这个容器就是非类型模板的

可以看出

模板特化

在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化

函数模板特化

函数模板的特化步骤：

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

namespace bit
{
	//函数模板
	template<class T>
	bool less(const T&  a, const T& b)
	{

		return a < b;
	}

	//函数特化
	template<>
	bool less<int>(const int& a, const int& b)
	{
		return a < b;
	}
}
int main()

{
	char  a = 20;
	char b = 10;
	cout << bit::less(a, b);
	return 0;
}

如果类型是特化后的类型，就走函数特化模板，否则就做走函数模板,
注意：函数模板必须有,特化后的函数,参数类型一定要对应函数模板的函数类型,否则会报错

类模板特化

同理,类模板特化的条件和函数特化的条件都是一样的, 只是类模板特化分为两类特化
一种是全参数特化,一种是部位参数特化

全特化

namespace bit
{
	//类模板
	template<class T, class Y>
	class AA
	{
	public:

		AA(const T& a, const Y& b)
		{
			num1 = a;
			num1 = b;
		}

	private:
		T num1;
		Y num2;
	};
	template<>
	class AA<int, int>
	{
	public:
		AA(const int& a, const int& b)
		{
			num1 = a;
			num1 = b;
			cout << " 我使用了全特化" << endl;
		}

	private:
		int num1;
		int  num2;
	};

}

int main()

{
	bit::AA<int, int> funtion1(2, 2);
	bit::AA<int, char> funtion2(2, 2);
	return 0;
}

全特化,把所有的类模板参数都特化出类型, 然后使用

偏特化

偏特化有两个不一样的形式
一种是部位特化, 一种是类型的限定

部分特化

namespace bit
{
	//类模板
	template<class T, class Y>
	class AA
	{
	public:

		AA( T a,  Y b)
		{
			num1 = a;
			num2 = b;
			cout << " 我使用了类模板" << endl;
		}

	private:
		T num1;
		Y num2;
	};
	template<class Y>
	class AA<int, Y> //规定类型必须是指针类型
	{
		typedef int  type;
	public:
		AA( type a,  Y b)
		{
			num1 = a;
			num2 = b;
			cout << " 我使用了全特化" << endl;
		}

	private:
		type  num1;
		Y  num2;
	};

}

int main()

{
	int a = 10;
	int b = 20;
	char c = 'a';
	bit::AA<int*, int*> funtion1(&a, &b);
	bit::AA<int, char*> funtion2(a, &c);
	return 0;
}

这种特化,只是特化一部分,一部分留下,可以更加灵活的使用

参数限制

偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

namespace bit
{
	//类模板
	template<class T, class Y>
	class AA
	{
	public:

		AA( T a,  Y b)
		{
			num1 = a;
			num2 = b;
		}

	private:
		T num1;
		Y num2;
	};
	template<class T, class Y>
	class AA<T*, Y*> //规定类型必须是指针类型
	{
	public:
		AA( T* a,  Y* b)
		{
			num1 = a;
			num2 = b;
			cout << " 我使用了全特化" << endl;
		}

	private:
		const T* num1;
		const Y*  num2;
	};

}

int main()

{
	int a = 10;
	int b = 20;
	char c = 'a';
	bit::AA<int*, int*> funtion1(&a, &b);
	bit::AA<int, char*> funtion2(a, &c);

	return 0;
}

还有一种写法,这种写法有许多坑,

namespace bit
{
	//类模板
	template<class T, class Y>
	class AA
	{
	public:

		AA( const T& a,  const Y& b)
		{
			num1 = a;
			num2 = b;
			cout << " 我使用了类模板" << endl;
		}

	private:
		T num1;
		Y num2;
	};
	template<class T, class Y>
	class AA<T*, Y*> //规定类型必须是指针类型
	{
	public:
		AA( const T* const& a,  const T* const &  b)
		{
			num1 = a;
			num2 = b;
			cout << " 我使用了全特化" << endl;
		}

	private:
		const T*  num1;
		const Y*  num2;
	};

}

我们知道,传参会产生临时变量, 临时变量具有常性, 如果要引用, 需要const 修饰&

但是还是不建议使用,因为地址传递,引用用处不大

模板分离编译

一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。

假如有以下场景，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义：

test.h

#include<iostream>
#include<algorithm>
using namespace std;
namespace bit
{
	int Sub(int a, int b);

	template<class T>
	T Add(T a, T b);
}

test.cpp

namespace bit {
	template<class T>
	T Add(T a, T b)
	{
		return a + b;
	}

	int Sub(int a, int b)
	{
		return a - b;
	}
}

stack.cpp

#include"test.h"
int main()
{
	bit::Add<int>(1,2);
	 cout << bit::Sub(3, 9);
	return 0;
}

当我们运行的时候,报错

原理:

函数在生成可执行程序的时候,sub函数的类型是确定的,而Add的函数里面的参数类型是不确定的,所以不会生成对应的指令

如果想要编译成功,就必须要清楚Add参数的类型,所以了一个方法**:显示实例化**
如图:

但是这个方法很局限,如果传入的参数是其他类型,又必须写一个对应显示实例化,所以说明了一个问题
模板函数声明和定义不要分离,就不用编译链接的时候去寻找了,同理类的定义和声明不能分离,尽量写在头文件里面