派生類

任何類型別（無論使用 class-key class 或 struct 宣告）都可以宣告為派生自一個或多個基類，而基類又可以派生自它們自己的基類，從而形成一個繼承層次結構。

每個直接和間接基類都作為基類子物件存在於派生類的物件表示中，其偏移量取決於 ABI。空基類通常不會因為空基類最佳化而增加派生物件的大小。基類子物件的建構函式由派生類的建構函式呼叫：引數可以在成員初始化列表中提供給這些建構函式。

[編輯] 虛基類

對於每個指定為 virtual 的不同基類，最派生物件只包含該型別的一個基類子物件，即使該類在繼承層次結構中多次出現（只要每次都以 virtual 繼承）。

struct B { int n; };
class X : public virtual B {};
class Y : virtual public B {};
class Z : public B {};
 
// every object of type AA has one X, one Y, one Z, and two B's:
// one that is the base of Z and one that is shared by X and Y
struct AA : X, Y, Z
{
    AA()
    {
        X::n = 1; // modifies the virtual B subobject's member
        Y::n = 2; // modifies the same virtual B subobject's member
        Z::n = 3; // modifies the non-virtual B subobject's member
 
        std::cout << X::n << Y::n << Z::n << '\n'; // prints 223
    }
};

標準庫的 iostreams 層次結構是虛基類繼承層次結構的一個例子：std::istream 和 std::ostream 使用虛繼承從 std::ios 派生。std::iostream 從 std::istream 和 std::ostream 兩者派生，因此 std::iostream 的每個例項都包含一個 std::ostream 子物件、一個 std::istream 子物件，以及一個 std::ios 子物件（因此，也包含一個 std::ios_base）。

所有虛基子物件都在任何非虛基子物件之前初始化，因此只有最派生類在其成員初始化列表中呼叫虛基的建構函式

struct B
{
    int n;
 
    B(int x) : n(x) {}
};
 
struct X : virtual B { X() : B(1) {} };
struct Y : virtual B { Y() : B(2) {} };
struct AA : X, Y     { AA() : B(3), X(), Y() {} };
 
// the default constructor of AA calls the default constructors of X and Y
// but those constructors do not call the constructor of B because B is a virtual base
AA a; // a.n == 3
 
// the default constructor of X calls the constructor of B
X x;  // x.n == 1

當涉及虛繼承時，類成員的非限定名稱查詢有特殊規則（有時稱為支配規則）。

[編輯] 公有繼承

當一個類使用 public 成員訪問說明符從基類派生時，基類的所有公有成員都可作為派生類的公有成員訪問，基類的所有保護成員都可作為派生類的保護成員訪問（基類的私有成員除非是友元，否則永遠不可訪問）。

公有繼承模擬了面向物件程式設計的子型別關係：派生類物件 IS-A 基類物件。期望派生物件的引用和指標可被任何期望其任何公有基類的引用或指標的程式碼使用（參見 LSP）或，在 DbC 術語中，派生類應維護其公有基類的類不變式，不應加強任何前置條件或削弱其覆蓋的成員函式的任何後置條件。

執行此程式碼

#include <iostream>
#include <string>
#include <vector>
 
struct MenuOption { std::string title; };
 
// Menu is a vector of MenuOption: options can be inserted, removed, reordered...
// and has a title.
class Menu : public std::vector<MenuOption>
{
public:
    std::string title;
 
    void print() const
    {
        std::cout << title << ":\n";
        for (std::size_t i = 0, s = size(); i < s; ++i)
            std::cout << "  " << (i + 1) << ". " << at(i).title << '\n';
    }
};
// Note: Menu::title is not problematic because its role is independent of the base class.
 
enum class Color { WHITE, RED, BLUE, GREEN };
 
void apply_terminal_color(Color) { /* OS-specific */ }
 
// THIS IS BAD!
// ColorMenu is a Menu where every option has a custom color.
class ColorMenu : public Menu
{
public:
    std::vector<Color> colors;
 
    void print() const
    {
        std::cout << title << ":\n";
 
        for (std::size_t i = 0, s = size(); i < s; ++i)
        {
            std::cout << "  " << (i + 1) << ". ";
            apply_terminal_color(colors[i]);
            std::cout << at(i).title << '\n';
            apply_terminal_color(Color::WHITE);
        }
    }
};
// ColorMenu needs the following invariants that cannot be satisfied
// by publicly inheriting from Menu, for example:
// - ColorMenu::colors and Menu must have the same number of elements
// - To make sense, calling erase() should remove also elements from colors,
//   in order to let options keep their colors
// Basically every non-const call to a std::vector method will break the invariant
// of the ColorMenu and will need fixing from the user by correctly managing colors.
 
