C++：模板（初级）

hello，各位小伙伴，本篇文章跟大家一起学习《C++：模板（初级）》，感谢大家对我上一篇的支持，如有什么问题，还请多多指教 ！

如果本篇文章对你有帮助，还请各位点点赞！！！

话不多说，开始进入正题

文章目录

• • :rocket: 认识模板
  • • 1.:airplane: 模板的定义和作用
    • :rocket: 模板
    • • 1.:airplane: 函数模板
      • 2.:airplane:函数模板的实例化
      • 3.:airplane:模板参数的匹配原则
      • :rocket: 类模板
      • • 1.:airplane:类模板的定义格式
        • 2.:airplane:类模板的实例化

          🚀 认识模板

          1.✈️ 模板的定义和作用

          我们知道再制造月饼或其它食物时，会用到模具

          

          可以用来快速制作食品样子，即使食品的材料不一样，但是造出来的样子都是大差不差的。

          同理，C++中的模板也是用来制造的，我们来看下述代码：

          void Swap(int& left, int& right)
          {
          	int temp = left;
          	left = right;
          	right = temp;
          }
          void Swap(double& left, double& right)
          {
          	double temp = left;
          	left = right;
          	right = temp;
          }
          void Swap(char& left, char& right)
          {
          	char temp = left;
          	left = right;
          	right = temp;
          }
          

          以上代码都是实现了交换的功能，利用了函数重载，但是要交换不同的类型，就要再写一次函数，那实在是太麻烦了，所以引入了模板。以交换功能为主，实现多种类型的交换，也就是：“交换功能”为模板，“交换类型”为材料，我们来提供材料，编译器负责用模板制造。

          🚀 模板

          1.✈️ 函数模板

          🔥函数模板的概念：

          函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

          🔥模板格式：

          template
          返回值类型 函数名(参数列表){}
          

          注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

          举个例子：

          template 
          void Swap(T& x, T& y)
          {
          	T tmp;
          	tmp = x;
          	x = y;
          	y = tmp;
          }
          

          🔥模板的原理：

          编译器是否是调用了该模板函数来实现交换功能呢？实际上并不是，就好像你用月饼摸具来制造月饼，但是我们吃的还是月饼，也就是说，模板函数只是帮我们制造函数，并不会帮我们实现功能。

          在实际调用模板函数时，编译器会帮我们制造该类型的函数，然后再调用被制造的函数。

          那编译器怎么知道我们要那种呢？这就和函数重载有点像，编译器会通过对实参的推演，确定类型，产生一份专门属于该类型的代码。如：

          template 
          void Swap(T& x, T& y)
          {
          	T tmp;
          	tmp = x;
          	x = y;
          	y = tmp;
          }
          int main()
          {
          	int a = 10;
          	int b = 20;
          	cout 
          	T1 tmp;
          	tmp = x;
          	x = y;
          	y = tmp;
          }
          int main()
          {
          	int a = 1;
          	double b = 2.3;
          	cout 
          	return left + right;
          }
          int main()
          {
          	int a = 1;
          	double b = 2.3;
          	cout 
          	return left + right;
          }
          int main()
          {
          	int a1 = 10, a2 = 20;
          	double d1 = 10.0, d2 = 20.0;
          	Add(a1, a2);
          	Add(d1, d2);
          	return 0;
          }
          
          	int a = 10;
          	double b = 20.0;
          	// 显式实例化
          	Add
          	return left + right;
          }
          // 通用加法函数
          template
          	return left + right;
          }
          void Test()
          {
          	Add(1, 2); // 与非模板函数匹配，编译器不需要特化
          	Add
          	return left + right;
          }
          // 通用加法函数
          template
          	return left + right;
          }
          void Test()
          {
          	Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
          	
          	Add(1, 2.0); // 模板函数可以生成更加匹配的版本，
          				//编译器根据实参生成更加匹配的Add函数
          }
          
          	// 类内成员定义
          };
          
          public:
          	Vector(size_t capacity = 10)
          		: _pData(new T[capacity])
          		, _size(0)
          		, _capacity(capacity)
          	{}
          	// 使用析构函数演示：在类中声明，在类外定义。
          	~Vector();
          	void PushBack(const T& data);
          		void PopBack();
          		// ...
          		size_t Size() { return _size; }
          	T& operator[](size_t pos)
          	{
          		assert(pos