36.C++类型转换

C语言中的类型转换：

隐式类型转化：由编译器在编译阶段自动进行，能转就转，不能转就编译失败

显式类型转化：需要用户自己处理

// 隐式类型转换
int i = 1;
double d = i;

// 显示的强制类型转换
int* p = &i;
int address = (int) p;

c语言的类型转换存在精度丢失和类型混用强转的情况，因此C ++，引入了四种命名的强制类型转换操作符：

static_cast、reinterpret_cast、const_cast、dynamic_cast    

static_cast用于非多态类型的转换（静态转换），编译器隐式执行的任何类型转换都可用static_cast，但它不能用于两个不相关的类型进行转换

//非多态类型（大多数是指内置类型）的转换

double a = 9.9;
int b = static_cast<int>(a);  //a必须用括号括起来

//不能用于两个不相关的类型进行转换

int *p = static_cast<int*>(&a);  //编译错误

reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释，用于将一种类型转换为另一种不同的类型

int a = 0;
const char* str = "string";
a = reinterpret_cast<int>(str);

reinterpret_cast是低层次的重新解释，自定义类型地址向上转型（多态）不安全。 强制类型转换和static_cast对自定义类型向上转型是正确的

class A{
private:
	int a = 0;
};
class B{
private:
	int b = 0;
};

class C : public A, public B{
};

int main(){
	C c;
	printf("%p, %p, %p\n", &c, reinterpret_cast<B*>(&c), static_cast<B*>(&c));
	printf("%p\n", (B*)&c);  
	/**/
	return 0;
}

const_cast最常用的用途就是删除变量的const属性，方便赋值

const int a = 10;
//int* p = (int*)&a;  //显式类型转换
int* pa = const_cast<int*>(&a);  //const_cast删除常性
*pa = 100;
cout << a << endl;  //10
cout << *pa << endl;  //100
//a的值并没有被修改，*pa才是修改的值


volatile int b = 99;
int* pb = const_cast<int*>(&b);
*pb = 100;
cout << b << endl;  //100
cout << *pb << endl;  //100

volatile关键字可以用来提醒编译器它后面所定义的变量随时有可能改变，因此编译后的程序每次需要存储或读取这个变量的时候，都会直接从变量地址中读取数据。如果没有volatile关键字，则编译器可能优化读取和存储，可能暂时使用寄存器中的值，如果这个变量由别的程序更新了的话，将出现不一致的现象。

dynamic_cast用于将一个父类对象的指针/引用转换为子类对象的指针或引用(动态转换)

向上转型：子类对象指针/引用->父类指针/引用(不需要转换，赋值兼容规则)

向下转型：父类对象指针/引用-

子类指针/引用(用dynamic_cast转型是安全的)

1. dynamic_cast只能用于含有虚函数的类

2. dynamic_cast会先检查是否能转换成功，能成功则转
   换，不能则返回0

class A
{
public:
	virtual void f() {}
};
class B : public A
{};
void fun(A* pa)
{
	// dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回
	B* pb1 = static_cast<B*>(pa);
	B* pb2 = dynamic_cast<B*>(pa);
	cout << "pb1:" << pb1 << endl;
	cout << "pb2:" << pb2 << endl;
}
int main()
{
	A a;
	B b;
	fun(&a);
	fun(&b);
	return 0;
}