C++ 软技能向：常用的面向对象设计原则总结

三个概念的关系

面向对象的四大基本特征是：抽象、封装、继承、多态。

四大基本特征是我们在进行面向对象编程的准则，但是我们在进行面向对象编程之前还需要进行面向对象分析（Object-Oriented Analysis），通过分析业务，确定需求，找出对象，知道我们要干什么，然后就是进行面向对象的设计（Object-OrientedDesign），知道我们如何干，最后才是面向对象的编程（Object-Oriented Program），具体的代码实现阶段。

为什么要面向对象设计（OOD）

不论是面向过程的思维方式，还是面向对象的思维方式，最终都是为了能更好的进行软件开发，而软件开发的唯一真理是“软件一定会变化”，而一个好的设计是应该能够轻松的应对变化，能被扩展，并且能够被复用。应该最好是能以最小的代价满足变化，不用改变现有代码架构来满足扩展，这样的设计才是一个优秀的设计，所以我们需要进行面向对象的设计。

UML语言

为了能够更好的进行面向对象的设计，所以需要引用专门的设计语言，也就是我们的UML语言，Unifed Modeling Language， 又称统一建模语言或标准建模语言，是始于1997年一个OMG(Object Management Group)标准，它是一个模型化和软件系统开发的图形化语言。UML为软件开发提供了一些标准的图例(10种)，统一开发思想，从而促进团队协作。这10中图例如下：

这里我们主要的来看红色的两种图例，第一种是类图，描述的是类与类之间的关系，第二种是一种动态图，可以看到一个动态的过程，后面对序列图我们在进一步了解，现在先来学习类图。

类与类之间的关系

我们知道UML中有10中图例，第一种就是类图，也就是描述类与类之间的关系，那类与类之间具备哪些关系呢？在此我们来看看他们之间的五种关系，继承（泛化）、关联、聚合、组合、依赖。

继承（泛化）

继承关系，或者泛化关系，描述的是两个类之间一种很强的关系，基类部分会成为派生类的一部分，在语义上是一个A is B的特点。例如经理是个员工、软件开发工程师是个员工、销售也是一个员工，所以可以设计下面的图例：

此例中，派生类经理、软件工程师、销售都是一个职员，体现出了is的关系。如果使用UML语言的话，使用空心三角箭头从派生类指向基类，这种关系其实是一种垂直的关系。

继承与泛化的区别：继承是先有基类，然后从基类产生新的类，也就是派生类；而泛化是先有派生类，然后多个派生类抽出基类，也就是先有派生类，然后才有基类。二者考虑的方向不一样，其实泛化更符合面向对象的思想。

关联

关联关系，是两个类之间最简单，最单纯的关系，表明两个类之间是有关系的，试想，如果两个类之间没有关系，那就不能满足面向对象的特点，对象与对象之间进行交互，使得彼此之间的状态发生变化的特点。而关联关系包括两种：双向的关联关系与单向的关联关系。但是不论哪种关联关系，两个类之间彼此并不负责对方的生命周期。注意在语义上是A has B的关系，一种固定的关系。在代码上的表现形式是：使用引用或者指针。

下面是两种关联关系的例子。

双向的关联关系（使用直线），客户与订单之间的关系：

单向的关联关系，条件变量与互斥锁（Condition知道MutexLock的存在，但是MutexLock不知道 Condition的存在，使用实线箭头从Condition指向MutexLock）：

聚合

是一种比较强的关联关系。对象之间的关系表现为整体和局部，整体部分并不负责局部对象的销毁。语义上表现为A has B。代码上表现为：数据成员以指针或者引用形式存在。使用空心菱形箭头表示，部分指向整体。

组合

更强的一种关联关系。对象之间的关系表现为整体和局部，整体部分负责局部对象的销毁。语义上表现为A has B。代码上表现为，数据成员以子对象成员形式存在。使用实心菱形箭头表示，部分指向整体。

依赖

是两个类之间的一种不确定的关系，语义上是一种A use B的关系，这种关系是偶然的，临时的，并非固定的。在代码上表现为：B作为A的成员函数参数；B作为A的成员函数的局部变量（B作为A的成员函数的返回值）；A的成员函数调用B的静态方法。使用虚线的箭头，从A指向B。

五种关系的总结

类与类之间的这五种关系，是类和类之间的一种普遍关系。

