dynamic_cast<type-id> (expression)
這個表達式將
expression
轉換為一個
type-id
類型的對象。
Type-id
必須是一個指針、指向一個已經定義類的類型或一個指向
VOID
的指針。
Expression
的類型必須是一個指針，如果
type-id
是一個指針；當
type-id
是一個引用的時候必須是一個左值。
如果
type-id
是一個到
expression
類的直接或間接的模棱兩可的指針，結果是一個到
type-id
類型的子對象：
class B { ... };
class C : public B { ... };
class D : public C { ... };
?
void f(D* pd)
{
?? C* pc = dynamic_cast<C*>(pd);?? // ok: C
是一個直接的基類
???????????????????????????????? // pc
指向
pd
的
C
子對象
?
?? B* pb = dynamic_cast<B*>(pd);?? // ok: B
是一個間接的基類
???????????????????????????
?????// pb
指向
pd
的
B
子對象
?? ...
}
這個類型轉換叫做向上轉型，因為它將一個指針在其繼承層次向上轉型，即從一個繼承類到其基類。向上轉型是隱式轉換。
如果
type-id
是一個
void*
，運行時檢查將決定表達式的實際類型。結果是一個到
expression
指向的完整對象。例如：
class A { ... };
?
class B { ... };
?
void f()
{
?? A* pa = new A;
?? B* pb = new B;
?? void* pv = dynamic_cast<void*>(pa);
?? // pv
指向一個
A
類型的對象
?? ...
?? pv = dynamic_cast<void*>(pb);
?? // pv
指向一個
B
類型的對象
}
如果
type-id
不是
void*
，運行時檢查指向
expression
的對象能否轉換為指向
type-id
類型的對象。
如果
expression
類型是
type-id
的基類，運行時檢查是否
expression
實際是一個指向
type-id
類型的完整對象，如果是，結果返回指向
type-id
類型的完整對象，否則返回
NULL
。例如：
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
實際指向
D
?? ...
?? D* pd2 = dynamic_cast<D*>(pb2);?? // pb2
實際指向
B
而不是
D
?????????
??????????????????????????//
轉換失敗，
pd2
是
NULL
?? ...
}
向下類型轉換之所以這么說是因為其從類繼承層次的父類向子類轉換。
在多重繼承的情況，可能導致二義性。看一下下面的類繼承層次：
指向類型D的指針轉換為B或C都正常，但如果從D轉換到A將會怎么樣來？這個結果導致轉換的二義性錯誤；為了結果這個問題，你可以指向兩次明確的轉型，例如：
void f()
{
?? D* pd = new D;
?? A* pa = dynamic_cast<A*>(pd);??? ??//
錯誤：二義性
?? B* pb = dynamic_cast<B*>(pd);????? //
首先轉換到
B
?? A* pa2 = dynamic_cast<A*>(pb);?? // ok:
明確的
}
在使用虛基類的時候就導致更復雜的模糊；看下面的類層次圖：
在這個繼承層次中，A是虛基類。假定一個類E的實例并且一個指向A子對象的指針，一次到B的dynamic_cast會由于不明確性導致失敗，你必須首先轉換到適當的層次，然后再向上轉換到確定的層次，一直按照這種方式直到到達正確的B對象。
看下面的類層次圖：
假定一個類型E的對象和一個指向D子對象的指針，從D子對象導航到左上A子對象，必須執行三個轉換。從D到E的dynamic_cast的轉換，然后一個從E到B的轉換（可以是dynamic_cast或者隱式轉換），最終是從B到A的轉換，例如：
void f(D* pd)
{
?? E* pe = dynamic_cast<E*>(pd);//
這里的
D
實際上是
E
類型的對象
?? B* pb = pe;????? // upcast, implicit conversion
?? A* pa = pb;????? // upcast, implicit conversion
}
dynamic_cast
操作能執行交叉轉換，使用上面相同的類層次，從
B
子對象到
D
子對象轉換是可能的，只要完整的對象是
E
。
由于交叉轉換，從
D
指針到左上角
A
子對象的指針是可行的；首先從
D
到
B
的交叉轉換，然后隱式從
B
到
A
的轉換。例如：
void f(D* pd)
{
?? B* pb = dynamic_cast<B*>(pd);????? // cross cast
?? A* pa = pb;?????????????? ???// upcast, implicit conversion
}
一個
NULL
指針值通過
dynamic_cast
轉換到一個
NULL
指針。
當使用
dynamic_cast <
type-id
> (
expression
)
時，
如果
expression
不能安全的轉換到
type-id
，運行時檢查導致轉型失敗，例如：
class A { ... };
?
class B { ... };
?
void f()
{
?? A* pa = new A;
?? B* pb = dynamic_cast<B*>(pa);????? // fails, not safe;
??????????????????????????????????? // B not derived from A
?? ...
}
轉換失敗的指針類型是
NULL
指針。失敗的引用類型轉換拋出
bad_cast_exception
異常；如果
expression
沒有指向或引用一個有效的對象將拋出
__non_rtti_object
異常。