工厂模式

优秀的代码：业务逻辑和界面逻辑无耦合，简洁，可扩张性强

工厂模式有三种：简单工厂模式、工厂方法模式、抽象工厂模式。单看字面意思，感觉都是工厂，没什么不一样。下面我们一一说明不同的工厂模式的特点。首先，简单工厂模式，简单来讲就是用一个工厂类来实现需要的实例的创建过程。每增加一个产品类型，我们就需要在这个工厂类中添加相应产品的实例创建过程。这样讲有些抽象，下面我们用一个实例来进行说明，一家厂家生产不同型号的处理器，我们用A和B来表示不同的型号。他只有一家工厂来生产，故用户需要显示的给出需要那种型号的产品给工厂，工厂再进行生产。

#include<iostream>
#include<string>
using namespace std;

class  SingleCore
{
public:
	virtual void show() = 0;// { cout << "Single Core" << endl; };
};
class SingleCoreA:public SingleCore
{
public:
	void show(){ cout << "Single Core A" << endl; }
};

class SingleCoreB :public SingleCore
{
public:
	void show(){ cout << "Single Core B" << endl; }
};

class  OperationFactory
{
public:
	SingleCore* createOperation(string str)
	{
		if ("A" == str)
			return new SingleCoreA();
		if ("B" == str)
			return new SingleCoreB();
	}
};
//调用过程
int main()
{
       OperationFactory oper;//创建工厂对象
      oper.createOperation("A")->show();//工厂根据客户提供的产品型号，创建相应的实例
      system("pause");
      return 0;
}

简单工厂根据用户提供的产品型号动态生产了相应的产品，这样对于用户来说， 去除了与具体产品的依赖。但是如果随着发展，厂家的技术提升，又设计出了一种C型号的处理器，则在简单工厂模式中，我们需要修改创建实例的函数，为其添加一个if分支，这个违反了开放-封闭原则（ 代码可扩展，但是不能修改）。我们可使用工厂 方法 模式（Factory Method）进行修正，工厂方法模式，定义一个用于创建对象的接口，将类的实例化推迟到其之类中。也就是说，随着产品型号的增加，厂家决定为每一个型号的产品建立一个工厂，客户需要到选择特定的工厂来获取相应的型号产品，也就是工厂方法模式将简单工厂中的逻辑移交给了客户来选择。工厂方法的实现：

#include<iostream>
#include<string>
using namespace std;

class  SingleCore
{
public:
	virtual void show() = 0;// { cout << "Single Core" << endl; };
};
class SingleCoreA :public SingleCore
{
public:
	void show(){ cout << "Single Core A" << endl; }
};

class SingleCoreB :public SingleCore
{
public:
	void show(){ cout << "Single Core B" << endl; }
};

class SingleFactory
{
public:
	virtual SingleCore*createOper()= 0;
};
class SingleCoreAFactory :public SingleFactory
{
public:
	SingleCoreA* createOper()
	{
		return new SingleCoreA();
	}
};
class SingleCoreBFactory :public SingleFactory
{
public:
	SingleCoreB * createOper()
	{
		return new SingleCoreB();
	}
};
void main()
{
	SingleFactory *oper = new SingleCoreAFactory();//选择相应的工厂
	SingleCore  *co = oper->createOper();
	co->show();
	system("pause");
}

这样我们只需要用户来选择具体创建哪种产品的实例，不需要对业务逻辑进行修改。随着厂家规模的扩大，处理器的不同型号又出现单核和双核，多核。如果使用工厂方法，我们需要为每一种型号的每种核数的处理器创建一个工厂类，这样代码量过大，不简洁，对此种情况，我们可使用抽象工厂来实现，抽象工厂：提供了一个创建一系列相关或相互依赖对象的接口，无需指定他们具体的类。厂家现在能够生产A型号的单核和多核处理器，B型号的单核和多核处理器，故厂家决定建立2个工厂，一个工厂用来生产A型号的处理器，另一个则生产B型号的处理器

#include<iostream>
#include<string>
using namespace std;

class  SingleCore
{
public:
	virtual void show() = 0;// { cout << "Single Core" << endl; };
};
class  MultiCore
{
public:
	virtual void show() = 0;// { cout << "Single Core" << endl; };
};
class SingleCoreA :public SingleCore
{
public:
	void show(){ cout << "Single Core A" << endl; }
};

class SingleCoreB :public SingleCore
{
public:
	void show(){ cout << "Single Core B" << endl; }
};
class MultiCoreA :public MultiCore
{
public:
	void show(){ cout << "Multi Core A" << endl; }
};

class MultiCoreB :public MultiCore
{
public:
	void show(){ cout << "Multi Core B" << endl; }
};
class Factory
{
public:
	virtual SingleCore*createSingleOper() = 0;
	virtual MultiCore*createMultiOper() = 0;
};
class AFactory :public Factory
{
public:
	SingleCoreA* createSingleOper()
	{
		return new SingleCoreA();
	}
	MultiCore* createMultiOper()
	{
		return new MultiCoreA();
	}
};
class BFactory :public Factory
{
public:
	SingleCoreB * createSingleOper()
	{
		return new SingleCoreB();
	}
	MultiCore* createMultiOper()
	{
		return new MultiCoreB();
	}
};

void main()
{
	Factory *fac = new BFactory();
	MultiCore  *multi = fac->createMultiOper();
	multi->show();
	system("pause");
}

这样便于交换产品的系列。这个可用于访问不同的数据库上，我只需要修改创建的工厂，即可选择相应的处理器类型或者数据库。