※设计模式※→☆创建型模式☆============Builder模式（五）

最新推荐文章于 2023-06-19 19:16:43 发布

arvin_xiaoting

最新推荐文章于 2023-06-19 19:16:43 发布

阅读量5.5w

点赞数 1

分类专栏：设计模式 DesignPattern(设计模式) 文章标签： Builder模式 c++ C++ Design Pattern design pattern Design pattern 建造者模式设计模式

本文链接：https://blog.csdn.net/xiaoting451292510/article/details/8330462

版权

DesignPattern(设计模式) 同时被 2 个专栏收录

13 篇文章 44 订阅

订阅专栏

设计模式

10 篇文章 0 订阅

订阅专栏

模式概述

Builder模式相当容易让人误解，并走向误区。相信各位也同我一样对Builder模式有着许许多多的疑惑，非常容易与abstract factory模式和Template模式混淆，这些我将在模式实现中仔细同大家一起研究讨论。鉴于Builder模式的误解性比较高，本人也是研究和思考很多人写的一些文章，当然本人此次的文章也仅仅只供大家的参考。开篇前先一起参考下几篇有关还是比较有意义的文章吧！我也无法说哪个对哪个是错误的。在开发过程中，我们根据自己的场合选择适合自己的一种形式即可。

http://www.cnblogs.com/happyhippy/archive/2010/09/01/1814287.html

http://redsnow-fenglin.iteye.com/blog/691868

http://www.riabook.cn/doc/designpattern/BuilderPattern.htm

http://www.iteye.com/topic/71175

http://blog.csdn.net/zhongjiekangping/article/details/4557837

http://www.cnblogs.com/bastard/archive/2011/11/21/2257625.html

统设计中，有时候面临着一个“复杂系统”的创建工作，该对象通常由各个部分的子对象用一定的算法构成，或者说按一定的步骤组合而成；这些的算法和步骤是稳定的，而构成这个对象的子对象却经常由于需求改变而发生变化，此时我们可以选择使用Builder模式。尽管Builder模式相当容易让人误解，但我认为这几点应该是不会有错的。因此我个人认为Builder模式中要好好把握如下几点

1. 需要创建的对象是复杂对象

2. 对象的创建过程是一步步创建(即：可能由于过程的不同而导致有不同的对象展示)

3. 明确建造者（Builder）、具体建造者（Concrete Builder）、指导者（Director）、产品（Product）之间的职责和联系。

建造者（Builder）：

给出一个抽象接口，以规范产品对象的各个组成成分的建造。一般而言，此接口独立于应用程序的商业逻辑。模式中直接创建产品对象的是具体建造者（ConcreteBuilder）：具体建造者类必须实现这个接口所要求的方法：一个是建造方法，另一个是结果返还方法。

具体建造者（Concrete Builder）：

担任这个角色的是于应用程序紧密相关的类，它们在应用程序调用下创建产品实例。这个角色主要完成的任务包括：

实现Builder角色提供的接口，一步一步完成创建产品实例的过程。

在建造过程完成后，提供产品的实例。

指导者（Director）：

担任这个角色的类调用具体建造者角色以创建产品对象。导演者并没有产品类的具体知识，真正拥有产品类的具体知识的是具体建造者对象。

产品（Product）：

产品便是建造中的复杂对象。

意图：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

模式结构

Builder模式结构如下：

这里我把所有的子类Builder类使用Singleton模式处理了，因为确确实实我只需要一个这样的具体建造者，而不是需要多个。
Singleton模式见：
http://blog.csdn.net/xiaoting451292510/article/details/8285710

惯例，我个人习惯是喜欢把拷贝构造函数和赋值函数私有化，并不对其进行实现。以避免一些不必要的麻烦，如果确实是需要使用拷贝构造函数和赋值函数时，再进行一些相关具体情况的处理。

模式讨论

