C++笔记（六） 设计模式第二部分：抽象工厂/建造者模式等

一、抽象工厂

工厂模式只能生产一个产品，抽象工厂可以一下生产一个产品组

/*******************************************/
//抽象工厂
#include <iostream>
using namespace std;
class Fruit
{
public:
	virtual void SayName() = 0;

};
class AbstracFactory
{
public:
	virtual Fruit* createBanana() = 0;
	virtual Fruit* createApple() = 0;

};

class NorthBanana :public Fruit
{
public :
	virtual void SayName()
	{
		cout << "我是北方香蕉" << endl;
	}
};
class NorthApple :public Fruit
{
public :
	virtual void SayName()
	{
		cout << "我是北方苹果" << endl;
	}
};

class SouthBanana :public Fruit
{
public:
	virtual void SayName()
	{
		cout << "我是南方香蕉" << endl;
	}
};
class SouthApple :public Fruit
{
public:
	virtual void SayName()
	{
		cout << "我是南方苹果" << endl;
	}
};
class NorthFactory :public AbstracFactory
{
public :
	virtual Fruit* createBanana()
	{
		return new NorthBanana;
	}
	virtual Fruit* createApple()
	{
		return new NorthApple;
	}
};
class SouthFactory :public AbstracFactory
{
public:
	virtual Fruit* createBanana()
	{
		return new SouthBanana;
	}
	virtual Fruit* createApple()
	{
		return new SouthApple;
	}
};
void maiddddn()
{
	Fruit * fruit = NULL;
	AbstracFactory *af = NULL;


	af = new SouthFactory;
	fruit = af->createApple();
	fruit->SayName();

	fruit=af->createBanana();
	fruit->SayName();



	delete fruit;
	delete af;
	

	system("pause");
	return;
}
/*****************************************************************/
建造者模式
#include <iostream>
using namespace std;
#include "string"

class House
{
private:
	string m_door;
	string m_wall;
	string m_window;

public :
	void setDoor(string door)
	{
		this->m_door = door;
	}
	void setWall(string wall)
	{
		this->m_wall = wall;
	}
	void setWindow(string window)
	{
		this->m_window = window;
	}
	string getDoor()
	{
		cout << m_door << endl;
		return this->m_door;
	}
	string getWall()
	{
		cout << m_wall << endl;
		return this->m_wall;
	}
	string getWindow()
	{
		cout << m_window << endl;
		return this->m_window;
	}
};

class Builder
{
public :
	virtual void buildWall() = 0;
	virtual void buildDoor() = 0;
	virtual void buildWindow() = 0;
	virtual House* getHouse() = 0;
};
class FlatBuiler:public Builder
{
private:
	House *m_house;
public:
	FlatBuiler()
	{
		m_house = new House;
	}
	virtual void buildWall()
	{
		m_house->setWall("flat wall");
	}
	virtual void buildDoor()
	{
		m_house->setDoor("flat door");
	}
	virtual void buildWindow()
	{
		m_house->setWindow("flat window");
	}
	virtual House* getHouse()
	{
		return m_house;
	}
};
class VillaBuiler :public Builder
{
private:
	House *m_house;
public:
	VillaBuiler()
	{
		m_house = new House;
	}
	virtual void buildWall()
	{
		m_house->setWall("villa wall");
	}
	virtual void buildDoor()
	{
		m_house->setDoor("villa door");
	}
	virtual void buildWindow()
	{
		m_house->setWindow("villa window");
	}
	virtual House* getHouse()
	{
		return m_house;
	}
};
class Director
{
public:
	Director(Builder *build)
	{
		this->m_build = build;
	}
	void Construct()
	{
		m_build->buildWall();
		m_build->buildWindow();
		m_build->buildDoor();
	}
private :
	Builder *m_build;
};

void main()
{
	House *house = NULL;
	VillaBuiler *vllaBuilder = new VillaBuiler();
	Director *director = new Director(vllaBuilder);
	director->Construct();
	house =vllaBuilder->getHouse();
	house->getDoor();
	house->getWall();

	delete house;
	delete vllaBuilder;
	system("pause\n");
	return;
}

二、建造者模式

适用情况：一个对象的构建比较复杂，将一个对象的构建和对象的表示进行分离

builder模式是一种对象创建型模式之一吗用来隐藏复合对象的创建过程，他把符合对象的创建过程加以抽象，通过子类继承和重载的方式，动态的创建具有符合属性的对象。

角色分类：

• 1.builder:为创建产品各个部分，统一抽象接口。
• 2.concretebuilder:具体的创建产品的各个部分，部分A，部分B
• 3.director:构造一个使用builder接口的对象
• 4.product：表示被构造的复杂对象。

三、原型模式

prototype模式是一种对象创建模式，他采用复制原型对象的方法来创建对象的实例。使用prototype模式创建的实例，具有与原型一样的数据。

适用情况：一个复杂对象，具有自我复制功能，统一一套接口。

 

 

四、代理模式

结构型模式：proxy模式又叫代理模式，是构造型的设置模式之一，他可以为其他对象提供一种代理以控制对这个对象的访问。虽未代理，是指具有与代理元（被代理的对象）具有相同的接口的类，客户端必须通过代理与被代理的目标类交互，而代理一般在交互的过程中（交互前后），进行某些特别的处理。

适用于：为其他对象提供一种代理以控制对这个对象的访问。
 

五、装饰模式

 

装饰模式又叫包装模式，通过一种对客户端透明的方式来扩展对象的功能，是集成关系的一个替代方案。装饰模式就是把要添加的附加功能分别放在单例的类中，并让这个类包含他要装饰的对象。

