『C++』模板初识

泛型编程

什么是泛型编程？

在大多数人眼里，计算机既神秘又能干。但在大多数程序猿眼里，计算机实在是又蠢又笨。只不过运算速度比人类快，记忆力好。而且不给指令还什么都干不了。就是给指令，写一个程序，计算机也不灵活。比如，在C++中，同样一个加法，居然要给出不同的数据类型的运算方式。基于此，人们设想能否研制一种编程机制，让一个函数适应所有的数据类型，包括自己定义的。后来，人们实现了这种机制，就称它为泛型编程。

泛型编程最初提出时的动机很简单直接，就是发明一种语言机制，能够帮助实现：

• 一个通用的标准容器库。所谓通用的标注容器库，就是要能够做到，比如用一个List存放所有可能类型的对象。
• 泛型编程让编写完全一般化并可以重复使用的算法，其效率与针对某特定数据类型而设计的算法相同。泛型即是指具有多种数据类型上皆可操作的含义，这样算法与数据结构完全分离，其中算法是泛型的，不与任何特定数据结构或对象类型联系在一起。

泛型编程的代表作品STL是一种高效、泛型、可交互操作的软件组件。STL以迭代器和容器为基础，是一种泛型算法库，容器的存在使这些算法有东西可以操作。STL包含各种泛型算法、泛型迭代器、泛型容器以及函数对象。STL并非只是一些有用组件的集合，它是描述软件组件抽象需求条件的一个正规而有条理的架构。

如何实现一个通用的swap函数

代码演示

#include 
using std::cout;
using std::endl;

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;

}

int main(){

	int ai = 1;
	int bi = 2;
	cout << "The origin: " << ai << " " << bi << endl;
	swap(ai, bi);
	cout << "After swap: " << ai << " " << bi << endl;

	double ad = 1.11;
	double bd = 2.22;
	cout << "The origin: " << ad << " " << bd << endl;
	swap(ad, bd);
	cout << "After swap: " << ad << " " << bd << endl;

	char ac = 'a';
	char bc = 'b';
	cout << "The origin: " << ac << " " << bc << endl;
	swap(ac, bc);
	cout << "Afte swap: " << ac << " " << bc << endl;

	return 0;

}

运行结果

[sss@aliyun template]$ !g++ 
g++ swap.cc -o swap 
[sss@aliyun template]$ ./swap 
The origin: 1 2
After swap: 2 1
The origin: 1.11 2.22
After swap: 2.22 1.11
The origin: a b
Afte swap: b a

使用函数重载虽然可以实现泛型编程，但是有几个不好的地方：

• 重载的函数仅仅只是类型不同，代码的复用率较低，只要有新类型出现，就需要增加对应的函数。
• 代码的可维护性较低，一个出错可能所有的重载均出错。

模板

那能够告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

函数模板

概念

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

函数模板格式

template <typename T1, typename T2, ... typename Tn>
ret_val_type function(parameter list){

}

注意：typename是用来定义模板参数的关键字，也可以用class。（切记，不可用struct替代class）。

代码演示

#include 
using std::cout;
using std::endl;

template <typename T>
void swap(T& left, T& right){
	T temp = left;
	left = right;
	right = temp;
}

int main(){

	int ai = 1;
	int bi = 2;
	cout << "The origin: " << ai << " " << bi << endl;
	swap(ai, bi);
	cout << "After swap: " << ai << " " << bi << endl;

	double ad = 1.11;
	double bd = 2.22;
	cout << "The origin: " << ad << " " << bd << endl;
	swap(ad, bd);
	cout << "After swap: " << ad << " " << bd << endl;

	char ac = 'a';
	char bc = 'b';
	cout << "The origin: " << ac << " " << bc << endl;
	swap(ac, bc);
	cout << "Afte swap: " << ac << " " << bc << endl;

	return 0;

}

运行结果

