C++初阶模板-编程知识

介绍：

我们先认识以下C++中的模板。模板是一种编程技术，允许程序员编写与数据类型无关的代码，它是一种泛型编程的方式，可以用于创建可处理多种数据类型的函数或类，也就是说泛型编程就是编写与类型无关的通用代码，是代码复用的一种手段，而模板是泛型编程的基础。其中，模板分为函数模板和类模板。

函数模板：

函数模板是一种通用的函数定义，可以接受多种类型作为输入，并生成对应的特定类型函数。

格式：

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

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

//定义一个可以实现多种类型交换的函数

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

注意：上面的typename是用来定义模板参数的关键字，这可使用class，我们目前可先认为class与typename无任何区别，但是这里不能使用struct来代替。

函数模板的工作原理：

这里要说明的是函数模板是一个 “ 蓝图 ”，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。

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

注意：函数模板并不会为每个可能的类型组合生成函数，后文会对齐深入讲解。

函数模板的实例化：

函数模板根据传入的实参类型生成特定类型的函数，然后调用这些函数，此过程称为函数模板的实例化。其中，模板参数实例化分为：隐式实例化和显式实例化。

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

template<class T>
T Add(const T& left, const T& right)
{
   return left + right;
}
int main()
{
   //隐式实例化
   Add(1, 2);
   Add(1.2, 1.3);
   return 0;
}

显式实例化：在函数名后的<>中指定模板参数的实际类型。

template<class T>
T Add(const T& left, const T& right)
{
   return left + right;
}
int main()
{
   int a = 10;
   double b = 20.0;
   //显式实例化
   Add<int>(a, b);
   return 0;
}

注意：当进行类型转换时，如果编译器没有找到与实参类型匹配的函数模板，它会自动进行隐式实例化，如果还无法确定实例化的类型，就会报错。

下面我们观察以下代码的问题：

template<class T>
T Add(const T& left, const T& right)
{
   return left + right;
}
template<typename T1, typename T2>
T1 add(const T1& left, const T2& right)
{
   return left + right;
}
int main()
{
   Add(1, 1.2);//系统报错
   Add(1, (int)1.2);//强制转换，运行正常
   Add<int>(1, 1.2);//显示实例化，运行正常

   add(1, 1.2);//参数匹配，运行正常
   return 0;
}

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

注意：在模板中，编译器一般不会进行类型转换操作。

解决以上方法有三种：1. 直接强制转化 2. 使用显式实例化 3. 设置多个模板参数

模板函数与非模板函数：

一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数，当调用时，如果其他条件都相同，会优先调用非模板函数。如果模板可以产生一个具有更好匹配的函数，那么将选择模板函数。

int Add(int left, int right)
{
   return left + right;
}
template<class T>
T Add(T left, T right)
{
   return left + right;
}
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
   return left + right;
}
int main()
{
   Add(1, 2); //调用非模板函数
   Add<int>(1, 2); //显示实例化，调用模板函数

   Add(1, 2); //与非函数模板类型完全匹配，调用非函数模板
   Add(1, 2.0); //模板函数可以生成更加匹配的版本，调用函数模板
   return 0;
}

这里再强调一次，模板函数不允许自动类型转换，但普通函数可以进行自动类型转换。

类模板：

格式如下：

template<class T1, class T2, ..., class Tn>
class 类模板名
{
..........
};

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

template<class T>

class Stack
{
public:
   Stack(int capacity = 4)
   {
       cout << "Stack(int capacity = 4)" << endl;
       _a = new T[capacity];//这里需要用到T，所以不能直接实例化int*或double*
       _top = 0;
       _capacity = capacity;
   }
   ~Stack()
   {
       cout << "~Stack()" << endl;
       delete[] _a;
       _a = nullptr;
       _top = 0;
       _capacity = 0;
   }
   T* _a;
   int _top;
   int _capacity;
};
int main()
{
   //显示实例化
   Stack<int> st1;
   cout << typeid(st1._a).name() << endl;//输出int*，因为 T* _a
   Stack<double> st2;
   cout << typeid(st2._a).name() << endl;//输出double*，因为 T* _a
   return 0;
}