设计模式

工作模式是由面向对象语言特性得来的固定模式，也就是套路。

其设计原则主要有：

OCP-开放封闭原则：开放扩展，封装更改；
LSP-里氏代换原则：子类必须能够替换其父类；
DIP-依赖倒转原则：抽象不应依赖细节，细节应依赖抽象（面向接口）；
ISP-接口隔离原则：一个类对另外一个类的依赖应当建立在最小的接口上；
CARP-合成/聚合复用原则：尽量使用合成/聚合，尽量不要使用继承（因继承是强偶合）；
LoD-迪米特法则：若两个类不必直接通信，则不应直接交互。成员该私有要私有；
SRP-单一职责原则：就一个类而言，应该仅有一个引起它变化的原因；

工作模式可以分为三大类，即：创建型模式，结构性模式和行为型模式；

这篇主要实现创建型模式中的工厂模式：

简单工厂模式：

#include <iostream>

using namespace std;

class Car				//产品模板类；
{
public:
	virtual void show() = 0;	//虚函数；
};

class BMW:public Car			//具体产品类，继承于产品模板；
{
	public:
	void show()
	{
		cout << "BWM" << endl;	//具体实现函数；
	}
};

class SLK:public Car
{
	public:
	void show()
	{
		cout << "SLK" << endl;
	}
};

class MINI:public Car
{
	public:
	void show()
	{
		cout << "MINI" << endl;
	}
};

class Factory				//工厂类
{
public:
	Car *GreatBMW()			//产品生产函数；
	{
		return new BMW;		//返回值为创建的产品对象；
	}
	
	Car *GreatSLK()
	{
		return new SLK; 
	}
	
	Car *GreatMINI()
	{
		return new MINI; 
	}

};

int main()
{
	Car *car = NULL;		//模板产品指针；
	Factory *f = new Factory;	//构造一个工厂指针指向工厂类，即创建一个工厂对象；

	car = f->GreatBMW();		//产品指针指向产品生产函数创建的具体产品对象；
	car->show();				
	delete car;		        //释放产品指针

	car = f->GreatSLK();
	car->show();
	delete car;
	
	car = f->GreatMINI();
	car->show();
	delete car;
	delete f;			//释放工厂指针；
	return 0;
}

简单工厂模式是由一个工程对象决定创建出哪种实例，即只有一个工厂，由工厂指针指向具体产品生产函数；

工厂方法模式：

#include <iostream>

using namespace std;

class Car
{
public:
	virtual void show() = 0;
};

class BMW:public Car
{
	public:
	void show()
	{
		cout << "BWM" << endl;
	}
};

class SLK:public Car
{
	public:
	void show()
	{
		cout << "SLK" << endl;
	}
};

class MINI:public Car
{
	public:
	void show()
	{
		cout << "MINI" << endl;
	}
};

class Factory					//生产工厂模板类；
{
public:
	virtual Car * Great() = 0;		//产品生产虚函数；
};

class BMWFactory:public Factory		        //具体产品工厂类；
{
public:
	Car *Great()
	{
		return new BMW;			//具体产品生产函数；
	}
};

class SLKFactory:public Factory
{
public:
	Car *Great()
	{
		return new SLK; 
	}
};
class MINIFactory:public Factory
{
public:
	Car *Great()
	{
		return new MINI; 
	}
};
int main()
{
	Car *car = NULL;
	Factory *f = NULL;
	
	f = new BMWFactory;		        //工厂指针指向创建的具体的产品工厂；
	car = f->Great();	                //产品指针指向产品生产函数；
	car->show();
	delete car;
	delete f;

	f = new SLKFactory;
	car = f->Great();
	car->show();
	delete car;
	delete f;
	
	f = new MINIFactory;
	car = f->Great();
	car->show();
	delete car;
	delete f;
	
	return 0;
}

工厂方法模式将原本的工厂类变成模板生产工厂类，具体的产品生产函数扩展为具体的产品生产工厂类便于，调用更加方便，增加产品时也不需要修改工厂类；

抽象工厂模式：

#include <iostream>

using namespace std;

class Fruit
{
public:
	virtual void show() = 0;
};

class Northapple:public Fruit
{
public:
	void show()
	{
		cout << "Northapple" << endl;
	}
};

class Northpeach:public Fruit
{
public:
	void show()
	{
		cout << "Northpeach" << endl;
	}
};

class Southapple:public Fruit
{
public:
	void show()
	{
		cout << "Southapple" << endl;
	}
};

class Southpeach:public Fruit
{
public:
	void show()
	{
		cout << "Southpeach" << endl;
	}
};

class Manor									//模板工厂类；
{
public:
	virtual Fruit *Greatapple() = 0;		//产品生产虚函数；
	virtual Fruit *Greatpeach() = 0;
};

class Northmanor:public Manor				//北方工厂类；
{
public:
	Fruit *Greatapple()
	{
		return new Northapple;
	}
	Fruit *Greatpeach()
	{
		return new Northpeach;
	}
};

class Southmanor:public Manor				//南方工厂类；
{
public:
	Fruit *Greatapple()
	{
		return new Southapple;
	}
	Fruit *Greatpeach()
	{
		return new Southpeach;
	}
};

int main()
{
	Fruit *f = NULL;
	Manor *m = NULL;

	m = new Southmanor;
	f = m->Greatapple();
	f->show();
	f = m->Greatpeach();
	f->show();
	delete f;	
	delete m;
	
	m = new Northmanor;
	f = m->Greatapple();
	f->show();
	f = m->Greatpeach();
	f->show();
	delete f;	
	delete m;

	return 0;
}

抽象工厂模式是在工厂模式上再进行抽象的工厂模式，将具有相同属性的产品归属于此属性的工厂，满足依据属性调用生产工厂的需求。