C++四种类型强制转换——const_cast、static_cast、dynamic_cast、reinterpret_cast

---

一、const_cast

1.基本知识

(1)const_cast只针对指针、引用，当然，this指针也是其中之一。
(2)const_cast的大部分使用主要是将常量指针转换为常指针。常量指针指向的空间的内容不允许被修改，但是使用const_cast进行强制转换就可以修改。
(3)const_cast只能调节类型限定符，不能修改基本类型。在普通指针演示中给出示例。

2.示例演示

（1）普通指针
用代码演示：

int main()
{
	const int* p = new int(1);
	//int* d = p;//错误原因：const int*类型不能赋值或者初始化int*类型的实体
	*const_cast<int*>(p) = 50;
	cout << *p << endl;//50

	int* d = const_cast<int*>(p);
	*d = 100;
	cout << *p << endl;//100

	//char* dd = const_cast<char*>(p)//错误原因：const_cast只能调节类型限定符，不能更改基础类型

	return 0;
}

（2）引用

int main()
{
	int a = 10;
	const int& b = a;
	//b = 20;//错误原因：常量引用，不允许修改值
	//int& c = b;//错误，和常量指针不允许给普通指针赋值或者初始化一样

	int& c = const_cast<int&>(b);
	c = 20;
	cout << a << endl;//20

	const_cast<int&>(b) = 30;
	cout << a << endl;//30
	return 0;
}

（3）this指针

class Test 
{
public:
	Test() {}
	void fun()const//此时this指针相当于const Test* const this
	{
		//this->val1 = 10;//错误
		const_cast<Test*>(this)->val1 = 10;//OK
	}
private:
	int val1;
	int val2;
};

二、static_cast

1.基本知识

（1）static_cast的使用基本等价于隐式转换的一种类型转化运算符，可使用于需要明确隐式转换的地方。就相当于把隐式转换给明确写了出来而已。
（2）可以用于低风险的转换
什么叫低风险的转化，一般只要编译器能自己进行隐式转换的都是低风险转换，一般平等转换和提升转换都是低风险的转换。比如以下几种情况：
①整形和浮点型
②字符与整形
③转换运算符
④空指针转换为任何目标类型的指针
（3）不可以用于风险较高的转换
①不同类型的指针之间互相转换
②非指针类型和指针类型之间的相互转换
③不同类型的引用之间的转换

2.示例演示

class Base 
{
public:
	Base() {}
	~Base() {}
};
class Son:public Base
{
public:
	Son() {}
	~Son() {}
};

int main()
{
	char c_a = 0;
	int i_a = 0;
	float f_a = 0;
	double d_a = 1.111111;
	void* v_ptr = NULL;
	int* i_ptr = new int(1);
	char* c_ptr = new char(1);

	//下面部分没有报错，可以运行，但是平时不允许这样写，除非自己很明确自己在干什么
	//从高字节数到低字节数的转换平常肯定是不允许这样用的，因为将一个多字节的内容转换到少字节，非常容易丢失数据
	char c_sc = static_cast<char>(i_a);
	c_sc = static_cast<char>(f_a);
	c_sc = static_cast<char>(d_a);

	//类似于下面的转换不允许，因为两个不同的指针类型之间不允许相互转换
	//int* i_scptr = static_cast<int*>(c_ptr);//报错

	//下面的指针类型转换允许
	int* i_scptr = static_cast<int*>(v_ptr);
	void* v_scptr = static_cast<void*>(i_ptr);


	//下面的可取，只不过有时候精度可能会降低而已，比如float转换为int，被视为低风险
	float f_sc = static_cast<float>(i_a);
	int i_sc = static_cast<int>(c_a);
	cout << i_sc << endl;


	//父类指针和派生类指针的指向问题
	Base* bptr1 = new Base();
	Son* sptr1 = new Son();
	Base* bptr;
	Son* sptr;
	bptr = new Son();    //语句1   正确，基类指针指向派生类实体
	//sptr = new Base();//语句2   错误，派生类指针指向父类
	bptr = static_cast<Base*>(sptr1);//等同于语句1，正确
	sptr = static_cast<Son*>(bptr1); //等同于语句2，但是不安全，平时使用也不会使派生类指针指向基类,会出现访问越界，有时候会崩溃，有时候我们却没办法发现
	//对于派生类指针指向基类，会用另一个强制转换dynamic_cast
	
	return 0;
}

三、dynamic_cast

1.基本知识

（1）用于具有虚函数的基类与派生类之间的指针或引用的转换。
（2）基类必须具有虚函数。dynamic_cast是运行时类型信息（RTTI），而这个信息是存储与类的虚函数表关系紧密的信息，只有一个类定义了虚函数，才会有虚函数表。
运行时检查，转型不成功则返回一个空指针
非必要不使用dynamic_cast，因为有额外的开销。
（3）常用的转换方式
基类指针或引用转派生类指针（必须使用dynamic_cast）
派生类指针或引用转基类指针（可以使用dynamic_cast,但是更推荐用static_cast）

2.示例演示

在这里只演示必须使用dynamic_cast的情况。（注意，基类必须有虚函数）

class Base 
{
public:
	Base() { b_val = 1; }
	~Base() {}
	virtual void fun() {}
	int b_val;
};

class Son :public Base
{
public:
	Son() { s_val = 2; }
	~Son() {}
	int s_val;
};

int main()
{
	Base* b_ptr = new Base();
	Son* s_ptr = dynamic_cast<Son*>(b_ptr);

	return 0;
}

调试可以发现，s_ptr为NULL，转换不成功。因为代码运行时，dynamic_static转换时进行了运行时安全检查，检查了被转换的指针的类型，和转换成的指针的类型，发现不安全，就会转换失败，返回空指针。

四、reinterpret_cast

这个和C语言的强制转换没什么区别，只不过C++用自己的写法替代了C语言的强制转换而已。
①不同类型的指针之间的转换
②指针和能容纳指针的整数类型之间的转换（比如将int类型强转成int*类型）
③不同类型的引用之间的转换
编译期处理执行的是逐字节复制的操作。
类似于强制转换，至于强制转换会产生什么后果需要自己承担。
由于和C语言的强制转换一样，这里不进行赘述。