static_cast、dynamic_cast、const_cast、reinterpret_cast

static_cast <new_type> (expression) 静态转换

静态转换是最接近于C风格转换，很多时候都需要程序员自身去判断转换是否安全。比如：

double d=3.14159265;

int i = static_cast<int>(d);

但static_cast已经有安全性的考虑了，比如对于不相关类指针之间的转换。参见下面的例子：

class base
{
public:
	base()	{cout<<"construct base"<<endl;}
	~base()	{cout<<"destroy base"<<endl;}
};

class derived:public base
{
public:
	derived()	{cout<<"construct derived"<<endl;}
	~derived()	{cout<<"destroy derived"<<endl;}
};

class noderiver
{
public:
	int a;
	int b;
};

int main()
{
	base *b = new base;
	derived* d;
	noderiver* n;
	n = (noderiver*) b;				//不会报错，可以通过，c风格的转换，缺乏安全性
	n = static_cast<noderiver*> (b);	//error，检验出不相关指针不能相互转换
	d = static_cast<derived*> (b);	//可以转换，安全性有所提升
}

dynamic_cast <new_type> (expression) 动态转换

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

#include <iostream>
using namespace std;
class CBase { };
class CDerived: public CBase { };

int main()
{
CBase b; CBase* pb;
CDerived d; CDerived* pd;

pb = dynamic_cast<CBase*>(&d);     // ok: derived-to-base
pd = dynamic_cast<CDerived*>(&b);  // wrong: base-to-derived 
}

把类的定义改成：

class CBase { virtual void dummy() {} };

class CDerived: public CBase {};

再编译，则成功，但是cderived指向的是空指针

dynamic_cast提升安全性的功能，dynamic_cast可以识别出不安全的下行转换，但并不抛出异常，而是将转换的结果设置成null（空指针）

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

 

这个转换是最“不安全”的，两个没有任何关系的类指针之间转换都可以用这个转换实现，举个例子：

class A {};

class B {};

A * a = new A;

B * b = reinterpret_cast<B*>(a);//correct!

更厉害的是，reinterpret_cast可以把整型数转换成地址（指针），这种转换在系统底层的操作，有极强的平台依赖性，移植性不好。

它同样要求new_type是指针或引用，下面的例子是通不过编译的：

double a=2000.3;

short b;

b = reinterpret_cast<short> (a); //compile error!

 

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

这个转换好理解，可以将常量转成非常量。

原文可以参考如下链接：

http://www.cnblogs.com/jerry19880126/archive/2012/08/14/2638192.html