C++工厂模式：从基础到游戏开发实战

1. 工厂模式在C++中的核心价值

工厂模式作为创建型设计模式的代表，在C++领域有着特殊的地位。与Java等自带垃圾回收机制的语言不同，C++要求开发者显式管理对象生命周期，这使得工厂模式在资源控制方面展现出独特优势。想象一下汽车制造厂的生产线——你不需要知道每个零部件的具体制造过程，只需告诉工厂你需要什么型号的零件。这种抽象正是工厂模式的核心思想。

在实际项目中，工厂模式最常见的应用场景包括：

• 对象创建逻辑复杂（需要多步初始化或依赖注入）
• 需要统一管理特定类型对象的创建过程
• 系统需要支持多种相似产品的灵活切换
• 希望隐藏具体实现类的实例化过程

特别是在游戏开发领域，工厂模式几乎无处不在。比如角色生成系统，当玩家点击"创建战士"按钮时，底层代码并不需要知道战士盔甲的锻造细节、武器的装配流程，这些都被封装在对应的工厂类中。这种设计使得新增角色类型时，只需扩展新的工厂类而无需修改现有创建逻辑。

2. 基础工厂模式实现解析

2.1 简单工厂的典型实现

让我们从一个最基础的武器工厂示例开始：

cpp复制class Weapon {
public:
    virtual void attack() = 0;
    virtual ~Weapon() = default;
};

class Sword : public Weapon {
public:
    void attack() override { cout << "Swing sword!" << endl; }
};

class Bow : public Weapon {
public:
    void attack() override { cout << "Shoot arrow!" << endl; }
};

class WeaponFactory {
public:
    static Weapon* createWeapon(const string& type) {
        if (type == "sword") return new Sword();
        if (type == "bow") return new Bow();
        return nullptr;
    }
};

这个简单实现已经展现出工厂模式的核心优势：将对象创建逻辑集中管理。当需要新增武器类型时，只需添加新的派生类和修改工厂方法，客户端代码无需变动。

注意：这里返回的是原始指针，实际项目中应考虑使用智能指针。但在讲解基础模式时，我们暂时保持简单实现。

2.2 工厂方法的进阶实现

当产品种类增多时，简单工厂会变得臃肿。这时可以采用工厂方法模式，将创建逻辑分散到各个具体工厂中：

cpp复制class WeaponFactory {
public:
    virtual Weapon* createWeapon() = 0;
    virtual ~WeaponFactory() = default;
};

class SwordFactory : public WeaponFactory {
public:
    Weapon* createWeapon() override { return new Sword(); }
};

class BowFactory : public WeaponFactory {
public:
    Weapon* createWeapon() override { return new Bow(); }
};

这种实现方式符合开闭原则——新增产品类型时只需添加新的工厂类，无需修改已有代码。在游戏引擎开发中，这种模式常用于不同平台的特效系统创建，每个平台实现自己的工厂即可。

3. 抽象工厂模式实战

3.1 跨平台UI组件案例

当需要创建相关产品族时，抽象工厂展现出强大威力。考虑一个跨平台UI系统：

cpp复制// 抽象产品接口
class Button {
public:
    virtual void render() = 0;
    virtual ~Button() = default;
};

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

// 具体Windows产品
class WinButton : public Button {
public:
    void render() override { cout << "Windows style button" << endl; }
};

class WinCheckbox : public Checkbox {
public:
    void check() override { cout << "Windows checkbox checked" << endl; }
};

// 抽象工厂接口
class GUIFactory {
public:
    virtual Button* createButton() = 0;
    virtual Checkbox* createCheckbox() = 0;
    virtual ~GUIFactory() = default;
};

// 具体Windows工厂
class WinFactory : public GUIFactory {
public:
    Button* createButton() override { return new WinButton(); }
    Checkbox* createCheckbox() override { return new WinCheckbox(); }
};

这种模式在Qt等框架中广泛应用。当需要支持新的操作系统时，只需实现对应的工厂和产品类，现有业务逻辑完全不受影响。

3.2 内存管理优化技巧

在C++实现中，内存管理是需要特别注意的环节。推荐使用unique_ptr来管理工厂创建的对象：

