【C++】一文理清C++中的五种强制类型转换

古城微笑少年丶 2023-10-13 07:51 21阅读 0赞

## 深入理解C++中五种强制类型转换的使用场景 ##

### 一、C风格的强制类型转换 ###

使用形式：

Type b = (Type)a;

C风格的强制类型转换很容易理解，不管什么类型都可以直接进行转换。C++也支持C风格的强制类型转换，但是C风格的强制类型转换可能会带来一些隐患，出现一些难以察觉的问题，所以C++又推出了四种新的强制类型转换来替代C风格的强制类型转换，降低使用风险。

### 二、C++风格的强制类型转换 ###

#### 2.1 static\_cast ####

使用格式：

static_cast<type_id>(expression);

##### 2.1.1 基本内置数据类型之间的转换 #####

static\_cast 可以用于基本内置数据类型之间的转换，比如把 char 转成 float、double 转换成 long 等，这种内置类型之间的转换往往可以由隐式转换自动执行，而不需要人工特地去执行强制类型转换。由于转换结果可能存在截断性，这种转换的安全性要由开发人员来保证（一般不会出现严重程序运行错误，但是可能会出现逻辑错误），编译器可能会适当打印警告信息。示例如下：

#include <iostream>
    
    int main(int argc, char* argv[])
    {
        char type_char = 'A';
        float type_float = type_char; // 隐式转换也可以
        float type_float_cast = static_cast<float>(type_char); // 显式地使用static_cast进行强制类型转换
    
        double type_double = 1.23;
        long type_long = type_double; // 隐式转换也可以
        long type_long_cast = static_cast<long>(type_double); // 显式地使用static_cast进行强制类型转换
    }

##### 2.1.2 指针之间的转换 #####

`static_cast`可以用于指针之间的转换，这种转换类型检查非常严格，不同类型的指针是直接不给转的，除非使用`void*`作为中间参数，我们知道隐式转换下`void*`类型是无法直接转换为其它类型指针的，这时候就需要借助static\_cast来转换了。示例如下：

#include <iostream>
    
    int main(int argc, char* argv[])
    {
        int type_int = 10;
        float* float_ptr1 = &type_int; // int* -> float* 隐式转换无效
        float* float_ptr2 = static_cast<float*>(&type_int); // int* -> float* 使用static_cast转换无效
        char* char_ptr1 = &type_int; // int* -> char* 隐式转换无效
        char* char_ptr2 = static_cast<char*>(&type_int); // int* -> char* 使用static_cast转换无效
    
        void* void_ptr = &type_int; // 任何指针都可以隐式转换为void*
        float* float_ptr3 = void_ptr; // void* -> float* 隐式转换无效
        float* float_ptr4 = static_cast<float*>(void_ptr); // void* -> float* 使用static_cast转换成功
        char* char_ptr3 = void_ptr; // void* -> char* 隐式转换无效
        char* char_ptr4 = static_cast<char*>(void_ptr); // void* -> char* 使用static_cast转换成功
    }

> **补充说明**：`static_cast`是直接不允许不同类型的引用进行转换的，因为没有void类型引用可以作为中间介质，这点和指针是有相当大区别的

##### 2.1.3 类实例的之间转换 #####

#include <iostream>
    
    class A
    {
    public:
        int a;
    };
    
    class B
    {
    public:
        int b;
    };
    
    class C : public A, public B
    {
    public:
        int c;
    };
    
    int main(int argc, char* argv[])
    {
        C c;
        A a = static_cast<A>(c); // 上行转换正常
        B b = static_cast<B>(c); // 上行转换正常
    
        C c_a = static_cast<C>(a); // 下行转换无效
        C c_b = static_cast<C>(b); // 下行转换无效
    }

从测试程序中可以看到如果对类实例使用static\_cast进行转换，static\_cast是会进行类型判断的，对于上行转换来说这个过程就是正常的，但是下行转换则不行，static\_cast认为下行转换等同于两个无关联的类进行转换，会报错。但是这个错误是有解决方法的，我们从报错信息中可以看到当static\_cast转换失败时，会使用expression作为传入参数来调用type\_id的构造函数，所以我们可以把类C改成以下形式，上面的示例即可编译通过：

class C : public A, public B
    {
    public:
        C()
        {
        }
    
        C(const A& v)
        {
            a = v.a;
        }
    
        C(const B& v)
        {
            b = v.b;
        }
    
        int c;
    };

综上，我们可以得出使用static\_cast对类实例进行强制类型转换时有以下特点：

