继承、多态与异常
掌握虚函数多态、接口设计与异常安全
#继承:语法与访问控制
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++ 没有包的概念)。
#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),表里是该类的虚函数地址;对象里存一个指向 vtable 的隐藏指针 vptr。调用虚函数时,运行时通过 vptr 找到实际类型的 vtable 再跳转——这就是动态绑定。
三条必须遵守的规则:
- 多态基类的析构函数必须是
virtual。否则delete一个指向派生类对象的基类指针时,只会调用基类析构函数,派生类部分泄漏。这是 C++ 最经典的陷阱之一,Java/Python 完全不需要考虑(GC 会正确回收)。 - 重写虚函数时必须写
override。它让编译器检查"你确实在重写基类虚函数"——拼错参数类型时,override会立刻报错,否则你只是悄悄定义了一个新函数。 - 不希望被继续重写的虚函数加
final。
#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; 也要写出来),因为派生类析构时会调用它。
#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 基类。
#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()。
#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 引入的"函数承诺不抛异常"标记。它有两个作用:
- 优化:编译器知道不会抛异常,可以省略栈展开的准备工作,生成更小更快的代码。
std::vector在扩容时只有当元素类型的移动构造是noexcept时才敢用移动(否则退回拷贝,以保证强异常安全),这也是第 5 章强调给移动函数加noexcept的原因。 - 契约:如果
noexcept函数真的抛了异常,程序会直接调用std::terminate()终止——不会栈展开,不会调用析构。
栈展开(stack unwinding)是异常传播的过程:从 throw 点开始,逐层退出函数调用,每退出一层就析构该层的局部对象。这依赖于 RAII(第 5 章),是 C++ 异常安全的基础。Java 的 finally 需要手写清理逻辑,Python 的 with 也要显式写;C++ 里只要成员是 RAII 类型,就什么都不用做。
#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 的风格,但理解异常机制对读标准库和第三方代码仍然必要。
#小结
- C++ 支持多继承(Java 只能单继承 + 多接口);
public继承保持基类可见性,protected成员对派生类可见而private不可见。 - 成员函数默认非虚,必须显式
virtual;多态通过 vtable + vptr 实现动态绑定,有空间和时间开销。 - 三条铁律:多态基类的析构函数必须是 virtual;重写时必须写
override;不再允许重写时用final。 - 纯虚函数(
= 0)构成抽象类,等价于 Java 的 interface / Python 的 ABC;纯虚析构函数仍需提供函数体。 - 菱形继承会产生重复的基类子对象,用虚继承(
virtual public)共享;实际项目更推荐组合优先。 - 异常按引用捕获(
const std::exception&),顺序从派生到基类;C++ 没有检查型异常,且 iostream 默认用状态位而非异常。 noexcept既是优化提示也是契约,违反则直接std::terminate();异常传播时的栈展开依赖 RAII 自动析构局部对象。
#练习
- 定义一个
Shape抽象基类(纯虚area()和name(),虚析构),派生Triangle、Circle、Rectangle,把它们放进std::vector<std::unique_ptr<Shape>>并计算总面积。 - 故意去掉基类析构函数的
virtual,用std::unique_ptr<Shape>持有派生类对象并在派生类析构函数里打印,观察只调用了基类析构(漏掉派生部分)。加回virtual再对比。 - 实现一个
IPlayable接口(play()、stop()、is_playing()),写MusicPlayer和VideoPlayer两个实现;再写一个只依赖接口的Playlist类,遍历播放并统计时长。 - 构造菱形继承(
A→B1/B2→D),在A的构造函数里打印,观察普通继承打印两次、虚继承打印一次,并对比sizeof差异。再写safe_divide(a, b):除数为 0 时抛std::invalid_argument,在main里捕获并打印what();故意用catch (std::exception e)按值捕获一次,思考"对象切片"会丢失什么。最后用Tracer类观察异常栈展开:三层嵌套函数各创建一个 Tracer,从最深层抛出,记录并解释析构顺序。