C++中的单例模式

　　最近遇到几道类似的笔试题：

　　1. 请实现一个单例模式的类，要求线程安全。

　　2. 用C++设计一个不能被继承的类。

　　3. 如何定义一个只能在堆上（栈上）生成对象的类?

　　这些题目本质上都跟单例模式相关。

单例模式

　　单例模式就是保证一个类只有一个实例，并提供一个访问它的全局访问点。首先，需要保证一个类只有一个实例；在类中，要构造一个实例，就必须调用类的构造函数，如此，为了防止在外部调用类的构造函数而构造实例，需要将构造函数的访问权限标记为protected或private；最后，需要提供要给全局访问点，就需要在类中定义一个static函数，返回在类内部唯一构造的实例。

　　下边就是一个常见的单例模式程序例子：

 // 程序1
 1 class Singleton
{
private:
    Singleton(){}
    ~Singleton(){}
    static Singleton *pInstance; 

public:
    static Singleton *GetInstance()        // 对GetInstance稍加修改，这个设计模板便可以适用于可变多实例情况，如一个类允许最多五个实例。
    {
        if (pInstance == NULL)             //判断是否第一次调用
        {
            pInstance = new Singleton ();
        }
        return pInstance;
    }

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

};

Singleton *Singleton ::pInstance = NULL;

　　该程序保证在不调用类中的静态函数的情况下，不能够在类外创建该类的实例（因为构造函数为私有函数）；另外，在非多线程模式下只能创建该类的一个实例。

　　注：

　　1. 因为上述构造函数或析构函数为私有函数，所以该类是无法被继承的，满足文章开头提到的第二题。

　　2. 该类的实例只能被创建在堆上（new），因为析构函数被声明为私有函数，满足文章开头提到的第三题。具体原因摘自博文如何限制对象只能建立在堆上或者栈上：　　

　　“ 

　　在C++中，类的对象建立分为两种，一种是静态建立，如A a；另一种是动态建立，如A* ptr=new A；这两种方式是有区别的。

　　静态建立一个类对象，是由编译器为对象在栈空间中分配内存，是通过直接移动栈顶指针，挪出适当的空间，然后在这片内存空间上调用构造函数形成一个栈对象。使用这种方法，直接调用类的构造函数。

　　动态建立类对象，是使用new运算符将对象建立在堆空间中。这个过程分为两步，第一步是执行operator new()函数，在堆空间中搜索合适的内存并进行分配；第二步是调用构造函数构造对象，初始化这片内存空间。这种方法，间接调用类的构造函数。

　　... ...

　　类对象只能建立在堆上，就是不能静态建立类对象，即不能直接调用类的构造函数。

　　容易想到将构造函数设为私有。在构造函数私有之后，无法在类外部调用构造函数来构造类对象，只能使用new运算符来建立对象。然而，前面已经说过，new运算符的执行过程分为两步，C++提供new运算符的重载，其实是只允许重载operator new()函数，而operator()函数用于分配内存，无法提供构造功能。因此，这种方法不可以。

　　当对象建立在栈上面时，是由编译器分配内存空间的，调用构造函数来构造栈对象。当对象使用完后，编译器会调用析构函数来释放栈对象所占的空间。编译器管理了对象的整个生命周期。如果编译器无法调用类的析构函数，情况会是怎样的呢？比如，类的析构函数是私有的，编译器无法调用析构函数来释放内存。所以，编译器在为类对象分配栈空间时，会先检查类的析构函数的访问性，其实不光是析构函数，只要是非静态的函数，编译器都会进行检查。如果类的析构函数是私有的，则编译器不会在栈空间上为类对象分配内存。

　　... ...

　　只有使用new运算符，对象才会建立在堆上，因此，只要禁用new运算符就可以实现类对象只能建立在栈上。将operator new()设为私有即可。代码如下：

class A
{
private:
    void* operator new(size_t t){}     // 注意函数的第一个参数和返回值都是固定的
    void operator delete(void* ptr){}  // 重载了new就需要重载delete
public:
    A(){}
    ~A(){}
};

　　” 

自动析构实例

　　我们知道，对于类Singleton的实例，最后我们需要显式调用DestroyInstance函数来释放内存。那有没有一种方法可以让程序自动析构实例呢？

　　要自动析构实例，这里我们需要用到C++中的RAII（Resource Acquisition Is Initialization）机制。具体地，我们在类Singleton中在声明一个静态类（析构函数释放Singleton实例内存）并定义一个该类的静态实例。这样，在Singleton实例被析构时，该静态实例的析构函数会被自动调用，所以最终能够将Singleton实例的内存自动释放掉。具体程序如下：

 // 程序2
 1 class Singleton
{
private:
    Singleton(){}
    ~Singleton(){}
    static Singleton *pInstance;

    class Garbo                           //它的唯一工作就是在析构函数中删除Singleton的实例  
    {
    public:
        ~Garbo()
        {
            if (pInstance != NULL)
            {
                delete pInstance;
                pInstance = NULL;
                cout << "Delete instance!" << endl;
            }
        }
    };
    static Garbo garbo;                    //定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数 

public:
    static Singleton *GetInstance()        // 对GetInstance稍加修改，这个设计模板便可以适用于可变多实例情况，如一个类允许最多五个实例。
    {
        if (pInstance == NULL)             //判断是否第一次调用
        {
            pInstance = new Singleton();
            cout << "Create instance" << endl;
        }
        return pInstance;
    }

};

