设计模式之建造者模式(C++实现)

这两天工作不忙，抽空学习了设计模式中的建造者模式，感觉《设计模式---可复用面向对象软件的基础》这本书不适合我看，有些东西写的太杂，反正我是没心情一点点的看，所以又买了一本《大话设计模式》，对于设计模式的学习今天看了一篇文章说：学习设计模式最主要的是记住模式的应用场景和UML图，深有感触，设计模式的思想靠死记硬背确实不是容易记住，好了，发发牢骚，言归正传，下面的对今天设计模式的总结以及对设计模式理解的代码实现。  

建造者模式：将一个复杂的对象的构建和表示区分开来。最主要的特征了对象的创建必须按照一定的流程，指挥者使用建造者按照这个流程创建对象，该流程不可变，建造者在建造具体对象的细节是可变的，也就是对象的表示。

ifndef BUILDER_H_
#define BUILDER_H_
#include "product.h"
class builder
{

	//按照统一步骤构建产品，但是产品的构建过程对客户不可见，这样就可以创建不一样的产品，将对象的构建和它的表示实现分离的目的
public:
	virtual void buildPartA(){};
	virtual void buildPartB(){};
	virtual void buildPartC(){};

public:
	Product *product;
};

class ConcreteBuilderFat : public builder
{
public:
	ConcreteBuilderFat();
	~ConcreteBuilderFat();
	void buildPartA();
	void buildPartB();
	void buildPartC();
	Product * GetResult();
};

class ConcreteBuilderThin : public builder
{
public:
	ConcreteBuilderThin();
	~ConcreteBuilderThin();
	void buildPartA();
	void buildPartB();
	void buildPartC();
	Product * GetResult();
};
#endif

builder.cpp

#include "builder.h"

void ConcreteBuilderFat::buildPartA()
{
	product->SetPartA("胖子头");
}
void ConcreteBuilderFat::buildPartB()
{
	product->SetPartB("胖子身子");
}

void ConcreteBuilderFat::buildPartC()
{
	product->SetPartC("胖子脚");
}

Product* ConcreteBuilderFat::GetResult()
{
	return this->product;
}

ConcreteBuilderFat::ConcreteBuilderFat()
{
	product = new Product();
}

ConcreteBuilderFat::~ConcreteBuilderFat()
{
	delete product;
	product = NULL;
}


void ConcreteBuilderThin::buildPartA()
{
	product->SetPartA("瘦子头");
}
void ConcreteBuilderThin::buildPartB()
{
	product->SetPartB("瘦子身子");
}

void ConcreteBuilderThin::buildPartC()
{
	product->SetPartC("瘦子脚");
}

Product* ConcreteBuilderThin::GetResult()
{
	return this->product;
}

ConcreteBuilderThin::ConcreteBuilderThin()
{
	product = new Product();
}

ConcreteBuilderThin::~ConcreteBuilderThin()
{
	delete product;
	product = NULL;
}

Product.h

#ifndef PRODUCT_H_
#define PRODUCT_H_
#include <iostream>

class Product
{

public:
	void SetPartA(std::string str){ partA = str; }
	void SetPartB(std::string str){ partB = str; };
	void SetPartC(std::string str){ partC = str; }
	void ShowPartA(){ std::cout << partA.c_str() << std::endl; }
	void ShowPartB(){ std::cout << partB.c_str() << std::endl; }
	void ShowPartC(){ std::cout << partC.c_str() << std::endl; }

private:
	std::string partA,partB,partC;
};

#endif

Director.h

#ifndef DIRECTOR_H_
#define DIRECTOR_H_
#include"builder.h"
class Director
{
public:
	void Construct();
	void SetBuilder(builder *);
private:
	builder* m_builder;
};

#endif

Director.cpp

#include "Director.h"

void Director::Construct()
{
	m_builder->buildPartA();
	m_builder->buildPartB();
	m_builder->buildPartC();
}

void Director::SetBuilder(builder * builder)
{
	m_builder = builder;
}

main.cpp

#include "Director.h"

int main()
{
	ConcreteBuilderFat *mBuilderfat = new ConcreteBuilderFat();
	Director dir;
	dir.SetBuilder(mBuilderfat);
	dir.Construct();
	Product *fat = mBuilderfat->GetResult();
	fat->ShowPartA();
	fat->ShowPartB();
	fat->ShowPartC();


	ConcreteBuilderThin * mbuilderThin = new ConcreteBuilderThin();
	dir.SetBuilder(mbuilderThin);
	dir.Construct();
	Product* thin = mbuilderThin->GetResult();
	thin->ShowPartA();
	thin->ShowPartB();
	thin->ShowPartC();
	delete mBuilderfat;
	delete mbuilderThin;
	//调用指挥者同样的构建过程Construct，可以创建不一样的对象，这就是讲对象的构建和表示分开，对象总是按照统一的步骤构建的
	return 0;
}