一篇文章比较static_cast和dynamic_cast的区别

最新推荐文章于 2024-02-28 11:44:31 发布
最新推荐文章于 2024-02-28 11:44:31 发布
阅读量2.1k 收藏 7
点赞数
分类专栏： cpp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gx_1983/article/details/78141454
版权

static_cast和dynamic_cast的区别如下：

    1. 基本类型
      • 1.1 基本类型间转换：
        • static_cast可以在基本类型间做转换，与隐式转换规则相同，不符合隐式转换规则的static_cast同样不能转换。
        • dynamic_cast不能再基本类型之间做转换。
      • 1.2 基本类型指针或引用间转换
        • static_cast不能在基本类型指针或者引用间做转换
        • dynamic_cast不能在基本类型指针或引用间做转换
      • 1.3 基本类型指针与void *之间做转换
        • static_cast可以在基本类型指针与void *之间做转换
        • dynamic_cast不能在基本类型指针与void*之间做转换

  • 2.类继承之间转换

    • 2.1 无关类之间互相转换
      • static_cast不能在没有继承关系的类指针或引用之间做转换。
      • dynamic_cast也不能够在没有继承关系的类指针或引用之间做转换，如果在没有继承关系的类之间做转换，那么转换后的指针为空。虽然偶尔程序不会崩溃，但是这种是不推荐的也是不对的。dynamic_cast的转化有个前提，即被转换的类必须有虚函数表，否则会报错error: cannot dynamic_cast ‘ps’ (of type ‘class Son*’) to type ‘class Father*’ (source type is not polymorphic)，其中Son和Father为用户自定义的类，没有继承关系，Son没有virtual函数，即没有虚函数表。如果在Son类中声明一个virtual函数，即Son类具备了虚函数表，则不会报此错误了，虽然转换后的指针是NULL。所以说dynamic_cast需要在有虚函数表的类上使用，否则会报错。
      • dynamic_cast在极特殊的情况下可以在无关类之间做转换，但是在实际编写代码做工程的时候一定不能这么做，而且要在转换后判断转换后的指针是否为空，如果转换失败那么指针为空。总之，dynamic_cast的常规用法还是在具有继承关系的类之间做转换的。
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
using namespace std;

class Father {
public:
    void fun() { cout << "this is father fun" << endl; }
    //void fun1() { cout << "fun1" << endl; }
};

class Son {
public:
    virtual void fun() { cout << "this is son fun" << endl; }
    //void fun2() { cout << "fun2" << endl; }
    int k;
};

void test() {
    Father * pf, f;
    Son * ps, s;

    pf = &f;
    ps = &s;
    pf = dynamic_cast<Father *>(ps);
    printf("%p  %p  %p\n",ps,pf,NULL);
    pf->fun();
    //pf->fun1();
}

int main(int argc, char ** argv) {
    test();
    return 0;
}

上面这个例子能够正确编译和执行，执行结果如下：

[root@VM_24_16_centos cast]# ./a.out 
0x7fff9e261230  (nil)  (nil)
this is father fun
fun1
为什么指针打印为空但是还是执行对了程序没有崩溃？？？答案是：原因还没有搞清楚，但是确定的是这是瞎猫撞上死耗子了，如果fun()引用到了成员变量，那么程序指定会崩溃，怀疑没有崩溃的原因是在没有使用到数据成员的时候，只是需要通过类名找到函数成员，然后执行，虽然指针为空，但是此时只是通过类名进行查找，并没有使用到此指针；但是一旦需要引用成员变量的时候就需要使用这个指针查找成员变量的位置了，但是因为转换后指针为空，所以导致程序崩溃。
例如如下稍微修改之后的程序：

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
using namespace std;

class Father {
public:
    void fun() {
        k = 1;
        cout << "this is father fun" << endl; }
private:
    int k;
};

class Son {
public:
    virtual void fun() { cout << "this is son fun" << endl; }
    int k;
};

void test() {
    Father * pf, f;
    Son * ps, s;

    pf = &f;
    ps = &s;
    pf = dynamic_cast<Father *>(ps);
    if(pf == NULL) {
        cout << "pf is NULL" << endl;
    }
    printf("%p  %p  %p\n",ps,pf,NULL);
    pf->fun();
}

