浅析C++中dynamic_cast和static_cast实例语法详解

1. static_cast

1.1 static_cast语法

static_cast< new_type >(expression)

备注：new_type为目标数据类型，expression为原始数据类型变量或者表达式。

c风格写法：

double scores = 96.5;
int n = (int)scores;

c++ 新风格的写法为：

double scores = 96.5;
int n = static_cast<int>(scores);

1.2 为什么要有static_cast等

隐式类型转换是安全的，显式类型转换是有风险的，c语言之所以增加强制类型转换的语法，就是为了强调风险，让程序员意识到自己在做什么。

但是，这种强调风险的方式还是比较粗放，粒度比较大，它并没有表明存在什么风险，风险程度如何。

为了使潜在风险更加细化，使问题追溯更加方便，使书写格式更加规范，c++ 对类型转换进行了分类，并新增了四个关键字来予以支持，它们分别是：

关键字	说明
static_cast	用于良性转换，一般不会导致意外发生，风险很低。
const_cast	用于 const 与非 const、volatile 与非 volatile 之间的转换。
reinterpret_cast	高度危险的转换，这种转换仅仅是对二进制位的重新解释，不会借助已有的转换规则对数据进行调整，但是可以实现最灵活的 c++ 类型转换。
dynamic_cast	借助 rtti，用于类型安全的向下转型（downcasting）。

1.2 static_cast的作用

static_cast相当于传统的c语言里的强制转换，该运算符把expression转换为new_type类型，用来强迫隐式转换如non-const对象转为const对象，编译时检查，用于非多态的转换，可以转换指针及其他，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：

风险较低的用法：

• 原有的自动类型转换，例如 short 转 int、int 转 double、const 转非 const、向上转型等；
• void 指针和具体类型指针之间的转换，例如void *转int *、char *转void *等；
• 有转换构造函数或者类型转换函数的类与其它类型之间的转换，例如 double 转 complex（调用转换构造函数）、complex 转 double（调用类型转换函数）。

需要注意的是，static_cast 不能用于无关类型之间的转换，因为这些转换都是有风险的，例如：

• 两个具体类型指针之间的转换，例如int *转double *、student *转int *等。不同类型的数据存储格式不一样，长度也不一样，用 a 类型的指针指向 b 类型的数据后，会按照 a 类型的方式来处理数据：如果是读取操作，可能会得到一堆没有意义的值；如果是写入操作，可能会使 b 类型的数据遭到破坏，当再次以 b 类型的方式读取数据时会得到一堆没有意义的值。
• int 和指针之间的转换。将一个具体的地址赋值给指针变量是非常危险的，因为该地址上的内存可能没有分配，也可能没有读写权限，恰好是可用内存反而是小概率事件。

1.3 static_cast用法

#include <iostream>
#include <cstdlib>
using namespace std;
class complex{
public:
    complex(double real = 0.0, double imag = 0.0): m_real(real), m_imag(imag){ }
public:
    operator double() const { return m_real; }  //类型转换函数
private:
    double m_real;
    double m_imag;
};
int main(){
    //下面是正确的用法
    int m = 100;
    complex c(12.5, 23.8);
    long n = static_cast<long>(m);  //宽转换，没有信息丢失
    char ch = static_cast<char>(m);  //窄转换，可能会丢失信息
    int *p1 = static_cast<int*>( malloc(10 * sizeof(int)) );  //将void指针转换为具体类型指针
    void *p2 = static_cast<void*>(p1);  //将具体类型指针，转换为void指针
    double real= static_cast<double>(c);  //调用类型转换函数
   
    //下面的用法是错误的
    float *p3 = static_cast<float*>(p1);  //不能在两个具体类型的指针之间进行转换
    p3 = static_cast<float*>(0x2df9);  //不能将整数转换为指针类型
    return 0;
}

2. dynamic_cast

2.1 dynamic_cast 语法

dynamic_cast <newtype> (expression)

newtype 和 expression 必须同时是指针类型或者引用类型。换句话说，dynamic_cast 只能转换指针类型和引用类型，其它类型（int、double、数组、类、结构体等）都不行。

对于指针，如果转换失败将返回 null；对于引用，如果转换失败将抛出std::bad_cast异常。

2.2 dynamic_cast 用法

dynamic_cast 用于在类的继承层次之间进行类型转换，它既允许向上转型（upcasting），也允许向下转型（downcasting）。向上转型是无条件的，不会进行任何检测，所以都能成功；向下转型的前提必须是安全的，要借助 rtti 进行检测，所有只有一部分能成功。

dynamic_cast 与 static_cast 是相对的，dynamic_cast 是“动态转换”的意思，static_cast 是“静态转换”的意思。dynamic_cast 会在程序运行期间借助 rtti 进行类型转换，这就要求基类必须包含虚函数；static_cast 在编译期间完成类型转换，能够更加及时地发现错误。

2.3 dynamic_cast 实例

2.3.1 向上转型（upcasting）

向上转型时，只要待转换的两个类型之间存在继承关系，并且基类包含了虚函数（这些信息在编译期间就能确定），就一定能转换成功。因为向上转型始终是安全的，所以 dynamic_cast 不会进行任何运行期间的检查，这个时候的 dynamic_cast 和 static_cast 就没有什么区别了。

「向上转型时不执行运行期检测」虽然提高了效率，但也留下了安全隐患，请看下面的代码：

#include <iostream>
#include <iomanip>
using namespace std;
class base{
public:
    base(int a = 0): m_a(a){ }
    int get_a() const{ return m_a; }
    virtual void func() const { }
protected:
    int m_a;
};

