设计模式中的单例模式有懒汉单例模式和饿汉单例模式两种，这部分内容记录在http://blog.csdn.net/qq_29344757/article/details/75575217中。
懒汉单例模式的设计步骤为：
(1) 将构造函数的访问属性设置为private，不让该类中外部生成对象
(2) 将标志指针变量初始化为NULL
(3) 当外部需要使用对象时，调用类的静态成员函数，该函数判断：
若标志指针变量为NULL，则动态生成对象，并且将该对象的地址赋值给标志指针变量，最后返回该对象的地址；
若标志指针变量不为NULL，即其值等于前面生成的对象的地址，那么直接返回该标志指针
(正是因为这个判断操作，使得懒人单例模式是一种非线程安全的设计模式)

饿汉单例模式的设计步骤为：
(1) 将构造函数的访问属性设置为private，不让该类中外部生成对象
(2) 将标志指针变量初始化为动态生成的对象的地址
(3) 当外部需要使用对象时，调用类的静态成员函数，该函数直接返回标志指针

不论是二者中的哪一种，我们要将设计的类赋予单例模式属性时，都需要定义静态成员指针变量p和静态成员函数instance()以获得该类唯一对象的地址，这一部分可以提取出来，作为一个单例类模板：

1. 饿汉单例类模板

//singleton_class.h
#ifndef __SINGLETON_CLASS_H__
#define __SINGLETON_CLASS_H__

#include <stdio.h>
#include <iostream>

template <typename T>
class singleton
{
private:
    static T* p;        //标志指针

public:
    static T* instance();   //得到类型为T对象的方法
};

template <typename T>
T* singleton<T>::p = new T();   //不管外部是否要使用对象，进入main函数前就生成T对象，p指向该对象的地址

template <typename T>
T* singleton<T>::instance()
{
    return p;
}

#endif /* __SINGLETON_CLASS_H__ */

2. 懒汉单例模板类

#ifndef __SINGLETON_CLASS_H__
#define __SINGLETON_CLASS_H__

#include <stdio.h>
#include <iostream>

template <typename T>
class singleton
{
private:
    static T* p;

public:
    static T* instance();
};

template <typename T>
T* singleton<T>::p = NULL;  //初始化为NULL，等到外部需要到T类型类对象时再生成对象

template <typename T>
T* singleton<T>::instance()
{
    if (NULL == p)
        p = new T();

    return p;
}

#endif /* __SIGLETON_CLASS_H__ */

上面两种方式的单例模板类测试一样：

#include "singleton_class.h"

class TestCls
{
private:
    TestCls(){}                             //私有化构造函数，使本类不能再外部生成对象
    TestCls(const TestCls& );               //私有化拷贝构造函数，使本类不能为其它本类对象初始化
    TestCls& operator= (const TestCls& );   //私有化赋值操作符，使本类不能为其它本类对象赋值

    friend class singleton<TestCls>;        //singleton模板类为本类的友缘类，它才能new对象

public:
    void print_this()
    {
        printf("this = %p\n", this);
    }
};

int main(void)
{
    TestCls* s = singleton<TestCls>::instance();
    s->print_this();

    TestCls* s1 = singleton<TestCls>::instance();
    s1->print_this();

    return 0;
}

编译运行：

单例模式几乎是最常用的设计模式，简单易懂，使用起来效果显著，在此也不对单例模式做剖析，不了解的可以自行查阅资料。
项目中多次使用单例模式后发现每次都是重复的构建单例类，于是做了一个单例模式的模板。

//单例模板
//delete 与 default 来自于 c++ 11
template <typename T>
class Singleton {
    //使用默认构造和析构函数
    Singleton() = default;
    ~Singleton() = default;
public:
	//删除默认的移动、拷贝、赋值、取址
    Singleton(T &&) = delete;
    Singleton(const T &) = delete;
    void operator = (const T &) = delete;
    T *operator &() = delete;
	//获取实例，对此处有异议也可自行查阅资料
    static T* instance()
    {
        static T object;
        return &object;
    }
};

使用示例：

//测试类
class Test
{
    int id;
public:
    void setId(int id)
    {
        this->id = id;
    }
    int getId() const
    {
        return this->id;
    }
};

