# C++设计模式：工厂模式（Factory Pattern）

工厂模式是最重要的创建型设计模式之一，它通过封装对象创建过程，实现了创建与使用的解耦。

工厂模式的三种变体：简单工厂模式、工厂方法模式和抽象工厂模式，以及它们在 C++中的现代实现方式。

------

## 🎯 写在前面

你是否遇到过这样的问题：

- • 🎨 **图形系统**：需要根据用户选择创建不同类型的图形（圆形、矩形、三角形），但不想在业务代码中直接使用`new Circle()`、`new Rectangle()`
- • 🗄️ **数据库连接**：需要根据配置创建不同类型的数据库连接（MySQL、PostgreSQL、SQLite），但希望代码与具体数据库类型解耦
- • 🎮 **游戏开发**：需要根据关卡类型创建不同的敌人（普通敌人、Boss、精英怪），但希望添加新敌人类型时不影响现有代码
- • 📦 **序列化系统**：需要根据文件格式创建不同的序列化器（JSON、XML、Binary），但希望统一接口

传统方法的问题：

```
// ❌ 问题1：业务代码与具体类耦合
void drawShape(const std::string& type) {
    if (type == "circle") {
        Circle* circle = new Circle();  // 直接依赖具体类
        circle->draw();
        delete circle;
    } else if (type == "rectangle") {
        Rectangle* rect = new Rectangle();  // 需要知道所有具体类
        rect->draw();
        delete rect;
    }
    // 添加新类型需要修改这里
}

// ❌ 问题2：创建逻辑分散，难以维护
// 问题3：违反开闭原则（对扩展开放，对修改关闭）
```

**工厂模式**就是为了解决这些问题而生的！它封装了对象创建过程，实现了创建与使用的解耦。

------

## 🧠 工厂模式核心概念

### 什么是工厂模式？

**工厂模式（Factory Pattern）**是一种创建型设计模式，它提供了一种创建对象的最佳方式。工厂模式的核心思想是：**将对象的创建过程封装起来，让使用者不需要知道对象的具体创建细节**。

### 工厂模式的三种变体

工厂模式有三种主要变体，它们解决的问题和复杂度不同：

1. 1. **简单工厂模式（Simple Factory）**：一个工厂类根据参数创建不同类型的对象
2. 2. **工厂方法模式（Factory Method）**：每个产品都有对应的工厂类
3. 3. **抽象工厂模式（Abstract Factory）**：创建一系列相关或依赖的对象族

### 工厂模式的 UML 图

**简单工厂模式**：

```
┌──────────────┐
│   Product    │
│  (接口/基类)  │
└──────┬───────┘
       │
   ┌───┴────┐
   │        │
┌──▼──┐  ┌─▼────┐
│Circle│  │Rect │
└──────┘  └─────┘

┌──────────────┐
│ SimpleFactory│
├──────────────┤
│+create()     │
└──────────────┘
```

**工厂方法模式**：

```
┌──────────────┐      ┌──────────────┐
│   Product    │      │   Factory     │
│  (接口/基类)  │      │  (接口/基类)  │
└──────┬───────┘      └──────┬───────┘
       │                     │
   ┌───┴────┐          ┌─────┴─────┐
   │        │          │           │
┌──▼──┐  ┌─▼────┐  ┌──▼──┐  ┌─────▼──┐
│Circle│  │Rect │  │Circle│  │Rect   │
│      │  │     │  │Factory│  │Factory│
└──────┘  └─────┘  └──────┘  └───────┘
```

------

## 💻 简单工厂模式（Simple Factory）

### 模式介绍

**简单工厂模式**是最基础的工厂模式，它通过一个工厂类根据传入的参数决定创建哪种产品对象。

### 实现代码

