C++的类型转换：static_cast、dynamic_cast、reinterpret_cast和const_cast

在C++中，存在类型转换，通常意味着存在缺陷（并非绝对）。所以，对于类型转换，有如下几个原则：
（1）尽量避免类型转换，包括隐式的类型转换
（2）如果需要类型转换，尽量使用显式的类型转换，在编译期间转换
（3）避免使用reinterpret_cast和老式的强制类型转换操作符
通常，隐式的类型转换会导致警告，需要重视这些警告，并使用显式的类型转换代替，例如static_cast代替一些算术类型转换。

在C++中，对象的类型通常有如下几种：
（一）内置类型，如int ，bool ，枚举类型等
（二）自定义类型  （1）数组类型 （2）指针类型 （3）引用类型 （4）类类型（结构类型）（5）联合类型
  对于内置类型，存在一组标准类型转换（也叫算术类型转换）。算术类型转换的核心包括两点：
（1）有符号类型和无符号类型的转换----如果存在无符号类型，那么其他类型也需要提升至无符号类型
（2）整型提升原则----对于比int小的整型，全部提升为int类型进行计算
（3）提升到最宽类型原则----对于自定义类型，其中类类型的转换是依靠转换操作符来进行。指针类型、引用类型和数组类型的转换在后面进行讲解。
1. 隐式类型转换
编译器在必要时将隐式类型转换应用到内置类型和类类型的对象上，通常在下面三种情况下发生隐式类型转换：
（1）混合类型表达式中，其操作数要转换为相同类型
（2）用作条件的表达式被转换为bool类型
（3）用表达式初始化或者赋值变量时，表达式被转换为该变量的类型
（4）函数调用时，形参和返回值都可能发生隐式类型转换
（5）指针的转换：
　　a、数组通常转换为指向第一个元素的指针（）
　　b、指向任意数据类型的指针可以转换为void*类型的指针
　　c、0可以转换为任意类型的指针
（6）枚举类型转换为整型
（7）非const对象转换为const对象
（8）由标准库（自定义）定义的转换

2. 显式类型转换（强制转换）:不提倡使用旧式的强制类型转换
使用强制类型转换可能的原因：
1)要覆盖通常的标准转换（隐式）
2)可能存在多种转换，需要选择一种特定的转换
3)不存在隐式类型转换，单由必须进行类型转换

常见四种显示转换方式如下所示，且先从功能强弱上排个序，从强到弱应该是：reinterpret_cast，旧式转换，static_cast，dynamic_cast。

（1）static_cast
用法：static_cast < type-id > ( exdivssion ) 
该运算符把exdivssion转换为type-id类型，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：
①用于类层次结构中基类和子类之间指针或引用的转换。
　　a. 进行上行转换（把子类的指针或引用转换成基类表示）是安全的；
　　b. 进行下行转换（把基类指针或引用转换成子类表示）时，由于没有动态类型检查，所以是不安全的。
②用于基本数据类型之间的转换，如把int转换成char，把int转换成enum。这种转换的安全性也要开发人员来保证。
③把空指针转换成目标类型的空指针。
④把任何类型的表达式转换成void类型。
注意：static_cast不能转换掉exdivssion的const、volitale、或者__unaligned属性。

（2） dynamic_cast
用法：dynamic_cast < type-id > ( exdivssion )
该运算符把exdivssion转换成type-id类型的对象。Type-id必须是类的指针、类的引用或者void *；
如果type-id是类指针类型，那么exdivssion也必须是一个指针，如果type-id是一个引用，那么exdivssion也必须是一个引用。
注意：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(pb);
D *pd2 = dynamic_cast(pb);
}
在上面的代码段中，如果pb指向一个D类型的对象，pd1和pd2是一样的，并且对这两个指针执行D类型的任何操作都是安全的；
但是，如果pb指向的是一个B类型的对象，那么pd1将是一个指向该对象的指针，对它进行D类型的操作将是不安全的（如访问m_szName），
而pd2将是一个空指针。
另外要注意：B要有虚函数，否则会编译出错；static_cast则没有这个限制。
这是由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表（关于虚函数表的概念，详细可见）中，只有定义了虚函数的类才有虚函数表，没有定义虚函数的类是没有虚函数表的。
另外，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(pb); //compile error
D *pd2 = dynamic_cast(pb); //pd2 is NULL
delete pb;
}
在函数foo中，使用static_cast进行转换是不被允许的，将在编译时出错；而使用 dynamic_cast的转换则是允许的，结果是空指针。

