INE1 Ein-/Ausgabe, Dateien (Files) Einführung Datenstruktur und Operationen Textdateien Binärdateien Standard Streams

INE1 Ein-/Ausgabe, Dateien (Files) Einführung Datenstruktur und Operationen Textdateien Binärdateien Standard Streams

Einführung 2 von 42

Einführung Wie kann ein Programm mit seiner Umgebung Information austauschen? Prog.-Aufruf-Argumente (Kommandozeile) Strings (argv[ ])! Input-Kanäle (Datenströme, Streams) Tastatur, Dateien Programm Return-Wert von main (int) Output-Kanäle (Datenströme, Streams) Bildschirm, Dateien geordnete geordnete Folge Folge von von Bytes Bytes Datei, Verzeichnis (File) Datenstrom (Stream) hello how.. Files Files werden werden oft oft sequentiell sequentiell verarbeitet verarbeitet ein ein Byte Byte nach nach dem dem anderen anderen lesen/schrieben lesen/schrieben und und dann dann den den "Arbeitskopf" "Arbeitskopf" zum zum nächsten nächsten Byte/Record Byte/Record automatisch automatisch verschieben verschieben 3 von 42

Einführung Dateien werden physikalisch auf der Speicherplatte gespeichert (Blöcke von z.b. 1024 Bytes in Sektoren auf den Spuren, verteilt über die ganze Speicherplatte) Betriebssystem (z.b. Windows, OSX) verbirgt diese Komplexität: Die Dateien werden in einer logischen hierarchischen Verzeichnisstruktur angeordnet Wir können eine Datei mit dem Datei-Pfadnamen ansprechen und BS sucht die Dateiteile auf der Disk. Es stehen Systemfunktionen für die grundlegenden Operationen (Öffnen, Lesen, Schreiben, Positionieren, Zumachen) zur Verfügung. Programmsicht: Sicht Programm-Sicht Anwendungen/Shells/UNIX - Werkzeuge Prozessverwaltung (Scheduler, Memory Management, IPC) Bibliotheken Schnittstelle für Systemaufrufe Dateisystem Treiber Hardwaresteuerung (Behandlung der Interrupts und Kommunikation mit der Hardware) Hardware z.b. z.b. stdio-library stdio-library in in C C Dateizugriffsfunktionen Dateisystem A Dateisystem B 4 von 42

Dateitypen In C werden die Dateien als einfacher Strom von Bytes (Char-Stream) aufgefasst. Die Organisation der Datei in Records und die Interpretation des Dateiinhaltes ist die Sache des Programmes. Grundsätzlich wird im Programm unterschieden zwischen Textdateien Die kein festes Binärformat haben, sondern aus menschenlesbaren Zeichensequenzen (Textzeilen unterschiedlicher Länge (mit Zeilenende markiert) ) aufgebaut sind. Binärdateien solche, die ein festes Datenformat besitzen und meist ein Speicherabbild eines Arrays oder einer struct darstellen (d.h. aus gleichen sog "Records" bestehen) 5 von 42

Dateitypen Textdateien enthalten ASCII-Zeichen und können auf dem Bildschirm oder Drucker direkt ausgegeben werden. Der Text ist normalerweise in Zeilen gegliedert. Ein Zeilenende wird mit EOLN ('\n') markiert. Unter Linux werden die Zeilen im Textfile mit dem <LF>-Zeichen abgeschlossen. Unter DOS/Windows wird das Zeilenende im Textfile mit Bytes zwei Zeichen markiert <CR> und <LF>. Bytes mit mit ASCII-Code ASCII-Code der der Ziffern; Ziffern; 10=LF 10=LF Unter Apple/Macintosh OS werden die Zeilenenden mit <CR> markiert. 1234567 abgespeichert in einer Texdatei: 49 50 51 52 53 54 55 10 Binärdateien enthalten Datenstrukturen und Variablen in der Maschinendarstellung und können nur von Programmen, welche die File-Struktur und Darstellung der dort gespeicherten Variablen verstehen, gelesen werden. 1234567 abgespeichert in einer Binärdatei:.... Record Record mit mit nur nur 4 4 Bytes, Bytes, die die eine eine Integer- Integer- Zahl Zahl enthalten enthalten effizienter effizienter 6 von 42