适用于：装饰者模式（Decorator pattern) 动态的非一个对象添加一些额外的职责，就增加功能来说，此模式比生成子类更为灵活。

六、适配器模式

adapter模式也叫适配器模式，是构造模型之一，通过adapter模式可以改变已有类的接口形式。

适用于：是将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

 

七、桥接模式

bridge 模式又叫 桥接模式，是构造型的设计模式之一，bridge模式基于类的最小设计原则，通过使用封装、聚合、继承等行为来让不容的类承担不同的责任。他的主要特点是把抽象与行为实现分离开来。

适用于：桥接模式是将抽象部分与现实部分分离（解耦合），使他们都可以独立变化。

 

 

八、组合模式

composite模式也叫组合模式，是构造型模式设计之一，通过递归手段来构造树形的对象结构，并可以通过一个对象来访问整个对象树。

适用于：单一对象和组合对象的使用具有一致性，将对象组合成树形结构以表示“部分--整体”；

 

九、外观模式

适用于:为子系统中统一一套接口,让紫汐容更加容易使用.

 

 

十、享元模式

flyweight模式也叫享元模式，是构造模型之一，他通过与其他类似对象共I轩昂数据来减小内存占用。

适用场景：以共享的 方式，高效的支持大量的细粒度的对象。

 

十一、模板模式

template method 模式也叫模板方法模式，是行为模式之一，他把具有特定步骤算法中的某些必要的处理委让给抽象方法，通过子类继承对抽象方法的不同实现改变整个算法的行为。

应用场景：在抽象类中统一操作步骤，并规定好接口，让子类实现接口，这样可以把各个具体的子类和操作步骤解耦合。

 

十二、命令模式

command模式也叫命令模式，是行为设计模式的一种，command模式通常被称为command的类封装了对目标对象的调用行为以及调用参数。

在面向对象的程序设计中，一个对象调用另一个对象，一般情况下的调用过程是：创建目标对象实例；设置调用参数；调用目标对象的方法。但是在有些情况下必须使用一个专门的类对这种调用过程加以封装，我们把这种专门的类称作command类。

 

十三、责任链模式

chain of responsibility(CoR)，是行为模式之一，该模式构造一系列分别承担不同的职责的类的对象来共同完成一个任务，这些类的对象之间像链条一样紧密相连，所以称为责任链模式

适用于：链条式处理事情，工作流程化、消息处理流程化、事务流程化。

 

十四、策略模式

strategy是行为模式之一，它对一系列的算法加以封装，为所有算法定义一个抽象的算法接口，并通过继承该抽象算法接口对所有的算法加以封装和实现，具体的算法选择交由客户端决定（策略）；strategy模式主要用来平滑的处理算法的切换。

适用于：准备一组算法，并将每一个算法封装起来，使得他们可以互换。

 

十五、中介者模式

mediator，是由GoF提出的23种设计模式的一种，行为模式之一。在mediator模式中，类之间的交互行为被统一放在mediator的对象中，对象通过mediator对象同其他对象交互，mediator对象起着控制器的作用

适用于：用一个中介对象，封装一些列对象（同事）的交换，中介者是各个对象不需要显示的相互作用。从而实现了耦合松散，而且可以独立的改变他们之间的交换。

 

十六、观察者模式

observe是行为模式之一，他的作用是当一个对象的状态发生变化时，能够自动通知其他关联对象，自动刷新对象状态。observe模式提供给关联对象一种同步通信的手段，使某个对象与依赖他的其他对象之间保持状态同步。

适用于：定义对象间一种一对多的依赖关系，使得每一个对象改变状态，则所有依赖于他们的对象都会得到通知。

 

十七、备忘录模式

memento模式是行为模式之一，他的作用是保存对象的内部状态，并在需要的时候恢复之前的状态。

适用于：在不破坏封装性的前提下，补货一个对象的内部状态，并在该对象之外保存这个状态，这样就可以将以后的对象状态恢复到先前保存的状态。适用于功能比较复杂的，但需要记录或维护属性历史的类，或者需要保存的属性只是众多属性中的一小部分时originator可以根据保存的memo还原到之前状态。

 

十八、访问者模式

visitor模式是行为模式之一，它分离对象的数据和行为，使用visitor模式，可以不修改已有类的情况下，增加新的操作角色和职责。

适用于：把数据结构和作用于数据结构上的操作进行解耦；适用于数据结构比较稳定的场合。

总结：访问者模式有点事增加新的操作很容易，因为增加新的操作就意味着增加一个新的访问者，访问者模式将有关的行为集中到一个访问者对象中。访问者模式的缺点就是增加新的数据结构变得困难了

 

十九、状态模式

state模式是行为设计模式的一种，state模式允许通过改变对象内部的状态而改变对象的行为，这个对象表现得好像修改了他的类一样。状态模式主要解决的是当控制一个对象状态转换的条件表达式国语复杂时的情况，把状态的判断逻辑转移到表现不同状态的一系列类中，可以把复杂的潘大U呢逻辑简化。

适用于：通过用户的状态改变对象的行为。

 

二十、解释模式

一些应用提供了内建（build-in)的脚本或者宏语言来让用户可以定义他们能够在系统中进行操作，interpreter模式的目的就是使用一个解释器为用户提供一个一门定义语言的语法表示解释器，然后通过这个解释器来解释语言中的句子。

interpreter模式提供了这样的一个实现语法解释器的框架

 

二十一、迭代器模式

iterator是行为模式之一，他对容器中包含的内部对象的访问委让给外部类，使用iterator按顺序遍历访问的设计模式。

在迭代器中  持有一个集合的引用，所以通过迭代器，可以访问集合。