✔ Statisches Programm dynamisch machen

[mc_gulasch]

Aloah Forum,

ich hab eine bestehendes Programm und definiere am Anfang die Arrays:

unsigned int table_one[NUM_TAB_TWO][MAX_TO+MAX_FROM+2];
unsigned int table_two[NUM_TAB_TWO][MAX_TO+MAX_FROM+2];

Es ist kein Problem wieder an die Größen der Arrays zu kommen und auch weiß ich (so ungefähr) wie man diese dann mit malloc verwurstet, allerdings ist mir noch eine Sache etwas unklar:

Ich hab in meinem bestehnden Programm einige Funktionen, die direkt auf diese tables zugreifen und ich möchte sie auch gerne als diese behalten. Jetzt geht es allerdings nicht, sie als

unsigned int table_one[][];

zu initialisieren.

Was muss ich machen, dass eine Funktion,die direkt auf die Tabellen zugreift,wie z.B.

void make_jump_table (void)
{	int i,j;
	j=0;
	for (i=0;i<NUM_TAB_ONE;i++)
	{	if(jump_table_one[table_one[i][2]]==0)
			jump_table_one[table_one[i][2]]=&(table_one[i][0]);
	}
	for (i=0;i<NUM_TAB_TWO;i++)
	{	if(jump_table_two[table_two[i][2]]==0)
			jump_table_two[table_two[i][2]]=&(table_two[i][0]);
	}
}

weiterhin funktioniert?

Danke schonmal!

 

[deepthroat]

Hi.

Das hab ich dir hier schonmal gezeigt wie ein dynamisches 2-dimensionales Array definiert und initialisiert wird: http://www.tutorials.de/forum/1286246-post9.html

Du mußt dann natürlich dran denken die "Unterarrays" und danach auch das ganze Array mit free wieder freizugeben.

Gruß

 

[mc_gulasch]

Danke dir, klappt wunderbar. Aber es klappt noch eine Kleinigkeit nicht:
Ich habe einen Wechselpointer, der mal auf die eine Tabelle, mal auf die andere zeigt

unsigned int **pTabs = table_one;

wenn ich jetzt über

 **(pTabs+i) = j

Werte zuweise, dann wird aber in table_one lediglich die erste Spalte (table_one[i][0]) gefüllt. Wie springe ich im Speicher weiter auf, z.B. table_one[0][i] (über pTabs mein ich)?

 

[deepthroat]

 **(pTabs+i) = j

Man kann das natürlich so schreiben. Die j-te Spalte erreichst du dann über:

*(*(pTabs + i) + j) = x;

Allerdings macht es sich meistens besser die Array-Schreibweise zu verwenden:

pTabs[i][j] = x;

(da pTabs als int** deklariert ist, ist das äquivalent zu der Schreibweise oben)

Gruß

 

[mc_gulasch]

Oh mann...diese Zeiger machen mich irgendwann nochmal fertig oder ich versteh sie... mal schauen, was zuerst kommt.
Wenn du grad noch Zeit & Lust hast, magst du mir noch folgendes verraten:
Ich habe in der main - Fkt eine Datei geöffnet, möchte sie aber 2 x in einer Fkt verwenden:

FILE *o = fopen("pfad","r");
fkt1(o);
fkt2(o);

Leider haben beide eine While - Schleife mit "feof(*file)", d.h. das Ende der Datei ist in der ersten Fkt. erreicht. Wie schaff ich es, dass die 2. Fkt es trotzdem liest?

 

[deepthroat]

Erstmal solltest du die Schleife besser so schreiben:

while (!ferror(datei) && !feof(datei)) ...

denn wenn ein Fehler aufritt wird das Dateiende nie erreicht und du hast eine Endlosschleife.

Dann kannst du den Befehl fseek verwenden um den internen Dateicursor wieder an den Anfang von der Datei zu positionieren bevor du die zweite Funktion aufrufst (oder in der zweiten Funktion):

fseek(datei, 0, SEEK_SET);

Gruß

 

[mc_gulasch]

Ok, danke.
Du hast mir doch auch letztens bei diesem qsort() Prob geholfen. Ich hab den Aufruf des qsorts() jetzt so gelassen, wie er vorher war, allerdings funktioniert er jetzt nichtmehr, soll heissen, er fängt nichtmal an. Wenn man in die cmp-Fkt ein "HI" ausgeben lässt, kriegt man es nicht.
Code dafür wäre dieser:

