C++基础之强制类型转换

C++中的类型转换分为：隐式类型转换和显式类型转换。

隐式类型转换

关于隐式转换原则，这篇文章中有详细讲解：混合运算中不同数据类型之间的转换原则（C语言），在此简略带过。

1) 算术转换(Arithmetic conversion)

在混合类型的算术表达式中, 最宽的数据类型成为目标转换类型。

int ival = 3;
double dval = 3.14159;
ival + dval;//ival被提升为double类型

2)一种类型表达式赋值给另一种类型的对象

目标类型是被赋值对象的类型。

int *pi = 0; // 0被转化为int *类型
ival = dval; // double->int

3)将一个表达式作为实参传递给函数调用，此时形参和实参类型不一致

目标转换类型为形参的类型。

extern double sqrt(double);
cout << "The square root of 2 is " << sqrt(2) << endl;
//2被提升为double类型：2.0

4)从一个函数返回一个表达式，表达式类型与返回类型不一致

目标转换类型为函数的返回类型。

double difference(int ival1, int ival2) {
    return ival1 - ival2;
    //返回值被提升为double类型
}

显式类型转换

C语言强制类型转换主要用于基础的数据类型间的转换，语法为：

(type-id)expression//OR
type-id(expression)

隐式类型转换是安全的，显式类型转换是有风险的。

为了使潜在风险更加细化，使问题追溯更加方便，使书写格式更加规范，C++对类型转换进行了分类，并新增了四个关键字来予以支持，它们分别是：

关键字	说明
static_cast	用于良性转换，一般不会导致意外发生，风险很低。
const_cast	用于 const 与非 const、volatile 与非 volatile 之间的转换。
reinterpret_cast	高度危险的转换，这种转换仅仅是对二进制位的重新解释，不会借助已有的转换规则对数据进行调整，但是可以实现最灵活的 C++ 类型转换。
dynamic_cast	借助 RTTI，用于类型安全的向下转型（Downcasting）。

这四个关键字的语法格式都是一样的，具体为：

xxx_cast<newType>(expression)

newType 是要转换成的新类型，expression是被转换的表达式。double 转 int 的新旧风格对比：

double scores = 95.5;
int n = (int)scores; //C
int n = static_cast<int>(scores); //C++

static_cast 关键字

static_cast 只能用于良性转换，这样的转换风险较低，一般不会发生什么意外，例如：

• 原有的自动类型转换，例如short转int、int转double、const转非const、向上转型等；
• void指针和具体类型指针之间的转换，例如 void * 转 int * 、 char * 转 void * 等；
• 有转换构造函数或者类型转换函数的类与其它类型之间的转换，例如double转Complex（调用转换构造函数）、Complex转double（调用类型转换函数）。

需要注意的是，static_cast不能用于无关类型之间的转换，因为这些转换都是有风险的，例如：

• 两个具体类型指针之间的转换，例如 int * 转 double * 、 Student * 转 int * 等。不同类型的数据存储格式不一样，长度也不一样，用A类型的指针指向B 类型的数据后，会按照A类型的方式来处理数据：如果是读取操作，可能会得到一堆没有意义的值；如果是写入操作，可能会使B类型的数据遭到破坏，当再次以 B类型的方式读取数据时会得到一堆没有意义的值。
• int和指针之间的转换。将一个具体的地址赋值给指针变量是非常危险的，因为该地址上的内存可能没有分配，也可能没有读写权限，恰好是可用内存反而是小概率事件。

static_cast也不能用来去掉表达式的const修饰和volatile修饰。换句话说，不能将const/volatile类型转换为非const/volatile类型。

static_cast是“静态转换”的意思，也就是在编译期间转换，转换失败的话会抛出一个编译错误。

示例

#include <iostream>
#include <cstdlib>
using namespace std;

class Complex{
public:
    Complex(double real = 0.0, double imag = 0.0): m_real(real), m_imag(imag){ }
public:
    operator double() const { return m_real; }  //类型转换函数
private:
    double m_real;
    double m_imag;
};

