设计模式-单件

static变量从某种意义上说就是一个单件，也就是只有一个对象将被创建。它的分创建时机是：当它作为一个类成员变量时，只有当类被创建或说是被分配内存空间时才会创建；如果它是一个函数（包括类的成员函数），里时，只是当成员函数第一次被使用时才会被创建。

首先，我们提供一个文件的单件，为我们在使用文件输入输出时提供方便：

//:LogFile.h

#ifndef LOGFILE_H

#define LOGFILE_H

#include <fstream>

std::ofstream& ologfile();

std::ifstream& ilogfile();

#endif // LOGFILE_H ///:~

 

//:LogFile.cpp {O}

#include "LogFile.h"

std::ofstream& ologfile() {

  static std::ofstream olog( "oLogfile.log");

  return olog;

}

std::ifstream& ilogfile() {

  static std::ifstream ilog("ilogfile.log");

  return ilog;

} ///:~

此时olog和ilog对象将在ologfile()和ilogfile()被调用时创建，所以如果创建以下函数：

//:UseLog1.h

#ifndef USELOG1_H

#define USELOG1_H

void f();

#endif // USELOG1_H ///:~

 

此时ologfile()被使用：

//:UseLog1.cpp {O}

#include "UseLog1.h"

#include "LogFile.h"

void f() {

  ologfile() << __FILE__ << std::endl;

} ///:~

 

同时创建另外一个函数：

//: C10:UseLog2.cpp

//{L} LogFile UseLog1

#include "UseLog1.h"

#include "LogFile.h"

using namespace std;

void g() {

  ologfile() << __FILE__ << endl;

}

 

int main() {

  f();

  g();

} ///:~

 

olog将在f()在main中使用时被创建。

在此我们可以将logfile.h和logfile.cpp保存起来供以后使用，而不必每次重复的去写输入输出文件了。

 

这是《thinking in C++》中提供的一个单件设计模式，他使用的是引用：

 

//:SingletonPattern.cpp

#include <iostream>

using namespace std;

 

class Singleton {

  int i;

  Singleton( int x) : i(x) { }

  ~Singleton(){}

  void operator=(Singleton&);

  Singleton( const Singleton&);

public:

  static Singleton& instance() {

    static Singleton s(47);

    return s;

  }

  int getValue() { return i; }

  void setValue( int x) { i = x; }

};

 

int main() {

  Singleton& s = Singleton::instance();

  cout << s.getValue() << endl;

  Singleton& s2 = Singleton::instance();

  s2.setValue(9);

  cout << s.getValue() << endl;

} ///:~

这里我们注意到在Singleton中构造函数，析构函数，赋值函数，拷贝函数都被私有化，而且赋值函数及自初始化往复运动数没有提供实现，这就杜绝了通过其它途径创建一个对象，只有在静态成员函数instance()被调用时才会唯一的创建一个静态对象。