QC++ / Qt 学习之路

继承、多态与异常

掌握虚函数多态、接口设计与异常安全

进阶第 10 / 48 章第一篇 · C++ 基础巩固

#继承:语法与访问控制

C++ 用 class Derived : public Base 表达继承。冒号后的 public / protected / private 决定基类成员在派生类里的可见性上限:public 继承保持原样(最常用),protected 继承把基类的 public 降为 protected,private 继承把全部降为 private。实际项目里 protected 和 private 继承极其罕见,看到时基本可以按"组合的替代品"理解。

和 Java 的关键差异:Java 只支持单继承(类只能 extends 一个类,多继承靠 implements 多个接口),而 C++ 支持真正的多继承。Python 也支持多继承并用 C3 线性化(MRO)解决方法查找顺序;C++ 没有 MRO,多继承时名字冲突必须显式用 Base::name 限定。

另外,C++ 里 private 成员对派生类不可见——如果希望子类能访问,要声明为 protected(Java 的 protected 还包含同包可见,C++ 没有包的概念)。

C++
#include <iostream>
#include <string>
#include <utility>      // std::move

class Animal {
public:
    Animal(std::string name) : name_(std::move(name)) {}

    void eat() const {
        std::cout << name_ << " 在进食\n";
    }

protected:      // 派生类可访问,外部不可访问
    std::string name_;

private:        // 派生类也不可访问
    int secret_code_{1234};
};

// public 继承:Animal 的 public 成员在 Dog 里仍是 public
class Dog : public Animal {
public:
    Dog(std::string name) : Animal(std::move(name)) {}

    void bark() const {
        // 可以访问 protected 成员
        std::cout << name_ << ":汪汪!\n";
    }

    // 派生类可以直接调用基类 public 方法
    void feed() const {
        eat();
    }

    // void peek() { std::cout << secret_code_; }   // 编译错误:private 不可访问
};

// 多继承:C++ 支持,Java 不支持(Java 只能 implements 多个接口)
class Flyable {
public:
    void fly() const { std::cout << "在飞\n"; }
};

class SuperDog : public Dog, public Flyable {
public:
    explicit SuperDog(std::string name) : Dog(std::move(name)) {}

    void show_off() const {
        bark();
        fly();       // 两个基类的方法都能用
    }
};

int main() {
    Dog d("旺财");
    d.eat();         // 继承自 Animal
    d.bark();
    d.feed();

    SuperDog s("飞天犬");
    s.show_off();
    s.eat();         // 通过 Dog 继承而来

    // 基类指针可以指向派生类对象,这是多态的基础
    Animal* a = &d;
    a->eat();        // 调用 Animal::eat(非虚,静态绑定)
    // a->bark();    // 编译错误:Animal 类型看不到 Dog 的成员

    std::cout << "sizeof(Dog) = " << sizeof(Dog) << "\n";
    return 0;
}

这段代码需要 #include <utility>(std::move)。

#虚函数与 vtable:多态的实现

这是与 Java 差异最大的一节。在 Java 里,所有实例方法默认都是虚函数(除非加 final 或 private)。C++ 恰恰相反:成员函数默认非虚,必须显式写 virtual 才有动态绑定。这个设计叫 "opt-in polymorphism",理由是虚函数有成本:每个对象多一个虚表指针(vptr),每次调用多一次间接跳转。

虚函数表 vtable 与运行时多态含虚函数的对象内存首部存放 vptr,指向类的虚函数表Base 对象vptrint base_dataBase 的 vtableBase::foo()Derived 对象vptrint derived_dataDerived 的 vtableDerived::foo()Base* p = new Derived();p->foo();// 编译期只知 p 是 Base*// 运行期沿 vptr 查表// 最终调用 Derived::foo调用链:p(Base* 指针)对象内 vptrDerived::foo()
虚函数表与动态派发:Base* 如何调用到 Derived::foo

