【C/C++】设计模式之工厂模式：从简单到抽象的演进

设计模式之工厂模式：从简单到抽象的演进

1 “工厂”模式分类

“工厂”模式在设计模式中是一个重要的创建型模式，它可以分为以下几类：

1.1 简单工厂（Simple Factory）

【不是 GOF 23 种经典设计模式之一】

• 特点：由一个工厂类根据传入参数决定创建哪种产品类。
• 缺点：违反开闭原则，每新增一个产品就要修改工厂逻辑。
• 适用场景：产品种类不多，变化不频繁。

#include 
#include 
#include 

class Shape {
public:
    virtual void draw() = 0;
    virtual ~Shape() = default;
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing Circle\n";
    }
};

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

class ShapeFactory {
public:
    static std::unique_ptr<Shape> createShape(const std::string& type) {
        if (type == "circle") return std::make_unique<Circle>();
        if (type == "rectangle") return std::make_unique<Rectangle>();
        return nullptr;
    }
};

// 使用
int main() {
    auto shape = ShapeFactory::createShape("circle");
    if (shape) shape->draw();
    return 0;
}

---

1.2 工厂方法（Factory Method）

【GOF 经典设计模式之一】

• 特点：定义一个用于创建对象的接口，让子类决定实例化哪一个类。

• 优点：符合开闭原则。

• 适用场景：产品种类较多，或需要定制化创建流程。

• 与简单工厂区别：每个产品对应一个具体工厂类；新增产品只需新增一个工厂类，符合开闭原则。

#include 
#include 

class Shape {
public:
    virtual void draw() = 0;
    virtual ~Shape() = default;
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing Circle\n";
    }
};

// 工厂基类
class ShapeFactory {
public:
    virtual std::unique_ptr<Shape> createShape() = 0;
    virtual ~ShapeFactory() = default;
};

// 工厂子类
class CircleFactory : public ShapeFactory {
public:
    std::unique_ptr<Shape> createShape() override {
        return std::make_unique<Circle>();
    }
};

// 使用
int main() {
    std::unique_ptr<ShapeFactory> factory = std::make_unique<CircleFactory>();
    auto shape = factory->createShape();
    shape->draw();
    return 0;
}

---

1.3 抽象工厂（Abstract Factory）

【GOF 经典设计模式之一】

• 特点：提供一个接口，用于创建多个相关或依赖的对象族。

• 优点：适合产品之间存在关系（如 UI 控件风格：Windows vs Mac）。

• 适用场景：需要创建多个相互关联的产品族，而不需要指定具体类。

• 与前面工厂模式的区别：创建一组相关产品（产品族）；适用于系统需要生产多个产品系列（如不同平台的 UI）。

#include 
#include 

// 抽象产品
class Button {
public:
    virtual void paint() = 0;
    virtual ~Button() = default;
};

class Checkbox {
public:
    virtual void toggle() = 0;
    virtual ~Checkbox() = default;
};

// Windows 产品
class WindowsButton : public Button {
public:
    void paint() override {
        std::cout << "Windows Button\n";
    }
};

class WindowsCheckbox : public Checkbox {
public:
    void toggle() override {
        std::cout << "Windows Checkbox toggled\n";
    }
};

// Mac 产品
class MacButton : public Button {
public:
    void paint() override {
        std::cout << "Mac Button\n";
    }
};

class MacCheckbox : public Checkbox {
public:
    void toggle() override {
        std::cout << "Mac Checkbox toggled\n";
    }
};

// 抽象工厂
class GUIFactory {
public:
    virtual std::unique_ptr<Button> createButton() = 0;
    virtual std::unique_ptr<Checkbox> createCheckbox() = 0;
    virtual ~GUIFactory() = default;
};

// Windows 工厂
class WindowsFactory : public GUIFactory {
public:
    std::unique_ptr<Button> createButton() override {
        return std::make_unique<WindowsButton>();
    }

    std::unique_ptr<Checkbox> createCheckbox() override {
        return std::make_unique<WindowsCheckbox>();
    }
};

// Mac 工厂
class MacFactory : public GUIFactory {
public:
    std::unique_ptr<Button> createButton() override {
        return std::make_unique<MacButton>();
    }

    std::unique_ptr<Checkbox> createCheckbox() override {
        return std::make_unique<MacCheckbox>();
    }
};

// 使用
int main() {
    std::unique_ptr<GUIFactory> factory = std::make_unique<WindowsFactory>();

    auto button = factory->createButton();
    auto checkbox = factory->createCheckbox();

    button->paint();
    checkbox->toggle();

    return 0;
}

---

2 分析

简单工厂模式通过一个固定工厂类根据参数决定创建哪个单一产品对象，它是一种集中式、非继承的设计；

工厂方法模式将创建逻辑交由各自的工厂子类实现，满足开闭原则，适用于单一产品类的灵活扩展；

抽象工厂模式在工厂方法的基础上增加了“产品族（多个相关产品）”的抽象接口，统一生产一组彼此关联的产品，实现更高级别的解耦和扩展。

设计模式	核心思想	是否使用继承
简单工厂	使用一个类集中管理对象创建（if-else）	否
工厂方法	为每个产品定义一个创建类（工厂子类）	是
抽象工厂	为一组产品族提供统一创建接口	是

辅助记忆方法：
简单工厂 = 统一超市收银台：你买啥，告诉我商品代码，我帮你找。
工厂方法 = 各品牌有独立专卖店：你要耐克去耐克店，要阿迪去阿迪店。
抽象工厂 = 同一品牌店提供一整套商品组合（鞋、衣服、帽子）：Nike-全套，Adidas-全套。

---

3 总结对比

模式	是否符合开闭原则	是否属于 GOF 设计模式	创建方式	应用场景
简单工厂	不符合	否	一个工厂方法创建所有产品	产品种类较少，创建逻辑简单，变化不频繁
工厂方法	符合	是	一个产品一个工厂	产品种类较多，需扩展性
抽象工厂	符合	是	一组产品族使用一个工厂接口	不同平台或风格的产品成组创建，创建“产品族”，产品之间有关联性