【C++设计模式】Singleton模式（单例模式）

1万 · 2014-10-24 10:17

我们怎样去创建一个唯一的变量（对象）？保证这个类只有唯一的对象是很有必要的。在很多应用中是这样的。

1万 · 2014-10-24 10:18

单例模式UML图：

1万 · 2014-10-24 10:32

头文件：singleton.h
#ifndef _SINGLETON_H_
#define _SINGLETON_H_

#include <iostream>
using namespace std;

class Singleton
{
      static Singleton * instance;

public:
      Singleton();
      static Singleton *Instance();
};

#endif

1万 · 2014-10-24 10:33

cpp文件：singleton.cpp
#include "singleton.h"

#include <iostream>
using namespace std;

Singleton * Singleton::instance=0;

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

Singleton * Singleton::Instance()
{
      if(instance==0)

            instance=new Singleton();

      return instance;

}

int main(int argc,char* argv[])
{
      Singleton* sgn = Singleton::Instance();

      return 0;
}

1万 · 2014-10-24 10:34

g++编译运行结果：
[root@localhost singleton]# g++ -o os singleton.cpp
[root@localhost singleton]# ls
os singleton.cpp singleton.h
[root@localhost singleton]# ./os
Singleton....

1万 · 2014-10-24 10:38

各位，请思考一下单例模式的用处是什么？

1万 · 2014-10-24 10:41

CTRL+C CTRL+V一个单例模式的介绍：

单实例设可能是使用最广泛的设计模式。其思想意图是保证一个类只有一个实例，并且提供类对象的全程访问。单实例对象应用的范围很广：如GUI应用必须是单鼠标，MODEM的联接需要一条且只需要一条电话线，操作系统只能有一个窗口管理器，一台PC连一个键盘。本文将讨论如何用C++实现单实例模式，并解释如何优化单线程应用的设计。

设计方案

使用全程对象能够保证方便地访问实例，但是不能保证只声明一个对象-也就是说除了一个全程实例外，仍然能创建相同类的本地实例。单实例模式通过类本身来管理其唯一实例，这种特性提供了问题的解决办法。唯一的实例是类的一个普通对象，但设计这个类时，让它只能创建一个实例并提供对此实例的全程访问。唯一实例类Singleton在静态成员函数中隐藏创建实例的操作。习惯上把这个成员函数叫做Instance()，它的返回值是唯一实例的指针。Singleton的定义如下：

class Singleton
{
public:
static Singleton* Instance();
protected:
Singleton();
Singleton(const Singleton&);
Singleton& operator= (const Singleton&);
private:
static Singleton* pinstance;
};

你还可以创建诸如Mouse，FileManager，Scheduler等为名字的类并声明相应的成员。为了保证用户不能创建类的本地实例，Singleton的构造器是赋值操作符，构造函数的副本被声明为protected。类中还声明了一个私有的静态实例指针。当第一次调用静态函数Instance()时，它创建唯一实例，将实例地址赋值给pinstance，然后返回这个地址。在每次并发调用中，Instance()也将只返回这个地址。

下面是类的实现：

Singleton* Singleton::pinstance = 0;// 初始化指针
Singleton* Singleton::Instance ()
{
if (pinstance == 0) // 是第一次调用吗?
{
pinstance = new Singleton; // 创建唯一实例
}
return pinstance; // 唯一实例的地址
}
Singleton::Singleton()
{
//... 实现必要的实例初始化
}

用户访问唯一实例的方法只有Instance()成员函数。如果不通过这个函数，任何创建实例的尝试都将失败，因为类的构造函数是被保护的。Instance()使用懒惰初始化，也就是说它返回的值是当这个函数被首次访问时被创建的。这是一种防弹设计-所有Instance()之后的调用都返回相同实例的指针：

Singleton *p1 = Singleton::Instance();
Singleton *p2 = p1->Instance();
Singleton & ref = * Singleton::Instance();

虽然本文的例子针对的是单实例，但对Instance()稍加修改，这个设计模板便可适用于可变多实例情况。如一个类允许最多五个实例。

优化Singleton类，使之适用于单线程应用

Singleton使用操作符new为唯一实例分配存储空间。因为new操作符是线程安全的，在多线程应用中你可以使用此设计模板。但是有一个缺陷：就是在应用程序终止之前必须手工用delete摧毁实例。否则，不仅导致内存溢出，还要造成不可预测的行为，因为Singleton的析构函数将根本不会被调用。而通过使用本地静态实例代替动态实例，单线程应用可以很容易避免这个问题。以下是与上面的Instance()稍有不同的实现，这个实现专门用于单线程应用：

Singleton* Singleton::Instance ()
{
static Singleton inst;
return &inst;
}

本地静态对象实例inst是第一次调用Instance()时被构造，一直保持活动状态直到应用程序终止。指针pinstance变得多余并可以从类定义中删除掉。与动态分配对象不同，静态对象当应用程序终止时被自动销毁掉，所以就不必再手动销毁实例了。

1万 · 2014-10-24 10:48

源码：用g++编译即可。

1万 · 2014-11-21 18:16

yyy71cj 发表于 2014-11-7 21:19
文字太少了，要多些文字

其实做mcu开发的都不关注这个，但是这个蛮有用的，不过暂时没时间去把它通俗化，等有写书的冲动时候吧。

1万 · 2014-12-25 09:18

[cpp] view plaincopy在CODE上查看代码片派生到我的代码片

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

   ~Singleton()
   {
         cout << "~Singleton"<<endl;
   }
private:

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

   这种实现方式利用了static修改函数内部的变量，当第一次调用GetInstance函数时，系统将构造一个Singleton对象，在后续再次调用这个函数时，系统不再执行这个语句，也就不会再构造Singleton类对象了，而直接返回instance_本身。另外，当Singleton类对象生命周期结束时，对象会自动调用析构函数销毁，这里也就不存在申请资源之类的了，需要注意的是GetInstance()函数返回的是引用，这样就不会调用拷贝构造函数了，使用时也应该声明Singleton的引用，如下：


[cpp] view plaincopy在CODE上查看代码片派生到我的代码片

int main()
{
   Singleton &s1 = Singleton::GetInstance();
   Singleton &s2 = Singleton::GetInstance(); //s1与s2是同一对象的引用

   return 0;
}

1万 · 2014-12-25 09:19

上面是单例模式的另一种实现，和前者有何不同？

【C++设计模式】Singleton模式（单例模式）

相关下载

相关帖子

突出贡献奖章

沉静之湖泊

七世轮回

技术奇才奖章