【C++】【设计模式的六大原则】

news/2024/4/19 8:22:18/文章来源:https://blog.csdn.net/zwh1298454060/article/details/136523358

文章目录

  • 一、设计模式的六大原则
    • 1.1单一职责原则(Single Responsibility Principle,SRP):
    • 1.2 开放封闭原则(Open/Closed Principle,OCP):
    • 1.3里氏替换原则(Liskov Substitution Principle,LSP):
    • 1.4 依赖倒置原则(Dependency Inversion Principle,DIP):
    • 1.5 接口隔离原则(Interface Segregation Principle,ISP):
    • 1.6 合成复用原则(Composite/Aggregate Reuse Principle,CARP):
  • 二、总结

一、设计模式的六大原则

设计模式的六大原则是常见的面向对象设计原则,它们有助于编写可维护、可扩展和易于理解的代码。这些原则包括:

1.1单一职责原则(Single Responsibility Principle,SRP):

一个类应该只有一个引起变化的原因。换句话说,一个类应该只负责一种类型的任务或功能。这样做可以使类更加内聚,并且减少对类的修改造成的影响。

代码示例:

#include <iostream>
#include <string>// 用户信息类
class UserInfo {
private:std::string username;std::string email;public:UserInfo(const std::string& username, const std::string& email): username(username), email(email) {}// 获取用户名std::string getUsername() const {return username;}// 获取邮箱std::string getEmail() const {return email;}
};// 用户验证类
class UserValidator {
public:bool validate(const UserInfo& user) {// 对用户进行验证的逻辑...return true; // 假设验证通过}
};// 用户通知类
class UserNotifier {
public:void notify(const UserInfo& user, const std::string& message) {// 向用户发送通知的逻辑...std::cout << "Sending notification to " << user.getUsername() << ": " << message << std::endl;}
};int main() {// 创建用户信息对象UserInfo user("john_doe", "john@example.com");// 用户验证UserValidator validator;if (validator.validate(user)) {// 用户验证通过,发送通知UserNotifier notifier;notifier.notify(user, "Welcome to our system!");} else {std::cout << "User validation failed!" << std::endl;}return 0;
}

在这个例子中,我们将 User 类拆分成了 UserInfo、UserValidator 和 UserNotifier 三个类。UserInfo 类负责管理用户信息,UserValidator 类负责验证用户,UserNotifier 类负责向用户发送通知。每个类都只负责一个单一的功能,这样提高了代码的可维护性和可扩展性,并且减少了对类的修改造成的影响。

1.2 开放封闭原则(Open/Closed Principle,OCP):

软件实体(类、模块、函数等)应该对扩展开放,对修改关闭。换句话说,应该通过扩展已有的代码来添加新功能,而不是修改已有的代码。这可以通过抽象和接口实现来实现。
代码示例:
假设我们有一个图形绘制程序,它可以绘制不同形状的图形,如圆形、矩形等。现在我们需要给程序添加一个新的功能,即计算每个图形的面积。按照开放封闭原则的要求,我们应该通过扩展已有的代码来实现这个功能,而不是修改已有的代码。

#include <iostream>
#include <vector>
#include <cmath>// 抽象图形类
class Shape {
public:virtual double area() const = 0; // 计算图形的面积virtual void draw() const = 0;   // 绘制图形virtual ~Shape() {} // 虚析构函数,确保子类的析构函数被调用
};// 圆形类
class Circle : public Shape {
private:double radius;public:Circle(double r) : radius(r) {}double area() const override {return M_PI * radius * radius;}void draw() const override {std::cout << "Drawing a circle with radius " << radius << std::endl;}
};// 矩形类
class Rectangle : public Shape {
private:double width;double height;public:Rectangle(double w, double h) : width(w), height(h) {}double area() const override {return width * height;}void draw() const override {std::cout << "Drawing a rectangle with width " << width << " and height " << height << std::endl;}
};// 计算图形的总面积
double calculateTotalArea(const std::vector<Shape*>& shapes) {double totalArea = 0.0;for (const auto& shape : shapes) {totalArea += shape->area();}return totalArea;
}int main() {std::vector<Shape*> shapes;shapes.push_back(new Circle(5.0));shapes.push_back(new Rectangle(3.0, 4.0));// 绘制图形for (const auto& shape : shapes) {shape->draw();}// 计算总面积double totalArea = calculateTotalArea(shapes);std::cout << "Total area of all shapes: " << totalArea << std::endl;// 释放内存for (const auto& shape : shapes) {delete shape;}return 0;
}

在这个例子中,我们定义了一个抽象基类 Shape,它包含纯虚函数 area() 用于计算图形的面积,以及纯虚函数 draw() 用于绘制图形。然后我们创建了两个具体的图形类 Circle 和 Rectangle,它们分别继承自 Shape 类,并且实现了 area() 和 draw() 函数。通过这种方式,我们可以通过扩展新的图形类来添加新功能,而不需要修改已有的代码。

1.3里氏替换原则(Liskov Substitution Principle,LSP):

子类型必须能够替换其基类型。也就是说,派生类必须能够替换基类并且不会影响程序的正确性。这要求派生类在继承基类时不应该改变基类的行为。
代码示例:

#include <iostream>// 基类
class Shape {
public:virtual double area() const = 0; // 纯虚函数,计算面积
};// 派生类:矩形
class Rectangle : public Shape {
private:double width;double height;public:Rectangle(double w, double h) : width(w), height(h) {}double area() const override {return width * height;}
};// 派生类:正方形
class Square : public Shape {
private:double side;public:Square(double s) : side(s) {}double area() const override {return side * side;}
};// 计算面积的函数
void printArea(const Shape& shape) {std::cout << "Area: " << shape.area() << std::endl;
}int main() {Rectangle rect(5.0, 4.0);Square square(3.0);printArea(rect);   // 输出矩形的面积printArea(square); // 输出正方形的面积return 0;
}

在这个例子中,Rectangle 和 Square 都是 Shape 的派生类,它们都实现了 area() 函数来计算各自的面积。在 printArea() 函数中,我们通过基类的引用来传递 Rectangle 和 Square 对象,并调用它们的 area() 函数。由于派生类能够替换其基类,因此我们可以将 Rectangle 和 Square 对象传递给 printArea() 函数,而不会影响程序的正确性。

1.4 依赖倒置原则(Dependency Inversion Principle,DIP):

高层模块不应该依赖于低层模块,两者都应该依赖于抽象。抽象不应该依赖于具体实现,具体实现应该依赖于抽象。这可以通过依赖注入等技术来实现。
代码示例:

#include <iostream>
#include <string>// 定义抽象的消息发送接口
class IMessageSender {
public:virtual void sendMessage(const std::string& message) const = 0;
};// 实现具体的邮件发送类
class EmailSender : public IMessageSender {
public:void sendMessage(const std::string& message) const override {std::cout << "Sending email: " << message << std::endl;}
};// 实现具体的短信发送类
class SMSSender : public IMessageSender {
public:void sendMessage(const std::string& message) const override {std::cout << "Sending SMS: " << message << std::endl;}
};// 高层模块,依赖于抽象的消息发送接口
class NotificationService {
private:const IMessageSender& messageSender;public:NotificationService(const IMessageSender& sender) : messageSender(sender) {}void sendNotification(const std::string& message) const {messageSender.sendMessage(message);}
};int main() {EmailSender emailSender;SMSSender smsSender;// 使用邮件发送服务NotificationService emailService(emailSender);emailService.sendNotification("Hello, this is an email notification.");std::cout << std::endl;// 使用短信发送服务NotificationService smsService(smsSender);smsService.sendNotification("Hello, this is an SMS notification.");return 0;
}

在这个例子中,IMessageSender 是一个抽象的消息发送接口,EmailSender 和 SMSSender 是具体的邮件发送类和短信发送类,它们都实现了 IMessageSender 接口。NotificationService 是一个高层模块,它不直接依赖于具体的邮件发送类或短信发送类,而是依赖于抽象的 IMessageSender 接口。这样做使得 NotificationService 更加灵活,可以轻松地切换不同的消息发送实现,而不需要修改 NotificationService 的代码。

1.5 接口隔离原则(Interface Segregation Principle,ISP):

客户端不应该依赖它不需要的接口。换句话说,应该将大的接口拆分成多个小的接口,以便客户端只需要知道与自己相关的接口。
代码示例:

#include <iostream>// 定义一个门的接口
class Door {
public:virtual void open() = 0;virtual void close() = 0;
};// 定义一个锁的接口
class Lock {
public:virtual void lock() = 0;virtual void unlock() = 0;
};// 实现木门
class WoodenDoor : public Door {
public:void open() override {std::cout << "Wooden door opened." << std::endl;}void close() override {std::cout << "Wooden door closed." << std::endl;}
};// 实现智能锁
class SmartLock : public Lock {
public:void lock() override {std::cout << "Smart lock locked." << std::endl;}void unlock() override {std::cout << "Smart lock unlocked." << std::endl;}
};// 定义一个安全门,它同时具有门和锁的功能
class SecurityDoor : public Door, public Lock {
public:void open() override {std::cout << "Security door opened." << std::endl;}void close() override {std::cout << "Security door closed." << std::endl;}void lock() override {std::cout << "Security door locked." << std::endl;}void unlock() override {std::cout << "Security door unlocked." << std::endl;}
};int main() {WoodenDoor woodenDoor;SmartLock smartLock;SecurityDoor securityDoor;// 使用木门woodenDoor.open();woodenDoor.close();// 使用智能锁smartLock.lock();smartLock.unlock();// 使用安全门securityDoor.open();securityDoor.lock();securityDoor.unlock();securityDoor.close();return 0;
}

在这个例子中,我们定义了 Door 和 Lock 两个接口,分别表示门和锁的功能。然后我们实现了 WoodenDoor 类和 SmartLock 类来分别表示木门和智能锁,并且它们分别实现了对应的接口。最后,我们定义了 SecurityDoor 类,它同时继承了 Door 和 Lock 接口,表示一个同时具有门和锁功能的安全门。通过这样的设计,客户端只需要使用与自己相关的接口,不需要依赖于不需要的接口,实现了接口隔离原则。

1.6 合成复用原则(Composite/Aggregate Reuse Principle,CARP):

尽量使用合成/聚合,而不是继承来实现代码复用。通过将多个对象组合成一个更大的对象,可以更灵活地管理对象之间的关系,并且减少了继承带来的耦合。
代码示例:
假设我们有一个 Car 类和一个 Engine 类,Car 类需要使用 Engine 类的功能来驱动汽车。如果我们使用继承来实现这个关系,那么 Car 类将会成为 Engine 类的子类,这样做会导致 Car 类与 Engine 类之间的强耦合,而且如果我们想要更换引擎,可能会导致修改 Car 类的代码。相反,我们可以使用合成复用原则,将 Engine 类作为 Car 类的一个成员对象,使得 Car 类可以通过调用 Engine 对象的方法来驱动汽车。

#include <iostream>// 引擎类
class Engine {
public:void start() {std::cout << "Engine started." << std::endl;}void stop() {std::cout << "Engine stopped." << std::endl;}
};// 汽车类
class Car {
private:Engine engine; // 引擎对象作为成员public:void start() {engine.start(); // 调用引擎对象的方法std::cout << "Car started." << std::endl;}void stop() {engine.stop(); // 调用引擎对象的方法std::cout << "Car stopped." << std::endl;}
};int main() {Car car;car.start(); // 启动汽车car.stop();  // 停止汽车return 0;
}

在这个例子中,Car 类包含了一个 Engine 对象作为成员。通过将 Engine 对象作为 Car 类的一部分,我们可以在 Car 类中调用 Engine 类的方法来启动和停止汽车。这样做使得 Car 类和 Engine 类之间的耦合程度降低,同时也使得代码更加灵活和可维护。

二、总结

书山有路勤为径,学海无涯苦作舟。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.luyixian.cn/news_show_997508.aspx

如若内容造成侵权/违法违规/事实不符,请联系dt猫网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

前端网络请求异步处理——Promise使用记录

Promise是ES6中新增的一个处理复杂异步请求的工具&#xff0c;其主要形式为&#xff1a; const baseUrl http://localhost:80 export const $request (param {}) > {console.log(请求参数, param)return new Promise((resolve, reject) > {wx.request({url: baseUrl …

海外服务器被DDOS攻击了该怎么办

在当今全球化的时代&#xff0c;越来越多的企业和组织选择将业务拓展至海外市场。然而&#xff0c;随着业务的扩大和网络的延伸&#xff0c;也面临着来自不同地区的网络威胁和攻击风险。如果您的海外服务器遭受了DDOS攻击&#xff0c;以下是一些应对措施&#xff1a; 一、立即断…

【Redis】Redis的应用场景

&#x1f4dd;个人主页&#xff1a;五敷有你 &#x1f525;系列专栏&#xff1a;Redis ⛺️稳中求进&#xff0c;晒太阳 Redis的应用场景&#xff1a; 限流 要求10s内只能访问一次 RequestMapping("xian")public String xianLiu(String sign){String sign1 …

力扣刷题

文章目录 1. 双指针1.1 两数之和1.2 三数之和1.3 盛最多水的容器1.4 接雨水 2. 字串2.1 滑动窗口最大值 3. 动态规划4. 多维动态规划4.1 最长回文字串 1. 双指针 1.1 两数之和 思路&#xff1a;因为是有序数组&#xff0c; 1.2 三数之和 题目要求不能重复 思路&#xff1a;三…

简明固体物理--晶体的形成与晶体结构的描述

简明固体物理-国防科技大学 chapter 1 Formation of Crystal Contents and roadmapQuantum Mechanics and atomic structureElectronsOld quantum theoryMethod of Quantum MechanicsDistributing functions of micro-particles BindingCrystal structure and typical crystal…

YOLOv9(2):YOLOv9网络结构

1. 前言 本文仅以官方提供的yolov9.yaml来进行简要讲解。 讲解之前&#xff0c;还是要做一些简单的铺垫。 Slice层不做任何的操作&#xff0c;纯粹是做一个占位层。这样一来&#xff0c;在parse_model时&#xff0c;ch[n]可表示第n层的输出通道。 Detect和DDetect主要区别还…

Java开发从入门到精通(一):Java的基础语法进阶

Java大数据开发和安全开发 &#xff08;一&#xff09;Java注释符1.1 单行注释 //1.2 多行注释 /* */1.3 文档注释 /** */1.4 各种注释区别1.5 注释的特点1.5 注释的快捷键 &#xff08;二&#xff09;Java的字面量&#xff08;三&#xff09;Java的变量3.1 认识变量3.2 为什么…

例行性工作(at,crontab)

目录 单一执行的例行性工作at 语法 选项 时间格式 at的工作文件存放目录 at工作的日志文件 实例 命令总结&#xff1a; 循环执行的例行性工作crond 语法 选项 crontab工作调度对应的系统服务 crontab工作的日志文件 用户定义计划任务的文件所在目录 动态查看 crontab文件格式 文…

集合拆分Lists.partition的使用

集合拆分Lists.partition的使用 集合拆分Lists.partition的使用 需要的包 import com.google.common.collect.Lists;引入maven依赖 <dependency><groupId>com.google.guava</groupId><artifactId>guava</artifactId><version>21.0</…

真Unity-Editor二次开发-ScriptableObject 可自定义UI界面

关于ScriptablObject自定义 作为官方指定的&#xff0c;曾经我也吐槽过ScriptableObject很鸡肋&#xff0c;个人曾经也是强烈反对在项目中使用&#xff0c;但直到我今天看到下面这个代码&#xff0c;菜发现其实只是自己太菜鸡而已 --------------不想多写什么 -------------…

Rust组织管理,箱Crate包Package和模块module定义和区别,use关键字作用

Rust 组织管理 任何一门编程语言如果不能组织代码都是难以深入的&#xff0c;几乎没有一个软件产品是由一个源文件编译而成的。 本教程到目前为止所有的程序都是在一个文件中编写的&#xff0c;主要是为了方便学习 Rust 语言的语法和概念。 对于一个工程来讲&#xff0c;组织…

NineData与OceanBase完成产品兼容认证,共筑企业级数据库新生态

近日&#xff0c;云原生智能数据管理平台 NineData 和北京奥星贝斯科技有限公司的 OceanBase 数据库完成产品兼容互认证。经过严格的联合测试&#xff0c;双方软件完全相互兼容、功能完善、整体运行稳定且性能表现优异。 此次 NineData 与 OceanBase 完成产品兼容认证&#xf…

Manz高压清洗机S11-028GCH-High Quality Cleaner 操作使用说明492页

Manz高压清洗机S11-028GCH-High Quality Cleaner 操作使用说明492页

理解 JSON 和 Form-data 的区别

在讨论现代网络开发与API设计的语境下&#xff0c;理解客户端和服务器间如何有效且可靠地交换数据变得尤为关键。这里&#xff0c;特别值得关注的是两种主流数据格式&#xff1a;JSON与Form-data。尽管它们的终极目标一致&#xff0c;即数据传输的高效性和可靠性&#xff0c;但…

wps没保存关闭了怎么恢复数据?数据恢复这样做

WPS文件已成为我们不可或缺的一部分。从撰写报告、制作表格到展示演讲&#xff0c;WPS系列软件为我们提供了极大的便利。然而正如任何电子设备都可能遇到的问题一样&#xff0c;WPS文件有时也可能出现损坏的情况&#xff0c;这无疑给我们的工作带来了不小的困扰。 那么当WPS文件…

RPC——远程过程调用

一、RPC介绍 1.1 概述 RPC&#xff08;Remote Procedure Call Protocol&#xff09; 远程过程调用协议。RPC是一种通过网络从远程计算机程序上请求服务&#xff0c;不需要了解底层网络技术的协议。RPC主要作用就是不同的服务间方法调用就像本地调用一样便捷。 1.2 RPC框架 …

【项目笔记】java微服务:黑马头条(day02)

文章目录 app端文章查看&#xff0c;静态化freemarker,分布式文件系统minIO1)文章列表加载1.1)需求分析1.2)表结构分析1.3)导入文章数据库1.3.1)导入数据库1.3.2)导入对应的实体类 1.4)实现思路1.5)接口定义1.6)功能实现1.6.1)&#xff1a;导入heima-leadnews-article微服务&am…

JEDEC标准介绍及JESD22全套下载

JEDEC标准 作为半导体相关的行业的从业者&#xff0c;或多或少会接触到JEDEC标准。标准对硬件系统的设计、应用、验证&#xff0c;调试等有着至关重要的作用。 JEDEC&#xff08;全称为 Joint Electron Device Engineering Council&#xff09;是一个电子组件工程标准制定组织…

面试题个人总结(面经)

自我介绍 你好&#xff0c;我叫XXX&#xff0c;是今天面试初级蓝队的人员&#xff0c;我毕业于XXXX&#xff0c;专业为网络空间安全,我曾经在XXXXX实习过&#xff0c;有过大概一年左右的工作经验&#xff0c;还有过一定的护网经验&#xff0c;去年在XXX厂商护过网&#xff0c;…

Python与FPGA——图像锐化

文章目录 前言一、图像锐化二、Python robert锐化三、Python sobel锐化四、Python laplacian锐化五、FPGA sobel锐化总结 前言 在增强图像之前一般会先对图像进行平滑处理以减少或消除噪声&#xff0c;图像的能量主要集中在低频部分&#xff0c;而噪声和图像边缘信息的能量主要…