design pattern——abstract factory

model

implement

abstract product

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

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

AbstractProductA::AbstractProductA()
{
}

AbstractProductA::~AbstractProductA()
{
}

AbstractProductB::AbstractProductB()
{
}

AbstractProductB::~AbstractProductB()
{
}

concrete product

class ConcreteProductA1 : public AbstractProductA
{
public:
    ConcreteProductA1();
    ~ConcreteProductA1();
};

class ConcreteProductA2 : public AbstractProductA
{
public:
    ConcreteProductA2();
    ~ConcreteProductA2();
};

class ConcreteProductB1 : public AbstractProductB
{
public:
    ConcreteProductB1();
    ~ConcreteProductB1();
};

class ConcreteProductB2 : public AbstractProductB
{
public:
    ConcreteProductB2();
    ~ConcreteProductB2();
};

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

ConcreteProductA1::~ConcreteProductA1()
{
}

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

ConcreteProductA2::~ConcreteProductA2()
{
}

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

ConcreteProductB1::~ConcreteProductB1()
{
}

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

ConcreteProductB2::~ConcreteProductB2()
{
}

abstract factory

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

AbstractFactory::AbstractFactory()
{
}

AbstractFactory::~AbstractFactory()
{
}

concrete factory

class ConcreteFactoryA : public AbstractFactory
{
public:
    ConcreteFactoryA();
    ~ConcreteFactoryA();
    
public:
    AbstractProductA* CreateProductA();
    AbstractProductB* CreateProductB();
};

class ConcreteFactoryB : public AbstractFactory
{
public:
    ConcreteFactoryB();
    ~ConcreteFactoryB();
    
public:
    AbstractProductA* CreateProductA();
    AbstractProductB* CreateProductB();
};

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

ConcreteFactoryA::~ConcreteFactoryA()
{
}

AbstractProductA* ConcreteFactoryA::CreateProductA()
{
    return new ConcreteProductA1();
}

AbstractProductB* ConcreteFactoryA::CreateProductB()
{
    return new ConcreteProductB1;
}

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

ConcreteFactoryB::~ConcreteFactoryB()
{
}

AbstractProductA* ConcreteFactoryB::CreateProductA()
{
    return new ConcreteProductA2();
}

AbstractProductB* ConcreteFactoryB::CreateProductB()
{
    return new ConcreteProductB2();
}

应用

void abstractfactory_test()
{
    AbstractFactory* factoryA = new ConcreteFactoryA();
    AbstractProductA* productAA = factoryA->CreateProductA();
    AbstractProductB* productAB = factoryA->CreateProductB();
    
    AbstractFactory* factoryB = new ConcreteFactoryB();
    AbstractProductA* productBA = factoryB->CreateProductA();
    AbstractProductB* productBB = factoryB->CreateProductB();
}

总结

• 抽象：concrete productX的公共基类AbstractProductX进行了抽象，concrete factory的公共基类AbstractFactory进行了抽象
• 扩展：AbstractProductX种类可以进行扩展，每种AbstractProductX的concrete product可以进行扩展，concrete factory可以进行扩展
• 开发者不需要知道concrete productX和concrete factory，开发者只与公共基类AbstractProductX和公共基类AbstractFactory交互
• abstract factory pattern是对factory pattern的扩展，abstract factory pattern和factory pattern的主要区别是abstract factory pattern可以维护多种AbstractProductX，可以对concrete factory进行扩展，而factory pattern维护单种product，concrete factory唯一，无需扩展，因为product种类唯一