这五种关系，从耦合程度来看的话是：依赖< 关联 < 聚合 < 组合 < 继承；

从语义上来看，继承是A is B，关联、聚合、组合是A has B，依赖是A use B的关系；

从方向上来看，继承是类与类之间的纵向关系，而其他四种是类与类之间的横向关系。

之前我们实现多态使用的是继承与虚函数这种面向对象的方法，现在知道了类与类之间的其他关系后，可以使用组合与依赖这种基于对象的方法实现。

面向对象的设计原则

在进行面向对象设计的时候，需要考虑类与类之间的关系，这样可以让类之间的关系更加明确。但是，除此之外，在进行面向对象设计的时候，还需要注意满足一定的设计要求，也就是面向对象的设计原则，只有遵循一定的原则，才能更好的满足软件的设计需求，更好的满足变化。而一个优良的系统设计，强调要保持低耦合、高内聚的要求，为了满足这个要求，面向对象的设计原则设计了七种， 包括：

1、单一职责原则 (Single Responsibility Principle)

2、开闭原则(Open Closed Principle)

3、里氏替换原则 (Liscov Substitution Principle)

4、接口分离原则 (Interface Segregation Principle)

5、依赖倒置原则 (Dependency Inversion Principle)

6、迪米特法则（Law of Demeter -> Least Knowledge Principle）

7、组合复用原则 (Composite/Aggregate Reuse Principle)

单一职责原则

定义：一个对象应该只包含单一的职责，并且该职责被完整地封装在一个类中。单一职责原则的另一种定义方式：就一个类而言，应该仅有一个引起它变化的原因。单一职责原则是最简单的面向对象设计原则，它用于控制类的粒度大小。核心思想：一个类，最好只做一件事，只有一个引起它变化的原因。

核心是：解耦与增加内聚性。

在软件系统中，一个类（大到模块，小到方法）承担的职责越多，它被复用的可能性就越小，而且一个类承担的职责过多，相当于将这些职责耦合在一起，当其中一个职责变化时可能会影响其他职责的运作，因此要将这些职责进行分离，将不同的职责封装在不同的类中，即将不同的变化原因封装在不同的类中，如果多个职责总是同时发生改变则可将它们封装在同一类中。

单一职责原则是实现高内聚、低耦合的指导方针，它是最简单但又最难运用的原则，需要设计人员发现类的不同职责并将其分离，而发现类的多重职责需要设计人员具有较强的分析设计能力和相关实践经验。

例子：将长方形类的画图与计算面积功能分开，这样的话，计算面积就是计算面积，画图就是画图。

开闭原则

定义：软件实体应当对扩展开放，对修改关闭。开闭原则是面向对象的可复用性设计的第一块基石，它是最重要的面向对象设计原则。核心思想：对抽象编程，而不对具体编程，因为抽象相对稳定。在开闭原则的定义中，软件实体可以指一个软件模块、一个由多个类组成的局部结构或一个独立的类。开闭原则就是指软件实体应尽量在不修改原有代码的情况下进行扩展。任何软件都需要面临一个很重要的问题，即它们的需求会随时间的推移而发生变化。当软件系统需要面对新的需求时应该尽量保证系统的设计框架是稳定的。如果一个软件设计符合开闭原则，那么可以非常方便地对系统进行扩展，而且在扩展时无须修改现有代码，使得软件系统在拥有适应性和灵活性的同时具备较好的稳定性和延续性。随着软件规模越来越大， 软件寿命越来越长，软件维护成本越来越高，设计满足开闭原则的软件系统也变得越来越重要。

为了满足开闭原则，需要对系统进行抽象化设计，抽象化是开闭原则的关键。在C++中，可以为系统定义一个相对稳定的抽象层，而将不同的实现行为移至具体的实现层中完成。在C++语言中提供了抽象类的机制，可以通过它定义系统的抽象层，再通过具体类来进行扩展。如果需要修改系统的行为，无须对抽象层进行任何改动，只需要增加新的具体类来实现新的业务功能即可，实现在不修改已有代码的基础上扩展系统的功能，达到开闭原则的要求。

例子：版本升级，不改源代码，原来的功能就是可以使用的。计算器代码的实现：分别设计加减乘除，不如直接使用继承，实现虚方法。

