C++ 面向對象三大支柱：封裝、繼承、多態 深度解析與工程實踐

一、封裝 — 數據與行為的有機結合

核心定義

將**數據 (屬性)** 與**操作數據的函數 (方法)** 綁定在一起，形成 **類**。通過訪問控制 (`public`/`protected`/`private`) 隱藏內部實現細節，對外暴露穩定介面。

三大訪問級別語義

封裝收益

• 安全性：防止外部隨意修改內部狀態，通過 setter 驗證約束
• 解耦：內部實現變更 (如數據結構優化) 不影響調用者
• 簡化介面：使用者只需知道「做什麼」，不必知道「怎麼做」
• 不變量維護：構造函數建立、析構函數清理、方法保證狀態一致性

代碼示範

class BankAccount {
    // 內部實現完全隱藏
    std::string m_owner;
    int64_t m_balance_cents; // 用分存儲，避免浮點誤差
    std::mutex m_mutex;      // 線程安全內部實現細節

public:
    // 穩定介面
    BankAccount(std::string owner, int64_t initial_cents)
        : m_owner(std::move(owner)), m_balance_cents(initial_cents) {}

    // 只讀介面
    std::string owner() const { return m_owner; }
    double balance() const { return m_balance_cents / 100.0; }

    // 受控修改介面
    bool deposit(int64_t cents) {
        if (cents <= 0) return false;
        std::lock_guard lock(m_mutex);
        m_balance_cents += cents;
        return true;
    }
    bool withdraw(int64_t cents) {
        if (cents <= 0) return false;
        std::lock_guard lock(m_mutex);
        if (m_balance_cents < cents) return false;
        m_balance_cents -= cents;
        return true;
    }
};

二、繼承 — 類型層次與代碼復用

繼承語義分類

訪問控制實戰演示

class Base {
public:    int a; void pubFunc() {}
protected: int b; void proFunc() {}
private:   int c; void priFunc() {}
};

class DerivedPublic : public Base {
    void test() {
        a = 1; pubFunc(); // ✅
        b = 2; proFunc(); // ✅
        // c = 3; priFunc(); // ❌ 編譯錯誤
    }
};

class DerivedPrivate : private Base {
    void test() {
        a = 1; pubFunc(); // ✅ (但在 DerivedPrivate 外部不可訪問)
        b = 2; proFunc(); // ✅
        // c = 3; priFunc(); // ❌
    }
};

// 外部使用
DerivedPublic dp;  dp.a = 1; dp.pubFunc(); // ✅
DerivedPrivate dv; // dv.a = 1; // ❌ 私有繼承隱藏了基類 public 介面

友元與繼承：不傳遞性

class Base { friend class FriendOfBase; protected: int x; };
class Derived : public Base { protected: int y; };

class FriendOfBase {
    void access(Base& b) { b.x = 1; } // ✅
    void access(Derived& d) { d.x = 1; } // ❌ FriendOfBase 不是 Derived 的友元
};

class DerivedFriend : public FriendOfBase {
    void access(Base& b) { b.x = 1; } // ✅ 繼承不傳遞友元權限
};

三、多態 — 運行時綁定與行為抽象

觸發條件 (雙重保險)

1. 虛函數：基類成員函數聲明 `virtual` (析構函數**必須**虛)
2. 基類指針/引用**調用**：`Base* ptr = &derived; ptr->virtualFunc();`

滿足兩者 → **動態綁定** (查虛表調用派生類覆寫版本)
否則 → **靜態綁定** (編譯期確定調用基類版本)

虛函數覆寫規範 (C++11 `override`/`final`)

class Base {
public:
    virtual void foo() = 0;        // 純虛函數 → 抽象類
    virtual void bar() { /*默認實現*/ }
    virtual ~Base() = default;     // 虛析構：刪除基類指針正確調用派生類析構
};

class Derived : public Base {
public:
    void foo() override { /*必須實現*/ }      // override: 編譯期檢查確實覆寫了虛函數
    void bar() final override { /*最終版*/ }  // final: 禁止進一步派生類覆寫
    // void foo() {} // ❌ 無 override，編譯器不報錯但隱藏基類虛函數 (非覆寫)
};

