【C++实战㉟】解锁C++面向对象设计：里氏替换原则实战指南

---

一、里氏替换原则的概念

1.1 里氏替换原则的定义

里氏替换原则（Liskov Substitution Principle，LSP）是面向对象设计的基本原则之一 ，由 Barbara Liskov 在 1987 年提出。其核心定义为：所有引用基类（父类）的地方必须能透明地使用其子类的对象，也就是子类对象能够替换程序中父类对象出现的任何地方，并且保证原来程序的逻辑行为不变及正确性不被破坏。

用一个生活中的例子来理解，比如我们定义一个 “交通工具” 类，其中有一个 “行驶” 的方法。汽车类继承自交通工具类，因为汽车是一种交通工具，它完全可以替换交通工具在程序中的位置去调用 “行驶” 方法，并且行为符合预期。但如果有一个 “火箭” 类，虽然它也能移动，但和一般意义上交通工具的行驶方式和应用场景差异巨大，如果让火箭类继承交通工具类并替换其在程序中的位置，就可能导致程序逻辑混乱，这就是违反了里氏替换原则。

1.2 里氏替换原则的优势

从实际项目经验来看，里氏替换原则有着诸多显著优势。在代码复用方面，遵循该原则可以使父类的代码得到充分复用，子类只需继承父类并根据自身需求扩展功能即可。例如在一个图形绘制项目中，定义一个 “图形” 父类，包含一些通用的属性和方法，如颜色、位置等，“圆形”“矩形” 等子类继承 “图形” 类，复用其通用部分，各自实现具体的绘制逻辑，减少了重复代码的编写。

在可维护性上，由于子类替换父类时不会破坏原有逻辑，当需要修改或扩展功能时，只需要在子类中进行操作，不会对使用父类的其他部分代码产生影响，降低了维护的难度和风险。比如在一个游戏开发项目中，角色类有通用的移动、攻击等方法，战士、法师等子类继承角色类，后续如果要为战士类增加特殊技能，只需要在战士子类中添加，不会影响到游戏中其他依赖角色类的系统。

从扩展性角度，当有新的需求出现时，可以很方便地通过创建新的子类来满足，而不需要大规模修改原有代码结构。以电商系统为例，已有的商品类有计算价格等方法，当新出现一种特殊的打折商品时，创建打折商品子类继承商品类，重写计算价格方法来实现打折逻辑，系统可以轻松扩展以适应新的业务场景。

1.3 里氏替换原则与多态的关系

里氏替换原则是实现多态的基础，二者相辅相成。多态是指同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。在 C++ 中，通过父类指针或引用指向子类对象，调用虚函数来实现多态。而里氏替换原则保证了这种父类与子类之间的替换关系是安全可靠的。

例如：

#include <iostream>class Animal {
public:virtual void sound() {std::cout << "Animal makes sound" << std::endl;}
};class Dog : public Animal {
public:void sound() override {std::cout << "Dog barks" << std::endl;}
};class Cat : public Animal {
public:void sound() override {std::cout << "Cat meows" << std::endl;}
};void makeSound(Animal* animal) {animal->sound();
}int main() {Animal* animal1 = new Dog();Animal* animal2 = new Cat();makeSound(animal1); makeSound(animal2); delete animal1;delete animal2;return 0;
}

在这个例子中，makeSound函数接受一个Animal类型的指针，根据里氏替换原则，我们可以传入Dog或Cat的对象指针，因为它们是Animal的子类。在运行时，根据实际指向的对象类型，调用相应子类的sound方法，实现了多态。如果没有里氏替换原则保证子类替换父类的正确性，多态就无法正常实现，可能会导致运行时错误。所以说，里氏替换原则为多态提供了安全保障，多态则是里氏替换原则在实际编程中的一种体现和应用方式。

二、里氏替换原则的实战应用

2.1 违反里氏替换原则的代码案例分析