FILE Datenstruktur und Operationen 7 von 42

Dateien: FILE - Datenstruktur Für die Arbeit mit Dateien wird ein Zeiger auf die FILE-Datenstruktur benötigt: Diese ist in stdio.h wie folgt deklariert: FILE FILE *file *file typedef struct{ short level; unsigned flags; char fd; unsigned char hold; short bsize; unsigned char *buffer, *curp; unsigned istemp; short token; FILE; File- Pointer (stream) Struktur vom Typ FILE Dateideskriptor Pointer auf Dateipuffer Akt. Dateipositionszeiger Anzahl Zeichen im Puffer Flags... Programmvariable, die in Programmvariable, die in fopen initialisiert und fopen initialisiert und anschliessen in allen Fileanschliessen in allen File- Funktionen verwendet wird Funktionen verwendet wird Dateipuffer Datei Alle File-Operationen verwenden den FILE Zeiger 8 von 42

Dateien: Grundoperationen Wichtigste File-Operationen Öffnen einer Datei fopen Ein-/Ausgabe fprintf fscanf formatiert Pufferinhalt schreiben putc, fputc getc, fgetc stringweise zeichenweise fflush fputs fgets fwrite fread binär fseek ftell rewind ferror feof clearerr Positionieren Fehlerbehandlung Schließen einer Datei Löschen einer Datei fclose remove Dateioperationen Weitere File-Operationen: copy rename remove 9 von 42

Datei öffnen FILE *fopen (const char *filename, const char *mode) Filename steht für den Namen inkl. Path lokales (zum Ausführungspfade) Verzeichnis: z.b. "output_file.dat" Absoluter Pfad: "c:\\temp\\out.txt" - um Verzeichnisse in Windows abzutrennen, "\\" in Stringkonstante Die Funktion fopen Pointer zum File zurück Im Fehlerfall gibt NULL zurück, wenn die Datei nicht geöffnet werden konnte Ändern bedeutet, dass die gleiche Datei gelesen und geschrieben werden darf 10 von 42

Modes für fopen mode für den Dateityp und die Zugriffsart "r" Textdatei wird zum Lesen geöffnet. "w" Textdatei wird zum Schreiben geöffnet. "a" Textdatei wird zum Anhängen geöffnet (Wenn Datei vorhanden, dann bewirkt eine Schreiboperation das Anhängen des Textes am Dateiende). "rb" Binärdatei wird zum Lesen geöffnet. "wb" Binärdatei wird zum Schreiben geöffnet. Siehe Anhang für weitere Modes 11 von 42

Binärdateien Die fopen-anweisung unterscheidet durch die Angabe des "b"-parameter zwischen beiden Dateitypen: "b"-parameter: Die Datei wird als Binärdatei interpretiert. Die Zeichen (Bytes) werden ohne jeglicher Interpretierung und Konversionen gelesen und geschrieben. kein "b"-parameter: Die Datei wird als Textdatei interpretiert und es finden evtl. Konversionen statt: Unter DOS/Windows werden bei der Ausgabe von '\n' jeweils 2 Zeichen (<CR> und <LF>) in die Datei geschrieben. Unter DOS/Windows wird beim Lesen einer Zeichenkombination (<CR><LF>) das <CR>-Zeichen entfernt. Unter Unix hat der Parameter "b" keine Auswirkung, da die Zeilenenden dort nur mit dem <LF>-Zeichen ('\n') abgeschlossen werden. Regel: wenn man mit Binärdateien arbeitet, so müssen diese unter DOS/Windows immer mit dem "b"-parameter geöffnet werden! 12 von 42

In Datei schreiben int fprintf (FILE *stream, const char *format,...) fprintf wandelt Ausgaben um und schreibt sie in stream unter Kontrolle von format Der Resultatwert ist die Anzahl der geschriebenen Zeichen; er ist negativ, wenn ein Fehler passiert ist 13 von 42

String I/O Operationen Es gibt zahlreiche weitere Funktionen für die Ein- und Ausgabe von Strings Schreibe ein einzelnes Zeichen int fputc(const char c, FILE* stream); Lese ein einzelnes Zeichen (int kann char zugewiesen werden) int fgetc(file* stream); Schreibe einen String in das File int fputs ( const char * str, FILE * stream ); Leseaus einer Datei in einen String-Buffer, maximal num-1 Zeichen oder bis zum nächsten Zeilenwechsel Achtung! Das EOLN-Char ('\n') wird auch in den String eingelesen! char * fgets ( char * str, int num, FILE *stream ); 14 von 42

Aus Text Datei formatiert lesen int fscanf (FILE *stream, const char *format,...) fscanf liest von stream unter Kontrolle von format Nachfolgende Argumente müssen Zeiger sein fscanf liefert EOF, wenn vor der ersten Umwandlung das Dateiende erreicht wird oder ein Fehler passiert Andernfalls liefert die Funktion die Anzahl der umgewandelten und abgelegten Eingaben Bemerkung: die fscanf-funktion sollte besser nicht für die direkte Bearbeitung der Textdateien verwendet werden! (Probleme mit EOLN und "white spaces"). Lösung: eine Zeile mit fgets einlesen (bis Zeilenumbruch '\n') und anschliessend den eingelesenen String mit strtoc in die einzelnen Komponenten zerlegen (parsing) 15 von 42

String Tokenizer char *strtok(string, "<delimitors>"); in <string.h> definiert Lesen der ganzen Zeile als String Zum Zerlegen der Strings kann der String-Tokenizer strtok aus der Bibliothek string.h verwendet werden Auch mehrere Deliminatoren erlaubt char s[256]; strcpy(s, "one,two,three"); char* token = strtok(s, ","); while (token) { printf("token: %s\n", token); token = strtok(null, ","); 16 von 42

Positionierung innerhalb Datei int fseek (FILE *stream, long int offset,int origin) Wenn eine Datei zum Lesen und Schreiben geöffnet wird, benötigt man eine Möglichkeit, die aktuelle Position in der Datei zu setzen 17 von 42

Datei schliessen int fclose(file *stream) fclose schreibt noch nicht geschriebene Daten für stream, wirft noch nicht gelesene, gepufferte Eingaben weg, gibt automatisch angelegte Puffer frei und schliesst den Datenstrom Die Funktion liefert EOF bei Fehlern und sonst 0 Eine geöffnete Datei muss nach dem Gebrauch wieder geschlossen werden Sehr wichtig beim schreibenden Zugriff, da ansonsten noch Daten im Schreibpuffer stecken bleiben könnten. 18 von 42

Gepufferte Daten schreiben int fflush(file *stream) fflush schreibt noch nicht geschriebene Daten für stream, wirft noch nicht gelesene, gepufferte Eingaben weg Die Funktion liefert Fehlercode bei Fehlern und sonst 0 19 von 42

Zugriffsmethoden Zwei Zugriffsmethoden auf File sequentieller Zugriff: sequential access Textdateien + Binärdateien current position Datei, Verzeichnis (File) Datenstrom (Stream) hello how.. rewind direkter Zugriff random access (direct access) Binärdateien read or write (ab momentaner Position) dann Zeiger verstellen aufs nächste Record 0 1 2 3 4 5 6 7 8 9 10 11 read or write gleich lange logische Records zuerst Positionierung (Berechnung der Startposition) mit seek (Record-Nr) 20 von 42

Textdateien 21 von 42

Beispiel: Aus Text-Datei lesen #include <stdio.h> int main (void) { FILE *datei; int zahl; datei = fopen("testdatei.txt", "r"); if (datei!= NULL) { fscanf(datei, "%d", &zahl); printf("%d\n", zahl); fclose(datei); return 0; 22 von 42

Beispiel: In Text-Datei schreiben #include <stdio.h> int main (void) { FILE *datei; datei = fopen("testdatei.txt", "w"); if (datei == NULL) { printf("fehler beim Oeffnen der Datei."); return 1; fprintf(datei, "Hallo, Welt\n"); fclose(datei); return 0; 23 von 42

Beispiel: In Text-Datei schreiben /* Dieses Program schreibt 10 Textzeilen mit Zahlen 1..10 in die Datei out.txt*/ #include <stdio.h> #define MAX 10 int main(void) { FILE *fout; int x; fout = fopen("out.txt","w"); for(x=1; x<=max; x++){ fprintf(fout,"%d\n",x); fclose(fout); fprint fprint wandelt wandelt eine eine int-zahl int-zahl x x in in einen einen String, String, der der als als Zeichenkette Zeichenkette in in die die Textdatei Textdatei geschrieben geschrieben wird. wird. Die Die Textzeile Textzeile wird wird mit mit '\n' '\n' abgeschlossen abgeschlossen fprintf-anweisung funktioniert gleich wie printf ; es enthält aber zusätzlich die File- Zeigervariable als ersten Parameter. Die fclose-anweisung macht die Datei wieder zu (zuerst alle Buffers in die Datei schreiben). 24 von 42

Beispiel: Daten in Text Datei speichern int speichern (struct artikel liste[], int anzahl) { int i; FILE *fp = fopen(datei, "w"); if (fp == NULL) { return -1; for (i=0; i<anzahl; i++) { fprintf(fp,"%d,%s,%d,%d\n", liste[i].nr, liste[i].bez, liste[i].preis,liste[i].anz); fclose(fp); return 0; 25 von 42

Beispiel: Text Kopierprogramm #include <stdio.h> #include <stdlib.h> int main(void){ char c; FILE *fin;// zwei File-Vars. (für In- und Out-File FILE *fout; fin=fopen("test.txt", "r"); fout=fopen("out.txt", "w"); if(fin == NULL) { printf("error in-file\n"); exit(4); Aufrufparameter. Aufrufparameter. Definieren Definieren hier, hier, ob ob die die Datei Datei nur nur zum zum Lesen Lesen (r) (r) oder oder zum zum Schreiben Schreiben (w) (w) geöffnet geöffnet wird wird // Datei öffnen und die Referenzen // auf die File-Var.-Strukturen initialisieren Zeichenweise Zeichenweise in in der der Schleife Schleife kopieren: kopieren: Ein Ein Zeichen Zeichen mit mit fgetc fgetc lesen lesen und und mit mit fputc fputc schreiben schreiben sequentieller sequentieller Dateizugriff: Dateizugriff: nach nach jeder jeder fgetc-, fgetc-, fpuc-op. fpuc-op. Verschiebt Verschiebt sich sich der der Bearbeitungszeiger Bearbeitungszeiger while ((c=fgetc(fin))!=eof){ fputc(c, fout); fclose (fin); fclose(fout); Ein Zeichen wird mit getc() gelesen und in die Var. c Ein Zeichen wird mit getc() gelesen und in die Var. c gespeichert. gespeichert. Anschliessend wird c mit der Konstante des EOF-Zeichen Anschliessend wird c mit der Konstante des EOF-Zeichen verglichen (EOF markiert Dateiende und ist als Konstante in verglichen (EOF markiert Dateiende und ist als Konstante in stdlib.h definiert). stdlib.h definiert). 26 von 42

Beispiel: Text zeilenweise lesen und ausgeben #include <stdio.h> int main(void) { FILE *f; char zeile[1000]; // Zeilen-Buffer char s[200]; // Dateiname /* Dateiname einlesen und die Datei aufmachen */ printf("dateiname =? "); scanf("%s",s); f=fopen(s,"r"); printf("\n\ninhalt der Datei %s : \n\n",s); /* zeilenweise lesen und ausgeben, max. Zeilenlänge = 998 char */ while (fgets(zeile,1000,f)!=null) { // File-Zeile lesen printf("%s",zeile); // zum Bildschirm ausgeben fclose(f); 27 von 42

Beispiel: Daten aus Text Datei laden int laden (struct artikel liste[]) { int i = 0, count; FILE *fp = fopen(datei, "r"); if (fp == NULL) { return -1; while (fscanf(fp,"%d,%s,%d,%d", &liste[i].nr, liste[i].bez,&liste[i].preis,&liste[i].anz)!= 0) { i += 1; fclose(fp); return i; 28 von 42

Binärdateien 29 von 42

Binärdateien Sind ähnlich einem Array mit struct-variablen, gespeichert auf dem Disk Möglichkeit des "random-access"-zugriffes -> seek-funktion Schnellerer, effizienter Zugriff, da alle Konversionen entfallen Ein Mensch kann sie nicht direkt lesen (interne Rechnerdarstellung) man kann auch unterschiedlich grosse Records schreiben und lesen (z.b. ein int, double und struct nacheinander hineinschreiben Lesen: in der gleichen Reihenfolge ein int, doube und struct Die Position des Dateizeigers wird in Bytes (char) angegeben. seek()-fkt. Beim Lesen und Schreiben mit fread und fwrite muss die Grösse und die Anzahl des zu schreibenden/lesenden Records angegeben werden (es können auch mehr als ein Record aufs mal gelesen/geschrieben werden) nach jedem Dateizugriff wird der Dateizeiger um die(anzahl * sizeof(record) ) Bytes versetzt. (= Anzahl Records * Record-Grösse) 30 von 42

Binärdateien fread Syntax int fread(void *ptr, int size, int n, FILE *f); Description Reads data from a stream. size = size of struct fread reads n items of data each of length size bytes from the given input stream into a data block pointed to by ptr. The total number of bytes read (n * size). Return Value: On success fread returns the number of items (not bytes) actually read. On end-of-file or error returns 0. while (fread ( )!=0) { file lesen und bearbeiten 31 von 42

Binärdateien fwrite Syntax int fwrite(const void *ptr, int size, int n, FILE *f); Description Writes to a stream. fwrite appends n items of data each of length size bytes to the given output file. The data written begins at ptr. The total number of bytes written is (n * size). "ptr" in the declarations is a pointer to any object. Return Value On successful completion fwrite returns the number of items (not bytes) actually written. On error it returns a short count. 32 von 42

Binärdateien: Funktion fseek Syntax int fseek(file *f, long offset, int whence); Description Repositions a file pointer on a stream. seek sets the file pointer associated with stream to a new position that is offset bytes from the file location given by whence. For text mode streams offset should be 0 or a value returned by ftell. "whence" must be one of the values 0, 1, or 2 which represent three symbolic constants (defined in stdio.h) as follows: Constant whence File location SEEK_SET 0 File beginning ( moves the pointer offset bytes down from the beginning of the file (from byte 0 in the file)). SEEK_CUR 1 Current file pointer position (moves the pointer offset bytes down from the current pointer position) SEEK_END 2 End-of-file (moves the pointer from the end of the file (so you must use negative offsets with this option!! ). Return Value fseek returns 0 if the pointer is successfully moved and nonzero on failure. After fseek the next operation on an update file can be either input or output. 33 von 42

... Binärdateien: Programmbeispiel #include <stdio.h> Die typedef struct { /* Die Datei beliebige Datei wird wird 10 10 solche solche struct Recordstruktur struct als als Records Records enthalten */ enthalten int x; double y,z; Data ; x, y, z x, y, z x, y, z x, y, z x, y, z. void main(void) { Schreib- Lese-Zeiger (durch Read/Write oder seek() positioniert int i,j; FILE *f; Data d; /*..writes and then reads 10 arbitrary records from the file "junk". */ /*...create the file of 10 records */ f=fopen("junk","wb"); for (i=1;i<=10; i++) { d.x=i; d.y=0.1*i; d.z=0.01*i; /* record füllen */ fwrite(&d,sizeof(data),1,f); /* record in die Datei schreiben */ fclose(f); Param: Pointer auf Record, Länge des Records, Anzahl Records, File-Var Param: Pointer auf Record, Länge des Records, Anzahl Records, File-Var /*...Records von der Datei "junk" zurücklesen und ausgeben */ f=fopen("junk","rb"); for (i=1;i<=10; i++) { fread(&d,sizeof(data),1,f); printf("recordinhalt = %d %f %f\n",d.x, d.y, d.z); fclose(f); Param: Pointer auf Record, Länge des Records, Anzahl Records, File-Var Param: Pointer auf Record, Länge des Records, Anzahl Records, File-Var 34 von 42

Programmbeispiel (Fortsetzung) /* Records von der Datei "junk" in umgekehrter Reihenfolge lesen und ausgeben */ printf("\n 2.: read the 10 records in reverse order \n\n"); /*...use fseek to read the 10 records in reverse order */ f=fopen("junk","rb"); for (i=9; i>=0; i--) { fseek(f,sizeof(data)*i,seek_set); fread(&r,sizeof(data),1,f); printf("recordinhalt = %d %f %f\n",d.x, d.y, d.z); fclose(f); printf("\n 3.: read every other record \n\n"); /*...use fseek to read every other record */ f=fopen("junk","rb"); fseek(f,0,seek_set); for (i=0;i<5; i++) { fread(&d,sizeof(data),1,f); printf("recordinhalt = %d %f %f\n",d.x, d.y, d.z); fseek(f,sizeof(data),seek_cur); fclose(f); Posit. Posit. auf auf i-ten i-ten Record Record vom vom Anfang Anfang der der Datei, Datei, (1.Rec: (1.Rec: i=0) i=0) Ein Record in die Var. d einlesen Ein Record in die Var. d einlesen Positionieren Positionieren auf auf Anfang Anfang der der Datei Datei (index=0) (index=0) Positionieren Positionieren um um ein ein Record Record weiter weiter (von (von momentanen momentanen Position). Position). Zusätzlich Zusätzlich wurde wurde die die Position Position schon schon beim beim Lesen Lesen um um 1 1 Rec. Rec. verändert verändert 35 von 42

Programmbeispiel (Fortsetzung) /*..use fseek to read 4th record, change it, and write it back */ printf("\n read 4th record, change it, and write it back\n"); f=fopen("junk","rb+"); Parameter Parameter "+" "+" erlaubt erlaubt den den Lese- Leseund und Schreibzugriff: Schreibzugriff: Teile Teile der der Datei Datei können können somit somit modifiziert modifiziert werden werden fseek(f,sizeof(data)*3,seek_set); /* 4.Rec. von Anf.; von 0 aus numeriert*/ fread(&r,sizeof(data),1,f); d.x=100; /* eingelesene struct modifizieren */ fseek(f,sizeof(data)*3,seek_set); /* Repositionieren auf 4.Rec. von Anf. */ fwrite(&r,sizeof(data),1,f); /* Zurückschreiben */ fclose(f); /*...read sequentiell and print all 10 records to insure 4th record was changed */ printf("\nrecord-inhalte nach der Änderung des 4.Records\n"); f=fopen("junk","rb"); while (fread(&r,sizeof(data),1,f)!=0){ printf("recordinhalt = %d %f %f\n",d.x, d.y, d.z); fclose(f); detektiert, detektiert, wenn wenn das das Ende Ende der der Datei Datei erreicht erreicht wird wird nützlich, nützlich, wenn wenn man man die die ganze ganze Datei Datei einlesen einlesen möchte möchte 36 von 42

Standard-Streams 37 von 42

Standard-Streams Die drei Standard-Files stdin, stdout und stderr stehen automatisch zur Verfügung Das sind die üblichen Ein-/Ausgabekanäle einer Konsolenanwendung: Tastatur für die Eingabe und der Bildschirm bzw. das Konsolenfenster für die Ausgabe Anwendungen mit fflush(stdin) kann die Eingabe "geleert" werden (manchmal notwendig, wenn noch Zeichen im Tastaturbuffer) Der Fehlerkanal stderr dient zur Ausgabe von Fehlermeldungen 38 von 42

Standard-Streams Die Ausgabe der Fehlermeldung aus einem der Beispielprogramme lautete: printf("fehler beim Oeffnen der Datei."); Die Fehlermeldung sollte man also besser so ausgeben: fprintf(stderr, "Fehler beim Oeffnen der Datei."); 39 von 42

Standard-Streams Beim Aufruf einer Konsolenanwendung können diese Kanäle umgeleitet werden: programm < datei programm > datei programm 2> datei programm 2> NUL Standardeingabe stdin aus Datei statt von der Tastatur Standardausgabe stdout auf Dateiumleiten Nur Fehlermeldungen in Date umleiten Fehlermeldungen ignorieren (Windows) (/dev/null in Linux) 40 von 42

Noch Fragen? 41 von 42

Zugriffsmodes auf Textdateien 42 von 42