20140422 ALT+F8 四个强制类型转换

一、static_cast, dynamic_cast, const_cast

http://www.cnblogs.com/chio/archive/2007/07/18/822389.html

http://blog.csdn.net/deyili/article/details/5354242（很重要的）

1. dynamic_cast一般用在父类和子类指针或引用的互相转化;  
2. static_cast一般是普通数据类型(如int m=static_cast<int>(3.14));  
3. reinterpret_cast很像c的一般类型转换操作  
4. const_cast是把cosnt或volatile属性去掉

• void 指针无法直接复制给其他指针

#include<iostream>
void main()
{
    void *p=NULL;
    int *pp=p;
}

//ok
#include<iostream>
void main()
{
    int *pp=NULL;
    void *p=pp;
}

• static_cast<>()的类型检查是什么意思

例子如下：

#include <iostream>
using namespace std;
class A
{
public:
    int m_a;
};
class B: public A
{
public:
    int m_b;
};
class C
{
public:
    int m_c;
};
void f(A &a)
{
    cout<<"f is called"<<endl;
}
void main()
{
    B b;
    C c;
    B *pc;
    f(static_cast<A &>(b));//static_cast的一大作用：子类对象b转化为父类对象，可以通过编译
//    f(static_cast<A &>(c));//进行了类型检查，类A和类C是毫无关系的，检查出错，不能通过编译
//f(static_cast<A *>(pc));//进行了类型检查，类A和类C是毫无关系的，检查出错，不能通过编译
}

static_cast和dynamic_cast的不同

例子如下：三个类的定义同上

void main()
{
    B b;
    C c;
    B & ref_b=reinterpret_cast<B &>(c);
    f(static_cast<A &>(ref_b));//成功欺骗编译器，编译通过，成功运行
    //f(dynamic_cast<A &(ref_b));//编译通过，但是运行时检查了ref_b的实际类型为B，所以运行失败    
}

void main()
{
    B b;
    C c;
    A & ref_b=reinterpret_cast<A &>(c);
    f(ref_b);//成功欺骗编译器，编译通过，成功运行
}

 

• dynamic_cast的作用

在应用多态编程时，当我们无法确定传过来的对象的实际类型时使用dynamic_cast：如我们并不能确定传入的ref_b到底是B类型还是C类型（c通过reinterpret_cast转换为b，编译器并不知情），这时就应该用dynamic_cast。

void main()
{
    B b;
    C c;
    B & ref_b=reinterpret_cast<B &>(c);
    f(static_cast<A &>(ref_b));//成功欺骗编译器，编译通过，成功运行
    //f(dynamic_cast<A &>(ref_b));//编译通过，但是运行时检查了ref_b的实际类型，所以运行失败    
}

如果能保证对象的实际类型，用static_cast就可以了。至于reinterpret_cast，我很喜欢，很象c语言那样的暴力转换：）

• 例子：无关类之间的转换

#include<iostream>
class CBaseX  
{  
public:  
    void foo() { printf("CBaseX::foo() x=%d/n", x); }  
};  
class CBaseY  
{  
public:  
    void bar() { printf("CBaseY::bar()");   
    }  
};  
void main()
{
    CBaseX* pX = new CBaseX();    // 两个无关类：CBaseX* 和 CBaseY*之间的转换 
    // CBaseY* pY1 = static_cast<CBaseY*>(pX);   // 错误， 类型指向是无关的 (解释：指针变量PX是CBaseX类型，现在要将其转换为CBase类型) 
    CBaseY* pY2 = reinterpret_cast<CBaseY*>(pX);       // 成功编译, 但是 pY2 不是CBaseX  
    pY2->bar();//如果你尝试转换一个对象（pX）到另一个无关的类(pY2)static_cast<>将失败，而reinterpret_cast<>总是能成功“欺骗”编译器：认为被转换的那个对象(pX)就是要转换到的无关类（pY）。        
}

• 例子：相关类之间的转换

 

#include<iostream>
class CBaseX  
{  
public:  
    int x;  
    CBaseX() { x = 10; }  
    void foo() { printf("CBaseX::foo() x=%d/n", x); }  
};  
class CBaseY  
{  
public:  
    int y;  
    int* py;  
    CBaseY() { y = 20; py = &y; }  
    void bar() { printf("CBaseY::bar() y=%d, *py=%d/n", y, *py);   
    }  
};  
class CDerived : public CBaseX, public CBaseY  
{  
public:  
    int z;  
};
void main()
{
    CDerived* pD = new CDerived();  
    printf("CDerived* pD = %x\n", (int)pD);  
    // static_cast<> CDerived* -> CBaseY* -> CDerived*  
    //成功编译，隐式static_cast<>转换  
    CBaseY* pY1 = pD;  
    printf("CBaseY* pY1 = %x\n", (int)pY1);  
    // 成功编译, 现在 pD1 = pD  
    CDerived* pD1 = static_cast<CDerived*>(pY1);  
    printf("CDerived* pD1 = %x\n", (int)pD1);  
    // reinterpret_cast  
    // 成功编译, 但是 pY2 不是 CBaseY*  
    CBaseY* pY2 = reinterpret_cast<CBaseY*>(pD);  
    printf("CBaseY* pY2 = %x\n", (int)pY2);  
    // 无关的 static_cast<>  
    CBaseY* pY3 = new CBaseY();  
    printf("CBaseY* pY3 = %x\n", (int)pY3);  
    // 成功编译,尽管 pY3 只是一个 "新 CBaseY()"  
    CDerived* pD3 = static_cast<CDerived*>(pY3);  
    printf("CDerived* pD3 = %x\n", (int)pD3);          
}

如图所示，CDerived的内存布局包括两个对象，CBaseX 和 CBaseY，编译器也知道这一点。因此，当你将CDerived* 转换到 CBaseY*时，它给指针添加4个字节，同时当你将CBaseY*转换到CDerived*时，它给指针减去4。然而，甚至它即便不是一个CDerived你也可以这样做。
当然，这个问题只在如果你做了多继承时发生。在你将CDerived转换 到 CBaseX时static_cast<> 和 reinterpret_cast<>是没有区别的。

 

• 例子3：void*之间的向前和向后转换

  void main()
  {
      CDerived* pD = new CDerived();
      printf("CDerived* pD = %x\n", (int)pD);// 打印的是派生类的地址
      CBaseY* pY = pD; // 成功编译, pY = pD + 4
      printf("CBaseY* pY = %x\n", (int)pY);// 打印的是基类pY的地址
      void* pV1 = pY; //成功编译, pV1 = pY  //打印的是基类pY的地址
      printf("void* pV1 = %x\n", (int)pV1);
      CDerived* pD2 = static_cast<CDerived*>(pV1);// pD2 = pV1=pY, 但是我们预期 pD2 = pY - 4 
      printf("CDerived* pD2 = %x\n", (int)pD2);
      // 系统崩溃
      // pD2->bar();      
  }

  1. 一旦我们已经转换指针为void*，我们就不能轻易将其转换回原类。在上面的例子中，从一个void* 返回CDerived*的唯一方法是将其转换为CBaseY*然后再转换为CDerived*。  
  2. 但是如果我们不能确定它是CBaseY* 还是 CDerived*，这时我们不得不用dynamic_cast<> 或typeid[2]。

• 注释：

  1. 1. dynamic_cast<>，从另一方面来说，可以防止一个泛型CBaseY* 被转换到CDerived*。 
  2. 2. dynamic_cast<>需要类成为多态，即包括“虚”函数，并因此而不能成为void*。