23种设计模式之二（创建型模式）AbstactFactory模式

一、简介

        AbstractFactory 模式就是用来解决要创建一组相关或者相互依赖的对象的问题。如下图AbstractFactory 模式典型的结构图，其中ProductA和ProductB依赖于ConcreteFactory的对象，Product它们对象的创建被封装到用于创建对象的类ConcreteFactory中，这样只用维护一个创建对象ConcreteFactory类，比维护n多Product的相关对象的创建过程要简单的多，简化了维护的成本和工作。

二、详解

1、代码实现

（完整代码已上传到csdn）

（1）代码product.h：

#ifndef _PRODUCT_H_
#define _PRODUCT_H_

class AbstractProductA
{
    public:
        virtual ~AbstractProductA();
    protected:
        AbstractProductA();
    private:
};
class AbstractProductB
{
    public:
        virtual ~AbstractProductB();
    protected:
        AbstractProductB();
    private:
};
class ProductA1 : public AbstractProductA
{
    public:
        ProductA1();
        ~ProductA1();
    protected:
    private:
};
class ProductA2 : public AbstractProductA
{
    public:
        ProductA2();
        ~ProductA2();
    protected:
    private:
};
class ProductB1 : public AbstractProductB
{
    public:
        ProductB1();
        ~ProductB1();
    protected:
    private:
};
class ProductB2 : public AbstractProductB
{
    public:
        ProductB2();
        ~ProductB2();
    protected:
    private:
};

#endif

（2）代码product.cpp：

#include <iostream>
#include "product.h"
using namespace std;

AbstractProductA::AbstractProductA()
{
}

AbstractProductA::~AbstractProductA()
{
}

AbstractProductB::AbstractProductB()
{
}

AbstractProductB::~AbstractProductB()
{
}

ProductA1::ProductA1()
{
    cout<<"---ProductA1 constructor"<<endl;
}

ProductA1::~ProductA1()
{
    cout<<"---ProductA1 destructor"<<endl;
}

ProductA2::ProductA2()
{
    cout<<"---ProductA2 constructor"<<endl;
}

ProductA2::~ProductA2()
{
    cout<<"---ProductA2 destructor"<<endl;
}

ProductB1::ProductB1()
{
    cout<<"+++ProductB1 constructor"<<endl;
}

ProductB1::~ProductB1()
{
    cout<<"+++ProductB1 destructor"<<endl;
}

ProductB2::ProductB2()
{
    cout<<"+++ProductB2 constructor"<<endl;
}

ProductB2::~ProductB2()
{
    cout<<"+++ProductB2 destructor"<<endl;
}

（3）代码abstractfactory.h：

#ifndef _ABSTRACTFACTORY_H_
#define _ABSTRACTFACTORY_H_

class AbstractProductA;
class AbstractProductB;
class AbstractFactory
{
    public:
        virtual ~AbstractFactory();
        virtual AbstractProductA *CreateProductA() = 0;
        virtual AbstractProductB *CreateProductB() = 0;
    protected:
        AbstractFactory();
        AbstractProductA *pointA1;
        AbstractProductA *pointA2;
        AbstractProductB *pointB1;
        AbstractProductB *pointB2;
    private:
};

class ConcreteFactory1 : public AbstractFactory
{
    public:
        ConcreteFactory1();
        ~ConcreteFactory1();
        AbstractProductA *CreateProductA();
        AbstractProductB *CreateProductB();
    protected:
    private:
};

class ConcreteFactory2 : public AbstractFactory
{
    public:
        ConcreteFactory2();
        ~ConcreteFactory2();
        AbstractProductA *CreateProductA();
        AbstractProductB *CreateProductB();
    protected:
    private:
};

#endif

（4）代码abstractfactory.cpp：

#include <iostream>
#include "product.h"
#include "abstractfactory.h"
using namespace std;

AbstractFactory::AbstractFactory()
{
    cout<<"father:AbstractFactory constructor"<<endl;
    pointA1 = NULL;
    pointA2 = NULL;
    pointB1 = NULL;
    pointB2 = NULL;
}

AbstractFactory::~AbstractFactory()
{
    cout<<"father:AbstractFactory destructor"<<endl;
    if (pointA1)  delete pointA1;
    if (pointA2)  delete pointA2;
    if (pointB1)  delete pointB1;
    if (pointB2)  delete pointB2;
}

ConcreteFactory1::ConcreteFactory1()
{
}

ConcreteFactory1::~ConcreteFactory1()
{
}

AbstractProductA *ConcreteFactory1::CreateProductA()
{
    cout<<"ConcreteFactory1:new ProductA1()"<<endl;
    pointA1 = new ProductA1();
    return pointA1;
}

AbstractProductB *ConcreteFactory1::CreateProductB()
{
    cout<<"ConcreteFactory1:new ProductB1()"<<endl;
    pointB1 = new ProductB1();
    return pointB1;
}

ConcreteFactory2::ConcreteFactory2()
{
}

ConcreteFactory2::~ConcreteFactory2()
{
}

AbstractProductA *ConcreteFactory2::CreateProductA()
{
    cout<<"ConcreteFactory2:new ProductA2()"<<endl;
    pointA2 = new ProductA2();
    return pointA2;
}

AbstractProductB *ConcreteFactory2::CreateProductB()
{
    cout<<"ConcreteFactory2:new ProductB2()"<<endl;
    pointB2 = new ProductB2();
    return pointB2;
}

（5）代码main.cpp：

#include <iostream>
#include "abstractfactory.h"
using namespace std;

int main()
{
    AbstractFactory *cf1 = new ConcreteFactory1();
    cf1->CreateProductA();
    cf1->CreateProductB();
    
    AbstractFactory *cf2 = new ConcreteFactory2();
    cf2->CreateProductA();
    cf2->CreateProductB();

    delete cf1;
    delete cf2;
    return 0;
}

（6）makefile：

CFLAGS = -g
DEFINED = #-D _VERSION
LIBS = 
CC = g++
INCLUDES = -I./
OBJS= main.o abstractfactory.o product.o
TARGET= main
all:$(TARGET)

$(TARGET):$(OBJS)
	$(CC) $(CFLAGS) -o $@ $(OBJS)

.SUFFIXES:.o .h
.SUFFIXES:.cpp .o
.cpp.o:
	$(CC) $(DEFINED) -c $(CFLAGS) -o $@ $<

ok:
	./$(TARGET)
clean:
	rm -f $(OBJS) $(TARGET) core *.log

2、运行结果

（centos6.3系统中运行结果：）

三、总结

（1）AbstractFactory 模式和 Factory 模式的差异是使用设计模式时候的一个容易引起困惑的地方，实际上AbstractFactory 模式是为创建一组(有多类)相关或依赖的对象提供创建接口，而 Factory 模式是为一类对象提供创建接口或延迟对象的创建到子类中实现，并且可以看到AbstractFactory 模式通常都是使用 Factory 模式实现(ConcreteFactory1)。

（2）源码已经打包上传到csdn上可登录下载（http://download.csdn.net/detail/taiyang1987912/8403151）。