C++中4个与类型转换相关的关键词分析

C++中4个与类型转换相关的关键词分别是：
（ 与通用的类型转换机制相比，它们能够提供更安全、更明确的类型转换）

• static_cast

• reinterpret_cast

• dynamic_cast

• const_cast

1.dynamic_cast：处理基类到派生类的转换
RTTI是运行阶段类型识别（Runtime Type Identification）的简称。这个特性让程序能够检测对象的类型。RTTI只适用于包含虚函数的类，即为多态时。

dynamic_cast运算符不能回答“指针指向的时哪类对象”这样的问题，但是能回答“能否安全地将对象的地址赋给特定的类型指针”这样的问题。

语法形式：

dynamic_cast<type_name>(expression)
//例如：
	Derived*pd=dynamic_cast<Derived*>pb;

如果指针pb能够安全的转换成Derived*，运算符将返回对象的地址，否者返回一个空指针。

用途：使得能够在类层次中 进行向上转换（由于是is-a关系，这样的转换是安全的），而不允许其他转换。（dynamic_cast也可以用于用于引用，但是不同点在于没有与空指针对应的引用值，因此无法使用特殊的引用值来表示失败，当请求不正确时将引发类型为bad_cast的异常，这种异常从exception类派生而来）

#include<iostream>
using namespace std;

class Base
{
public:
	virtual void test() { cout << "Base" << endl; } //虚函数
	void func_b(){}
};

class Derived :public Base
{
public:
	virtual void test() { cout << "Derived" << endl; }
	void func_d(){}
};
void main()
{
	Base*pB = new Base;
	Derived*pD = new Derived;
	//通用的显式类型转换
	Base*pB2 = (Base*)pD;//派生类对象的地址赋给基类指针，安全
	Derived*pD2 = (Derived*)pB;//基类对象的地址赋给派生类指针，不安全

	pB2->test();//Derived,ok
	pD2->test();//Base,ok

	//dynamic_cast用于指针转换
	Derived*pD3 = dynamic_cast<Derived*>(pB);
	if (pD3 == nullptr)
		cout << "NULLPTR" << endl;
	else
		pD3->test();
		
	//dynamic_cast用于指针转换
	//Derived& rd1=dynamic_cast<Derived&>(*p1);//p1没有真正指向派生类，rd1抛出异常bad_cast
	Derived& rd2=dynamic_cast<Derived&>(*pD );//正确
	
	//用于基类指针调用派生类特有的成员函数
	{
		Derived md;
		Base*pb=&md;
		Derived*pd;
		//pb->func_d();//基类的指针并不能直接调用派生了中独有的函数func_d
		dynamic_cast<Derived*> (pb)->func_d();//通过类型转换可以
	}
}

2.const_cast：用来移除变量的const或volatile限定符
语法形式：

const_cast<type_name>(expression)

注：type_name和expression的类型必须相同。（或者两者可以隐式的进行转换，不能是两个无关的类型。）

用途：用来移除变量的const或volatile限定符。
有时候需要一个这样的值，它在大多数时候是常量，而有时候又是可以修改的。这时候可以声明成const，并在需要修改的时候，使用const_cast。

使用通用转换：

	Derived dd;
	const Derived*ptr1 = ⅆ
	Derived* ptr2 = (Derived*)ptr1;//ok
	Base* ptr3 = (Base*)ptr1;//ok

使用const_cast转换：

	Derived dd;
	const Derived*ptr1 = ⅆ
	Derived*ptr2 = const_cast<Derived*>(ptr1);//ok
	ptr2->test();//Derived
	Base*ptr3 = const_cast<Derived*>(ptr1);//ok
	ptr3->test();//Derived
	//Base*ptr4 = const_cast<Base*>(ptr1);//error，类型不一样

const_cast并不是万能的。它可以修改指向一个指针的值，但是修改const值的结果是不确定的。

void change(const int*p, int n)
{
	int*pc;
	pc = const_cast<int*>(p);
	*pc += n;
}

void main()
{
	int pp1 = 123;
	const int pp2 = 456;

	change(&pp1, 1);
	change(&pp2, 2);
	cout << pp1 << endl;//124
	cout << pp2 << endl;//456
}

在change()函数中，指针pc删除了cosnt特征，因此可以用来修改指向的值，但仅当指向的值不是const时才行。因此pc可用于修改pp1,但不能用于修改pp2。

volatile的作用是： 作为指令关键字，确保本条指令不会因编译器的优化而省略，且要求每次直接读值.
简单地说就是防止编译器对代码进行优化.比如如下代码：
a=1;
a=2;
a=3;
a=4;
对外部硬件而言，上述四条语句分别表示不同的操作，会产生四种不同的动作，但是编译器却会对上述四条语句进行优化，认为只有a=4（即忽略前三条语句，只产生一条机器代码）。如果键入volatile，则编译器会逐一的进行编译并产生相应的机器代码（产生四条代码）.

3.static_cast：完成相关类型之间的转换
语法形式：

static_cast<type_name>(expression)

注：type_name和expression两者可以隐式地进行转换，不能是两个无关的类型。

用途：如在同一类层次结构中的一个指针类型到另一个指针类型，整型到枚举类型，或者浮点型到整型等。

Base Base1;
Derived Derive;
Derived*ppptr1 = static_cast<Derived*>(&Base1);//ok
Base*ppptr2 = static_cast<Base*>(&Derived1);//ok

int m=10;
double n=static_cast < int > m;//ok
int * q=static_cast < int* >(malloc(100));//ok

以上代码的第二种转换是从基类指针到派生类指针，在不进行显示转换的情况下，将无法进行，使用static_cast转换是合法的。第一种转换是合法的，因为向上转换可以显式地进行。

2.reinterpret_cast:处理互不相关类型之间的转换
语法形式：

reinterpret_cast<type_name>(expression)

用途：用于天生危险的转换，如从整型到指针，一种类型的指针到另一种类型的指针等

int a=10;
double* b=reinterpret_cast<double*>(a); //b的转换结果为0x0000000a

reinterpret_cast并不支持所有的类型转换，比如可以将指针类型转换成足以存储指针表示的整形，但是不能将指针转换成更小的整形或浮点型；不能将函数指针转换成数据指针，反之亦然。