Classes and Objects⚓︎

Declaration and Definition⚓︎

在 C++ 程序设计中，仅靠变量和函数这种面向过程的范式很难表述清楚复杂的现实问题。为了解决这个问题，C++ 提供了 OOP 范式，其“核心出装”就是本篇笔记的主角类(classes) 和对象(objects)。

目前，为了便于理解，我们可以将类和对象的关系对应到类型和变量的关系。其中，类定义了一系列的属性和方法，分别称作成员变量(member variables) 和成员函数(member functions)；而对象则是类的一个实例 (instance)，具备独立于其他对象的属性。

一个基本的类应该包含：

• 构造函数 (constructor)
• 私有成员函数 / 变量
• 公有成员函数（面向用户的接口）
• 析构函数 (destructor)

Header Files and Source Files⚓︎

• .h 头文件用于定义接口

  • 一般包括：函数原型、类声明、类型定义、宏、常量、外部变量等，可能为多个源文件所用
  • 建议一个头文件仅包含一个类的声明
  • 用到头文件的接口时，记得在代码开头用 #include 导入，它将被包含的文件插入到 .cpp 文件内这条语句的位置上
    • #include "xx.h"：先搜索当前目录，然后寻找系统目录
    • #include <xx.h>：直接搜索系统目录
    • #include <xx>：与 #include <xx.h> 相同

  • 以下是一个标准的头文件结构，里面的声明仅出现一次，这样可以避免头文件内容被多次包含，从而导致编译失败的问题

    #ifndef HEADER_FLAG
    #define HEADER_FLAG
    // Type declaration here...
    #endif // HEADER_FLAG
    

• .cpp 源文件一般起到实现函数或类的作用

  • 一般包括：函数实现、可执行代码
  • 如果是用于类的实现的话，建议与对应的头文件同名
  • 编译器一次只看一个 .cpp 文件，并将其编译为 .obj 文件
  • 链接器将所有的 .obj 文件链接为一个可执行文件

Access Control⚓︎

比较 struct 和 class

在结构体中，里面的所有字段默认是公有的 (public)，这意味着任何人都可以修改字段值，没有针对结构体的访问控制，这往往是我们不希望看到的。

C++ 的一大重要思想是封装(encapsulation)，其中最重要的封装手段便是访问说明符(access specifiers)，用于控制成员的访问权限。C++ 提供了以下几种访问说明符（从上到下封装性越来越强）：

• public（公有）：能被任何对象访问
• protected（受保护）：只能在类内部以及该类的派生类内被访问（涉及到继承的知识）
• private（私有）：只能在类内部被访问

class zjuID {
private:
    string name;            
    int idNumber;
public:
    void setName(string n);
    void setIdNumber(int id);
    void display();
};


zjuID myCard;
myCard.setName("NoughtQ");     // OK
myCard.setIDNumber(114514);    // OK
myCard.idNumber = 1919;        // Error! We cannot access private members directly

Initialization and Clean-Up⚓︎

• 构造函数(constructor，简写为 ctor) 用于初始化新创建对象的状态

  • 构造函数的名称与类名相同，且无需指出返回类型

  • 构造函数有两类：

    • 参数化构造函数：

      • 函数体内还可以增加一些额外限制

      zjuID::zjuID(std::string name, int idNumber) {
          this->name = name;
          if (idNumber > 0)
              this->idNumber = idNumber;
      }
      

      • 成员初始化列表(member initialization list)：

        zjuID::zjuID(std::string name, int idNumber): name(name), idNumber(idNumber) { }
        

        • 相比在函数体内为每个成员变量赋值，这种方法的效率更高，因为前者在赋值前还会调用默认构造函数进行初始化，而这个初始化马上就会被后面的赋值操作覆盖。

        • 也可以将初始化列表里的圆括号改为花括号，这样就用到了统一初始化的语法，相比一般方法能够防止缩窄转换，更加安全。

          zjuID::zjuID(std::string name, int idNumber): name{name}, idNumber{idNumber} { }
          

        • 初始化列表可以为空，此时编译器会进行零初始化（对于数值类型的话就会赋予 0）。

        • 成员初始化的顺序按照声明成员的次序，而和其在初始化列表中的顺序无关

    • 默认构造函数：没有参数的构造函数

      zjuID::zjuID() {
          name = "NoughtQ";
          idNumber = 114514;
      }
      

      • 如果在类里面没有声明构造函数，那么编译器会自动为该类创建一个这样的构造函数 - 这两类构造函数可以同时存在（函数重载） - C++ 11 引入了一种显式设置默认构造函数的方法：= default，此时编译器会自动生成一个空的实现，为基本类型成员变量进行默认初始化（不是零初始化）。该关键字仅用于默认构造函数（也就是说不得有任何参数），

  • 注意：初始化的顺序不是按照初始化列表的顺序，而是按照类里面变量声明的顺序

  • 用 explicit 关键字修饰构造函数，表明该构造函数不允许隐式类型转换。这主要为了阻止那些意外的、不直观的隐式类型转换，从而提高代码的清晰度、可读性和安全性。