*  进行上行转换是完全安全合法的，当然这个过程由隐式转换来完成也是合法的；
 *  进行下行转换时，static\_cast会认为两个类无关联，这种转换不合法。如果此时硬要转换的话，比如类A->类B（这两个类可以无任何关系，因为实例下行转换static\_cast就是认为他们没关联），可以在B中添加一个使用类A进行构造的构造函数，比如B(const A&)，这样就可以正常使用static\_cast来进行类A->类B的操作了

##### 2.1.4 没有多态的类实例指针或引用之间的转换 #####

#include <iostream>
    
    class A
    {
    public:
        int a;
    };
    
    class B
    {
    public:
        int b;
    };
    
    class C : public A, public B
    {
    public:
        int c;
    };
    
    int main(int argc, char* argv[])
    {
        C c;
    
        A* a_ptr = static_cast<A*>(&c); // 上行指针转换正常
        B* b_ptr = static_cast<B*>(&c); // 上行指针转换正常
        A& a_ref = static_cast<A&>(c);  // 上行引用转换正常
        B& b_ref = static_cast<B&>(c);  // 上行引用转换正常
    }

可以看到上行转换都是正常的，转换过程中不会出现任何显性和隐性错误，下面来看一下下行转换的示例：

int main(int argc, char* argv[])
    {
        C c;
        A* a_ptr = static_cast<A*>(&c);
        B* b_ptr = static_cast<B*>(&c);
        A& a_ref = static_cast<A&>(c);
        B& b_ref = static_cast<B&>(c);
    
        C* c_ptra = static_cast<C*>(a_ptr); // 下行指针转换正常
        C* c_ptrb = static_cast<C*>(b_ptr); // 下行指针转换正常
        C& c_refa = static_cast<C&>(a_ref); // 下行引用转换正常
        C& c_refb = static_cast<C&>(b_ref); // 下行引用转换正常
    
        A* a_ptr_fail = static_cast<A*>(b_ptr); // B* -> A*，无关联的两个类型，无效
    }

从上面的例子可以看到，下行转换也是正常的，并且`static_cast`也会拒绝掉两个无关联类之间的转换？？？这和书中说的不一样啊，不是说`static_cast`下行转换不安全吗？别急，上面的例子是片面的，各位看一下下面的代码就知道了：

int main(int argc, char* argv[])
    {
        A a;
        B b;
    
        // 以下都能转换成功，说明static_cast根本就没有安全检查，只看到有继承关系就给转换了
        C* c_ptra = static_cast<C*>(&a);
        C* c_ptrb = static_cast<C*>(&b);
        C& c_refa = static_cast<C&>(a);
        C& c_refb = static_cast<C&>(b);
    }

综上，我们可以得出使用static\_cast对没有多态的类实例指针或引用进行强制类型转换时有以下特点：

*  进行上行转换（派生类指针->基类指针、派生类引用->基类引用）是完全安全的，没有任何问题，当然这个过程由隐式转换来完成也是合法的
 *  进行下行转换（基类指针->派生类指针、基类引用->派生类引用）由于缺乏安全检查，所以是有问题的，要尽量避免这种用法（可以转，但不推荐）
 *  如果两个类无继承关系，则使用static\_cast进行转换时会失败，但是这种情况下static\_cast会显性地展示出错误信息，是安全的

##### 2.1.5 具有多态的类实例指针或引用之间的转换 #####

#include <iostream>
    
    class A
    {
    public:
        virtual void print()
        {
            std::cout << "A" << std::endl;
        }
    };
    
    class B
    {
    public:
        virtual void print()
        {
            std::cout << "B" << std::endl;
        }
    };
    
    class C : public A, public B
    {
    public:
        virtual void print() override
        {
            std::cout << "C" << std::endl;
        }
    };
    
    int main(int argc, char* argv[])
    {
        C c;
    
        A* a_ptr = static_cast<A*>(&c); // 上行指针转换正常
        B* b_ptr = static_cast<B*>(&c); // 上行指针转换正常
        a_ptr->print();                 // 输出C，符合多态的要求
        b_ptr->print();                 // 输出C，符合多态的要求
    
        A& a_ref = static_cast<A&>(c); // 上行引用转换正常
        B& b_ref = static_cast<B&>(c); // 上行引用转换正常
        a_ref.print();                 // 输出C，符合多态的要求
        b_ref.print();                 // 输出C，符合多态的要求
    }

