以上这种行为只有当“存在某个隐式转换可将一个U* 指针转换为一个T * 指针”时才能通过编译。

下面是TR1规范中关于tr1::shared_ptr ,的一份摘录，其中强烈倾向声明template 参数时采用关键字class而不是 typename。

template
class shared_ptr
{
public:template//构造，来自任何兼容的内置指针explicit shared_ptr(Y* p);//内置指针template shared_ptr(shared_ptr const &r);//或shared_prttemplate explicit shared_ptr(weak_ptr const &r);//或weak_ptr template explicit shared_ptr(auto_ptr const &r);//或auto_ptr      template shared_ptr& operator=(shared_ptr const &r);//赋值，来自任何兼容的shared_prt或auto_ptrtemplate shared_ptr& operator=(auto_ptr &r);//赋值，来自任何兼容的shared_prt或auto_ptr//。。。
};

上述所有构造函数都是explicit, 唯有“泛化copy构造函数”除外。那意味从某个shared_ptr类型隐式转换至另一个shared_ptr 类型是被允许的，但从某个内置指针或从其它智能指针类型进行隐式转换则不被认可（如果是显式转换如cast 强制类型动作倒是可以）。

在class内声明一个copy构造函数（是个member template）并不会阻止编译器生成它们自己的copy构造函数（一个non-template）,所以如果你想要控制copy构造的方方面面，你必须同时声明泛化copy 构造函数和 “正常的”copy构造函数。相同规则也适用于赋值操作。下面是tr1::shared_ptr的一份定义摘要，例证上述所言：

template
class shared_ptr
{
public:shared_ptr(shared_ptr const &r);//copy构造函数template//泛化copy构造函数shared_ptr(shared_ptr const& r);shared_ptr &operator=(shared_ptr const &r);//copy assignmenttemplate//泛化 copy assignmentshared_ptr &operator=(shared_ptr const &r);//。。。
};

请记住：
1、请使用成员函数模板生成“可接受所有兼容类型”的函数
2、如果你声明member template用于“泛化copy构造”或“泛化assignment操作”,你还是需要声明正常的copy构造函数和copy assignment 操作符。

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

下面例子

template
class Rational
{
public:Rational(const T& numerator =0,const T & denominator =1);const T numerator() const;const T denominator() const;//...
};
template
const Rational operator *(const Rational& lhs,const Rational& rhs)
{//...
}Rational oneHalf(1,2);
Rational result = oneHalf *2;//错误，无法通过编译

因为在template实参推导过程中从不将隐式类型转换函数纳入考虑。

在template class内的friend 声明式可以指涉某个特定函数。那意味着class Rational 可以声明operator* 是它的一个friend函数。class template 并不依赖template 实参推导，所以编译器总是能够在class Rational具现化时得知T .。因此，令Rational class 声明适当的operator* 为其friend 函数，可以简化整个问题。

template
class Rational
{
public:Rational(const T& numerator =0,const T & denominator =1);const T numerator() const;const T denominator() const;//...friend const Rational operator *(const Rational& lhs,const Rational& rhs);
};
template
const Rational operator *(const Rational& lhs,const Rational& rhs)
{//...
}

现在对operator* 的混合式调用可以通过编译了，因为当对象oneHalf被声明为一个 Rational ,class Rational于是被具现化出来，而作为过程的一部分，friend函数 operator* (接受Rational 参数)也就被自动声明出来。后者作为一个函数而非函数模板，因此编译器可在调用它时使用隐式转换函数，而这便是混合式调用之所以成功的原因。

本例中的operator*被声明为接受并返回Rationals(而非Rationals) .。如果它被声明如下，一样有效:

template
class Rational
{
public:Rational(const T& numerator =0,const T & denominator =1);const T numerator() const;const T denominator() const;//...friend const Rational operator *(const Rational& lhs,const Rational& rhs);
};

最简单的可行方法就是将operator*函数本体合并至声明式内：

template
class Rational
{
public:Rational(const T& numerator =0,const T & denominator =1);const T numerator() const;const T denominator() const;//...friend const Rational operator *(const Rational& lhs,const Rational& rhs){return Rational(lhs.numerator()* rhs.numerator(),lhs.denominator()* rhs.denominator());}
};

为了令类型转换可能发生于所有实参身上，我们需要一个non-member函数；为了令这个函数被自动具现化，我们需要将它声明在class内部；而在class内部声明non-member 函数的唯一办法就是：令它成为一个friend 。

