C++ 工厂模式 - 技术栈

这三个名字很容易混，我直接用一句话区分：

txt 复制代码

简单工厂：一个工厂，根据参数创建不同对象。
工厂方法：一个产品对应一个工厂子类。
抽象工厂：一个工厂创建一整套相关产品。

1. 简单工厂模式

核心意思

有一个统一的工厂类，里面用 if / switch 判断要创建什么对象。

比如：

txt 复制代码

传入 1 -> 创建奔驰车
传入 2 -> 创建宝马车

代码例子

cpp 复制代码

#include <stdio.h>

class ICar
{
public:
    virtual ~ICar() {}
    virtual void Run() = 0;
};

class BenzCar : public ICar
{
public:
    void Run()
    {
        printf("BenzCar Run\n");
    }
};

class BmwCar : public ICar
{
public:
    void Run()
    {
        printf("BmwCar Run\n");
    }
};

class CarFactory
{
public:
    static ICar* CreateCar(int type)
    {
        if (type == 1)
        {
            return new BenzCar();
        }
        else if (type == 2)
        {
            return new BmwCar();
        }

        return NULL;
    }
};

int main()
{
    ICar* car = CarFactory::CreateCar(1);

    if (car != NULL)
    {
        car->Run();
        delete car;
        car = NULL;
    }

    return 0;
}

特点

简单工厂的重点是这个：

cpp 复制代码

static ICar* CreateCar(int type)

客户端不用直接写：

cpp 复制代码

new BenzCar();
new BmwCar();

而是交给工厂：

cpp 复制代码

CarFactory::CreateCar(1);

但是它有一个缺点：以后增加 AudiCar，就要修改 CarFactory 里面的 if / switch。

2. 工厂方法模式

核心意思

简单工厂是：

txt 复制代码

一个工厂负责创建所有车

工厂方法是：

txt 复制代码

奔驰工厂只创建奔驰车
宝马工厂只创建宝马车

也就是：

txt 复制代码

BenzFactory -> BenzCar
BmwFactory  -> BmwCar

代码例子

cpp 复制代码

#include <stdio.h>

class ICar
{
public:
    virtual ~ICar() {}
    virtual void Run() = 0;
};

class BenzCar : public ICar
{
public:
    void Run()
    {
        printf("BenzCar Run\n");
    }
};

class BmwCar : public ICar
{
public:
    void Run()
    {
        printf("BmwCar Run\n");
    }
};

// 抽象工厂
class ICarFactory
{
public:
    virtual ~ICarFactory() {}

    // 工厂方法
    virtual ICar* CreateCar() = 0;
};

// 奔驰工厂
class BenzFactory : public ICarFactory
{
public:
    ICar* CreateCar()
    {
        return new BenzCar();
    }
};

// 宝马工厂
class BmwFactory : public ICarFactory
{
public:
    ICar* CreateCar()
    {
        return new BmwCar();
    }
};

int main()
{
    ICarFactory* factory = new BenzFactory();

    ICar* car = factory->CreateCar();

    car->Run();

    delete car;
    car = NULL;

    delete factory;
    factory = NULL;

    return 0;
}

特点

工厂方法的核心是：

cpp 复制代码

virtual ICar* CreateCar() = 0;

父类只规定：

txt 复制代码

你必须有一个 CreateCar() 函数

但是具体创建奔驰还是宝马，由子类工厂决定。

3. 抽象工厂模式

核心意思

抽象工厂不是创建一个产品，而是创建一整套产品。

比如奔驰工厂不只是创建奔驰车，而是创建一整套奔驰产品：

txt 复制代码

奔驰工厂：
    创建奔驰商务车
    创建奔驰跑车

宝马工厂：
    创建宝马商务车
    创建宝马跑车

这就是你图里讲的"产品族"。

代码例子

cpp 复制代码

#include <stdio.h>

