【设计模式（创建型）】

单例模式

定义：单例对象的类只允许有一个实例存在，并提供一个全局访问点。
案例：比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理

代码实现

// Singleton.h
class Singleton
{
public:
	static Singleton* Instance();   //1、Instance()是静态成员函数
protcet:      						//2、Singleton不可被实例化，因此构造函数声明为protected或private
	Singleton();
private:
	static Singleton*  m_instance;    //3、m_instance是静态成员变量，因为各个对象要共享对象，并判断是否唯一。
	
}

// Singleton.cpp
Singleton* Singleton::m_instance = NULL; 
Singleton* Singleton::Instance()
{
	//单例模式的核心实现
	if(m_instance == 0)
	{
		m_instance = new Singleton();   // 类内可new，类外不可new，控制类外实例化
	}
	return m_instance;
}
Singleton::Singleton()
{
	cout<<"单例模式。。。。"
}

1、是否将构造函数声明为protected或private，控制实例化，确保只有一个实例。
2、Instance、m_instance声明为static。

懒汉式

对象的创建在第一次调用Instance函数时创建，但是是线程不安全的。
如上代码，即为懒汉式实现

饿汉式

对象在程序执行式创建，还没有使用该单例对象，就已经加载到内存了，易造成内存浪费。

Singleton* Singleton::m_instance = new Singleton;   // 在main函数执行前执行
Singleton* Singleton::Instance()
{
	return m_instance;
}

进阶用法，封装为单例模板类

// Singleton.h
template<typename T>
class Singleton
{
public:
	static T* Instance();        //1、Instance()是静态成员函数
protcet:      //2、Singleton不可被实例化，因此构造函数声明为protected或private
	Singleton();
private:
	static T*  m_instance;    //  m_instance是静态成员变量，因为各个对象要共享对象，并判断是否唯一。
	static std::mutex mtx;
	
}

// Singleton.cpp
T* Singleton::Instance()
{
	//单例模式的核心实现
	if(m_instance == 0)
	{
		mtx.lock();    // 防止静态含函数的多线程不安全问题
		m_instance = new Singleton();   雷内可new，类外不可new，控制类外实例化
		mtx.unlock();
	}
	return m_instance;
}
Singleton::Singleton()
{
	cout<<"单例模式。。。。"
}

class CMQDispatchMdl : public Singleton<CMQDispatchMdl>  // 继承单例模板类，实现单例
{}

// main.cpp
#include<Singleton.h>
int main()
{
	CMQDispatchMdl * sin = CMQDispatchMdl ::Instance();    
	return 0;
}

工厂方法模式

类图

实现

class Object
{
public:
    void Sweep()
    {
        cout << "雷锋扫地";
    }
};

class FirstObject:public Object
{};
class SecondObject:public Object
{};

class Factory        // 抽象工厂
{
public:
    virtual Object* createOb() = 0;     // 纯虚函数
};

class SimpleFactory :public Factory    // 不同对象的工厂类
{
public:
    Object* createOb()
    {
        Object *lf= new FirstObject();   // new的LeiFeng具体子类
        return lf;
    }
};

int main()
{
    Factory* factory = new SimpleFactory();
    Object* lf = factory->createOb();
    lf->Sweep();
}

存在的问题

抽象工厂模式

抽象工厂模式是为创建一组（有多类）相关或者依赖的对象提供创建接口，实现略

建造者模式（待补充）

定义：封装一个复杂对象的构造过程，并允许安步骤构造

原型模式（待补充）

定义：通过复制现有实例来创建新的实例