Zum Inhalt springen

Problem mit dem Speichern, bzw Auslesen von Zahlen


paka

Empfohlene Beiträge

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.

Link zu diesem Kommentar
Auf anderen Seiten teilen

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

Link zu diesem Kommentar
Auf anderen Seiten teilen

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.

Link zu diesem Kommentar
Auf anderen Seiten teilen

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 von paka
Link zu diesem Kommentar
Auf anderen Seiten teilen

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 ;)

Link zu diesem Kommentar
Auf anderen Seiten teilen

Dein Kommentar

Du kannst jetzt schreiben und Dich später registrieren. Wenn Du ein Konto hast, melde Dich jetzt an, um unter Deinem Benutzernamen zu schreiben.

Gast
Auf dieses Thema antworten...

×   Du hast formatierten Text eingefügt.   Formatierung wiederherstellen

  Nur 75 Emojis sind erlaubt.

×   Dein Link wurde automatisch eingebettet.   Einbetten rückgängig machen und als Link darstellen

×   Dein vorheriger Inhalt wurde wiederhergestellt.   Editor leeren

×   Du kannst Bilder nicht direkt einfügen. Lade Bilder hoch oder lade sie von einer URL.

Fachinformatiker.de, 2024 by SE Internet Services

fidelogo_small.png

Schicke uns eine Nachricht!

Fachinformatiker.de ist die größte IT-Community
rund um Ausbildung, Job, Weiterbildung für IT-Fachkräfte.

Fachinformatiker.de App

Download on the App Store
Get it on Google Play

Kontakt

Hier werben?
Oder sende eine E-Mail an

Social media u. feeds

Jobboard für Fachinformatiker und IT-Fachkräfte

×
×
  • Neu erstellen...