C++中的类型转换分为两种：
隐式类型转换；
显式类型转换。
而对于隐式变换，在很多时候，不经意间就发生了，比如int类型和float类型相加时，int类型就会被隐式的转换位float类型，然后再进行相加运算。而关于隐式转换不是今天总结的重点，重点是显式转换。
在标准C++中有四个类型转换符：static_cast、dynamic_cast、const_cast和reinterpret_cast；下面将对它们一一的进行总结。
1. static_cast
static_cast的转换格式：static_cast <type-id> (expression)
将expression转换为type-id类型，主要用于非多态类型之间的转换，不提供运行时的检查来确保转换的安全性。主要在以下几种场合中使用：
- 用于类层次结构中，基类和子类之间指针和引用的转换；
当进行上行转换，也就是把子类的指针或引用转换成父类表示，这种转换是安全的；
当进行下行转换，也就是把父类的指针或引用转换成子类表示，这种转换是不安全的，也需要程序员来保证； - 用于基本数据类型之间的转换，如把int转换成char，把int转换成enum等等，这种转换的安全性需要程序员来保证；
- 把void指针转换成目标类型的指针，是及其不安全的；
注：static_cast不能转换掉expression的const、volatile和__unaligned属性。
//隐式的类型转换
int firstnumber=10;
double result=(double)firstnumber/secondnumber;
//使用static_dynamic
double result=static_cast<double> (firstnumber/secondnumber);
-
举个例子：
将int（4字节）显示转换成short(2字节)，用vs调试一下，发现static_cast的作用就是将高位截断。
再举一个例子，讲short显示转换成int，结果如下图所示。
short是2个字节，int是4个字节，将short转换成int之后，高位根据符号位补满。
so，小结一下static_cast:
基本数据类型之间的转换，如把int转换成char，把int转换成enum
用于类层次结构中基类和子类之间指针或引用的转换。
进行上行转换（把子类的指针或引用转换成基类表示）是安全的；
进行下行转换（把基类指针或引用转换成子类指针或引用）时，由于没有动态类型检查，所以是不安全的。把void指针转换成目标类型的指针(不安全!!)
2. 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，因为类型提供了运行时信息。下面我将分别在以下的几种场合下进行dynamic_cast的使用总结：
- 最简单的上行（xing）转换
比如B继承自A，B转换为A，进行上行转换时，是安全的，如下：
#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
}
- 多重继承之间的上行转换
C继承自B，B继承自A，这种多重继承的关系；但是，关系很明确，使用dynamic_cast进行转换时，也是很简单的：
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转换符而已。
- （这个真的是重点）如果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
}
这个就是下行转换，从基类指针转换到派生类指针。
在《More effective C++》里面看见一个很好的例子，也补充在这里
//定义
class Widget{};
class SpecialWidget:public Widget{};
void update(SpecialWidget *psw);
Widget * pw;
...
//如果pw所指的是SpecialWidget ，那么就传递过去；如果pw指的是Widget ，
//那么传递过去的值是null
update(dynamic_cast<SpecialWidget *> (pw));
-
对于一些复杂的继承关系来说，使用dynamic_cast进行转换是存在一些陷阱的；比如，有如下的一个结构：
image.png
D类型可以安全的转换成B和C类型，但是D类型要是直接转换成A类型呢？
class A
{
virtual void Func() = 0;
};
class B : public A
{
void Func(){};
};
class C : public A
{
void Func(){};
};
class D : public B, public C
{
void Func(){}
};
int main()
{
D *pD = new D;
A *pA = dynamic_cast<A *>(pD); // You will get a pA which is NULL
}
如果进行上面的直接转，你将会得到一个NULL的pA指针；这是因为，B和C都继承了A，并且都实现了虚函数Func，导致在进行转换时，无法进行抉择应该向哪个A进行转换。正确的做法是：
int main()
{
D *pD = new D;
B *pB = dynamic_cast<B *>(pD);
A *pA = dynamic_cast<A *>(pB);
}
这就是我在实现QueryInterface时，得到IUnknown的指针时，使用的是*ppv = static_cast<IX *>(this);而不是*ppv = static_cast<IUnknown *>(this);
对于多重继承的情况，从派生类往父类的父类进行转时，需要特别注意；比如有下面这种情况：
现在，你拥有一个A类型的指针，它指向E实例，如何获得B类型的指针，指向E实例呢？如果直接进行转的话，就会出现编译器出现分歧，不知道是走E->C->B，还是走E->D->B。对于这种情况，我们就必须先将A类型的指针进行下行转换，获得E类型的指针，然后，在指定一条正确的路线进行上行转换。
上面就是对于dynamic_cast转换的一些细节知识点，特别是对于多重继承的情况，很容易出现问题。
如何你是好奇宝宝，想知道dynamic_cast是如何实现的？
侯捷在《内存与对象》书里面做了一个详细的解释，我试着理解了一下。给一个blog ： http://blog.csdn.net/bitboss/article/details/53574236
3. const_cast
常量指针被转化成非常量指针，并且仍然指向原来的对象；
常量引用被转换成非常量引用，并且仍然指向原来的对象；
const_cast的作用是用来改变表达式里面的常量性（const）或易变性（volatile）。
#include <iostream>
using std::cout;
using std::endl;
int main(void)
{
const int b = 10;
//b = 11 报错，因为b是一个常量对象
int * pc = const_cast<int *>(&b);
*pc = 11;
cout << "*pc = " << *pc << endl;//b原来地址的数据现在可由*pc来改变，即解除const
cout << "b = " << b << endl; //b其实类似(编译器处理问题)#define b 10 不会变的
return 0;
}
