（Effective C++）第七章 模板与泛型编程 (Templates and Generic Programming)

C++template机制自身是一部完整的图灵机（Turing-complete）：它可以被用来计算任何可计算的值。于是导出了模板元编程（templatemetaprogramming），创造出“在C++编译器内执行并于编译完成时停止执行”的程序。

9.1 条款41：了解隐式接口和编译期多态 (Understand implicit interface and compile-time polymorphism)

面向对象编程世界总是以显示接口（explicit interfaces）和运行期多态（runtime polymorphism）解决问题。

class Widget{
public://函数显示接口
Widget();
virtual ~Widget();
virtual std::size_t size()const;
virtual void normalize();
void swap(Widget &other);
};
void doProccessing(Widget &w)
{
    if (w.size() > 10 && w!= someNastWidget){
     Widget temp(w);
     temp.normalize();
     temp.swap(w);
}
}
//改为模板
template <typename T>
void doProccessing(T &w)
{
    if (w.size() > 10 && w!= someNastWidget){
     T temp(w);
     temp.normalize();
     temp.swap(w);
}
}
示例9-1-1  模板
改成模板函数之前：
由于w的类型被声明为Widget，所以w必须支持Widget接口。
由于Widget的某些成员函数是virtual，w对那些函数的调用将表现出运行期多态（runtime polymorphism），也就是说将于运行期根据w的动态类型决定调用哪个函数。
改成模板函数之后：
Templates及泛型编程的世界，与面向对象有根本的不同，反倒是隐式接口（implicit interface）和编译期多态（compile-time polymorphism）移到前面了。
W必须支持哪一种接口，系由template中执行于w身上的操作来决定。本例w的类型是T必须支持size，normalize和swap成员函数，copy构造函数。这一组表达式便是T必须支持的一组隐式接口（implicit interface）。
凡是涉及w的任何函数调用，例如operator>和operator!=，有可能造成template具现化（instantiated），使这些调用得以成功。“以不同的template参数具现化function templates”会导致调用不同的函数，这就是所谓的编译期多态（compile-time polymorphism）。
运行期多态和编译期多态之间的差异，类似于“哪个重载函数被调用”（发生在编译期）和“哪个virtual函数被绑定”（发生在运行期）之间的差异。
通常显示接口由函数的签名式（也就是函数名称，参数类型，返回类型）构成。
隐式接口并不基于函数签名式，而是有效表达式（valid expression）组成。如本例doProccessing的template函数。
Classes和templates都支持接口（interface）和（polymorphism）。对于classes而言接口是显式的，以函数签名为中心，多态则通过virtual函数发生在运行期。对于tempate参数而言，接口是隐式的，奠基与有效表达式。多态则是通过template具现化和函数重载解析（function overloading resolution）发生于编译期。

9.2 条款42：了解typename的双重意义 (Understand the two meaning of typename)

以下template声明式中，class和typename有什么不同？
template<class> class Widget;    //使用“class”
template<typename> class Widget;    //使用“typename”
答案：没有不同。
假设我们需要打印容器的第二个元素，如下：

template <typename C>
void print2nd(const C &container)
{
    if (container.size() > 2){
     typename C::const_iterator iter(container.begin());
     ++iter;
int valude = *iter;
std::cout<<vaule;
}
}
示例9-2-1  print2nd模板
Template内出现的名称如果相依 与某个template参数，称为从属名称（dependent names）。如果从属名称在class呈嵌套状，称为嵌套从属名称（nested dependent names）。C::const_iterator就是这样一个名称。实际上，它还是一个嵌套从属类型名称（nested dependent type name），也就是个嵌套从属名称且指涉某类型。
Local变量value是一个并不依赖任何template参数的名称，称为非从属名称（non-dependent names）。
嵌套从属名称可鞥导致解析困难，编译器便假设这名称不是一个类型，除非你告诉它是。所以缺省情况下，嵌套从属名称不是类型。
C::const_iterator被编译器假设为非类型，所以前面需要加关键字typename。

