Effective C++ 读书笔记三

清明时节雨纷纷，转眼已经到清明，来杭许久，入职也近两周。上班加班太多，学习时断时续。其实，已经转战客户端开发的我，略显迷茫。这本书啊，明天看完吧！！！

实现

Item26:尽可能延后变量定义式出现的时间

减少不必要的构造、析构（最好定义和赋值放到一块）。

Item27:尽量少做转型动作

C++四中转换类型：

const_cast<T>(expression) 
dynamic_cast<T>(expression) 
reinterpret_cast<T>(expression) 
static_cast<T>(expression)

特别是避免使用dynamic_cast，底层实现复杂，效率太慢。可采用下面方式：

typedef std::vector<std::tr1::shared_ptr<SpecialWindow> > VPSW; 
VPSW winPtrs;
...
for (VPSW::iterator iter = winPtrs.begin(); iter != winPtrs.end(); ++iter)
    (*iter)->blink( );

或基类声明virtual函数。

调用同名基类方法，如果采用下面的操作只是副本的操作：

static_cast(*this).onResize( );

应该改写为：

Window::onResize();

Item28:避免返回handles指向对象内部成分

会破坏封装性，也可能导致悬挂指针（悬挂handles）。

Item29:为“异常安全”而努力是值得的

异常安全就像怀孕，要么没怀上（不安全)，要么怀上了（安全)。

“异常安全函数”即使发生异常也不会有资源泄漏或允许任何数据结构败坏。在这个基础下，它有3个级别：基本保证、强烈保证、不抛异常。

基本保证：

class PrettyMenu 
{ 
    ...
    std::tr1::shared_ptr<Image> bgImage;
    ... 
};

void PrettyMenu::changeBackground(std::istream& imgSrc) {
    Lock ml(&mutex);
    bgImage.reset(new Image(imgSrc)); 
    ++imageChanges;
}

“强烈保证”往往可以通过copy-and-swap实现：

struct PMImpl { 
    std::tr1::shared_ptr<Image> bgImage; 
    int imageChanges;
};
class PrettyMenu 
{
     ...
private:
    Mutex mutex; 
    std::tr1::shared_ptr<PMImpl> pImpl;
};

void PrettyMenu::changeBackground(std::istream& imgSrc) {
    using std::swap;
    Lock ml(&mutex);
    std::tr1::shared_ptr<PMImpl> pNew(new PMImpl(*pImpl));
    pNew->bgImage.reset(new Image(imgSrc)); 
    ++pNew->imageChanges;
    swap(pImpl, pNew);
}

ps:内置类型和指针的操作就绝不会抛出异常

Item30:透彻了解inline函数的里里外外

讲解了编译器如何对待内联函数。

Item31:将文件的编译依存关系降到最低

相依于声明式，不要相依于定义式。
两个手段：Handle classes(impl对象提供服务)和Interface classes。

继承与面对对象设计

Item32:确定你的public继承塑模出is-a模型

public继承意味着is-a。适用于base class身上的每一个函数也一定适用于derived class。

Item33:避免遮掩继承而来的名称

Names in derived classes hide names in base classes.
To make hidden names visible again, employ using declarations or forwarding functions.

class Drive{
public:
    using Base::f1; //using 声明式
    void f1(int);
}

class Drive{
public:
    void f1(){
        Base::f1(); //转交函数
    }
}

Item34:区分接口继承和实现继承

class Shape 
{ 
public:
    virtual void draw() const = 0;
    virtual void error(const std::string& msg);
    int objectID() const;
    ... 
};

纯虚函数：提供接口继承 Drived class必须实现纯虚函数，但同时可以给纯虚函数提供定义

pure virtual functions must be redeclared in concrete derived classes, but they may also have implementations of their own.

虚函数：提供接口继承和默认的实现继承

非虚函数：提供了接口继承和强制的实现继承

Item35:考虑virtual函数以外的选择

提供非虚接口（模板方法模式）

non-virtual interface（NVI)

 class GameCharacter 
 { 
 public:
    int healthValue() const
    {
        ... //事前工作
        int retVal = doHealthValue();
        ... //事后工作
        return retVal; 
    }
    ...
private: //protected、public亦可
    virtual int doHealthValue() const {
        ...
    }
};

藉由函数指针实现策略模式

class GameCharacter; // forward declaration
int defaultHealthCalc(const GameCharacter& gc);
class GameCharacter
{ 
public:
    typedef int (*HealthCalcFunc)(const GameCharacter&);
    explicit GameCharacter(HealthCalcFunc hcf = defaultHealthCalc) 
    : healthFunc(hcf )
    {}
    int healthValue() const
    { return healthFunc(*this); }
    ...
private:
    HealthCalcFunc healthFunc;
};

藉由tr1::function实现策略模式

这个东西boost库里也有，C++11也有此特性（陈硕极力推崇之)

class GameCharacter 
{ 
public:
    typedef std::tr1::function<int (const GameCharacter&)> HealthCalcFunc; 
    explicit GameCharacter(HealthCalcFunc hcf = defaultHealthCalc) 
    : healthFunc(hcf )
    {}
    int healthValue() const
    { return healthFunc(*this); }
    ...
private:
    HealthCalcFunc healthFunc;
};

