精华内容
下载资源
问答
  • dynamic_cast_benchmark 三种不同的dynamic_cast实现的性能比较 请参阅我的博客文章: 汇编: git submodule init git submodule update make ./dynamic_cast_benchmark 目标编译器:clang版本13.0.0 以下是...
  • 下面小编就为大家带来一篇由static_cast和dynamic_cast到C++对象占用内存的全面分析。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • dynamic_cast static_cast 都可以用来强制转换指针类型,但不同的是dynamic_cast在进行类层次间的下行转换时更加安全。 dynamic_cast 运算符可以在执行期决定真正的类型。如果下行转换是安全的(也就是说,如果...

    今天在看王道宝典的时候看到dynamic_cast ,一直都没用过,也不了解,今天来总结一下。

    dynamic_cast 和 static_cast 都可以用来强制转换指针类型,但不同的是dynamic_cast在进行类层次间的下行转换时更加安全

    dynamic_cast 运算符可以在执行期决定真正的类型。如果下行转换是安全的(也就是说,如果基类指针或者引用确实指向一个派生类对象),这个运算符会传回转型过的指针。如果下行转换不安全,这个运算符会传回空指针(也就是说,基类指针或者引用没有指向一个派生类对象)。

    说了这么多是什么意思呢?总结可以是两句话:

    1)在类层次间进行上行转换时,dynamic_cast 和 static_cast 的效果是一样的。

    2)在类层次间进行下行转换时,dynamic_cast 具有类型检查的功能,比static_cast 更安全。

    例子:下述代码中,若调用函数 func 的实参指向一个B类型的对象,语句1和语句2有什么差别?

     1 #include<iostream>
     2 using namespace std;
     3 
     4 class B{
     5 public:
     6     B():b(1){}
     7     virtual void foo(){};
     8     int b;
     9 };
    10 
    11 class D:public B{
    12 public:
    13     D():d(2){}
    14     int d;
    15 };
    16 
    17 void func(B *pb){
    18     D *pd1 = static_cast<D *>(pb);//语句1
    19     cout<<pd1->b<<endl;
    20     cout<<pd1->d<<endl;
    21     
    22     D *pd2 = dynamic_cast<D *>(pb);//语句2
    23     cout<<pd2->b<<endl;
    24     cout<<pd2->d<<endl;
    25 }
    26 
    27 int main(){
    28     //B* pb = new D;
    29     //func(pb);
    30     B* pb = new B;
    31     func(pb);
    32     return 0;
    33 }

    一、在上面的代码中,如果pb指向一个D类型的对象,即

        B* pb = new D;
        func(pb);    

    输出:

    pd1,pd2是一样的,正常得到结果,这两个指针执行D类型的任何操作都是安全的。

    二、但是,如果pb指向的是一个B类型的对象,即

       B* pb = new B;
        func(pb);

    输出:

    那么pd1将是一个指向B对象的指针,对它进行D类型的操作将是不安全的(如访问d),输出d的值时,将会是一个垃圾值(此次输出是0),延后了错误的发现;

    而pd2将是一个空指针,对空指针进行操作,将会发生异常,从而能够更早地发现错误。

     此外,还需注意的一点是 使用dynamic_cast 必须要声明virtual字段,即要有虚函数表!错误输出如下:

    这是因为dynamic_cast 运行时类型检查需要类型信息,而这个类型信息存储在类的虚函数表中,只有定义了虚函数的类才有虚函数表,所以编译错误。而static_cast 则没有这个限制

    以上是dynamic_cast 和 static_cast 的区别

     

    转载于:https://www.cnblogs.com/Hwangzhiyoung/p/8640847.html

    展开全文
  • 1.static_cast对类的指针只能转换有继承关系的类。对普通的指针来说只能在void*其他指针之间转换。它还可转换简单的类型,比如int到char等。不能提供数字到指针的转换。不能提供不同类型指针之间的转换比如int*到...
  • 前言 这篇文章总结的是C++中的类型转换,这些小的知识点,有的时候,自己不是很注意,但是在实际开发中确实经常使用的。俗话说的好,不懂自己写的代码的程序员,不是好的...在标准C++中有四个类型转换符:static_cast
  • 本文用示例讲解了dynamic_caststatic_cast子类与基类之间转换功能的使用方法
  • C++中的类型转换分为两种: ...在标准C++中有四个类型转换符:static_castdynamic_cast、const_cast和reinterpret_cast;下面将对它们一一的进行总结。 1. static_cast static_cast的转换格式:static_ca

    C++中的类型转换分为两种:
    隐式类型转换;
    显式类型转换。

    而对于隐式变换,在很多时候,不经意间就发生了,比如int类型和float类型相加时,int类型就会被隐式的转换位float类型,然后再进行相加运算。而关于隐式转换不是今天总结的重点,重点是显式转换。

    在标准C++中有四个类型转换符:static_cast、dynamic_cast、const_cast和reinterpret_cast;下面将对它们一一的进行总结。

    1. static_cast

    static_cast的转换格式:static_cast (expression)

    将expression转换为type-id类型,主要用于非多态类型之间的转换,不提供运行时的检查来确保转换的安全性。主要在以下几种场合中使用:

    1. 用于类层次结构中,基类和子类之间指针和引用的转换;
      当进行上行转换,也就是把子类的指针或引用转换成父类表示,这种转换是安全的;
      当进行下行转换,也就是把父类的指针或引用转换成子类表示,这种转换是不安全的,也需要程序员来保证;
    2. 用于基本数据类型之间的转换,如把int转换成char,把int转换成enum等等,这种转换的安全性需要程序员来保证;
    3. 把void指针转换成目标类型的指针,是及其不安全的;
      注:static_cast不能转换掉expression的const、volatile和__unaligned属性。
    //隐式的类型转换
    int firstnumber=10;
    double result=(double)firstnumber/secondnumber;
    
    //使用static_dynamic
    double result=static_cast<double> (firstnumber/secondnumber);
    
    
    • 举个例子:
      将int(4字节)显示转换成short(2字节),用vs调试一下,发现static_cast的作用就是将高位截断。

      image

    再举一个例子,讲short显示转换成int,结果如下图所示。
    short是2个字节,int是4个字节,将short转换成int之后,高位根据符号位补满。

    image

    so,小结一下static_cast:

    1. 基本数据类型之间的转换,如把int转换成char,把int转换成enum

    2. 用于类层次结构中基类和子类之间指针或引用的转换。
      进行上行转换(把子类的指针或引用转换成基类表示)是安全的;
      进行下行转换(把基类指针或引用转换成子类指针或引用)时,由于没有动态类型检查,所以是不安全的。

    3. 把void指针转换成目标类型的指针(不安全!!)

    2. dynamic_cast

    dynamic_cast的转换格式:dynamic_cast (expression)

    将expression转换为type-id类型,type-id必须是类的指针、类的引用或者是void *;如果type-id是指针类型,那么expression也必须是一个指针;如果type-id是一个引用,那么expression也必须是一个引用。

    dynamic_cast主要用于类层次间的上行转换和下行转换,还可以用于类之间的交叉转换。在类层次间进行上行转换时,dynamic_cast和static_cast的效果是一样的;在进行下行转换时,dynamic_cast具有类型检查的功能,比static_cast更安全。在多态类型之间的转换主要使用dynamic_cast,因为类型提供了运行时信息。下面我将分别在以下的几种场合下进行dynamic_cast的使用总结:

    1. 最简单的上行(xing)转换
      比如B继承自A,B转换为A,进行上行转换时,是安全的,如下:
    #include <iostream>
    using namespace std;
    class A
    {
         // ......
    };
    class B : public A
    {
         // ......
    };
    int main()
    {
         B *pB = new B;
         A *pA = dynamic_cast<A *>(pB); // Safe and will succeed
    }
    
    
    1. 多重继承之间的上行转换
      C继承自B,B继承自A,这种多重继承的关系;但是,关系很明确,使用dynamic_cast进行转换时,也是很简单的:
    class A
    {
         // ......
    };
    class B : public A
    {
         // ......
    };
    class C : public B
    {
         // ......
    };
    int main()
    {
         C *pC = new C;
         B *pB = dynamic_cast<B *>(pC); // OK
         A *pA = dynamic_cast<A *>(pC); // OK
    }
    
    

    而上述的转换,static_cast和dynamic_cast具有同样的效果。而这种上行转换,也被称为隐式转换;比如我们在定义变量时经常这么写:B *pB = new C;这和上面是一个道理的,只是多加了一个dynamic_cast转换符而已。

    1. 这个真的是重点)如果expression是type-id的基类,使用dynamic_cast进行转换时,在运行时就会检查expression是否真正的指向一个type-id类型的对象,如果是,则能进行正确的转换,获得对应的值;否则返回NULL,如果是引用,则在运行时就会抛出异常;例如:
    class B
    {
         virtual void f(){};
    };
    class D : public B
    {
         virtual void f(){};
    };
    void main()
    {
         B* pb = new D;   // unclear but ok
         B* pb2 = new B;
         D* pd = dynamic_cast<D*>(pb);   // ok: pb actually points to a D
         D* pd2 = dynamic_cast<D*>(pb2);   // pb2 points to a B not a D, now pd2 is NULL
    }
    
    

    这个就是下行转换,从基类指针转换到派生类指针。

    在《More effective C++》里面看见一个很好的例子,也补充在这里

    //定义
    class Widget{};
    class SpecialWidget:public Widget{};
    void update(SpecialWidget  *psw);
    
    Widget * pw;
    ...
    
    //如果pw所指的是SpecialWidget ,那么就传递过去;如果pw指的是Widget ,
    //那么传递过去的值是null
    update(dynamic_cast<SpecialWidget  *> (pw)); 
    
    
    1. 对于一些复杂的继承关系来说,使用dynamic_cast进行转换是存在一些陷阱的;比如,有如下的一个结构:

      image

    D类型可以安全的转换成B和C类型,但是D类型要是直接转换成A类型呢?

    class A
    {
         virtual void Func() = 0;
    };
    class B : public A
    {
         void Func(){};
    };
    class C : public A
    {
         void Func(){};
    };
    class D : public B, public C
    {
         void Func(){}
    };
    int main()
    {
         D *pD = new D;
         A *pA = dynamic_cast<A *>(pD); // You will get a pA which is NULL
    }
    
    

    如果进行上面的直接转,你将会得到一个NULL的pA指针;这是因为,B和C都继承了A,并且都实现了虚函数Func,导致在进行转换时,无法进行抉择应该向哪个A进行转换。正确的做法是:

    int main()
    {
         D *pD = new D;
         B *pB = dynamic_cast<B *>(pD);
         A *pA = dynamic_cast<A *>(pB);
    }
    
    

    这就是我在实现QueryInterface时,得到IUnknown的指针时,使用的是*ppv = static_cast<IX >(this);而不是ppv = static_cast<IUnknown *>(this);

    对于多重继承的情况,从派生类往父类的父类进行转时,需要特别注意;比如有下面这种情况:

    image

    现在,你拥有一个A类型的指针,它指向E实例,如何获得B类型的指针,指向E实例呢?如果直接进行转的话,就会出现编译器出现分歧,不知道是走E->C->B,还是走E->D->B。对于这种情况,我们就必须先将A类型的指针进行下行转换,获得E类型的指针,然后,在指定一条正确的路线进行上行转换。

    上面就是对于dynamic_cast转换的一些细节知识点,特别是对于多重继承的情况,很容易出现问题。

    如何你是好奇宝宝,想知道dynamic_cast是如何实现的?

    侯捷在《内存与对象》书里面做了一个详细的解释,我试着理解了一下。给一个blog : http://blog.csdn.net/bitboss/article/details/53574236

    3. const_cast

    常量指针被转化成非常量指针,并且仍然指向原来的对象;
    常量引用被转换成非常量引用,并且仍然指向原来的对象;

    const_cast的作用是用来改变表达式里面的常量性(const)或易变性(volatile)。

    #include <iostream>
    
    using std::cout;
    using std::endl;
    
    int main(void)
    {
        const int b = 10;
        //b = 11 报错,因为b是一个常量对象
        int * pc = const_cast<int *>(&b);
        *pc = 11;
        cout << "*pc = " << *pc << endl;//b原来地址的数据现在可由*pc来改变,即解除const
        cout << "b = " << b << endl; //b其实类似(编译器处理问题)#define b 10 不会变的
    
        return 0;
    }
    
    4. reinterpret_cast

    reinterpret_cast是为了映射到一个完全不同类型的意思,这个关键词在我们需要把类型映射回原有类型时用到它。我们映射到的类型仅仅是为了故弄玄虚和其他目的,这是所有映射中最危险的。(这句话是C++编程思想中的原话)

    static_cast 和 reinterpret_cast操作符修改了操作数类型。它们不是互逆的; static_cast 在编译时使用类型信息执行转换,在转换执行必要的检测(诸如指针越界计算, 类型检查). 其操作数相对是安全的。另一方面;reinterpret_cast仅仅是重新解释了给出的对象的比特模型而没有进行二进制转换, 例子如下:

    int n=9; 
    double d=static_cast < double > (n);
    

    上面的例子中, 我们将一个变量从 int 转换到 double。 这些类型的二进制表达式是不同的。 要将整数9转换到 双精度整数9,static_cast 需要正确地为双精度整数 d补足比特位。其结果为9.0。而reinterpret_cast 的行为却不同:

    int n=9;
    double d=reinterpret_cast<double & > (n); 
    

    这次, 结果有所不同. 在进行计算以后,d包含无用值. 这是因为 reinterpret_cast 仅仅是复制 n 的比特位到 d, 没有进行必要的分析.

    因此, 你需要谨慎使用 reinterpret_cast。

    其他文章

    0. 免费帮忙下载csdn和百度文库资料福利

    1. 学习笔记和学习资料汇总:前端 + 后端 + java + 大数据 + python + 100多实战项目 + C++

    2. 我的秋招经历总结:一站式秋招规划

    3. 零基础学爬虫

    4. 零基础C++学习总结

    欢迎关注个人公众号【菜鸟名企梦】,公众号专注:互联网求职面经javapython爬虫大数据等技术分享:

    公众号菜鸟名企梦后台发送“csdn”即可免费领取【csdn】和【百度文库】下载服务;

    公众号菜鸟名企梦后台发送“资料”:即可领取5T精品学习资料java面试考点java面经总结,以及几十个java、大数据项目,资料很全,你想找的几乎都有

    扫码关注,及时获取更多精彩内容。(博主985、A+学科硕士,今日头条大数据工程师)

    展开全文
  • static_cast关键字(编译时类型检查) 用法:static_cast &amp;lt; type-id &amp;gt; ( expression ),该运算符把expression转换为type-id类型,但没有运行时类型检查来保证转换的安全性,它主要有如下几种...

    static_cast关键字(编译时类型检查)
    用法:static_cast < type-id > ( expression ),该运算符把expression转换为type-id类型,但没有运行时类型检查来保证转换的安全性,它主要有如下几种用法:
    (1)用于基本数据类型之间的转换,如把int转换为char,把int转换成enum,但这种转换的安全性需要开发者自己保证(这可以理解为保证数据的精度,即程序员能不能保证自己想要的程序安全),如在把int转换为char时,如果char没有足够的比特位来存放int的值(int>127或int<-127时),那么static_cast所做的只是简单的截断,及简单地把int的低8位复制到char的8位中,并直接抛弃高位。
    (2)把空指针转换成目标类型的空指针
    (3)把任何类型的表达式类型转换成void类型
    (4)用于类层次结构中父类和子类之间指针和引用的转换。
    对于以上第(4)点,存在两种形式的转换,即上行转换(子类到父类)和下行转换(父类到子类)。对于static_cast,上行转换时安全的,而下行转换时不安全的,为什么呢?因为static_cast的转换时粗暴的,它仅根据类型转换语句中提供的信息(尖括号中的类型)来进行转换,这种转换方式对于上行转换,由于子类总是包含父类的所有数据成员和函数成员,因此从子类转换到父类的指针对象可以没有任何顾虑的访问其(指父类)的成员。而对于下行转换为什么不安全,是因为static_cast只是在编译时进行类型坚持,没有运行时的类型检查,具体原理在dynamic_cast中说明。
    二、dynamic_cast关键字(运行时类型检查)
    用法:同static_cast
    dynamic_cast 被用来处理多态,,多态分为上行转换和下行转换,主要用于类层次结构中父类和子类之间指针和引用的转换,由于具有运行时类型检查,因此可以保证下行转换的安全性,何为安全性?即转换成功就返回转换后的正确类型指针,如果转换失败,则返回NULL,之所以说static_cast在下行转换时不安全,是因为即使转换失败,它也不返回NULL。
    对于上行转换,dynamic_cast和static_cast是一样的,子类指针转换成父类的指针(子类总是包含父类的所有数据成员和函数成员)
    对于下行转换,父类指针指向一个子类对象,如parent* P1 = new Children(); 但这个指针只能访问父类定义的数据成员和函数,可以把父类的指针P1转换成子类的指针,这是C++中的静态联翩,但一般不定义指向父类对象的子类类型指针,如Children* P1 = new parent;这种转换不成功,因为多态里面没有子类的指针指向父类的,采用static_cast 不会报错,返回的是转换后的指针,但程序此时是不安全的,如果是dynamic_cast,它会根据虚函数表找到P1指向的是什么对象(要求父类有虚函数)。如果是父类对象,返回NULL,如果是子类对象,返回转换后的指针,程序是安全的.这就解释了也说明了,在上行转换中,static_cast和dynamic_cast效果是一样的,而且都比较安全,因为向上转换的对象一般是指向子类对象的子类类型指针;而在下行转换中,由于可以定义就不同了指向子类对象的父类类型指针,同时static_cast只在编译时进行类型检查,而dynamic_cast是运行时类型检查,则需要视情况而定。下面通过代码进行说明
    class Base
    {
    virtual void fun(){}
    };
    class Derived:public Base
    {
    };

    由于需要进行向下转换,因此需要定义一个父类类型的指针Base *P,但是由于子类继承与父类,父类指针可以指向父类对象,也可以指向子类对象,这就是重点所在。如果 P指向的确实是子类对象,则dynamic_cast和static_cast都可以转换成功,如下所示:

    Base *P = new Derived();
    Derived *pd1 = static_cast

    展开全文
  • dynamic_castdynamic_cast < type-id > ( expression) 该运算符把expression转换成type-id类型的对象。Type-id必须是类的指针、类的引用或者void*; 如果type-id是类指针类型,那么expression也必须是一个...

    dynamic_cast:

    dynamic_cast < type-id > ( expression)

    该运算符把expression转换成type-id类型的对象。Type-id必须是类的指针、类的引用或者void*;

    如果type-id是类指针类型,那么expression也必须是一个指针,如果type-id是一个引用,那么expression也必须是一个引用。

    dynamic_cast运算符可以在执行期决定真正的类型。如果downcast是安全的(也就说,如果基类指针或者引用确实指向一个派生类对象)这个运算符会传回适当转型过的指针。如果downcast不安全,这个运算符会传回空指针(也就是说,基类指针或者引用没有指向一个派生类对象)。

    dynamic_cast主要用于类层次间的上行转换和下行转换,还可以用于类之间的交叉转换。

    运行时类型信息通过运算符dynamic_cast来提供。dynamic_cast用来向下转型,将基类指针转换为派生类指针.(把基类指针转换为派生类指针)向下转型,向上转型的话就用强制转换。

    作用:将一个基类对象指针(或引用)cast到继承类指针,dynamic_cast会根据基类指针是否真正指向继承类指针来做相应处理

    对指针进行dynamic_cast,失败返回null,成功返回正常cast后的对象指针;
    对引用进行dynamic_cast,失败抛出一个异常,成功返回正常cast后的对象引用

    在类层次间进行上行转换时,dynamic_cast和static_cast的效果是一样的;
    在进行下行转换时,dynamic_cast具有类型检查的功能,比static_cast更安全

    看下代码:

    classB
    {
    public:
        int m_iNum;
        virtual void foo();
    };
    
    classD:public B
    {
    public:
        char* m_szName[100];
    };
    
    void func(B *pb)
    {
        D *pd1 =static_cast<D*>(pb);
        D *pd2 =dynamic_cast<D*>(pb);
    }
    
    

    在上面的代码段中,如果pb指向一个D类型的对象,pd1和pd2是一样的,并且对这两个指针执行D类型的任何操作都是安全的;

    但是,如果pb指向的是一个B类型的对象,那么pd1将是一个指向该对象的指针,对它进行D类型的操作将是不安全的(如访问m_szName),
    而pd2将是一个空指针


    B要有虚函数,否则会编译出错;static_cast则没有这个限制。

    B中需要检测有虚函数的原因:类中存在虚函数,就说明它有想要让基类指针或引用指向派生类对象的情况,此时转换才有意义。

    这是由于运行时类型检查需要运行时类型信息,而这个信息存储在类的虚函数表(关于虚函数表的概念,详细可见<Inside c++ object model>)中,只有定义了虚函数的类才有虚函数表

    static_cast

    static_cast ( expression)

    • static_cast(expression) The static_cast<>() is used to cast between the integer types. ‘e.g.’ char->long, int->short etc.
      用来数值之间的转换
    • 可以在相关指针之间转换,指针在void *之间转换,还可以在基类和派生类之间转换。 这些转换是在编译的时候就确定下来转换(无非就是根据继承关系,偏移指针而已),但是这需要自己保证安全。
    #include <iostream>
    using namespace std;
    
    class Base
    {
    public:
        virtual void f() {cout<<"Base::f()"<<endl;}
    };
    
    class Derive: public Base
    {
    public:
        virtual  void f() {cout<<"Derive::f()"<<endl;}
        virtual  void f2() {cout<<"Derive::f1()"<<endl;}
    }
    
    int main()
    {
        Base *pbase1  = new Derive();
        Derive* pderive1 = static_cast<Derive *>(pbase1);
        pderive1->f(); // Derive::f()
        
        Base* pbase2 = new Base();
        Derive * pderive2 = static_cast<Derive *>(pbase2);
        pderive2->f();  // Base::f()
    
        pderive2->f2(); // throw exception "Access violation reading"
        
        delete pbase1;
        delete pbase2;
    }
    

    虽然 由 pbase2转化到 pderive2,编译器编译正确。 可以调用 pderive2->f();但是调用pderive2->f2()因为基类本身就没有这个函数,说以运行时出错,抛出异常。

    所以说static_cast 是编译时确定下来,需要自己确保转换类型安全,否则运行时会抛出异常

    而dynamic_cast是专门用于具有继承关系的类之间转换的,尤其是向下类型转换,是安全的。

    dynamic_cast < type-id > ( expression)

    #include <iostream>
    
    using namespace std;
    
    class Base
    {
    public:
    	virtual void f() {cout<<"Base::f()"<<endl;}
    };
    
    class Derive: public Base
    {
    public:
    	virtual void f() {cout<<"Derive::f()"<<endl;}
    	virtual void f2() {cout<<"Derive::f1()"<<endl;}
    };
    
    int main()
    {
    	Base *pbase1 = new Derive();
    	Derive* pderive1 = dynamic_cast<Derive *>(pbase1); //down-cast
    	pderive1->f(); // Derive::f()
    
    	Base* pbase2 = new Base();
    	Derive * pderive2 = dynamic_cast<Derive *>(pbase2); //up-cast
    
    	if ( pderive2) // NULL
    	{
    		pderive2->f();
    		pderive2->f2();
    	}
    
    	delete pbase1;
    	delete pbase2;
    }
    
    
    展开全文
  • dynamic_cast和static_cast效率测试

    千次阅读 2015-05-05 17:55:28
    class A { ...结论:因为dynamic_cast有安全监测,效率大打折扣,建议子类转父类这种安全转换用static_cast,反之如果没有效率需求用dynamic_cast更安全 测试环境 vs2010 win7。
  • 1、子类转换到父类自动转换,不需要强制转型 // Derived派生类(子类) // Base 基类(父类) ...就要使用dynamic_cast和static_cast转换 dynamic_cast和static_cast区别 例子: class Base{}//基类...
  • C++同时提供了4种新的强制类型转换形式(通常称为新风格的或C++风格的强制转 型):const_cast(expression)、dynamic_cast(expression)、 reinterpret_cast(expression) static_cast(expression),每一种都适用于...
  • 但是可怕是向下转换类型,也就是我们从基类向派生类转换,当我们采用传统的C语言c++转换时,就会出现意想不到的情况,因为转换后派生类自己的方法属性丢失了,一旦我们去调用派生类的方法属性那就糟糕了,这...
  • const_cast,dynamic_cast,reinterpret_cast,static_cast四种转换的区别一,const_cast一,dynamic_cast一,reinterpret_cast一,static_cast C++是一种强类型语言,对类型的检查非常严格,我们可以使用C语言中的...
  • 标准C++的类型转换符:static_castdynamic_cast、reinterpret_cast和const_cast
  • 1 dynamic_cast : 书上主要有两个地方说明白了用途: dynamic_cast运算符的用途是,使得能够在类层次中进行向上转换 仅当Low是High的可访问基类时,下面的语句才会将一个Low*指针赋给pl: pl = dynamic_cast&...
  • dynamic_cast和static_cast

    2021-12-30 23:03:32
    dynamic_cast和static_cast - LEO__Y - 博客园1. static_cast在c++中类似于c中的强制类型转换 2.dynamic_cast, C++提供了dynamic_cast函数用于动态转型,相比C风格的强制类型转换C++ reinterphttps://...
  • 以下是对static_cast,dynamic_cast,reinterpret_cast和const_cast之间的区别进行了详细的介绍,需要的朋友可以过来参考下
  • 特别是在指针转换数值转换时用到的非常多。只要编写程序的人知道自己要做什么转换,并知道应该怎样转换的话,我认为上边的转换方式非常之好。但是没有清楚的了解每个转换的细节的话,就有可能
  • 本文简介C++中static_castdynamic_cast的使用场景,并介绍一些C++中的其他*caststatic_cast 你应该在牵涉到自定义的C++ class类型转换中用到它。因为它会帮你做一些静态类型检查。如下的例子是一种可能的应用...
  • 在C++标准中,提供了关于类型层次转换中的两个关键字static_cast和dynamic_cast。 一、static_cast关键字(编译时类型检查) 用法:static_cast &lt; type-id &gt; ( expression ),该运算符把expression...
  • 标准C++中有四个类型转换符:static_castdynamic_cast、reinterpret_castconst_cast。在C++中,使用数据类型转换时,该怎样选用合适的数据类型转换方式呢?下面分别对这几种转换方法的使用场景做一个说明:1) ...
  • static_cast和dynamic_cast的区别

    万次阅读 多人点赞 2018-09-10 10:42:30
    3.1 static_cast 用法:static_cast &lt; type-id &gt; ( exdivssion )  该运算符把exdivssion转换为type-id类型,但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法: ①用于类层次结构中...
  • dynamic_cast:运行时检查,用于多态的类型转换(upcast,downcastcrosscast),只能转换指针引用。 2。static_cast:编译时检查,用于非多态的转换,可以转换指针及其他,比如:int-&gt;float还可以逆隐式...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,133
精华内容 11,653
关键字:

dynamic_cast和static_cast