Re: Singleton base class
[posted & mailed; reply was already mailed to OP]
Vicky wrote:
On Jun 12, 5:46 pm, Bart van Ingen Schenau <b...@ingen.ddns.info>
wrote:
Vicky wrote:
Can we define a base class say Singleton whose responsibility will
be
make its own derived class Singleton too without tempting the
internal
structure and representation of derived class. Ex:
No, because if TestClass has a public constructor & destructor,
there is
very little to stop a user from writing
Testclass a;
Testclass b;
and defeating the one-instance policy.
class Singleton
{
};
class TestClass : <access specifier> Singleton
{
// No changes are allowed here because it is already well
defined.
};
We can't even add "friend class Singleton" in TestClass.
If you can live with a runtime error, instead of a compile-time
error
for attempting to create multiple instances, you could inherit from
this
class:
template <class Derived>
class Singleton
{
public:
static Derived& getInstance()
{
static Derived instance;
return instance;
}
protected:
Singleton()
{
if (m_instanceExist)
throw std::logic_error("Singleton policy broken");
m_instanceExists = true;
}
public:
~Singleton() { m_instanceExists = false; }
private:
Singleton(const Singleton&); // not implemented
void operator=(const Singleton&); // not implemented
static bool m_instanceExists;
};
class TestClass : public Singleton<TestClass>
{
// original contents of TestClass
};
Thanks in advance
Bart v Ingen Schenau
I don't think what you proposed is the solution. Because according to
this, Any body can create object of TestClass without calling
Singleton<Derived>::getInstance().
Anybody can try to do that, but the constructor of Singleton<Derived>
will throw an exception if a second object is being constructed. Note
that the member m_instanceExists is static and thus is shared between
all instances.
Since ctor of Singleton is protected and dctor of Singleton is public
both of these functions are easily accessible through TestClass.
In fact, there are problems:
1. TestClass should maintain the behaviour of singleton
2. No modification is allowed in TestClass. We can change their
members access specifier only.
Here you give some very important information that was not present
before. If you can change the access specifiers, you can make the
constructors inaccessible to casual users of the class.
3. The member of TestClass should also be initialize (ctor call).
4. At the time of destruction if dctor should be called.
In general we have to define a class named Singleton whose all derived
class must behave as Singleton without forcing major modification (any
kind of coupling etc.) into derived class.
The major problem with your requirements is that, for a Singleton policy
to work correctly, there must be only one function (or if need be,
class) that has access to the constructors, but you are not allowed to
add either that function itself or a friend declaration for it to the
class.
Without changing access to the constructors, your only option is a class
like I posted before, with a pure runtime check that there is only a
single instance.
When you can change the access to the constructor (to protected, which
is the best you can get given the constraints), you can use a trick like
the one below, to get a compiler error for accidental definitions like
Testclass a;
Multiple instances through a derived class must still be checked at
runtime.
template <class Derived>
class Singleton
{
private:
/* Create a private derived class to gain access to the (protected)
constructor of Derived, so we can create an instance. */
struct SingletonHelper : Derived {};
public:
static Derived& getInstance()
{
static SingletonHelper instance;
return instance; /* implicit conversion D -> B */
}
protected:
/* Constructor is protected to we are created only together with a
derived class */
Singleton()
{
if (m_instanceExist)
throw std::logic_error("Singleton policy broken");
m_instanceExists = true;
}
/* public: // public or protected access to destructor does not really
matter */
~Singleton() { m_instanceExists = false; }
private:
/* dis-allow copying and assignment. This carries over to the derived
class */
Singleton(const Singleton&); // not implemented
void operator=(const Singleton&); // not implemented
static bool m_instanceExists;
};
class TestClass : public Singleton<TestClass>
{
protected:
TestClass() {}
public:
// original contents of TestClass
};
Usage:
class Hack : TestClass {};
Testclass& ref = Testclass:getInstance();
//Testclass obj; Error: constructor inaccessible
Hack hacked; // Compiles, but runtime error (exception)
Bart v Ingen Schenau
--
a.c.l.l.c-c++ FAQ: http://www.comeaucomputing.com/learn/faq
c.l.c FAQ: http://c-faq.com/
c.l.c++ FAQ: http://www.parashift.com/c++-faq-lite/
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]