玩技术,Geeker
一个原创技术文章分享网站

C++设计模式——单例模式

问题描述

现在,不管开发一个多大的系统(至少我现在的部门是这样的),都会带一个日志功能;在实际开发过程中,会专门有一个日志模块,负责写日志,由于在系统的任何地方,我们都有可能要调用日志模块中的函数,进行写日志。那么,如何构造一个日志模块的实例呢?难道,每次new一个日志模块实例,写完日志,再delete,不要告诉我你是这么干的。在C++中,可以构造一个日志模块的全局变量,那么在任何地方就都可以用了,是的,不错。但是,我所在的开发部门的C++编码规范是参照Google的编码规范的。

全局变量在项目中是能不用就不用的,它是一个定时炸弹,是一个不安全隐患,特别是在多线程程序中,会有很多的不可预测性;同时,使用全局变量,也不符合面向对象的封装原则,所以,在纯面向对象的语言Java和C#中,就没有纯粹的全局变量。那么,如何完美的解决这个日志问题,就需要引入设计模式中的单例模式。

单例模式

何为单例模式,在GOF的《设计模式:可复用面向对象软件的基础》中是这样说的:保证一个类只有一个实例,并提供一个访问它的全局访问点。首先,需要保证一个类只有一个实例;在类中,要构造一个实例,就必须调用类的构造函数,如此,为了防止在外部调用类的构造函数而构造实例,需要将构造函数的访问权限标记为protected或private;最后,需要提供要给全局访问点,就需要在类中定义一个static函数,返回在类内部唯一构造的实例。意思很明白,使用UML类图表示如下。

UML类图

Singleton Pattern

代码实现

单例模式,单从UML类图上来说,就一个类,没有错综复杂的关系。但是,在实际项目中,使用代码实现时,还是需要考虑很多方面的。

实现一:

/*
** FileName     : SingletonPatternDemo1
** Author       : Jelly Young
** Date         : 2013/11/20
** Description  : More information, please go to http://www.jellythink.com
*/

#include <iostream>
using namespace std;

class Singleton
{
public:
	static Singleton *GetInstance()
	{
		if (m_Instance == NULL )
		{
			m_Instance = new Singleton ();
		}
		return m_Instance;
	}

	static void DestoryInstance()
	{
		if (m_Instance != NULL )
		{
			delete m_Instance;
			m_Instance = NULL ;
		}
	}

	// This is just a operation example
	int GetTest()
	{
		return m_Test;
	}

private:
	Singleton(){ m_Test = 10; }
	static Singleton *m_Instance;
	int m_Test;
};

Singleton *Singleton ::m_Instance = NULL;

int main(int argc , char *argv [])
{
	Singleton *singletonObj = Singleton ::GetInstance();
	cout<<singletonObj->GetTest()<<endl;

	Singleton ::DestoryInstance();
	return 0;
}

这是最简单,也是最普遍的实现方式,也是现在网上各个博客中记述的实现方式,但是,这种实现方式,有很多问题,比如:没有考虑到多线程的问题,在多线程的情况下,就可能创建多个Singleton实例,以下版本是改善的版本。

实现二:

/*
** FileName     : SingletonPatternDemo2
** Author       : Jelly Young
** Date         : 2013/11/20
** Description  : More information, please go to http://www.jellythink.com
*/

#include <iostream>
using namespace std;

class Singleton
{
public:
	static Singleton *GetInstance()
	{
		if (m_Instance == NULL )
		{
			Lock(); // C++没有直接的Lock操作,请使用其它库的Lock,比如Boost,此处仅为了说明
			if (m_Instance == NULL )
			{
				m_Instance = new Singleton ();
			}
			UnLock(); // C++没有直接的Lock操作,请使用其它库的Lock,比如Boost,此处仅为了说明
		}
		return m_Instance;
	}

	static void DestoryInstance()
	{
		if (m_Instance != NULL )
		{
			delete m_Instance;
			m_Instance = NULL ;
		}
	}