（3）reinterpret_cast
用法：reinterpret_cast (exdivssion)
type-id必须是一个指针、引用、算术类型、函数指针或者成员指针。
它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针（先把一个指针转换成一个整数，在把该整数转换成原类型的指针，还可以得到原先的指针值）。该运算符的用法比较多。

（4） const_cast 
用法：const_cast (exdivssion)
该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外， type_id和exdivssion的类型是一样的。
常量指针被转化成非常量指针，并且仍然指向原来的对象；
常量引用被转换成非常量引用，并且仍然指向原来的对象；常量对象被转换成非常量对象。

Voiatile和const类试。举如下一例：
class B{
public:
int m_iNum;
}
void foo(){
const B b1;
b1.m_iNum = 100; //comile error
B b2 = const_cast(b1);
b2. m_iNum = 200; //fine
}
上面的代码编译时会报错，因为b1是一个常量对象，不能对它进行改变；
使用const_cast把它转换成一个常量对象，就可以对它的数据成员任意改变。注意：b1和b2是两个不同的对象。
范例：
== ===========================================
== dynamic_cast .vs. static_cast 
== ===========================================
class B { ... }; 
class D : public B { ... };
void f(B* pb) 
{
D* pd1 = dynamic_cast(pb);
D* pd2 = static_cast(pb); 
}
　dynamic_cast可用于继承体系中的向下转型，即将基类指针转换为派生类指针，比static_cast更严格更安全。dynamic_cast在执行效率上比static_cast要差一些，但static_cast在更宽上范围内可以完成映射，这种不加限制的映射伴随着不安全性。static_cast覆盖的变换类型除类层次的静态导航以外，还包括无映射变换、窄化变换(这种变换会导致对象切片,丢失信息)、用VOID*的强制变换、隐式类型变换等...

== ===========================================
== static_cast .vs. reinterdivt_cast 
== ===========================================

reinterpret_cast是为了映射到一个完全不同类型的意思，这个关键词在我们需要把类型映射回原有类型时用到它。我们映射到的类型仅仅是为了故弄玄虚和其他目的，这是所有映射中最危险的。(这句话是C++编程思想中的原话)
static_cast 和 reinterdivt_cast 操作符修改了操作数类型。它们不是互逆的； static_cast 在编译时使用类型信息执行转换，在转换执行必要的检测(诸如指针越界计算, 类型检查). 其操作数相对是安全的。另一方面；reinterdivt_cast 仅仅是重新解释了给出的对象的比特模型而没有进行二进制转换， 例子如下：
int n=9; double d=static_cast < double > (n);
上面的例子中, 我们将一个变量从 int 转换到 double。 这些类型的二进制表达式是不同的。 要将整数 9 转换到 双精度整数 9，static_cast 需要正确地为双精度整数 d 补足比特位。其结果为 9.0。而reinterpret_cast 的行为却不同:
int n=9;
double d=reinterpret_cast (n);
这次, 结果有所不同. 在进行计算以后, d 包含无用值. 这是因为 reinterpret_cast 仅仅是复制 n 的比特位到 d, 没有进行必要的分析.
因此, 你需要谨慎使用reinterpret_cast.

================================================================
一、dynamic_cast<type-id>(expression)
将expression转化为具有type-id型的指针。type-id必须是一个指针、引用(一个已经定义的类)或者void指针。如果是个指针，expression也必须是个指针或者引用。

