最近，我遇到了C++的Singleton设计模式的实现/实现。它看起来是这样的（我采用了现实生活中的例子）：
// a lot of methods are omitted here
class Singleton
{
public:
static Singleton* getInstance( );
~Singleton( );
private:
Singleton( );
static Singleton* instance;
};
从这个声明中，我可以推断实例字段是在堆上启动的。这意味着存在内存分配。对我来说完全不清楚的是，内存将在何时被释放？或者是否存在错误和内存泄漏？似乎在实现方面存在问题。
我的主要问题是，如何以正确的方式实现它？
当前回答
我们最近在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何时消失？但对于简单的应用程序，这很好。"
其他回答
@洛基·阿斯塔里的回答很好。
然而，有时使用多个静态对象时，您需要能够保证在所有使用单例的静态对象不再需要它之前，单例不会被破坏。
在这种情况下，std:：shared_ptr可用于保持所有用户的单例有效，即使在程序结束时调用静态析构函数：
class Singleton
{
public:
Singleton(Singleton const&) = delete;
Singleton& operator=(Singleton const&) = delete;
static std::shared_ptr<Singleton> instance()
{
static std::shared_ptr<Singleton> s{new Singleton};
return s;
}
private:
Singleton() {}
};
您可以避免内存分配。有很多变体，在多线程环境中都有问题。
我更喜欢这种实现（事实上，我更喜欢的说法并不正确，因为我尽可能避免单例）：
class Singleton
{
private:
Singleton();
public:
static Singleton& instance()
{
static Singleton INSTANCE;
return INSTANCE;
}
};
它没有动态内存分配。
简单的单例类，这必须是你的头类文件
#ifndef SC_SINGLETON_CLASS_H
#define SC_SINGLETON_CLASS_H
class SingletonClass
{
public:
static SingletonClass* Instance()
{
static SingletonClass* instance = new SingletonClass();
return instance;
}
void Relocate(int X, int Y, int Z);
private:
SingletonClass();
~SingletonClass();
};
#define sSingletonClass SingletonClass::Instance()
#endif
像这样访问单例：
sSingletonClass->Relocate(1, 2, 5);
上面链接的论文描述了双重检查锁定的缺点，即编译器可以在调用对象的构造函数之前为对象分配内存并设置指向分配内存地址的指针。在c++中，使用分配器手动分配内存，然后使用构造调用初始化内存是非常容易的。使用这种方法，双重检查锁定工作正常。
作为单身汉，你通常不希望它被破坏。
当程序终止时，它将被拆除并释放，这是单例的正常行为。如果您希望能够显式地清理它，那么向类中添加一个静态方法非常容易，该方法允许您将其恢复到干净状态，并在下次使用时重新分配，但这超出了“经典”单例的范围。
