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

*工厂模式解决了一部分问题，但还有一些缺点，所以这时抽象工厂模式应运而生。。。→_→*

在阅读本文之前，需要了解一些知识点。。。请戳传送门——工厂模式

1. 工厂模式与抽象工厂模式的区别

   • 工厂模式中，在工厂子类中无论多么辛苦的制造产品子类，其实它们都同属一个父类
   • 而在现实生活中，工厂不可能只制造一种产品。所以一个工厂子类有可能制造多种产品子类，而它们来源于不同的父类

2. 抽象工厂模式的作用

   • 将一组来自于不同父类的子类对象的创建封装到一个类中， 维护这样一个创建类总比维护n个相关对象的创建过程要简单的多

3. 抽象工厂模式结构示意图

4. 代码实现

#include <iostream>
#include <vld.h>
using namespace std;

//产品A父类
class AbstractProductA
{
public:
    virtual ~AbstractProductA() {}
protected:
    AbstractProductA() {}
};

//产品B父类
class AbstractProductB
{
public:
    virtual ~AbstractProductB() {}
protected:
    AbstractProductB() {}
};

//产品A的子类A1
class ProductA1 : public AbstractProductA
{
public:
    ProductA1()
    {
        cout << "ProductA1..." << endl;
    }
    ~ProductA1() {}
};

//产品A的子类A2
class ProductA2 : public AbstractProductA
{
public:
    ProductA2()
    {
        cout << "ProductA2..." << endl;
    }
    ~ProductA2() {}
};

//产品B的子类B1
class ProductB1 : public AbstractProductB
{
public:
    ProductB1()
    {
        cout << "ProductB1..." << endl;
    }
    ~ProductB1() {}
};

//产品B的子类B2
class ProductB2 : public AbstractProductB
{
public:
    ProductB2()
    {
        cout << "ProductB2..." << endl;
    }
    ~ProductB2() {}
};

//抽象工厂父类
class AbstractFactory
{
public:
    virtual ~AbstractFactory() {}
    //工厂中生产有可能生产多种类型的产品，所以对应不同的调用接口
    virtual AbstractProductA* CreateProductA() = 0;
    virtual AbstractProductB* CreateProductB() = 0;
protected:
    AbstractFactory() {}
};

//抽象工厂子类CF1
class ConcreteFactory1 : public AbstractFactory
{
public:
    ConcreteFactory1() {}
    ~ConcreteFactory1() {}
    //工厂CF1针对A产品的初始化调用接口实现
    AbstractProductA* CreateProductA()
    {
        return new ProductA1();
    }
    //工厂CF1针对B产品的初始化调用接口实现
    AbstractProductB* CreateProductB()
    {
        return new ProductB1();
    }
};

//抽象工厂子类CF2
class ConcreteFactory2 : public AbstractFactory
{
public:
    ConcreteFactory2() {}
    ~ConcreteFactory2() {}
    //工厂CF2针对A产品的初始化调用接口实现
    AbstractProductA* CreateProductA()
    {
        return new ProductA2();
    }
    //工厂CF2针对B产品的初始化调用接口实现
    AbstractProductB* CreateProductB()
    {
        return new ProductB2();
    }
};

int main()
{
    AbstractFactory* cf1 = new ConcreteFactory1();//创建抽象工厂子类CF1
    AbstractProductA* pA1 = cf1->CreateProductA();//在CF1中生产产品A的子类A1
    AbstractProductB* pB1 = cf1->CreateProductB();//在CF1中生产产品B的子类B1

    AbstractFactory* cf2 = new ConcreteFactory2();//创建抽象工厂子类CF2
    AbstractProductA* pA2 = cf2->CreateProductA();//在CF2中生产产品A的子类A2
    AbstractProductB* pB2 = cf2->CreateProductB();//在CF2中生产产品B的子类B2

    delete cf1;
    delete pA1;
    delete pB1;
    delete cf2;
    delete pA2;
    delete pB2;
    return 0;
}

运行结果

*码完。。。收工。。。→_→*