Buider模式可以一步步的进行复杂对象的构建。我们可以处理每一个步骤的细节化工作，使得经过相同的步骤创建最后得到的不同的对象。例如：我们经常使用的电脑，一般由鼠标（Mouse）、键盘（Keyboard）、显示器（Monitor）和主机（Host）构成。当我们组装机器的时候，我们就可以精细的选择各个部件。如果简单一点的，如我代码中的示例。我们可以选择Dell、ASUS还是HP的鼠标等，细化的话，可以继续对相应的鼠标进行加工处理。是要游戏性的鼠标还是办公式的鼠标。

在项目开发中，经常性各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将他们组合在一起的算法却相对稳定（例如：电脑一般由鼠标（Mouse）、键盘（Keyboard）、显示器（Monitor）和主机（Host）构成）。因此Builder模式的精髓：子对象变化较频繁（表示），对算法相对稳定（构建过程）（将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示）。

后续讨论：

如下网址，有人深入的说明了一些Builder模式相关和应该注意的地方，当然也应该仅供参考。

http://www.cnblogs.com/happyhippy/archive/2010/09/01/1814287.html

作者很注重于闭合性，当然这也是我们每个开发人员理应注重的地方。拿他雨的第二个例子来看好了。他把创建左手、创建右手合成了一个创建手的方法。当然这样就可以创建出各种各样的手了。比如说：三只手，一只手等等。或者也可以一只一只的创建。内部封装我们不必关注。但是毫无疑问，Person类的手也是要从左手+右手抽象成手了。然后使用手的多态实现手可以操作的功能。因此，我认为原书作者也是没有错的，Builder模式的选择使用方式在于不同的场合你对于现实中情景反应到Coding中的建模情况而定。而不能因Coding的需求来尽量拟合现实的场景。

Builder模式与Abstract Factory模式

相同点

1. 二者都是用来创建大的复杂对象

不同点

1. 抽象工厂通过不同的构建过程生成不同的对象表示，而Builder模式通过相同的构建过程生成不同的表示。

2. 抽象工厂中创建粒度为最终产品；builder模式中创建粒度为产品的各个构件。

3. 抽象工厂中，Client包含了Director的功能。

4. 抽象工厂中ProductA、ProductB的具体生成过程可以分别使用buidler模式实现。

5. 返回对象不同，抽象工厂对象是直接返回的，Builder模式对象不是直接返回的。

6. 强调的内容不同，抽象工厂强调创建多个相互依赖的对象提供一个同一的接口。Builder模式强制一步步创建对象，并通过相同的创建过程获得不同的结果对象。

最后，无论模式多么优越，我们也需要根据实际的具体情况而慎重考虑。

模式实现

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
以后的笔记潇汀会尽量详细讲解一些相关知识的，希望大家继续关注我的博客。
本节笔记到这里就结束了。

潇汀一有时间就会把自己的学习心得，觉得比较好的知识点写出来和大家一起分享。
编程开发的路很长很长，非常希望能和大家一起交流，共同学习，共同进步。
如果文章中有什么疏漏的地方，也请大家指正。也希望大家可以多留言来和我探讨编程相关的问题。
最后，谢谢你们一直的支持~~~

C++完整个代码示例（代码在VS2005下测试可运行）
代码及相关下载地址：
http://download.csdn.net/detail/xiaoting451292510/4935368

DesignPattern.cpp

