工厂模式属于创建型设计模式，核心思想是将对象的创建过程封装起来，让客户端不需要直接依赖具体类的构造函数，而是通过统一的工厂接口获取对象实例，从而降低代码耦合度，提升扩展性。在C++中实现工厂模式有多种方式，不同方式的适用场景有所区别。
简单工厂模式
简单工厂模式是最基础的工厂实现方式，通过一个工厂类根据传入的参数决定创建哪种具体产品对象，适合产品类型较少且不会频繁变动的场景。
首先定义抽象产品接口和具体产品类：
#include <iostream>
#include <memory>
#include <string>
// 抽象产品类：运算接口
class Operation {
public:
virtual ~Operation() = default;
virtual double calculate(double a, double b) = 0;
};
// 具体产品类：加法
class AddOperation : public Operation {
public:
double calculate(double a, double b) override {
return a + b;
}
};
// 具体产品类：减法
class SubOperation : public Operation {
public:
double calculate(double a, double b) override {
return a - b;
}
};
接下来实现简单工厂类，根据传入的类型参数创建对应的产品实例：
// 简单工厂类
class OperationFactory {
public:
static std::unique_ptr<Operation> createOperation(const std::string& type) {
if (type == "add") {
return std::make_unique<AddOperation>();
} else if (type == "sub") {
return std::make_unique<SubOperation>();
}
return nullptr;
}
};
客户端使用方式如下，不需要直接实例化具体产品类：
int main() {
auto addOp = OperationFactory::createOperation("add");
if (addOp) {
std::cout << "3 + 5 = " << addOp->calculate(3, 5) << std::endl;
}
auto subOp = OperationFactory::createOperation("sub");
if (subOp) {
std::cout << "10 - 4 = " << subOp->calculate(10, 4) << std::endl;
}
return 0;
}
简单工厂的缺点是如果需要新增产品类型，必须修改工厂类的判断逻辑，违反了开闭原则，适合产品类型固定的场景。
工厂方法模式
工厂方法模式将对象的创建延迟到子类工厂中，每个具体产品对应一个具体工厂，新增产品时只需要新增对应的工厂类，不需要修改原有代码，符合开闭原则。
首先定义抽象工厂接口：
// 抽象工厂接口
class OperationFactory {
public:
virtual ~OperationFactory() = default;
virtual std::unique_ptr<Operation> createOperation() = 0;
};
然后为每个具体产品实现对应的具体工厂类：
// 加法工厂
class AddFactory : public OperationFactory {
public:
std::unique_ptr<Operation> createOperation() override {
return std::make_unique<AddOperation>();
}
};
// 减法工厂
class SubFactory : public OperationFactory {
public:
std::unique_ptr<Operation> createOperation() override {
return std::make_unique<SubOperation>();
}
};
客户端使用时根据需要选择对应的工厂实例：
int main() {
// 使用加法工厂
OperationFactory* addFactory = new AddFactory();
auto addOp = addFactory->createOperation();
std::cout << "4 + 6 = " << addOp->calculate(4, 6) << std::endl;
delete addFactory;
// 使用减法工厂
OperationFactory* subFactory = new SubFactory();
auto subOp = subFactory->createOperation();
std::cout << "9 - 3 = " << subOp->calculate(9, 3) << std::endl;
delete subFactory;
return 0;
}
工厂方法模式的缺点是每增加一个产品就需要新增一个工厂类，当产品类型较多时会产生较多的类文件。
抽象工厂模式
抽象工厂模式用于创建一系列相关或者相互依赖的对象，适合需要创建多个产品族的场景，比如不同数据库的操作对象、不同系统的UI组件等。
假设我们需要创建两种产品族：运算操作和日志输出，首先定义所有抽象产品接口：
// 抽象日志产品
class Logger {
public:
virtual ~Logger() = default;
virtual void log(const std::string& msg) = 0;
};
// 具体日志产品：控制台日志
class ConsoleLogger : public Logger {
public:
void log(const std::string& msg) override {
std::cout << "控制台日志：" << msg << std::endl;
}
};
// 具体日志产品：文件日志
class FileLogger : public Logger {
public:
void log(const std::string& msg) override {
std::cout << "文件日志：" << msg << std::endl;
}
};
然后定义抽象工厂接口，包含创建所有产品族的方法：
// 抽象工厂接口，包含创建运算和日志的方法
class AbstractFactory {
public:
virtual ~AbstractFactory() = default;
virtual std::unique_ptr<Operation> createOperation() = 0;
virtual std::unique_ptr<Logger> createLogger() = 0;
};
实现具体工厂类，每个工厂对应一个产品族，创建该族下的所有产品：
// 具体工厂1：创建加法+控制台日志的产品族
class Factory1 : public AbstractFactory {
public:
std::unique_ptr<Operation> createOperation() override {
return std::make_unique<AddOperation>();
}
std::unique_ptr<Logger> createLogger() override {
return std::make_unique<ConsoleLogger>();
}
};
// 具体工厂2：创建减法+文件日志的产品族
class Factory2 : public AbstractFactory {
public:
std::unique_ptr<Operation> createOperation() override {
return std::make_unique<SubOperation>();
}
std::unique_ptr<Logger> createLogger() override {
return std::make_unique<FileLogger>();
}
};
客户端使用方式如下，切换产品族只需要更换工厂实例：
int main() {
// 使用产品族1
AbstractFactory* factory1 = new Factory1();
auto op1 = factory1->createOperation();
auto logger1 = factory1->createLogger();
logger1->log("执行加法运算");
std::cout << "2 + 8 = " << op1->calculate(2, 8) << std::endl;
delete factory1;
// 使用产品族2
AbstractFactory* factory2 = new Factory2();
auto op2 = factory2->createOperation();
auto logger2 = factory2->createLogger();
logger2->log("执行减法运算");
std::cout << "7 - 2 = " << op2->calculate(7, 2) << std::endl;
delete factory2;
return 0;
}
抽象工厂模式的缺点是如果需要新增一个产品类型，比如新增乘法操作，那么所有抽象工厂和具体工厂都需要修改，扩展性不如工厂方法模式灵活。
三种工厂模式的选择建议
在实际开发中可以根据场景选择合适的工厂模式：
- 如果产品类型很少且不会频繁变动，优先选择简单工厂模式，实现简单成本低
- 如果产品类型会频繁新增，且每个产品相对独立，选择工厂方法模式，符合开闭原则
- 如果需要创建多个相关的产品族，且产品族内的产品需要配套使用，选择抽象工厂模式
合理使用工厂模式可以有效解耦对象的创建和使用逻辑，让代码更容易维护和扩展，是C++面向对象开发中非常实用的设计模式。