好的，我将详细介绍三种工厂模式，并附上相应的C++测试程序。

一、工厂模式详解

1. 简单工厂模式

功能作用：

• 提供一个统一的接口来创建不同类型的对象
• 将对象的创建逻辑集中管理

工作原理：

• 定义一个工厂类，包含静态创建方法
• 根据输入参数动态实例化具体类

使用场景：

• 对象创建逻辑简单
• 客户端不关心具体创建过程
• 需要减少客户端与具体类的耦合

设计优势：

• 封装变化点：当新增产品时只需修改工厂类
• 符合开闭原则：对扩展开放（新增产品），对修改关闭（不修改客户端）
  $$\text{客户端}\to \text{工厂}\to \text{具体产品}$$

C++ 实现：

#include <iostream>
using namespace std;

// 产品接口
class Car {
public:
    virtual void drive() = 0;
};

// 具体产品
class SUV : public Car {
public:
    void drive() override {
        cout << "Driving SUV" << endl;
    }
};

class Sedan : public Car {
public:
    void drive() override {
        cout << "Driving Sedan" << endl;
    }
};

// 简单工厂
class CarFactory {
public:
    static Car* createCar(const string& type) {
        if (type == "SUV") return new SUV();
        if (type == "Sedan") return new Sedan();
        return nullptr;
    }
};

// 测试
int main() {
    Car* car1 = CarFactory::createCar("SUV");
    Car* car2 = CarFactory::createCar("Sedan");
    
    car1->drive();  // Output: Driving SUV
    car2->drive();  // Output: Driving Sedan
    
    delete car1;
    delete car2;
    return 0;
}

---

2. 工厂方法模式

功能作用：

• 定义创建对象的接口，由子类决定实例化类
• 支持"类不知道需要创建的对象类型"的场景

工作原理：

• 抽象工厂声明工厂方法
• 具体工厂实现该方法返回具体产品

使用场景：

• 需要灵活扩展新产品
• 创建过程需要复杂初始化
• 框架需要为不同平台提供组件

设计优势：

• 完全符合开闭原则
• 解耦产品创建与使用
  $$\text{客户端}\to \text{抽象工厂}\leftarrow \text{具体工厂}\to \text{具体产品}$$

C++ 实现：

// 抽象工厂
class CarFactory {
public:
    virtual Car* createCar() = 0;
};

// 具体工厂
class SUVFactory : public CarFactory {
public:
    Car* createCar() override {
        return new SUV();
    }
};

class SedanFactory : public CarFactory {
public:
    Car* createCar() override {
        return new Sedan();
    }
};

// 测试
int main() {
    CarFactory* suvFactory = new SUVFactory();
    CarFactory* sedanFactory = new SedanFactory();
    
    Car* suv = suvFactory->createCar();
    Car* sedan = sedanFactory->createCar();
    
    suv->drive();  // Output: Driving SUV
    sedan->drive(); // Output: Driving Sedan
    
    delete suv;
    delete sedan;
    delete suvFactory;
    delete sedanFactory;
    return 0;
}

---

3. 抽象工厂模式

功能作用：

• 创建相关或依赖对象的家族
• 提供产品族的创建接口

工作原理：

• 定义抽象工厂接口包含多个创建方法
• 具体工厂实现整个产品族的创建

使用场景：

• 系统需要多系列产品
• 产品需要协同工作
• 需要保证产品兼容性

设计优势：

• 隔离具体类的创建
• 保证产品之间的兼容性
• 支持产品族动态切换
  $$\text{客户端}\to \text{抽象工厂}\leftarrow \text{具体工厂}\to \{\begin{array}{l}\text{产品A}\\ \text{产品B}\end{array}$$

C++ 实现：

// 新增产品接口
class Engine {
public:
    virtual void start() = 0;
};

// 具体产品
class ElectricEngine : public Engine {
public:
    void start() override {
        cout << "Starting electric engine" << endl;
    }
};

class GasEngine : public Engine {
public:
    void start() override {
        cout << "Starting gas engine" << endl;
    }
};

// 抽象工厂
class VehicleFactory {
public:
    virtual Car* createCar() = 0;
    virtual Engine* createEngine() = 0;
};

// 具体工厂
class ElectricVehicleFactory : public VehicleFactory {
public:
    Car* createCar() override {
        return new Sedan(); // 电动车通常是轿车
    }
    Engine* createEngine() override {
        return new ElectricEngine();
    }
};

class GasVehicleFactory : public VehicleFactory {
public:
    Car* createCar() override {
        return new SUV(); // 燃油车通常是SUV
    }
    Engine* createEngine() override {
        return new GasEngine();
    }
};

// 测试
int main() {
    VehicleFactory* electricFactory = new ElectricVehicleFactory();
    VehicleFactory* gasFactory = new GasVehicleFactory();
    
    Car* electricCar = electricFactory->createCar();
    Engine* electricEngine = electricFactory->createEngine();
    
    Car* gasCar = gasFactory->createCar();
    Engine* gasEngine = gasFactory->createEngine();
    
    electricCar->drive();     // Driving Sedan
    electricEngine->start();  // Starting electric engine
    
    gasCar->drive();         // Driving SUV
    gasEngine->start();       // Starting gas engine
    
    delete electricCar;
    delete electricEngine;
    delete gasCar;
    delete gasEngine;
    delete electricFactory;
    delete gasFactory;
    return 0;
}

---

编译运行说明

1. 将代码保存为 .cpp 文件（如 factory_demo.cpp）
2. 编译命令：

g++ -std=c++11 factory_demo.cpp -o factory_demo

3. 运行程序：

./factory_demo

输出结果

Driving SUV
Driving Sedan
Driving SUV
Starting electric engine
Driving SUV
Starting gas engine

模式对比总结

模式	解耦程度	扩展性	复杂度	适用场景
简单工厂	★★☆	★☆☆	低	产品类型少，变化不频繁
工厂方法	★★★	★★☆	中	单一产品系列扩展
抽象工厂	★★★	★★★	高	多产品族协同工作

三种模式均遵循 {依赖倒置原则} ：高层模块不依赖低层模块的具体实现，而是依赖抽象接口。