C++强制类型转换的方式有哪些

本篇内容主要讲解“C++强制类型转换的方式有哪些”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“C++强制类型转换的方式有哪些”吧!

1 C++类型转换本质

1.1 自动类型转换（隐式）

利用编译器内置的转换规则，或者用户自定义的转换构造函数以及类型转换函数（这些都可以认为是已知的转换规则）。
例如从 int 到 double、从派生类到基类、从type *到void *、从 double 到 Complex 等。
注：

type *是一个具体类型的指针，例如int *、double *、Student *等，它们都可以直接赋值给void *指针。
例如，malloc() 分配内存后返回的就是一个void *指针，我们必须进行强制类型转换后才能赋值给指针变量。

1.2 强制类型转换（显式）

隐式不能完成的类型转换工作，就必须使用强制类型转换
(new_type) expression

1.3 类型转换的本质

数据类型的本质：
这种「确定数据的解释方式」的工作就是由数据类型（Data Type）来完成的。例如int a;表明，a 这份数据是整数，不能理解为像素、声音、视频等。
数据类型转换的本质：
数据类型转换，就是对数据所占用的二进制位做出重新解释。

• 隐式类型转换：编译器可以根据已知的转换规则来决定是否需要修改数据的二进制位

• 强制类型转换：由于没有对应的转换规则，所以能做的事情仅仅是重新解释数据的二进制位，但无法对数据的二进制位做出修正。

1.4 类型转换的安全性

隐式类型转换必须使用已知的转换规则，虽然灵活性受到了限制，但是由于能够对数据进行恰当地调整，所以更加安全（几乎没有风险）。
强制类型转换能够在更大范围的数据类型之间进行转换，例如不同类型指针（引用）之间的转换、从 const 到非 const 的转换、从 int 到指针的转换（有些编译器也允许反过来）等，这虽然增加了灵活性，但是由于不能恰当地调整数据，所以也充满了风险，程序员要小心使用。

2 四种类型转换运算符

2.1 C语言的强制类型转换与C++的区别

C风格的强制类型转换统一使用()，而()在代码中随处可见，所以也不利于使用检索工具定位强转的代码位置。
C++ 对类型转换进行了分类，并新增了四个关键字来予以支持，它们分别是：

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

语法格式为： xxx_cast<newType>(data)

3 static_cast

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;}

4 reinterpret_cast

reinterpret_cast 用于进行各种不同类型的指针之间、不同类型的引用之间以及指针和能容纳指针的整数类型之间的转换。转换时，执行的是逐个比特复制的操作。

#include <iostream>using namespace std;class A{public:    int i;    int j;    A(int n):i(n),j(n) { }};int main(){    A a(100);    int &r = reinterpret_cast<int&>(a); //强行让 r 引用 a    r = 200;  //把 a.i 变成了 200    cout << a.i << "," << a.j << endl;  // 输出 200,100    int n = 300;    A *pa = reinterpret_cast<A*> ( & n); //强行让 pa 指向 n    pa->i = 400;  // n 变成 400    pa->j = 500;  //此条语句不安全，很可能导致程序崩溃    cout << n << endl;  // 输出 400    long long la = 0x12345678abcdLL;    pa = reinterpret_cast<A*>(la); //la太长，只取低32位0x5678abcd拷贝给pa    unsigned int u = reinterpret_cast<unsigned int>(pa);//pa逐个比特拷贝到u    cout << hex << u << endl;  //输出 5678abcd    typedef void (* PF1) (int);    typedef int (* PF2) (int,char *);    PF1 pf1;  PF2 pf2;    pf2 = reinterpret_cast<PF2>(pf1); //两个不同类型的函数指针之间可以互相转换}

reinterpret_cast体现了 C++ 语言的设计思想：用户可以做任何操作，但要为自己的行为负责。

5 const_cast

const_cast 运算符仅用于进行去除 const 属性的转换，它也是四个强制类型转换运算符中唯一能够去除 const 属性的运算符。

将 const 引用转换为同类型的非 const 引用，将 const 指针转换为同类型的非 const 指针时可以使用 const_cast 运算符。例如：

const string s = "Inception";string& p = const_cast <string&> (s);string* ps = const_cast <string*> (&s);  // &s 的类型是 const string*

6 dynamic_cast

用 reinterpret_cast 可以将多态基类（包含虚函数的基类）的指针强制转换为派生类的指针，但是这种转换不检查安全性，即不检查转换后的指针是否确实指向一个派生类对象。
dynamic_cast专门用于将多态基类的指针或引用强制转换为派生类的指针或引用，而且能够检查转换的安全性。对于不安全的指针转换，转换结果返回 NULL 指针。

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

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

dynamic_cast 是通过“运行时类型检查”来保证安全性的。
dynamic_cast 不能用于将非多态基类的指针或引用强制转换为派生类的指针或引用&mdash;&mdash;这种转换没法保证安全性，只好用 reinterpret_cast 来完成。

6.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() 是虚函数，必须到虚函数表中才能找到它的地址。

6.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;}

当使用 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 只是让不同的基类指针指向同一个派生类对象罢了。

到此，相信大家对“C++强制类型转换的方式有哪些”有了更深的了解，不妨来实际操作一番吧！这里是编程网网站，更多相关内容可以进入相关频道进行查询，关注我们，继续学习！