	int GetTest()
	{
		return m_Test;
	}

private:
	Singleton(){ m_Test = 0; }
	static Singleton *m_Instance;
	int m_Test;
};

Singleton *Singleton ::m_Instance = NULL;

int main(int argc , char *argv [])
{
	Singleton *singletonObj = Singleton ::GetInstance();
	cout<<singletonObj->GetTest()<<endl;
	Singleton ::DestoryInstance();

	return 0;
}

此处进行了两次m_Instance == NULL的判断,是借鉴了Java的单例模式实现时,使用的所谓的“双检锁”机制。因为进行一次加锁和解锁是需要付出对应的代价的,而进行两次判断,就可以避免多次加锁与解锁操作,同时也保证了线程安全。但是,这种实现方法在平时的项目开发中用的很好,也没有什么问题?但是,如果进行大数据的操作,加锁操作将成为一个性能的瓶颈;为此,一种新的单例模式的实现也就出现了。

实现三:

/*
** FileName     : SingletonPatternDemo3
** Author       : Jelly Young
** Date         : 2013/11/20
** Description  : More information, please go to http://www.jellythink.com
*/

#include <iostream>
using namespace std;

class Singleton
{
public:
	static Singleton *GetInstance()
	{
		return const_cast <Singleton *>(m_Instance);
	}

	static void DestoryInstance()
	{
		if (m_Instance != NULL )
		{
			delete m_Instance;
			m_Instance = NULL ;
		}
	}

	int GetTest()
	{
		return m_Test;
	}

private:
	Singleton(){ m_Test = 10; }
	static const Singleton *m_Instance;
	int m_Test;
};

const Singleton *Singleton ::m_Instance = new Singleton();

int main(int argc , char *argv [])
{
	Singleton *singletonObj = Singleton ::GetInstance();
	cout<<singletonObj->GetTest()<<endl;
	Singleton ::DestoryInstance();
}

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

实现四:

/*
** FileName     : SingletonPatternDemo4
** Author       : Jelly Young
** Date         : 2013/11/20
** Description  : More information, please go to http://www.jellythink.com
*/

#include <iostream>
using namespace std;

class Singleton
{
public:
	static Singleton *GetInstance()
	{
		static Singleton m_Instance;
		return &m_Instance;
	}

	int GetTest()
	{
		return m_Test++;
	}

private:
	Singleton(){ m_Test = 10; };
	int m_Test;
};

int main(int argc , char *argv [])
{
	Singleton *singletonObj = Singleton ::GetInstance();
	cout<<singletonObj->GetTest()<<endl;

	singletonObj = Singleton ::GetInstance();
	cout<<singletonObj->GetTest()<<endl;
}

以上就是四种主流的单例模式的实现方式,如果大家还有什么好的实现方式,希望大家能推荐给我。谢谢了。

实例销毁

在上述的四种方法中,除了第四种没有使用new操作符实例化对象以外,其余三种都使用了;我们一般的编程观念是,new操作是需要和delete操作进行匹配的;是的,这种观念是正确的。在上述的实现中,是添加了一个DestoryInstance的static函数,这也是最简单,最普通的处理方法了;但是,很多时候,我们是很容易忘记调用DestoryInstance函数,就像你忘记了调用delete操作一样。由于怕忘记delete操作,所以就有了智能指针;那么,在单例模型中,没有“智能单例”,该怎么办?怎么办?

那我先从实际的项目中说起吧,在实际项目中,特别是客户端开发,其实是不在乎这个实例的销毁的。因为,全局就这么一个变量,全局都要用,它的生命周期伴随着软件的生命周期,软件结束了,它也就自然而然的结束了,因为一个程序关闭之后,它会释放它占用的内存资源的,所以,也就没有所谓的内存泄漏了。但是,有以下情况,是必须需要进行实例销毁的:

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

以上,就是我总结的两点。

