Singleton：有内存泄漏吗？

Question

这是一个简单的单例：

class Singleton
{
    Singleton();
    virtual ~Singleton();

    Singleton * Singleton::getInstance() 
    {
        static Singleton * instance;

        if (!instance) {
            instance = new Singleton();
        };
        return instance;
    };
}

主代码第一次调用Singleton::getInstance()->someMethod()时，类不是实例化了两次吗？会不会有内存泄露？

我之所以问，是因为 Visual Leak Detector 检测到内存泄漏与 new Singleton()。

Answer 1

主代码第一次调用Singleton::getInstance()->someMethod()时，类不是实例化了两次吗？

没有。调用Singleton 的静态成员不会实例化Singleton，因此此处存在的唯一Singleton 实例是您使用new 创建的实例。而且你只创建一次，因为一旦instance 指向它，你就再也不会调用new。

但是，您在这里遇到的一个问题是您未能使getInstance 成为静态成员函数。我认为这是一个错字/疏忽，否则，您的程序甚至无法编译。事实上，即使作为非静态成员，声明也是格式错误的。此外，构造函数应该是 private 以强制执行只有 getInstance 可以实例化类型的概念。

会不会有内存泄漏？

是的，这就是 Leak Detector 报告的内容。然而，它是最小的：问题是在你的程序关闭之前，delete 那个单例实例没有任何东西。

坦率地说，我不会担心。这可能是可以接受泄漏的罕见情况之一，主要是因为不仅仅是“泄漏”，它只是在进程关闭时取消分配的一次性失败。

但是，如果您完全摆脱指针，那么您可以同时避免这两个问题，因为您的程序所做的最后一件事就是销毁静态存储持续时间的对象：

#include <iostream>

class Singleton
{
public:
    ~Singleton()  { std::cout << "destruction!\n"; }

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

    void foo() { std::cout << "foo!\n"; }

private:
    Singleton() { std::cout << "construction!\n"; }
};

int main()
{
    Singleton::getInstance().foo();
}

// Output:
//   construction!
//   foo!
//   destruction!

(live demo)

甚至不需要指针！

这具有额外的好处，即整个函数本质上是线程安全的，至少在 C++11 中是这样。

Answer 2

@LightnessRacesInOrbit 的答案是正确的，而且切中要害。由于您的问题以某种方式致力于实现单例时的最佳实践（您应该尽量避免顺便说一句），我会给您我的看法。您可以使用称为Curiously Recurring Template Pattern 的东西来创建Singleton 基类，它将您想要创建单例的类作为模板参数。一旦你正确地做到了这一点，创建单例就像在公园里散步一样。只需从Singleton<Foo> 派生Foo 并将Foo::Foo() 和Foo::~Foo() 设为私有即可。这是我使用的代码，带有 cmets，live on Coliru：

// Singleton pattern via CRTP (curiously recurring template pattern)
// thread safe in C++11 and later

#include <iostream>
#include <type_traits>

// generic Singleton via CRTP
template <typename T>
class Singleton
{
protected:
    Singleton(const Singleton&) = delete; // to prevent CASE 3
    Singleton& operator=(const Singleton&) = delete; // to prevent CASE 4
    Singleton() noexcept = default; // to allow creation of Singleton<Foo>
    // by the derived class Foo, since otherwise the (deleted)
    // copy constructor prevents the compiler from generating
    // a default constructor;
    // declared protected to prevent CASE 5
public:
    static T& get_instance()
    noexcept(std::is_nothrow_constructible<T>::value)
    {
        static T instance;
        return instance;
    }
    // thread local instance
    static thread_local T& get_thread_local_instance()
    noexcept(std::is_nothrow_constructible<T>::value)
    {
        static T instance;
        return instance;
    }
};

// specific Singleton instance
// use const if you want a const instance returned
// make the constructor and destructor private
class Foo: public Singleton</*const*/ Foo>
{
    // so Singleton<Foo> can access the constructor and destructor of Foo
    friend class Singleton<Foo>;
    Foo() // to prevent CASE 1
    {
        std::cout << "Foo::Foo() private constructor" << std::endl;
    }
    // OK to be private, since Singleton<Foo> is a friend and can invoke it
    ~Foo() // to prevent CASE 2
    {
        std::cout << "Foo::~Foo() private destructor" << std::endl;
    }
public:
    void say_hello()
    {
        std::cout << "\t Hello from Singleton" << std::endl;
    }
};

int main()
{
    Foo& sFoo = Foo::get_instance();
    sFoo.say_hello();

    Foo& sAnotherFoo = Foo::get_instance(); // OK, get the same instance
    sAnotherFoo.say_hello();

    Foo& sYetAnotherFoo = sFoo; // still OK, get the same instance
    sYetAnotherFoo.say_hello();

    thread_local Foo& stlFoo = Foo::get_thread_local_instance(); // thread local instance
    stlFoo.say_hello();

    // CASE 1: error: 'Foo::Foo()' is private
    // Foo foo;
    // Foo* psFoo = new Foo;

    // CASE 2: error: 'Foo::~Foo()' is private
    Foo* psFoo = &Foo::get_instance(); // can get pointer
    psFoo->say_hello();
    // delete psFoo; // cannot delete it

    // CASE 3: error: use of deleted function 'Foo::Foo(const Foo&)'
    // Foo foo(sFoo);

    // CASE 4: error: use of deleted function 'Foo& Foo::operator=(const Foo&)'
    // sFoo = sAnotherFoo;

    // CASE 5: error: 'Singleton<T>::Singleton() [with T = Foo]' is protected
    // Singleton<Foo> direct_sFoo;
}

Answer 3

new Singleton() 没有匹配的delete，所以是的，您正在泄漏资源。

程序关闭时你会取回内存，但程序结束时并非所有资源都返回。

您可以通过将实例设为std::auto_ptr 或std::unique_ptr 来修复它。或者干脆不使用指针。