Singleton：析构函数怎么会被调用两次？答案

【问题标题】：Singleton: how can destructor be called twice?Singleton：析构函数怎么会被调用两次？
【发布时间】：2015-06-02 18:21:59
【问题描述】：

几分钟前，我向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!

Live demo

更正确地说，我理解为什么它被调用了两次。但是我无法理解如何如果在第一次析构函数之后类的实例被销毁，它可以被调用两次？为什么没有例外？

或者它没有被摧毁？为什么？

【问题讨论】：

将Singleton(Singleton const&) { std::cout << "copy construction!\n"; } 添加到您的示例中，所有内容都会显示出来。
你应该使类不可复制和不可移动：Singleton(Singleton const&) = delete; Singleton(Singleton &&) = delete; Singleton &operator=(Singleton const&) = delete;Singleton operator=(Singleton &&) = delete;
您的程序中有两个 Singleton 类型的实例。一个是static 在getInstance 内。另一个是本地内部main。每个对象最终都会被销毁。因此有两个析构函数调用。为什么你会惊讶于析构函数被调用了两次？
对不起，我应该删除复制构造函数和赋值运算符。虽然从某种意义上说我很高兴我没有这样做，因为那时你必须问这个:)
@LightnessRacesinOrbit 在熟练使用 Singleton 的写作和使用之后，他们可以继续 learning to avoid using them :)

标签： c++ design-patterns singleton destructor

【解决方案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

【讨论】：

是的。如果您真的希望单例成为单例，则需要删除其复制构造函数或将其设为私有。
无需显式删除右值引用版本，因为编译器不会自动生成它们。
很多事情都不需要

【解决方案2】：

线

Singleton inst = Singleton::getInstance();

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

Singleton( const Singleton& ) = delete;

到你的班级，以防止那些意外的副本。为确保发现更隐蔽的错误，还添加

void operator=( const Singleton& ) = delete;

也是。您不必显式删除移动构造或赋值，因为编译器不会在声明其他（已删除）成员的情况下生成它们。

【讨论】：

@πάνταῥεῖ 理论上你是对的，但是对于单身人士来说，不应该存在第二个实例来分配；）但是，是的，有可能最终得到愚蠢的代码触发分配，我将编辑答案。
@DanielFrey 我想一个人可以做到Singleton::getInstance() = Singleton::getInstance();，这确实超出了界限，但仍然可行;)
@vsoftco 是的，但这不再是意外，而是自找麻烦。 :-D
如果可以做到，最终会有人做到的 :D 但我完全同意，这是自找麻烦。
@vsoftco 这就是为什么我认为有点偏执对软件开发人员来说是一种资产：-P

【解决方案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;

【讨论】：

看到我任意选择的调试输出通过两个人发送到另一个帖子，这让我感到很满足 :)
听起来也很开心！

【解决方案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';
}

【讨论】：