template <typename C>   //允许使用typename或class
void f(const C &container,  //不允许使用typename
typename C::iterator iter)  //一定要使用typename
{
}

template <typename T>   //允许使用typename或class
class Derived:public Base<T>::Nested{  //base class list中不允许typename
public:
explicit Derived(int)
:Base<T>::Nested(x)     //mem.init.list不允许使用typename
{
typename Base<T>::Nested temp; //一定要使用typename
}
}
//假设写一个function template，它接收一个迭代器，而我们打算为该迭代器指涉
//的对象做一份local复件temp，如下
template <typename IterT>   //允许使用typename或class
void workWithInterator(IterT iter)  
{
    typename std::iterator_traits<IterT>::vaule_type temp(*iter);
}
示例9-2-2  typename用法
使用typename关键字标识嵌套从属类型名称；但不得在base class lists（基类列）或member initialization list（成员初始列）内以它作为base class修饰符。

9.3 条款43：学习处理模板化基类内的名称 (Know how to access names in templatized base class)

假设写一个程序，它能够传达信息到诺干不同的公司去。信息可能是加密的译文，可能是未经加工的文字。如果编译期间，有足够信息来决定哪一个信息传至哪家公司，就可以采用基于template解法：

class CompanyA
{
public:
void sendCleartext(const std::string &msg);
void sendEncrypted (const std::string &msg);
…
};
class CompanyB
{
public:
void sendCleartext(const std::string &msg);
void sendEncrypted (const std::string &msg);
…
};
…
class CompanyZ
{
public:
…        //这个class不提供sendCleartext
void sendEncrypted (const std::string &msg);
};
class MsgInfo {…};

template <typename Company>
class MsgSender
{
public:
void sendClear(const MsgInfo& info)
{
    std::string msg;
//根据info产生信息
Company c;
c.sendCleartext(msg);
}
}
Void sendSecret(const MsgInfo& info) //调用c.sendEncrypted
{…}
};
//后期需要记录日志
template <typename Company>
class LoggingMsgSender::public MsgSender<Company>
{
public:
void sendClearMsg(const MsgInfo& info)
{
    //将传送前的信息写至log
sendClear(info);
//将传送后的信息写至log
}
}
};
示例9-3-1  template解法
本例中，LoggingMsgSend调用base class函数sendClear将无法通过编译。当编译器遇到class template LoggingMsgSender定义式，并不知道它继承什么样的class。虽然它继承的是MsgSender<Company>，但是其中的Company并不知道是什么，就无法调用sendClear函数。一般性的MsgSender template对于CompanyZ并不适合，因为CompanyZ没有sendCleartext函数。与纠正这个问题，我们针对CompanyZ产生一个MsgSender特化版本。
template <> //一个全特化的MsgSender，
class MsgSender<CompanyZ>{ //他和一般的template的差别在于它删除了sendClear
public:
…
void sendSecret(const MsgInfo& info);
}
示例9-3-2  特化版
注意class定义式最前头的“template <>”语法是个特化版本的MsgSender template，在template实参是CompanyZ时被使用。
我们再来看LoggingMsgSender:: sendClearMsg函数，如果Company==CompanyZ，sendclear不存在，编译器往往拒绝在templatized base classes（模板化基类，本例的MsgSender<Company>）内寻找继承而来的名称。为了解决该问题，有三个办法：

//第一，在base class函数调用动作之前加上this->
template <typename Company>
class LoggingMsgSender::public MsgSender<Company>
{
public:
void sendClearMsg(const MsgInfo& info)
{
    //将传送前的信息写至log
this->sendClear(info);
//将传送后的信息写至log
}
}
};
//第二，使用using声明书
template <typename Company>
class LoggingMsgSender::public MsgSender<Company>
{
public:
using MsgSender<Company>::sendClear;
void sendClearMsg(const MsgInfo& info)
{
    //将传送前的信息写至log
sendClear(info);
//将传送后的信息写至log
}
}
};
//第三，明白指出被调用的函数位于base class内，
//但是，不提倡，因为它关闭virtual绑定行为
template <typename Company>
class LoggingMsgSender::public MsgSender<Company>
{
public:
void sendClearMsg(const MsgInfo& info)
{
    //将传送前的信息写至log
MsgSender<Company>::sendClear(info);
//将传送后的信息写至log
}
}
};

