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、建造者模式
将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。