C++依赖倒转原则和里氏代换原则有什么好处

 更新时间:2023年02月25日 11:24:02   作者:北冥有鱼丶丶  
设计模式(Design pattern)代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。本篇介绍设计模式七大原则之一的依赖倒转原则

初学依赖倒转原则和里氏代换原则时,由于笔者水平有限,并没有看懂书上的专业术语的解释,经过反复摸索和学习,发现里氏代换原则和依赖倒转原则可以一言以蔽之:

里氏代换原则:开发时以抽象为核心,针对抽象编程,能够抽象为一个抽象类或者接口的,就将其抽象为抽象类或者接口,然后用子类来进行实现

依赖倒转原则:将代码分为3层考虑,业务逻辑层,抽象层和实现层,其中业务逻辑层依赖抽象层,实现层也依赖抽象层

那么在代码中使用依赖倒转原则和里氏代换原则有什么好处吗?

只要能抽象你就进行抽象,然后不管高层模块(业务逻辑层)还是低层模块(实现层),它们都依赖于抽象,具体一点就是接口或抽象类,只要接口是稳定的,那么任何一个的更改都不用担心其他受到影响,即降低了耦合度。

光看理论,肯定还是一头雾水,下面通过一个例子来理清里氏代换原则和依赖倒转原则。

我们现在有张三司机和李四司机,有宝马和奔驰汽车,需求包括张三开宝马,李四开奔驰。

#include<iostream>
using namespace std;
class Benz
{
public:
	void run()
	{
		cout << "Benz is running" << endl;
	}
};
class BMW
{
public:
	void run()
	{
		cout << "BMW is runnning" << endl;
	}
};
class Zhang3
{
public:
	void driveBenz(Benz* benz)
	{
		cout << "zhang3 drives Benz" << endl;
		benz->run();
	}
};
class Li4
{
public:
	void driveBMW(BMW* bmw)
	{
		cout << "li4 drives BMW" << endl;
		bmw->run();
	}
};
int main()
{
	Benz benz;
	BMW bmw;
	Zhang3 zhang3;
	Li4 li4;
	zhang3.driveBenz(&benz);
	li4.driveBMW(&bmw);
	return 0;
}

那如果我们要拓展业务需求,张三既要开奔驰,也要开宝马,李四既要开奔驰也要开宝马,那也很简单,只需要在张三类和李四类中各增加一个方法即可。

#include<iostream>
using namespace std;
class Benz
{
public:
	void run()
	{
		cout << "Benz is running" << endl;
	}
};
class BMW
{
public:
	void run()
	{
		cout << "BMW is runnning" << endl;
	}
};
class Zhang3
{
public:
	void driveBenz(Benz* benz)
	{
		cout << "zhang3 drives Benz" << endl;
		benz->run();
	}
	void driveBMW(BMW* bmw)
	{
		cout << "zhang3 drives BMW" << endl;
		bmw->run();
	}
};
class Li4
{
public:
	void driveBenz(Benz* benz)
	{
		cout << "li4 drives Benz" << endl;
		benz->run();
	}
	void driveBMW(BMW* bmw)
	{
		cout << "li4 drives BMW" << endl;
		bmw->run();
	}
};
int main()
{
	Benz benz;
	BMW bmw;
	Zhang3 zhang3;
	Li4 li4;
	zhang3.driveBenz(&benz);
	zhang3.driveBMW(&bmw);
	li4.driveBenz(&benz);
	li4.driveBMW(&bmw);
	return 0;
}

这是一个耦合度极高的设计,那以后拓展了新功能,张三开丰田,李四开奥迪,那我得设计一个新丰田类,新奥迪类,然后在张三类中进行修改,在李四类中进行修改,我每次拓展新功能,都要修改其它模块中的内容,这样的一个设计显然是一个耦合度极高的设计。

如果一个系统有上百个模块,那么再添加一个新模块,新功能的时候,那可能还得修改几百个模块的内容,这样显然是极不方便的。

那如果我们利用里氏代换原则和依赖倒转原则,能抽象就抽象,并将代码分为3层考虑,分别是业务逻辑层,抽象层和实现层,具体思路就是将奔驰,宝马,丰田等等汽车抽象为一个汽车类,汽车类包含一个公共接口run,将张三,李四,王五等等人物抽象为一个人物类,人物类中包含一个公共接口drive,drive中的参数也是抽象的汽车类,然后假设我们需要李四开奔驰,我们就在实现层去实现一个具体的奔驰类,在实现层实现一个具体的李四类,然后在业务逻辑层创建一个李四对象,创建一个奔驰对象,将奔驰汽车对象传给李四对象中的drive方法,就实现了李四开奔驰,如果想要实现李四开宝马,那么同样,只需要在实现层新实现一个宝马类,然后去业务逻辑层创建一个宝马对象,再将宝马对象传给李四对象中的drive方法,就实现了李四开宝马,后面我们再想去拓展功能,只要接口不需要发生变化,我们就无需去动之前的代码,只需要增加新的代码即可,这也符合开放-封闭原则,如果我们想去修改一些功能代码,比如把李四开宝马修改为李四开奔驰,只需要在业务逻辑层更换参数即可,无需动其它模块的内容,显然极大降低了代码之间的耦合度。

