05.模板和泛型编程

模板和泛型编程

条款41：了解隐式接口和编译期多态

理解条款41的关键点如下：

1. 隐式接口：隐式接口是指一个类或对象所提供的所有可用的成员函数和非成员函数，包括非虚函数、虚函数和重载函数。通过这些函数，对象向外部提供了一种使用的方式，形成了其隐式接口。

2. 编译期多态：编译期多态是通过函数重载和模板技术来实现的。在编译期间，编译器可以根据函数的参数类型和模板实例化的类型进行静态类型推导和函数匹配，从而选择调用合适的函数。这种多态性在编译期间解决，不涉及运行时的动态绑定。

3. 隐式接口和编译期多态的优势：理解隐式接口和编译期多态的概念可以提供更好的代码复用、可扩展性和可维护性。通过隐式接口，可以在不修改类定义的情况下添加新的功能和行为。通过编译期多态，可以在编译期间解决函数的调用问题，提高性能并避免运行时的开销。

4. 使用隐式接口和编译期多态：为了有效地利用隐式接口和编译期多态，应该遵循一些准则：

   • 尽量使用非成员函数，将算法和数据分离。
   • 使用函数重载来处理不同参数类型的操作。
   • 使用模板来实现通用的算法和数据结构。

条款42：了解typename的双重意义

理解条款42的关键点如下：

1. typename关键字的第一层意义：在C++模板中，当使用一个嵌套从属类型（nested dependent type）时，编译器无法确定这个从属类型是一个类型名（type name）还是一个静态成员变量（static member variable）。此时，需要使用typename关键字来明确告诉编译器这个从属类型是一个类型名。

2. typename关键字的第二层意义：在C++中，当定义模板的类型参数时，使用typename关键字来指定该参数是一个类型名。

3. typename的正确使用方式：在模板中，当使用从属类型时，如果编译器无法推断出这是一个类型名，需要使用typename关键字。例如：

template<typename T>
void foo() {
    typename T::NestedType* ptr; // 使用typename指定T::NestedType是一个类型名
    // 其他代码...
}

4. typename关键字的限制：typename关键字只能在模板中使用，用于指定从属类型是一个类型名。在非模板代码中，不需要使用typename关键字。

请记住：

1. 声明template参数时，前缀关键字class和typename可互换。
2. 请使用关键字typename标识嵌套从属类型名称；但不得在base class lists（基类列）或member initialization list（成员初值列）内以它作为base class 修饰符。

条款43：学习处理模板化基类内的名称

1、存在的问题：

template<typename T1>
class Class_A{
public:
	void send1(T1 var);
};

template <typename T1>
class Class_B:public Class_A< T1 >{
public:
	void send2(T1 var) { send1(var); } //编译错误，调用模板基类内函数失败
};

与普通继承的差别：在一般继承体系中，派生类可以调用基类方法，但模板继承中存在问题。

原因：由于base class template可能被特化，而特化版本可能不提供和一般性template模板相同的接口。因此编译器往往拒绝在templated base class（模板基类）内寻找继承而来的名称

例子：

template<>
class Class_A<Type_1>{ //特化模板类，类型为Type_1时的模板类
public:
	void send3(Type_1 var); // 该特化类中不存在send1函数
};

知识点：template<>为特化模板标志
现象：由于特化类中不存在send1函数，因此派生类调用该函数失败**。所以编译器由于知道基类模板可能被特化，使得接口不一致，所以禁止了这样的调用。**

2、解决方法：

解决方法的原理：对编译器承诺，base class template的任何版本（包括特化版本）都将支持一般版本所提供的的接口。

a）使用this->

template <typename T1>
class Class_B:public Class_A< T1 >{
public:
	void send2(T1 var) { this->send1(var); }  // 告诉编译器，假设send1被继承
};

b） 使用using声明

template <typename T1>
class Class_B:public Class_A< T1 >{
public:
	using Class_A< T1 >::send1; // 告诉编译器，send1在基类中
	void send2(T1 var) { send1(var); }  
};

C） 指明被调函数所在类：基类资格修饰符

template <typename T1>
class Class_B:public Class_A< T1 >{
public:
	void send2(T1 var) { Class_A< T1 >::send1(var); }  // 告诉编译器，send1在基类中
	// 此方法不好若send1为虚函数，则Class_A< T1 >::修饰会关闭virtual绑定行为
};

