C Singleton design pattern

Question

Recently I ve bumped into a realization implementation of the Singleton design pattern for C    It has looked like this  I have adopted it from the real-life example      a lot of methods are omitted here class Singleton      public         static Singleton  getInstance             Singleton        private         Singleton            static Singleton  instance      From this declaration  I can deduce that the instance field is initiated on the heap  That means there is a memory allocation  What is completely unclear for me is when exactly the memory is going to be deallocated  Or is there a bug and memory leak  It seems like there is a problem with the implementation  My main question is  how do I implement it in the right way

User · Answer

Here is my view on how to do proper singletons (and other non-trivial static objects): https://github.com/alex4747-pub/proper_singleton

Summary:

Use static initialization list to instantiate singletons at the right time: after entering main and before enabling multi-threading
Add minor improvements to make it unit-test friendly.

User · Answer

My implementation is similar to Galik s  The difference is my implementation allows the shared pointers to clean up allocated memory  as opposed to holding onto the memory until the application is exited and the static pointers are cleaned up    pragma once   include  lt memory gt   template lt typename T gt  class Singleton   private    static std  weak ptr lt T gt   singleton  public    static std  shared ptr lt T gt  singleton           std  shared ptr lt T gt  singleton    singleton lock        if   singleton               singleton reset new T            singleton   singleton             return singleton          template lt typename T gt  std  weak ptr lt T gt  Singleton lt T gt    singleton

User · Answer

This is about object life-time management  Suppose you have more than singletons in your software  And they depend on Logger singleton  During application destruction  suppose another singleton object uses Logger to log its destruction steps  You have to guarantee that Logger should be cleaned up last  Therefore  please also check out this paper  http   www cs wustl edu  schmidt PDF ObjMan pdf

User · Answer

Being a Singleton  you usually do not want it to be destructed   It will get torn down and deallocated when the program terminates  which is the normal  desired behavior for a singleton   If you want to be able to explicitly clean it  it s fairly easy to add a static method to the class that allows you to restore it to a clean state  and have it reallocate next time it s used  but that s outside of the scope of a  classic  singleton

User · Answer

Here is an easy implementation    include  lt Windows h gt   include  lt iostream gt   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  lt  lt   SingletonClass instance created  n          SingletonClass              private copy constructor and assignment operator     SingletonClass const SingletonClass amp        SingletonClass amp  operator  const SingletonClass amp         static SingletonClass  m instanceSingleton      SingletonClass  SingletonClass  m instanceSingleton   nullptr     int main int argc  const char   argv           SingletonClass  singleton      singleton   singleton- gt getInstance        cout  lt  lt  singleton  lt  lt  endl          Another object gets the reference of the first object      SingletonClass  anotherSingleton      anotherSingleton   anotherSingleton- gt getInstance        cout  lt  lt  anotherSingleton  lt  lt  endl       Sleep 5000        return 0      Only one object created and this object reference is returned each and every time afterwords   SingletonClass instance created  00915CB8 00915CB8   Here 00915CB8 is the memory location of singleton Object  same for the duration of the program but  normally   different each time the program is run   N B  This is not a thread safe one You have to ensure thread safety

User · Answer

Your code is correct  except that you didn t declare the instance pointer outside the class  The inside class declarations of static variables are not considered declarations in C    however this is allowed in other languages like C  or Java etc   class Singleton      public         static Singleton  getInstance        private         Singleton            static Singleton  instance     Singleton  Singleton  instance    we need to declare outside because static variables are global   You must know that Singleton instance doesn t need to be manually deleted by us  We need a single object of it throughout the whole program  so at the end of program execution  it will be automatically deallocated

User · Answer

Has anyone mentioned std  call once and std  once flag  Most other approaches - including double checked locking - are broken   One major problem in singleton pattern implementation is safe initialization  The only safe way is to guard the initialization sequence with synchronizing barriers  But those barriers themselves need to be safely initiated  std  once flag is the mechanism to get guaranteed safe initialization

User · Answer

In addition to the other discussion here  it may be worth noting that you can have global-ness  without limiting usage to one instance  For example  consider the case of reference counting something     struct Store     std  array lt Something  1024 gt  data     size t get size t idx                  void incr ref size t idx                 void decr ref size t idx                  template lt Store  store p gt  struct ItemRef     size t idx     auto get    return store p- gt get idx         ItemRef     store p- gt incr ref idx          ItemRef     store p- gt decr ref idx          Store store1 g  Store store2 g     we don t restrict the number of global Store instances   Now somewhere inside a function  such as main  you can do   auto ref1 a   ItemRef lt  amp store1 g gt  101   auto ref2 a   ItemRef lt  amp store2 g gt  201      The refs don t need to store a pointer back to their respective Store because that information is supplied at compile-time  You also don t have to worry about the Store s lifetime because the compiler requires that it is global   If there is indeed only one instance of Store then there s no overhead in this approach  with more than one instance it s up to the compiler to be clever about code generation  If necessary  the ItemRef class can even be made a friend of Store  you can have templated friends     If Store itself is a templated class then things get messier  but it is still possible to use this method  perhaps by implementing a helper class with the following signature   template  lt typename Store t  Store t  store p gt  struct StoreWrapper     stuff to access store p  e g  methods returning                         instances of ItemRef lt Store t  store p gt           The user can now create a StoreWrapper type  and global instance  for each global Store instance  and always access the stores via their wrapper instance  thus forgetting about the gory details of the template parameters needed for using Store

