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*的强制变换、隐式类型变换等...



================================================================
一、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(或子类)的互相转型。

转自http://hi.baidu.com/leonardhuang/blog/item/13785dd4abde962406088bc7.html

     和http://hi.baidu.com/zcx185973968/blog/item/9fc3e04f9c477901b3de05a4.html