C++ 参考手册

位置：首页 > C++ 参考手册 >C++ 语言 > dynamic_cast 转换

dynamic_cast 转换

沿继承层级向上、向下及侧向，安全地转换到其他类的指针和引用。

语法

dynamic_cast < 新类型 > ( 表达式 )
新类型 - 指向完整类类型的指针、到完整类类型的引用，或指向（可选的 cv 限定）void 的指针
表达式 - 若 新类型 为引用，则为完整类类型的左值 (C++11 前)泛左值 (C++11 起)表达式，若 新类型 为指针，则为指向完整类类型的指针纯右值。

若转型成功，则 dynamic_cast 返回 新类型 类型的值。若转型失败且 新类型 是指针类型，则它返回该类型的空指针。若转型失败且 新类型 是引用类型，则它抛出与类型 std::bad_cast 的处理块匹配的异常。

解释

唯有下列转换能用 dynamic_cast 进行，但若这种转换会转换走常量性或易变性则亦不允许。

1) 若 表达式 的类型恰是 新类型 或 新类型 的较少 cv 限定版本，则结果是 表达式 具有 新类型 类型的值。（换言之，dynamic_cast 可用以添加常量性。隐式转换和 static_cast 亦能进行此转换。）
2) 若 表达式 的值是空指针值，则结果是 新类型 类型的空指针值。
3) 若 新类型 是到 Base 的指针或引用，且 表达式 的类型是到 Derived 的指针或引用，其中 Base 是 Derived 的唯一可访问基类，则结果是到 表达式 所标识的对象中 Base 类子对象的指针或引用。（注意：隐式转换和 static_cast 亦能进行此转换。）
4) 若 表达式 是指向多态类型的指针，且 新类型 是到 void 的指针，则结果是指向 表达式 所指向或引用的最终派生对象的指针。
5) 若 表达式 是到多态类型 Base 的指针或引用，且 新类型 是到 Derived 类型的指针或引用，则进行运行时检查：
a) 检验 表达式 所指向/标识的最终派生对象。若在该对象中 表达式 指向/指代 Derived 的公开基类，且只有一个 Derived 类型对象从 表达式 所指向/标识的子对象派生，则转型结果指向/指代该 Derived 对象。（此之谓“向下转型（downcast）”。）
b) 否则，若 表达式 指向/指代最终派生对象的公开基类，而同时最终派生对象拥有 Derived 类型的无歧义公开基类，则转型结果指向/指代该 Derived（此之谓“侧向转型（sidecast）”。）
c) 否则，运行时检查失败。若 dynamic_cast 用于指针，则返回 新类型 类型的空指针值。若它用于引用，则抛出 std::bad_cast 异常。
6) 当在构造函数或析构函数中（直接或间接）使用 dynamic_cast，且 表达式 指代正在构造/销毁的对象时，该对象被认为是最终派生对象。若 新类型 不是到构造函数/析构函数自身的类或其基类之一的指针或引用，则行为未定义。

与其他转型表达式相似：

  • 若 新类型 是左值引用类型（表达式 必为左值），则其结果为左值
  • 若 新类型 是右值引用类型（表达式 为完整类类型，可以是左值或右值 (C++17 前)必为泛左值（纯右值被实质化） (C++17 起)），则其结果为亡值
  • 若 新类型 是指针类型，则其结果为纯右值

注解

  • 亦可用 static_cast 进行向下转型，它避免运行时检查的开销，但只有在程序（通过某些其他逻辑）能够保证 表达式 所指向的对象肯定是 Derived 时才是安全的。
  • 某些形式的 dynamic_cast 依赖于运行时类型鉴别（ RTTI ），即编译的程序中关于每个多态类的信息。编译器通常有选项禁用此信息。

关键词

dynamic_cast

示例

运行此代码
#include <iostream>
 
struct V {
    virtual void f() {};  // 必须为多态以使用运行时检查的 dynamic_cast
};
struct A : virtual V {};
struct B : virtual V {
  B(V* v, A* a) {
    // 构造中转型（见后述 D 的构造函数中的调用）
    dynamic_cast<B*>(v); // 良好定义：v 有类型 V*，B 的 V 基类，产生 B*
    dynamic_cast<B*>(a); // 未定义行为：a 有类型 A*，A 非 B 的基类
  }
};
struct D : A, B {
    D() : B((A*)this, this) { }
};
 
struct Base {
    virtual ~Base() {}
};
 
struct Derived: Base {
    virtual void name() {}
};
 
int main()
{
    D d; // 最终派生对象
    A& a = d; // 向上转型，可以用 dynamic_cast，但不必须
    D& new_d = dynamic_cast<D&>(a); // 向下转型
    B& new_b = dynamic_cast<B&>(a); // 侧向转型
 
 
    Base* b1 = new Base;
    if(Derived* d = dynamic_cast<Derived*>(b1))
    {
        std::cout << "downcast from b1 to d successful\n";
        d->name(); // 可以安全调用
    }
 
    Base* b2 = new Derived;
    if(Derived* d = dynamic_cast<Derived*>(b2))
    {
        std::cout << "downcast from b2 to d successful\n";
        d->name(); // 可以安全调用
    }
 
    delete b1;
    delete b2;
}

输出： 

downcast from b2 to d successful

参阅