C++依賴倒轉(zhuǎn)原則和里氏代換原則的作用是什么

這篇“C++依賴倒轉(zhuǎn)原則和里氏代換原則的作用是什么”文章的知識點大部分人都不太理解，所以小編給大家總結(jié)了以下內(nèi)容，內(nèi)容詳細(xì)，步驟清晰，具有一定的借鑒價值，希望大家閱讀完這篇文章能有所收獲，下面我們一起來看看這篇“C++依賴倒轉(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)在有張三司機和李四司機，有寶馬和奔馳汽車，需求包括張三開寶馬，李四開奔馳。

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

以上就是關(guān)于“C++依賴倒轉(zhuǎn)原則和里氏代換原則的作用是什么”這篇文章的內(nèi)容，相信大家都有了一定的了解，希望小編分享的內(nèi)容對大家有幫助，若想了解更多相關(guān)的知識內(nèi)容，請關(guān)注億速云行業(yè)資訊頻道。