short calcHealth(const GameCharacter&);
struct HealthCalculator {
    int operator()(const GameCharacter&) const { ... }
};
class GameLevel { 
public:
    float health(const GameCharacter&) const;
};

class EvilBadGuy: public GameCharacter { 
    ...
};
class EyeCandyCharacter: public GameCharacter { 
    ...
};

EvilBadGuy ebg1(calcHealth);
EyeCandyCharacter ecc1(HealthCalculator());
GameLevel currentLevel; …
EvilBadGuy ebg2(std::tr1::bind(&GameLevel::health, currentLevel, _1));

Classic的策略模式

这就是一般书籍上介绍的策略模式。

Item36:绝不重新定义继承而来的non-virtual函数

否则何必定义为non-virtual函数。

Item37:绝不重新定义继承而来的缺省参数值

缺省参数是静态绑定编译的，也就是说实际上只会用基类的缺省值。

Item38:通过复合塑模出has-a或者”根据某物实现出”

组合降低耦合，属于设计原则之一。
本条里实现的Set算是适配器的实现方式吧。

Item39:明智而审慎地使用private继承

private继承是”根据某物实现出“

class Widget: private Timer 
{ 
private:
    virtual void onTick() const;
    ... 
};

✦ Private inheritance means is-implemented-in-terms of. It’s usually inferior to composition, but it makes sense when a derived class needs access to protected base class members or needs to redefine inherited virtual functions. //访问保护成员或重定义虚函数
✦ Unlike composition, private inheritance can enable the empty base optimization. This can be important for library developers who strive to minimize object sizes. //空白基类最优化

采用组合方式更好：

class Widget 
{ 
private:
        class WidgetTimer: public Timer 
        {
        public:
            virtual void onTick() const;
            ... 
        };
    WidgetTimer timer;
    ... 
};

Item40:明智而审慎地使用多重继承

钻石型多重继承（deadly MI diamond）

虚继承来达到子类只有一份基类数据目的（但代价不小)

多重继承使用场景：public继承某个Interface class，private继承某个协助实现的class。

模板与泛型编程

Item41:了解隐式接口和编译期多态

对模板而言，接口是隐式的，多态表现在template具象化和函数重载解析，发生在编译期。

Item42:了解typename的双重意义

声明template参数时，前缀关键字class和typename可以互换
使用typename标识嵌套从属类型名称（但最终解释权属于编译器)

typename C::const_iterator iter(container.begin());

Item43:学习处理模板化基类内的名称

由于存在模板特例化的可能，编译器并不能直接识别模板化基类内的名称:

template<typename Company>
class LoggingMsgSender: public MsgSender<Company> 
{ 
public:
    void sendClearMsg(const MsgInfo& info) {
        sendClear(info); //sendClear是基类方法，但这样编译会报错
    }
    ... 
};

可以采用：

this->sendClear(info); //方法一：使用this
using MsgSender::sendClear; //方法二：使用using
MsgSender::sendClear(info); //方法三：使用作用域运算符

Item44:将参数无关代码抽离template

非类型模板参数造成的代码膨胀：以函数参数或者成员变量替换

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;
public: 
    void invert() { invert(n); } //以函数参数代替模板参数
};

Item45:运用成员函数模版接收所有兼容类型

模板类的继承实现——成员函数模板

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); //成员函数模板
};

成员函数模板是为了泛化，当“泛化拷贝构造函数”和“泛化的赋值构造”时，仍然需要声明正常的拷贝构造函数和赋值构造函数（不改变C++特性）

Item46:需要类型转换的时请为模版定义非成员函数

这是与普通类条款24对应的模板类条款。
但不能在类外直接定义（类型推导不可行），其形式只能是友元的定义和声明在一起，如下：

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

Item47:请使用traits classes表现类型信息

特性萃取技术（对我而言是新知识，作者讲到的实现真是令人叹为观止）

template < ... > 
class list { 
public:
    class iterator { 
    public:
        typedef bidirectional_iterator_tag iterator_category;
        ... 
    };
};

<typename IterT>
struct iterator_traits {
    typedef typename IterT::iterator_category iterator_category;
    ... 
};

template<typename T> // partial template specialization struct iterator_traits<T*> // for built-in pointer types
{
    typedef random_access_iterator_tag iterator_category;
};

Item48:认识模版元编程

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

杂项讨论

Item53:不要轻易忽略编译器的警告

略

Item54:让自己熟悉包括TR1在内的标准程序库

tr1简直就是c++11的新特性！

Item55:让自己熟悉Boost

略

总结

终于看完了，杂项其实很重要，但的确需要大把时间去看，我也没罗列一些东西，暂且不提。
第五章的实现内容，主要是从高效的角度阐述实现，譬如定义延后、内联、少用转换。其中异常安全值得细读。
第六章偏重于继承的讲解，其实暗带多态。继承和多态是一对难兄难弟，多态其实就是面向接口编程，继承一直为人诟病，组合也早成为其后继者。第35条取代虚函数的方法很好。
第七章看的最慢，也最难懂（我没写过类模板）。感觉还是偏重理论而非工程了，后半段倒是有点意思，譬如第47条。

---