设计模式之建造者模式

 

 

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

优点:

        封装性：封装了具体步骤，减少冗余。

        易扩展性：建造者独立，扩展性强。

缺点：

       建造的算法不能发生太大的变化，否则影响灵活性。

适用于多个方法不同顺序，多个部件组装但结果不同等场景。

代码实现：

//builder.h
#ifndef _BUILDER_H_
#define _BUILDER_H_

#include <iostream>

class Product
{
	public:
		Product();
		~Product();
		
		void setPartA(int param);
		void setPartB(int param);
		void setPartC(int param);
		
		void show();
		
	private:
		int partA;
		int partB;
		int partC;
};


class AbstractBuilder
{
	public:
		AbstractBuilder();
		virtual ~AbstractBuilder();
		
		virtual void createProduct() = 0;
		virtual void buildPartA(int param) = 0;
		virtual void buildPartB(int param) = 0;
		virtual void buildPartC(int param) = 0;
		
		virtual Product* getProduct() = 0;
};

class Builder : public AbstractBuilder
{
	public:
		Builder();
		~Builder();
		
		void createProduct();
		void buildPartA(int param);
		void buildPartB(int param);
		void buildPartC(int param);
		
		Product* getProduct();
	private:
		Product* curProduct;
};

#endif

//builder.cpp
#include "builder.h"
#include <iostream>


Product::Product()
{
	
}
Product::~Product()
{
	
}

void Product::setPartA(int param)
{
	partA= param;
}
void Product::setPartB(int param)
{
	partB= param;
}
void Product::setPartC(int param)
{
	partC= param;
}

void Product::show()
{
	fprintf(stderr,"partA = %d,partB = %d,partC = %d\n",partA,partB,partC);
}
		




AbstractBuilder::AbstractBuilder()
{
	
}
AbstractBuilder::~AbstractBuilder()
{
	
}



Builder::Builder() : curProduct(NULL)
{
	
}
Builder::~Builder()
{
	
}

void Builder::createProduct()
{
	fprintf(stderr,"创建一个产品空壳\n");
	curProduct = new Product();
}
void Builder::buildPartA(int param)
{
	fprintf(stderr,"正在构建产品的A部分\n");
	curProduct->setPartA(param);
}
void Builder::buildPartB(int param)
{
	fprintf(stderr,"正在构建产品的B部分\n");
	curProduct->setPartB(param);
}
void Builder::buildPartC(int param)
{
	fprintf(stderr,"正在构建产品的C部分\n");
	curProduct->setPartC(param);
}

Product* Builder::getProduct()
{
	return curProduct;
}

//director.h
#ifndef _DIRECTOR_H_
#define _DIRECTOR_H_

#include "builder.h"

class Director
{
	public:
		Director(AbstractBuilder* builder);
		~Director();
		
		void construct();
	private:
		AbstractBuilder* curBuilder;
};


#endif

//director.cpp
#include "director.h"

Director::Director(AbstractBuilder* builder)
{
	curBuilder = builder;
}
Director::~Director()
{
	
}
		
void Director::construct()
{
	if(!curBuilder)
		return;
	curBuilder->createProduct();
	curBuilder->buildPartA(1);
	curBuilder->buildPartB(2);
	curBuilder->buildPartC(3);
}

//main.cpp
#include "director.h"

int main()
{
	AbstractBuilder* builder = new Builder();
	Director* director = new Director(builder);
	
	director->construct();
	
	Product* product = builder->getProduct();
	product->show();
	
	
	return 0;
}