重读《设计模式》之学习笔记（三）－－SINGLETON模式的疑惑

    《More Effective C++》的条款26限制某个class所能产生的对象数量中也讲解了本书的3.5节的SINGLETON模式。3.5节一开始就说明了该模式的意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
    然而，两本书在产生唯一的实例的方法上却是截然相反。本书使用类的静态成员函数，而《More Effective C++》中却用静态对象。他们唯一的相同之处就是都批评了另外一种方法。下面是两本书中的原文（两本书分别指出了另外一种方法的好几种缺点，下面的仅仅是两本书中相反的论述）：
    《设计模式》：使用全局/静态对象的实现方法还有另一个（尽管很小）的缺点，它使得所有单件无论用到与否都要被创建。使用静态成员函数避免了所有这些问题。
    《More Effective C++》：「class拥有一个static对象」的意思是，纵使从未被用到，它也会被构造（及析构）。相反地「函数拥有一个static对象」的意思是，此对象在函数第一次被调用时才产生。
    这使我非常疑惑！
    一个说在全局函数中使用的静态对象无论使用与否都会被创建，使用静态成员函数可以避免这个问题；而另一个却说类中的静态对象无论使用与否都会被创建，在全局函数中使用静态对象可以避免这个问题。这完全是相反的论述，我们到底该相信谁的呢？
    虽然他们的论述完全相反，但是他们有一个基本出发点是相同的－－避免创建不被使用的对象。下面我用自己的代码来分别表述两本书推荐的方法：
    《Design Patterns》：

class  ClxSingletonDP
{
public :
     static  ClxSingletonDP *  InstanceDP();

private :
     static  ClxSingletonDP *  m_pInstance;
    ClxSingletonDP();
};

ClxSingletonDP *  ClxSingletonDP::m_pInstance  =  NULL;

ClxSingletonDP *  ClxSingletonDP::InstanceDP()
{
     if  (m_pInstance  ==  NULL)
        m_pInstance  =   new  ClxSingletonDP;

     return  m_pInstance;
}

    《More Effective C++》：

class  ClxSingletonMEC
{
public :
    friend ClxSingletonMEC &  InstanceMEC();

private :
    ClxSingletonMEC();
};

ClxSingletonMEC &  InstanceMEC()
{
     static  ClxSingletonMEC Instance;
     return  Instance;
}

    其实，仔细研究代码就会知道，两本书的观点并不冲突。本书中指的全局对象肯定是不管使用与否都会被创建，而静态对象也是是指全局的静态对象，当然也是不管使用与否都会被创建；而《More Effective C++》却很巧妙的避开了这一点，使用了函数中的静态对象，使得这个静态对象只在函数被调用的时候创建；同时，本书使用的是类中一个指向对象的静态指针，而不是《More Effective C++》书中所批评的类的静态对象，这样就可以使对象的创建延迟到第一次使用。
    两种方法的区别就是一个是返回对象的指针，一个是返回对象的引用。我个人观点是，最好使用后者。优点是：1、不用担心对象的销毁，前一种方法得到的对象的指针是new出来的，如果忘记了delete就会造成内存泄漏；2、声明对象时必须初始化，如果忘记初始化，在编译阶段就会得到一个不能访问私有构造函数的错误信息。

2007年6月13号补充：

    针对第二种方法，每次要使用类ClxStringtonMEC的唯一对象，都必须调用函数InstanceMEC()来获取该唯一对象。为了防止错误的使用InstanceMEC()函数，必须将类ClxStringtonMEC的拷贝构造函数也设置为私有的！下面用一个详细一点儿的代码来说明：

class  ClxSingletonMEC
{
public :
    friend ClxSingletonMEC &  InstanceMEC();

     void  SetValue( int  iValue) { m_iValue  =  iValue; };
     int  GetValue() {  return  m_iValue; };

private :
    ClxSingletonMEC() : m_iValue( 0 ) {};
    ClxSingletonMEC( const  ClxSingletonMEC  & lxSington) {};

     int  m_iValue;
};

ClxSingletonMEC &  InstanceMEC()
{
     static  ClxSingletonMEC Instance;
     return  Instance;
} 

    下面是一段正确的使用代码：

cout  <<  InstanceMEC().GetValue()  <<  endl;   //  输出0

InstanceMEC().SetValue( 13 );

cout  <<  InstanceMEC().GetValue()  <<  endl;   //  输出13

    而下面的代码将不能通过编译：

ClxSingletonMEC lxMEC  =  InstanceMEC();

    如果类ClxSingletonMEC的拷贝构造函数不为私有的话，那么上面的代码就会调用拷贝构造函数，那么lxMEC就是函数InstanceMEC()返回值的一个副本。那在程序中类ClxSingletonMEC的对象就不是唯一的了。也就不能是SINGLETON模式了。所以，类ClxSingletonMEC的拷贝构造函数必须为私有的。

2007年10月30日补充：

    虽然要用类似下面这种看起来比较怪诞的代码来得到对象的指针，但是毕竟这种可能是存在的。

ClxSingletonMEC  * p  =   & InstanceMEC();

//  ......

delete p;

    所以类ClxSingletonMEC的析构函数也应该是私有的。（这里要感谢purewinter在评论里面指出这个问题。）
    下面是简化后的正确代码：

class  ClxSingletonMEC
{
public :
    friend ClxSingletonMEC &  InstanceMEC();

private :
    ClxSingletonMEC() {};
    ClxSingletonMEC( const  ClxSingletonMEC  & lxSington) {};
     ~ ClxSingletonMEC() {};
};

ClxSingletonMEC &  InstanceMEC()
{
     static  ClxSingletonMEC Instance;
     return  Instance;
} 

2007年10月31日补充：

    这里说明一下昨天补充的代码里面delete p;这行代码的危害。其实，这样的代码可以通过编译，但是却会在运行期出现错误。因为p指向的是一个静态对象，是存放在进程全局数据区的，是不能被delete的（delete操作只能delete堆上的对象），这些对象在进程结束的时候才会被销毁。

    昨天，我以上面的例子发表了一篇《C++中friend对类封装性的强大破坏性》的文章，说明了为什么把类ClxSingletonMEC的析构函数定义为private的后，在进程结束的时候（已经离开friend函数的作用范围）系统还能调用该析构函数。没想到却引发了很多网友的讨论，最后还从对friend的讨论牵扯到了对Singleton模式的实现。其实最好的实现方法是用类的静态函数，里面声明一个局部的静态对象，而且类的构造函数，析构函数，拷贝构造函数，赋值操作符函数都是私有的。下面就是详细的代码：

class  ClxSingleton
{
public :
     static  ClxSingleton &  GetInstance()
    {
        static ClxSingleton Instance;
         return  Instance;
    };

private :
    ClxSingleton() {};
    ClxSingleton( const  ClxSingleton & ) {};
    ClxSingleton &   operator = ( const  ClxSingleton) {};
     ~ ClxSingleton() {};
};