C++强制类型转换之static_cast

//C语言中的一般强转

int main()
{
    float a=5.6;
    int b=5;
    a=(float)b;
    b=(int)a;
    int x=10,y=3;
    
    float c=(float)x/y;
    
    cout<<c<<endl;
    cout<<a<<" "<<b<<endl;
}

C++中的一般强转
在一个方向上可以作隐式转换的，在另外一个方向上可以作静态转换。发生在编译阶段，
不保证后序使用的正确性。 

int main()
{
    float a=5.6;
    int b=5;
    b=static_cast<int>(a);
    a=static_cast<float>(b);
    cout<<b<<" "<<a<<endl;
    int x=10;
    int y=3;
    float z=static_cast<float>(x)/y;
    cout<<z<<endl;
}
dynamic_cast 一种运行时的类型转化方式,所以要在运行时作转换判断。检查指针所指
类型，然后判断这一类型是否与正在转换成的类型有一种 “is a”的关系，如果是，
dynamic_cast 返回对象地址。如果不是，dynamic_cast 返回 NULL。
dynamic_cast 常用多态继承中，判断父类指针的真实指向 
#include <iostream>
#include <typeinfo>

using namespace std;

class A{
public:
    A(){
        cout<<"A(){}"<<endl;
    }
    virtual ~A(){
        cout<<"~A(){}"<<endl;
    }
    virtual void func(){
        cout<<"A::func(){}"<<endl;
    }
};

class B:public A{
public:
    B(){
        cout<<"B(){}"<<endl;
    }
    ~B(){
        cout<<"~B(){}"<<endl;
    }
    void func(){
        cout<<"B::func(){}"<<endl;
    }

};
class C:public A
{
};
class D
{
};
int main()
{
    B b;
    A *pa = &b;

    B *pb = dynamic_cast<B*>(pa); //成功
    cout<<pb<<endl;

    C *pc = dynamic_cast<C*>(pa); //成功 安全 C和A(实指的B类型的b)之间没有直接关系
    if(dynamic_cast<C*>(pa))      //dynamic_cast<C*>(pa)==0
    cout<<pc<<endl;

    D *pd = dynamic_cast<D*>(pa); //成功 安全 D和A也没有关系
    if(dynamic_cast<D*>(pa))
    cout<<pd<<endl;

    pb = static_cast<B*>(pa); //成功
    cout<<pb<<endl;

    pc = static_cast<C*>(pa); //成功 不安全
    cout<<pc<<endl;

    // pd = static_cast<D*>(pa); //编译 不成功
    // cout<<pd<<endl;
    pb = reinterpret_cast<B*>(pa); //成功 不安全
    cout<<pb<<endl;

    pc = reinterpret_cast<C*>(pa); //成功 不安全
    cout<<pc<<endl;

    pd = reinterpret_cast<D*>(pa); //成功 不安全
    cout<<pd<<endl;
    return 0;
}