C++：语言级别提供的四种类型转换

一、const_cast

const_cast：修改类型的const或volatile属性。 使用该运算方法可以返回一个指向非常量的指针（或引用）指向，就可以通过该指针（或引用）对它的数据成员任意改变。

注意：
1.不考虑const或valatile后类型保持一致才可以进行合理的类型转换。
2.const_cast<里面必须是指针或引用类型>

实例1：const_cast使用实例

const int a = 10;
int *p1 = (int*)&a;//C中类型转换
int *p2 = const_cast<int*>(&a);//C++中类型转换const_cast

转换为相同类型的时候，我们通过反汇编查看时候，发现C中的类型强转与C++中const_cast所生成的汇编指令底层是一模一样的。

但是在转换成汇编指令之前，即编译阶段，就有所不同。

注意1：不考虑const或valatile后类型保持一致才可以进行合理的类型转换。

const int a = 10;
char *p1 = (char*)&a;//C中类型转换，可以
char *p2 = const_cast<char*>(&a);//C++中类型转换const_cast，不可以

我们如果通过C中类型转换可以将int * 转换为多种不同的类型，没有任何问题；这里为整型常量的地址，但是如果通过const_cast将整型常量地址转换为另一个指针类型不匹配的指针，是不可以的。const_cast使用时，地址的类型是与左边类型以及转换的类型需要保持一致。防止了C中低级别的类型强转任意的转换指针的类型导致一些不确定的错误。
编译出错：

注意2：const_cast<里面必须是指针或引用类型>，否则出错，例如：

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

编译出错：

 

二、static_cast

static_cast(静态)：编译时期的类型转换，提供编译器认为安全的类型转换。 是一个c++运算符，功能是把一个表达式转换为某种类型，使用最多。

注意：
1.有联系的类型之间可以互相转换。
2.没有任何联系的类型之间的转换会被否定。
3.基类类型与派生类类型进行转换，可以用static_cast，它们类型之间有关系，但不一定安全。

实例2：static_cast使用实例
注意1：有联系的类型之间可以互相转换。

int a = 10;
char b = static_cast<int>(a);

编译成功，int与char直之间有联系。

注意2：没有任何联系的类型之间的转换会被否定。

int *p = nullptr;
//double* = (double*)p;C可以转换
double* b = static_cast<double*>(p);

编译失败：int * 与short * 直接没有任何联系。

注意3：基类类型与派生类类型进行转换，可以用static_cast，它们类型之间有关系，但不一定安全。
 

三、reinterpret_cast

reinterpret_cast：类似于C风格的强制类型转换，是C++里的强制类型转换符，不安全。

注意：
1.如果非要进行没有任何联系的类型转换，可以使用reinterpret_cast。

实例3：reinterpret_cast使用实例
注意1：如果非要进行没有任何联系的类型转换，可以使用reinterpret_cast。

int *p = nullptr;
double* b = reinterpret_cast<double*>(p);

reinterpret_cast与C中类型转换类似，转换成功，不安全。
 

四、dynamic_cast

dynamic_cast(动态)：运行时期的类型转换，用于继承结构中，可以支持RTTI类型识别的上下转换及识别。 将一个基类对象指针（或引用）转换到继承类指针，dynamic_cast会根据基类指针是否真正指向继承类指针来做相应处理。

实例4：dynamic_cast使用实例

class Base
{
public:
	virtual void func() = 0;
};

class Derive1 : public Base
{
public:
	void func()
	{
		cout << "call Derive1::func" << endl;
	}
};

class Derive2 : public Base
{
public:
	void func()
	{
		cout << "call Derive2::func" << endl;
	}
};

void showFunc(Base* p)
{
	p->func();//动态绑定
}

int main()
{
	Derive1 d1;
	Derive1 d2;
	showFunc(&d1);
	showFunc(&d2);

	return 0;
}

执行结果：执行成功。

但是，我们的需求改变了。Derive实现了一个新功能的API接口函数。

class Derive2 : public Base
{
public:
	void func()
	{
		cout << "call Derive2::func" << endl;
	}
	//需求更改 Derive2实现新功能的API接口函数
	void derive02func()
	{
		cout << "call derive02func()::func" << endl;
	}
};

我们的void show()应该区分判断一下，如果Base* p指向了其他的派生类对象，调用p->func()方法就好。但如果指向Derive2对象，不调用func()方法，而调用Derive2的derive02func()方法。我们该如何做呢？
      这里就要识别*p的类型，看它指向哪个对象。此时就需要我们的dynamic_cast()了。dynamic会检查p指针是否指向的是一个Derive2类型的对象；p->vfptr->vftable RTTI信息 如果是dynamic_cast，
转换类型成功，返回Derive2对象地址；否则，返回nullptr。

void showFunc(Base* p)
{
	//dynamic会检查p指针是否指向的是一个Derive2类型的对象
	//p->vfptr->vftable RTTI信息 如果是dynamic_cast，
	//转换类型成功，返回Derive2对象地址；否则，返回nullptr
	Derive2 *pd2 = dynamic_cast<Derive2*>(p);
	if (pd2 != nullptr)
	{
		pd2->derive02func();
	}
	else
	{
		p->func();//动态绑定
	}
}

指向结果：调用成功。