• 析构函数(destructor，简写为 dtor) 在对象销毁（生命周期结束）前被调用

  • 函数名 = ~ + 类名，无需任何参数，且同样没有返回类型

  • 如果使用 new 关键字动态分配数据的话，那就一定要在析构函数里用 delete 释放内存空间

    struct Y {
        ~Y();
    };
    

  • 可以显式调用析构函数，但一般来说没这个必要

  • 析构的顺序和构造的顺序相反
  • 析构函数不应该将抛出的异常影响到外部，因为这可能会让程序过早结束或出现未定义的行为。所以一旦抛出异常，析构函数应该及时捕获，然后要么中止程序，要么就当作无事发生，让程序继续执行下去。
    • 还有一种选择是设计一个函数，让析构函数调用这个函数。如果这个函数在执行期间发生异常，用户就有机会决定是否处理这个异常以及如何处理这个异常。

Getters and Setters⚓︎

一般情况下，类里面的成员变量都是私有的，类外部的对象无法直接访问成员变量。因此要想访问这些变量的话，我们需要通过该类的成员函数间接访问。其中用于读取成员变量的函数被称为 getter，用于修改成员变量的函数被称为 setter。

• getter

  std::string zjuID::getName() {
      return this->name;
  }
  
  int zjuID::getIdNumber() {
      return this->idNumber;
  }
  

• setter

  void zjuID::setName(std::string name) {
      this->name = name;
  }
  
  void zjuID::setIdNumber(int idNumber) {
      if (idNumber >= 0)
          this->idNumber = idNumber;
  }
  

Friends⚓︎

友元(friends) 是一种用关键字 friend 修饰的函数或类，它可以访问另一个类（就是在这个类内部进行 friend 声明）的私有或受保护的成员（这在原来是不行的），从而实现“越权访问”（开后门）。

class Box {
private:
    int length;

public:
    Box(int l) : length(l) {}

    friend void printLength(const Box& b);
};

void printLength(const Box& b) {
    std::cout << "Length is: " << b.length << std::endl;
}

class Engine;

class Car {
private:
    int speed;

public:
    Car() : speed(200) {}
    friend class Engine;
};

class Engine {
public:
    void boost(Car& c) {
        c.speed += 100;  
    }
};

• 友元类不具备：

  • 对称性：类 A 是类 B 的友元，不代表 B 一定是 A 的友元
  • 传递性：若类 A 是类 B 的友元，类 B 是类 C 的友元，那么 A 不一定是 C 的友元
  • 继承性：子类不会继承父类的友元关系

• 友元函数不是成员函数，因为友元函数是在类外部实现的，不具备 this 指针。所以要想访问成员变量，还得将对象引用作为参数传递

Scope and Lifetime⚓︎

Local Objects⚓︎

字段、参数和局部变量的作用域和生命周期：

• 字段(fields)

  • 在类里面，但是在构造函数和方法外定义
  • 生命周期等同于对象的生命周期，因此可用来维护对象的当前状态等
  • 作用域为整个类，因此可被类里面的构造函数或方法使用（包括相同类的不同对象）
  • 不过用 private 字段定义字段后，该字段不得在类之外的区域被访问（其他对象不得访问这样的字段）

• 形参(parameters)：

  • 定义在构造函数或方法的签名 / 声明上，接收来自外部的值（实参值），该过程即为形参初始化的过程
  • 生命周期仅在构造函数或方法的调用内，函数调用结束后就消失了
  • 作用域限制在定义它们的构造函数或方法内

• 局部变量(local variables)：

  • 定义在构造函数或方法的主体 / 定义内，仅在构造函数或方法内来初始化和使用变量
  • 由于局部变量没有被赋予默认值，在表达式中使用局部变量时必须先初始化
  • 生命周期仅在构造函数或方法的调用内，函数调用结束后就消失了
  • 作用域限制在定义它们的块内，在块外面无法访问它们

Global Objects⚓︎

全局对象 (global objects)：

• 全局对象的构造函数(constructor) 需要在进入 main() 函数之前被调用，声明顺序即为代码书写顺序，因此 main() 不再是程序中第一个被调用的函数
• 全局对象的析构函数(destructor) 在 main() 退出或 exit() 调用时被调用

Static⚓︎

静态初始化依赖性(static initialization dependency)：单个文件内的对象构造顺序是已知的，但是多个文件之间的构造顺序是未定的。那么当位于不同文件的非局部静态对象有依赖关系时，它们的初始化顺序是不确定的，这样就可能产生不符预期的后果。

满足以下情况的对象称为非局部静态对象(non-local static object)：

• 定义于全局或命名空间作用域内
• 在类中或文件作用域内声明为静态变量的

解决上述问题的方案：

• 避免非局部静态变量的依赖关系
• 按正确的顺序在单个文件内定义静态对象
• 非局部静态对象 -> 局部静态对象，具体来说可以将非局部静态对象搬到对象所属类的函数内，该函数返回一个引用，指向其所含的对象。之后用户通过调用这些函数来访问对象，从而保证访问的对象是初始化过的。
  • 这正是设计模式中 Singleton 模式的一种常见实现方式

static（静态）关键字

• 静态的基本含义：静态存储（持续）、受限访问（隐藏）
• 在固定的地址上仅分配一次空间：名称可见性、内部链接

