C++依賴倒轉原則和里氏代換原則有什么好處

更新時間：2023年02月25日 11:24:02 作者：北冥有魚丶丶

設計模式（Design pattern）代表了最佳的實踐，通常被有經驗的面向對象的軟件開發(fā)人員所采用。設計模式是軟件開發(fā)人員在軟件開發(fā)過程中面臨的一般問題的解決方案。本篇介紹設計模式七大原則之一的依賴倒轉原則

初學依賴倒轉原則和里氏代換原則時，由于筆者水平有限，并沒有看懂書上的專業(yè)術語的解釋，經過反復摸索和學習，發(fā)現里氏代換原則和依賴倒轉原則可以一言以蔽之：

里氏代換原則：開發(fā)時以抽象為核心，針對抽象編程，能夠抽象為一個抽象類或者接口的，就將其抽象為抽象類或者接口，然后用子類來進行實現

依賴倒轉原則：將代碼分為3層考慮，業(yè)務邏輯層，抽象層和實現層，其中業(yè)務邏輯層依賴抽象層，實現層也依賴抽象層

那么在代碼中使用依賴倒轉原則和里氏代換原則有什么好處嗎？

只要能抽象你就進行抽象，然后不管高層模塊（業(yè)務邏輯層）還是低層模塊（實現層），它們都依賴于抽象，具體一點就是接口或抽象類，只要接口是穩(wěn)定的，那么任何一個的更改都不用擔心其他受到影響，即降低了耦合度。

光看理論，肯定還是一頭霧水，下面通過一個例子來理清里氏代換原則和依賴倒轉原則。

我們現在有張三司機和李四司機，有寶馬和奔馳汽車，需求包括張三開寶馬，李四開奔馳。

#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;
}

那如果我們要拓展業(yè)務需求，張三既要開奔馳，也要開寶馬，李四既要開奔馳也要開寶馬，那也很簡單，只需要在張三類和李四類中各增加一個方法即可。

#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層考慮，分別是業(yè)務邏輯層，抽象層和實現層，具體思路就是將奔馳，寶馬，豐田等等汽車抽象為一個汽車類，汽車類包含一個公共接口run，將張三，李四，王五等等人物抽象為一個人物類，人物類中包含一個公共接口drive，drive中的參數也是抽象的汽車類，然后假設我們需要李四開奔馳，我們就在實現層去實現一個具體的奔馳類，在實現層實現一個具體的李四類，然后在業(yè)務邏輯層創(chuàng)建一個李四對象，創(chuàng)建一個奔馳對象，將奔馳汽車對象傳給李四對象中的drive方法，就實現了李四開奔馳，如果想要實現李四開寶馬，那么同樣，只需要在實現層新實現一個寶馬類，然后去業(yè)務邏輯層創(chuàng)建一個寶馬對象，再將寶馬對象傳給李四對象中的drive方法，就實現了李四開寶馬，后面我們再想去拓展功能，只要接口不需要發(fā)生變化，我們就無需去動之前的代碼，只需要增加新的代碼即可，這也符合開放-封閉原則，如果我們想去修改一些功能代碼，比如把李四開寶馬修改為李四開奔馳，只需要在業(yè)務邏輯層更換參數即可，無需動其它模塊的內容，顯然極大降低了代碼之間的耦合度。

使用依賴倒轉原則后，我們再去拓展新的功能或者修改一些功能就無需去更改其它模塊中的內容了。

具體代碼如下：

#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();
	}
};
//業(yè)務邏輯層
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;
}

通過上述解釋，我們清楚了里氏代換原則和依賴倒轉原則對代碼的作用，但是在代碼中還有一個值得注意的地方，很顯然，實現層依賴了抽象層，而在業(yè)務邏輯層，我們要注意要讓父類（抽象類）指針指向子類對象，這樣業(yè)務邏輯層才是依賴了抽象層，才符合依賴倒轉原則。

到此這篇關于C++依賴倒轉原則和里氏代換原則有什么好處的文章就介紹到這了,更多相關C++依賴倒轉原則內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: