目录
一、内置 转 内置
C++兼容C语言，在内置类型之间转换规则和C语言一样的，C/C++语言因为允许类型转换所以不是类型安全的语言。
隐式转化：编译器识别出类型不同后，能转就转，不能转则报错。
例如：
- int = 'a'
- char = 4
- int = 8.26
除此之外函数调用中形参和实参的类型不同时，编译器会尝试进行隐式转化。
显示转化（强制类型转化）：用户进行指定的显示转换。
例如：
- int = (int)'a'
- char = (char)4
- int = (int)8.26
什么时候能转什么时候不能转呢？
通常有关联性的类型，有转换意义的类型都是可以转化的。比如int类型与double类型，float类型，short类型等，都是描述数字的大小，又或者各种指针类型之间。
又比如int与指针不能隐式转换，因为转化后也是无意义的。但可以显示转化（强制类型转化）。
二、内置 转 自定义
c++中支持内置类型转自定义类型，只需要提供相应的构造函数，就可以想怎么转就怎么转，全在于你的构造函数怎么实现。如下：
using namespace std;
class A
{
public:
A(int x)
:a(x),b(x)
{}
A(int x,int y,int z)
:a(x), b(y+z)
{}
private:
int a;
int b;
};
void fun(A x)
{
//......
}
int main()
{
int v = 10;
A a1 = v;//int类型隐式转化为A类型
A a2 = { 1,2,3 };
fun(6);
return 0;
}- A a1 = v：调用构造函数产生临时对象，然后调用拷贝赋值。逻辑上是这样，但实际上会被编译器优化。
- A a2 = {1,2,3}：通过花括号传入多个参数构造临时对象，然后调用拷贝赋值。
- fun(6)：在函数传参时，同样会隐式转换，不用单独构造出类型后传入，这样就显得方便得多。
在构造函数的函数名前加关键字explicit：不被允许隐式转换，要进行转换需要显示的进行。
三、自定义 转 内置
c++中支持自定义类型转内置类型，提供相应的运算符重载函数（operator），同样可以想怎么转就怎么转，都是自己设定的。
强制类型转化的运算符是()，按理来说应该重载()运算符，但是又与仿函数冲突，所以c++制定了特殊的函数来做类型转化，即：
- operator 类型 ()
该函数不用写返回类型，但在函数名后面需要加目标类型，函数结束也需要return返回。
class A
{
public:
A(int x,int y)
:_a(x),_b(y)
{}
operator int()
{
return _a + _b;
}
private:
int _a;
int _b;
};
int main()
{
A a1 = { 1,3 };
int x = a1;
return 0;
}同样可以使用explicit修饰，修饰后不支持隐式转化。
比如在c++智能指针shared_ptr中使用了operator bool()把指针转换为bool类型来判断指针是否为空，如下：
测试如下：
#include <iostream>
#include <memory>
using namespace std;
int main()
{
shared_ptr<int> p(new int(10));
if (!p)//隐式转换为bool类型
cout << "p为nullptr";
else
cout << "p不为nullptr";
return 0;
}四、自定义 转 自定义
c++中自定义与自定义之间同样可以转换，核心是让构造函数产生临时对象。比如我们要让B类型转换为A类型，我们可以构造这样一个函数：
class A
{
public:
A(int x)
:_a(x),_b(x)
{}
int get_a()
{
return _a;
}
private:
int _a;
int _b;
};
class B
{
public:
B(A x)
:_val(x.get_a())
{}
private:
int _val;
};
int main()
{
A a = 4;
B b = a;
return 0;
}五、类型转换规范化
C 风格的类型转换过于“暴力”，允许许多不安全的转换。C++提供的 显式类型转换运算符来替代传统的 C 风格强制类型转换（如 (int)x）。这种机制的目的是提高代码的 类型安全性、可读性 和 维护性，同时限制不安全的隐式转换。
它有四种类型转换运算符，接下来我们依次来学习。
1.static_case
用于意义相近的转换，比如int与double，char与int，左值与右值，如下：
int main()
{
char ch = 'm';
int x = static_cast<int>(ch);
return 0;
}2.reinterpret_cast
reinterpret_cast用于高风险的类型转换，即意义不相近的类型之间，或各种指针之间的转换，比如int与int*，char*与int*。
int main()
{
int x = 10;
int* p = reinterpret_cast<int*>(x);
return 0;
}3.const_cast
const_cast用来添加/移除const属性的类型间转换，或者添加/移除volatile属性的类型间转换，如下：
int main()
{
volatile const int n = 10;
int* v = const_cast<int*>(&n);//移除const属性
const int& m = const_cast<const int&>(m);//移除volatile属性
return 0;
}4.dynamic_cast
用于基类与派生类之间的类型转换。
派生类转基类也叫切片，天然就可以实现的，但是基类转派生类可能会存在越界访问的问题。用这个关键字可以有效避免。
class Base {
public:
virtual ~Base() {}
};
class Derived : public Base {};
Base* base_ptr = new Base(); // 基类指针指向基类对象
// 尝试向下转型
Derived* derived_ptr = dynamic_cast<Derived*>(base_ptr);
if (derived_ptr == nullptr) {
// 转换失败！
}六、RTTI
RTTI（Runtime Type Information，运行时类型信息） 是 C++ 提供的一种在程序运行时获取对象类型信息的机制。它允许程序在运行时检测对象的实际类型，并支持安全的类型转换（如 dynamic_cast）和类型查询（如 typeid）。
注意：typeid并不是每次都是运行时类型识别。RTTI依赖多态类型，只有类有虚函数时才能体现 。