1. 模版简介

1) c++模板简介

c++中，模板可以允许函数或者类通过泛型的方式来表现或者运行。
例如，我们可以用max函数来计算两个整数的最大值，代码如下：

int Max(int x, int y)
{
  return x > y ? x : y;  
}

但是如果我们对double、long等其他类型也想定义Max函数，那么就会出现重复定义类似代码的情况，我们可以使用函数模板，定义如下：

template <typename T> T Max(T a, T b)
{
  return a > b ? a : b;
}

在实际使用函数模板时，我们仍然可以使用以前的方式来使用Max函数：

cout << Max(33, 25) << endl;

在c++中模版可以分成两类：类模版和函数模板。
模板还两个重要的概念，即模板声明和模版实例化。
模板声明是给出函数或者类的模板形式的定义。
而模板实例化是从模板构建出一个真正的类或者函数的过程。
前面Max函数模版的定义就是模板声明，而后面调用Max(33,25)时会执行模版实例化。
模板实例化有两种方式：

1. 显式实例化

在代码中明确指定使用哪种类型进行实例化

2.隐式实例化

在首次使用模版时根据情况自动选择合适的类型进行实例化

2) c++函数模板

前面的Max还可以定义成如下形式：

template <class T> T Max(T a, T b)
{
  return a > b ? a : b;
}

但是class和typename有不同的含义，最好使用typename。
前面提到模板实例化，也可以理解成用具体类型替代模板参数的过程。
函数模版的实例化是编译器自动实现的。
写了一个小程序来测试：

#include <iostream>
using namespace std;

template <typename T> T Max(T x, T y)
{
  return x > y ? x : y;
}

int main(void)
{
  cout << Max(33, 28) << endl;
}

这个文件使用 clang 编译生成汇编文件，然后使用c++filt将其中符号转换成原来函数，命令如下：

clang++ -S max.cpp 
 cat max.s  | c++filt

汇编文件内容(仅保留关键内容)：

.Ltmp10:
    .cfi_def_cfa_register %ebp
    subl    $24, %esp
    movl    $33, %eax
    movl    $28, %ecx
    movl    $33, (%esp)
    movl    $28, 4(%esp)
    movl    %eax, -4(%ebp)          # 4-byte Spill
    movl    %ecx, -8(%ebp)          # 4-byte Spill
    calll   int Max<int>(int, int)
    leal    std::cout, %ecx
    movl    %ecx, (%esp)
    movl    %eax, 4(%esp)
    calll   std::basic_ostream<char, std::char_traits<char> >::operator<<(int)
    leal    std::basic_ostream<char, std::char_traits<char> >& std::endl<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&), %ecx
    movl    %eax, (%esp)
    movl    %ecx, 4(%esp)
    calll   std::basic_ostream<char, std::char_traits<char> >::operator<<(std::basic_ostream<char, std::char_traits<char> >& (*)(std::basic_ostream<char, std::char_traits<char> >&))
......
int Max<int>(int, int):                      # @int Max<int>(int, int)
# BB#0:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $12, %esp
    movl    12(%ebp), %eax
    movl    8(%ebp), %ecx
    movl    %ecx, -4(%ebp)
    movl    %eax, -8(%ebp)
    movl    -4(%ebp), %eax
    cmpl    -8(%ebp), %eax
    jle .LBB2_2
......

从汇编代码可以看到，实际调用的是int Max<int>(int,int)。而且代码段后面有这个实例化的函数模板的定义。
显然，函数模版需要生成实例化之后的代码，然后才能使用实例化后的函数。
在对函数模版实例化时，需要根据实参的类型判断需要怎么实例化，这个过程被成为参数推导。在参数推导的过程中，不允许自动类型转换。
例如下面的用法是错误的：

Max(1,2.0)

但是可以使用下面任何一种方式类处理这类错误：

Max(static_cast<double)1, 2.0)
Max<double>(1,2.0)

函数模版和普通函数一样可以重载，并且可以和普通函数共存。如果非模版函数和模版函数都适用，那么优先选用非模版函数。
允许使用Max<>(23,7)，会自动推导选择合适的类型来进行模版实例化，跟前面Max(23,7)等价。

3) 类模板

类模版的一个例子：

const std::size_t DefaultStackSize = 1024;
template <typename T, std::size_t n = DefaultStackSize> class Stack{
public:
    void Push(const T const & element);
    int Pop(T &element);
    int Top(T &element) const;
private:
    std::vector<T> m_Members;
    std::size_t m_nMaxSize = n;
};

类模板定义跟函数模版定义类似。
在类模版函数定义中，如果需要用到类本身，那么需要其完整定义（Stack<T>)，而不是使用T。
在定义类的模板函数时，需要指明是一个模板函数，例如Push函数的定义如下：

template <typename T, std::size_t nMaxSize>
void Stack<T, nMaxSize>::Push(const T const& element)
{
 ....
}

使用类模版方式如下：

Stack<int> stack;  //定义一个内部存放int类型的stack
Stack<int, 100> stack; //定义一个内部存放类型为int的栈，栈的默认大小是100.
Stack<Stack<int> > intStackStack; //定义一个栈，栈中元素是Stack<int>类型。

允许对类模版进行特化，类似下面代码：

template <>
class Stack<std::wstring> {
...
};

也可以对类模版进行偏特化（即仅有部分模板类型进行特化）。

4) c++操作符重载

c++中关键字operator定义了一种特殊函数，可以对常见的操作（例如*、->或者括号操作符）等进行重载。
操作符重载不能用于内部类型。
操作符重载可用于非静态成员函数或静态全局函数。
一元操作符重载为成员函数没有参数，二元操作符重载为成员函数只有一个参数。
操作符重载不能带有默认参数。

2. 泛型编程

1) 简介

泛型编程是一种编程思想，与具体语言无关，它可以允许类型在需要调用的时候以参数的方式给出。

2)Traits