当前位置： 首页 > news >正文

C++中的八大设计原则

news 2025/7/17 22:11:21

目录

摘要

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();}
};

C++中的23种设计模式

C++中的23种设计模式_c++设计模式-CSDN博客

http://www.lryc.cn/news/378696.html

相关文章：

  • 2024广东省职业技能大赛云计算赛项实战——Minio服务搭建
  • 【考研408计算机组成原理】数值表示和运算之快速数值转换
  • 理解 JTBD 框架和EJ 理念：深挖以用户为中心的设计
  • 数据提取与治理：企业实现数据驱动决策的必经之路
  • Avalonia：一个.NET跨平台UI框架
  • 海量数据处理——bitMap/BloomFilter、hash + 统计 + 堆/归并/快排
  • TrainingArguments、ModelArguments、DataArguments参数使用(@dataclass)
  • 基于jeecgboot-vue3的Flowable流程-自定义业务表单处理（一）支持同一个业务多个关联流程的选择支持
  • 解决数据丢失问题的MacOS 数据恢复方法
  • [ARM-2D 专题]3. ##运算符
  • 基于语音识别的智能电子病历（五）电子病历编辑器
  • 云计算技术高速发展，优势凸显
  • 文本三剑客其二
  • 【达梦数据库】typeorm+node.js+达梦数据库返回自增列值
  • 【ARMv8/ARMv9 硬件加速系列 2.1 -- ARM NEON 向量寄存器单个元素赋值】
  • GD32学习
  • LangChain：如何高效管理 LLM 聊天历史记录？
  • 【React】useState 更新延迟的原因是什么，怎么解决？
  • 非关系型数据库NoSQL数据层解决方案 之 redis springboot整合与读写操作 2024详解以及window版redis5.0.14下载百度网盘
  • jigdo无法下载的文件
  • C#面：C# 类的执行顺序？
  • 昇思25天学习打卡营第3天|数据集Dataset
  • SpringCloud 服务调用 spring-cloud-starter-openfeign
  • 基于Elementui组件，在vue中实现多种省市区前端静态JSON数据展示并支持与后端交互功能，提供后端名称label和id
  • 基于DPU的云原生裸金属网络解决方案
  • pip install镜像源（更新和换源）
  • 基础语法——组合与继承
  • openGauss开发者大会、华为云HDC大会举行； PostgreSQL中国技术大会7月杭州开启
  • 编译报错：No rule to make target xx/libcam.halmemory_intermediates/export_includes
  • 【备考指南】CDA Level Ⅰ 最全备考攻略