C++ - 类型转换 - static_cast - reinterpret_cast - const_cast - dynamic_cast
目录
类型转换
C语言当中的类型转换
为什么C++需要四种类型转换 （讲解volatile关键字）
C++强制类型转换
static_cast
reinterpret_cast
const_cast
dynamic_cast（动态转换）
RTTI
类型转换
C语言当中的类型转换
其实在 C语言当中就已经有了类型转换，只要是 赋值运算符的左右两侧的类型不同，或者是形参与实参的类型不匹配，还有返回值和接受返回值的类型不一样时，就会发生类型转换。
在C 语言当中，总共有两种类型转换方式：
隐式类型转换：编译器在编译时期自动进行，如果能转换就转换，如果不能转换就报错。
显示类型转换（强制类型转换）：需要用户自己进行处理。
void Test()
{
int i = 1;
// 隐式类型转换
double d = i;
printf("%d, %.2f\n", i, d);
int* p = &i;
// 显示的强制类型转换
int address = (int)p;
printf("%x, %d\n", p, address);
}对于相似类型，或者说是意义相近的类型，可能进行隐式类型转换。
比如：像 double ，int ， char ， shrot 等等这些整形家族是可以发生隐式类型转换的；整形 和 指针类型也是可以的，因为 指针存储的是地址，地址是编号，是 四个字节存储的十六进制的数。
还有，单参数的构造函数 也支持隐式类型转换。
class A
{
public:
A(int a = 1)
:_a(a)
{}
private:
int _a;
};
class B
{
public:
B(const A& a)
{}
private:
//....
};
int main()
{
A a;
a = 1; // 此时也是 发生 隐式类型转换
// 由 int 转换为 A
B b = a; // 此处发生隐式类型转换
// 本来是 拷贝 + 拷贝构造
// 由a 构造一个 A 类型的临时对象
// 由这个临时对象拷贝构造个 b 这个对象
// 但是编译器在这里进行优化，由 a 直接构造了 b
return 0;
}上述两者都是，构造 + 拷贝构造，由赋值运算符右边的数据类型，构造一个 赋值赋值运算符左边的 自定义类型的临时变量，然后由这个临时变量 拷贝构造 给 左边的 自定义类型变量。
如果，你不想在此发生隐式类型转换，你可以把 单参数的 构造函数用 explicit 关键词修饰：
explicit A(int a = 1)
:_a(a)
{}此时报错：
只要是有点关联的类型之间，一般是可以发生隐式类型转换的；如果是完全没有关联的话，是不能发生隐式类型转换的，例如：string 和 vector
而，对于强制类型转换，就都可以转换了。
为什么C++需要四种类型转换 （讲解volatile关键字）
隐式类型转换 是会带来很多坑的，比如下面这个代码：
在while 循环条件当中，end 是int 类型，pos 是 size_t 类型，就会发生隐式类型转换，转换为 size_t 类型，一般这种转换是 小类型转换为 大类型，比如 如果是 int 和 double 就是 int 转换为 double 类型，在下述博客 的 "增" 这一章节当中，insert（）函数的实现就遇到了这个问题，在下述博客当中介绍的更详细：
C++-string类的模拟实现_chihiro1122的博客-CSDN博客
那么，在上述这个问题，有了隐式类型转换之后，机会造成误解，如果不支持的话，那么while 当中的条件肯定是会报错的，我们一眼就能看出错误，但是有了隐式类型转换就不一定了。
还有下面这种情况：
上述的 n 不是常量，n是常变量。常变量不能直接修改，当然也不能直接被指针引用：
只能间接修改 或者间接被指针引用：
int* pn = (int*)&n;
*pn++;上述是可以编译通过的。
那么，你可以猜一猜下述的代码输出的是什么：
const int n = 10;
int* pn = (int*)&n;
(*pn)++;
cout << n << endl;
cout << *pn << endl;不是 10 10 和 11 11 ，结果如下：
10
11此时你可能会认为，pn 指向的变量 和 n 已经不是一个变量了，其实不是，当我们输出两个地址，发现还是一个地址：
const int n = 10;
int* pn = (int*)&n;
(*pn)++;
cout << &n << endl;
cout << pn << endl;输出结果：
0000002134EFF984
0000002134EFF984如果你不服，再去逐步调试，发现，其实 pn 指针的修改确实是影响到了 n 的值，但是 n 的输出确还是 原来的值：
这是为什么呢？
其实是编译器在此处进行了优化，因为编译器认为，const 变量是不能进行修改的，没有在内存当中取 n 的数据，把 n 实际的值放到了 寄存器当中，当我们访问 n 的值的时候是直接从寄存区当中去取 n 的值的。
关于常变量的取出，你可以理解为 从 寄存器当中取值，然后进行了类似宏替换的操作（但是实际上不是宏替换）。
如果你不想让编译器从 寄存器当中取数据，来替换的话，可以使用 volatile 这个关键字修饰 n 这个变量，告诉编译器，直接从内存当中去取 n 的值。
我们要记住的是，修改一个 常变量的 const 属性是要 背上风险的，就像上述一样，pn 指针是能修改到 n 的值，但是 在访问 n 的 时候 n 的值还是没变。类似 (int*)&n 这样的操作是会有安全隐患的。
总结一下：
C风格的转换格式很简单，但是有不少缺点的：
- 隐式类型转化有些情况下可能会出问题：比如数据精度丢失。
- 显式类型转换将所有情况混合在一起，代码不够清晰。
因此C++提出了自己的类型转化风格，注意因为C++要兼容C语言，所以C++中还可以使用C语言的转化风格。
C++强制类型转换
在 C++ 当中对 强制类型转换进行了 四种归类，引入了四种命名的强制类型转换操作符：
static_cast
reinterpret_cast
const_cast
dynamic_castC++ 当中期望你在对类型转换的时候，进行规范的转换。
static_cast
当你在进行 相近类型，或者是意思相近类型转换，也就是在 C 当中的隐式类型转换，期望你用 static_cast 关键字来进行转换：
static_cast 语法（关于语法我们直接举例来说明）：
double n = 10;
int m = static_cast(n); 向上述情况就是把 double 类型的 n 强转为 int 类型，从而被 int 类型的 m 变量所接收。
需要注意区分的是：括号说要扩在 被强转类型的变上面的，而不是 static_cast 本身，不是像之前强转一样 （int*）n 这种方式，使用在 static_cast 上面是错误的，如下面的错误示范：
int m = (static_cast)n; // 这种方式是错误的写法 不是相近类型，不要用 static_cast 来转换，会报错：
reinterpret_cast
reinterpret_cast 就可以实现 不相关类型，不相近类型之间的类型转换。reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释来实现。
语法 是和 static_cast 是一样的：
int b = 10;
int* m = reinterpret_cast(b); 这种不相关类型之间的 转换 关键字（reinterpret_cast） ，是不处理 上述 const int n = 10 的强制类型转换的，这里编译器进行了强制的识别，直接报错：
const_cast
对于 const int n = 10; (int*)&n; 这种方式的强制类型转换，需要用 const_cast 关键字来实现，用上述的 reinterpret_cast 是不行的。
const_cast最常用的用途就是删除变量的const属性，方便赋值。
语法都是一样的：
const int a = 2;
int* p = const_cast< int*>(&a );
*p = 3;
cout<但是，即便是上述的方式，也是修改了 const 变量的 const 属性，所以还是有风险的，要用 volatile 关键词修饰。
dynamic_cast（动态转换）
dynamic_cast 用于将一个 父类对象的指针/引用 转换为 子类对象的指针或引用(动态转换)
在了解什么是 动态转换之前，我们先来了解一下什么是 向上转型 和 向下转型：
比如现在有两个类：
如果是 ptra = ptrb 的话，就是把 子类对象指针 赋值给 父类对象指针，此时就是向上转型，此时就会发生隐式类型转换，父类发生赋值兼容规则，也就是切片，从而可以接收到 子类当中父类那部分的数据。
如果是 ptrb = ptra 的话，就是把 父类对象指针 赋值给 子类对象指针，如果是直接赋值的话是不行的，会报错：
此时我们可以利用 C 当中指针之间可以进行强转的规则，来对 ptra 来进行类型的强转，就可以实现 把 父类对象指针 赋值给 子类对象指针。
这就是向下转型。
但是，向下转型是不安全的。如下例子所示：
class A
{
public:
virtual void f() {}
int _x = 0;
};
class B : public A
{
public:
int _y = 0;
};
void fun(A* pa)
{
B* pb = (B*)pa;
pb->_x++;
pb->_y++;
}
int main()
{
A aa;
fun(&aa);
return 0;
}如上，在 fun（）函数当中，参数类型用的是 A类对象指针，在函数当中，对 传入的 A类对象指针进行了 强制转换，使得 pb 能够接受到 pa。
此时，如果 fun（）函数在外部传入的是一个 B 类对象，那么是没问题的，此时 pa 指针大小就是 8 个字节的大小去访问，pb就可以访问到 pa 当中的_x 成员变量了。因为 pa 此时是B类指针类型，B 类是一个子类，其中是有父类的对象加上子类B自己对象空间，也就是说，在B对象当中是存储得有 A类对象的。那么在 pa 指向的B类对象当中 _x 和 _y 是都有的。
但是fun（）函数在外部传入的是一个 A类对象指针，此时 pa 指针大小就是 4 个字节的大小去访问，此时 pb 就会按照 他的指针指向的类型大小去看，就会访问 8 个字节，但是实际上 pa 指向的类型大小就是 4个字节，此时就是访问越界，那么pa 指向这个A类对象，这个A类对象当中是只有 _x 的，没有 _y 。所以在fun（）函数的当中访问到 _y 就会报错。
如果是 传入 的是一个 A类对象 这种情况，就会发生越界，或者说是找不到 _y 的问题。
此时，我们可以用 dyonamic_cast 来解决问题，他会帮助我们去判断，要转换的类型是处于上述两种情况的哪一种，如果是第一种，那么就可以强制转换，向上述例子就是正常返回地址；如果是第二种不行了，返回一个 nullptr 指针。
所以，此时，就上述例子，我们可以进行一下修改：
void fun(A* pa)
{
// pa是指向子类对象B的，转换可以成功，正常返回地址
// pa是指向父类对象A的，转换失败，返回空指针
B* pb = dynamic_cast(pa);
if (pb)
{
cout << "转换成功" << endl;
pb->_x++;
pb->_y++;
}
else
{
cout << "转换失败" << endl;
}
} 关于 dynamic_cast 是如何实现的，其实是在 对象当中做了标记，我们可以简单的做一些实验，我们把 父类 A当中的 虚函数给变成普通函数，就会编译报错：
不是多态，就说明父类没有虚函数，也就没有虚函数表，只要有虚函数表，dynamic_cast 才能在虚表当中进行标记。在转换 pa 的时候，就会去虚函数表当中去检测 pa 指向的对象是子类还是父类。
在使用 dynamic_cast 转换的话，此时向下转型是安全的了。
RTTI
RTTI：Run-time Type identification的简称，即：运行时类型识别。
顾名思义，就是在运行时，识别某一个变量（对象）的类型。
在 C++ 当中可以用以下的方式支持 RTTI：
typeid运算符（仅仅只能打印，只能看，不能用）：
vector v;
cout << typeid(v).name() << endl; 输出：
class std::vector > dynamic_cast运算符（识别当前要强转的对象是子类还父类）：
// 如上述使用的例子
B* pb = dynamic_cast(pa); decltype，取到某变量，或者某对象的类型，这个类型是可以使用的，我们可以使用这个类型来创建变量，函数传参，函数返回值接收等等操作：