示例9-3-3  三个方法

9.4 条款44：将与参数无关的代码抽离templates (Factor parameter-independent code out of templates)

在non-template代码中，重复十分明确：你可以“看”到两个函数或两个classes之间有所重复。然而在template代码中重复是隐晦的：毕竟只存在一份template源码，所以你必须训练自己去感受当template被具现化多次时可能发生的重复。
假设你想为固定尺寸的正方矩阵编写一个template，该矩阵的性质之一是支持逆矩阵运算（matrix inversion）。

template <typename T,std::size_t n> //template支持n*n矩阵，
class SquareMatrix{
public:
…
void invert(); //求逆矩阵运算
};
SquareMatrix<double, 5> sm1;
sm1.invert();  //调用SquareMatrix<double, 5>::invert
SquareMatrix<double, 10> sm2;
sm2.invert();  //调用SquareMatrix<double, 10>::invert
示例9-4-1  正方矩阵求逆运算函数的与尺寸无关版本
本例会具现化两份invert。这些函数并非完全相同，因为其中一个操作是5*5矩阵而另一个操作的是10*10矩阵，但是除了常量5和10，两个函数的其它部分完全相同。这会引出代码膨胀。
下面是对SquareMatrix的第一次修改：
template <typename T>
class SquareMatrixBase{  //与尺寸无关的基类
protected: //避免derived classes代码重复
…
void invert(std::size_t matrixSize); //以给定的尺寸求逆矩阵
};
template <typename T, std::size_t  n>
class SquareMatrix::private SquareMatrixBase<T>{
private:
using SquareMatrixBase<T>:: invert; //避免这样base版的invert,条款33
public:
…
//制造inline，调用base版的invert
//不使用this->,就会使模板化基类内的函数名称会被derived类掩盖
void invert(){return this->invert(n);};
};
示例9-4-2  正方矩阵建立带数值参数的函数
但是还有一个问题没有解决，SquareMatrixBase<T>::invert如何知道哪个特定矩阵的数据在哪儿？一个方法是令SquareMatrixBase存储一个指针，指向矩阵数值所在的内存。
template <typename T>
class SquareMatrixBase{  //与尺寸无关的基类
protected: //避免derived classes代码重复
SquareMatrixBase(std::size_t n, T*pMem):size(n),pData(pMem){}
…
void invert(std::size_t matrixSize); //以给定的尺寸求逆矩阵
private:
std::size_t size;  //矩阵大小
T* pData;    //指针，指向矩阵数据
};
// derived classes之一
template <typename T, std::size_t  n>
class SquareMatrix::private SquareMatrixBase<T>{
private:
using SquareMatrixBase<T>:: invert; //避免这样base版的invert,条款33
T data[n*n];
public:
SquareMatrix():SquareMatrixBase<T>(n,data){}
…
//制造inline，调用base版的invert
//不使用this->,就会使模板化基类内的函数名称会被derived类掩盖
void invert(){return this->invert(n);};
};
// derived classes之二
template <typename T, std::size_t  n>
class SquareMatrix::private SquareMatrixBase<T>{
private:
using SquareMatrixBase<T>:: invert; //避免这样base版的invert,条款33
boost::scoped_array<T> pData;   //关于boost::scoped_array,条款13
public:
SquareMatrix():SquareMatrixBase<T>(n,0),  //将base class的数据指针设为NULL
pData(new T[n*n])      //将指向矩阵内存的指针存储起来
{ this->setDataPtr(pData.get());}  //将它的一个副本交给base class
…
//制造inline，调用base版的invert
//不使用this->,就会使模板化基类内的函数名称会被derived类掩盖
void invert(){return this->invert(n);};
};
示例9-4-3  正方矩阵求逆运算函数的与尺寸有关版本
此例硬是绑着矩阵尺寸的那个invert版本，有可能生成比共享版本更佳的代码。
从另一个角度看，不同大小的矩阵只拥有单一版本的invert，可减少指向文件大小，也就是降低程序的working set大小，并强化指令高速缓存的引用集中化，提高了效率。
另一个关心的主题是对象大小。如果你不介意，可将前述“与矩阵大小无关的函数版本”搬至base class内，这会增加每一个对象的大小。
Template生成多个classes和多个函数，所以任何template代码都不该与某个造成膨胀的template参数发生相依关系。
因非类型模板参数而造成的代码膨胀可以消除，做法是以函数参数或class成员变量替换template参数。

