抽象工厂模式

抽象工厂模式 提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

#include <iostream>
#include <string>


using namespace std;


struct AbstractProductA {
public:
    virtual void operationA() = 0;
};

struct ProductA_1 : public AbstractProductA {
public:
    void operationA() {
        cout << "ProductA_1" << endl;
    }
};

struct ProductA_2 : public AbstractProductA {
public:
    void operationA() {
        cout << "ProductA_2" << endl;
    }
};


struct AbstractProductB {
public:
    virtual void operationB() = 0;
};

struct ProductB_1 : public AbstractProductB {
public:
    void operationB() {
        cout << "ProductB_1" << endl;
    }
};

struct ProductB_2 : public AbstractProductB {
public:
    void operationB() {
        cout << "ProductB_2" << endl;
    }
};


struct AbstractFactory {
public:
    virtual AbstractProductA *createProductA() = 0;
    virtual AbstractProductB *createProductB() = 0;
};

struct Factory1 : public AbstractFactory {
public:
    AbstractProductA *createProductA() {
        return new ProductA_1();
    }
    AbstractProductB *createProductB() {
        return new ProductB_1();
    }
};

struct Factory2 : public AbstractFactory {
public:
    AbstractProductA *createProductA() {
        return new ProductA_2();
    }
    AbstractProductB *createProductB() {
        return new ProductB_2();
    }
};


int main(int argc, char **argv)
{
    AbstractFactory *factory1 = new Factory1();
    AbstractProductA *pA = factory1->createProductA();
    AbstractProductB *pB = factory1->createProductB();
    pA->operationA();
    pB->operationB();
    delete pA;
    delete pB;
    delete factory1;

    AbstractFactory *factory2 = new Factory2();
    pA = factory2->createProductA();
    pB = factory2->createProductB();
    pA->operationA();
    pB->operationB();
    delete pA;
    delete pB;
    delete factory2;

    return 0;
}