可以看到上行转换都是正常的，转换过程中不会出现任何显性和隐性错误，下面来看一下正常的下行转换的示例：

int main(int argc, char* argv[])
    {
        C c;
        A* a_ptr = static_cast<A*>(&c);
        B* b_ptr = static_cast<B*>(&c);
        A& a_ref = static_cast<A&>(c);
        B& b_ref = static_cast<B&>(c);
    
        C* c_ptra = static_cast<C*>(a_ptr); // 下行指针转换正常
        C* c_ptrb = static_cast<C*>(b_ptr); // 下行指针转换正常
        c_ptra->print(); // 输出C，符合多态的要求
        c_ptrb->print(); // 输出C，符合多态的要求
    
        C& c_refa = static_cast<C&>(a_ref); // 下行引用转换正常
        C& c_refb = static_cast<C&>(b_ref); // 下行引用转换正常
        c_refa.print(); // 输出C，符合多态的要求
        c_refb.print(); // 输出C，符合多态的要求
    }

可以看到这个也是正常的，和前面那个没有多态的差不多，接下来看一下不正常的下行转换例子：

int main(int argc, char* argv[])
    {
        A a;
        B b;
    
        C* c_ptra = static_cast<C*>(&a);
        C* c_ptrb = static_cast<C*>(&b);
        c_ptra->print(); // 正常输出A
        c_ptrb->print(); // 段错误
    
        C& c_refa = static_cast<C&>(a);
        C& c_refb = static_cast<C&>(b);
        c_refa.print(); // 正常输出A
        c_refb.print(); // 段错误
    }

上面这个例子中的下行转换是错误的，但是通过c\_ptra可以正常调用类A的print()方法打印出字母A来，使用c\_ptrb就直接段错误了，原因是类A是第一个被继承的，类B是第二个被继承的，也就是在类C中，第一个虚表指针指向的就是类A的虚表，第二个虚表指针指向的就是类B的虚表。在上面的例子那样进行错误地转换时，由于类A被继承之后它位置的特殊性导致可以使用c\_ptra正确地调用类A的print()方法，而类B则不行，可能这有点难理解，下面给大家看张图就明白了，如图2-1所示：

![img][]

从图2-1中可以看出，对于类C来说，它始终调用着\_vptr.A指向的print()方法，当我们使用纯类B类型进行下行转换时，根本就没有这一块的数据（这个转换是不完整的、不安全的），所以就会出现段错误了。当然，使用纯类A类型进行下行转换也是不完整、不安全的，只不过位置刚好才不会出现段错误而已。综合分析上面的代码是完全错误的，一定要杜绝写出这种垃圾代码。

综上，我们可以得出使用static\_cast对具有多态的类实例指针或引用进行强制类型转换时有以下特点：

*  进行上行转换（派生类指针->基类指针、派生类引用->基类引用）是完全安全的，没有任何问题，当然这个过程由隐式转换来完成也是合法的
 *  进行下行转换（基类指针->派生类指针、基类引用->派生类引用）由于缺乏安全检查，所以是有问题的，并且因为具有多态的类往往具有特殊的用法，所以在这种情况下产生的后果比前面没有多态情况下的要更严重，要尽量避免这种用法
    
    ##### 2.1.6 不能转换掉expression的const或volitale属性 #####

`static_cast`不能转换掉`expression`的`const`或`volitale`属性。示例如下：

#include <iostream>
    
    int main(int argc, char* argv[])
    {
        int temp = 10;
    
        const int* a_const_ptr = &temp;
        int* b_const_ptr = static_cast<int*>(a_const_ptr); // const int* -> int* 无效
    
        const int a_const_ref = 10;
        int& b_const_ref = static_cast<int&>(a_const_ref); // const int& -> int& 无效
    
        volatile int* a_vol_ptr = &temp;
        int* b_vol_ptr = static_cast<int*>(a_vol_ptr); // volatile int* -> int* 无效
    
        volatile int a_vol_ref = 10;
        int& b_vol_ref = static_cast<int&>(a_vol_ref); // volatile int& -> int& 无效
    }

##### 2.1.7 小结 #####

通过上面的介绍，我们可以很直观地看到static\_cast相比C风格的强制类型转换要安全很多，有很大程度上的类型安全检查。本节我们所有的例子都可以使用C风格的强制类型转换去做，但是转出来的结果有可能会错到天际去，并且编译器不会给你任何报错信息。同时我们也要认识到static\_cast也是有明显缺点的，那就是无法消除const和volatile属性、无法直接对两个不同类型的指针或引用进行转换和下行转换无类型安全检查等，不过没关系，其它三个强制类型转换的关键字刚好能弥补static\_cast的这些缺点。

