C++ 四种显式类型转换-CSDN博客

2019独角兽企业重金招聘Python工程师标准>>>

显式类型转换

reinterpret_cast<new_type>(EXPression)显式转换
const_cast<new_type>(EXPression)      显式转换
static_cast<new_type>(EXPression)     显式转换
dynamic_cast<new_type>(EXPression)    显式转换
功能: 将EXPression表达式的值转换为 new_type类型的值。
1 前三种类型的转换是在编译时期实现转换的,
   最后一个是在运行时期进行类型转换的，并且返回转换成功与否标志，这是传统的类型转换所不具备的功能

double   d=3.2;
int i= d; //隐式转换double变量d 为int 变量， i=3
倘若使用C++显式类型转换 static_cast(exp)函数做以上同样的事，就可以让他人知道这样的double 到 int 类型的转换，是有意这么做的，
并非疏忽大意所致。

double   d=3.2;
int i = static_cast<int>(d);//显式转换

A reinterpret_cast 类型转换函数将一个类型的指针，转换为另一个类型的指针。这种转换不用改变指针变量值数据存放格式(不改变指针变量值),只需在编译时重新解释指针的类型就可以做到。reinterpret_cast 可以将指针转换为一个整形数(隐式转换),但不能用于非指针类型的转换，即使这样做也不会通过编译
   1> 用显式的reinterpret_cast 将基本类型或一个类的指针，转换为另一个类型或类的指针
       //基本类型指针的类型转换
       double d=9.3;
       double* pd = &d;
       int *pi = reinterpret_cast<int* >(pd); //相当于隐式转换 int* pi = (int* )pd;
   2>
       //不相关的类的指针的类型转换
       class A{}; class B{};
       A* pa = new A;
       B* pb = reinterpret_cast<B* >(pa); // 相当于隐式转换 B* pb = (B*)pa;

   3>   指针转换为整数
       long j = reinterpret_cast<long>(pi); //相当于隐式转换 long j = (long)pi;

   4>   尝试将int 类型的变量转换为double 类型，由于并非指针类型转换，因此转换不成功.
       //企图转换非指针变量
       int i=8;
       double dl = reinterpret_cast<double>(i); //不能编译通过
       //企图转换 const 指针为 void * 指针
       const int* pci - 0;
       void* pv = reinterpret_cast<void* >(pci); //不能编译通过

B const_cast 类型转换函数用于去除指针变量的常量属性，将它转换为一个对应指针类型的普通变量。反过来，也可以将一个非常量的指针变量转换为一个常指针变量。这种转换是在编译期间做出的类型更改。
   1> 将int 类型的常指针便利pci 转换为int 指针变量，将类A的常指针便利pca 转换为类A的普通指针变量,将类A的常指针变量pca转换为类A的普通指针变量
       const int* pci = 0;
       int *pj = const_cast<int* >(pci); //相当于隐式转换 int * pj = (int* )pci;
       const A* pca = new A;
       A *pa = const_cast<A*>(pca);      //相当于隐式转换 A* pa = (A*)pca;
   2> 基于安全考虑，const_cast 无法将非指针的常变量转换为普通变量
       const int i = 0;
       const_cast<int>(i); //去除变量i的常属性，不能编译通过
   3>将普通指针变量pi 转换为常指针变量，但不能将非指针的普通变量转换为常变量。而隐式转换则允许
       int * pi = 0; //相当于隐式转换 const int* pcj = (int*)pi;
       const int* pcj = const_cast<const int* >(pi);

       int i =0;
       const int cj = const_cast<const int>(i); //非指针转换，不能编译通过
       const int ck = (const int)i; // 隐式转换，可通过编译
        该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外， type_id和expression的类型是一样的。
    常量指针被转化成非常量指针，并且仍然指向原来的对象；
    常量引用被转换成非常量引用，并且仍然指向原来的对象；常量对象被转换成非常量对象。
    volatile和const类型，举例如下所示。
    class B
    {
    public:
        int m_iNum;
    }
    void foo()
    {
        const B b1;
        b1.m_iNum = 100; //comile error
        B b2 = const_cast<B>(b1);
        b2. m_iNum = 200; //fine
    }
上面的代码编译时会报错，因为b1是一个常量对象，不能对它进行改变；
使用const_cast把它转换成一个非常量对象，就可以对它的数据成员任意改变。注意：b1和b2是两个不同的对象。

