c++强制类型转换(static_cast,const_cast,dynamic_cast,reinterpret_cast)

static_cast <typeid>(exdlvssion)

static_cast 很像 C 语言中的旧式类型转换。它能进行基础类型之间的转换，也能将带有可被单参调用的构造函数或用户自定义类型转换操作符的类型转换，还能在存有继承关系的类之间进行转换（即可将基类转换为子类，也可将子类转换为基类），还能将 non-const对象转换为 const对象（注意：反之则不行，那是const_cast的职责。）。

double d = 3.14159265;

 int i = static_cast<int>(d);

 

 class A {};

 class B

 {

     public:

      B (A a) {};

 };

 A a;

 B b = static_cast<B>(a);

 

 class CBase {};

 class CDerived: public CBase {};

 CBase * a = new CBase;

 CDerived * b = static_cast<CDerived *>(a);

注意：static_cast 转换时并不进行运行时安全检查，所以是非安全的，很容易出问题。因此 C++ 引入 dynamic_cast 来处理安全转型。

dynamic_cast<typeid>(exdlvssion)

dynamic_cast 主要用来在继承体系中的安全向下转型。它能安全地将指向基类的指针转型为指向子类的指针或引用，并获知转型动作成功是否。如果转型失败会返回null（转型对象为指针时）或抛出异常（转型对象为引用时）。dynamic_cast 会动用运行时信息（RTTI）来进行类型安全检查，因此 dynamic_cast 存在一定的效率损失。（我曾见过属于优化代码80/20法则中的20那一部分的一段游戏代码，起初使用的是 dynamic_cast，后来被换成 static_cast 以提升效率，当然这仅是权宜之策，并非好的设计。）

class CBase { };

 class CDerived: public CBase { };

 CBase b;

 CBase* pb;

 CDerived d;

 CDerived* pd;

 pb = dynamic_cast<CBase*>(&d);     // ok: derived-to-base

 pd = dynamic_cast<CDerived*>(&b);  // error: base-to-derived

上面的代码中最后一行会报如下错误 ,这是因为 dynamic_cast 只有在基类带有虚函数的情况下才允许将基类转换为子类。

class CBase

 {

    virtual void dummy() {}

 };

 class CDerived: public CBase

 {

     int a;

 };

 

 int main ()

 {

    CBase * pba = new CDerived;

    CBase * pbb = new CBase;

    CDerived * pd1, * pd2;

    pd1 = dynamic_cast<CDerived*>(pba);

    pd2 = dynamic_cast<CDerived*>(pbb);

   return 0;

 }

 

结果是：上面代码中的 pd1 不为 null,而 pd2 为 null。

class BaseClass { 

public: 

　　int m_iNum; 

　　virtual void foo(){}; //基类必须有虚函数。保持多台特性才能使用dynamic_cast 

}; 



class DerivedClass: public BaseClass { 

public: 

　　char *m_szName[100];

　　void bar(){};

};



BaseClass* pb = new DerivedClass();

DerivedClass *pd1 = static_cast<DerivedClass *>(pb); //子类->父类，静态类型转换，正确但不推荐

DerivedClass *pd2 = dynamic_cast<DerivedClass *>(pb); //子类->父类，动态类型转换，正确





BaseClass* pb2 = new BaseClass();

DerivedClass *pd21 = static_cast<DerivedClass *>(pb2); //父类->子类，静态类型转换，危险！访问子类m_szName成员越界

DerivedClass *pd22 = dynamic_cast<DerivedClass *>(pb2); //父类->子类，动态类型转换，安全的。结果是NULL

 

dynamic_cast 也可在 null 指针和指向其他类型的指针之间进行转换，也可以将指向类型的指针转换为 void 指针（基于此，我们可以获取一个对象的内存起始地址 const void * rawAddress = dynamic_cast<const void *> (this);）。

 

const_cast<typeid>(exdivission)

前面提到 const_cast 可去除对象的常量性（const），它还可以去除对象的易变性（volatile）。const_cast 的唯一职责就在于此，若将 const_cast 用于其他转型将会报错。

 void print (char * str)

 {

   cout << str << endl;

 }

 int main ()

 {

   const char * c = " http://www.cppblog.com/kesalin/";

   print ( const_cast<char *> (c) );

   return 0;

 }

 

 

reinterpret_cast<typeid>(exdivssion>

reinterpret_cast 用来执行低级转型，如将执行一个 int 的指针强转为 int。其转换结果与编译平台息息相关，不具有可移植性，因此在一般的代码中不常见到它。reinterpret_cast 常用的一个用途是转换函数指针类型，即可以将一种类型的函数指针转换为另一种类型的函数指针，但这种转换可能会导致不正确的结果。总之，reinterpret_cast 只用于底层代码，一般我们都用不到它，如果你的代码中使用到这种转型，务必明白自己在干什么。

int doSomething(){ return 0; }



typedef void(*FuncPtr)();//FuncPtr is 一个指向函数的指针，该函数没有参数，返回值类型为 void



FuncPtr funcPtrArray[10];//10个FuncPtrs指针的数组 让我们假设你希望（因为某些莫名其妙的原因）把一个指向下面函数的指针存入funcPtrArray数组：



funcPtrArray[0] = &doSomething; // 编译错误！类型不匹配，reinterpret_cast可以让编译器以你的方法去看待它们：funcPtrArray



funcPtrArray[0] = reinterpret_cast<FuncPtr>(&doSomething); //不同函数指针类型之间进行转换