10、新型的类型转换

1、强制类型转换

首先我们提出一个问题：C语言已经有强制类型转换，为什么C++还要创造新型的类型转换呢？

• C方式的强制类型转换
  — （Type）（Expression）
  — Type（Expression）

typedef void(PF)(int);
struct Point
{
	int x;
	int y;
};

int v = 0x12345;
PF* pf = (PF*)v;
char c = (char)v;
Point* p = (Point*)v;

上面这段代码毫无疑问是可以编译通过的，运行之后会发生什么？没人知道，在我看来，这个程序虽然可以编译通过，但是简直就是乱来。所以我们可以回答开头的那个问题：为什么C++还要创造新型的类型转换，因为C语言的强制类型转换太过于粗暴，而且不严谨，不安全，产生的问题根本很难去解决。
程序：

#include <stdio.h>
typedef void(PF)(int);
struct Point
{
	int x;
	int y;
};

int main()
{
	int v = 0x12345;
	PF* pf = (PF*)v;
	char c = (char)v;
	Point* p = (Point*)v;

	pf(1);
	printf("p->x = %d\n", p->x);
	printf("p->y = %d\n", p->y);
	return 0;
}

• C方式强制类型转换存在的问题
  — 过于粗暴
  　　　任意类型之间都可以进行转换，编译器很难判断其正确性
  — 难于定位
  　　　在源码中无法快速定位所有使用强制类型转换的语句。你在源码里面想找错误。应该搜索什么关键字呢？所以说很难定位。
  　　　
  问题：强制类型转换在实际工程中是很难完全避免的！如何进行更加安全可靠的转换？

2、新式类型转换

• C++将强制类型转换分为4中不同的类型，产生4个关键字
  
  用法：xxx_cast< Type >（Expression）

• static_cast 强制类型转换（静态类型转换）
  — 用于 基本类型 之间的转换
  — 不能用于基本类型指针间的转换
  — 用于有继承关系类对象之间的转换和类指针之间的转换

• const_cast 强制类型转换
  — 用于去除变量的只读属性
  — 强制转换的目标类型必须是指针或者引用

• reinterpret_cast 强制类型转换
  — 用于指针类型间的强制转换
  — 用于整数和指针类型间的强制类型转换

• dynamic_cast 强制类型转换
  — 用于有继承关系的类指针间的转换
  — 用于有交叉关系的类指针间的转换
  — 具有类型检查的功能
  — 需要虚函数的支持

#include <stdio.h>
void static_cast_demo()
{ 
	int i = 0x12345;
	char c = 'c';
	int* pi = &i;
	char* pc = &c;

	c = static_cast<char>(i);
	pc = reinterpret_cast<char*>(pi);
}
void const_cast_demo()
{
	const int& j = 1;
	int& k = const_cast<int&>(j);

	const int x = 2;
	int& y = const_cast<int&>(x);

	//int z = const_cast<int>(x);  //error,const_cast<int>的对象只能是指针和引用

	k = 5;
	printf("k = %d\n", k);  //5
	printf("j = %d\n", j);  //5

	y = 8;
	printf("x = %d\n", x);  //2
	printf("y = %d\n", y);  //8
	printf("&x = %p\n", &x);  //栈上的内存地址
	printf("&y = %p\n", &y);  
}
void reinterpret_cast_demo()
{
	int i = 0;
	char c = 'c';
	int* pi = &i;
	char* pc = &c;

	pc = reinterpret_cast<char*>(pi);
	pi = reinterpret_cast<int*>(pc);
	pi = reinterpret_cast<int*>(c);
	c = static_cast<char>(i);	
}
void dynamic_cast_demo()		
{
	int i = 0;
	int* pi = &i;

	//char* pc = dynamic_cast<char*>(pi);				error，虽然dynamic_cast针对的也是指针，但是对象必须要是类指针，而且要有虚函数的支持,这个用reinterpret_cast就可以转换

}
int main()
{
	static_cast_demo();
	const_cast_demo();
	reinterpret_cast_demo();
	dynamic_cast_demo();

	return 0;
}

分析：在写这段代码的时候，我一直对29行和第30行代码有异议，我认为他们两个的内存地址应该是不相同的。产生这种错误想法的原因在于我把y当做了一个新定义的变量，而并有看到他的本质是一个引用，引用就是变量的别名，显然，y和x一样存在栈上。

小结：

• C方式的强制类型转换
  — 过于粗暴
  — 潜在的问题不易被发现
  — 不易在代码中定位
• 新式类型转换以C++关键字的方式出现
  — 编译器能够帮助检查潜在的问题
  — 非常方便的在代码中定位
  — 支持动态类型识别（dynami_cast）