AbstactFactory 模式（抽象工厂模式）

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 模式主要在于应对“ 新系列 ”的需求变动。其缺点在于难以应对“新对象”的需求变动