虽然,在代码实现部分的第四种方法能满足第二个条件,加上析构函数能满足第一个条件。好了,接下来,就介绍另一种方法,这种方法也是我从网上学习而来的,代码实现如下:

/*
** FileName     : SingletonPatternDemo5
** Author       : Jelly Young
** Date         : 2013/11/20
** Description  : More information, please go to http://www.jellythink.com
*/

#include <iostream>
using namespace std;

class Singleton
{
public:
	static Singleton *GetInstance()
	{
		return m_Instance;
	}

	int GetTest()
	{
		return m_Test;
	}

private:
	Singleton(){ m_Test = 10; }
	static Singleton *m_Instance;
	int m_Test;

	// This is important
	class GC
	{
	public :
		~GC()
		{
			// We can destory all the resouce here, eg:db connector, file handle and so on
			if (m_Instance != NULL )
			{
				cout<< "Here is the test" <<endl;
				delete m_Instance;
				m_Instance = NULL ;
			}
		}
	};
	static GC gc;
};

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

int main(int argc , char *argv [])
{
	Singleton *singletonObj = Singleton ::GetInstance();
	cout<<singletonObj->GetTest()<<endl;

	return 0;
}

在程序运行结束时,系统会调用Singleton的静态成员GC的析构函数,该析构函数会进行资源的释放,而这种资源的释放方式是在程序员“不知道”的情况下进行的,而程序员不用特别的去关心,使用单例模式的代码时,不必关心资源的释放。那么这种实现方式的原理是什么呢?我剖析问题时,喜欢剖析到问题的根上去,绝不糊涂的停留在表面。由于程序在结束的时候,系统会自动析构所有的全局变量,实际上,系统也会析构所有类的静态成员变量,就像这些静态变量是全局变量一样。我们知道,静态变量和全局变量在内存中,都是存储在静态存储区的,所以在析构时,是同等对待的。

由于此处使用了一个内部GC类,而该类的作用就是用来释放资源,而这种使用技巧在C++中是广泛存在的,在后面的博客中,我会总结这一技巧,参见《C++中的RAII机制》

模式扩展

在实际项目中,一个模式不会像我们这里的代码那样简单,只有在熟练了各种设计模式的特点,才能更好的在实际项目中进行运用。单例模式和工厂模式在实际项目中经常见到,两种模式的组合,在项目中也是很常见的。所以,有必要总结一下两种模式的结合使用。

一种产品,在一个工厂中进行生产,这是一个工厂模式的描述;而只需要一个工厂,就可以生产一种产品,这是一个单例模式的描述。所以,在实际中,一种产品,我们只需要一个工厂,此时,就需要工厂模式和单例模式的结合设计。由于单例模式提供对外一个全局的访问点,所以,我们就需要使用简单工厂模式中那样的方法,定义一个标识,用来标识要创建的是哪一个单件。由于模拟代码较多,在文章最后,提供下载链接。

总结

为了写这篇文章,自己调查了很多方面的资料,由于网上的资料在各方面都有很多的瑕疵,质量参次不齐,对我也造成了一定的误导。而这篇文章,有我自己的理解,如有错误,请大家指正。

由于该文对设计模式的总结,我认为比网上80%的都全面,希望对大家有用。在实际的开发中,并不会用到单例模式的这么多种,每一种设计模式,都应该在最适合的场合下使用,在日后的项目中,应做到有地放矢,而不能为了使用设计模式而使用设计模式。

工程下载

2013年11月21日 于大连、东软。

未经允许不得转载:果冻想 » C++设计模式——单例模式

分享到:更多 ()

