1.兼容C隐式类型转换和强制类型转换
2.期望不要用了，期望你通用规范的C++显式的强制类型转换
3.static_cast对应隐式类型转换
reinterpret_cast、const_cast对应的是强制类型转换

dynamic_cast用于将一个父类对象的指针/引用转换为子类对象的指针或引用(动态转换)
向上转型：子类对象指针/引用->父类指针/引用(不需要转换，赋值兼容规则)
向下转型：父类对象指针/引用->子类指针/引用(用dynamic_cast转型是安全的)

注意：

1. dynamic_cast只能用于==含有虚函数的类 ==
2. dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回0

子类给父类是向上转换，是C++的一个特例，是赋值兼容的，虽然两个对象的类型不一样，但是所有的类型转换都会产生临时变量

int main()
{int i=0;
    //将i转给临时变量，然后再将这个值给d
    double d=i;
    //临时变量具有常性，所以我们不能直接将i赋值给rd
//    double& rd=i;
    //加上const就可以了
    //c语言的写法
    const double& rd1=i;
    //C++的写法
    const double& rd2=static_cast(i);
}

class A
{public:
    int _a=0;
};
class B:public A{public:
    int _b=0;
};
int main()
{B bb;
    //进行切片，然后转换。
    A aa1=bb;
    A& ra1=bb;
}

父类是不允许转换成子类的，无论是我们上面说的C++中的四个转换中的任何一个都是不可以的。
指针也引用要允许转换！
为什么指针和引用要允许转换（为什么允许指针或者对象向下转换呢？）
因为父类的指针有可能指向父类对象，也有可能指向子类对象。

如果你是一个父类的指针，你原本只能查看四个字节的大小，但是你如果现在能查看8个字节的大小，那么，这就是越界访问了。
（你的父类的指针指向一个子类的对象，但是你如果访问到了子类的部分，你就是越界访问，这是不被允许的）
但是你用dynamic_cast去转换，那么你就是安全的

class A
{public :
    virtual void f(){}
    int _a;
};
class B : public A
{int _b;
};

//A*的指针有可能指向父类，也有可能指向子类，
void fun (A* pa)
{//如果pa指向子类，那么可以转换，重新转换成子类，这种方式是安全的
    //如果pa指向父类，那么不能转换，转换表达式为nullptr
// dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回
    B* pb1 = dynamic_cast(pa);
    cout<<"pb1:"<A a;
    B b;
    fun(&a);
    fun(&b);
    fun(nullptr);
    return 0;
}

如果是static_cast或者c语言的转换的话，可以转换，但是其实已经越界访问了

class A
{public :
    virtual void f(){}
    int _a;
};
class B : public A
{int _b;
};

//A*的指针有可能指向父类，也有可能指向子类，
void fun (A* pa)
{//如果pa指向子类，那么可以转换，重新转换成子类，这种方式是安全的
    //如果pa指向父类，那么不能转换，转换表达式为nullptr
    B* pb1 = static_cast(pa);
    B* pb2=(B*)pa;
    cout<<"pb1:"<A a;
    B b;
    fun(&a);
    fun(&b);
    fun(nullptr);
    return 0;
}

在多继承中的使用情况

class A1
{public :
    virtual void f(){}
    int _a1;
};


class A2
{public :
    virtual void f(){}
    int _a2;
};
class B : public A1,public A2
{public:
    int _b;
};

int main ()
{B bb;
    A1* ptr1=&bb;
    A2* ptr2=&bb;
    cout<(ptr1);
    B* pb6=dynamic_cast(ptr2);
    cout<


它会把我们的指针偏移给修改回去。都会重新指向子类对象的起始位置，不会因为两个不同的父类的指针指向子类的对象而产生不同。

强制类型转换能够将我们的类型转换给规范起来，我们最好去遵守这些规范。

RAII
初始化一个对象。将资源交给这个对象进行管理
（资源获得即初始化）
RTTI（Run_time Type identification）
运行时类型识别
1.typeid运算符，拿到对象的类型的字符串，帮助我们观察
2.dynamic_cast运算符，用来识别父类的指针是指向父类的对象还是指向子类的对象、
3.decltype
推导一个对象类型，可以用来定义另一个对象。