AbstractFactory模式

在软件系统中，经常面临“一系列相互依赖的对象”的创建工作，同时由于需求的变化，往往存在更多的系列的对象的创建工作。
定义一个接口，让该接口负责创建的一系列“相关或者相互依赖的对象”，不需要指定它们具体的类。如果没有应对“对系列对象构建”的需求的变化，就没必要用AbstractFactory模式，可以使用简单工厂模式。其中系列对象是指的某一特定系列下对象之间相互依赖的关系。
AbstractFactory模式用来解决：
应对“新系列”需求的变动，要创建一组相关或者相互依赖的对象。
AbstractFactory模式关键是：
将一组对象的创建封装到一个用于创建对象的类中，这样维护一个创建类比维护N个相关对象创建过程简单。
优点：
当要创建一组对象的时候，只需要维护一个创建对象，简化维护成本和工作。
AbstractFactory模式和FactoryMethod模式区别：
AbstractFactory模式用于创建一组相关或者依赖的对象提供创建接口，FactoryMethod模式用于一类对象提供接口或者延迟对象的创建到子类中实现。
缺点：
难以应对“新对象”的需求变动。

Product.h

#pragma once
class AbstractProductA {
public:
	virtual ~AbstractProductA();
protected:
	AbstractProductA();
};
class AbstractProductB {
public:
	virtual ~AbstractProductB();
protected:
	AbstractProductB();
};
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();
};

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

}

Factory.h

#pragma once
class AbstractProductA;
class AbstractProductB;
class AbstractFactory {
public:
	virtual ~AbstractFactory();
	virtual AbstractProductA* CreateProductA() = 0;
	virtual AbstractProductB* CreateProductB() = 0;
protected:
	AbstractFactory();
};
class CreateFactory1 :public AbstractFactory {
public:
	CreateFactory1();
	~CreateFactory1();
	AbstractProductA* CreateProductA();
	AbstractProductB* CreateProductB();
};
class CreateFactory2 :public AbstractFactory {
public:
	CreateFactory2();
	~CreateFactory2();
	AbstractProductA* CreateProductA();
	AbstractProductB* CreateProductB();
};

Factory.cpp

#include"Factory.h"
#include"Product.h"
AbstractFactory::AbstractFactory() {

}
AbstractFactory::~AbstractFactory() {

}
CreateFactory1::CreateFactory1() {

}
CreateFactory1::~CreateFactory1() {

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

}
CreateFactory2::~CreateFactory2() {

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

main.cpp

#include"Product.h"
#include"Factory.h"
#include<iostream>
using namespace std;
int main() {
	AbstractFactory* fac1 = new CreateFactory1();
	fac1->CreateProductA();
	fac1->CreateProductB();
	AbstractFactory* fac2 = new CreateFactory2();
	fac2->CreateProductA();
	fac2->CreateProductB();
	return 0;
}

运行结果图