fprintf ist nicht drucken, um die Datei

Im folgenden code die fprintf ist nicht Druck auf die Datei und printf zeigt falsche Ausgabe:

#include<stdio.h>

 void main()
{  
    FILE *fp;  
    int d,w,t;
    fp = fopen("file.txt","r+");//already created file having value 10
    fscanf(fp,"%d",&d); 
    printf("%d",d);//print value 10
    t=ftell(fp);
    fseek(fp,t,SEEK_END);
    fprintf(fp,"%d",1000); //printing 1000 to the file
    fscanf(fp,"%d",&w);
    printf("%d",w); //this printf is still printing wrong value 12803
    fclose(fp);
    getch();
}

Ich glaube, Sie brauchen, um zu initialisieren, d und w 0
Schalten Sie Ihren compiler-Warnungen. Auch überprüfen Sie die Rückgabe-Werte der system calls!
und der return-Wert von library-Funktionen.
Erwarten Sie zu Lesen, der Wert von 1000, nachdem Sie es schreiben? Du brauchst ftell und fseek zu sichern, nach dem schreiben, weil das schreiben wird die Datei verschieben-Zeiger als gut.
Sagen uns nicht, es ist "mit dem falschen Ausgang", ohne dass Sie uns die Ausgabe. Und void main() falsch ist; verwenden Sie int main(void).

InformationsquelleAutor Sachin Rana | 2013-08-11

c file-io printf

0

Müssen Sie die Durchführung einer fseek() (oder ähnliches) zwischen lese-und Schreiboperationen in der gleichen Datei. Es ist nicht eine strenge Anforderung, die in allen Implementierungen, aber es ist notwendig, für die Portabilität.

BEARBEITEN

OK, Ihr neue verison hat:
```
t=ftell(fp);
fseek(fp,t,SEEK_END);
```
was vielleicht Sinn machen in einigen Fällen, aber wahrscheinlich nicht diese. Ich
denke, du meintest:
```
fseek(fp, 0, SEEK_CUR);
```
versucht und relativ zur aktuellen position, ohne sich zu bewegen
überall.

Aber der Grund, Sie sind nicht immer w==1000 ist zwischen diese beiden Zeilen:
```
fprintf(fp,"%d",1000); //printing 1000 to the file
fscanf(fp,"%d",&w);
```
Ihnen den übergang vom schreiben zum Lesen ohne suchen, hier. Sie können nicht
werden ganz sicher dort, wo in der Datei, die Sie versuchen zu Lesen w
aus, ohne einen zu suchen, um wieder behaupten, die position, die Sie wollen.

Versuchen:
```
t = ftell(fp);
fprintf(fp,"%d",1000); //printing 1000 to the file
fseek(fp, t, SEEK_SET);
fscanf(fp,"%d",&w);
```
Gibt es eine Reihe anderer Gefahren, um diesen code, durch die Art und Weise; wie
dass die fprintf drucken nicht jede Beendigung Charakter, so dass es
vielleicht werden nachfolgende stellen nach, wo du geschrieben hast (aus der vorherigen
schreibt andere Werte, oder was auch immer), die an den Wert
Lesen Sie in w.

Ich benutze fseek (), aber immer noch die printf () - Anweisung wird das drucken der Wert 12803

InformationsquelleAutor sh1
1
```
#include<stdio.h>

 void main()
```
Dies ist falsch; es sollte int main(void). Wenn Sie ein Buch, das
sagt Ihnen, Sie zu nutzen void main(), dessen Autor nicht weiß, C sehr gut;
ein besseres Buch.
```
{
    FILE *fp;
    int d,w,t;
    fp = fopen("file.txt","r+");//already created file having value 10
```
Müssen Sie prüfen, ob die fopen Aufruf erfolgreich war oder nicht, und
wahrscheinlich beenden Sie das Programm, wenn es fehlgeschlagen ist.
```
    fscanf(fp,"%d",&d);
    printf("%d",d);//print value 10
```
Vorausgesetzt, dass alles gut gegangen ist, so weit dies gedruckt wird 10 ohne newline.
Wenn Ihr Programm gearbeitet, dessen Ausgang wäre 101000. Ändern Sie "%d" "%d\n".
```
    t=ftell(fp);
```
t ist die aktuelle position in der Datei, die gerade nach
die 10, es ist also 2 bytes vom Anfang.
```
    fseek(fp,t,SEEK_END);
```
Nun positionieren Sie den Datei-Zeiger um 2 Byte vor dem Ende
die Datei. Das macht keinen Sinn. Wo Sie landen, relative
auf der "10" hängt davon ab, was sonst noch in file.txt (newline? CR-LF?)

