【与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;
}//...

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推演出doublereturn 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);

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号函数模板则会发生歧义不能强转)

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;
}

📌 类模板实例化

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