```
#include <iostream>
#include <memory>
#include <string>

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

// 具体产品：圆形
class Circle : public Shape {
public:
    void draw() override {
        std::cout << "绘制圆形\n";
    }
};

// 具体产品：矩形
class Rectangle : public Shape {
public:
    void draw() override {
        std::cout << "绘制矩形\n";
    }
};

// 具体产品：三角形
class Triangle : public Shape {
public:
    void draw() override {
        std::cout << "绘制三角形\n";
    }
};

// 简单工厂类
class ShapeFactory {
public:
    // 根据类型创建对象
    static std::unique_ptr<Shape> createShape(const std::string& type) {
        if (type == "circle") {
            return std::make_unique<Circle>();
        } else if (type == "rectangle") {
            return std::make_unique<Rectangle>();
        } else if (type == "triangle") {
            return std::make_unique<Triangle>();
        } else {
            throw std::invalid_argument("未知的图形类型: " + type);
        }
    }
};

// 使用示例
int main() {
    try {
        // 通过工厂创建对象，不需要知道具体类
        auto circle = ShapeFactory::createShape("circle");
        circle->draw();

        auto rect = ShapeFactory::createShape("rectangle");
        rect->draw();

        auto triangle = ShapeFactory::createShape("triangle");
        triangle->draw();
    } catch (const std::exception& e) {
        std::cerr << "错误: " << e.what() << std::endl;
    }

    return 0;
}
```

### 优点

- • ✅ 客户端与具体产品类解耦
- • ✅ 集中管理对象创建逻辑
- • ✅ 代码简单易懂

### 缺点

- • ❌ 违反开闭原则：添加新产品需要修改工厂类
- • ❌ 工厂类职责过重，包含所有创建逻辑
- • ❌ 难以扩展

------

## 🏭 工厂方法模式（Factory Method）

### 模式介绍

**工厂方法模式**为每个产品提供一个对应的工厂类，这样添加新产品时只需要添加新的工厂类，不需要修改现有代码。

### 实现代码

```
#include <iostream>
#include <memory>
#include <string>

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

// 具体产品
class Circle : public Shape {
public:
    void draw() override {
        std::cout << "绘制圆形\n";
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        std::cout << "绘制矩形\n";
    }
};

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

// 具体工厂：圆形工厂
class CircleFactory : public ShapeFactory {
public:
    std::unique_ptr<Shape> createShape() override {
        return std::make_unique<Circle>();
    }
};

// 具体工厂：矩形工厂
class RectangleFactory : public ShapeFactory {
public:
    std::unique_ptr<Shape> createShape() override {
        return std::make_unique<Rectangle>();
    }
};

// 使用示例
void renderShape(ShapeFactory& factory) {
    auto shape = factory.createShape();
    shape->draw();
}

int main() {
    CircleFactory circleFactory;
    RectangleFactory rectFactory;

    renderShape(circleFactory);
    renderShape(rectFactory);

    return 0;
}
```

### 优点

- • ✅ 符合开闭原则：添加新产品只需添加新工厂类
- • ✅ 每个工厂职责单一
- • ✅ 易于扩展和维护

### 缺点

- • ⚠️ 类的数量增加（每个产品对应一个工厂）
- • ⚠️ 增加了系统复杂度

------

## 🏢 抽象工厂模式（Abstract Factory）

### 模式介绍

**抽象工厂模式**提供一个接口，用于创建一系列相关或依赖的对象，而不需要指定它们的具体类。它适用于需要创建产品族（多个相关产品）的场景。

### 实现代码