User · Answer

In 2008 I provided a C  98 implementation of the Singleton design pattern that is lazy-evaluated  guaranteed-destruction  not-technically-thread-safe  Can any one provide me a sample of Singleton in c       Here is an updated C  11 implementation of the Singleton design pattern that is lazy-evaluated  correctly-destroyed  and thread-safe   class S       public          static S amp  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 amp                    Don t Implement         void operator  S const amp       Don t implement             C   11                               We can use the better technique of deleting the methods            we don t want      public          S S const amp                   delete          void operator  S const amp      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      See this article about when to use a singleton   not often  Singleton  How should it be used  See this two article about initialization order and how to cope  Static variables initialisation order Finding C   static initialization order problems    See this article describing lifetimes  What is the lifetime of a static variable in a C   function     See this article that discusses some threading implications to singletons  Singleton instance declared as static variable of GetInstance method  is it thread-safe   See this article that explains why double checked locking will not work on C    What are all the common undefined behaviours that a C   programmer should know about  Dr Dobbs  C   and The Perils of Double-Checked Locking  Part I

User · Answer

Another non-allocating alternative  create a singleton  say of class C  as you need it   singleton lt C gt      using  template  lt class X gt  X amp  singleton         static X x      return x      Neither this nor Catalin s answer is automatically thread-safe in current C    but will be in C  0x

User · Answer

You could avoid memory allocation  There are many variants  all having problems in case of multithreading environment   I prefer this kind of implementation  actually  it is not correctly said I prefer  because I avoid singletons as much as possible    class Singleton   private     Singleton     public     static Singleton amp  instance              static Singleton INSTANCE        return INSTANCE            It has no dynamic memory allocation

User · Answer

We went over this topic recently in my EECS class  If you want to look at the lecture notes in detail  visit http   umich edu  eecs381 lecture IdiomsDesPattsCreational pdf There are two ways that I know to create a Singleton class correctly  First Way  Implement it similar to the way you have it in your example  As for destruction   quot Singletons usually endure for the length of the program run  most OSs will recover memory and most other resources when a program terminates  so there is an argument for not worrying about this  quot  However  it is good practice to clean up at program termination  Therefore  you can do this with an auxiliary static SingletonDestructor class and declare that as a friend in your Singleton  class Singleton   public    static Singleton  get instance            disable copy move -- this is a Singleton   Singleton const Singleton amp     delete    Singleton Singleton amp  amp     delete    Singleton amp  operator  const Singleton amp     delete    Singleton amp  operator  Singleton amp  amp     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   The Singleton destroyer will be created on program startup  and  quot when program terminates  all global static objects are destroyed by the runtime library shutdown code  inserted by the linker   so the destroyer will be destroyed  its destructor will delete the Singleton  running its destructor  quot  Second Way This is called the Meyers Singleton  created by C   wizard Scott Meyers  Simply define get instance   differently  Now you can also get rid of the pointer member variable     public member function static Singleton amp  Singleton  get instance       static Singleton s    return s     This is neat because the value returned is by reference and you can use   syntax instead of - gt  to access member variables   quot Compiler automatically builds code that creates  s  first time through the declaration  not thereafter  and then deletes the static object at program termination  quot  Note also that with the Meyers Singleton you  quot can get into very difficult situation if objects rely on each other at the time of termination - when does the Singleton disappear relative to other objects  But for simple applications  this works fine  quot

User · Answer

The paper that was linked to above describes the shortcoming of double checked locking is that the compiler may allocate the memory for the object and set a pointer to the address of the allocated memory  before the object s constructor has been called  It is quite easy in c   however to use allocaters to allocate the memory manually  and then use a construct call to initialize the memory  Using this appraoch  the double-checked locking works just fine

User · Answer

Here is a mockable singleton using CRTP  It relies on a little helper to enforce a single object at any one time  at most   To enforce a single object over program execution  remove the reset  which we find useful for tests   A ConcreteSinleton can be implemented like this  class ConcreteSingleton   public Singleton lt ConcreteSingleton gt    public    ConcreteSingleton const Singleton lt ConcreteSingleton gt   PrivatePass amp           Singleton lt StandardPaths gt   Singleton pass                   concrete interface   int f   const  return 42        And then used with ConcreteSingleton  instance   f

User · Answer

