C++四种强制类型转换介绍

朱雀 2021-06-22 15:37 476阅读 0赞

## 1、C风格的强制转换： ##

C风格的强制转换(Type Cast)容易理解,不管什么类型的转换都可以使用使用下面的方式。

TypeName b = (TypeName)a;

规则：

*  将浮点型数据赋值给整型变量时，舍弃其小数部分。
 *  将整型数据赋值给浮点型变量时，数值不变，但是以指数形式存储。
 *  将double型数据赋值给float型变量时，注意数值范围溢出。
 *  字符型数据可以赋值给整型变量，此时存入的是字符的ASCII码。
 *  将一个int，short或long型数据赋值给一个char型变量，只将低8位原封不动的送到char型变量中。
 *  将有符号型数据赋值给长度相同的无符号型变量，连同原来的符号位一起传送。

当然C++也是支持C风格的强制转换，但是C风格的强制转换可能带来一些隐患，让一些问题难以察觉。所以C++提供了一组可以用在不同场合的强制转换的函数。

## 2、C++风格的强制转换： ##

在C++语言中新增了四个关键字const\_cast、static\_cast、dynamic\_cast和reinterpret\_cast。这四个关键字都是用于强制类型转换的。

新类型的强制转换可以提供更好的控制强制转换过程，允许控制各种不同种类的强制转换。

C++中风格是static\_cast<type>(content)。C++风格的强制转换其他的好处是，它们能更清晰的表明它们要干什么。程序员只要扫一眼这样的代码，就能立即知道一个强制转换的目的。

**2.1）const\_cast：**

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

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

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

我们看一个错误的例子：

#include <iostream>
    using namespace std;
    int main() {
      const int a = 10;
      int* q = &a;//compile error
    
      const int* p = &a;
      *q = 20;//compile error
     
      int b = const_cast<int>(a);//compile error
    
      return 0;
    }

正确示例：

#include <iostream>
    using namespace std;
    int main() {
      const int a = 10;
      const int* p = &a;
    
      int* q;
      q = const_cast<int*>(p);
      *q = 20;
    
      cout<<a<<" "<<*p<<" "<<*q<<endl;
      cout<<&a<<" "<<p<<" "<<q<<endl;
      return 0;
    }

输出：

10 20 20
    0x7ffee2ef2ffc 0x7ffee2ef2ffc 0x7ffee2ef2ffc

指针p和指针q都是指向a变量，指向地址相同，而且经过调试发现002CFAF4地址内的值确实由10被修改成了20，这是怎么一回事呢？为什么a的值打印出来还是10呢？

其实这是一件好事，我们要庆幸a变量最终的值没有变成20！变量a一开始就被声明为一个常量变量，不管后面的程序怎么处理，它就是一个常量，不会变化的。试想如果a最终变成了20会有什么后果呢？对于简短的程序而言，如果a变成了20，我们会一眼看出是q指针修改了，但一个项目工程非常庞大的时候，在程序某个地方出现了一个q这样的指针，它可以修改常量a，这是一件很可怕的事情的，可以说是一个程序的漏洞。

“\*q=20”语句为未定义行为语句，所谓的未定义行为是指在标准的C++规范中并没有明确规定这种语句的具体行为，该语句的具体行为由编译器来自行决定如何处理。对于这种未定义行为的语句我们应该尽量予以避免！

上例中可以看出我们是不想修改变量a的值的，既然如此，定义一个const\_cast关键字强制去掉指针的常量性到底有什么用呢？我们看一个例子：

#include <iostream>
    using namespace std;
    
    const int* search(const int* a,int n,int val) {
        for (int i = 0;i < n; ++i){
          if (a[i] == val) {
            return &a[i];
          }
        }
        return nullptr;
    }
    
    int main() {
      int a[5] = {0,2,4,6,8};
      int val = 4;
      int* p = const_cast<int&>(search(a,5,val));
      if (p == nullptr){
        cout<<"not found..."<<endl;
      } else {
        cout<<"found..."<<endl;
      }
    }

函数Search返回值是const指针，当我们在a数组中找到了val值的时候，我们会返回val的地址，最关键的是a数组在main函数中并不是const，因此即使我们去掉返回值的常量性有可能会造成a数组被修改，但是这也依然是安全的。

再看一个引用的例子：

#include <iostream>
    using namespace std;
    
    const int& search(const int* a,int n,int val) {
        for (int i = 0;i < n; ++i){
          if (a[i] == val) {
            return a[i];
          }
        }
        return NULL;
    }
    
    int main() {
      int a[5] = {0,2,4,6,8};
      int val = 4;
      int& p = const_cast<int&>(search(a,5,val));
      if (p == NULL){
        cout<<"not found..."<<endl;
      } else {
        cout<<"found..."<<endl;
      }
    }

