四种类型转换_四种强制类型转换 - CSDN
精华内容
参与话题
  • C++四种类型转换操作符

    千次阅读 2018-04-25 12:53:32
    首先回忆一下c语言中的类型转换,在c语言中进行类型转换只需要在变量前加上变量类型,并且转换是双向的。例如,int类型可以转换成double类型,double类型也可子转换成int类型。 int i = 0; double d = 1.9; int ...

    首先回忆一下c语言中的类型转换,在c语言中进行类型转换只需要在变量前加上变量类型,并且转换是双向的。例如,int类型可以转换成double类型,double类型也可子转换成int类型。

    int i = 0;
    double d = 1.9;
    
    int d2i = (int)d;
    double i2d = (double)i;

    c语言中这种简单粗暴的类型转换方式对基本类型还勉强可以,对复杂的自定义类型就不行了。因此,C++中提供了四种类型转换符:static_cast、dynamic_cast、const_cast、reinterpret_cast。

    1、static_cast可以完全替代c的类型转换,而且在对对象指针之间的类型转换时,可以将父类指针转换成子类指针,也可以将子类指针转换成父类指针,但是如果两个类不相关则无法相互转换。 需注意的是,如果父类指针指向一个父类对象,此时将父类指针转换成子类指针虽然可以通过static_cast实现,但是这种转换很不安全;如果父类指针本身就指向子类指针则不存在安全问题。

    class Base(){};
    class Derived:public Base{};
    
    Base *b1 = new Base;
    Base *b2 = new Derived;
    
    Derived *b2d1 = static_cast<Derived*>(b1);   //转换成功不安全
    Derived *b2d2 = static_cast<Derived*>(b2);    //转换成功安全
    
    int i = 0;
    double d = 1.9;
    
    int d2i = static_cast<int>d;
    double i2d = static_cast<double>i;

    2、dynamic_cast 只能用于对象指针之间的类型转换,可以将父类指针转换成子类指针,也可以将子类指针转换成父类指针,转换结果也可以是引用,但是dynamic_cast不等同于static_cast。dynamic_cast在将父类指针转换为子类指针的过程中,需要对其背后的对象类型进行检查,以保证类型完全匹配,而static_cast不会。只有当一个父类指针指向一个子类对象,且父类中包含虚函数时,使用dynamic_cast将父类指针转换成子类指针才会成功,否则返回空指针,如果是引用则抛出异常。

    class Base(){virtual void dummy(){} };
    class Derived:public Base{};
    
    Base *b1 = new Base;
    Base *b2 = new Derived;
    
    Derived *b2d1 = dynamic_cast<Derived*>(b1);   //转换失败,返回NULL
    Derived *b2d2 = dynamic_cast<Derived*>(b2);    //转换成功
    
    Derived &b2d3 = dynamic_cast<Derived&>(*b1);   //转换失败,抛出异常
    Derived &b2d4 = dynamic_cast<Derived&>(*b2);    //转换成功
    

    3、const_cast转换过程中增加或删除const属性。

    class Test{};
    const Test *t1 = new Test;
    Test *t2 = const_cast<Test*>(t1);      //转换成功

    4、reinterpret_cast可以将一种类型的指针直接转换成另一种类型的指针,不论两个类型之间是否有继承关系。而且reinterpret_cast可以将一个指针转换为一个整数,也可以把一个整数转换成一个指针。reinterpret_cast还经常用咋不同函数指针之间的转换。

    class A{};
    class B{};
    
    A *a = new A;
    B *a2b = reinterpret_cast<B*>(a);     //转换成功
    展开全文
  • C++四种类型转换

    2019-03-22 21:10:51
    static_cast能进行基础类型之间的转换,也是最常看到的类型转换。它主要有如下几用法: 用于类层次结构中父类和子类之间指针或引用的转换。进行上行转换(把子类的指针或引用转换成父类表示)是安全的; 进行...

    ​​​​​​

    • static_cast能进行基础类型之间的转换,也是最常看到的类型转换。它主要有如下几种用法:

           用于类层次结构中父类和子类之间指针或引用的转换。进行上行转换(把子类的指针或引用转换成父类表示)是安全的;

            进行下行转换(把父类指针或引用转换成子类指针或引用)时,没有动态类型检查,不安全;

            用于基本数据类型之间的转换,如把int转换成char,把int转换成enum。

            把void指针转换成目标类型的指针,不安全。

    • const_cast运算符用来修改类型的const或volatile属性。除了去掉const 或volatile修饰之外, type_id和expression得到的类型是一样的。但需要特别注意的是const_cast不是用于去除变量的常量性,而是去除指向常数对象的指针或引用的常量性,其去除常量性的对象必须为指针或引用。
    • reinterpret_cast它可以把一个指针转换成一个整数,也可以把一个整数转换成一个指针(先把一个指针转换成一个整数,在把该整数转换成原类型的指针,还可以得到原先的指针值)。
    • dynamic_cast 主要用在继承体系中的安全向下转型。它能安全地将指向基类的指针转型为指向子类的指针或引用,并获知转型动作成功是否。转型失败会返回null(转型对象为指针时)或抛出异常bad_cast(转型对象为引用时)。 dynamic_cast 会动用运行时信息(RTTI)来进行类型安全检查,因此 dynamic_cast 存在一定的效率损失。当使用dynamic_cast时,该类型必须含有虚函数,这是因为dynamic_cast使用了存储在VTABLE中的信息来判断实际的类型,RTTI运行时类型识别用于判断类型。typeid表达式的形式是typeid(e),typeid操作的结果是一个常量对象的引用,该对象的类型是type_info或type_info的派生。
    展开全文
  • 四种强制类型转换

    千次阅读 2018-12-08 17:14:54
    四种强制类型转换在实际开发中使用场景比较较多,做以下总结: (一)用法:static_cast &lt;类型说明符&gt; (变量或表达式) 它主要有如下几用法: (1)用于类层次结构中基类和派生类之间指针或引用的...

    四种强制类型转换在实际开发中使用场景比较较多,做以下总结:

    (一)用法:static_cast <类型说明符> (变量或表达式)

    它主要有如下几种用法:
    (1)用于类层次结构中基类和派生类之间指针或引用的转换
    进行上行转换(把派生类的指针或引用转换成基类表示)是安全的
    进行下行转换(把基类的指针或引用转换为派生类表示),由于没有动态类型检查,所以是不安全的
    (2)用于基本数据类型之间的转换,如把int转换成char。这种转换的安全也要开发人员来保证
    (3)把空指针转换成目标类型的空指针
    (4)把任何类型的表达式转换为void类型
    注意:static_cast不能转换掉expression的const、volitale或者__unaligned属性。

    static_cast:可以实现C++中内置基本数据类型之间的相互转换。

    如果涉及到类的话,static_cast只能在有相互联系的类型中进行相互转换,不一定包含虚函数。

    (2) 用法:const_cast<type_id> (expression)

    在C语言中,const限定符通常被用来限定变量,用于表示该变量的值不能被修改。

    而const_cast则正是用于强制去掉这种不能被修改的常数特性,但需要特别注意的是const_cast不是用于去除变量的常量性,而是去除指向常数对象的指针或引用的常量性,其去除常量性的对象必须为指针或引用。

    该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外, type_id和expression的类型是一样的。
    常量指针被转化成非常量指针,并且仍然指向原来的对象;
    常量引用被转换成非常量引用,并且仍然指向原来的对象;常量对象被转换成非常量对象。

    (3) 用法:reinterpret_cast<type_id> (expression)

    在C++语言中,reinterpret_cast主要有三种强制转换用途:改变指针或引用的类型、将指针或引用转换为一个足够长度的整形、将整型转换为指针或引用类型。

    type-id必须是一个指针、引用、算术类型、函数指针或者成员指针。
    它可以把一个指针转换成一个整数,也可以把一个整数转换成一个指针(先把一个指针转换成一个整数,在把该整数转换成原类型的指针,还可以得到原先的指针值)。
    在使用reinterpret_cast强制转换过程仅仅只是比特位的拷贝,因此在使用过程中需要特别谨慎!

    (4)用法:dynamic_cast<type_id> (expression)

    (1)其他三种都是编译时完成的,dynamic_cast是运行时处理的,运行时要进行类型检查。

    (2)不能用于内置的基本数据类型的强制转换。

    (3)dynamic_cast转换如果成功的话返回的是指向类的指针或引用,转换失败的话则会返回NULL。

    (4)使用dynamic_cast进行转换的,基类中一定要有虚函数,否则编译不通过。

        B中需要检测有虚函数的原因:类中存在虚函数,就说明它有想要让基类指针或引用指向派生类对象的情况,此时转换才有意义。
    
       
        这是由于运行时类型检查需要运行时类型信息,而这个信息存储在类的虚函数表(关于虚函数表的概念,详细可见<Inside c++ object model>)中,
        只有定义了虚函数的类才有虚函数表。
    

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

        向上转换,即为子类指针指向父类指针(一般不会出问题);向下转换,即将父类指针转化子类指针。
    
       向下转换的成功与否还与将要转换的类型有关,即要转换的指针指向的对象的实际类型与转换以后的对象类型一定要相同,否则转换失败。
    
        在C++中,编译期的类型转换有可能会在运行时出现错误,特别是涉及到类对象的指针或引用操作时,更容易产生错误。Dynamic_cast操作符则可以在运行期对可能产生问题的类型转换进行测试。
    
    展开全文
  • C++中四种类型转换方式

    千次阅读 2018-08-03 09:32:34
    C++中四种类型转换方式 C风格的强制类型转换(Type Cast)很简单,不管什么类型转换统统是:TYPE b = (TYPE)a,但是c 风格的类型转换有不少的缺点,有的时候用c风格的转换是不合适的,因为它可以在任意类型之间转换...

    C++中四种类型转换方式

    C风格的强制类型转换(Type Cast)很简单,不管什么类型的转换统统是:TYPE b = (TYPE)a,但是c 风格的类型转换有不少的缺点,有的时候用c风格的转换是不合适的,因为它可以在任意类型之间转换,比如你可以把一个指向const对象的指针转换成指向非 const对象的指针,把一个指向基类对象的指针转换成指向一个派生类对象的指针,这两种转换之间的差别是巨大的,但是传统的c语言风格的类型转换没有区 分这些。还有一个缺点就是,c风格的转换不容易查找,他由一个括号加上一个标识符组成,而这样的东西在c++程序里一大堆。所以c++为了克服这些缺点,引进了4种类型转换操作符(C++风格的强制转换其他的好处是,它们能更清晰的表明它们要干什么。程序员只要扫一眼这样的代码,就能立即知道一个强制转换的目的。):

    1、static_cast:可以实现C++中内置基本数据类型之间的相互转换,enum、struct、 int、char、float等。它不能进行无关类型(如非基类和子类)指针之间的转换。

    int c=static_cast<int>(7.987);

    如果涉及到类的话,static_cast只能在有相互联系的类型中进行相互转换,不一定包含虚函数。

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    class A

    {};

    class B:public A

    {};

    class C

    {};

     

    int main()

    {

        A* a=new A;

        B* b;

        C* c;

        b=static_cast<B>(a);  // 编译不会报错, B类继承A类

        c=static_cast<B>(a);  // 编译报错, C类与A类没有任何关系

        return 1;

    }

     2、const_cast: const_cast操作不能在不同的种类间转换。相反,它仅仅把一个它作用的表达式转换成常量。它可以使一个本来不是const类型的数据转换成const类型的,或者把const属性去掉。
     3、reinterpret_cast: (interpret是解释的意思,reinterpret即为重新解释,此标识符的意思即为数据的二进制形式重新解释,但是不改变其值。)有着和C风格的强制转换同样的能力。它可以转化任何内置的数据类型为其他任何的数据类型,也可以转化任何指针类型为其他的类型。它甚至可以转化内置的数据类型为指针,无须考虑类型安全或者常量的情形。不到万不得已绝对不用。
     4、dynamic_cast: 
    (1)其他三种都是编译时完成的,dynamic_cast是运行时处理的,运行时要进行类型检查。
    (2)不能用于内置的基本数据类型的强制转换。
    (3)dynamic_cast转换如果成功的话返回的是指向类的指针或引用,转换失败的话则会返回NULL。
    (4)使用dynamic_cast进行转换的,基类中一定要有虚函数,否则编译不通过。
            需要检测有虚函数的原因:类中存在虚函数,就说明它有想要让基类指针或引用指向派生类对象的情况,此时转换才有意义。 
            这是由于运行时类型检查需要运行时类型信息,而这个信息存储在类的虚函数表(关于虚函数表的概念,详细可见<Inside c++ object model>)中,
            只有定义了虚函数的类才有虚函数表。
    (5) 在类的转换时,在类层次间进行上行转换时,dynamic_cast和static_cast的效果是一样的。在进行下行转换 时,dynamic_cast具有类型检查的功能,比               static_cast更安全。向上转换即为指向子类对象的向下转换,即将父类指针转化子类指针。向下转换的成功与否还与将要转换的类型有关,即要转换的指针指向的对象的实际类型与转换以后的对象类型一定要相同,否则转换失败。

    例如:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    60

    61

    62

    63

    64

    65

    66

    67

    68

    69

    70

    #include<iostream>

    #include<cstring>

    using namespace std;

    class A

    {

       public:

       virtual void f()

       {

           cout<<"hello"<<endl;

           };

    };

     

    class B:public A

    {

        public:

        void f()

        {

            cout<<"hello2"<<endl;

            };

     

    };

     

    class C

    {

      void pp()

      {

          return;

      }

    };

     

    int fun()

    {

        return 1;

    }

    int main()

    {

        A* a1=new B;//a1是A类型的指针指向一个B类型的对象

        A* a2=new A;//a2是A类型的指针指向一个A类型的对象

        B* b;

        C* c;

        b=dynamic_cast<B*>(a1);//结果为not null,向下转换成功,a1之前指向的就是B类型的对象,所以可以转换成B类型的指针。

        if(b==NULL)

        {

            cout<<"null"<<endl;

        }

        else

        {

            cout<<"not null"<<endl;

        }

        b=dynamic_cast<B*>(a2);//结果为null,向下转换失败

        if(b==NULL)

        {

            cout<<"null"<<endl;

        }

        else

        {

            cout<<"not null"<<endl;

        }

        c=dynamic_cast<C*>(a);//结果为null,向下转换失败

        if(c==NULL)

        {

            cout<<"null"<<endl;

        }

        else

        {

            cout<<"not null"<<endl;

        }

        delete(a);

        return 0;

    }

    展开全文
  • C++的四种类型转换

    2020-09-05 14:22:02
    C++语言级别提供了四种类型转换方式,分别是: const_cast:去掉常量属性的一个类型转化 static_cast:提供编译器认为安全的类型转换,编译时期的类型转换 reinterpret_cast:类似于C风格的强制类型转换 dynamic_cast...
  • 四种类型转换

    2019-01-18 22:09:55
    C语言支持类型强制转换,C++为什么要引入其他类型转换,原因如下:  1、C风格的转换格式很简单,但是有不少缺点的: (1)转换太过随意,可以在任意类型之间转换。你可以把一个指向const对象的指针转换成指向非...
  • c++ 四种强制类型转换

    万次阅读 2018-07-27 20:11:37
    const_cast , static_cast , dynamic_cast , reinterpret_cast 1. C风格的强制转换 ...C风格的强制转换(Type Cast)容易理解,不管什么类型转换都可以使用使用下面的方式.  TypeName b = (Type...
  • C++风格的类型转换提供了4种类型转换操作符来应对不同场合的应用。  const_cast,字面上理解就是去const属性。  static_cast,命名上理解是静态类型转换。如int转换成char。  dynamic_cast,命名上理解是动态...
  • C++四种类型转换方式

    千次阅读 2018-07-31 12:28:16
    C++四种类型转换方式 reinterpret_cast&lt;new_type&gt;(expression) dynamic_cast&lt;new_type&gt;(expression) static_cast&lt;new_type&gt;(expression) const_cast&lt;new_type&...
  • c++11中四种类型转换

    千次阅读 2017-04-26 10:44:00
    功能:完成编译器认可的隐式类型转换。 格式type1 a; type2 b = staic_cast(a);将type1的类型转化为type2的类型; 使用范围: (1)基本数据类型之间的转换,如int->double; int a = 6; double b = static_...
  • 四种类型转换(cast)的关键字 详解 及 代码 本文原创, 禁止转载, 如有需要, 请站内联系. 本文地址: http://blog.csdn.net/caroline_wendy/article/details/19042529 C++中常见的面试题. 题目: 关于C++中, 四种...
  • C++四种类型转换的关键字及其特点

    千次阅读 2015-09-21 15:08:07
    C++四种类型转换的关键字及其特点 原文地址:http://blog.sina.com.cn/s/blog_5a2bbc860101hgho.html C++的四种强制类型转换,所以C++不是类型安全的。 关键字分别为:static_cast , dynamic_cast , const_cast ,...
  • cpp四种类型转换

    千次阅读 2017-08-06 15:32:27
    C++ 类型转换(C风格的强制转换): 在C++基本的数据类型中,可以分为四类:整型,浮点型,字符型,布尔型。其中数值型包括 整型与浮点型;字符型即为char。 (1)将浮点型数据赋值给整型变量时,舍弃其小数...
  • 用于数值类型之间的转换,也可以用于指针之间的转换,编译时已经确定好,效率高,但须要自己保证其安全性。 (1)用于数值之间的转化, 可以在相关指针在void* 之间转换   (2)在基类和派生类之间进行转换(必须是...
  • 【C++】四种强制类型转换

    万次阅读 多人点赞 2019-10-18 15:01:03
    C++ 四种强制类型转换   C语言中的强制类型转换(Type Cast)有显式和隐式两,显式一般就是直接用小括号强制转换,TYPE b = (TYPE)a; 隐式就是直接 float b = 0.5; int a = b; 这样隐式截断(by the way 这样...
  • C++中四种类型转换和智能指针

    千次阅读 2019-04-30 21:18:15
    一、C++中四种类型转换是:static_cast, dynamic_cast, const_cast, reinterpret_cast 1、const_cast 用于将const变量转为非const 2、static_cast 用于各种隐式转换,比如非const转const,void*转指针等, static...
  • 点击打开链接reinterpret_cast用在任意指针(或引用)类型之间的转换;以及指针与足够大的整数类型之间的转换;从整数类型(包括枚举类型)到指针类型,无视大小。...
  • C++四种强制类型转换

    千次阅读 2019-04-22 21:59:58
    C语言中的类型转换 在C语言中的类型转换一般有一下几 int i = 1; double d = i;//隐式类型转换 int *p = &...//强制类型转换 ...为什么需要四种类型转换? 1.隐式类型转换有些情况下会出问题。 ...
  • C++中的四种类型转换

    千次阅读 2008-11-15 11:42:00
     但是c风格的类型转换有不少的缺点,有的时候用c风格的转换是不合适的,因为它可以在任意类型之间转换,比如你可以把一个指向const对象的指针转换成指向非const对象的指针,把一个指向基类对象的指针转换成指向一个...
  • 一 C风格显式转换和函数风格式转换 在C++中有些数据类型转换是可以直接转换的,这种称为隐式转换。例如:double a = 12.0;int b = a;但有时编译器对于一些数据精度变小的转换会报错,幸运的是C++给我们几个简单...
1 2 3 4 5 ... 20
收藏数 730,547
精华内容 292,218
关键字:

四种类型转换