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答案是正确的，并且重点突出。因为你的问题在某种程度上致力于实施Singleton时的最佳实践（你应该尽量避免使用它），我会给你我的看法。您可以使用名为Curiously Recurring Template Pattern的内容来创建Singleton基类，该基类将您要创建Singleton的类作为模板参数。一旦你做得正确，创建单身就像在公园散步。只需从Foo派生Singleton<Foo>，然后将Foo::Foo()和Foo::~Foo()设为私有。这是我使用的代码，带有注释， 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来解决此问题。或者只是不要使用指针。

Singleton：有内存泄漏吗？

3 个答案:

（live demo）