unsigned int **table_one;
....
//Hier wird die Groesse der Tabelle festgelegt:
void alloc_tables(void)
{
	int i;
	table_one = (int**) calloc(NUM_TAB_ONE,sizeof(int*));
	for(i=0;i<NUM_TAB_ONE;i++)
		table_one[i]=(int*) calloc ((MAX_ONE+2),sizeof(int));
}
...
//Tabelle wird befuellt und dann hier der qsort():
qsort(table_one,sizeof(table_one)/sizeof(table_one[0]),sizeof(table_one[0],cmp);
//mit cmp:
int cmp(const void **ptr1, const void **ptr2) 
{
	const unsigned int** p_1 = (unsigned int**)ptr1;
	const unsigned int** p_2 = (unsigned int**)ptr2;
		
	if (*(p_1+2)<*(p_2+2))
		return 1;
	
	else if (*(p_1+2)==*(p_2+2))
	         return 0;
	else
		return -1;
}

Leider packt er das nimmer. Er sagt fuer
size(table_one) = 4
size(table_one[0]) = 4
wobei doch eigentlich size(table_one) die Zeilenzahl der Matrix sein müsste (oder nicht) und die bei mir bei ca. 80 liegt. Check grod nix mehr!

 

[deepthroat]

Leider packt er das nimmer. Er sagt fuer
size(table_one) = 4
size(table_one[0]) = 4
wobei doch eigentlich size(table_one) die Zeilenzahl der Matrix sein müsste (oder nicht) und die bei mir bei ca. 80 liegt. Check grod nix mehr!

Der sizeof Operator bestimmt zur Kompilierzeit die Größe der Variablen oder des Typs das als Argument übergeben wird. Dadurch das table_one als int** deklariert und also table_one[0] vom Typ int* ist, ist das natürlich völlig richtig das beide Werte gleich sind. Auf einer 32 Bit Maschine ist es auch logisch das ein Zeiger 4 Byte groß ist.

Ich hab den Aufruf des qsorts() jetzt so gelassen, wie er vorher war

Irgendwie seh ich da was anderes. Wenn du es so gelassen hättest, wäre es richtig gewesen.

Die Vergleichsfunktion muß diesen Prototyp haben:

int func(const void*, const void*)

Das heißt du solltest da die Typen der Parameter nicht verändern. Das ist zwar nicht tragisch (du kannst da auch 50 Sternchen eintragen) aber auch nicht schön.

Die Vergleichsfunktion mußt du jetzt natürlich ändern, da du ja vorher Zeiger auf eine flache Struktur übergeben bekamst und jetzt bekommst du tatsächlich Zeiger auf Zeiger.

int cmp (const void* a, const void* b) {
  const unsigned aa* = *(unsigned int**)a;
  const unsigned ba* = *(unsigned int**)b;

  if (aa[2] < ba[2]) ...

Gruß

 

[mc_gulasch]

Sorry, aber er schmeisst mir bei aa* zig - Fehler, aber nur von der Art

missing ";" before "*" (oder "type" oder....)

//edit: Abgesehen davon, wenn ich die cmp NUR aus

printf("HI")

bestehen lasse, passiert auch nix. Das mit den Bytes, seh ich ein, aber wenn ich die zweite Eingabegröße für qsort() verändere, geht er wenigstens rein in cmp()...

 

[deepthroat]

Ach herrje. :-(

Ich wollte natürlich schreiben:

unsigned int* aa = *(unsigned int**)a;

Und bei dem Aufruf hab ich mich wohl an etwas anderes erinnert - deswegen sagte ich ja, das ich da was anderes sehe. Sorry.

Also, nachdem ich ja schon erklärt habe wieso du sizeof für die Bestimmung der Anzahl der Elemente eines dynamischen Arrays nicht verwenden kannst (weil der Speicher ja erst zur Laufzeit alloziert wird), mußt du die Anzahl der Elemente selbst speichern/wissen.

qsort (table_one, NUM_TAB_ONE, sizeof(table_one[0]), cmp);

PS: Zeit Feierabend zu machen. Bis denne.

Gruß