dynamic_cast conversion
来自cppreference.com
 |
该页由英文版wiki使用Google Translate机器翻译而来。
该翻译可能存在错误或用词不当。鼠标停留在文本上可以看到原版本。你可以帮助我们修正错误或改进翻译。参见说明请点击这里. |
安全将向上，向下，侧身沿着继承层次结构的类的指针和引用.
原文：
Safely converts pointers and references to classes up, down, and sideways along the inheritance hierarchy.
目录 |
[编辑] 语法
dynamic_cast < new_type > ( expression )
|
|||||||||
返回值的类型
new_type或抛出一个异常.原文：
Returns a value of type
new_type or throws an exception.[编辑] 解释
只有下列转换可以dynamic_cast，但这种转换时，将抛弃“常量性”或“波动”
原文：
Only the following conversions can be done with dynamic_cast, except when such conversions would cast away constness or volatility.
1)
如果类型expression完全相同new_type或new_type少cv限定版本的，其结果是expression.
原文：
If the type of expression is the exactly new_type or a less cv-qualified version of new_type, the result is expression.
2)
如果该值expression空指针值，其结果是空指针值的类型new_type
原文：
If the value of expression is the null pointer value, the result is the null pointer value of type new_type
3)
如果new_type是一个指针或引用
Base，expressionDerived，Base是一个独特的，Derived访问基类的指针或引用类型，其结果是在BaseDerived类子对象的指针或引用指向的对象或标识的expression。 （注：隐式转换的static_cast可以执行这种转换也一样）原文：
If new_type is a pointer or reference to
Base, and the type of expression is a pointer or reference to Derived, where Base is a unique, accessible base class of Derived, the result is a pointer or reference to the Base class subobject within the Derived object pointed or identified by expression. (note: implicit cast and static_cast can perform this conversion as well)4)
expression是一个多态类型的指针或引用，并
new_type是一个指针，指向void，结果是一个指针，最派生指向的对象或引用的expression.原文：
If expression is a pointer or reference to a polymorphic type, and
new_type is a pointer to void, the result is a pointer to the most derived object pointed or referenced by expression.5)
expression是一个多态类型
Base的指针或引用，并new_type是一个指针或引用类型Derived运行时检查被执行：原文：
If expression is a pointer or reference to a polymorphic type
Base, and new_type is a pointer or reference to the type Derived a run-time check is performed:a)
检查指出的expression/识别最派生类对象。如果，在该对象中，expression点/公共基地
Derivedreferes到，并且如果只有一个子对象Derived类型来自子对象指出由expression/识别，然后铸造点的结果/是指到该Derived子对象。 （这就是所谓的“垂头丧气”）原文：
The most derived object pointed/identified by expression is examined. If, in that object, expression points/referes to a public base of
Derived, and if only one subobject of Derived type is derived from the subobject pointed/identified by expression, then the result of the cast points/refers to that Derived subobject. (this is known as the "downcast")b)
否则，如果expression点/指最派生的对象到一个公共基地，共存，最派生的对象有一个明确的公共基类类型
Derived，铸造点的结果/指该Derived（这被称为作为“边抛弃”）原文：
Otherwise, if expression points/refers to a public base of the most derived object, and, simultanously, the most derived object has an unambiguous public base class of type
Derived, the result of the cast points/refers to that Derived (this is known as the "sidecast")c)
否则，运行时检查失败。如果dynamic_cast的指针，new_type的类型的值，则返回空指针。如果它被用来在引用上，除std::bad_cast被抛出.
原文：
Otherwise, the runtime check fails. If the dynamic_cast is used on pointers, the null pointer value of type new_type is returned. If it was used on references, the exception std::bad_cast is thrown.
6)
dynamic_cast是在构造函数或析构函数（直接或间接），expression是指目前正在建设/破坏的对象，该对象被认为是最派生的对象。 new_type是不是一个指针或引用的建设/析构函数的类或它的基地之一，其行为是未定义.
原文：
When dynamic_cast is used in a constructor or a destructor (directly or indirectly), and expression refers to the object that's currently under construction/destruction, the object is considered to be the most derived object. If new_type is not a pointer or reference to the construction's/destructor's own class or one of its bases, the behavior is undefined.
与其他演员表达式，其结果是：
原文：
Similar to other cast expressions, the result is:
- 如果一个左值new_type是一个左值的引用类型（expression必须是左值）原文：an lvalue if new_type is an lvalue reference type (expression must be an lvalue)
- 值为xValue，如果new_type是一个右值引用类型（expression可能是左值或右值）原文：an xvalue if new_type is an rvalue reference type (expression may be lvalue or rvalue)
- 一个prvalue否则（在这种情况下，如果new_type是一个指针类型）原文：a prvalue otherwise (in this case, if new_type is a pointer type)
[编辑] 请注意
低迷现状，也可以进行static_cast，从而避免了运行时检查的成本，但它只是安全的，如果该程序可以保证，通过一些其他的逻辑，即指向的对象的expression绝对是
Derived.原文：
Downcast can also be performed with static_cast, which avoids the cost of the runtime check, but it's only safe if the program can guarantee, through some other logic, that the object pointed to by expression is definitely
Derived.[编辑] 关键字
[编辑] 示例
#include <iostream> struct V { virtual void f() {}; // must be polymorphic to use runtime-checked dynamic_cast }; struct A : virtual V {}; struct B : virtual V { B(V* v, A* a) { // casts during construction dynamic_cast<B*>(v); // well-defined: v of type V*, V base of B, results in B* dynamic_cast<B*>(a); // undefined behavior: a has type A*, A not a base of B } }; struct D : A, B { D() : B((A*)this, this) { } }; struct Base { virtual ~Base() {} }; struct Derived: Base { virtual void name() {} }; int main() { D d; // the most derived object A& a = d; // upcast, dynamic_cast may be used, but unnecessary D& new_d = dynamic_cast<D&>(a); // downcast B& new_b = dynamic_cast<B&>(a); // sidecast Base* b1 = new Base; if(Derived* d = dynamic_cast<Derived*>(b1)) { std::cout << "downcast from b1 to d successful\n"; d->name(); // safe to call } Base* b2 = new Derived; if(Derived* d = dynamic_cast<Derived*>(b2)) { std::cout << "downcast from b2 to d successful\n"; d->name(); // safe to call } delete b1; delete b2; }
输出：
downcast from b2 to d successful
