static_cast<目標(biāo)類型>(待轉(zhuǎn)換的值/表達(dá)式)

// 1. 寬轉(zhuǎn)換：無精度丟失（安全）
int a = 10;
double b = static_cast<double>(a); // int → double
// 2. 窄轉(zhuǎn)換：可能丟失精度（需手動(dòng)負(fù)責(zé)）
double pi = 3.14159;
int c = static_cast<int>(pi); // c = 3，double → int
// 3. 字符與整數(shù)轉(zhuǎn)換
char ch = 'A';
int ascii = static_cast<int>(ch); // 字符 → ASCII碼

class Base {
public:
    virtual ~Base() = default;  // 多態(tài)需要虛函數(shù)
    void base_func() {}
};
class Derived : public Base {
public:
    void derived_func() {}
};
// 向上轉(zhuǎn)換（派生類→基類）- 安全
Derived derived;
Base* base_ptr = static_cast<Base*>(&derived);  // 安全，相當(dāng)于隱式轉(zhuǎn)換
// 向下轉(zhuǎn)換（基類→派生類）- 危險(xiǎn)！需要確保類型正確
Base* base = new Derived();
Derived* derived_ptr = static_cast<Derived*>(base);  // 可以，但假設(shè) base 真的指向 Derived
// 錯(cuò)誤使用 - 危險(xiǎn)的向下轉(zhuǎn)換
Base* base2 = new Base();
Derived* derived_ptr2 = static_cast<Derived*>(base2);  // 編譯通過，但運(yùn)行時(shí)會(huì)出錯(cuò)！
// derived_ptr2->derived_func();  // 未定義行為！

int* p = static_cast<int*>(nullptr);
Base* bp = static_cast<Base*>(nullptr);

class MyInt {
public:
    MyInt(int x) : val(x) {} // 單參數(shù)構(gòu)造函數(shù)
private:
    int val;
};
// 用 static_cast 顯式調(diào)用構(gòu)造函數(shù)，完成 int → MyInt 轉(zhuǎn)換
MyInt obj = static_cast<MyInt>(100);

int value = 42;
void* void_ptr = &value;
// void* → 具體類型指針
int* int_ptr = static_cast<int*>(void_ptr);
std::cout << *int_ptr << std::endl;  // 42
// 具體類型 → void*（可以不用 static_cast）
void* void_ptr2 = static_cast<void*>(int_ptr);  // 等價(jià)于 void* void_ptr2 = int_ptr;

class Base { virtual ~Base() = default; };
class Derived : public Base {};
Derived d;
Base& b = d;
// 向下轉(zhuǎn)換引用（不安全）
Derived& d2 = static_cast<Derived&>(b);  // 假設(shè) b 真的引用 Derived
// 如果類型不匹配，會(huì)拋出 std::bad_cast（但 static_cast 不檢查）
// 用 dynamic_cast 會(huì)更安全

Base* base = new Base();
Derived* derived = static_cast<Derived*>(base);  // 編譯通過，但危險(xiǎn)！
derived->derived_func();  // 未定義行為！訪問了不存在的內(nèi)存

const std::string str = "hello";
// std::string* p = static_cast<std::string*>(&str);  // 編譯錯(cuò)誤！

int* ptr = new int(42);
// double* dptr = static_cast<double*>(ptr);  // 編譯錯(cuò)誤！不相關(guān)的指針類型
// 如果想做這種轉(zhuǎn)換，用 reinterpret_cast（但非常危險(xiǎn)）
double* dptr = reinterpret_cast<double*>(ptr);

int address = 0x12345678;
// int* ptr = static_cast<int*>(address);  // 編譯錯(cuò)誤！

// ? C 風(fēng)格 - 不明確
double d = (double)a / b;
// ? static_cast - 意圖明確
double d = static_cast<double>(a) / b;

// ? 危險(xiǎn)
Derived* d = static_cast<Derived*>(base_ptr);
// ? 安全（有運(yùn)行時(shí)檢查）
if (Derived* d = dynamic_cast<Derived*>(base_ptr)) {
    // 使用 d
}

// 明確告訴讀者：我知道可能溢出
int index = static_cast<int>(large_size_t_value);

int x = 10;
// char c = x;  // 可能警告
char c = static_cast<char>(x);  // 明確意圖