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

简单的单例类，这必须是你的头类文件

#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);

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

这里是一个简单的实现。

#include <Windows.h>
#include <iostream>

using namespace std;


class SingletonClass {

public:
    static SingletonClass* getInstance() {

    return (!m_instanceSingleton) ?
        m_instanceSingleton = new SingletonClass : 
        m_instanceSingleton;
    }

private:
    // private constructor and destructor
    SingletonClass() { cout << "SingletonClass instance created!\n"; }
    ~SingletonClass() {}

    // private copy constructor and assignment operator
    SingletonClass(const SingletonClass&);
    SingletonClass& operator=(const SingletonClass&);

    static SingletonClass *m_instanceSingleton;
};

SingletonClass* SingletonClass::m_instanceSingleton = nullptr;



int main(int argc, const char * argv[]) {

    SingletonClass *singleton;
    singleton = singleton->getInstance();
    cout << singleton << endl;

    // Another object gets the reference of the first object!
    SingletonClass *anotherSingleton;
    anotherSingleton = anotherSingleton->getInstance();
    cout << anotherSingleton << endl;

    Sleep(5000);

    return 0;
}

只创建了一个对象，并且每次在词尾都会返回该对象引用。

SingletonClass instance created!
00915CB8
00915CB8

这里00915CB8是单例对象的内存位置，在程序的持续时间内相同，但每次运行程序时（通常！）不同。

注意：这不是线程安全的。您必须确保线程安全。

我没有在答案中找到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＞

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

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所需的模板参数的详细信息）。