int main()
{
    Singleton<Test>::instance()->setId(5);
    std::cout << Singleton<Test>::instance()->getId() << std::endl;
}

如果使用的时候觉得调用太长，可以将其 #define 一下，如：

#define SingletonTest Singleton<Test>::instance()

使用时短小很多，减少自己手指的损耗，如下：

int main()
{
    SingletonTest->setId(5);
    std::cout << SingletonTest->getId() << std::endl;
}

宏定义本身是c/c++程序设计中不推荐的做法，关于宏定义是预处理期展开在此也不做赘述，个中利害还需自己斟酌。

到这里你可能会提出质疑，我们在此处并没有做到禁止创建 Test 用户类的对象，如果你有这样的需求，那请往下看.

为了禁止擅自创建 Test（用户类对象），我们改变下策略:

放开模板限制
在此不再删除取址操作（会影响返回对象的引用），取消模板类构造函数的私有化，作为基类，析构函数标记为virtual；

template <typename T>
class Singleton {
public:
    Singleton() = default;
    virtual ~Singleton() = default;
    Singleton(T &&) = delete;
    Singleton(const T &) = delete;
    void operator = (const T &) = delete;

    static T* instance()
    {
        static T object;
        return &object;
    }
};

用户类继承单例模板
与之前不同的是，将创建对象的限制放在了用户类（即将构造函数设置为私有），构造函数私有化后，单例模板也无法创建对象，于是，将单例模板作为友元类；

class Test : public Singleton<Test>
{
    int id;
    Test() = default;
public:
    //单例模板作为友元类
    friend class Singleton;
    void setId(int id)
    {
        this->id = id;
    }
    int getId() const
    {
        return this->id;
    }
};

示例：

int main()
{
    //Test t;  //错误，禁止创建对象
    Test::instance()->setId(5);
    std::cout << Test::instance()->getId();
}

目前想到的方法就是这样，如有更好的的方法，还请留下宝贵的意见。

C++单例模式以及C++单例类模板

在单例类里,又分为了懒汉式和饿汉式,它们的区别在于创建实例的时间不同:

懒汉式 : 指代码运行后,实例并不存在,只有当需要时,才去创建实例(适用于单线程)
饿汉式 : 指代码一运行,实例已经存在,当时需要时,直接去调用即可(适用于多线程)

用法

将构造函数的访问属性设置为private,
提供一个GetInstance()静态成员函数,只能供用户访问唯一一个实例.
定义一个静态成员指针,用来供用户获取
重载 (=)赋值操作符以及拷贝构造函数,并设为private, 避免对象间拷贝,复制.
简单单例类-懒汉式:

class CSingleton
{
private:
    static CSingleton* m_pInstance;
 
    CSingleton()     //构造函数为private
    {
    } 
 
    CSingleton& operator = (const CSingleton& t);
    CSingleton(const CSingleton &);
public:
    static CSingleton* getInstance()
    {
       if(m_pInstance==NULL)
           m_pInstance= new CSingleton(); 
       
        return m_pInstance;
    }
 
    void print()
    {
      cout<<this<<endl;   
    }
};
 
CSingleton* CSingleton::m_pInstance = NULL;
 
int main()
{
    CSingleton *p1=CSingleton::getInstance();
    CSingleton *p2=CSingleton::getInstance(); 
    CSingleton *p3=CSingleton::getInstance();
 
    p1->print();
    p2->print();
    p3->print();
 
　　　　return 0;
}

打印结果

0x6e2d18
0x6e2d18
0x6e2d18

从打印结果可以看出,该指针对象指向的都是同一个地址,实现了一个类最多只能有一个实例(instance)存在.

**注意:**由于实例(instance),在系统生命期中,都是存在的,所以只要系统还在运行,就不需要delete

上面的懒汉式如果在多线程情况下 ,多个Csingleton指针对象同时调用getInstance()成员函数时,由于m_pInstance = NULL,就会创建多个实例出来.

所以,在多线程情况下,需要使用饿汉实现

class CSingleton
{
private:
 
    static CSingleton* m_pInstance;
 
    CSingleton()     //构造函数为private
    {
    }       
 