template class Rational;//声明Rational templatetemplate
const Rational doMultiply(const Rational& lhs,  const Rational& rhs);//声明helper templatetemplate
class Rational
{
public:Rational(const T& numerator =0,const T & denominator =1);const T numerator() const;const T denominator() const;//...friend const Rational operator *(const Rational& lhs,const Rational& rhs){return doMultiply(lhs,rhs);}
};
//许多编译器实质上会强迫你把所有template 定义式放进头文件内，所//以你或许需要在头文件内定义doMultiply
template
const Rational doMultiply(const Rational& lhs,  const Rational& rhs)//函数定义
{return Rational(lhs.numerator()* rhs.numerator(),lhs.denominator()* rhs.denominator());
}

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

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

定义一个template函数，名为advance，用来将某个迭代器移动某个给定距离：

template//将迭代器向前移动单位
void advance(IterT& iter,DistT d);//如果d < 0 则向后移动。 

STL有五类迭代器，分别是input迭代器、output迭代器、forward迭代器、Bidirectional迭代器、random accecc迭代器；C++标准程序库分别提供专属的卷标结构加以确认：

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{};

这些structs之间的继承关系是有效的is-a关系：所有的forward 迭代器都是input迭代器，依此类推。很快我们会看到这个继承关系的效力。

实现advance的策略之一是采用“最低但最普及”的迭代器能力，以循环反复递增或递减迭代器。但是这种做法耗费线性时间。我们知道random access 迭代器支持迭代器算术运算，只耗费常量时间，因此如果面对这种迭代器，我们希望运用其优势。

advance的实现方式如下：

