模式动机

在工厂方法模式中具体工厂负责生产具体的产品，每一个具体工厂对应一种具体产品，工厂方法也具有唯一性，一般情况下，一个具体工厂中只有一个工厂方法或者一组重载的工厂方法。但是有时候我们需要一个工厂可以提供多个产品对象，而不是单一的产品对象。
当系统所提供的工厂所需生产的具体产品并不是一个简单的对象，而是多个位于不同产品等级结构中属于不同类型的具体产品时需要使用抽象工厂模式。
抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形态。
抽象工厂模式与工厂方法模式最大的区别在于，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则需要面对多个产品等级结构，一个工厂等级结构可以负责多个不同产品等级结构中的产品对象的创建。当一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象时，抽象工厂模式比工厂方法模式更为简单、有效率。

模式定义

抽象工厂模式(Abstract Factory Pattern)：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。

模式结构

抽象工厂模式包含如下角色：

AbstractFactory：抽象工厂
ConcreteFactory：具体工厂
AbstractProduct：抽象产品
Product：具体产品

时序图

代码

// AbstractFactoryPattern.h
//
// Created by zhaoyf on 2022/4/30.
//

#ifndef CPPDESIGNPATTERN_ABSTRACTFACTORYPATTERN_H
#define CPPDESIGNPATTERN_ABSTRACTFACTORYPATTERN_H

#include <string>

namespace AbstractFactoryPattern {
    // A类产品基类
    // ProductA
    class ProductA {
    public:
        virtual ~ProductA() {}

        virtual std::string GetName() = 0;
        // ...
    };

    // A类产品实际类型
    // ConcreteProductAX
    class ConcreteProductAX : public ProductA {
    public:
        ~ConcreteProductAX() {}

        virtual std::string GetName() override;
        // ...
    };

    // ConcreteProductAY
    class ConcreteProductAY : public ProductA {
    public:
        ~ConcreteProductAY() {}

        virtual std::string GetName() override;
        // ...
    };

    // B类产品基类
    // ProductB
    class ProductB {
    public:
        virtual ~ProductB() {}

        virtual std::string GetName() = 0;
        // ...
    };

    // ConcreteProductBX
    class ConcreteProductBX : public ProductB {
    public:
        ~ConcreteProductBX() {}

        virtual std::string GetName() override;
        // ...
    };

    // ConcreteProductBY
    class ConcreteProductBY : public ProductB {
    public:
        ~ConcreteProductBY() {}

        virtual std::string GetName() override;
        // ...
    };

    // 抽象工厂基类
    // AbstractFactory
    class AbstractFactory {
    public:
        virtual ~AbstractFactory() {}

        virtual ProductA *createProductA() = 0;

        virtual ProductB *createProductB() = 0;
    };

    // ConcreteFactoryX
    class ConcreteFactoryX : public AbstractFactory {
    public:
        ~ConcreteFactoryX() {}

        virtual ProductA *createProductA() override;

        virtual ProductB *createProductB() override;
        // ...
    };

    // ConcreteFactoryY
    class ConcreteFactoryY : public AbstractFactory {
    public:
        ~ConcreteFactoryY() {}

        virtual ProductA *createProductA() override;

        virtual ProductB *createProductB() override;
        // ...
    };
}


#endif //CPPDESIGNPATTERN_ABSTRACTFACTORYPATTERN_H

// AbstractFactoryPattern.cpp
//
// Created by zhaoyf on 2022/4/30.
//

#include "AbstractFactoryPattern.h"
#include <iostream>
#include <memory>

namespace AbstractFactoryPattern {

    // ConcreteProductAY
    std::string ConcreteProductAX::GetName() {
        return "A-X";
    }

    std::string ConcreteProductAY::GetName() {
        return "A-Y";
    }

    // ConcreteProductBX
    std::string ConcreteProductBX::GetName() {
        return "B-X";
    }

    std::string ConcreteProductBY::GetName() {
        return "B-Y";
    }

    // ConcreteFactoryX
    ProductA *ConcreteFactoryX::createProductA() {
        return new ConcreteProductAX();
    }

    ProductB *ConcreteFactoryX::createProductB() {
        return new ConcreteProductBX();
    }

    // ConcreteFactoryY
    ProductA *ConcreteFactoryY::createProductA() {
        return new ConcreteProductAY();
    }

    ProductB *ConcreteFactoryY::createProductB() {
        return new ConcreteProductBY();
    }
}

// main.cpp 测试代码
  int main() {
        // 如下代码存在内存泄露，但是为了方便测试忽略处理，改进请见智能指针版本
        AbstractFactory *pFactory = new ConcreteFactoryX();
        std::cout << "start create X factory series product:" << std::endl;
        std::cout << pFactory->createProductA()->GetName() << std::endl;
        std::cout << pFactory->createProductB()->GetName() << std::endl;
        delete pFactory;
        pFactory = nullptr;

        pFactory = new ConcreteFactoryY();
        std::cout << "start create Y factory series product:" << std::endl;
        std::cout << pFactory->createProductA()->GetName() << std::endl;
        std::cout << pFactory->createProductB()->GetName() << std::endl;
        delete pFactory;
        pFactory = nullptr;

        // 智能指针， 无内存泄露
        auto upFactoryX = std::make_unique<ConcreteFactoryX>();
        std::cout << "start create X factory series product:" << std::endl;
        std::cout << upFactoryX->createProductA()->GetName() << std::endl;
        std::cout << upFactoryX->createProductB()->GetName() << std::endl;

        auto upFactoryY = std::make_unique<ConcreteFactoryY>();
        std::cout << "start create Y factory series product:" << std::endl;
        std::cout << upFactoryY->createProductA()->GetName() << std::endl;
        std::cout << upFactoryY->createProductB()->GetName() << std::endl;
        return 0;
    }

output:
start create X factory series product:
A-X
B-X
start create Y factory series product:
A-Y
B-Y
start create X factory series product:
A-X
B-X
start create Y factory series product:
A-Y
B-Y