【设计模式】02-SOLID 设计原则

面向对象编程（OOP）是一种广泛应用的编程范式，它鼓励开发者通过对象来模拟现实世界。为了提高面向对象设计（OOD）的质量和可维护性，Robert C. Martin提出了 SOLID 原则，这五个原则构成了编写良好、可扩展和可维护OOP代码的基础。

SOLID是一个缩写词，代表以下设计原则（及其缩写）：

Single Responsibility Principle (SRP)
Open-Closed Principle (OCP)
Liskov Substitution Principle (LSP)
Interface Segregation Principle (ISP)
Dependency Inversion Principle (DIP)

这五个特定的主题贯穿了对模式和软件设计的一般讨论，所以在我们深入研究设计模式之前（我知道你们都很渴望），我们将简要回顾一下SOLID原则是什么。

2.1 S - 单一职责原则（Single Responsibility Principle）

每个类应该只有一个改变的理由，即一个类应该只负责一个功能领域中的相应职责。这有助于使类更加可维护，并减少在代码需要变更时出现的复杂性。

C++ 示例：

cpp 复制代码

class Logger {
public:
    void logToFile(const std::string& message) {
        // 将消息记录到文件
    }
};

class Order {
    // Order类的其他职责...

    Logger logger;

public:
    void finalizeOrder() {
        // 完成订单处理
        logger.logToFile("Order finalized.");
    }
};

在上述示例中，Logger类负责日志记录的职责，而Order类处理订单相关的业务逻辑，并使用Logger来记录日志，而不是自己处理日志逻辑。

2.2 O - 开放/封闭原则（Open/Closed Principle）

软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。这意味着应该能够在不修改现有代码的情况下增加新功能。

C++ 示例：

cpp 复制代码

class Shape {
public:
    virtual double area() const = 0;
};

class Rectangle : public Shape {
    double width, height;

public:
    double area() const override {
        return width * height;
    }
};

class Circle : public Shape {
    double radius;

public:
    double area() const override {
        return 3.14159 * radius * radius;
    }
};

这里，Shape是一个抽象基类，它允许派生类通过实现area方法来扩展，而无需修改基类或其他派生类。

2.3 L - 里氏替换原则（Liskov Substitution Principle）

子类型必须能够替换掉它们的基类型。这意味着如果程序中使用了基类的对象，那么可以无缝地使用其子类的对象替换，而不会影响程序的正确性。

C++ 示例：

cpp 复制代码

void printArea(const Shape& shape) {
    std::cout << shape.area() << std::endl;
}

// 由于Rectangle和Circle都是Shape的子类，
// 它们的对象都可以传递给printArea函数。
Rectangle rect;
Circle circle;
printArea(rect);
printArea(circle);

在这个例子中，不管是Rectangle还是Circle对象，都可以传递给printArea函数，因为它们都遵循Shape的约定。

2.4 I - 接口隔离原则（Interface Segregation Principle）

客户端不应该被迫依赖于它们不使用的方法。接口隔离原则鼓励我们创建细粒度的接口，这样客户端只需要了解它们真正使用的方法。

C++ 示例：

cpp 复制代码

class Printer {
public:
    virtual void printDocument(const Document& doc) = 0;
};

class Scanner {
public:
    virtual void scanDocument(Document& doc) = 0;
};

// 不应该强迫一个只打印机实现扫描方法，
// 或者一个只扫描仪实现打印方法。
class OfficePrinter : public Printer, public Scanner {
    void printDocument(const Document& doc) override {
        // 实现打印
    }

    void scanDocument(Document& doc) override {
        // 实现扫描
    }
};

在这里，OfficePrinter实现了Printer和

Scanner接口，但如果有一个只需要打印功能的类，它就只实现Printer接口。

2.5 D - 依赖倒置原则（Dependency Inversion Principle）

高层模块不应该依赖低层模块，两者都应该依赖抽象。抽象不应该依赖细节，细节应该依赖抽象。这意味着我们应该针对接口编程，而不是针对实现编程。

C++ 示例：

cpp 复制代码

class DataAccess {
public:
    virtual Data getData() = 0;
};

class FileDataAccess : public DataAccess {
    Data getData() override {
        // 从文件系统获取数据
    }
};

class Application {
    DataAccess& dataAccess;

public:
    Application(DataAccess& da) : dataAccess(da) {}

    void doWork() {
        Data data = dataAccess.getData();
        // 使用数据
    }
};

FileDataAccess fileDataAccess;
Application app(fileDataAccess);
app.doWork();

这里的Application依赖于DataAccess抽象，而不是具体的FileDataAccess，使得数据访问的具体实现可以灵活更换。

SOLID原则为面向对象设计提供了强大的指导，遵循这些原则将帮助你构建更健壮、灵活且易于维护的软件系统。在C++编程中运用这些原则，能够使你的代码质量大幅提升。