template
void advance(IterT& iter,DistT d)
{if(iter is a random access iterator){iter += d;//针对random access 迭代器使用迭代器算术运算}else {if(d>=0){ while (d--) {++iter;//针对其它迭代器分类}}else {while (d++) {--iter;//反复调用 ++ 或 --}}}}

traits ,它们允许你在编译期间取得某些类型信息。

因此类型的traits信息必须位于类型自身之外。

template//template 用来处理
struct iterator_traits;//迭代器分类的相关信息

如你所见，iterator_traits 是个struct,习惯上traits总是被实现为tructs, 但它们又被称为traits class .。

iterator_traits 的运作方式是，针对每一个类型IterT ,在struct iterator_traits< IterT >内一定声明某个typedef 名为iterator_category 。这个typedef用来确认IterT的迭代器分类。
iterator_traits 以两部分实现上述所言。首先它要求每一个“用户自定义的迭代器类型”必须嵌套一个typedef ， 名为iterator_category ，用来确认适当的卷标结构。
例如下面的queue:

template<...>//略而未写template参数
class deque{
public:class iterator{public:typedef random_access_iterator_tag iterator_category;//...};//...
};

list 的实现如下：

template<...>//略而未写template参数
class list{
public:class iterator{public:typedef bidirectional_iterator_tag iterator_category;//...};//...
};

iterator_traits例子如下：

//类型IterT 的iterator_category其实就是用来表现 “IterT说它自己是什么”
//关于 “typedef typename”的运用，见条款42
template
struct iterator_traits
{typedef typename IterT::iterator_category iterator_category; 
};

上面的例子针对指针行不通，下面是iterator_traits为指针指定的迭代器类型

template//template 偏特化
struct iterator_traits //针对内置指针
{typedef random_access_iterator_tag iterator_category;};

如何设计并实现一个traits class：
1、确认若干你希望将来可取得的类型相关信息。例如对迭代器而言，我们希望将来可取得其分类（ category）。
2、为该信息选择一个名称（例如 iterator_category）。
3、提供一个template 和一组特化版本（例如稍早说的iterator_traits），内含你希望支持的类型相关信息。
下面实现advance 的伪代码：

template
void advance(IterT& iter,DistT d)
{if(typeid (typename std::iterator_traits::iterator_category)==\typeid (std::random_access_iterator_tag))//..
}

但是，以上代码“if(typeid (typename std::iterator_traits::iterator_category)==
typeid (std::random_access_iterator_tag))”会导致编译问题。
下面doAdvance函数替换其功能：

template
void advance(IterT& iter,DistT d)
{if(typeid (typename std::iterator_traits::iterator_category)==\typeid (std::random_access_iterator_tag))//..
}
template//这份实现用于random access 迭代器
void doAdvance(IterT& iter,DistT d,std::random_access_iterator_tag)
{iter +=d;    
}template//这份实现用于bidirectional 迭代器
void doAdvance(IterT& iter,DistT d,std::bidirectional_iterator_tag)
{if(d >= 0){while (d--) {++iter;}}else {while (d++) {--iter;}}}
template//这份实现用于input 迭代器
void doAdvance(IterT& iter,DistT d,std::input_iterator_tag)
{if(d<0){throw std::out_of_range("Negative distance");}while (d--) {++iter;}}

有了这些重载doAdvance版本，advance需要做的只是调用它们并额外传递一个对象，后者必须带有适当的迭代器分类。

于是编译器运用重载解析机制调用适用的实现代码：

template
void advance(IterT& iter,DistT d)
{doAdvance(iter,d,typename std::iterator_traits::iterator_category());//调用的doAdvance版本，对iter之迭代器分类而言必须是适当的。
}

现在我们可以总结如何使用一个traits class了：
1、建立一组重载函数（身份像劳工）或函数模板（例如doAdvance），彼此间的差异只在于各自的traits参数。令每个函数实现码与其接受之traits信息相应和。

2、建立一个控制函数（身份像工头）或函数模板（例如advance），它调用上述那些“劳工函数”并传递traits class所提供的信息。

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

条款48：认识template元编程

模板元编程（TMP）有两个伟大的效力。第一，它让某些事情更容易。第二，由于TMP执行于C++ 编译期，因此可将工作从运行期转移到编译期。这导致的一个结果是，某些错误原本通常在运行期才能侦测到，现在可在编译期找出来。另一个结果是，使用TMP的C++程序可能在每一个方面都更高效：较小的可执行文件、较短的运行期、较少的内存需求。然而将工作从运行期转移至编译期的另一个结果是，编译时间变长了。

这是STL advance的伪代码：

template
void advance(IterT& iter,DistT d)
{if(iter is a random access iterator){iter += d;//针对random access 迭代器使用迭代器算术运算}else {if(d>=0){ while (d--) {++iter;//针对其它迭代器分类}}else {while (d++) {--iter;//反复调用 ++ 或 --}}}}

我们使用typeid让其中的伪代码成为真实的代码，取得C++对此问题的一个“正常”解决方案——所有工作都在运行期进行：

template
void advance(IterT& iter,DistT d)
{if(typeid (typename std::iterator_traits::iterator_category)==\typeid (std::random_access_iterator_tag)){iter += d;//针对random access 迭代器使用迭代器算术运算}else {if(d>=0){ while (d--) {++iter;//针对其它迭代器分类}}else {while (d++) {--iter;//反复调用 ++ 或 --}}}}

条款47指出。这个typeid—based解法的效率比traits解法低，因为在此方案中（1）类型测试发生于运行期而非编译期，（2）“运行期类型测试”代码会出现在（或者说被连接于）可执行文件中。实际上这个例子展示了TMP如何能够比 “正常的”C++程序效率更高效，因为traits解法就是TMP。

advance的typeid—based实现方式可能导致编译期问题，下面就是个例子：

 std::list::iterator_traits iter;//..advance(iter ,10);//移动iter向前走10个元素；上述实现无法通过编译。

下面这一版advance便是针对上述调用而产生的。将template参数IterT 和DistT 分别替换为iter和10的类型之后，我们得到这些：

void advance( std::list::iterator_traits & iter,int d)
{if(typeid (typename std::iterator_traits::iterator_category)==\typeid (std::random_access_iterator_tag)){iter += d;//错误}else {if(d>=0){ while (d--) {++iter;//针对其它迭代器分类}}else {while (d++) {--iter;//反复调用 ++ 或 --}}}}

list::iterator_traits 是bidirectional迭代器，并不支持+= ，只有random access迭代器才支持+=；

TMP的起手程序是在编译期计算阶乘。TMP的阶乘运算示范如何通过“递归模板具现化”实现循环，以及如何在TMP中创建和使用变量，例如下面代码：

template//一般情况Factorial的值是 n乘以Factorial的值
struct Factorial{enum{value =n*Factorial::value;};
};
template<>
struct Factorial<0>//特殊情况：Factorial<0> 的值是1
{enum{ value=1};
};int main()
{std::cout<::value;//输出120std::cout<::value;//输出3628800return 0;
}

TMP可以达成以下三个目标：
1、确保量度单位正确。
2、优化矩阵计算。
3、可以生成客户定制之设计模式实现品。

请记住：
1、模板元编程可将工作由运行期移往编译期，因而得以实现早期错误侦测和更高的执行效率。
2、模板元编程可以被用来生成“基于政策选择组合”的客户定制代码，也可以用来避免生成对某些特殊类型并不适合的代码。