C++设计模式之工厂模式

接下来我将详细讲解C++设计模式之工厂模式的完整攻略。

工厂模式概述

工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们使用一个工厂方法来创建对象，而不是直接通过new来创建。这样有助于我们实现松耦合和高内聚。

工厂模式的核心思想是定义一个用来创建对象的接口，让子类决定具体要实例化对象的类。这样能够将具体的实现类和客户端分离，使得客户端无需直接关心实例化的过程，只需调用工厂方法即可获取需要的对象。

具体而言，工厂模式可分为简单工厂模式、工厂方法模式和抽象工厂模式。

简单工厂模式

简单工厂模式（Simple Factory Pattern）又称静态工厂方法模式，它定义一个工厂类，该类负责创建不同类型的对象并返回给调用者。

下面是一个简单工厂模式的示例代码：

#include <iostream>
using namespace std;

// 抽象产品
class Product
{
public:
    virtual void show() const = 0;
};

// 具体产品A
class ProductA : public Product
{
public:
    void show() const override { cout << "ProductA" << endl; }
};

// 具体产品B
class ProductB : public Product
{
public:
    void show() const override { cout << "ProductB" << endl; }
};

// 工厂类
class Factory
{
public:
    Product* createProduct(const char type) const
    {
        switch (type)
        {
            case 'A': return new ProductA();
            case 'B': return new ProductB();
            default: return nullptr;
        }
    }
};

// 客户端代码
int main()
{
    Factory factory;
    Product* productA = factory.createProduct('A');
    productA->show();

    Product* productB = factory.createProduct('B');
    productB->show();

    delete productA;
    delete productB;

    return 0;
}

在上面的示例代码中，我们首先定义了一个抽象产品Product和两个具体产品ProductA和ProductB，它们都继承自Product。然后定义了一个工厂类Factory，其中的createProduct方法接收一个产品类型type，根据类型返回不同的具体产品对象。最后，在客户端代码中，我们使用工厂对象创建不同类型的产品对象，并调用它们的show方法。

工厂方法模式

工厂方法模式（Factory Method Pattern）是在简单工厂模式的基础上发展而来的。它定义了一个抽象工厂，具体的工厂由具体的产品类继承实现。这样每个具体的产品都有对应的具体工厂，客户端只需调用工厂方法即可创建产品对象，不再需要关注具体的实现。

下面是一个工厂方法模式的示例代码：

#include <iostream>
using namespace std;

// 抽象产品
class Product
{
public:
    virtual void show() const = 0;
};

// 具体产品A
class ProductA : public Product
{
public:
    void show() const override { cout << "ProductA" << endl; }
};

// 具体产品B
class ProductB : public Product
{
public:
    void show() const override { cout << "ProductB" << endl; }
};

// 抽象工厂
class Factory
{
public:
    virtual Product* createProduct() const = 0;
};

// 具体工厂A
class FactoryA : public Factory
{
public:
    Product* createProduct() const override { return new ProductA(); }
};

// 具体工厂B
class FactoryB : public Factory
{
public:
    Product* createProduct() const override { return new ProductB(); }
};

// 客户端代码
int main()
{
    Factory* factoryA = new FactoryA();
    Product* productA = factoryA->createProduct();
    productA->show();
    delete productA;
    delete factoryA;

    Factory* factoryB = new FactoryB();
    Product* productB = factoryB->createProduct();
    productB->show();
    delete productB;
    delete factoryB;

    return 0;
}

在上面的示例代码中，我们首先定义了一个抽象产品Product和两个具体产品ProductA和ProductB，它们都继承自Product。然后定义了一个抽象工厂Factory，其中的createProduct方法返回一个产品对象。接着，定义了两个具体工厂类FactoryA和FactoryB，它们分别负责创建具体产品A和B。最后，在客户端代码中，我们使用具体工厂创建不同类型的产品对象，并调用它们的show方法。

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是在工厂方法模式的基础上发展而来的。它定义了一个抽象工厂，每个抽象工厂可以创建多个不同的产品，且每个产品都有多个不同的实现。具体工厂继承自抽象工厂，负责创建具体的产品实例。

下面是一个抽象工厂模式的示例代码：

#include <iostream>
using namespace std;

// 抽象产品A
class AbstractProductA
{
public:
    virtual void display() const = 0;
};

// 具体产品A1
class ProductA1 : public AbstractProductA
{
public:
    void display() const override { cout << "ProductA1" << endl; }
};

// 具体产品A2
class ProductA2 : public AbstractProductA
{
public:
    void display() const override { cout << "ProductA2" << endl; }
};

// 抽象产品B
class AbstractProductB
{
public:
    virtual void display() const = 0;
};

// 具体产品B1
class ProductB1 : public AbstractProductB
{
public:
    void display() const override { cout << "ProductB1" << endl; }
};

// 具体产品B2
class ProductB2 : public AbstractProductB
{
public:
    void display() const override { cout << "ProductB2" << endl; }
};

// 抽象工厂
class AbstractFactory
{
public:
    virtual AbstractProductA* createProductA() const = 0;
    virtual AbstractProductB* createProductB() const = 0;
};

// 具体工厂1
class ConcreteFactory1 : public AbstractFactory
{
public:
    AbstractProductA* createProductA() const override { return new ProductA1(); }
    AbstractProductB* createProductB() const override { return new ProductB1(); }
};

// 具体工厂2
class ConcreteFactory2 : public AbstractFactory
{
public:
    AbstractProductA* createProductA() const override { return new ProductA2(); }
    AbstractProductB* createProductB() const override { return new ProductB2(); }
};

// 客户端代码
int main()
{
    AbstractFactory* factory1 = new ConcreteFactory1();
    AbstractProductA* productA1 = factory1->createProductA();
    AbstractProductB* productB1 = factory1->createProductB();
    productA1->display();
    productB1->display();
    delete productA1;
    delete productB1;
    delete factory1;

    AbstractFactory* factory2 = new ConcreteFactory2();
    AbstractProductA* productA2 = factory2->createProductA();
    AbstractProductB* productB2 = factory2->createProductB();
    productA2->display();
    productB2->display();
    delete productA2;
    delete productB2;
    delete factory2;

    return 0;
}

在上面的示例代码中，我们首先定义了两个抽象产品AbstractProductA和AbstractProductB，它们都定义了各自的接口方法。然后定义了四个具体产品类ProductA1、ProductA2、ProductB1和ProductB2，它们都继承自对应的抽象产品。接着，定义了一个抽象工厂AbstractFactory，其中的createProductA方法和createProductB方法分别负责创建抽象产品A和B的实例。最后，定义了两个具体工厂类ConcreteFactory1和ConcreteFactory2，它们分别生成具体产品A1和B1、A2和B2。

在客户端代码中，我们使用具体工厂来创建产品，并分别调用它们的display方法，我们可以看到，通过不同的具体工厂，我们可以创建不同种类的具体产品并执行其对应的操作。