设计模式——抽象工厂模式

抽象工厂模式(Abstract Factory)

抽象工厂模式是一种创建型设计模式，提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

#include 
#include 

using namespace std;

// 产品系列中的每个不同产品都应有一个基本接口。产品的所有变体都必须实现此接口。
class AbstractProductA
{
public:
    virtual ~AbstractProductA(){};
    virtual string UsefulFunctionA() const = 0;
};

// 具体产品是由相应的具体工厂创建的
class ConcreteProductA1 : public AbstractProductA
{
public:
    string UsefulFunctionA() const override
    {
        return "The result of the product A1";
    }
};

class ConcreteProductA2 : public AbstractProductA
{
public:
    string UsefulFunctionA() const override
    {
        return "The result of the product A2";
    }
};

// 另一个产品的基本接口
// 只有同一类的产品之间才可以有适当的交互
class AbstractProductB
{
public:
    virtual ~AbstractProductB() {}
    virtual string UsefulFunctionB() const = 0;

    // 抽象工厂确保其创建的所有产品都是同一变体，因此兼容
    virtual string AnotherUsefulFunctionB(const AbstractProductA &collaborator) const = 0;
};

class ConcreteProductB1 : public AbstractProductB
{
public:
    string UsefulFunctionB() const override
    {
        return "The result of the product B1";
    }

    // 变体 Product B1 只能与变体 Product A1 正确配合使用。不过，它接受 AbstractProductA 的任何实例作为参数。
    string AnotherUsefulFunctionB(const AbstractProductA &collaborator) const override
    {
        const string result = collaborator.UsefulFunctionA();
        return "The result of the B1 collaborating with ( " + result + " )";
    }
};

class ConcreteProductB2 : public AbstractProductB
{
public:
    string UsefulFunctionB() const override
    {
        return "The result of the product B2";
    }

    // 变体 Product B2 只能与变体 Product A2 正确配合使用。不过，它接受 AbstractProductA 的任何实例作为参数。
    string AnotherUsefulFunctionB(const AbstractProductA &collaborator) const override
    {
        const string result = collaborator.UsefulFunctionA();
        return "The result of the B2 collaborating with ( " + result + " )";
    }
};

// 抽象工厂接口声明了一组返回不同抽象产品的方法，这些产品属于一个系列，一个系列的产品可以相互协作。
// 一个产品系列可能有多个变体，但是一个变体的产品与另一个变体的产品不兼容
class AbstractFactory
{
public:
    virtual AbstractProductA *CreateProductA() const = 0;
    virtual AbstractProductB *CreateProductB() const = 0;
};

// 具体的工厂生产属于单一变体的一系列产品
// 具体工厂方法返回的是抽象产品，而在方法内部实例化一个具体产品
class ConcreteFactory1 : public AbstractFactory
{
public:
    AbstractProductA *CreateProductA() const override
    {
        return new ConcreteProductA1();
    }

    AbstractProductB *CreateProductB() const override
    {
        return new ConcreteProductB1();
    }
};

class ConcreteFactory2 : public AbstractFactory {
public:
    AbstractProductA *CreateProductA() const override {
        return new ConcreteProductA2();
    }
    AbstractProductB *CreateProductB() const override {
        return new ConcreteProductB2();
    }
};

void ClientCode(const AbstractFactory &factory) {
    const AbstractProductA *product_a = factory.CreateProductA();
    const AbstractProductB *product_b = factory.CreateProductB();
    std::cout << product_b->UsefulFunctionB() << "\n";
    std::cout << product_b->AnotherUsefulFunctionB(*product_a) << "\n";
    delete product_a;
    delete product_b;
}

int main() {
    std::cout << "Client: Testing client code with the first factory type:\n";
    ConcreteFactory1 *f1 = new ConcreteFactory1();
    ClientCode(*f1);
    delete f1;
    std::cout << std::endl;
    std::cout << "Client: Testing the same client code with the second factory type:\n";
    ConcreteFactory2 *f2 = new ConcreteFactory2();
    ClientCode(*f2);
    delete f2;
    return 0;
}

输出为

Client: Testing client code with the first factory type:
The result of the product B1
The result of the B1 collaborating with ( The result of the product A1 )

Client: Testing the same client code with the second factory type:
The result of the product B2
The result of the B2 collaborating with ( The result of the product A2 )