模板概念

模板是泛型编程的基础，泛型编程即以一种独立于任何特定类型的方式编写代码。模板是创建泛型类或函数的蓝图或公式。库容器，比如迭代器和算法，都是泛型编程的例子，它们都使用了模板的概念。每个容器都有一个单一的定义，比如向量，我们可以定义许多不同类型的向量，比如 vector <int> 或 vector <string>。

模板是一种对类型进行参数化的工具，通常有两种形式：

• 函数模板：参数类型不同的函数。
• 类模板：数据成员和成员函数类型不同的类。

使用模板可以让代码变得更简洁。比如编写一个swap函数，交换两个int类型参数，但不能交换两个double或者char类型参数。这时就要重载swap函数，对于程序员来说还是比较麻烦的，因此模板函数可以解决这个问题。

注意：模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行，比如不能在main函数中声明或定义一个模板。

函数模板

模板函数定义的一般形式如下所示：

template <typename 类型参数1 , typename 类型参数2 , ...>
返回值类型 函数名(形参列表)
{
   //在函数体中可以使用类型参数
}
// 类型参数可以有多个，它们之间以逗号,分隔。类型参数列表以< >包围，形式参数列表以( )包围。

在这里，type 是函数所使用的数据类型的占位符名称，这个名称可以在函数定义中使用。

函数模板，实际上是建立一个通用函数，它所用到的数据的类型(包括返回值类型、形参类型、局部变量类型)可以不具体指定，而是用一个虚拟的类型来代替(实际上是用一个标识符来占位)，等发生函数调用时再根据传入的实参来逆推出真正的类型。这个通用函数就称为函数模板。在函数模板中，数据的值和类型都被参数化了，发生函数调用时编译器会根据传入的实参来推演形参的值和类型。换个角度说，函数模板除了支持值的参数化，还支持类型的参数化。

在函数重载中，为了交换不同类型变量的值，通过函数重载定义了四个名字相同，参数列表不同的函数，如下所示：

//交换 int 变量的值
void Swap(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}
//交换 float 变量的值
void Swap(float &a, float &b)
{
    float temp = a;
    a = b;
    b = temp;
}

//交换 char 变量的值
void Swap(char &a, char &b)
{
    char temp = a;
    a = b;
    b = temp;
}

从例子中可以看出，需要定义三个swap函数，可以借助模板进行简化。一但定义了函数模板，就可以将类型参数用于函数定义和函数声明了。原来使用 int、float、char 等内置类型的地方，都可以用类型参数来代替。

下面我们就来实践一下，将上面的Swap() 函数压缩为一个函数模板：

#include <iostream>
using namespace std;
template<typename T>
void Swap(T& a, T& b) 
{
  T temp = a;
  a = b;
  b = temp;
}

int main()
{
  //交换 int 变量的值
  int n1 = 100, n2 = 200;
  Swap(n1, n2);
  cout << n1 << ", " << n2 << endl;
  //交换 float 变量的值
  float f1 = 12.5, f2 = 56.93;
  Swap(f1, f2);
  cout << f1 << ", " << f2 << endl;
  return 0;
}

例子中template<typename T>也可以写成template<class T>，模板中typename和class关键字的区别？。C++早期对模板的支持并不严谨，没有引入新的关键字，而是用class来指明类型参数，但是class关键字本来已经用在类的定义中了，这样做显得不太友好，所以后来C++又引入了一个新的关键字typename，专门用来定义类型参数。不过至今仍然有很多代码在使用class关键字，包括C++标准库、一些开源程序等。

《Effective C++》中建议尽量使用typename而不是class来声明一个模板。因为class给人的感觉总像是T应该是一个类，或者说是用户自定义的类型，而typename则更像是表明T可以是任意一种类型。虽然在C++编译器看来，这两种声明方式没有任何的区别，其意义是完全一样的。

typename关键字在模板中还有另一种用法: 使用嵌套依赖类型

class Cat 
{
public:
  class Color {};
  using Weight = int;	
  typedef int Age;	//和Color一样，属于内部类型，在模板类中作为类型使用前面要加上 typename
};
template<class T>
class Animal 
{
public:
  T::Color* p1;	                      //(1) 	×
  typename T::Color* p2;      //(2)	√
  T::Weight Weight;	             //(3) 	×
  typename T::Age Age;       //(4)	√
};