// 抽象产品A：商务车
class IBusinessCar
{
public:
    virtual ~IBusinessCar() {}
    virtual void Show() = 0;
};

// 抽象产品B：跑车
class ISportsCar
{
public:
    virtual ~ISportsCar() {}
    virtual void Show() = 0;
};

// 奔驰商务车
class BenzBusinessCar : public IBusinessCar
{
public:
    void Show()
    {
        printf("Benz Business Car\n");
    }
};

// 奔驰跑车
class BenzSportsCar : public ISportsCar
{
public:
    void Show()
    {
        printf("Benz Sports Car\n");
    }
};

// 宝马商务车
class BmwBusinessCar : public IBusinessCar
{
public:
    void Show()
    {
        printf("BMW Business Car\n");
    }
};

// 宝马跑车
class BmwSportsCar : public ISportsCar
{
public:
    void Show()
    {
        printf("BMW Sports Car\n");
    }
};

// 抽象工厂
class ICarFactory
{
public:
    virtual ~ICarFactory() {}

    virtual IBusinessCar* CreateBusinessCar() = 0;
    virtual ISportsCar* CreateSportsCar() = 0;
};

// 奔驰工厂：创建一整套奔驰产品
class BenzFactory : public ICarFactory
{
public:
    IBusinessCar* CreateBusinessCar()
    {
        return new BenzBusinessCar();
    }

    ISportsCar* CreateSportsCar()
    {
        return new BenzSportsCar();
    }
};

// 宝马工厂：创建一整套宝马产品
class BmwFactory : public ICarFactory
{
public:
    IBusinessCar* CreateBusinessCar()
    {
        return new BmwBusinessCar();
    }

    ISportsCar* CreateSportsCar()
    {
        return new BmwSportsCar();
    }
};

int main()
{
    ICarFactory* factory = new BenzFactory();

    IBusinessCar* businessCar = factory->CreateBusinessCar();
    ISportsCar* sportsCar = factory->CreateSportsCar();

    businessCar->Show();
    sportsCar->Show();

    delete businessCar;
    businessCar = NULL;

    delete sportsCar;
    sportsCar = NULL;

    delete factory;
    factory = NULL;

    return 0;
}

4. 三者区别总结

模式	核心	工厂数量	创建对象数量	举例
简单工厂	一个工厂用参数判断创建谁	1 个	通常 1 个	`CarFactory::CreateCar(1)`
工厂方法	一个具体工厂创建一个具体产品	多个	通常 1 个	`BenzFactory -> BenzCar`
抽象工厂	一个具体工厂创建一整套产品	多个	多个	`BenzFactory -> BenzBusinessCar + BenzSportsCar`

5. 最好理解的比喻

简单工厂

像一个万能汽车店：

txt 复制代码

你告诉它：我要奔驰
它给你奔驰

你告诉它：我要宝马
它给你宝马

代码上就是：

cpp 复制代码

CarFactory::CreateCar(1);
CarFactory::CreateCar(2);

工厂方法

像不同品牌的专门工厂：

txt 复制代码

奔驰工厂只造奔驰
宝马工厂只造宝马

代码上就是：

cpp 复制代码

BenzFactory -> BenzCar
BmwFactory  -> BmwCar

抽象工厂

像不同品牌的产品线工厂：

txt 复制代码

奔驰工厂：
    奔驰商务车
    奔驰跑车

宝马工厂：
    宝马商务车
    宝马跑车

代码上就是：

cpp 复制代码

BenzFactory:
    CreateBusinessCar()
    CreateSportsCar()

BmwFactory:
    CreateBusinessCar()
    CreateSportsCar()

6. 一句话记忆

txt 复制代码

简单工厂：一个工厂，靠参数创建不同产品。

工厂方法：一个产品，对应一个具体工厂。

抽象工厂：一个工厂，创建一整套同品牌、同系列的产品。

你图里面讲的就是第三种：抽象工厂模式，重点是"产品族"。