class Calculator
{
public:
	int plus(int x, int y)
	{
		return x + y;
	}
	int minus(int x, int y)
	{
		return x - y;
	}int multiply(int x, int y)
	{
		return x * y;
	}
	int divide(int x, int y)
	{
		if (0 != y)
		{
			return x / y;
		}
		else
		{
			cout << "除数不能为0" << endl;
			return 1 << 31;
		}
	}
};

class Calculator
{
public:
	virtual int getResult(int x, int y) = 0;
	virtual ~Calculator() {}
};

class PlusCalculator
	: public Calculator
{
public:
	virtual int getResult(int x, int y)
	{
		return x + y;
	}
	~PlusCalculator()
	{
	}
};

class MinusCalculator
	: public Calculator
{
public:
	virtual int getResult(int x, int y) {
		return x - y;
	}
	~MinusCalculator()
	{
	}
};

class MultiplyCalculator
	: public Calculator
{
public:
	virtual int getResult(int x, int y)
	{
		return x * y;
	}
	~MultiplyCalculator()
	{
	}
};

class DivideCalculator
	: public Calculator
{
public:
	virtual int getResult(int x, int y)
	{
		if (0 != y)
		{
			return x / y;
		}
		else
		{
			cout << "除数不能为0" << endl;
			return 1 << 31;
		}
	}
	~DivideCalculator()
	{
	}
};

里氏替换原则

定义：所有引用基类（父类）的地方必须能透明地使用其派生类（子类）的对象。里氏代换原则表明，在软件中将一个基类对象替换成它的派生类对象，程序将不会产生任何错误和异常，反过来则不成立，如果一个软件实体使用的是一个派生类对象，那么它不一定能够使用基类对象。
核心思想：派生类必须能够替换其基类。派生类可以扩展基类的功能，但不能改变基类原有的功能。

表现为：派生类（子类）可以实现基类（父类）的抽象方法，表现多态，但不能覆盖基类（父类）的非抽象方法，当然派生类（子类）可以有自己的个性。

例如我喜欢动物，那我一定喜欢狗，因为狗是动物的派生类（子类）；但是我喜欢狗，不能据此断定我喜欢所有的动物。

里氏代换原则是实现开闭原则的重要方式之一，由于在使用基类（父类）对象的地方都可以使用派生类（子类）对象，因此在程序中尽量使用基类类型来对对象进行定义，而在运行时再确定其派生类（子类）类型，用派生类（子类）对象来替换基类（父类）对象。

在运用里氏代换原则时应该将基类（父类）设计为抽象类或者接口，让派生类（子类）继承基类（父类）或实现父接口，并实现在基类（父类）中声明的方法，在运行时派生类（子类）实例替换基类（父类）实例，可以很方便地扩展系统的功能，无须修改原有派生类（子类）的代码，增加新的功能可以通过增加一个新的派生类（子类）来实现。

有代码的实现：（注意接口的概念，功能服务，普通函数、自由函数，类的public成员函数，虚函数，
纯虚函数），注意与隐藏做区分，派生类要保有原来的功能，然后在此基础上扩展该功能。

class User
{
public:
	User(const string& name)
		: _name(name)
		, _score(0)
	{
	}
	void consume(float delta)
	{
		cout << "User::consume()" << endl;
		_score += delta;
		cout << ">> " << _name << " consume " << delta << endl;
	}
protected:
	string _name;
	float _score;
};

class VipUser
	: public User
{
public:
	VipUser(const string& name)
		: User(name)
		, _discount(1)
	{
	}void consume(float delta)
	{
		cout << "VipUser::consume()" << endl;
		float tmp = delta * _discount;
		_score += tmp;
		if (_score > 1000 && _score < 5000)
		{
			_discount = 0.9;
		}
		cout << ">> " << _name << " consume " << tmp << endl;
	}
private:
	float _discount;
};

void test()
{
	User user("刘德华");
	user.consume(2000);
	user.consume(2000);
	cout << endl;
	VipUser vip("张学友");
	vip.consume(2000);
	vip.consume(2000);//改变了基类的方法，隐藏
}

class User
{
public:
	User(const string& name)
		: _name(name)
		, _score(0) {
	}
	void consume(float delta)
	{
		_score += delta;
		cout << ">> " << _name << " consume " << delta << endl;
	}
protected:
	string _name;
	float _score;
};

