设计模式 - 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.对于抽象工厂模式，需要修改所有加入新元素的类，同时修改需要生成该元素的工厂。