机制简述:编译器为每个含虚函数的类生成一张虚函数表(vtable),表里是该类的虚函数地址;对象里存一个指向 vtable 的隐藏指针 vptr。调用虚函数时,运行时通过 vptr 找到实际类型的 vtable 再跳转——这就是动态绑定。

三条必须遵守的规则:

  1. 多态基类的析构函数必须是 virtual。否则 delete 一个指向派生类对象的基类指针时,只会调用基类析构函数,派生类部分泄漏。这是 C++ 最经典的陷阱之一,Java/Python 完全不需要考虑(GC 会正确回收)。
  2. 重写虚函数时必须写 override。它让编译器检查"你确实在重写基类虚函数"——拼错参数类型时,override 会立刻报错,否则你只是悄悄定义了一个新函数。
  3. 不希望被继续重写的虚函数加 final。
C++
#include <iostream>
#include <memory>
#include <string>
#include <vector>

class Shape {
public:
    Shape() = default;

    // 多态基类的析构函数必须是 virtual,否则通过基类指针 delete 会漏掉派生部分
    virtual ~Shape() {
        std::cout << "Shape 析构\n";
    }

    // 虚函数:派生类可以重写
    virtual double area() const {
        return 0.0;
    }

    virtual std::string name() const {
        return "抽象形状";
    }

    // 非虚函数:不希望被改变的行为,静态绑定
    void describe() const {
        std::cout << "这是一个 " << name() << ",面积 " << area() << "\n";
        // 注意:describe 里调用 name() 会走虚函数,这是模板方法模式的常见写法
    }
};

class Circle : public Shape {
public:
    explicit Circle(double r) : r_(r) {}

    ~Circle() override {
        std::cout << "Circle 析构\n";
    }

    double area() const override {
        return 3.14159265358979 * r_ * r_;
    }

    std::string name() const override {
        return "圆形";
    }

private:
    double r_;
};

class Rectangle : public Shape {
public:
    Rectangle(double w, double h) : w_(w), h_(h) {}

    ~Rectangle() override {
        std::cout << "Rectangle 析构\n";
    }

    double area() const override {
        return w_ * h_;
    }

    std::string name() const override {
        return "矩形";
    }

private:
    double w_, h_;
};

// final 禁止进一步派生或重写
class Square final : public Rectangle {
public:
    explicit Square(double s) : Rectangle(s, s) {}

    // final 也可以单独用在函数上:这是最后一次重写
    std::string name() const override final {
        return "正方形";
    }
};

int main() {
    // 通过基类指针操作不同派生类对象 —— 运行时多态
    std::vector<std::unique_ptr<Shape>> shapes;
    shapes.push_back(std::make_unique<Circle>(2.0));
    shapes.push_back(std::make_unique<Rectangle>(3.0, 4.0));
    shapes.push_back(std::make_unique<Square>(5.0));

    double total = 0.0;
    for (const auto& s : shapes) {
        s->describe();               // describe 非虚,内部调用虚函数 → 表现出多态
        total += s->area();          // 各调各的 area
    }
    std::cout << "总面积 = " << total << "\n";

    // 关键验证:unique_ptr<Shape> 析构时,因为有虚析构函数,
    // 会先调用 Circle::~Circle 再调用 Shape::~Shape(顺序正确)
    std::cout << "开始释放\n";
    shapes.clear();
    std::cout << "释放完毕\n";

    // 对比:如果没有虚析构函数,Circle 的析构不会被调用 → 资源泄漏
    return 0;
}

注意 describe() 的设计:它本身非虚(行为固定),但内部调用虚函数 name() 和 area(),从而让固定流程中嵌入可变行为。这是模板方法模式,在 Qt 的事件处理、QWidget::paintEvent 里会反复见到。

#纯虚函数与接口

把虚函数声明为 virtual 返回类型 函数名(...) = 0; 就得到纯虚函数;含纯虚函数的类是抽象类,不能实例化。