[sss@aliyun template]$ !g++
g++ swap.cc -o swap 
[sss@aliyun template]$ ./swap 
The origin: 1 2
After swap: 2 1
The origin: 1.11 2.22
After swap: 2.22 1.11
The origin: a b
Afte swap: b a

模板只是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的道具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。
在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于其他类型也是如此。

函数模板实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。

隐式实例化

让编译器根据实参类型推演模板参数的实际类型。

代码演示

#include 
using std::cout;
using std::endl;

template <typename T>
T Add(T left, T right){
	return left + right;
}

int main(){

	int ai = 1, bi = 2;
	int sumi = Add(ai, bi);
	cout << "ai + bi = " << sumi << endl;

	double ad = 1.11, bd = 2.22;
	double sumd = Add(ad, bd);
	cout << "ad + bd = " << sumd << endl;

	Add(ai, bd);

	return 0;
}

运行结果

[sss@aliyun template]$ !g++
g++ instantiation.cc -o instantiation
instantiation.cc: In function ‘int main()’:
instantiation.cc:20:12: error: no matching function for call to ‘Add(int&, double&)’
  Add(ai, bd);
            ^
instantiation.cc:20:12: note: candidate is:
instantiation.cc:6:3: note: template<class T> T Add(T, T)
 T Add(T left, T right){
   ^
instantiation.cc:6:3: note:   template argument deduction/substitution failed:
instantiation.cc:20:12: note:   deduced conflicting types for parameter ‘T’ (‘int’ and ‘double’)
  Add(ai, bd);
            ^

Add(ai, bd);是有问题的，编译期间，编译器通过ai将T推演为int，但是又看到bd，所以将T推演为double类型，但是模板参数列表只有一个T，所以编译器无法根据实参类型推导出T的类型。
注意：在模板中，编译器一般不会进行类型转换操作。
此处有两种解决方案：

• 用户自己进行类型转化。Add(ai, (int)bd);
• 显式实例化

显式实例化

在函数名后的<>中指定模板参数的实际类型。

代码演示

#include 
using std::cout;
using std::endl;

template <typename T>
T Add(T left, T right){
	return left + right;
}

int main(){

	int ai = 1, bi = 2;
	int sumi = Add(ai, bi);
	cout << "ai + bi = " << sumi << endl;

	double ad = 1.11, bd = 2.22;
	double sumd = Add(ad, bd);
	cout << "ad + bd = " << sumd << endl;

	int sum = Add<int>(ai, bd);
	cout << "ai + bd = " << sum << endl;

	return 0;
}

运行结果

[sss@aliyun template]$ !g++
g++ instantiation.cc -o instantiation
[sss@aliyun template]$ ./instantiation 
ai + bi = 3
ad + bd = 3.33
ai + bd = 3

当函数调用不需要传参时，显式实例化更有必要

当函数不需要传参，使用隐式实例化

#include 
using std::cout;
using std::endl;

template <typename T>
T Add(){
	T left = 1;
	T right = 2;
	return left + right;
}

int main(){

	Add();

	return 0;
}

运行结果

[sss@aliyun template]$ !g++
g++ instantiation.cc -o instantiation
instantiation.cc: In function ‘int main()’:
instantiation.cc:14:6: error: no matching function for call to ‘Add()’
  Add();
      ^
instantiation.cc:14:6: note: candidate is:
instantiation.cc:6:3: note: template<class T> T Add()
 T Add(){
   ^
instantiation.cc:6:3: note:   template argument deduction/substitution failed:
instantiation.cc:14:6: note:   couldn't deduce template parameter ‘T’
  Add();
      ^

当函数不需要传参，使用显式实例化

代码演示

#include 
using std::cout;
using std::endl;

template <typename T>
T Add(){
	T left = 1;
	T right = 2;
	return left + right;
}

int main(){

	Add<int>();

	return 0;
}

运行结果

[sss@aliyun template]$ !g++
g++ instantiation.cc -o instantiation
[sss@aliyun template]$ ./instantiation 
[sss@aliyun template]$ 

注意：显式实例化，如果匹配不成功，编译器会尝试进行隐式类型转换，如果转换不成功编译器将会报错。

模板参数的匹配原则

• 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。
• 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生一个实例。如果模板可以产生一个具有更好匹配的函数，那么将选择模板。
• 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换。

代码演示

模板函数和同名非模板函数同时存在。

#include 

int Add(int left, int right){

	std::cout << "func!" << std::endl;

	return left + right;

}

template <typename T>
T Add(T left, T right){

	std::cout << "template func!" << std::endl;

	return left + right;

}

int main(){

	Add(1, 2);
	Add<int>(1, 2);

	return 0;
}

运行结果

[sss@aliyun template]$ g++ matching.cc -o matching
[sss@aliyun template]$ ./matching 
func!
template func!

除非模板可以产生一个具有更好匹配的函数，否则优先调用非模板函数

#include 

int Add(int left, int right){

	std::cout << "func!" << std::endl;

	return left + right;

}

template <typename T1, typename T2>
T1 Add(T1 left, T2 right){

	std::cout << "template func!" << std::endl;

	return left + right;

}

int main(){

	Add(1, 2);
	Add(1, 2.0);

	return 0;
}

运行结果

[sss@aliyun template]$ !g++
g++ matching.cc -o matching
[sss@aliyun template]$ ./matching 
func!
template func!

注意

• 编译器在编译时不对函数模板的语法规则做过多检查。只检查模板实例化出来的代码。
  
• 但是也会做一些简单的检查。
  

类模板

类模板的定义格式

template <class T1, class T2, ..., class Tn>
class 类模板名{
	类内成员定义
}

代码演示

template_class.h

#pragma once

#include 
#include 
#include 
using std::cout;
using std::endl;

template <class T>
class SequenceList{
	public:
		SequenceList(int capacity = 10){

			_capacity = capacity;
			_size = 0;
			_seq_list = (T*)malloc(sizeof(T) * _capacity);
			assert(_seq_list != NULL);

		}

		~SequenceList(){

			free(_seq_list);
			_seq_list = NULL;
			_size = 0;
			_capacity = 0;

		}

		void PushBack(const T& data);

		void PopBack();

		void Display() const{

			size_t i = 0;

			for(; i < _size; ++i){
				cout << _seq_list[i] << " ";
			}
			cout << endl;
		}

	private:
		void checkCapacity(){

			if(_size >= _capacity){
				_capacity *= 2;
				_seq_list = (T*)realloc(_seq_list, sizeof(T) * _capacity);
				assert(_seq_list != NULL);
			}

		}

	private:
		T* _seq_list;
		size_t _size;
		size_t _capacity;
};

template_class.cc

#include "template_class.h"

template <class T>
void SequenceList<T>::PushBack(const T& data){

	++_size;
	checkCapacity();
	_seq_list[_size - 1] = data;

}

template <class T>
void SequenceList<T>::PopBack(){

	--_size;

}

注意：类模板中函数放在类外定义时，需要加模板参数列表。SequenceList不是具体的类，是编译器根据被实例化的类型生成具体类的模具。

类模板的实例化

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后面跟<>，然后将实例化的类型放在<>中即可，而实例化的结果才是真正的类。

代码演示

void slTest(){

	SequenceList<int> si;

	si.PushBack(1);
	si.PushBack(2);
	si.PushBack(3);
	si.PushBack(4);
	si.PushBack(5);

	si.Display();

	SequenceList<double> sd;
	sd.PushBack(1.11);
	sd.PushBack(2.22);
	sd.PushBack(3.33);
	sd.PushBack(4.44);
	sd.PushBack(5.55);

	sd.Display();

}

int main(){

	slTest();

	return 0;
}

运行结果

[sss@aliyun class]$ !g++
g++ template_class.cc -o template_class
[sss@aliyun class]$ ./template_class 
1 2 3 4 5 
1.11 2.22 3.33 4.44 5.55