c++ 设计模式--外观模式&建造者模式(11,12)

案例：睡觉前可以一次性关闭电视，电脑，点灯

外观模式

外观模式定义(FasadePattern)

外观模式为子系统的一组接口提供统一的入口，定义了一个高层接口，使得子系统更加容易使用。简化客户端和子系统之间的交互，方便客户端使用。

外观模式结构

• Fasade(外观角色)：外观角色知道多个相关子系统的功能，将所有从客户端发来的请求委派给相应的子系统作相应处理
• SubSystem(子系统角色)：子系统是一个类，或者由多个类组成的类的集合，实现外观角色要求的具体实现
  

外观模式示例

https://gitee.com/NiMiKiss/design-pattern.git

#ifndef _FASADE_PATTERN_
#define _FASADE_PATTERN_
#include<iostream>
#include<memory>
class TV
{
public:
	void ON() { std::cout << "TV ON" << std::endl; }
	void OFF() { std::cout << "TV OFF" << std::endl; }
};

class Light
{
public:
	void ON() { std::cout << "Light ON" << std::endl; }
	void OFF() { std::cout << "Light OFF" << std::endl; }
};

class Computer
{
public:
	void ON() { std::cout << "Light ON" << std::endl; }
	void OFF() { std::cout << "Light OFF" << std::endl; }
};

class Fasade
{
public:
	Fasade()
	{
		m_spTV = std::shared_ptr<TV>(new TV());
		m_spLight = std::shared_ptr<Light>(new Light());
		m_spComputer = std::shared_ptr<Computer>(new Computer());
	}
	void ON() { m_spTV->ON(); m_spLight->ON(); m_spComputer->ON(); }
	void OFF() { m_spTV->OFF(); m_spLight->OFF(); m_spComputer->OFF(); }
private:
	std::shared_ptr<TV> m_spTV;
	std::shared_ptr<Light> m_spLight;
	std::shared_ptr<Computer> m_spComputer;
};
#endif // !_FASADE_PATTERN_

客户端调用

#include "Fasade_Pattern.h"
#include<iostream>
#include<memory>
int main()
{
	auto spFasade = std::shared_ptr<Fasade>(new Fasade());
	spFasade->ON();
	spFasade->OFF();
	return EXIT_SUCCESS;
}

案例： 民用飞机和军用飞机构造过程基本一致，只是使用的具体的材料不同

建造者模式(BuilderPattern)

建造者模式简介

建造者模式将客户端与包含多个部件的复杂对象的构建过程分离，客户端不必知道复杂对象的内部组成方式与装配方式，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

外观模式和建造者模式

外观模式和建造者模式都是在基础层之上多了一层包装，开放简洁的接口给调用者。
外观模式是结构型的模式，建造者模式是创建型的模式

建造者模式结构

• 抽象建造者(AbstractBuilder): 创建一个Product对象的各个部件指定的抽象接口
• 具体建造者(ConcreteBuilder):实现AbstractBuilder的接口，实现各个部件的具体构造方法和装配方法，并返回创建结果
• 产品(Product):具体的产品对象
• 指挥者(Direct):构建一个使用Builder对象的接口，安排复杂对象的构建过程。
  

建造者模式示例

https://gitee.com/NiMiKiss/design-pattern.git

#ifndef _BUILDER_PATTERN
#define _BUILDER_PATTERN
#include<iostream>
#include<memory>
class Aircraft
{
public:
	void SetEngine(const std::string& sEngine) { m_sEngine = sEngine; }
	void SetBody(const std::string& sBody) { m_sBody = sBody; }
	void SetWing(const std::string& sWing) { m_sWing = sWing; }
	void SetLandgear(const std::string& sLandgear) { m_sLandgear = sLandgear; }
	void DisplayAircraftInfo() const
	{
		std::cout << "Engine= " << m_sEngine << std::endl;
		std::cout << "Body= " << m_sBody << std::endl;
		std::cout << "Wing= " << m_sWing << std::endl;
		std::cout << "Landgear= " << m_sLandgear << std::endl;
	}
private:
	std::string m_sEngine;
	std::string m_sBody;
	std::string m_sWing;
	std::string m_sLandgear;
};

class AircraftBulider
{
public:
	AircraftBulider() { m_spAircraft = std::shared_ptr<Aircraft>(new Aircraft()); }
	virtual void AddEngine() = 0;
	virtual void AddBody() = 0;
	virtual void AddWing() = 0;
	virtual void AddLandgear() = 0;
	virtual std::shared_ptr<Aircraft> GetAircraft() { return m_spAircraft; };
protected:
	std::shared_ptr<Aircraft> m_spAircraft;
};

class MilitaryAircraftBulider:public AircraftBulider
{
public:
	void AddEngine() { m_spAircraft->SetEngine("MilitaryAircraftEngine"); }
	void AddBody() { m_spAircraft->SetBody("MilitaryAircraftBody"); }
	void AddWing() { m_spAircraft->SetWing("MilitaryAircraftWing"); }
	void AddLandgear() { m_spAircraft->SetLandgear("MilitaryAircraftEngine"); }
};

class CivilAircraftBulider :public AircraftBulider
{
public:
	void AddEngine() { m_spAircraft->SetEngine("CivilAircraftEngine"); }
	void AddBody() { m_spAircraft->SetBody("CivilAircraftBody"); }
	void AddWing() { m_spAircraft->SetWing("CivilAircraftWing"); }
	void AddLandgear() { m_spAircraft->SetLandgear("CivilAircraftEngine"); }
};

class BuilderDirector
{
public:
	void SetBuilder(std::shared_ptr<AircraftBulider> spAircraftBulider)
	{
		m_spAircraftBulider = spAircraftBulider;
	}
	std::shared_ptr<Aircraft> Builder()
	{
		m_spAircraftBulider->AddEngine();
		m_spAircraftBulider->AddBody();
		m_spAircraftBulider->AddWing();
		m_spAircraftBulider->AddLandgear();
		return m_spAircraftBulider->GetAircraft();
	}
private:
	std::shared_ptr<AircraftBulider> m_spAircraftBulider;
};
#endif // !_BUILDER_PATTERN

客户端调用

#include "Builder_Pattern.h"
#include<iostream>
#include<memory>
int main()
{
	auto spBuilderDirector = std::shared_ptr<BuilderDirector>(new BuilderDirector());
	auto spMilitaryAircraftBulider = std::shared_ptr<MilitaryAircraftBulider>(new MilitaryAircraftBulider());
	spBuilderDirector->SetBuilder(spMilitaryAircraftBulider);
	auto spAircraft=spBuilderDirector->Builder();
	spAircraft->DisplayAircraftInfo();

	auto spCivilAircraftBulider = std::shared_ptr<CivilAircraftBulider>(new CivilAircraftBulider());
	spBuilderDirector->SetBuilder(spCivilAircraftBulider);
	auto spCivilAircraft = spBuilderDirector->Builder();
	spCivilAircraft->DisplayAircraftInfo();
	return EXIT_SUCCESS;
}