1. 应用场景

当一个类的构造函数参数个数超过4个，而且这些参数有些是可选的参数，考虑使用构造者模式。

2. 使用builder链式创建对象

class Person {
private:
    string name;
    int age;
    
public:
    string GetName() {
        return this->name;
    }

    int GetAge() {
        return this->age;
    }
    
    Person(const Builder& builder) {
        name = builder.name;
        age = builder.age;
    }

    class Builder {
    public:
        string name;
        int age;
    public:
        Builder& SetName(const string &name) {
            this->name = name;
            return *this;
        }

        Builder& SetAge(const int age) {
            this->age = age;
            return *this;
        }

        shared_ptr<Person> build() {
            return make_shared<Person>(*this);
        }
    };
};
int main() {
    auto person = Person::Builder().SetName("zhangsan").SetAge(1).build();
    cout << person->GetName() << endl;
    cout << person->GetAge() << endl;
}

传统方法

普通实现

class Car {
public:
    string wheel;
    string engine;
    Car(string wheel_in, string engine_in):wheel(wheel_in),engine(engine_in){}
};

class CarBuilder {
public:
    Car buildCar1() {
        return Car("111","111");
    }
    Car buildCar2() {
        return Car("222","222");
    }
    // 新增类型需要修改该类
};

int main() {
    CarBuilder builder;
    auto Car2 = builder.buildCar2();
}

运用建造者模式

将builder提取出接口

class Car {
public:
    string wheel;
    string engine;
    Car(string wheel_in, string engine_in):wheel(wheel_in),engine(engine_in){}
};

class BuildInterface {
public:
    virtual string buildWheel() = 0;
    virtual string buildEngine() = 0;
    virtual ~BuildInterface() = default;
};

class Car1Build : public BuildInterface{
public:
    string buildEngine() override{return "111";}
    string buildWheel() override{return "111";}
};

//director类
class Director{
private:
    BuildInterface* buildInterface;
public:
    Director(BuildInterface* buildInterface1) {
        buildInterface = buildInterface1;
    }
    Car BuildCar() {
        return Car(buildInterface->buildWheel(), buildInterface->buildEngine());
    }
    ~Director(){
        if (buildInterface) {
            delete buildInterface;
            buildInterface = nullptr;
        }
    }
};

int main() {
    Director director(new Car1Build);
    auto car = director.BuildCar();
    cout << car.engine << car.wheel << endl;
}