// DesignPattern.cpp : Defines the entry point for the console application. // #include "stdafx.h" #ifndef CXX_DESIGNPATTERN_SINGLETON_H #include "DESIGNPATTERN_Singleton.h" #endif #ifndef CXX_PROFESSION_H #include "Profession.h" #endif #ifndef CXX_DESIGNPATTERN_SIMPLEFACTORY_H #include "DESIGNPATTERN_SimpleFactory.h" #endif #ifndef CXX_DESIGNPATTERN_COMPLEXFACTORY_H #include "DESIGNPATTERN_ComplexFactory.h" #endif #ifndef CXX_MOUSE_H #include "Mouse.h" #endif #ifndef CXX_KEYBOARD_H #include "Keyboard.h" #endif #ifndef CXX_MONITOR_H #include "Monitor.h" #endif #ifndef CXX_HOST_H #include "Host.h" #endif #ifndef CXX_DESIGNPATTERN_ABSTRACTFACTORY_H #include "DESIGNPATTERN_AbstractFactory.h" #endif #ifndef CXX_DESIGNPATTERN_DIRECTOR_H #include "CXX_DESIGNPATTERN_Director.h" #endif #ifndef CXX_DESIGNPATTERN_BUILDER_H #include "DESIGNPATTERN_Builder.h" #endif #ifndef CXX_COMPUTER_H #include "Computer.h" #endif int _tmain(int argc, _TCHAR* argv[]) { #if DEBG_TEST_SINGLETON cout<<"***************************Singleton***************************"<<endl; Singleton* pSingletonA = NULL; Singleton* pSingletonB = NULL; pSingletonA = Singleton::Instance(); pSingletonB = Singleton::Instance(); Singleton::Destroy(); Singleton::Destroy(); #endif #if DEBG_TEST_SIMPLEFACTORY cout<<"***************************SimpleFactory***************************"<<endl; Singleton* pSingletonA = NULL; Profession* pProfession[3] = {0}; for (int i=0; i<3; i++) { pProfession[i] = SimpleFactory::Instance()->CreateProfession(i); } for (int i=0; i<3; i++) { if (NULL != pProfession[i]) { delete pProfession[i]; pProfession[i] = NULL; } } #endif #if DEBG_TEST_COMPLEXFACTORY cout<<"***************************ComplexFactory***************************"<<endl; ComplexFactory* pWarriorFactory = WarriorFactory::Instance(); ComplexFactory* pMasterFactory = MasterFactory::Instance(); Profession* pWarrior = pWarriorFactory->CreateProfession(); Profession* pMaster = pMasterFactory->CreateProfession(); if (NULL != pWarrior) { delete pWarrior; pWarrior = NULL; } if (NULL != pMaster) { delete pMaster; pMaster = NULL; } #endif #if DEBG_TEST_ABSTRACTFACTORY cout<<"***************************AbstractFactory***************************"<<endl; AbstractFactory* pDELLFactory = DELLFactory::Instance(); AbstractFactory* pASUSFactory = ASUSFactory::Instance(); AbstractFactory* pHPFactory = HPFactory::Instance(); //DELL product Mouse* pDellMouse = pDELLFactory->CreateMouse(); Keyboard* pDellKeyboard = pDELLFactory->CreateKeyboard(); Monitor* pDellMonitor = pDELLFactory->CreateMonitor(); Host* pDellHost = pDELLFactory->CreateHost(); //ASUS product Mouse* pASUSMouse = pASUSFactory->CreateMouse(); Keyboard* pASUSKeyboard = pASUSFactory->CreateKeyboard(); Monitor* pASUSMonitor = pASUSFactory->CreateMonitor(); Host* pASUSHost = pASUSFactory->CreateHost(); //HP product Mouse* pHPMouse = pHPFactory->CreateMouse(); Keyboard* pHPKeyboard = pHPFactory->CreateKeyboard(); Monitor* pHPMonitor = pHPFactory->CreateMonitor(); Host* pHPHost = pHPFactory->CreateHost(); if (NULL != pDellMouse) { delete pDellMouse; pDellMouse = NULL; } if (NULL != pDellKeyboard) { delete pDellKeyboard; pDellKeyboard = NULL; } if (NULL != pDellMonitor) { delete pDellMonitor; pDellMonitor = NULL; } if (NULL != pDellHost) { delete pDellHost; pDellHost = NULL; } if (NULL != pHPMouse) { delete pHPMouse; pHPMouse = NULL; } if (NULL != pHPKeyboard) { delete pHPKeyboard; pHPKeyboard = NULL; } if (NULL != pHPMonitor) { delete pHPMonitor; pHPMonitor = NULL; } if (NULL != pHPHost) { delete pHPHost; pHPHost = NULL; } if (NULL != pASUSMouse) { delete pASUSMouse; pASUSMouse = NULL; } if (NULL != pASUSKeyboard) { delete pASUSKeyboard; pASUSKeyboard = NULL; } if (NULL != pASUSMonitor) { delete pASUSMonitor; pASUSMonitor = NULL; } if (NULL != pASUSHost) { delete pASUSHost; pASUSHost = NULL; } #endif #if DEBG_TEST_BUILDER cout<<"***************************Builder***************************"<<endl; Director* pDellDirector = new Director(DELLBuilder::Instance()); AbstractComputer* pDellComputer = pDellDirector->CreateComputer(); Director* pASUSDirector = new Director(ASUSBuilder::Instance()); AbstractComputer* pASUSComputer = pASUSDirector->CreateComputer(); Director* pHPDirector = new Director(HPBuilder::Instance()); AbstractComputer* pHPComputer = pHPDirector->CreateComputer(); if (NULL != pDellComputer) { delete pDellComputer; pDellComputer = NULL; } if (NULL != pASUSComputer) { delete pASUSComputer; pASUSComputer = NULL; } if (NULL != pHPComputer) { delete pHPComputer; pHPComputer = NULL; } #endif return 0; }