了解了const\_cast的使用场景后，可以知道使用const\_cast通常是一种无奈之举，同时也建议大家在今后的C++程序设计过程中一定不要利用const\_cast去掉指针或引用的常量性并且去修改原始变量的数值，这是一种非常不好的行为。

**2.2）static\_cast：**

static\_cast 作用和C语言风格强制转换的效果基本一样，由于没有运行时类型检查来保证转换的安全性，所以这类型的强制转换和C语言风格的强制转换都有安全隐患。主要用于：

*  用于类层次结构中基类（父类）和派生类（子类）之间指针或引用的转换。注意：进行上行转换（把派生类的指针或引用转换成基类表示）是安全的；进行下行转换（把基类指针或引用转换成派生类表示）时，由于没有动态类型检查，所以是不安全的。
 *  用于基本数据类型之间的转换，如把int转换成char，把int转换成enum。这种转换的安全性需要开发者来维护。
 *  static\_cast不能转换掉原有类型的const、volatile、或者 \_\_unaligned属性。(前两种可以使用const\_cast 来去除)
 *  在c++ primer 中说道：c++ 的任何的隐式转换都是使用 static\_cast 来实现。

/* 常规的使用方法 */
    float f_pi=3.141592f
    int   i_pi=static_cast<int>(f_pi); /// i_pi 的值为 3
    
    //编译通过，安全
    Sub sub;
    Base *base_ptr = static_cast<Base*>(&sub);

**2.3）reinterpret\_cast：**  
在C++语言中，reinterpret\_cast主要有三种强制转换用途：改变指针或引用的类型、将指针或引用转换为一个足够长度的整形（取决于操作系统，32位的OS，需要4个字节及以上的整型，64位的OS，需要8个字节及以上的整型）、将整型转换为指针或引用类型。  
它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针（先把一个指针转换成一个整数，在把该整数转换成原类型的指针，才可以得到原先的指针值）。  
在使用reinterpret\_cast强制转换过程仅仅只是比特位的拷贝，因此在使用过程中需要特别谨慎！

#include<iostream>
    #include<cstdint>
    using namespace std;
    int main() {
        int *ptr = new int(233);
        uint32_t ptr_addr = reinterpret_cast<uint32_t>(ptr);
        cout << "ptr 的地址: " << hex << ptr << endl
            << "ptr_addr 的值(hex): " << hex << ptr_addr << endl;
        delete ptr;
        return 0;
    }
    /*
    ptr 的地址: 0061E6D8
    ptr_addr 的值(hex): 0061e6d8
    */

**2.4）dynamic\_cast：**

dynamic\_cast是运行时处理的，运行时要进行类型检查，其他三种都是编译时完成的。在C++中，编译期的类型转换有可能会在运行时出现错误，特别是涉及到类对象的指针或引用操作时，更容易产生错误。Dynamic\_cast操作符则可以在运行期对可能产生问题的类型转换进行测试。

规则：

*  不能用于内置的基本数据类型的强制转换；dynamic\_cast转换如果成功的话返回的是指向类的指针或引用，转换失败的话则会返回NULL。
 *  使用dynamic\_cast进行转换的，基类中一定要有虚函数，否则编译不通过；（原因：类中存在虚函数，就说明它有想要让基类指针或引用指向派生类对象的情况，此时转换才有意义。这是由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表中，只有定义了虚函数的类才有虚函数表）
 *  在类的转换时，在类层次间进行上行转换时，dynamic\_cast和static\_cast的效果是一样的。在进行下行转换时，dynamic\_cast具有类型检查的功能，比static\_cast更安全。

#include<iostream>
    using namespace std;
    
    class Base{
    public:
        void print() {
            std::cout << "I'm Base" << endl;
        }
        virtual void i_am_virtual_foo() {}
    };
    
    class Sub: public Base{
    public:
        void print() {
            std::cout << "I'm Sub" << endl;
        }
        virtual void i_am_virtual_foo() {}
    };
    int main() {
        //Sub->Base
        Sub * sub = new Sub();
        sub->print();
        Base* sub2base = dynamic_cast<Base*>(sub);
        if (sub2base != nullptr) {
            sub2base->print();
        }
        cout << "<sub->base> sub2base val is: " << sub2base << endl;
    
    
        //Base->Sub
        Base *base = new Base();
        base->print();
        Sub  *base2sub = dynamic_cast<Sub*>(base);
        if (base2sub != nullptr) {
            base2sub->print();
        }
        cout <<"<base->sub> base2sub val is: "<< base2sub << endl;
    
        delete sub;
        delete base;
        return 0;
    }

输出：  
I'm Sub  
I'm Base  
<sub->base> sub2base val is: 00B9E080    
I'm Base  
<base->sub> base2sub val is: 00000000

分析：在我们可以将由子类上转型父类的对象，再下转型成子类对象。