• 使用场景：

  • 全局变量：作用域被限制在当前文件，不得被其他文件访问
  • 局部变量：该变量的生命周期存在于整个程序的运行期间

  • 成员变量：此时成员变量属于类本身，而不是属于某个特定的对象（对象属性 -> 类属性）

    • 在类的内部只能对其声明（此时可以为变量赋初值）而不能定义，所以记得要在类外面定义一下这种变量

      class CostEstimate {
      private:
          static const double cost;
          // ...
      };
      const double CostEstimate::cost = 1.35;
      

    • 对于整数类型的变量，如果某些老式编译器不支持在声明时赋初值的话，可以用枚举类型 enum 来替代

  • 成员函数：此时成员函数属于类本身，而不是属于某个特定的对象（对象方法 -> 类方法）

• 对于静态成员变量 / 函数：

  • 由于不属于任何一个对象，所以没法对其使用 this 指针

  • 访问静态成员的两种方法（推荐前者）：

    <class name>::<static member>
    <object variable>.<static member>
    

Constants⚓︎

C++ 的 const 关键字是一个限定词，表示不可修改。常见的用法有：

• 修饰变量：const int x = y;，之后 x 就不得再被修改了

  • 不能将非 const 引用绑定在 const 变量上
  • 编译器尝试避免为 const 变量创建内存空间，而将其保存在符号表(symbol table) 内
  • 但如果在前面使用 extern 关键字的话，就会让编译器强制分配内存空间
  • 也可以修饰数组、结构体等复杂数据结构，但此时编译器会为它们分配一块无法被修改的内存空间。但是在编译时，无法使用内部的元素，因为编译器在编译时不会获取里面的信息

  • 被 const 修饰的类成员变量必须在构造函数中被初始化，但由于这样的变量没有在编译时被确定，所以要当心！解决方法有：

    • 匿名枚举
    • 在 const 前加上 static

    // compilation error
    class HasArray {
        const int size = 100;
        int array[size];
    }
    
    // anonymous enumeration -- OK!
    class HasArray {
        enum { size = 100 };
        int array[size]; // OK!
    };
    
    // use static keyword -- OK!
    class HasArray {
        static const int size = 100;
        int array[size];
    }
    

• 修饰指针：分多种情况讨论：

  • const int* p1;：const 修饰的是值，所以 p1 指向的值不得被修改，但 p1 本身可以被修改
  • int* const p2;：const 修饰的是指针，所以 p2 本身不得被修改，但可以修改其指向的值
  • const int* const p3;：无论是指针还是指向的值都不得变
  关于迭代器

  STL 迭代器本质上也是指针（可看作 T* 指针）。所以为迭代器声明 const 修饰的事迭代器自身：它不可以指向其他值，但它所指的值可以修改。

  如果希望迭代器所指的值不得修改，那么要用 const_iterator 替代 iterator。

• 修饰函数参数：void foo(const int& x);，防止函数修改传入的参数

• 修饰返回值：如果返回的是指针或引用，为防止误修改，可以加 const
  • e.g. const std::string& getStr();

• 修饰成员函数：const 加在函数签名之后（花括号之前）（声明和定义都要加）

  class A {
  public:
      int getVal() const {
          return val;
      }
  
  private:
      int val;
  };
  

  • 必要性：在 C++ 中，由于 const 对象只能使用其 const 成员函数，所以不为成员函数添加 const 的话，编译器就不知道这个成员函数是否会修改 const 对象的成员变量，从而编译失败
    • 一般我们不会刻意创建 const 对象；const 对象主要用于向函数传入被 const 修饰的参数（一般是指针或引用）
  • 此时该成员函数不能修改成员变量，并且它只能调用其他 const 成员函数；但它可以修改全局变量、传入的参数以及 static 成员变量（因为它不属于任何对象）
  • 被 const 修饰的对象只能调用同样被 const 修饰的成员函数
  • 实际上，这个 const 修饰的是 this 指针
  • 另外，这里的 const 修饰可以让类的接口更容易被理解

  • 函数重载：可以为同名成员函数设置被 const 修饰和不被 const 修饰的两个版本，这两个版本可以分别被 const 对象和非 const 对象调用

    void f() const;
    void f();
    

    • 一般情况下这两个版本的实现代码是一样的，所以会带来代码重复。要想避免这一情况，我们可以先定义一个 const 版本的函数，然后再让非 #！cpp const 版本调用这个函数。在这一过程中涉及到两步转型(casting)：
      • static_cast：将非 const 对喜庆转化为 const 对象
      • const_cast：移除 const
    例子

    template <typename T>
    const T& Vector<T>::findElement(const T& value) const {
        for (size_t i = 0; i < logical_size; i++) {
            if (elems[i] == value) return elems[i];
        }
        throw std::out_of_range("Element not found");
    }
    
    template <typename T>
    T& Vector<T>::findElement(const T& value) {
        return const_cast<T&>(static_cast<const Vector<T>&>(*this).findElement(value));
    }
    

    • 反过来做（即先定义非 const 版本，后让 const 版本调用这一函数）是不合理的，因为前者可能会对某些成员变量作修改，但后者显然不具备这种能力

Composition⚓︎

