C++中的类型转换

目录

1. C语言中的类型转换

2. C++强制类型转换

2.1 static_cast

2.2 reinterpret_cast

2.3 const_cast

2.4 dynamic_cast

---

1. C语言中的类型转换

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

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

（ 多存在于意义相近的类型之间，比如表示数值的int, float, double等之间 ）

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

（ 多存在于意义不相近的类型之间，但值转换后有意义 ）

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);
}

缺陷 ：

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

void Insert(size_t pos, char ch)
{
	size_t _size = 5;
	//....
	int end = _size - 1;
	while (end >= pos) // 比较时end会隐式类型转换为size_t类型，从而结果出现问题
	{
		//_str[end + 1] = _str[end];
		--end;
	}
}

2. C++强制类型转换

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

static_cast 、 reinterpret_cast 、 const_cast 、 dynamic_cast

2.1 static_cast

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

2.2 reinterpret_cast

        reinterpret_cast 操作符通常为操作数的位模式提供较低层次的重新解释，用于 将一种类型转换为另一种不同的类型 。（ 类似C语言显示类型转换 ）

int main()
{
	double d = 12.34;
	int a = static_cast<int>(d);
	cout << a << endl;

	// 这里使用static_cast会报错，应该使用reinterpret_cast
	//int *p = static_cast<int*>(a);
	int* p = reinterpret_cast<int*>(a);

	return 0;
}

2.3 const_cast

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

 但是我们会发现这样一个问题：为何下图a的值和*p的值不一样？

 调用监视窗口查看一下：

 此时更迷惑了，为何打印值和监视窗口值也不一样？

原因：此处编译器进行了优化，将const修饰的值直接放在寄存器里，这样需要的时候直接读就行了（寄存器里不能写会报错），而a的值实际内存中已经被修改，但从寄存器读取的值还是原来的值，而监视窗口查看的就是内存中的值，所以出现了上述情况。

因此，在使用const的值时要格外谨慎！

那么如何解决上述问题？

加关键字volatile：

2.4 dynamic_cast

        dynamic_cast 用于将一个 父类对象的 指针/引用 转换为子类对象的 指针或引用 ( 动态转换)（向下转型）（ 父类对象无论如何都是不允许转换成子类对象的 ）

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

向下转型 ：父类对象指针 / 引用 -> 子类指针 / 引用 ( 用dynamic_cast转型是 安全的 )

注意：

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

2. dynamic_cast 会先检查是否能转换成功，能成功则转换，不能则返回 0。(所以说安全)

class A
{
public:
	virtual void f(){}
public:
	int _a = 0;
};

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

// A*指针pa有可能指向父类，有可能指向子类
void fun(A* pa)
{
	// 如果pa是指向子类，那么可以转换，转换表达式返回正确的地址
	// 如果pa是指向父类，那么不能转换，转换表达式返回nullptr
	B* pb = dynamic_cast<B*>(pa); // 安全的
	//B* pb = (B*)pa;             // 不安全
	if (pb)
	{
		cout << "转换成功" << endl;
		pb->_a++;
		pb->_b++;
		cout << pb->_a << ":" << pb->_b << endl;
	}
	else
	{
		cout << "转换失败" << endl;
		pa->_a++;
		cout << pa->_a << endl;
	}
}
int main()
{
	A a;
	B b;
	fun(&a);
	fun(&b);
	return 0;
}