class VipUser
	: public User
{
public:
	VipUser(const string& name)
		: User(name)
		, _discount(1)
	{
	}
	void consume2(float delta)
	{
		float realDelta = delta * _discount;
		_score += realDelta;
		updateDiscount();
		cout << ">> " << _name << " consume " << realDelta << endl;
	}
	void updateDiscount()
	{
		if (_score > 10000)
		{
			_discount = 0.7;
		}
		else if (_score > 5000)
		{
			_discount = 0.8;
		}
		else if (_score > 1000)
		{
			_discount = 0.9;
		}
		else
		{
			_discount = 1;
		}
	}
private:
	float _discount;
};

void test()
{
	User user("lili");
	user.consume(2000);
	user.consume(2000);
	cout << endl;
	VipUser vip("lucy");
	vip.consume2(2000);
	vip.consume2(20000);//添加自己的个性
	vip.consume(20000);//基类的方法还是保留在,
}

接口分离原则

定义：客户端不应该依赖那些它不需要的接口。

核心思想：使用多个小的专门的接口，而不要使用一个大的总接口。

根据接口隔离原则，当一个接口太大时需要将它分割成一些更细小的接口，使用该接口的客户端仅需知道与之相关的方法即可。每一个接口应该承担一种相对独立的角色，不干不该干的事，该干的事都要干。这里的“接口”往往有两种不同的含义：一种是指一个类型所具有的方法特征的集合，仅仅是一种逻辑上的抽象；另外一种是指C++语言中声明纯虚函数的抽象类。对于这两种不同的含义，接口隔离原则的表达方式以及含义也有所不同。

（1）当把“接口”理解成一个类型所提供的所有方法特征的集合的时候，这就是一种逻辑上的概念，接口的划分将直接带来类型的划分。可以把接口理解成角色，一个接口只能代表一个角色，每个角色都有它特定的一个接口，此时这个原则可以叫“角色隔离原则”。

（2）如果把“接口”理解成狭义的C++语言的抽象类，那么接口隔离原则表达的意思是指接口仅仅提供客户端需要的行为，客户端不需要的行为则隐藏起来，应当为客户端提供尽可能小的单独的接口，而不要提供大的总接口。在C++语言中，实现一个接口需要实现该接口中定义的所有方法，因此大的总接口使用起来不一定很方便，为了使接口的职责单一，需要将大接口中的方法根据其职责不同分别放在不同的小接口中，以确保每个接口使用起来都较为方便，并都承担某一单一角色。接口应该尽量细化，同时接口中的方法应该尽量少，每个接口只包含一个客户端（如子模块或业务逻辑类）所需的方法即可，这种机制也称为“定制服务”，即为不同的客户端提供宽窄不同的接口。

例子：鸟与鸵鸟。

class Bird
{
public:
	virtual void eat() = 0;
	virtual void walk() = 0;
	virtual void chirp() = 0;
	virtual void fly() = 0;
	virtual ~Bird() {}
}; class Crow
	: public Bird
{
public:
	void eat() override
	{
		cout << "乌鸦喝水" << endl;
	}
	void walk() override
	{
		cout << "乌鸦散步" << endl;
	}
	void chirp() override
	{
		cout << "乌鸦蹦蹦跳跳" << endl;
	}
	void fly() override
	{
		cout << "乌鸦飞翔" << endl;
	}
};
class Ostrich
	: public Bird
{
public:
	void eat() override
	{
		cout << "鸵鸟吃东西" << endl;
	}
	void walk() override
	{
		cout << "鸵鸟散步" << endl;
	}
	void chirp() override
	{
		cout << "鸵鸟蹦蹦跳跳" << endl;
	}
	void fly() override
	{
		cout << "鸵鸟不会飞翔" << endl;
	}
};

class Bird
{
public:
	virtual void eat() = 0;
	virtual void walk() = 0;
	virtual void chirp() = 0;
	virtual ~Bird() {}
};
class FlyingBird
	: public Bird
{
public:
	virtual void fly() = 0;
	~FlyingBird() {}
};
class Crow
	: public FlyingBird
{
public:
	void eat() override
	{
		cout << "乌鸦喝水" << endl;
	}
	void walk() override
	{
		cout << "乌鸦散步" << endl;
	}
	void chirp() override
	{
		cout << "乌鸦蹦蹦跳跳" << endl;
	}void fly() override
	{
		cout << "乌鸦飞翔" << endl;
	}
};
class Ostrich
	: public Bird
{
public:
	void eat() override
	{
		cout << "鸵鸟吃东西" << endl;
	}
	void walk() override
	{
		cout << "鸵鸟散步" << endl;
	}
	void chirp() override
	{
		cout << "鸵鸟蹦蹦跳跳" << endl;
	}
};

