单例模式：如何会发生析构函数被调用两次的情况？

Question

我几分钟前问了一个关于单例实现的问题，从@LightnessRacesinOrbit那里得到了非常好的答案。

但是我不明白为什么在下一个示例中，如果我在变量inst中实例化Singleton，它的析构函数会被调用两次？

#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 inst = Singleton::getInstance();
    inst.foo();
}

输出：

construction!
foo!
destruction!
destruction!

实时演示

更准确地说，我理解为什么会调用两次。但是，如果在第一个析构函数之后类的实例已被销毁，我就不明白它怎么可能被调用两次了呢？为什么没有异常抛出？

或者说它并没有被销毁吗？为什么？

- vladon

---

将 Singleton(Singleton const&) { std::cout << "copy construction!\n"; } 添加到您的示例中，就会揭示一切。 - Praetorian

你应该使类不可复制和不可移动：Singleton(Singleton const&) = delete; Singleton(Singleton &&) = delete; Singleton &operator=(Singleton const&) = delete;Singleton operator=(Singleton &&) = delete; - bames53

您的程序中有两个Singleton类型的实例。一个是getInstance中的static，另一个是main中的本地变量。每个对象最终都会被销毁，因此有两个析构函数调用。为什么你会对析构函数被调用两次感到惊讶呢？ - AnT stands with Russia

抱歉，我本应该删除拷贝构造函数和赋值运算符。虽然在某种意义上我很高兴我没有这样做，因为这样你就会问这个问题 :) - Lightness Races in Orbit

@LightnessRacesinOrbit 在熟悉编写和使用单例模式之后，接下来可以学习避免使用它们 :) - Cory Kramer

Answer 1

这一行

Singleton inst = Singleton::getInstance();

应该是这样的

Singleton& inst = Singleton::getInstance();

如果按照目前的写法，Singleton::getInstance() 返回一个引用，但是接着会将其复制到 inst 中。所以从你的函数返回的 Singleton 和它的拷贝都被销毁了。你并没有看到复制过程的发生，因为使用的是拷贝构造函数而非默认构造函数。

在第二种方法中，返回引用，然后只需将 inst 设为该 Singleton 的引用，而不是创建副本。

正如其他人提到的那样，你可以将该类定义为不可复制和不可移动，以防止这种情况的发生。

Singleton(Singleton const&) = delete;             // Copy construct
Singleton(Singleton&&) = delete;                  // Move construct
Singleton& operator=(Singleton const&) = delete;  // Copy assign
Singleton& operator=(Singleton &&) = delete;      // Move assign

- Cory Kramer

---

没错。如果你真的想让一个单例成为单例，你需要删除它的复制构造函数或将其设置为私有。 - Fred Larson

不需要显式删除右值引用版本，因为编译器不会自动生成它们。 - Daniel Frey

没有必要为许多事情费心。 - Lightness Races in Orbit

Answer 2

这条线

Singleton inst = Singleton::getInstance();

使用自动生成的拷贝构造函数复制您的实例。为了防止这种情况发生，请添加

Singleton( const Singleton& ) = delete;

为了防止意外复制，您可以将以下代码添加到您的类中。为了确保更多不明显的错误也能被捕捉到，还需要添加：

void operator=( const Singleton& ) = delete;

此外，您无需显式删除移动构造或赋值操作符，因为编译器不会生成它们与其他（已删除）成员声明一起。

- Daniel Frey

---

@πάνταῥεῖ 理论上你是对的，但对于单例来说，本来就不应该存在第二个实例可以分配;) 但是，是可能出现愚蠢的代码意外触发赋值的情况，我会编辑答案。 - Daniel Frey

@DanielFrey 我猜可以做 Singleton::getInstance() = Singleton::getInstance();，虽然有些超出范围，但仍然可行 ;) - vsoftco

@vsoftco 是的，但这已经不是偶然了，这会招来麻烦。 :-D - Daniel Frey

如果可以做到，最终总会有人去做:D 但我完全同意，这是在自找麻烦。 - vsoftco

@vsoftco 这就是为什么我认为对于软件开发人员来说，有点儿偏执狂是一种优势的原因 :-P - Daniel Frey

Answer 3

尝试添加一个公共复制构造函数：

Singleton(const Singleton&) { std::cout << "copy construction!\n"; }

你的输出将变成：

construction!
copy construction!
foo!
destruction!
destruction!

由于从getInstance()获取的单例被复制了，所以现在有两个“单例”存在。为避免无意中复制单例，您应该删除复制构造函数和赋值运算符：

Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;

- isanae

---

看到我随意选择的调试输出通过两个人传递到另一篇文章中，这种感觉很令人满意 :) - Lightness Races in Orbit

这听起来也太开心了！ - isanae

Answer 4

您可以将单例隐藏在一个不显示其静态性质的常规类中：

#include <iostream>
#include <string>

class Singleton // A bad name for a specific class, you should not generalize
{
    private:
    struct Context {
        std::string name;
        Context()
        :   name("Hello")
        {}
    };

    private:
    static Context& context() { static Context result; return result; }

    public:
    const std::string& name() const { return context().name; }
};

int main()
{
    Singleton a;
    std::cout << a.name() << '\n';
}

- user2249683