设计模式

1、单例模式

单例模式即在应用程序中一个类有且仅有一个实例的一种设计模式。

单例模式保证系统中一个类只有一个实例且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。

结合以上需求、编程经验，不难总结单例模式要点有三：

一、某个类只能有一个实例。体现为构造函数为私有。

二、必须自行创建这个实例。

三、必须自行向整个应用程序系统提供这个实例。体现为供访问的接口设计为静态static成员函数。

#include<iostream>
using namespace std;

class Singleton
{
public:
	static Singleton * GetSinglePtr()  //接口，设置为静态成员函数调用静态成员变量
	{
		if (nullptr == m_SingletonPtr)
		{
			m_SingletonPtr = new Singleton(); //第一次调用
		}
		return m_SingletonPtr;
	}
private:
	static Singleton* m_SingletonPtr;  //只向单例模式对象的指针
	Singleton()
	{}
};

Singleton * Singleton::m_SingletonPtr = nullptr;

int main()
{
	Singleton *obj1 = Singleton::GetSinglePtr();
	Singleton *obj2 = Singleton::GetSinglePtr();

	cout << "obj1:" << obj1 << endl;
	cout << "obj2:" << obj2 << endl;
	
	if (obj1 == obj2)
	{
		cout << "the same!" << endl;
	}
	system("pause");
	return 0;
}

2、简单工厂模式

        简单工厂模式：创建一个具体工厂角色，根据客户端输入的条件产生相应的实体对象，然后由不同实体对象对virtual操作方法的调用得到不同的结果。

        本质：根据条件生成不同的实例。利用多态的特性，调用同名方法，不同的实例将得到不同的结果。

       简单工厂模式有三个核心类，一个是数据类（是操作类的基类），第一个是操作类，一个是简单工厂类，而简单工厂类是对数据类进行多态操作进行不同运算。

       数据类有多个数据，而操作类能对数据进行多种操作，如加减乘除之类的，根据你客户端输入的符号，生成对应的加法类对象还是其他类对象，利用virtual对结果进行输出。

#include<iostream>
#include<string>

using namespace std;

class Data  //基类：数据类
{
protected:   //为什么定义为保护类型？因为基类私有成员在派生类中不可见。
	double m_numberA;
	double m_numberB;

public:
	double GetNumberA()
	{
		return m_numberA;
	}
	void SetNumberA(int value)
	{
		m_numberA = value;
	}

	double GetNumberB()
	{
		return m_numberB;
	}
	void SetNumberB(int value)
	{
		m_numberB = value;
	}

	virtual double GetResult()
	{
		return 0;
	}

};

//以下为操作类，表示数据能进行的操作，数据源来自对基类数据的继承
/*---------- +号 ------------*/
class AddOperation :public Data
{
public:
	double GetResult()
	{
		return  m_numberB + m_numberA;   //派生类能直接访问，说明数据为保护或者共有类型
	}
};

/*------------- -号 --------------*/
class SubOpreation :public Data
{
public:
	double GetResult()
	{
		return m_numberA - m_numberB;
	}
};

/*-------------- *号 ----------------*/
class MulOperation :public Data
{
public:
	double GetResult()
	{
		return m_numberA * m_numberB;
	}
};

/*--------------- 除法 -------------------*/
class  DivOperation:public Data
{
public:
	double GetResult()
	{
		if (0 == m_numberB)
		{
			return 0;
		}
		else
		{
			return m_numberA / m_numberB;
		}
	}
};


/*
  以下定义一个简单工厂类，通过输入一定条件，产生一定的类型
  本程序为：客服端输入条件为加减乘除符号，对应产生一个类
*/
class SimpleFactory
{
public:
	static Data* CreateOperation(char c)
	{
		switch (c)
		{
		case'+':                         //条件
			return (new AddOperation);   //产生一个特定实体；
		case'-':
			return (new SubOpreation);
		case'*':
			return (new MulOperation);
		case'/':
			return (new DivOperation);
		default:
			return (new AddOperation);
		}
	}
};

