C++单体类 || 单例模式 的实现

单件模式是设计模式中最简单的模式了。

    定义： 确保一个类只有一个实例，并提供一个全局的访问点。

• 把一个类设计成自己管理的一个单独实例，同时避免其他类再自行生成实例(所以构造函数用protect或privite)
• 也提供全局的访问点。public函数

一、

普通Singleton

#include<iostream>
using namespace std;


class Singleton
{
    public:
        static Singleton* getInstance();


    private:
        static Singleton* instance;
        
        Singleton() 
        {
            cout<<"constructor\n";
            // do something 
        };


        ~Singleton()
        {
            cout<<"destructor\n";
            //do something
        }
};


Singleton* Singleton::instance = NULL;


Singleton* Singleton::getInstance()
{
    if(instance == NULL)
        instance = new Singleton();
    return instance;
}


int main()
{
    cout<<"begin main\n";
    Singleton* instance = Singleton::getInstance();
    cout<<"end main\n";
}

但是这样构造函数不会自动调用，需要用户这个类的用户手动delete instance. 这样是不太好的

这是懒汉式的，在多线程的情况下需要同步。也可以写成饿汉式的，但是c++里面写成饿汉式的不太好，如果有多个单例类，而他们是相互引用的，那么饿汉式就有可能出问题。因为在C++中，这几个单例类的静态成员的初始化顺序是不确定的。

二、

2B的Singleton

#include<iostream>

using namespace std;


class Singleton
{
    public:
        static Singleton* getInstance();


    private:
        static Singleton* instance;
        
        Singleton() 
        {
            cout<<"constructor\n";
            // do something 
        };


        ~Singleton()
        {
            cout<<"destructor\n";
            //do something
        }


        class Garbo
        {
            public:
                ~Garbo()
                {
                    cout<<"Garbo destructor\n";
                    if(Singleton::instance != NULL)
                        delete Singleton::instance;
                }
        };


        static Garbo garbo;
};


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


Singleton* Singleton::getInstance()
{
    if(instance == NULL)
        instance = new Singleton();
    return instance;
}


int main()
{
    cout<<"begin main\n";
    Singleton* instance = Singleton::getInstance();
    cout<<"end main\n";
}

用了一个内部类, Garbo。 由于main结束后，会自动释放 garbo， 而garbo就会调用instance的destructor.

三、

文艺Singleton

#include<iostream>
using namespace std;


class Singleton
{
    public:
        static Singleton* getInstance();


    private:
        static Singleton instance;
        
        Singleton() 
        {
            cout<<"constructor\n";
            // do something 
        };


        ~Singleton()
        {
            cout<<"destructor\n";
            //do something
        }
};


Singleton Singleton::instance;


Singleton* Singleton::getInstance()
{
    return &instance;
}


int main()
{
    cout<<"begin main\n";
    Singleton* instance = Singleton::getInstance();
    cout<<"end main\n";
}

instance在main开始前就已经构造好了，在main结束后会自动释放。

但是这样的话，只能是饿汉式的singleton。如果在构造函数中需要申请大量资源，这些资源就一直存在在整个运行阶段。而不管这些资源什么时候需要，什么时候不许要。

#include<iostream>
using namespace std;


class Singleton
{
    public:
        static Singleton* getInstance();


    private:
        
        Singleton() 
        {
            cout<<"constructor\n";
            // do something 
        };


        ~Singleton()
        {
            cout<<"destructor\n";
            //do something
        }
};


Singleton* Singleton::getInstance()
{
    static Singleton instance;
    return &instance;
}


int main()
{
    cout<<"begin main\n";
    Singleton* instance = Singleton::getInstance();
    cout<<"end main\n";
}

这样，就可以在需要的时候再构造singleton， 也就是懒汉式的