因类型而造成的代码膨胀，往往可以降低，做法是让带有完全相同二进制表述的具现类型共享实现吗。例如，如果你实现某些成员函数而它们的操作强型指针（strongly typed pointers，T*），你应该令他们调用另一个操作无类型指针（untyped pointers，void*）。某些C++STL实现版本的确为vector，deque和list等template做了这件事。

9.5 条款45：运用成员函数模板介绍所有兼容类型 (Use member function templates to accept "all compatible types")

所谓智能指针（Smart pointers）是“行为像指针”的对象，并提供指针没有的机能。真实指针做的很好的一件事，支持隐式转换（implicit conversions）。
如果想在用户自定的智能指针中模拟Derived class指针可以隐形转换为base class指针，或“指向non-const对象”的指针转为“指向const对象”等行为，如下：

class Top {…};
class Middle:public Top {…};
class Bottom:public Middle {…};
Top* p1 = new Middle;
Top* p2 = new Bottom;
const Top* pc2 = pt1;

template <typename T>
class SmartPtr{  
public:
template<typename U>
SmartPtr(const SmartPtr<U> & other):heldPtr(other.get())
{…}; //member template copy构造函数
T* get const{return heldPtr;};
…
private:
T* heldPtr;  //这个SmartPtr持有的内置原始指针
};
SmartPtr<Top> pt1 = SmartPtr<Middle>(new Middle);
SmartPtr<Top> pt2 = SmartPtr<Middle>(new Bottom);
SmartPtr<const Top> pt2 = pt1;
示例9-5-1  泛化copy构造函数
此例，我们是为了写一个构造目标，这样的模板是所谓member function templates，作用是为class生成函数。对于任何类型T和任何类型U，这里可以根据SmartPtr<U>生成一个SmartPtr<T>，因为SmartPtr<T>有个构造函数接收一个SmartPtr<U>参数。
我们使用成员初始列来初始化SmartPtr<T>之内类型为T*的成员变量。并以类型为U*的指针作为初值。这个行为只有当“存在某个隐式转换可将一个U*指针转为一个T*指针”时才能通过编译。
Member function templates的效用不限于构造函数，他们常扮演的另一个角色是支持赋值操作。参见shared_ptr的实现。
在class内声明泛化copy构造函数（一个template）并不会阻止编译器生成他们自己的copy构造函数（一个non-template）。
Member function templates（成员函数模板）生成可以接受所用兼容类型的函数。
如果你声明了Member templates用于泛化copy构造函数或泛化assignment操作，你还是需要声明正常的copy构造函数和copy assignment操作符。

9.6 条款46：需要类型转换时请为目标定义非成员函数 (Define non-member functions inside templates when type conversions are desired)

条款24讨论了为什么唯有non-member函数才有能力“在所有实参身上实施隐式类型转换”，该条款并以Rational class的operator*函数为例。本条款将Rational和operator*模板化了：

template<typename T>
class Rational {  
public:
Rational (const T& numerator = 0, //条款20，pass by reference
const T& denominator = 1);
       const T numerator() const; //条款28，pass by vaule
       const T denominator() const; //条款3，返回const
};
template<typename T>
const Rational<T> operator*(const Rational<T> &lhs,
const Rational<T> &rhs);
{
return Rational(lhs.numerator()*rhs.numerator(),
lhs.denominator ()*rhs.denominator());
}
Rational<int> oneHalf(1,2);  //a =1/2
Rational<int> result;
  result = oneHalf * 2;         //错误无法通过编译