Können Sie den zurückgegebenen Wert von ftell() und verwenden Sie es später in einem
Aufruf fseek, aber das macht nur Sinn, wenn das Dritte argument ist
SEEK_SET. So möchten Sie wahrscheinlich:
```
t = ftell(fp);
fseek(fp, t, SEEK_SET);
```
Nicht ändern Sie Ihre position in der Datei, aber es erlaubt Ihnen,
aus einer Datei zu Lesen, dass du schon schreiben.

Oh, und ftell und fseek Arbeit mit long Werte, nicht int.
Ihr Programm (mit diesen fixes) wird wahrscheinlich funktionieren, wenn die Datei nicht
zu groß, aber Sie wirklich sollte erklären t als long variable.

Außerdem schlage ich vor, dass die Verwendung von Namen wie d, w, und t machen den code schwerer zu Lesen. Verwenden Sie mehr beschreibende Namen. Denken Sie an jemand anderen, als Sie versuchen, zu Lesen und zu verstehen, Ihre code -, oder Lesen Sie Ihren eigenen code ein Monat ab jetzt, wenn Sie vergessen haben, was d ist.

Mit diesen Veränderungen, Ihren aktuellen Stand im file.txt should now be just after the10`.
```
    fprintf(fp,"%d",1000); //printing 1000 to the file
```
Ist und du jetzt drucken 1000 unmittelbar nach der 10, so ist jetzt die Datei
enthält 101000 und Ihre aktuelle position ist nach das Letzte
Zeichen, das Sie schrieb.
```
    fscanf(fp,"%d",&w);
```
Hier können Sie versuchen, die Datei zu Lesen, sofort nach writng.
Aber du bist am Ende der Datei, so gibt es nichts zu Lesen.
Da du nicht überprüfen, das Ergebnis der fscanf (was hätte es dir gesagt
es fehlgeschlagen ist), w ist unverändert,
```
    printf("%d",w); //this printf is still printing wrong value 12803
```
Wieder, indem ein Zeilenumbruch machen würde, die Ausgabe viel einfacher zu Lesen.
```
    fclose(fp);
    getch();
```
getch() ist eine Windows-spezifische (und MS-DOS-spezifische) Funktion, die
Benutzereingabe wartet, bevor der Beendigung Ihres Programms. Wenn Sie darauf bestehen
auf es zu benutzen, müssen Sie, wenn ich mich Recht erinnere, #include <windows.h>.
Sie soll sich Ihr compiler die Warnung Ebenen, wenn es uns nicht beschweren
über eine fehlende Erklärung für getch.
```
}
```
Zusammenfassung:

Wenn Sie wollen Lesen und schreiben in die gleiche Datei öffnen, können Sie das tun
- aber Sie brauchen, um eine Positionierung Funktion wie fseek
zwischen Lesen und schreiben, oder zwischen schreiben und Lesen.

Sollten Sie die Werte, die von allen library-Aufrufe. Für
Beispiel, wenn file.txt existiert nicht, Ihr Programm ruhig ignoriert
die Fehler und versuchen weiterhin lese-und Schreibzugriff auf die Datei, mit
Undefinierte Ergebnisse. (Es ist üblich, ignorieren Sie das Ergebnis einer printf
nennen, denn es gibt nicht viel Sie tun können, wenn das drucken auf standard
Ausgabe nicht, aber es ist sehr lehrreich zu betrachten, das Ergebnis sowieso.)

Schreiben Sie Ihre printf fordert, damit die Ausgabe lesbar ist. Print newline
(\n) am Ende der einzelnen Zeilen der Ausgabe.

Lesen Sie die Dokumentation für jede Funktion, die Sie verwenden.

Fragen Sie Ihren compiler um Sie zu warnen, über fragwürdige Konstrukte. Finden Sie Ihre
compiler-Dokumentation, um herauszufinden, wie dies zu tun.

InformationsquelleAutor Keith Thompson

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.