```
#include <iostream>
#include <memory>
#include <string>

// 抽象产品A：按钮
class Button {
public:
    virtual ~Button() = default;
    virtual void render() = 0;
};

// 抽象产品B：窗口
class Window {
public:
    virtual ~Window() = default;
    virtual void render() = 0;
};

// Windows风格的具体产品
class WindowsButton : public Button {
public:
    void render() override {
        std::cout << "渲染Windows风格按钮\n";
    }
};

class WindowsWindow : public Window {
public:
    void render() override {
        std::cout << "渲染Windows风格窗口\n";
    }
};

// Linux风格的具体产品
class LinuxButton : public Button {
public:
    void render() override {
        std::cout << "渲染Linux风格按钮\n";
    }
};

class LinuxWindow : public Window {
public:
    void render() override {
        std::cout << "渲染Linux风格窗口\n";
    }
};

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

// Windows风格工厂
class WindowsUIFactory : public UIFactory {
public:
    std::unique_ptr<Button> createButton() override {
        return std::make_unique<WindowsButton>();
    }

    std::unique_ptr<Window> createWindow() override {
        return std::make_unique<WindowsWindow>();
    }
};

// Linux风格工厂
class LinuxUIFactory : public UIFactory {
public:
    std::unique_ptr<Button> createButton() override {
        return std::make_unique<LinuxButton>();
    }

    std::unique_ptr<Window> createWindow() override {
        return std::make_unique<LinuxWindow>();
    }
};

// 客户端代码
class Application {
private:
    std::unique_ptr<UIFactory> factory;

public:
    Application(std::unique_ptr<UIFactory> f) : factory(std::move(f)) {}

    void renderUI() {
        auto button = factory->createButton();
        auto window = factory->createWindow();

        button->render();
        window->render();
    }
};

// 使用示例
int main() {
    // 根据平台创建对应的工厂
    #ifdef _WIN32
        auto factory = std::make_unique<WindowsUIFactory>();
    #else
        auto factory = std::make_unique<LinuxUIFactory>();
    #endif

    Application app(std::move(factory));
    app.renderUI();

    return 0;
}
```

### 优点

- • ✅ 保证产品族的兼容性
- • ✅ 符合开闭原则
- • ✅ 符合单一职责原则

### 缺点

- • ⚠️ 扩展产品族困难（需要修改抽象工厂接口）
- • ⚠️ 系统复杂度高

------

## 🚀 现代 C++替代方案

### 使用函数对象和 lambda 表达式

现代 C++提供了更灵活的方式来替代传统工厂模式：

```
#include <iostream>
#include <memory>
#include <string>
#include <map>
#include <functional>

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

class Circle : public Shape {
    double radius;
public:
    Circle(double r) : radius(r) {}
    void draw() override {
        std::cout << "绘制圆形（半径: " << radius << "）\n";
    }
};

class Rectangle : public Shape {
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    void draw() override {
        std::cout << "绘制矩形（" << width << "x" << height << "）\n";
    }
};

// 使用函数对象和lambda的现代工厂
class ModernShapeFactory {
private:
    using Creator = std::function<std::unique_ptr<Shape>()>;
    std::map<std::string, Creator> creators;

public:
    // 注册创建函数
    template<typename T, typename... Args>
    void registerShape(const std::string& type, Args... args) {
        creators[type] = [args...]() {
            return std::make_unique<T>(args...);
        };
    }

    // 使用lambda注册
    void registerShapeLambda(const std::string& type, Creator creator) {
        creators[type] = creator;
    }

    // 创建对象
    std::unique_ptr<Shape> create(const std::string& type) {
        auto it = creators.find(type);
        if (it != creators.end()) {
            return it->second();
        }
        throw std::invalid_argument("未知类型: " + type);
    }
};

// 使用示例
int main() {
    ModernShapeFactory factory;

    // 方式1：使用模板注册
    factory.registerShape<Circle>("circle", 5.0);
    factory.registerShape<Rectangle>("rectangle", 10.0, 8.0);

    // 方式2：使用lambda注册
    factory.registerShapeLambda("big_circle", []() {
        return std::make_unique<Circle>(10.0);
    });

    // 创建对象
    auto circle = factory.create("circle");
    circle->draw();

    auto rect = factory.create("rectangle");
    rect->draw();

    return 0;
}
```

### 优势

- • ✅ 更灵活：可以使用 lambda 表达式
- • ✅ 更简洁：减少类定义
- • ✅ 类型安全：编译期检查
- • ✅ 易于扩展：动态注册创建函数