请记住：

1. 可在derived class templates内通过“this->”指涉base class template内的成员名称或藉由一个明白写出的“base class 资格修饰符”完成。

条款44：将与参数无关的代码抽离templates

template <typename T,std::size_t n>
class SquareMatrix{
public:
    ...
    void invert();
};

现在，考虑这些代码：

SquareMatrix<double,5) sm1;
...
sm1.invert();

SquareMatrix<double,10> sm2;
...
sm2.invert();

这样将会生成两份invert，这些函数并非完全相同，因为其中一个操作的是55矩阵而另一个是1010的矩阵，但除了常量5和10，两个函数的其他部分完全相同，这是templates引出代码膨胀的一个典型例子。

可以发现这两个函数完全相同，只除了一个使用5而另一个使用10，那你会怎么做？以5和10来调用这个带参数的函数，而不重复代码。下面我们来进行第一次对SquareMatrix的修改：

策略1：

template <typename T>
class SquareMatrixBase{
protected:
    ...
    void invert(std::size_t matrixSize);
    ...
};
template <typename T,std::size_t n>
class SquareMatrix:private SquareMatrixBase<T>{
private:
    using SquareMatrixBase<T>::invert;

public:
    ...
    void invert(){this->invert(n);}
};

带参数的invert位于base class SquareMatrixBase中，和SquareMatrix一样，SquareMatrixBase也是个template，不同的是它只对“矩阵元素对象的类型”参数化，不对矩阵的尺寸参数化，因此对于某给定之元素对象那个类型，所有矩阵共享同一个（也是唯一一个）SquareMatrixbase class，它们也将因此共享这唯一一个class内的invert。注意这些函数中我们使用“this->”标记，因为如果不这样做，便如条款43所讲的那样，模板化基类内的函数名称会被derived class掩盖，同时我们这儿使用private继承的原因是base class SquareMatrixBase只是为了帮助derived class SquareMatrix是实现，子类和父类之间不是“is-a”关系。

策略2：
针对SquareMatrixBase::invert的实现，我们该如何操作呢？解决办法是让SquareMatrixBase贮存一个指针，指向矩阵数值所在的内存，而只要它存储了这些东西，也就可能存储矩阵尺寸，如下：

template <typename T>
class SquareMatrixBase{
protected:
    SquareMatrixBase(std::size_t n,T* pMem):size(n),pDate(pMem){

    }
    void setDataPtr(T* ptr){pData=ptr;}
    ...
private:
    std::size_t size;
    T* pData;
};

这允许derived class中决定内存分配方式，这里我们针对derived class有两种分配方式：
1）存储指针数组，这样可能导致对象吱声超级大！！！

template <typename T,std::size_t n>
class SquareMatrix:private SquareMatrixBase<T>{
public:
    SquareMatrix():SquareMtrixBase<T>(n,data){}
    ...
private:
    T data[n*n];
};

2）把每一个矩阵的数据放进heap中，即通过new进行动态内存分配；

template <typename T,std::size_t n>
class SquareMatrix:private SquareMatrixBase<T>{
public:
    SquareMatrix():SquareMatrixBase<T>(n,0),pData(new T[n*n]){
    this->setDataPtr(pData.get());
    }
    ...
private:
    boost::scoped_array<T> pData;
};

1）non-type template parameters（非类型模板参数）：模板参数并不局限于类型，template <<>typename T,int n>或者template <<>typename T,size_t n>等等，第二个就是非类型模板参数！
2）type parameters：标准的类型模板参数，template <<>typename T>。

请记住：

1. template生成多个classes和多个函数，所以任何template代码都不应该与某个造成膨胀的template参数产生相依关系；
2. 因类型模板参数（non-type template parameters）造成的代码膨胀，往往可以消除，做法是以函数参数或者class成员变量代替template参数；
3. 因类型参数（type parameters）而造成的代码膨胀，往往可以降低，做法是让带有完全相同的二进制表搜狐的具现类型共享实现码。

条款45：运用成员函数模板接受所有兼容类型

一、添加成员函数模板

以一个例子引出，何时设计成员函数模板

• 第一步：我们知道指针的一个特点就是：支持隐式转换。
• 例如“指向non-const对象的指针可以转换为指向const对象”，“派生类指针可以隐式转换为基类指针”等等。代码如下：

