C++单例模式的实现（二）

最新推荐文章于 2024-05-19 17:18:13 发布
置顶 最新推荐文章于 2024-05-19 17:18:13 发布
阅读量2.1k 收藏 9
点赞数
文章标签： 单例模式 c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34793133/article/details/80522603
版权

题目：实现Singleton模

1 解法一：单线程解法

缺点：多线程情况下，每个线程可能创建出不同的Singleton实例

#include <iostream>
using namespace std;

class Singleton
{
public:
	static Singleton* GetInstance()
	{
		static Singleton instance;		// 局部静态对象
		return &instance;
	}

	~Singleton()
	{
		cout << "~Singleton ..." << endl;
	}

private:
	Singleton(const Singleton& other);
	Singleton& operator=(const Singleton& other);
	Singleton()
	{
		cout << "Singleton ..." << endl;
	}
};

int main(void)
{
	Singleton* s1 = Singleton::GetInstance();
	Singleton* s2 = Singleton::GetInstance();

    	return 0;
}

模板实现单例模式，法一 

//string,h文件包含如下内容
#include <iostream>
using namespace std;

template <typename T>
class Singleton
{
   public:
	   static T& getInstance()
	   {
		   static T instance;
		   return instance;
	   }
	 
	
   private:
	   Singleton(const Singleton& other);
	   Singleton& operator=(const Singleton& other);
	
	   Singleton();
	   ~Singleton();
};

//01.cpp内容如下
//Singleton.h文件如下内容

#include "Singleton.h"
class ApplicationImp1
{
public:
	ApplicationImp1()
	{
		cout << "ApplicationImp1..." << endl;
	}
	~ApplicationImp1()
	{
		cout << "~ApplicationImp1..." << endl;
	}

	void Run()
	{
		cout << "Run..." << endl;
	}
};

typedef Singleton<ApplicationImp1> Application;

int main()
{
	//Application a;
	Application::getInstance().Run();
	Application::getInstance().Run();

	return 0;

}

模板实现单例模式，法二（学着用此法）

//01.cpp与上例相同.将Singleton.h修改如下：
//运行结果同上例

#include <iostream>
using namespace std;

template <typename T>
class Singleton
{
public:
	static T& getInstance()
	{
		Init();  //静态成员函数不能调用非静态成员函数，所以把Init()定义成静态的
		return *instance_;
	}

private:
	Singleton(const Singleton& other);
	Singleton& operator=(const Singleton& other);
	Singleton();
	~Singleton();

	static T* instance_;
	static void Init()
	{
		if (instance_ == 0)
		{
			instance_ = new T;
			atexit(Destroy);
		}
	}

	static void Destroy()
	{
	  delete instance_;
	}
};

template<typename T>
T* Singleton<T> ::instance_ = 0;

2 ：多线程+加锁

​ 解法1是最简单，也是最普遍的实现方式，也是现在网上各个博客中记述的实现方式，但是，这种实现方式，有很多问题，比如：没有考虑到多线程的问题，在多线程的情况下，就可能创建多个Singleton实例，以下版本是改善的版本。 
​ 注意：下面的代码涉及互斥锁以及多线程测试，使用了C++11的多线程库，std::thread,，std::mutex，请使用支持C++11多线程的编译器，并确认开启了C++11的编译选项，具体方法见：Windows下CodeBlocks配置 支持C++11 多线程 std::thread_我想有个长长的名字的博客-CSDN博客_codeblocks多线程

#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
using namespace std;

class Singleton
{
public:
	Singleton()
	{
		cout << "Singleton......." << endl;
	}

	~Singleton()
	{
		cout << "~Singleton......." << endl;
	}
	static Singleton* getInstance(){
		if (m_pInstance == NULL){
			m_mutex.lock(); // 使用C++11中的多线程库
			if (m_pInstance == NULL){ // 两次判断是否为NULL的双重检查
				m_pInstance = new Singleton();
			}
			m_mutex.unlock();
		}
		return m_pInstance;
	}

	class Garbo
	{
	public:
		~Garbo()
		{
			if (Singleton::m_pInstance != NULL)
				delete m_pInstance;
		}

	};
	//static void destroyInstance(){
	//	if (m_pInstance != NULL){
	//		delete m_pInstance;
	//		m_pInstance = NULL;
	//	}
	//}
private:
	static Garbo garbo_;

	static mutex m_mutex; // 互斥量
	static Singleton* m_pInstance;

	Singleton(const Singleton& other);
	Singleton& operator=(const Singleton& other);
};

Singleton::Garbo Singleton::garbo_;
Singleton* Singleton::m_pInstance = NULL; 
mutex Singleton::m_mutex;


void print_singleton_instance(){
	Singleton *singletonObj = Singleton::getInstance();
	cout << singletonObj << endl;
}

