最近，我遇到了C++的Singleton设计模式的实现/实现。它看起来是这样的（我采用了现实生活中的例子）：
// a lot of methods are omitted here
class Singleton
{
public:
static Singleton* getInstance( );
~Singleton( );
private:
Singleton( );
static Singleton* instance;
};
从这个声明中，我可以推断实例字段是在堆上启动的。这意味着存在内存分配。对我来说完全不清楚的是，内存将在何时被释放？或者是否存在错误和内存泄漏？似乎在实现方面存在问题。
我的主要问题是，如何以正确的方式实现它？
当前回答
我想在这里展示C++中的另一个单例。使用模板编程是有意义的。此外，从不可复制和不可移动的类派生出单例类是有意义的。下面是代码中的样子：
#include<iostream>
#include<string>
class DoNotCopy
{
protected:
DoNotCopy(void) = default;
DoNotCopy(const DoNotCopy&) = delete;
DoNotCopy& operator=(const DoNotCopy&) = delete;
};
class DoNotMove
{
protected:
DoNotMove(void) = default;
DoNotMove(DoNotMove&&) = delete;
DoNotMove& operator=(DoNotMove&&) = delete;
};
class DoNotCopyMove : public DoNotCopy,
public DoNotMove
{
protected:
DoNotCopyMove(void) = default;
};
template<class T>
class Singleton : public DoNotCopyMove
{
public:
static T& Instance(void)
{
static T instance;
return instance;
}
protected:
Singleton(void) = default;
};
class Logger final: public Singleton<Logger>
{
public:
void log(const std::string& str) { std::cout << str << std::endl; }
};
int main()
{
Logger::Instance().log("xx");
}
拆分为NotCopyable和NotMovable类允许您更具体地定义单例（有时您希望移动单个实例）。
其他回答
这是关于对象生命周期管理的。假设您的软件中有多个单体。它们依赖于Logger单例。在应用程序销毁期间，假设另一个单例对象使用Logger记录其销毁步骤。您必须保证Logger应该最后清理。因此，请同时查看本文：http://www.cs.wustl.edu/~schmidt/PDF/ObjMan.PDF
上面链接的论文描述了双重检查锁定的缺点，即编译器可以在调用对象的构造函数之前为对象分配内存并设置指向分配内存地址的指针。在c++中，使用分配器手动分配内存，然后使用构造调用初始化内存是非常容易的。使用这种方法，双重检查锁定工作正常。
您的代码是正确的，只是没有在类外部声明实例指针。静态变量的类内声明在C++中不被视为声明，但在其他语言（如C#或Java等）中允许这样做。
class Singleton
{
public:
static Singleton* getInstance( );
private:
Singleton( );
static Singleton* instance;
};
Singleton* Singleton::instance; //we need to declare outside because static variables are global
您必须知道Singleton实例不需要我们手动删除。我们需要在整个程序中使用它的一个对象，因此在程序执行结束时，它将被自动释放。
以下是我对如何实现正确的单线图（以及其他非平凡静态对象）的看法：https://github.com/alex4747-pub/proper_singleton
摘要：
使用静态初始化列表在正确的时间实例化单线程：在进入main之后和启用多线程之前添加一些小的改进，使其对单元测试友好。
@洛基·阿斯塔里的回答很好。
然而，有时使用多个静态对象时，您需要能够保证在所有使用单例的静态对象不再需要它之前，单例不会被破坏。
在这种情况下，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() {}
};