使用依赖倒转原则后,我们再去拓展新的功能或者修改一些功能就无需去更改其它模块中的内容了。

具体代码如下:

#include<iostream>
#include<string>
using namespace std;
//抽象层
class Car
{
	string name;
public:
	virtual void run() = 0;
	Car(string _name):name(_name){}
	string getName()
	{
		return name;
	}
};
class Person
{
public:
	virtual void drive(Car& car) = 0;
};
//实现层
class Benz :public Car
{
public:
	Benz(string _name) :Car(_name) {}
	virtual void run()
	{
		cout << "奔驰正在奔跑" << endl;
	}
};
class BMW :public Car
{
public:
	BMW(string _name) :Car(_name) {}
	virtual void run()
	{
		cout << "宝马正在奔跑" << endl;
	}
};
class Zhang3 :public Person
{
public:
	virtual void drive(Car& car)
	{
		cout << "张三在开" << car.getName() << endl;
		car.run();
	}
};
class Li4 :public Person
{
public:
	virtual void drive(Car& car)
	{
		cout << "李四在开" << car.getName() << endl;
		car.run();
	}
};
//业务逻辑层
int main()
{
	Person* person = new Zhang3;
	Person* person2 = new Li4;
	Car* car1 = new Benz("奔驰");
	Car* car2 = new BMW("宝马");
	person->drive(*car1);
	person2->drive(*car2);
	return 0;
}

通过上述解释,我们清楚了里氏代换原则和依赖倒转原则对代码的作用,但是在代码中还有一个值得注意的地方,很显然,实现层依赖了抽象层,而在业务逻辑层,我们要注意要让父类(抽象类)指针指向子类对象,这样业务逻辑层才是依赖了抽象层,才符合依赖倒转原则。

到此这篇关于C++依赖倒转原则和里氏代换原则有什么好处的文章就介绍到这了,更多相关C++依赖倒转原则内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

相关文章

  • 完全掌握C++编程中构造函数使用的超级学习教程

    完全掌握C++编程中构造函数使用的超级学习教程

    这篇文章主要介绍了C++中的构造函数,包括C++11标准中的新特性的介绍,十分推荐!需要的朋友可以参考下
    2016-01-01
  • 利用Matlab实现时域分析功能的示例详解

    利用Matlab实现时域分析功能的示例详解

    利用MATLAB可以方便地进行控制系统的时域分析。这篇文章主要通过简单的示例为大家介绍了Matlab进行时域分析的具体操作,需要的可以参考一下
    2023-02-02
  • C++抽象基类讲解

    C++抽象基类讲解

    这篇文章主要介绍了C++抽象基类讲解,象基类abstract base class简称ABC,C++实现继承的时候,需要保证派生类和基类之间是一种is-a的关系。在大多数时刻,这样的关系是没有问题的,然而在一些特殊的情况可能会遇到问题,下面来看看文章的具体介绍吧
    2022-01-01
  • 使用Qt生成Word和PDF文档的详细教程

    使用Qt生成Word和PDF文档的详细教程

    Qt 是一个跨平台的应用程序开发框架,除了用于创建图形界面应用程序外,还可以用来生成 Word 和 PDF 文档,本文将介绍如何使用 Qt 来生成Word和PDF文档,以及相关的代码示例,需要的朋友可以参考下
    2023-10-10
  • C++中char*转换为LPCWSTR的解决方案

    C++中char*转换为LPCWSTR的解决方案

    最近在学习C++,遇到了一个char*转换为LPCWSTR的问题,通过查找资料终于解决了,所以下面这篇文章主要介绍了C++中char*转LPCWSTR的解决方案,文中通过详细的示例代码介绍的很详细,有需要的朋友可以参考借鉴,下面来一起看看吧。
    2017-01-01
  • C,C++中常用的操作字符串的函数

    C,C++中常用的操作字符串的函数

    这篇文章主要介绍了C,C++中常用的操作字符串的函数,需要的朋友可以参考下
    2017-09-09
  • 深入解析C++中的mutable关键字

    深入解析C++中的mutable关键字

    在C++中,mutable也是为了突破const的限制而设置的。被mutable修饰的变量,将永远处于可变的状态,即使在一个const函数中
    2013-10-10
  • C语言数据结构递归之斐波那契数列

    C语言数据结构递归之斐波那契数列

    这篇文章主要介绍了C语言数据结构递归之斐波那契数列的相关资料,希望通过本文能帮助到大家,让大家理解掌握这部分内容,需要的朋友可以参考下
    2017-10-10
  • 深入理解memmove()与memcpy()的区别以及实现方法

    深入理解memmove()与memcpy()的区别以及实现方法

    本篇文章是对memmove()与memcpy()的区别以及实现方法进行了详细的分析介绍,需要的朋友参考下
    2013-05-05
  • C语言运算符及其优先级汇总表口诀

    C语言运算符及其优先级汇总表口诀

    由于C语言的运算符优先级与C++的不完全一样(主要是增加了几个运算符),所以这个口诀不能完全实用于C++.但是应该能够兼容,大家可以比较一下他们的区别应该就能够很快掌握C++的优先级的
    2013-07-07

最新评论