依赖倒置原则

与这个原则相关的还有 “控制反转” 一个概念。

定义：高层模块不应该依赖低层模块，它们都应该依赖抽象。抽象不应该依赖于细节，细节应该依赖于抽象。简单来说，依赖倒置原则要求针对接口编程，不要针对实现编程。

核心思想：面向接口编程，依赖于抽象。

在 C++ 中，此处面向接口编程，说的就是纯虚函数，包含纯虚函数的类，称为抽象类，抽象类是稳定不变的。

如果说开闭原则是面向对象设计的目标，那么依赖倒置原则就是面向对象设计的主要实现机制之一。依赖倒置原则要求在程序代码中传递参数时或在关联关系中尽量引用层次高的抽象层类，即使用接口和抽象类进行变量类型声明、参数类型声明、方法返回类型声明，以及数据类型的转换等，而不要用具体类来做这些事情。为了确保该原则的应用，一个具体类应当只实现接口或抽象类中声明过的方法，而不要给出多余的方法，否则将无法调用到在子类中增加的新方法。

在引入抽象层后，系统将具有很好的灵活性，在程序中尽量使用抽象层进行编程，而将具体类写在配置文件中，这样如果系统行为发生变化，只需要对抽象层进行扩展，并修改配置文件，而无须修改原有系统的源代码，在不修改的情况下来扩展系统的功能，满足开闭原则的要求。

在实现依赖倒置原则时需要针对抽象层编程，而将具体类的对象通过依赖注入（Dependence Injection，DI）的方式注入到其他对象中，依赖注入是指当一个对象要与其他对象发生依赖关系时采用抽象的形式来注入所依赖的对象。常用的注入方式有3种，分别是构造注入、设值注入和接口注入。构造注入是指通过构造函数来传入具体类的对象，设值注入是指通过Setter方法来传入具体类的对象，而接口注入是指通过在接口中声明的业务方法来传入具体类的对象。这些方法在定义时使用的是抽象类型，在运行时再传入具体类型的对象，由子类对象来覆盖父类对象。

在大多数情况下，开闭原则、里氏代换原则和依赖倒置原则会同时出现，开闭原则是目标，里氏代换原则是基础，依赖倒置原则是手段。

例子：银行业务类。

class BankWorker
{
public:
	void saveService()
	{
		cout << "办理存款业务" << endl;
	}
	void payService()
	{
		cout << "办理支付业务" << endl;
	}void transferService()
	{
		cout << "办理转账业务" << endl;
	}
};
void doSaveBusiness(BankWorker* worker)
{
	worker->saveService();
}
void doPayBusiness(BankWorker* worker)
{
	worker->payService();
}
void doTransferBusiness(BankWorker* worker)
{
	worker->transferService();
}
void test()
{
	unique_ptr<BankWorker> worker(new BankWorker());
	doSaveBusiness(worker.get());
	doPayBusiness(worker.get());
	doTransferBusiness(worker.get());
}

class BankWorker
{
public:
	virtual void doBusiness() = 0;
	virtual ~BankWorker() {}
};
class SaveBankWorker
	: public BankWorker {
public:
	void doBusiness() override
	{
		cout << "办理存款业务" << endl;
	}
};
class PayBankWorker
	: public BankWorker
{
public:
	void doBusiness() override
	{
		cout << "办理支付业务" << endl;
	}
};
class TransferBankWorker
	: public BankWorker
{
public:
	void doBusiness() override
	{
		cout << "办理转账业务" << endl;
	}
};
void doBusiness(BankWorker* worker)
{
	worker->doBusiness();
}
void test()
{
	unique_ptr<BankWorker> saveWorker(new SaveBankWorker());
	unique_ptr<BankWorker> payWorker(new PayBankWorker());
	unique_ptr<BankWorker> transferWorker(new TransferBankWorker());
	doBusiness(saveWorker.get());
	doBusiness(payWorker.get());
	doBusiness(transferWorker.get());
}

迪米特法则

定义：每一个软件单位对其他单位都只有最少的知识，而且局限于那些与本单位密切相关的软件单位。