class Top {};
class Middle :public Top {};
class Bottom :public Middle {};
 
Top* pt1 = new Middle;  //将Miffle*转换为Top*
Top* pt2 = new Bottom;  //将Bottom*转换为Top*
const Top* pct2 = pt1;  //将Top*转换为const Top*

• 第二步：假设现在我们设计一个模板，用来模仿智能指针类，并且希望智能指针能像普通指针一样进行类型转换。例如：

class Top {};
class Middle :public Top {};
class Bottom :public Middle {};
 
//自己设计的智能指针类
template<typename T>
class SmartPtr
{
public:
    explicit SmartPtr(T* realPtr);
};
 
int main()
{
    //下面是我们希望能完成的，但是还没有实现
    SmartPtr<Top> pt1 = SmartPtr<Middle>(new Middle);
    SmartPtr<Top> pt2 = SmartPtr<Bottom>(new Bottom);
    SmartPtr<const Top> pct2 = pt1;
 
    return 0;
}

• 第三步：根据上面的需求，我们希望让自己的智能指针类能像普通指针一样进行类型转换，那么我们可以为SmartPtr设计拷贝构造函数或拷贝赋值运算符，那么上面的功能就能实现了。

  • 一种低效的做法是：在SmartPtr模板中针对于每一个Top派生类定义一个拷贝构造函数和拷贝赋值运算符。但是这种做法十分低效，因为针对每一个派生类设计相对应的拷贝构造函数和拷贝赋值运算符会使class膨胀，并且如果将来加入新的派生类，那么还需要继续添加新的成员函数

• 第四步：另一种做法是：为 SmartPtr 模板添加一个成员函数模板

  • 例如：根据下面的拷贝构造函数，我们可以对任何类型T和任何类型U，将一个SmartPtr转换为SmartPtr
  • 下面的拷贝构造函数并未声明为explicit：因为原始指针类型之间的转换是隐式转换，如果我们的模板类型为原始指针，那么要支持这种隐式转换，因为我们并未声明explicit

template<typename T>
class SmartPtr
{
public:
    //拷贝构造函数，是一个成员函数模板
    typename<typename U>
    SmartPtr(const SmartPtr<U>& other);
};

• 根据上面的介绍我们可以知道，为类模板设计一个成员函数模板是为了进行统一性与间接性，避免冗余操作

二、约束成员函数模板的行为

• 在“一”中，我们为智能指针类设计了拷贝构造函数，这样就可以根据类型进行类型转换了

• 但是还有一些问题没有解决：

  • 那就是，对于类继承来说，派生类指针可以转换为基类指针，但是基类指针不能转换为派生类指针
  • 类似的，对于普通类型来说，我们不能将int*转换为double*

• 因此，即使我们设计了成员函数模板，那么还需要考虑一些转换的特殊情况（上面列出的）

解决方法

• 我们可以为自己的只能指针类提供一个类似于shared_ptr的get()成员函数，这个函数返回智能指针锁封装的那个原始指针

• 设计的代码如下：

  template<typename T>
  class SmartPtr
  {
  public:
      typename<typename U>
      SmartPtr(const SmartPtr<U>& other)
          :heldPtr(other.get())
      T get()const {
          return heldPtr;
      }
  private:
      T* heldPtr;
  };
  

• 此处设计的原理：

  • get()成员函数返回原始指针
  • 在拷贝构造函数中，我们使用了成员初始化列表来进行初始化智能指针封装的原始指针
  • 因此，在拷贝构造函数的构造过程中，是根据原始指针进行转换的，因此如果原始指针会自己判断这种转换行为：如果可以转换，那么拷贝构造函数就正确执行；如果不能转换，那么拷贝构造函数出错

三、设计赋值成员函数模板

• 我们上面设计的智能指针模板不限于构造函数，而且还可以自己设计赋值操作

演示说明

• 例如shared_ ptr：
  • 支持所有“来自内置指针、shared_ptr、auto_ptr、weak_ptr”的构造函数
  • 支持上面所有（出去weak_ptr）的赋值操作
• 例如下面是shared_ptr的源码摘录：（其中template参数强烈倾向使用class而不是typename）

template<class T>
class shared_ptr
{
public:
    //下面都是拷贝构造函数(列出了一部分)
    template<class Y>
    explicit shared_ptr(Y* p);
    template<class Y>
    shared_ptr(shared_ptr<Y> const& r);
    template<class Y>
    explicit shared_ptr(weak_ptr<Y> const& r);
    template<class Y>
    explicit shared_ptr(auto_ptr<Y>& r);