int main()
{
    ColorMenu color_menu;
 
    // The big problem of this class is that we must keep ColorMenu::Color
    // in sync with Menu.
    color_menu.push_back(MenuOption{"Some choice"});
 
    // color_menu.print(); // ERROR! colors[i] in print() is out of range
 
    color_menu.colors.push_back(Color::RED);
 
    color_menu.print(); // OK: colors and Menu has the same number of elements
}

[編輯] 保護繼承

當一個類使用 protected 成員訪問說明符從基類派生時，基類的所有公有和保護成員都可作為派生類的保護成員訪問（基類的私有成員除非是友元，否則永遠不可訪問）。

保護繼承可用於“受控多型性”：在派生類的成員以及所有進一步派生類的成員中，派生類 IS-A 基類：派生類的引用和指標可在期望基類的引用和指標的地方使用。

[編輯] 私有繼承

當一個類使用 private 成員訪問說明符從基類派生時，基類的所有公有和保護成員都可作為派生類的私有成員訪問（基類的私有成員除非是友元，否則永遠不可訪問）。

私有繼承通常用於基於策略的設計，因為策略通常是空類，將其用作基類既可以實現靜態多型性，又可以利用空基類最佳化。

私有繼承也可以用於實現組合關係（基類子物件是派生類物件的一個實現細節）。使用成員提供更好的封裝，通常是首選，除非派生類需要訪問基類的保護成員（包括建構函式），需要覆蓋基類的虛成員，需要在其他基子物件之前構造並在之後銷燬基類，需要共享虛基類，或者需要控制虛基類的構造。在從引數包多重繼承或基類的標識在編譯時透過模板超程式設計確定時，使用成員實現組合也不適用。

與保護繼承類似，私有繼承也可以用於受控多型性：在派生類的成員內部（但不在進一步派生類內部），派生類 IS-A 基類。

template<typename Transport>
class service : private Transport // private inheritance from the Transport policy
{
public:
    void transmit()
    {
        this->send(...); // send using whatever transport was supplied
    }
};
 
// TCP transport policy
class tcp
{
public:
    void send(...);
};
 
// UDP transport policy
class udp
{
public:
    void send(...);
};
 
service<tcp> service(host, port); 
service.transmit(...); // send over TCP

[編輯] 成員名稱查詢

類成員的非限定和限定名稱查詢規則在名稱查詢中詳細說明。

[編輯] 關鍵詞

virtual

[編輯] 缺陷報告

下列更改行為的缺陷報告追溯地應用於以前出版的 C++ 標準。

缺陷報告	應用於	釋出時的行為	正確的行為
CWG 1710	C++98	class-or-decltype 的語法使得無法從需要 template 消歧符的從屬類派生	允許 template

編譯器支援
自由（freestanding）與宿主（hosted）
語言
標準庫
標準庫標頭檔案
具名要求
特性測試宏 (C++20)
語言支援庫
概念庫 (C++20)
診斷庫
記憶體管理庫
超程式設計庫 (C++11)
通用工具庫
容器庫
迭代器庫
範圍庫 (C++20)
演算法庫
字串庫
文字處理庫
數值庫
日期和時間庫
輸入/輸出庫
檔案系統庫 (C++17)
併發支援庫 (C++11)
執行控制庫 (C++26)
技術規範
符號索引
外部庫

通用
概覽
`class`/`struct` 型別
`union` 型別
注入類名
類屬性說明符 (C++26)
成員
資料成員
靜態成員
`this` 指標
巢狀類
成員模板
位域
`using`-宣告
成員函式
成員訪問說明符
建構函式和成員初始化列表
預設成員初始化器 (C++11)
`friend` 說明符
`explicit` 說明符
轉換建構函式
特殊成員函式
預設建構函式
複製建構函式
移動建構函式 (C++11)
複製賦值運算子
移動賦值運算子 (C++11)
解構函式
繼承
基類和派生類
空基類最佳化 (EBO)
虛成員函式
純虛擬函式和抽象類
`override` 說明符 (C++11)
`final` 說明符 (C++11)


attr (可選) class-or-computed	(1)

attr (可選) `virtual` class-or-computed	(2)

attr (可選) access-specifier class-or-computed	(3)

attr (可選) `virtual` access-specifier class-or-computed	(4)

attr (可選) access-specifier `virtual` class-or-computed	(5)

cppreference.com

名稱空間

變體

檢視

操作

派生類

目錄

[編輯] 語法