effective c++：dynamic_cast，避免返回handles指向对象内部

关于dynamic_cast

假定我们有一个基类指针bp，我们在运行时需要把它转换成他的派生类指针，这个时候需要用到dynamic_cast.

Derived *dp = dynamic_cast<Derived*> bp

值得注意的是dynamic_cast执行速度很慢，如果在深度继承或多重继承中使用，成本更高，所以在程序中要尽量避免使用dynamic_cast，有两种方案替代它：

第一，在容器中存储指向派生类的指针，尽量避免以下dynamic_cast的用法

class Window { ... };

class SpecialWindow: public Window {

public:

　　void blink();

...

};

typedef // see Item 13 for info

std::vector<std::tr1::shared_ptr<Window> > VPW; // on tr1::shared_ptr

VPW winPtrs;

...

for (VPW::iterator iter = winPtrs.begin(); // undesirable code:

　　iter != winPtrs.end(); // uses dynamic_cast

　　++iter) {

　if (SpecialWindow *psw = dynamic_cast<SpecialWindow*>(iter->get()))

　　psw->blink();

}

取而代之的应该是：

typedef std::vector<std::tr1::shared_ptr<SpecialWindow> > VPSW;

VPSW winPtrs;

...

for (VPSW::iterator iter = winPtrs.begin(); // better code: uses

　　iter != winPtrs.end(); // no dynamic_cast

　　++iter)

　　(*iter)->blink();

这种方法有个缺陷就是无法使用容器内的指针指向基类所有的派生类。

一般来讲另一种方法更通用些,即在容器中存放基类指针，通过虚函数来选择各种派生类想要实现的功能。

class Window {

public:

　　virtual void blink() {} // default impl is no-op;

　　... // see Item34 for why

}; // a default impl may be

// a bad idea

class SpecialWindow: public Window {

public:

　　virtual void blink() { ... } // in this class, blink

　　... // does something

};

typedef std::vector<std::tr1::shared_ptr<Window> > VPW;

VPW winPtrs; // container holds

// (ptrs to) all possible

... // Window types

for (VPW::iterator iter = winPtrs.begin();

　　iter != winPtrs.end();

　　++iter) // note lack of

　　(*iter)->blink(); // dynamic_cast

避免返回handles(reference,指针，迭代器)指向对象内部

class Rectangle {

public:

　　...

　　const Point& upperLeft() const { return pData->ulhc; }

　　const Point& lowerRight() const { return pData->lrhc; }

　　...

};

struct RectData { // Point data for a Rectangle

　　Point ulhc; // ulhc = “ upper left-hand corner”

　　Point lrhc; // lrhc = “ lower right-hand corner”

};

class Rectangle {

　　...

private:

　　std::tr1::shared_ptr<RectData> pData; // see Item13 for info on

};

这段代码是返回一个Point对象，考虑到封装性问题，该对象是禁止修改的，但是他的问题是返回了private内容，可能在下面场合下出现问题。

class GUIObject { ... };

const Rectangle // returns a rectangle by

boundingBox(const GUIObject& obj); // value; see Item3 for why

// return type is const

GUIObject *pgo; // make pgo point to

... // some GUIObject

const Point *pUpperLeft = // get a ptr to the upper

&(boundingBox(*pgo).upperLeft()); // left point of its

// bounding box

boundingBox调用获得的是一个暂时的Rectangle对象，返回一个指向内部成员的引用，在执行完最后一条语句后，这个暂时的对象被销毁，最终导致的是pUpperLeft指向的是一个被销毁的对象，造成指针悬空(dangling)。

所以说返回一个handles代表的内部成员变量总是危险的。