在实际编程中，违反里氏替换原则的情况并不少见。以图形计算为例，假设我们有一个Rectangle类表示矩形，包含设置宽和高的方法，以及计算面积的方法 ：

class Rectangle {
protected:double width;double height;
public:void setWidth(double w) {width = w;}void setHeight(double h) {height = h;}double getArea() {return width * height;}
};

然后，我们可能错误地让Square类继承自Rectangle类，因为数学上正方形是矩形的一种特殊情况。但在编程实现中，正方形的边长是相等的，当重写Rectangle类的setWidth和setHeight方法时，就可能出现问题：

class Square : public Rectangle {
public:void setWidth(double w) override {width = w;height = w;}void setHeight(double h) override {width = h;height = h;}
};

在客户端代码中，我们可能会有这样的函数来处理矩形：

void processRectangle(Rectangle& rect) {rect.setWidth(5);rect.setHeight(4);double area = rect.getArea();// 预期面积为20assert(area == 20); 
}

当我们尝试将Square对象传入processRectangle函数时，问题就会暴露出来：

int main() {Square square;processRectangle(square); return 0;
}

在这个例子中，Square类违反了里氏替换原则。因为processRectangle函数是按照Rectangle类的行为来编写的，即设置宽和高是相互独立的操作。但Square类重写了setWidth和setHeight方法，使得这两个操作相互影响，导致传入Square对象时，计算出的面积与预期不符，破坏了程序的正确性。这种违反里氏替换原则的设计，会使代码的维护和扩展变得困难，增加了潜在的错误风险。

2.2 遵循里氏替换原则的类设计

为了遵循里氏替换原则，我们需要重新设计类结构。可以定义一个抽象的Shape类作为基类，包含一个纯虚函数getArea用于计算面积 ：

class Shape {
public:virtual double getArea() const = 0;virtual ~Shape() = default;
};然后，分别定义Rectangle类和Square类继承自Shape类，并实现各自的getArea方法 ：
class Rectangle : public Shape {
private:double width;double height;
public:Rectangle(double w, double h) : width(w), height(h) {}double getArea() const override {return width * height;}
};class Square : public Shape {
private:double side;
public:Square(double s) : side(s) {}double getArea() const override {return side * side;}
};

在客户端代码中，我们可以统一使用Shape类型的指针或引用来处理不同的图形：

void processShape(const Shape& shape) {double area = shape.getArea();// 可以根据不同的图形进行相应的处理
}

在main函数中，我们可以这样使用：

int main() {Rectangle rect(5, 4);Square square(5);processShape(rect); processShape(square); return 0;
}

通过这种设计，Rectangle类和Square类都能正确地替换Shape类，满足里氏替换原则。不同的图形类各自实现getArea方法，互不干扰，保证了程序的正确性和可维护性。同时，这种设计也提高了代码的扩展性，当有新的图形类（如圆形）需要添加时，只需要继承Shape类并实现getArea方法即可，不会影响到已有的代码。

2.3 里氏替换原则在继承体系中的应用

在复杂的继承体系中，里氏替换原则的应用尤为重要。以游戏开发中的角色系统为例，假设我们有一个抽象的Character类作为所有角色的基类，包含一些通用的属性和方法，如生命值、攻击力、移动方法等：

class Character {
protected:int health;int attackPower;
public:Character(int h, int ap) : health(h), attackPower(ap) {}virtual void move() = 0;virtual void attack() = 0;virtual ~Character() = default;
};

然后，有Warrior类和Mage类继承自Character类，分别实现各自的移动和攻击方式 ：

