设计模式之创建型模式（简单工厂模式、工厂模式、抽象工厂模式、建造者模式、单例模式）

1、创建型模式

主要关注点是：“怎样创建对象？”

主要特点是：“将对象的创建与使用分离”

这样使用者不需要关注对象的创建细节，对象的创建由相应的工厂实现。
（隐藏了对象如何被创建和组合在一起）

包括五种：
简单工厂模式（Simple Factory）
工厂方法模式（Factory Method）
抽象工厂模式（Abstract Factory）
建造者模式（Builder）
单例模式（Singleton）

---

2、简单工厂模式

2.1 定义

简单工厂模式(Simple Factory Pattern)因为内部使用静态方法根据不同参数构造不同产品对象实例，也称静态工厂方法模式。

在简单工厂模式中，可以根据参数的不同返回不同实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

2.2 模式结构

• 工厂角色：工厂角色负责实现创建所有实例的内部逻辑。工厂类内部提供静工厂方法，用于创建所需产品对象，可被外界直接调用。
• 抽象产品角色：抽象产品角色是所创建的所有对象的父类，负责描述所有的实例所共有的公共接口。抽象产品是工厂类创建创建的所有对象的父类或共有的接口，封装各种产品对象的公有方法。
• 具体产品角色：具体产品角色是创建目标，所有的创建的对象都充当这个角色的某个具体类的实例。每个具体产品都继承了抽象产品角色，实现抽象产品角色中的抽象方法。

2.3 C++代码

简单工厂模式的核心是，对于一个父类的多个继承子类，工厂对象的工厂函数根据用户输入，自动new出一个子类对象并返回其父类的指针，这样利用父类的指针执行父类的虚函数，就可以动态绑定子类的重写函数，从而实现多态。

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <iostream>


using namespace std;

//抽象产品类-操作
class Operation
{
   
private:
	double A, B;
public:
	Operation() :A(0), B(0) {
   }
	double GetA() const {
    return A; }
	double GetB() const {
    return B; }
	void SetA(double x) {
    A = x; }
	void SetB(double y) {
    B = y; }
	virtual double GetResult() = 0;
	/*
	double GetA() const{return A;}中的const：
	只有函数是一个类的非静态成员函数才可以。
	类的非静态成员函数不管有几个参数，都会隐形的传入一个参数this
	this是指向该类的指针，加了const以后，表示不可以更改这个对象的成员变量。
	如return A++; 编译的时候就会报错。其实是A是this->A
	*/
};

//具体产品类-加法
class Add :public Operation
{
   
public:
	double GetResult() {
    return GetA() + GetB(); }
};

//具体产品类-减法
class Sub :public Operation
{
   
public:
	double GetResult() {
    return GetA() - GetB(); }
};

//具体产品类-乘法
class Mul :public Operation
{
   
public:
	double GetResult() {
    return GetA()*GetB(); }
};

//具体产品类-除法
class Div :public Operation
{
   
public:
	double GetResult() {
    return GetA() / GetB(); }
};

//工厂类
class SimpleFactory
{
   
public:
	static Operation* CreateOperator(char ch)
	{
   
		Operation* p=NULL;
		switch (ch)
		{
   
		case '+':
			p = new Add();
			break;
		case '-':
			p = new Sub();
			break;
		case '*':
			p = new Mul();
			break;
		case '/':
			p = new Div();
			break;
		}
		return p;
	}
};

int main()
{
   
	double A = 0;
	double B = 0;
	char ch= '\0';
	cin >> A >> ch >> B;

	Operation* op=SimpleFactory::CreateOperator(ch);
	op->SetA(A);
	op->SetB(B);
	cout << op->GetResult() << endl;

	delete op;
	return</