【C++设计模式】依赖倒转原则

这篇具有很好参考价值的文章主要介绍了【C++设计模式】依赖倒转原则。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

2023年8月30日,周三上午


目录

  • 概述
  • 含义
  • 举个简单的例子
  • 传统做法
  • 使用依赖倒转原则
  • 代码说明
  • 再举一个具体的例子
  • 以生活为例

概述

依赖倒转原则(Dependency Inversion Principle,DIP)是面向对象设计中的一个基本原则。

含义

高层模块不应该依赖低层模块,两者都应该依赖其抽象。

也就是说:

  • 高层模块不应该直接依赖低层模块,两者之间应使用抽象来解耦。
  • 具体实现应该依赖抽象,而不应该依赖细节。
  • 抽象不应该依赖细节,细节应该依赖抽象。

举个简单的例子

  • 高层模块:用户模块
  • 低层模块:数据库模块
  • 抽象:接口或抽象基类

传统做法

这违反了依赖倒转原则,因为高层用户模块直接依赖了低层数据库模块。

用户模块 -> 直接依赖数据库模块

使用依赖倒转原则

  • 定义一个数据库操作的接口或抽象基类
  • 数据库模块实现这个接口/基类
  • 用户模块只依赖接口/基类,通过接口/基类与数据库模块解耦
         依赖                 实现
用户模块 -----> 接口/抽象基类<-----数据库模块

这样一来,用户模块与数据库模块的依赖关系就通过抽象进行了解耦。如果需要替换数据库,只需要修改数据库模块的实现,不影响用户模块。

总之,依赖倒转原则通过抽象层解耦高低层模块的依赖关系,提高了模块的独立性、可扩展性和可维护性。

代码说明

这里用一个简单的代码例子来说明依赖倒转原则。

            依赖                   实现
UserModule -----> 抽象类IDataBase<-----MysqlDatabase

首先定义一个数据库操作的接口:

// 抽象接口
class IDatabase {
public:
  virtual void Insert(const string& data) = 0;
  virtual void Select() = 0;
};

然后实现这个接口的具体数据库类:

// 具体实现
class MysqlDatabase : public IDatabase{
public:
  void Insert(const string& data) override {
  // 具体插入逻辑
  }

  void Select() override {
  // 具体查询逻辑 
  }
};

用户模块只依赖接口,不依赖具体实现:

// 用户模块
class UserModule {
private:
  IDatabase* db;

public:
  UserModule(IDatabase* db) : db(db) {}

  void Run() {
  // ...
  db->Insert("some data");
  db->Select();
  }
};

在主函数中:

int main() {

  MysqlDatabase mysql;
  UserModule user(&mysql);

  user.Run();

  return 0;
}

在这个程序里:

  • 用户模块只依赖抽象接口IDatabase,不依赖具体的MysqlDatabase类。
  • MysqlDatabase实现了IDatabase接口。
  • 通过接口解耦了用户模块和数据库模块的依赖关系。

如果需要替换数据库,只需要修改MysqlDatabase实现,而不影响用户模块。这就是依赖倒转原则的实现。

再举一个具体的例子

在windows平台上用这套

                依赖                实现
DrawingProgram -----> 抽象类IShape<-----RectangleOnWindows

在Linux平台上用这套

                依赖                实现
DrawingProgram -----> 抽象类IShape<-----RectangleOnLinux
#include<iostream>

class IShape {
public:
  virtual void draw() = 0;
};

//在windows平台上画矩形
class RectangleOnWindows : public IShape {
public:
  void draw() override {
  std::cout << "在Windows上画矩形" << std::endl;
  std::cout << "先画左边和右边,再画上边和下边" << std::endl;
  }  
};

//在Linux平台上画矩形
class RectangleOnLinux : public IShape {
public:
  void draw() override {
  std::cout << "在Linux上画矩形" << std::endl;
  std::cout << "先画上边和左边,再画下边和右边" << std::endl;
  }  
};

class DrawingProgram {
private:
  IShape* shape;

public:
  DrawingProgram(IShape* shape) {
  this->shape = shape;
  }

  void run() {
  shape->draw();
  }
};
int main() {

//在Windows平台上用这一套
  RectangleOnWindows ROW;
  DrawingProgram program(&ROW);
  program.run();
  
//在Linux平台上用这一套
//  RectangleOnLinux ROL;
//  DrawingProgram program(&ROL);
//  program.run();

  return 0;
}

这这个程序中:

  • 绘图程序只依赖形状接口,不依赖具体形状类。
  • 形状类实现了形状接口。
  • 通过接口解耦了绘图程序和形状类的依赖关系。

如果需要添加新的形状,只需要实现形状接口,不影响绘图程序。这就是一个完整的依赖倒转原则示例。

以生活为例

电脑中的主板就是最好的一个依赖倒转原则例子,

在主板上有非常多的硬件接口,用来安装内存、硬盘、电源等等,