在模板类 Animal 中的代码 (1)，T::Color* CatColor 看起来是声明一个 T::Color 指针类型的对象，然而在编译器的眼里却不是这样的。模板函数/类的代码在编译过程中，并不知道模板类型参数是什么，要等到实际运行了才知道。这就导致了编译器不知道 T::Color 是类型还是类变量。如果 T::Color 是类变量，p1 是一个全局变量，这条语句就是乘法*操作了。

这时候就需要用到 typename 了，将他放到嵌套依赖类型名称的前面，就能显式告诉编译器，这是一个类型，而不是变量，从而正确实现代码功能，比如上述代码中的 (2)。

模板类中，可以使用模板类型参数本身，也可以使用参数内部定义的类，如：using Weight = int 和 typedef int Age 定义的类都可以在模板类中使用。

如果没有加上 typename 关键字，默认情况下，C++ 语言假定通过作用域运算符访问的名字不是类型。

不能使用typename的地方：

typename可以出现在函数体内，可以出现在函数返回类型前，可以出现在函数参数前。但是当子类继承的父类是嵌套依赖类型名称的时候，typename不能出现在类的基类列表以及成员初始化列表中作为父类的修饰符。

template <typename T>
class Animal
{
protected:
  T Size;
};
template <typename T>
class Cat : public Animal<T>::Size //Animal<T>::Size 前不可用 typename 修饰
{
public:
  Cat(int m) : Animal<T>::Size(m) //Animal<T>::Size 前不可用 typename 修饰
  {
    //函数体中可以使用
  }
};

从例子可以看出，在继承过程中不使用typename修饰。在《Effective C++》中的条款 42，书中关于相关概念有如下描述：

一个 template（模板）中的依赖于一个 template parameter（模板参数）的名字被称为 dependent names（依赖名字）。当一个 dependent names（依赖名字）嵌套在一个 class（类）的内部时，我称它为 nested dependent name（嵌套依赖名字）。一个涉及到一个 type（类型）的 nested dependent name（嵌套依赖名字）就是 nested dependent type name（嵌套依赖类型名）。

类模板

类模板定义的一般形式如下所示：

template<typename 类型参数1 , typename 类型参数2 , …> class 类名
{
     //TODO:
};

上面仅仅是类的声明，我们还需要在类外定义成员函数。在类外定义成员函数时仍然需要带上模板头，格式为：

template<typename 类型参数1 , typename 类型参数2 , …>
返回值类型 类名<类型参数1 , 类型参数2, ...>::函数名(形参列表)
{
    //TODO:
}
// 第一行是模板头，第二行是函数头，它们可以合并到一行，不过为了让代码格式更加清晰，一般是将它们分成两行。

下面的实例定义了类 Stack<>，并实现了泛型方法来对元素进行入栈出栈操作：

// 栈模板.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include <iostream>
#include <vector>
#include <cstdlib>
#include <string>
#include <stdexcept>
using namespace std;
template <typename T>
class Stack 
{
public:
  void push(T const& elem); //入栈
  void pop();		//出栈
  void clear();	//清空栈
  T top() const;	//返回栈顶元素
  bool empty() const	//判断是否为空
  {
    return elems.empty();
  }
private:
  vector<T> elems;//元素容器
};
template<typename T>
void Stack<T>::push(T const& elem)
{
  elems.push_back(elem);
}
template<typename T>
void Stack<T>::pop()
{
  if (elems.empty())
  {
    throw out_of_range("Stack<>::pop(): empty stack");
  }
  //删除最后一个元素
  elems.pop_back();
}
template<typename T>
void Stack<T>::clear()
{
  if (elems.empty())
  {
    return;
  }
  else
  {
    elems.clear();
  }
}
template <typename T>
T Stack<T>::top() const
{
  if (elems.empty()) 
  {
    throw out_of_range("Stack<>::top(): empty stack");
  }
  // 返回最后一个元素的副本 
  return elems.back();
}
int main()
{
  try
  {
    Stack<int> int_stack; //int类型栈
    Stack<string> str_stack; //string类型栈
    //int类型压入栈
    int_stack.push(1);
    int_stack.push(2);
    cout << int_stack.top() << endl;
    int_stack.clear();
    cout << (int_stack.empty() ? "true" : "false") << endl;
    //sting类型压入栈
    str_stack.push("hello");
    str_stack.push("world");
    cout << str_stack.top() << endl;
    str_stack.pop();
    str_stack.pop();
    str_stack.pop();
  }
  catch (exception const& e)
  {
    cerr << "Exception: " << e.what() << endl;
    return -1;
  }
  return 0;
}

从例子中可以看出，Stack可以对任意类型元素进行操作。