    //下面都是赋值操作(列出了一部分)
    template<class Y>
    shared_ptr& operator=(shared_ptr<Y> const& r);
    template<class Y>
    shared_ptr& operator=(auto_ptr<Y>& r);
};

• 代码说明：
  • 构造函数：都是explicit，除了“泛化copy构造函数”除外。因为从某个shared_ptr类型隐式转换为另一个shared_ptr是被允许的，但是从某个内置指针或从其他智能指针进行隐式转换为shared_ptr是不被允许的（除了使用cast进行强制类型转换）
  • auto_ptr：参数为auto_ptr的拷贝构造函数和赋值运算符，其参数都不是const的（条款13说过，当你赋值一个auto_ptr时，我们希望其所管理的对象被移动改动）

四、与默认函数的区别

• 我们曾说过，一个类如果没有提供构造函数、拷贝构造函数、拷贝赋值运算符，那么编译器会自动为类提供合成/默认的版本，这一规则同样适用于模板类
• 因此，例如我们上面为自己的类添加了成员函数模板（拷贝构造函数），那么当我们使用拷贝构造函数的时候是调用哪一个版本呢？答案为：根据实际调用情况选择
• 因此，如果我们自己设计成员函数模板还需要拷贝类为我们自己提供的合成版本，在必要时自己设计非成员函数模板
• 例如，下面是shared_ptr的源码摘录：

template<class T>
class shared_ptr
{
public:
    //拷贝构造函数
    shared_ptr (shared_ptr const& r);   //非泛化版本
    template<class Y>
    shared_ptr(shared_ptr<Y> const& r); //泛化版本
 
    //拷贝赋值运算符
    shared_ptr& operator=(shared_ptr const& r);    //非泛化版本
    template<class Y>
    shared_ptr& operator=(shared_ptr<Y> const& r); //泛化版本
};

五、总结

请记住：

• 请使用member function templates（成员函数模板）生成“可接受所有兼容类型”的函数
• 如果你生命member templates用于“泛化copy构造”或“泛化assignment操作”，你还是需要声明正常的copy构造函数和copy assignment操作符

条款46：需要类型转换时请为模板定义非成员函数

首先为什么类似于operator 这样的重载运算符要定义成非成员函数，主要是为了保证混合乘法2 Variant或者Variant * 2都可以通过编译，但是2不能同时进行隐式类型转换成某个Variant，再作this用。

所以我们一般将之定义成友元函数，像下面这样：

class Variant
{
public:
    Variant(const int& value = 0) {}
 
    friend const Variant operator* (const Variant&lhs, const Variant& rhs);
};
 
const Variant operator* (const Variant&lhs, const Variant& rhs) 
{
    return Variant();
}
 
//使用方式
Variant val(1);             //ok
Variant result = val * 1;   //ok
result = 2 * val;           //ok

现在引入模板，可以像下面这样写，注意这里的operator*是一个独立的模板函数：

template<typename T>
class Variant
{
public:
    Variant(const T& value = 0) {}
};
 
template<typename T>
const Variant<T> operator* (const Variant<T>&lhs, const Variant<T>& rhs)
{
    return Variant<T>();
}

但是这次不能通过编译并且在vs2015下的报错信息：

C2784   “const Variant<T> operator *(const Variant<T> &,const Variant<T> &)”: 未能从“int”为“const Variant<T> &”推导 模板 参数 

原因是编译器推导T出现了困难，val * 1在编译器看来，可以由a是Variant将T推导成int，但是1是什么，理想情况下编译器会尝试将它先转换成一个Variant，并将T推导成int，但事实上编译器在“T推导过程中从不将隐式类型转换函数纳入考虑”。所以无论是val * 1还是1 * val 都是不能通过编译的，一句话，隐式转换+推导T不能被同时被编译器接受。

解决问题的思路便接着产生，编译器既然不能同时接受这两个过程，就让它们事先满足好一个条件，再由编译器执行另一个过程好了。

如果把这个operator*放在template class里面，也就是先在生成模板类的那一步就定下T，这样编译器只要执行隐式转换这一步就可以了。

因此我们可以这样来改：

template<typename T>
class Variant
{
public:
    Variant(const T& value = 0) {}
 