cpp复制class WeaponFactory {
public:
    virtual unique_ptr<Weapon> createWeapon() = 0;
    virtual ~WeaponFactory() = default;
};

class SwordFactory : public WeaponFactory {
public:
    unique_ptr<Weapon> createWeapon() override {
        return make_unique<Sword>();
    }
};

这种实现方式既保持了工厂模式的灵活性，又避免了内存泄漏风险。在性能敏感的场景中，可以考虑使用对象池技术预创建对象，工厂方法改为从对象池中获取实例。

4. 现代C++中的工厂模式变体

4.1 模板工厂实现

C++模板为工厂模式带来了新的可能性。下面是一个类型安全的模板工厂实现：

cpp复制template <typename T>
class GenericFactory {
public:
    template <typename... Args>
    static auto create(Args&&... args) {
        return make_unique<T>(forward<Args>(args)...);
    }
};

// 使用示例
auto sword = GenericFactory<Sword>::create();

这种实现完全消除了运行时类型检查的开销，适合在性能关键路径使用。在游戏引擎开发中，这种模式常用于粒子系统等需要高频创建对象的场景。

4.2 lambda工厂模式

C++11引入的lambda表达式可以创建更灵活的工厂：

cpp复制class WeaponFactory {
public:
    using Creator = function<unique_ptr<Weapon>()>;
    
    void registerCreator(const string& type, Creator creator) {
        creators_[type] = move(creator);
    }
    
    unique_ptr<Weapon> create(const string& type) {
        if (auto it = creators_.find(type); it != creators_.end())
            return it->second();
        return nullptr;
    }

private:
    unordered_map<string, Creator> creators_;
};

// 注册创建器
factory.registerCreator("magic_staff", [] {
    return make_unique<MagicStaff>();
});

这种动态注册机制在插件系统开发中特别有用，允许运行时添加新的产品类型而无需重新编译工厂类。

5. 工厂模式在游戏开发中的典型应用

5.1 游戏实体创建系统

现代游戏引擎通常采用基于组件的架构，工厂模式在这里大显身手：

cpp复制class GameObjectFactory {
public:
    GameObject createCharacter(const string& type) {
        GameObject obj;
        
        if (type == "warrior") {
            obj.addComponent<WarriorComponent>();
            obj.addComponent<HealthComponent>(100);
            obj.addComponent<EquipmentComponent>();
        }
        else if (type == "mage") {
            obj.addComponent<MageComponent>();
            obj.addComponent<HealthComponent>(60);
            obj.addComponent<ManaComponent>(200);
        }
        
        return obj;
    }
};

实际项目中，这种配置通常会从数据文件加载，实现数据驱动的对象创建。Unreal Engine的UFactory系统和Unity的Prefab系统本质上都是高级工厂模式的实现。

5.2 特效系统工厂

不同平台的特效实现差异很大，但通过抽象工厂可以保持统一的接口：

cpp复制class ParticleSystemFactory {
public:
    virtual unique_ptr<ParticleEmitter> createEmitter() = 0;
    virtual unique_ptr<ParticleRenderer> createRenderer() = 0;
};

class DX12ParticleFactory : public ParticleSystemFactory {
    unique_ptr<ParticleEmitter> createEmitter() override {
        return make_unique<DX12ParticleEmitter>();
    }
    
    unique_ptr<ParticleRenderer> createRenderer() override {
        return make_unique<DX12ParticleRenderer>();
    }
};

这种设计使得在PC上使用DirectX 12，在移动端使用Vulkan时，只需切换工厂实例即可，所有特效相关代码无需修改。

6. 性能优化与常见陷阱

6.1 对象池与工厂的结合

对于频繁创建销毁的对象，可以考虑工厂与对象池的结合：

cpp复制template <typename T>
class PooledFactory {
public:
    template <typename... Args>
    unique_ptr<T, PoolDeleter> create(Args&&... args) {
        if (pool_.empty()) {
            return {new T(forward<Args>(args)...), PoolDeleter(this)};
        }
        
        auto obj = move(pool_.back());
        pool_.pop_back();
        resetObject(obj.get(), forward<Args>(args)...);
        return {obj.release(), PoolDeleter(this)};
    }

private:
    vector<unique_ptr<T>> pool_;
    
