在C++編程的奇妙世界里，類型轉換就像是一位默默工作卻至關重要的幕后英雄，在各種編程場景中頻繁登場。想象一下，你在處理數據時，常常會遇到這樣的情況：一個函數期望接收某種特定類型的參數，但你手頭的數據卻是另一種類型。這時候，類型轉換就派上用場了，它能巧妙地將數據從一種類型轉換為另一種類型，讓程序得以順利運行 。

在 C++ 中，有四種類型轉換方式，它們各自有著獨特的 “本領” 和適用場景，就像工具箱里不同功能的工具，在不同的編程需求下發揮關鍵作用。接下來，就讓我們深入了解這四位 “得力干將”，掌握它們的使用技巧，以便在 C++ 編程中更加游刃有余。

Part1.static_cast：安全可控的常規轉換

1.1語法與基本用法

static_cast是 C++ 中較為常用的類型轉換方式，其語法格式為：static_cast<目標類型>(表達式) 。它就像是一個溫和的 “轉換器”，主要用于具有明確定義的類型轉換，只要是編譯器隱式執行的類型轉換，基本都可以使用static_cast來顯式地完成 。

在基本類型轉換中，static_cast大顯身手。比如，將int類型轉換為float類型：

int num = 10;
float f_num = static_cast<float>(num);

這里，static_cast把整數10平穩地轉換為了浮點數10.0 ，在這個過程中，編譯器會按照既定的規則處理數值轉換的細節，比如可能會涉及精度的調整，但整體轉換是安全且符合預期的。又比如，將double類型轉換為int類型時，小數部分會被舍棄 ：

double d_num = 10.5;
int i_num = static_cast<int>(d_num);

經過轉換，i_num的值為10，小數部分.5被舍去，這也是static_cast在基本類型轉換中遵循的常規規則。

1.2類類型轉換

在類類型轉換的領域里，static_cast也有著獨特的作用。在類的繼承體系中，它可以實現基類指針與派生類指針之間的轉換，以及基類引用與派生類引用之間的轉換 。不過，這里面的門道可不少，使用時得格外小心。

當進行上行轉換，也就是把子類的指針或引用轉換成基類表示時，static_cast是安全可靠的。因為派生類對象天生包含了基類對象的所有成員，這種轉換就像是給一個更豐富的對象穿上了一件更基礎的 “外衣”，不會丟失任何關鍵信息 。例如：

