设计模式：工厂方法、抽象工厂

简单工厂

#include <string>
#include <iostream>
/*
简单工程 Simlpe Factory(不包含在23种设计模式中)
工程方法 Factory Method
抽象工程  Abstract Factory

工厂模式：主要时封装了对象的创建
*/

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

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

class Audi :public Car
{
public:
	Audi(std::string name) :Car(name)
	{
	}
	void show()
	{
		std::cout << "获取一辆奥迪汽车:" << m_name << std::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:
			std::cerr << "传入工厂的参数不正确:" << ct << std::endl;
			break;
		}
		return nullptr;
	}
};
int main()
{
	//如果直接new，相当调用方(购买者)需要知道怎么new(相当与要知道怎么制造),而现实中调用方(购买者）不需要理解怎么制造.
	//所以引入工厂，怎么制造交给工程制造。
	/*Car* p1 = new Bmw("X1");
	Car* p2 = new Audi("A6");*/

	SimpleFactory* factory = new SimpleFactory();
	Car* p1 = factory->createCar(BMW);
	Car* p2 = factory->createCar(AUDI);
	p1->show();
	p2->show();
	delete p1;
	delete p2;
	delete factory;
	return 0;
}

输出结果

获取一辆宝马汽车:X1
获取一辆奥迪汽车:A6

工厂方法

#include <string>
#include <iostream>
#include <memory>
/*
简单工程 Simlpe Factory(不包含在23种设计模式中)
工程方法 Factory Method
抽象工程  Abstract Factory

工厂模式：主要时封装了对象的创建
*/

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

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

class Audi :public Car
{
public:
	Audi(std::string name) :Car(name)
	{
	}
	void show()
	{
		std::cout << "获取一辆奥迪汽车:" << m_name << std::endl;
	}
};
enum CarType
{
	BMW,AUDI
};
//工厂方法
class Factory
{
public:
	virtual Car* createCar(std::string name) = 0;
};
//宝马工厂
class BMWFacatory :public Factory
{
public :
	Car* createCar(std::string name)
	{
		return new Bmw(name);
	}
};
//奥迪工厂
class AudiFactory :public Factory
{
public :
	Car* createCar(std::string name)
	{
		return new Audi(name);
	}
};
int main()
{
	Factory* bmwFactory = new BMWFacatory();
	Car* p1= bmwFactory->createCar("X1");
	p1->show();


	Factory* audiFactory = new AudiFactory();
	Car* p2 = audiFactory->createCar("A8");
	p2->show();
	delete p1;
	delete p2;
	delete bmwFactory;
	delete audiFactory;
	//工厂方法：
	//如需加入奔驰汽车。只需要加入奔驰工厂，不需改动要动宝马工厂和奥迪工厂。达到了开闭原则：达到了已有功能修改关闭，对扩展开放
	return 0;
}

输出结果：

获取一辆宝马汽车:X1
获取一辆奥迪汽车:A8

抽象工厂

#include <string>
#include <iostream>
#include <memory>
/*
简单工程 Simlpe Factory(不包含在23种设计模式中)
优点：把对象的创建封装在一个接口函数里面，通过传入不同的标识，返回创建的对象，客户不用自己负责new对象，不用了解对象创建的详细过程
缺点：提供创建对象实例的接口不闭合，不能对修改关闭  

工程方法 Factory Method
优点：Factory 基类提供了一个纯虚函数(创建产品）,定义派生类（具体产品的工厂)负责创建对应的产品，可以做到不同的产品，
     在不同的工厂里面的创建，能够对现有工程，以及产品的修改关闭
缺点:实际上，很多产品是有关联关系的，属于一个产品簇，不应该放在不同的工厂里面取创建，这样一是不符合实际的产品对象创建逻辑
     二是工厂类太多了，不好维护

抽象工程  Abstract Factory
优点：把关联关系的，属于一个产品簇的所有产品创建的接口函数，放在一个抽象工厂里面AbstractFactory，
      派生类（具体产品的工厂）应该负责创建该产品簇里面所有的产品
缺点：
     缺点：假设宝马工厂有一项奥迪工程没有的业务。那么在 AbstractFactory中添加一个新的工厂方法，奥迪工厂必须也要实现本来自己不做的业务。
工厂模式：主要时封装了对象的创建
*/

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

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

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

//系列产品2
class Light
{
public:
	virtual void show() = 0;
};
class BmwLight :public Light
{
public:
	void show()
	{
		std::cout << "BMW light!" << std::endl;
	}
};
class  AudiLight :public Light
{
public:
	void show()
	{
		std::cout << "Audi light" << std::endl;
	}
};
enum CarType
{
	BMW,AUDI
};

//抽象工厂(对有一组关联关系的产品簇提供产品对象的统一创建)
class AbstractFactory
{
public:
	virtual Car* createCar(std::string name) = 0;//工厂方法 创建汽车
	virtual Light* createCarLight() = 0;//工厂方法 创建汽车关联产品车灯
};
//宝马工厂
class BMWFacatory :public AbstractFactory
{
public :
	Car* createCar(std::string name)
	{
		return new Bmw(name);
	}
	Light* createCarLight()
	{
		return new BmwLight();
	}
};
//奥迪工厂
class AudiFactory :public AbstractFactory
{
public :
	Car* createCar(std::string name)
	{
		return new Audi(name);
	}
	Light* createCarLight()
	{
		return new AudiLight();
	}
};
int main()
{
	//现在考虑产品簇（有关联关系的系列产品），应放到同一个工厂中生产。
	//如果一个产品对应一个工厂将导致工厂类急剧增多，而抽象工厂
	
	AbstractFactory* bmwFactory = new BMWFacatory();
	Car* p1= bmwFactory->createCar("X1");
	Light* light1 = bmwFactory->createCarLight();
	p1->show();
	light1->show();


	AbstractFactory* audiFactory = new AudiFactory();
	Car* p2 = audiFactory->createCar("A8");
	Light* light2 = audiFactory->createCarLight();
	p2->show();
	light2->show();
	delete p1;
	delete light1;
	delete p2;
	delete light2;
	delete bmwFactory;
	delete audiFactory;	
	return 0;
}

输出结果

获取一辆宝马汽车:X1
BMW light!
获取一辆奥迪汽车:A8
Audi light