ich habe ein Problem mit einem Singleton.

Im Prinzip sagt ja die Fehlermeldung
"Kein Zugriff auf private Member, dessen Deklaration in der Application-Klasse erfolgte"

das ich auf einen privaten Member zugreifen will, das ist aber in diesem Fall (glaub ich) nicht so ...

Singleton.hpp

#ifndef Singleton_hpp
#define Singleton_hpp

template <class T>
class Singleton
{
protected:
	static T* singleton;

public:
	inline static T* Get()
	{
		if (!singleton)
			singleton = new T(); //Hier zeigt er die Meldung an

		return singleton;
	}

	static void Destroy()
	{
		delete singleton;
	}
};

template <class T>
T* Singleton<T>::singleton = NULL;

#endif //Singleton_hpp

Application.hpp

#ifndef Application_hpp
#define Application_hpp

#include "Singleton.hpp"

#define App (*(Application::Get()))

class Application : public Singleton<Application>
{
private:
	Application() : x(0), y(0.f){}
	~Application(){ Singleton<Application>::Destroy(); }

	Application(int x) : x(x), y(0.f){}

	Application(float y) : x(0), y(0.f){}

private:
	int x;
	float y;

public:
	int GetX(){ return x; }
	float GetY(){ return y; }
};

#endif //Application_hpp

main.cpp

#include "Application.hpp"
#include <iostream>

int main()
{
	std::cout << App.GetX() << std::endl;
	std::cout << App.GetY() << std::endl;

	std::cin.get();
}

Meiner Meinung nach, rufe ich doch dann mit

App.GetX();
//das hier auf
Application.Get().GetX();

Mit Application.Get() kann ich doch auf den privaten Konstruktor von Application zugreifen, oder nicht?

Was ich noch erreichen will, aber erst später hinzu kommt, sind verschiedene Konstruktoren in Application, die ich zum Initialisieren beim 1. mal benutzten möchte, dh ich habe mehrere Konstruktoren und definiere in etwa so etwas:

#define App (*(Application::Get))

//und
class Application
{
...
public:
    static Application* Get(int x);
    static Application* Get(float y);
...
}

Und dann hier sowas:

App(1); //Initialisierung mit einem Integer
App(1.f); //Initialisierung mit einem Float
App(); //Standard

Aber bei dem Versuch bekomme ich die Meldung, das der Compiler nicht weiß, welche Funktion er benutzen soll ...

IDE: VS2010 -> zugehöriger Compiler

Gruß Simon

Mit Application.Get() kann ich doch auf den privaten Konstruktor von Application zugreifen, oder nicht?

Application::Get gibt's nicht, nur Singleton::Get. Und da darfst du den Konstruktor von Application nicht aufrufen, weil er private ist.

... oder gibt es noch andere Möglichkeiten?

... oder gibt es noch andere Möglichkeiten?

Friend?

Ich habe da noch ein kleines Problem, welches sicherlich leicht zu lösen ist:
bei

template <class T>
T* Singleton<T>::singleton = NULL;

bekomme ich die Fehlermeldung "'NULL': nichtdeklarierter Bezeichner"

Wenn ich mit der Maus über "NULL" gehe ist dort "#define NULL 0" angegeben

Wenn ich den Pointer nicht auf NULL setzte bekomme ich einen anderen Fehler:

Nicht aufgelöstes externes Symbol ""protected: static class Application * Singleton<class Application>::singleton" (?singleton@?$Singleton@VApplication@@@@1PAVApplication@@A)" ....\main.obj

Schreibe 0 statt NULL

Immer eine gute Idee. denn es könnte ja irgendein Schelm im Projekt mal NULL umdefinieren. Und den Fehler suchst du lang!

Lars

das mit 0 statt NULL ist keine schlechte Idee, ich versuch mir das mal anzugewöhnen ...

Das mit Destroy: Sollte ich Destroy im Destruktor des Singletons(Basis) aufrufen?
also

~Singleton(){ Destroy(); }

?

...
Das mit Destroy: Sollte ich Destroy im Destruktor des Singletons(Basis) aufrufen?
also

~Singleton(){ Destroy(); }

?

Nein, in keinem Destruktor. Die Funktion Destroy ruft (implizit über delete) den Destruktor auf. Dann darf der aber nicht wieder Destroy aufrufen, da das dann nie (naja, beim Stacküberlauf schon) endet.

Was willst du denn mit der Funktion erreichen? Das am Programmende der Speicher freigegeben wird? Oder soll das Singleton während das Programmablaufs neu gesetzt werden können?

Lars

