设计模式 | 原型模式

原型模式通过克隆机制实现对象高效创建，是性能敏感场景的利器。本文结合C++示例详解实现原理、深拷贝陷阱、应用场景，并与工厂模式对比分析。

为何需要原型模式？

当遇到以下场景时，传统构造方法面临挑战：

1. 创建成本高：对象初始化需访问数据库/读取文件（如游戏角色加载资源）

2. 状态复杂：对象包含多层嵌套结构（如DOM树节点）

3. 动态配置：运行时需基于现有对象微调生成新对象

原型模式优势：

• 避开重复初始化开销

• 免去工厂类继承体系

• 支持运行时动态对象生成

原型模式核心概念

用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象

C++ 深度实现（解决浅拷贝陷阱）

基础实现

#include <iostream>
#include <memory>

// 抽象原型
class IPrototype {
public:
    virtual ~IPrototype() = default;
    virtual std::unique_ptr<IPrototype> clone() const = 0;
    virtual void render() const = 0;
};

// 具体原型：游戏敌人角色
class Enemy : public IPrototype {
public:
    Enemy(int hp, int dmg, std::string model) 
        : hp_(hp), damage_(dmg), model_(std::move(model)) 
    {
        // 模拟高成本资源加载
        std::cout << "Loading 3D model: " << model_ << "...\n";
    }

    std::unique_ptr<IPrototype> clone() const override {
        return std::make_unique<Enemy>(*this); // 调用拷贝构造
    }

    void render() const override {
        std::cout << "Enemy[HP:" << hp_ 
                  << " DMG:" << damage_
                  << " MODEL:" << model_ << "]\n";
    }

    void setHP(int hp) { hp_ = hp; }

private:
    int hp_;
    int damage_;
    std::string model_;  // 字符串自动深拷贝
};

含指针成员的深拷贝解决方案

class Weapon {
public:
    Weapon(std::string name, int dmg) : name_(std::move(name)), base_dmg_(dmg) {}
    std::unique_ptr<Weapon> clone() const {
        return std::make_unique<Weapon>(*this);
    }
private:
    std::string name_;
    int base_dmg_;
};

class ArmedEnemy : public IPrototype {
public:
    ArmedEnemy(int hp, std::unique_ptr<Weapon> weapon)
        : hp_(hp), weapon_(std::move(weapon)) {}

    // 深拷贝关键：递归克隆指针成员
    std::unique_ptr<IPrototype> clone() const override {
        auto new_weapon = weapon_->clone();
        return std::make_unique<ArmedEnemy>(hp_, std::move(new_weapon));
    }

private:
    int hp_;
    std::unique_ptr<Weapon> weapon_;  // 需特殊处理
};

具体使用示例

int main() {
    // 1. 初始化原型对象（高成本操作）
    auto skeleton_prototype = std::make_unique<Enemy>(100, 15, "skeleton.fbx");
    
    // 2. 批量生成敌人（零初始化成本）
    std::vector<std::unique_ptr<IPrototype>> enemies;
    for (int i = 0; i < 5; ++i) {
        auto new_enemy = skeleton_prototype->clone();
        dynamic_cast<Enemy*>(new_enemy.get())->setHP(80); // 差异化调整
        enemies.push_back(std::move(new_enemy));
    }

    // 3. 验证独立状态
    enemies[0]->render(); // HP:80
    skeleton_prototype->render(); // HP:100 (原型不受影响)
    
    return 0;
}

应用场景与典型案例

优缺点对比分析

 优势：

• 性能提升：规避昂贵初始化操作

• 动态性：运行时增减产品对象

• 简化结构：无需工厂类继承体系

陷阱：

• 深拷贝问题：指针成员需递归克隆

• 循环引用：复杂对象图可能导致拷贝死循环

• 初始化限制：克隆无法执行构造函数逻辑

与其他创建型模式对比

选择原则：当系统需要动态生成对象或避免初始化开销时，优先选择原型模式

最佳实践

1. 实现Clone接口：明确标识可克隆对象

2. 深拷贝防御：对指针/引用类型实现递归克隆

3. 原型管理器：使用注册表管理常用原型

   class PrototypeRegistry {
       std::unordered_map<std::string, std::unique_ptr<IPrototype>> prototypes_;
   public:
       void add(const std::string& key, std::unique_ptr<IPrototype> proto) {
           prototypes_[key] = std::move(proto);
       }
       std::unique_ptr<IPrototype> clone(const std::string& key) {
           return prototypes_.at(key)->clone();
       }
   };

“原型模式不是从零开始构造对象，而是通过克隆现有实例来高效创建新对象，它是面向对象设计中复制与复用对象实例的巧妙捷径。“ - 设计模式实践者