一、旧式风格的类型转换
C++类型转换分为显式类型转换和隐式类型转换 ，隐式类型转换由编译器自动完成，这里只讨论显式类型转换。
type(expr); // 函数形式的强制类型转换
(type)expr; // C语言风格的强制类型转换
隐式类型转换是安全的，显式类型转换是有风险的，C语言之所以增加强制类型转换的语法，就是为了强调风险，让程序员意识到自己在做什么。
但是，这种强调风险的方式还是比较粗放，粒度比较大，它并没有表明存在什么风险，风险程度如何。再者，C风格的强制类型转换统一使用( )，而( )在代码中随处可见，所以也不利于使用文本检索工具定位关键代码。
为了使潜在风险更加细化，使问题追溯更加方便，使书写格式更加规范，C++ 对类型转换进行了分类，并新增了四个关键字来予以支持
二、现代C++风格的类型转换
cast-name<type>(expression)
- type是转换的目标类型。
- expression是被转换的值。
- cast-name有static_cast，dynamic_cast，const_cast和reinterpret_cast四种，表示转换的方式。
| 关键字 | 说明 |
|---|---|
| static_cast | 用于良性转换，一般不会导致意外发生，风险很低。 |
| const_cast | 用于 const 与非 const、volatile 与非 volatile 之间的转换。 |
| reinterpret_cast | 高度危险的转换，这种转换仅仅是对二进制位的重新解释，不会借助已有的转换规则对数据进行调整，但是可以实现最灵活的 C++ 类型转换。 |
| dynamic_cast | 借助 RTTI，用于类型安全的向下转型（Downcasting）。 |
1. static_cast 关键字
static_cast 是“静态转换”的意思，也就是在编译期间转换，转换失败的话会抛出一个编译错误。
任何编写程序时能够明确的类型转换都可以使用static_cast（static_cast不能转换掉底层const，volatile和__unaligned属性）。由于不提供运行时的检查，所以叫static_cast，因此，需要在编写程序时确认转换的安全性。
主要在以下几种场合中使用：
- 原有的自动类型转换，例如 short 转 int、int 转 double、const 转非 const、向上转型（上行转换，把子类对象的指针/引用转换为父类指针/引用，这种转换是安全的；进行下行转换，把父类对象的指针/引用转换成子类指针/引用，这种转换是不安全的，需要编写程序时来确认）等；
- void 指针和具体类型指针之间的转换，例如
void *转int *、char *转void *等； - 有转换构造函数或者类型转换函数的类与其它类型之间的转换，例如 double 转 Complex（调用转换构造函数）、Complex 转 double（调用类型转换函数）。
需要注意的是，static_cast 不能用于无关类型之间的转换，因为这些转换都是有风险的，例如：
- 两个具体类型指针之间的转换，例如
int *转double *、Student *转int *等。不同类型的数据存储格式不一样，长度也不一样，用 A 类型的指针指向 B 类型的数据后，会按照 A 类型的方式来处理数据：如果是读取操作，可能会得到一堆没有意义的值；如果是写入操作，可能会使 B 类型的数据遭到破坏，当再次以 B 类型的方式读取数据时会得到一堆没有意义的值。 - int 和指针之间的转换。将一个具体的地址赋值给指针变量是非常危险的，因为该地址上的内存可能没有分配，也可能没有读写权限，恰好是可用内存反而是小概率事件。
static_cast 也不能用来去掉表达式的 const 修饰和 volatile 修饰。换句话说，不能将 const/volatile 类型转换为非 const/volatile 类型。
示例：
#include <cstdlib>
using namespace std;
class Complex {
public:
Complex(double real = 0.0, double imag = 0.0) : m_real(real), m_imag(imag) {}
operator double() const { return m_real; } //类型转换函数
private:
double m_real;
double m_imag;
};
int main() {
// 下面是正确的用法
int m = 100;
Complex c(12.5, 23.8);
long n = static_cast<long>(m); //宽转换，没有信息丢失
char ch = static_cast<char>(m); //窄转换，可能会丢失信息
int *p1 = static_cast<int *>( malloc(10 * sizeof(int))); //将void指针转换为具体类型指针
void *p2 = static_cast<void *>(p1); //将具体类型指针，转换为void指针
double real = static_cast<double>(c); //调用类型转换函数
// 下面的用法是错误的
// float *p3 = static_cast<float*>(p1); //不能在两个具体类型的指针之间进行转换
// p3 = static_cast<float*>(0X2DF9); //不能将整数转换为指针类型
return 0;
}
2. const_cast 关键字
const_cast 比较好理解，它用来去掉表达式的 const 修饰或 volatile 修饰。换句话说，const_cast 就是用来将 const/volatile 类型转换为非 const/volatile 类型。
以 const 为例来说明 const_cast 的用法：
int main() {
const int n = 100;
int *p = const_cast<int *>(&n);
*p = 234;
cout << "n = " << n << endl;
cout << "*p = " << *p << endl;
return 0;
}
// 运行结果：
// n = 100
// *p = 234
&n 用来获取 n 的地址，它的类型为const int *，必须使用 const_cast 转换为int *类型后才能赋值给 p。由于 p 指向了 n，并且 n 占用的是栈内存，有写入权限，所以可以通过 p 修改 n 的值。
有读者可能会问，为什么通过 n 和 *p 输出的值不一样呢？这是因为 C++ 对常量的处理更像是编译时期的#define，是一个值替换的过程，代码中所有使用 n 的地方在编译期间就被替换成了 100。换句话说，第 8 行代码被修改成了下面的形式：cout<<"n = "<<100<<endl;
这样以来，即使程序在运行期间修改 n 的值，也不会影响 cout 语句了。
使用 const_cast 进行强制类型转换可以突破 C/C++ 的常数限制，修改常数的值，因此有一定的危险性；但是程序员如果这样做的话，基本上会意识到这个问题，因此也还有一定的安全性。
一般不得不使用 const_cast 的情况，都是因为前期设计的不够合理。const_cast 是不推荐使用的。
3. reinterpret_cast 关键字
reinterpret 是“重新解释”的意思，顾名思义，reinterpret_cast 这种转换仅仅是对二进制位的重新解释，不会借助已有的转换规则对数据进行调整，非常简单粗暴，所以风险很高。
非常激进的指针类型转换，在编译期完成，可以转换任何类型的指针，所以极不安全。非极端情况不要使用。
reinterpret_cast 可以认为是 static_cast 的一种补充，一些 static_cast 不能完成的转换，就可以用 reinterpret_cast 来完成，例如两个具体类型指针之间的转换、int 和指针之间的转换（有些编译器只允许 int 转指针，不允许反过来）。
示例：
class A {
public:
A(int a = 0, int b = 0) : m_a(a), m_b(b) {}
private:
int m_a;
int m_b;
};
int main() {
//将 char* 转换为 float*
char str[] = "http://c.biancheng.net";
float *p1 = reinterpret_cast<float *>(str);
cout << *p1 << endl;
//将 int 转换为 int*
int *p = reinterpret_cast<int *>(100);
//将 A* 转换为 int*
p = reinterpret_cast<int *>(new A(25, 96));
cout << *p << endl;
cout << *(p + 1) << endl;
return 0;
}
// 运行结果：
// 3.0262e+29
// 25
// 96
可以想象，用一个 float 指针来操作一个 char 数组是一件多么荒诞和危险的事情，这样的转换方式不到万不得已的时候不要使用。将A转换为 int，使用指针直接访问 private 成员刺穿了一个类的封装性，更好的办法是让类提供 get/set 函数，间接地访问成员变量。
4. dynamic_cast 关键字
dynamic_cast 用于在类的继承层次之间进行类型转换，它既允许向上转型（Upcasting），也允许向下转型（Downcasting）。向上转型是无条件的，不会进行任何检测，所以都能成功；向下转型的前提必须是安全的，要借助 RTTI 进行检测，所有只有一部分能成功。
dynamic_cast 与 static_cast 是相对的，dynamic_cast 是“动态转换”的意思，static_cast 是“静态转换”的意思。dynamic_cast 会在程序运行期间借助 RTTI 进行类型转换，这就要求基类必须包含虚函数；static_cast 在编译期间完成类型转换，能够更加及时地发现错误。
对于指针，如果转换失败将返回 NULL；对于引用，如果转换失败将抛出std::bad_cast异常。
-
(1) 向上转型(Upcasting)
向上转型时，只要待转换的两个类型之间存在继承关系，并且基类包含了虚函数（这些信息在编译期间就能确定），就一定能转换成功。因为向上转型始终是安全的，所以 dynamic_cast 不会进行任何运行期间的检查，这个时候的 dynamic_cast 和 static_cast 就没有什么区别了。
「向上转型时不执行运行期检测」虽然提高了效率，但也留下了安全隐患，请看下面的代码：
class Base { public: Base(int a = 0) : m_a(a) {} int get_a() const { return m_a; } virtual void func() const {} protected: int m_a; }; class Derived : public Base { public: Derived(int a = 0, int b = 0) : Base(a), m_b(b) {} int get_b() const { return m_b; } private: int m_b; }; int main() { //情况① Derived *pd1 = new Derived(35, 78); Base *pb1 = dynamic_cast<Derived *>(pd1); cout << "pd1 = " << pd1 << ", pb1 = " << pb1 << endl; cout << pb1->get_a() << endl; pb1->func(); //情况② int n = 100; Derived *pd2 = reinterpret_cast<Derived *>(&n); Base *pb2 = dynamic_cast<Base *>(pd2); cout << "pd2 = " << pd2 << ", pb2 = " << pb2 << endl; cout << pb2->get_a() << endl; //输出一个垃圾值 pb2->func(); //内存错误 return 0; }情况①是正确的，没有任何问题。对于情况②，pd 指向的是整型变量 n，并没有指向一个 Derived 类的对象，在使用 dynamic_cast 进行类型转换时也没有检查这一点，而是将 pd 的值直接赋给了 pb（这里并不需要调整偏移量），最终导致 pb 也指向了 n。因为 pb 指向的不是一个对象，所以get_a()得不到 m_a 的值（实际上得到的是一个垃圾值），pb2->func()也得不到 func() 函数的正确地址。
pb2->func()得不到 func() 的正确地址的原因在于，pb2 指向的是一个假的“对象”，它没有虚函数表，也没有虚函数表指针，而 func() 是虚函数，必须到虚函数表中才能找到它的地址。
-
(2) 向下转型(Downcasting)
向下转型是有风险的，dynamic_cast 会借助 RTTI 信息进行检测，确定安全的才能转换成功，否则就转换失败。
哪些向下转型是安全地呢，哪些又是不安全的呢？这里比较复杂，等以后遇到了再研究，感兴趣可以参考文末的引用部分。
三、总结
各类cast关键字适用场景：
- 先考虑static_cast，能满足80%的场景；
- 需要向下转型时，考虑dynamic_cast；
- 不到万不得已不使用const_cast(通常是设计的有问题才必须用，违背了const关键字的承诺)、reinterpret_cast(比较暴力，不安全)
补充：
恕我直言，如果您100％确定所有 dynamic_cast<>正确，则没有理由不将其更改为static_cast<>的理由。您可以更改它们的。
四、补充
assert_cast
写严谨代码时，也可以使用assert进行严格的条件判断。
Ref: