设计模式之抽象工厂模式

意图

提供一个创建一系列相关或相关依赖对象的接口，而无需指定它们具体的类。

举例说明

生产一辆车，需要车身上的各种零件。
为了简便说明，假设生产一辆车只需要轮胎和方向盘，并且它们必须要相互匹配才能够使车辆正常运行，所以轮胎和方向盘之间具有依赖关系。就是说车辆A只能使用轮胎A和方向盘A才能正常运行，如果使用轮胎A和方向盘B就无法正常运行。

代码

#include <iostream>
using namespace std;

// 轮胎产品 
class TyreProduct{
};
//轮胎A 
class TyreA: public TyreProduct{
	public:
		TyreA(){
			cout << "轮胎A" << endl;
		}		
};

//轮胎B 
class TyreB: public TyreProduct{
	public:
		TyreB(){
			cout << "轮胎B" << endl;
		}
};

// 方向盘产品 
class WheelProduct{
	
}; 

// 方向盘A 
class WheelA:public WheelProduct{
	public:
		WheelA(){
			cout << "方向盘A" << endl;
		}
}; 

// 方向盘B 
class WheelB: public WheelProduct{
	public:
		WheelB(){
			cout << "方向盘B" << endl;
		}
};

// 抽象工厂，生产轮胎和方向盘 
class Factory{
	public:
		virtual TyreProduct* CreateTyre() = 0;
		virtual WheelProduct* CreateWheel() = 0;
}; 

// 工厂A,只生产A车辆品牌的方向盘和轮胎 
class CarAFactory:public Factory{
	public:
		virtual TyreProduct* CreateTyre(){
			return new TyreA();
		}
		virtual WheelProduct* CreateWheel(){
			return new WheelA();
		}
};

// 工厂B,只生产B车辆品牌的方向盘和轮胎 
class CarBFactory:public Factory{
	public:
		virtual TyreProduct* CreateTyre(){
			return new TyreB();
		}
		virtual WheelProduct* CreateWheel(){
			return new WheelB();
		}
};

// 商家 
class CarBusiness{
	private:
		Factory *factory;
	public:
		CarBusiness(Factory *factory):factory(factory){}
		void CreateCar(){
			cout << "开始生产车辆" << endl;
			factory->CreateTyre();
			factory->CreateWheel();
			cout << "车辆生产完毕" << endl << endl;
		} 
};

int main(void) 
{
	// 生产CarA
	Factory* carAFactory = new CarAFactory();
	CarBusiness* businessA = new CarBusiness(carAFactory); 
	businessA->CreateCar();
	
	// 生产CarB
	Factory* carBFactory = new CarBFactory();
	CarBusiness* businessB = new CarBusiness(carBFactory); 
	businessB->CreateCar();
	return 0;
}

结果如下