    friend const Variant<T> operator* (const Variant<T>&lhs, const Variant<T>& rhs);
};

在类中加一个友元。

我们添加了一个友元函数的声明，果然编译通过了，但链接时又报错了，原因是链接器找不到operator*的定义，这里又要说模板类中的一个特殊情况了，它不同与普通的类，模板类的友元函数只能在类中实现，所以要把函数体部分移至到类内，像下面这样：

template<typename T>
class Variant
{
public:
    Variant(const T& value = 0) {}
 
    friend const Variant<T> operator* (const Variant<T>&lhs, const Variant<T>& rhs)
    {
        return Variant<T>();
    }
};

这下编译和链接都没有问题了。这里还要说一下，就是移至类内后，T的标识符可以不写了。

operator*里面只有一句话，但如果friend函数里面的东西太多了，可以定义一个辅助方法，比如Doxxx()，这个Doxxx可以放在类外去实现，Doxxx本身不支持混合乘法（2 * Variant或者Variant* 2），但由于在operator*里面已经进行了隐式类型转换，所以到Doxxx()这一级是没有问题的。

请记住：

• 当我们编写一个class template，而它所提供之“与此template相关的”函数支持“所有参数之隐式类型转换”时，请将那些函数定义为“class template内部的friend函数”。

条款47:请使用traits classes表现类型信息

1、如果想写一个将迭代器移动d单位的函数

template<template IterT,typename DistT>
void advance(IterT& iter,DistT d);//d>0前移，d<0后移

具体过程该怎么写呢？直接写 iter += d 是行不通的，因为这种只有random acces（随机访问）迭代器才支持+=的操作，而其他威力不那么强大的迭代器种类，advance必须反复施行 ++ 或 --，共d次。

2、STL迭代器一共有5类

• input迭代器：只能向前移动，一次一步，只能读取。例如，模仿指向输入文件的读指针(read pointer)。C++程序库中的istream_iterators是这一分类的代表。

• Output迭代器：只能向前移动，一次一步，只能写。例如，模仿指向输出文件的写指针(write pointer)。C++程序库中的ostream_iterators是这一分类的代表。

以上两种迭代器是威力最小的两个迭代器分类。因为一次只能一步，所以它们只适合“一次性操作算法”

• forward迭代器：可以做前述两种迭代器所能做的每一件事，而且可以读写其所指物一次以上，因此可施行于“多次性操作算法”，TR1 hashed容器可能是这一分类（这里说“可能”是因为hashed容器的迭代器可为单向也可为双向，取决于实现版本）。

• Bidirectional迭代器：除了可前移还可后移。STL的list迭代器就属于这一分类，set，multiset，map和multimap的迭代器也都是这一分类。

• random access迭代器：威力最大的迭代器，可以执行“迭代器算术”因此可在常量时间内前后随机移动任意的距离。 vector，deque和string提供的迭代器都是这一分类。有时内置指针也可被当做random access 迭代器使用。

对于这5类，C++标准库分别提供tag struct（卷标结构）加以确认

struct input_iterator_tag{};
struct output_iterator_tag{};
struct forward_iterator_tag :public input_iterator_tag{};
struct bidirectional_iterator_tag :public forward_iterator_tag{};
struct random_access_iterator_tag :public bidirectional_iterator_tag{};

在写advance函数时前4类迭代器可以使用++，–，而最后一个可以使用iter+=d,所以我们就需要在编译期取得类型信息，知道是哪一种迭代器.

3、解决方式就是利用iterator_traits

template<typename IterT> struct iterator_traits;//template,用来处理迭代器分类的相关信息

iterator_traits的运作方式是，针对每一个IterT,在struct iterator_traits<IterT>内一定声明某个typedef名为iterator_category。这个typedef用来确认IterT的迭代器分类。即首先要求用户自定义的迭代器类型必须嵌套一个typedef，名为iterator_category,用来确认适当的卷标结构

例如

template<...>
class deque{
public:
	class iterator{
	public:
		typedef random_access_iterator_tag iterator_category;
	};
};

iterator_traits只是响应iterator class的嵌套式typedef

template<typename IterT>
struct iterator_traits{
	typedef typename IterT::iterator_category iterator_category;
};
//针对指针,偏特化
template<typename IterT>
struct iterator_traits<IterT*>{
	typedef typename IterT::iterator_category iterator_category;
};

