建造者模式（Builder Pattern）C++

上一节：模板方法模式（Template Method Pattern） C++

1.理论

建造者模式（Builder Pattern）是一种创建型设计模式，旨在通过逐步构建复杂对象来解决对象创建过程的灵活性和可扩展性问题。它允许你将对象的构建步骤与表示分离，以便可以使用相同的构建过程创建不同的表示。
建造者模式通常用于创建具有多个组成部分的复杂对象，或者需要进行一系列步骤才能完成的对象构建过程。该模式将对象的构建过程封装在一个单独的"建造者"类中，它负责构建对象的各个组成部分。
建造者模式的主要角色包括以下几个部分：

1. 产品（Product）：表示正在构建的复杂对象。它通常由多个部分组成，这些部分可以是对象、属性或其他组件。
2. 抽象建造者（Builder）：定义了构建产品所需的所有方法和操作。它提供了一种接口，用于在不同的具体建造者类之间进行交互。
3. 具体建造者（Concrete Builder）：实现了抽象建造者接口，负责实际构建产品的各个部分，并定义了返回最终产品的方法。
4. 指导者（Director）：负责管理建造者的构建过程。它根据特定的顺序调用建造者的方法，以确保正确地构建产品。

使用建造者模式的基本流程如下：

1. 定义产品的类，确定产品的各个部分。
2. 创建抽象建造者接口，定义构建产品所需的方法。
3. 创建具体建造者类，实现抽象建造者接口。在具体建造者类中，实现构建产品各个部分的具体操作。
4. 创建指导者类，负责协调建造者的构建过程。它根据特定的顺序调用建造者的方法来构建产品。
5. 客户端通过实例化具体建造者和指导者类，调用指导者的构建方法来构建产品。

建造者模式的优点包括：

• 将对象的构建过程与表示分离，使得相同的构建过程可以创建不同的表示。
• 可以控制产品对象的创建过程，并可以逐步构造复杂对象。
• 提供了更好的封装性，隐藏了产品的内部细节。
• 提高了代码的可读性和可维护性。

建造者模式在需要创建复杂对象，并希望将构建过程与表示分离的情况下非常有用。它常被用于构建各种对象，例如在创建数据库连接、配置对象、表单生成器等场景中。

2.实践

你现在是一个游戏开发人员，当你使用C++编写一个游戏角色的创建过程时，可以使用建造者模式来实现。假设你的游戏角色由以下几个组成部分：角色名称、角色类型、角色性别、角色等级。
首先，定义一个表示游戏角色的类Character，包含角色名称、角色类型、角色性别、角色等级等属性。

class Character {
private:
    std::string name;
    std::string type;
    std::string gender;
    int level;

public:
    void setName(const std::string& name) {
        this->name = name;
    }

    void setType(const std::string& type) {
        this->type = type;
    }

    void setGender(const std::string& gender) {
        this->gender = gender;
    }

    void setLevel(int level) {
        this->level = level;
    }

    // Other methods...
};

接下来，创建一个抽象建造者类CharacterBuilder，定义构建游戏角色的各个部分的方法，并声明一个返回最终产品的方法。

class CharacterBuilder {
public:
    virtual void buildName() = 0;
    virtual void buildType() = 0;
    virtual void buildGender() = 0;
    virtual void buildLevel() = 0;

    virtual Character getResult() = 0;
};

然后，创建具体建造者类ConcreteCharacterBuilder，实现抽象建造者接口，并具体实现构建游戏角色各个部分的方法。

class ConcreteCharacterBuilder : public CharacterBuilder {
private:
    Character character;

public:
    void buildName() override {
        character.setName("John"); // 默认名称为"John"
    }

    void buildType() override {
        character.setType("Warrior"); // 默认角色类型为"Warrior"
    }

    void buildGender() override {
        character.setGender("Male"); // 默认性别为"Male"
    }