这些硬件接口就相当于抽象类,

正是因为有了接口,才能在一块主板上安装不同品牌、不同厂商生产的内存条、硬盘、电源等等。

如果主板上没有这些硬件接口,而是直接让主板与某个品牌的内存条连接,

那么当这个内存条坏了,你就只能买这个品牌的内存条,用其他品牌的没用,

因为这个主板是针对这个品牌的内存条设计的,没办法做到抽象,也就只能用这个品牌的。文章来源地址https://www.toymoban.com/news/detail-686367.html

到了这里,关于【C++设计模式】依赖倒转原则的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Spring学习笔记(二)Spring的控制反转(设计原则)与依赖注入(设计模式)

    是一种设计原则,降低程序代码之间的耦合度 对象由Ioc容器统一管理,当程序需要使用对象时直接从IoC容器中获取。这样对象的控制权就从应用程序转移到了IoC容器 依赖注入是一种消除类之间依赖关系的设计模式。例如,A类要依赖B类,A类不再直接创建B类,而是把这种依赖

    2024年02月19日
    浏览(38)
  • 【C++设计模式】单一职责原则

    2023年8月26日,周六上午 目录 概述 一个简单的例子 用单一职责原则来设计一个简单的学生管理系统 单一职责原则(Single Responsibility Principle,SRP),它是面向对象设计中的一个基本原则。 单一职责原则的核心思想是,一个类应该只有一个引起它变化的原因。 换句话说, 一个

    2024年02月11日
    浏览(41)
  • 【C++设计模式】开放-封闭原则

    2023年8月27日,周日下午 我觉得我的这篇博客还是写得很不错的,哈哈哈。 目录 概述 举例说明 用开放-封闭原则重构 开放-封闭原则(Open-Closed Principle,OCP)是面向对象设计中的一个重要原则,也是许多设计模式的基础。它由Bertrand Meyer在他的书 《面向对象软件构造》 中提出

    2024年02月10日
    浏览(48)
  • 【8】c++设计模式——>单一职责原则

    C++面向对象三大特性之一的 封装 指的就是将单一事物抽象出来组合成一个类,所以我们在设计类的时候每个类中处理的是单一事物而不是某些事物的集合。让类的功能单一,不让类与具体的事物耦合。 设计模式中所谓的单一职责原则,就是对一个类而言,应该仅有一个引起

    2024年02月07日
    浏览(39)
  • C++设计模式_02_面向对象设计原则

    变化是复用的天敌!面向对象设计或者说使用了抽象原则的面向对象设计最大的优势在于#

    2024年02月11日
    浏览(52)
  • 【设计模式】设计原则-开闭原则

    定义 作用 1、方便测试;测试时只需要对扩展的代码进行测试。 2、提高代码的可复用性;粒度越小,被复用的可能性就越大。 3、提高软件的稳定性和延续性,易于扩展和维护。 实现方式 通过“抽象约束、封装变化”来实现开闭原则。通过接口或者抽象类为软件实体定义一

    2024年02月15日
    浏览(37)
  • 【设计模式】设计原则-里氏替换原则

    定义 任何基类可以出现的地方,子类一定可以出现。 通俗理解:子类可以扩展父类的功能,但不能改变父类原有的功能。 换句话说,子类继承父类时,除添加新的方法完成新增功能外,尽量不要重写父类的方法。 针对的问题 主要作用就是规范继承时子类的一些书写规则。

    2024年02月14日
    浏览(49)
  • 前端设计模式和设计原则之设计原则

    1 开闭原则 该原则指出软件实体(类、模块、函数等)应该 对扩展开放,对修改关闭 。也就是说,在添加新功能时,应该通过扩展现有代码来实现,而不是直接修改已有的代码。这样可以确保现有代码的稳定性,并且减少对其他部分的影响。 在上述例子中,有一个原始功能

    2024年02月07日
    浏览(39)
  • 【Java 设计模式】设计原则之开放封闭原则

    在软件开发中,设计原则是创建灵活、可维护和可扩展软件的基础。 这些原则为我们提供了指导方针,帮助我们构建高质量、易理解的代码。 ✨单一职责原则(SRP) ✨开放/封闭原则(OCP) ✨里氏替换原则(LSP) ✨依赖倒置原则(DIP) ✨接口隔离原则(ISP) ✨合成/聚合复

    2024年02月02日
    浏览(49)
  • 【Java 设计模式】设计原则之里氏替换原则

    在软件开发中,设计原则是创建灵活、可维护和可扩展软件的基础。 这些原则为我们提供了指导方针,帮助我们构建高质量、易理解的代码。 ✨单一职责原则(SRP) ✨开放/封闭原则(OCP) ✨里氏替换原则(LSP) ✨依赖倒置原则(DIP) ✨接口隔离原则(ISP) ✨合成/聚合复

    2024年01月20日
    浏览(44)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包