抽象工厂

#include <iostream>


class AbstractProductA
{
public:
    virtual ~AbstractProductA(){}
protected:
    AbstractProductA(){}
};

class AbstractProductB
{
public:
    virtual ~AbstractProductB(){}
protected:
    AbstractProductB(){}
};

class ProductA1:public AbstractProductA
{
public:
    ProductA1(){ std::cout << "ProductA1...."<< std::endl;}
    ~ProductA1(){}
};

class ProductA2:public AbstractProductA
{
public:
    ProductA2(){std::cout << "ProductA2...."<< std::endl;}
    ~ProductA2(){}
};
class ProductB1:public AbstractProductB
{
public:
    ProductB1(){std::cout << "ProductB1...."<< std::endl;}
    ~ProductB1(){}
};

class ProductB2:public AbstractProductB
{
public:
    ProductB2(){std::cout << "ProductB2...."<< std::endl;}
    ~ProductB2(){}
};

//-----------------------------------------------------------------

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


class CreateFactory1 : public AbstractFactory
{
public:
    CreateFactory1(){}
    ~CreateFactory1(){}

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

class CreateFactory2:public AbstractFactory
{
public:
    CreateFactory2(){}
    ~CreateFactory2(){}

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





int main()
{
    AbstractFactory *f1 = new CreateFactory1();

    f1->CreateProductA();
    f1->CreateProductB();

    AbstractFactory *f2 = new CreateFactory2();
    f2->CreateProductA();
    f2->CreateProductB();

    return 0;
}