C++风格的类型转换提供了4种类型转换操作符来应对不同场合的应用。
const_cast，字面上理解就是去const属性。
static_cast，命名上理解是静态类型转换。如int转换成char。
dynamic_cast，命名上理解是动态类型转换。如子类和父类之间的多态类型转换。
reinterpreter_cast，仅仅重新解释类型，但没有进行二进制的转换。
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;
const_cast: const_cast操作不能在不同的种类间转换。相反，它仅仅把一个它作用的表达式转换成常量。
它可以使一个本来不是const类型的数据转换成const类型的，或者把const属性去掉。
static_cast
类似于C风格的强制转换。无条件转换，静态类型转换。用于：
1. 基类和子类之间转换：其中子类指针转换成父类指针是安全的;但父类指针转换成子类指针是不安全的。(基类和子类之间的动态类型转换建议用dynamic_cast)
2. 基本数据类型转换。enum, struct, int, char, float等。static_cast不能进行无关类型(如非基类和子类)指针之间的转换。--------------{如果涉及到类的话，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类型
class A {}; class B:public A {}; class C {}; int main() { A* a=new A; B* b; C* c; b=static_cast<B>(a); // 编译不会报错, B类继承A类 c=static_cast<B>(a); // 编译报错, C类与A类没有任何关系 return 1; }
dynamic_cast
有条件转换，动态类型转换，运行时类型安全检查(转换失败返回NULL)：
1. 安全的基类和子类之间转换。
2. 必须要有虚函数。
Base中需要检测有虚函数的原因：类中存在虚函数，就说明它有想要让基类 指针或引用 指向派生类对象的情况，此时转换才有意义。
这是由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表（关于虚函数表的概念，详细可见<Inside c++ object model>）中，
只有定义了虚函数的类才有虚函数表。
3. 相同基类不同子类之间的交叉转换。但结果是NULL。
（1）其他三种都是编译时完成的，dynamic_cast是运行时处理的，运行时要进行类型检查。
（2）不能用于内置的基本数据类型的强制转换。
（3）dynamic_cast转换如果成功的话返回的是指向类的指针或引用，转换失败的话则会返回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_castDerivedClass *>(pb);
//子类->父类，静态类型转换，正确但不推荐
DerivedClass *pd2 = dynamic_castDerivedClass *>(pb);
//子类->父类，动态类型转换，正确
BaseClass* pb2 = new BaseClass();
DerivedClass *pd21 = static_castDerivedClass *>(pb2);
//父类->子类，静态类型转换，危险！访问子类m_szName成员越界
DerivedClass *pd22 = dynamic_castDerivedClass *>(pb2);
//父类->子类，动态类型转换，安全的。结果是NULL
（5）在类的转换时，在类层次间进行上行转换时，dynamic_cast和static_cast的 效果是一样的。在进行下行转换时，dynamic_cast具有类型检查的功能，比 static_cast更安全。向上转换即为指向子类对象的向下转换，即将父类指针转化子类指针。向下转换的成功与否还与将要转换的类型有关，即要转换的 指针指向的对象的实际类型与转换以后的对象类型一定要相同，否则转换失败。
#include<iostream> #include<cstring> //c++中，调用string.h的风格 using namespace std; class A { public: virtual void f() { cout<<"hello"<<endl; }; }; class B:public A { public: void f() { cout<<"hello2"<<endl; }; }; class C { void pp() { return; } }; int fun() { return 1; } int main() { A* a1=new B;//a1是A类型的指针指向一个B类型的对象 A* a2=new A;//a2是A类型的指针指向一个A类型的对象 B* b; C* c; b=dynamic_cast<B*>(a1);//结果为not null，向下转换成功，a1之前指向的就是B类型的对象，所以可以转换成B类型的指针。 if(b==NULL) { cout<<"null"<<endl; } else { cout<<"not null"<<endl; } b=dynamic_cast<B*>(a2);//结果为null，向下转换失败 if(b==NULL) { cout<<"null"<<endl; } else { cout<<"not null"<<endl; } c=dynamic_cast<C*>(a);//结果为null，向下转换失败 if(c==NULL) { cout<<"null"<<endl; } else { cout<<"not null"<<endl; } delete(a); return 0; }
reinterpreter_cast（保存数据到中间态，像md5）
仅仅重新解释类型，但没有进行二进制的转换：
1. 转换的类型必须是一个指针、引用、算术类型、函数指针或者成员指针。
2. 在比特位级别上进行转换。它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针(先把一个指针转换成一个整数，在把该整数转换成原类型的指针，还可以得到原先的指针值)。但不能将非32bit的实例转成指针。
3. 最普通的用途就是在函数指针类型之间进行转换。
4. 很难保证移植性。
reinterpret_cast: 有着和C风格的强制转换同样的能力。它可以转化任何内置的数据类型为其他任何的数据类型，也可以转化任何指针类型为其他的类型。它甚至可以转化内置的数据类型为指针，无须考虑类型安全或者常量的情形。
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);
//不同函数指针类型之间进行转换
总 结
去const属性用const_cast。
基本类型转换用static_cast。
多态类之间的类型转换用daynamic_cast。
不同类型的指针类型转换用reinterpreter_cast。
参考文章：http://www.cnblogs.com/alexqdh/archive/2011/06/09/2075713.html