int main()
{
	Data* pOpe = SimpleFactory::CreateOperation('+'); //为指向基类型的派生类对象
	pOpe->SetNumberA(13);
	pOpe->SetNumberB(25);
	cout << "结果为：" << pOpe->GetResult() << endl;
    delete pOpe;
	system("pause");
	return 0;
}

3、工厂方法模式

       定义一个创建产品对象的工厂接口（IFactory），将实际创建工作推迟到子类(addFactory、subFactory、mulFactory、divFactory)当中。

       核心工厂类(IFactory)不再负责产品的创建，仅作为一个抽象（有纯虚方法）工厂角色，只负责声明具体工厂子类必须实现的接口（即纯虚方法）。

       这样进一步抽象化的好处：系统在不需要修改具体工厂角色的情况下引进新的产品（与简单工厂模式相比）。

#include<iostream>
#include<string>

using namespace std;

class Data  //基类：数据类
{
protected:  
	double m_numberA;
	double m_numberB;

public:
	double GetNumberA()
	{
		return m_numberA;
	}
	void SetNumberA(int value)
	{
		m_numberA = value;
	}

	double GetNumberB()
	{
		return m_numberB;
	}
	void SetNumberB(int value)
	{
		m_numberB = value;
	}

	virtual double GetResult()
	{
		return 0;
	}

};

/*---------- +号 ------------*/
class AddOperation :public Data
{
public:
	double GetResult()
	{
		return  m_numberB + m_numberA;   //派生类能直接访问，说明数据为保护或者共有类型
	}
};

/*------------- -号 --------------*/
class SubOperation :public Data
{
public:
	double GetResult()
	{
		return m_numberA - m_numberB;
	}
};

/*-------------- *号 ----------------*/
class MulOperation :public Data
{
public:
	double GetResult()
	{
		return m_numberA * m_numberB;
	}
};

/*--------------- 除法 -------------------*/
class  DivOperation :public Data
{
public:
	double GetResult()
	{
		if (0 == m_numberB)
		{
			return 0;
		}
		else
		{
			return m_numberA / m_numberB;
		}
	}
};

/*
以下定义一个工厂方法类，创建为纯虚类
*/
class Factory
{
public:
	virtual Data* CreateOperation() = 0;
};

class ADDOperation :public Factory
{
public:
	static Data * CreateOperation()
	{
		return new AddOperation;
	}
};

class SUBOperation :public Factory
{
public:
	static Data * CreateOperation()
	{
		return new SubOperation;
	}
};

class MULOperation :public Factory
{
public:
	static Data * CreateOperation()
	{
		return new MulOperation;
	}
};

class DIVOperation :public Factory
{
public:
	static Data * CreateOperation()
	{
		return new DivOperation;
	}
};

int main()
{
	Data * pOpe = MULOperation::CreateOperation();
	pOpe->SetNumberA(9);
	pOpe->SetNumberB(3);

	cout << "结果为：" << pOpe->GetResult() << endl;
	delete pOpe;
	system("pause");
	return 0;
}

4、抽象工厂模式

       为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。

       专业书上都是这句话：“为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。”

逐级分解一下：

1、为创建一组相关的对象提供一个接口，而且无需指定他们的具体类。

2、为创建一组相互依赖的对象提供一个接口，而且无需指定他们的具体类。

3、为创建对象提供一个接口，而且无需指定他们的具体类。

4、为创建对象提供一个接口。

5、一个接口。

       抽象工厂：抽象是指接口，工厂是指集合，其实是接口集合。既然是接口集合，那么属于哪种类型的接口集合？即具体工厂类。比如SqlFactory，是指Sql数据库的接口集合。而Sql数据库的接口集合最终都可以创建出哪种类型的Sql产品？即具体产品类。比如SqlUser,SqlDepartment，是指具体的Sql产品类。所以，抽象工厂，即创建出产品类的接口集合。比如，IFactory，创建出产品类的接口集合，不可以实例化对象，仅仅提供接口规范。每个具体工厂，即创建出同一类产品的功能集合。比如，SqlFactory，创建出同一类产品SqlUser、SqlDepartment的功能集合。

5、建造者模式

        将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。