    void buildLevel() override {
        character.setLevel(1); // 默认等级为1
    }

    Character getResult() override {
        return character;
    }
};

最后，创建指导者类CharacterDirector，负责协调建造者的构建过程，按照特定顺序调用建造者的方法来构建游戏角色。

class CharacterDirector {
private:
    CharacterBuilder* builder;

public:
    void setBuilder(CharacterBuilder* builder) {
        this->builder = builder;
    }

    Character construct() {
        builder->buildName();
        builder->buildType();
        builder->buildGender();
        builder->buildLevel();
        return builder->getResult();
    }
};

使用示例：

int main() {
    ConcreteCharacterBuilder builder;
    CharacterDirector director;
    director.setBuilder(&builder);

    Character character = director.construct();

    // 使用构建后的角色对象
    // ...
    
    return 0;
}

通过以上示例，你可以看到建造者模式的应用。在这个例子中，游戏角色的创建过程被封装在CharacterBuilder中，通过指导者CharacterDirector按照特定顺序调用建造者的方法来构建角色.

以下是完整的代码

#include 
#include 

class Character {
private:
    std::string name;
    std::string type;
    std::string gender;
    int level;

public:
    void setName(const std::string& name) {
        this->name = name;
    }

    void setType(const std::string& type) {
        this->type = type;
    }

    void setGender(const std::string& gender) {
        this->gender = gender;
    }

    void setLevel(int level) {
        this->level = level;
    }

    void displayInfo() {
        std::cout << "Character Information:" << std::endl;
        std::cout << "Name: " << name << std::endl;
        std::cout << "Type: " << type << std::endl;
        std::cout << "Gender: " << gender << std::endl;
        std::cout << "Level: " << level << std::endl;
    }
};

class CharacterBuilder {
protected:
    Character character;

public:
    virtual void buildName() = 0;
    virtual void buildType() = 0;
    virtual void buildGender() = 0;
    virtual void buildLevel() = 0;

    Character getResult() {
        return character;
    }
};

class WarriorBuilder : public CharacterBuilder {
public:
    void buildName() override {
        character.setName("Warrior");
    }

    void buildType() override {
        character.setType("Warrior");
    }

    void buildGender() override {
        character.setGender("Male");
    }

    void buildLevel() override {
        character.setLevel(1);
    }
};

class MageBuilder : public CharacterBuilder {
public:
    void buildName() override {
        character.setName("Mage");
    }

    void buildType() override {
        character.setType("Mage");
    }

    void buildGender() override {
        character.setGender("Female");
    }

    void buildLevel() override {
        character.setLevel(1);
    }
};

class CharacterDirector {
private:
    CharacterBuilder* builder;

public:
    void setBuilder(CharacterBuilder* builder) {
        this->builder = builder;
    }

    Character construct() {
        builder->buildName();
        builder->buildType();
        builder->buildGender();
        builder->buildLevel();
        return builder->getResult();
    }
};

int main() {
    CharacterDirector director;

    // 创建一个战士角色
    WarriorBuilder warriorBuilder;
    director.setBuilder(&warriorBuilder);
    Character warrior = director.construct();
    warrior.displayInfo();

    std::cout << std::endl;

    // 创建一个法师角色
    MageBuilder mageBuilder;
    director.setBuilder(&mageBuilder);
    Character mage = director.construct();
    mage.displayInfo();

    return 0;
}

输出结果如下：

Character Information:
Name: Warrior
Type: Warrior
Gender: Male
Level: 1

Character Information:
Name: Mage
Type: Mage
Gender: Female
Level: 1

这个例子展示了建造者模式的使用。通过使用不同的建造者，我们可以构建具有不同属性的游戏角色，而无需直接操作复杂的构建过程。建造者模式将对象的构建过程和表示分离，使得我们可以更灵活地构建不同的对象，并且可以随时增加新的建造者类来扩展构建过程。

下一节：还没有写。