标准C++中有四个类型转换符：static_cast、dynamic_cast、reinterpret_cast 和 const_cast。

I. static_cast

用法：static_cast < type-id > ( expression )

该运算符把expression转换为type-id类型，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：

①用于类层次结构中基类和子类之间指针或引用的转换。

进行上行转换（把子类的指针或引用转换成基类表示）是安全的；

进行下行转换（把基类指针或引用转换成子类表示）时，由于没有动态类型检查，所以是不安全的。

②用于基本数据类型之间的转换。如把int转换成char，把int转换成enum。这种转换的安全性也要开发人员来保证。

③把空指针转换成目标类型的空指针。

④把任何类型的表达式转换成void类型。

注意：static_cast不能转换掉expression的const、volitale、或者__unaligned属性。

 

II. dynamic_cast

主要用于执行“安全的向下转型（safe down casting）”，也就是说，要确定一个对象是否是一个继承体系中的一个特定类型。

用法：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更安全。

class B{

public:

int m_iNum;

virtual void foo();

};

class D:public B{

public:

char *m_szName[100];

};

void func(B *pb){

D *pd1 = static_cast<D *>(pb); //下行转换，安全；上行转换不安全。

D *pd2 = dynamic_cast<D *>(pb);//下行转换，安全；下行转换安全。

}

在上面的代码段中，

情形1：如果pb指向一个D类型的对象，pd1和pd2是一样的，并且对这两个指针执行D类型的任何操作都是安全的；

情形2：如果pb指向的是一个 B类型的对象，那么pd1将是一个指向该对象的指针，对它进行D类型的操作将是不安全的（如访问m_szName），而pd2将是一个空指针。

注意：B要有虚函数，否则会编译出错；static_cast则没有这个限制。这是由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表（关于虚函数表的概念，详细可见<Inside c++ object model>）中，只有定义了虚函数的类才有虚函数表，没有定义虚函数的类是没有虚函数表的。

 

另外，dynamic_cast还支持交叉转换（cross cast）。如下代码所示。

class A{

public:

int m_iNum;

virtual void f(){}

};

class B:public A{

};

class D:public A{

};

void foo(){

B *pb = new B;

pb->m_iNum = 100;

D *pd1 = static_cast<D *>(pb); //copile error，因为static_cast不能进行类的交叉转换。B类与D类间没有继承和派生的关系。

D *pd2 = dynamic_cast<D *>(pb); //pd2 is NULL

delete pb;

}

在函数foo中，使用static_cast进行转换是不被允许的，将在编译时出错；而使用 dynamic_cast的转换则是允许的，结果是空指针。

 

向void*转换

如果 type-id 是一个 void* ，运行时检查将决定表达式的实际类型。结果是一个到 expression 指向的完整对象。例如：

class A { ... };

class B { ... };

void f()

{

  A* pa = new A;

  B* pb = new B;

  void* pv = dynamic_cast< void* >(pa);

  // pv指向一个 A 类型的对象

  ...

  pv = dynamic_cast<void*>(pb);

  // pv 指向一个 B 类型的对象

}

 

向下转换

如果 type-id 不是 void* ，运行时检查指向 expression 的对象能否转换为指向 type-id 类型的对象。

如果 expression 类型是 type-id 的基类，运行时检查expression 实际上是否是一个指向 type-id 类型的完整对象，如果是，结果返回指向 type-id 类型的完整对象，否则返回 NULL 。例如：

class B { ... };

class D : public B { ... };

void f()

{

  B* pb = new D;                // unclear but ok

  B* pb2 = new B;

   // 判断一个基类指针指向的对象是否是一个指定子类型

  D* pd = dynamic_cast< D* >(pb);     // ok: pb实际指向 D, 返回D*

  D* pd2 = dynamic_cast< D* >(pb2);  // pb2实际指向 B 而不是 D,转换失败， pd2 是 NULL

  ...

}

 

 

看一下下面的类继承层次：

  class A {...};

class B:public A { ...};

class C:public A{ ...};

class D:public B, public C { ... };

指向类型D的指针转换为B或C都正常，但如果从D转换到A将会怎么样来？这个结果导致转换的二义性错误；为了j解决这个问题，你可以指向两次明确的转型，例如：

void f()

{

  D* pd = new D;

  A* pa = dynamic_cast<A*>(pd);     //错误：二义性

  B* pb = dynamic_cast<B*>(pd);     //首先转换到 B

  A* pa2 = dynamic_cast<A*>(pb);  // ok:明确的

}

在使用虚基类的时候就导致更复杂的模糊；看下面的类层次图：

在这个继承层次中，A是虚基类。假定一个类E的对象和一个指向A子对象的指针，一次到B的dynamic_cast会由于不明确性导致失败，你必须首先转换到适当的层次，然后再向上转换到确定的层次，一直按照这种方式直到到达正确的B对象。

看下面的类层次图：

假定一个类型E的对象和一个指向D子对象的指针，从D子对象导航到左上A子对象，必须执行三个转换。从D到E的dynamic_cast的转换，然后一个从E到B的转换（可以是dynamic_cast或者隐式转换），最终是从B到A的转换，例如：

void f(D* pd)

{

  E* pe = dynamic_cast<E*>(pd);// 这里的 D 实际上是 E 类型的对象

  B* pb = pe;     // upcast, implicit conversion

  A* pa = pb;     // upcast, implicit conversion

}

 

 

 

III. reinpreter_cast

用法：reinpreter_cast<type-id> (expression)

type-id必须是一个指针、引用、算术类型、函数指针或者成员指针。它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针（先把一个指针转换成一个整数，在把该整数转换成原类型的指针，还可以得到原先的指针值）。

该运算符的用法比较多。

例如：

char  *p，*p1;

char a[]="abcd";

p=a;

int i=reinterpret_cast<int>(p) ;// 把一个指针转换成一个整数

p1= reinterpret_cast<char*>(i); // 把一个整数转换成一个指针,p和p1均指向a的首地址。

IV. const_cast

用法：const_cast<type_id> (expression)

该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外， type_id和expression的类型是一样的。

常量指针被转化成非常量指针，并且仍然指向原来的对象；常量引用被转换成非常量引用，并且仍然指向原来的对象；常量对象被转换成非常量对象。

Voiatile和const类试。举如下一例：

class B{

public:

int m_iNum;

}

void foo(){

const B b1;

b1.m_iNum = 100; //comile error 编译出错

B b2 = const_cast<B>(b1);

b2. m_iNum = 200; //fine 正确

}

上面的代码编译时会报错，因为b1是一个常量对象，不能对它进行改变；使用const_cast把它转换成一个常量对象，就可以对它的数据成员任意改变。注意：b1和b2是两个不同的对象。