DESIGNPATTERN_Builder.h

/**
  @file     	DESIGNPATTERN_Builder.h 
  @brief    	1.When the algorithm to create complex object should be independent of the part of the object, 
                  as well as their assembly;
				2.When construction process must be allowed to construct the object is different;
  @author  	arvin
  @version 	1.0   2012/12/20
 */

#ifndef CXX_DESIGNPATTERN_BUILDER_H
#define CXX_DESIGNPATTERN_BUILDER_H

class AbstractComputer;
class Mouse;
class Keyboard;
class Monitor;
class Host;

class Builder
{
public:
	/**
	* Destruction
	*
	* @param VOID
	* @return 
	*/
	virtual ~Builder();

	/**
	* Create Computer
	*
	* @param VOID
	* @return AbstractComputer*
	* @note
	*/
	virtual AbstractComputer* CreateComputer();

protected:
	/**
	* Construction
	*
	* @param VOID
	* @return 
	*/
	Builder();

private:
	/**
	* Copy Construction
	*
	* @param const Builder& cBuilder
	* @return 
	*/
	Builder(const Builder& cBuilder);

	/**
	* Assignment
	*
	* @param const Builder& cBuilder
	* @return Builder&
	*/
	Builder& operator=(const Builder& cBuilder);

	/**
	* Build Mouse
	*
	* @param VOID
	* @return Mouse*
	* @note build and process product
	*/
	virtual Mouse* BuildMouse() = 0;

	/**
	* Build Keyboard
	*
	* @param VOID
	* @return Keyboard*
	* @note build and process product
	*/
	virtual Keyboard* BuildKeyboard() = 0;

	/**
	* Build Monitor
	*
	* @param VOID
	* @return Monitor*
	* @note build and process product
	*/
	virtual Monitor* BuildMonitor() = 0;

	/**
	* Build Host
	*
	* @param VOID
	* @return Host*
	* @note build and process product
	*/
	virtual Host* BuildHost() = 0;

public:
protected:
private:
};

class DELLBuilder : public Builder
{
public:
	/**
	* Destruction
	*
	* @param VOID
	* @return 
	*/
	virtual ~DELLBuilder();

	/**
	* Instance
	*
	* @param VOID
	* @return DELLBuilder*
	* @note singleton
	*/
	static DELLBuilder* Instance();
	
	/**
	* Destroy
	*
	* @param VOID
	* @return VOID
	* @note singleton
	*/
	static VOID Destroy();

protected:
private:
	/**
	* Construction
	*
	* @param VOID
	* @return 
	*/
	DELLBuilder();

	/**
	* Copy Construction
	*
	* @param const DELLBuilder& cDELLBuilder
	* @return 
	*/
	DELLBuilder(const DELLBuilder& cDELLBuilder);