// 多个进程获得单例
void Test1(){
	// 预期结果，打印出相同的地址，之间可能缺失换行符，也属正常现象
	vector<thread> threads;
	for (int i = 0; i < 10; ++i){
		threads.push_back(thread(print_singleton_instance));
	}

	for (auto& thr : threads){
		thr.join();
	}
}

int main(){
	Test1();
	//Singleton::destroyInstance();
	return 0;
}

​ 此处进行了两次m_pInstance == NULL的判断，是借鉴了Java的单例模式实现时，使用的所谓的“双检锁”机制。因为进行一次加锁和解锁是需要付出对应的代价的，而进行两次判断，就可以避免多次加锁与解锁操作，同时也保证了线程安全。但是，如果进行大数据的操作，加锁操作将成为一个性能的瓶颈；为此，一种新的单例模式的实现也就出现了。

3 ：const static 型实例

#include <iostream>
#include <thread>
#include <vector>
using namespace std;

class Singleton
{
private:
    Singleton(){}
    static const Singleton* m_pInstance;
public:
    static Singleton* getInstance(){

        return const_cast<Singleton *>(m_pInstance); // 去掉“const”特性
        // 注意！若该函数的返回值改为const static型，则此处不必进行const_cast静态转换
        // 所以该函数可以改为：
        /*
        const static Singleton* getInstance(){
            return m_pInstance;
        }
        */
    }

    static void destroyInstance(){
        if(m_pInstance != NULL){
            delete m_pInstance;
            m_pInstance = NULL;
        }
    }
};
const Singleton* Singleton::m_pInstance = new Singleton(); // 利用const只能定义一次，不能再次修改的特性，static继续保持类内只有一个实例

void print_singleton_instance(){
    Singleton *singletonObj = Singleton::getInstance();
    cout << singletonObj << endl;
}

// 多个进程获得单例
void Test1(){
    // 预期结果，打印出相同的地址，之间可能缺失换行符，也属正常现象
    vector<thread> threads;
    for(int i = 0; i < 10; ++i){
        threads.push_back(thread(print_singleton_instance));
    }

    for(auto& thr : threads){
        thr.join();
    }
}

int main(){
    Test1();
    Singleton::destroyInstance();
    return 0;
}

​ 因为静态初始化在程序开始时，也就是进入主函数之前，由主线程以单线程方式完成了初始化，所以静态初始化实例保证了线程安全性。在性能要求比较高时，就可以使用这种方式，从而避免频繁的加锁和解锁造成的资源浪费。由于上述三种实现，都要考虑到实例的销毁，关于实例的销毁，待会在分析。

4：在get函数中创建并返回static临时实例的引用

PS：该方法不能人为控制单例实例的销毁

#include <iostream>
#include <thread>
#include <vector>
using namespace std;

class Singleton
{
private:
    Singleton(){}

public:
    static Singleton* getInstance(){
        static Singleton m_pInstance; // 注意，声明在该函数内
        return &m_pInstance;
    }
};

void print_singleton_instance(){
    Singleton *singletonObj = Singleton::getInstance();
    cout << singletonObj << endl;
}

// 多个进程获得单例
void Test1(){
    // 预期结果，打印出相同的地址，之间可能缺失换行符，也属正常现象
    vector<thread> threads;
    for(int i = 0; i < 10; ++i){
        threads.push_back(thread(print_singleton_instance));
    }

    for(auto& thr : threads){
        thr.join();
    }
}

// 单个进程获得多次实例
void Test2(){
    // 预期结果，打印出相同的地址，之间换行符分隔
    print_singleton_instance();
    print_singleton_instance();
}

int main(){
    cout << "Test1 begins: " << endl;
    Test1();
    cout << "Test2 begins: " << endl;
    Test2();
    return 0;
}

以上就是四种主流的单例模式的实现方式。

5 ：最终方案，最简&显式控制实例销毁

​ 在上述的四种方法中，除了第四种没有使用new操作符实例化对象以外，其余三种都使用了；

​ 我们一般的编程观念是，new操作是需要和delete操作进行匹配的；是的，这种观念是正确的。在上述的实现中，是添加了一个destoryInstance的static函数，这也是最简单，最普通的处理方法了；但是，很多时候，我们是很容易忘记调用destoryInstance函数，就像你忘记了调用delete操作一样。由于怕忘记delete操作，所以就有了智能指针；那么，在单例模型中，没有“智能单例”，该怎么办？怎么办？

​ 在实际项目中，特别是客户端开发，其实是不在乎这个实例的销毁的。因为，全局就这么一个变量，全局都要用，它的生命周期伴随着软件的生命周期，软件结束了，它也就自然而然的结束了，因为一个程序关闭之后，它会释放它占用的内存资源的，所以，也就没有所谓的内存泄漏了。