a. 如果type-id是expression的直接或间接基类指针，结果将是指向该expression实体的type-id类型指针。这称作"upcast"。比如：
class B {...}; 
class C : public B {...}; 
class D : public C {...}; 

void f (D *pD) 
{ 
C* pc = dynamic_cast<C*>(pD); // ok 
B* pb = dynamic_cast<B*>(pD); // ok 
} 

b.如果type-id是void *，那么运行时将检查expression的实际类型。其结果是指向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的一个对象 
} 

c.如果type-id不是void *，将在运行时检查expression对象是否可以被转型为type-id。
c-1.如果expression是type-id的一个基类，那么将在运行时检查expression是否指向type-id一个完整对象。如果是，结果就是该对象的指针。否则出错。如：
class B {...}; 
class D : public B {...}; 
void f() 
{ 
B *pB = new D; 
B *pB2 = new B; 

D *pD = dynamic_cast<D*> (pB); // ok. 
D *pD2 = dynamic_cast<D*> (pB2) // error. 
} 
上面称作"downcast" 
c-2.如果是多重继承，比如： 
class A {...}; 
class B : public A {...}; // B继承自A 
class C : public A {...}; // C继承自A 
class D : public B, public C {...}; // D继承自B, C 
此时指向D的指针可以安全的cast为B或者C(见上)，不过如果将其cast到A该怎么办呢？这样吗？ 
D *pD = new D; 
A *pA = dynamic_cast <A*> (pD); //error.不知道指向哪个A. 
这时我们可以先转型为B(或C)，然后间接批向A。如下 
B *pB = dynamic_cast <B*> (pD); 
A *pA = dynamic_cast <A*> (pB); // ok 

c-3.虚拟继承的情况
class A {...} // 以后就直接简写作class name了 
class B : vitual public A; 
class C : public B; 
class D : public B; 
class E : publc C, public D; 
如果E的实体或者A的子对象想要转型为B将会是失败的(原因见上)，这时你需要先转型为一个完整的E对象，然后逐层进行明确的转型操作。

c-4. 
class A; 
class B : public A; 
class C : public A; 
class D; 
class E : public B, public C, publc D; 

假如E的一个对象和D子对象的一个指针，想要从D的子对象中得到A的子对象，需要三个转换。 
先将D类型的指针转型为E型的一个指针，然后再逐层转型到A。如 
void f (D *pD) 
{ 
E *pE = dynamic_cast <E*> (pD); 
B *pB = dynamic_cast <B*> (pE); 
// 或者 B *pB = pe; 
A *pA = dynamic_cast <A*> (pB); 
// or A *pA = pB; 
}

c-5. (十字)交叉转换(cross cast)。
如上例中从B(或子类)与D(或子类)的互相转型。

二、static_cast 
static_cast通常可用于类层次的静态导航，无映射变换，窄化变换（会丢失信息）等等，static_cast的应用要广一些，但如前所提到的，在类层次导航变换中我们应该使用前者，因为后者static_cast可能意味着冒险(比如变换时类似于强制转换一样丢失信息)。但是在一个类层次中没有虚函数或者我们确定有其他允许我们安全向下映射的信息则后者static_cast更快一些。 
它将expression类型转型为 type-id类型。可以是类(包括继承)的转型，也可以是普通类型的转型(如int->float)。请注意，它运行时不做类型检查，因而可能是不安全的。比如将基类转型为派生类指针。 

三、const_cast 
简单的说，其作用就是将一个类的const、volatile以及__unaligned属性去掉。 
四、reinterpret_cast 
C++中的reinterpret_cast主要是将数据从一种类型的转换为另一种类型。所谓“通常为操作数的位模式提供较低层的重新解释”也就是说将数据以二进制存在形式的重新解释。比如：
int i;
char *p = "This is a example.";
i = reinterpret_cast<int>(p);
此时结果，i与p的值是完全相同的。reinterpret_cast的作用是说将指针p的值以二进制（位模式）的方式被解释为整型，并赋给i，一个明显的现象是在转换前后没有数位损失。
================================================================
static_cast：强制类型转换cast。因此，当然可以用于有继承关系的类之间的cast，细分有三类：
upcast：Just same as dynamic_cast. 由于不用做runtime类型检查，效率比dynamic_cast高；
downcast：不安全得很。不建议使用。
crosscast：不能用。带来编译错误。