评论 95

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址
  1. #0

    写的确实不错,从第一节课看到这里了,单例模式我还需要好好理解下,顺便赞一个楼主的博客,简洁且美观哈

    msccreater3年前 (2013-12-23)回复
    • 谢谢~

      Jelly3年前 (2013-12-24)回复
  2. #0

    感谢楼主无私的分享。但有个问题:Singleton *Singleton ::m_Instance = new Singleton();何不改为Singleton *Singleton ::m_Instance = &Singleton();呢?这样在Singleton类析构中释放资源不可以吗?

    bingran63年前 (2014-01-03)回复
    • 谢谢!谢谢你与我分享你的想法。对于你说的Singleton *Singleton ::m_Instance = &Singleton();,你考虑的很周到,但是,Singleton()此处构造的是一个临时变量,会很快就会被销毁的,此处建立对象是没有意义的。你可以亲自实验一下。希望能再次和你进行讨论。

      果冻想3年前 (2014-01-03)回复
      • 您好,我想问下静态变量不是存储于静态存储区吗?它的生命周期和程序周期一样,为什么您说Singleton此处构造的是一个临时变量呢?

        小届哥哥3年前 (2014-06-16)回复
        • 谢谢你和我分享你的看法。是的,你的理解没有问题。这里是一个静态变量,但是这个静态变量是一个指针,说明这个静态变量是指向一个内存区域的,如果你使用&Singleton();初始化这个静态变量时,这个静态变量的指针指向了这块内存,而Singleton()这块内存是在栈上开辟的,当出了作用域时,这块内存就被释放了,也就是说,静态的指针变量还是指向这篇内存的,而这篇内存已经无效了,这个静态指针变量已经是一个“野指针”了。这是我的理解。

          果冻想3年前 (2014-06-25)回复
      • 这里我觉得疑惑: &Singleton()这里的“临时变量”是类外定义的,应该是具有全局声明周期的,因此很快就被销毁,不是很理解你的意思。根据网上所言,c++中的临时变量是const的,因此我觉得会不会是因为常量的原因。文章很好,赞一个。学习了。[嘻嘻]

        xiaolu1年前 (2015-09-14)回复
        • C++的临时变量是const的???

          果冻想1年前 (2015-09-14)回复
    • Singleton *Singleton ::m_Instance = &Singleton();
      这种语法正确吗?
      编译不通过
      error: taking address of temporary [-fpermissive]
      Singleton *Singleton ::m_Instance = &Singleton();
      ^

      Msign_1周前 (01-06)回复
  3. #0

    方法四没有考虑线程安全

    greatt1n3年前 (2014-03-10)回复
    • 亲爱的。你四种方法是不需要考虑线程安全的。知道问什么么?考虑一下。

      宁采臣3年前 (2014-03-11)回复
      • 没想明白,麻烦指点一下,谢谢

        locy3年前 (2014-04-30)回复
        • 那个是静态变量。

          果冻想3年前 (2014-04-30)回复
          • 还是有多线程问题,局部静态变量在第一次调用时初始化,多线程调用可能会导致初始化多次

            phanil2年前 (2015-01-19)
          • 不,这是线程安全的。

            果冻想2年前 (2015-01-19)
          • 这里有篇文章,可以阅读以下:http://anotherlayer.net/2012/05/04/static-initialization-and-thread-safety/

            果冻想2年前 (2015-01-19)
          • 我阅读了下这篇文章,说是新C++标准才支持线程安全的局部静态变量初始化,原文是这样的“That’s true, as I mentioned above. It’s worth noting that they won’t be safe in Microsoft Visual C++ until the VS2014 release”,也就是说直到vs2014才有可能支持这个标准(C++ 11标准才引入),所以我建议大家还是不要这样用比较好

            phanil2年前 (2015-01-21)
          • 是的,很高兴你和我这么深入的讨论这个问题。对于C++11标准,各个编译器厂家的支持都是不一致的。

            果冻想2年前 (2015-01-21)
  4. #0

    嗯。第四种方法是不需要考虑线程安全的。

    果冻想3年前 (2014-04-18)回复
  5. #0

    谢谢分享,博客很赞,简洁大方美观,用什么模板做的呀~~~~

    Koala3年前 (2014-04-24)回复
    • 是在别人的博客主题上进行定制的。具体名字我也忘了。

      果冻想3年前 (2014-06-25)回复
  6. #0

    请教下这行代码Singleton *Singleton ::m_Instance = new Singleton();构造函数是private的啊,为什么可以在类外调用,用于初始化static成员

    coolz3年前 (2014-07-27)回复
  7. #0

    写的真好!希望多写一些模式结合使用的例子,像你给的单例模式和简单工厂模式结合。

    fly2年前 (2014-08-11)回复
    • 没问题。我会在以后多多总结设计模式在实际中的应用的实例的。

      果冻想2年前 (2014-08-13)回复
  8. #0

    你好,我尝试将其改成类模板,但是在编译的时候出现了问题,GC没有被构造和析构,我的编译环境是vs2010templateclass CSingleton{public: static T* GetInstance() { return m_Instance; } private: static T* m_Instance; // This is important class CGarbageCollection { public : CGarbageCollection() { ATLTRACE(_T(“CGarbageCollection initrn”)); } ~CGarbageCollection() { // We can destory all the resouce here, eg:db connector, file handle and so on if (m_Instance != NULL ) { ATLTRACE(_T(“Here is the testrn”)); delete m_Instance; m_Instance = NULL ; } } }; static CGarbageCollection GC;};templatetypename CSingleton::CGarbageCollection CSingleton::GC;templateT* CSingleton::m_Instance = new T();

    DJ2年前 (2014-08-14)回复
    • #include using namespace std;class MySingleton;templateclass CSingleton{public: CSingleton() { cout << “constructor” << endl; } static T* GetInstance() { gc; return m_Instance; }private: static T* m_Instance; // This is important class CGarbageCollection { public: CGarbageCollection() { cout << “CGarbageCollection initrn”; } ~CGarbageCollection() { // We can destory all the resouce here, eg:db connector, file handle and so on if (m_Instance != NULL) { cout << “Here is the testrn”; delete m_Instance; m_Instance = NULL; } } }; static CGarbageCollection gc;};templatetypename CSingleton::CGarbageCollection CSingleton::gc;templateT* CSingleton::m_Instance = new T();class MySingleton : public CSingleton{public: MySingleton(){} ~MySingleton(){}};int main(){ MySingleton *pMySingleton = MySingleton::GetInstance(); return 0;}这是一个复杂的问题,至于有多复杂,请看这里:http://stackoverflow.com/questions/1819131/c-static-member-initalization-template-fun-inside可以仔细的阅读以下那份正确的答案。有时间,我们再继续讨论。

      果冻想2年前 (2014-08-15)回复
  9. #0

    你好,我尝试将其改成类模板,但是在编译的时候出现了问题,GC没有被构造和析构,我的编译环境是vs2010templateclass CSingleton{public:static T* GetInstance(){return m_Instance;}private:static T* m_Instance;// This is importantclass CGarbageCollection{public :CGarbageCollection(){ATLTRACE(_T(“CGarbageCollection initrn”));}~CGarbageCollection(){// We can destory all the resouce here, eg:db connector, file handle and so onif (m_Instance != NULL ){ATLTRACE(_T(“Here is the testrn”));delete m_Instance;m_Instance = NULL ;}}};static CGarbageCollection GC;};templatetypename CSingleton::CGarbageCollection CSingleton::GC;templateT* CSingleton::m_Instance = new T();

    DJ2年前 (2014-08-14)回复
  10. #0

    最后一份代码中的GC类 换成析构函数里delete行吗

    李嘉图.M.统2年前 (2014-10-31)回复
    • 那会多次delete 我2了 木事鸟

      李嘉图.M.统2年前 (2014-10-31)回复
      • ???你觉得析构函数会被调用么?

        果冻想2年前 (2014-11-01)回复
        • 你的用GetInstance()直接new出一个 肯定不会析构啦。。。 我自己写了个demo验证后太着急回复。。。结果成了在评论中说成了我的代码了。。。。。。。

          李嘉图.M.统2年前 (2014-11-01)回复
  11. #0

    你这样没有考虑类的复制拷贝和=带来的问题,单例应该这些也要屏蔽掉

    xxm2年前 (2014-11-11)回复
    • 恩,是的。没有考虑这个问题。在实际开发中要考虑这个问题的。

      果冻想2年前 (2014-11-11)回复
  12. #0

    不错 顶一下

    ican2年前 (2014-12-18)回复
  13. #0

    我有点疑惑为什么要在单例里面提供一个销毁这个类的方法,如果是释放资源,完全应该写对应资源的申请和释放的方法,而不是直接销毁整个单例。。

    贝壳2年前 (2015-01-18)回复
    • 那么创建的单例对象,要不要销毁掉呢?

      果冻想2年前 (2015-01-18)回复
  14. #0

    新手,学习了

    刘果宁2年前 (2015-02-06)回复
    • 互相学习的过程。

      果冻想2年前 (2015-02-08)回复
    • 这个是不是需要禁止拷贝和赋值操作?

      笑泪6个月前 (07-07)回复
      • 是的。防止复制。

        果冻想6个月前 (07-07)回复
      • 如果返回指针的,也不用。但是一般都是显示声明为private的。

        果冻想6个月前 (07-07)回复
  15. #0

    既然构造考虑线程安全,销毁的时候也应该考虑线程安全吧。。。

    牧童Damian2年前 (2015-03-26)回复
    • 你的考虑是对的。但是在实际生产项目上,是不需要考虑销毁时的线程安全的。由于单例模式,就创建一个实例,在程序退出时,都是集中进行销毁这一个实例的,也就是说,只有一个线程去做销毁的工作,一般的情况下,我们不会说去使用多个线程去销毁资源,这样的话,是给自己找罪受。

      果冻想2年前 (2015-03-28)回复
  16. #0

    为什么实现三中
    static Singleton *GetInstance()
    {
    return const_cast <Singleton *>(m_Instance);
    }
    const_cast ???为什么要去除const呢?不明白

    张浩1年前 (2015-07-26)回复
    • 为什么返回值类型不设为static const???

      张浩1年前 (2015-07-26)回复
      • 可以返回为const类型的,但是,你把代码copy下来,运行一下,你就会发现为什么了。

        果冻想1年前 (2015-07-27)回复
    • 如果这个单例类中,我要修改m_Test成员变量的值,怎么办???

      果冻想1年前 (2015-07-27)回复
  17. #0

    为什么实现三中
    static Singleton *GetInstance()
    {
    return const_cast <Singleton *>(m_Instance);
    }
    const_cast ???为什么要去除const呢?不明白

    张浩1年前 (2015-07-26)回复
  18. #0

    文章写的很好,有深度,有发散,咱一个。加油

    jackycoder1年前 (2015-08-25)回复
  19. #0

    感谢大牛分享,这是我在网上看到的介绍单例模式最好的博客了

    tastier1年前 (2015-09-14)回复
  20. #0

    Singleton *Singleton ::m_Instance = new Singleton();
    Singleton ::GC Singleton ::gc;
    这个gc 难道不用给他初始化一次? new GC(); 不然他怎么在系统结束时自己析构

    日子1年前 (2015-10-21)回复
    • 不用啊,这个不是指针变量,就是一个静态变量,静态变量的析构由程序全局控制。

      果冻想1年前 (2015-10-21)回复
  21. #0

    看了博主的”模式扩展”中提到的代码——“工厂模式和单例模式的结合”的 SingletonPatternEx.zip。当中,博主将m_instance放在了SingletonFactory 也就是基类当中,基类中的static变量是所有子类共享的,那么当我们在创建FactoryA之后,我们就创建不了FactoryB了,代码中的一段if判断 if(m_instance==NULL){…./*构造对象*/..}。不知道我的理解是否正确,等待博主回复。
    #include
    #include “Constant.h”
    using namespace std;

    // The singleton factory
    class SingletonFactory{
    public:
    static SingletonFactory *GetInstance(FactoryEnum factory);
    virtual void Operation() = 0;
    protected:
    SingletonFactory(){}
    virtual ~SingletonFactory(){}
    private:
    static SingletonFactory *m_Instance;
    class GC
    {………..};
    static GC gc;
    };

    seii1年前 (2015-10-31)回复
    • 是的,只能创建一个工厂。程序一旦启动建立了一个全局的工厂,那么就无法变更工厂。示例代码可能误导你了,Sorry!!!

      果冻想1年前 (2015-11-01)回复
  22. #0

    看了博主的”模式扩展”中提到的代码——“工厂模式和单例模式的结合”的 SingletonPatternEx.zip。当中,博主将m_instance放在了SingletonFactory 也就是基类当中,基类中的static变量是所有子类共享的,那么当我们在创建FactoryA之后,我们就创建不了FactoryB了,代码中的一段if判断 if(m_instance==NULL){…./*构造对象*/..}。不知道我的理解是否正确,等待博主回复。
    #include
    #include “Constant.h”
    using namespace std;

    // The singleton factory
    class SingletonFactory{
    public:
    static SingletonFactory *GetInstance(FactoryEnum factory);
    virtual void Operation() = 0;
    protected:
    SingletonFactory(){}
    virtual ~SingletonFactory(){}
    private:
    static SingletonFactory *m_Instance;
    class GC
    {………..};
    static GC gc;
    };

    seii1年前 (2015-10-31)回复
  23. #0

    哥们,我看你的实现四就是最好的实现啊?局部静态变量是会自动释放的,在程序结束的时候

    richardor1年前 (2015-11-28)回复
  24. #0

    膜拜一下大神,确实,很详细。

    mly10个月前 (03-23)回复
  25. #0

    楼主,貌似现在双重锁已经被证明是不可靠的了,而c++提供了pthread_once,可以借此来实现单例模式,这是大牛陈硕的实现 https://github.com/chenshuo/muduo/blob/master/muduo/base/Singleton.h

    NULL9个月前 (04-10)回复
  26. #0

    不知道,楼主还能不能看到,有个问题一直想问楼主,在创建单例实例时,为什么一定要返回一个指针Singleton *,我如果之间创建一个static Singleton 对象,这样在程序结束时不就会自动销毁对象么?

    优雅的二货9个月前 (04-21)回复
    • 首先,所有回复,我都能看到,并且我都会认真的回答每一个回复。你的这个问题,文中有说啊。你再仔细看看。

      果冻想9个月前 (04-22)回复
  27. #0

    最近也在学习设计模式:
    综合博主的东西,写出来的:
    #include
    #include
    using namespace std;

    class Singleton1
    {
    public:
    static Singleton1 &GetInstance()
    {
    return m_Instance;
    }
    void show()
    {
    cout << m_num << endl;
    }
    private:
    Singleton1()
    {
    m_num = 10;
    }

    int m_num;
    static Singleton1 m_Instance;
    };
    Singleton1 Singleton1::m_Instance;

    class Singleton2
    {
    public:
    static Singleton2 *GetInstance()
    {
    return m_Instance.get();
    }
    void show()
    {
    cout << m_num << endl;
    }
    private:
    Singleton2() { m_num = 10; }
    int m_num;
    static shared_ptr m_Instance;
    };
    shared_ptr Singleton2::m_Instance(new Singleton2);

    void main()
    {
    Singleton2::GetInstance()->show();
    }

    bingxueyidao9个月前 (04-25)回复
    • static shared_ptr m_Instance;
      谢谢分享你的代码。

      果冻想9个月前 (04-26)回复
  28. #0

    最近也在学习设计模式. 综合博主的东西,写出来的:
    #include
    #include
    using namespace std;

    class Singleton1
    {
    public:
    static Singleton1 &GetInstance()
    {
    return m_Instance;
    }
    void show()
    {
    cout << m_num << endl;
    }
    private:
    Singleton1()
    {
    m_num = 10;
    }

    int m_num;
    static Singleton1 m_Instance;
    };
    Singleton1 Singleton1::m_Instance;

    class Singleton2
    {
    public:
    static Singleton2 *GetInstance()
    {
    return m_Instance.get();
    }
    void show()
    {
    cout << m_num << endl;
    }
    private:
    Singleton2() { m_num = 10; }
    int m_num;
    static shared_ptr m_Instance;
    };
    shared_ptr Singleton2::m_Instance(new Singleton2);

    void main()
    {
    Singleton2::GetInstance()->show();
    }

    bingxueyidao9个月前 (04-25)回复
  29. #0

    果冻哥你好,为什么第四个例子我自己在运行的时候并没有看到调用GC类内部的析构函数?

    zhouyang7个月前 (06-08)回复
  30. #0

    楼主您好 请问在方法4中奖instance指针类型改成Singleton类型就可以在程序退出的时候调用析构函数了啊,这样做可以不?
    https://github.com/wizzhangquan/cpp_primer/blob/master/design_patterns/singleton/v4_thread_static_deleteGC/singleton_nopointer.cc
    代码链接

    wizzhangquan6个月前 (07-28)回复
  31. #0

    实现3中static const Singleton *m_Instance;为什么要加一个const?我总感觉有点多余,博主能帮忙解释下么

    嘿嘿5个月前 (08-18)回复
  32. #0

    实现4中也可以做到跟GC类的回收一样的效果,只要把需要释放的内存和需要关闭的操作写在析构函数里不就行了?为什么博主说不行呢?(PS:我是看了第二遍才想到的,不知道有没有弄错)

    嘿嘿5个月前 (08-18)回复
    • 恩。我刚刚也复习了下,可以的。

      果冻想4个月前 (09-08)回复
  33. #0

    写的很不错。之前就看过楼主的lua教程,现在好好把设计模式看一遍~谢谢楼主

    nil5个月前 (08-29)回复
  34. #0

    我觉得比网上95%都要棒,而不是80%!

    品味5个月前 (08-31)回复
  35. #0

    实例四为啥不满足条件一, 在程序结束时也会调用析构函数释放对象,和最后一个没啥区别啊

    laogaoyang4个月前 (09-07)回复
    • 是这样的。如果instance是new的话,就无法使用析构函数了。

      果冻想4个月前 (09-08)回复
      • 可是 实现4中 并没有new,最后程序结束会调用析构函数的

        laogaoyang4个月前 (09-09)回复
        • new了反而并不会主动调用析构的吧。

          果冻想4个月前 (09-09)回复
          • 是啊,new不会,但是没必要刻意去new啊

            laogaoyang4个月前 (09-09)
  36. #0

    然后常用的还是封装成引用计数类型的智能指针,第四种方法是有缺陷的,没有提供给m_Instance设置为NULL的接口,如果外面删除了new出来的内存,那么m_Instance不为NULL的时候就会变成野指针,你删除的时候就会有异常

    无罪契约3个月前 (10-20)回复
    • 我认为“外面删除了这一块内存”,没有这个用法,应该避免.。如果有人这样做,作为惩罚,应该直接让程序挂掉

      sunf2个月前 (11-14)回复
  37. #0

    良心分享啊

    hgz_gavin3个月前 (10-27)回复
  38. #0

    最后一个例子感觉思路很牛叉啊

    hgz_gavin3个月前 (10-27)回复
  39. #0

    看了你的最后一个单例和工厂模式的混用,才发现友元的作用。之前一直在怀疑为什么会出现友元这个玩意。
    所以,大赞博主。

    Msign_1周前 (01-06)回复

在这里玩技术,享受技术带来的疯狂

捐赠名单关于果冻