概览：C++类型转换：static_cast，dynamic_cast，const_cast，reinterpret_cast。

---

C语言的类型转换

int a = 65;
char b = (char)a;

static_cast转换

• 语法：type a = static_cast<type>(b);
• 将其他类型的b转换成type类型的a。
• static_cast用于基本数据类型以及有继承关系的子类与父类的指针或者引用之间的类型转换。

class Person {};
class Animal {
public:
	void speak() {
		cout << "Animal speak" << endl;
	}
};
class Cat :public Animal {
public:
	void speak() {
		cout << "Cat speak" << endl;
	}
};

void test1() {

	//static_cast
	//static_cast用于 基本数据类型 
	//以及 有继承关系的子类与父类的 指针 或者 引用 之间的类型转换。

	//type a = static_cast<type>(b);

	//1.基本数据类型
	int a = 65;
	char b = static_cast<char>(a);
	cout << b << endl;	//A

	//2.基础类型指针
	int *ip = new int(3);
	//float *fp = static_cast<float>(ip); //错误：类型转换无效

	//3.自定义数据类型的转换
	Person *person = new Person();
	//Animal *animal = static_cast<Animal *>(person); //错误：类型转换无效

	//4.具有继承关系的 指针转换
	Animal *animal = new Animal();
	Cat* cat = static_cast<Cat *>(animal);	//可以转换
	cat->speak();		//Cat speak

	//5.具有继承关系的 引用转换
	Animal row;
	Animal & ani = row;
	Cat & meow = static_cast<Cat &>(ani);
	meow.speak();		//Cat speak

}

dynamic_cast转换

• 语法：type a = dynamic_cast<type>(b);

• 将其他类型的b转换成type类型的a。

• dynamic_cast只能用于子类类型转化为父类类型。

子类指针转父类指针，是由大到小，是类型安全的。

而父类指针转子类指针，由小到大，是类型不安全的。

class Person {};
class Animal {
public:
	void speak() {
		cout << "Animal speak" << endl;
	}
};
class Cat :public Animal {
public:
	void speak() {
		cout << "Cat speak" << endl;
	}
};

void test2() {

	//dynamic_cast
	//只能用于子类对象转父类对象

	//1.基本数据类型
	//char a = 'A';
	//int b = dynamic_cast<int>(a);
	//错误 dynamic_cast中的类型必须是指向完整类类型或者void *类型的指针或者引用

	//2.基本数据类型的指针
	//int *a = new int(3);
	//char * b = dynamic_cast<char *>(a);
	//错误  dynamic_cast中的类型必须是指向完整类类型或者void *类型的指针或者引用

	//3.非继承关系的对象指针
	//Animal *animal = new Animal();
	//Person*person = dynamic_cast<Person *>(animal);
	//错误 运行时dynamic_cast的操作数必须包含多态类类型

	//4.继承关系 父类指针转子类指针
	//Animal *animal = new Animal();
	//Cat * cat = dynamic_cast<Cat*>(animal);
	//错误 运行时dynamic_cast的操作数必须包含多态类类型

	//5.继承关系 子类指针转父类指针
	Cat* cat = new Cat();
	Animal * animal = dynamic_cast<Animal*>(cat);
	animal->speak();	//Animal speak

	//6.继承关系 子类引用转父类引用
	Cat meow;
	Cat & ca = meow;
	Animal & ani = dynamic_cast<Animal &>(ca);
	ani.speak();//Animal speak

}

const_cast转换

• 语法：type a = dynamic_cast<type * / &>(b);
• 模板参数列表那里要填写指针或者引用。

const_cast用于针对基本数据类型的指针、引用以及自定义类型对象的指针进行const权限的增加或者去除（去除是不改变员数据，会将结果给到一个新的值）。

void test3() {

	//const_cast
	//const_cast用于针对基本数据类型的指针、引用
	//以及自定义类型对象的指针进行const权限的增加或者去除（去除是不改变员数据，会将结果给到一个新的值）。

	//1.基本数据类型
	//int a = 10;
	//int b = const_cast<int>(a);
	//错误，const_cast中的类型必须是指针，引用或者指向对象类型成员的指针

	//2.基本数据类型的引用
	int a = 10;
	const int &b = a;
	//b = 20;//错误

	//去除const权限
	int &c = const_cast<int &>(b);
	c = 20;

	//增加const权限
	const int &d = const_cast<const int &>(a);
	//d = 20;//错误

	cout << "a = " << a << endl;//20
	cout << "b = " << b << endl;//20
	cout << "c = " << c << endl;//20
	cout << "d = " << d << endl;//20

	//3.基本数据类型的指针

	a = 10;
	int *p = &a;

	//增加const权限
	const int * cp = const_cast<const int *>(p);

	cout << "*cp = " << *cp << endl;	//10

	const int * cp2 = &a;

	//去除const权限
	int *p2 = const_cast<int *>(cp2);

	*p2 = 100;

	cout << "a = " << a << endl;		//100
	cout << "*p = " << *p << endl;		//100
	cout << "*cp = " << *cp << endl;	//100
	cout << "*cp2 = " << *cp2 << endl;	//100
	cout << "*p2 = " << *p2 << endl;	//100

}

reinterpret_cast 强制类型转换

reinterpret_cast是强制类型转换，任何类型指针都可以转化为其他类型指针。

void test4() {

	//reinterpret_cast 强制转换

	//两个不相关的类转换
	Person *person = new Person();
	Cat* cat = reinterpret_cast<Cat *>(person);
	cat->speak();	//Cat speak
					//能运行出结果

	//函数指针转换
	typedef void(*FUNC1)(int, int);
	typedef int(*FUNC2)(int, char*);

	FUNC1 func1 = nullptr;
	FUNC2 func2 = reinterpret_cast<FUNC2>(func1);
}

总结

程序员必须清楚的知道要转变的变量，转换前的类型与转换后的类型，会有什么后果。

一般情况下，不建议类型转换，应当尽量避免类型转换。