int main(){
    //下面是正确的用法
    int m = 100;
    Complex c(12.5, 23.8);
    long n = static_cast<long>(m);  //宽转换，没有信息丢失
    char ch = static_cast<char>(m);  //窄转换，可能会丢失信息
    int *p1 = static_cast<int*>( malloc(10 * sizeof(int)) );  //将void指针转换为具体类型指针
    void *p2 = static_cast<void*>(p1);  //将具体类型指针，转换为void指针
    double real = static_cast<double>(c);  //调用类型转换函数
   
    //下面的用法是错误的
    float *p3 = static_cast<float*>(p1);  //不能在两个具体类型的指针之间进行转换
    p3 = static_cast<float*>(0X2DF9);  //不能将整数转换为指针类型

    return 0;
}

const_cast 关键字

const_cast比较好理解，它用来去掉表达式的const修饰或volatile修饰。换句话说，const_cast就是用来将const/volatile类型转换为非const/volatile类型。

示例

#include <iostream>
using namespace std;

int main(){
    const int n = 100;
    int *p = const_cast<int*>(&n);
    *p = 234;
    cout << "n = " << n << endl;
    cout << "*p = " << *p << endl;

    return 0;
}
/*output:
n = 100
*p = 234
*/

 &n 用来获取n的地址，它的类型为 const int * ，必须使用const_cast 转换为 int * 类型后才能赋值给 int * 类型的p。由于p指向了n，并且n占用的是栈内存，有写入权限，所以可以通过p修改n的值。

编译器优化

为什么通过n和*p输出的值不一样呢？

这是因为C++对常量的处理更像是编译时期的 #define ，是一个值替换的过程，代码中所有使用n的地方在编译期间就被替换成了100（体现在汇编中就是直接在寄存器中写入立即数而非通过访问内存）。换句话说，第8行代码被替换成了： cout << "n = " << 100 << endl; 。这样以来，即使程序在运行期间修改 n 的值，也不会影响 cout 语句了。

使用const_cast进行强制类型转换可以突破 C/C++ 的常量限制，修改常量的值，因此有一定的危险性；但是程序员如果这样做的话，基本上会意识到这个问题，因此也还有一定的安全性。

reinterpret_cast 关键字

reinterpret是“重新解释”的意思，顾名思义，reinterpret_cast这种转换仅仅是对二进制位的重新解释，不会借助已有的转换规则对数据进行调整，非常简单粗暴，所以风险很高。

reinterpret_cast 可以认为是static_cast的一种补充，一些static_cast不能完成的转换，就可以用reinterpret_cast来完成，例如两个具体类型指针之间的转换、int 和指针之间的转换（有些编译器只允许int转指针，不允许反过来）。

示例

#include <iostream>
using namespace std;

class A{
public:
    A(int a = 0, int b = 0): m_a(a), m_b(b){}
private:
    int m_a;
    int m_b;
};

int main(){
    //将 char* 转换为 float*
    char str[]="http://c.biancheng.net";
    float *p1 = reinterpret_cast<float*>(str);
    cout << *p1 << endl;
    //将 int 转换为 int*
    int *p = reinterpret_cast<int*>(100);
    //将 A* 转换为 int*
    p = reinterpret_cast<int*>(new A(25, 96));
    cout << *p << endl;
   
    return 0;
}
/*output:
3.0262e+29
25*/

可以想象，用一个float指针来操作一个char数组是一件多么荒诞和危险的事情，这样的转换方式不到万不得已的时候不要使用。将 A* 转换为 int* ，使用指针直接访问 private成员刺穿了一个类的封装性，更好的办法是让类提供get/set函数，间接地访问成员变量。

dynamic_cast 关键字

dynamic_cast用于在类的继承层次之间进行类型转换，它既允许向上转型（Upcasting），也允许向下转型（Downcasting）。向上转型是无条件的，不会进行任何检测，所以都能成功；向下转型的前提必须是安全的，要借助RTTI进行检测，所有只有一部分能成功。

