1、动机
在软件系统中，经常面临着“ 一系列相互依赖的对象 ”的创建工作；同时，由于需求的变化，往往存在更多系列对象的创建工作，如何应对这种变化，如何绕过常规的对象创建方法（new），提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？
2、定义
提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定它们具体的类
3、结构图
4、代码实现
#pragma once
#include <iostream>
#include <memory>
// 抽象产品A
class CAbstactProductA {
public:
virtual ~CAbstactProductA() {}
virtual void mvOperation() = 0;
};
// 具体产品A1
class CConcreteProductA1 : public CAbstactProductA {
public:
virtual ~CConcreteProductA1() {}
virtual void mvOperation() {
std::cout << __FUNCTION__ << std::endl;
}
};
// 具体产品A2
class CConcreteProductA2 : public CAbstactProductA {
public:
virtual ~CConcreteProductA2() {}
virtual void mvOperation() {
std::cout << __FUNCTION__ << std::endl;
}
};
// 抽象产品B
class CAbstactProductB {
public:
virtual ~CAbstactProductB() {}
virtual void mvOperation() = 0;
};
// 具体产品B1
class CConcreteProductB1 : public CAbstactProductB {
public:
virtual ~CConcreteProductB1() {}
virtual void mvOperation() {
std::cout << __FUNCTION__ << std::endl;
}
};
// 具体产品B2
class CConcreteProductB2 : public CAbstactProductB {
public:
virtual ~CConcreteProductB2() {}
virtual void mvOperation() {
std::cout << __FUNCTION__ << std::endl;
}
};
// 抽象工厂
class CAbstactFactory {
public:
virtual ~CAbstactFactory() {}
virtual CAbstactProductA* mopCreateProductA() = 0;
virtual CAbstactProductB* mopCreateProductB() = 0;
};
// 具体工厂1 : 生产产品A1/B1
class CConcreteFactory1 : public CAbstactFactory {
public:
virtual ~CConcreteFactory1() {}
virtual CAbstactProductA* mopCreateProductA() {
return new CConcreteProductA1;
}
virtual CAbstactProductB* mopCreateProductB() {
return new CConcreteProductB1;
}
};
// 具体工厂2 : 生产产品A2/B2
class CConcreteFactory2 : public CAbstactFactory {
public:
virtual ~CConcreteFactory2() {}
virtual CAbstactProductA* mopCreateProductA() {
return new CConcreteProductA2;
}
virtual CAbstactProductB* mopCreateProductB() {
return new CConcreteProductB2;
}
};
void mvTest() {
// 创建工厂1
CAbstactFactory* op_factory1 = new CConcreteFactory1;
std::unique_ptr<CAbstactFactory> up1(op_factory1);
// 生产产品A1/B1
CAbstactProductA* op_product_a1 = op_factory1->mopCreateProductA();
std::unique_ptr<CAbstactProductA> up2(op_product_a1);
op_product_a1->mvOperation();
CAbstactProductB* op_product_b1 = op_factory1->mopCreateProductB();
std::unique_ptr<CAbstactProductB> up3(op_product_b1);
op_product_b1->mvOperation();
// 创建工厂2
CAbstactFactory* op_factory2 = new CConcreteFactory2;
std::unique_ptr<CAbstactFactory> up4(op_factory2);
// 生产产品A2/B2
CAbstactProductA* op_product_a2 = op_factory2->mopCreateProductA();
std::unique_ptr<CAbstactProductA> up5(op_product_a2);
op_product_a2->mvOperation();
CAbstactProductB* op_product_b2 = op_factory2->mopCreateProductB();
std::unique_ptr<CAbstactProductB> up6(op_product_b2);
op_product_b2->mvOperation();
}
5、要点总结
如果没有应对“多系列对象构建”的需求变化，则没有必要使用 Abstract Factory 模式，这时候使用简单的工厂完全可以
“ 系列对象 ”指的是在某一特定系列下的对象之间有相互依赖或作用的关系，不同系列的对象之间不能互相依赖
Abstract Factory 模式主要在于应对“ 新系列 ”的需求变动。其缺点在于难以应对“新对象”的需求变动