C  11 Thread safe implementation    include  lt iostream gt    include  lt thread gt     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  amp other    delete                           Singletons should not be assignable                        void operator  const Singleton  amp     delete              static Singleton  GetInstance const std  string amp  value            static Singleton  GetInstance const std  string amp  value                          if   instance    nullptr                                  std  lock guard lt std  mutex gt  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  quot FOO quot         std  cout  lt  lt  singleton- gt value    lt  lt   quot  n quot        void ThreadBar         std  this thread  sleep for std  chrono  milliseconds 1000         Singleton  singleton   Singleton  GetInstance  quot BAR quot         std  cout  lt  lt  singleton- gt value    lt  lt   quot  n quot        int main           std  cout  lt  lt  quot If you see the same value  then singleton was reused  yay  n quot   lt  lt                    quot If you see different values  then 2 singletons were created  booo    n n quot   lt  lt                    quot RESULT  n quot        std  thread t1 ThreadFoo        std  thread t2 ThreadBar        t1 join         t2 join         std  cout  lt  lt   quot Complete  quot   lt  lt  std  endl        return 0

User · Answer

Simple singleton class  This must be your header class file   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   Access your singleton like this   sSingletonClass- gt Relocate 1  2  5

User · Answer

The solution in the accepted answer has a significant drawback - the destructor for the singleton is called after the control leaves the main   function  There may be problems really  when some dependent objects are allocated inside main   I met this problem  when trying to introduce a Singleton in the Qt application  I decided  that all my setup dialogs must be Singletons  and adopted the pattern above  Unfortunately  Qt s main class QApplication was allocated on stack in the main function  and Qt forbids creating destroying dialogs when no application object is available   That is why I prefer heap-allocated singletons  I provide an explicit init   and term   methods for all the singletons and call them inside main  Thus I have a full control over the order of singletons creation destruction  and also I guarantee that singletons will be created  no matter whether someone called getInstance   or not

User · Answer

It is indeed probably allocated from the heap  but without the sources there is no way of knowing   The typical implementation  taken from some code I have in emacs already  would be   Singleton   Singleton  getInstance         if   instance            instance   new Singleton               return instance          and rely on the program going out of scope to clean up afterwards   If you work on a platform where cleanup must be done manually  I d probably add a manual cleanup routine   Another issue with doing it this way is that it isn t thread-safe  In a multithreaded environment  two threads could get through the  if  before either has a chance to allocate the new instance  so both would   This still isn t too big of a deal if you are relying on program termination to clean up anyway

User · Answer

I would like to show here another example of a singleton in C    It makes sense to use template programming  Besides  it makes sense to derive your singleton class from a not copyable and not movabe classes  Here how it looks like in the code   include lt iostream gt   include lt string gt   class DoNotCopy   protected      DoNotCopy void    default      DoNotCopy const DoNotCopy amp     delete      DoNotCopy amp  operator  const DoNotCopy amp     delete      class DoNotMove   protected      DoNotMove void    default      DoNotMove DoNotMove amp  amp     delete      DoNotMove amp  operator  DoNotMove amp  amp     delete      class DoNotCopyMove   public DoNotCopy      public DoNotMove   protected      DoNotCopyMove void    default      template lt class T gt  class Singleton   public DoNotCopyMove   public      static T amp  Instance void                static T instance          return instance         protected      Singleton void    default      class Logger final  public Singleton lt Logger gt    public      void log const std  string amp  str    std  cout  lt  lt  str  lt  lt  std  endl          int main         Logger  Instance   log  quot xx quot       The splitting into NotCopyable and NotMovable clases allows you to define your singleton more specific  sometimes you want to move your single instance

User · Answer

define INS c  private void operator  c const amp     public static c amp  I   static c  instance return  instance     Example      class CCtrl           private          CCtrl void           virtual  CCtrl void        public          INS CCtrl

User · Answer

Loki Astari s answer is excellent    However there are times with multiple static objects where you need to be able to guarantee that the singleton will not be destroyed until all your static objects that use the singleton no longer need it   In this case std  shared ptr can be used to keep the singleton alive for all users even when the static destructors are being called at the end of the program   class Singleton   public      Singleton Singleton const amp     delete      Singleton amp  operator  Singleton const amp     delete       static std  shared ptr lt Singleton gt  instance                 static std  shared ptr lt Singleton gt  s new Singleton           return s         private      Singleton

User · Answer

If you want to allocate the object in heap  why don t use a unique pointer  Memory will also be deallocated since we are using a unique pointer   class S       public          static S amp  getInstance                         if  m s get      0                               m s reset  new S                                return  m s                 private          static std  unique ptr lt S gt  m s           S            S S const amp                  Don t Implement         void operator  S const amp       Don t implement     std  unique ptr lt S gt  S  m s 0

User · Answer

I did not find a CRTP implementation among the answers  so here it is   template lt typename HeirT gt  class Singleton   public      Singleton     delete       Singleton const Singleton  amp     delete       Singleton  amp operator  const Singleton  amp     delete       static HeirT  amp instance                 static HeirT instance          return instance             To use just inherit your class from this  like  class Test   public Singleton lt Test gt

[c++] C++ Singleton design pattern

Examples related to c++

Examples related to design-patterns

Examples related to singleton