这就是 Java 的 interface、Python 的 abc.ABC + @abstractmethod、C# 的 interface。差别在于 C++ 没有独立的 interface 关键字——接口就是一个"所有函数都是纯虚、且通常没有成员变量"的类。惯例上把它命名为 IXXX 或 XXXInterface。

还有一个 C++ 特有的注意点:纯虚析构函数必须有函数体(virtual ~IX() = default; 也要写出来),因为派生类析构时会调用它。

C++
#include <iostream>
#include <memory>
#include <string>
#include <vector>

// 接口:只有纯虚函数,没有数据成员,等价于 Java 的 interface
class ILogger {
public:
    virtual ~ILogger() = default;               // 纯虚类的析构也要是 virtual

    virtual void log(const std::string& msg) = 0;
    virtual void set_level(int level) = 0;
};

// 实现一:打到控制台
class ConsoleLogger : public ILogger {
public:
    void log(const std::string& msg) override {
        std::cout << "[console] " << msg << "\n";
    }
    void set_level(int level) override { level_ = level; }
private:
    int level_{1};
};

// 实现二:收集到内存(便于测试)
class MemoryLogger : public ILogger {
public:
    void log(const std::string& msg) override {
        records_.push_back(msg);
    }
    void set_level(int level) override { level_ = level; }

    std::size_t count() const { return records_.size(); }
private:
    std::vector<std::string> records_;
    int level_{1};
};

// 业务代码只依赖接口,不依赖具体实现 —— 依赖倒置原则
// 对比 Java:参数写成 ILogger 接口;Python 里靠鸭子类型,连接口都不用声明
class OrderService {
public:
    explicit OrderService(ILogger& logger) : logger_(logger) {}

    void place_order(const std::string& item) {
        logger_.log("下单: " + item);
    }
private:
    ILogger& logger_;      // 引用接口,不使用具体类型
};

int main() {
    ConsoleLogger console;
    MemoryLogger  memory;

    OrderService s1(console);
    s1.place_order("键盘");

    OrderService s2(memory);
    s2.place_order("鼠标");
    s2.place_order("显示器");
    std::cout << "内存日志记录数 = " << memory.count() << "\n";

    // 抽象类和接口不能实例化
    // ILogger bad;                    // 编译错误:抽象类
    // ILogger* p = new ILogger();     // 编译错误

    // 用 unique_ptr 持有接口指针,配合多态
    std::unique_ptr<ILogger> logger = std::make_unique<ConsoleLogger>();
    logger->set_level(2);
    logger->log("通过接口指针调用");

    // 运行时类型识别:需要"向下转型"时用 dynamic_cast,失败返回 nullptr
    ILogger* raw = logger.get();
    if (auto* c = dynamic_cast<ConsoleLogger*>(raw)) {
        c->log("确认是 ConsoleLogger");
    }
    return 0;
}

dynamic_cast 需要基类有虚函数(开启 RTTI),失败时返回 nullptr(指针)或抛 std::bad_cast(引用)。它比 Java 的 instanceof + 强转更安全,但频繁使用通常意味着设计上该用虚函数来分派,而不是判断类型。

#菱形继承与虚继承

多继承带来一个 C++ 独有的问题:菱形继承(diamond problem)。当 D 同时继承 B1 和 B2,而两者都继承自 A 时,D 里会有两份 A 的子对象。访问 A 的成员会产生二义性,而且 A 的构造函数会被调用两次。

解法是虚继承(virtual public A):让 B1 和 B2 共享同一份 A 实例。

Java 完全没有这个问题(单继承 + 接口无状态)。Python 用 MRO 自动线性化,配合 super() 协作式调用。C++ 则要求你显式声明。

实际建议:优先用组合而非多继承,多继承主要用在"混入(mixin)接口"这类场景(也就是继承多个纯虚接口类,只有一个真正带状态的基类)。Qt 里 QObject 就是这样的设计:可以多重继承多个接口类,但只能有一个 QObject 基类。

C++
#include <iostream>
#include <string>