dynamic_cast与static_cast是相对的，dynamic_cast是“动态转换”的意思，static_cast是“静态转换”的意思。dynamic_cast会在程序运行期间借助RTTI进行类型转换，这就要求基类必须包含虚函数；static_cast在编译期间完成类型转换，能够更加及时地发现错误。

dynamic_cast 的语法格式为：

dynamic_cast <newType> (expression)

newType和expression必须同时是指针类型或者引用类型。换句话说，dynamic_cast只能转换指针类型和引用类型，其它类型（int、double、数组、类、结构体等）都不行。
对于指针，如果转换失败将返回NULL；对于引用，如果转换失败将抛出 std::bad_cast 异常。

1) 向上转型（Upcasting）

向上转型时，只要待转换的两个类型之间存在继承关系，并且基类包含了虚函数（这些信息在编译期间就能确定），就一定能转换成功。因为向上转型始终是安全的，所以 dynamic_cast不会进行任何运行期间的检查，这个时候的 dynamic_cast 和 static_cast 就没有什么区别了。

示例

「向上转型时不执行运行期检测」虽然提高了效率，但也留下了安全隐患：

#include <iostream>
#include <iomanip>
using namespace std;

class Base{
public:
    Base(int a = 0): m_a(a){ }
    int get_a() const{ return m_a; }
    virtual void func() const { }
protected:
    int m_a;
};

class Derived: public Base{
public:
    Derived(int a = 0, int b = 0): Base(a), m_b(b){ }
    int get_b() const { return m_b; }
private:
    int m_b;
};

int main(){
    //情况①
    Derived *pd1 = new Derived(35, 78);
    Base *pb1 = dynamic_cast<Derived*>(pd1);
    cout<< "pd1 = " << pd1 << ", pb1 = " << pb1 << endl;
    cout<< pb1->get_a() << endl;
    pb1->func();

    //情况②
    int n = 100;
    Derived *pd2 = reinterpret_cast<Derived*>(&n);
    Base *pb2 = dynamic_cast<Base*>(pd2);
    cout<< "pd2 = " << pd2 << ", pb2 = " << pb2 <<endl;
    cout<< pb2->get_a() << endl;  //输出一个垃圾值
    pb2->func();  //内存错误

    return 0;
}

情况①是正确的，没有任何问题。对于情况②，pd指向的是整型变量n，并没有指向一个Derived类的对象，在使用dynamic_cast进行类型转换时也没有检查这一点，而是将pd的值直接赋给了pb（这里并不需要调整偏移量），最终导致pb也指向了n。因为pb指向的不是一个对象，所以 get_a() 得不到m_a的值（实际上得到的是一个垃圾值）， pb2->func() 也得不到func()函数的正确地址。

pb2->func() 得不到func()的正确地址的原因在于，pb2指向的是一个假的“对象”，它没有虚函数表，也没有虚函数表指针，而func()是虚函数，必须到虚函数表中才能找到它的地址。

2) 向下转型（Downcasting）

向下转型是有风险的，dynamic_cast会借助RTTI信息进行检测，确定安全的才能转换成功，否则就转换失败。

示例

#include <iostream>
using namespace std;

class A{
public:
    virtual void func() const { cout<<"Class A"<<endl; }
private:
    int m_a;
};

class B: public A{
public:
    virtual void func() const { cout<<"Class B"<<endl; }
private:
    int m_b;
};

class C: public B{
public:
    virtual void func() const { cout<<"Class C"<<endl; }
private:
    int m_c;
};

class D: public C{
public:
    virtual void func() const { cout<<"Class D"<<endl; }
private:
    int m_d;
};

