Effective C++ 读书笔记(七)

7 模板与泛型编程

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

n   classes和templates都支持接口和多态。

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

n   对template参数而言,接口是隐式的,奠基于有效表达式。多态则是通过template具体化和函数重载解析 发生于编译期。

 

条款42:了解typename的双重意义

n   声明template参数时,前缀关键字class和typename可互换。

n   使用typename标识嵌套从属类型名称;但不得在base class lists或member initialization list内以它为base class修饰符。

template<typename  T>

class  Derived: public Base<T>::Nested {

public:

         explicit Derived (int  x) : Base<T>::Nested (x)

         {

                   typename Base<T>::Nested  temp;

                   …

}

};

 

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

class CompanyA

{

public:

         void sendClearText(const std::string&){}

         void sendEncrypted(const std::string&){}

};

 

class CompanyB

{

public:

         void sendClearText(const std::string&){}

         void sendEncrypted(const std::string&){}

};

 

template<typename Company>

class MsgSender

{

public:

         void sendClear(std::string&)

         {

                   Company c;

                   c.sendClearText(std::string(""));

         }

};

class CompanyC

{

public:

         void sendEncrypted(const std::string& msg){}

};

 

template<>

class MsgSender<CompanyC>

{

public:

         void sendSecret(std::string&)

         {

                   CompanyC c;

                   c.sendEncrypted("");

         }

}; //全特化版本,没有实现sendClear

 

template<typename Company>

class LoggingMsgSender: public MsgSender<Company>

{

public:

     void sendClearMsg(std::string&)

     {

         sendClear(std::string("")); //当Company == CompanyZ时,这个函数不存在

     }

};

 

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

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

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

 

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

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;

};

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

 

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

         …

};

 

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

template<typename T>

class Rational

{

public:

     Rational(const T& numerator = 0, const T& denominator = 1):n(numerator),d(denominator){}

     T numerator()const{return n;}

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

};

 

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

}

};

 

条款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

 

你可能感兴趣的:(effective)