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++和双重检查锁定的危险：第一部分

作为单身汉，你通常不希望它被破坏。

当程序终止时，它将被拆除并释放，这是单例的正常行为。如果您希望能够显式地清理它，那么向类中添加一个静态方法非常容易，该方法允许您将其恢复到干净状态，并在下次使用时重新分配，但这超出了“经典”单例的范围。

我们最近在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何时消失？但对于简单的应用程序，这很好。"

它确实可能是从堆中分配的，但没有源就无从得知。

典型的实现（取自我在emacs中已有的一些代码）是：

Singleton * Singleton::getInstance() {
    if (!instance) {
        instance = new Singleton();
    };
    return instance;
};

……然后依靠超出范围的程序进行清理。

如果您在必须手动进行清理的平台上工作，我可能会添加一个手动清理例程。

这样做的另一个问题是它不是线程安全的。在多线程环境中，两个线程可以通过“if”，然后任何一个线程都有机会分配新实例（所以两者都会）。如果你依靠程序终止来清理，这仍然不是什么大问题。

除了这里的其他讨论之外，可能值得注意的是，您可以使用全局性，而不限于一个实例。例如，考虑引用计数的情况。。。

struct Store{
   std::array<Something, 1024> data;
   size_t get(size_t idx){ /* ... */ }
   void incr_ref(size_t idx){ /* ... */}
   void decr_ref(size_t idx){ /* ... */}
};

template<Store* store_p>
struct ItemRef{
   size_t idx;
   auto get(){ return store_p->get(idx); };
   ItemRef() { store_p->incr_ref(idx); };
   ~ItemRef() { store_p->decr_ref(idx); };
};

Store store1_g;
Store store2_g; // we don't restrict the number of global Store instances

现在，在函数（如main）中的某个位置，您可以执行以下操作：

auto ref1_a = ItemRef<&store1_g>(101);
auto ref2_a = ItemRef<&store2_g>(201); 

ref不需要将指针存储回各自的store，因为这些信息是在编译时提供的。您也不必担心Store的生存期，因为编译器要求它是全局的。如果确实只有一个Store实例，那么这种方法没有开销；在不止一个实例的情况下，编译器需要对代码生成进行巧妙处理。如果需要，ItemRef类甚至可以成为Store的朋友（您可以有模板朋友！）。

如果Store本身是一个模板化的类，那么事情就变得更糟了，但是仍然可以使用这个方法，也许可以通过实现具有以下签名的helper类：

template <typename Store_t, Store_t* store_p>
struct StoreWrapper{ /* stuff to access store_p, e.g. methods returning 
                       instances of ItemRef<Store_t, store_p>. */ };

用户现在可以为每个全局Store实例创建StoreWrapper类型（和全局实例），并始终通过其包装器实例访问商店（从而忘记使用Store所需的模板参数的详细信息）。

#define INS(c) private:void operator=(c const&){};public:static c& I(){static c _instance;return _instance;}

例子：

   class CCtrl
    {
    private:
        CCtrl(void);
        virtual ~CCtrl(void);

    public:
        INS(CCtrl);