Effective C++ 7.0 模板与泛型编程

来源：互联网发布：盘丝洞怎么玩知乎编辑：程序博客网时间：2024/06/06 05:19

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

1. classes 和 templates 都支持接口和多态

2. 对 classes 而言接口是显式的，以函数签名为中心，多态则是通过 virtual 函数发生于运行期间。

3. 对 template 参数而言，接口是隐式的，奠基于有效的表达式。

   多态则是通过 template具现化和函数重载解析发生于编译期。

条款42   了解typename的双重意义
1. 声明 template 参数时，前缀关键字 class 和 typename 可互换。

2. 请使用关键字typename标识嵌套从属类型名称；但不得在 base class list(基类列) 或 member initialization list(成员初值列)内以它作为base class 修饰类。

template<typename C>

void f(const C& container,         // 不允许使用 typename
         typename C::iterator iter   // 一定要使用 typename 说明C::iterator 是一种数据类型
       );

   template<typename T>
   class Derived: public Base<T>::Nested      // base class list 中不允许 typename
   {
   public:
       explicit Derived(int x):Base<T>::Nested(x) // member initialization list 中不允许 typename
       {
           // 嵌套从属类型名称既不在base class list 也不在 mem init list 中
           // 作为一个base class 修饰符需要加上 typename
           typename Base<T>::Nested temp;
       }

   };

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

1. 可在 derived class templates 内通过 "this->" 指涉 base class templates 内的成员名称，或借由一个明白写出
    的"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 MsgInfo { ... };

   template<typename Company>
   class MsgSender
   {
   public:
       ...
       void sendClear(const MsgInfo& info)
       {
         std::string msg;
       Company c;
       c.sendCleartext(msg);
       }

       // 类似sendClear, 唯一不同的是这里调用了 c.sendEncrypted
       void sendSecret(const MsgInfo& info)
       { ... }
   };


   // 日志记录某些信息
   template<typename Company>
   class LoggingMsgSender:public MsgSender<Company>
   {
   public:
   ... ...
   void sendClearMsg(const MsgInfo& info)
   {
      sendClear(info);   // 调用base class函数，这段代码无法通过编译。
   }
   ... ...
   };

   验证：
   当
   class CompanyZ
   {
   public:
   ... ...
   // 这个class 不提供 sendCleartext函数 void sendCleartext(const std::string& msg);
   void sendEncrypted(const std::string& msg);
   ... ...
   };

   template<> // 全特化
   class MsgSender<CompanyZ>
   {
   public:
       ...
       // 类似sendClear, 唯一不同的是这里调用了 c.sendEncrypted
       void sendSecret(const MsgInfo& info)
       { ... }
   };

   此时若在
       // 日志记录某些信息
   template<typename Company>
   class LoggingMsgSender:public MsgSender<Company>
   {
   public:
   ... ...
   void sendClearMsg(const MsgInfo& info)
   {
      sendClear(info);   // 如果Company == CompanyZ 这个函数不存在
                         // 所以上面代码编译不通过是有道理的。
   }
   ... ...
   };


   为了不让其编译失效，有三种办法:
   (1) 加上 this->
   template<typename Company>
   class LoggingMsgSender:public MsgSender<Company>
   {
   public:
        ... ...
        void sendClearMsg(const MsgInfo& info)
        {
           this->sendClear(info);   // 成立，假设sendClear将被继承
        }
        ... ...
   };

   (2)使用using声明式
   template<typename Company>
   class LoggingMsgSender:public MsgSender<Company>
   {
   public:
        using MsgSender<Company>::sendClear; // 告诉编译器，请他假设sendClear位于base class 内。
        ... ...
        void sendClearMsg(const MsgInfo& info)
        {
           sendClear(info);   // 成立，假设sendClear将被继承
        }
        ... ...
   };

   （3）明白指出被调用位于base class 内：
   template<typename Company>
   class LoggingMsgSender:public MsgSender<Company>
   {
   public:
        ... ...
        void sendClearMsg(const MsgInfo& info)
        {
           MsgSender<Company>::sendClear(info);   // 成立，假设sendClear将被继承
        }
        ... ...

};

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

