C++依賴倒轉原則和里氏代換原則的作用是什么

這篇“C++依賴倒轉原則和里氏代換原則的作用是什么”文章的知識點大部分人都不太理解，所以小編給大家總結了以下內容，內容詳細，步驟清晰，具有一定的借鑒價值，希望大家閱讀完這篇文章能有所收獲，下面我們一起來看看這篇“C++依賴倒轉原則和里氏代換原則的作用是什么”文章吧。

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

依賴倒轉原則：將代碼分為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++依賴倒轉原則和里氏代換原則的作用是什么”這篇文章的內容，相信大家都有了一定的了解，希望小編分享的內容對大家有幫助，若想了解更多相關的知識內容，請關注億速云行業資訊頻道。