原型模式，建造者模式，桥接模式

同样的，今天就介绍三种模式；

先从第一种模式开始讲起，原型模式；

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象，

原型模式要解决的问题是不用重新初始化对象，而是动态的获取对象运行时的状态，你只需要对对象做部分属性或行为的修改；

原型模式实现的关键是实现Clone函数，对于c++来说，其实就是拷贝构造函数，需要实现深拷贝；

看代码：

//父类
class Resume
{
protected:
    char *name;
public:
    Resume() {}
    virtual ~Resume() {}
    virtual Resume* Clone() { return NULL; }
    virtual void Set(char *n) {}
    virtual void Show() {}
};
//子类A
class ResumeA : public Resume
{
public:
    ResumeA(const char *str);  //构造函数
    ResumeA(const ResumeA &r); //拷贝构造函数
    ~ResumeA();                //析构函数
    ResumeA* Clone();          //克隆，关键所在
    void Show();               //显示内容
};
ResumeA::ResumeA(const char *str)
{
    if(str == NULL) {
        name = new char[1];
        name[0] = '\0';
    }
    else {
        name = new char[strlen(str)+1];
        strcpy(name, str);
    }
}
ResumeA::~ResumeA() { delete [] name;}
ResumeA::ResumeA(const ResumeA &r) {
    name = new char[strlen(r.name)+1];
    strcpy(name, r.name);
}
ResumeA* ResumeA::Clone() {
    return new ResumeA(*this);
}
void ResumeA::Show() {
    cout<<"ResumeA name : "<<name<<endl; 
}
//子类B
class ResumeB : public Resume
{
public:
    ResumeB(const char *str);  //构造函数
    ResumeB(const ResumeB &r); //拷贝构造函数
    ~ResumeB();                //析构函数
    ResumeB* Clone();          //克隆，关键所在
    void Show();               //显示内容
};
ResumeB::ResumeB(const char *str)
{
    if(str == NULL) {
        name = new char[1];
        name[0] = '\0';
    }
    else {
        name = new char[strlen(str)+1];
        strcpy(name, str);
    }
}
ResumeB::~ResumeB() { delete [] name;}
ResumeB::ResumeB(const ResumeB &r) {
    name = new char[strlen(r.name)+1];
    strcpy(name, r.name);
}
ResumeB* ResumeB::Clone() {
    return new ResumeB(*this);
}
void ResumeB::Show() {
    cout<<"ResumeB name : "<<name<<endl;
}

int main()
{
    Resume *r1 = new ResumeA("A");
    Resume *r2 = new ResumeB("B");
    Resume *r3 = r1->Clone();
    Resume *r4 = r2->Clone();
    r1->Show(); r2->Show();
    //删除r1,r2
    delete r1; delete r2;
    r1 = r2 = NULL;
    //深拷贝所以对r3,r4无影响
    r3->Show(); r4->Show();
    delete r3; delete r4;
    r3 = r4 = NULL;
}

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－华丽的分割线－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

下面介绍第2种模式：

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

 对于客户来说，只需知道导向者就可以了，通过导向者，客户就能构造复杂的对象，而不需要知道具体的构造过程。下面给出小人例子的代码实现。

看代码：

class Builder  
{
public:
	virtual void BuildHead() {}
	virtual void BuildBody() {}
	virtual void BuildLeftArm(){}
	virtual void BuildRightArm() {}
	virtual void BuildLeftLeg() {}
	virtual void BuildRightLeg() {}
};
//构造瘦人
class ThinBuilder : public Builder
{
public:
	void BuildHead() { cout<<"build thin body"<<endl; }
	void BuildBody() { cout<<"build thin head"<<endl; }
	void BuildLeftArm() { cout<<"build thin leftarm"<<endl; }
	void BuildRightArm() { cout<<"build thin rightarm"<<endl; }
	void BuildLeftLeg() { cout<<"build thin leftleg"<<endl; }
	void BuildRightLeg() { cout<<"build thin rightleg"<<endl; }
};
//构造胖人
class FatBuilder : public Builder
{
public:
	void BuildHead() { cout<<"build fat body"<<endl; }
	void BuildBody() { cout<<"build fat head"<<endl; }
	void BuildLeftArm() { cout<<"build fat leftarm"<<endl; }
	void BuildRightArm() { cout<<"build fat rightarm"<<endl; }
	void BuildLeftLeg() { cout<<"build fat leftleg"<<endl; }
	void BuildRightLeg() { cout<<"build fat rightleg"<<endl; }
};
//构造的指挥官
class Director  
{
private:
	Builder *m_pBuilder;
public:
	Director(Builder *builder) { m_pBuilder = builder; }
	void Create(){
		m_pBuilder->BuildHead();
		m_pBuilder->BuildBody();
		m_pBuilder->BuildLeftArm();
		m_pBuilder->BuildRightArm();
		m_pBuilder->BuildLeftLeg();
		m_pBuilder->BuildRightLeg();
	}
};

int main()
{
	FatBuilder thin;
	Director director(&thin);
	director.Create();
	return 0;
}

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－华丽的分割线－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

下面就介绍第三种设计模式：桥接模式

定义：将抽象部分与它的实现部分分离，让他们可以独立的变化；

就以操作系统为例，有多种配置的计算机，同样也有不同的操作系统；

UML图为：

看代码：

//操作系统
class OS
{
public:
	virtual void InstallOS_Imp() {}
};
class WindowOS: public OS
{
public:
	void InstallOS_Imp() { cout<<"安装Window操作系统"<<endl; } 
};
class LinuxOS: public OS
{
public:
	void InstallOS_Imp() { cout<<"安装Linux操作系统"<<endl; } 
};
class UnixOS: public OS
{
public:
	void InstallOS_Imp() { cout<<"安装Unix操作系统"<<endl; } 
};
//计算机
class Computer
{
public:
	virtual void InstallOS(OS *os) {}
};
class DellComputer: public Computer
{
public:
	void InstallOS(OS *os) { os->InstallOS_Imp(); }
};
class AppleComputer: public Computer
{
public:
	void InstallOS(OS *os) { os->InstallOS_Imp(); }
};
class HPComputer: public Computer
{
public:
	void InstallOS(OS *os) { os->InstallOS_Imp(); }
};

int main()
{
	OS *os1 = new WindowOS();
	OS *os2 = new LinuxOS();
	Computer *computer1 = new AppleComputer();
	computer1->InstallOS(os1);
	computer1->InstallOS(os2);
}