C++建造者模式（原理+代码）

构建者模式的运用场景：

某类对象的构建过程由多步组成，各步执行细节一直变化，但是所有步骤间的组合关系不变。

构建者模式的结构：

产品类：具体的产品对象，在下面的示例中人 = 头发+ 眼睛+鼻子，“人”就是对象，头发，眼睛，鼻子是人的属性。这类里主要是列出产品属性，设置set方法给属性赋值。

抽象构建者类：在构造函数中new一个产品类的对象（作为该类的成员变量），根据产品属性设置对应的抽象方法，在子类中实现。并写一个抽象接口返回产品类对象。

具体构建者类：公共继承抽象构建者类，根据具体要求实现对应的抽象方法。

指挥者类：声明一个抽象构建者对象，一个类方法是将具体构建者对象给抽象构建者对象赋值，第二个类方法是将具体构建者构建产品类的步骤按顺序集中到函数中，最后返回一个产品类的对象。

产品类代码：

//产品类（定义产品的属性，给产品属性赋值的方法）
class Product
{
public:
    Product() {}
    void setHairColor(std::string hairColor) {
        this->m_HairColor = hairColor; 
    }

    void setEyeColor(std::string eyeColor) {
        this->m_EyeColor = eyeColor;
    }

    void setNoseColor(std::string noseColor){
        this->m_NoseColor = noseColor;
    }
    
    //打印验证函数
    void PrintProuct()
    {
        std::cout << "HairColor is " << m_HairColor << "--" << "EyeColor is " << m_EyeColor <<
            "--" << "NoseColor is " << m_NoseColor << std::endl;
    }


private:
    std::string m_HairColor;
    std::string m_EyeColor;
    std::string m_NoseColor;
};

抽象构建者类代码：

//抽象构建者（一个产品对象和给产品对象属性赋值的抽象方法）
class AbstractBuilder
{
public:
    AbstractBuilder(){
        m_product = new Product();
    }
    //抽象方法：
    virtual void buildHair() = 0;
    virtual void buildEye() = 0;
    virtual void buildNose() = 0;
    virtual Product* returnProduct() = 0;

    Product *m_product;
};

具体构建者类代码：

//具体构建者(给继承的产品类对象赋值)
class ConcreteBuilderA : public AbstractBuilder
{
public:   
    ConcreteBuilderA(){
        std::cout << "ConcreteBuilderA" << std::endl;
    }

    void buildHair(){
        this->m_product->setHairColor("YellowA");
    }

    void buildEye(){
        this->m_product->setEyeColor("BlueA");
    }
    void buildNose(){
        this->m_product->setNoseColor("PurpleA");
    }

    Product* returnProduct() {
        return this->m_product;
    }
};

//具体构建者(给继承的产品类对象赋值)
class ConcreteBuilderB : public AbstractBuilder
{
public:
    ConcreteBuilderB() {
        std::cout << "ConcreteBuilderB" << std::endl;
    }

    void buildHair() {
        this->m_product->setHairColor("BlackB");
    }

    void buildEye() {
        this->m_product->setEyeColor("GreenB");
    }
    void buildNose() {
        this->m_product->setNoseColor("PinkB");
    }

    Product* returnProduct() {
        return this->m_product;
    }
};

指挥者类代码：

/指挥者
class Director
{
public:
    Director() {}
 //具体实现方法
    void setBuilder(AbstractBuilder* builder) {
        this->m_builder = builder;
    }
//封装组装流程，返回构建结果
    Product* construct() {
        m_builder->buildHair();
        m_builder->buildEye();
        m_builder->buildNose();
        return m_builder->returnProduct();
    }
private:
    AbstractBuilder* m_builder;
};

验证和调用：

int main()
{
    std::cout << "Hello World!\n";

    Director *director = new Director();//指挥者
    AbstractBuilder* builder;//抽象建造者

    builder = new ConcreteBuilderA();//产品A（子类指针给父类对象赋值）
    director->setBuilder(builder);//builder为具体建造者
    Product*  proA = director->construct();//具体构建者给产品属性赋值
    proA->PrintProuct();

    builder = new ConcreteBuilderB();//产品B（子类指针给父类对象赋值）
    director->setBuilder(builder);//builder为具体建造者
    Product* proB = director->construct();//具体构建者给产品属性赋值
    proB->PrintProuct();     
}

结果：