C++学习笔记 继承，虚基类

一，派生类

省略访问说明符，关键词struct声明的类默认为public，关键词class声明的类为private

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

二，虚基类

对于每个指定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 << '
'; // 打印 223
    }
};

所有虚基类子对象都在任何非虚基类子对象之前初始化，故只有最终派生类会在其成员初始化器列表中调用虚基类的构造函数：

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

允许空基类子对象大小为零

若空基类之一亦为首个非静态数据成员的类型或其类型的基类，则禁用空基优化，因为要求两个同类型基类子对象在最终派生类型的对象表示中必须拥有不同地址。

三，virtual函数说明符，虚函数

指定非静态成员函数为虚函数并支持动态调用派发，它只能在非 静态成员函数的首个声明（即当它与类定义中声明时）的声明说明符序列中出现

虚函数是可以在派生类中覆盖其行为的成员函数，与非虚函数相反，即使没有关于该类实际类型的编译时信息，仍然保留被覆盖的行为。

#include <iostream>
struct Base {
    virtual void f() {
        std::cout << "base
";
    }
};
struct Derived : Base {
    void f() override { // 'override' 可选
        std::cout << "derived
";
    }
};
int main()
{
    Base b;
    Derived d;

    // 通过引用调用虚函数
    Base& br = b; // br 的类型是 Base&
    Base& dr = d; // dr 的类型也是 Base&
    br.f(); // 打印 "base"
    dr.f(); // 打印 "derived"

    // 通过指针调用虚函数
    Base* bp = &b; // bp 的类型是 Base*
    Base* dp = &d; // dp 的类型也是 Base*
    bp->f(); // 打印 "base"
    dp->f(); // 打印 "derived"

    // 非虚函数调用
    br.Base::f(); // 打印 "base"
    dr.Base::f(); // 打印 "base"
}

每个虚函数都有其最终覆盖函数，它是进行虚函数调用时所执行的函数。基类 Base 的虚成员函数 vf 是最终覆盖函数，除非派生类声明或（通过多重继承）继承了覆盖 vf 的另一个函数。

struct A { virtual void f(); };     // A::f 是虚函数
struct B : A { void f(); };         // B::f 覆盖 A::f in B
struct C : virtual B { void f(); }; // C::f 覆盖 A::f in C
struct D : virtual B {}; // D 不引入覆盖函数，B::f 在 D 中为最终
struct E : C, D  {       // E 不引入覆盖函数，C::f 在 E 中为最终
    using A::f; // 非函数声明，仅令 A::f 能为查找所见
};
int main() {
   E e;
   e.f();    // 虚调用调用 C::f，e 中的最终覆盖函数
   e.E::f(); // 非虚调用调用 A::f，它在 E 中可见
}

若函数以说明符 override 声明，但不覆盖任何虚函数

若函数以说明符 final 声明，而另一函数试图覆盖之，

struct B {
    virtual void f(int);
};
struct D : B {
    virtual void f(int) override; // OK，D::f(int) 覆盖 B::f(int)
};


struct B {
    virtual void f() const final;
};
struct D : B {
    void f() const; // 错误：D::f 试图覆盖 final B::f
};

非成员函数和静态成员函数不能为虚函数。

函数模板不能被声明为 virtual。这只适用于自身是模板的函数——类模板的常规成员函数可被声明为虚函数。

虚析构函数

虽然析构函数是不继承的，但若基类声明其析构函数为 virtual，则派生的析构函数始终覆盖它。这使得可以通过指向基类的指针 delete 动态分配的多态类型对象

class Base {
 public:
    virtual ~Base() { /* 释放 Base 的资源 */ }
};
 
class Derived : public Base {
    ~Derived() { /* 释放 Derived 的资源 */ }
};
 
int main()
{
    Base* b = new Derived;
    delete b; // 进行对 Base::~Base() 的虚函数调用
              // 由于它是虚函数，故它调用的是 Derived::~Derived()，
              // 这就能释放派生类的资源，然后遵循通常的析构顺序
              // 调用 Base::~Base()
}

四，抽象类

定义不能被实例化，但可以作基类的抽象类型

虚说明符=0

抽象类（abstract class）时定义或继承了至少一个最终覆盖函数为纯虚的函数的类，

抽象类型不能用形参类型，函数返回类型，或显示转换类型

可以声明到抽象类的指针或引用

struct Abstract {
    virtual void f() = 0; // 纯虚
}; // "Abstract" 为抽象
 
struct Concrete : Abstract {
    void f() override {} // 非纯虚
    virtual void g();     // 非纯虚
}; // "Concrete" 为非抽象
 
struct Abstract2 : Concrete {
    void g() override = 0; // 纯虚覆盖函数
}; // "Abstract2" 为抽象
 
int main()
{
    // Abstract a; // 错误：抽象类
    Concrete b; // OK
    Abstract& a = b; // OK：到抽象基类的引用
    a.f(); // 虚派发到 Concrete::f()
    // Abstract2 a2; // 错误：抽象类（g() 的最终覆盖函数为纯虚）
}

override 说明符

指定一个虚函数覆盖另一个虚函数

struct A
{
    virtual void foo();
    void bar();
};
 
struct B : A
{
    void foo() const override; // 错误：B::foo 不覆盖 A::foo
                               // （签名不匹配）
    void foo() override; // OK：B::foo 覆盖 A::foo
    void bar() override; // 错误：A::bar 非虚
};

final 说明书

指定某个虚函数不能在子类中被覆盖，或者某个类不能被子类继承

struct Base
{
    virtual void foo();
};
 
struct A : Base
{
    void foo() final; // Base::foo 被覆盖而 A::foo 是最终覆盖函数
    void bar() final; // 错误： bar 不能为 final 因为它非虚
};
 
struct B final : A // struct B 为 final
{
    void foo() override; // 错误：foo 不能被覆盖，因为它在 A 中是 final
};
 
struct C : B // 错误：B 为 final
{
};