组合(composition)：一个类将另一个类的对象作为其成员变量，组织和复用其代码，从而“拥有”另一个类的功能，体现的是一种 "has-a"（拥有）关系。

有以下组合方式：

• 值组合 /嵌入对象(embedded objects)（完全包含）

  • 假如 "A has aB "，那么在对象 A 创建或销毁时，被嵌入的对象 B 会自动调用构造函数和析构函数（生命周期强绑定）
  • 成员初始化通常通过构造函数初始化列表进行
    • 可以只初始化部分成员，未初始化的将调用默认构造函数
    • 构造顺序由成员声明顺序决定，与初始化列表顺序无关

  • 嵌入对象通常是私有的（private）

    class A {
        int x;
    public:
        A(int val) : x(val) {}
    };
    class B {
        A a1, a2;
    public:
        B() : a1(10), a2(20) {}  // 初始化列表初始化子对象
    };
    

• 引用 / 指针组合

  • 引用 / 指针绑定的对象不会自动调用构造函数和析构函数，需要手动初始化和销毁对象（生命周期独立）
  • 应用场景：逻辑关系并不是完全的、程序开始时还不清楚对象大小、需要在运行时分配 / 连接资源 ...
  • 其他 OOP 语言只能采用这种方式

template<class T>
class Set {
public:
    bool member(const T& item) const;
    void insert(const T& item);
    void remove(const T& item);
    std::size_t size() const;
private:
    std::list<T> rep;
};

template<typename T>
bool Set<T>::member(const T& item) const {
    return std::find(rep.begin(), rep.end(), item) != rep.end();
}

template<typename T>
void Set<T>::insert(const T& item) {
    if (!member(item))
        rep.push_back(item);
}

template<typename T>
void Set<T>::remove(const T& item) {
    auto it = std::find(rep.begin(), rep.end(), item);
    if (it != rep.end())
        rep.erase(it);
}

template<typename T>
std::size_t Set<T>::size() const {
    return rep.size();
}

Inheritance⚓︎

继承(inheritance)：基于已有的类（称为基类(base class) 或超类(superclass)）创建一个新类（称为派生类(derived class) 或子类(subclass)），派生类自动获得基类的属性和方法，并在此基础上进行添加或修改。

继承的好处有：

• 代码复用：避免在多个类中重复编写相同的代码
• 简化维护：修改基类可以影响所有派生类，便于统一管理
• 扩展性：方便地在现有类的基础上进行功能扩展

能继承的内容有：

• 成员变量
  • 包括 private 和 protected 的成员变量，派生类拥有基类的全部变量
  • 但是派生类无法直接访问 private 成员变量，必须通过基类的 public 或 protected 的成员函数来访问
• publilc 或 protected 的成员函数：可被派生类直接访问和调用
• 静态成员：作用域仍然在类范围内

不能继承的内容有：

• 构造函数
  • 派生类不直接继承基类构造函数的内容
  • 创建派生类对象时，总是先调用基类的构造函数来初始化基类部分，然后再执行派生类的构造函数
  • 可以在派生类构造函数的初始化列表中显式调用指定的基类构造函数 ; 若不显式调用，则会自动调用基类的默认构造函数
  • 派生类的拷贝构造函数需要显式调用基类的拷贝构造函数，否则会调用基类的默认构造函数
• 析构函数
  • 不直接继承
  • 析构函数的调用顺序与构造函数相反：先调用派生类的析构函数，再调用基类的析构函数
• 赋值运算
  • 不直接继承
  • 派生类的赋值运算符需要显式调用基类的赋值运算符，以确保基类部分的正确赋值，否则可能导致资源管理问题（如浅拷贝）
  • 如果未显式定义，编译器会生成默认的赋值运算符，进行成员逐一赋值（可能会有问题）
• 私有数据被隐藏起来，但仍然存在

访问保护：

• 成员

  • 公有：对所有用户都是可见的
  • 受保护：对派生类和友元而言是可见的
  • 私有：仅对自己和友元可见

• 继承：

  • 公有：class Derived : public Base ...
    • 公有继承是一种 "is-a" 的关系
  • 受保护：class Derived : protected Base ...
  • 私有（默认）：class Derived : private Base ...

继承对访问的影响：假设类 B 是类 A 的派生类，那么：

何时“受保护”失效：

• 派生类的行为异常
• 对所有派生类而言，受保护的成员是公有的
• 因此，需要让成员函数是受保护的，而成员变量是私有的
• 析构函数按照调用构造函数时的倒序被调用

Polymorphism⚓︎

下面我们学习 OOP 中另一个重要思想——多态(polymorphism)，它允许我们以统一的方式处理不同但相关的对象，其核心思想就是“一个接口，多种实现”。

Subclassing and Subtyping⚓︎

子类(subclassing) 和子类型(subtyping) 是多态的基础，提供了多态所需要的 “多种形态”的对象。具体是通过以下方法实现的：

• public 继承
  • 在 C++ 中，public 继承是设计者用来表达子类型关系的主要工具。它在语法上建立了 "is-a" 关系，并允许从子类到父类的隐式类型转换（向上转型），这是实现多态的基础。

