[设计模式]单例模式_饿汉_懒汉模式代码片段

@ 单例模式 懒汉式
单例模式是一种对象创建型模式，使用单例模式，可以保证为一个类只生成唯一的实例对象。
也就是说，在整个程序空间中，该类只存在一个实例对象
a) 构造函数私有化
b) 提供一个全局的静态方法（全局访问点）
c) 在类中定义一个静态指针，指向本类的变量的静态变量指针
d)禁用拷贝构造函数
为了管理好单例实例对象 使用智能指针来管理 当对象引用计数为0时智能指针自动帮我们释放
@ 单例模式 懒汉式 遇到多线程 需要加锁
饿汉式 就是不管你用不用 我都帮你 创建对象实例 也无需考虑多线程安全的问题
直接看代码

懒汉式

#pragma once
#include <iostream>
#include <memory>
#include <mutex>
#include <string>
#include <windows.h>
std::mutex g_mutex;
/*
@ 单例模式 懒汉式
单例模式是一种对象创建型模式，使用单例模式，可以保证为一个类只生成唯一的实例对象。
也就是说，在整个程序空间中，该类只存在一个实例对象
a) 构造函数私有化
b) 提供一个全局的静态方法（全局访问点）
c) 在类中定义一个静态指针，指向本类的变量的静态变量指针
d)禁用拷贝构造函数
为了管理好单例实例对象 使用智能指针来管理 当对象引用计数为0时智能指针自动帮我们释放
@ 单例模式 懒汉式 遇到多线程 需要加锁
*/
class singleton 
{
public:
	~singleton() {
		if (!m_SingletonPtr.use_count())
		{
			m_SingletonPtr.reset();
		}
		std::cout << "~singleton 析构函数 智能指针引用计数 = "  << m_SingletonPtr.use_count() << std::endl;
	}
	singleton(const singleton & oter) = delete;
	singleton operator=(const singleton& oter) = delete;
public:
	void output(const std::string& value) {
		Sleep(1000);
		std::cout << "智能指针引用计数 = " << m_SingletonPtr.use_count() << std::endl;
		std::cout << value << std::endl;
	}
	static singleton* GetInstance() {
		/*通过这个函数获取实例对象*/
		if (m_SingletonPtr == nullptr)
		{
			std::lock_guard<std::mutex> lock_mutex(g_mutex); // 加锁 防止多线程 重复创建
			if (m_SingletonPtr.get() == nullptr)
			{
				m_SingletonPtr.reset(new singleton());
			}
		}
		return m_SingletonPtr.get();
	}
private:
	singleton() {
		std::cout << "singleton 构造函数" << std::endl;
	}
private:
	static std::shared_ptr<singleton> m_SingletonPtr;
};
//初始化静态成员变量
std::shared_ptr<singleton> singleton::m_SingletonPtr = nullptr;

饿汉式

#pragma once
#include <iostream>
#include <memory>
#include <mutex>
#include <string>
#include <windows.h>
/*
@ 单例模式 饿汉式
单例模式是一种对象创建型模式，使用单例模式，可以保证为一个类只生成唯一的实例对象。
也就是说，在整个程序空间中，该类只存在一个实例对象
a) 构造函数私有化
b) 提供一个全局的静态方法（全局访问点）
c) 在类中定义一个静态指针，指向本类的变量的静态变量指针
d)禁用拷贝构造函数
饿汉式 就是不管你用不用 我都帮你 创建对象实例 也无需考虑多线程安全的问题
*/
class singleton 
{
public:
	~singleton() {
		if (!m_SingletonPtr.use_count())
		{
			m_SingletonPtr.reset();
		}
		std::cout << "~singleton 析构函数 智能指针引用计数 = "  << m_SingletonPtr.use_count() << std::endl;
	}
	singleton(const singleton & oter) = delete;
	singleton operator=(const singleton& oter) = delete;
public:
	void output(const std::string& value) {
		Sleep(1000);
		std::cout << "智能指针引用计数 = " << m_SingletonPtr.use_count() << std::endl;
		std::cout << value << std::endl;
	}
	static singleton* GetInstance() {
		/*通过这个函数获取实例对象*/
		return m_SingletonPtr.get();
	}
private:
	singleton() {
		std::cout << "singleton 构造函数" << std::endl;
	}
private:
	static std::shared_ptr<singleton> m_SingletonPtr;
};
std::shared_ptr<singleton> singleton::m_SingletonPtr = std::shared_ptr<singleton>(new singleton);

下面是执行代码

执行代码

// 设计模式.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <thread>
//#include "单例模式.hpp"
#include "单例模式_饿汉.hpp"
int main()
{
	for (auto i = 0; i < 10;++i)
	{
		std::thread t([&]() {
			singleton::GetInstance()->output("thread index: " + std::to_string(i));
		});
		t.join();
	}
    std::cout << "Hello World!\n";
}