#### 2.2 const\_cast ####

`const_cast`的作用是去除掉`const`或`volitale`属性，前面介绍`static_cast`的时候我们知道`static_cast`是不具备这种功能的。使用格式如下：

const_cast<type_id>(expression);

> \*\*注意事项：\*\*const\_cast不是用于去除变量的常量性，而是去除指向常量对象的指针或引用的常量性，其去除常量性的对象必须为指针或引用，并且const\_cast不支持不同类型指针或引用之间的转换，比如说float\*转换成int\*是不允许的，直白一点说就是type\_id和expression要基本类型保持一致，相差的话只能差const或volatile属性。

先来看一个错误的使用示例：

#include <iostream>
    
    int main(int argc, char* argv[])
    {
        int type_int = 100;
        float type_float = const_cast<float>(type_int);        // 错误，const_cast只能转换引用或者指针
        float* type_float_ptr = const_cast<float*>(&type_int); // 错误，从int* -> float* 无效
        float& type_float_ref = const_cast<float&>(type_int);  // 错误，从int& -> float& 无效
    }

再来看一个不太正确的使用示例：

#include <iostream>
    
    int main(int argc, char* argv[])
    {
        const int type_const_int = 100;
        int* type_const_int_ptr = const_cast<int*>(&type_const_int); // 转换正确
        int& type_const_int_ref = const_cast<int&>(type_const_int);  // 转换正确
        
        *type_const_int_ptr = 10;
        std::cout << *type_const_int_ptr << std::endl; // 输出10
        std::cout << type_const_int << std::endl;      // 输出100，没有改变
    
        type_const_int_ref = 20;
        std::cout << type_const_int_ref << std::endl; // 输出20
        std::cout << type_const_int << std::endl;     // 输出100，没有改变
    
        // 以下三个输出结果一致，说明const_cast确实只是去除了一些属性，并没有重新搞快内存把需要转换的变量给复制过去
        std::cout << "&type_const_int:\t" << &type_const_int << std::endl;
        std::cout << "type_const_int_ptr:\t" << type_const_int_ptr << std::endl;
        std::cout << "&type_const_int_ref:\t" << &type_const_int_ref << std::endl;
    }

在上面这个例子中，转换是成功了，但是type\_const\_int的常量性并没有被改变，这是因为const\_cast并没有办法把变量的常量性去除，而且比较有意思的是我们可以看到type\_const\_int对应地址的内容确实被改变了，但是type\_const\_int的值却并没有被改变，这是好事，因为从一开始我们把它定义为常量类型时这个值就不应该再被改变了。至于后面使用type\_const\_int\_ptr和type\_const\_int\_ref试图去改变type\_const\_int的值，这是很危险的做法，不同编译器可能会有不同的处理，是有可能出现严重错误的，要杜绝这种用法。  
从这里看起来const\_cast好像有点鸡肋。。。但是事实上不是这样的，在某些场景下const\_cast还是挺好用的，比如下面这个例子：

#include <iostream>
    
    void fun(const int& v)
    {
        int& type_int_ref = const_cast<int&>(v);
        type_int_ref = 10;
    }
    
    int main(int argc, char* argv[])
    {
        int type_int = 100;
    
        fun(type_int);
        std::cout << type_int << std::endl; // 输出10，改变了
    }

上面的例子比较粗糙，但是大致上也就是这么个用法了。如果一个变量本来就不具备const属性，但是在传递过程中被附加了const属性，这时候使用const\_cast就能完美清除掉后面附加的那个const属性了。

#### 2.3 reinterpret\_cast ####

`reinterpret_cast`意为“重新解释”，它是C++中最接近于C风格强制类型转换的一个关键字。它让程序员能够将一种对象类型转换为另一种，不管它们是否相关。使用格式如下：

reinterpret_cast<type_id>(expression);

注意事项如下：

