C语言中的类型转换
C语言中有两种形式的类型转换，分别是隐式类型转换和显式类型转换：
隐式类型转换：编译器在编译阶段自动进行，能转就转，不能转就编译失败。
显式类型转换：需要用户自己处理，以(指定类型)变量的方式进行类型转换。
需要注意的是，只有相近类型之间才能发生隐式类型转换，比如int和double表示的都是数值，只不过它们表示的范围和精度不同。而指针类型表示的是地址编号，因此整型和指针类型之间不会进行隐式类型转换，如果需要转换则只能进行显式类型转换。比如：
int main()
{
//隐式类型转换
int i = 1;
double d = i;
cout << i << endl;
cout << d << endl;
//显式类型转换
int* p = &i;
int address = (int)p;
cout << p << endl;
cout << address << endl;
return 0;
}我们再补充一点隐式类型转换的知识，来看下面一种场景,我们知道单参数的构造函数也支持隐式类型转换。
class A
{
public:
A(int a)
:_a(a)
{}
private:
int _a;
};
class B
{
public:
B(const A& a)
{}
private:
//....
};
int main()
{
A aa1=1; //支持隐式类型转换
B bb1=aa1; //支持隐式类型转换
return 0;
}A aa1=1这句代码等价于以下两句代码
A tmp(1); //先构造
A aa1(tmp); //再拷贝构造所以在早期的编译器中，当编译器遇到A aa1 = 1这句代码时，会先构造一个临时对象，再用这个临时对象拷贝构造aa1。但是现在的编译器对于“连续的构造加拷贝构造”已经做了优化，当遇到A aa1 = 1这句代码时，会直接按照A aa1(1)的方式进行处理，这也叫做隐式类型转换。
但是加上explicit后，就不会发生隐式类型转换。
class A
{
public:
explicit A(int a)
:_a(a)
{}
private:
int _a;
};
int main()
{
A aa1=1; //会报错，不再支持隐式类型转换
}C风格的转换格式虽然很简单，但也有很多缺点：
1.隐式类型转换在某些情况下可能会出问题，比如数据精度丢失。
2.显式类型转换将所有情况混合在一起，转换的可视性比较差。
因此C++为了加强类型转换的可视性，引入了四种命名的强制类型转换操作符，分别是static_cast、reinterpret_cast、const_cast和dynamic_cast。
C++强制类型转换
static_cast
static_cast用于相近类型之间的转换，编译器隐式执行的任何类型转换都可用static_cast，但它不能用于两个不相关类型之间转换。示例代码如下。
int main()
{
double d = 12.34;
int a = static_cast<int>(d);
cout << a << endl;
int* p = &a;
int address = static_cast<int>(p); //会报错
return 0;
}reinterpret_cast
reinterpret_cast用于两个不相关类型之间的转换，用于将一种类型转换转换为另一种不相关的类型。示例代码如下。
int main()
{
int a = 10;
int* p = &a;
int address = reinterpret_cast<int>(p);
cout << address << endl;
return 0;
}const_cast
const_cast用于删除变量的const属性，转换后就可以对const变量的值进行修改。代码示例如下
int main()
{
const int n = 10;
int* p = const_cast<int*>(&n);
(*p)++;
cout << n << endl; //10
cout << *p << endl; //11
return 0;
}我们发现调试过程中的n的值与最终打印出来的n的值不同
这是由于编译器认为const修饰的变量是不会被修改的，因此会将const修饰的变量存放到寄存器当中，当需要读取const变量时就会直接从寄存器中进行读取，而我们修改的实际上是内存中的n的值，因此最终打印出n的值是未修改之前的值。
如果不想让编译器将const变量优化到寄存器当中，可以用volatile关键字对const变量进行修饰，这时当要读取这个const变量时编译器就会从内存中进行读取，即保持了该变量在内存中的可见性。
int main()
{
volatile const int n = 10;
//const int n = 10;
int* p = const_cast<int*>(&n);
(*p)++;
cout << n << endl; //11
cout << *p << endl; //11
return 0;
}
dynamic_cast
dynamic_cast用于将父类的指针（或引用）转换成子类的指针（或引用）。
向上转换： 子类的指针（或引用）→ 父类的指针（或引用）。
向下转换： 父类的指针（或引用）→ 子类的指针（或引用）。
其中，向上转换就是所说的切割/切片，复制兼容规则，是语法天然支持的，而向下转换需要进行强制类型转换。
向下转换分为两种情况：
- 如果父类的指针（或引用）指向的是一个父类对象，那么将其转换为子类的指针（或引用）是不安全的，因为转换后可能会访问到子类的资源，而这个资源是父类对象所没有的。
- 如果父类的指针（或引用）指向的是一个子类对象，那么将其转换为子类的指针（或引用）则是安全的。
使用dynamic_cast进行向下转换是安全的，如果父类的指针（或引用）指向的是子类对象那么dynamic_cast会转换成功，但如果父类的指针（或引用）指向的是父类对象那么dynamic_cast会转换失败并返回一个空指针。代码示例如下。
class A
{
public:
virtual void f() {}
int _x = 0;
};
class B : public A
{
public:
int _y = 0;
};
void fun(A* pa)
{
// pa是指向子类对象B的，转换可以成功，正常返回地址
// pa是指向父类对象A的，转换失败，返回空指针
B* pb = dynamic_cast<B*>(pa);
if (pb)
{
cout << "转换成功" << endl;
pb->_x++;
pb->_y++;
}
else
{
cout << "转换失败" << endl;
}
}
int main()
{
//父类指针指向父类对象
A aa;
fun(&aa);
//父类指针指向子类对象
B bb;
fun(&bb);
return 0;
}
注意：dynamic_cast只能用于含有虚函数的类，因为运行时类型检查需要运行时的类型信息，而这个信息是存储在虚函数表中的，只有定义了虚函数的类才有虚函数表。
RTTI
RTTI（Run-Time Type Identification）就是运行时类型识别。
C++通过以下几种方式来支持RTTI：
- typeid：在运行时识别出一个对象的类型。
- dynamic_cast：在运行时识别出一个父类的指针（或引用）指向的是父类对象还是子类对象。
- decltype：在运行时推演出一个表达式或函数返回值的类型。