	/**
	* Assignment
	*
	* @param const DELLBuilder& cDELLBuilder
	* @return DELLBuilder&
	*/
	DELLBuilder& operator=(const DELLBuilder& cDELLBuilder);

	/**
	* Build Mouse
	*
	* @param VOID
	* @return Mouse*
	* @note build and process product
	*/
	virtual Mouse* BuildMouse();

	/**
	* Build Keyboard
	*
	* @param VOID
	* @return Keyboard*
	* @note build and process product
	*/
	virtual Keyboard* BuildKeyboard();

	/**
	* Build Monitor
	*
	* @param VOID
	* @return Monitor*
	* @note build and process product
	*/
	virtual Monitor* BuildMonitor();

	/**
	* Build Host
	*
	* @param VOID
	* @return Host*
	* @note build and process product
	*/
	virtual Host* BuildHost();

public:
protected:
private:
	static DELLBuilder* m_pInstance;
};


class ASUSBuilder : public Builder
{
public:
	/**
	* Destruction
	*
	* @param VOID
	* @return 
	*/
	virtual ~ASUSBuilder();

	/**
	* Instance
	*
	* @param VOID
	* @return ASUSBuilder*
	* @note singleton
	*/
	static ASUSBuilder* Instance();
	
	/**
	* Destroy
	*
	* @param VOID
	* @return VOID
	* @note singleton
	*/
	static VOID Destroy();

protected:
private:
	/**
	* Construction
	*
	* @param VOID
	* @return 
	*/
	ASUSBuilder();

	/**
	* Copy Construction
	*
	* @param const ASUSBuilder& cASUSBuilder
	* @return 
	*/
	ASUSBuilder(const ASUSBuilder& cASUSBuilder);

	/**
	* Assignment
	*
	* @param const ASUSBuilder& cASUSBuilder
	* @return ASUSBuilder&
	*/
	ASUSBuilder& operator=(const ASUSBuilder& cASUSBuilder);

	/**
	* Build Mouse
	*
	* @param VOID
	* @return Mouse*
	* @note build and process product
	*/
	virtual Mouse* BuildMouse();

	/**
	* Build Keyboard
	*
	* @param VOID
	* @return Keyboard*
	* @note build and process product
	*/
	virtual Keyboard* BuildKeyboard();

	/**
	* Build Monitor
	*
	* @param VOID
	* @return Monitor*
	* @note build and process product
	*/
	virtual Monitor* BuildMonitor();

	/**
	* Build Host
	*
	* @param VOID
	* @return Host*
	* @note build and process product
	*/
	virtual Host* BuildHost();

public:
protected:
private:
	static ASUSBuilder* m_pInstance;
};

class HPBuilder : public Builder
{
public:
	/**
	* Destruction
	*
	* @param VOID
	* @return 
	*/
	virtual ~HPBuilder();

	/**
	* Instance
	*
	* @param VOID
	* @return HPBuilder*
	* @note singleton
	*/
	static HPBuilder* Instance();
	
	/**
	* Destroy
	*
	* @param VOID
	* @return VOID
	* @note singleton
	*/
	static VOID Destroy();

protected:
private:
	/**
	* Construction
	*
	* @param VOID
	* @return 
	*/
	HPBuilder();

	/**
	* Copy Construction
	*
	* @param const HPBuilder& cHPBuilder
	* @return 
	*/
	HPBuilder(const HPBuilder& cHPBuilder);

	/**
	* Assignment
	*
	* @param const HPBuilder& cHPBuilder
	* @return HPBuilder&
	*/
	HPBuilder& operator=(const HPBuilder& cHPBuilder);

	/**
	* Build Mouse
	*
	* @param VOID
	* @return Mouse*
	* @note build and process product
	*/
	virtual Mouse* BuildMouse();

	/**
	* Build Keyboard
	*
	* @param VOID
	* @return Keyboard*
	* @note build and process product
	*/
	virtual Keyboard* BuildKeyboard();

	/**
	* Build Monitor
	*
	* @param VOID
	* @return Monitor*
	* @note build and process product
	*/
	virtual Monitor* BuildMonitor();

