C++梁哥笔记day20 | 我的日常分享

C++梁哥笔记day20

发表于2021-01-19更新于2021-01-19字数统计1.9k阅读时长23分

一、C++类型转换

1.1 概念

类型转换（cast）是将一种数据类型转换成另一种数据类型。例如，如果将一个整型值赋给一个浮点类型的变量，编译器会暗地里将其类型转换成浮点类型。转换是非常有用的，但是它也会带来一些问题，比如在转换指针时，我们很可能将其转换成比它更大的类型，但这可能会破坏其它的数据。应该小心类型转换，因为转换也就相当于对编译器来说：忘记类型检查，把它看做其它的类型，一般情况下，尽可能地少去使用类型转换，除非来解决非常特殊的问题。

无论什么原因，任何一个程序如果使用很多类型转换都值得怀疑。

标准C++提供了一个显示的转换的语法，来替代旧的C语言风格的类型转换。使用C风格的强制类型转换可以把想要的任何东西转换成我们需要的类型。那为什么还需要新的C++风格的强制类型转换呢？新类型的强制类型转换可以提供更好的控制强制类型转换过程，允许控制各种不同种类的强制转换。C++风格的强制类型转换的其它的好处是，它们能更清晰地表明它们要干什么。程序要只要扫一眼这样的代码，就能立即知道一个强制类型转换的目的。

1.2 静态转换（static_cast）

用于类层次结构中基类（父类）和派生类（子类）之间指针或引用的转换。进行上行转换（把派生类的指针或引用转换成基类表示）是安全的；进行下行转换（把基类指针或引用转换成派生类表示）时，由于没有动态类型检查，所以是不安全的。用于几倍数据类型的转换，如把int转换成char，把char转换成int。这种转换的安全性也要开发人员来保证。

image-20210119212104332

  • static_cast作用于基本数据类型

    1
    2
    3
    4
    5
    6
    7
    8
    //静态转换static_cast
    void test01(){
        //C语言风格
        char ch = 'a';
        double d = (double)ch;
        //C++风格 static_cast作用于基本类型
        double d1 = static_cast<double>(ch);
    }

  • static_cast作用于自定义数据类型

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    class Animal{

    };
    class Dog:public Animal{

    };
    void test02(){
        //static_cast作用于自定义数据类型（结构体、类）
        //有关系的类之间
        //上行转换
        Animal *p = static_cast<Animal *>(new Dog());
        //下行转换
        Dog *p1 = static_cast<Dog *>(new Animal());

    }

  • 注意：static_cast 不能作用于 不相关类之间的转换

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    class Animal{

    };
    class Dog:public Animal{

    };
    class Other{

    };
    void test03(){
        //static_cast 不能作用于 不相关类之间的转换
        //Animal *p2 = static_cast<Animal *>(new Other());//err
    	Animal *p2 = (Animal *)(new Other());// 传统的C语言方式是不会报错的
    }

    image-20210119214600335
    这就是为什么要使用static_cast而不使用传统的C语言方式了，在上面代码13行可以看到，这个是不会报错的，但是这个操作是危险的，而使用static_cast则对我们的代码进行了检查，保证了危险的发生。

1.3 动态转换（dynamic_cast）

dynamic_cast 主要用于类层次间的上行转换和下行转换；在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。

  1. 不支持基本类型的转换

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    class Animal{

    };
    class Dog:public Animal{

    };
    class Other{

    };
    void test01(){
        //1、不支持基本类型转换
        char ch = 'a';
        double d = static_cast<double>(ch);
    }

    image-20210119215850215

  2. dynamic_cast进行上行转换 （父类指针指向子类空间是安全的）是可以的

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    class Animal{

    };
    class Dog:public Animal{

    };
    class Other{

    };
    void test02(){
        //dynamic_cast进行上行转换 （父类指针指向子类空间是安全的）
        Animal *p = dynamic_cast<Animal *>(new Dog());
    }

  3. dynamic_cast进行下行转换 （子类指针指向父类空间是不安全的）是不行的

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    class Animal{

    };
    class Dog:public Animal{

    };
    class Other{

    };
    void test03(){
        //dynamic_cast进行下行转换 （子类指针指向父类空间是不安全的）
        Dog *p1 = static_cast<Dog *>(new Animal());
    }

    image-20210119220120833

    使用static_cast 对于下行转换仍然是可以进行的，而对于dynamic_cast是不行的，所以相对而言，在对类的类型转换时使用dynamic_cast更加安全，一般都用这个。

  4. dynamic_cast 进行不相关类之间的转换

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    class Animal{

    };
    class Dog:public Animal{

    };
    class Other{

    };
    void test02(){
        //dynamic_cast  进行不相关类之间的转换
        Animal *p2 = static_cast<Animal *>(new Other());
    }

    image-20210119220343197

1.4 常量转换（const_cast）

该运算符用来修饰类型的const属性，常量指针被转换成非常量指针，并且仍然指向原来的对象；常量引用被转换成非常量引用，并且仍然指向原来的对象。

注意：不能对非指针或非引用的变量使用const_cast操作符去直接移除它的const。

  • 1、常量指针被转换成非常量指针 和 非常量指针被转换成常量指针

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    void test01(){
        const int *p = NULL;
        //int *p1 = p;
        int *p1 = (int *)p;//C语言 风格
        int *p11 = const_cast<int *>(p);
        
        int *p2 = NULL;
        const int *p3 = p2;// 虽然类型不匹配但是没有报错
        const int *p4 = (const int *)p2;//C语言 风格
        const int *p44 = const_cast<const int *>(p2);
    }

  • 2、不支持 非指针或引用的转换

    1
    2
    3
    4
    5
    void test02(){
        //const_cast 不支持 非指针或引用的转换
        const int a = 100;
        int b = const_cast<int>(a);
    }

    image-20210119222323284

  • 3、常引用转换成普通引用 和

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    void test03(){
        int data = 200;
        //常引用转换成普通引用
        const int &ob = data;
        int &ob2 = (int &)ob;//C语言 风格
        int &ob3 = const_cast<int &>(ob);

        //普通引用转换成常引用
        int &ob4 = data;
        const int &ob5 = (const int &)ob4;//C语言 风格
        const int &ob6 = const_cast<const int &>(ob4);
    }

1.5 重新解释转换（reinterpret_cast）

这是不安全的一种转换机制，最有可能出现问题。主要用于将一种数据类型从一种类型转换为另一种类型。它可以将指针转换成一个整数，也可以将一个整数转换成一个指针。

相当于C语言风格的强制类型转换。

  • 不支持基本数据类型

    1
    2
    3
    4
    5
    void test01(){
        //不支持基本数据类型
        char ch = 'a';
        double d = reinterpret_cast<double>(ch);//error
    }

    image-20210119225013498

  • 可以进行不相关类之间的转换，这个相当不安全

    1
    2
    3
    4
    void test02(){
        //进行不相关类之间的转换
        Animal *p1 = reinterpret_cast<Animal *>(new Other());
    }

  • 可以进行上行转换 （父类指针指向子类空间是安全的）

    1
    2
    3
    4
    void test03(){
        //进行上行转换 （父类指针指向子类空间是安全的）
        Animal *p2 = reinterpret_cast<Animal *>(new Dog());
    }

  • 可以进行下行转换 （子类指针指向父类空间是不安全的）

    1
    2
    3
    4
    void test04(){
        //进行下行转换 （子类指针指向父类空间是不安全的）
        Dog *p3 = reinterpret_cast<Dog *>(new Animal());
    }