Prototype (원형) 디자인 모델 에 대한 분석

프로 토 타 입 인 스 턴 스 로 생 성 대상 의 종 류 를 지정 하고 이 프로 토 타 입 을 복사 하여 새로운 대상 을 만 듭 니 다.
Prototype 프로 토 타 입 모델 은 생 성 형 디자인 모델 입 니 다. Prototype 모델 은 한 대상 이 다른 맞 춤 형 대상 을 만 들 수 있 도록 합 니 다. 어떻게 만 드 는 지 알 필요 가 없습니다. 작업 원 리 는 하나의 프로 토 타 입 대상 을 만 들 대상 에 게 전달 하 는 것 입 니 다. 이 생 성 대상 은 프로 토 타 입 대상 에 게 자신 을 복사 하도록 요청 합 니 다.
    그것 이 주로 직면 하 는 문 제 는 '일부 구조 가 복잡 한 대상' 의 창설 작업 이다.수요 의 변화 로 인해 이런 대상 들 은 격렬 한 변화 에 직면 하지만 비교적 안정 적 이 고 일치 하 는 인 터 페 이 스 를 가지 고 있다.
Prototype Manager 가 있 는 원형 모드:   
클 라 이언 트 (Client) 역할: 클 라 이언 트 클래스 가 원형 관리자 에 게 생 성 대상 을 요청 합 니 다.
[1]
추상 적 인 원형 (Prototype) 역할: 이것 은 추상 적 인 역할 로 보통 C \ # 인터페이스 나 추상 적 인 유형 으로 이 루어 진다.이 캐릭터 는 모든 구체 적 인 원형 류 에 필요 한 인 터 페 이 스 를 제공 합 니 다.C \ # 에서 추상 적 인 원형 캐릭터 는 보통 ICloneable 인 터 페 이 스 를 실현 한다.
구체 적 인 원형 (Concrete Prototype) 역할: 복 제 된 대상.이 캐릭터 는 추상 적 인 원형 캐릭터 가 요구 하 는 인 터 페 이 스 를 실현 해 야 한다.
프로 토 타 입 관리자 (Prototype Manager) 역할: 구체 적 인 프로 토 타 입 클래스 의 대상 을 만 들 고 만 든 대상 을 기록 합 니 다.
     

#include "stdafx.h"
#include<iostream>
#include<vector>
#include<assert.h>
usingnamespace std;
//  
class Resume
{
protected:
char *name;
public:
Resume() {}
virtual ~Resume() {}
virtual Resume* Clone() { return NULL; }
virtualvoid Set(char *n) {}
virtualvoid Show() {}
};
class ResumeA : public Resume
{
public:
ResumeA(constchar *str); //    
ResumeA(const ResumeA &r); //      
~ResumeA(); //    
ResumeA* Clone(); //  ，    
void Show(); //    
};
ResumeA::ResumeA(constchar *str)
{
if(str == NULL) {
name = newchar[1];
name[0] = '\0';
}
else {
name = newchar[strlen(str)+1];
strcpy(name, str);
}
}
ResumeA::~ResumeA() { delete [] name;}
ResumeA::ResumeA(const ResumeA &r) {
name = newchar[strlen(r.name)+1];
strcpy(name, r.name);
}
ResumeA* ResumeA::Clone() {
returnnew ResumeA(*this);
}
void ResumeA::Show() {
cout<<"ResumeA name : "<<name<<endl;
}
class ResumeB : public Resume
{
public:
ResumeB(constchar *str); //    
ResumeB(const ResumeB &r); //      
~ResumeB(); //    
ResumeB* Clone(); //  ，    
void Show(); //    
};
ResumeB::ResumeB(constchar *str)
{
if(str == NULL) {
name = newchar[1];
name[0] = '\0';
}
else {
name = newchar[strlen(str)+1];
strcpy(name, str);
}
}
ResumeB::~ResumeB() { delete [] name;}
ResumeB::ResumeB(const ResumeB &r) {
name = newchar[strlen(r.name)+1];
strcpy(name, r.name);
}
ResumeB* ResumeB::Clone() {
returnnew ResumeB(*this);
}
void ResumeB::Show() {
cout<<"ResumeB name : "<<name<<endl;
}
class ResumeManager
{
private:
vector<Resume *> mResume;
public:
ResumeManager()
{
}
void add(Resume * resume)
{
mResume.push_back(resume);
}
Resume * get(int index) const
{
assert(index>=0 && index<mResume.size());
return mResume[index];
}
};
int _tmain(int argc, _TCHAR* argv[])
{
ResumeManager *manager = new ResumeManager();
Resume *r1 = new ResumeA("A");
Resume *r2 = new ResumeB("B");
manager->add(r1);
manager->add(r2);
manager->get(0)->Show();
manager->get(1)->Show();
Resume *r3 = manager->get(0)->Clone();
Resume *r4 = manager->get(1)->Clone();
//  r1,r2
delete r1; delete r2;
r1 = r2 = NULL;
//      r3,r4   
r3->Show(); r4->Show();
delete r3; delete r4;
r3 = r4 = NULL;
return 0;
}