工厂模式

简单工厂模式

    根据参数的不同返回不同的实例。当你需要什么只需要传一个正确的参数，就可以获取你所需要的对象，无需知道创建细节
1、能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。
2、这个类的职责过重，如果发生意外，会影响到很多使用这个工厂的模块
3、当系统中的具体产品类不断增多时候，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；

#include <iostream>
#include <string>

class Product
{
public:
	Product(std::string name):mname(name){}
	virtual void operation()=0;
	virtual ~Product(){}
protected:
	std::string mname;
};
class ProductA:public Product
{
public:
	ProductA(std::string name):Product(name){}
	virtual void operation()
	{
		std::cout<<"this is a "<<mname<<std::endl;
	}
};

class ProductB:public Product
{
public:
	ProductB(std::string name):Product(name){}
	virtual void operation()
	{
		std::cout<<"this is a "<<mname<<std::endl;
	}
};

class Factory
{
public:
	Product* createProduct(int flag)
	{
		switch(flag)
		{
		case 1:
			return new ProductA("A");
			break;
		case 2:
			return new ProductB("B");
			break;
		default:
			break;
		}
	}
};

int main()
{
	Factory f;
	Product* pp = f.createProduct(2);
	pp->operation();//动多态
	delete pp;
	return 0;
}

工厂方法模式

一个产品一个工厂生产
    在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做。该核心类成为一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。
    缺点：增加产品时，类的个数成倍增加，导致类越来越多，增加维护成本
    优点：符合开闭原则

#include <iostream>
#include <string>

class Product
{
public:
	Product(std::string name):mname(name){}
	virtual void operation()=0;
	virtual ~Product(){}
protected:
	std::string mname;
};

class ProductA:public Product
{
public:
	ProductA(std::string name):Product(name){}
	virtual void operation()
	{
		std::cout<<"this is a "<<mname<<std::endl;
	}
};

class ProductB:public Product
{
public:
	ProductB(std::string name):Product(name){}
	virtual void operation()
	{
		std::cout<<"this is a "<<mname<<std::endl;
	}
};

class Factory
{
public:
	virtual Product* createProduct()=0;
	virtual ~Factory(){}
};

class FactoryA:public Factory
{
public:
	Product* createProduct()
	{
		return new ProductA("A");
	}
};

class FactoryB:public Factory
{
public:
	Product* createProduct()
	{
		return new ProductB("B");
	}
};

class ProductC:public Product
{
public:
	ProductC(std::string name):Product(name){}
	virtual void operation()
	{
		std::cout<<"this is a "<<mname<<std::endl;
	}
};

class FactoryC:public Factory
{
public:
	Product* createProduct()
	{
		return new ProductC("C");
	}
};

int main()
{
	Factory *pf=new FactoryC();
	Product* pp = pf->createProduct();
	pp->operation();

	delete pf;
	delete pp;
	return 0;
}

抽象工厂模式

    抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。
产品族
    是指位于不同产品等级结构中，功能相关联的产品组成的家族。一般是位于不同的等级结构中的相同位置上。
    工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结构。

#include <iostream>
#include <string>

class ProductA
{
public:
	ProductA(std::string name):mname(name){}
	virtual void operation()=0;
	virtual ~ProductA(){}
protected:
	std::string mname;
};

class ProductA1:public ProductA
{
public:
	ProductA1(std::string name):ProductA(name){}
	virtual void operation()
	{
		std::cout<<"this is a "<<mname<<std::endl;
	}
};

class ProductA2:public ProductA
{
public:
	ProductA2(std::string name):ProductA(name){}
	virtual void operation()
	{
		std::cout<<"this is a "<<mname<<std::endl;
	}
};

class ProductB
{
public:
	ProductB(std::string name):mname(name){}
	virtual void operation()=0;
	virtual ~ProductB(){}
protected:
	std::string mname;
};

class ProductB1:public ProductB
{
public:
	ProductB1(std::string name):ProductB(name){}
	virtual void operation()
	{
		std::cout<<"this is a "<<mname<<std::endl;
	}
};

class ProductB2:public ProductB
{
public:
	ProductB2(std::string name):ProductB(name){}
	virtual void operation()
	{
		std::cout<<"this is a "<<mname<<std::endl;
	}
};

class AbstractFactory
{
public:
	virtual ProductA* createProductA()=0;
	virtual ProductB* createProductB()=0;
	virtual ~AbstractFactory(){}
};

class Factory_1:public AbstractFactory
{
public:
	ProductA* createProductA()
	{
		return new ProductA1("A1");
	}
	ProductB* createProductB()
	{
		return new ProductB1("B1");
	}
};

class Factory_2:public AbstractFactory
{
public:
	ProductA* createProductA()
	{
		return new ProductA2("A2");
	}
	ProductB* createProductB()
	{
		return new ProductB2("B2");
	}
};

int main()
{
	AbstractFactory *paf=new Factory_2();
	ProductA* pa = paf->createProductA();
	ProductB* pb = paf->createProductB();
	pa->operation();
	pb->operation();

	delete paf;
	delete pa;
	delete pb;
	return 0;
}