单例：通过一个对象只能创建一个该类的实例。当然，可以创建两个指针指向该实例。
应用场景：比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。其他还有如系统的日志输出、MODEM的联接需要一条且只需要一条电话线，操作系统只能有一个窗口管理器，一台PC连一个键盘等等。
当需要频繁调用该类时，单例类可以保证无需重复创建，节省资源。

1 懒汉模式

classSingleton{private:Singleton();Singleton(constSingleton&other);public:staticSingleton*getInstance();staticSingleton*m_instance;};

首先所有单例类设计必须私有化构造函数、拷贝构造函数，

//线程非安全版本，两个线程检测同一个m_instance;Singleton*Singleton::getInstance(){if(m_instance==nullptr){m_instance=newSingleton();}returnm_instance;}

上述代码在单线程是安全的，它首先检测是否为空，但是在多线程中由于线程调度的问题，可鞥两个线程都检测到m_instance为空。
下面是调用锁的版本一共两个：

//线程安全版本，但锁的代价过高Singleton*Singleton::getInstance(){Lock lock;if(m_instance==nullptr){m_instance=newSingleton();}returnm_instance;}/双检查锁，但由于内存读写reorder不安全 Singleton*Singleton::getInstance(){if(m_instance==nullptr){Lock lock;if(m_instance==nullptr){m_instance=newSingleton();}}returnm_instance;}

在双检查锁中，reorder指的是new Singleton()时，编译器可能不是按我们所想的步骤进行的，他可能只分配了内存就返回了申请的地址，但还未调用构造函数，所以此时可能还是为空，另一线程在调用getInstance就会创建两个单例对象。
在C++11后的实现方式如下，解决了上述问题：

#include<iostream>#include<mutex>classSingleton{private:Singleton(){std::cout<<"Singleton constructed!\n";}~Singleton()=default;Singleton(constSingleton&)=delete;Singleton&operator=(constSingleton&)=delete;staticSingleton*instance;staticstd::once_flag onceFlag;public:staticSingleton&getInstance(){std::call_once(onceFlag,‌[]{instance=newSingleton();});return*instance;}};Singleton*Singleton::instance=nullptr;std::once_flag Singleton::onceFlag;

还有一种方式，将单例对象以局部静态对象的方式定义在函数内部，C++11可以保证多个线程不会同时进入静态变量的初始化流程。

template<typenameT>classSingleton{public:staticT&GetInstance(){staticT instance;returninstance;}Singleton(T&&)=delete;Singleton(constT&)=delete;voidoperator=(constT&)=delete;protected:Singleton()=default;virtual~Singleton()=default;};

2 饿汉模式

饿汉模式采用直接定义静态对象的方法

classSingleton{private:Singleton(){};Singleton(constSingleton&){};//拷贝构造函数private:staticSingleton m_instance;public:staticSingleton&getInstance(){returnm_instance;}};Singleton Singleton::m_instance;//静态对象类外定义//函数调用Singleton&instance=Singleton::GetInstance();

上述代码实现简单，可用于多线程。
但是：
（1）如果存在多个单例对象且这几个单例对象相互依赖，可能会出现程序崩溃的危险。原因:对编译器来说，静态成员变量的初始化顺序和析构顺序是一个未定义的行为;具体分析在懒汉模式中也讲到了。
（2）在程序开始时，就创建类的实例，如果Singleton对象产生很昂贵，而本身有很少使用，这种方式单从资源利用效率的角度来讲，比懒汉式单例类稍差些。但从反应时间角度来讲，则比懒汉式单例类稍好些。

饿汉模式采用静态指针 + 类外初始化时new空间

classSingleton{public:staticSingleton*GetInstance();private:Singleton(){}Singleton(constSingleton&);private:staticSingleton*m_Instance;};//CPP文件Singleton*Singleton::m_Instance=newSingleton();//类外定义-不要忘记写Singleton*Singleton::GetInstance(){returnm_Instance;}