示例9-6-1  Rational类的模板化
上述失败的启示是，模板化的Rational内的某些东西似乎和其non-template版本不同，这里编译器试图具现化某个“名为operator*并接受两个Rational<T>参数”的函数，但是不知道T是什么。原因在于，function template实参推到过程中从不将隐式类型转换函数纳入考虑，也就是没有考虑通过构造函数而发生的隐式转换。
Template class内的friend声明式可以指涉某个特定函数，这就意味class Rational<T>可以声明为operator*是它的一个friend函数。Class template并不依赖function template实参推导，所以编译器总能在class Rational<T>具现化时得知T。因此，令Rational<T> class声明适当的operator*为其friend函数：
template<typename T>
class Rational {  
public:
Rational (const T& numerator = 0, //条款20，pass by reference
const T& denominator = 1);
       const T numerator() const; //条款28，pass by vaule
       const T denominator() const; //条款3，返回const

friend const Rational operator*(const Rational &lhs,
const Rational &rhs);  //声明

};
template<typename T>
const Rational<T> operator*(const Rational<T> &lhs,
const Rational<T> &rhs);
{
return Rational(lhs.numerator()*rhs.numerator(),
lhs.denominator ()*rhs.denominator());
}

Rational<int> oneHalf(1,2);  //a =1/2
Rational<int> result;
  result = oneHalf * 2;         //通过编译，但不能链接
示例9-6-2  Rational类声明friend函数
在一个class template内，template名称可被用来作为“template和其参数”的简略表达方式，所以在Rational<T>内我们可以只写Rational而不必写Rational<T>。
template<typename T>
class Rational {  
public:
Rational (const T& numerator = 0, //条款20，pass by reference
const T& denominator = 1);
       const T numerator() const; //条款28，pass by vaule
       const T denominator() const; //条款3，返回const

friend const Rational operator*(const Rational &lhs,
const Rational &rhs);
{
return Rational(lhs.numerator()*rhs.numerator(),
lhs.denominator ()*rhs.denominator());
}
};
template<typename T>
const Rational<T> operator*(const Rational<T> &lhs,
const Rational<T> &rhs);
{
return Rational(lhs.numerator()*rhs.numerator(),
lhs.denominator ()*rhs.denominator());
}

Rational<int> oneHalf(1,2);  //a =1/2
Rational<int> result;
  result = oneHalf * 2;         //通过编译也能链接
示例9-6-3  Rational类定义friend函数
当我们编写一个class template，而他所提供之“与此template相关的”函数支持“所有参数之隐式转换”时，请讲那些函数定义于“class template内部的friend函数”。

此时friend函数的用途不再是访问class的non-public成分，而是让类型转换可能发生在所有实参身上。

9.7 条款47：请使用traits classes表现类型信息 (Use traits classes for information about types)

STL主要由“用以表现容器、迭代器和算法”的templates构成，但也覆盖若干工具，如advance，用来将某个迭代器移动某个给定距离：
template<typename IterT, typename DistT>
void advance(IterT &iter, DistT d);  //如果d<0，则向后移动
对于STL的5种迭代器专属的卷标接口（tag struct），如下：
struct input_iterator_tag{};
struct output_iterator_tag{};
struct forward_iterator_tag:public input_iterator_tag {};
struct bidirectinal_iterator_tag: public forward_iterator_tag {};
struct random_access_iterator_tag: public bidirectinal_iterator_tag {};
这些structs之间的继承关系是有效的is-a关系。Advance的实现
template<typename IterT, typename DistT>
void advance(IterT &iter, DistT d);
{
    if (iter is random access iterator){
        iter+=d;
}
    else{
    if (d > =0) { while (d--) ++iter;}
    else { while (d++) --iter;}
}
}
示例9-7-1  Advance的实现
这种做法需要知道IterT是否为random access迭代器分类。而Traits技术允许你在编译期间取得某些类型信息。这个技术的要求之一，它对内置类型和用户自定义类型的表现必须一样好。比如，上述advance收到的实参是一个指针和一个int，advance仍然必须有效运作。但是它，排除了类型内的嵌套信息。因此，类型的traits信息必须位于类型自身之外。标准技术是把它放进一个template及其多个特化版本中。下面template用来处理迭代器分类的相关信息：
template<typename IterT >
struct  iterator_traits;
这里的iterator_traits是个struct，又往往被称为traits classes。它的运作方式是，针对每一个类型IterT，在struct iterator_traits<IterT>内声明某个typedef名为iterator_category。这个typedef用确认IterT迭代器分类。例如：