​ 但是，有以下情况，是必须需要进行实例销毁的：

  1. 在类中，有一些文件锁了，文件句柄，数据库连接等等，这些随着程序的关闭而不会立即关闭的资源，必须要在程序关闭前，进行手动释放；
  2. 具有强迫症的程序员。

​ 在代码实现部分的第四种方法能满足第二个条件，但是无法满足第一个条件。好了，接下来，就介绍一种方法，这种方法也是我从网上学习而来的，代码实现如下：

#include <iostream>
#include <thread>
#include <vector>
using namespace std;

class Singleton
{
private:
    Singleton(){}
    static Singleton* m_pInstance;

    // **重点在这**
    class GC // 类似Java的垃圾回收器
    {
    public:
        ~GC(){
            // 可以在这里释放所有想要释放的资源，比如数据库连接，文件句柄……等等。
            if(m_pInstance != NULL){
                cout << "GC: will delete resource !" << endl;
                delete m_pInstance;
                m_pInstance = NULL;
            }
        };
    };

    // 内部类的实例
    static GC gc;

public:
    static Singleton* getInstance(){
        return m_pInstance;
    }
};


Singleton* Singleton::m_pInstance = new Singleton();
Singleton::GC Singleton::gc;

void print_instance(){
    Singleton* obj1 = Singleton::getInstance();
    cout << obj1 << endl;
}

// 多线程获取单例
void Test1(){
    // 预期输出：相同的地址，中间可能缺失换行符，属于正常现象
    vector<thread> threads;
    for(int i = 0; i < 10; ++i){
        threads.push_back(thread(print_instance));
    }

    for(auto& thr : threads){
        thr.join();
    }
}

// 单线程获取单例
void Test2(){
    // 预期输出：相同的地址，换行符分隔
    print_instance();
    print_instance();
    print_instance();
    print_instance();
    print_instance();
}

int main()
{
    cout << "Test1 begins: " << endl;
    cout << "预期输出：相同的地址，中间可以缺失换行（每次运行结果的排列格式通常不一样）。" << endl;
    Test1();
    cout << "Test2 begins: " << endl;
    cout << "预期输出：相同的地址，每行一个。" << endl;
    Test2();
    return 0;
}
  • 参考：https://blog.csdn.net/huhaijing/article/details/51756225