C static_cast 主要用于基本类型之间和具有继承关系的类型之间的转换，这种转换一般会更改变量的内部表示方式，因此static_cast应用于指针类型转换，没有太大意义，即使允许指针类型转换，也不及reinterpret_cast解释效率高
static_cast类型转换用于相关类型之间的转换，诸如：在同一个类的继承层次关系中，向上或向下转换；枚举类型与整数类型之间的转换；浮点类型与指数类型之间的转换。在这4中类型转换中，static_cast是最接近C-style的了。

该运算符把expression转换为type-id类型，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：
（1）用于类层次结构中基类和派生类之间指针或引用的转换
进行上行转换（把派生类的指针或引用转换成基类表示）是安全的
进行下行转换（把基类的指针或引用转换为派生类表示），由于没有动态类型检查，所以是不安全的
（2）用于基本数据类型之间的转换，如把int转换成char。这种转换的安全也要开发人员来保证
（3）把空指针转换成目标类型的空指针
（4）把任何类型的表达式转换为void类型
注意：static_cast不能转换掉expression的const、volitale或者__unaligned属性。

        1> // 基本类型转换
           int i=0;
           double d = static_cast<double>(i); //相当于隐式转换 double d =(double)i;
           int j = static_cast<int>(d);        //相当于隐式转换 int j = (int)d;
       2> //转换继承类的对象为基类对象
           class Base{};
           class Derived : public Base{};
           Derived d;
           Base b = static_cast<Base >(d);   //相当于隐式转换 Base b = (Base)d;
       3> 如下将继承类与基类的指针进行相互转换，都能编译通过，但基类指针转换为继承类指针，具有一定的危害性.
            // 继承类指针转换为基类指针
            Derived* pd = new Derived;
            Base* pb = static_cast<Base* >(pd); //相当于隐式转换 Base* pb = (Derived*)pd;
            // 基类指针转换为继承类指针
            Base* pb = new Base;
            Derived* pd = static_cast<Derived* >(pb); //相当于隐式转换 Derived* pd = (Dervived*)pb;
       4> 以下代码尝试用static_cast 转换基本数据类型的指针，将继承类对象转换为基类对象或转换无继承关系的类的指针，都不能编译通过.
            class A{};
           class B{};
           int *pi = 0;
           double *pd = static_cast<double* >(pi); //企图int* 转换为 double* , 不能编译通过
           //
           Base b;
           Derived d = static_cast<Derived>(b); //企图继承类对象转换为基类对象，不能编译通过

           //
           A a;
           B b = static_cast<B>(a);   //企图转换无继承关系的类，不能编译通过

           A * pa = NULL;
           B* pb = static_cast<B*>(pa); // 企图转换无继承关系的类的指针，不能编译通过


D dynamic_cast 与静态static_cast 相对，是动态的转换。这种转换是在运行时进行转换分析的，并非在编译时期进行。
   dynamic_cast 只能在继承类对象的指针之间或引用之间进行类型转换。进行转换时，会根据当前运行对象的运行时类型信息(RTTI),判断类型对象之间的转换是否合法。dynamic_cast的指针转换失败，可通过是否为NULL指针检测；引用转换失败，则抛出一个bad_cast异常。

用法：dynamic_cast<type_id> (expression)
该运算符把expression转换成type_id类型的对象。type_id必须是类的指针、引用或者void*；
如果type_id是类指针类型，那么expression也必须是一个指针，如果type_id是一个引用，那么expression也必须是一个引用。
    dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。
    在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；
    在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。

        1> dynamic_cast 将继承类指针或引用转换为基类指针或引用，并对没有继承关系，但被转换的类具有虚函数的对象指针进行转换，均可编译通过。
           class Base{};
           class Derived: public Base{};
           //继承类指针转换为基类指针
           Derived* pd = new Derived();
           Base* pb = dynamic_cast<Base* >(pd);
           if(!pb)
               printf("dynamic_cast 类型转换失败\n");
           else
               printf("dynamic_cast 类型转换成功\n");
           //有继承关系的引用之间转换
           Derived d;
           Base& b = dynamic_cast<Base& >(d);

           //没有继承关系，但被转换的类有虚函数
           class A {virtual ~A(){}}; // 有虚函数
           class B{};
           A* pa = new A;
           B* pb = dynamic_cast<B* >(pa); //有虚函数的对象指针，可以转换
           if(!pb)
               printf("dynamic_cast 类型转换失败\n");
           else
               printf("dynamic_cast 类型转换成功\n");
       2> 如下代码尝试将非指针的继承对象转换为基类对象，对无继承关系(且没有虚函数)的对象指针进行转换, 基本类型指针转换以及基类指针转换为继承类指针，均不能编译通过
           class A{}; //没有虚函数
           class B{virtual ~B(){}};
           //继承类转换为基类对象，不能编译通过
           Derived d;
           Base b = dynamic_cast<Base>(d);

           //无继承关系，且A 无虚函数， A类对象指针转换，不能编译通过
           A* pa = new A;
           B* pb = dynamic_cast<B* >(pa);

           // 基本类型之间转换(无继承关系)，不能通过
           int* i=0;
           int j = dynamic_cast<int* >(i);

           //基类指针转换为继承类指针，不能编译通过
           Base*   pb = new Base;
           Derived *pd = dynamic_cast<Derived* >(pb);

       3> dynamic_cast 不只是应用于类型转换，通常利用它做运行时对象类型检查的特性，在程序中检测当前内存对象的类型信息。

