工厂模式通过解耦对象创建与使用，提升代码扩展性和维护性；其通用方法为工厂方法模式，定义抽象工厂和产品，由子类决定具体创建类型，适用于需动态创建不同对象的场景。
C++中工厂模式创建对象的通用方法，本质上是为了将对象的创建过程与使用过程解耦。它提供了一种灵活、可扩展的机制，让你可以在运行时决定创建哪种类型的对象，而无需在客户端代码中硬编码具体的类名。这就像你走进一家定制店，你告诉店员你想要什么（比如“一辆跑车”），店员根据你的需求从幕后为你打造并交付，你不需要知道跑车是如何具体制造出来的。
谈到C++工厂模式创建对象的通用方法，我个人倾向于将其视为一个设计理念，而非单一的固定模式。最常见的实现方式，也是我认为最“通用”的，通常是工厂方法模式（Factory Method Pattern）。它通过定义一个用于创建对象的接口，让子类决定实例化哪一个类。这听起来有点抽象，但核心思想是：让创建者（Factory）的子类来决定创建具体哪种产品（Product）。
设想一下，你有一个游戏，里面有各种各样的敌人（比如兽人、精灵、恶魔）。如果每次需要一个新敌人，你都直接
new Orc()
new Elf()
工厂方法模式的通用实现步骤大致是这样的：
立即学习“C++免费学习笔记（深入）”；
定义抽象产品（Abstract Product）接口或基类： 这是所有具体产品（例如
Orc
Elf
// Abstract Product
class Enemy {
public:
virtual ~Enemy() = default;
virtual void attack() const = 0;
virtual void takeDamage(int amount) = 0;
// ... 其他通用行为
};定义具体产品（Concrete Products）： 实现抽象产品接口的具体类。
// Concrete Products
class Orc : public Enemy {
public:
void attack() const override {
std::cout << "Orc charges and attacks with an axe!" << std::endl;
}
void takeDamage(int amount) override {
std::cout << "Orc takes " << amount << " damage." << std::endl;
}
};
class Elf : public Enemy {
public:
void attack() const override {
std::cout << "Elf fires an arrow from afar!" << std::endl;
}
void takeDamage(int amount) override {
std::cout << "Elf takes " << amount << " damage." << std::endl;
}
};定义抽象创建者（Abstract Creator）接口或基类： 这就是工厂的抽象层。它声明了一个工厂方法，用于返回一个产品对象。这个方法通常是虚函数。
// Abstract Creator (Factory)
class EnemyFactory {
public:
virtual ~EnemyFactory() = default;
// 工厂方法，返回一个指向抽象产品的指针
virtual std::unique_ptr<Enemy> createEnemy() const = 0;
};定义具体创建者（Concrete Creators）： 实现抽象创建者接口的具体工厂类。每个具体工厂负责创建一种或一类具体产品。
// Concrete Creators (Specific Factories)
class OrcFactory : public EnemyFactory {
public:
std::unique_ptr<Enemy> createEnemy() const override {
return std::make_unique<Orc>(); // 创建具体的Orc对象
}
};
class ElfFactory : public EnemyFactory {
public:
std::unique_ptr<Enemy> createEnemy() const override {
return std::make_unique<Elf>(); // 创建具体的Elf对象
}
};客户端使用： 客户端代码通过抽象工厂接口与产品交互，不需要知道具体的工厂和产品类。
// Client Code
void gameLoop(const EnemyFactory& factory) {
std::unique_ptr<Enemy> enemy = factory.createEnemy();
enemy->attack();
enemy->takeDamage(10);
// ... 游戏逻辑
}
// main 函数中
// OrcFactory orcFactory;
// gameLoop(orcFactory); // 创建一个Orc敌人
// ElfFactory elfFactory;
// gameLoop(elfFactory); // 创建一个Elf敌人这种结构的最大好处在于，当你需要添加一个新的敌人类型（比如
Goblin
Goblin
GoblinFactory
gameLoop
if-else if
C++工厂模式的核心优势，在我看来，主要体现在解耦、扩展性和维护性上。它将“谁来创建对象”的责任从客户端代码中剥离出来，交给专门的工厂来处理。这种分离，对于大型、复杂的系统来说，简直是救命稻草。
首先是解耦。客户端代码不再直接依赖于具体的产品类。它只知道抽象产品接口和抽象工厂接口。这意味着，即使具体产品的实现细节发生变化，或者需要替换为另一个具体产品，客户端代码也无需改动。这就像你点外卖，你只需要知道你点的是“披萨”，而不需要关心是哪家店的披萨，也不需要知道披萨是怎么烤出来的。这种松散耦合让系统更加健壮。
其次是扩展性。当系统需要引入新的产品类型时，你只需要创建新的具体产品类和对应的具体工厂类，而无需修改现有的工厂或客户端代码。这完美地遵循了面向对象设计的开闭原则（Open/Closed Principle）——对扩展开放，对修改关闭。比如，在我的游戏例子中，如果我想加入一个“巨魔”敌人，我只需要写
Troll
TrollFactory
Orc
Elf
gameLoop
再者是维护性。集中式的对象创建逻辑使得代码更容易理解和管理。如果某个对象的创建过程很复杂，或者涉及到资源管理（比如对象池、单例），将其封装在工厂中，可以避免在多处重复这些复杂逻辑。当创建逻辑需要调整时，你只需要修改工厂类，而不是在整个代码库中搜索并修改所有
new
那么，它适用于哪些场景呢？
总的来说，只要你的系统中有“创建”和“使用”的分离需求，并且希望这个分离能够带来更好的灵活性和可维护性，工厂模式就值得考虑。我个人在处理多平台兼容性（比如不同操作系统下的GUI组件）、配置加载器、或者复杂的业务对象实例化时，都倾向于使用工厂模式。
构建一个灵活的工厂方法模式，不仅仅是实现上面提到的那些类，更重要的是要考虑如何让它在实际项目中真正“活”起来，适应变化。这里我分享一些我个人在实践中觉得很有效的点，以及一些值得深思的细节。
首先，使用智能指针管理产品生命周期是现代C++的标配。在上面的示例中，我用了
std::unique_ptr
std::shared_ptr
delete
// 示例：工厂方法返回智能指针
class EnemyFactory {
public:
virtual ~EnemyFactory() = default;
virtual std::unique_ptr<Enemy> createEnemy() const = 0;
};其次，注册机制（Registration Mechanism）可以进一步提升工厂的灵活性，尤其是当你面对的是一个简单工厂（Simple Factory），或者希望在运行时动态添加产品类型而无需修改工厂代码时。虽然工厂方法模式通常是每个具体工厂创建一个具体产品，但如果你的需求是“一个工厂可以根据字符串ID创建不同产品”，那么注册机制就很有用。
#include <map>
#include <string>
#include <functional> // for std::function
// 假设我们有一个通用的SimpleEnemyFactory，它能创建所有注册过的敌人
class SimpleEnemyFactory {
public:
// 类型别名，表示一个创建Enemy的函数
using CreatorFunc = std::function<std::unique_ptr<Enemy>()>;
// 注册产品类型
static void registerEnemy(const std::string& type, CreatorFunc func) {
getRegistry()[type] = std::move(func);
}
// 根据类型创建敌人
static std::unique_ptr<Enemy> createEnemy(const std::string& type) {
auto it = getRegistry().find(type);
if (it != getRegistry().end()) {
return it->second();
}
std::cerr << "Error: Unknown enemy type: " << type << std::endl;
return nullptr;
}
private:
// 静态成员函数返回一个静态map，确保单例且延迟初始化
static std::map<std::string, CreatorFunc>& getRegistry() {
static std::map<std::string, CreatorFunc> registry;
return registry;
}
};
// 注册具体敌人，通常在文件作用域或某个初始化函数中进行
struct OrcRegister {
OrcRegister() {
SimpleEnemyFactory::registerEnemy("Orc", [](){ return std::make_unique<Orc>(); });
}
};
static OrcRegister registerOrc; // 利用静态对象在程序启动时自动注册
struct ElfRegister {
ElfRegister() {
SimpleEnemyFactory::registerEnemy("Elf", [](){ return std::make_unique<Elf>(); });
}
};
static ElfRegister registerElf; // 同样方式注册Elf这种注册机制让
SimpleEnemyFactory
register
registerEnemy
第三，参数化创建。很多时候，创建对象需要传递参数。工厂方法可以接受参数，并将这些参数传递给产品对象的构造函数。
// 抽象产品，构造函数接受参数
class Enemy {
public:
Enemy(int health, int damage) : m_health(health), m_damage(damage) {}
virtual ~Enemy() = default;
virtual void attack() const = 0;
virtual void takeDamage(int amount) = 0;
protected:
int m_health;
int m_damage;
};
// 抽象工厂，工厂方法接受参数
class ParametrizedEnemyFactory {
public:
virtual ~ParametrizedEnemyFactory() = default;
virtual std::unique_ptr<Enemy> createEnemy(int health, int damage) const = 0;
};
// 具体工厂实现
class OrcFactory : public ParametrizedEnemyFactory {
public:
std::unique_ptr<Enemy> createEnemy(int health, int damage) const override {
return std::make_unique<Orc>(health, damage); // 传递参数给Orc构造函数
}
};这样，客户端在创建对象时就可以动态地指定对象的属性，而不是工厂只能创建固定属性的对象。
最后，考虑模板化工厂。如果你的产品类型很多，但它们的创建逻辑（比如都需要一个构造函数参数）非常相似，你可以考虑使用模板来减少重复代码。但这会增加一些复杂性，需要权衡。例如，一个通用的
TemplatedFactory<ProductBase, ConcreteProduct>
构建灵活的工厂模式，关键在于识别出变化点，并用设计模式来封装这些变化。它不是一蹴而就的，而是随着项目演进和需求变化，不断调整和优化的过程。
C++工厂模式并非只有一种，它是一个模式家族，包含几种常见的变体。理解这些变体以及它们各自的优缺点，对于在实际项目中做出明智选择至关重要。我个人在不同场景下会灵活运用它们，因为没有“一招鲜吃遍天”的模式。
简单工厂（Simple Factory）
switch
if-else if
工厂方法模式（Factory Method Pattern）
抽象工厂模式（Abstract Factory Pattern）
总结与选择策略：
我通常会这样思考：
在实际开发中，我发现模式之间并非总是独立的，有时它们会结合使用。比如，一个抽象工厂内部的某个工厂方法，可能又是一个简单工厂的实现。理解它们的本质和适用场景，远比死记硬背它们的结构图重要得多。
以上就是C++工厂模式创建对象的通用方法的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
128
收藏
