Problem mit dem Speichern, bzw Auslesen von Zahlen

[paka]

Hallo

Ich hab ein Problem mit dem Speichern, bzw Auslesen von Zahlen in bzw aus einer Datei.

In meinem Programm, sollen Zahlen berechnet, und zuerst einmal in 2 Arrays gespeichert. Wenn die Arrays voll sind, werden die Zahlen in eine Dateien geschrieben. Für jedes Array eine.

Wenn alle Zahlen berechnet sind, sollen die Dateien zu einer Datei zusammengefasst werden.

Die Zahlen die dabei aus den Dateien gelesen werden, stimmen allerdings nicht mit den vorher gespeicherten überein.

Also hier das ganze etwas genauer.

Ich speichere ein unsigned long int Array in einer Datei.

	if(NULL == (neuIndxFp = fopen(neuIndx , "w"))){

		perror("##################### in neueZeile : Fehler bei fopen(neuIndx) ") ;

		return -1 ;

	}

// jetzt kommt Code, in dem das Array mit Zahlen belegt wird

Mit dieser Function, wird der Inhalt des Array in eine Datei geschrieben

int leereTmpArrays(struct zeileTmpArrays *zA , FILE *indxFp , FILE *eintrFp ){

	if((*zA).count != fwrite(&((*zA).indexArr) , sizeof(unsigned long int) , (*zA).count, indxFp) ){

		printf("############  in leereTmpArrays : Fehler bei fwrite(indizes). Anz der geschriebenen Indizes entspricht nicht der Anzahl der im Array gespeicherten \n");

		return -1 ;

	}

	if((*zA).count != fwrite(&((*zA).eintrArr), sizeof(double) , (*zA).count , eintrFp) ){

		printf("###########  in leereTmpArrays : Fehler bei fwrite(Eintraege). Anz der geschriebenen Eintraege entspricht nicht der Anzahl der im Array gespeicherten \n");

		return -1 ;

	}

	(*zA).count = 0 ;

	return 0 ;

}

Bei Aufruf der Fkt stehen die richtigen Werte im Array. Diese sollen jetzt in eine andre Datei kopiert werden. Die Dateien werden geschlossen, und nun mit folgenden Zeilen geöffnet.

	fclose(neuEintrFp) ;

	fclose(neuIndxFp) ;

	fclose(zeilIFp) ;

//	printf("      %s neu erzeugen\n   entferne %s \n", zeilenName , zeilenName) ;

//	if(0 > remove(zeilenName)){

//		perror("########################## in neueZeile : Fehler beim loeschen der Zeile ");

//		printf("                                          Zeilenname : %s \n", zeilenName) ;

//		return -1 ;

//	}

//	printf("                    oeffne Dateien %s und %s zum lesen und %s zum erzeugen \n", neuIndx , neuEintr , zeilenName) ;

	if(NULL == (neuIndxFp = fopen(neuIndx , "r"))){

		perror("######################### in neueZeile : Fehler beim oeffnen der Datei neuIndex zum lesen ") ;

		return -1 ;

	}

	if(NULL == ( neuEintrFp = fopen(neuEintr , "r"))){

		perror("########################### in neueZeile : Fehler beim oeffnen der Datei neuEintr zum lesel ") ;

		return -1 ;

	}

	// Datei zeilenName löschen und neu erzeugen

	if(NULL == ( zeilIFp = fopen(zeilenName , "w+"))){

		perror( "############################# in neueZeile : Fehler beim oeffnen der Zeile zum schreiben ") ;

		printf("                                               Zeilenname : %s \n", zeilenName) ;

		return -1 ;

	}

Zum Kopieren nutze ich eine andre Funktion. Hier die entscheidenden Zeilen.

	unsigned long int *indxBuff ;

	double *eintrBuff ;

	long anzCpy ;

      ...

		if(NULL == (indxBuff = (unsigned long int *)malloc(sizLU * anzCpy))){

			perror("#######################  in copyIndxUndEintrInZeil : Fehler bei malloc(indxBuffer) ") ;

			printf("                                                     %lu Eintraege zu Kopieren \n", anzEintr) ;

			return -1 ;

		}

		if(NULL == (eintrBuff = (double *)malloc(sizDouble * anzCpy))){

						perror("#######################  in copyIndxUndEintrInZeil : Fehler bei malloc(EintragsBuffer) ") ;

						printf("                                                     %lu Eintraege zu Kopieren \n", anzEintr) ;

						return -1 ;

		}

		fread(indxBuff , sizLU , anzCpy , indxFp) ;

		fwrite(indxBuff , sizLU , anzCpy , zeilFp) ;

		fread(eintrBuff , sizDouble , anzCpy , eintrFp) ;

		fwrite(eintrBuff , sizDouble , anzCpy , zeilFp) ;

Hier enthält der Puffer indxBuff nach fread allerdings Zahlen, die nichts mit denen, die oben im Array standen gemein.

Ich vermute, dass ich was übersehen habe, aber ich bin das jetzt alles schon zig-mal durchgegangen, und hab nix gefunden.

Ich hoffe, ich hab alle entscheidenden Teile des Codes angegeben.

[paka]

Also

Das Problem existiert nicht mehr:), wenn ich auch nicht weiß warum.:confused:

Vorher hatte ich die Arrays als Pointer deklariert, und mit

ptr = (unsigned long int *)malloc(sizeof(unsigned long int) * KONST)

den Speicher reserviert. Nun deklariere ich sie mit

unsigned long int indxArray[KONST]

und alles klappt wie es soll.

Wenn das jemand versteht, und Lust hat, das zu erklären wäre ich trotzdem dankbar.

Chiao

[Klotzkopp]

Wenn du einen Zeiger hast, solltest du an fwrite nicht dessen Adresse übergeben, sondern den Zeiger selbst.

Den Fehler hätte man übrigens leichter finden können, wenn du gleich im ersten Beitrag geschrieben hättest, welche Typen die beteiligten Variablen haben. So fehlten wichtige Informationen für die Fehlersuche.

[TDM]

Den Rückgabewert von malloc sollte man nicht casten.

[paka]

Wenn du einen Zeiger hast, solltest du an fwrite nicht dessen Adresse übergeben, sondern den Zeiger selbst.

Ich weiß nicht, welche Stelle du meinst. Soviel ich sehe, habe ich überall die Zeiger übergeben.

Den Rückgabewert von malloc sollte man nicht casten.

Das wird nach dem ANSI Standart doch so verlangt.

Bearbeitet 28. Oktober 2009 von paka

[Klotzkopp]

Ich weiß nicht, welche Stelle du meinst. Soviel ich sehe, habe ich überall die Zeiger übergeben.

Ich meine diese Stelle:

	if((*zA).count != fwrite(&((*zA).indexArr) , sizeof(unsigned long int) , (*zA).count, indxFp) ){

[/code]

Falls indexArr ein Array ist, funktioniert das so. Wenn es aber ein Zeiger ist, schreibst du den Zeigerinhalt in die Datei, nicht das, worauf der Zeiger zeigt.


Das wird nach dem ANSI Standart doch so verlangt.
Nein, malloc gibt ein void* zurück, und das ist implizit in jeden anderen Zeigertyp konvertierbar. Ein Cast ist hier nicht notwendig, und kann unter Umständen sogar Fehler verdecken.


Zu Problemen kommt es hier üblicherweise dann, wenn du deinen C-Code von einem C++-Compiler verarbeiten lässt. In C++ gibt es diese implizite Konvertierung nämlich nicht