本文包括C++ 11的特性如智能指针, magic static，线程锁;本文的全部代码在 g++ 5.4.0 编译器下编译运行通过。

一、什么是单例

单例 Singleton 是设计模式的一种，其特点是只提供唯一一个类的实例,具有全局变量的特点，在任何位置都可以通过接口获取到那个唯一实例;
具体运用场景如：

1. 设备管理器，系统中可能有多个设备，但是只有一个设备管理器，用于管理设备驱动;
2. 数据池，用来缓存数据的数据结构，需要在一处写，多处读取或者多处写，多处读取;

二、C++单例的实现

2.1 基础要点

• 全局只有一个实例：static 特性，同时禁止用户自己声明并定义实例（把构造函数设为 private）
• 线程安全
• 禁止赋值和拷贝
• 用户通过接口获取实例：使用 static 类成员函数

2.2 C++ 实现单例的几种方式

2.2.1 有缺陷的懒汉式

懒汉式(Lazy-Initialization)的方法是直到使用时才实例化对象，也就说直到调用get_instance() 方法的时候才 new 一个单例的对象， 如果不被调用就不会占用内存。

#include 
// version1:
// with problems below:
// 1. thread is not safe
// 2. memory leak

class Singleton{
private:
    Singleton(){
        std::cout<<"constructor called!"< 
运行的结果是constructor called!
 
可以看到，获取了两次类的实例，却只有一次类的构造函数被调用，表明只生成了唯一实例，这是个最基础版本的单例实现，他有哪些问题呢？
 
线程安全的问题,当多线程获取单例时有可能引发竞态条件：第一个线程在if中判断 m_instance_ptr是空的，于是开始实例化单例;同时第2个线程也尝试获取单例，这个时候判断m_instance_ptr还是空的，于是也开始实例化单例;这样就会实例化出两个对象,这就是线程安全问题的由来; 解决办法:加锁
内存泄漏. 注意到类中只负责new出对象，却没有负责delete对象，因此只有构造函数被调用，析构函数却没有被调用;因此会导致内存泄漏。解决办法： 使用共享指针;
因此，这里提供一个改进的，线程安全的、使用智能指针的实现;
 
2.2.2 线程安全、内存安全的懒汉式单例 （智能指针，锁）
 
#include 
#include  // shared_ptr
#include   // mutex

// version 2:
// with problems below fixed:
// 1. thread is safe now
// 2. memory doesn't leak

class Singleton{
public:
    typedef std::shared_ptr Ptr;
    ~Singleton(){
        std::cout<<"destructor called!"< lk(m_mutex);
            if(m_instance_ptr == nullptr){
              m_instance_ptr = std::shared_ptr(new Singleton);
            }
        }
        return m_instance_ptr;
    }


private:
    Singleton(){
        std::cout<<"constructor called!"< 
运行结果如下，发现确实只构造了一次实例，并且发生了析构。
 
constructor called! destructor called!
 
shared_ptr和mutex都是C++11的标准，以上这种方法的优点是
 
基于 shared_ptr, 用了C++比较倡导的 RAII思想，用对象管理资源,当 shared_ptr 析构的时候，new 出来的对象也会被 delete掉。以此避免内存泄漏。
加了锁，使用互斥量来达到线程安全。这里使用了两个 if判断语句的技术称为双检锁；好处是，只有判断指针为空的时候才加锁，避免每次调用 get_instance的方法都加锁，锁的开销毕竟还是有点大的。
不足之处在于： 使用智能指针会要求用户也得使用智能指针，非必要不应该提出这种约束; 使用锁也有开销; 同时代码量也增多了，实现上我们希望越简单越好。
 
还有更加严重的问题，在某些平台（与编译器和指令集架构有关），双检锁会失效！具体可以看这篇文章，解释了为什么会发生这样的事情。
 
因此这里还有第三种的基于 Magic Staic的方法达到线程安全
 
2.2.3 最推荐的懒汉式单例(magic static )——局部静态变量
 
#include 

class Singleton
{
public:
    ~Singleton(){
        std::cout<<"destructor called!"< 
运行结果constructor called! destructor called!
 
C++可继承的单例基类模板 
// author: sunchaothu
// brief: a singleton base class offering an easy way to create singleton
#include 

template
class Singleton{
public:
    static T& get_instance() noexcept(std::is_nothrow_constructible::value){
        static T instance;
        return instance;
    }
    virtual ~Singleton() noexcept{
        std::cout<<"destructor called!"<{
   // !!!! attention!!!
   // needs to be friend in order to
   // access the private constructor/destructor
   friend class Singleton;
public:
   DerivedSingle(const DerivedSingle&)=delete;
   DerivedSingle& operator =(const DerivedSingle&)= delete;
private:
   DerivedSingle()=default;
};

int main(int argc, char* argv[]){
    DerivedSingle& instance1 = DerivedSingle::get_instance();
    DerivedSingle& instance2 = DerivedSingle::get_instance();
    return 0;
}

 
关键处 
子类需要把自己作为模板参数，如 class DerivedSingle:public Singleton；
 这里用到的是CRTP(Curiously recurring template pattern) 奇异循环模板模式
在子类中需要把基类 Singleton 声明为友元;这样才能访问私有构造函数（这个链接里还提供了不需要声明为友元的实现）
这个使用了局部静态变量保证了线程安全，成为 Magic Static。
使用限制 
继承了这个类的代码不可以作为基类再被继承。