template<…>
class deque {
public:
class iterator {
    typedef random_access_iterator_tag iterator_category;
};
};
template<…>
class list {
public:
class iterator {
    typedef bidirectinal_iterator_tag iterator_category;
};
};
template<typename IterT>
struct  iterator_traits {
    typedef  typename IterT::iterator_category iterator_category;
};
示例9-7-2 iterator_traits第一部分实现
此例iterator_traits对于用户自定义类型行得通，但是对指针行不通，因为指针不可能嵌套typedef。


template<typename IterT>
struct  iterator_traits< IterT *> {
    typedef  random_access_iterator_tag iterator_category;
};
示例9-7-2 iterator_traits第二部分实现
如何设计并实现traits class：
1）    确认若干你希望将来可取得的类型相关信息，例如对于迭代器而言，希望取得分类（category）。
2）    为该信息选择一个名称，例如iterator_category。
3）    提供一个template和一组特化版本，内含你希望支持的类型相关信息。
好了，我们对advice实践先前的为嘛：
template<typename IterT, typename DistT>
void advance(IterT &iter, DistT d);
{
    if (typeid(typname std::iterator_traits<IterT>::iterator_category)
== typeid(std::random_access_iterator_tag)){
}
。。。
}
IterT类型在编译期间获知，所以std::iterator_traits<IterT>::iterator_category也可在编译期间确定。
   把条件式改成重载：
template<typename IterT, typename DistT>
void doAdvance(IterT &iter, DistT d, std::random_access_iterator_tag);
{
   iter +=d;
}
void doAdvance(IterT &iter, DistT d, std::bidirectinal_iterator_tag);
{
 if (d > =0) { while (d--) ++iter;}
else { while (d++) --iter;}
}
void doAdvance(IterT &iter, DistT d, std::input_iterator_tag);
{
 if (d < 0) {thow std::out_of_range(“Negative distance”);}
else { while (d++) --iter;}
}
template<typename IterT, typename DistT>
void advance(IterT &iter, DistT d);
{
    doAdvance(
iter, d,   // 对iter之迭代器分类而言
typename  //必须的
std::Iterator_traits<IterT>::iterator_category());
}
示例9-7-3  Advance的再次实现
总结如何使用一个traits class了：
1）    建立一组重载函数(身份像劳工)或函数模板（例如doAdvance），彼此之间差异在于各自的traits参数。
2）    建立一个控制函数（身份像工头）或函数模板（例如advance），它调用哪些劳工函数并传递traits class所提供的信息。

9.8 条款48：认识template元编程 (Be aware of template metaprogramming)

Template metaProgramming（TMP，模板元编程）是编写template-based C++程序并执行于编译期的过程。所谓template metaprogram(模板元程序)是以C++写成、执行于C++编译器内的程序。
Template metaProgramming（TMP，模板元编程）可将工作由运行期移往编译期，因而得以实现早期错误侦查和更高的效率。
TMP可被用来生成“基于政策选择组合”（base on combination of policy choices）的客户定制代码，也可用来避免生成对某些特殊类型并不适合的代码。
其他见《Effective C++ 中文 第三版》P233。