> 1.  type-id和expression中必须有一个是指针或引用类型（可以两个都是指针或引用，指针引用在一定场景下可以混用，但是建议不要这样做，编译器也会给出相应的警告）。
> 2.  reinterpret\_cast的第一种用途是改变指针或引用的类型
> 3.  reinterpret\_cast的第二种用途是将指针或引用转换为一个整型，这个整型必须与当前系统指针占的字节数一致
> 4.  reinterpret\_cast的第三种用途是将一个整型转换为指针或引用类型
> 5.  可以先使用reinterpret\_cast把一个指针转换成一个整数，再把该整数转换成原类型的指针，还可以得到原先的指针值（由于这个过程中type-id和expression始终有一个参数是整形，所以另一个必须是指针或引用，并且整型所占字节数必须与当前系统环境下指针占的字节数一致）
> 6.  使用reinterpret\_cast强制转换过程仅仅只是比特位的拷贝，和C风格极其相似（但是reinterpret\_cast不是全能转换，详见第1点），实际上reinterpret\_cast的出现就是为了让编译器强制接受static\_cast不允许的类型转换，因此使用的时候要谨而慎之
> 7.  reinterpret\_cast同样也不能转换掉expression的const或volitale属性。

先来看一个错误的使用示例：

#include <iostream>
    
    class A
    {
    public:
        int a;
    };
    
    class B
    {
    public:
        int b;
    };
    
    int main(int argc, char* argv[])
    {
        float type_float = 10.1;
        int type_int = reinterpret_cast<int>(type_float); // 出错，type-id和expression中必须有一个是指针或者引用（注意事项第1点）
        char type_char = reinterpret_cast<char>(&type_float); // 出错，我的是64位系统，这里type-id只能是long类型（注意事项第3点）
        double* type_double_ptr = reinterpret_cast<double*>(type_float); // 出错，这里expression只能是整型（注意事项第4点）
    
        A a;
        B b;
        long type_long = reinterpret_cast<long>(a); // 出错，type-id和expression中必须有一个是指针或者引用（注意事项第1点）
        B b1 = reinterpret_cast<B>(a); // 出错，type-id和expression中必须有一个是指针或者引用（注意事项第1点）
        A a1 = reinterpret_cast<A>(&b); // 出错，B* -> A不允许，我的是64位系统，type-id只能是long（注意事项第3点）
        A* a_ptr = reinterpret_cast<A*>(b); // 出错，这里expression只能是整型（注意事项第4点）
    }

下面再来看正确的使用示例：

#include <iostream>
    
    class A
    {
    public:
        int a;
    };
    
    class B
    {
    public:
        int b;
    };
    
    int main(int argc, char* argv[])
    {
        float type_float = 10.1;
    
        long type_long = reinterpret_cast<long>(&type_float); // 正确，float* -> long（注意事项第3点）
    
        float* type_float_ptr = reinterpret_cast<float*>(type_long); // 正确，long -> float*（注意事项第4点）
        std::cout << *type_float_ptr << std::endl; // 正确，仍然输出10.1（注意事项第5点）
    
        long* type_long_ptr = reinterpret_cast<long*>(&type_float); // 正确，float* -> long*（注意事项第1点）
        
        char type_char = 'A';
        double& type_double_ptr = reinterpret_cast<double&>(type_char); // 正确，char -> double&（注意事项第4点）
    
        A a;
        B b;
        long a_long = reinterpret_cast<long>(&a); // 正确，A* -> long（注意事项第3点）
        A* a_ptr1 = reinterpret_cast<A*>(type_long); // 正确，long -> A*（注意事项第4点）
        A* a_ptr2 = reinterpret_cast<A*>(&b); // 正确，B* -> A*（注意事项第1点）
    }

#### 2.3 dynamic\_cast ####

前面三种都是编译时完成的，而`dynamic_cast`是运行时处理的，使用格式如下：

dynamic_cast<type_id>(expression);

注意事项如下：

> 1.  dynamic\_cast是运行时处理的，运行时会进行类型检查（这点和static\_cast差异较大）
> 2.  dynamic\_cast不能用于内置基本数据类型的强制转换，并且dynamic\_cast只能对指针或引用进行强制转换
> 3.  dynamic\_cast如果转换成功的话返回的是指向类的指针或引用，转换失败的话则会返回nullptr
> 4.  使用dynamic\_cast进行上行转换时，与static\_cast的效果是完全一样的
> 5.  使用dynamic\_cast进行下行转换时，dynamic\_cast具有类型检查的功能，比static\_cast更安全。并且这种情况下dynamic\_cast会要求进行转换的类必须具有多态性（即具有虚表，直白来说就是有虚函数或虚继承的类），否则编译不通过
> 6.  需要有虚表的原因：类中存在虚表，就说明它有想要让基类指针或引用指向派生类对象的情况，dynamic\_cast认为此时转换才有意义（事实也确实如此）。而且dynamic\_cast运行时的类型检查需要有运行时类型信息，这个信息是存储在类的虚表中的
> 7.  在C++中，编译期的类型转换有可能会在运行时出现错误，特别是涉及到类对象的指针或引用操作时，更容易产生错误。dynamic\_cast则可以在运行期对可能产生问题的类型转换进行测试

