c++——四种强转方式 static_cast dynamic_cast const_cast reinterpret_cast

不常用 但是很有趣

//c++强转
    //4中强转的方式
        //用c++强转有什么好处：：代码比较清晰

 

//1.static_cast 和 C 的强转差不多，运行时没有类型检查来确保安全性
    class CA
    {
        int a;
    public:
        CA(int i){ a = i; }
        void run(){ printf("%d\n", a); }
    };
    class CB :public CA
    {
        int b;
    public:
        CB(int i) :CA(i){ b = 4; }
        void run(){ printf("%d", b); }
    };
    void main()
    {
        //===============================================
        float f = 1.45f;
        int i = 0; 
        i = (int)f;  // 1
        //------------------------------------------------
        i = static_cast<int>(f);    // 1
        //===============================================

        //===============================================
        CA a(1), *pa;
        CB b(10), *pb;
        pa = &a;    pa->run();    // 1
        pb = &b;    pb->run();    // 4
        pa = &b;    pa->run();    // 10
        //未知值（把a强转为CB类型，会多出来未知的CB部分，pb所访问的就是那未知部分）很危险，一般不会写
        pb = (CB*)&a; pb->run();
        //------------------------------------------------
        CA a(1), *pa;
        CB b(10), *pb;
        pa = &a;    pa->run();    // 1
        pb = &b;    pb->run();    // 4
        pa = &b;    pa->run();    // 10
        //未知值（把a强转为CB类型，会多出来未知的CB部分，pb所访问的就是那未知部分）很危险，一般不会写
        pb = static_cast<CB *>(&a); pb->run();
        //===============================================

    }

    class CA
    {
        int a;
    public:
        CA(){ a = 10; }
        int getCA() const{ return a; }
    };
    class CB
    {
        int b;
        int c;
    public:
        CB(){ b = 20; c = 30; }
        int getCB() const { return b; }
    };
    void main()
    {
        CA a;
        CB *pb;
        pb = (CB*)&a;        //只要CB比CA大，解析方式一致(访问内存的方式)（int a; // int b;）就可以
        printf("%d\n", pb->getCB()); // 10
    }

 

 

    //2.dynamic_cast,在多态的时候会去检查类型是否安全，且类中最少要有一个虚函数
    class CA
    {
        int a;
    public:
        int m;
        CA(int i) { a = i; }
        virtual void run() { printf("%d\n", a); }
    };

    class CB : public CA
    {
        int b;
    public:
        CB(int i) :CA(i) { b = 4; }
        void run() { printf("%d\n", b); }
    };
    void main()
    {
        CA a(1), *pa;
        CB b(10), *pb;
        pa = &a;    pa->run();    // 1
        pb = &b;    pb->run();    // 4
        pa = &b;    pa->run();    // 4
        //报错，dynamic_case 检查是否安全，pb是一个空指针，不可以访问
        pb = dynamic_cast<CB*>(&a); pb->run();
    }

 

 

    

    //3.const_cast,常量指针转成非常量指针，常量引用转成非常量引用，常量对象转成非常量对象
    int a = 10;
    const int *p = &a;
    *p = 20;  //error 不可以
    //------------------------------------------------------
    int a = 10;
    int b = 20;
    const int *p = &a;
    p = &b;  //可以的
    //------------------------------------------------------
    //如果非要改：
    int a = 10;
    int b = 20;
    const int *p = &a;
    int *p1 = (int*)p;  //p 之前为const int* 类型，现在强转重新定义为int *类型
    //----------------
    int *p1 = const_cast<int*>(p); 
    *p1 = 50; 

    CA a(1);
    CA const&h = a;
    h.run();    //run函数为非const类型， 不对
    h.m = 100;    //m为共有变量，因为h为const& ,所以也不对
    //-----------若要实现-----------
    CA &mh = const_cast<CA &>(h);
    mh.m = 100;

 

    //4.reinterpret_cast 把数据的二进制形式重新解释，不改变值
    //比如：把一个指针强行转化为一个整型变量，把一个整型变量强行认为是一个首地址
    int *p = 10;//错的 因为10的位置应该为地址
    //------------------
    int *p = reinterpret_cast < int *(10);
    //数据的二进制形式，当成地址 10：：00001010