C++ Singleton 设计模式

Question

最近我遇到了 C++ 的 Singleton 设计模式的实现/实现。它看起来像这样（我从现实生活中的例子中采用了它）：

// a lot of methods are omitted here
class Singleton
{
   public:
       static Singleton* getInstance( );
       ~Singleton( );
   private:
       Singleton( );
       static Singleton* instance;
};

从这个声明中，我可以推断出实例字段是在堆上启动的。 这意味着有一个 memory 分配。 我完全不清楚的是 memory 什么时候会被释放？ 或者是否存在错误和 memory 泄漏？ 执行起来好像有问题。

我的主要问题是，如何以正确的方式实施它？

Answer 1

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
};

请参阅这篇关于何时使用 singleton 的文章：（不经常）
Singleton：应该怎么用

请参阅这两篇关于初始化顺序以及如何应对的文章：
Static 变量初始化顺序
查找 C++ static 初始化顺序问题

请参阅这篇描述生命周期的文章：
C++ function 中的 static 变量的生命周期是多少？

请参阅这篇讨论对单例的一些线程影响的文章：
Singleton实例声明为GetInstance方法的static变量，它是线程安全的吗？

请参阅这篇文章，解释为什么双重检查锁定在 C++ 上不起作用：
C++ 程序员应该了解哪些常见的未定义行为？
Dobbs 博士：C++ 和双重检查锁定的危险：第一部分

Answer 2

您可以避免 memory 分配。 有许多变体，在多线程环境中都存在问题。

我更喜欢这种实现方式（实际上，我更喜欢这种说法并不正确，因为我尽可能避免使用单例）：

class Singleton
{
private:
   Singleton();

public:
   static Singleton& instance()
   {
      static Singleton INSTANCE;
      return INSTANCE;
   }
};

它没有动态 memory 分配。

Answer 3

作为 Singleton，您通常不希望它被破坏。

当程序终止时，它会被拆除并释放，这是 singleton 的正常期望行为。如果您希望能够明确清理它，可以很容易地向 class 添加一个 static 方法，允许您恢复它到一个干净的 state，并让它在下次使用时重新分配，但它在“经典”singleton 的 scope 之外。

Answer 4

@Loki Astari 的回答非常好。

然而，有时有多个 static 对象，您需要能够保证singleton不会被销毁，直到使用singleton的所有 static 对象不再需要它为止。

在这种情况下，即使在程序结束时调用 static 析构函数时， std::shared_ptr也可用于为所有用户保持singleton活动：

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() {}
};

Answer 5

另一个非分配替代方案：根据需要创建一个 singleton，例如 class C ：

singleton<C>()

使用

template <class X>
X& singleton()
{
    static X x;
    return x;
}

在当前的 C++ 中，这和 Cătălin 的答案都不是自动线程安全的，但将在 C++0x 中。

Answer 6

我没有在答案中找到 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，例如： class Test: public Singleton<Test>

Answer 7

我们最近在我的 EECS class 中讨论了这个主题。如果您想详细查看讲义，请访问http://umich.edu/~eecs381/lecture/IdiomsDesPattsCreational.pdf 。 这些笔记（以及我在这个回答中给出的引文）是由我的教授 David Kieras 创建的。

我知道有两种方法可以正确创建 Singleton class。

第一种方式：

实现它类似于您在示例中使用它的方式。 至于销毁，“单身人士通常会在程序运行期间持续；大多数操作系统会在程序终止时恢复 memory 和大多数其他资源，因此有理由不担心这一点。”

但是，最好在程序终止时进行清理。 因此，您可以使用辅助 static SingletonDestructor class 并在您的 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 将在程序启动时创建，“当程序终止时，所有全局/静态对象都被运行时库关闭代码（由链接器插入）销毁，因此 the_destroyer 将被销毁；它的析构函数将删除 Singleton，运行它的析构函数。”

第二种方式

这叫做迈耶斯 Singleton，由 C++ 奇才斯科特·迈耶斯创造。 只需以不同方式定义 get_instance() 即可。 现在你也可以去掉指针成员变量了。

// public member function
static Singleton& Singleton::get_instance()
{
  static Singleton s;
  return s;
}

这很简洁，因为返回的值是引用，您可以使用. 语法而不是->来访问成员变量。

“编译器通过声明自动构建第一次创建‘s’的代码，之后不会，然后在程序终止时删除 static object。”