• 此外里氏替换原则 (Liskov Substitution Principle, LSP)发挥重要作用，它保证子类还必须在行为上与父类兼容，结合 public 继承，构成真正安全的子类型关系。LSP 有以下要求：

  • 子类不能强化父类方法的前置条件（对输入要求更严格）
  • 子类不能弱化父类方法的后置条件（对输出保证更少）
  • 子类必须维持父类的不变性（类状态的约束）

  如果没有遵循 LSP，即便是 public 继承，在运行时也可能导致逻辑错误或程序崩溃。这种情况下，这样的子类就不能表示有效的子类型。

Upcasting⚓︎

向上转型(upcasting) 是指将派生类的指针或引用转换为基类的指针或引用。

class Animal {};
class Dog : public Animal {};

Dog myDog;
Animal* pAnimal = &myDog; // Upcasting
Animal& rAnimal = myDog;  // Upcasting

向上转型具有以下特点：

• 隐式且安全：public 继承保证了 "is-a" 关系
• 信息丢失（静态角度）：通过基类指针 / 引用，我们只能访问基类中定义的成员（包括虚函数），子类特有的成员在编译时是不可见的
• 多态的关键：这是使用多态机制的前提；通过基类指针 / 引用调用虚函数时，才能触发动态绑定

Dynamic Binding⚓︎

动态绑定(dynamic binding)（也称为后期绑定 (late binding)或运行时绑定 (runtime binding)）是指在程序运行时，根据指针或引用实际指向的对象类型（而不是指针或引用的声明类型）来决定调用哪个成员函数版本的机制。

动态绑定的发生条件为：

• 调用必须通过基类的指针或引用进行
• 被调用的成员函数必须在基类中声明为 virtual（即虚函数(virtual functions)，下面马上介绍👇）

动态绑定是 C++ 实现运行时多态的基石，使得我们可以编写操作基类指针 / 引用的通用代码，而这些代码在运行时能够自动适应所指向的具体子类对象，调用该子类对象特有的行为实现（如果子类重写了该虚函数）。正是这种运行时的决策能力，赋予了程序处理不同类型对象的高度灵活性和可扩展性。

Virtual Functions⚓︎

虚函数(virtual functions) 允许子类重写 (override) 基类的行为，并在运行时根据对象的实际类型（而不是指针 / 引用的静态类型）来决定调用哪个版本的函数。

class Shape {
public:
    virtual void Draw() { cout << "Drawing a generic shape" << endl; }
    virtual ~Shape() {}
};

我们可能会遇到这样一个问题：如果通过基类指针 delete 一个派生类对象，而基类的析构函数不是虚函数，那么程序只会调用基类的析构函数，而派生类的析构函数不会被调用，这样就会得到一个“局部销毁”的对象，这可能会带来资源泄漏等一系列问题。

class Base { public: ~Base() { /* 非虚析构函数 */ } };
class Derived : public Base {
    Resource* res; // 假设 Derived 管理某种资源
public:
    Derived() : res(new Resource()) {}
    ~Derived() { delete res; /* 清理资源 */ } // 这个析构函数可能不会被调用！
};

Base* pB = new Derived();
delete pB; // !!! 未定义行为 (Undefined Behavior) !!!
           // 只调用了 ~Base()，Derived 的析构函数未调用，导致 res 内存泄漏！

因此，如果打算将一个类作为基类，并且之后可能会通过基类指针删除派生类对象，那么它的析构函数必须声明为 virtual。

或者说，只要类中有任何一个虚函数，就应该提供一个虚析构函数。即使类不打算被继承，这样做也无大碍，并且还更安全。

• 然而，如果类里面没有虚函数的话，那么就不要搞一个虚析构函数出来，因为虚函数有一个虚拟表指针，这个指针占据一定空间，导致空间浪费。

class Base {
public:
    virtual ~Base() = default;
};

Overriding⚓︎

重写(overriding) 的目的是为子类提供一个与基类虚函数签名完全相同的函数，以实现自己的特定行为。其规则如下：

• 函数签名：名称、参数列表、const 修饰符必须严格一致
• virtual 关键字：
  • 基类函数必须是 virtual
  • 子类重写时 virtual 关键字可选（但强烈推荐写上）

• override 关键字（C++11 标准引入，强烈推荐使用）：使用该关键字后，编译器会检查该函数是否真的重写了基类的虚函数，防止因签名错误导致的意外行为（变成隐藏而非重写）

  例子

  class Base {
  public:
      virtual void display(int x) const;
  };
  
  class Derived : public Base {
  public:
      // 正确重写，编译器会检查
      void display(int x) const override;
      // void display(int x) override; // 编译错误！const 不匹配
      // void display(double x) const override; // 编译错误！参数类型不匹配
  };
  

• 返回类型协变 (covariant return types)：如果基类虚函数返回 Base* 或 Base&，子类重写时可以返回 Derived* 或 Derived&（其中 Derived 继承自 Base）（通常应用于克隆函数等场景中）

  例子

  class Document {
  public:
      virtual Document* clone() const = 0;
      virtual ~Document() = default;
  };
  class TextDocument : public Document {
  public:
      // 返回更具体的类型，是合法的协变
      TextDocument* clone() const override { return new TextDocument(*this); }
  };
  