// 菱形继承的顶点
class Object {
public:
    Object() { std::cout << "Object 构造\n"; }
    int id_{0};                 // 一份数据成员,用来观察是否被复制
};

// 普通继承:每个分支各持有一份 Object
class Button : public Object {};
class Label  : public Object {};

class BadWidget : public Button, public Label {};

// 虚继承:两个分支共享同一份 Object
class VButton : virtual public Object {};
class VLabel  : virtual public Object {};

class GoodWidget : public VButton, public VLabel {
public:
    GoodWidget() {
        // 只有一份 id_,无需限定
        id_ = 42;
    }
};

int main() {
    std::cout << "=== 普通继承(两份 Object)===\n";
    BadWidget bad;
    // bad.id_ = 1;                     // 编译错误:二义性,有两个 id_
    bad.Button::id_ = 1;                // 必须显式限定
    bad.Label::id_  = 2;
    std::cout << "Button::id_ = " << bad.Button::id_
              << ",Label::id_ = " << bad.Label::id_ << "\n";

    std::cout << "=== 虚继承(共享一份 Object)===\n";
    GoodWidget good;
    std::cout << "good.id_ = " << good.id_ << "\n";   // 42,无二义性
    good.VButton::id_ = 7;
    std::cout << "通过 VButton 改后,VLabel 看到的是 "
              << good.VLabel::id_ << "\n";             // 也是 7,验证了共享

    std::cout << "sizeof(BadWidget) = " << sizeof(BadWidget)
              << ",sizeof(GoodWidget) = " << sizeof(GoodWidget) << "\n";
    return 0;
}

注意输出中 Object 构造 的打印次数:普通继承会打印两次,虚继承只打印一次。这是验证是否共享基类实例最直观的办法。

#异常:try / catch / throw

C++ 的异常机制表面与 Java、Python 相似(throw / try / catch),但有几个重要差异:

  • 没有检查型异常(checked exception)。Java 的 throws 会强制调用方处理,C++ 不会——函数签名上看不出会不会抛异常(noexcept 是唯一线索)。这是设计上的有意为之,也是很多 C++ 项目禁用异常的间接原因。
  • catch 按类型匹配,按引用捕获。永远写 catch (const std::exception& e),不要按值捕获(会切片,丢掉派生类的信息,比如 what() 不再是派生类实现)。
  • 捕获顺序从派生到基类。把 catch (const std::exception&) 写在最前面,后面的具体类型永远进不去。

标准异常体系在 <stdexcept> 里:std::runtime_error、std::logic_error、std::invalid_argument、std::out_of_range 等,都继承自 std::exception,重写了 what()。

C++
#include <fstream>
#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>

// 自定义异常:继承 std::runtime_error,自带 what()
class ConfigError : public std::runtime_error {
public:
    explicit ConfigError(const std::string& msg)
        : std::runtime_error("配置错误: " + msg) {}
};

double divide(double a, double b) {
    if (b == 0.0) {
        throw std::invalid_argument("除数不能为零");
    }
    return a / b;
}

int parse_port(const std::string& text) {
    int port = 0;
    try {
        port = std::stoi(text);          // stoi 失败会抛 std::invalid_argument
    } catch (const std::invalid_argument&) {
        throw ConfigError("端口不是数字: " + text);   // 重新抛出为自定义类型
    } catch (const std::out_of_range&) {
        throw ConfigError("端口超出范围: " + text);
    }
    if (port < 1 || port > 65535) {
        throw ConfigError("端口不合法: " + std::to_string(port));
    }
    return port;
}

