C++类型转换

本文重点：

1.C语言中的强制类型转换；

2.C++强制类型转换；

3.为什么要进行强制类型转换；

4.RTTI；

一.C语言中的强制类型转换：

在C语言中类型转换分为两种：一种为隐式类型转换，一种为显示类型转换；

1.隐式类型转换：

我们写代码的时候，在类型转换的时候，通常在前面加上类型的名字，如果不加的话，不同的类型进行运算，编译器自己去判断如何进行转换，这种方式就是隐式类型转换。

• 由编译器自己完成，无需用户的任何外部触发器。
• 通常在表达式中存在多个数据类型时发生。在这种情况下，类型转换（类型提升）发生以避免数据丢失；
• 变量的所有数据类型都升级为具有最大数据类型的变量的数据类型。
  bool - > char - > short int - > int - > unsigned int - > long - > unsigned - > long long - > float - > double - > long double
• 隐式转换可能会丢失信息，符号可能会丢失，并且可能发生溢出（当long long被隐式转换为float时）。

举个栗子：

#include<stdio.h> 
int main() 
{ 
    int x = 10;    
    char y = 'a';  
    // 'a' is 97 
    x = x + y; 
     
    float z = x + 1.0; 
  
    printf("x = %d, z = %f", x, z); 
    return 0; 
} 

输出结果为：
x = 107, z = 108.000000

2.显示类型转换：

此过程也称为类型转换，它是用户定义的。在这里，用户可以键入强制转换结果以使其具有特定的数据类型；

C语言中的语法：（类型）表达；

举个栗子：

#include<stdio.h> 
  
int main() 
{ 
    double x = 1.2; 
    int sum = (int)x + 1; 
  
    printf("sum = %d", sum); 
  
    return 0; 
} 

输出结果为：sum=2；

此外还有关于指针类型的转换；

3.C语言转换的缺陷：

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

二.C++强制类型转换：

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

1.static_cast操作符：

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

#include <iostream>
using namespace std;

int main() {   
	int a = 10;
	char b = 5;
	a = static_cast<int>(b); //隐式类型转换
	cout << a << endl;
	return 0；
}

2.reinterprint_cast操作符：

reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释，用于将一种类型转换为另一种不同的类型；（也就是我们说的重新解释，即强制类型转换）

#include <iostream>
using namespace std;

int main() {   
	int a = 10;
	char b = 5;
	a = static_cast<int>(b);//隐式类型转换
	cout << a << endl;

	//强制类型转换
	int* p = reinterpret_cast<int*>(a);
	cout << p << endl;
	return 0;
	

3.const_cast操作符：

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

#include <iostream>
#include <stdlib.h>
using namespace std;

int main() {
	const int a = 10;

	int& b = const_cast<int&>(a);

	b = 20;

	cout << a << endl;
	cout << b << endl;
	system("pause");
	return 0;
}

输出结果为：

注意：const常量在使用的时候值是存放在寄存器中，每次使用的时候从寄存器中拿出，并不会从内存中取值。当修改为20的时候都是内存中的值已经被修改了。使用关键字volatile。可以保证每次都是从内存中取值。

volatile const int a = 10;
	
volatile int& b = const_cast<int&>(a);

修改这两行代码，得到如下的结果：

4.dynamic操作符：

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

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

注意：

1. dynamic_cast只能用于含有虚函数的类；
2. dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回0；

#include <iostream>
using namespace std;
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);   
	system("pause");
	return 0; 
}

输出结果为：

5.explicit操作符：

explicit关键字阻止经过转换构造函数进行的隐式转换的发生；

#include <iostream>
#include <stdlib.h>
using namespace std;
class A{
public:
	explicit A(int a){
		cout << "A(int a)" << endl;
	}
	A(const A&a){
		cout << "A(const A& a)" << endl;
	}
private:
	int _a;

};


int main() {
	A a1(1);
	A a2 = 1; //此时此就不可行了,会直接报错；
	system("pause");
	return 0; 
}

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

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

1. 隐式类型转化有些情况下可能会出问题；

int main() {
	int a = 10;
	size_t b = 0;
	while (a >= b){
		cout << a << endl;
		a--;
	}

	system("pause");
	return 0; 
}

这种情况下会造成代码的死循环；

2. 显式类型转换将所有情况混合在一起，代码不够清晰；

四.RTTI：

RTTI：运行时类型识别；

C++通过以下方式来支持RTTI：

• typeid运算符；
• dynamic_cast运算符；