C++实现工厂模式

什么是设计模式

设计模式是一套被多数人知晓, 被大家反复使用的一种代码设计经验的总结, 在写代码的时候合理的运用设计模式,可以使自己的代码的可读性变得更高, 也可以增强代码的复用性

工厂模式

工厂模式是创建性模式的一种, 工厂模式是一个系列 : 其中包括了, 简单工厂模式, 工厂方法模式以及抽象工厂模式.
工厂模式的特点在于将对象的创建于使用区分开来, 使用工厂类来创建用户所需要的对象.

简单工厂模式

简单工厂模式也叫静态工厂模式, 他是通过一个静态的工厂接口, 使用户达到创建自己所需要的对象.

简单工厂模式包含了三个重要的组成部分:

1. 抽象产品
2. 具体产品类
3. 工厂类

接下来用汽车品牌的例子来体现简单工厂模式.

//定义抽象产品类
class MyCar{
public:
	virtual string CarName() = 0;
};
//定义具体产品类
class BMWCAR:public MyCar{
public:
	BMWCAR(){
		cout << "creater BMW success" << endl;
	}
	string CarName(){
		return "BMWCar";
	}
};
class BanzCAR :public MyCar{
public:
	BanzCAR(){
		cout << "creater Banz success" << endl;
	}
	string CarName(){
		return "BanzCar";
	}
};

class BYDCAR:public MyCar{
public:
	BYDCAR(){
		cout << "creater BYD success" << endl;
	}
	string CarName(){
		return "BYDCAR";
	}
};
//定义工厂类
class Factory{
public:
	enum CAR{
		BMWCar,
		BanzCar,
		BYDCar
	};
	static MyCar* CreatCar(CAR type){
		MyCar* ptr = nullptr;
		switch (type)
		{
		case CAR::BMWCar:
			ptr = new BMWCAR();
			
			break;
		case CAR::BanzCar:
			ptr = new BanzCAR();
			
			break;
		case CAR::BYDCar:
			ptr = new BYDCAR();
			
			break;
		default:
			break;
		}
		return ptr;
	}
};

• 优点 : 客户端不用关心产品的创建过程等, 只需要向其提供一个自己所需要的对象参数,即可获得.
• 缺点 : 每一次要添加新产品的时候, 都需要手动在代码中进行添加,违背OPC(开放封闭原则)
• 使用场景 : 适用于产品对象少的情况

工厂方法模式

工厂方法模式是对简单工厂模式的一次升级, 他解决了简单工厂模式违背开放封闭原则的问题, 他在原有的基础上,有加了一个抽象工厂类, 每一个具体工厂都需要对抽象工厂类进行实现.

简单工厂模式包含了四个重要的组成部分:

1. 抽象产品
2. 具体产品类
3. 抽象工厂类
4. 工厂类

接下来用汽车品牌的例子来体现简单工厂模式.

class MyCar{
public:
	virtual string CarName() = 0;
};

class BMWCAR :public MyCar{
public:
	BMWCAR(){
		cout << "creater BMW success" << endl;
	}
	string CarName(){
		return "BMWCar";
	}
};

class BanzCAR :public MyCar{
public:
	BanzCAR(){
		cout << "creater Banz success" << endl;
	}
	string CarName(){
		return "BanzCar";
	}
};

class BYDCAR :public MyCar{
public:
	BYDCAR(){
		cout << "creater BYD success" << endl;
	}
	string CarName(){
		return "BYDCAR";
	}
};

//定义抽象工厂类
class CreateFactory{
public:
	virtual MyCar* creatercar() = 0;
};

//具体工厂的定义
class Create_BMW_Factory: public CreateFactory{
	MyCar* creatercar(){
		return new BMWCAR();
	}
};

class Create_Banz_Factory : public CreateFactory{
	MyCar* creatercar(){
		return new BanzCAR();
	}
};
class Create_BYD_Factory : public CreateFactory{
	MyCar* creatercar(){
		return new BYDCAR();
	}
};



int main(){
	CreateFactory* ptr = new Create_Banz_Factory;
	ptr->creatercar();
	delete ptr;
	ptr = new Create_BYD_Factory;
	ptr->creatercar();
	delete ptr;

	ptr = new Create_BMW_Factory;
	ptr->creatercar();
	delete ptr;

	system("pause");
	return 0;
}

