设计模式 - AbstractFactory抽象工厂

1.简单描述

抽象工厂包含两部分：一是继承自同一个抽象类的产品类族；二是不同类型的抽象工厂。抽象工厂中可以创建该类产品所需要的元素（创建产品类的数据成员），而生产的所有元素便是抽象工厂的产物。由于抽象工厂可以生成许多元素，所以我们又可以认为，抽象工厂是封装了多个工厂方法，对于每一个元素就相当于一个工厂方法。到底是哪一种类型的元素则由具体的工厂类型决定（子类决定）。产品不再作为抽象工厂的直接输出产物，而是使用工厂的输出组合而成，所以产品可以更加抽象不用再区分大类（大类由抽象工厂决定）。

2.类图

。。。。。。。。

待补

3.实例程序

3.1 元素定义

#ifndef Ingredient_H
#define Ingredient_H

#include <string>
#include <iostream>


class IngredientA
{
public:
    virtual void printIngredientName() = 0;
};

class IngredientA1: public IngredientA
{
    void printIngredientName()
    {
        std::cout<<"IngredientA1"<<std::endl;
    }
};

class IngredientA2: public IngredientA
{
    void printIngredientName()
    {
        std::cout<<"IngredientA2"<<std::endl;
    }
};

class IngredientB
{
public:
    virtual void printIngredientName() = 0;
};

class IngredientB1: public IngredientB
{
    void printIngredientName()
    {
        std::cout<<"IngredientB1"<<std::endl;
    }
};

class IngredientB2: public IngredientB
{
    void printIngredientName()
    {
        std::cout<<"IngredientB2"<<std::endl;
    }
};

#endif
           

3.2 产品定义

// product.h
#ifndef Product_H
#define Product_H

#include "Ingredient.h"

class AbstractFactory;
class Product
{
public:
	Product(){};
    virtual ~Product(){};
    virtual void printProductName() = 0;
};

class ProductA: public Product
{
public:
    ProductA(const AbstractFactory& factory);
	virtual ~ProductA(){};
    virtual void printProductName();

private:
    IngredientA* m_pIA;
    // IngredientB* m_pIB;
};

class ProductB: public Product
{
public:
    ProductB(const AbstractFactory& factory);
	virtual ~ProductB(){};
    virtual void printProductName();

private:
    IngredientA* m_pIA;
    IngredientB* m_pIB;
};

#endif
           

// product.cpp
#include "stdafx.h"
#include <iostream>
#include "Product.h"
#include "AbstractFactory.h"
using namespace std;

ProductA::ProductA(const AbstractFactory& factory)
{
    m_pIA = factory.createIngredientA();
}

void ProductA::printProductName()
{
    cout<<"ProductA->";
    if (NULL != m_pIA)
    {
        m_pIA->printIngredientName();
    }
}

ProductB::ProductB(const AbstractFactory& factory)
{
    m_pIA = factory.createIngredientA();
    m_pIB = factory.createIngredientB();
}

void ProductB::printProductName()
{
    cout<<"ProductB->";
    if (NULL != m_pIB)
    {
        m_pIB->printIngredientName();
    }
    cout<<"ProductB->";
    if (NULL != m_pIA)
    {
        m_pIA->printIngredientName();
    }
}
           

3.3 工厂定义

// factory,h
#ifndef AbstractFactory_H
#define AbstractFactory_H

#include "Ingredient.h"

class AbstractFactory
{
public:
    virtual IngredientA* createIngredientA() const = 0;
    virtual IngredientB* createIngredientB() const = 0;
};

class AbstractFactoryA: public AbstractFactory
{
public:
	AbstractFactoryA(){};
	~AbstractFactoryA(){};
    virtual  IngredientA* createIngredientA() const;
    virtual  IngredientB* createIngredientB() const;
};

class AbstractFactoryB: public AbstractFactory
{
public:
	AbstractFactoryB(){};
	~AbstractFactoryB(){};
    virtual IngredientA* createIngredientA() const;
    virtual IngredientB* createIngredientB() const;
};

#endif
           

// factory.cpp
#include "stdafx.h"
#include "AbstractFactory.h"

IngredientA* AbstractFactoryA::createIngredientA() const
{
    return new IngredientA1();
}

IngredientB* AbstractFactoryA::createIngredientB() const
{
    return new IngredientB1();
}


IngredientA* AbstractFactoryB::createIngredientA() const
{
    return new IngredientA2();
}

IngredientB* AbstractFactoryB::createIngredientB() const
{
    return new IngredientB2();
}
           

3.4 测试程序

// test.cpp
#include <iostream>
#include "AbstractFactory.h"
#include "Product.h"
using namespace std;

int main(int argc, char const *argv[])
{
    /* code */
    AbstractFactoryA factoryA;
    AbstractFactory& factory1 = factoryA;
    Product* produce1 = new ProductA(factory1);
    if (NULL != produce1)
    {
        produce1->printProductName();
        delete produce1;
        produce1 = NULL;
    }
    produce1 = new ProductB(factory1);
    if (NULL != produce1)
    {
        produce1->printProductName();
        delete produce1;
        produce1 = NULL;
    }

    AbstractFactoryB factoryB;
    factory1 = factoryB;
    produce1 = new ProductA(factory1);
    if (NULL != produce1)
    {
        produce1->printProductName();
        delete produce1;
        produce1 = NULL;
    }
    produce1 = new ProductB(factory1);
    if (NULL != produce1)
    {
        produce1->printProductName();
        delete produce1;
        produce1 = NULL;
    }
    
    return 0;
}
           

4.扩展分析

4.1 产品扩展

1.对于普通工厂模式，新增产品需要扩充产品子类，在一个或多个工厂类中加入新扩充产品的创建。 2.对于抽象工厂模式，新增产品只需要扩充产品子类，新产品可有老元素组合而成，工厂类不用变化，也不会加减。

4.2 产品元素扩展

1.对于普通工厂模式，需要修改所有加入新元素的类。 2.对于抽象工厂模式，需要修改所有加入新元素的类，同时修改需要生成该元素的工厂。