------

## ⚠️ 工厂模式的优缺点

### ✅ 优点

1. 1. **解耦创建与使用**：客户端不需要知道具体产品类
2. 2. **符合开闭原则**：添加新产品不需要修改现有代码（工厂方法模式）
3. 3. **单一职责**：创建逻辑集中在工厂类
4. 4. **易于测试**：可以轻松替换为测试对象
5. 5. **统一管理**：集中管理对象创建逻辑

### ❌ 缺点

1. 1. **增加复杂度**：引入了额外的类和接口
2. 2. **类的数量增加**：工厂方法模式需要为每个产品创建工厂类
3. 3. **简单工厂违反开闭原则**：添加新产品需要修改工厂类
4. 4. **抽象工厂扩展困难**：添加新产品族需要修改抽象工厂接口

------

## 🎯 何时使用工厂模式

### ✅ 适合使用的场景

1. 1. **需要根据条件创建对象**：根据配置、用户输入等创建不同类型对象
2. 2. **隐藏对象创建细节**：创建过程复杂，需要封装
3. 3. **需要统一管理对象创建**：集中管理创建逻辑和资源
4. 4. **需要支持对象扩展**：未来可能添加新的产品类型
5. 5. **需要创建产品族**：抽象工厂模式适合创建相关对象族

### ❌ 不适合使用的场景

1. 1. **简单对象创建**：如果对象创建很简单，直接使用构造函数即可
2. 2. **固定类型对象**：如果总是创建同一类型对象，不需要工厂
3. 3. **性能敏感场景**：工厂模式有额外的间接调用开销
4. 4. **过度设计**：不要为了使用模式而使用模式

------

## 💡 最佳实践建议

### 1. 优先使用智能指针

```
// ✅ 推荐：使用智能指针管理内存
std::unique_ptr<Shape> createShape() {
    return std::make_unique<Circle>();
}

// ❌ 不推荐：使用原始指针
Shape* createShape() {
    return new Circle();  // 需要手动管理内存
}
```

### 2. 使用工厂方法模式而非简单工厂

```
// ✅ 推荐：工厂方法模式，符合开闭原则
class CircleFactory : public ShapeFactory {
    std::unique_ptr<Shape> create() override {
        return std::make_unique<Circle>();
    }
};

// ⚠️ 谨慎使用：简单工厂，违反开闭原则
class SimpleFactory {
    static std::unique_ptr<Shape> create(const std::string& type) {
        // 需要修改这里来添加新类型
    }
};
```

### 3. 考虑使用现代 C++替代方案

```
// ✅ 现代方式：使用函数对象和lambda
std::map<std::string, std::function<std::unique_ptr<Shape>()>> creators;
creators["circle"] = []() { return std::make_unique<Circle>(); };
```

### 4. 结合 RAII 管理资源

```
// ✅ 结合RAII：自动管理资源生命周期
class ConnectionManager {
    std::unique_ptr<DatabaseConnection> conn;
public:
    ConnectionManager() {
        conn = DatabaseFactory::createConnection();
        conn->connect();
    }
    ~ConnectionManager() {
        conn->disconnect();
    }
};
```

------

## 🔍 常见问题解答

### Q1: 工厂模式和构造函数有什么区别？

**A**: 构造函数是直接创建对象的方式，而工厂模式封装了创建过程。工厂模式的优势在于：

- • 可以返回基类指针，隐藏具体类型
- • 可以包含复杂的创建逻辑
- • 可以统一管理对象创建

### Q2: 什么时候使用简单工厂，什么时候使用工厂方法？

**A**:

- • **简单工厂**：产品类型固定，不会频繁扩展
- • **工厂方法**：需要频繁添加新产品类型

### Q3: 工厂模式会影响性能吗？

**A**: 工厂模式有轻微的间接调用开销，但在大多数场景下可以忽略。如果性能是瓶颈，可以考虑：

