抽象工厂模式（Abstract Factory），提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。
通常是在运行时刻在创建一个ConcreteFactory类的实例，这个具体的工厂再创建具有特定实现的产品对象，也就是说，为创建不同的产品对象，客户端应使用不同的具体工厂。
abstractproducta.h
#include <string>
class AbstracProductA
{
public:
AbstracProductA();
virtual ~AbstracProductA();
void Show();
virtual std::string Name();
};
class ConcreteProductA1 : public AbstracProductA
{
public:
ConcreteProductA1();
std::string Name() override;
};
class ConcreteProductA2 : public AbstracProductA
{
public:
ConcreteProductA2();
std::string Name() override;
};
abstractfactory.h
#include "abstracproducta.h"
#include "abstracproductb.h"
class AbstractFactory
{
public:
AbstractFactory();
virtual ~AbstractFactory();
virtual AbstracProductA* CreateProductA() = 0;
virtual AbstracProductB* CreateProductB() = 0;
};
class ConcreteFactory1 : public AbstractFactory
{
public:
ConcreteFactory1();
AbstracProductA* CreateProductA() override;
AbstracProductB* CreateProductB() override;
};
class ConcreteFactory2 : public AbstractFactory
{
public:
ConcreteFactory2();
AbstracProductA* CreateProductA() override;
AbstracProductB* CreateProductB() override;
};
main.cpp
#include <iostream>
#include "abstractfactory.h"
#include "abstracproducta.h"
#include "abstracproductb.h"
using namespace std;
int main()
{
AbstractFactory* factory1 = new ConcreteFactory1();
AbstracProductA* pA1 = factory1->CreateProductA();
AbstracProductB* pB1 =factory1->CreateProductB();
pA1->Show();
pB1->Show();
AbstractFactory* factory2 = new ConcreteFactory2();
AbstracProductA* pA2 = factory2->CreateProductA();
AbstracProductB* pB2 =factory2->CreateProductB();
pA2->Show();
pB2->Show();
return 0;
}
运行结果
抽象工厂模式的优点
模式的缺点
一个程序员如果从来没有熬夜写程序的经历，不能算是一个好程序猿，因为他没有痴迷过，所以他不会有大成就。
