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

Templates能够节省时间和避免代码反复。对于相似的classes或functions。能够写一个class template或function template，让编译器来做剩余的事。这样做，有时候会导致代码膨胀（code bloat）：其二进制码带着反复（或差点儿反复）的代码、数据。或者两者。

但这时候源代码看起来可能非常整齐。

先来学习一个名词：共性与变性分析（commonality and variability analysis）。

比較easy理解。比如，你在编写几个函数，会用到同样作用的代码。这时候你往往将同样代码搬到一个新函数中。给其它几个函数调用。同理，假设编写某个class。当中某些部分和另外几个class同样，这时候你不会反复编写这些同样部分，仅仅需把共同部分搬到新class中去就可以，去使用继承或复合（**条款**32,38,39），让原先的classes取用这些共同特性，原classes的互异部分（变异部分）仍然留在原位置不动。

编写templates时，也要做同样分析，避免反复。non-template代码中反复十分明白：你能够看到两个函数或classes之间有所反复。可是在template代码中，反复是隐晦的。由于仅仅有一份template源代码。

比如。你打算在为尺寸固定的正方矩阵编写一个template，该矩阵有个支持逆矩阵运算的函数

 template<typename T, std::size_t n>//T为数据类型。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

上面会详细化两份invert。

这两份函数差点儿全然同样（除了一个操作5*5矩阵。一个操作10*10）。这就是代码膨胀的一个典型样例。

上面两个函数除了操作矩阵大小不同外。其它同样。这时能够为其建立一个带数值的函数，而不是反复代码。于是有了对SquareMatrix的第一份改动：

 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();//编码遮掩base中的invert，**条款**33
    public:
    ……
        void invert()//求逆运算
            {
                this->invsert(n);//稍后解释为什么用this
            }
    };

SquareMatrixBase::invert仅仅是企图避免derived classes代码反复，所以它以protected替换public。这个函数使用this->，由于模板化基类内的函数名称会被derived classes掩盖（条款**43）。

注意，SquareMatrixBase和SquareMatrix之间继承关系是private。这说明base class是为了帮助derived classes实现，两者不是**is-a关系。

如今另一个问题，SquareMatrixBase::invert操作的数据在哪？它在參数中直到矩阵大小，可是矩阵数据derived class才知道。derived class和base class怎样联络？一个做法是能够为SquareMatrixBase::invert加入一个參数（比如一个指针）。

这个行得通，可是考虑到其它因素（比如，SquareMatrixBase内还有其它函数。也要操作这些数据），能够把这个指针加入到SquareMatrixBase类中。

    template<typename T>
    class SquareMatrixBase{
    protected:
        SquareMatirxBase(std::size_t n,T* pMem)
        :size(n), pData(pMem){}
        void setDataPtr(T* ptr) {pData=ptr;}
        ……
    private:
        std::size_t size;
        T* pData;
    };
    template<typename T, std::size_t n>
    class SquareMatrix:private SquareMatrixBase<T>{
    public:
        SquareMatrix()
        :SquareMatrixBase<T>(n, data){}
        ……
    private:
        T data[n*n];
    };

这样的类型的对象不须要动态分配内存。可是对象自身可能非常大。另一个做法是把矩阵数据放到heap

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

这样以来。类型同样的derived classes会共享base class。比如。SquareMatrix

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

在模板中，详细化模板參数后的类不会由于详细化类型而存在派生关系。来看一个关于指针的样例。真实指针支持隐式转换（implitic conversions）。derived class指针能够隐式转换为base class指针，指向non-const对象的指针能够转换为指向const对象的指针，等等。比如：

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

假设使用模板定义智能指针，上面的转换就有点麻烦了

    template<typename T>
    class SmartPrt{
    public:
        explicit SmartPtr(T* realPtr);
        ……
    };
    SmartPtr<Top> pt1=SmartPtr<Middle>(new Middle);//SmartPtr<Middle>转换为SmartPtr<Top>
    SmartPrt<Top> pt2=SmartPrt<Bottom>(new Bottom);
    SmartPrt<const Top> pct2=pt1;

同一个template的不同详细化之间不存在什么关系，即使详细化的两个类型之间有继承、派生关系。

编译器把SmartPtr和SmartPtr视为全然不同两种类型的classes。为了让上面代码编译通过，获得SmartPtr classes之间的转换能力，必须明白的把它们编写出来。

Templates和泛型编程

要想实现转换，能够在智能指针的构造函数中完毕，可是假设派生类有继续派生，那么构造函数又要加入，这显然不合理。因此，我们须要的不是简简单单为SmartPtr写构造函数，而是编一个构造模板。这么的模板是所谓的member function template（简称member templates）。作用是为class生成函数

    template<typename T>
    class SmartPrt{
    public:
        template<typename U>
        SmartPtr(const SmartPrt<U>& other);//member template，为了生成copy cotr
        ……
    };

以上代码意思是。对不论什么类型T和不论什么类型U，能够依据SmartPrt生成一个SmartPtr。copy cotr没有声明为explicit。由于转换可能是隐式的。

这个为SmartPtr而写的泛化构造函数提供的东西比我们须要的很多其它。我们希望依据一个SmartPtr创建一个Smartprt。却不希望依据一个SmartPtr创建一个SmartPtr。由于对于public继承来说是矛盾的。

上述代码并不完整，在SmartPtr没有实现copy cotr。假设SmartPtr像auto_ptr和tr1::shared_ptr一样。提供get成员函数。返回智能指针对象，那么就能够在构造模板中约束转换行为

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

在上述代码中，存一个隐式转换：将U* 转换为 T*，这限制了转换行为。

member function templates作用不仅仅在于构造函数。另一个重要作用是支持赋值操作。比如TR1的shared_ptr支持全部来自兼容之内置指针、tr1::shared_ptrs、auto_ptrs和tr1::weak_ptrs的构造行为，以及来自上述各物（tr1::weak_ptr除外）的赋值操作。来看一下TR1规范中关于tr1::shared_ptr的一份摘录

    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> const& r);
        template<class Y>
            shared_ptr& operator=(shared_ptr<Y> const& r);
        template<class Y>
            shared_ptr& operator=(auto_ptr<Y> const& r);
        ……
    };

上面除了泛化copy构造函数外，其它构造函数都是explicit，表示shared_ptr类型隐式转换被同意，可是从其它智能指针隐式转换为shared_ptr不被同意。

member function templates并不改变语言基本规则，和编译器产生copy构造函数以及copy assignment不冲突。

tr1:shared_ptr声明了一个泛化的copy构造函数，假设T和Y同样，泛化的copy构造函数会被详细化为正常的copy构造函数。

编译器会暗自为tr1::shared_ptr生成一个copy构造函数？还是当tr1::shared_ptr对象依据另一个同类型的tr1::shared_ptr对象展开构造行为时，编译器会将泛化的copy构造函数模板详细化呢？

member templates没有改变语言规则。假设程序须要一个copy构造函数。你却没有声明它，编译器就会替你生成。在class内声明泛化copy构造函数并不阻止编译器生成它们自己的copy构造函数（non-template）。

假设想要控制copy构造函数的方方面面，就要声明正常的copy构造函数。同样的规则也适用于赋值assignment操作。

总结
- 请使用member function templates（成员函数模板）生成“可接受全部兼容类型”的函数。
- 假设声明member templates用于泛化copy构造函数或泛化assignment操作，还是要声明正常的copy构造函数和copy assignment操作符。