Das mit Destroy: Sollte ich Destroy im Destruktor des Singletons(Basis) aufrufen?

Gleiches Problem.

Die Frage ist doch, wie die Zerstörung deines Singleton überhaupt ausgelöst werden soll. Soll das von allein gehen, oder muss der Benutzer etwas tun?

Am besten beides, dh wenn ich das "neu initialiseren" will und halt bei Programmende den Speicher freigeben ...

Dann müsste dein Destroy so aussehen:

static void Destroy()
    {
        delete singleton;
        singleton = 0;
    }

Am Programmende musst du Application::Destroy() zu Fuß ausführen, oder immer dann, wenn du das Singleton neu initialisieren möchtest. Im Detruktor wird die Funktion aber nicht aufgerufen.

Ich glaube aber noch ein anderes Problem zu sehen: die eigentliche Singeltonvariable wird mit

template <class T>
T* Singleton<T>::singleton = NULL;

im Header Singleton.hpp definiert. Meiner Meinung nach erzeugst du damit mehrere Versionen in den CPPs, in denen du Applikation benutzt => ODR (one definition rule) verletzt => undefiniertes Verhalten. Ich bin mir aber nicht sicher, ob das wirklich falsch ist.

Lars

Aber das mit dem manuell Aufrufen ist schon ein bisschen umständlich, ich will ja später mehrere Klassen von Singleton erben lassen und das dann von allen selber aufrufen

Ok, die Destroy-Methode ist geändert ...

Aber das mit dem manuell Aufrufen ist schon ein bisschen umständlich, ich will ja später mehrere Klassen von Singleton erben lassen und das dann von allen selber aufrufen

Naja, du kannst das Löschen am Ende ja auch sein lassen. Das macht das Betriebssystem sowieso. Oder du benutzt statt T* für die Membervariable singleton einen std::auto_ptr<T>. Dann musst du nichts manuell machen.

Lars

Warum eigentlich überhaupt erben?

Singleton-Vererbung ist C++-Anfänger-Stil, das sieht man leider in jedem schlechten Code.

ich wollte mir halt eine einzige Klasse erstellen, von der ich nur noch erben muss, aber im Prinzip habt ihr recht, um ein Singleton zu erstellen braucht man ja nicht viel, das kann man dann auch jedesmal wieder machen, und die 3 Zeilen mehr Code machens dann auch nich mehr aus.

Ich werde euren Rat beherzigen und die Singleton Klasse über Bord werfen.

Baut man eigentlich bei einem Singleton einen Destruktor ein?, oder benutzt man hier nur eine Destroy / Delete-Methode?

Wie müsste ich eine Singleton-Klasse aufbauen, die mit einem auto_ptr funktioniert?

Baut man eigentlich bei einem Singleton einen Destruktor ein?, oder benutzt man hier nur eine Destroy / Delete-Methode?

Destruktor und Destroy sind verschiedene Sachen. Destroy soll das statische Objekt zerstören (mit delete), der Destruktor kümmert sich darum, dass beim Zerstören auch brav alle Member zerstört werden und der Speicher bereinigt wird.

Du brauchst also auch bei einem Singleton einen Destruktor, wenn du z.B. dynamisch alloziierte Member hast, oder sonst was aufgeräumt werden muss.

Wie müsste ich eine Singleton-Klasse aufbauen, die mit einem auto_ptr funktioniert?

Das brauchst du eigentlich auch nicht. Ich hab oben schon den "Meyer Singleton" erwähnt:

#include <vector>
#include <iostream>

struct Item {
    Item(int val)
     : value(val)
    {}
    int value;
};

class Manager {
    Manager() { std::cout << "Konstruktor" << std::endl; }
    ~Manager() { std::cout << "Destruktor" << std::endl; }
    Manager(const Manager&);
    Manager& operator=(const Manager&);

    std::vector<Item> items;

public:
    static Manager& get() {
        static Manager m;
        return m;
    }

    void manage(const Item& i) {
        items.push_back(i);
    }

    const std::vector<Item>& managedItems() const {
        return items;
    }
};

int main() {
    Manager::get().manage(Item(10));
    Manager::get().manage(Item(20));

    const std::vector<Item>& items = Manager::get().managedItems();
    for(size_t i=0; i<items.size(); ++i)
        std::cout << items[i].value << " ";
    std::cout << std::endl;
}

Schau dir die get()-Funktion an. Auch den Destruktor kannst du private machen, damit niemand auf dumme Gedanken kommt :p

Alle meine Fragen sind jetzt beantwortet ....

CLOSED