迪米特法则要求一个软件实体应当尽可能少地与其他实体发生相互作用。如果一个系统符合迪米特法则，那么当其中的某一个模块发生修改时就会尽量少地影响其他模块，扩展会相对容易，这是对软件实体之间通信的限制，迪米特法则要求限制软件实体之间通信的宽度和深度。应用迪米特法则可降低系统的耦合度，使类与类之间保持松散的耦合关系。当两个类之间直接通信的时候，会造成高度依赖的后果（高耦合）。解决此问题的办法，尽量避免两个类直接接触（低耦合），通过一个第三者做转发。

在迪米特法则中，对于一个对象，其朋友包括以下几个类：

（1）当前对象本身（this）。
（2）以参数形式传入到当前对象方法中的对象。
（3）当前对象的成员对象。
（4）如果当前对象的成员对象是一个集合，那么集合中的元素也都是朋友。
（5）当前对象所创建的对象。

任何一个对象如果满足上面的条件之一，就是当前对象的“朋友”，否则就是“陌生人”。在应用迪米特法则时，一个对象只能与直接朋友发生交互，不要与“陌生人”发生直接交互，这样做可以降低系统的耦合度，一个对象的改变不会给太多其他对象带来影响。

迪米特法则要求在设计系统时应该尽量减少对象之间的交互，如果两个对象之间不必彼此直接通信，那么这两个对象就不应当发生任何直接的相互作用，如果其中一个对象需要调用另一个对象的方法，可以通过“第三者”转发这个调用。简而言之，就是通过引入一个合理的“第三者”来降低现有对象之间的耦合度。

在将迪米特法则运用到系统设计时要注意下面几点：在类的划分上应当尽量创建松耦合的类，类之间的耦合度越低，就越有利于复用，一个处在松耦合中的类一旦被修改不会对关联的类造成太大影响；在类的结构设计上，每一个类都应当尽量降低其成员变量和成员函数的访问权限；在类的设计上，只要有可能，一个类型应当设计成不变类；在对其他类的引用上，一个对象对其他对象的引用应当降到最低。

例如：使用买房者购房的一个例子。

A方案，购房者需要挨个楼盘的去知道确切的消息，需要对每个楼盘都有详细的了解，而B方案是购房者可以不用知道每个楼盘的具体信息，直接找个中介，告诉中介自己的需求，让中介进行推荐，这样购房者与楼盘之间的关系就不是那么强相关。

方案A的代码实现:

class Building
{
public:
	virtual void sale() = 0;
	virtual string getQuality() = 0;
	virtual ~Building() {}
};
class WankeBuilding
	: public Building
{
public:
	WankeBuilding() : _quality("高品质")
	{
	}
	void sale() override
	{
		cout << "万科楼盘" << _quality << "的房子被出售" << endl;
	}
	string getQuality() override
	{
		return _quality;
	}
private:
	string _quality;
};
class HengdaBuilding
	: public Building
{
public:
	HengdaBuilding()
		: _quality("低品质")
	{
	}
	void sale() override
	{
		cout << "恒大楼盘" << _quality << "的房子被出售" << endl;
	}
	string getQuality() override
	{
		return _quality;
	}
private:
	string _quality;
};
void test()
{
	Building* pbuidingA = new WankeBuilding();
	Building* pbuidingB = new HengdaBuilding();
	string demand = "低品质";
	if (pbuidingA->getQuality() == demand)
	{
		pbuidingA->sale();
	}
	if (pbuidingB->getQuality() == demand)
	{
		pbuidingB->sale();
	}
}

方案B的代码实现:

class Mediator
{
public:
	Mediator()
	{
		Building* pbuildingA = new WankeBuilding();
		Building* pbuildingB = new HengdaBuilding();
		_buildings.push_back(pbuildingA);
		_buildings.push_back(pbuildingB);
	}
	Building* findBuilding(const string& quality)
	{
		for (auto& building : _buildings)
		{
			if (building->getQuality() == quality)
			{
				return building;
			}
		}
		return nullptr;
	}
	~Mediator()
	{
		for (auto& building : _buildings)
		{
			if (building)
			{
				delete building;
			}
		}
	}
private:
	vector<Building*> _buildings;
};

