Ahh! Sorry.. das kommt davon, wenn man nachts kurz vorm Einpennen aus dem Gedächtnis sourcecode schreibt

Quote:

Du erstellst im ersten Konstrukt eine Funktion, die ein TEX_INFO Objekt zurückgibt, muss es nicht ein TEX_LAYER Objekt sein?



Richtig!

Quote:

Du hast da jetzt geschrieben, das du eigene Destruktoren schreibst, weil free nicht wirklich effizient ist. Wie kann man das machen?




Indem du für jeden Datentyp eine Funktion dafür schreibst! Wenn ein struct Unterstructs besitzt, müssen die nämlich evtl. gesondert verarbeitet werden. Weil du nämlich in TEX_INFO ein array von pointern hast, würde free(..) nur die Pointer löschen - und nicht das, was dahinter steckt. Oder wenn du z.B. strings in einem struct hast, musst du ja str_remove aufrufen - da wird free(..) dann nicht das gewünschte Ergebnis bringen.

Code:
void freeTEX_LAYER(TEX_LAYER* _obj)
{
	//TEX_LAYER hat nur Standardvariablen, also können wir free benutzen!!!
	free(_obj);
}

void freeTEX_INFO (TEX_INFO* _obj)
{
	static int i;
	for (i = 0; i < 10; i++)
		freeTEX_LAYER(_obj->texinfo[i]);

	free(_obj);
}


Quote:

In der Struktur TEX_INFO ist ja ein Array von TEX_LAYER Objekten definiert. In deinen Konstrukt ist wird aber nur ein Objekt Initialisiert. Das kann man aber auch mit einer schleife machen, die alle Array Objekte initialisiert, oder?



Ja, sicher. Aber du brauchst dafür noch nicht einmal eine Schleife.

Code:
//Schleifenvariante:
TEX_INFO* getTEX_INFO()
{
   TEX_INFO* temp = (TEX_INFO*)(malloc(sizeof(TEX_INFO)));

   static int i;
   for(i = 0; i < 10; i++)
      temp->texinfo[i] = getTEX_LAYER();

   //hier kannst du irgendwas initialisieren

   return(temp);
}

//Mallocvariante:
TEX_INFO* getTEX_INFO()
{
   TEX_INFO* temp = (TEX_INFO*)(malloc(sizeof(TEX_INFO)));

   temp->texinfo = (TEX_INFO**)malloc(sizeof(TEX_INFO*[10]));

   //hier kannst du irgendwas initialisieren

   return(temp);
}


Die zweite Variante ist einerseits effizienter, weil du mit einem Schlag den Speicherbereich allozierst - aber dann verstößt du auch wieder gegen den Versuch, das alles mit Konstruktoren zu lösen. Du könntest dir jetzt eine Funktion schreiben, die das erledigt (somit wird dein Code auch schlanker, bzw. lesbarer (ich persönlich mag es nicht wenn Allozierungszeug irgendwo in meinem gamecode steht).

Nun, wenn du aber das Erzeugen eines Arrays von Objekten auslagerst und das mit einem Schlag mit malloc(..) machst, dann hast du das Problem, dass die Objekte nicht initialisiert werden. Diesen Code hast du aber bereits in der Funktion stehen, die EIN Objekt von TEX_LAYER erzeugt. Nun ist es am besten den Initialsierungscode auszulagern - sodass alle Konstruktoren diesen code sharen. Beispiel:

Code:
TEX_LAYER* initTEX_LAYER(TEX_LAYER* _obj)
{
   //hier kannst du irgendwas initialisieren
   return(_obj);
}

TEX_LAYER* getTEX_LAYER()
{
   TEX_LAYER* temp = (TEX_LAYER*)(malloc(sizeof(TEX_LAYER)));
   return(initTEX_LAYER(temp)); //initialisierung und Rückgabe
}

TEX_LAYER** getTEX_LAYER_array (int _size)
{
   TEX_LAYER** temp = (TEX_LAYER**)(malloc(sizeof(TEX_LAYER*[_size])));

   //initialisierung
   static int i;
   for (i = 0; i < _size)
      initTEX_LAYER((TEX_LAYER*)(temp[i]));

   return(temp);
}


Wie du nun einen Destruktor für das Löschen von Arrays von Objekten baust, kannst du nun von den Beispielen relativ einfach ableiten.

Kein Gewähr auf die Lauffähigkeit des codes bin grad aufgestanden

Viel Erfolg,
Christian