Singleton per Makro?

SideWinder

Wieso funktioniert das hier nicht wie gewünscht, der meint getInstance() sei private und ich kann nicht drauf zugreifen:

#define PUBLIC public:
#define PROTECTED protected:
#define PRIVATE private:
#define INTERN private:

#define FORBIDDEN_COPY(classname) private: classname (const classname& rhs) {}
#define FORBIDDEN_ASSIGN(classname) private: classname& operator= (const classname& rhs) { return *this; }

#define MAKE_SINGLETON(classname) \
	PRIVATE classname (); \
	PUBLIC ~classname (); \
	PUBLIC static classname& getInstance () { static classname object; return object; } \
	FORBIDDEN_COPY(classname) \
	FORBIDDEN_ASSIGN(classname)

class Example
{
    MAKE_SINGLETON(Example)
};

Bzw. gibts da sicher auch schönere Lösungen die ihr kennt? Wäre nett, ich will das nämlich vereinfachen und da nicht jedesmal x Methoden aufschreiben.

MfG SideWinder

phlox81

Man kann den Singelton über ein Template realisieren.
Man erhält dann zur Laufzeit das Verhalten eines Singeltons,
ohne das man das Verhalten in der eigentlichen Klasse selber
implementiert hat.

SideWinder

Hab nur beim Instanzieren einen Fehler gemacht, funktioniert also doch.

Aber kennt jemand schönere Lösungen?

MfG SideWinder

SideWinder

phlox81 schrieb:

Man kann den Singelton über ein Template realisieren.
Man erhält dann zur Laufzeit das Verhalten eines Singeltons,
ohne das man das Verhalten in der eigentlichen Klasse selber
implementiert hat.

Kennst du da Links? Ich möchte eigentlich ganz einfach nur eine Zeile irgendwo hinklatschen und ein Singleton haben

MfG SideWinder

Kennst du Loki?

phlox81

Über die Forensuche wirst du leider wohl nix dazu finden

Dann paste ich den Code mal hier rein:

#ifndef Singelton_h
#define Singelton_h

template<class T>
class Singelton
{
	static T* singelton;
	static unsigned int n;
protected:
public:
	Singelton()
	{
		if(!singelton)
			singelton = new T;
		n++;
	};
	virtual ~Singelton(){
	if(!--n)
		delete singelton;
	};
	T* operator->()
	{
	return singelton;
	}
	T& GetInstance()
	{
	return *singelton;
	}
};

template<class T> T* Singelton<T>::singelton;
template<class T> unsigned int Singelton<T>::n;
#endif

Die boost library enthält eine Klasse noncopyable, von der man ableiten kann. Schau dir das doch mal an.
rya.
Scorcher24

miller_m

Scorcher24 schrieb:

Die boost library enthält eine Klasse noncopyable, von der man ableiten kann. Schau dir das doch mal an.
rya.
Scorcher24

hat doch gar nichst mit singletons zu tun.

#define FORBIDDEN_COPY(classname) private: classname (const classname& rhs) {}
#define FORBIDDEN_ASSIGN(classname) private: classname& operator= (const classname& rhs) { return *this; }

aber mit diesem code. und er wollte ne elegantere Lösung für den ganzen code wissen. Ich finde class foo : public noncopyable eleganter. Das ist alles.
rya.
Scorcher24

miller_m

Scorcher24 schrieb:

aber mit diesem code. und er wollte ne elegantere Lösung für den ganzen code wissen. Ich finde class foo : public noncopyable eleganter. Das ist alles.
rya.
Scorcher24

jetzt wird mir es klar