typedef struct
{
	char tex_name[35];
	var tex_id;
	var tile_count;	
}TEX_LAYER;

typedef struct
{
	TEX_LAYER texinfo[10];
	char vorschau[20];
	char format[5];
}TEX_INFO;

TEX_INFO tex_info;

typedef struct
{
	char tex_name[35];
	var tex_id;
	var tile_count;	
} TEX_LAYER;

TEX_INFO* getTEX_LAYER()
{
	TEX_LAYER* temp = (TEX_LAYER*)(malloc(sizeof(TEX_LAYER)));
	//hier kannst du irgendwas initialisieren
	return(temp);
}

typedef struct
{
	TEX_LAYER* texinfo[10];
	char vorschau[20];
	char format[5];
} TEX_INFO;


TEX_INFO* getTEX_INFO()
{
	TEX_INFO* temp = (TEX_INFO*)(malloc(sizeof(TEX_INFO)));
	temp->texinfo = getTEX_LAYER();
	//hier kannst du irgendwas initialisieren
	return(temp);
}

void main ()
{
	TEX_INFO* test123 = getTEX_INFO();	
	test123->texinfo->tex_id = 12345;
}

• Struktur definiere und per typedef zu einem Datentyp machen
• mindestens eine Konstruktorfunktion schreiben, die die Struktur komplett initialisiert und evtl. Unterstrukturen erzeugt und initialisiert.
• Eventuell andere alternative Konstruktoren schreiben, die eine Parameterliste enthalten, um bestimmte Attribute zu initialisieren
• Auch Destruktoren schreiben, die eine Struktur komplett entfernen. Wenn du außergewöhnliche Datentypen als Attribute hast (bitmaps, texts, andere eigene Strukturen), dann soll der Destruktor natürlich die ganz besonders anfassen. Ein simpler free Befehl hilft da nicht weiter (Unterschied flaches löschen und tiefes löschen!)
• Getter und Setter Funktionen für die Variablen. Durch die -> Syntax kann man zwar bequem auf die Attribute zugreifen, aber eventuell ändert sich ja was in der Struktur oder in der Verarbeitung und dann sitzt man da und ändert das im gesamten Code ab. Gemäß des Sichtbarkeitsprinzips aus der OOP hab ich mir angewöhnt getter/setter Funktionen auch für meine C Strukturen zu schreiben. Vor allem weil man dann bei nicht trivialen Attributen gesondert darauf zugreifen/schreiben kann

  
typedef struct
{
	char tex_name[35];
	int tex_id;
	int tile_count;	
}TEX_LAYER;

typedef struct
{	
	TEX_LAYER* tex_layer[layer_count];
	char vorschau[20];
	char format[5];
}TEX_INFO;

TEX_LAYER* getTEX_LAYER()
{
	TEX_LAYER* temp = (TEX_LAYER*)(malloc(sizeof(TEX_LAYER)));
	temp->tex_name = " ";
	temp->tex_id = 0;
	temp->tile_count = 16;
	return(temp);
}

TEX_INFO* getTEX_INFO()
{
	var count_var = layer_count-1;
	TEX_INFO* temp = (TEX_INFO*)(malloc(sizeof(TEX_INFO)));
	
	while(count_var > 0)
	{
	temp->tex_layer[count_var] = getTEX_LAYER();
	count_var -= 1;
	}
	
	temp->vorschau = "_vorschau";
	temp->format = ".dds";
	
	return(temp);
}

...
tex_info = getTEX_INFO();
...

//Und hier crash es und nicht nur da, bei allen zugriffen auf das Objekt crashed es.

function get_tex_enter( var x, var y, TEXT* text_p, TEX_INFO* tinfo, var index, STRING* enter, BMAP* pre_map, PANEL* layer_tx)
{
	...
	tinfo->tex_layer[index]->tex_id = index;
	...	
	return;	
} 
...
//die aufgerufene function hat folgende Parameter:
get_tex_enter(920, 90, eingabetext,tex_info, button_number, eingabe, test, layer1);
...

Quote:

---

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

---

Quote:

---

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

---

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

typedef struct
{
	char tex_name[35];
	int tex_id;
	int tile_count;	
}TEX_LAYER;

typedef struct
{	
	TEX_LAYER* tex_layer[layer_count];
	char vorschau[20];
	char format[5];
	var  testvar;
}TEX_INFO;

TEX_LAYER* getTEX_LAYER()
{
	TEX_LAYER* temp = (TEX_LAYER*)(malloc(sizeof(TEX_LAYER)));
	temp->tex_name = " ";
	temp->tex_id = 0;
	temp->tile_count = 16;
	return(temp);
}

TEX_INFO* getTEX_INFO()
{
	var count_var = layer_count-1;
	TEX_INFO* temp = (TEX_INFO*)(malloc(sizeof(TEX_INFO)));
	
	static int i;
   for(i = 0; i < 10; i++)
	temp->tex_layer[count_var] = getTEX_LAYER();
	
	temp->vorschau = "_vorschau";
	temp->format = ".dds";
	temp->testvar = 0;
	
	return(temp);
}

...
TEX_INFO* tex_info = getTEX_INFO();
...

//Und hier crash es und nicht nur da, bei allen zugriffen auf das Objekt crashed es.

function get_tex_enter( var x, var y, TEXT* text_p, TEX_INFO* tinfo, var index, STRING* enter, BMAP* pre_map, PANEL* layer_tx)
{
	...
	tinfo->tex_layer[index]->tex_id = index;
	...	
	return;	
} 
...
//die aufgerufene function hat folgende Parameter:
get_tex_enter(920, 90, eingabetext,tex_info, button_number, eingabe, test, layer1);
...