三种工厂模式

简单工厂模式：通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

#include<iostream>

using namespace std;

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

class Apple:public Fruit
{
public:
	void show()
	{
		cout<<"this is apple"<<endl;
	}
};

class Banana:public Fruit
{
public:
	void show()
	{
		cout<<"this is banana"<<endl;
	}
};

class Pear : public Fruit
{
public:
	void show()
	{
		cout<<"this is pear"<<endl;
	}
};

class Factory
{
public:
	Fruit * createApple()
	{
		return new Apple;
	}
	Fruit * createBanana()
	{
		return new Banana;
	}
	Fruit * createPear()
	{
		return new Pear;
	}
};

int main()
{
	Fruit * fruit = NULL;
	Factory *factory = new Factory;
	
	fruit = factory -> createApple();
	fruit -> show();
	delete factory;
	delete fruit;
	return 0;
}

工厂方法模式同样属于类的创建型模式又被称为多态工厂模式 。工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。

核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

#include<iostream>

using namespace std;

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

class Apple:public Fruit
{
public:
	void show()
	{
		cout<<"this is apple"<<endl;
	}
};

class Banana:public Fruit
{
public:
	void show()
	{
		cout<<"this is banana"<<endl;
	}
};

class Pear : public Fruit
{
public:
	void show()
	{
		cout<<"this is pear"<<endl;
	}
};

class AbsFactory
{
public:
	virtual Fruit * create()=0;
};


class AppleFactory : public AbsFactory
{
public:
	Fruit * create()
	{
		return new Apple;
	}
};

class BananaFactory : public AbsFactory
{
public:
	Fruit * create()
	{
		return new Banana;
	}
};



int main()
{
	Fruit * fruit = NULL;
	AbsFactory *factory = new AppleFactory;
	
	fruit = factory -> create();
	fruit -> show();
	delete factory;
	delete fruit;
	return 0;
}

抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的。抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，能够创建多个产品族的产品对象。

5#include<iostream>

using namespace std;

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

class SouthApple:public Fruit
{
public:
	void show()
	{
		cout<<"this is southapple"<<endl;
	}
};

class SouthBanana:public Fruit
{
public:
	void show()
	{
		cout<<"this is southbanana"<<endl;
	}
};



class NorthApple:public Fruit
{
public:
	void show()
	{
		cout<<"this is northapple"<<endl;
	}
};

class NorthBanana:public Fruit
{
public:
	void show()
	{
		cout<<"this is northbanana"<<endl;
	}
};






class Factory
{
public:
	virtual Fruit * CreateApple()=0;
	virtual Fruit * CreateBanana()=0;
};

class SouthFactory : public Factory
{
public:
	Fruit * CreateApple()
	{
		return new SouthApple;
	}
	Fruit * CreateBanana()
	{
		return new SouthBanana;
	}
	
};


class NorthFactory : public Factory
{
public:
	Fruit * CreateApple()
	{
		return new NorthApple;
	}
	Fruit * CreateBanana()
	{
		return new NorthBanana;
	}
	
};

void Create(Factory *factory)
{
	Fruit *fruit = NULL;
	fruit = factory->CreateApple();
	fruit->show();
	delete fruit;
	
	fruit = factory->CreateBanana();
	fruit->show();
	delete fruit;
}




int main()
{
	
	Factory *factory = new SouthFactory;
	Create(factory);
	
	delete factory;
	
	factory = new NorthFactory;
	Create(factory);
	delete factory;
	
	
	
	
	return 0;
}

抽象工厂模式令我不是很懂