Re: Problem with Singleton template (2)

hi David,

you need to make Singleton a friend of MyList if you want to keep
MyList constructors hidden (private or protected).
second error you get comes from

theIntList* ptheIntList = theIntList::instance();

where you try to assign a pointer to IntList to a pointer to a
Singleton< IntList >. that line should be:

IntList * pIntList = theIntList::instance();

understand that theIntList::instance( ) is your (hopefully) unique
IntList instance.
theIntList is a type of (a specialization of) Singleton that creates
(by demand) a unique instance of IntList.

by looking at your code I would think you're not familiar with boost
libs or if you are you don't want to include some boost libs in this
project.
keep in mind that latest boost libs come with a somehow simplified
meyer singleton implementation. I say simplified because it doesn't
come with creation and destruction policies so you can't control its
lifecycle (nor creation type) although I suspect it's enough for your
project.
also there is a boost::noncopyable base class and some other things
that can solve your issues (for example boost::function_requires to
check type passed to Singleton agains DefaultConstructibleConcept).

singletons, although a simple idiom, proved themselves hard to
implement in a complete, optimized and flexible way in C++ because
mainly the language doesn't allow to us to tell compilers not to
optimize a code block. there are good implementations floating around
but there is always a tradeoff between simplicity, speed and
flexibility. what I'm trying to say is for example std::vector,
std::string and boost::smart_ptr are widely used and accepted but
there is no widely used and accepted singleton template I know of.

back to your project it looks to me that you want to use a singleton
template to create different unique instances on a single base class
hierarchy.
and it also seems that you want to prevent users from instantiating
your base class template and derived classes directly (if this
requirement refers to base class only you can remove the friend
singleton declaration from derived and make their default constructors
public.
I also assumed you also don't know about or you don't want to use
boost.

so I put together some code for you below. the trivial singleton
example is not thread safe and also doesn't come with any lifecycle or
creation/destruction policy. I just wanted to show you how a class
hierarchy can be used together with a singleton, that's it. I tested
the code with mingw/gcc.

cheers,
Gil

/*
  * test_single.cpp
  *
  * Created on: Aug 21, 2008
  * Author: Gill
  */

#include <iostream>
#include <typeinfo>
//#include "boost/concept_check.hpp"

using namespace std;
//using namespace boost;

/**
  * @brief example meyers singleton for David.
  * @warning not thread safe, if used in multithreaded process than
each
  * single instance must be initialized (called for construction)
before
  * spawning threads.
  */
template< class T >
class singleton {

   public:
     static T * instance( ) {
       /*
        * types used as parameters to singleton template must be
default
        * constructible.
        */
       //boost::function_requires< boost::DefaultConstructibleConcept<
T > >( );
       static T t;
       return &t;
     }
   private:
     singleton( );
     ~singleton( );
};

/*
  * @brief non-copy base class
  */
template< class T >
class MyList {
   friend class singleton< MyList< T > >;
   public:
     virtual void foo( ) {
       cout << this << " this is an instance of MyList< " <<
typeid( T ).name( ) << " >" << endl;
     }
   protected:
     MyList( ) { }
     MyList( const MyList< T >& ) { }
     virtual ~MyList( ) { }
};

class IntList
   : public MyList< int > {
   friend class singleton< IntList >;
   public:
     void foo( ) {
       cout << this << " this is an instance of IntList" << endl;
     }
   protected:
     IntList( ) : MyList< int >( ) { }
};

class DoubleList
   : public MyList< double > {
   friend class singleton< DoubleList >;
   public:
     void foo( ) {
       cout << this << " this is an instance of DoubleList" << endl;
     }
   protected:
     DoubleList( ) : MyList< double >( ) { }
};

typedef singleton< IntList > theIntList;
typedef singleton< MyList< int > > theMyListInt;
typedef singleton< DoubleList > theDoubleList;

int
main(
   int argc,
   char ** argv
) {
   IntList * pIntList1 = theIntList::instance( );
   DoubleList * pDoubleList1 = theDoubleList::instance( );
   MyList< int > * pMyListInt1 = theMyListInt::instance( );;

   //polymorphic dispatch from singleton instances
   //use base class pointer to manipulate different types of singleton
   //adapted leaf classes
   MyList< int > * pMyListInt2 = theIntList::instance( );;

   pIntList1->foo( );
   pDoubleList1->foo( );
   pMyListInt1->foo( );
   pMyListInt2->foo( );

   //now check the instances again
   IntList * pIntList2 = theIntList::instance( );
   DoubleList * pDoubleList2 = theDoubleList::instance( );

   pIntList2->foo( );
   pDoubleList2->foo( );

   return 0;
}

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]