c++设计模式之建造者模式

建造者模式:
结构:
1.产品对象:一类产品的抽象，具体产品的建造应该在具体建造者中实现
3.抽象建造者
4.具体建造者：对于每种具体产品都应该有一个对应的建造者，其中应该有一个抽象产品对象成员变量
5.装配者：建造者对各个零件单独建造，没有顺序，因此，需要早装配者中确定建造顺序

优点:
1.建造者独立，易扩展
缺点:
1.产品必须具有相同属性
2.产品越多，需要的建造者类也就越多

场景:
手机有很多，小米，华为，三星，苹果，虽然名称不一样，但是内部结构基本差不多。这种场景就很适合使用建造者模式:

//IBuilder.h
#pragma once
#include "Phone.h"
class IBuilder
{
public:
    IBuilder();
    ~IBuilder();
protected:
    Phone* phone_;
public:
    virtual void build_camera() = 0;
    virtual void build_earphone() = 0;
    virtual void build_screen() = 0;
    virtual Phone* get_phone();
};

class XiaomiBuilder:public IBuilder
{
public:
    XiaomiBuilder();
    void build_camera();
    void build_earphone();
    void build_screen();
};


class HuaweiBuilder :public IBuilder
{
public:
    HuaweiBuilder();
    void build_camera();
    void build_earphone();
    void build_screen();
};

//IBuilder.cpp
#include "pch.h"
#include "IBuilder.h"


IBuilder::IBuilder()
{
}


IBuilder::~IBuilder()
{
}

Phone* IBuilder::get_phone() 
{
    return phone_;
}

XiaomiBuilder::XiaomiBuilder() 
{
    phone_ = new Phone;
}

void XiaomiBuilder::build_camera() 
{
    phone_->set_camera("xiaomi camera!!1");
}

void XiaomiBuilder::build_screen() 
{
    phone_->set_screen("xiaomi screen!!!");
}

void XiaomiBuilder::build_earphone() 
{
    phone_->set_earphone("xiaomi earphone!!!");
}

HuaweiBuilder::HuaweiBuilder()
{
    phone_ = new Phone;
}

void HuaweiBuilder::build_camera()
{
    phone_->set_camera("huawei camera!!1");
}

void HuaweiBuilder::build_screen()
{
    phone_->set_screen("huawei screen!!!");
}

void HuaweiBuilder::build_earphone()
{
    phone_->set_earphone("huawei earphone!!!");
}

//Assembler.h
#pragma once
#include "IBuilder.h"
class Assembler
{
public:
    Assembler();
    ~Assembler();
    void create(IBuilder* builedr);
};

//Assembler.cpp
#include "pch.h"
#include "Assembler.h"


Assembler::Assembler()
{
}


Assembler::~Assembler()
{
}


void Assembler::create(IBuilder* builedr) 
{
    builedr->build_screen();
    builedr->build_earphone();
    builedr->build_camera();
}

//Phone.h
#pragma once
#include <iostream>
#include <string.h>
using namespace std;

class Phone
{
public:
    Phone();
    ~Phone();
    void set_camera(string camera);
    void set_screen(string screen);
    void set_earphone(string earphone);
    void display_camera();
    void display_earphone();
    void display_screen();
private:
    string camera_;
    string screen_;
    string earphone_;
};

//Phone.cpp
#include "pch.h"
#include "Phone.h"


Phone::Phone()
{
}


Phone::~Phone()
{
}

void Phone::set_camera(string camera) 
{
    camera_ = camera;
}

void Phone::set_earphone(string earphone) 
{
    earphone_ = earphone;
}

void Phone::set_screen(string screen) 
{
    screen_ = screen;
}

void Phone::display_camera() 
{
    cout << camera_.c_str() << endl;
}

void Phone::display_earphone() 
{
    cout << earphone_.c_str() << endl;
}

void Phone::display_screen() 
{
    cout << screen_.c_str() << endl;
}

//main.cpp
#include "Phone.h"
#include "IBuilder.h"
using namespace std;

#ifndef SAFE_DELETE
#define  SAFE_DELETE(p){if(p){delete (p);(p)=NULL;}}
#endif


int main()
{ 
    IBuilder* xiaomi = new XiaomiBuilder;
    IBuilder* huawei = new HuaweiBuilder;
    Assembler* assembler = new Assembler;
    assembler->create(xiaomi);
    assembler->create(huawei);

    Phone* xiaomi_phone = xiaomi->get_phone();
    Phone* huawei_phone = huawei->get_phone();

    xiaomi_phone->display_camera();
    xiaomi_phone->display_earphone();
    xiaomi_phone->display_screen();

    huawei_phone->display_camera();
    huawei_phone->display_earphone();
    huawei_phone->display_screen();


    SAFE_DELETE(xiaomi);
    SAFE_DELETE(xiaomi_phone);
    SAFE_DELETE(huawei);
    SAFE_DELETE(huawei_phone);
    SAFE_DELETE(assembler);

    getchar();
}

//运行结果