[Boost-users] shared_ptr singleton

16 Oct 2008

      Hello,
I'm getting some troubles with shared_ptr when trying to implement a
singleton pattern.
Actually, it's not the singleton itself (which seems to work, in a
separate program), but in the context I need it, doesn't work.

I tried to figure out why (and actually I found an alternative
implementation which works), but still I'm trying to understand what
goes wrong.

I'm trying to do this:
having a hierarchy of classes where there is one Base class and a
number of derived ones, each class is in a different cpp file.
All these classes must be registered in a Register class, which is
itself derived from Object.
Register is the singleton, implemented like this:

class Register;
typedef shared_ptr<Register> RegisterP;
class Register: public Object {
public:
	Register();
	void add(string name) {
		// Stuff with name
	}
	static RegisterP global() {
		if (!_global) _global = RegisterP(new Register); // *
		return _global;
	}
private:
	static RegisterP _global;
};

To register the various classes, does exist a special class, not in
hierarchy, like this:

class ClassRegisterer {
public:
	ClassRegisterer::ClassRegisterer(string name) {
		Register::global()->register(name);
		// **
	}
}

#define REGISTER(C) ClassRegisterer _registerClass_ ## C ( #C)

In each file of the of the project, this macro is used when a class is created:

Foo.cpp
class Foo: public Object {...};
REGISTER(Foo);

Bar.cpp
class Bar: public Object {...};
REGISTER(Bar);

This is also used for the Register class itself:

Register.cpp
class Register: public Object {...};
REGISTER(Register);

The problem is that global() is called N times, but the new Register
(*) is executed twice, instead of once.
Investigating with some couts, I found out that - dunno why - the
pointer _global is set to 0 after the first execution,
in fact at the time of second execution it's created another object,
which isn't deleted and is kept.

Trying quickly with a debugger, it seems that at (**) a destructor for
shared_ptr is called,
and I think that it may be the cause of the issue, but I'm having an
hard time figuring this out and *why* a destructor is called (maybe
it's just for a temporary object).

Looking at boost docs, i found out this:
http://www.boost.org/doc/libs/1_35_0/libs/smart_ptr/sp_techniques.html#stati...
so I tried to use that null deleter, like this:

struct nullDeleter {
	void operator()(void const *p) const {
		cout << "Trying to delete " << p << endl;
	}
};

and used like:
		if (!_global) _global = RegisterP(new Register, nullDeleter());

The problem is that this is never called! The object is never
destroyed by this, but somehow the static _global is set to 0 (only
once), and thus allocated twice.

I temporary solved this using a static raw pointer, which is allocated
once and a shared_ptr is built with it:

class Register {
...
	static RegisterP global() {
		if (!_global) _global = new Register;
		return RegisterP(_global, nullDeleter());
	}
...
	static Register *_global;
};

Which works.

Any suggestion is welcome :)

Thanks
-- 
~Ale

[Boost-users] shared_ptr singleton

Alessandro Re