先来看一个错误的使用示例：

#include <iostream>
    
    class A
    {
    public:
        void print()
        {
            std::cout << "A" << std::endl;
        }
    };
    
    class B
    {
    public:
        void print()
        {
            std::cout << "B" << std::endl;
        }
    };
    
    class C : public A, public B
    {
    public:
        void print()
        {
            std::cout << "C" << std::endl;
        }
    };
    
    int main(int argc, char* argv[])
    {
        C c;
        A* a_ptr = dynamic_cast<A*>(&c); // 成功，上行转换没有任何要求（注意事项第4点）
        B* b_ptr = dynamic_cast<B*>(&c); // 成功，上行转换没有任何要求（注意事项第4点）
    
        A a = dynamic_cast<A>(c); // 错误，dynamic_cast无法用于转换类实例（注意事项第2点）
    
        C* c_ptra = dynamic_cast<C*>(a_ptr); // 错误，类C不具备多态，无法进行下行转换（注意事项第5点）
        C* c_ptrb = dynamic_cast<C*>(b_ptr); // 错误，类C不具备多态，无法进行下行转换（注意事项第5点）
    }

从上面的例子中可以看到，`dynamic_cast`是无法对实例进行转换的，并且`dynamic_cast`进行下行转换时是需要对应的类拥有多态性的，这两点和`static_cast`是有区别，当然这些不是最重要的区别，下面我们再来看一个例子：

#include <iostream>
    
    class A
    {
    public:
        virtual void print()
        {
            std::cout << "A" << std::endl;
        }
    };
    
    class B
    {
    public:
        virtual void print()
        {
            std::cout << "B" << std::endl;
        }
    };
    
    class C : public A, public B
    {
    public:
        virtual void print()
        {
            std::cout << "C" << std::endl;
        }
    };
    
    int main(int argc, char* argv[])
    {
        C c;
    
        // 第一组
        A* a_ptr = dynamic_cast<A*>(&c);
        B* b_ptr = dynamic_cast<B*>(&c);
        C* c_ptra = dynamic_cast<C*>(a_ptr); // 成功，类C具备多态性，可以使用dynamic_cast进行下行转换
        C* c_ptrb = dynamic_cast<C*>(b_ptr); // 成功，类C具备多态性，可以使用dynamic_cast进行下行转换
        // 以下输出内容一致
        std::cout << &c << std::endl;
        std::cout << c_ptra << std::endl;
        std::cout << c_ptra << std::endl;
    
        // 第二组
        A a;
        B b;
        C* c_ptra1 = dynamic_cast<C*>(&a); // 编译正常（好的编译器会给你个警告），转换结果为nullptr，说明转换失败
        C* c_ptrb1 = dynamic_cast<C*>(&b); // 编译正常（好的编译器会给你个警告），转换结果为nullptr，说明转换失败
        // 以下输出内容一致，都是0，说明c_ptra1和c_ptrb1都是nullptr
        std::cout << c_ptra1 << std::endl;
        std::cout << c_ptrb1 << std::endl;
    }

从上面的例子中可以看出以下几点信息：

*  对于第一组来说，因为这一组的下行转换是安全的（因为a\_ptr和b\_ptr本来就是类C的指针类型转换过去的），所以对于这种情况static\_cast和dynamic\_cast是一样的，都可以正常使用。
 *  对于第二组来说，这个是一个错误使用的示例，我们之前也有用static\_cast做过同样的实验（忘了的话可以翻回去2.1.3小节看一下），当时使用static\_cast进行这种错误的下行转换时是一点问题没有的，可以转换成功，甚至可以使用一下（当然这是极其糟糕的行为），而现在使用dynamic\_cast来转换则不同了，虽然编译也可以通过，但是它返回的结果是一个空指针，这就可以在运行时提示我们转换不合法了。

以上论述了C++中新增的四种强制类型转换，文中也有对它们各自的优点和缺点进行解析。整体来说C++增加的这几种强制类型转换相比C风格的更加安全，所以在编写C++代码时还是尽量使用它们替换C风格的强制类型转换吧。

[img]: https://img-blog.csdnimg.cn/20210702221611916.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc5ODg4Nw==,size_16,color_FFFFFF,t_70#pic_center