class Warrior : public Character {
public:Warrior(int h, int ap) : Character(h, ap) {}void move() override {// 战士的移动方式std::cout << "Warrior moves quickly" << std::endl;}void attack() override {// 战士的攻击方式std::cout << "Warrior attacks with sword" << std::endl;}
};class Mage : public Character {
public:Mage(int h, int ap) : Character(h, ap) {}void move() override {// 法师的移动方式std::cout << "Mage moves slowly" << std::endl;}void attack() override {// 法师的攻击方式std::cout << "Mage attacks with magic" << std::endl;}
};

在游戏的战斗系统中，我们可以通过Character类型的指针或引用来处理不同类型的角色：

void battle(Character& character) {character.move();character.attack();
}

在main函数中，我们可以这样调用：

int main() {Warrior warrior(100, 20);Mage mage(80, 30);battle(warrior); battle(mage); return 0;
}

在这个继承体系中，Warrior类和Mage类都遵循了里氏替换原则，能够正确地替换Character类。这使得战斗系统可以统一处理不同类型的角色，而不需要为每个角色类型编写单独的处理逻辑。同时，当有新的角色类型（如刺客）加入时，只需要继承Character类并实现相应的方法，战斗系统的代码不需要修改，符合开闭原则，提高了代码的可维护性和扩展性。在应用里氏替换原则时，需要注意子类不能改变父类的接口契约，包括方法签名、前置条件和后置条件等。子类可以扩展父类的功能，但不能削弱父类原有的功能，这样才能保证在继承体系中，子类对象能够安全地替换父类对象，确保程序的正确性和稳定性。

三、里氏替换原则的实战技巧

3.1 子类对父类方法的重写规范

在 C++ 中，当子类重写父类的方法时，需要严格遵循一定的规范，以确保符合里氏替换原则。首先，重写方法的参数列表必须与父类中被重写方法的参数列表完全一致，包括参数的类型、个数和顺序。这是因为如果参数列表不同，就不再是重写，而是函数重载，可能会导致在使用父类指针或引用调用方法时，无法正确调用到子类的实现。例如：

class Parent {
public:virtual void method(int a, double b) {// 父类方法实现}
};class Child : public Parent {
public:void method(int a, double b) override {// 子类重写方法实现}
};

其次，重写方法的返回值类型必须与父类中被重写方法的返回值类型相同，或者是父类返回值类型的子类型（在 C++ 中，这种情况相对较少，但在一些复杂的类继承体系中可能会出现）。如果返回值类型不兼容，同样会破坏里氏替换原则。比如：

class Parent {
public:virtual std::unique_ptr<int> method() {return std::make_unique<int>(0);}
};class Child : public Parent {
public:std::unique_ptr<int> method() override {return std::make_unique<int>(1);}
};

在这个例子中，Child类的method方法返回值类型与Parent类的method方法返回值类型相同，满足重写规范。

最后，在异常抛出方面，子类重写的方法不能抛出比父类方法更多的异常，或者抛出的异常类型必须是父类方法抛出异常类型的子类型。如果父类方法没有声明抛出异常，子类重写方法时也不应该抛出受检异常（在 C++ 中，虽然没有像 Java 那样严格区分受检异常和非受检异常，但也应遵循类似的原则）。例如：

class Parent {
public:virtual void method() throw(std::runtime_error) {// 父类方法实现}
};class Child : public Parent {
public:void method() throw(std::runtime_error) override {// 子类重写方法实现}
};

这里Child类的method方法抛出的异常类型与Parent类的method方法抛出的异常类型相同，符合规范。如果Child类的method方法抛出了std::logic_error（与std::runtime_error同级的异常类型），就违反了里氏替换原则。

3.2 子类新增方法的设计原则

当子类需要新增方法时，应确保这些新增方法不会破坏里氏替换原则。新增方法应是对父类功能的合理扩展，而不是改变父类已有的行为或依赖关系。首先，新增方法不应影响父类方法的正常调用和功能实现。例如，在一个图形绘制的继承体系中，Shape类是父类，有draw方法用于绘制图形。Circle类继承自Shape类，新增一个calculateRadius方法用于计算圆的半径，这是合理的扩展，因为calculateRadius方法与draw方法相互独立，不会影响draw方法在任何使用Shape类的地方的正常调用。

其次，新增方法不应使子类在替换父类时出现不符合预期的行为。比如，在一个游戏角色的继承体系中，Character类是父类，有move方法用于角色移动。如果Warrior类继承自Character类，新增一个specialAttack方法用于战士的特殊攻击，但在实现specialAttack方法时，修改了move方法依赖的一些内部状态，导致调用move方法时出现异常或不符合预期的移动行为，这就违反了里氏替换原则。

另外，在设计新增方法时，要考虑到子类与父类的一致性和可替代性。新增方法的命名、参数设计和功能语义应与父类的风格和设计意图相匹配，以便在使用父类指针或引用操作子类对象时，整个系统的行为是一致且可预测的。例如，在一个文件操作的继承体系中，File类是父类，有read和write方法。TextFile类继承自File类，新增一个countWords方法用于统计文本文件中的单词数量，countWords方法的命名和功能与文件操作的整体语义相符，不会破坏系统的一致性。

3.3 里氏替换原则的验证方法

在实际项目中，需要有效的方法来验证代码是否遵循里氏替换原则。一种常用的方法是测试驱动开发（Test - Driven Development，TDD）。在 TDD 中，先编写测试用例，然后根据测试用例编写代码。对于涉及继承体系的代码，编写一系列测试用例，确保在使用父类指针或引用操作子类对象时，程序的行为与预期一致。例如，在一个图形计算项目中，有Shape类和它的子类Rectangle和Circle。编写测试用例来验证Rectangle和Circle对象在替换Shape对象时，getArea方法的计算结果是否正确，以及其他与图形相关的操作是否符合预期。通过运行这些测试用例，可以发现是否存在违反里氏替换原则的情况，如子类重写方法的行为与父类不一致等问题。

另一种验证方法是契约式设计（Design by Contract，DbC）。契约式设计的核心思想是在方法调用者和方法实现者之间定义清晰的契约，包括前置条件、后置条件和不变式。在继承体系中，子类必须遵守父类方法定义的契约。例如，父类Stack类有一个push方法，其前置条件可能是栈未满，后置条件是元素被正确压入栈中。子类SafeStack继承自Stack类，在重写push方法时，必须确保满足父类push方法的前置条件，并且不能削弱后置条件。通过在代码中显式地定义和检查这些契约，可以验证子类是否能够正确替换父类，从而遵循里氏替换原则。在实际实现中，可以使用断言（assert）来检查前置条件和后置条件，确保契约的遵守。例如：

class Stack {
public:virtual void push(int value) {assert(!isFull()); // 模拟将元素压入栈的操作}virtual bool isFull() const = 0;
};class SafeStack : public Stack {
public:void push(int value) override {assert(!isFull()); // 可以添加额外的检查或操作Stack::push(value);}bool isFull() const override {// 实现判断栈是否满的逻辑}
};

在这个例子中，SafeStack类的push方法通过断言确保满足父类push方法的前置条件，有助于保证里氏替换原则的遵循。

四、实战项目：图形计算系统（里氏替换版）

4.1 项目需求

本图形计算系统旨在实现对多种常见图形的面积和周长计算功能，并且要求系统具备良好的扩展性，能够方便地添加新的图形类型。具体需求如下：

• 图形种类：支持矩形（Rectangle）、圆形（Circle）和正方形（Square）三种基本图形。后续应能轻松扩展其他图形，如三角形（Triangle）等。
• 计算方法：对于每种图形，需要提供计算其面积和周长的方法。例如，矩形的面积为长乘以宽，周长为 2 倍的长加宽；圆形的面积根据半径和圆周率计算（公式为$S=\pi r^2$），周长公式为$C=2\pi r$；正方形面积为边长的平方，周长为 4 倍边长。
• 子类替换要求：系统设计要遵循里氏替换原则，使得在任何使用父类图形（如 Shape）的地方，都可以透明地使用其子类图形（Rectangle、Circle、Square 等），而不会影响程序的正确性和功能。例如，有一个计算多个图形总面积的函数，它接受一个 Shape 类型的数组作为参数，那么这个函数应该能够正确处理传入的 Rectangle、Circle 或 Square 对象数组，无需为每个子类单独编写处理逻辑。

4.2 遵循里氏替换原则的代码实现

首先，定义一个抽象的Shape类作为所有图形的基类，其中包含纯虚函数getArea和getPerimeter用于计算面积和周长 ：

class Shape {
public:virtual double getArea() const = 0;virtual double getPerimeter() const = 0;virtual ~Shape() = default;
};

然后，分别实现Rectangle类、Circle类和Square类继承自Shape类，并实现各自的getArea和getPerimeter方法 ：

class Rectangle : public Shape {
private:double width;double height;
public:Rectangle(double w, double h) : width(w), height(h) {}double getArea() const override {return width * height;}double getPerimeter() const override {return 2 * (width + height);}
};class Circle : public Shape {
private:double radius;
public:Circle(double r) : radius(r) {}double getArea() const override {return 3.14159 * radius * radius;}double getPerimeter() const override {return 2 * 3.14159 * radius;}
};class Square : public Shape {
private:double side;
public:Square(double s) : side(s) {}double getArea() const override {return side * side;}double getPerimeter() const override {return 4 * side;}
};

在这个实现中，每个子类都正确地实现了父类Shape中定义的抽象方法，并且各自的行为符合对应的图形计算逻辑。这样，在使用Shape类的地方，都可以安全地替换为Rectangle、Circle或Square类的对象，满足里氏替换原则。例如，我们可以定义一个函数来计算一组图形的总面积：

double calculateTotalArea(const Shape* shapes[], int count) {double totalArea = 0;for (int i = 0; i < count; ++i) {totalArea += shapes[i]->getArea();}return totalArea;
}

这个函数接受一个Shape类型指针的数组和数组元素个数，通过调用每个Shape对象的getArea方法来计算总面积。由于Rectangle、Circle和Square类都遵循里氏替换原则，所以可以将这些子类对象的指针放入数组中传递给该函数，而无需担心类型不兼容或逻辑错误。

4.3 子类替换测试与正确性验证

为了验证代码是否遵循里氏替换原则以及功能的正确性，我们编写如下测试用例：

#include <iostream>
#include <cassert>int main() {Rectangle rect(5, 4);Circle circle(3);Square square(4);// 测试Rectangle的面积和周长计算assert(rect.getArea() == 5 * 4);assert(rect.getPerimeter() == 2 * (5 + 4));// 测试Circle的面积和周长计算assert(circle.getArea() == 3.14159 * 3 * 3);assert(circle.getPerimeter() == 2 * 3.14159 * 3);// 测试Square的面积和周长计算assert(square.getArea() == 4 * 4);assert(square.getPerimeter() == 4 * 4);// 测试子类替换Shape* shapes[3] = {&rect, &circle, &square};double totalArea = calculateTotalArea(shapes, 3);double expectedTotalArea = rect.getArea() + circle.getArea() + square.getArea();assert(totalArea == expectedTotalArea);std::cout << "All tests passed!" << std::endl;return 0;
}

在这个测试代码中，首先分别测试了Rectangle、Circle和Square类的面积和周长计算方法是否正确。然后，通过创建一个包含这三种图形对象指针的数组，并将其传递给calculateTotalArea函数，验证了在使用父类Shape的地方替换为子类对象后，计算总面积的功能仍然正确。如果所有断言都通过，说明代码遵循里氏替换原则，并且功能实现正确。运行上述测试代码，输出 “All tests passed!”，表明图形计算系统的实现符合里氏替换原则，并且面积和周长计算功能正确，具备良好的可靠性和稳定性。