C++类型转换个人总结(初稿)

面试被问了一个dynamic_cast,没答上来，之前这方面看的还是太少，基础掌握的不够牢，于是下午回来赶紧恶补一下！

// Type_Cast.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include <iostream>
using namespace std;
/*******************************************************************
** C++类型转换示例
** const_cast:去const/valitale属性的转换
** static_cast:静态类型转换，只负责在类型上的无条件转换
** dynamic_cast:动态转换，运行时进行类型安全检查（转换失败返回NULL）
** reinterpret_cast:仅仅是重新解释类型并没有进行实际的类型转换
源自：http://www.cnblogs.com/goodhacker/archive/2011/07/20/2111996.html
*******************************************************************/

int doSomething(){return 0;};
int _tmain(int argc, _TCHAR* argv[])
{
	//const_cast example
	struct constExample {
		int i;
		constExample(int i):i(i){};
	};
	const constExample ra(5);
	//ra.i = 10; //直接修改const类型，编译错误
	constExample &rb = const_cast<constExample&>(ra);
	rb.i =10;
	cout<<ra.i<<endl;

	//static_cast example
	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类型

	//dynamic_cast example
	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

	//reinterpret_cast example
	typedef void(*FuncPtr)(); //FuncPtr is 一个指向函数的指针，该函数没有参数，返回值类型为 void
	FuncPtr funcPtrArray[10]; //10个FuncPtrs指针的数组 让我们假设你希望（因为某些莫名其妙的原因）把一个指向下面函数的指针存入funcPtrArray数组： 
    //funcPtrArray[0] =&doSomething;// 编译错误！类型不匹配，reinterpret_cast可以让编译器以你的方法去看待它们：funcPtrArray
	funcPtrArray[0] = reinterpret_cast<FuncPtr>(&doSomething); //不同函数指针类型之间进行转换

	return 0;
}

const_cast：主要是负责去掉变量的const或者validate属性，不负责进行变量之间的具体类型转换；

static_cast：与传统C类型转换相似，主要负责类型之间的转换。但是需要注意一下几点：

类似于C风格的强制转换。无条件转换，静态类型转换。用于：
1. 基类和子类之间转换：其中子类指针转换成父类指针是安全的；但父类指针转换成子类指针是不安全的。(基类和子类之间的动态类型转换建议用dynamic_cast)
2. 基本数据类型转换。enum,  int, char, float等。static_cast不能进行无关类型（如非基类和子类）指针之间的转换。
3. 把空指针转换成目标类型的空指针。
4. 把任何类型的表达式转换成void类型。
5. static_cast不能去掉类型的const、volitale属性(用const_cast)。

【摘自<More Effective C++>】static_cast 在功能上基本上与C风格的类型转换一样强大，含义也一样。它也有功能上限制。例如，你不能用static_cast象用C风格的类型转换一样把struct转换成int类型或者把double类型转换成指针类型，另外，static_cast不能从表达式中去除const属性，因为另一个新的类型转换操作符const_cast有这样的功能。

dynamic_cast:这里要重点说一下：

作为四个内部类型转换操作符之一的dynamic_cast和传统的C风格的强制类型转换有着巨大的差别。除了dynamic_cast以外的转换，其行为的都是在编译期就得以确定的，转换是否成功，并不依赖被转换的对象。而dynamic_cast则不然。在这里，不再讨论其他三种转换和C风格的转换。
首先，dynamic_cast依赖于RTTI信息，其次，在转换时，dynamic_cast会检查转换的source对象是否真的可以转换成target类型，这种检查不是语法上的，而是真实情况的检查。
先看RTTI相关部分，通常，许多编译器都是通过vtable找到对象的RTTI信息的，这也就意味着，如果基类没有虚方法，也就无法判断一个基类指针变量所指对象的真实类型, 这时候，dynamic_cast只能用来做安全的转换,例如从派生类指针转换成基类指针.而这种转换其实并不需要dynamic_cast参与.
也就是说,dynamic_cast是根据RTTI记载的信息来判断类型转换是否合法的.

下面看一个例子:
struct B1{
    virtual ~B1(){}
};
struct B2{
    virtual ~B2(){}
};
struct D1 : B1, B2{};
int main()
{
    D1 d;
    B1* pb1 = &d;
    B2* pb2 = dynamic_cast<B2*>(pb1);//L1
    B2* pb22 = static_cast<B2*>(pb1);  //L2
    return 0;
}
上述定义中可以看到,B1和B2是不相关的类,从L1可以看到,dynamic_cast允许这种转换:只要B1存在多态方法.
L2将编译失败,static_cast并不允许两个完全不相干的类互相转换.

dynamic_cast的这种特性，在提取一个对象的某个接口的时候，非常有用，它很类似于实现了COM的QueryInterface的功能。

dynamic_cast 主要用于执行“安全的向下转型（safe downcasting）”，也就是说，要确定一个对象是否是一个继承体系中的一个特定类型。
－－－这个描述是不完整的，dynamic_cast 固然可以实现完全的向下转型，也可以实现更为强大的QueryInterface的功能。

一下摘自《More Effective C++》

　第二种特殊的类型转换符是dynamic_cast，它被用于安全地沿着类的继承关系向下进行类型转换。这就是说，你能用dynamic_cast把指向基类的指针或引用转换成指向其派生类或其兄弟类的指针或引用，而且你能知道转换是否成功。失败的转换将返回空指针（当对指针进行类型转换时）或者抛出异常（当对引用进行类型转换时）：

Widget *pw; ... update(dynamic_cast(pw)); // 正确，传递给update函数一个指针 // 是指向变量类型为SpecialWidget的pw的指针 // 如果pw确实指向一个对象, // 否则传递过去的将使空指针。 void updateViaRef(SpecialWidget& rsw); updateViaRef(dynamic_cast(*pw)); //正确。 传递给updateViaRef函数 // SpecialWidget pw 指针，如果pw // 确实指向了某个对象 // 否则将抛出异常

　　dynamic_casts在帮助你浏览继承层次上是有限制的。它不能被用于缺乏虚函数的类型上，也不能用它来转换掉constness:

int firstNumber, secondNumber; ... ... double result = dynamic_cast(firstNumber)/secondNumber; // 错误！没有继承关系 const SpecialWidget sw; ... update(dynamic_cast(&sw)); // 错误! dynamic_cast不能转换 // 掉const。

　　如你想在没有继承关系的类型中进行转换，你可能想到static_cast。如果是为了去除const，你总得用const_cast。

　这四个类型转换符中的最后一个是reinterpret_cast。这个操作符被用于的类型转换的转换结果几乎都是实现时定义（implementation-defined）。因此，使用reinterpret_casts的代码很难移植。

参考文章：

http://www.cnblogs.com/goodhacker/archive/2011/07/20/2111996.html

http://blog.csdn.net/wingfiring/article/details/633033