创建型设计模式---构建模式(Builder)

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

适用场景：

（1）当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时

（2）当构造过程必须允许被构造的对象有不同的表示时



#include <iostream>

#include <string>

#include <map>

using namespace std;

class Vehicle

{

public:

        Vehicle(const string &type) : type_(type)

        {

        }

        void setPart(const string &partKey, const string &partValue)

        {

                parts_[partKey] = partValue;

        }

        void const show()

        {

                cout << "Type:        " << type_ << endl;

                cout << "Engine:      " << parts_["engine"] << endl;

                cout << "Wheels:      " << parts_["wheels"] << endl;

        }

private:

        Vehicle();

private:

        string type_;

        map<string, string> parts_;

};

class VehicleBuilder

{

public:

        VehicleBuilder()

        {

                vehicle_ = NULL;

        }

        virtual ~VehicleBuilder()

        {

                if (NULL != vehicle_)

                {

                        delete vehicle_;

                        vehicle_ = NULL;

                }

        }

        Vehicle *getVehicle()

        {

                return vehicle_;

        }

        virtual void buildEngine() = 0;

        virtual void buildWheels() = 0;

protected:

        Vehicle *vehicle_;

};

class BMW : public VehicleBuilder

{

public:

        BMW()

        {

                vehicle_ = new Vehicle("BMW");

        }

        void buildEngine()

        {

                vehicle_->setPart("engine", "BMW Engine");

        }

        void buildWheels()

        {

                vehicle_->setPart("wheels", "BMW Wheels");

        }

};

class Audi : public VehicleBuilder

{

public:

        Audi()

        {

                vehicle_ = new Vehicle("Audi");

        }

        void buildEngine()

        {

                vehicle_->setPart("engine", "Audi Engine");

        }

        void buildWheels()

        {

                vehicle_->setPart("wheels", "Audi Wheels");

        }

};

class Director

{

public:

        void construct(VehicleBuilder *builder)

        {

                builder->buildEngine();

                builder->buildWheels();

        }

};

int main()

{

        VehicleBuilder *builder  = NULL;

        Director director;

        builder = new BMW();

        director.construct(builder);

        builder->getVehicle()->show();

        delete builder;

        builder = new Audi();

        director.construct(builder);

        builder->getVehicle()->show();

        delete builder;

        builder = NULL;

        return 0;

}

output:

Type:        BMW

Engine:      BMW Engine

Wheels:      BMW Wheels

Type:        Audi

Engine:      Audi Engine

Wheels:      Audi Wheels