int main(){
    A *pa = new A();
    B *pb;
    C *pc;
   
    //情况①
    pb = dynamic_cast<B*>(pa);  //向下转型失败
    if(pb == NULL){
        cout<<"Downcasting failed: A* to B*"<<endl;
    }else{
        cout<<"Downcasting successfully: A* to B*"<<endl;
        pb -> func();
    }
    pc = dynamic_cast<C*>(pa);  //向下转型失败
    if(pc == NULL){
        cout<<"Downcasting failed: A* to C*"<<endl;
    }else{
        cout<<"Downcasting successfully: A* to C*"<<endl;
        pc -> func();
    }
   
    cout<<"-------------------------"<<endl;
   
    //情况②
    pa = new D();  //向上转型都是允许的
    pb = dynamic_cast<B*>(pa);  //向下转型成功
    if(pb == NULL){
        cout<<"Downcasting failed: A* to B*"<<endl;
    }else{
        cout<<"Downcasting successfully: A* to B*"<<endl;
        pb -> func();
    }
    pc = dynamic_cast<C*>(pa);  //向下转型成功
    if(pc == NULL){
        cout<<"Downcasting failed: A* to C*"<<endl;
    }else{
        cout<<"Downcasting successfully: A* to C*"<<endl;
        pc -> func();
    }
   
    return 0;
}
/*output:
Downcasting failed: A* to B*
Downcasting failed: A* to C*
-------------------------
Downcasting successfully: A* to B*
Class D
Downcasting successfully: A* to C*
Class D*/

这段代码中类的继承顺序为：A => B => C => D。pa 是 A* 类型的指针，当pa指向A类型的对象时，向下转型失败，pa不能转换为 B* 或 C* 类型。当pa指向D类型的对象时，向下转型成功，pa可以转换为 B* 或 C* 类型。同样都是向下转型，为什么pa指向的对象不同，转换的结果就大相径庭呢？

RTTI和继承链

有虚函数存在时对象的真实内存模型中，每个类都会在内存中保存一份类型信息（ struct type_info ），编译器会将存在继承关系的类的类型信息使用指针“连接”起来，从而形成一个继承链（Inheritance Chain），也就是如下图所示的样子：

当使用dynamic_cast对指针进行类型转换时，程序会先找到该指针指向的对象，再根据对象找到当前类（指针指向的对象所属的类）的类型信息，并从此节点开始沿着继承链向上遍历，如果找到了要转化的目标类型，那么说明这种转换是安全的，就能够转换成功，如果没有找到要转换的目标类型，那么说明这种转换存在较大的风险，就不能转换。

对于本例中的情况①，pa指向A类对象，根据该对象找到的就是A的类型信息，当程序从这个节点开始向上遍历时，发现A的上方没有要转换的B类型或C类型（实际上A 的上方没有任何类型了），所以就转换败了。对于情况②，pa指向D类对象，根据该对象找到的就是D的类型信息，程序从这个节点向上遍历的过程中，发现了C类型和 B类型，所以就转换成功了。

总起来说，dynamic_cast会在程序运行过程中遍历继承链（代价是影响效率），如果途中遇到了要转换的目标类型，那么就能够转换成功，如果直到继承链的顶点（最顶层的基类）还没有遇到要转换的目标类型，那么就转换失败。对于同一个指针（例如 pa），它指向的对象不同，会导致遍历继承链的起点不一样，途中能够匹配到的类型也不一样，所以相同的类型转换产生了不同的结果。

从表面上看起来 dynamic_cast确实能够向下转型，本例也很好地证明了这一点：B和C都是A的派生类，我们成功地将pa从A类型指针转换成了B和C类型指针。但是从本质上讲，dynamic_cast还是只允许向上转型，因为它只会向上遍历继承链。造成这种假象的根本原因在于，派生类对象可以用任何一个基类的指针指向它，这样做始终是安全的。本例中的情况②，pa指向的对象是D类型的，pa、pb、pc 都是D的基类的指针，所以它们都可以指向D类型的对象，dynamic_cast只是让不同的基类指针指向同一个派生类对象罢了。

参考资料

http://c.biancheng.net/view/2343.html

https://www.cnblogs.com/ljygoodgoodstudydaydayup/p/3897314.html

https://www.cnblogs.com/chenyangchun/p/6795923.html