디자인 모델: 13 건설 자 모델

작성 자 모드:
복잡 한 대상 의 구조 재 를 그 표시 와 분리 시 켜 같은 구조 재 과정 이 서로 다른 표 시 를 만 들 수 있 도록 한다.
사용 자 는 만들어 야 할 유형 만 지정 하면 얻 을 수 있 으 며 구체 적 인 과정 과 세부 사항 은 알 필요 가 없다.
Builder: 제품 대상 의 위 젯 별로 지정 한 추상 적 인 인 터 페 이 스 를 만 듭 니 다.
ConcreteBuilder: 구체 적 인 건설 자, Builder 인터페이스 실현, 각 부품 구조 및 조립
제품: 구체 적 인 제품
Director: 지휘자, Builder 인 터 페 이 스 를 사용 하 는 대상 을 구축 하여 복잡 한 대상 을 구축 합 니 다.
장점: 건설 코드 와 표시 코드 를 분리 시 키 고 건설 자 는 제품 을 어떻게 조립 하 는 지 숨 기 며 제품 내부 표 시 를 바 꾸 려 면 구체 적 인 건설 자 를 정의 하면 된다.
 
요약: 건설 자 모델 은 복잡 한 대상 을 만 드 는 알고리즘 이 이 대상 의 구성 부분 과 그들의 조립 방식 에 독립 되 어야 할 때 적용 되 는 모델 이다.
 
main.cpp

#include <iostream>
#include <stdlib.h>
#include <memory>
#include "PersonBuilder.h"
#include "PersonDirector.h"
#include "PersonThinBuilder.h"
#include "PersonFatBuilder.h"
using namespace std;

void process()
{
	PersonThinBuilder personThinBuilder("  ");
	PersonFatBuilder personFatBuilder("  ");
	PersonDirector personThinDirector(personThinBuilder);
	personThinDirector.createPerson();
	PersonDirector personFatDirector(personFatBuilder);
	personFatDirector.createPerson();	
}

int main(int argc,char* argv[])
{
	process();
	system("pause");
	return 0;
}

PersonBuilder.h

#ifndef PERSONBUILDER_H
#define PERSONBUILDER_H
#include <string>
class PersonBuilder
{
public:
	PersonBuilder(const std::string& sName);
	virtual ~PersonBuilder(void);

	virtual void buildHead();
	virtual void buildBody();
	virtual void buildArmLeft();
	virtual void buildArmRight();
	virtual void buildLegLeft();
	virtual void buildLegRight();
protected:
	std::string _sName;
};
#endif

PersonBuilder.cpp

#include "PersonBuilder.h"


PersonBuilder::PersonBuilder(const std::string& sName):_sName(sName)
{
}


PersonBuilder::~PersonBuilder(void)
{
}

void PersonBuilder::buildHead()
{
}

void PersonBuilder::buildBody()
{
}

void PersonBuilder::buildArmLeft()
{
}

void PersonBuilder::buildArmRight()
{

}

void PersonBuilder::buildLegLeft()
{
}

void PersonBuilder::buildLegRight()
{
}

 
PersonFatBuilder.h

#ifndef PERSONFATBUILDER_H
#define PERSONFATBUILDER_H
#include <string>
#include "personbuilder.h"
class PersonFatBuilder :
	public PersonBuilder
{
public:
	PersonFatBuilder(const std::string& sName);
	~PersonFatBuilder(void);

	void buildHead();
	void buildBody();
	void buildArmLeft();
	void buildArmRight();
	void buildLegLeft();
	void buildLegRight();
};
#endif

PersonFatBuilder.cpp

<p>#include "PersonFatBuilder.h"
#include <iostream></p><p>using namespace std;</p><p>
PersonFatBuilder::PersonFatBuilder(const std::string& sName):PersonBuilder(sName)
{
}</p><p>
PersonFatBuilder::~PersonFatBuilder(void)
{
}</p><p>void PersonFatBuilder::buildHead()
{
 cout << _sName << "     " << endl;
}</p><p>void PersonFatBuilder::buildBody()
{
 cout << _sName << "     " << endl;
}</p><p>void PersonFatBuilder::buildArmLeft()
{
 cout << _sName << "     " << endl;
}</p><p>void PersonFatBuilder::buildArmRight()
{
 cout << _sName << "     " << endl;
}</p><p>void PersonFatBuilder::buildLegLeft()
{
 cout << _sName << "     " << endl;
}</p><p>void PersonFatBuilder::buildLegRight()
{
 cout << _sName << "     " << endl;
}</p>

PersonThinBuilder.h

#ifndef PERSONTHINBUILDER_H
#define PERSONTHINBUILDER_H
#include <string>
#include "personbuilder.h"
class PersonThinBuilder :
	public PersonBuilder
{
public:
	PersonThinBuilder(const std::string& sName);
	~PersonThinBuilder(void);
	void buildHead();
	void buildBody();
	void buildArmLeft();
	void buildArmRight();
	void buildLegLeft();
	void buildLegRight();
};
#endif

PersonThinBuilder.cpp

#include "PersonThinBuilder.h"
#include <iostream>

using namespace std;

PersonThinBuilder::PersonThinBuilder(const std::string& sName):PersonBuilder(sName)
{
}


PersonThinBuilder::~PersonThinBuilder(void)
{
}

void PersonThinBuilder::buildHead()
{
	cout << _sName << "     " << endl;
}

void PersonThinBuilder::buildBody()
{
	cout << _sName << "     " << endl;
}

void PersonThinBuilder::buildArmLeft()
{
	cout << _sName << "     " << endl;
}

void PersonThinBuilder::buildArmRight()
{
	cout << _sName << "     " << endl;
}

void PersonThinBuilder::buildLegLeft()
{
	cout << _sName << "     " << endl;
}

void PersonThinBuilder::buildLegRight()
{
	cout << _sName << "     " << endl;
}

 
PersonDirector.h

#ifndef PERSONDIRECTOR_H
#define PERSONDIRECTOR_H
#include "PersonBuilder.h"
#include <memory>
class PersonDirector
{
public:
	PersonDirector(PersonBuilder& personBuilder);
	~PersonDirector(void);
	void createPerson();
private:
	std::shared_ptr<PersonBuilder> _ptrPersonBuilder;
	//PersonBuilder _personBuilder;
};

#endif

PersonDirector.cpp

#include "PersonDirector.h"


PersonDirector::PersonDirector(PersonBuilder& personBuilder)//:_personBuilder(personBuilder)
{
	_ptrPersonBuilder.reset(&personBuilder);
}


PersonDirector::~PersonDirector(void)
{
}

void PersonDirector::createPerson()
{

	_ptrPersonBuilder->buildHead();
	_ptrPersonBuilder->buildBody();
	_ptrPersonBuilder->buildArmLeft();
	_ptrPersonBuilder->buildArmRight();
	_ptrPersonBuilder->buildLegLeft();
	_ptrPersonBuilder->buildLegRight();

	/*
	_personBuilder.buildHead();
	_personBuilder.buildBody();
	_personBuilder.buildArmLeft();
	_personBuilder.buildArmRight();
	_personBuilder.buildLegLeft();
	_personBuilder.buildLegRight();
	*/
}