C++中的类型转换

C++是强类型语言，不推荐进行类型转换。在C++看来，类型转换就是因为设计不好。但是，有些情况类型转换也是不可避免的。一下介绍介绍C++的类型转换，以备以后查阅：

C++类型转换涉及到四个函数，他们都是通过模板来实现的，分别是static_cast、 dynamic_cast、 const_cast、 reinterpret_cast。

static_cast  为一般类型转换函数，可以转换内嵌数据类型，指针、引用，具有继承关系的类指针或引用

dynamic_cast 通常在基类和派生类之间转换（指针或引用），转换之前会进行类型检查，而且会进行安全检查，一般只能进行子类到父类的转换，不能将父类转换为子类。

const_cast  用于脱const或加const，转换的值必须是指针

referinter_cast  称为重定向，它能重新定义内存空间，因此几乎是不受限制的进行转换。

以下用一些例子进行说明：

#include <iostream>
using namespace std;

/*
	static_cast 
	一般转换，内嵌数据，指针和引用，具有继承关系的类指针或引用
	dynamic_cast   
	通常在基类和派生类之间转换（指针或引用），转换之前会进行类型检查，而且进行安全检查
	一般可以进行子类转父类，不能父类转子类
	const_cast  针对const转换
	referinter_cast  重定义,不需要有任何关联性
*/

class Animal {};
class Cat :public Animal {};
class Build {};

typedef void(*func1)();
typedef int(*func2)();

int main(void)
{

	int a = 10;
	int* pa = &a;
	int& ra = a;

	Animal ani;
	Animal* pAni;
	Animal& rAni = ani;
	
	Cat cat;
	Cat* pCat;
	Cat& rCat = cat;

	Build bui;
	Build* pBui;
	Build& rBui = bui;

	func2 *f2;
	func1* f1；

	double da = static_cast<double>(a);  //基本类型的强制转换
	double* pda = static_cast<double*>(pa); //错误，不能将指向int类型的指针转换为指向double类型的指针
	Cat tani = static_cast<Cat>(ani);   //错误，转换需要拷贝构造函数
	Cat* tpAni = static_cast<Cat*>(pAni);  //通过指针可以进行转换,父类到子类的转换
	Animal* tc = static_cast<Cat*>(pCat);  //子类到父类的转换
	func1* tf1 = static_cast<func1*>(f2);  //错误，不能进行不相关的转换， reinterpret_cast可以
	func1* tf2 = reinterpret_cast<func1*>(f2); //正确，给一块内存重新定义

	double dda = dynamic_cast<double>(a);  //错误，不能进行基本数据类型的转换
	Animal ttan = dynamic_cast<Animal>(cat);  //错误，只能转换指针和引用
	Animal* ttan2 = dynamic_cast<Animal*>(pCat);  //正确, 子类向父类转换
	Cat* ttcat = dynamic_cast<Cat*>(pAni); //错误， 不能父类向子类转换， 这种转换是不安全的
	//dynamic_cast检查很严格，只能进行子类向父类转换，而且只能通过指针和引用

	const int cint = 10;
	const int* pcint = &cint;
	int* cc = const_cast<int*>(pcint);   //脱const
	const int* pcc = const_cast<const int*>(cc); //加const
	const int& rci = cint;
	int& ri = const_cast<int&>(rci);  //脱const
	const int& trc = const_cast<const int&>(ri); //加const
	//const_cast用于脱const和加const，只能用于指针和引用

	int ta = 10;
	int* p = reinterpret_cast<int*>(ta); //reinterpret_cast属于无下限转换，只要是空间大小相同，不管什么类型都可以相互转换，称为重定向
									     //是对内存块的重新定义。

}