Abstract Factory

#include <iostream>
#include <memory>
using namespace std;

//abstract product A
class IProductA {
    public:
    virtual ~IProductA() = default;
    virtual void testA() = 0;
};

//abstract product B
class IProductB {
    public:
    virtual ~IProductB() = default;
    virtual void testB() = 0;
};

//concrete product A1
class ProductA1: public IProductA {
    public:
    void testA() {
        cout << "test A1\n";
    }
};

//concrete product A2
class ProductA2: public IProductA {
    public:
    void testA() {
        cout << "test A2\n";
    }
};

//concrete product B1
class ProductB1: public IProductB {
    public:
    void testB() {
        cout << "test B1\n";
    }
};

//concrete product B2
class ProductB2: public IProductB {
    public:
    void testB() {
        cout << "test B2\n";
    }
};

//abstract factory
class IFactory {
    public:
    virtual ~IFactory() = default;
    virtual unique_ptr<IProductA> createA() = 0;
    virtual unique_ptr<IProductB> createB() = 0;
};

//concrete factory 1
class Factory1: public IFactory {
    public:
    unique_ptr<IProductA> createA() {
        return make_unique<ProductA1>();
    }
    unique_ptr<IProductB> createB() {
        return make_unique<ProductB1>();
    }
};

//concrete factory 2
class Factory2: public IFactory {
    public:
    unique_ptr<IProductA> createA() {
        return make_unique<ProductA2>();
    }
    unique_ptr<IProductB> createB() {
        return make_unique<ProductB2>();
    }
};

//client code
void testFactory(IFactory& factory) {
    unique_ptr<IProductA> productA = factory.createA();
    unique_ptr<IProductB> productB = factory.createB();
    productA->testA();
    productB->testB();
}

Factory1 factory1;
testFactory(factory1);
//printed: test A1
//         test B1
Factory2 factory2;
testFactory(factory2);
//printed: test A2
//         test B2