🖨️ 原型模式-对象复印机

🖨️ 原型模式-对象复印机

字数统计: 632字   |   阅读时长≈ 2分

🎯 导读：本文讲解原型模式——不用 new 从头构建对象，而是像复印机一样直接”克隆”已有对象！适合需要频繁创建相似对象的场景。

🖨️ 原型模式（Prototype Pattern） 是创建型设计模式中最特别、也最符合人类日常直觉的一个。

如果说”工厂模式”是按图纸在流水线上从零开始制造产品 🏭，那么”原型模式”就是 复印机 📠 或 细胞分裂 🧬。它的核心思想极其简单：不要用 new 从头构建一个复杂的对象，而是拿一个已经存在的、配置好的对象作为”原型（Prototype）”，直接把它”克隆（Clone）”一份出来。

📚 1. 客户端（使用者）需要知道哪些类？

在这个模式下，客户端程序员的负担被降到了极低：

✅ 你需要知道的类：

序号 类名 说明
1️⃣ 抽象原型接口
Prototype Interface		 接收克隆对象，调用 clone() 方法
2️⃣ 原型管理器/注册表
Prototype Registry		 存放配置好的原型（如 std::map），按名字获取克隆体 🗂️

❌ 你不需要/绝不应该知道的类：

  • 具体的实现类（Concrete Prototype）： 客户端完全不需要知道正在克隆的是什么子类。只需拿到基类指针，大喊一声：“克隆你自己！” 🎤，多态就会在底层搞定一切

🎮 2. 生动的实战场景：游戏里的”怪物生成器”

假设你在开发一款大型动作角色扮演游戏（ARPG）。游戏里有成百上千种怪物，比如”持盾哥布林”、”火焰飞龙”等。

❌ 痛点（没有原型模式）

每次要在屏幕上刷出一只怪，你都要：

1
2
3
4
5
6
new Goblin();  // 创建对象
// 然后费劲地初始化属性：
// ❤️ 血量 = 100
// 🛡️ 护甲 = 50  
// ⚔️ 武器 = "生锈的铁剑"
// 🚶 AI 巡逻路线 = ...

刷 100 只哥布林，这段初始化代码就要跑 100 遍，极其消耗 CPU 性能和时间 ⏱️💸

✅ 解法（原型模式）

在游戏加载关卡时，我们只精心捏出一只完美的”持盾哥布林”对象，把它作为原型（种子） 🌱 放进注册表里。

当游戏开始，需要刷怪时，我们直接对着这只原型哥布林按下 Ctrl+C 和 Ctrl+V（调用 clone()）。

🚀 瞬间，100 只一模一样、属性全满的哥布林就被复制出来了，性能极高！

📊 UML 类图

classDiagram
    class IMonster {
        <>
        +clone()
    }
    
    class Goblin {
        -hp: int
        -armor: int
        -weapon: string
        +clone()
    }
    
    class Dragon {
        -hp: int
        -fireDamage: int
        +clone()
    }
    
    class MonsterRegistry {
        -prototypes: map
        +register(name, monster)
        +create(name)
    }
    
    IMonster <|-- Goblin : 实现
    IMonster <|-- Dragon : 实现
    MonsterRegistry ..> IMonster : 克隆

💻 3. C++ 现代代码生动演绎

在 C++ 中，原型模式的本质其实就是 多态封装下的拷贝构造函数 🧬。我们来看代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#include <iostream>
#include <string>
#include <unordered_map>
#include <memory>

// ==========================================
// 1. 抽象原型接口：所有能被克隆的怪物都必须遵守
// ==========================================
class IMonster {
public:
    virtual ~IMonster() = default;
    
    // 【核心契约】：必须提供一个返回自身克隆体的纯虚函数
    // 在现代 C++ 中，返回 unique_ptr 极其安全，表达了所有权的转移
    virtual std::unique_ptr<IMonster> clone() const = 0; 
    
    virtual void printInfo() const = 0;
};

// ==========================================
// 2. 具体原型 A：哥布林
// ==========================================
class Goblin : public IMonster {
private:
    int health;
    std::string weapon;

public:
    // 假设这个构造过程极其复杂、耗时
    Goblin(int h, std::string w) : health(h), weapon(w) {
        std::cout << "  [系统加载] 正在从硬盘读取哥布林模型和材质，耗时很久..." << std::endl;
    }

