AbstractFactory 추상 공장 모드

AbstractFactory
관련되거나 서로 의존하는 대상을 만들려면
역할: 구체적인 클래스를 지정하지 않고 관련되거나 서로 의존하는 일련의 인터페이스를 제공합니다.
UML 맵:
추상 기본 클래스:
1) AbstractProductA, AbstractProductB: 각각 두 가지 서로 다른 유형의 제품을 대표하고 구체적인 제품의 파생 클래스가 이를 실현한다.
2) AbstractFactory: 추상적인 공장 클래스로 두 제품의 인터페이스를 만드는 CreateProductA와 CreateProductB를 제공하며 파생된 각 구체적인 공장 클래스에 의해 실현된다.
설명:
AbstractFactory 모드의 관건은 이 그룹의 대상 생성을 대상을 만드는 클래스(ConcreteFactory)에 봉인하는 것이다.
Abstract Factory 모델과 Factory의 가장 큰 차이점은 추상적인 공장이 만들어진 것은 일련의 관련 대상이다. 그 중에서 만들어진 실현은 사실 Factory 모델의 방법을 사용했다. 특정한 실현에 대해 파생된 추상적인 공장이 있고 다른 실현에는 또 다른 파생된 공장이 있다.
추상 공장이 특별히 주의해야 할 부분은 서로 다른 유형의 제품과 이런 제품의 서로 다른 실현을 구분하는 것이다.만약에 n가지 제품이 동시에 m에서 다른 실현을 한다면 곱셈 원리에 따라 n*m개의 팩토리 모델의 사용이 있음을 알 수 있다
AbstractFactory 모드는 관련되거나 의존하는 대상을 만드는 데 인터페이스를 제공하고, Factory 모드는 대상을 만드는 데 인터페이스를 제공하거나 하위 클래스로 만드는 것을 지연시킨다.또한AbstractFactory 모드는 대개 Factory 모드로 이루어진다(ConcreteFactory 1).

#ifndef _PRODUCT_H_
#define _PRODUCT_H_

// AbstractProductA， A 
class AbstractProductA
{
public:
    virtual ~AbstractProductA()=0;
    virtual void Produce()=0;
protected:
    AbstractProductA();// 
};

// ProductA1， AbstractProductA，A 
class ProductA1 : public AbstractProductA
{
public:
    ProductA1();
    virtual void Produce();
    virtual ~ProductA1();
};

// ProductA2， AbstractProductA，A 
class ProductA2:public AbstractProductA
{
public:
    ProductA2();
    virtual void Produce();
    virtual ~ProductA2();
};

// AbstractProductB， B 
class AbstractProductB
{
public:
    virtual ~AbstractProductB()=0;
    virtual void Produce()=0;
protected:
    AbstractProductB();// 
};

// ProductB1， AbstractProductB，B 
class ProductB1:public AbstractProductB
{
public:
    ProductB1();
    virtual void Produce();
    virtual ~ProductB1();
};

// ProductB2， AbstractProductB，B 
class ProductB2:public AbstractProductB
{
public:
    ProductB2();
    virtual void Produce();
    virtual ~ProductB2();
};

#endif

#ifndef _FACTORY_H_
#define _FACTORY_H_

//AbstractFactory， ， A B 
class AbstractProductA;
class AbstractProductB;
class AbstractFactory
{
public:
    virtual ~AbstractFactory()=0;
    virtual AbstractProductA* CreateProductA()=0;
    virtual AbstractProductB* CreateProductB()=0;
protected:
    AbstractFactory();
};

//ConcreteFactory1， ， AbstractFactory
// ， A B 
class ConcreteFactory1:public AbstractFactory
{
public:
    ConcreteFactory1();
    ~ConcreteFactory1();
    virtual AbstractProductA* CreateProductA();
    virtual AbstractProductB* CreateProductB();
};

//ConcreteFactory2， ， AbstractFactory
// ， A B 
class ConcreteFactory2:public AbstractFactory
{
public:
    ConcreteFactory2();
    ~ConcreteFactory2();
    virtual AbstractProductA* CreateProductA();
    virtual AbstractProductB* CreateProductB();
};

#endif

#include "Product.h"
#include <iostream>

using namespace std;

//AbstractProductA
AbstractProductA::AbstractProductA()
{
    cout << "AbstractProductA..." << endl;
}

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

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

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

void ProductA1::operation()
{}

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

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

void ProductA2::operation()
{}

//AbstractProductB
AbstractProductB::AbstractProductB()
{
    cout << "AbstractProductB..." << endl;
}

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

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

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

void ProductB1::operation()
{}

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

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

void ProductB2::operation()
{}

#include "Factory.h"
#include "Product.h"
#include <iostream>

using namespace std;

AbstractFactory::AbstractFactory()
{
    cout << "AbstractFactory..." << endl;
}

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

ConcreteFactory1::ConcreteFactory1()
{
    cout << "ConcreteFactory1..." << endl;
}

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

AbstractProductA* ConcreteFactory1::CreateProductA()
{
    return new ProductA1();
}

AbstractProductB* ConcreteFactory1::CreateProductB()
{
    return new ProductB1();
}

ConcreteFactory2::ConcreteFactory2()
{
    cout << "ConcreteFactory2..." << endl;
}

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

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

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

#include <iostream>
#include "Factory.h"
#include "Product.h"

using namespace std;

int main()
{
    AbstractFactory* fa1 = new ConcreteFactory1();
    AbstractProductA* a1 = fa1->CreateProductA();
    AbstractProductB* b1 = fa1->CreateProductB();

    cout << endl;
    AbstractFactory* fa2 = new ConcreteFactory2();
    AbstractProductA* a2 = fa2->CreateProductA();
    AbstractProductB* b2 = fa2->CreateProductB();

    cout << endl;
    delete fa1;
    delete a1;
    delete b1;

    cout << endl;
    delete fa2;
    delete a2;
    delete b2;

    return 0;
}