C++中的类型转换（static_cast,dynamic_cast,const_cast,reinterpret_cast）

前言

标题中的四中显示转换有时候总会忘掉，特意在此总结一下。

C++中的类型转换分为两种：

隐式类型转换；

显示类型转换；

g关于隐式转换这里不做总结，主要说明显示转换。在标准C++中有四个类型转换符：static_cast, dynamic_cast, const_cast 和 reinterpret_cast；

static_cast

static_cast的转换格式:

static_cast <type_id> (expression)

将expression转换为type_id类型，主要用于非多态类型之间的转换，不提供运行时间的检查来确保转换的安全性。主要在下面3种情况下使用

1. 用于类层次结构种，基类和子类之间指针和引用的转换；

当进行上行转换，也就是把子类的指针或引用转换成父类表示，这种转换是安全的；

当进行下行转换，也就是把父类的指针或引用转换成子类表示，这种转换是不安全的，也需要程序员来保证；

2. 用于基本数据类型之间的转换，如把int转换成char，把int转换成enum等等，这种转换的安全性需要程序员来保证；

3. 把void指针转换成目标类型的指针，是及其不安全的；

注意：static_cast不能转换掉expression的const、volatile和__unaligned属性。

dynamic_cast

dynamic_cast的转换格式：

dynamic_cast <type-id> (expression)

将expression转换为type-id类型，type-id必须是类的指针、类的引用或者是void *；如果type-id是指针类型，那么expression也必须是一个指针；如果type-id是一个引用，那么expression也必须是一个引用。

dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。在多态类型之间的转换主要使用dynamic_cast，因为类型提供了运行时信息。来看看下面的示例

1. 最简单的上行转换

#include <iostream>
using namespace std;
class A
{
// ......
};
class B : public A
{
// ......
};
int main()
{
B *pB = new B;
A *pA = dynamic_cast<A *>(pB); // Safe and will succeed
}

2.多重继承之间的上行转换

C继承自B，B继承自A，这种多重继承的关系；但是，关系很明确。

class A
{
// ......
};
class B : public A
{
// ......
};
class C : public B
{
// ......
};
int main()
{
C *pC = new C;
B *pB = dynamic_cast<B *>(pC); // OK
A *pA = dynamic_cast<A *>(pC); // OK
}

而上述的转换，static_cast和dynamic_cast具有同样的效果。而这种上行转换，也被称为隐式转换；比如我们在定义变量时经常这么写：B *pB = new C;这和上面是一个道理的，只是多加了一个dynamic_cast转换符而已。

3.转换成void*

class A
{
public:
virtual void f(){}
// ......
};
class B
{
public:
virtual void f(){}
// ......
};
int main()
{
A *pA = new A;
B *pB = new B;
void *pV = dynamic_cast<void *>(pA); // pV points to an object of A
pV = dynamic_cast<void *>(pB); // pV points to an object of B
}

但是，在类A和类B中必须包含虚函数，为什么呢？因为类中存在虚函数，就说明它有想让基类指针或引用指向派生类对象的情况，此时转换才有意义；由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表中，只有定义了虚函数的类才有虚函数表。

4.如果expression是type-id的基类，使用dynamic_cast进行转换时，在运行时就会检查expression是否真正的指向一个type-id类型的对象，如果是，则能进行正确的转换，获得对应的值；否则返回NULL，如果是引用，则在运行时就会抛出异常；例如：

class B
{
virtual void f(){};
};
class D : public B
{
virtual void f(){};
};
void main()
{
B* pb = new D;   // unclear but ok
B* pb2 = new B;
D* pd = dynamic_cast<D*>(pb);   // ok: pb actually points to a D
D* pd2 = dynamic_cast<D*>(pb2);   // pb2 points to a B not a D, now pd2 is NULL
}

这就是下行转换，从基类指针转换到派生类指针。

const_cast

const_cast的转换格式：

const_cast <type_id> (expression)

const_cast用来将类型的const、volatile和__unaligned属性移除。常量指针被转换成非常量指针，并且仍然指向原来的对象；常量引用被转换成非常量引用，并且仍然引用原来的对象。如下：

void foo(const int* cp) {
int* p = const_cast<int *>(cp);
(*p)++;
}

d但是上面的代码在逻辑上是混乱的，它将形参声明为const，承诺不会通过cp修改任何变量的值，但是它却出尔反尔了。

注意：const_cast只用来将常指针转换为普通指针，将常引用转换为普通引用，而不用来将常对象转换为普通对象，因为这没有什么意义。因为对象的转换（而非引用）会产生对象的副本，而使用常对象本来就可以直接生成普通对象的副本。例如：

const int i=5;
int j=i;
//这里常量i赋值给变量j不需要任何转换的。

const_cast的正确用法，看看下面的例子：

class test
{
public:
test(int cnt)
: size(cnt), num(new int[cnt]){

}
~test() {
delete[] num;
}
int &element(int index) {
assert(index>=0 && index<size);
return num[index];
}
const int &element(int index) const {
assert(index>=0 && index<size);
return num[index];
}

private:
int *num;
int size;
};

为了能够让普通对象、普通指针、普通引用和常对象、常指针、常引用，都能访问element，我们不得以只能创建两个element函数，它们的内容相差不多很少浪费，如果代码行数少，倒还可以接受，如果代码更长，恐怕会很麻烦。当修改一个函数时，另外一个也要修改。这种方式是不明智的。这是，const_cast就可以排上用场了。我们可以将非const的element函数修改如下：

int &element(int index) {
return const_cast<Point &>
static_cast<const test*>(this)->element(index));
}

因为普通指针向常指针转换是安全的，所以可以用static_cast执行。我们现将this显示转换为常指针，然后通过它去调用常函数element（否则会一直递归下去）。在得到常引用类型的结果后，使用const_cast将其转换为普通引用，就是最后想要的结果。这样一来，日后的维护会变得简单很多。这就是const_cast的安全用法。

reinterpret_cast

reinterpret_cast的转换格式：

reinterpret_cast <typd_id> (expression)

允许将任何指针类型转换为其它的指针类型；听起来很强大，但是也很不靠谱。它主要用于将一种数据类型从一种类型转换为另一种类型。它可以将一个指针转换成一个整数，也可以将一个整数转换成一个指针，在实际开发中，先把一个指针转换成一个整数，在把该整数转换成原类型的指针，还可以得到原来的指针值；特别是开辟了系统全局的内存空间，需要在多个应用程序之间使用时，需要彼此共享，传递这个内存空间的指针时，就可以将指针转换成整数值，得到以后，再将整数值转换成指针，进行对应的操作。