	/**
	* Build Host
	*
	* @param VOID
	* @return Host*
	* @note build and process product
	*/
	virtual Host* BuildHost();

public:
protected:
private:
	static HPBuilder* m_pInstance;
};
#endif	/* >>CXX_DESIGNPATTERN_BUILDER_H<< */
/* EOF */

DESIGNPATTERN_Builder.cpp

/**
  @file     	DESIGNPATTERN_Builder.h 
  @brief    	1.When the algorithm to create complex object should be independent of the part of the object, 
                  as well as their assembly;
				2.When construction process must be allowed to construct the object is different;
  @author  	arvin
  @version 	1.0   2012/12/20
 */

#include "stdafx.h"

#ifndef CXX_DESIGNPATTERN_BUILDER_H
#include "DESIGNPATTERN_Builder.h"
#endif

#ifndef CXX_DESIGNPATTERN_ABSTRACTFACTORY_H
#include "DESIGNPATTERN_AbstractFactory.h"
#endif

#ifndef CXX_COMPUTER_H
#include "Computer.h"
#endif

#ifndef CXX_MOUSE_H
#include "Mouse.h"
#endif

#ifndef CXX_KEYBOARD_H
#include "Keyboard.h"
#endif

#ifndef CXX_MONITOR_H
#include "Monitor.h"
#endif

#ifndef CXX_HOST_H
#include "Host.h"
#endif


/**
* Construction
*
* @param VOID
* @return 
*/
Builder::Builder()
{

}

/**
* Destruction
*
* @param VOID
* @return 
*/
Builder::~Builder()
{

}


/**
* Create Computer
*
* @param VOID
* @return AbstractComputer*
* @note
*/
AbstractComputer* 
Builder::CreateComputer()
{
	//build Mouse;
	Mouse* pMouse = BuildMouse();
	//build Keyboard;
	Keyboard* pKeyboard = BuildKeyboard();
	//build Monitor;
	Monitor* pMonitor = BuildMonitor();
	//build Host;
	Host* pHost = BuildHost();

	return new Computer(pMouse, pKeyboard, pMonitor, pHost);
}


/**
* Build Mouse
*
* @param VOID
* @return Mouse*
* @note build and process product
*/
Mouse* 
Builder::BuildMouse()
{
	//system error log
	cerr<<"[Builder::BuildMouse] got called from thread "<</*ThreadID*/"at: "/**gettimeofday()*/<<endl;

	return NULL;
}

/**
* Build Keyboard
*
* @param VOID
* @return Keyboard*
* @note build and process product
*/
Keyboard* 
Builder::BuildKeyboard()
{
	//system error log
	cerr<<"[Builder::BuildKeyboard] got called from thread "<</*ThreadID*/"at: "/**gettimeofday()*/<<endl;

	return NULL;
}
/**
* Build Monitor
*
* @param VOID
* @return Monitor*
* @note build and process product
*/
Monitor* 
Builder::BuildMonitor()
{
	//system error log
	cerr<<"[Builder::BuildMonitor] got called from thread "<</*ThreadID*/"at: "/**gettimeofday()*/<<endl;

	return NULL;
}

/**
* Build Host
*
* @param VOID
* @return Host*
* @note build and process product
*/
Host* 
Builder::BuildHost()
{
	//system error log
	cerr<<"[Builder::BuildHost] got called from thread "<</*ThreadID*/"at: "/**gettimeofday()*/<<endl;

	return NULL;
}



DELLBuilder* DELLBuilder::m_pInstance = NULL;

/**
* Construction
*
* @param VOID
* @return 
*/
DELLBuilder::DELLBuilder()
{

}

/**
* Destruction
*
* @param VOID
* @return 
*/
DELLBuilder::~DELLBuilder()
{

}

/**
* Instance
*
* @param VOID
* @return DELLBuilder*
* @note singleton
*/
DELLBuilder* 
DELLBuilder::Instance()
{
	if (NULL == m_pInstance) {
		m_pInstance = new DELLBuilder;
	}
	return m_pInstance;
}