    CSingleton& operator = (const CSingleton& t);
    CSingleton(const CSingleton &); 
 
public:
    static CSingleton* getInstance()
    { 
        return m_pInstance;
    }
};
 
CSingleton* CSingleton::m_pInstance = new CSingleton;

单例类模板

单例类模板，使用时候可以友元使用，可以继承使用。

注意

优先使用组合而非继承

/************************************************************************/
/* 名称：单例模板类                                                
/* 说明：可把任何类包装成线程安全的全局单例类，	利用了C++11的智能指针和自解锁等	并实现自动GC。	*/
/************************************************************************/

#include <mutex>
#include <memory>

template<typename T>
class CSingleton {
public:

	//获取全局单例对象
	template<typename ...Args>
	static std::shared_ptr<T> GetInstance(Args&&... args) {
		if (!m_pSington) {
			std::lock_guard<std::mutex> gLock(m_Mutex);
			if (nullptr == m_pSington) {
				m_pSington = std::make_shared<T>(std::forward<Args>(args)...);
			}
		}
		return m_pSington;
	}

	//主动析构单例对象（一般不需要主动析构，除非特殊需求）
	static void DesInstance() {
		if (m_pSington) {
			m_pSington.reset();
			m_pSington = nullptr;
		}
	}

private:
	explicit CSingleton ();
	CSingleton (const CSingleton &) = delete;
	CSingleton & operator=(const CSingleton &) = delete;
	~CSingleton ();

private:
	static std::shared_ptr<T> m_pSington;
	static std::mutex m_Mutex;
};

template<typename T>
std::shared_ptr<T> CSingleton<T>::m_pSington = nullptr;

template<typename T>
std::mutex CSingleton<T>::m_Mutex;

#endif

使用

using namespace std;

class Test{
public:
	Test(const string& strData) : m_strData(strData) {
		cout << m_strData.data() << endl;
	};
	~Test() {
		cout << "destory" << endl;
	};

private:
	string m_strData;
};

auto main()->int { //等同于入口函数int main()
	auto pTest = CSingleton <Test>::GetInstance("create");

	CSingleton <Test>::DesInstance();

	return 1;
}

#pragma once

#include <QtCore/QCoreApplication>
#include <QtCore/QAtomicPointer>
#include <QtCore/QReadWriteLock>
#include <QtCore/QMutex>
#include <QtCore/QDebug>

template<class T>
class JSingleton
{
public:
    static T& getInstance(void); //获取唯一实例

private:
    JSingleton();                                       //禁止外部构造函数
    JSingleton(const JSingleton<T> &);                  //禁止外部拷贝构造函数
    JSingleton<T>& operator = (const JSingleton<T>&);   //禁止外部赋值拷贝函数
    ~JSingleton();                                      //禁止外部析构函数

    QReadWriteLock              m_internalMutex;        //函数使用的读写锁
    static QMutex               m_mutex;                //实例互斥锁
    static QAtomicPointer<T>    m_instance;             //实例
};

//静态成员变量初始化
template<class T>
QMutex JSingleton<T>::m_mutex(QMutex::Recursive);       //一个线程可以多次锁同一个互斥量

template<class T>
QAtomicPointer<T>JSingleton<T>::m_instance;             //原子指针，默认初始化为0

template<typename T>
T& JSingleton<T>::getInstance(void)
{
#ifdef Q_ATOMIC_POINTER_TEST_AND_SET_IS_ALWAYS_NATIVE
    if(!QAtomicPointer<T>::isTestAndSetNative())        //运行时检测
        qDebug() << QStringLiteral("Error: don's support TestAndSetNative!!!");
#endif
    //双重检测加锁
    /*  ! testAndSetOrders 操作保证在原子操作前和后的的内存访问
    *    不会被重新排序。
    */
    if(m_instance.testAndSetOrdered(0, 0))          //第一次检测
    {
        QMutexLocker locker(&m_mutex);              //加锁
        m_instance.testAndSetOrdered(0, new T);     //第二次检测
    }
    return *m_instance/*.load()*/;
}

//调用示例： 如对于class JTest()
//typedef JSingleton<JTest> test; //使用JTest来实例化模板
//test::getInstance().fxxx();