常用设计模式之抽象工厂模式

抽象工厂模式：
抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。
应用场景：
当每个抽象产品都有多于一个的具体子类的时候，工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品角色都有两个具体产品。抽象工厂模式提供两个具体工厂角色，分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。
每一个模式都是针对一定问题的解决方案，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结构。
这里写图片描述
实现代码：

//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();
};
class ProductA2:public AbstractProductA
{
public:
    ProductA2();
    ~ProductA2();
};
class ProductB1:public AbstractProductB
{
public:
    ProductB1();
    ~ProductB1();
};
class ProductB2:public AbstractProductB
{
public:
    ProductB2();
    ~ProductB2();
};

#endif // PRODUCT_H

//Product.cpp

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

}

//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();
};
class ConcreteFactory1:public AbstractFactory
{
public:
    ConcreteFactory1();
    ~ConcreteFactory1();
    AbstractProductA* CreateProductA();
    AbstractProductB* CreateProductB();
};
class ConcreteFactory2:public AbstractFactory
{
public:
    ConcreteFactory2();
    ~ConcreteFactory2();
    AbstractProductA* CreateProductA();
    AbstractProductB* CreateProductB();
};

#endif // ABSTRACTFACTORY_H

//AbstractFactory.cpp

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

//Main.cpp

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

using namespace std;

int main(int argc, char *argv[])
{
    AbstractFactory* cf1 = new ConcreteFactory1();

    cf1->CreateProductA();
    cf1->CreateProductB();

    AbstractFactory* cf2 = new ConcreteFactory2();

    cf2->CreateProductA();
    cf2->CreateProductB();

    system("pause");
    return 0;
}

常用设计模式之抽象工厂模式

猜你喜欢