/**
* Destroy
*
* @param VOID
* @return VOID
* @note singleton
*/
VOID 
DELLBuilder::Destroy()
{
	if (NULL != m_pInstance) {
		delete m_pInstance;
		m_pInstance = NULL;
	}
}

/**
* Build Mouse
*
* @param VOID
* @return Mouse*
* @note build and process product
*/
Mouse* 
DELLBuilder::BuildMouse()
{
	return DELLFactory::Instance()->CreateMouse();
}

/**
* Build Keyboard
*
* @param VOID
* @return Keyboard*
* @note build and process product
*/
Keyboard* 
DELLBuilder::BuildKeyboard()
{
	return DELLFactory::Instance()->CreateKeyboard();
}

/**
* Build Monitor
*
* @param VOID
* @return Monitor*
* @note build and process product
*/
Monitor* 
DELLBuilder::BuildMonitor()
{
	return DELLFactory::Instance()->CreateMonitor();
}

/**
* Build Host
*
* @param VOID
* @return Host*
* @note build and process product
*/
Host* 
DELLBuilder::BuildHost()
{
	return DELLFactory::Instance()->CreateHost();
}


ASUSBuilder* ASUSBuilder::m_pInstance = NULL;

/**
* Construction
*
* @param VOID
* @return 
*/
ASUSBuilder::ASUSBuilder()
{

}

/**
* Destruction
*
* @param VOID
* @return 
*/
ASUSBuilder::~ASUSBuilder()
{

}

/**
* Instance
*
* @param VOID
* @return ASUSBuilder*
* @note singleton
*/
ASUSBuilder* 
ASUSBuilder::Instance()
{
	if (NULL == m_pInstance) {
		m_pInstance = new ASUSBuilder;
	}
	return m_pInstance;
}


/**
* Destroy
*
* @param VOID
* @return VOID
* @note singleton
*/
VOID 
ASUSBuilder::Destroy()
{
	if (NULL != m_pInstance) {
		delete m_pInstance;
		m_pInstance = NULL;
	}
}

/**
* Build Mouse
*
* @param VOID
* @return Mouse*
* @note build and process product
*/
Mouse* 
ASUSBuilder::BuildMouse()
{
	return ASUSFactory::Instance()->CreateMouse();
}

/**
* Build Keyboard
*
* @param VOID
* @return Keyboard*
* @note build and process product
*/
Keyboard* 
ASUSBuilder::BuildKeyboard()
{
	return ASUSFactory::Instance()->CreateKeyboard();
}

/**
* Build Monitor
*
* @param VOID
* @return Monitor*
* @note build and process product
*/
Monitor* 
ASUSBuilder::BuildMonitor()
{
	return ASUSFactory::Instance()->CreateMonitor();
}

/**
* Build Host
*
* @param VOID
* @return Host*
* @note build and process product
*/
Host* 
ASUSBuilder::BuildHost()
{
	return ASUSFactory::Instance()->CreateHost();
}



HPBuilder* HPBuilder::m_pInstance = NULL;

/**
* Construction
*
* @param VOID
* @return 
*/
HPBuilder::HPBuilder()
{

}

/**
* Destruction
*
* @param VOID
* @return 
*/
HPBuilder::~HPBuilder()
{

}

/**
* Instance
*
* @param VOID
* @return HPBuilder*
* @note singleton
*/
HPBuilder* 
HPBuilder::Instance()
{
	if (NULL == m_pInstance) {
		m_pInstance = new HPBuilder;
	}
	return m_pInstance;
}


/**
* Destroy
*
* @param VOID
* @return VOID
* @note singleton
*/
VOID 
HPBuilder::Destroy()
{
	if (NULL != m_pInstance) {
		delete m_pInstance;
		m_pInstance = NULL;
	}
}

/**
* Build Mouse
*
* @param VOID
* @return Mouse*
* @note build and process product
*/
Mouse* 
HPBuilder::BuildMouse()
{
	return HPFactory::Instance()->CreateMouse();
}

