工厂模式与建造者模式

1. 两种模式概念的区别

(1).工厂模式 创建单一类型的对象（隐藏具体类，直接返回成品）。
(2).建造者模式 分步骤构建复杂对象（控制组装过程，支持可选组件和灵活配置）。

2. 工厂模式代码举例

#pragma once
#include <iostream>
#include <memory>

// 产品接口
class Shape
{
public:
    virtual void draw() = 0;
    virtual ~Shape() = default;
};

// 具体产品类
class Circle : public Shape
{
public:
    void draw() override
    {
        std::cout << "Drawing a Circle" << std::endl;
    }
};

class Rectangle : public Shape
{
public:
    void draw() override
    {
        std::cout << "Drawing a Rectangle" << std::endl;
    }
};

class ShapeFactory
{
public:
    enum ShapeType
    {
        CIRCLE,
        RECTANGLE
    };

    static std::unique_ptr<Shape> createShape(ShapeType type)
    {
        switch (type)
        {
        case CIRCLE:
            return std::make_unique<Circle>();
        case RECTANGLE:
            return std::make_unique<Rectangle>();
        default:
            return nullptr;
        }
    }
};

void testfactory()
{
    auto circle = ShapeFactory::createShape(ShapeFactory::CIRCLE);
    circle->draw();
    auto rectangle = ShapeFactory::createShape(ShapeFactory::RECTANGLE);
    rectangle->draw();
}

3. 建造者模式代码举例

#pragma once
#include <iostream>
#include <string>
#include <memory>

// 1. 最终要构造的复杂对象: 一台电脑
class Computer
{
public:
    void setCPU(const std::string &cpu) { m_cpu = cpu; }
    void setRAM(const std::string &ram) { m_ram = ram; }
    void setStorage(const std::string &storage) { m_storage = storage; }
    void setGPU(const std::string &gpu) { m_gpu = gpu; }

    void showSpecs() const
    {
        std::cout << "Computer Specs:\n"
                  << "- CPU: " << m_cpu << "\n"
                  << "- RAM: " << m_ram << "\n"
                  << "- Storage: " << m_storage << "\n"
                  << "- GPU: " << (m_gpu.empty() ? "None" : m_gpu) << "\n";
    }

private:
    std::string m_cpu;
    std::string m_ram;
    std::string m_storage;
    std::string m_gpu;
};

// 2.抽象建造者，定义组装电脑的步骤
class ComputerBuilder
{
public:
    virtual ~ComputerBuilder() = default;
    virtual void buildCPU() = 0;
    virtual void buildRAM() = 0;
    virtual void buildStorage() = 0;
    virtual void buildGPU() = 0; // 可选步骤
    virtual Computer getComputer() = 0;
};

// 3.具体建造者
//(1) 游戏电脑建造者 (高端配置)
class GamingComputerBuilder : public ComputerBuilder
{
public:
    GamingComputerBuilder() { m_computer = Computer(); }

    void buildCPU() override { m_computer.setCPU("Intel i9-13900K"); }
    void buildRAM() override { m_computer.setRAM("32GB DDR5"); }
    void buildStorage() override { m_computer.setStorage("2TB NVMe SSD"); }
    void buildGPU() override { m_computer.setGPU("NVIDIA RTX 4090"); }

    Computer getComputer() override { return m_computer; }

private:
    Computer m_computer;
};

// (2) 办公电脑建造者（基础配置）
class OfficeComputerBuilder : public ComputerBuilder
{
public:
    OfficeComputerBuilder() { m_computer = Computer(); }

    void buildCPU() override { m_computer.setCPU("Intel i5-12400"); }
    void buildRAM() override { m_computer.setRAM("16GB DDR4"); }
    void buildStorage() override { m_computer.setStorage("512GB SSD"); }
    void buildGPU() override { /* 办公电脑不需要独立显卡 */ }

    Computer getComputer() override { return m_computer; }

private:
    Computer m_computer;
};

// 4.指导者：控制建造流程（可以自定义步骤顺序）
class ComputerAssembler
{
public:
    void buildComputer(ComputerBuilder *builder)
    {
        builder->buildCPU();
        builder->buildRAM();
        builder->buildStorage();
        builder->buildGPU(); // 可选步骤
    }
};

void testbuilder()
{
    ComputerAssembler assembler;

    // 组装一台游戏电脑
    GamingComputerBuilder gamingBuilder;
    assembler.buildComputer(&gamingBuilder);
    Computer gamingPC = gamingBuilder.getComputer();
    gamingPC.showSpecs();

    // 组装一台办公电脑
    OfficeComputerBuilder officeBuilder;
    assembler.buildComputer(&officeBuilder);
    Computer officePC = officeBuilder.getComputer();
    officePC.showSpecs();

    return;
};

4.总结

总结： 一句话区分
工厂模式： “给我一个对象，我不关心你怎么造的。”
建造者模式： “我要这样一步步造对象，最后给我结果。”

选择依据：
需要快速获取简单对象 → 工厂模式。
需要精细控制复杂对象的构建 → 建造者模式。