class B
{
public:
   int m_iNum;
    virtual void foo();
};
class D:public B
{
public:
    char *m_szName[100];
};
void func(B *pb)
{
    D *pd1 = static_cast<D *>(pb);
    D *pd2 = dynamic_cast<D *>(pb);
}
在上面的代码段中，如果pb指向一个D类型的对象，pd1和pd2是一样的，并且对这两个指针执行D类型的任何操作都是安全的；
    但是，如果pb指向的是一个B类型的对象，那么pd1将是一个指向该对象的指针，对它进行D类型的操作将是不安全的（如访问m_szName），
    而pd2将是一个空指针。
    另外要注意：B要有虚函数，否则会编译出错；static_cast则没有这个限制。
    这是由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表（
    关于虚函数表的概念，详细可见<Inside c++ object model>）中，只有定义了虚函数的类才有虚函数表，
    没有定义虚函数的类是没有虚函数表的。

另外，dynamic_cast还支持交叉转换，如下所示。
    class A
    {
    public:
        int m_iNum;
        virtual void f(){}
    };
    class B:public A
    {

    };
    class D:public A
    {

    };
    void foo()
    {
        B *pb = new B;
        pb->m_iNum = 100;
        D *pd1 = static_cast<D *>(pb); //compile error
        D *pd2 = dynamic_cast<D *>(pb); //pd2 is NULL
        delete pb;
    }
    在函数foo中，使用static_cast进行转换是不被允许的，将在编译时出错，而使用dynamic_cast转换则是允许的，结果是空指针。
    zongjie

在写代码中经常会有很多的隐式类型转换或显式类型转换。

对于隐式的类型转换主要是放生在赋值的时候，讲变量赋值给不同类型的变量的时候就会发生类型转换，如果是宽化转换（即从占字节少的类型向占字节多的类型转换），这个时候是不会出现丢失数据的。如果是窄化转换（从占字节多的类型向占字节少的类型转换），这个时候就很有可能会出现丢失数据，或者数据错误（如从有符号向无符号转换，就可能会出现各种无法想象的问题）。。。所以这种情况应该尽量避免。

对于C风格显式转换，就是强制转换，可能会造成数据解释错误，也是很不安全的。

在C++中有四种类型转换：

static_cast <new_type> (expression) 静态转换

静态转换类似于C风格显式转换，但是会判断转换类型之间的关系，如果转换类型之间没有任何关系，则不可转换，编译器会报错。（不相关类型之间不可以发生转换）.

dynamic_cast <new_type> (expression) 动态转换

动态转换有两个约束条件：其一是要求new_type为指针或引用，其二是下行转换时要求基类是多态的（基类中包含至少一个虚函数）。

动态转换支持上行转换和下行转换，但是对于不安全的下行转换，会返回NULL，提高安全性（上行转换：子类转化为父类，下行转换：父类转化为子类）。

reinterpret_cast <new_type> (expression) 重解释转换

重解释转换则是任何两个类型之间都可以转换，是最不安全的一种类型转换，尽量不要用。

const_cast <new_type> (expression) 常量向非常量转换

将常量转换为非常量，这个转换并不转换原常量本身，只是它返回的结果为非常量了

http://blog.csdn.net/coding_hello/article/details/2211466

http://www.xuebuyuan.com/1554696.html

http://www.2cto.com/kf/201411/353737.html

http://blog.csdn.net/thesys/article/details/5651713
https://www.google.com.hk/search?q=ttp://blog.csdn.net/pongba/archive/2004/09/01/90642.aspx&ie=utf-8&oe=utf-8&gws_rd=cr&ei=tWTLVM7UJMTU8gXN5IGwBA
http://blog.csdn.net/pongba/article/details/90642
http://blog.csdn.net/pongba/article/details/2544894
http://blog.csdn.net/pongba/article/list/2http://blog.csdn.net/pongba/article/list/2
http://blog.csdn.net/pongba/article/list/2

转载于:https://my.oschina.net/u/1178070/blog/374834