디자인 모드 의 원형 모드 (Prototype) 발췌

23 가지 GOF 디자인 모델 은 보통 세 가지 로 나 뉘 는데 그것 이 바로 창설 형 모델, 구조 형 모델, 행위 모델 이다.
창설 형 모드 는 1. Factory Method (공장 방법 모드) 를 포함한다.2. 추상 공장 (추상 공장 모델);3. Singleton (단일 모드);4. Builder (건설 자 모드, 생 성기 모드);5. Prototype (원형 모드).
구조 형 모델 은 6. Bridge (브리지 모델) 를 포함한다.7. 어댑터 (어댑터 모드);8. 장식 (장식 모드);9. Composite (조합 모드);10. Flyweight (향원 모드);11. Facade (외관 모델);12. 프 록 시 (프 록 시 모드).
행위 모드 는 13. TemplateMethod (템 플 릿 방법 모드) 를 포함한다.14. Strategy (전략 모델);15. 상태 (상태 모드);16. Observer (관찰자 모드);17. Memento (비망록 모드);18. Mediator (중개자 모드);19. command (명령 모드);20. Visitor (방문 자 모드);21. 책임 체인 (책임 체인 모델);22. Iterator (교체 기 모드);23. Interpreter (해석 기 모드).
Factory Method: 대상 을 만 드 는 데 사용 할 인 터 페 이 스 를 정의 하여 하위 클래스 가 어떤 종 류 를 예화 할 지 결정 합 니 다.Factory Method 는 클래스 의 실례 화 를 하위 클래스 로 지연 시 킵 니 다.
Abstract Factory: 일련의 관련 되 거나 서로 의존 하 는 대상 을 만 드 는 인 터 페 이 스 를 제공 합 니 다. 구체 적 인 종 류 를 지정 하지 않 아 도 됩 니 다.
Singleton: 하나의 인 스 턴 스 만 있 고 전체 방문 점 을 제공 합 니 다.
Builder: 복잡 한 대상 의 구축 을 표시 와 분리 시 켜 같은 구축 과정 에서 서로 다른 표 시 를 만 들 수 있 습 니 다.
Prototype: 생 성 대상 의 종 류 를 프로 토 타 입 인 스 턴 스 로 지정 하고 이 프로 토 타 입 을 복사 하여 새로운 대상 을 만 듭 니 다.
Bridge: 추상 적 인 부분 과 그 실현 부분 을 분리 하여 독립 적 으로 변화 시 킬 수 있 습 니 다.
Adapter: 하나의 인 터 페 이 스 를 고객 이 원 하 는 다른 인터페이스 로 변환 합 니 다.Adapter 모드 는 인터페이스 가 호 환 되 지 않 아 함께 일 할 수 없 었 던 클래스 들 을 함께 일 할 수 있 게 합 니 다.
Decorator: 대상 에 게 동적 으로 추가 적 인 직책 을 추가 합 니 다.확장 기능 의 경우 Decorator 모드 는 하위 클래스 생 성 방식 보다 유연 합 니 다.
Composite: 대상 을 트 리 구조 로 조합 하여 '부분 - 전체' 의 차원 구 조 를 나타 낸다.Composite 는 고객 이 단일 대상 과 복합 대상 에 대한 사용 을 일치 시 킵 니 다.
Flyweight: 공유 기술 을 활용 하여 대량의 입자 도 를 효과적으로 지원 하 는 대상.
Facade: 서브 시스템 의 인터페이스 에 일치 하 는 인 터 페 이 스 를 제공 합 니 다. Facade 모델 은 고 층 인 터 페 이 스 를 정 의 했 습 니 다. 이 인 터 페 이 스 는 이 서브 시스템 을 더욱 쉽게 사용 할 수 있 습 니 다.
Proxy: 이 대상 에 대한 접근 을 제어 하기 위해 다른 대상 에 게 에이 전 트 를 제공 합 니 다.
Template Method: 작업 중인 알고리즘 의 골격 을 정의 하고 일부 절 차 를 하위 클래스 로 지연 합 니 다.Template Method 는 하위 클래스 가 하나의 알고리즘 구 조 를 바 꾸 지 않 고 이 알고리즘 의 특정한 절 차 를 다시 정의 할 수 있 도록 합 니 다.
Strategy: 일련의 알고리즘 을 정의 하여 하나씩 포장 하고 서로 바 꿀 수 있 도록 합 니 다.이 모델 은 알고리즘 의 변 화 를 사용 하 는 고객 에 게 독립 시 킬 수 있 습 니 다.
State: 대상 이 내부 상태 가 바 뀔 때 행동 을 바 꿀 수 있 도록 합 니 다.대상 이 자신 이 속 한 종 류 를 수정 한 것 처럼 보인다.
Observer: 대상 간 의 다 중 의존 관 계 를 정의 합 니 다. 도시락 대상 의 상태 가 바 뀌 었 을 때 모든 의존 대상 이 알림 을 받 고 자동 으로 새로 고침 됩 니 다.
Memento: 패 키 징 성 을 파괴 하지 않 는 전제 에서 대상 의 내부 상 태 를 포착 하고 이 대상 외 에 이 상 태 를 저장 합 니 다.이렇게 하면 이 대상 을 저 장 된 상태 로 복원 할 수 있다.
Mediator: 일련의 대상 의 상호작용 을 중개 대상 으로 밀봉 합 니 다.중개 자 는 각 대상 이 명시 적 으로 서로 인용 하지 않 아 도 되 고 결합 을 느슨 하 게 하 며 독립 적 으로 그들의 상호작용 을 바 꿀 수 있다.
command: 하나의 요청 을 대상 으로 밀봉 하여 서로 다른 요청 으로 고객 을 매개 변수 화 할 수 있 습 니 다.요청 대기 열 이나 요청 로 그 를 기록 하고 취소 가능 한 동작 을 지원 합 니 다.
Visitor: 특정한 대상 구조 에 작용 하 는 각 요소 의 조작 을 나타 낸다.그것 은 각 요소 의 종 류 를 바 꾸 지 않 는 전제 에서 이러한 요소 에 작용 하 는 새로운 조작 을 정의 할 수 있 게 한다.
Chain of Responsibility: 요청 한 발송 자 와 수신 자 간 의 결합 을 해제 하기 위해 여러 대상 이 이 요청 을 처리 할 수 있 도록 합 니 다.이 대상 들 을 하나의 체인 으로 연결 하고 이 체인 을 따라 이 요 구 를 전달 하 며 한 대상 이 처리 할 때 까지 합 니 다.
Iterator: 취 합 대상 의 각 요 소 를 순서대로 방문 하 는 방법 을 제공 하고 이 대상 의 내부 표 시 를 노출 하지 않 아 도 됩 니 다.
Interpreter: 언어 를 지정 하여 문법 을 정의 하고 해석 기 를 정의 합 니 다. 이 해석 기 는 이 표현 을 사용 하여 언어 중의 문장 을 설명 합 니 다.
 
         Prototype: (1), 의도: 생 성 대상 의 종 류 를 원형 인 스 턴 스 로 지정 하고 이 원형 을 복사 하여 새로운 대상 을 만 듭 니 다.(2) 시스템 이 제품 의 생 성, 구성 과 표시 에 독립 해 야 할 때 Prototype 모드 를 사용 해 야 합 니 다.그리고 실례 화 할 클래스 가 실행 시간 에 지 정 될 때, 예 를 들 어 동적 으로 불 러 오기;또는 제품 류 차원 과 평행 하 는 공장 류 차원 을 만 드 는 것 을 피하 기 위해또는 하나의 인 스 턴 스 가 몇 개의 서로 다른 상태 조합 중 하나 만 있 을 때.해당 수량의 원형 을 만 들 고 복제 하 는 것 이 매번 적당 한 상태 로 수공 으로 이 종 류 를 예화 하 는 것 보다 더 편리 할 수 있 습 니 다.(3) 장점: A. 운영 시간 에 제품 을 추가 하고 삭제 합 니 다. Prototype 은 고객 이 원형 인 스 턴 스 를 등록 하면 새로운 구체 적 인 제품 류 를 시스템 에 통합 할 수 있 습 니 다.이것 은 다른 창설 형 모델 보다 더욱 유연 하 다. 왜냐하면 고객 은 운행 시간 에 원형 을 구축 하고 삭제 할 수 있 기 때문이다.B. 값 을 바 꾸 어 새로운 대상 을 지정 합 니 다. 고도 의 동적 시스템 은 대상 을 통 해 새로운 행 위 를 복합 적 으로 정의 할 수 있 습 니 다. 예 를 들 어 하나의 대상 변수 로 값 을 지정 합 니 다. - 그리고 새로운 종 류 를 정의 하지 않 습 니 다.기 존 클래스 를 예화 하고 이 인 스 턴 스 를 고객 대상 의 원형 으로 등록 하면 새로운 유형의 대상 을 효과적으로 정의 할 수 있 습 니 다.고객 은 직책 을 원형 에 대리 하여 새로운 행 위 를 나 타 낼 수 있다.이런 디자인 은 사용자 로 하여 금 프로 그래 밍 없 이 새로운 '클래스' 를 정의 할 수 있 게 한다.실제로 하나의 원형 을 복제 하 는 것 은 하나의 종 류 를 예화 하 는 것 과 유사 하 다.Prototype 모드 는 시스템 에 필요 한 클래스 의 수 를 크게 줄 일 수 있 습 니 다.C. 구 조 를 바 꾸 어 새로운 대상 을 지정 합 니 다.D. 하위 클래스 의 구 조 를 감소 합 니 다. Factory Method 는 제품 류 의 차원 과 평행 하 는 Creator 류 의 차원 을 자주 발생 합 니 다.Prototype 모드 는 공장 에 새로운 대상 을 만 드 는 방법 을 요청 하 는 것 이 아니 라 원형 을 복제 할 수 있 습 니 다.그래서 Creator 클래스 가 필요 없습니다.이 장점 은 주로 C + + 와 같이 등급 을 낮 추 지 않 고 1 급 대상 으로 하 는 언어 에 적용 된다.E. 클래스 동적 설정 응용 프로그램: 일부 실행 시간 환경 에서 클래스 를 응용 프로그램 에 동적 으로 불 러 올 수 있 습 니 다.C + + 와 같은 언어 에서 Prototype 모델 은 이러한 기능 을 이용 하 는 관건 이다.
         동적 불 러 오 는 인 스 턴 스 를 만 들 려 는 프로그램 은 정적 참조 클래스 를 만 들 수 없 는 구조 기 입 니 다.실행 환경 이 불 러 올 때 모든 종류의 인 스 턴 스 를 자동 으로 만 들 고 프로 토 타 입 관리자 로 이 인 스 턴 스 를 등록 해 야 합 니 다.이렇게 하면 프로 토 타 입 관리자 에 게 새로 불 러 온 클래스 의 인 스 턴 스 를 요청 할 수 있 습 니 다. 이 클래스 들 은 원래 프로그램 과 연결 되 지 않 았 습 니 다.
         Prototype 의 주요 결함 은 모든 Prototype 의 하위 클래스 가 반드시 Clone 작업 을 실현 해 야 한 다 는 것 입 니 다. 이것 은 매우 어 려 울 수 있 습 니 다.예 를 들 어 고려 한 클래스 가 이미 존재 할 때 Clone 작업 을 추가 하기 어렵다.내부 에 복사 가 지원 되 지 않 거나 순환 적 으로 인용 되 는 대상 이 포함 되 어 있 을 때 복 제 를 실현 하 는 것 도 어 려 울 수 있 습 니 다.
         Prototype 과 Abstract Factory 모델 은 어떤 면 에서 서로 경쟁 합 니 다.하지만 그것들 도 함께 사용 할 수 있다.Abstract Factory 는 복 제 된 원형 집합 을 저장 하고 제품 대상 으로 돌아 갈 수 있 습 니 다.Composite 와 Decorator 모델 을 대량으로 사용 하 는 디자인 도 일반적으로 Prototype 모델 에서 이득 을 볼 수 있다.
         Prototype 모드 는 자체 복제 기능 을 제공 합 니 다. 즉, 새로운 대상 의 생 성 은 기 존 대상 을 통 해 생 성 할 수 있 습 니 다.Prototype 모드 는 존재 하 는 대상 을 통 해 새로운 대상 을 만 드 는 인터페이스 (Clone) 를 제공 합 니 다. Clone () 실현 은 구체 적 인 실현 언어 와 관련 되 고 C + + 에서 복사 구조 함 수 를 통 해 이 루어 집 니 다.
         대상 에서 맞 춤 형 대상 을 만 들 고 만 든 세부 사항 을 알 필요 가 없 으 며 만 든 성능 을 향상 시 킬 수 있 습 니 다.말하자면 copy 기술 로 한 대상 의 완전한 copy 를 한 부 내 라.
         Prototype 모드 는 프로 토 타 입 (Prototype) 을 복사 하여 새로운 대상 을 만 드 는 기능 을 얻 습 니 다. 여기 서 Prototype 자체 가 '대상 공장' (대상 이 생 길 수 있 기 때 문) 입 니 다. 실제로 Prototype 모드 와 Builder 모드, Abstract Factory 모드 는 하나의 클래스 (이미지 인 스 턴 스) 를 통 해 대상 의 생 성 작업 (공장 대상) 을 전담 합 니 다.이들 의 차이 점 은 Builder 모드 는 복잡 한 대상 의 한 걸음 한 걸음 만 들 기 (대상 으로 직접 돌아 가지 않 음) 에 중심 을 두 고 있 으 며, Abstract Factory 모드 는 서로 의존 하 는 대상 을 만 드 는 데 중심 을 두 고 있 으 며, Prototype 모드 는 자신 이 복사 한 것 에서 새로운 종 류 를 만 드 는 데 중심 을 두 고 있다.
