C++四种强转

C++风格的类型转换提供了4种类型转换操作符来应对不同场合的应用。

　　const_cast，字面上理解就是去const属性。

　　static_cast，命名上理解是静态类型转换。如int转换成char。

　　dynamic_cast，命名上理解是动态类型转换。如子类和父类之间的多态类型转换。

　　reinterpreter_cast，仅仅重新解释类型，但没有进行二进制的转换。

语法：

　　reinterpret_cast<new_type>(expression)
　　dynamic_cast<new_type>(expression)
　　static_cast<new_type>(expression)
　　const_cast<new_type>(expression)

　　4种类型转换的格式，如：

　　TYPE B = static_cast(TYPE)(a)

const_cast

　　去掉类型的const或volatile属性。

　　struct SA {

　　int i;

　　};

　　const SA ra;

　　//ra.i = 10; //直接修改const类型，编译错误

　　SA &rb = const_cast<SA&>(ra);

　　rb.i = 10;

static_cast

　　类似于C风格的强制转换。无条件转换，静态类型转换。用于：

　　1. 基类和子类之间转换：其中子类指针转换成父类指针是安全的;但父类指针转换成子类指针是不安全的。(基类和子类之间的动态类型转换建议用dynamic_cast)

　　2. 基本数据类型转换。enum, struct, int, char, float等。static_cast不能进行无关类型(如非基类和子类)指针之间的转换。

　　3. 把空指针转换成目标类型的空指针。

　　4. 把任何类型的表达式转换成void类型。

　　5. static_cast不能去掉类型的const、volitale属性(用const_cast)。

　　int n = 6;

　　double d = static_cast<double>(n); // 基本类型转换

　　int *pn = &n;

　　double *d = static_cast<double *>(&n) //无关类型指针转换，编译错误

　　void *p = static_cast<void *>(pn); //任意类型转换成void类型

　　　'static_cast'允许执行任意的隐式转换和相反转换动作。（即使它是不允许隐式的）
　　   应用到类的指针上，意思是说它允许子类类型的指针转换为父类类型的指针（这是一个有效的隐式转换），同时，也能够执行相反动作：转换父类为它的子类。
　　　在这最后例子里，被转换的父类没有被检查是否与目的类型相一致。
　　　　代码：
　　　　class Base {};
　　　　class Derived : public Base {};

　　　　Base *a    = new Base;
　　　　Derived *b = static_cast<Derived *>(a);
　　　　'static_cast'除了操作类型指针，也能用于执行类型定义的显式的转换，以及基础类型之间的标准转换:
　　　　代码:
　　　　double d = 3.14159265;
　　　　int    i = static_cast<int>(d);

dynamic_cast

　　有条件转换，动态类型转换，运行时类型安全检查(转换失败返回NULL)：

　　1. 安全的基类和子类之间转换。

　　2. 必须要有虚函数。

　　3. 相同基类不同子类之间的交叉转换。但结果是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_castDerivedClass *>(pb2);

　　//父类->子类，动态类型转换，安全的。结果是NULL

　　　　　　'dynamic_cast'只用于对象的指针和引用。当用于多态类型时，它允许任意的隐式类型转换以及相反过程。不过，与static_cast不同，在后一种情况里（注：即隐式转换的相反过程），dynamic_cast会检查操作是否有效。也就是说，它会检查转换是否会返回一个被请求的有效的完整对象。检测在运行时进行。如果被转换的指针不是一个被请求的有效完整的对象指针，返回值为NULL.

　　代码：
　　class Base { virtual dummy() {} };
　　　　class Derived : public Base {};
　　　　Base* b1 = new Derived;
　　　　Base* b2 = new Base;
　　　　Derived* d1 = dynamic_cast<Derived *>(b1);          // succeeds
　　　　Derived* d2 = dynamic_cast<Derived *>(b2);          // fails: returns 'NULL'
　　　　如果一个引用类型执行了类型转换并且这个转换是不可能的，一个bad_cast的异常类型被抛出：
　　　　代码:
　　　　class Base { virtual dummy() {} };
　　　　class Derived : public Base { };
　　　　Base* b1 = new Derived;
　　　　Base* b2 = new Base;
   　　　Derived d1 = dynamic_cast<Derived &*>(b1);          // succeeds
　　　　Derived d2 = dynamic_cast<Derived &*>(b2);          // fails: exception thrown
reinterpreter_cast 

　　仅仅重新解释类型，但没有进行二进制的转换：

　　1. 转换的类型必须是一个指针、引用、算术类型、函数指针或者成员指针。

　　2. 在比特位级别上进行转换。它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针(先把一个指针转换成一个整数，在把该整数转换成原类型的指针，还可以得到原先的指针值)。但不能将非32bit的实例转成指针。

　　3. 最普通的用途就是在函数指针类型之间进行转换。

　　4. 很难保证移植性。

　　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_castFuncPtr>(&doSomething);

　　//不同函数指针类型之间进行转换

　　'reinterpret_cast'转换一个指针为其它类型的指针。它也允许从一个指针转换为整数类型。反之亦然。
　　这个操作符能够在非相关的类型之间转换。操作结果只是简单的从一个指针到别的指针的值的二进制拷贝。在类型之间指向的内容不做任何类型的检查和转换。
　　如果情况是从一个指针到整型的拷贝，内容的解释是系统相关的，所以任何的实现都不是方便的。一个转换到足够大的整型能够包含它的指针是能够转换回有效的指针的。
　　　　代码:
　　　　class A {};
　　　　class B {};
　　　　A * a = new A;
　　　　B * b = reinterpret_cast<B *>(a);
　　　　'reinterpret_cast'就像传统的类型转换一样对待所有指针的类型转换。

总 结

　　去const属性用const_cast。

　　基本类型转换用static_cast。

　　多态类之间的类型转换用daynamic_cast。

　　不同类型的指针类型转换用reinterpreter_cast。

　　每一种适用于特定的目的： 
　　·dynamic_cast 主要用于执行“安全的向下转型（safe downcasting）”，也就是说，要确定一个对象是否是一个继承体系中的一个特定类型。它是唯一不能用旧风格语法执行的强制转型，也是唯一可能有重大运行时代价的强制转型。
    ·static_cast 可以被用于强制隐型转换（例如，non-const 对象转型为 const 对象，int 转型为 double，等等），它还可以用于很多这样的转换的反向转换（例如，void* 指针转型为有类型指针，基类指针转型为派生类指针），但是它不能将一个 const 对象转型为 non-const 对象（只有 const_cast 能做到），它最接近于C-style的转换。
　 ·const_cast 一般用于强制消除对象的常量性。它是唯一能做到这一点的 C++ 风格的强制转型。 
　 ·reinterpret_cast 是特意用于底层的强制转型，导致实现依赖（implementation-dependent）（就是说，不可移植）的结果，例如，将一个指针转型为一个整数。这样的强制转型在底层代码以外应该极为罕见。