多態實戰：插件架構

// 接口定義
class IPlugin {
public:
    virtual ~IPlugin() = default;
    virtual std::string name() const = 0;
    virtual void execute() = 0;
};

// 具體插件
class LoggerPlugin : public IPlugin {
    std::string name() const override { return "Logger"; }
    void execute() override { std::cout << "[LOG] " << __TIME__ << '\n'; }
};

class AuthPlugin : public IPlugin {
    std::string name() const override { return "Auth"; }
    void execute() override { std::cout << "[AUTH] Token verified\n"; }
};

// 框架核心 — 僅依賴抽象接口
class Application {
    std::vector> plugins;
public:
    void registerPlugin(std::unique_ptr p) { plugins.push_back(std::move(p)); }
    void run() {
        for (auto& p : plugins) {
            std::cout << "Running " << p->name() << "...\n";
            p->execute(); // 動態綁定，調用具體插件實現
        }
    }
};

int main() {
    Application app;
    app.registerPlugin(std::make_unique());
    app.registerPlugin(std::make_unique());
    app.run();
}

四、進階主題：名字隱藏、using 聲明、菱形繼承

名字隱藏 vs 重載

class Base {
public:
    void func(int) { std::cout << "Base::func(int)\n"; }
    void func(double) { std::cout << "Base::func(double)\n"; }
};

class Derived : public Base {
public:
    void func(char) { std::cout << "Derived::func(char)\n"; } // 隱藏 Base 所有 func!
};

int main() {
    Derived d;
    d.func('c'); // ✅ Derived::func(char)
    d.func(1);   // ❌ 編譯錯誤：Base::func(int) 被隱藏
    d.func(1.0); // ❌ 編譯錯誤：Base::func(double) 被隱藏
    d.Base::func(1); // ✅ 显式限定作用域
}

解決方案：`using` 聲明引入基類重載集

class DerivedFixed : public Base {
public:
    using Base::func; // 引入 Base 所有 func 重載到 DerivedFixed 作用域
    void func(char) { std::cout << "Derived::func(char)\n"; }
};

int main() {
    DerivedFixed d;
    d.func('c'); // ✅
    d.func(1);   // ✅ Base::func(int)
    d.func(1.0); // ✅ Base::func(double)
}

菱形繼承與虛繼承

class A { public: int x; };
class B : virtual public A { }; // 虛繼承
class C : virtual public A { };
class D : public B, public C { }; // D 中只有一個 A 子對象

int main() {
    D d;
    d.x = 10; // ✅ 無歧義
    // 內存佈局：D 包含 B、C、A (共享)、虛表指針
}

五、工程最佳實踐清單

1. ✅ **組合優於繼承**：`Has-A` (成員變量) 優於 `Is-A` (繼承)，除非確有 Liskov 替換原則需求
2. ✅ **基類析構函數必須虛**：`virtual ~Base() = default;`
3. ✅ **覆寫必加 `override`**：編譯期捕獲拼寫錯誤、簽名不匹配
4. ✅ **接口與實現分離**：抽象基類 (純虛) 定義契約，具體類實現
5. ✅ **避免深層繼承樹**：> 3 層通常意味著設計問題，考慮組合/策略模式
6. ✅ **`final` 封鎖不變行為**：葉子類/關鍵方法加 `final`，防止意外覆寫、優化去虛化
7. ✅ **`using` 管理重載集**：公開繼承且需保留基類重載時必加
8. ✅ **虛繼承謹慎使用**：菱形問題確認存在時才用，增加內存/訪問開銷、構造順序複雜

核心洞見： 封裝是**邊界**，繼承是**契約**，多態是**擴展點**。優秀的 C++ 設計：以封裝守護不變量、以抽象基類定義契約、以多態實現開放封閉原則、**以組合替代大多數繼承**、**以 `override`/`final`/`using` 消除隱式語義陷阱**。這才是現代 C++ 面向對象的工程智慧。