    // 【魔法核心】：实现 clone 方法，直接调用 C++ 自带的拷贝构造函数！
    std::unique_ptr<IMonster> clone() const override {
        // *this 代表当前对象本身，这里触发了 Goblin(const Goblin&) 拷贝构造
        return std::make_unique<Goblin>(*this); 
    }

    void printInfo() const override {
        std::cout << "我是哥布林，血量: " << health << "，武器: " << weapon << std::endl;
    }
};

// ==========================================
// 2. 具体原型 B：飞龙
// ==========================================
class Dragon : public IMonster {
private:
    int fireDamage;

public:
    Dragon(int dmg) : fireDamage(dmg) {
        std::cout << "  [系统加载] 正在生成巨大的飞龙骨骼动画，耗时很久..." << std::endl;
    }

    std::unique_ptr<IMonster> clone() const override {
        return std::make_unique<Dragon>(*this);
    }

    void printInfo() const override {
        std::cout << "我是火焰飞龙！喷火伤害: " << fireDamage << std::endl;
    }
};

// ==========================================
// 3. 原型管理器 (Spawner)：客户端只需要和它打交道
// ==========================================
class MonsterSpawner {
private:
    // 预先存好所有怪物的“原型种子”
    std::unordered_map<std::string, std::unique_ptr<IMonster>> prototypes;

public:
    void registerPrototype(const std::string& name, std::unique_ptr<IMonster> prototype) {
        prototypes[name] = std::move(prototype);
    }

    // 客户端调用的刷怪接口
    std::unique_ptr<IMonster> spawnMonster(const std::string& name) {
        if (prototypes.find(name) != prototypes.end()) {
            // 直接调用原型的 clone() 方法！不走原本耗时的构造函数！
            return prototypes[name]->clone(); 
        }
        return nullptr;
    }
};

// ==========================================
// 业务调用端：体验瞬间刷怪的快感
// ==========================================
int main() {
    MonsterSpawner spawner;

    std::cout << "=== 游戏加载阶段：精心配置原型 ===" << std::endl;
    // 耗时操作在这里发生，且只发生一次
    spawner.registerPrototype("EliteGoblin", std::make_unique<Goblin>(100, "精钢大剑"));
    spawner.registerPrototype("BossDragon", std::make_unique<Dragon>(9999));
    std::cout << "\n=== 游戏正式开始 ===" << std::endl;

    // 客户端只需要传字符串，完全不需要 include Goblin 或 Dragon 的头文件！
    // 也不需要重新去读取硬盘材质，直接内存拷贝，瞬间完成！
    std::unique_ptr<IMonster> m1 = spawner.spawnMonster("EliteGoblin");
    std::unique_ptr<IMonster> m2 = spawner.spawnMonster("EliteGoblin"); // 第二只
    std::unique_ptr<IMonster> boss = spawner.spawnMonster("BossDragon");

    m1->printInfo();
    m2->printInfo();
    boss->printInfo();

    return 0;
}

🔰 初学者版本：不用智能指针的原型模式

💡 给初学者的说明：上面的代码使用了 std::unique_ptr（智能指针），这是现代 C++ 的推荐做法。但如果你还不熟悉智能指针，下面这个版本使用原始指针，更容易理解！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
#include <iostream>
#include <string>
#include <unordered_map>

// ==========================================
// 1. 抽象原型接口
// ==========================================
class IMonster {
public:
    virtual ~IMonster() {}  // 虚析构函数，确保子类正确释放
    
    // 【核心】克隆方法，返回原始指针
    virtual IMonster* clone() const = 0; 
    virtual void printInfo() const = 0;
};

// ==========================================
// 2. 具体原型：哥布林
// ==========================================
class Goblin : public IMonster {
private:
    int health;
    std::string weapon;

public:
    Goblin(int h, std::string w) : health(h), weapon(w) {
        std::cout << "  [加载] 创建哥布林..." << std::endl;
    }

    // 实现克隆：new 一个副本
    IMonster* clone() const override {
        return new Goblin(*this);  // 调用拷贝构造
    }

    void printInfo() const override {
        std::cout << "哥布林：血量=" << health << ", 武器=" << weapon << std::endl;
    }
};

// ==========================================
// 2. 具体原型：飞龙
// ==========================================
class Dragon : public IMonster {
private:
    int fireDamage;

public:
    Dragon(int dmg) : fireDamage(dmg) {
        std::cout << "  [加载] 创建飞龙..." << std::endl;
    }

    IMonster* clone() const override {
        return new Dragon(*this);
    }