Singleton *Singleton::pInstance = NULL;
Singleton::Garbo Singleton::garbo;

　　这个程序可能会显得麻烦臃肿，我们可以改进成这个样子：

 // 程序3
 1 class Singleton
{
private:
    Singleton(){}                        // 构造函数是私有的
    // ~Singleton(){}                    // 在这里不可以声明为private。因为我们在函数GetInstance声明定义了位于栈上的变量，
                                         // 这样程序结束时会自动调用析构函数（为private则调用不了，编译不通过）.

public:
    static Singleton& GetInstance()
    {
        static Singleton instance;        // 局部静态变量
        return instance;
    }
};

int main()
{
    Singleton singleton1 = Singleton::GetInstance();
    Singleton singleton2 = singleton1;
    cout << &singleton1 << endl;
    cout << &singleton2 << endl;

    return 0;
}

　　这一下，程序简洁又能够在程序运行结束时自动释放实例内存。但我们发现，在测试（main函数）时，我们发现singleton1和singleton2的地址并不一样，也就是说，这个程序存在漏洞，即通过默认拷贝函数可以生成不止一个类的实例。不过我们可以考虑将默认拷贝函数和默认赋值函数权限设定为private或protect：

 // 程序4
 1 class Singleton
{
private:
    Singleton(){}                        // 构造函数是私有的
    Singleton(const Singleton& orig){};
    Singleton& operator=(const Singleton& orig){};
    // ~Singleton(){}                    // 在这里不可以声明为private。因为我们在函数GetInstance声明定义了位于栈上的变量，
                                         // 这样程序结束时会自动调用析构函数（为private则调用不了，编译不通过）.

public:
    static Singleton& GetInstance()
    {
        static Singleton instance;        // 局部静态变量
        return instance;
    }
};

int main()
{
    Singleton singleton1 = Singleton::GetInstance();    // 通不过编译，实际会调用默认拷贝函数
    Singleton singleton2 = singleton1;                  // 通不过编译，因为会调用默认拷贝函数
    cout << &singleton1 << endl;
    cout << &singleton2 << endl;

    return 0;
}

　　接下来，我们继续改进这个程序：

 // 程序5
 1 class Singleton
{
private:
    Singleton(){}                        // 构造函数是私有的
    // ~Singleton(){}                    // 在这里不可以声明为private。因为我们在函数GetInstance声明定义了位于栈上的变量，
                                         // 这样程序结束时会自动调用析构函数（为private则调用不了，编译不通过）.

public:
    ~Singleton(){ cout << "~Singleton is called!" << endl; }
    static Singleton* GetInstance()
    {
        static Singleton instance;       // 局部静态变量
        return &instance;
    }
};

int main()
{
    Singleton *singleton1 = Singleton::GetInstance();
    Singleton *singleton2 = singleton1;
    Singleton *singleton3 = Singleton::GetInstance();
    cout << singleton1 << endl;
    cout << singleton2 << endl;
    cout << singleton3 << endl;

    return 0;
}

　　程序运行结果如下：

　　

　　结果证明了最后改进的这个程序能够只生成一个类的实例，而且在程序结束时能够自动调用析构函数释放内存。

考虑多线程

 　　对于程序5而言，不存在线程竞争的问题；但对程序1和程序2而言是存在这个问题的。这里以程序2为例来说明如何避免线程竞争：

class Singleton
{
private:
    Singleton(){}
    ~Singleton(){}
    static Singleton *pInstance;

    class Garbo                           //它的唯一工作就是在析构函数中删除Singleton的实例  
    {
    public:
        ~Garbo()
        {
            if (pInstance != NULL)
            {
                Lock();
                if (pInstance != NULL)
                {
                    delete pInstance;
                    pInstance = NULL;
                    cout << "Delete instance!" << endl;
                }
                Unlock();
            }
        }
    };
    static Garbo garbo;                  //定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数 

public:
    static Singleton *GetInstance()        // 对GetInstance稍加修改，这个设计模板便可以适用于可变多实例情况，如一个类允许最多五个实例。
    {
        if (pInstance == NULL)            //判断是否第一次调用
        {
            Lock();
            if (pInstance == NULL)        // 此处进行了两次m_Instance == NULL的判断，是借鉴了Java的单例模式实现时，
                                          // 使用的所谓的“双检锁”机制。因为进行一次加锁和解锁是需要付出对应的代价的，
                                          // 而进行两次判断，就可以避免多次加锁与解锁操作，同时也保证了线程安全。
            {
                pInstance = new Singleton();
                cout << "Create instance" << endl;
            }
            Unlock();
        }
        return pInstance;
    }

};

Singleton *Singleton::pInstance = NULL;
Singleton::Garbo Singleton::garbo;

参考资料

　　C++中的单例模式

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

　　如何限制对象只能建立在堆上或者栈上