thinkng in c++卷2

向中间层造型

正如你在前面使用Security类层次里所看到的，dynamic_cast能在一个有多个层的继承层次里探测到原来的类型和中间的类型。这儿是另一个例子：

//: C08:IntermediateCast.cpp

#include <cassert>

#include <typeinfo>

using namespace std;

class B1 {

public:

  virtual ~B1() {}

};

class B2 {

public:

  virtual ~B2() {}

};

class MI : public B1, public B2 {};

class Mi2 : public MI {};

int main() {

  B2* b2 = new Mi2;

  Mi2* mi2 = dynamic_cast<Mi2*>(b2);

  MI* mi = dynamic_cast<MI*>(b2);

  B1* b1 = dynamic_cast<B1*>(b2);

  assert(typeid(b2) != typeid(Mi2*));

  assert(typeid(b2) == typeid(B2*));

  delete b2;

} ///:~

这个例子有多重继承的额外复杂性（你在本章的后面第9章学习更多关于多重继承的内容）。如果你创建了一个Mi2而且把他向上转换到根（在这种情况下，两个可能根中的一个被选到），dynamic_cast回到继承层MI或者Mi2是成功的。

你甚至能从一个根造型到另一个：

B1* b1 = dynamic_cast<B1*>(b2);

这是成功的因为B2事实上指向一个Mi2对象，它包含了一个类型为B1.的子对象。

 

向中间层造型在dynamic_cast和typeid之间产生了一个有趣的差异。Typeid操作符经常产生指向一个静态type_info对象的引用，该type_info对象描述了对象的动态型别。因此，他不会给你中间层的信息。在下面的表达式里（它为true）, typeid不会将b2看作指向衍生类型的指针，象dynamic_cast一样：

typeid(b2) != typeid(Mi2*)

b2的类型就是该指针的实际类型：typeid(b2) == typeid(B2*)

 

void指针

RTTI仅仅对完整类型起作用，意味着使用typeid的时候所有的类信息都是可能用到。特别的，它不对void指针起作用：

//: C08:VoidRTTI.cpp

// RTTI & void pointers.

//!#include <iostream>

#include <typeinfo>

using namespace std;

 

class Stimpy {

public:

  virtual void happy() {}

  virtual void joy() {}

  virtual ~Stimpy() {}

};

 

int main() {

  void* v = new Stimpy;

  // Error:

//!  Stimpy* s = dynamic_cast<Stimpy*>(v);

  // Error:

//!  cout << typeid(*v).name() << endl;

} ///:~

Void实际上意味着“没有类型信息”。

 

RTTI用于模版

类模版与RTTI工作正常，因为它所有的事情就是产生类。像平常一样，RTTI提供了一个方便的获得你所在的类的名字的方法。下面的例子打印出构造函数和析构函数调用的顺序。

//: C08:ConstructorOrder.cpp

// Order of constructor calls.

#include <iostream>

#include <typeinfo>

using namespace std;

 

template<int id> class Announce {

public:

  Announce() {

    cout << typeid(*this).name() << " constructor" << endl;

  }

  ~Announce() {

    cout << typeid(*this).name() << " destructor" << endl;

  }

};

class X : public Announce<0> {

  Announce<1> m1;

  Announce<2> m2;

public:

  X() { cout << "X::X()" << endl; }

  ~X() { cout << "X::~X()" << endl; }

};

 

int main() { X x; } ///:~

 这个模版用一个常整型来区别一个类和另一个类，但是类型参数也能工作。在构造函数和析构函数内部，RTTI信息产生了打印的类名字。类X用继承和组合来产生一个类，该类的构造和析构函数调用顺序很有趣。输出是：

Announce<0> constructor

Announce<1> constructor

Announce<2> constructor

X::X()

X::~X()

Announce<2> destructor

Announce<1> destructor

Announce<0> destructor

当然，你也能得到不同的输出，依赖于你的编译器怎样表现它的name( )信息。