    void printInfo() const override {
        std::cout << "飞龙：喷火伤害=" << fireDamage << std::endl;
    }
};

// ==========================================
// 3. 原型管理器
// ==========================================
class MonsterSpawner {
private:
    // 用原始指针存储原型
    std::unordered_map<std::string, IMonster*> prototypes;

public:
    // 注册原型
    void registerPrototype(const std::string& name, IMonster* prototype) {
        prototypes[name] = prototype;
    }

    // 刷怪：克隆一个出来
    IMonster* spawnMonster(const std::string& name) {
        if (prototypes.find(name) != prototypes.end()) {
            return prototypes[name]->clone();  // 调用克隆！
        }
        return nullptr;
    }
    
    // 【重要】清理内存，防止内存泄漏
    ~MonsterSpawner() {
        for (auto& pair : prototypes) {
            delete pair.second;  // 删除每个原型
        }
    }
};

// ==========================================
// 业务调用端
// ==========================================
int main() {
    MonsterSpawner spawner;

    std::cout << "=== 游戏加载 ===" << std::endl;
    // 先创建原型（只创建一次）
    spawner.registerPrototype("Goblin", new Goblin(100, "铁剑"));
    spawner.registerPrototype("Dragon", new Dragon(999));
    std::cout << "\n=== 开始游戏 ===" << std::endl;

    // 克隆怪物！
    IMonster* m1 = spawner.spawnMonster("Goblin");
    IMonster* m2 = spawner.spawnMonster("Goblin");  // 第二只
    IMonster* boss = spawner.spawnMonster("Dragon");

    m1->printInfo();
    m2->printInfo();
    boss->printInfo();

    // 【重要】手动释放克隆出来的怪物
    delete m1;
    delete m2;
    delete boss;
    // spawner 析构时会自动释放原型

    return 0;
}

🔑 两个版本的关键区别

特性 智能指针版本 原始指针版本
内存管理 自动释放 ✅ 手动 delete ⚠️
代码复杂度 稍复杂 更简单
安全性 不会内存泄漏 容易忘记释放 💥
学习曲线 需要懂智能指针 只需懂 new/delete

📌 建议：先理解原始指针版本，再学习智能指针版本。实际项目中强烈推荐使用智能指针！

⚠️ 4. C++ 程序员必须面对的”深渊”：深拷贝与浅拷贝

原型模式在 C++ 中有一个极其致命的坑，也就是面试必考题：深拷贝（Deep Copy）vs. 浅拷贝（Shallow Copy） 🕳️

在上面的代码中，return std::make_unique<Goblin>(*this); 使用了编译器自动生成的默认拷贝构造函数。

✅ 安全的情况

如果你的类里只有普通变量（如 int, double）和标准容器（如 std::string, std::vector），默认拷贝是安全的（深拷贝） 🛡️

🔥 致命危险

如果你的类里面有一个裸指针（比如 int* data），默认拷贝只会复制这个指针的地址（浅拷贝）。

1
2
原型对象 ──► [内存块 A] ◄── 克隆对象
              (共享内存!)

结果就是：原型和克隆体共享了同一块内存！一旦原型被销毁，克隆体里的指针就变成了悬空指针（Dangling Pointer） 💀，程序直接崩溃！

💡 解决办法

如果你的原型类管理了堆内存，你必须手动重写类的拷贝构造函数，在里面为克隆体重新 new 一块独立的内存并复制数据（实现深拷贝）。

⚖️ 5. 优缺点总结

✅ 优点：

优点 说明
🚀 极致的性能 绕过了复杂的构造函数调用逻辑，直接在内存级别进行复制
🔄 动态配置 相比于死板的工厂类，原型模式可以在运行时动态地增加或删除原型种类

❌ 缺点：

缺点 说明
😵 实现复杂 为每一个类配备一个完美的 clone() 方法有时极其困难（尤其是当类内部存在复杂的循环引用、或者持有不可拷贝的资源如网络 Socket、文件句柄时）

🎯 总结

💡 在 C++ 中，理解了拷贝构造函数，就等于理解了原型模式的本质。

你对 C++ 的深拷贝和浅拷贝机制足够熟悉了吗？如果不熟悉，推荐阅读：🌊 浅拷贝 vs 🏗️ 深拷贝 —— 一文看懂！

📚 这篇文章用生动的”复印钥匙”比喻，配合完整代码示例，帮你彻底搞懂深拷贝与浅拷贝的区别！

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

僕は新世界の神となる!