GetInstance-Methode, um an Klassenpointer aus anderen Modulen ranzukommen

Hallo,

ich hätte eine Frage bzgl. objektorientiertes Design. Und zwar habe ich in einem File global einen Klassenpointer deklariert. In diesem Objekt halte ich irgendwelche Daten. Nun möchte ich von einem anderen file aus auf die Daten in dem globalen Objekt zugreifen. So habe ich es momentan gelöst (die Implementierung ist nur beispielhaft zu verstehen):

/* myClass.h */

class myTestClass
{
private: 
	int i; 
	int j;

public: 
	int GetI( void );
	int GetJ( void );
	void SetI( int newI );
	void SetJ( int newJ ); 
};

/*wrapper functions*/
void InitClass( void );
myTestClass* GetInstance( void );

/* myClass.cpp*/
#include "myClass.h"

static myTestClass* pMyTestClass; /*global class pointer*/

int myTestClass::GetI()
{
	return i;
}

int myTestClass::GetJ()
{
	return j; 
}

void myTestClass::SetI(int newI)
{
	i = newI;
}

void myTestClass::SetJ(int newJ)
{
	j = newJ;
}

/*wrapper functions*/

void InitClass( void )
{
	pMyTestClass = new myTestClass;
}

myTestClass* GetInstance( void )
{
	return pMyTestClass;
}

// test.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "myClass.h"

int _tmain(int argc, _TCHAR* argv[])
{
	if(GetInstance()) /*ensure that the objekt is already available*/
	{
		printf("i: %i - j: %i\n", GetInstance()->GetI(), GetInstance()->GetJ());
	}

	InitClass(); /*NOW the object is available*/
	GetInstance()->SetI(5);  /*use the return value of GetInstance() in order to access members*/
	GetInstance()->SetJ(10);

	printf("i: %i - j: %i\n", GetInstance()->GetI(), GetInstance()->GetJ());

	return 0;
}

Ist das "the way it is supposed to be" oder gibt es irgend etwas ganz tolles, was C++ genau für so etwas vorsieht? Vielen Dank schon mal im Voraus!

Tachyon

Guck Dir mal das hier an. Oder such mal nach weiteren Infos zum Thema Singleton.

Hi,

danke für die rasche Antwort. Dieses Design-Pattern macht auf jeden Fall das, was ich will. Da ich aber schon relativ viel implementiert habe, stellt sich mir die Frage ob mein Ansatz mit der GetInstance()-Funktion einen signifikanten Nachteil hat den ich momentan nicht sehe? Danke.

drakon

Das Problem bei deinem Vorgehen ist, dass man grundsätzlich diese Abfrage immer vornehmen muss, was ein wenig mühsam und unnötig ist. Das singleton hat halt den Vorteil, dass man sicher sein kann, dass es vorhanden ist, wenn man es benutzt. Respektive es wird zuerst halt noch erzeugt. Der heikle Punkt von singletons ist halt die Destruktion. Es könnte z.B sein, dass ein singleton zerstört ist und danach noch von irgendwoher darauf zugegriffen wird. Aber auch dafür gibt es Lösungen, wie z.B das Phoenix Singleton.

Bei dir ist dasselbe Problem ebenfalls vorhanden, du hast aber nichteinmal einen Destruktor, welcher dein Objekt freigibt. Aber selbst wenn du das implementiert hättest, müsstest du überall, wo der Code zu Ende gehen kann (exceptions, return aus der main usw. ) irgendwie ein

GetInstance()->destroy ();

haben.