转：《C++ Templates》读书笔记

有三种模板参数（形参）：

（1）类型参数（这是使用得最多的）
（2）非类型参数
（3）模板的模板参数
类型参数:

  类型参数是通过关键字typename或者class引入。关键字后面必须是一个简单的标识符，后面用逗号来隔开下一个参数声明，等号代表接下来的是缺省模板实参，一个封闭的尖括号（>）表示参数化子句的结束。

  在模板声明内部，类型参数的作用类似于typedef名称。例如，如果T是一个模板参数，就不能使用诸如class T等形式的修饰名称，即使T是一个要被class类型替换的参数也不可以。 

   非类型参数表示的是：在编译期或链接期可以确定的常值（模板的模板参数也不属于类型模板参数，但讨论非类型模板参数时，并不考虑模板的模板参数）。这种参数的类型必须是下面的一种：

       1. 整型或者枚举类型
       2. 指针类型（包含普通对象的指针类型、函数指针类型、指向成员的指针类型）
       3. 引用类型（指向对象或者指向函数的引用都是允许的）

  所有其他的类型现今都不允许作为非类型参数使用（但在将来很可能会增加浮点数类型）。在某些情况下，非模板参数的声明也可以使用关键字typename：

template <typename T, typename T::Allocator* Allocator>
class List;

  这两个参数的区别在于：第1个typename后面是一个简单标识符T，而第2个typename后面是一个受限的名称（即是一个包含双冒号 :: 的名称)，它表示Allocator是属于T的一个子类型。

   函数和数组类型也可以被指定为非模板参数，但要把它们先隐式地转换为指针类型，这种转型也成为decay：

template <int buf[5]> class Lexer;               // buf实际上是一个int* 类型
template <int* buf> class Lexer;                  // 这是上面的重新声明

  非类型模板参数的声明和变量的声明很相似，但它们不能具有static、mutable等修饰符；只能具有const和volatile[1]限定符。但如果这两个限定符限定的如果是最外层的参数类型，编译器将会忽略它们：

template <int const length> class Buffer;           //  const在这里是没用的，被忽略了
tempalte <int length> class Buffer;                    // 和上面等价

  最后，非类型模板参数只能是右值：它们不能被取址，也不能被赋值。

模板的模板参数：

    模板的模板参数是代表类模板的占位符。它的声明和类模板的声明很类似，但不能使用关键字struct和union：

 template <template<typename X> class C>     //正确
 void f(C<int>* p);

 template <template<typename X> struct C>     //错误
 void f(C<int>* p);

 template <template<typename X> union C>     //错误
 void f(C<int>* p);

  在它们声明的作用域中，模板的模板参数的用法和类模板的用法很类似。模板的模板参数的参数（如下面的A）可以具有缺省模板实参。显然，只有在调用时没有指定该参数的情况下，才会应用缺省模板实参： 

    现今，只有类模板声明才能具有缺省模板实参。任何类型的模板参数都可以拥有一个缺省实参，只要该缺省实参能够匹配这个参数就可以。显然，缺省实参不能依赖于自身的参数；但可以依赖于前面的参数：

template <typename T, typename Allocator = allocator<T> >
class List;              // 就是说，allocator<T>不能依赖于本身参数Allocator，但是能依赖于前面参数T

       与缺省的函数调用参数的约束一样，对于任一个模板参数，只有在之后的模板参数都提供了缺省实参的前提下，才能具有缺省模板实参。后面的缺省值通常是在同个模板声明中提供的，但也可以在前面的模板声明中提供。下面的例子说明了这一点：

[1] 关于volatile，它的作用在于限定一个对象可以被外部进程（操作系统、硬件或并发进程等）改变，声明的语法如下：    
   int volatile nVint;

《C++ Templates》读书笔记（二）：模板实参

2009-08-17 17:45

tempalte <typename T>
void clear (T p)
{
       *p = 0;                // 要求单目运算符*可以用于类型T
}
int main()
{
      int a;
      clear(a);               // 错误：int类型并不支持但不运算符*
}

非类型实参：

tempalte <typename T, T nontype_parm>
class C;
C<int, 33>* c1;               // 整型
int a;
C<int*, &a>* c2;              // 外部变量地址
void f();
void f(int);
C<void(*)(int), f>* c3;       // 函数名称。在这个例子中，重载解析会选择f(int)，f前面的&隐式省略了
class X {
 public:
        int n;
        static bool b;
};
C<bool&, X::b>* c4;        // 静态类成员是可取的变量（和函数）名称
       C<int X::*, &X::n>* c5;      // 指向成员的指针常量
       template <typename T>
       void templ_func();
 C<void(), &templ_func<double> >* c6;        // 函数模板实例同时也是函数

    模板实参的一个普遍约束是：在程序创建的时候，编译器或者链接器要能够确定实参的值。如果实参的值要等到程序运行时才能够确定（譬如，局部变量的地址），就不符合“模板是在程序创建的时候进行实例化”的概念了。

template <char const* str>
class Message;
extern char const hello[] = "Hello World!";
Message<hello>* hello_msg;

#include <list>
       // List 的声明：
       //      namespace std {
       //             template <typename T, typename Allocator = allocator<T> >
        //             class list;
       //       }

 tempalte <typename T1, typename T2,
                             tempalte<typename> class Container>
                                                     // Container期望的是只具有一个参数的模板
 class Relation {
    public:
         …
    private:
         Container<T1> dom1;
         Container<T2> dom2;
 };
 int main()
 {
         Relation<int, double, std::list> rel;    // 错误，std::list是一个具有两个参数的模板
         …
  }

   这里的问题是：标准库中的 std::list模板具有两个参数，它的第2个参数（我们称之为内存配置器 allocator）具有一个缺省值；但当我们匹配 std::list和 Container参数时，事实上并不会考虑这个缺省值（即认为缺省值并不存在）。

#include <memory>
tempalte <typename T1, typename T2,
                             tempalte<typename T, typename = std::allocator<T> > class Container>
                                              // Container现在就能够接受一个标准容器模板了
class Relation {
    public:
         …
    private:
         Container<T1> dom1;
         Container<T2> dom2;
 };

  显然，这并不是一个令人满意的解决方案，但它可以让标准容器模板得到使用。另外我们注意到了一个事实：从语法上讲，只有关键字 class才能被用来声明模板的模板参数；但是这并不意味着只有用关键字 class声明的类模板才能作为它的替换实参。实际上，“ struct模板”、“ union模板”都可以作为模板的模板参数的有效实参。这和我们前面所提到的事实很相似：对于用关键字 class声明的模板类型参数，我们可以用（满足约束的）任何类型作为它的替换实参。