简单工厂模式

工厂模式（Factory Pattern ）是最常用的一类创建型设计模式，包含简单工厂模式（Simple Factory Pattern），工厂方法模式（Factory Method Pattern），和抽象工厂模式（Abstract Factory Pattern）。

简单工厂模式（Simple Factory Pattern）：定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。因为在简单工厂模式中用于创建实例的方法是静态方法，因此简单工厂模式又称为静态工厂方法模式（Static Factory Method Pattern）。

抽象产品（Product）角色：是简单工厂所创建的所有对象的父类，提供所有实例有公有的公共接口；

//动物（产品）基类
class Animal
{
public:
	Animal();
	Animal(string name);
	virtual ~Animal();

	virtual void Sound();

protected:
	string _name;
};


#include "Animal.h"

Animal::Animal()
{}

Animal::Animal(string name)
	:_name(name)
{}

Animal::~Animal()
{}

void Animal::Sound()
{
	cout <<_name << "：米西米西，滑不拉几" << endl;
}

具体产品（Concrete Product）角色：是简单工厂创建的目标，每一个具体产品都继承于抽象产品，实现抽象产品提供的公共方法。

//具体产品1
class AnimalCat :
    public Animal
{
public:
    AnimalCat();
    AnimalCat(string name);
    virtual void Sound();
};

#include "AnimalCat.h"

AnimalCat::AnimalCat()
{}

AnimalCat::AnimalCat(string name)
{
	_name = name;
}

void AnimalCat::Sound()
{
	cout << _name << "是一只小猫：喵喵喵" << endl;
}

//具体产品2
#include "Animal.h"
class AnimalDog :
    public Animal
{
public:
    AnimalDog();
    AnimalDog(string name);
    virtual void Sound();
}; 

#include "AnimalDog.h"

AnimalDog::AnimalDog()
{}

AnimalDog::AnimalDog(string name)
{
	_name = name;
}

void AnimalDog::Sound()
{
	cout << _name << "是一只小狗：汪汪汪" << endl;
}

工厂（Creator）角色：简单工厂的核心，他负责实现创建所有实例的内部逻辑，可以直接被外界调用创建所需的产品对象，提供的静态方法，返回一个抽象产品类Product，所有具体的产品都是Priduct的子类。

#include "AnimalCat.h"
#include "AnimalDog.h"

//工厂角色
class Factory
{
public:
	static Animal* CreateAnimal(string species,string name);
};

Animal* Factory::CreateAnimal(string species,string name)
{
	if (species == "dog")
	{
		return new AnimalDog(name);
	}
	else if (species == "cat")
	{
		return new AnimalCat(name);
	}
	else
	{
		return new Animal(name);
	}
}

#include "Factory.h"

#ifdef _DEBUG  
#define DEBUG_CLIENTBLOCK new( _CLIENT_BLOCK, __FILE__, __LINE__)  
#else  
#define DEBUG_CLIENTBLOCK  
#endif  
#define _CRTDBG_MAP_ALLOC  
#include   
#include   
#ifdef _DEBUG  
#define new DEBUG_CLIENTBLOCK  
#endif  

//调用
int main()
{
	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

	Factory* factory = new Factory;
	Animal * dog = factory->CreateAnimal("dog", "贝贝");
	dog->Sound();

	Animal* cat = factory->CreateAnimal("cat", "花花");
	cat->Sound();

	Animal* pig = factory->CreateAnimal("pig", "哼哼");
	pig->Sound();

	delete factory;
	factory = NULL;
	delete dog;
	dog = nullptr;
	delete cat;
	cat = NULL;
	delete pig;
	pig = NULL;
	return 0;
}

优点：
（1）工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅“消费”产品；
（2）客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可
缺点：
（1）违背单一职责原则：这个类的职责并不单一，或者说这个类由于要创建不同的对象实例，而每种对象实例的变化都会影响到工厂类（工厂类会修改），所以不只一个原因是这个工厂类改变。
（2）违背开闭原则：如果有一天，需要添加一种新的示例创建方法，而这里我们只能修改工厂中的代码来实现，而开闭原则要求我们，添加新的功能尽量通过添加一个类来实现，而非修改代码。