派生类

来自cppreference.com
< cpp‎ | language
 
C++
 
C++ 语言
 
类
 

任何类类型（无论是以 类关键词 class 还是 struct 声明）均可被声明为派生于一个或多个基类，各基类也可以派生自其自身的基类，组成继承层级结构。

基类的列表在类声明语法的 基类子句 中提供。基类子句 由字符 : 后随一或多个 基类说明符 的逗号分隔列表组成。

属性(可选) 访问说明符(可选) 虚说明符(可选) 类或-decltype
属性 - (C++11 起) 可选的任意数量属性的序列
访问说明符 - private、public 或 protected 之一
虚说明符 - 关键词 virtual
类或-decltype - 以下之一：
  • 嵌套名说明符(可选) 类型名
  • 嵌套名说明符 template 简单模板标识
(C++11 起)

虚说明符 与 访问说明符 可以以任意顺序出现。由于语法限制，详述类型说明符不能直接作为 类或-decltype 出现。

基类子句 中的 基类说明符 可以是包展开。

类或-decltype 不能指代声明为 final 的类或结构体。

(C++11 起)

如果省略 访问说明符，那么它对以 类关键词 struct 声明的类默认为 public，对以 类关键词 class 声明的类为 private。 

struct Base {
    int a, b, c;
};
// 每个 Derived 类型对象包含一个 Base 子对象
struct Derived : Base {
    int b;
};
// 每个 Derived2 类型对象包含 Derived 与 Base 子对象
struct Derived2 : Derived {
    int c;
};

在 基类子句 中列出的 类或-decltype 所指代的类是直接基类。它们的基类是间接基类。同一类不能被多次指定为直接基类，但同一类可以既是直接又是间接基类。

每个直接和间接基类都作为基类子对象，以依赖于 ABI 的偏移量存在于派生类的对象表示中。因为空基类优化，空基类通常不会增加派生类对象的大小。基类子对象的构造函数被派生类的构造函数所调用：可以在成员初始化器列表中向这些构造函数提供实参。

虚基类

对于每个指定为 virtual 的不同基类，最终派生对象中仅含有该类型的一个基类子对象，即使该类在继承层级中出现多次也是如此（只要它每次都以 virtual 继承）。 

struct B { int n; };
class X : public virtual B {};
class Y : virtual public B {};
class Z : public B {};
// 每个 AA 类型对象拥有一个 X，一个 Y，一个 Z 和两个 B：
// 一个是 Z 的基类，另一个由 X 与 Y 所共享
struct AA : X, Y, Z {
    void f() {
        X::n = 1; // 修改虚 B 子对象的成员
        Y::n = 2; // 修改同一虚 B 子对象的成员
        Z::n = 3; // 修改非虚 B 子对象的成员
 
        std::cout << X::n << Y::n << Z::n << '\n'; // 打印 223
    }
};

继承层级有虚基类的例子之一是标准库的 iostream 的继承层级：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() {} };
 
// AA 的默认构造函数调用 X 和 Y 的默认构造函数
// 但这些构造函数不调用 B 的构造函数，因为 B 是虚基类
AA a; // a.n == 3
// X 的默认构造函数调用 B 的构造函数
X x; // x.n == 1

涉及虚继承时，对类成员的无限定名字查找有特殊规则（有时被称为“优先性（dominance）规则”）。

公开继承

当类使用 public 成员访问说明符从基类派生时，基类的所有公开成员可作为派生类的公开成员访问，基类的所有受保护成员可作为派生类的受保护成员访问（基类的私有成员始终不可访问，除非设为友元）。

公开继承塑造了面向对象编程的子类型关系：派生类对象是（IS-A）基类对象。到派生类对象的引用和指针，可被期待到其任何公开基类的引用和指针的代码所用（见 LSP），或者以 DbC 的说法，派生类应该维护其公开基类的类不变式，不应强化其所覆盖的成员函数的任何前条件，或弱化其任何后条件。

运行此代码
#include <vector>
#include <string>
#include <iostream>
 
struct MenuOption { std::string title; };
// Menu 是 MenuOption 的 vector ：能插入、移除、重排……选项并拥有标题。
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';
    }
};
// 注： Menu::title 没有问题因为它的角色与基类独立。
 
enum class Color { WHITE, RED, BLUE, GREEN };
 
void apply_terminal_color(Color) { /* 操作系统特定 */ }
 
// 这不好！
// ColorMenu 是每个选项都有定制颜色的 Menu 。
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 需要下列通过公开继承 Menu 无法满足的不变式，例如：
// - ColorMenu::colors 与 Menu 必须拥有相同数量的元素
// - 为使得有意义，调用 erase() 也应该从 colors 移除元素以保持选项颜色
// 基本上每个对 std::vector 的非 const 方法调用都会破坏 ColorMenu 的不变式
// 并将会需要从用户由正确管理颜色来修复。
 
int main() {
    ColorMenu color_menu;
 
    // 这个类的大问题是我们必须保持_Color 与的 Menu 同步。
    color_menu.push_back(MenuOption{"某些选择"});
 
    // color_menu.print(); // 错误！print() 中的 colors[i] 在范围外
 
    color_menu.colors.push_back(Color::RED);
 
    color_menu.print(); // OK ：colors 与 Menu 拥有相同的元素数
}

受保护继承

当类使用 protected 成员访问说明符从基类派生时，基类的所有公开和受保护成员可作为派生类的受保护成员访问（基类的私有成员始终不可访问，除非设为友元）。

受保护继承可用于“受控制的多态”：在派生类的成员中，以及所有进一步派生的类的成员中，派生类是（IS-A）基类：到派生类的引用和指针可用于期待到基类的引用和指针处。

私有继承

当类使用 private 成员访问说明符从基类派生时，基类的所有公开和受保护成员可作为派生类的私有成员访问（基类的私有成员始终不可访问，除非设为友元）。

私有继承常用于基于策略的设计，因为策略常是空基类，而使用基类可以同时启用静多态并活用空基类优化

私有继承也可以用于实现合成关系（基类子对象是派生类对象的实现细节）。除非派生类需要访问基类的受保护成员（包含构造函数），需要覆盖基类的虚成员，需要基类在某个其他基类子对象之前构造或在其之后销毁，需要共享虚基类或需要控制虚基类的构造，否则使用成员方案可以提供更好的封装，而且通常是更受偏好的方式。使用成员来实现合成关系，亦不适用于从参数包进行多重继承的情况，或在编译时通过模板元编程确定各基类身份的情况。

与受保护继承相似，私有继承也可以用于受控制的多态：在派生类的成员内（但不在进一步派生的类中），派生类是（IS-A）基类。 

template<typename Transport>
class service : private Transport  // 从 Transport 策略私有继承
{
public:
    void transmit() {
        this->send(...);  // 使用 Transport 提供的任何东西进行发送
    }
};
// TCP 传输策略
class tcp {
public:
    void send(...);
};
// UDP 传输策略
class udp {
public:
    void send(...);
};
 
service<tcp> service(host, port); 
service.transmit(...); // 通过 TCP 发送

成员名字查找

针对类成员进行的无限定和有限定的名字查找规则，详见于名字查找。

参阅

来自“https://zh.cppreference.com/mwiki/index.php?title=cpp/language/derived_class&oldid=72405”