另请注意，对于 Meyers Singleton，“如果对象在终止时相互依赖，您可能会陷入非常困难的境地 - Singleton 何时相对于其他对象消失？但对于简单的应用程序，这很好用。”

Answer 8

已接受答案中的解决方案有一个明显的缺点 - 在控件离开main() function 后调用 singleton 的析构函数。当一些依赖对象在main内部分配时，可能确实存在问题。

我在尝试在 Qt 应用程序中引入 Singleton 时遇到了这个问题。 我决定，我所有的设置对话框都必须是单例，并采用了上面的模式。 不幸的是，Qt 的主要 class QApplication在main function 的堆栈上分配，并且 Qt 禁止在没有应用程序 object 可用时创建/销毁对话框。

这就是为什么我更喜欢堆分配的单例。 我为所有单例提供了显式的init()和term()方法，并在main中调用它们。 因此，我可以完全控制单例创建/销毁的顺序，并且我保证将创建单例，无论是否有人调用getInstance() 。

Answer 9

这是一个简单的实现。

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

只创建了一个 object，这个 object 引用每次都返回。

SingletonClass instance created!
00915CB8
00915CB8

这里 00915CB8 是 singleton Object 的 memory 位置，在程序运行期间相同，但（通常）每次运行程序时都不同。

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

Answer 10

有没有人提到std::call_once和std::once_flag ？ 大多数其他方法——包括双重检查锁定——都被破坏了。

singleton 模式实现中的一个主要问题是安全初始化。 唯一安全的方法是用同步屏障保护初始化序列。 但这些障碍本身需要安全启动。 std::once_flag是保证安全初始化的机制。

Answer 11

如果要在堆中分配 object，为什么不使用唯一指针。 Memory 也将被释放，因为我们使用的是唯一指针。

class S
{
    public:
        static S& getInstance()
        {
            if( m_s.get() == 0 )
            {
              m_s.reset( new S() );
            }
            return *m_s;
        }

    private:
        static std::unique_ptr<S> m_s;

        S();
        S(S const&);            // Don't Implement
        void operator=(S const&); // Don't implement
};

std::unique_ptr<S> S::m_s(0);

Answer 12

C++11 线程安全实现：

 #include <iostream>
 #include <thread>


 class Singleton
 {
     private:
         static Singleton * _instance;
         static std::mutex mutex_;

     protected:
         Singleton(const std::string value): value_(value)
         {
         }
         ~Singleton() {}
         std::string value_;

     public:
         /**
          * Singletons should not be cloneable.
          */
         Singleton(Singleton &other) = delete;
         /**
          * Singletons should not be assignable.
          */
         void operator=(const Singleton &) = delete;

         //static Singleton *GetInstance(const std::string& value);
         static Singleton *GetInstance(const std::string& value)
         {
             if (_instance == nullptr)
             {
                 std::lock_guard<std::mutex> lock(mutex_);
                 if (_instance == nullptr)
                 {
                     _instance = new Singleton(value);
                 }
             }
             return _instance;
         }

         std::string value() const{
             return value_;
         }
 };

 /**
  * Static methods should be defined outside the class.
  */
 Singleton* Singleton::_instance = nullptr;
 std::mutex Singleton::mutex_;


 void ThreadFoo(){
     std::this_thread::sleep_for(std::chrono::milliseconds(10));
     Singleton* singleton = Singleton::GetInstance("FOO");
     std::cout << singleton->value() << "\n";
 }

 void ThreadBar(){
     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
     Singleton* singleton = Singleton::GetInstance("BAR");
     std::cout << singleton->value() << "\n";
 }

 int main()
 {
     std::cout <<"If you see the same value, then singleton was reused (yay!\n" <<
                 "If you see different values, then 2 singletons were created (booo!!)\n\n" <<
                 "RESULT:\n";
     std::thread t1(ThreadFoo);
     std::thread t2(ThreadBar);
     t1.join();
     t2.join();
     std::cout << "Complete!" << std::endl;

     return 0;
 }

Answer 13

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

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

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

...然后依靠从 scope 发出的程序进行清理。

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

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

Answer 14

除了此处的其他讨论之外，可能值得注意的是，您可以具有全局性，而不会将使用限制在一个实例中。 例如，考虑引用计数的情况......

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

现在在 function 的某处（比如main ）你可以这样做：

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