void test()
{
	string demand = "低品质";
	Mediator mediator;
	Building* pbuilding = mediator.findBuilding(demand);
	if (pbuilding)
	{
		pbuilding->sale();
	}
	else
	{
		cout << "没有符合要求的楼盘" << endl;
	}
}

组合复用原则

定义：优先使用对象组合，而不是通过继承来达到复用的目的。合成复用原则就是在一个新的对象里通过关联关系（包括组合关系和聚合关系）来使用一些已有的对象，使之成为新对象的一部分，新对象通过委派调用已有对象的方法达到复用功能的目的。简而言之，在复用时要尽量使用组合/聚合关系（关联关系），少用继承。

在面向对象设计中可以通过两种方法在不同的环境中复用已有的设计和实现，即通过组合/聚合关系或通过继承，但首先应该考虑使用组合/聚合，组合/聚合可以使系统更加灵活，降低类与类之间的耦合度，一个类的变化对其他类造成的影响相对较少；其次才考虑继承，在使用继承时需要严格遵循里氏代换原则，有效使用继承会有助于对问题的理解，降低复杂度，而滥用继承反而会增加系统构建和维护的难度以及系统的复杂度，因此需要慎重使用继承复用。

通过继承来进行复用的主要问题在于继承复用会破坏系统的封装性，因为继承会将基类的实现细节暴露给子类，由于基类的某些内部细节对子类来说是可见的，所以这种复用又称“白箱”复用，如果基类发生改变，那么子类的实现也不得不发生改变；从基类继承而来的实现是静态的，不可能在运行时发生改变，没有足够的灵活性；而且继承只能在有限的环境中使用（如类没有声明为不能被继承）。

由于组合/聚合关系可以将已有的对象纳入到新对象中，使之成为新对象的一部分，因此新对象可以调用已有对象的功能，这样做可以使成员对象的内部实现细节对于新对象不可见，所以这种复用又称为“黑箱”复用，相对继承关系而言，其耦合度相对较低，成员对象的变化对新对象的影响不大，可以在新对象中根据实际需要有选择性地调用成员对象的操作；合成复用可以在运行时动态进行，新对象可以动态地引用与成员对象类型相同的其他对象。

一般而言，如果两个类之间是“Has-A”的关系应使用组合/聚合，如果是“Is-A”的关系可以使用继承。“Is-A”是严格的分类学意义上的定义，意思是一个类是另一个类的“一种”；而“Has-A”则不同，它表示某一个角色具有某一项责任。

class Vehicle
{
public:
	virtual void run() = 0;
	virtual ~Vehicle() {}
};

class Tesla
	: public Vehicle
{
public:void run() override
{
	cout << "Model Y start..." << endl;
}
};

class BYD
	: public Vehicle
{
public:
	void run() override
	{
		cout << "汉EV start..." << endl;
	}
};

class Geely
	: public Vehicle
{
public:
	void run() override
	{
		cout << "Geely LYNK03 start..." << endl;
	}
};

class PersonA
	: public Tesla
{
};

class PersonB
	: public BYD
{
};

class PersonC
	: public Geely
{
};

void test()
{
	PersonA pa;
	pa.run();
	PersonB pb;
	pb.run();
	PersonC pc;
	pc.run();
}

class Vehicle
{
public:
	virtual void run() = 0;
	virtual ~Vehicle() {}
};

class Tesla
	: public Vehicle
{
public:
	void run() override
	{
		cout << "Model Y start..." << endl;
	}
};

class BYD
	: public Vehicle
{
public:
	void run() override
	{
		cout << "汉EV start..." << endl;
	}
};

class Geely
	: public Vehicle
{
public:
	void run() override
	{
		cout << "Geely LYNK03 start..." << endl;
	}
};

class Person
{
public:
	void getVehicle(Vehicle* vehicle)
	{
		_vehicle = vehicle;
	}void drive()
	{
		_vehicle->run();
	}
private:
	Vehicle* _vehicle;
};

void test()
{
	Person person;
	unique_ptr<Vehicle> tesla(new Tesla());
	unique_ptr<Vehicle> han(new BYD());
	unique_ptr<Vehicle> geely(new Geely());
	person.getVehicle(tesla.get());
	person.drive();
	person.getVehicle(han.get());
	person.drive();
	person.getVehicle(geely.get());
	person.drive();
}

七大设计原则的总结

原则的目的只有一个：降低对象之间的耦合，增加程序的可复用性、可扩展性和可维护性。