1. C语言中的类型转换

隐式类型转换：编译器在编译阶段自动进行，能转就转，不能转就编译失败（相近类型：（整形和浮点）、（指针和指针））
显式类型转化：非相近类型强制类型转换

void Test ()
{
     int i = 1;
     // 隐式类型转换
     double d = i;
     printf("%d, %.2f\n" , i, d);
     int* p = &i;
     // 显示的强制类型转换
     int address = (int) p;
     printf("%x, %d\n" , p, address);
}

c语言隐式类型转换会发生的一些问题

下面代码i和j比较会把i隐式类型转换为unsigned int，和j比较不会小于0死循环

int main()
{
    int i = 5; size_t j = 0;
    while (i >= j)
    {
        i--;
        if (i == -10)
            break;
        cout << i << " ";
    }
    return 0;
}

所以C++提出了中类型转换来规范

2.1.类型转换：static_cast

static_cast对应的是C语言中的隐式类型转换，支持相近类型的转换，非相近类型编译不通过；

void Test1()
{
    int i = 1;
    // sattic_cast
    double d = static_cast<double>(i);
    printf("%d, %.2f\n", i, d);
}
int main()
{
    Test1();
    return 0;
}

2.2.类型转换：reinterpret_cast

reinterpret_cast对应的是C语言中的显示类型转换，支持非相近类型的转换

void Test1()
{
    int i = 1;
    // reinterpret_cast
    int* p = &i;
    int address = reinterpret_cast<int>(p);
    printf("%x, %d\n", p, address);
}
int main()
{
    Test1();
    return 0;
}

2.3.类型转换：const_cast

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

int main()
{
	const int a = 5;
	int* p = const_cast<int*>(&a);
	*p = 10;
	cout << a << endl;
	cout << *p << endl;

	return 0;
}

上面代码执行结果

原因：编译器都被const修饰的变量有优化；不会取内存中取，会直接使用常量5;

关键字volatile：不让编译器优化，去内存中取值

常量区禁止写入，编译好的指令在常量区

volatile const int a = 0;//常量区不能写入,编译好的指令在常量区
int main()
{
	int* p = const_cast<int*>(&a);
	*p = 10;
	cout << a << endl;
	cout << *p << endl;

	return 0;
}

2.4.类型转换：dynamic_cast

向上转型：子类对象指针/引用->父类指针/引用(不需要转换，赋值兼容规则)(切片行为)
向下转型：父类对象指针/引用->子类指针/引用(用dynamic_cast转型是安全的)

要求：

dynamic_cast只能用于父类含有虚函数的类（必须是多态，因为虚函数表内存了一个判断它是子类还是父类）
dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回nullptr

需求：如果pa是指向父类对象，那么不做任何处理，如果pa是指向子类对象，那么请转回子类，并打印子类对象地址

class A
{
	virtual void f() {}
public:
};

class B : public A
{
public:
};
void func(A* pa)//切片
{
	// dynamic_cast--如果pa指向的父类对象，那么则转换不成功，返回nullptr
	// dynamic_cast--如果pa指向的子类对象，那么则转换成功，返回对象指针
	B* pb1 = dynamic_cast<B*>(pa);
	if (pb1 == nullptr)
	{
		cout << "转换失败" << endl;
	}
	else
	{
		cout << "pb1:" << pb1 << endl;
	}
}

int main()
{
	A aa;
	B bb;
	func(&aa);
	func(&bb);
}