int main(int argc, char ** argv) {
    test();
    return 0;
}

此程序在执行的时候就发生了崩溃，

[root@VM_24_16_centos cast]# g++ cast1.cpp 
[root@VM_24_16_centos cast]# ./a.out 
pf is NULL
0x7ffdc7ad9a20  (nil)  (nil)
Segmentation fault
[root@VM_24_16_centos cast]#

所以，这个故事告诉我们一个道理！！！
在使用dynamic_cast的时候需要判断转换后的指针是否为空，如果为空说明转换时不允许的，只有不为空才能继续运行程序

 - 2.2 子类型转换成父类型
     - static_cast与dynamic_cast的作用相同。
     - dynamic_cast转换后的指针此时就不为空了。


 - 2.3 父类型转换为子类型
     - static_cast可以把父类型指针转换为子类型指针，但是由于没有静态类型检查，所以是不安全的。那么何时可以使用static_cast把父类型指针转换成子类型指针？答案是在实际使用的时候这种强制类型转换一般都是用在参数传递中，在传递过程中需要确保传递过来的类型与转换之后的类型相同，虽然在传递的时候形参的类型不同，但是其实形参指向的真正类型是一样的，及形参类型虽然是Father，但是实际指向的是Son，转换完成之后还是Son，这种类型一直需要程序员来保证，但是dynamic_cast能够自动检查这种类型是否一致。

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
using namespace std;

class Father {
public:
    void fun() {
        cout << "this is father fun" << endl;
    }
    void fun1() {
        cout << "this is father fun1" << endl;
    }
};

class Son : public Father {
public:
    void fun() { cout << "this is son fun" << endl; }
    void fun2() { k[999] = 2;n[999] = 3;cout << "this is son fun2" << endl; }
private:
    int m[1000];
    int n[1000];
    int k[1000];
};

void test() {
    Father * pf, f;
    Son * ps, s;

    pf = &f;
    ps = &s;
    ps = static_cast<Son *>(pf);
    if(ps == NULL) {
        cout << "ps is NULL" << endl;
    }
    printf("%p  %p  %p\n",ps,pf,NULL);
    ps->fun2();
    pf->fun();
}

int main(int argc, char ** argv) {
    test();
    return 0;
}
  • dynamic_cast也可以把子类型转换为父类型，但是在转换的时候是有运行时类型检查的，如果转换失败会返回NULL，因此在使用的时候最好判断返回值。例如：
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
using namespace std;

class Father {
public:
    virtual void fun() {
        cout << "this is father fun" << endl;
    }
};

class Son : public Father {
public:
    void fun() { cout << "this is son fun" << endl; }
};

void test() {
    Father * pf, f;
    Son * ps, s,s1;

    pf = &f;
    //pf = &s1;
    ps = &s;
    ps = dynamic_cast<Son *>(pf);
    if(ps == NULL) {
        cout << "ps is NULL" << endl;
    }
    printf("%p  %p  %p\n",ps,pf,NULL);
    pf->fun();
}

int main(int argc, char ** argv) {
    test();
    return 0;
}

     此代码转换失败，返回NULL，原因是pf在转换之前指向的类型为Fathre与要转换的类型Son不符合，所以转换失败。
     如果把//pf = &s1;加上的话，那么转换成功，原因是pf转换前后的运行时类型相同。

（所以这个结论非常重要：如果被转换的指针在转换前后的运行时类型（即运行时候的真实类型）相同，那么转换成功，如果运行时类型不同，那么转换失败。）
如下例子：

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
using namespace std;

class Father {
public:
    virtual void fun() {
        cout << "this is father fun" << endl;
    }
};

class Son : public Father {
public:
    void fun() { cout << "this is son fun" << endl; }
};

void test() {
    Father * pf, f;
    Son * ps, s,s1;

    pf = &f;
    pf = &s1;
    ps = &s;
    ps = dynamic_cast<Son *>(pf);
    if(ps == NULL) {
        cout << "ps is NULL" << endl;
    }
    printf("%p  %p  %p\n",ps,pf,NULL);
    pf->fun();
}

int main(int argc, char ** argv) {
    test();
    return 0;
}

父类指针在转换前就指向Son类型对象，转换的类型也是Son类型，那么类型匹配，可以转换成功。
下面是一个参数转换的例子：

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
using namespace std;