• 访问权限：子类重写函数的访问权限不能比基类更严格

  • 举例：如果基类是 public 的话 , 那么子类就不能是 protected 或 private

重写可能会带来名称隐藏 (name hiding)的问题：如果子类定义了一个与基类同名但参数列表不同的函数（无论基类是否为 virtual），基类所有同名的重载版本都会被隐藏。该问题的解决方法是使用 using 声明将基类同名函数引入子类作用域。

class Base {
public:
    virtual void func(int);
    void func(double); // overloading
};
class Derived : public Base {
public:
    // 只重写 int 版本
    void func(int) override;
    // 如果没有下一行, Base::func(double) 将被隐藏
    using Base::func; // 将 Base 的 func(double) 引入 Derived 作用域
};

Abstract Classes⚓︎

抽象类(abstract classes) 是一种包含至少一个纯虚函数(pure virtual function) 的类。

• 纯虚函数：在声明末尾加上 = 0，表示该函数没有实现，必须由子类提供。

class Shape { // Shape 是一个抽象类
public:
    // 纯虚函数：定义接口，强制子类实现
    virtual double calculateArea() const = 0;

    // 抽象类可以有普通成员函数和数据成员
    void setColor(const std::string& c) { color = c; }

    // 即使是抽象类，如果可能被继承，也需要虚析构函数！
    virtual ~Shape() = default;
private:
    std::string color;
};

抽象基类具备以下特点：

• 不能实例化：不能创建抽象类的对象
• 作为接口基类：主要用于定义一套接口规范，强制派生类实现这些接口

而抽象类的意义在于：它为一组具有共同特征的类提供统一的接口规范，通过包含纯虚函数强制子类实现特定行为，从而支持多态性、提高代码一致性与可扩展性，同时防止对未完全实现的类进行误用，是一种构建灵活、安全、可维护的面向对象系统的重要机制。

Inheritance of Interface and Implementation⚓︎

继承可分为接口继承和实现继承：

• 派生类总是继承基类的接口。
• 声明纯虚函数(pure virtual functions) 的目的是为了让派生类只继承函数接口。
  • 但我们可以为纯虚函数提供实现（但一定要在类声明外面提供）。但要想让派生类用到基类的这个实现，就必须明确指出基类名称（+ 作用域解析符 ::）
• 声明简单的非纯虚函数(simple impure functions) 的目的是让派生类继承该函数的接口和缺省实现。
  • 如果派生类不重写这一实现的话，那么通过基类指针调用时，仍然会调用基类的实现。
• 声明非虚函数(non-virtual functions) 的目的是为了让派生类继承函数接口以及一份强制性实现。
  • 非虚函数的不变性(invariant) 凌驾于其特异性 (specialization) 之上，也就是说无论派生类之间有多么不同，它的行为都不可以改变。

Multiple Inheritance⚓︎

多重继承(multiple inheritance) 是指一个类可以同时继承多个基类的机制。该机制允许新类结合多个已有类的功能，从而在设计上具有更高的灵活性和表达能力。

多重继承有以下应用场景：

• 实现多个接口：一个类可以同时满足多个不同的契约。

  例子

  class Clickable { public: virtual void onClick() = 0; virtual ~Clickable() = default; };
  class Serializable { public: virtual void serialize(std::ostream& os) const = 0; virtual ~Serializable() = default; };
  
  // Button 同时实现了 Clickable 和 Serializable 接口
  class Button : public Clickable, public Serializable { /* ... 实现接口 ... */ };
  

  • 因为继承了多个基类，所以很可能会遇到继承相同名称的成员的情况，而编译器无法帮我们选出最佳匹配。此时就需要我们手动指出具体要用哪个基类的成员（类名 + 作用域解析符 ::）

• 混合继承：继承一个具体的基类，同时实现一个或多个接口。

在多重继承中，我们常遇到的最经典的问题便是菱形继承问题(diamond problem) 了：当一个类通过不同的路径继承自同一个间接基类时，该基类的成员会在派生类中存在多份拷贝，导致访问出现歧义。

class Top { public: int value; };
class Left : public Top {};
class Right : public Top {};
class Bottom : public Left, public Right {};

Bottom b;
// b.value = 10; // 编译错误！编译器无法判断是 Left::Top::value 还是 Right::Top::value

该问题的解决方案是采用虚继承(virtual inheritance)，即在中间类继承共同基类时使用 virtual 关键字。

• 这样做的代价是：虚继承通常会引入额外的复杂性和轻微的性能开销
• 初始化规则：虚基类的构造函数由最终派生类 (most-derived class) 的构造函数负责调用，即使中间类也尝试调用，也会被忽略，从而确保虚基类只被初始化一次
• 使用建议：
  • 非必要不使用虚基类，平常只用非虚继承。
  • 如果要用到虚基类，应尽可能避免在里面放置数据，从而减小额外开销。

class Top { public: int value; };
// 使用虚继承
class Left : virtual public Top {};
class Right : virtual public Top {};
// Bottom 现在只包含一份 Top 的子对象
class Bottom : public Left, public Right {};

Bottom b;
b.value = 10; // 正确！只有一份 value

#include <iostream>

