templates

啥是模版？
把类型或是值当成参数的类或是函数。

template<typename T>
class A{
public:
    explicit A(int s);
    ~A(){ delete [] e; }
    T& operator[](int i);
    const T& operator[](int i) const;
    int size() const ｛ return sz; ｝

private:
    T* e;
    int sz;
};

上面的typename可以换成class
template< typename T> 可以读成 for all T，或是for all types T

在实现的前面加一个template< typename T> 。 eg：

template< typename T> 
A< T >::A(int s) {
    ...
}

在此，新标准有一个需要注意的地方：

vector<list<int>> v;

新标准之后， >> 中间不需要空格了，算是修复了以前的一个小瑕疵

模版 是一种编译期机制。所以并不花费运行期的资源。
模版除了用类型作为参数，也可以用值作为参数。

template<typename T, int N>
strcut buf{
    using value_type = T;
    constexpr int size() { return N; }
    T[N];
};

其中using在这里的表示，为类型T取一个别名。除此之外还可以给namespace取别名。
constexpr是编译期的玩意。
用数值作为模版参数 ，在很多场合都是非常有用的。只是这个参数一定要是常量表达式。

模版能用来干嘛？
先来看看模版相对其他技术的优势：
可以传递类型、延时类型检查、常量参数(可以在编译期进行计算)。
总的来说，模版提供了一到强大的机制( 编译期计算和类型操作)可以使代码更加紧凑高效

模版最常用的是支持泛型编程(generic programming)
gp着重于设计、实现、使用泛型算法。
模版提供了编译期参数多态性。

如果一个类型被称为常规类型，必须和int、string、vector等一样，需要满足以下几点：
有默认的构造函数
可以拷贝(通过拷贝构造和赋值构造)
可以比较(==、！=)
没有过高编程技巧带来的技术问题
string就是一个基本类型。

模版的另一个使用就是函数对象，有时也称为仿函数(functor)
什么是函数对象？
如果一个类的使用看起来像一个函数，那么这个类可以称为函数对象。
如何使一个类的使用看起来像函数？
实现operator()

仿函数比较常用的是用在算法中的参数。

相比函数指针，仿函数还是一个函数对象，可以将部分值保存在自己的对象中，这样就不需要函数指针的全局变量什么的，算是向优雅迈进了一小步。
再者，仿函数可以将operator()做成inline内联函数，这样效率比函数指针高一些。

仿函数是泛型算法的一个关键点，函数对象也经常被称为policy objects。

// =======================================================================================
// functor

template <typename T>
class Less_than {
public:
  Less_than ( const T& v ) : val ( v ) {
  }

  bool operator() ( const T& x ) const {
    return x < val;
  }

private:
  const T val;
};

template <typename C, typename P>
int count ( const C& c, P pred ) {
  int cnt = 0;
  for ( const auto & x : c )
    if ( pred ( x ) )
      ++cnt;

  return cnt;
}

void ff ( const std::vector<int>& vec,
         const std::list<std::string>& lst,
         int x,
         const std::string& s ) {
  std::cout << count ( vec, Less_than<int>{x} ) << std::endl;
  std::cout << count ( lst, Less_than<std::string>{s} ) << std::endl;
}

void gg ( const std::vector<int>& vec,
         const std::list<std::string>& lst,
         int x,
         const std::string& s ) {
  std::cout << count ( vec, [&]( int a ) { return a < x; } ) << std::endl;
  std::cout << count ( lst, [&]( const std::string& a ) { return a < s; } ) << std::endl;
}

void test_func () {
  std::cout << std::endl << std::endl << "-------------------------- functor test------------------------" << std::endl;

  // 将仿函数作为一个对象使用
  Less_than<int> lti { 234 };
  Less_than<std::string> lts { "abc" };

  std::cout << "123 < 234 : " << (lti(123) ? "true" : "false") << std::endl;
  std::cout << "bb < abc : " << (lts("bb") ? "true" : "false") << std::endl;

  // 将仿函数用在算法中
  // ff()将仿函数用在算法中，不管是当成一个对象使用，还是用在算法中，
  // 都是先创建一个函数对象(仿函数)的实例，再调用operator()来实现逻辑
  std::vector<int> vec { 1, 2, 3, 4, 5 };
  std::list<std::string> ls { "abcdef", "cd" };
  ff ( vec, ls, 4, "c" );

  // 好了，新标准看到了函数指针的局限，就告诉我们还有仿函数，
  // 在某些情况下，新标准还告诉我们有个东西叫lambda
  // g() 中[&](int a) { return a < x; }这个就叫lambda表达式
  gg ( vec, ls, 2, "b" );

  // lambda中的[&]：
  // []被称为捕获列表，指出了lambda里面如何引用外面的变量
  // [] 表示不捕获
  // [&] 表示以引用的方式捕获外面的值 [=]表示以复制的方式捕获外面的值
  // [&x] 表示x变量以引用的方式捕获  [=x] 表示以复制的方式捕获
  // lambda 比较方便简洁 缺点是模糊
  // 对于琐碎的操作，使用lambda可以，对于不琐碎的操作，最好不好用lambda
}

// =======================================================================================

下面看一下模版中的可变参数

// =======================================================================================
// variadic templates

// 可变参数的个数不确定，类型也可以不一样，把这些参数称为参数包
// 主要的问题主要集中在如何拆包，下面演示递归拆包(其他的拆包方式(逗号拆包)可以google)


// 由于所有的测试例子都写在一个文件里，为了解决命名问题，使用了namespace
namespace var {

namespace {

// g() 主要是用来处理每一个具体的元素的
template <typename T>
void g ( const T& v ) {
  std::cout << "one of the variadic templates: " << v << std::endl;
}

// 递归的终结 这个不能少，少了就没有出来的了
// 这个是用空来终结，也可以用最后一个元素来终结
void f () {
}

// 逗号拆包
template <typename T>
void print ( const T& t ) {
  std::cout << "one of param list " << t << std::endl;
}

};

// 递归拆包
// typename... 中的省略号表示这是一个可变参数
// tail... 参数表示剩下的可变参数
template<typename T, typename... Tail>
void f ( T head, Tail... tail ) {
  g ( head );
  f ( tail... );
}

// 逗号拆包
// 原理一：a = (b = c, d); 根据逗号原理，先将c丢给b，然后将d丢给a；
// 原理二：初始化参数列表
// 利用新标准的新特性(初始化参数列表)，来初始化一个变长的数组
// 最后数组里的全是0，而初始化会被展开成print(arg0) print(arg1)...等
template <typename... Tail>
void t ( Tail... tail ) {
  int arr[] = { ( print ( tail ), 0 )... };
}

};

void test_var () {
  std::cout << std::endl << std::endl << "-------------------------- variadic templates test------------------------" << std::endl;

  var::f (1, 2, 3, "12", "abc", 12, 'c', 12.33);

  var::t ( "abd", "d", 'c', 2993.12, 12, 32, 0 );
}

// =======================================================================================

上面的例子中只解释了递归拆包和逗号拆包的方式，其中需要注意的是递归的结束，这个是不能省的，其次在递归中，是将头一个拿出来处理，剩下的继续走递归；而逗号拆包是利用初始化列表和逗号原理来实现。

若加上新标准(c++11的初始化列表、c++14的lambda)，进一步的还可以扩展很多，详情可以google

由于可变参数的高灵活性，在标准库中大量使用了这种方式。

别名
在模版中的别名之前也略提及，用法是
using AA = T; 在标准库中也是大量用到。

模版编译模型
编译期做的事