设计模式（c++）：抽象工厂模式

介绍

相比工厂方法模式抽象工厂方法模式对一类对象多同表现能够更好处理。
工厂方法模式适用于一个工厂生产一个产品需求（各子工厂生产产品零件）的需求，抽象工厂模式适用于一个工厂生产多个产品（一个产品族）的需求（子工厂能够生产不同型号的产品零件，每个子工厂能够生产一种型号的产品）。

概念

提供一个接口，让该接口负责创建一系列相关或者相互依赖的对象，儿无需指定他们具体的类。

示例

Father类（产品零件父类）

class Father
{
public:
	Father() :num(0) { num = 0; }
	Father(int number) :num(number) { cout << "Father::Father" << endl; }
	virtual ~Father() {}
protected:
	int num;
};

类（两种规格的零件A）

class A_Model_1 :public Father
{
public:
	A_Model_1() {}
	A_Model_1(int number) :Father(number) //调用父类构造函数
	{
		cout << "A_Model_1::A_Model_1" << endl;
	}
	virtual ~A_Model_1() {}
};

class A_Model_2 :public Father
{
public:
	A_Model_2() {}
	A_Model_2(int number) :Father(number) //调用父类构造函数
	{
		cout << "A_Model_2::A_Model_2" << endl;
	}
	virtual ~A_Model_2() {}
};

B类（两种规格的零件B）

class B_Model_1 :public Father
{
public:
	B_Model_1() {}
	B_Model_1(int number) :Father(number) //调用父类构造函数
	{
		cout << "B_Model_1::B_Model_1" << endl;
	}
	virtual~B_Model_1() {}
};

class B_Model_2 :public Father
{
public:
	B_Model_2() {}
	B_Model_2(int number) :Father(number) //调用父类构造函数
	{
		cout << "B_Model_2::B_Model_2" << endl;
	}
	virtual~B_Model_2() {}
};

FactoryFather类（工厂父类）

class FactoryFather
{
public:
	virtual ~FactoryFather() {};
	virtual Father* create_object_a() = 0;
	virtual Father* create_object_b() = 0;
};

FactoryModel1 类（生产类型I的产品零件）

class FactoryModel1 :public FactoryFather
{
public:
	virtual ~FactoryModel1() {};
	virtual Father* create_object_a()
	{
		Father* object = nullptr;
		cout << "FactoryModel1::create_object_a" << endl;
		object = new A_Model_1(10);
		/* 此处实现业务逻辑 */
		return object;
	}
	virtual Father* create_object_b()
	{
		Father* object = nullptr;
		cout << "FactoryModel1::create_object_b" << endl;
		object = new B_Model_1(10);
		/* 此处实现业务逻辑 */
		return object;
	}
};

FactoryModel2 类（生产类型II的产品零件）

class FactoryModel2 :public FactoryFather
{
public:
	virtual ~FactoryModel2() {};
	virtual Father* create_object_a()
	{
		Father* object = nullptr;
		cout << "FactoryModel2::create_object_a" << endl;
		object = new A_Model_2(100);
		/* 此处实现业务逻辑 */
		return object;
	}
	virtual Father* create_object_b()
	{
		Father* object = nullptr;
		cout << "FactoryModel2::create_object_b" << endl;
		object = new B_Model_2(100);
		/* 此处实现业务逻辑 */
		return object;
	}
};

main函数

int main()
{
	FactoryFather * factory_model1 = new FactoryModel1();
	FactoryFather * factory_model2 = new FactoryModel2();
	Father * a_mode1 = factory_model1->create_object_a();
	Father * b_mode1 = factory_model1->create_object_b();
	Father * a_mode2 = factory_model2->create_object_a();
	Father * b_mode2 = factory_model2->create_object_b();
	system("pause");
	return 0;
}

执行结果：

概念图