AbstractFactory Pattern

AbstractFactory模式用来解决这类问题：要创建一组相关或者相互依赖的对象。

AbstractFactory Pattern结构图

实现：

#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

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

AbstractProductA::AbstractProductA() 
{

}
AbstractProductA::~AbstractProductA() 
{

}
AbstractProductB::AbstractProductB() 
{

}
AbstractProductB::~AbstractProductB() 
{

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

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

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

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

}

#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();
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

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

AbstractFactory::AbstractFactory() 
{

}
AbstractFactory::~AbstractFactory()
{

}
ConcreteFactory1::ConcreteFactory1() 
{

}
ConcreteFactory1::~ConcreteFactory1() 
{

}
AbstractProductA* ConcreteFactory1::CreateProductA() 
{ 
    return new ProductA1(); 
}
AbstractProductB* ConcreteFactory1::CreateProductB() 
{ 
    return new ProductB1(); 
}
ConcreteFactory2::ConcreteFactory2() 
{

}
ConcreteFactory2::~ConcreteFactory2() 
{

}
AbstractProductA* ConcreteFactory2::CreateProductA() 
{ 
    return new ProductA2(); 
}
AbstractProductB* ConcreteFactory2::CreateProductB() 
{ 
    return new ProductB2(); 
}