《Effective C++》：规定44-规定45
条款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操作符。
版权声明：本文博客原创文章，博客，未经同意，不得转载。