refs 不需要将指针存储回它们各自的Store ，因为该信息是在编译时提供的。 您也不必担心Store的生命周期，因为编译器要求它是全局的。 如果确实只有一个Store实例，那么这种方法就没有开销； 对于不止一个实例，编译器要聪明地生成代码。 如有必要， ItemRef class 甚至可以成为Store的friend （您可以有模板化的朋友。）。

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

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

Answer 15

这是一个使用CRTP的可模拟 singleton 。 它依靠一个小帮手在任何时候（最多）强制执行单个 object。 要在程序执行过程中强制执行单个 object，请删除重置（我们发现这对测试很有用）。

ConcreteSinleton可以这样实现：

class ConcreteSingleton : public Singleton<ConcreteSingleton>
{
public:
  ConcreteSingleton(const Singleton<ConcreteSingleton>::PrivatePass&)
      : Singleton<StandardPaths>::Singleton{pass}
  {}
  
  // ... concrete interface
  int f() const {return 42;}

};

然后与

ConcreteSingleton::instance().f();

Answer 16

它将 class 的实例化限制为一个 object。当需要一个 object 来协调整个系统的动作时，这很有用

class Singleton {
private:
    int data;
    static Singleton* instance;
    Singleton();
public:
    static Singleton* getInstance();
};
Singleton* Singleton::instance = 0;
Singleton::Singleton()
{
    this->data = 0;
    cout << "constructor called.." << endl;
}

 

Singleton* Singleton::getInstance() {
    if (!instance) {
        instance = new Singleton();
        return instance;
    }
}
int main() {
    Singleton *s = s->getInstance();
    Singleton *s1 =s1->getInstance();
    }

Answer 17

这是关于 object 生命周期管理。 假设您的软件中有多个单例。 并且它们依赖于Logger singleton。在应用销毁过程中，假设另一个singleton object使用Logger记录其销毁步骤。 您必须保证最后清理 Logger。 因此，也请查看这篇论文： http://www.cs.wustl.edu/~schmidt/PDF/ObjMan.pdf

Answer 18

我的实现与 Galik 的类似。 区别在于我的实现允许共享指针清理分配的 memory，而不是保留 memory 直到应用程序退出并清理 static 指针。

#pragma once

#include <memory>

template<typename T>
class Singleton
{
private:
  static std::weak_ptr<T> _singleton;
public:
  static std::shared_ptr<T> singleton()
  {
    std::shared_ptr<T> singleton = _singleton.lock();
    if (!singleton) 
    {
      singleton.reset(new T());
      _singleton = singleton;
    }

    return singleton;
  }
};

template<typename T>
std::weak_ptr<T> Singleton<T>::_singleton;

Answer 19

您的代码是正确的，只是您没有在 class 之外声明实例指针。 static 变量的内部 class 声明不被视为 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 实例不需要我们手动删除。 在整个程序中我们需要一个 object，所以在程序执行结束时，它会自动释放。

Answer 20

这是我对如何做正确的单例（和其他重要的 static 对象）的看法： https://github.com/alex4747-pub/proper_singleton

概括：

1. 使用static初始化列表在合适的时间实例化单例：进入main之后，开启多线程之前
2. 添加小的改进以使其单元测试友好。

Answer 21

我想在这里展示另一个 C++ 中的 singleton 的例子。使用模板编程是有意义的。 此外，从不可复制且不可移动的类派生 singleton class 是有意义的。 这是它在代码中的样子：

#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 类允许您更具体地定义 singleton（有时您想要移动单个实例）。

Answer 22

简单 singleton class，这一定是你的 header class 文件

#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

像这样访问您的 singleton：

sSingletonClass->Relocate(1, 2, 5);

Answer 23

上面链接的论文描述了双重检查锁定的缺点，即编译器可能会为 object 分配 memory，并在调用对象的构造函数之前设置指向分配的 memory 地址的指针。 在 c++ 中使用分配器手动分配 memory 非常容易，然后使用构造调用来初始化 memory。使用此方法，双重检查锁定工作得很好。

Answer 24

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

Answer 25

我认为您应该编写一个静态函数，其中删除了您的静态对象。 当您要关闭应用程序时，应调用此函数。 这将确保您没有内存泄漏。

Answer 26

如何像这样使用new放置：

class singleton
{
    static singleton *s;
    static unsigned char *buffer[sizeof(singleton)/4 *4] //4 byte align
    static singleton* getinstance()
    {
        if (s == null)
        {
            s = new(buffer) singleton;
        }
        return s;
    }
};