C++建造者模式实现与设计解析

建造者模式与工厂模式的区别在于，工厂模式用于创建不同类型的对象，而建造者模式专注于构建复杂对象的不同部分。1. 工厂模式通常一步返回完整对象；2. 建造者模式允许逐步构建并控制过程；3. 建造者适用于对象构建复杂、需灵活配置组件的情况；4. 建造者避免构造函数臃肿，提高可维护性；5. C++中通过在析构函数中释放内存或使用智能指针防止内存泄漏。

C++建造者模式的核心在于将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。这在对象构造过程复杂，且需要灵活配置不同组件时非常有用。

解决方案

建造者模式通过定义一个抽象的建造者类（Builder），以及具体的建造者类（ConcreteBuilder）来实现。抽象建造者定义了构建产品各个部分的接口，而具体建造者则负责实现这些接口，并最终构建出产品。一个指挥者类（Director）负责调用建造者来按照特定的顺序构建产品。

以下是一个C++建造者模式的简单示例：

#include 
#include 

// 产品类
class Computer {
public:
    void setCPU(const std::string& cpu) { cpu_ = cpu; }
    void setRAM(const std::string& ram) { ram_ = ram; }
    void setStorage(const std::string& storage) { storage_ = storage; }

    void display() const {
        std::cout << "CPU: " << cpu_ << std::endl;
        std::cout << "RAM: " << ram_ << std::endl;
        std::cout << "Storage: " << storage_ << std::endl;
    }

private:
    std::string cpu_;
    std::string ram_;
    std::string storage_;
};

// 抽象建造者
class ComputerBuilder {
public:
    virtual ~ComputerBuilder() = default;
    virtual void buildCPU() = 0;
    virtual void buildRAM() = 0;
    virtual void buildStorage() = 0;
    virtual Computer* getComputer() = 0;
protected:
    Computer* computer_ = new Computer();
};

// 具体建造者
class GamingComputerBuilder : public ComputerBuilder {
public:
    void buildCPU() override { computer_->setCPU("Intel i9"); }
    void buildRAM() override { computer_->setRAM("32GB"); }
    void buildStorage() override { computer_->setStorage("1TB SSD"); }
    Computer* getComputer() override { return computer_; }
    ~GamingComputerBuilder() override {
        if(computer_){
            delete computer_;
            computer_ = nullptr;
        }
    }
};

class OfficeComputerBuilder : public ComputerBuilder {
public:
    void buildCPU() override { computer_->setCPU("Intel i5"); }
    void buildRAM() override { computer_->setRAM("8GB"); }
    void buildStorage() override { computer_->setStorage("256GB SSD"); }
    Computer* getComputer() override { return computer_; }
    ~OfficeComputerBuilder() override {
        if(computer_){
            delete computer_;
            computer_ = nullptr;
        }
    }
};

// 指挥者
class Director {
public:
    void construct(ComputerBuilder* builder) {
        builder->buildCPU();
        builder->buildRAM();
        builder->buildStorage();
    }
};

int main() {
    Director director;
    GamingComputerBuilder gamingBuilder;
    OfficeComputerBuilder officeBuilder;

    director.construct(&gamingBuilder);
    Computer* gamingComputer = gamingBuilder.getComputer();
    std::cout << "Gaming Computer:" << std::endl;
    gamingComputer->display();
    delete gamingComputer;

    director.construct(&officeBuilder);
    Computer* officeComputer = officeBuilder.getComputer();
    std::cout << "\nOffice Computer:" << std::endl;
    officeComputer->display();
    delete officeComputer;

    return 0;
}

建造者模式与工厂模式的区别是什么？

建造者模式和工厂模式都用于创建对象，但它们的应用场景不同。工厂模式主要用于创建不同类型的对象，而建造者模式则专注于构建一个复杂对象的不同部分。工厂模式通常返回一个已经完整构建好的对象，而建造者模式允许客户端逐步构建对象，并控制构建过程。可以这么理解，工厂模式是“一步到位”，而建造者模式是“分步构建”。

何时应该使用建造者模式？

当对象的构建过程非常复杂，涉及多个步骤，并且需要灵活配置不同组件时，就应该考虑使用建造者模式。 比如，构建一个汽车，需要先构建发动机、车身、轮胎等部件，然后将它们组装起来。不同的汽车可能需要不同的发动机、车身和轮胎。使用建造者模式可以很好地处理这种情况。 另外，如果构造函数的参数过多，使用建造者模式可以避免构造函数过于臃肿，提高代码的可读性和可维护性。

C++中如何避免建造者模式中的内存泄漏？

在C++中使用建造者模式时，需要特别注意内存管理，避免内存泄漏。在上面的例子中，ComputerBuilder 维护了 Computer* computer_ 指针。为了防止内存泄漏，需要在具体建造者的析构函数中释放 computer_ 指向的内存。 此外，还需要注意在 getComputer() 方法返回 computer_ 指针后，客户端代码需要负责释放该指针指向的内存。 如果使用智能指针（例如 std::unique_ptr 或 std::shared_ptr），可以更容易地管理内存，避免手动释放内存的麻烦。例如，可以将 computer_ 定义为 std::unique_ptr，这样当 ComputerBuilder 对象销毁时，Computer 对象也会自动销毁。