C++转换类型

1.static_cast<目标类型>(源类型)静态转换类型

*1.static_cast静态转换类型可用于父类和子类之间的强制类型转换。

2.需要注意的是，当父类转换为子类的时候是不安全的转换类型编译会报错，当子类转换为父类的时候是安全的转换类型，能正常编译通过。

3.也可以用于内置数据类型之间的转换，在内置数据类型转换时不管安全不安全都能转换成功。
4.两个不相干的类的转换是不允许的。

5.另外发生多态时转换总是安全的。*
代码如下：

#include
#include 
#include 
using namespace std;
#pragma warning(disable:4996)

class A
{

};
class B :public A	
{

};
class C
{

};
int main() {


	//父类转为子类是不安全的
	A a;
	//B b= static_cast(a); //报错，因为父类转换为子类是不安全的
	B b;
	//子类转换为父类是安全的可以转换
	A a1 = static_cast<A>(b); 

	//内置数据类的转换
	double d;
	char str;
	//内置数据类型之间的转换，char到double不会造成数据丢失，转换成功
	d = static_cast<double>(str);
	//double到char的转换，会造成数据丢失不安全，但是编译能通过
	str = static_cast<char>(d);
	
	//当发送多态时总是安全的
	A* a2 = new B;
	//这时父类转换为子类就是安全的，可以编译通过
	B* b2 = static_cast<B*>(a2);
	//两个类之间的转换时不允许的
	//C c = static_cast a;     //编译失败
	system("pause");
	return 0;
}

2.dynamic_cast<目标类型>(源类型)动态类型转换

*1.动态类型转换是安全的转换，可用于父类和子类之间的转换（只能是子类转为父亲）

2.不能用于内置数据类型的转换

3.不允许发生不安全的类型转换

4.源类型和目标类型必须是指针或者引用，否则报错

5.发生多态时的转换总是安全的
代码例子如下：*

#include
#include 
#include 
using namespace std;
#pragma warning(disable:4996)

class A
{

};
class B :public A	
{

};
class C
{

};
int main() {


	//父类转换为子类不安，不允许发生转换，报错
	//A a;
	//B b = dynamic_cast(a);  //报错必须是指针或者引用

	A* a;
	//B* b = dynamic_cast(a);  //不允许发生不安全的类型转换
	B* b;
	a = dynamic_cast<A*>(b);        //是安全的类型转换，编译通过

	//不允许内置数据类型的转换
	//double d;
	//int i;
	//d = dynamic_cast(i);  //失败必须是指针或者引用

	//double* d;
	//int* i;

	//d = dynamic_cast(i);   //报错不允许内置数据类型之间的转换
	system("pause");

	
	return 0;
}

3.const_cast<目标类型>(源类型)常量类型转换

1.可以修改const的指针属性

2.常量指针被转化成非常量指针，并且仍然指向原来的对象

3.常量引用被转换成非常量引用，并且仍然指向原来的对象；

4.只能发生在指针或者引用类型之间的转换

#include
#include 
#include 
using namespace std;
#pragma warning(disable:4996)

class A
{

};
class B :public A	
{

};
class C
{

};
int main() {

	//指针常量：int* const p;表示指针指向的地址不可以修改，而指针指向的值可以修改
	
	int a = 10;
	int b = 20;
	int* const p = &a;
	//p = &b;       报错因为p是一个指针常量，指向的地址不可以修改，但是值可以修改
	*p = 100;       //正确因为值可以修改

	//常量指针：cosnt int* p;表示指针指向的地址可以修改，而指针指向的值不可以修改
	const int* p1 = &a;
	p1 = &b;              //正确常量指针的指向可以修改，但是指向的值不可以修改
	//*p1 = 100;             //报错值不可以修改 



	//动态类型转换将常量指针转换为非常量指针

	const int* num1;
	int* num2 = const_cast<int*>(num1);

	//常量引用与非常量引用之间的转换
	int num = 10;
	int& remnum = num;
	const int& num3 = const_cast<const int&>(remnum);
	
	//不允许非指针或引用之间的转换
	const int c = 10;
	//int d = const_cast(c); //报错
	system("pause");

	
	return 0;
}

4.reinterpret_cast<目标类型>(源类型)重新解释转换

该种转换模式时最不安全的，打破了前三种的转换方式，可以进行任意数据类型之间的转换，基本不使用该种转换类型进行转换。