工厂模式介绍

借鉴：(29条消息) C++设计模式 - 简单工厂，工厂方法和抽象工厂_大秦坑王的博客-优快云博客https://blog.youkuaiyun.com/QIANGWEIYUAN/article/details/88792594

简单工厂 simple factory ：

        所有对象的创建不再通过new类名称的方式进行了，而是把对象的创建都封装在了SimpleFactory类的create方法中，事先传入一个设计好的枚举类型，然后返回一个对应的对象。

        把对象的创建封装在一个接口函数中，通过传入不同的标识，返回创建的对象，客户不用自己负责new对象，不用了解对象创建的详细过程。

#include<iostream>
#include<string>
#include<memory>

using namespace std;

class Car
{
public:
	Car(string name) : _name(name){}
	virtual void show() = 0;
protected:
	string _name;
};

class Bmw : public Car
{
public:
	Bmw(string name) : Car(name) {}
	void show()
	{
		cout << "获取了一辆宝马汽车: " << _name << endl;
	}
};

class Audi : public Car
{
public:
	Audi(string name) : Car(name) {}
	void show()
	{
		cout << "获取了一辆奥迪汽车: " << _name << endl;
	}
};

enum CarType
{
	BMW, AUDI
};

class SimpleFactory
{
public:
	Car* createCar(CarType ct)
	{
		switch (ct)
		{
		case BMW:
			return new Bmw("X1"); 
		case AUDI:
			return new Audi("A6");
		default:
			cerr << "传入工厂的参数不正确：" << ct << endl;
			break;
		}
		return nullptr;
	}
};

int main()
{
	unique_ptr<SimpleFactory> factory (new SimpleFactory());
	unique_ptr<Car> p1 (factory->createCar(BMW));
	unique_ptr<Car> p2 (factory->createCar(AUDI));

	p1->show();
	p2->show();

	return 0;
}

提供创建对象实例的接口函数不闭合，不能对修改关闭。

工厂方法 factory method：

        factory基类，提供了一个纯虚函数（创建产品），定义派生类（具体产品的工厂）负责创建对应的产品，可以做到不同产品在不同工厂里面创建，能够对现有工厂以及产品的修改关闭。

#include<iostream>
#include<string>
#include<memory>

using namespace std;

class Car
{
public:
	Car(string name) : _name(name){}
	virtual void show() = 0;
protected:
	string _name;
};

class Bmw : public Car
{
public:
	Bmw(string name) : Car(name) {}
	void show()
	{
		cout << "获取了一辆宝马汽车: " << _name << endl;
	}
};

class Audi : public Car
{
public:
	Audi(string name) : Car(name) {}
	void show()
	{
		cout << "获取了一辆奥迪汽车: " << _name << endl;
	}
};

//工厂方法
class Factory
{
public:
	virtual Car* createCar(string name) = 0; //工厂方法
};

//宝马工厂
class BMWFactory : public Factory
{
public:
	Car* createCar(string name)
	{
		return new Bmw(name);
	}
};
//奥迪工厂
class AUDIFactory : public Factory
{
public:
	Car* createCar(string name)
	{
		return new Audi(name);
	}
};
int main()
{
	unique_ptr<Factory> bmwfty(new BMWFactory());
	unique_ptr<Factory> audifty(new AUDIFactory());
	unique_ptr<Car> p1(bmwfty->createCar("X6"));
	unique_ptr<Car> p2(audifty->createCar("A8"));
	p1->show();
	p2->show();

}

        实际上，很多产品是有关联关系的，属于一个产品簇，不应该放在不同的工厂里面去创建，这样一是不符合实际的产品对象创建逻辑，二是工厂类太多! 不好维护

抽象工厂 abstract factory：

把有关联关系的，属于一个产品簇的所有产品创建的接口函数，放在一个抽象工厂里面，派生类（具体产品工厂）负责生产整个产品簇里面所有的产品。

#include<iostream>
#include<string>
#include<memory>

using namespace std;

//系列产品1
class Car
{
public:
	Car(string name) : _name(name){}
	virtual void show() = 0;
protected:
	string _name;
};

class Bmw : public Car
{
public:
	Bmw(string name) : Car(name) {}
	void show()
	{
		cout << "获取了一辆宝马汽车: " << _name << endl;
	}
};

class Audi : public Car
{
public:
	Audi(string name) : Car(name) {}
	void show()
	{
		cout << "获取了一辆奥迪汽车: " << _name << endl;
	}
};

//系列产品2 
class Light
{
public:
	virtual void show() = 0;
};

class BmwLight : public Light
{
public:
	void show() { cout << "BMW light!" << endl; }
};

class AudiLight : public Light
{
public:
	void show() { cout << "Audi light!" << endl; }
};

//抽象工厂
class AbstractFactory
{
public:
	virtual Car* createCar(string name) = 0; //工厂方法 创建汽车
	virtual Light* createCarLight() = 0; //工厂方法 创建汽车关联的产品 车灯
};

//宝马工厂
class BMWFactory : public AbstractFactory
{
public:
	Car* createCar(string name)
	{
		return new Bmw(name);
	}
	Light* createCarLight() {
		return new BmwLight();
	}
};
//奥迪工厂
class AUDIFactory : public AbstractFactory
{
public:
	Car* createCar(string name)
	{
		return new Audi(name);
	}
	Light* createCarLight() {
		return new AudiLight(); 
	}
};
int main()
{
	unique_ptr<AbstractFactory> bmwfty(new BMWFactory());
	unique_ptr<AbstractFactory> audifty(new AUDIFactory());
	unique_ptr<Car> p1(bmwfty->createCar("X6"));
	unique_ptr<Car> p2(audifty->createCar("A8"));
	unique_ptr<Light> l1(bmwfty->createCarLight());
	unique_ptr<Light> l2(audifty->createCarLight());


	p1->show();
	l1->show();
	p2->show();
	l2->show();

}

总的来说：

        简单工厂模式：所有对象的创建封装在一个工厂类中，通过事先定义好的类型枚举，使用时只需要提供类请求对象即可；

        工厂方法模式：对象的创建交给具体的子类工厂来实现，工厂类提供一个纯虚函数；

        抽象工厂模式：相关的对象封装在一个工厂中。