工厂模式

主要解决对象的创建问题

首先是简单工厂

只有一个工厂类，每次有新的产品就需要修改里面接口的内容，违反了封闭原则

//1、定义抽象产品类
class AbstractCar
{
public:
	AbstractCar() = default;
	virtual ~AbstractCar() = default;

	virtual void showName() = 0;
};

//2、实现具体的产品
class CarA :public AbstractCar
{
public:
	CarA() = default;
	~CarA() = default;

	//3、重写虚接口
	void showName()override
	{
		cout << "我是汽车A";
	}

};

class CarB :public AbstractCar
{
public:
	CarB() = default;
	~CarB() = default;

	//3、重写虚接口
	void showName()override
	{
		cout << "我是汽车B";
	}
};

//4、定义工厂类
class CarFactory
{
public:
	CarFactory() = default;
	~CarFactory() = default;

	//5、实现创建函数,根据不同的参数创建不同的产品
	static AbstractCar* createCar(string name)
	{
		if (name == "carA")
		{
			return new CarA;
		}
		else if(name=="carB")
		{
			return new CarB;
		}
		//后续有新的产品，这里就需要加代码，违反了封闭原则
	}
};



int main()
{
	//外部使用
	//创建汽车A，直接调用工厂的创建函数
	AbstractCar* carA = CarFactory::createCar("carA");

	//创建汽车B，直接调用工厂的创建函数
	AbstractCar* carB = CarFactory::createCar("carB");

	carA->showName();
	carB->showName();
	
	return 0;
}

然后是工厂模式

将工厂也抽象出来，以后有新的产品，则新加一个具体的工厂类就可以了，不用修改工厂类的代码 

//1、定义抽象产品类
class AbstractCar
{
public:
	AbstractCar() = default;
	virtual ~AbstractCar() = default;

	virtual void showName() = 0;
};

//2、实现具体的产品
class CarA :public AbstractCar
{
public:
	CarA() = default;
	~CarA() = default;

	//3、重写虚接口
	void showName()override
	{
		cout << "我是汽车A";
	}

};

class CarB :public AbstractCar
{
public:
	CarB() = default;
	~CarB() = default;

	//3、重写虚接口
	void showName()override
	{
		cout << "我是汽车B";
	}
};

//4、定义抽象工厂类
class AbstractCarFactory
{
public:
	AbstractCarFactory() = default;
	virtual ~AbstractCarFactory() = default;

	//5、定义创建接口
	virtual AbstractCar* createCar() = 0;
};

//6、具体的工厂,生产A汽车
class CarAFactory:public AbstractCarFactory
{
public:
	CarAFactory() = default;
	~CarAFactory() = default;

	AbstractCar* createCar() override
	{
		return new CarA;
	}
};

//生产B汽车
class CarBFactory :public AbstractCarFactory
{
public:
	CarBFactory() = default;
	~CarBFactory() = default;

	AbstractCar* createCar() override
	{
		return new CarB;
	}
};

//.........需要生产新的车 则继续继承重写添加新的工厂，不用修改原来的代码




int main()
{
	//外部使用
	//A工厂生产汽车A
	CarAFactory a;
	AbstractCar* carA = a.createCar();

	//B工厂生产汽车B
	CarBFactory b;
	AbstractCar* carB = b.createCar();

	carA->showName();
	carB->showName();


	delete carA;
	delete carB;


	return 0;
}