C++中的八大设计原则

沉夢志昂丶

于 2024-06-17 10:42:35 发布

阅读量1.3k

点赞数 41

分类专栏： C++的自我救赎学习分享文章标签： c++ 开发语言设计原则

本文链接：https://blog.csdn.net/golojo/article/details/139737260

版权

分享同时被 3 个专栏收录

61 篇文章 0 订阅

订阅专栏

学习

59 篇文章 0 订阅

订阅专栏

C++的自我救赎

52 篇文章 2 订阅

订阅专栏

摘要

C+中的8大设计原则

1. 单一职责原则 (Single Responsibility Principle, SRP)

2. 开放封闭原则 (Open/Closed Principle, OCP)

3. 里氏替换原则 (Liskov Substitution Principle, LSP)

4. 依赖倒置原则 (Dependency Inversion Principle, DIP)

5. 接口隔离原则 (Interface Segregation Principle, ISP)

6. 迪米特法则 (Law of Demeter, LoD)

7. 合成复用原则 (Composite Reuse Principle, CRP)

8. 最少知识原则 (Least Knowledge Principle, LKP)

C++中的23种设计模式

摘要

C++ 中的八大设计原则可以帮助我们创建高内聚、低耦合的代码。

C+中的8大设计原则

1. 单一职责原则 (Single Responsibility Principle, SRP)

- 一个类应该只有一个引起变化的原因，即一个类只负责一个职责。可以提高类的可读性和可维护性，降低类的复杂度，但可能导致类的数量增加，进而增加系统设计的复杂性。

class UserManager {
public:
    void createUser(std::string username, std::string password) {
        // 创建用户
    }
    void deleteUser(std::string username) {
        // 删除用户
    }
    void generateUserReport(std::string username) {
        // 生成用户报告
    }
    void sendNotification(std::string message) {
        // 发送通知
    }
};

// 应用SRP后
class UserCreator {
public:
    void createUser(std::string username, std::string password) {
        // 创建用户
    }
};

class UserDeleter {
public:
    void deleteUser(std::string username) {
        // 删除用户
    }
};

class UserReporter {
public:
    void generateUserReport(std::string username) {
        // 生成用户报告
    }
};

class NotificationSender {
public:
    void sendNotification(std::string message) {
        // 发送通知
    }
};

2. 开放封闭原则 (Open/Closed Principle, OCP)

- 软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。可以提高系统的可扩展性，减少修改代码引入错误的风险，但需要仔细设计抽象层次，可能增加系统的复杂度。

class PaymentProcessor {
public:
    void processPayment(std::string paymentType) {
        if (paymentType == "CreditCard") {
            // 处理信用卡支付
        } else if (paymentType == "PayPal") {
            // 处理PayPal支付
        }
    }
};

// 应用OCP后
class IPayment {
public:
    virtual void processPayment() = 0;
};

class CreditCardPayment : public IPayment {
public:
    void processPayment() override {
        // 处理信用卡支付
    }
};

class PayPalPayment : public IPayment {
public:
    void processPayment() override {
        // 处理PayPal支付
    }
};

class PaymentProcessor {
public:
    void processPayment(IPayment* payment) {
        payment->processPayment();
    }
};

3. 里氏替换原则 (Liskov Substitution Principle, LSP)

- 子类对象应该能够替换掉基类对象且程序的行为不变。可以保证继承体系的正确性，增强代码的可替代性和可扩展性，但可能需要更多的抽象和接口设计，增加设计复杂度。

class Rectangle {
public:
    virtual void setWidth(double width) {
        this->width = width;
    }
    virtual void setHeight(double height) {
        this->height = height;
    }
    double getArea() {
        return width * height;
    }
protected:
    double width;
    double height;
};

class Square : public Rectangle {
public:
    void setWidth(double width) override {
        this->width = width;
        this->height = width;
    }
    void setHeight(double height) override {
        this->width = height;
        this->height = height;
    }
};

void process(Rectangle& r) {
    r.setWidth(5);
    r.setHeight(4);
    assert(r.getArea() == 20); // Square 不能替代 Rectangle
}

4. 依赖倒置原则 (Dependency Inversion Principle, DIP)

- 高层模块不应该依赖于低层模块，二者都应该依赖于抽象；抽象不应该依赖于具体，具体应该依赖于抽象。可以减少类之间的耦合，提高系统的灵活性和可维护性，但需要更多的抽象和接口设计，增加设计复杂度。

class Keyboard {
public:
    std::string getInput() {
        return "User input";
    }
};

class Monitor {
public:
    void display(std::string text) {
        // 显示文本
    }
};

class Computer {
public:
    void run() {
        std::string input = keyboard.getInput();
        monitor.display(input);
    }
private:
    Keyboard keyboard;
    Monitor monitor;
};