迭代器移动函数可这样实现

template<typename IterT,typename DistT>
void doAdvance(IterT& iter, DistT d, std::bidirectional_iterator_tag)
{
	if (d >= 0) 
	{
		while (d--)
			++iter;
	}
	else
	{
		while (d++)
			--iter;
	}
}
template<typename IterT, typename DistT>
void doAdvance(IterT& iter, DistT d, std::input_iterator_tag)
{
	if (d < 0)
		throw std::out_of_range("Negative distance");
	while(d--) ++iter;
}
template<typename IterT, typename DistT>
void advance(IterT& iter, DistT d)
{
	doAdvance(iter, d, typename std::iterator_traits<IterT>::iterator_category);
}

请记住

• Traits classes使得“类型相关信息”在编译期可用。它们以templates和“templates特化”完成实现
• 整合重载技术后，traits classes有可能在编译期对类型执行if…else测试

条款48：认识template元编程

1、内容

1. template metaprogramming（TMP，模板元编程）是：编写 template C++ 程序并执行于编译期的过程。所谓模板元程序就是：以 C++ 写成，执行于 C++ 编译器内的程序。该程序执行后产生具现的代码，和正常代码一并加入编译。也就说元编程可以做到用代码去生成代码。

2. TMP 伟大之处在于，由于 template metaprograms 执行于 C++ 编译期，因此可以将很多工作从运行期转移到编译期。例如：

   • 某些错误原本通常在运行期才能检测到，现在可在编译器找出来。

   • 使用 TMP 的 C++ 程序可能在每一方面都更加高效：比如较小的可执行文件，较短的运行期，较少的内存需求。

3. 在条款 47 我们曾提到如何实现一个 Move 函数：

   template <typename IteratorType>
   void Move(IteratorType& Iterator, int Distance) {
       // 使用类型信息
       if (typeid(IteratorTraits<IteratorType>::IteratorTag) == typeid(RandomAccessIteratorTag)) {   
           Iterator += Distance;
       }
       else {
           if (Distance >= 0) {
               while (Distance--)++Iterator;
           }
           else {
               while (Distance++)--Iterator;
           }
       }
   }
   

   并且我们曾描述这可能存在编译问题，现在就让我们看看是什么：虽然我们这里根据迭代器类型进行不同的操作，或 +=，或 ++，–，我们知道只有 Random Access Iterator 可以有 += 运算，但是 C++ 要求：编译器必须确保所有源码都有效，即使是不会执行的源码。也就是说编译器会拿着其他不支持 += 的迭代器，进入 if 语句先测试是否支持 += 运算，无效则会报错。

   所以相比于要支持所有操作，Traits class 针对不同类型进行函数重载的做法显然更好。

4. 我们先简单了解一下 TMP 编程。TMP 已被证明是一个图灵完备（Turing-complete）机器，这意味着它可以计算任何事物，使用 TMP 你可以声明变量，执行循环，编写及调用函数…但这些相对于正常的 C++ 的实现会有很大的不同。比如：TMP 并没有循环部件，所有的循环效果都由递归完成。如果你不了解递归，恐怕必须先解决这个问题。

5. 一个经典的入门案例是使用 TMP 计算阶乘：

   template <unsigned N>
   struct Factorial {
       static const int Value = N * Factorial<N - 1>::Value;
   };
   
   template <>
   struct Factorial<0> {
       static const int Value = 1;
   };
   
   inline void TryWithFactorial() {
       std::cout << Factorial<10>::Value << "\n";
   }
   

   和所有递归行为一样，我们需要一个特殊情况来结束递归。对于 TMP 而言就是使用 template 的特化版本。

   正如 TryWithFactorial 函数所使用的，只要你声明Factorial<N>::Value 就可以得到 N 阶乘值。当然这里存在值溢出的问题。

6. TMP 目前是一个新生的技术，语法不直观，也缺少 template 相关的调试器，但它将运行期工作移至编译期所带来的效率提升还是很令人印象深刻。

2、 总结

请记住：

• Template metaprogramming（TMP，模板元编程）可将工作由运行期移往编译期，因而得以实现早期错误侦测和更高的执行效率。
• TMP 可被用来生成基于政策选择组合（based on combination of policy choices）的客户定制代码，也可用来避免生成对某些特殊类型并不合适的代码。