예제 코드 1:

#include <iostream>
#include <vector>
#include <string>

using namespace std;

class Prototype//    
{
private:
	string m_strName;
public:
	Prototype(string strName) {m_strName = strName;}
	Prototype() {m_strName = "";}
	void Show()
	{
		cout<<m_strName<<endl;
	}
	virtual Prototype* Clone() = 0;
};

//class ConcretePrototype1
class ConcretePrototype1 : public Prototype
{
public:
	ConcretePrototype1(string strName) : Prototype(strName) {}
	ConcretePrototype1() {}

	virtual Prototype* Clone()
	{
		ConcretePrototype1* p = new ConcretePrototype1();
		*p = *this;//    
		return p;
	}
};

//class ConcretePrototype2
class ConcretePrototype2 : public Prototype
{
public:
	ConcretePrototype2(string strName) : Prototype(strName) {}
	ConcretePrototype2() {}

	virtual Prototype* Clone()
	{
		ConcretePrototype2* p = new ConcretePrototype2();
		*p = *this;//    

		return p;
	}
};

//   
int main()
{
	ConcretePrototype1* test1 = new ConcretePrototype1("  ");
	ConcretePrototype2* test2 = (ConcretePrototype2*)test1->Clone();

	test1->Show();
	test2->Show();
	/* result:
		  
		  
	*/

	return 0;
}

