Design patterns--单例模式

设计模式之单例模式

#ifndef SINGLETON_H
#define SINGLETON_H

// 懒汉式单例模式：在被调用时，对象才被实例化

class Singleton
{
public:
    static Singleton* Instance();
    // 单例对象释放
    static void Destroy();

private:
    Singleton();
    Singleton(const Singleton &);
    Singleton& operator=(const Singleton &);
    ~Singleton();

private:
    static Singleton* _instance;
};

#endif // SINGLETON_H

//========================

#include "singleton.h"
#include <iostream>

Singleton* Singleton::_instance = nullptr;

Singleton *Singleton::Instance()
{
    if(_instance == nullptr){
        _instance = new Singleton();
    }
    return _instance;
}

void Singleton::Destroy()
{
    if(_instance != nullptr){
        delete _instance;
        _instance = nullptr;
    }
}

Singleton::Singleton()
{
    std::cout << "[Lazy] Constructor" << std::endl;
}

Singleton::Singleton(const Singleton &)
{
    std::cout << "Copy Constructor" << std::endl;
}

Singleton &Singleton::operator=(const Singleton &)
{
    std::cout << "Overload assignment operator function" << std::endl;
}

Singleton::~Singleton()
{
    std::cout << "[Lazy] Destructor" << std::endl;
}

---

#ifndef SINGLETONSND_H
#define SINGLETONSND_H

// 饿汉式单例模式：程序运行时，对象主动实例化

class SingletonSnd
{
public:
    static SingletonSnd* Instance();

private:
    SingletonSnd();
    SingletonSnd(const SingletonSnd &);
    SingletonSnd& operator=(const SingletonSnd &);
    ~SingletonSnd();

    class Destroy
    {
    public:
        ~Destroy()
        {
            if(_instance != nullptr){
                delete _instance;
                _instance = nullptr;
            }
        }
    };

private:
    static SingletonSnd* _instance;
    static Destroy destroy;
};

#endif // SINGLETONSND_H

//===========================

#include "singletonsnd.h"
#include <iostream>

SingletonSnd* SingletonSnd::_instance = new SingletonSnd;
SingletonSnd::Destroy SingletonSnd::destroy;

SingletonSnd *SingletonSnd::Instance()
{
    return _instance;
}

SingletonSnd::SingletonSnd()
{
    std::cout << "[Hungry] Constructor" << std::endl;
}

SingletonSnd::SingletonSnd(const SingletonSnd &)
{
    std::cout << "Copy Constructor" << std::endl;
}

SingletonSnd &SingletonSnd::operator=(const SingletonSnd &)
{
    std::cout << "Overload assignment operator function" << std::endl;
}

SingletonSnd::~SingletonSnd()
{
    std::cout << "[Hungry] Destructor" << std::endl;
}

---

#include <iostream>
#include <string>
#include <stdio.h>
#include "singleton.h"
#include "singletonsnd.h"

using namespace std;

int main()
{
    Singleton* obj1 = Singleton::Instance();
    Singleton* obj2 = Singleton::Instance();
    printf("obj1 = 0x%p\n", obj1);
    printf("obj2 = 0x%p\n", obj2);
    obj1->Destroy();

    SingletonSnd* objSnd1 = SingletonSnd::Instance();
    SingletonSnd* objSnd2 = SingletonSnd::Instance();
    cout << "objSnd1 = " << objSnd1 << endl;
    cout << "objSnd2 = " << objSnd2 << endl;

    return 0;
}