- • 使用内联函数
- • 使用模板特化
- • 直接使用构造函数（如果不需要解耦）

### Q4: 如何测试使用工厂模式的代码？

**A**: 可以创建测试工厂，返回模拟对象：

```
class MockShapeFactory : public ShapeFactory {
    std::unique_ptr<Shape> create() override {
        return std::make_unique<MockShape>();
    }
};
```

------

## 📝 总结

### 工厂模式的核心价值

**工厂模式**是创建型设计模式中最重要的一种，它解决了一个核心问题：**如何将对象创建与使用解耦，让代码更加灵活和可维护**。通过封装对象创建过程，工厂模式让客户端代码不需要知道具体产品类，只需要知道产品接口，从而实现了依赖倒置原则。

工厂模式的三种变体：简单工厂模式、工厂方法模式和抽象工厂模式。每种模式都有其适用场景，**工厂方法模式以其良好的扩展性和符合开闭原则的特点，成为最推荐的实现方式**。

### 核心要点回顾

1. 1. **三种变体**：

   - • 简单工厂：适合产品类型固定的场景
   - • 工厂方法：适合需要频繁扩展的场景（推荐）
   - • 抽象工厂：适合创建产品族的场景

2. 2. **现代 C++实践**：

   - • 使用智能指针管理内存
   - • 使用函数对象和 lambda 表达式
   - • 结合 RAII 管理资源生命周期

3. 3. **适用场景**：需要根据条件创建对象、隐藏创建细节、支持扩展

4. 4. **设计原则**：符合开闭原则、单一职责原则、依赖倒置原则

### 现代 C++最佳实践

```
// 推荐：工厂方法模式 + 智能指针 + RAII
class ShapeFactory {
public:
    virtual std::unique_ptr<Shape> create() = 0;
};

class CircleFactory : public ShapeFactory {
public:
    std::unique_ptr<Shape> create() override {
        return std::make_unique<Circle>();
    }
};
```

### 设计哲学


**工厂模式是工具，不是目的**。它解决的是"对象创建解耦"这个具体问题，而不是为了展示设计能力。在实际开发中：

- • ✅ **该用时就用**：需要根据条件创建对象、需要隐藏创建细节的场景
- • ❌ **不该用时不用**：简单对象创建不需要工厂模式
- • 💡 **选择合适变体**：根据实际需求选择简单工厂、工厂方法或抽象工厂
- • **设计原则**：开闭原则、单一职责原则、依赖倒置原则

