Singleton template / private constructor for Singleton instances

if you derive from singleton class you need to make the baseclass constructors protected or you couldnt create any instance.

why do want derive from singleton class? actually it is some contradiction cause for any derived class you may have one instance. so the baseclass isnt a singleton anymore.

you make a singleton class by private constructor and providing a static instance of the class (the one and only instance). for example that way

class singleton
{
     singleton() {}
public:
     static singleton & Singleton()
     {
           // make a static instance
           static singleton s;
           return s;
     }
};

you then can access the singleton by Singleton()

 

sorry it is

    singleton::Singleton()

http:#26667444 is an example of The Meyers Singleton

http://www.devarticles.com/c/a/Cplusplus/C-plus-plus-In-Theory-The-Singleton-Pattern-Part-I/4/

Just expanding on evilrix below example should give u what u exactly need
http://www.devarticles.com/c/a/Cplusplus/C-plus-plus-In-Theory-The-Singleton-Pattern-Part-2/3/

evilrix:
I'm certainly no expert but I think I get the gist of the Myers singleton.  IOW I understand that.  My dilema reflected in the code below is this.  Now using the code reflected in the link provided by saifzahur, The end user could create an instance of the MyClass via:
McClass Mc ;
as shown in main.  I dont _want_ that.  If I make the MyClass constructor protected I get an error.  That's the issue.  The _one_ solutoin I could come up with is to declare MyClass a friend of the Singleton but that's undesirable.

# include <iostream>

// This is how a Gamma Singleton would instantiate its object.
template <class T> struct CreateGamma {
  static T* Create() { return new T; }
};

// This is how a Meyers Singleton would instantiate its object.
template <class T> struct CreateMeyers {
  static T* Create() {
    static T _instance;
    return &_instance;
  }
};

// This Singleton class accepts different creation policies.
template <class T, template<class> class CreationPolicy=CreateMeyers>
class Singleton {
public:
  static T& Instance() {
    if (!m_pInstance)
      m_pInstance=CreationPolicy<T>::Create();
    return *m_pInstance;
}

private:
  Singleton();            // ctor hidden
  ~Singleton() { std::cout << "l" << std::endl; }           // dtor hidden
  Singleton(Singleton const&);    // copy ctor hidden
  Singleton& operator=(Singleton const&);  // assign op hidden

  static T* m_pInstance;
};
template <class T, template<class> class C> T* Singleton<T,C>::m_pInstance=0;

class MyClass {
  int xx ;

public: 
  MyClass()    
   : xx ( 0 )
  {}
  void foo ( int x ) 
  { 
    xx = x; 
    std::cout << "MyClass::foo(" << std::hex << xx << ") called" << std::endl; 
  }
  int bar() 
  { 
    std::cout   << "MyClass::bar called" <<  std::endl; 
    return ( xx ) ; 
  }
  ~MyClass () 
  { std::cout << "~MyClass::MyClass" << std::endl; }
};

typedef Singleton<MyClass, CreateGamma> MyClassLeaking;
void test3()
{
  int val=MyClassLeaking::Instance().bar();
  MyClassLeaking::Instance().foo(++val);
  MyClassLeaking::Instance().bar();
}
typedef C_Singleton< lets_see > LetsSeeInstance; 


int main() {
  MyClass mC ; 
  std::cout << "using leaking singleton"  << std::endl; 
  MyClassLeaking::Instance().foo(0x0100);
  std::cout << "test3"  << std::endl; 
  test3();
  std::cout << "test3"  << std::endl; 
  test3();
  //std::cin.get();
}

Select allOpen in new window

evilrix: Two questions
a) Did you mean return new CreateGamma as opposed to new  T as reflected below?
b) The class implies that something amiss about the code with the reference to "leaking'.  I'm not sure if I'm seeing anything wrong per se besides the fact that MyClass desctructor is never called.  NOTE: I'm referencing the code posted at ID: 26712359   (with your MyClass destructor _IS_ called - a good thing). Of course you were using 'CreateGamma'

// This is how a Gamma Singleton would instantiate its object. 
template <class T> struct CreateGamma : T { 
  static T* Create() { return new CreateGamma; } 
}; 

Select allOpen in new window

evilrix:  Excellent!  Thanks.. I'm all set again.

>> Excellent!  Thanks.. I'm all set again.
You are very welcome. If you have any more questions please don't hesitate to post back here.