// 应用DIP后
class IInputDevice {
public:
    virtual std::string getInput() = 0;
};

class IOutputDevice {
public:
    virtual void display(std::string text) = 0;
};

class Keyboard : public IInputDevice {
public:
    std::string getInput() override {
        return "User input";
    }
};

class Monitor : public IOutputDevice {
public:
    void display(std::string text) override {
        // 显示文本
    }
};

class Computer {
public:
    Computer(IInputDevice* inputDevice, IOutputDevice* outputDevice)
        : inputDevice(inputDevice), outputDevice(outputDevice) {}

    void run() {
        std::string input = inputDevice->getInput();
        outputDevice->display(input);
    }
private:
    IInputDevice* inputDevice;
    IOutputDevice* outputDevice;
};

5. 接口隔离原则 (Interface Segregation Principle, ISP)

- 客户端不应该被迫依赖它不使用的方法，即类间的依赖关系应该建立在最小的接口上。可以减少代码的冗余，提高系统的灵活性和可维护性，但可能导致接口数量增加，进而增加系统设计的复杂性。

class IWorker {
public:
    virtual void work() = 0;
    virtual void eat() = 0;
};

class Worker : public IWorker {
public:
    void work() override {
        // 工作
    }
    void eat() override {
        // 吃饭
    }
};

class Robot : public IWorker {
public:
    void work() override {
        // 工作
    }
    void eat() override {
        // 机器人不吃饭
        throw std::logic_error("Robots don't eat");
    }
};

// 应用ISP后
class IWorkable {
public:
    virtual void work() = 0;
};

class IFeedable {
public:
    virtual void eat() = 0;
};

class Worker : public IWorkable, public IFeedable {
public:
    void work() override {
        // 工作
    }
    void eat() override {
        // 吃饭
    }
};

class Robot : public IWorkable {
public:
    void work() override {
        // 工作
    }
};

6. 迪米特法则 (Law of Demeter, LoD)

- 一个对象应该对其他对象有最少的了解，即“只和你的直接朋友通信”。可以降低对象之间的耦合，提高系统的模块化，但可能增加系统的消息传递复杂度。

class Engine {
public:
    void start() {
        // 启动引擎
    }
};

class Car {
public:
    Engine* getEngine() {
        return &engine;
    }
private:
    Engine engine;
};

class Driver {
public:
    void startCar(Car& car) {
        car.getEngine()->start();
    }
};

// 应用LoD后
class Engine {
public:
    void start() {
        // 启动引擎
    }
};

class Car {
public:
    void start() {
        engine.start();
    }
private:
    Engine engine;
};

class Driver {
public:
    void startCar(Car& car) {
        car.start();
    }
};

7. 合成复用原则 (Composite Reuse Principle, CRP)

- 尽量使用对象组合，而不是继承来达到复用的目的。这样可以减少类之间的耦合，提高系统的灵活性，但可能需要更多的对象管理代码，增加系统的复杂度。

class Engine {
public:
    void start() {
        // 启动引擎
    }
};

class ElectricEngine : public Engine {
public:
    void start() override {
        // 启动电动引擎
    }
};

class Car {
public:
    void start() {
        engine.start();
    }
private:
    Engine engine;
};

// 应用CRP后
class Engine {
public:
    virtual void start() = 0;
};

class GasEngine : public Engine {
public:
    void start() override {
        // 启动燃气引擎
    }
};

class ElectricEngine : public Engine {
public:
    void start() override {
        // 启动电动引擎
    }
};

class Car {
public:
    Car(Engine* engine) : engine(engine) {}

    void start() {
        engine->start();
    }
private:
    Engine* engine;
};

8. 最少知识原则 (Least Knowledge Principle, LKP)

- 一个对象应尽可能少地了解其他对象，以减少相互依赖。可以降低对象之间的耦合，提高系统的灵活性和可维护性，但也有可能需要引入更多的接口或中介，增加系统的复杂度。

class Engine {
public:
    void start() {
        // 启动引擎
    }
};

class Transmission {
public:
    void shiftGear() {
        // 换挡
    }
};

class Car {
public:
    Engine* getEngine() {
        return &engine;
    }
    Transmission* getTransmission() {
        return &transmission;
    }
private:
    Engine engine;
    Transmission transmission;
};

class Driver {
public:
    void startCar(Car& car) {
        car.getEngine()->start();
        car.getTransmission()->shiftGear();
    }
};

// 应用LKP后
class Engine {
public:
    void start() {
        // 启动引擎
    }
};

class Transmission {
public:
    void shiftGear() {
        // 换挡
    }
};

class Car {
public:
    void start() {
        engine.start();
        transmission.shiftGear();
    }
private:
    Engine engine;
    Transmission transmission;
};

class Driver {
public:
    void startCar(Car& car) {
        car.start();
    }
};