【C++】C++的类型转换

1.C语言中的类型转换

在C语言中，如果赋值运算符左右两侧类型不同，或者形参与实参类型不匹配，或者返回值类型与接收返回值类型不一致时，就需要发生类型转化，C语言中总共有两种形式的类型转换：隐式类型转换和显式类型转换。

1. 隐式类型转化：编译器在编译阶段自动进行，能转就转，不能转就编译失败
2. 显式类型转化：需要用户自己处理

int main()
{
	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);
}

那些支持隐式类型转换呢？
有一定关联，意义相近的类型就可以隐式类型转换。如int、double、short、char这些整型家族可以隐式类型转换。本质上它们都是表示数据大小只是说它们是一个字节、两个字节、有符号、无符号的问题等等。但是对于一些类型关联性不强甚至说完全不相关，就不能隐式类型转换，只能显示的强制类型转换。

就如这里int* 与 int，一个是地址，一个是整型。不能支持隐式类型转换就会报错，只能显示强制的类型转换。

缺陷：
转换的可视性比较差，所有的转换形式都是以一种相同形式书写，难以跟踪错误的转换

2.为什么C++需要四种类型转换

C风格的转换格式很简单，但是有不少缺点的：

1. 隐式类型转化有些情况下可能会出问题：比如数据精度丢失
2. 显式类型转换将所有情况混合在一起，代码不够清晰

因此C++提出了自己的类型转化风格，注意因为C++要兼容C语言，所以C++中还可以使用C语言的转化风格。

3.C++强制类型转换

标准C++为了加强类型转换的可视性，引入了四种命名的强制类型转换操作符：
static_cast、reinterpret_cast、const_cast、dynamic_cast

3.1static_cast

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

int main()
{
	int i = 1;
	//可以认为static_cast<int>是一个类型，(d)是一个对象
	double d = static_cast<int>(i);
	printf("%d, %.2f\n", i, d);
}

总结：static_cast适用于相似类型进行转换(这些类型的表示意义差不多）

这下面就不能用static_cast，它们两个没有严格的相似类型。

它们的转换用的是下面的reinterpret_cast

3.2reinterpret_cast

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

int main()
{
	int i = 1;
	double d = static_cast<int>(i);
	printf("%d, %.2f\n", i, d);
	int* p = &i;

	//这里使用static_cast会报错，应该使用reinterpret_cast
	//int address = static_cast<int>(p);
	int address = reinterpret_cast<int>(p);
	
	printf("%x, %d\n", p, address);
}

总结：reinterpret_cast适用于不相干的类型之间的转换

3.3 const_cast

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

int main()
{
	//a不能修改
	const int a = 2;
	//强制转换称int*，间接去修改
	int* p = const_cast<int*>(&a);
	*p = 3;
	cout << a << endl;
}

const变量并不是存在常量区，常量区的一定不能修改。实际上const变量还是存在栈上叫做常变量。常变量直接方式不能修改这种间接方式还是能修改的。

这里两行会怎么打印？

int main()
{
	const int a = 2;
	int* p = const_cast<int*>(&a);
	*p = 3;

	cout << a << endl;
	cout << *p << endl;
}

为什么a还是2？不是修改了吗？

调试往下走看一看，发现a不就是被改了吗。

这里的原因在于编译器会对const类型的变量进行优化，它认为默认情况下const类型的变量不会被修改，因此直接就把a变量放到寄存器中然后从寄存器中取，但是这里取到a的地址然后取修改，修改的地方是内存。内存被修改成3了，寄存器还是2。监视窗口还是从内存中取。

为了防止这个优化，我们可以使用C++关键字volatile(保持内存可见性)

总结：const_cast去掉const属性。单独分出来，警示你这个很危险，用的时候谨慎一点

以上三种类型转换方式可以认为是C就有的，为什么C++还要有呢？
C++只想期望用以上的方式来规范大家的行为。但是我们不用这些方式也是可以的。

int main()
{
	volatile const int a = 2;
	int* p = (int*)(&a);
	*p = 3;

	cout << a << endl;
	cout << *p << endl;
}

3.4dynamic_cast

dynamic_cast是C++单独的，C没有的

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

这里就涉及向上转换，向下转换：

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

那向下转换不用dynamic_cast就是不安全的了？我们写段代码看一下。

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

class B : public A
{};

void Func(A* ptr)
{
	B* bptr = (B*)ptr;
	cout << bptr << endl;
}

int main()
{
	A aa;
	B bb;
	Func(&aa);
	Func(&bb);
	return 0;
}

我们首先可以看到强制类型转换确实可以转换。但是这里确实是不安全的。

我们随便加点成员。

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

	int _a = 0;
};

class B : public A
{
	int _b = 0;
};

void Func(A* ptr)
{
	//直接转换是不安全的
	B* bptr = (B*)ptr;
	cout << bptr << endl;
	
	bptr->_a++;
	bptr->_b++;

	cout << bptr->_a << endl;
	cout << bptr->_b << endl;
}

int main()
{
	A aa;
	B bb;
	Func(&aa);
	Func(&bb);
	return 0;
}

父类指针既可能指向父类对象也可能指向子类对象。如果本身是指向父类对象但是把我转换成指向子类对象，可能导致越界问题！
因此它是不安全的。

所以说向下转换可能是不安全的。

1.ptr如果是指向子类对象，那么转回子类类型是没问题的
2.ptr如果是指向父类对象，那么转回子类类型是存在越界风险的

那用dynamic_cast就不会有问题了吗？
是的没错！

void Func(A* ptr)
{
	
	B* bptr = dynamic_cast<B*>(ptr);
	cout << bptr << endl;

	bptr->_a++;
	bptr->_b++;

	cout << bptr->_a << endl;
	cout << bptr->_b << endl;
}


int main()
{
	A aa;
	B bb;
	Func(&aa);
	Func(&bb);
	return 0;
}

如果ptr是指向父类，那就会转换失败，转换失败就会返回空！

因此这里的代码可以这样写，转换成功在修改。

void Func(A* ptr)
{
	//C++规范的dynamic_cast是安全的
	//如果ptr是指向父类，则转换失败，返回空
	//如果ptr是指向子类，则转换成功
	B* bptr = dynamic_cast<B*>(ptr);
	cout << bptr << endl;

	if (bptr)
	{
		bptr->_a++;
		bptr->_b++;

		cout << bptr->_a << endl;
		cout << bptr->_b << endl;
	}
}

所以说dynamic_cast，也可以用来区分父类指针到底指向的是父类对象还是子类对象

注意：

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

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

注意：

强制类型转换关闭或挂起了正常的类型检查，每次使用强制类型转换前，程序员应该仔细考虑是否还有其他不同的方法达到同一目的，如果非强制类型转换不可，则应限制强制转换值的作用域，以减少发生错误的机会。强烈建议：避免使用强制类型转换。

4. RTTI（了解）

RTTI：Run-time Type identification的简称，即：运行时类型识别。
C++通过以下方式来支持RTTI：

1. typeid运算符
2. dynamic_cast运算符
3. decltype

5. 常见问题

1. C++中的4中类型转化分别是：_________ 、_________ 、_________ 、_________
2. 说说4中类型转化的应用场景。