虚心学习进步
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++ 实现单类模式
thomas1997ster的博客
12-07 187
设计模式名称： singleton 设计模式解决的问题：实现只实例一个对象，程序其他地方应用它；比如程序的日子类，方便代码任何地方都可以使用，同时避免参数的传递。 设计模式的设计思想：定义一个类，其中包括了静态的方法获取或者实例化该单类，生产或者获得方法有些特别，其他方法都都普通C/C++特性，如多态性。值得注意是一个普通的全局变量的对象或者static 变量对象有时候不够完成单类的任务，有如
C++设计模式之单例模式
路过的熊的博客
06-16 2389
C++设计模式之单例模式
C++单例模式
zt18786458319的博客
11-16 290
（2）一般单例模式通常有两种形式：它的构造函数为private的，必须有一个静态方法，静态方法返回自己的实例；实现形式有两种：懒汉式和饿汉式；所谓的饿汉式就是在声明实例的时候直接初始化对象，而懒汉式是先声明一个空对象，在静态方法中实例化该对象并返回。一个类只有一个实例，单例模式的关键是static关键字的使用：static修饰类的成员变量时，在main()函数开始执行前就被初始化；（1）避免在开发过程中，创建出一个类的多个实例（占用空间，性能问题），所以使用单例模式，保证该类只创建一个对象。
C++实现单例模式(详细版)
最新发布
ReLesEason的博客
05-19 865
以循序渐进地方式详细介绍各种单例模式C++实现方法（详细写了6种方法）及其特点，并给出了测试案例
C++的三种单例模式-----深度解析
热门推荐
zhc的博客
03-06 10万+
简介 因为在设计或开发中，肯定会有这么一种情况，一个类只能有一个对象被创建，如果有多个对象的话，可能会导致状态的混乱和不一致。这种情况下，单例模式是最恰当的解决办法。它有很多种实现方式，各自的特性不相同，使用的情...
C++单例对象是什么？（单例模式）
Dontla的博客
04-07 445
在面向对象编程中，单例模式是一种创建型设计模式，用于确保类只有一个实例，并提供一个全局访问点以访问该实例。在单例模式中，类的构造函数被声明为私有，以防止通过常规的构造函数创建类的多个实例。取而代之的是，该类提供了一个静态方法来返回单个实例，如果该实例不存在，则该方法将创建一个新实例。单例对象是由单例模式创建的唯一实例，通常具有全局可访问的公共访问点。单例对象在整个程序的生命周期内只被创建一次，即只有一个实例对象。单例模式很难进行单元测试，因为它的实例是全局唯一的，很难模拟出多个实例的情况。
C++ 单例模式的几种实现方式研究
08-26
"C++ 单例模式的几种实现方式研究" 单例模式是设计模式中最常应用的一种模式，也是面试官最喜欢的题目。但是，如果没有学过设计模式的人，可能不会想到要去应用单例模式，面对单例模式适用的情况。 单例模式的主要...
C++单例模式应用实例
12-31
本文实例讲述了C++单例模式及其相关应用方法，分享给大家供大家参考。具体方法分析如下： 定义： 一个类有且仅有一个实例，并且提供一个访问它的全局访问点。 要点： 1、类只能有一个实例； 2、必须自行创建此实例；...
C++实现 单例模式实例详解
08-30
经典实现是最基本的单例模式实现方式，通过使用静态成员变量和静态成员函数来实现单例模式。其主要特点是只有当getInstance()函数被调用时，实例才被创建。 class Singleton { public: static Singleton* ...
使用C++11实现线程安全的单例模式
04-05
线程安全的单例模式实现可以基于静态局部变量和`std::call_once`。以下是一个简单的示例： ```cpp #include class Singleton { private: Singleton() {} // 私有构造函数 static std::once_flag init_flag; ...
【C++】—— 单例模式详解
m0_56069910的博客
09-07 827
c++ 单例模式详解
C++实现的单例模式代码
06-08
本人使用C++实现的单例模式，实现方式有三种，包括单线程下的，多线程下的代码。
如何在 C++ 中实现一个单例类模板
12-16
单例模式是最简单的设计模式之一。在实际工程中，如果一个类的对象重复持有资源的成本很高，且对外接口是线程安全的，我们往往倾向于将其以单例模式管理。 此篇我们在 C++ 中实现正确的单例模式。 选型 在 C++ 中，单例模式有两种方案可选。 一是实现一个没有可用的公开构造函数的基类，并提供 GetInstance 之类的静态接口，以便访问子类唯一的对象。由于子类构造必须调用基类构造，但基类无公开构造函数可用，这使得子类对象只能由基类及基类的友元来构造，从而在机制上保证单例。 二是实现一个类模板，其模板参数是希望由单例管理的类的名字，并提供 GetInstance 之类的静态接口。这种做法的
C++类和对象之对象组织和单例模式
yolan2626的博客
04-22 260
主要介绍：对象的组织，如const 对象 指向对象的指针，对象数组，堆对象，还有单例模式的思路和代码实现
C++ 单例模式(泛型, 线程安全)
PX1525813502的博客
11-20 449
单例模式，支持线程安全初始化, 可变模板参数与完美转发
C++中的单例模式
编程资料大全
04-14 1294
单例模式也称为单件模式、单子模式，可能是使用最广泛的设计模式。其意图是保证一个类仅有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。有很多地方需要这样的功能模块，如系统的日志输出，GUI应用必须是单鼠标，MODEM的联接需要一条且只需要一条电话线，操作系统只能有一个窗口管理器，一台PC连一个键盘。 单例模式有许多种实现方法，在C++中，甚至可以直接用一个全局变量做到这一点，...
C++单例基类模板
猪头三
01-09 5204
这是一个比较完善的c++单例基类模板，有很详细的注释。
C++实现单例模式（包括采用C++11中的智能指针）
FS's Home
02-05 2万+
对于设计模式来说，以前只是看过基础的理论，很多都没有实现和使用过。这段时间看到了别人C++代码中使用了单例模式，发现了很多新的东西，特此总结记录一下。说话比较啰嗦，希望由浅入深，帮助大家理解！     单例模式，顾名思义，即一个类只有一个实例对象。C++一般的方法是将构造函数、拷贝构造函数以及赋值操作符函数声明为private级别，从而阻止用户实例化一个类。那么，如何才能获得该类的对象呢？这时，
c++ 单例模式
weixin_40581617的博客
08-03 1416
C++编程语言是一个应用广泛的计算机应用语言，它功能强大，在一定程度上大大提高了程序开发效率。C++单例模式也称为单件模式、单子模式。使用单例模式，保证一个类仅有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。有很多地方需要这样的功能模块，如系统的日志输出等。 单例模式有许多种实现方法，在C++中，甚至可以直接用一个全局变量做到这一点，但这样的代码显得很不优雅。定义一个单例类，...
c++单例模式代码实现
06-09
以下是C++中单例模式的代码实现： ```cpp class Singleton { private: static Singleton* instance; Singleton() {} ...注意，该实现虽然满足单例模式的要求，但不是线程安全的，需要在多线程环境下进行改进。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值