简单工厂和工厂方法模式（附简单实例）

工厂模式：

工厂模式是常用的一类创建型设计模式，通常工厂模式是指工厂方法模式。其是使用频率最高的工厂模式。

 上图几种工厂模式由简到难；

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

简单工厂的要要点在于，只需要传一个正确的参数，就可以获取所需对象。其结构简单，核心在于

工厂类的设计。

简单工厂模式角色：

Factory（工厂角色）：即工厂类，是简单工厂模式的核心；工厂类可直接被外界函数调用，创建所需的产品对象；工厂类中提供了静态的工厂方法factoryMethod()，其返回类型为抽象产品类型Product。

Product（抽象产品角色）： 是工厂类所创建的所有对象的父类，封装了各种产品对象的公有方法，提高了整个系统的灵活性。使得在工厂类中只需要定义一个通用的工厂方法，因为创建的具体产品对象都是其子类的对象。

ConcreteProduct（具体产品角色）:是简单工厂模式的创建目标，所有被创建的对象都充当这个角色的某个具体类的实例。每个具体产品都继承了抽象产品角色，需要实现在抽象产品中声明的抽象方法。

Product（抽象产品角色）：

class shape	//形状类
{
public:
	virtual void show() = 0;
};

ConcreteProduct（具体产品角色）：

class Square : public shape //正方形类
{
public:
	void show() { cout << "this is square" << endl; }
};

class Rectangle : public shape //长方形类
{
public:
	void show() { cout << "this is rectangle" << endl; }
};

Factory（工厂角色）：

class factory //这就是工厂
{
public:
	factory() {};
	~factory() {};
	shape* create(int x, int y) //创建逻辑
	{
		if (x == y)
			return new Square;
		else
			return new Rectangle;
	}
};

简单工厂总代码：

class shape	//形状类
{
public:
	virtual void show() = 0;
};

class Square : public shape //正方形类
{
public:
	void show() { cout << "this is square" << endl; }
};

class Rectangle : public shape //长方形类
{
public:
	void show() { cout << "this is rectangle" << endl; }
};

class factory //这就是工厂
{
public:
	factory() {};
	~factory() {};
	shape* create(int x, int y) //创建逻辑
	{
		if (x == y)
			return new Square;
		else
			return new Rectangle;
	}
};

工厂方法模式：

简单工厂模式虽然简单，但当系统中需要引入新产品时，由于静态工厂方法通过所传入参数的不同来创建不同的产品类，此时必定要修改工厂类的源代码。违背“开闭原则”。此时为了不影响增加新产品而不影响已有代码？工厂方法模式应运而生。

工厂方法角色：

抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。

具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。

抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。

具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

工厂方法和简单工厂的区别：

         工厂方法：一个对象的构建由工厂的子类型（具体的工厂）对应。而简单工厂中，是由工厂的一个静态方法负责；

 

 Product（抽象产品角色）：

//写一个日志记录(工厂方法)--->抽象对象，具体对象，抽象工厂，具体工厂
//日志记录器接口：抽象产品
struct Logger
{
	Logger() { cout << "日志记录器接口Logger" << endl; }
	virtual ~Logger() { cout << "~Logger" << endl; }
	virtual void writelog() = 0;
};

ConcreteProduct（具体产品角色）：

// 数据库日志记录器：具体产品
class DatabaseLogger : public Logger
{
public:
	DatabaseLogger() { cout << "DatabaseLogger" << endl; }
	~DatabaseLogger() { cout << "~DatabaseLogger" << endl; }

	void writelog()
	{
		cout << "数据库日志记录。" << endl;
	}
};


// 文件日志记录器：具体产品
class FileLogger : public Logger
{
public:
	FileLogger() { cout << "FileLogger" << endl; }
	~FileLogger() { cout << "~FileLogger" << endl; }

	void writelog()
	{
		cout << "文件日志记录。" << endl;
	}
};

AbstractFactory（抽象工厂角色）：

