C++'da Singleton Pattern

 
   
   
  class Singleton { 
      public: 
          static Singleton* Instance(); 
      protected: 
          Singleton() { } 
   
          friend class SingletonDestroyer; 
          virtual ~Singleton() { } 
      private: 
          static Singleton* _instance; 
          static SingletonDestroyer _destroyer; 
      }; 
   
      Singleton* Singleton::_instance = 0; 
      SingletonDestroyer Singleton::_destroyer; 
   
      Singleton* Singleton::Instance () { 
          if (!_instance) { 
              _instance = new Singleton; 
              _destroyer.SetSingleton(_instance); 
          } 
          return _instance; 
      } 
   
   
  

 
   
   
  class SingletonDestroyer { 
      public: 
          SingletonDestroyer(Singleton* = 0); 
          ~SingletonDestroyer(); 
   
          void SetSingleton(Singleton* s); 
      private: 
          Singleton* _singleton; 
      }; 
   
      SingletonDestroyer::SingletonDestroyer (Singleton* s) { 
          _singleton = s; 
      } 
   
      SingletonDestroyer::~SingletonDestroyer () { 
          delete _singleton; 
      } 
   
      void SingletonDestroyer::SetSingleton (Singleton* s) { 
          _singleton = s; 
      } 
   
   
  

 
   
   
  //Singleton.h 
   
  #ifndef Singleton_H 
  #define Singleton_H 
   
  #include <iostream> 
   
   
  class Singleton 
  { 
   
  private: 
  	 Singleton(); 
  	~Singleton(); 
  	static bool isInit; 
  	int m_int; 
  	 
   
  public: 
   
  	static Singleton* getInstance(); 
  	void setInt(int i); 
  	int getInt(); 
   
   
  }; 
   
   
  #endif 
   
   
  

 
   
  //Singleton.cpp 
   
  #include "Singleton.h" 
   
  bool Singleton::isInit=false; 
   
   
  Singleton* Singleton::getInstance() 
  { 
  	static Singleton s; 
  	return isInit? &s:0; 
  } 
   
   
  void Singleton::setInt(int i) 
  { 
   
      m_int=i; 
  } 
   
  int Singleton::getInt() 
  { 
   
  	return m_int; 
   
  } 
   
  Singleton::Singleton() 
  { 
   
  isInit=true; 
   
  } 
   
  Singleton::~Singleton() 
  { 
  		 
      isInit=false; 
  } 
   
  

 
   
   
  //Main.cpp 
   
  #include "Singleton.h" 
   
   
   
  int main() 
  { 
  	Singleton* p=Singleton::getInstance(); 
  	 
  	p->setInt(5); 
   
  	Singleton* p2=Singleton::getInstance(); 
   
  	std::cout<<"Int degeri p2 icinde:"<<p2->getInt()<<std::endl; 
   
  	 
      system("pause"); 
  	return 0; 
  } 
   
  

 
  namespace deneme 
  { 
      // burada public metodlar, degiskenler 
      metod1(); 
      metod2(); 
      değişken1, değişken 2; 
      ... 
      .. 
      . 
   
      // Burada bu alana özel yani sınıflardaki private olayı gibi isimsiz bir namespace yaratılıyor 
      namespace 
      { 
           // özel metodlar, degiskenler.... 
      } 
  }