class derived: public base{
public:
    derived(int a = 0, int b = 0): base(a), m_b(b){ }
    int get_b() const { return m_b; }
private:
    int m_b;
};

int main(){
    //情况①
    derived *pd1 = new derived(35, 78);
    base *pb1 = dynamic_cast<derived*>(pd1);
    cout<<"pd1 = "<<pd1<<", pb1 = "<<pb1<<endl;
    cout<<pb1->get_a()<<endl;
    pb1->func();
    //情况②
    int n = 100;
    derived *pd2 = reinterpret_cast<derived*>(&n);
    base *pb2 = dynamic_cast<base*>(pd2);
    cout<<"pd2 = "<<pd2<<", pb2 = "<<pb2<<endl;
    cout<<pb2->get_a()<<endl;  //输出一个垃圾值
    pb2->func();  //内存错误
    return 0;
}

运行结果如下

可以看到pd1与pb1的地址相同，且pb1可以正常调用base类的方法

对于情况②

pd 2指向的是整型变量 n，并没有指向一个 derived 类的对象，在使用 dynamic_cast 进行类型转换时也没有检查这一点（因为向上转型始终是安全的，所以 dynamic_cast 不会进行任何运行期间的检查）

而是将 pd 的值直接赋给了 pb（这里并不需要调整偏移量），最终导致 pb 也指向了 n。因为 pb 指向的不是一个对象，所以get_a()得不到 m_a 的值（实际上得到的是一个垃圾值），pb2->func()也得不到 func() 函数的正确地址。

运行结果如下

简单来说就是向上转型是不检查的，所以大家得知道自己在做什么，不能随意的转换

2.3.2 向下转型（downcasting）

向下转型是有风险的，dynamic_cast 会借助 rtti 信息进行检测，确定安全的才能转换成功，否则就转换失败。

下面看一个例子

#include <iostream>
using namespace std;
class a{
public:
    virtual void func() const { cout<<"class a"<<endl; }
private:
    int m_a;
};
class b: public a{
public:
    virtual void func() const { cout<<"class b"<<endl; }
private:
    int m_b;
};
class c: public b{
public:
    virtual void func() const { cout<<"class c"<<endl; }
private:
    int m_c;
};
class d: public c{
public:
    virtual void func() const { cout<<"class d"<<endl; }
private:
    int m_d;
};
int main(){
    a *pa = new a();
    b *pb;
    c *pc;
   
    //情况①
    pb = dynamic_cast<b*>(pa);  //向下转型失败
    if(pb == null){
        cout<<"downcasting failed: a* to b*"<<endl;
    }else{
        cout<<"downcasting successfully: a* to b*"<<endl;
        pb -> func();
    }
    pc = dynamic_cast<c*>(pa);  //向下转型失败
    if(pc == null){
        cout<<"downcasting failed: a* to c*"<<endl;
    }else{
        cout<<"downcasting successfully: a* to c*"<<endl;
        pc -> func();
    }
   
    cout<<"-------------------------"<<endl;
   
    //情况②
    pa = new d();  //向上转型都是允许的
    pb = dynamic_cast<b*>(pa);  //向下转型成功
    if(pb == null){
        cout<<"downcasting failed: a* to b*"<<endl;
    }else{
        cout<<"downcasting successfully: a* to b*"<<endl;
        pb -> func();
    }
    pc = dynamic_cast<c*>(pa);  //向下转型成功
    if(pc == null){
        cout<<"downcasting failed: a* to c*"<<endl;
    }else{
        cout<<"downcasting successfully: a* to c*"<<endl;
        pc -> func();
    }
   
    return 0;
}

运行结果

可以看到，前两次转换失败，但是后两次转换成功

这段代码中类的继承顺序为：a --> b --> c --> d。pa 是a*类型的指针，当 pa 指向 a 类型的对象时，向下转型失败，pa 不能转换为b*或c*类型。当 pa 指向 d 类型的对象时，向下转型成功，pa 可以转换为b*或c*类型。同样都是向下转型，为什么 pa 指向的对象不同，转换的结果就大相径庭呢？

因为每个类都会在内存中保存一份类型信息，编译器会将存在继承关系的类的类型信息使用指针“连接”起来，从而形成一个继承链（inheritance chain），也就是如下图所示的样子：

当使用 dynamic_cast 对指针进行类型转换时，程序会先找到该指针指向的对象，再根据对象找到当前类（指针指向的对象所属的类）的类型信息，并从此节点开始沿着继承链向上遍历，如果找到了要转化的目标类型，那么说明这种转换是安全的，就能够转换成功，如果没有找到要转换的目标类型，那么说明这种转换存在较大的风险，就不能转换。

所以在第二种方式中，pa实际上是指向的d，于是程序顺着d开始向上找，找到了b和c,于是认定是安全的，所以转换成功

总起来说，dynamic_cast 会在程序运行过程中遍历继承链，如果途中遇到了要转换的目标类型，那么就能够转换成功，如果直到继承链的顶点（最顶层的基类）还没有遇到要转换的目标类型，那么就转换失败。对于同一个指针（例如 pa），它指向的对象不同，会导致遍历继承链的起点不一样，途中能够匹配到的类型也不一样，所以相同的类型转换产生了不同的结果。

3. 参考链接

【本文博客】

到此这篇关于浅析c++中dynamic_cast和static_cast实例演示的文章就介绍到这了,更多相关c++中dynamic_cast与static_cast内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！