C++ 四种类型转换static_cast、 dynamic_cast、reinpreter_cast和const_cast

1、static_cast

一般的内置类型转换或者具有继承关系的对象之间的转换，对有继承关系对象引用也能进行转换，注意：

1、static_cast不能转换掉expression的const、volitale、或者__unaligned属性

2、基础数据类型指针不能转换

3、无继承关系对象不能转换指针

 代码示例：

class building {};
class annimal {};
class cat :public annimal {};
void test01() {
	//基础类型变量转换
	int num = 97;
	char a = static_cast<char>(num);
	cout << a << endl;

	//基础数据类型指针不能转换
	/*char *p = nullptr;
	p = static_cast<char*>(num);*/

	//无继承关系对象不能转换指针
	//building *p1 = nullptr;
	//annimal *p2 = static_cast<annimal*>(p1);

	//有继承关系对象能转换指针
	annimal *canim=nullptr;
	cat* p3 = static_cast<cat*>(canim);//父类指针能转换成子类
	annimal *p4 = p3;//子类能默认可以转换为父类指针
	annimal *p5 = static_cast<annimal*>(p3);//子类能转换为父类指针

	//有继承关系对象引用转换
	annimal pobj;
	cat pobj1;
	annimal &pobjref = pobj;
	cat &pcatref = static_cast<cat&>(pobjref);
	annimal &paniref = pobj1;
}

2、dynamic_cast

该运算符转换具有继承关系的指针和引用，在转换前会进行类型检查。dynamic_cast具有类型检查的功能，比static_cast更安全。注意：

1、对基础数据和无继承关系的类之间不能用

2、准换类型必须为指针类型或引用类型

3、对于有虚函数的可以把父类转化为子类

由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表有定义了虚函数的类才有虚函数表，没有定义虚函数的类是没有虚函数表的。

class flower {
	virtual void sum() {};
};
class rose :public flower {
	void sum() override {
		cout << " " << endl;
	} 
};
void test02() {
	//无虚函数
	annimal *panim = new annimal;;
	cat *pcat=new cat;
	//有虚函数
	flower *pflower = new flower;
	rose*  prose = new rose;

	//子类转父类
	annimal *p1 = dynamic_cast<annimal*>(pcat);
	flower *p2 = dynamic_cast<flower*>(prose);

	//父类转子类
	//cat *p3= dynamic_cast<cat*>(panim);//编译器报错
	rose *p4 = dynamic_cast<rose*>(pflower);//这是由于运行时类型检查需要运行时类型信息，
	                                        //而这个信息存储在类的虚函数表 
}

 应用示例，当在一个基类（有虚函数）链表中存放许多不同的子类指针，想把当前的基类指针转换为子类指针，可以通过dynamic_cast转换后是否为空进行判断：

class A {
	virtual void sum() {};
};
class B :public A {
	virtual void sum()override {
		cout << "B" << endl;
	};
};
class C :public A {
	virtual void sum()override {
		cout << "C" << endl;
	};
};


//应用示例
B *b=new B;
A *a = static_cast<A*>(b);//先将子类转换为父类
C *p1 = dynamic_cast<C*>(a);
B *p2 = dynamic_cast<B*>(a);
//转换后为p1=nullptr,p2=b;

3、const_cast

该运算符用来修改类型的const或volatile属性，去const和加const（不用const_cast）属性，常量指针被转化成非常量指针，并且仍然指向原来的对象；常量引用被转换成非常量引用，并且仍然指向原来的对象；常量对象被转换成非常量对象。使用一个新的变量去除原来变量的const性，原变量cosnt性不变。

void test03() {

	//去引用const
	int a = 10;
	const int &b = a; //加const
	const int &c = const_cast<const int &>(a);//加const,一般使用上面的用法。
	//b = 20;报错
	int &d = const_cast<int&>(b);//去const
	d = 20;

	//去指针const
	const int *p1 = nullptr;
	int *p2 = const_cast<int *>(p1);//去const
}

4、reinpreter_cast

必须是一个指针、引用、算术类型、函数指针或者成员指针，强制类型指针转换，无关的指针类型都可以进行转换。

class building {};
class annimal {};

typedef void(*fun1)(int, int);
typedef int(*fun2)(int, char*);

void test04() {

	//强制类型转换
	building *p1 = nullptr;
	annimal*p2 = reinterpret_cast<annimal*>(p1);

	//函数指针转换
	fun1 p3=nullptr;
	fun2 p4 = reinterpret_cast<fun2>(p3);
}