// 日志记录器工厂接口：抽象工厂
struct LoggerFactory
{
	virtual my_unique_ptr<Logger> createLogger() = 0;
	LoggerFactory() { cout << "LoggerFactory" << endl; }
	virtual ~LoggerFactory() { cout << "~LoggerFactory" << endl; }
};

ConcreteProduct（具体产品）：

// 数据库日志记录器工厂类 ： 具体工厂
class DatabaseLoggerFactory : public LoggerFactory
{
public:
	DatabaseLoggerFactory() { cout << "DatabaseLoggerFactory" << endl; }
	~DatabaseLoggerFactory() { cout << "~DatabaseLoggerFactory" << endl; }

	my_unique_ptr<Logger> createLogger()
	{
		return my_unique_ptr<Logger>(new DatabaseLogger());
		// return my_make_unique<DatabaseLogger>();
	}
};


// 文件日志记录器工厂类 ： 具体工厂
class FileLoggerFactory : public LoggerFactory
{
public:
	FileLoggerFactory() { cout << "FileLoggerFactory" << endl; }
	~FileLoggerFactory() { cout << "~FileLoggerFactory" << endl; }
	my_unique_ptr<Logger> createLogger()
	{
		return my_unique_ptr<Logger>(new FileLogger());
	}
};

工厂方法模式完整代码：（其中my_unique_ptr 可以参考智能指针unique_ptr）

//写一个日志记录(工厂方法)--->抽象对象，具体对象，抽象工厂，具体工厂
//日志记录器接口：抽象产品
struct Logger
{
	Logger() { cout << "日志记录器接口Logger" << endl; }
	virtual ~Logger() { cout << "~Logger" << endl; }
	virtual void writelog() = 0;
};

// 数据库日志记录器：具体产品
class DatabaseLogger : public Logger
{
public:
	DatabaseLogger() { cout << "DatabaseLogger" << endl; }
	~DatabaseLogger() { cout << "~DatabaseLogger" << endl; }

	void writelog()
	{
		cout << "数据库日志记录。" << endl;
	}
};


// 文件日志记录器：具体产品
class FileLogger : public Logger
{
public:
	FileLogger() { cout << "FileLogger" << endl; }
	~FileLogger() { cout << "~FileLogger" << endl; }

	void writelog()
	{
		cout << "文件日志记录。" << endl;
	}
};


// 日志记录器工厂接口：抽象工厂
struct LoggerFactory
{
	virtual my_unique_ptr<Logger> createLogger() = 0;
	LoggerFactory() { cout << "LoggerFactory" << endl; }
	virtual ~LoggerFactory() { cout << "~LoggerFactory" << endl; }
};


// 数据库日志记录器工厂类 ： 具体工厂
class DatabaseLoggerFactory : public LoggerFactory
{
public:
	DatabaseLoggerFactory() { cout << "DatabaseLoggerFactory" << endl; }
	~DatabaseLoggerFactory() { cout << "~DatabaseLoggerFactory" << endl; }

	my_unique_ptr<Logger> createLogger()
	{
		return my_unique_ptr<Logger>(new DatabaseLogger());
		// return my_make_unique<DatabaseLogger>();
	}
};


// 文件日志记录器工厂类 ： 具体工厂
class FileLoggerFactory : public LoggerFactory
{
public:
	FileLoggerFactory() { cout << "FileLoggerFactory" << endl; }
	~FileLoggerFactory() { cout << "~FileLoggerFactory" << endl; }
	my_unique_ptr<Logger> createLogger()
	{
		return my_unique_ptr<Logger>(new FileLogger());
	}
};

int main()
{
	my_unique_ptr<LoggerFactory> factory(new FileLoggerFactory());
	my_unique_ptr<Logger> logger = factory->createLogger();//具体工厂创建具体日志
	logger->writelog();

	factory.reset(new DatabaseLoggerFactory());
	logger = factory->createLogger();
	logger->writelog();
	return 0;

}