class B { ... };
class C : public B { ... };
class D : public C { ... };

void f(D* pd)
{
   C* pc = dynamic_cast<C*>(pd);   // ok: C is a direct base class
                                 // pc points to C subobject of pd 

   B* pb = dynamic_cast<B*>(pd);   // ok: B is an indirect base class
                                 // pb points to B subobject of pd 
   ...
}

This type of conversion is called an "upcast" because it moves a pointer up a class hierarchy, from a derived class to a class it is derived from. An upcast is an implicit conversion.

If type-id is void*, a run-time check is made to determine the actual type of expression. The result is a pointer to the complete object pointed to by expression. For example:

class A { ... };

class B { ... };

void f()
{
   A* pa = new A;
   B* pb = new B;
   void* pv = dynamic_cast<void*>(pa);
   // pv now points to an object of type A
   ...
   pv = dynamic_cast<void*>(pb);
   // pv now points to an object of type B
}

If type-id is not void*, a run-time check is made to see if the object pointed to by expression can be converted to the type pointed to by type-id.

If the type of expression is a base class of the type of type-id, a run-time check is made to see if expression actually points to a complete object of the type of type-id. If this is true, the result is a pointer to a complete object of the type of type-id. For example:

class B { ... };
class D : public B { ... };

void f()
{
   B* pb = new D;                     // unclear but ok
   B* pb2 = new B;

   D* pd = dynamic_cast<D*>(pb);      // ok: pb actually points to a D
   ...
   D* pd2 = dynamic_cast<D*>(pb2);   // pb2 points to a B not a D
                                    // cast was bad so pd2 == NULL
   ...
}

This type of conversion is called a "downcast" because it moves a pointer down a class hierarchy, from a given class to a class derived from it.
小結：
? a???? 實際指向對象 和?? b 目標對象,? b 是a 的 基類（子對象），或者是2者 同級轉換才成功
否則 目標為NULL;也就是說不能向下轉



2?? 多重非虛的繼承模式

Class Hierarchy Showing Multiple Inheritance

A pointer to an object of type D can be safely cast to B or C. However, if D is cast to point to an A object, which instance of A would result? This would result in an ambiguous casting error. To get around this problem, you can perform two unambiguous casts. For example:

void f()
{
   D* pd = new D;
   A* pa = dynamic_cast<A*>(pd);      // error: ambiguous
   B* pb = dynamic_cast<B*>(pd);      // first cast to B
   A* pa2 = dynamic_cast<A*>(pb);   // ok: unambiguous
}

Further ambiguities can be introduced when you use virtual base classes. Consider the class hierarchy shown in the following figure.

??? 也就是說在2意性下會失敗
3.子對象間的轉換

Class Hierarchy Showing Duplicate Base Classes

????//pd 指向 e 對象
void f(D* pd)
{
?? E* pe = dynamic_cast<E*>(pd);
?? B* pb = pe;????? // upcast, implicit conversion
?? A* pa = pb;????? // upcast, implicit conversion
}

//pd 指向 e 對象
void f(D* pd)
{
?? B* pb = dynamic_cast<B*>(pd);????? // cross cast
?? A* pa = pb;????????????????? // upcast, implicit conversion
}

? 也就是? 所謂 cross cast

二? typeid( type-id )???? typeid( expression )?
?? 此操作符返回個? const type_info &?
??????????? expression?必須指向一個多態類型（帶虛函數??? ），并且要解引用

#include <iostream>
#include <typeinfo.h>

class Base {
public:
?? virtual void vvfunc() {}
};

class Derived : public Base {};

using namespace std;
int main()
{
?? Derived* pd = new Derived;
?? Base* pb = pd;
?? cout << typeid( pb ).name() << endl;?? //prints "class Base *"
?? cout << typeid( *pb ).name() << endl;?? //prints "class Derived"
?? cout << typeid( pd ).name() << endl;?? //prints "class Derived *"
?? cout << typeid( *pd ).name() << endl;?? //prints "class Derived"
?? delete pd;
}
// compile with: /GR /EHsc

在模版中使用
template < typename T > T max( T arg1, T arg2 ) {
?? cout << typeid( T ).name() << "s compared." << endl;
?? return ( arg1 > arg2 ? arg1 : arg2 );
}


???????????