C++类型转换（static_cast、dynamic_cast、reinterpret_cast、const_cast）

dynamic_cast

1.dynamic_cast是在运行时检查的，用于在集成体系中进行安全的向下转换downcast(当然也可以向上转换，但没必要，因为可以用虚函数实现),  即：基类指针/引用 -> 派生类指针/引用(如果源和目标没有继承/被继承关系，编译器会报错！)
2.dynamic_cast是4个转换中唯一的RTTI操作符，提供运行时类型检查。
3.dynamic_cast不是强制转换，而是带有某种”咨询“性质的，如果不能转换，返回NULL。这是强制转换做不到的。

4.源类中必须要有虚函数，保证多态，才能使用dynamic_cast<source>(expression)

static_cast

用法：static_cast < type-id > ( expression )

该运算符把expression转换为type-id类型，在编译时使用类型信息执行转换，在转换执行必要的检测（指针越界，类型检查），其操作数相对是安全的。

但没有运行时类型检查来保证转换的安全性。

reinterpret_cast

仅仅是复制n1的比特位到d_r, 没有进行必要的分析.interpret_cast是为了映射到一个完全不同类型\
的意思，这个关键词在我们需要把类型映射回原有类型时用到它。我们映射到的类型仅仅是为了故弄\
玄虚和其他目的，这是所有映射中最危险的。(这句话是C++编程思想中的原话

const_cast

去除const常量属性

示例代码如下：

#include<iostream>
#include<iomanip>
using namespace std;
 
 
/*
static_cast
基本类型转换；
dynamic_cast
父类指针转子类指针，不成功则为空；
 
*/
void StaticCast()
{
	float fVar = 1.314;
	int nVar = static_cast<int>(fVar);
}
class CBase{
protected:
	int m_nData;
public:
	virtual void Fun(){}
};
class CDerived1 : public CBase{
protected:
	int m_nData1;
};
class CDerived2 : public CBase{
protected:
	long m_nData2;
};
//////////////////////////////////////////////////////////////////////////  
void DynamicCast()
{
	CBase* pBase = new CBase();
	CDerived1* pDerived = new CDerived1();
	char szTrue[] = "true";
	char szFalse[] = "false";
	CBase* pDerived2Base = dynamic_cast<CBase*>(pDerived);
	if(pDerived2Base != NULL)					cout << "dynamic_cast<CBase*>(pDerived1) is ok !" << endl;
	else															cout << "dynamic_cast<CBase*>(pDerived1) is not ok !" << endl;
	CDerived1* pBase2Derived = dynamic_cast<CDerived1*>(pBase);
	if(pBase2Derived != NULL)					cout << "dynamic_cast<CDerived1*>(pBase) is ok !" << endl;
	else															cout << "dynamic_cast<CDerived1*>(pBase) is not ok !" << endl;
	pBase2Derived = dynamic_cast<CDerived1*>(pDerived2Base);
	if(pBase2Derived != NULL)					cout << "dynamic_cast<CDerived1*>(pDerived2Base) is ok !" << endl;
	else															cout << "dynamic_cast<CDerived1*>(pDerived2Base) is not ok !" << endl;
	delete pBase; pBase = NULL;
	delete pDerived; pDerived = NULL;
	pDerived2Base = NULL;
	pBase2Derived = NULL;
 
 
	try{
		CBase oBase;
		CDerived1 oDerived1;
		CBase& rBase = dynamic_cast<CBase&>(oDerived1);
		cout << "子类引用转换成父类引用，成功" << endl;
		CDerived1& rDerived1 = dynamic_cast<CDerived1&>(oBase);
		cout << "父类引用ob，如果真的指向子类对象，那么转换时成功的" << endl;
	}
	catch(bad_cast e){
		cout << "failed to cast" << endl;
	}
}
class ClassInt{
public:
	ClassInt(int i) : a(i){}
	int a;
};
class ClassFloat{
public:
	ClassFloat(float j) : b(j){}
	float b;
};
class ClassLongLong{
public:
	ClassLongLong(long long k) : c(k){}
	long long c;
};
//重新解释
void ReinterpretCast()
{
	ClassInt* pClassInt = new ClassInt(520);
	ClassFloat* pClassFloat = new ClassFloat(13.14);
	ClassLongLong* pClassLongLong = new ClassLongLong(5201314);
	ClassInt* pFloat2Int = reinterpret_cast<ClassInt*>(pClassFloat);
	if(pFloat2Int != NULL)				cout << "pFloat2Int = reinterpret_cast<ClassInt*>(pClassFloat), Int : " << pFloat2Int->a << endl;
	else												cout << "pFloat2Int = NULL" << endl;
 
	ClassInt* pLongLong2Int = reinterpret_cast<ClassInt*>(pClassLongLong);
	if(pLongLong2Int != NULL)				cout << "pLongLong2Int = reinterpret_cast<ClassInt*>(pClassLongLong), Int : " << pLongLong2Int->a << endl;
	else														cout << "pLongLong2Int = NULL" << endl;
	delete pClassInt; pClassInt = NULL;
	delete pClassFloat; pClassFloat = NULL;
	delete pClassLongLong; pClassLongLong = NULL;
}
void main()
{
	cout << "子类与父类之间的相互转换：" << endl;
	DynamicCast();
	ReinterpretCast();
}