예제 코드 2:
prototype.h:

#ifndef _PROTOTYPE_H_
#define _PROTOTYPE_H_

class Prototype
{
public:
	virtual ~Prototype();
	virtual Prototype* Clone() const = 0;
protected:
	Prototype();
private:
};

class ConcretePrototype : public Prototype
{
public:
	ConcretePrototype();
	ConcretePrototype(const ConcretePrototype& cp);
	~ConcretePrototype();
	Prototype* Clone() const;
protected:
private:
};

#endif//_PROTOTYPE_H_

prototype.cpp:

#include "prototype.h"
#include <iostream>
using namespace std;

Prototype::Prototype()
{

}

Prototype::~Prototype()
{

}

Prototype* Prototype::Clone() const
{
	return 0;
}

ConcretePrototype::ConcretePrototype()
{

}

ConcretePrototype::~ConcretePrototype()
{

}

ConcretePrototype::ConcretePrototype(const ConcretePrototype& cp)
{
	cout<<"ConcretePrototype copy ..."<<endl;
}

Prototype* ConcretePrototype::Clone() const
{
	return new ConcretePrototype(*this);
}

main.cpp:

#include "prototype.h"
#include <iostream>
using namespace std;

int main()
{
	Prototype* p = new ConcretePrototype();
	Prototype* p1 = p->Clone();
	/* result:
		ConcretePrototype copy ...
	*/
	return 0;
}

원형 모드 구성 도:
참고 문헌:
1. < 뻥 튀기 디자인 모델 C + + >
2. 는
3. 는 대상 소프트웨어 를 재 활용 할 수 있 는 기초 이다.