int main() {
    // 1) 基本 try/catch,按引用捕获
    try {
        std::cout << divide(10, 2) << "\n";
        std::cout << divide(10, 0) << "\n";
    } catch (const std::invalid_argument& e) {
        std::cout << "捕获参数错误: " << e.what() << "\n";
    }

    // 2) 多个 catch 分支,顺序必须从派生到基类
    try {
        std::cout << parse_port("8080") << "\n";
        std::cout << parse_port("99999999") << "\n";
    } catch (const ConfigError& e) {          // 具体类型在前
        std::cout << "捕获 ConfigError: " << e.what() << "\n";
    } catch (const std::exception& e) {       // 通用基类在后(兜底)
        std::cout << "捕获标准异常: " << e.what() << "\n";
    } catch (...) {                           // 捕获一切(含非标准异常)
        std::cout << "捕获未知异常\n";
    }

    // 3) 异常与 RAII:容器和智能指针在栈展开时自动清理
    try {
        auto buffer = std::make_unique<int[]>(1000);
        std::vector<std::string> lines{"a", "b"};
        throw std::runtime_error("中途崩溃");
        // buffer 和 lines 依然会被正确析构,无需 try/finally
    } catch (const std::exception& e) {
        std::cout << "异常被捕获,资源已自动释放: " << e.what() << "\n";
    }

    // 4) 文件操作:用异常还是返回值?标准库默认不抛(除非显式开启)
    std::ifstream file("not_exist.txt");
    if (!file.is_open()) {
        std::cout << "文件打开失败(iostream 默认用状态位而非异常)\n";
    }
    return 0;
}

第 4 点值得强调:C++ 标准库的 iostream 默认不用异常,而是用状态位(is_open()、fail())。这与 Python(打不开就抛 IOError)、Java(FileNotFoundException)的直觉不同,新手常在这里困惑——记得手动检查状态。

#noexcept 与栈展开

noexcept 是 C++11 引入的"函数承诺不抛异常"标记。它有两个作用:

  1. 优化:编译器知道不会抛异常,可以省略栈展开的准备工作,生成更小更快的代码。std::vector 在扩容时只有当元素类型的移动构造是 noexcept 时才敢用移动(否则退回拷贝,以保证强异常安全),这也是第 5 章强调给移动函数加 noexcept 的原因。
  2. 契约:如果 noexcept 函数真的抛了异常,程序会直接调用 std::terminate() 终止——不会栈展开,不会调用析构。

栈展开(stack unwinding)是异常传播的过程:从 throw 点开始,逐层退出函数调用,每退出一层就析构该层的局部对象。这依赖于 RAII(第 5 章),是 C++ 异常安全的基础。Java 的 finally 需要手写清理逻辑,Python 的 with 也要显式写;C++ 里只要成员是 RAII 类型,就什么都不用做。

C++
#include <iostream>
#include <new>
#include <stdexcept>
#include <string>
#include <type_traits>   // std::is_nothrow_move_assignable_v
#include <utility>
#include <vector>

// RAII 追踪对象:用来观察栈展开过程中的析构顺序
class Tracer {
public:
    explicit Tracer(std::string name) : name_(std::move(name)) {
        std::cout << "  构造 " << name_ << "\n";
    }
    ~Tracer() {
        std::cout << "  析构 " << name_ << "\n";
    }
private:
    std::string name_;
};

// noexcept 函数:承诺不抛异常
int safe_add(int a, int b) noexcept {
    return a + b;
}

// 移动构造标记 noexcept,vector 扩容时才会用移动而不是拷贝
struct Item {
    std::string data;
    Item(std::string s) : data(std::move(s)) {}
    Item(Item&&) noexcept = default;              // 关键: noexcept
    Item& operator=(Item&&) noexcept = default;
    Item(const Item&) = default;
    Item& operator=(const Item&) = default;
};

// 条件 noexcept:只有 T 的移动不抛异常时,本函数才 noexcept
template <typename T>
void relocate(T& a, T& b) noexcept(std::is_nothrow_move_assignable_v<T>) {
    a = std::move(b);
}

void level3() {
    Tracer t3("level3 的局部对象");
    throw std::runtime_error("深层出错");
    // t3 会在栈展开时析构
}

void level2() {
    Tracer t2("level2 的局部对象");
    level3();
}

