Welcome to 9ilk's Code World

       

(๑•́ ₃ •̀๑) 个人主页:         9ilk

(๑•́ ₃ •̀๑) 文章专栏：      与C++的邂逅

---

本篇博客我们将了解C++中泛型编程体现的一大利器 --- 模板，有了模板可以帮我们用户省力。

---

🏠 泛型编程

如何实现一个通用的交换函数呢？

<code>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. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数。

2. 代码的可维护性比较低，一个出错可能所有的重载均出错。

那能否

告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码

呢？

如果在

C++

中，也能够存在这样一个

模具

，通过给这个模具中

填充不同材料

(

类型

)

，来

获得不同材料的铸件

(

即生成具体类型的代码）

，那将会节省许多头发。巧的是前人早已将树栽好，我们只需在此乘凉。

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

🏠 函数模板

📌 概念

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

类型版本。

格式

template<typename T1,typename T2,...,typename Tn>

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

{}

注：typename是用来定义模板参数的关键字，也可以使用class(但是不能用struct替换class)。

我们可以用函数模板解决C语言中不同类型swap函数复用率低，代码量大的问题。

template<typename T>

void Swap(T& left , T& right)

{

T temp = left;

left = right;

right = temp;

}

int main()

{

int a = 1;

int b = 2;

double c = 1.1;

double d = 2.2;

Swap(a,b);

Swap(c,d);

return 0;

}

📌 原理

对于上述的函数模板，我们传不同类型参数时，它们调用的是同一个函数吗？

通过汇编，我们可以看到两次调用函数，call的函数地址都不同。这说明传不同的类型调用的是不同的函数。函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具，其实是编译器帮我们完成了我们原本需要干的事。

在编译器编译阶段

，

对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

注：对于像Swap这样的函数是我们在实践中经常需要用的所以库里面提供了swap函数模板。

📌 实例化

用不同类型的参数使用函数模板时

，

称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。

隐式实例化

隐式实例化：让编译器根据实参推演模板参数的实际类型。

<code>template<class T>

T Add(const T& left, const T& right)

{

return left + right;

}

template<class T1,class T2>

auto Add(const T1& left, const T2& right)

{

return left + right;

}

int main()

{

int a1 = 10, a2 = 20;

double d1 = 10.0, d2 = 20.0;

Add(a1, a2);

Add(d1,d2);

Add(a1,d2);//T1推演出int,T2推演出double

return 0;

}

如果函数模板参数个数只有一个，然后调用Add(a1,d2)呢？

template<class T>

T Add(const T& left, const T& right)

{

return left + right;

}

int main()

{

int a1 = 10, a2 = 20;

double d1 = 10.0, d2 = 20.0;

Add(a1,d2);

return 0;

}

此时该语句不同通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型，通过实参a1将T推演成int，通过实参d2将T推演成double类型，但模板参数列表中只有一个T，编译器无法确定此处到底应该将T确定为int或者double类型而报错。

注：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出现问题，编译器就需要背黑锅。

对于这种推演歧义问题，我们第一种解决方法是强转所传参数，第二种方式就是显示实例化。

Add(a1,d2);//编译器不会对其进行强转

Add(a1,(int)d2);

Add((double)a1,d2);

显式实例化

显式实例化：在函数名后的<>中指定模板参数的实际类型，不再让你去推演参数。

Add<int>(a1,d2);

Add<double>(a1,d2);

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

显式实例化使用场景：

template<class T>

T* func(int a)

{

T* p = (T*)operator new(sizeof(T));

new(p)T(a);

return p;

}

int main()

{

//int * ret1 = func(1);//返回值不能推演 因为我可能不接收返回值

int* ret1 = func<int>(1);

A* ret2 = func<A>(1);

return 0;

}

📌 模板参数匹配原则

// 专门处理int的加法函数 --- 1号

int Add(int left, int right)

{

cout << "int Add(int left, int right)" << endl;

return left + right;

}

//通用加法函数 --- 2号

template<class T>

T Add(T left, T right)

{

cout << "T Add(T left, T right) " << endl;

return left + right;

}

template<class T1,class T2> --- 3号

auto Add( T1 left, T2 right)

{

cout << " auto Add( T1 left, T2 right) " << endl;

return left + right;

}

int main()

{

Add(1,2); //匹配1号

Add(1.1,2.2); //匹配2号

Add(1,1.2); //匹配3号

}

说明：

1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化成这个非模板函数。

2.在普通函数(如1号)和函数模板(2,3号)都存在的情况下，会优先匹配普通函数+参数类型匹配的那一个，也就是有现成品+符合参数口味。比如，当调用Add(1,2)时，函数模板推演出来两个模板参数都是int，但是由于有现成的1号函数所以会调用1号。

3.没有普通函数时，会优先匹配函数模板+参数类型匹配。比如调用Add(1.1,2.2)，没有现成两个参数都是double的普通函数，于是去看函数模板，2号模板和3号模板虽然都能推演出是double，但是3号其实是表示两个不同模板参数，所以更匹配2号。再比如调用Add(1,1.2)时，只能匹配3号了，因为只有它能推演出是两个不同类型参数。

int Add(int left, int right)

{

cout << "int Add(int left, int right)" << endl;

return left + right;

}

int main()

{

Add(1,3);

Add(1.1,2.2);

Add(1.1, 2.2);

return 0;

}

输出：

int Add(int left, int right)

int Add(int left, int right)

int Add(int left, int right)

template<class T>

T Add(T left, T right)

{

cout << "T Add(T left, T right) " << endl;

return left + right;

}

int main()

{

Add(1,3);

Add(1.1,2.2);

Add(1.1, 2.2);

return 0;

}

输出结果：

屏蔽第三个函数调用，前两个分别是：

T Add(T left, T right)

T Add(T left, T right)

第三个编译报错。

template<class T1,class T2>

auto Add( T1 left, T2 right)

{

cout << " auto Add( T1 left, T2 right) " << endl;

return left + right;

}

int main()

{

Add(1,3);

Add(1.1,2.2);

Add(1.1, 2.2);

return 0;

}

输出结果：

auto Add( T1 left,  T2 right)

auto Add( T1 left,  T2 right)

auto Add( T1 left,  T2 right)

因此得出结论：

1. 当只有一个函数时，类型转换一下也能用，也可以匹配调用(口味不对但将就用)。

2. 模板参数不允许自动类型转换，但普通函数可以进行自动类型转换。(比如只有1号函数时，对于调用Add(1,1.2)发生了类型转换，而对于2号函数模板则会发生歧义不能强转)

🏠 类模板

typedef int DataType;

struct Stack

{

void Init(size_t capacity)

{

_array = (DataType*)malloc(sizeof(DataType) * capacity);

if (nullptr == _array)

{

perror("malloc申请空间失败");

return;

}

_capacity = capacity;

_size = 0;

}

void Push(const DataType& data)

{

// 扩容

_array[_size] = data;

++_size;

}

DataType Top()

{

return _array[_size - 1];

}

void Destroy()

{

if (_array)

{

free(_array);

_array = nullptr;

_capacity = 0;

_size = 0;

}

}

DataType* _array;

size_t _capacity;

size_t _size;

};

在C语言阶段我们实现的栈数据结构无法做到一个栈存int类型数据，一个栈存double类型数据，要的话只能写多个这样的类，但是这些类的接口一致，只是存储的数据类型不同，这时就得引出我们的类模板了。

📌 定义格式

template<class T1,class T2,...,class Tn>

class 类模板名

{

///...

};

注意：类模板中函数放在类外进行定义时，需要加模板参数列表。

template<class T>

class Vector

{

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 < _size);

return _pData[pos];

}

private:

T* _pData;

size_t _size;

size_t _capacity;

};

template <class T>

Vector<T>::~Vector()

{

if(_pData)

delete[] _pData;

_size = _capacity = 0;

}

📌 类模板实例化

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

而实例化的结果才是真正的类

。

// Vector类名，Vector<int>才是类型

Vector<int> s1;

Vector<double> s2;

🏠 辨析总结

模板分为函数模板和类模板，他们不是具体的一个类或函数，而是代表一个家族。

类模板 vs 模板类

类模板是一个类家族，而模板类是通过类模板实例化出来的具体类。

注：类模板中成员函数全是函数模板，因为所有类模板的成员函数，放在类外定义时，需要在函数名前加类名，而类名实际为ClassName<T>，所以定义时还需加模板参数列表。

函数模板 vs 模板函数

函数模板不是一个具体函数，而是一个函数家族，模板函数是根据函数模板实例化出来的函数。

---

完。