    struct PoolDeleter {
        void operator()(T* ptr) {
            parent->pool_.emplace_back(ptr);
        }
        PooledFactory* parent;
    };
};

这种技术在游戏开发中常用于子弹、粒子等需要高频创建的对象，可以显著减少内存分配开销。

6.2 循环依赖问题

工厂模式的一个常见陷阱是循环依赖。例如：

cpp复制class Vehicle {
public:
    virtual void assemble(Engine* engine) = 0;
};

class Engine {
public:
    Engine(Vehicle* vehicle) : vehicle_(vehicle) {}
private:
    Vehicle* vehicle_;
};

class CarFactory {
public:
    Vehicle* createCar() {
        Car* car = new Car();
        Engine* engine = new Engine(car);  // 需要car指针
        car->assemble(engine);  // 需要engine指针
        return car;
    }
};

这种情况可以通过引入建造者模式或分阶段初始化来解决。在实际项目中，要特别注意工厂创建对象时的初始化顺序问题。

7. 测试策略与Mock工厂

7.1 单元测试中的工厂应用

工厂模式可以极大简化单元测试。考虑以下测试场景：

cpp复制class MockWeapon : public Weapon {
public:
    MOCK_METHOD(void, attack, (), (override));
};

TEST(CombatTest, AttackSequence) {
    auto factory = [] { return make_unique<MockWeapon>(); };
    auto weapon = factory();
    
    EXPECT_CALL(*weapon, attack()).Times(3);
    
    performAttackSequence(weapon.get());
}

这种基于工厂的测试方式在Google Test等框架中广泛应用，可以灵活控制测试对象的创建过程。

7.2 性能测试工厂

在性能测试中，可以创建特殊的测量工厂：

cpp复制class InstrumentedFactory : public WeaponFactory {
public:
    unique_ptr<Weapon> createWeapon() override {
        auto start = chrono::high_resolution_clock::now();
        auto weapon = realFactory_->createWeapon();
        auto end = chrono::high_resolution_clock::now();
        
        stats_.emplace_back(typeid(*weapon).name(), end - start);
        return weapon;
    }

private:
    unique_ptr<WeaponFactory> realFactory_;
    vector<pair<string, chrono::nanoseconds>> stats_;
};

这种装饰器模式的应用可以在不影响生产代码的情况下收集性能数据，特别适合大型项目的性能优化工作。

8. 设计模式组合实践

8.1 工厂与策略模式结合

在实际项目中，工厂模式常与其他模式组合使用。例如策略模式：

cpp复制class PaymentStrategy {
public:
    virtual void pay(int amount) = 0;
};

class PaymentFactory {
public:
    unique_ptr<PaymentStrategy> create(const string& type) {
        if (type == "credit") return make_unique<CreditCardPayment>();
        if (type == "paypal") return make_unique<PayPalPayment>();
        return nullptr;
    }
};

class OrderProcessor {
public:
    void processOrder(Order& order, PaymentFactory& factory) {
        auto payment = factory.create(order.paymentType);
        payment->pay(order.total);
        // 处理订单逻辑
    }
};

这种组合在电商系统开发中非常常见，既保持了支付策略的灵活性，又通过工厂封装了创建细节。

8.2 工厂与建造者模式结合

对于复杂对象的创建，可以结合建造者模式：

cpp复制class CharacterBuilder {
public:
    virtual void buildAppearance() = 0;
    virtual void buildAttributes() = 0;
    virtual Character getResult() = 0;
};

class CharacterDirector {
public:
    Character createCharacter(CharacterBuilder& builder) {
        builder.buildAppearance();
        builder.buildAttributes();
        return builder.getResult();
    }
};

class WarriorBuilder : public CharacterBuilder {
    // 具体实现
};

class CharacterFactory {
public:
    Character create(const string& type) {
        if (type == "warrior") {
            WarriorBuilder builder;
            CharacterDirector director;
            return director.createCharacter(builder);
        }
        // 其他类型
    }
};

这种组合在MMORPG的角色创建系统中非常有用，可以精细控制复杂对象的构建过程。