class Father {
public:
    virtual void fun() {
        cout << "this is father fun" << endl;
    }
};

class Son : public Father {
public:
    void fun() { cout << "this is son fun" << endl; }
};

void test(Father * pf) {
    Son * ps, s;
    ps = &s;
    ps = dynamic_cast<Son *>(pf);
    if(ps == NULL) {
        cout << "ps is NULL" << endl;
    }
    printf("%p  %p  %p\n",ps,pf,NULL);
    pf->fun();
}

int main(int argc, char ** argv) {
    Father * p = new Father();
    //p = new Son();
    test(p);
    return 0;
}

转换失败，因为pf转换前后运行时类型不相同，pf指针转换后为空。
如果把 //p = new Son(); 加上，那么转换成功，pf指针不为空。

所以最终的结论是：
static_cast转换不做运行时的类型检查，转换正确性由程序员负责。
dynamic_cast转换时会做运行时类型检查，只有转换前后的运行时类型相同，才能转换成功，否则转换失败，转换后的指针为NULL
static_cast和dynamic_cast这些强制类型转换一般用在类似上述例子的参数传递过程中。

gx_1983
关注
专栏目录
static_cast 和 dynamic_cast 的区别
bjzhaoxiao的专栏
04-24 1576
本文很多题目都是来源用于网上，如有侵权，请及时通知。和别人不同的是，有些题目加上了自己的思考。标记为【Jacob】第一部分:简答题1. 一下C++中static_cast 和 dynamic_cast 的区别。答：static_cast 用于有比较明确定义的变换，包括不需要强制转换的变换。【others】l  dynamic_cast 适用于类型安全的向下转换，常用在继承中的父类指针向子类指针的转...
static_cast,dynamic_cast,reinterpret_cast,const_cast的区别及用法详解
12-31
2.dynamic_cast提供安全的转换如果两个指针不存在继承关系转换会失败返回空指针，如果你提供一个错误的指针那样会发生内存访问异常，因为它会去比较两个类型的虚函数表。虚函数表的指针一般放在对象指针最开始的四字...
强制类型转换 static_cast、dynamic_cast、reinterpret_cast、和const_cast
Thomas chen的专栏
05-30 875
<br />转自 http://blog.csdn.net/lemonbee/archive/2008/03/03/2143924.aspx<br /> static_cast、dynamic_cast、reinterpret_cast、和const_cast<br /> 关于强制类型转换的问题，很多书都讨论过，写的最详细的是C++ 之父的《C++ 的设计和演化》。最好的解决方法就是不要使用C风格的强制类型转换，而是使用标准C++的类型转换符：static_cast, dy
C++中static_cast和dynamic_cast强制类型转换
热门推荐
奋斗的程序猿的博客
03-15 5万+
前言 说起C++中的继承、多态、虚函数等概念，可能很多同学都有所了解，但是要说真正熟知的同学可能就不是很多了。最近在编程过程中了解到C++类型的层次转换（这就涉及到了多态和继承的相关概率），通常C语言中可以对内置类型进行强制转换，但是这样做不是很安全，在C++标准中，提供了关于类型层次转换中的两个关键字static_cast和dynamic_cast。
static_cast 和 dynamic_cast的区别
最新发布
qq_40666620的博客
02-28 714
static_cast和dynamic_cast的区别
static_cast和dynamic_cast的区别,看完这篇你就懂了!
Behold1942的博客
12-26 1万+
看了很久了这两个到底是怎么回事，终于今天幡然悔悟。还是要多读书呀。 在C++ primer plus的15章第5节里有介绍： 1 dynamic_cast : 书上主要有两个地方说明白了用途： dynamic_cast运算符的用途是，使得能够在类层次中进行向上转换 仅当Low是High的可访问基类时，下面的语句才会将一个Low*指针赋给pl: pl = dynamic_cast<Low*>ph ; //说明下其中ph是派生类指针，pl是基类指针 否则，该语句将空指针....
static_cast与dynamic_cast转换 最简单的理解
weixin_30247781的博客
08-23 1197
3.1static_cast用法：static_cast< type-id > ( exdivssion )该运算符把exdivssion转换为type-id类型，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：①用于类层次结构中基类和子类之间指针或引用的转换。　　进行上行转换（把子类的指针或引用转换成基类表示）是安全的；　　进行下行转换（把基类指针或引用转换成子类...
C++中的类型转换static_cast、dynamic_cast、const_cast和reinterpret_cast总结
09-04
本文将详细介绍四种主要的显式类型转换：`static_cast`、`dynamic_cast`、`const_cast`和`reinterpret_cast`。 首先，`static_cast`主要用于非多态类型的转换，它不提供运行时的类型检查。例如，当进行基类与子类...
static_cast,dynamic_cast,reinterpret_cast和const_cast的区别详解
12-25
C-style cast举例： int i; double d; i = (int) d;上面的代码就是本来为double类型的d，通过(int)d将其转换成整形值，并将该值赋给整形变量i (注意d本身的值并没有发生改变)。这就是典型的c-style类型转换。下面...
c++ dynamic_cast与static_cast使用方法示例
09-04
`dynamic_cast`和`static_cast`是两种不同的类型转换操作符，它们各自适用于不同的场景。本文将通过示例详细解释它们的使用方法，特别是它们在子类与基类之间的转换功能。 首先，我们来看`dynamic_cast`。`dynamic_...
类型强制转换的区别（static_cast、dynamic_cast的区别）
02-05
类型强制转换的区别 static_cast dynamic_cast 的区别
static_cast和dynamic_cast的区别
m0_54711064的博客
08-30 362
static_cast和dynamic_cast
dynamic_cast 与 static_cast的区别
gonelikefly的博客
09-10 566
昨天在网易的笔试中又遇到了这个问题。这个问题主要考察的是对这两者在继承中的使用。 dynamic_cast: 基本用法 dynamic_cast可以获取目标对象的引用或指针： T1 obj; T2* pObj = dynamic_cast(&obj);//转换为T2指针，失败返回NULL T2& refObj = dynamic_cast(obj);//转换为T2引用，失败抛出ba
static_cast与dynamic_cast区别
wu_wentao的博客
01-16 940
C语言类型转换C语言提供了隐式转换，显式转换。 通过这两种方式，C 语言中大部分的类型转换都可以顺利进行。至于能不能进行转换，转换后的结果如何，编译器不管，需要用户自己去控制。 C++类型转换C++ 继承了C中的隐式和显式转换的额方式。但这种转换并不是安全和严格的，加上C++ 本身对象模型的复杂性，C++增加了四个显式转换的关键字。 static_cast, dynamic_cast, con
dynamic_cast和static_cast的区别
lianghui0811
09-12 657
1、子类转换到父类自动转换，不需要强制转型 // Derived派生类（子类） // Base 基类（父类） Base *A =new Derived; //Derived->Base. 2、父类转换子类需要强制类型转换 就要使用dynamic_cast和static_cast转换 dynamic_cast和static_cast区别 例子： class Base{}//基类...
dynamic_cast和 static_cast的区别
lianghui0811
09-06 5579
(dynamic_cast)必须要有虚函数才能进行转换，static_cast静态转换，不安全。） 运行时类型信息通过运算符dynamic_cast来提供。dynamic_cast用来向下转型，将基类指针转换为派生类指针.（把基类指针转换为派生类指针）向下转型,向上转型的话就用强制转换。 运算符dynamic_cast（ptr）用来将一个指针类型转换为另外一个指针类型。它经常用来检查一个基类指
static_cast 和dynamic_cast区别
u010762216的专栏
05-06 731
1.static_cast在编译时期强制转换,dynamic_cast在运行时期转换(较安全)       2.static_cast是c语言的强制转换代替品；dynamic_cast会运行时检查该转换是否类型安全，只在多态类型时合法，即该类至少具有一个虚拟方法。 其中static_cast是相当于C的强制类型转换，用起来可能有一点危险。dynamic_cast在转换前会检查指针（或引用
C++类型转换：static_cast、dynamic_cast、const_cast与reinterpret_cast详解
如果试图将基类指针或引用转换为一个不匹配的子类类型，dynamic_cast会失败并返回nullptr（指针）或抛出异常。 3. 用于从派生类指针或引用到基类指针或引用的转换，这是安全的，因为这是上行转换。 4. 用于动态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值