Re: StateFull vs Stateless Singleton

On Jul 4, 9:02 am, Pallav singh <singh.pal...@gmail.com> wrote:


Neither - a simple template class eliminates the issue altogether:

<code>

#include <stdexcept>

template < typename Type >
class singleton
{
    public:

    singleton( void )
    {
        Type* ptr = static_cast< Type* >( this );
        if( self )
        {
        /*
            Or what have you...
        */
            throw std::runtime_error
            (
                "Error: attempt to instantiate multiple instances of a singleton"
            );
        }
        self = ptr;
    }

    static inline Type& instance( void )
    {
        return *self;
    }

    static inline bool exists( void )
    {
        return self != 0;
    }

    virtual ~singleton( void )
    {
        self = 0;
    }

    private:

    singleton( singleton const& );

    singleton& operator = ( singleton const& );

    static Type* self;
};

template < typename Type >
Type* singleton< Type >::self = 0;

// Example:

#include <iostream>

class foo : public singleton< foo >
{
    public:

    void bar( void ) const
    {
        std::cout << "foo::bar( )" << std::endl;
    }
};

int main( void )
{
    try
    {
        foo a;
        foo::instance( ).bar( );
        foo c; // Whoops!
        foo::instance( ).bar( );
    }
    catch( std::exception const& error )
    {
        std::cerr << error.what( ) << std::endl;
    }
}

</code>

The beauty of the design is that it allows the user to decide how to
allocate and initialize the derived class; it's sole purpose is to
make sure that multiple instances aren't created. Best of all, it's
completely generic!

Cheers.