单例模式简记

一、 C++单例模式（饿汉式）

#pragma once
#include <iostream>

//单例模式 - 饿汉式
class A
{
public:
	static A* GetInstance();
	static void deleteInstance();
	void Printf();

private:
	A();
	A(const A& a);
	const A& operator=(const A& single);
	~A();

private:
	//唯一单实例对象指针
	static A* g_pSingleton;
};


//默认构造
A::A()
{
	//TODU
	std::cout << "这是构造函数" << std::endl;
}

//拷贝构造
A::A(const A& a)
{
	//TODU
}

//拷贝赋值
const A& A::operator=(const A& single)
{
	//TODU
}

//析构
A::~A()
{
	std::cout << "这是析构函数" << std::endl;
}

//单例实现
A* A::g_pSingleton = new A();

//获取单例
A* A::GetInstance()
{
	//局部静态特性的方式实现单实例
	return g_pSingleton;
}

//删除单例对象
void A::deleteInstance()
{
	if (g_pSingleton)
	{
		delete g_pSingleton;
		g_pSingleton = NULL;
	}
}

//自定义函数实现
void A::Printf()
{
	std::cout << "实例内存地址是: " << this << std::endl;
}

//测试例

#include <stdlib.h>

#include "Single.h"



int main()
{
	//单例模式测试
	A* p1 = A::GetInstance();
	p1->Printf();

	A* p2 = A::GetInstance();
	p2->Printf();
	
}

//测试结果截图

二、Qt 单例模式

单例模式保证一个类仅有一个实例，并提供一个访问它的的全局访问点。

　　① 定义私有的静态对象、对象指针或引用

　　② 将该类构造函数设为private，防止外部用new来实例化

　　③ 外部仅能通过公有静态成员函数获得唯一对象

　　单例的实现方式分为懒汉式 和 饿汉式。

　　如下是饿汉式的实现方式：

//demo 饿汉式
//.h
#pragma once
#include <qobject.h>
#include <QMutex>

class Global :
    public QObject
{
        Q_OBJECT
public:
    ~Global();
    static Global* GetInstance();
    void sinTest();

private:
    Global();

    static Global* m_instance;
    static QMutex  m_mutex;
};

//.cpp
#include "Global.h"
#include <QDebug>


Global* Global::m_instance = nullptr;
QMutex  Global::m_mutex;

Global::Global()
{

}

Global::~Global()
{

}

Global* Global::GetInstance()
{
    if (m_instance == nullptr)
    {
        QMutexLocker locker(&m_mutex);
        if (m_instance == nullptr)
        {
            m_instance = new Global();
        }
    }
    return m_instance;
}

void Global::sinTest()
{
    qDebug() << "This is Single test example.";
}