• 优点 : 不仅解决了到哪里工厂模式违背开放封闭原则的问题, 该保留了封装创建过程的优点降低了工厂的耦合性
• 缺点 : 每增加一个产品,就绪定义一个创建该产品工厂的类,增加了额外的开发量.
• 使用场景 : 对于某个产品，调用者清楚地知道应该使用哪个具体工厂服务，实例化该具体工厂，生产出具体的产品来。

抽象工厂模式

抽象工厂模式是工厂模式中最抽象也是最一般使用的一种实现方法, 它指向用户一共一个接口, 客户端只需要传入自己所需要的产品的工厂即可, 它包含了多个抽象产品与多个抽象工厂, 在获取产品的时候,调用创建工厂的函数,先创建工厂,之后在创建所需要的产品.

组成部分

1. 多个抽象产品
2. 多个具体产品
3. 一个抽象工厂
4. 多个具体工厂

下面通过在不同的工厂中获取不同品牌的汽车与自行车的例子来实现该方法

//创建抽象产品类
class MyCar{
public:
	virtual string CarName() = 0;
};

class MyBike{
public:
	virtual string BikeName() = 0;
};

//创建汽车具体产品
class BMWCAR : public MyCar{
public:
	//宝马汽车
	string CarName(){
		return "BMWCAR";
	}
};

class BanzCAR : public MyCar{
public:
	//奔驰汽车
	string CarName(){
		return "BanzCAR";
	}
};

class BYDCAR : public MyCar{
public:
	//比亚迪汽车
	string CarName(){
		return "BYDCAR";
	}
};


//创建自行车集体产品
class BMWBike : public MyBike{
public:
	//宝马自行车
	string BikeName(){
		return "BMWBike";
	}
};

class BanzBike : public MyBike{
public:
	//奔驰自行车
	string BikeName(){
		return "BanzBike";
	}
};

class BYDBike : public MyBike{
public:
	//比亚迪自行车
	string BikeName(){
		return "BYDBike";
	}
};


class BMWFactory;
//创建抽象工厂
class Factory{
public:
	enum Factory_Type{
		BMWFACTORY,
		BanzFACTORY,
		BYDFACTORY
	};
	virtual MyCar* creatercar()=0 ;
	virtual MyBike* createrbike()=0 ;

	static Factory* createrfactory(Factory_Type type);
};

class BMWFactory :public Factory{
public:
	MyCar* creatercar(){
		MyCar* ptr = nullptr;
		ptr = new BMWCAR();
		return ptr;
	}

	MyBike* createrbike(){
		MyBike* ptr = nullptr;
		ptr = new BMWBike();
		return ptr;
	}
};
class BanzFactory :public Factory{
	MyCar* creatercar(){
		MyCar* ptr = nullptr;
		ptr = new BanzCAR();
		return ptr;
	}

	MyBike* createrbike(){
		MyBike* ptr = nullptr;
		ptr = new BanzBike();
		return ptr;
	}
};
class BYDFactory :public Factory{
	MyCar* creatercar(){
		MyCar* ptr = nullptr;
		ptr = new BYDCAR();
		return ptr;
	}

	MyBike* createrbike(){
		MyBike* ptr = nullptr;
		ptr = new BYDBike();
		return ptr;
	}
};

Factory* Factory::createrfactory(Factory_Type type){
	Factory* ptr = new BMWFactory();
	switch (type){
	case Factory_Type::BMWFACTORY:
		ptr = new BMWFactory();
		break;
	case Factory_Type::BanzFACTORY:
		ptr = new BanzFactory();
		break;
	case Factory_Type::BYDFACTORY:
		ptr = new BYDFactory();
		break;
	default:
		break;
	}
	return ptr;
}



int main(){
	Factory* ptr = Factory::createrfactory(Factory::Factory_Type::BMWFACTORY);
	cout << ptr->creatercar()->CarName() << endl;
	cout << ptr->createrbike()->BikeName() << endl;
	cout << endl;
	ptr = Factory::createrfactory(Factory::Factory_Type::BanzFACTORY);
	cout << ptr->creatercar()->CarName() << endl;
	cout << ptr->createrbike()->BikeName() << endl;
	cout << endl;
	ptr = Factory::createrfactory(Factory::Factory_Type::BYDFACTORY);
	cout << ptr->creatercar()->CarName() << endl;
	cout << ptr->createrbike()->BikeName() << endl;
	cout << endl;
	system("pause");
	return 0;
}

• 优点 : 不需要用户手动创建工厂, 只需要传入需要的产品的工厂名称参数, 之后调用创建工厂的接口即可, 还实现了一个工厂中不同产品的创建