/**
* Build Keyboard
*
* @param VOID
* @return Keyboard*
* @note build and process product
*/
Keyboard* 
HPBuilder::BuildKeyboard()
{
	return HPFactory::Instance()->CreateKeyboard();
}

/**
* Build Monitor
*
* @param VOID
* @return Monitor*
* @note build and process product
*/
Monitor* 
HPBuilder::BuildMonitor()
{
	return HPFactory::Instance()->CreateMonitor();
}

/**
* Build Host
*
* @param VOID
* @return Host*
* @note build and process product
*/
Host* 
HPBuilder::BuildHost()
{
	return HPFactory::Instance()->CreateHost();
}
/* EOF */

CXX_DESIGNPATTERN_Director.h

/**
  @file     	DESIGNPATTERN_Director.h 
  @brief    	1.When the algorithm to create complex object should be independent of the part of the object, 
                  as well as their assembly;
				2.When construction process must be allowed to construct the object is different;
  @author  	arvin
  @version 	1.0   2012/12/20
 */

#ifndef CXX_DESIGNPATTERN_DIRECTOR_H
#define CXX_DESIGNPATTERN_DIRECTOR_H

class AbstractComputer;
class Builder;

class Director
{
public:
	/**
	* Construction
	*
	* @param Builder* pBuilder
	* @return 
	*/
	Director(Builder* pBuilder);

	/**
	* Destruction
	*
	* @param VOID
	* @return 
	*/
	~Director();

	/**
	* Create Computer
	*
	* @param VOID
	* @return AbstractComputer*
	* @note
	*/
	AbstractComputer* CreateComputer();

protected:

private:
	/**
	* Copy Construction
	*
	* @param const Director& cDirector
	* @return 
	*/
	Director(const Director& cDirector);

public:
protected:
private:
	Builder* m_pBuilder;
};

#endif	/* >>CXX_DESIGNPATTERN_DIRECTOR_H<< */
/* EOF */

CXX_DESIGNPATTERN_Director.cpp

/**
  @file     	DESIGNPATTERN_Director.h 
  @brief    	1.When the algorithm to create complex object should be independent of the part of the object, 
                  as well as their assembly;
				2.When construction process must be allowed to construct the object is different;
  @author  	arvin
  @version 	1.0   2012/12/20
 */
#include "stdafx.h"

#ifndef CXX_DESIGNPATTERN_DIRECTOR_H
#include "CXX_DESIGNPATTERN_Director.h"
#endif

#ifndef CXX_DESIGNPATTERN_BUILDER_H
#include "DESIGNPATTERN_Builder.h"
#endif

#ifndef CXX_DESIGNPATTERN_ABSTRACTFACTORY_H
#include "DESIGNPATTERN_AbstractFactory.h"
#endif

#ifndef CXX_COMPUTER_H
#include "Computer.h"
#endif

/**
* Construction
*
* @param Builder* pBuilder
* @return 
*/
Director::Director(Builder* pBuilder):
m_pBuilder(pBuilder)
{

}

/**
* Destruction
*
* @param VOID
* @return 
*/
Director::~Director()
{
	
}

/**
* Create Computer
*
* @param VOID
* @return AbstractComputer*
* @note
*/
AbstractComputer* 
Director::CreateComputer()
{
	if (NULL != m_pBuilder) {
		return m_pBuilder->CreateComputer();
	}
	return NULL;
}
/* EOF */

arvin_xiaoting

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
2
评论
※设计模式※→☆创建型模式☆============Builder模式（五）

模式概述 Builder模式相当容易让人误解，并走向误区。相信各位也同我一样对Builder模式有着许许多多的疑惑，非常容易与abstract factory模式和Template模式混淆，这些我将在模式实现中仔细同大家一起研究讨论。鉴于Builder模式的误解性比较高，本人也是研究和思考很多人写的一些文章，当然本人此次的文章也仅仅只供大家的参考。开篇前先一起参考下几篇有关...
复制链接

扫一扫