void level1() {
    Tracer t1("level1 的局部对象");
    level2();
}

int main() {
    // 观察栈展开:析构顺序与构造顺序相反
    try {
        level1();
    } catch (const std::exception& e) {
        std::cout << "顶层捕获: " << e.what() << "\n";
    }

    // noexcept 的编译期查询
    static_assert(noexcept(safe_add(1, 2)), "safe_add 应该是 noexcept");
    std::cout << "safe_add 是 noexcept: " << std::boolalpha
              << noexcept(safe_add(1, 2)) << "\n";

    // Item 的移动是 noexcept,vector 扩容会走移动
    std::vector<Item> items;
    items.reserve(1);
    items.emplace_back("a");
    items.emplace_back("b");     // 触发扩容 → 移动而非拷贝
    std::cout << "items 大小 = " << items.size() << "\n";

    // 内存分配失败:默认抛 std::bad_alloc
    try {
        std::vector<int> huge(1'000'000'000'000ULL);   // 大概率失败
    } catch (const std::bad_alloc& e) {
        std::cout << "内存不足: " << e.what() << "\n";
    }
    return 0;
}

关于"要不要用异常"的工程建议:标准做法是用异常表示异常情况(不可恢复的错误),用返回值/std::optional 表示预期的失败(比如"用户输入格式不对")。Google C++ Style Guide 禁用异常,但那是为了兼容已有代码库;Qt 同样基本不用异常(历史原因,且要跨 ABI 边界)。本教程后续会遵循 Qt 的风格,但理解异常机制对读标准库和第三方代码仍然必要。

#小结

  1. C++ 支持多继承(Java 只能单继承 + 多接口);public 继承保持基类可见性,protected 成员对派生类可见而 private 不可见。
  2. 成员函数默认非虚,必须显式 virtual;多态通过 vtable + vptr 实现动态绑定,有空间和时间开销。
  3. 三条铁律:多态基类的析构函数必须是 virtual;重写时必须写 override;不再允许重写时用 final。
  4. 纯虚函数(= 0)构成抽象类,等价于 Java 的 interface / Python 的 ABC;纯虚析构函数仍需提供函数体。
  5. 菱形继承会产生重复的基类子对象,用虚继承(virtual public)共享;实际项目更推荐组合优先。
  6. 异常按引用捕获(const std::exception&),顺序从派生到基类;C++ 没有检查型异常,且 iostream 默认用状态位而非异常。
  7. noexcept 既是优化提示也是契约,违反则直接 std::terminate();异常传播时的栈展开依赖 RAII 自动析构局部对象。

#练习

  1. 定义一个 Shape 抽象基类(纯虚 area() 和 name(),虚析构),派生 Triangle、Circle、Rectangle,把它们放进 std::vector<std::unique_ptr<Shape>> 并计算总面积。
  2. 故意去掉基类析构函数的 virtual,用 std::unique_ptr<Shape> 持有派生类对象并在派生类析构函数里打印,观察只调用了基类析构(漏掉派生部分)。加回 virtual 再对比。
  3. 实现一个 IPlayable 接口(play()、stop()、is_playing()),写 MusicPlayer 和 VideoPlayer 两个实现;再写一个只依赖接口的 Playlist 类,遍历播放并统计时长。
  4. 构造菱形继承(A → B1/B2 → D),在 A 的构造函数里打印,观察普通继承打印两次、虚继承打印一次,并对比 sizeof 差异。再写 safe_divide(a, b):除数为 0 时抛 std::invalid_argument,在 main 里捕获并打印 what();故意用 catch (std::exception e) 按值捕获一次,思考"对象切片"会丢失什么。最后用 Tracer 类观察异常栈展开:三层嵌套函数各创建一个 Tracer,从最深层抛出,记录并解释析构顺序。
我的学习笔记笔记总览
笔记保存在本机浏览器(localStorage),换设备或清理缓存会丢失;重要内容请点「导出全部笔记」存成 .md 文件。