1. Templates生成多个classes和多个函数，所以任何template代码都不该与某个造成膨胀的template参数产生相依联系

    因非类型模板参数而造成的代码膨胀，往往可以消除，做法是以函数参数或class成员变量替换template参数。

   举例：
   template<typename T,std::size_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();
   这里具现了两份，引起了代码膨胀。

   避免代码膨胀
   方法1：
   template<typename T>   // 与尺寸无关的 base class
   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); } // 制造一个inline调用   调用base class版的invert.
   }

   SquareMatrix<double,5> sm1;
   sm1.invert();
   SquareMatrix<double,10> sm2;
   sm2.invert();
   // 由于共享同一份 SquareMatrixBase<double> 则只具现一份代码

   方法2：
   存储一份指针:
   template<typename T>
   class SquareMatrixBase
   {
   protected:
      SquareMatrixBase(std::size_t n, T* pMem): size(n), pData(pMem) { }
      void setDataPtr(T* ptr) { pData = ptr; }
      ... ...
   private:
       std::size_t size;   // 矩阵的大小
       T* pData;           // 指针，指向矩阵的内容
   };

   // 这允许 derived class 决定内存分配方式。
   某些将矩阵存储在内部
   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;
   };

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

原始指针类型之间的转换是隐式转换，因此并未声明为explicit。

template<typename T>
class SmartPtr
{
public:
   template<typename U>//member template，生成copy构造函数
   SmartPtr( const SmartPtr<U>& other): heldPtr(other.get()) { } //暗示只有U*可转为T*才可通过编译
   T* get( )const { return heldPtr; }

private:
   T* heldPtr;
};

在class内声明泛化copy构造函数并不会阻止编译器生成它们自己的copy构造函数（non-template），
所以如果想要控制copy构造函数的方方面面必须同时声明泛化copy构造函数和正常的copy构造函数。
同理，适用于赋值操作。

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

1. 请使用 member function templates(成员函数模板) 生成 "可接受所有的兼容类型"的函数
2. 如果你声明 member templates 用于 "泛华copy构造函数" 或 "泛化assignment操作"，
    你还是需要声明正常的 copy构造函数和 copy assignment 操作符。

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

template<typename T>

class Rational
{
   public:
    Rational(const T& numerator = 0, const T& denominator = 1):n(numerator),d(denominator){}
   const T numerator()   const{return n;}
   const T denominaotr() const{return d;}

   private:
     T n, d;
};

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

Rational<int> oneHalf(1,2);
Rational<int> result = oneHalf * 2; //编译error

operator*第一参数被声明为Rational<T>，而传给operator*的第一实参的类型是Rational<int>，所以T是int。第二参数是Rational<T>，但传入的实参是整数2。
template实参推导过程中并不考虑通过构造函数而发生的隐式类型转换。因此，不会转换为Rational<int>。

解决方法：
template class内的friend声明式可以指涉某个特定函数。因此可以声明operator*是Rational<T>的一个friend函数。
编译器总是能够在class Rational<T> 具现化时得知T。

template<typename T>
class Rational
{    …

     friend const Rational<T> operator*(const Rational& lhs, const Rational& rhs);   // 模板函数必须放在 .h 文件中只能声明即只能放在类里面。

};

template<typename T>
const Rational<T> operator*(const Rational<T>& lhs, const Rational<T>& rhs){ … }
可以通过编译，但不能链接。

编译器知道我们要调用哪个函数，但那个函数只被声明于Rational内，并没有被定义出来。
尽管我们意图令此class外部的operator* template提供定义式，但是行不通。
最简单的方法是：

template<typename T>
class Rational
{ …

    friend const Rational<T> operator*(const Rational& lhs, const Rational& rhs)
    {

       return Rational<T>(lhs.numerator()*rhs.numerator(), lhs.denominaotr()*rhs.denominaotr());

    }

};

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

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

条款47: 请使用 traits classes 表现类型信息
参考<STL源码剖析>内的实现

条款48：认识template元编程

TMP是编写template-based C++程序并执行编译期的过程。TMP是以C++写成，执行于C++编译器内的程序。一旦TMP程序结束执行，其输出也就是templates具现出来的若干C++源码，便会一如往常地被编译。
TMP（template metaprogramming）模板元编程可将工作由运行期移往编译期，因而得以实现早期错误侦测和更高的行为效率。
TMP是图灵完全的，足以计算任何事物。条款47中的traits就是TMP，traits引发编译期发生于类型身上的if … else计算。

示例:编译期计算阶乘!

template<unsigned n>

struct Factorial{

         enum {value = n * Factorial<n-1>::value};

};

template<>

struct Fatorial<0>{

   enum {value = 1};

   };

   std::cout<<Factorial<5>::value<<endl; //输出120

0 0