C++ 新特性 强制转换 static_cast

static_cast

基本等价于隐式转换的一种类型转换运算符，可使用于需要明确隐式转换的地方。

可以用于低风险的转换

• 整型和浮点型
• 字符与整型
• 转换运算符
• 空指针转换为任何目标类型的指针

不可以用于风险较高的转换

• 不同类型的指针之间互相转换
• 整型和指针之间的互相转换
• 不同类型的引用之间的转换

#include <iostream>
#include <string>

class CInt {
public:
    operator int () {
        return m_nInt;
    }

    int m_nInt;
};

int main() {
    int n = 5;
    float f = 10.0f;
    double dbl = 1.0;

    // 本质上，发生了隐式转换
    f = n;

    // static_cast
    f = static_cast<float>(n);

    // 低风险的转换：
    // 整型与浮点型
    n = static_cast<float>(dbl);

    // 字符与整型
    char ch = 'a';
    n = static_cast<int>(ch);

    // void*指针的转换
    void *p = nullptr;
    int *pN = static_cast<int*>(p);

    // 转换运算符的方式
    CInt nObj;
    int k = static_cast<int>(nObj);

    // 高风险二点转换
    int kk;
    char* p;
    // 整型与指针类型转换
    p = kk; // 转不了
    char *q = static_cast<char*>(kk); // 也不行


    int *pK;
    char *w = pK;  // 不行
    w = static_cast<char*>(pK); // 不允许

}

static_cast 用于基类与派生类的转换过程中，但是没有运行时类型检查

class CFather {
public:
    CFather() {
        m_nTest = 3;
    }
    
    virtual void foo() {
        std::cout << "CFather()::void foo()" << std::endl;
    }

    int m_nTest;

};

class CSon : public CFather {
    virtual void foo() {
        std::cout << "CSon::void foo()" << std::endl;
    }
};

int main() {
    CFather* pFather = nullptr;
    CSon* pSon = nullptr;

    // 父类转子类 （不安全）
    // pSon = pFather; // 通过不了
    pSon = static_cast<CSon*>(pFather); // 不安全，没有提供运行时的检测

    // 子类转父类 （安全）

    // pFather = pSon;
    // pFather = static_cast<CFather*>(pSon);
sq1s
}