最近，我遇到了C++的Singleton设计模式的实现/实现。它看起来是这样的（我采用了现实生活中的例子）：
// a lot of methods are omitted here
class Singleton
{
public:
static Singleton* getInstance( );
~Singleton( );
private:
Singleton( );
static Singleton* instance;
};
从这个声明中，我可以推断实例字段是在堆上启动的。这意味着存在内存分配。对我来说完全不清楚的是，内存将在何时被释放？或者是否存在错误和内存泄漏？似乎在实现方面存在问题。
我的主要问题是，如何以正确的方式实现它？
当前回答
我没有在答案中找到CRTP实现，所以这里是：
template<typename HeirT>
class Singleton
{
public:
Singleton() = delete;
Singleton(const Singleton &) = delete;
Singleton &operator=(const Singleton &) = delete;
static HeirT &instance()
{
static HeirT instance;
return instance;
}
};
要使用，只需从此继承类，例如：class Test:public Singleton＜Test＞
其他回答
我们最近在EECS课上讨论了这个话题。如果您想详细查看课堂讲稿，请访问http://umich.edu/~eecs381/讲座/习语DesPattsCreational.pdf。这些笔记（以及我在这个答案中给出的引文）由我的教授大卫·基拉斯创建。
我知道有两种方法可以正确创建Singleton类。
第一种方式：
按照示例中的方式实现它。至于破坏，“单线程通常会持续程序运行的时间；当程序终止时，大多数操作系统都会恢复内存和大多数其他资源，因此有理由不用担心这一点。”
然而，在程序终止时进行清理是一种很好的做法。因此，您可以使用辅助静态SingletonDestructor类来完成此操作，并将其声明为Singleton中的朋友。
class Singleton {
public:
static Singleton* get_instance();
// disable copy/move -- this is a Singleton
Singleton(const Singleton&) = delete;
Singleton(Singleton&&) = delete;
Singleton& operator=(const Singleton&) = delete;
Singleton& operator=(Singleton&&) = delete;
friend class Singleton_destroyer;
private:
Singleton(); // no one else can create one
~Singleton(); // prevent accidental deletion
static Singleton* ptr;
};
// auxiliary static object for destroying the memory of Singleton
class Singleton_destroyer {
public:
~Singleton_destroyer { delete Singleton::ptr; }
};
// somewhere in code (Singleton.cpp is probably the best place)
// create a global static Singleton_destroyer object
Singleton_destoyer the_destroyer;
Singleton_destroyer将在程序启动时创建，“当程序终止时，所有全局/静态对象都会被运行库关闭代码（由链接器插入）破坏，因此_destroyer将被破坏；其析构函数将删除Singleton，运行其析构器。”
第二条路
这叫做Meyers Singleton，由C++向导Scott Meyers创建。只需以不同的方式定义get_instance（）。现在还可以去掉指针成员变量。
// public member function
static Singleton& Singleton::get_instance()
{
static Singleton s;
return s;
}
这很简单，因为返回的值是通过引用的，您可以使用。语法而不是->来访问成员变量。
“编译器通过声明，而不是之后，然后在程序中删除静态对象结束"
还需要注意的是，使用Meyers Singleton时，如果对象在终止-相对于其他对象，Singleton何时消失？但对于简单的应用程序，这很好。"
作为单身汉，你通常不希望它被破坏。
当程序终止时，它将被拆除并释放，这是单例的正常行为。如果您希望能够显式地清理它，那么向类中添加一个静态方法非常容易，该方法允许您将其恢复到干净状态，并在下次使用时重新分配，但这超出了“经典”单例的范围。
2008年，我提供了一个Singleton设计模式的C++98实现，该模式是惰性评估的、保证破坏的，在技术上不是线程安全的：有人能给我提供一个c++中的Singleton示例吗？
这里是Singleton设计模式的一个更新的C++11实现，它是延迟评估的、正确销毁的和线程安全的。
class S
{
public:
static S& getInstance()
{
static S instance; // Guaranteed to be destroyed.
// Instantiated on first use.
return instance;
}
private:
S() {} // Constructor? (the {} brackets) are needed here.
// C++ 03
// ========
// Don't forget to declare these two. You want to make sure they
// are inaccessible(especially from outside), otherwise, you may accidentally get copies of
// your singleton appearing.
S(S const&); // Don't Implement
void operator=(S const&); // Don't implement
// C++ 11
// =======
// We can use the better technique of deleting the methods
// we don't want.
public:
S(S const&) = delete;
void operator=(S const&) = delete;
// Note: Scott Meyers mentions in his Effective Modern
// C++ book, that deleted functions should generally
// be public as it results in better error messages
// due to the compilers behavior to check accessibility
// before deleted status
};
请参阅本文，了解何时使用单例：（不经常）辛格尔顿：应该如何使用
请参阅这两篇关于初始化顺序和如何处理的文章：静态变量初始化顺序查找C++静态初始化顺序问题
请参阅这篇描述寿命的文章：C++函数中静态变量的生存期是多少？
请参阅本文，其中讨论了单线程的一些线程含义：Singleton实例声明为GetInstance方法的静态变量，它是线程安全的吗？
请参阅这篇文章，解释为什么双重检查锁定在C++上不起作用：C++程序员应该知道哪些常见的未定义行为？Dobbs博士：C++和双重检查锁定的危险：第一部分
您可以避免内存分配。有很多变体，在多线程环境中都有问题。
我更喜欢这种实现（事实上，我更喜欢的说法并不正确，因为我尽可能避免单例）：
class Singleton
{
private:
Singleton();
public:
static Singleton& instance()
{
static Singleton INSTANCE;
return INSTANCE;
}
};
它没有动态内存分配。
我没有在答案中找到CRTP实现，所以这里是：
template<typename HeirT>
class Singleton
{
public:
Singleton() = delete;
Singleton(const Singleton &) = delete;
Singleton &operator=(const Singleton &) = delete;
static HeirT &instance()
{
static HeirT instance;
return instance;
}
};
要使用，只需从此继承类，例如：class Test:public Singleton＜Test＞