// 公共接口类：模拟一个可打印的接口
class Printable {
public:
    virtual void print() const = 0;
    virtual ~Printable() = default;
};

// 私有实现辅助类：模拟一个内部计数器，不希望外部直接访问
class CounterHelper {
protected:
    int count_ = 0;
    void increment() { count_++; }
    int getCount() const { return count_; }
};

class MyPrinter : public Printable, private CounterHelper {
public:
    MyPrinter() {
        increment();
    }

    // 实现 Printable 接口
    void print() const override {
        std::cout << "MyPrinter: Hello! (Printed " << getCount() << " times)" << std::endl;
    }

    // 额外的方法，可能在内部使用计数器
    void doSomethingElse() {
        increment();
        std::cout << "MyPrinter: Doing something else. Current count: " << getCount() << std::endl;
    }
};

int main() {
    MyPrinter printer;
    printer.print(); // 通过 Printable 接口调用
    printer.doSomethingElse(); // 调用 MyPrinter 自身的方法
    printer.print(); // 再次打印，计数器已更新

    // 尝试访问私有继承的成员 (会编译错误)
    // printer.increment(); // 错误: 'increment' is a private member of 'CounterHelper'
    // std::cout << printer.count_ << std::endl; // 错误: 'count_' is a private member of 'CounterHelper'

    // 通过基类指针使用多态 (只能访问 Printable 接口)
    Printable* p = &printer;
    p->print(); // 正常调用

    return 0;
}

Advanced Topics⚓︎

Handle Classes⚓︎

句柄类(handle classes) 是一种包装了指向另一个对象的指针或引用的类。它的主要目的是管理被包装对象的生命周期、访问权限，并提供一种更安全、更方便的方式来操作底层对象。句柄类通常用于实现以下目标：

• 资源管理：自动管理动态分配的内存或其他系统资源（如文件句柄、网络连接等），确保资源在不再需要时被正确释放，防止内存泄漏。
• 隐藏实现细节：将类的私有实现细节从头文件中移除，只在源文件中包含，从而减少编译依赖，加快编译速度，并允许在不重新编译客户端代码的情况下更改实现。
• 多态：句柄类可以持有基类指针，从而通过基类接口操作派生类对象，实现运行时多态。
• 防止对象切片：当派生类对象按值传递或赋值给基类对象时，派生类特有的部分会被“切掉”。句柄类通过持有指针或引用来避免这种情况。
• 提供值语义的引用行为：句柄类本身可以具有值语义（可复制、可赋值），但它所管理的底层对象却表现出引用语义。

句柄类的常见形式有：

• 智能指针
• 自定义包装类：可以创建自己的类来包装原始指针或引用，并提供特定的管理逻辑。
• PIMPL 惯用法(pointer to implementation idiom)：一种特殊的句柄类应用，用于将类的私有数据成员和私有函数实现从头文件中分离出来。

句柄类有以下特点：

• 通常包含一个指向实际对象的指针（或智能指针）。
• 提供对底层对象的间接访问（通过 operator-> 和 operator* 重载）。
• 负责底层对象的创建和销毁（尤其是智能指针）。
• 可以实现复制控制（拷贝构造函数、拷贝赋值运算符），决定是深拷贝底层对象还是共享底层对象。

#include <iostream>
#include <memory>

class Resource {
public:
    Resource(int id) : id_(id) {
        std::cout << "Resource " << id_ << " created." << std::endl;
    }
    ~Resource() {
        std::cout << "Resource " << id_ << " destroyed." << std::endl;
    }
    void operation() const {
        std::cout << "Resource " << id_ << " performing operation." << std::endl;
    }
private:
    int id_;
};

// MyHandleClass 就是一个句柄类，它包装并管理 Resource 对象
class MyHandleClass {
public:
    MyHandleClass(int id) : resource_ptr_(std::make_unique<Resource>(id)) {
        std::cout << "MyHandleClass created for Resource " << id << std::endl;
    }

    // 拷贝构造函数和拷贝赋值运算符通常被禁用或自定义，
    // 因为 unique_ptr 不可拷贝，shared_ptr 可拷贝。
    // 这里为了简单，让 unique_ptr 自动处理移动语义。

    void doSomething() const {
        if (resource_ptr_) {
            resource_ptr_->operation();
        } else {
            std::cout << "No resource to operate on." << std::endl;
        }
    }

private:
    std::unique_ptr<Resource> resource_ptr_; // 句柄，管理 Resource 对象的生命周期
};

int main() {
    std::cout << "--- Start main ---" << std::endl;

    // MyHandleClass 实例创建时，Resource 对象也被创建
    MyHandleClass h1(1);
    h1.doSomething();

    // 当 h1 超出作用域时，它所管理的 Resource 对象会被自动销毁
    {
        MyHandleClass h2(2);
        h2.doSomething();
    } // h2 和其管理的 Resource 2 在这里被销毁

    std::cout << "--- End main ---" << std::endl;
    return 0;
} // h1 和其管理的 Resource 1 在这里被销毁

#include <iostream>
#include <string>
#include <memory>

class MyClass {
public:
    MyClass(const std::string& name);

    // 析构函数必须在 Impl 完整定义后才能被编译器正确生成
    // 所以这里只是声明，实际定义会放在 Impl 定义之后
    ~MyClass();

