ich habe nach dem Wikipedia BeispielCode (siehe http://de.wikipedia.org/wiki/Singleton_(Entwurfsmuster)#Implementierung_in_C.2B.2B)

class Singleton
   {
   private:
      static Singleton* instance;
      Singleton() {}
      Singleton(const Singleton&) {}
      ~Singleton() {}
   public:
      static Singleton& getInstance();
      static void destroy();
   };

   Singleton* Singleton::instance = 0;

   Singleton& Singleton::getInstance()
   {
      if ( !instance )
         instance = new Singleton();
      return *instance;
   }

   void Singleton::destroy()
   {
      if ( instance )
         delete instance;
      instance = 0;
   }

Eine Singelton Klasse implementiert. Und nun versuche ich in meiner weiteren Klasse einer Member Variable die Referenz von getInstance im Ctor zuzuweisen.

D. h. Singelton getInstanz() Ref -> speichern -> Klassenvariable

Also im Header steht:
Singleton* singleton;

CPP steht:

this->singleton=&Singleton::getInstance();

Das Problem was ich mir dadurch einhandle ist, das in der Singleton Methode getInstance() solange new aufgerufen wird bis dann letzten Endes der Stack um die Ohren fliegt.

Ich wollte aus reiner Bequemlichkeit heraus die Instanz meines Singleton Objektes in meiner Arbeitsklasse vorhalten, da diese damit in x Methoden mit dem Singleton Objekt arbeiten muss.

Problemlos möglich ist dagegen überall Singleton::getInstance().doAnything(); aufzurufen, jedoch sobald ich diese Singleton Instanz speichern möchte kracht es eben.

Ich möchte gerne der Vollständigkeit wegen erfahren wieso ich mir diesen Seiteneffekt eingehandelt habe und wie ich diesen gerne vermeide.

Vielen Dank

Nebenbei läuft das Speichern der Instanz dem eigentlichen Sinn eines Singleton etwas entgegen. Wenn du in einer Methode öfter auf den Singleton zugreifst, speicher dir doch lokal in der Funktion die Referenz.

Er ruft getSingleton im Konstruktor des Singleton auf. Das ist natürlich Quatsch und kann nicht gehen.

Sicher, eine Erklärung wäre es. Da er aber in seiner Beschreibung unterscheidet zwischen "Singleton" und "Arbeitsklasse" ging ich erstmal nicht davon aus.
Genaueres kann man erst mit seinem Originalcode sagen.

hustbaer schrieb:

Er ruft getSingleton im Konstruktor des Singleton auf. Das ist natürlich Quatsch und kann nicht gehen.

Sicher, eine Erklärung wäre es. Da er aber in seiner Beschreibung unterscheidet zwischen "Singleton" und "Arbeitsklasse" ging ich erstmal nicht davon aus.
Genaueres kann man erst mit seinem Originalcode sagen.

Nein das tue ich nicht.

Arbeitsklasse die das Singleton verwendet:

TcpClientHandler::TcpClientHandler(string host, string port, boost::asio::io_service& serv, ConnectionManager& connectionManager) : service(serv) {
	//Nachfolgende Zeile stellt den Singleton dar
        this->restService=&RestService::getInstance(); 

	client = new TcpClient(host, 
		port, serv, connectionManager, *this);
	tcpClient.reset(client);

	connectingInProgress = false;	
}

TcpClientHandler::~TcpClientHandler() {
}

Singleton Klasse aufs wesentliche reduziert:

RestService* RestService::instance = 0;

RestService::RestService()
{	
	//.....
	ioService.reset(new boost::asio::io_service());

	this->connectionManager = new ConnectionManager();

	ioServiceWork = new boost::asio::io_service::work(*ioService);

	this->tcpClientHandler = new TcpClientHandler("localhost","3333",*(ioService.get()),*this->connectionManager);

	communicationThread.reset(new boost::thread(boost::bind(&RestService::runIoService,this)));

	this->tcpClientHandler->connectServerAsync();
	// component is now initialized

        ...../
}

void RestService::runIoService() {
	while(!isGoingShutdown) {
		try {
			ioService->run();
			break; // run() exited normally
		}
		catch (exception& e) {
			// Deal with exception as appropriate.
			//onError(status_code_io_service_exception, e.what());
		}
	}
}

RestService& RestService::getInstance()
{
	if(!instance){
		instance = new RestService();
	}
	return *instance;
}

void RestService::destroy()
{
	if(instance)
		delete instance;
	instance = 0;
}

//Restservice.h
static RestService* instance;

Der Lifecycle sieht folgendermaßen aus.

RestService wird instanziert -> diese instanziert TcpClientHandler -> TcpClientHandler greift auf getInstance() des RestServices zu....

Ich habe absichtlich im Ctor von TcpClientHandler kein Object vom Typ RestService übergeben da der RestService ohnehin ein Singleton sein muss aufgrund der Architektur. Da sonst in etlichen Unterklassen Dummy Methoden das RestService Object entsprechend weiter delegieren müssten. Außerdem darf es nur ein Objekt von RestService geben.

Ich könnte zwar ein Objekt von RestService im ctor übergeben allerdings besteht keine Notwendigkeit aufgrund des Singletonansatzes.

Evtl. spielt Threading hier noch mit rein, was ich mir eigentlich nicht vorstellen kann.

RestService wird instanziert -> diese instanziert TcpClientHandler -> TcpClientHandler greift auf getInstance() des RestServices zu...

instance_ist aber noch nicht fertig instantiiert (wird haben unsere Kette dort begonnen), weshalb instance noch immer NULL ist, wodurch wieder RestService::RestService getriggert wird, welche wiederum ein TcpClientHandler-Objekt erzeugt, welches auf RestService::getInstance zugreift, welches...

Ich hoffe du erkennst die Rekursion.

Blutgerinsel schrieb:

RestService wird instanziert -> diese instanziert TcpClientHandler -> TcpClientHandler greift auf getInstance() des RestServices zu...

instance_ist aber noch nicht fertig instantiiert (wird haben unsere Kette dort begonnen), weshalb instance noch immer NULL ist, wodurch wieder RestService::RestService getriggert wird, welche wiederum ein TcpClientHandler-Objekt erzeugt, welches auf RestService::getInstance zugreift, welches...

Ich hoffe du erkennst die Rekursion.

Also wenn ich Dich richtig verstehe...

Dann resultiert das Problem daher, dass zum Zeitpunkt der Initalisierung des TcpClientHandlers der RestService noch nicht fertig initalisiert wurde, da der ctor noch nicht durchlaufen wurde.

Und deshalb funktioniert mein Methodenaufruf der Arbeitsklasse, da zu dem Zeitpunkt ein gültiges Objekt vorliegt.....

Wie konnte mir das nur entgehen

Vielen Dank für Deine Hilfestellung