快捷導(dǎo)航

C++依賴倒轉(zhuǎn)原則和里氏代換原則有什么好處

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

設(shè)計模式（Design pattern）代表了最佳的實踐，通常被有經(jīng)驗的面向?qū)ο蟮能浖_發(fā)人員所采用。設(shè)計模式是軟件開發(fā)人員在軟件開發(fā)過程中面臨的一般問題的解決方案。本篇介紹設(shè)計模式七大原則之一的依賴倒轉(zhuǎn)原則

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

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

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

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

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

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

我們現(xiàn)在有張三司機(jī)和李四司機(jī)，有寶馬和奔馳汽車，需求包括張三開寶馬，李四開奔馳。

#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è)務(wù)需求，張三既要開奔馳，也要開寶馬，李四既要開奔馳也要開寶馬，那也很簡單，只需要在張三類和李四類中各增加一個方法即可。

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

這是一個耦合度極高的設(shè)計，那以后拓展了新功能，張三開豐田，李四開奧迪，那我得設(shè)計一個新豐田類，新奧迪類，然后在張三類中進(jìn)行修改，在李四類中進(jìn)行修改，我每次拓展新功能，都要修改其它模塊中的內(nèi)容，這樣的一個設(shè)計顯然是一個耦合度極高的設(shè)計。

如果一個系統(tǒng)有上百個模塊，那么再添加一個新模塊，新功能的時候，那可能還得修改幾百個模塊的內(nèi)容，這樣顯然是極不方便的。

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

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

具體代碼如下：

#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;
};
//實現(xiàn)層
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è)務(wù)邏輯層
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;
}

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

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

您可能感興趣的文章: