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

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  

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