dynamic_cast：有继承关系的类之间的cast。非常安全，但是由于需要做runtime类型检查，并且需要virtual table的支持，效率低些。细分三类：
upcast：ok。static_cast就完全够了。
downcast：必须用它。这样，当做不正确的downcast时才能得到NULL指针，，而不会像static_cast那样得到一个可以用的其实是没有用的非空指针。
crosscast：只能用它才能实现。 
================================================================
在大多数情况下，对于这些操作符你只需要知道原来你习惯于这样写:
(type) expression
而现在你总应该这样写:
static_cast(expression)

例如，假设你想把一个int转换成double，以便让包含int类型变量的表达式产生出浮点数值的结果。如果用C风格的类型转换，你能这样写：
int firstNumber, secondNumber;
...
double result = ((double)firstNumber)/secondNumber;
如果用上述新的类型转换方法，你应该这样写：
double result = static_cast<double>(firstNumber)/secondNumber;

const_cast 通常用来将对象的常量性移除（cast away the constness）。它是唯一有此能力的C++-style转型操作符。该运算符用来修改类型的const或volatile属性。除了const或volatile修饰之外，type_id和expression的类型是一样的。
常量指针被转化成非常量指针，并且仍然指向原来的对象；
常量引用被转换成非常量引用，并且仍然指向原来的对象；
常量对象被转换成非常量对象。
Voiatile和const类试。举如下一例：
classB{
public:
int m_iNum;
}
void foo(){
const Bb1;
b1.m_iNum=100;//编译时会报错，因为b1是一个常量对象，不能对它进行改变；
B b2=const_cast<B>(b1);
b2.m_iNum=200; //fine
}
使用const_cast把它转换成一个常量对象，就可以对它的数据成员任意改变。注意：b1和b2是两个不同的对象。

dynamic_cast用来执行继承体系中安全的向下转型或跨系转型动作。也就是说你可以利用它将指向基类对象的指针或者引用转型为指向派生类对象的指针或引用，并得知转型是否成功。如果转型失败，会以一个null指针(当转型对象是指针)或一个exception(当转型对象是引用)表现出来。dynamic_cast是唯一无法由旧式语法执行的转型动作，也是唯一可能消耗重大运行成本的转型动作。
static_cast 基本上拥有与C旧式转型相同的威力与意义，以及相同的限制。例如将一个非 const 的对象转换为 const 对象，或将int 转换为double等等。它也可以用来执行上述多种转换的反向转换，例如将void*指针转为typed指针，将pointer-to-base转为pointer-to-derived。但是他无法将const转为non-const，这个只有const-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);
}
在上面的代码段中，如果pb指向一个D类型的对象，pd1和pd2是一样的，并且对这两个指针执行D类型的任何操作都是安全的；但是，如果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); //compile error
D *pd2 = dynamic_cast<D *>(pb); //pd2 is NULL
delete pb;
}
在函数foo中，使用static_cast进行转换是不被允许的，将在编译时出错；而使用 dynamic_cast的转换则是允许的，结果是空指针。
reinterpret_cast意图执行低级转型，实际动作及结果可能取决于编译器，这也就表示它不可移植。例如将一个pointer to int 转型为int。这一类转型在低级代码以外很少见。
旧式转型在 C++ 中仍然是合法的，但是这里更推荐使用新形式。首先，它们在代码中更加易于辨认（不仅对人，而且对 grep 这样的工具也是如此），因而得以简化“找出类型系统在哪个地点被破坏”的过程。第二，各转型动作的目标愈窄化，编译器愈可能诊断出错误的运用。例如，如果你打算将常量性去掉，除非使用新式转型中的const_cast，否则无法通过编译。