utilities（C++）——单例（Singleton） （使用智能指针 shared_ptr）

utilities（C++）——单例（Singleton）

上文简单版的单例类的实现的一大核心问题，在于new出来的堆对象不会被释放，就有可能造成内存泄漏的风险。

class Singleton
{
public:
    // 通过类名获得类实例指针
    static Singleton* instance()
    {
        if (!_instance)
            _instance = new Singleton;
        return _instance;
    }
    ~Singleton()
    {
        std::cout << "Singleton::~Singleton()" << std::endl;
    }
private:
    // 禁止拷贝
    Singleton(const Singleton& );
    Singleton& operator=(const Singleton& );
    // 将构造函数声明为私有的
    Singleton()
    {
        std::cout <<"Singleton::Singleton()" << std::endl;
    }
    static Singleton* _instance;
};

Singleton* Singleton::_instance = NULL;

int main(int, char**)
{
    Singleton* s1 = Singleton::instance();
    Singleton* s2 = Singleton::instance();
                    // 只会调用其构造函数
                    // 而不会调用其析构函数
    return 0;
}

法一

我们可在单例类内部给出一个 destroy 函数用于对 new 出来的对象进行析构，然后在客户端显式地进行调用。

void destroy()
{
    delete _instance;
    _instance = 0;
}

法二

智能指针是进行内存管理的重要工具。我们就以智能指针对类实例指针进行封装，已达到释放堆内存的作用。

#include <iostream>
#include <boost\shared_ptr.hpp>

class Singleton
{
public:
    static boost::shared_ptr<Singleton> instance()
    {
        if (_instance == 0)
            _instance = boost::shared_ptr<Singleton>(new Singleton);
        return _instance;
    }

    ~Singleton()
    {
        std::cout << "Singleton::~Singleton()" << std::endl;
    }
private:
    Singleton(const Singleton&);
    Singleton()
    {
        std::cout << "Singleton::Singleton()" << std::endl;
    }
    Singleton& operator=(const Singleton&);
    static boost::shared_ptr<Singleton> _instance;
};

boost::shared_ptr<Singleton> Singleton::_instance = NULL;

int main(int, char**)
{
    boost::shared_ptr<Singleton> s = Singleton::instance();
    boost::shared_ptr<Singleton> s2 = Singleton::instance();

    return 0;
}