    // 禁用拷贝构造和拷贝赋值，因为 unique_ptr 不可拷贝
    MyClass(const MyClass&) = delete;
    MyClass& operator=(const MyClass&) = delete;

    // 启用移动构造和移动赋值，因为 unique_ptr 支持移动语义
    MyClass(MyClass&&) noexcept;
    MyClass& operator=(MyClass&&) noexcept;

    // 公共接口方法
    void sayHello() const;

private:
    // 内部实现类的前向声明
    // 注意：这里 Impl 是 MyClass 的嵌套类
    class Impl;
    // 句柄：指向 Impl 对象的智能指针
    std::unique_ptr<Impl> pImpl;
};

// 内部 Impl 类的完整定义
// 必须在 MyClass 的析构函数和方法实现之前定义
class MyClass::Impl {
public:
    Impl(const std::string& name) : name_(name) {
        std::cout << "  [Impl] Impl object created for: " << name_ << std::endl;
    }
    ~Impl() {
        std::cout << "  [Impl] Impl object destroyed for: " << name_ << std::endl;
    }
    void sayHello_impl() const {
        std::cout << "  [Impl] Hello from " << name_ << "!" << std::endl;
    }
private:
    std::string name_;
};

// 外部 MyClass 类的成员函数实现
// 现在 Impl 已经完整定义，可以安全地使用 pImpl
MyClass::MyClass(const std::string& name) : pImpl(std::make_unique<Impl>(name)) {
    std::cout << "[MyClass] MyClass object created for: " << name << std::endl;
}

MyClass::~MyClass() = default;

MyClass::MyClass(MyClass&& other) noexcept = default;
MyClass& MyClass::operator=(MyClass&& other) noexcept = default;

void MyClass::sayHello() const {
    pImpl->sayHello_impl(); // 通过句柄调用 Impl 的方法
}

int main() {
    std::cout << "--- Start main ---" << std::endl;

    MyClass obj1("World");
    obj1.sayHello();

    {
        MyClass obj2("C++");
        obj2.sayHello();
    }

    std::cout << "--- End main ---" << std::endl;
    return 0;
}

--- Start main ---
[MyClass] MyClass object created for: World
[Impl] Impl object created for: World
[Impl] Hello from World!
[MyClass] MyClass object created for: C++
[Impl] Impl object created for: C++
[Impl] Hello from C++!
[Impl] Impl object destroyed for: C++
[MyClass] MyClass object destroyed for: C++
--- End main ---
[Impl] Impl object destroyed for: World
[MyClass] MyClass object destroyed for: World

Interface Classes⚓︎

在 C++ 中，并没有一个所谓的 interface 语法，但我们仍然可以利用现有语法构建一个“接口类”(interface classes)：它通常指的是一个抽象基类，主要声明一组纯虚函数，而不提供这些函数的具体实现，也不包含任何数据成员（或极少的数据成员）。它更像是一份契约(contract)，规定了任何实现该接口的派生类必须提供的行为。

#include <iostream>
#include <vector>
#include <memory>

// 接口类
class ILogger {
public:
    // 纯虚函数
    virtual void log(const std::string& message) = 0;

    // 虚析构函数
    virtual ~ILogger() {
        std::cout << "ILogger destructor called." << std::endl;
    }
};

// ILogger 接口的一个具体实现
class ConsoleLogger : public ILogger {
public:
    void log(const std::string& message) override {
        std::cout << "[Console] " << message << std::endl;
    }
    ~ConsoleLogger() override {
        std::cout << "ConsoleLogger destructor called." << std::endl;
    }
};

// 另一个具体实现
class FileLogger : public ILogger {
public:
    void log(const std::string& message) override {
        std::cout << "[File] " << message << " (simulated file write)" << std::endl;
    }
    ~FileLogger() override {
        std::cout << "FileLogger destructor called." << std::endl;
    }
};

// 客户端代码，只依赖于 ILogger 接口
void process_data(ILogger& logger) {
    logger.log("Processing data step 1...");
    // ...
    logger.log("Processing data step 2 finished.");
}

int main() {
    ConsoleLogger console_logger;
    process_data(console_logger);

    std::cout << "--------------------" << std::endl;

    FileLogger file_logger;
    process_data(file_logger);

    std::cout << "--------------------" << std::endl;

    std::unique_ptr<ILogger> logger_ptr = std::make_unique<ConsoleLogger>();
    logger_ptr->log("Message from unique_ptr managed logger.");

    logger_ptr = std::make_unique<FileLogger>();
    logger_ptr->log("Another message from unique_ptr managed logger.");

    return 0;
}

[Console] Processing data step 1...
[Console] Processing data step 2 finished.
--------------------
[File] Processing data step 1... (simulated file write)
[File] Processing data step 2 finished. (simulated file write)
--------------------
[Console] Message from unique_ptr managed logger.
ConsoleLogger destructor called.
ILogger destructor called.
[File] Another message from unique_ptr managed logger. (simulated file write)
FileLogger destructor called.
ILogger destructor called.
FileLogger destructor called.
ILogger destructor called.
ConsoleLogger destructor called.
ILogger destructor called.

评论区