记住：**好的设计是简单、清晰、易维护的**。工厂模式虽然强大，但也要根据实际需求选择，避免过度设计。
<!-- markdown for nginx, see https://phus.lu -->
<script>
!function(){
	var dom = {
		element: null,
		get: function (o) {
			var obj = Object.create(this)
			obj.element = (typeof o == "object") ? o : document.createElement(o)
			return obj
		},
		add: function (o) {
			var obj = dom.get(o)
			this.element.appendChild(obj.element)
			return obj
		},
		text: function (t) {
			this.element.appendChild(document.createTextNode(t))
			return this
		},
		attr: function (k, v) {
			this.element.setAttribute(k, v)
			return this
		}
	}

	if (!document.head) return
	head = dom.get(document.head)
	head.add('meta').attr('charset', 'utf-8')
	head.add('meta').attr('name', 'viewport').attr('content', 'width=device-width,initial-scale=1')

	if (!document.body) {
		document.write(["<div class=\"container\">",
		"<h3>nginx.conf</h3>",
		"<textarea rows=6 cols=50>",
		"# download markdown.html to /wwwroot",
		"location ~ \\.md$ {",
		"    default_type text/html;",
		"    add_after_body /markdown.html;",
		"}",
		"</textarea>",
		"</div>"].join("\n"))
		return
	}

	var bodytext = document.body.innerHTML
	document.body.innerHTML = ''

	div = dom.get('div').attr('class', 'container')

	div.add('script').attr('src', 'https://cdnjs.cloudflare.com/ajax/libs/marked/0.5.2/marked.min.js').attr('integrity', 'sha256-zFUosuESzULu5P+SZdjRRtBZR8+1u5RZDlbt3Q5KL8U=').attr('crossorigin', 'anonymous')
	div.add('link').attr('rel', 'stylesheet').attr('href', 'https://cdnjs.cloudflare.com/ajax/libs/github-markdown-css/5.1.0/github-markdown-light.min.css').attr('integrity', 'sha256-WQx0Y6LLZeGv3V3NVVge+YIL5MIOt45RPuFdkyNodls=').attr('crossorigin', 'anonymous')

	title = decodeURIComponent(document.location.pathname.replace(/.*\//, '').replace(/\.html$/, ''))
	document.title = '《' + title.replace(/\.md$/, '') + '》'
	tbody = div.add('table').add('tbody')
	tbody.add('tr').add('th').text(title).attr('class', 'octicon-book')
	tbody.add('tr').add('td').add('div').attr('id', 'readme').attr('class', 'markdown-body')

	wait = function (name, callback) {
		var interval = 10; // ms
		window.setTimeout(function() {
			if (window[name]) {
				callback(window[name])
			} else {
				window.setTimeout(arguments.callee, interval)
			}
		}, interval)
	}
	wait('marked', function() {
		document.getElementById("readme").innerHTML = marked.parse(bodytext)
	})

	document.body.appendChild(div.element)
}()
</script>

<style>
body {
	margin: 0;
	font-family: "ubuntu", "Tahoma", "Microsoft YaHei", Arial, Serif;
}
.markdown-body {
	float: left;
	font-family: "ubuntu", "Tahoma", "Microsoft YaHei", Arial, Serif;
}
.container {
	padding-right: 15px;
	padding-left: 15px;
	margin-right: auto;
	margin-left: auto;
}
@media (min-width: 768px) {
	.container {
		max-width: 80%;
	}
}
@media (min-width: 992px) {
	.container {
		max-width: 70%;
	}
}
@media (min-width: 1200px) {
	.container {
		max-width: 60%;
	}
}
table {
	width: 100%;
	max-width: 100%;
	margin-bottom: 20px;
	border: 1px solid #ddd;
	padding: 0;
	border-collapse: collapse;
}
table th {
	font-size: 14px;
}
table tr {
	border: 1px solid #ddd;
	padding: 5px;
}
table th, table td {
	border: 1px solid #ddd;
	font-size: 14px;
	line-height: 20px;
	padding: 3px;
	text-align: left;
}
.octicon-book {
	background-position: center left;
	background-repeat: no-repeat;
	padding-left: 20px;
	background-image: url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' viewBox='0 0 16 16'%3E%3Cpath d='M3,5 L7,5 L7,6 L3,6 L3,5 L3,5 Z M3,8 L7,8 L7,7 L3,7 L3,8 L3,8 Z M3,10 L7,10 L7,9 L3,9 L3,10 L3,10 Z M14,5 L10,5 L10,6 L14,6 L14,5 L14,5 Z M14,7 L10,7 L10,8 L14,8 L14,7 L14,7 Z M14,9 L10,9 L10,10 L14,10 L14,9 L14,9 Z M16,3 L16,12 C16,12.55 15.55,13 15,13 L9.5,13 L8.5,14 L7.5,13 L2,13 C1.45,13 1,12.55 1,12 L1,3 C1,2.45 1.45,2 2,2 L7.5,2 L8.5,3 L9.5,2 L15,2 C15.55,2 16,2.45 16,3 L16,3 Z M8,3.5 L7.5,3 L2,3 L2,12 L8,12 L8,3.5 L8,3.5 Z M15,3 L9.5,3 L9,3.5 L9,12 L15,12 L15,3 L15,3 Z' /%3E%3C/svg%3E");
}
</style>