class Animal {
public:
    virtual void speak() {
        std::cout << "Animal speaks" << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {
        std::cout << "Dog barks" << std::endl;
    }
};

Dog dog;
Animal* animal_ptr = static_cast<Animal*>(&dog);

在這段代碼中，Dog類繼承自Animal類，通過static_cast將Dog對象的指針轉換為Animal類指針animal_ptr，這個過程沒有任何風險，animal_ptr可以正常調用Animal類的成員函數 。

然而，當進行下行轉換，把基類指針或引用轉換成子類表示時，情況就變得復雜起來。因為基類對象可能并不包含派生類對象特有的所有成員，如果盲目地使用static_cast進行轉換，就好比讓一件基礎的 “外衣” 去冒充更豐富的對象，可能會導致未定義行為，就像在黑暗中摸索，充滿了不確定性 。比如：

Animal* animal = new Animal();
Dog* dog_ptr = static_cast<Dog*>(animal);

這里，animal實際上指向的是一個Animal對象，并非Dog對象，使用static_cast將其轉換為Dog*類型的指針dog_ptr，這是非常危險的行為，當后續通過dog_ptr調用Dog類特有的成員函數時，極有可能引發程序崩潰或其他不可預測的錯誤 。所以，只有在確?；愔羔槾_實指向派生類對象的情況下，才可以謹慎地使用static_cast進行下行轉換 。

1.3特點與局限性

static_cast可以進行一些相關類型之間的轉換，并且能夠在編譯期發現一些明顯的類型轉換錯誤，這是它的優點。但它也存在局限性，它無法進行運行時的類型檢查，這就意味著對于一些在運行時才能確定的類型轉換錯誤，static_cast無能為力。另外，static_cast不能轉換掉表達式的const、volatile等屬性。例如，不能使用static_cast將一個const int類型轉換為int類型來去除常量性，如果要去除常量性，需要使用const_cast。

Part2.dynamic_cast：多態世界的安全使者

2.1適用場景與前提條件

dynamic_cast是 C++ 中用于在運行時進行類型轉換的運算符，它的語法形式為dynamic_cast<目標類型>(表達式) 。這里的 “運行時” 是其與static_cast最大的區別之一，這意味著類型轉換的檢查和操作在程序運行時才進行。并且，dynamic_cast主要用于類層次結構中的指針或引用的類型轉換，其目標類型必須是類的指針、類的引用或者void*。如果目標類型是類指針類型，那么表達式也必須是一個指針；如果目標類型是一個引用，那么表達式也必須是一個引用 。

不過，dynamic_cast的工作有一個重要前提條件，那就是基類必須包含虛函數 。這是因為dynamic_cast依賴于運行時類型信息（RTTI，Run-Time Type Information）來判斷轉換的安全性，而虛函數正是觸發 RTTI 機制的關鍵因素 。當一個類包含虛函數時，編譯器會為該類生成一個虛函數表（vtable），對象中會包含一個指向這個虛函數表的指針（vptr），通過這個機制，dynamic_cast才能在運行時準確地獲取對象的實際類型信息，從而判斷轉換是否可行 。如果基類沒有虛函數，編譯器就不會生成必要的類型信息，dynamic_cast也就無法正常工作 ，這就好比在黑暗中沒有燈塔指引，船只很容易迷失方向 。

2.2運行時檢查機制

dynamic_cast最顯著的特點之一，就是它在運行時進行類型檢查，這與static_cast在編譯時檢查形成了鮮明對比 。在運行時，dynamic_cast會仔細檢查源對象的實際類型是否與目標類型兼容 。對于指針類型的轉換，如果轉換失敗，也就是源指針所指向的對象實際上并不是目標派生類類型，dynamic_cast會返回空指針（nullptr） ，這就像是給程序員發出了一個明確的信號：此次轉換不可行，需要謹慎處理后續操作 。例如：

class Animal {
public:
    virtual void speak() {
        std::cout << "Animal speaks" << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {
        std::cout << "Dog barks" << std::endl;
    }
};

class Cat : public Animal {
public:
    void speak() override {
        std::cout << "Cat meows" << std::endl;
    }
};

int main() {
    Animal* animal = new Cat();
    Dog* dog_ptr = dynamic_cast<Dog*>(animal); 
    if (dog_ptr == nullptr) {
        std::cout << "The conversion from Animal to Dog failed." << std::endl;
    }
    delete animal;
    return 0;
}

在這段代碼中，animal指針實際指向的是一個Cat對象，當使用dynamic_cast嘗試將其轉換為Dog*類型指針時，由于animal指向的對象并非Dog類型，轉換失敗，dog_ptr被賦值為nullptr，通過后續的if語句檢查，我們可以得知轉換失敗的情況 。

對于引用類型的轉換，情況稍有不同 。因為不存在空引用，所以當轉換失敗時，dynamic_cast會拋出std::bad_cast異常 。這就要求程序員在使用引用類型的dynamic_cast時，要使用try - catch塊來捕獲可能拋出的異常，以確保程序的穩定性 。比如：

void processAnimal(const Animal& animal) {
    try {
        const Dog& dog_ref = dynamic_cast<const Dog&>(animal);
        dog_ref.speak(); 
    } catch (const std::bad_cast& e) {
        std::cout << "Caught bad_cast exception: " << e.what() << std::endl;
    }
}

在這個函數中，processAnimal接收一個Animal類的引用，然后嘗試使用dynamic_cast將其轉換為Dog類的引用 。如果轉換失敗，就會拋出std::bad_cast異常，在catch塊中，我們捕獲并處理這個異常，輸出相應的錯誤信息 ，避免程序因為異常未處理而崩潰 。

2.3示例展示

下面通過一個更完整的示例，來進一步展示dynamic_cast的用法和特性 ：

#include <iostream>

class Shape {
public:
    virtual void draw() {
        std::cout << "Drawing a shape" << std::endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a circle" << std::endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a rectangle" << std::endl;
    }
};

void processShape(Shape* shape) {
    Circle* circle_ptr = dynamic_cast<Circle*>(shape);
    if (circle_ptr) {
        std::cout << "It's a circle, and now drawing it:" << std::endl;
        circle_ptr->draw(); 
    } else {
        Rectangle* rectangle_ptr = dynamic_cast<Rectangle*>(shape);
        if (rectangle_ptr) {
            std::cout << "It's a rectangle, and now drawing it:" << std::endl;
            rectangle_ptr->draw(); 
        } else {
            std::cout << "Unrecognized shape type." << std::endl;
        }
    }
}

int main() {
    Shape* shape1 = new Circle();
    Shape* shape2 = new Rectangle();

    std::cout << "Processing shape1:" << std::endl;
    processShape(shape1);

    std::cout << "Processing shape2:" << std::endl;
    processShape(shape2);

    delete shape1;
    delete shape2;

    return 0;
}

在這個示例中，Shape是基類，Circle和Rectangle是它的派生類 。processShape函數接收一個Shape*類型的指針，通過dynamic_cast分別嘗試將其轉換為Circle*和Rectangle*類型的指針 。如果轉換成功，就可以調用相應派生類的draw函數，繪制出對應的圖形；如果轉換失敗，就會給出相應的提示 。在main函數中，我們分別創建了Circle和Rectangle對象，并將它們傳遞給processShape函數進行處理 ，從輸出結果中可以清晰地看到dynamic_cast在不同情況下的表現 。

通過以上的介紹和示例，我們可以看到dynamic_cast在處理多態類型轉換時的嚴謹和安全，它為程序員在復雜的類繼承體系中進行類型轉換提供了可靠的保障 。

Part3.const_cast：const 屬性的操控者

3.1去除 const 屬性

const_cast在 C++ 類型轉換中扮演著獨特的角色，它主要用于處理const屬性的轉換 ，就像是一位專門處理常量限定的 “管家”，有著特殊的職責和使命 。其語法格式為：const_cast<目標類型>(表達式) ，這里的 “目標類型” 是去除或添加const屬性后的類型，“表達式” 則是需要進行轉換的對象 。

const_cast最常見的用途之一，是將const對象轉換為非const對象，從而允許對原本被視為常量的對象進行修改 。在某些特定的編程場景中，我們可能會遇到這樣的情況：一個對象在大多數時候應該保持常量的性質，以確保數據的安全性和穩定性，但在個別特殊情況下，又需要對其進行修改 。這時候，const_cast就派上用場了 。例如：

const int num = 10;
int* modifiable_num = const_cast<int*>(&num); 
*modifiable_num = 20;

在這段代碼中，num最初被聲明為const類型的整數，其值被固定為10 。通過const_cast，我們將指向num的const int*類型指針轉換為int*類型指針modifiable_num，這樣就去除了const屬性的限制 。隨后，我們可以通過modifiable_num對num的值進行修改，將其改為20 。不過，這里需要特別提醒的是，這種修改const對象的操作存在一定風險 。

因為const對象在設計上通常是不希望被修改的，修改const對象可能會導致未定義行為，比如在一些編譯器或運行環境下，可能會引發程序崩潰、數據錯誤等問題 。所以，在使用const_cast去除const屬性時，一定要慎之又慎，確保這種修改是合理且必要的 。

3.2添加 const 屬性

除了去除const屬性，const_cast還可以用于將非const對象指針轉換為const對象指針，也就是添加const屬性 。雖然這種用法相對較少，但在某些特定的編程需求下，也能發揮重要作用 。比如，當我們需要將一個非const對象傳遞給一個期望接收const對象指針的函數時，就可以使用const_cast進行轉換 。例如：

int value = 10;
const int* const_ptr = const_cast<const int*>(&value);

在這個例子中，value是一個普通的非const整數變量 。通過const_cast，我們將指向value的int*類型指針轉換為const int*類型指針const_ptr，為指針添加了const屬性 。這樣，const_ptr指向的value在使用上就被視為const對象，不能通過const_ptr對value進行修改 。這種轉換在函數參數傳遞、接口適配等場景中，能夠確保數據在特定的函數或模塊中保持常量性，避免意外的修改 。

3.3注意事項

在使用const_cast時，有一些關鍵的注意事項需要牢記 。一定要確保通過const_cast去除const屬性后進行修改的對象，本身在內存層面是可修改的 。如果對象本身是真正的常量，存儲在只讀內存區域或者編譯器對其進行了常量優化，那么使用const_cast修改它將會導致未定義行為，就像在薄冰上行走，隨時可能陷入危險 。比如前面提到的對const對象的修改，如果const對象是在只讀內存中，修改操作可能會引發程序異常 。

const_cast和static_cast在功能上有明顯的區別 。static_cast主要用于常規的類型轉換，如基本類型之間的轉換、類類型的上行和下行轉換等，它不會涉及到const屬性的處理 。而const_cast則專注于const屬性的去除和添加，是專門為處理常量限定而設計的 。在實際編程中，要根據具體的轉換需求，準確地選擇使用const_cast還是static_cast，避免混淆使用導致錯誤 。例如，當需要進行基本類型轉換時，應使用static_cast；而當需要處理const屬性轉換時，就應該使用const_cast 。

Part4.reinterpret_cast：底層世界的探險家

4.1指針類型轉換

reinterpret_cast堪稱 C++ 類型轉換中的 “底層探險家”，它有著獨特而強大的能力，主要用于執行底層的、與實現相關的類型轉換 ，就像是一把能夠打開底層世界大門的神秘鑰匙 。其語法格式為：reinterpret_cast<目標類型>(表達式) ，通過這個格式，它可以在幾乎任意類型的指針之間進行轉換，這種轉換的靈活性和底層性是其他類型轉換方式難以比擬的 。

在指針類型轉換的場景中，reinterpret_cast可以將一種類型的指針轉換為另一種看似毫無關聯的指針類型 。例如，將int*類型的指針轉換為char*類型的指針 ：

int num = 10;
int* int_ptr = #
char* char_ptr = reinterpret_cast<char*>(int_ptr);

在這個例子中，int_ptr原本指向一個int類型的變量num，通過reinterpret_cast，它被轉換為了char*類型的指針char_ptr 。這里需要特別注意的是，這種轉換僅僅是對指針所指向的內存地址的重新解釋，并不會改變內存中數據的實際內容 。也就是說，char_ptr現在指向的內存地址與int_ptr相同，但編譯器會按照char類型的方式來解讀這塊內存 。

如果后續通過char_ptr去訪問內存，就會按照char類型的大?。ㄍǔ?1 字節）來讀取數據 ，這與按照int類型（通常為 4 字節或 8 字節，取決于系統架構）讀取數據的方式截然不同 。又比如，在處理函數指針時，reinterpret_cast也能發揮作用 ：

int add(int a, int b) {
    return a + b;
}
void (*func_ptr)() = reinterpret_cast<void(*)()>(add);

這里，add是一個返回int類型、接收兩個int類型參數的函數 。通過reinterpret_cast，將其轉換為了一個無返回值、無參數的函數指針func_ptr 。這種轉換同樣是基于底層的重新解釋，在實際使用func_ptr時，如果調用它，由于函數簽名（參數和返回值類型）不一致，很可能會導致未定義行為 ，就像駕駛一輛經過改裝但不符合安全標準的汽車，充滿了不確定性 。

4.2指針與整數轉換

reinterpret_cast還可以在指針和足夠大的整數類型之間相互轉換，這在處理一些底層的內存操作、與硬件交互或特定的算法實現時非常有用 。通常，我們會使用std::uintptr_t或std::intptr_t這樣專門為存儲指針值而設計的整數類型 。例如，將指針轉換為整數 ：

int value = 100;
int* ptr = &value;
std::uintptr_t int_value = reinterpret_cast<std::uintptr_t>(ptr);

在這段代碼中，ptr是指向int類型變量value的指針，通過reinterpret_cast將其轉換為std::uintptr_t類型的整數int_value ，此時int_value中存儲的是ptr的內存地址值 。反過來，也可以將整數轉換回指針 ：

int* new_ptr = reinterpret_cast<int*>(int_value);

這樣，new_ptr就指向了與ptr相同的內存地址，通過new_ptr訪問內存就可以獲取到value的值 。不過，在進行這種指針與整數的轉換時，一定要確保整數類型的大小足夠容納指針值 。如果整數類型過小，可能會導致數據截斷，丟失部分地址信息，從而使轉換后的指針指向錯誤的內存位置，引發程序崩潰或其他嚴重錯誤 ，就像用一個小杯子去裝大瓶子里的水，水會溢出來 。

4.3風險與適用場景

雖然reinterpret_cast提供了強大的底層轉換能力，但它也伴隨著較高的風險 。由于這種轉換幾乎不進行任何類型檢查，完全是基于底層的二進制位重新解釋，所以如果使用不當，很容易導致未定義行為 。例如，將一個指向double類型的指針轉換為指向int類型的指針，然后直接解引用該int指針，就可能會讀取到錯誤的數據，甚至引發程序崩潰 ，因為double和int在內存中的存儲方式和大小都不同 。

reinterpret_cast通常適用于一些特定的場景 。在與底層硬件交互時，可能需要將指針轉換為特定的整數類型，以便與硬件寄存器或內存映射地址進行交互 。在處理 C 風格的代碼時，有時也需要使用reinterpret_cast來實現與 C 語言的兼容性 。在一些底層庫的實現中，為了追求極致的性能和對內存的精確控制，也會合理地使用reinterpret_cast 。但在使用時，一定要充分了解底層原理，確保轉換的安全性，并且在代碼中添加詳細的注釋，說明使用reinterpret_cast的原因和目的，以便其他開發者能夠理解和維護代碼 。

Part5.四者之間的區別

在 C++ 中，static_cast、dynamic_cast、const_cast和reinterpret_cast四種類型轉換方式各有其獨特用途和行為特性，理解它們之間的區別是寫出安全高效代碼的關鍵。

（1）轉換時機與檢查方式不同

（2）適用場景的本質差異

• static_cast：適用于 "邏輯上合理" 的類型轉換，如基本類型轉換、相關類層次間的轉換
• dynamic_cast：專為多態場景設計，僅用于類層次結構中基類與派生類之間的安全轉換
• const_cast：唯一能修改表達式 const 或 volatile 屬性的轉換方式
• reinterpret_cast：用于低層次的類型重新解釋，如指針與整數互轉、不相關類型的指針轉換

（3）安全性與風險等級

（4）對多態的支持差異

• dynamic_cast：必須依賴多態（基類包含虛函數）才能正常工作
• static_cast：可以用于類層次轉換，但不檢查對象的實際類型
• const_cast和reinterpret_cast：不涉及多態相關的類型檢查

在C++ 中，四種類型轉換各有明確分工：static_cast用于編譯期的合理轉換，dynamic_cast負責運行期的安全多態轉換，const_cast 專門處理 const 屬性的修改，reinterpret_cast 則是底層的暴力重解釋轉換。選擇轉換方式時，應遵循 "最小權限原則"：能用更安全的轉換方式就不要選擇風險更高的，這是寫出健壯 C++ 代碼的重要原則。

Part6.實際應用案例

6.1簡單類層次結構轉換

#include <iostream>

class Animal {
public:
    virtual void speak() {
        std::cout << "Animal is speaking" << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {
        std::cout << "Dog says woof" << std::endl;
    }
};

int main() {
    Dog dog;
    Animal* animalPtr = &dog; 

    // static_cast 上行轉換
    Animal* staticUpcastPtr = static_cast<Animal*>(&dog); 
    staticUpcastPtr->speak(); 

    // static_cast 下行轉換（不安全）
    Dog* staticDowncastPtr = static_cast<Dog*>(animalPtr); 
    staticDowncastPtr->speak(); 

    // dynamic_cast 上行轉換
    Animal* dynamicUpcastPtr = dynamic_cast<Animal*>(&dog); 
    dynamicUpcastPtr->speak(); 

    // dynamic_cast 下行轉換（安全）
    Dog* dynamicDowncastPtr = dynamic_cast<Dog*>(animalPtr); 
    if (dynamicDowncastPtr) {
        dynamicDowncastPtr->speak(); 
    } else {
        std::cout << "dynamic_cast 下行轉換失敗" << std::endl;
    }

    return 0;
}

在這個案例中，static_cast和dynamic_cast在上行轉換時都能正常工作，因為上行轉換是安全的，派生類對象必然包含基類的所有成員。但在下行轉換時，static_cast沒有運行時類型檢查，即使animalPtr實際指向的是Dog對象，但如果animalPtr指向的是其他類型的對象，就會產生未定義行為。而dynamic_cast會在運行時檢查對象的實際類型，若轉換成功則可以安全地調用派生類的方法，若失敗則返回nullptr，避免了未定義行為 。

6.2復雜多態場景應用

#include <iostream>
#include <vector>

class Shape {
public:
    virtual void draw() {
        std::cout << "Drawing a shape" << std::endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a circle" << std::endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a rectangle" << std::endl;
    }
};

void processShape(Shape* shape) {
    Circle* circlePtr = dynamic_cast<Circle*>(shape);
    if (circlePtr) {
        // 執行針對Circle的操作
        circlePtr->draw();
    } else {
        Rectangle* rectanglePtr = dynamic_cast<Rectangle*>(shape);
        if (rectanglePtr) {
            // 執行針對Rectangle的操作
            rectanglePtr->draw();
        } else {
            // 其他操作
            shape->draw();
        }
    }
}

int main() {
    std::vector<Shape*> shapes;
    shapes.push_back(new Circle());
    shapes.push_back(new Rectangle());

    for (Shape* shape : shapes) {
        processShape(shape);
    }

    for (Shape* shape : shapes) {
        delete shape;
    }

    return 0;
}

在這個復雜多態場景中，processShape函數接收一個Shape指針，它可能指向Circle或Rectangle對象。使用dynamic_cast可以在運行時根據實際對象類型進行安全轉換，并執行相應的操作。如果使用static_cast，由于無法在運行時確定對象的實際類型，很可能會將指針錯誤地轉換為不匹配的類型，從而導致程序出現錯誤 。

Part7.高頻面試題解析

問題1：請說出 C++ 中的四種類型轉換操作符。

答案：C++ 的四種類型轉換操作符分別為 static_cast、dynamic_cast、const_cast 和 reinterpret_cast。

問題2：static_cast 的主要用途有哪些？

答案：常用于基本數據類型間的轉換，如 int 轉 float；也適用于有繼承關系類間的向上轉換，即將派生類指針或引用轉成基類指針或引用等，其在編譯階段執行轉換。

問題3：為什么 dynamic_cast 要求基類必須包含虛函數？

答案：因為 dynamic_cast 依靠運行時類型信息（RTTI）判斷轉換合法性。只有基類定義了虛函數，編譯器才會為其添加 RTTI 信息供 dynamic_cast 在運行時利用。

問題4：dynamic_cast 轉換指針類型失敗時會怎樣？轉換引用類型失敗呢？

答案：指針轉換失敗返回空指針。轉換引用時失敗會拋出 std::bad_cast 異常。

問題5：const_cast 只能修改指針或引用的 const 屬性嗎？

答案：是的，const_cast 主要是去除或添加指針或引用的 const 限定符，不能改變變量本身的類型。

問題6：使用 const_cast 去除 const 屬性后修改對象，會有什么風險？

答案：若修改了本不應更改的成員變量等，違背常量語義，易引發程序未定義行為。

問題7：reinterpret_cast 的典型應用場景與風險是什么？

答案：常被用于不相關類型間轉換，像指針轉整數或不同指針類型互轉等。它基本不做類型檢查，按二進制重解釋數據，易致非法內存訪問，使用需慎重。

問題8：能否用 reinterpret_cast 實現去除變量的 const 屬性？

答案：不能。去除 const 屬性是 const_cast 的功能，reinterpret_cast 不能處理 const 屬性修改，使用它嘗試去除 const 會編譯報錯。

問題9：編譯期可判斷的類型轉換，能否優先選 static_cast 而不是 dynamic_cast？

答案：是的。編譯期可確定安全的轉換，用 static_cast 更合適。其無需運行時類型檢查開銷，dynamic_cast 需額外運行時成本，更適合依賴對象實際運行時類型判斷轉換安全的場景。

問題10：static_cast 做向下轉型（基類轉派生類）安全嗎？

答案：不安全。static_cast 向下轉型不做運行時類型校驗。若基類指針未實際指向派生類對象卻轉成派生類指針，后續訪問派生類特有成員易觸發未定義行為。

問題11：C 風格強制轉換和 C++ 四種類型轉換有何不同？

答案：C 風格強制轉換可視性差，各種轉換均用相同語法。C++ 四種類型轉換明確區分不同轉換場景，讓轉換目的清晰，編譯器可做針對性檢查，助于減少錯誤。

問題12：子類轉基類的向上轉型，是否一定需用 static_cast？

答案：不一定。向上轉型語法天然支持，常無需顯式轉換。使用 static_cast 可讓轉型意圖更明確，同時在部分需嚴格類型匹配處可輔助編譯。

問題13：能否用 dynamic_cast 對無繼承關系的自定義類型指針轉換？

答案：不能。dynamic_cast 通常針對有繼承或多態關聯的類指針或引用的轉換，非繼承關系的自定義類型不適用。

問題14：將 float 轉成 int，該用哪種類型轉換更合適？

答案：用 static_cast 合適。它能有效處理如 float、int 等相近基本數據類型間的合理轉換。

問題15：多繼承下，dynamic_cast 對基類指針向下轉型時，如何確定轉換至哪個派生類版本？

答案：dynamic_cast 依對象實際運行時類型與轉換目標類型，參照 RTTI 數據匹配。若對象實際類型與目標派生類相符或可兼容向上轉換至目標類型，則轉換至對應派生類指針或引用。

問題16：轉換類型時，C++ 風格類型轉換是否可替代所有 C 風格類型轉換？

答案：多數場景能替代。C++ 類型轉換增強了可視性與安全性。但 C++ 兼容 C，特定需兼容舊 C 代碼或極簡代碼場景，C 風格轉換仍能使用。

問題17：為何說 static_cast 類似 C 風格隱式類型轉換？

答案：編譯器隱式做的類型轉換，基本都能用 static_cast 顯式執行。其功能和 C 風格隱式轉換相近，但 static_cast 明確展現意圖，規避隱式轉換的隱蔽性，且限制了如指針轉不相關類型指針等不合理的轉換。

問題18：若一個類無虛函數，卻想向下轉型，能用什么替代 dynamic_cast？

答案：可在類內自定義判斷邏輯，或利用其他標識字段于運行時判斷對象真實類型后，用 static_cast 轉換。不過，其安全性需開發者確保，不像 dynamic_cast 有內建的運行時安全檢查。

問題19：用 const_cast 修改 volatile 變量的屬性可以嗎？

答案：可以。const_cast 除修改 const 屬性，也可處理變量的 volatile 屬性。

問題20：從性能角度分析，哪種類型轉換開銷通常最小，哪種最大？

答案：通常 static_cast 開銷最小，因其編譯期完成，無運行時額外判斷成本。dynamic_cast 開銷常最大，其依賴運行時查詢虛函數表等獲取 RTTI 做類型校驗等操作。