C++实现工厂模式及解析

工厂模式

1 工厂方法模式

1.1 定义以及作用

通过定义工厂父类负责定义创建对象的公共接口，而子类则负责生成具体的对象。工厂方法使一个类的实例化延迟到其子类，即由子类来决定应该实例化（创建）哪一个类

1.2 特点

• 克服了简单工厂的缺点：违背了开放-封闭原则的缺点
• 工厂方法模式将具体产品的创建推迟到工厂类的子类（具体工厂）中，工厂父类不在负责所有产品的创建，而只是给出具体工厂必须实现的接口。工厂方法模式集中封装了对象的创建，使得更换对象时，不需要做大的改动即可实现，可看下面的例子。符合开放封闭原则，克服了简单工厂模式的缺点

1.3 UML类图

工厂方法模式UML类图如下：

1.4 步骤流程

步骤1：创建抽象产品类 ，定义具体产品的公共接口；
步骤2：创建具体产品类（继承抽象产品类）， 定义生产的具体产品；
步骤3：创建抽象工厂类，定义具体工厂的公共接口；
步骤4：创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例方法；
步骤5：客户端通过调用具体工厂类的方法，从而创建不同具体产品类的实例

1.5 代码实现

背景：假设某大型工厂（抽象工厂类）承接汽车（抽象产品类）组装，其任务为根据客户图纸要求组装对应的汽车。其子工厂A（具体工厂类）组装A型汽车（具体产品类），子工厂B（具体工厂类）组装B型汽车（具体产品类），对应不同客户的要求，去不同的工厂组装，即下面Factory *factory = new ConcreteFactoryB()的改变。

C++实现代码如下:

// Product
// 创建抽象产品类，定义具体产品的公共接口
class Car {
public:
	virtual ~Car() { }
	virtual void Order() = 0;
};

//创建具体产品类（继承抽象产品类），定义生产的具体产品
class Car_A :public Car {
public:
	Car_A() {
		std::cout << "produce Car_A..." << endl;
	}
	void Order() {
		std::cout << "number of Car_A is 100..." << endl;
	}
	~Car_A() { }
};

class Car_B :public Car {
public:
	Car_B() {
		std::cout << "produce Car_B..." << endl;
	}
	void Order() {
		std::cout << "number of Car_B is 200..." << endl;
	}
	~Car_B() { }
};

// Factory
// 创建抽象工厂类，定义具体的工厂的公共接口
class Factory {
public:
	virtual Car* CreateProduct() = 0;
	virtual ~Factory() { }
protected:
	Factory() { }
};


//创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例方法
class ConcreteFactoryA :public Factory {
public:
	ConcreteFactoryA() {
		std::cout << "ConcreteFactory Produce Car_A..." << endl;
	}
	~ConcreteFactoryA() { }

	Car* CreateProduct() {
		return new Car_A();
	}
};

class ConcreteFactoryB :public Factory {
public:
	ConcreteFactoryB() {
		std::cout << "ConcreteFactory Produce Car_B..." << endl;
	}
	~ConcreteFactoryB() { }

	Car* CreateProduct() {
		return new Car_B();
	}
};

//test
int main() {
	//通过调用具体工厂类的方法，从而创建不同具体产品类的实例
	//客户不同的要求交给不同的工厂生产不同的汽车，这里改为工厂B即可生产B汽车
	Factory *factory = new ConcreteFactoryB();
	//生产汽车
	Car *car = factory->CreateProduct();
	//汽车订单的数量
	car->Order();

	delete factory;
	delete car;

	return 0;
}

2 抽象工厂模式

2.1 定义以及作用

提供一个创建一系列相关或相互依赖对象的接口，而无需指定其具体的类。具体的工厂（可理解为生产线）负责实现具体的产品实例。
抽象工厂模式与工厂方法模式的区别：抽象工厂中一个工厂有多条生产线可生产多种产品；而工厂方法一个工厂只能生产一种产品。

2.2 特点

客服了工厂方法模式中，每个工厂只能创建一类产品的缺点

2.3 UML类图

抽象工厂模式UML类图如下：

2.4 步骤流程

步骤1：创建抽象产品类 ，定义具体产品的公共接口；
步骤2：创建具体产品类（继承抽象产品类）， 定义生产的具体产品；
步骤3：创建抽象工厂类，定义具体产品的创建接口；
步骤4：创建具体工厂类（继承抽象工厂类），定义具体生产线生产具体的产品；
步骤5：客户端通过调用具体工厂类的不同生产线，从而创建不同具体产品类的实例

2.5 代码实现

背景：还是上例中的汽车组装工厂，考虑到扩建工厂的成本，周期长，一个工厂只能生产一种类型的汽车，效率较低（工厂方法的每个工厂只能创建一类产品的缺点），因此选择在工厂中增加生产线，即一个工厂可根据需要生产不同的汽车。

C++实现代码如下:

// Product
// 创建抽象产品类，定义具体产品的公共接口
class Car {
public:
	virtual ~Car() { }
	virtual void Order() = 0;
};

//创建具体产品类（继承抽象产品类），定义具体产品
class Car_A :public Car {
public:
	void Order() {
		std::cout << "number of Car_A is 100..." << endl;
	}
};

class Car_B :public Car {
public:
	void Order() {
		std::cout << "number of Car_B is 200..." << endl;
	}
};

// Factory
// 创建抽象工厂类，工厂中有多条生产线
class AbstractFactory {
public:
	virtual ~AbstractFactory() { }
	virtual Car* CreateCar_A() = 0;
	virtual Car* CreateCar_B() = 0;
};


//创建具体工厂类（继承抽象工厂类），定义具体生产线的生产具体的产品
class ConcreteFactory :public AbstractFactory {
public:
	Car* CreateCar_A() {
		return new Car_A();
	}

	Car* CreateCar_B() {
		return new Car_B();
	}
};


//test
int main() {
	//客户不同的要求交给工厂生产不同的汽车，**这里只有一个工厂**
	AbstractFactory *factory = new ConcreteFactory();
	//不同的生产线生产不同的汽车
	Car *car_A = factory->CreateCar_A();
	Car *car_B = factory->CreateCar_B();
	//汽车订单的数量
	car_A->Order();
	car_B->Order();

	delete factory;
	delete car_A;
	delete car_B;

	return 0;
}

工厂模式充分利用了C++面向对象编程的特点，使用类的封装、继承、多态的特点。降低了客户程序与产品对象的耦合。