Sie sind auf Seite 1von 8

L10.

Arbeit mit den Dateien


Argumente aus der Kommandozeile
Dateien und der Datentyp FILE


Onen und Schlieen von Dateien
Schreiben und Lesen von Dateien
Ein-/Ausgabe von Strings
Formatiertes Schreiben und Lesen
Blockweise Schreiben und Lesen
Textmodus und Binarmodus
Wahlfreier Dateizugri
1
Argumente aus der Kommandozeile
Beim Start eines Programms konnen auer dem Programmnamen noch weitere
Zeichenfolgen in der Kommandozeile angegeben werden.
Beispiel Programm test:
int main( int argc, char *argv[] ) { .... }
Aufruf: test Arg1 Arg2 Arg3
Dann enthalten:
argc 4
argv[0] test
argv[1] Arg1
argv[2] Arg2
argv[3] Arg3
In argc wird die Anzahl der Argumente ubergeben. Der Programmname zahlt auch
als Argument. ( argc 1)
Die einzelnen Argumente sind durch Leerzeichen zu trennen.
char *argv[] ist ein Array von Strings.
2
Dateien und der Datentyp FILE
Die Standardbibliothek von C stellt Funktionen f ur den High-Level-Dateizugri zur
Verf ugung. Sie behandeln die Ein-/Ausgaben einheitlich als Datenstrom (stream).
Eine Puerbereich (Dateipuer) wird f ur den Datentransfer zwischen Hauptspeicher
und externem Speichermedium verwendet.
Eine (Byte-orientierte) Datei ist ein char-Array. Die Strukturierung von Datei ist
Aufgabe des Programms. Jedes Zeichen hat eine Position. Die aktuelle Position ist
die Position des Zeichens, welches als nachstes gelesen oder geschrieben wird.
Der Zugri auf eine Datei erfolgt mit Hilfe eines Datei-Zeigers (File-Pointer) vom
Typ FILE* (deniert in stdio.h) zeigt.
Beim Start eines Programms sind schon drei Standard-Geratedatei geonet:
sdtin Standardeingabe (Tastatur)
sdtout Standardausgabe (Bildschirm)
stderr Standardfehlerausgabe (Fehlermeldung auf Bildschirm)
3

Onen von Dateien


Eine Datei kann mit der Funktion fopen() geonet bzw. erzeugt werden.
Prototyp: FILE *fopen(char *name, char *modus);
Beispiel: fp = fopen( "test.dat", "r"); // FILE *fp;
Der R uckgabewert ist ein Datei-Zeiger oder NULL-Zeiger bei Fehler.
Das erste Argument ist der Dateiname, der eine Pfadangabe enthalten kann.
Das zweite Argument legt die Zugrisart fest. Mogliche Zugrisraten sind:
Modus Beschreibung
"r" Eine bereits existierte Datei zum Lesen oen
"w" Eine neue Datei zum Schreiben onen. Existiert die Datei bereits, so
geht ihr Inhalt verloren
"a" Eine bestehende Datei zum Schreiben ab Dateiende onen. Existiert
Datei noch nicht, so wird sie neu erzeugt.
"r+" Eine bestehende Datei zum Schreiben und Lesen onen (open for update).
"w+" Eine neue Datei zum Schreiben und Lesen onen. Existiert die Datei
bereits, so geht ihr Inhalt verloren.
"a+" Eine bestehende Datei zum Lesen und Schreiben ab Dateiende onen.
Existiert die Datei noch nicht, so wird sie neu erzeugt.
4
Schlieen von Datei
Nach der Bearbeitung einer Datei, sollte diese Datei immer geschlossen werden.
Ansonst konnen Daten verloren gehen.
Die folgende Funktionen konnen die Dateien schlieen:
Prototyp: int fclose(FILE *fp);
Prototyp: void exit( int status);
Alle Dateien schlieen.
Das Programm wird auch beendet.
Das Argument status ist der Exit-Code des Programms.
#include <stdio.h>
void main(int argc, char *argv[])
{
FILE *fp1, *fp2; // File-Pointer definieren
fp1 = fopen( argv[1], "r" ); // Datei zum Lesen oeffnen
if (fp1 == NULL) printf("Fehler beim Oeffnen der Datei \"%s\"\n", argv[1]);
else { .... // mit der Datei fp1 arbeiten
fclose(fp1); // Datei fp1 schlieen
}
}
5
Schreiben und Lesen von Dateien
In C gibt es verschiedene Standardfunktionen zum Schreiben und Lesen von Dateien.
Die Informations ubergaben in bzw. aus einer Datei konnen zeichenweise, stringweise,
blockweise oder formatiert erfolgen.
Funktionen zum Schreiben und Lesen
Schreiben Lesen Daten
fputc() fgetc() Zeichen
fputs() fgets() String
fprintf() fscanf() Formatierte Daten
fwrite() fread() Block
Jede Schreib-/Leseoperation bezieht sich auf die aktuelle Position in der Datei.
Nach jeder Schreib-/Leseoperation erhoht sich die aktuelle Position automatisch
um die Anzahl der geschriebenen/gelesenen Bytes.
Die Prototypen dieser Funktionen benden sich in stdio.h. Zum Beispiel:
int fputc(int c, FILE *fp); // kopiert Zeichen c in die mit
// fp verbundene Datei
int fgetc(FILE *fp); // lesen ein Zeichen aus einer Datei
Der R uckgabewert der beiden Funktionen ist das ubertragenen Zeichen.
Im Fehlerfall oder bei Erreichen des Dateiendes ist der R uckgabewert EOF.
6
Beispiel TextZeigen
/* TextZeigen.c *
* Eine Datei oeffnen, lesen und auf Bildschirm aufgeben *
* Aufruf: TextZeigen dateiname */
#include <stdio.h>
void main(int argc, char *argv[])
{
long ZeichenAnzahl = 0;
char c;
FILE *fp; // File-Pointer definieren
fp = fopen( argv[1], "r" );
while( (c =fgetc(fp)) != EOF)
{
ZeichenAnzahl++;
fputc(c, stdout);
}
fclose(fp);
printf("\n");
printf("Anzahl der Zeichen: %ld\n", ZeichenAnzahl);
}
7
Beispiel TextEinlesen
/* TextEinlesen.c: Kopiert die Standardeingabe an das Ende der angegebene Datei*
* Falls die Datei noch nicht existiert, wird sie neu erzeugt. *
* Aufruf: TextEinlesen dateiname */
#include <stdio.h>
void main(int argc, char *argv[]) {
int c; FILE *fp;
if (argc != 2)
printf("Benutzung: TextEinlesen dateiname\n");
else if ( (fp = fopen(argv[1], "a")) == NULL)
printf("Fehler beim Oeffnen der Datei %s\n", argv[1]);
else {
//Die Eingabe von der Tastatur wird an die Datei angehaengt
printf("Bitte Test eingaben:\n\n");
while( (c = getchar()) != EOF)
fputc(c, fp);
fclose(fp);
}
}
8
Schreiben und Lesen von Strings
Ein String kann mithilfe der Funktionen fputs() und fgets() behandelt werden.
Prototyp: int fputs(char *string, FILE *fp);
Beispiel: fputs("Hello", fp);
Der string wird in die von fp gezeigte Datei geschrieben.
Das String-Endezeichen \0 wird dabei nicht in die Datei kopiert.
Bei der fehlerfrei Ausf uhrung gibt die Funktion einen positiven Wert zur uck.
Beim Fehler wird den R uckgabewert EOF zur uckgegeben.
Prototyp: char* fgets(char *string, int n, FILE *fp);
Beispiel: fgets(string, 80, fp); // char string[81];
Maximal n-1 Zeichen werden gelesen und in den string geschrieben.
Das Einlesen wird vorher abgebrochen, wenn das Zeilenwechselzeichen \n
gelesen wurde.
Als letztes Zeichen wird stets das String-Endezeichen \0 angehangt.
Bei Erfolg wird der Zeiger string zur uckgegeben, ansonsten der NULL-Zeiger.
Mit dem Aufruf feof(fp) kann uberpr uft werden, ob das Ende der Datei erreicht
wurde.
9
Beispiel LesenKopieren
/* LesenKopieren.c --> Auslesen von Strings aus einer Datei bis Dateiende *
* Datei auf Bildschirm ausgeben und an eine andere Datei kopieren *
* Aufruf: LesenKopieren dateiname1 dateiname2 */
#include <stdio.h> #include <stdlib.h>
void main(int argc, char *argv[]) {
char s[80];
FILE *fp1, *fp2;
if (argc != 3) {
printf("Benutzung: LensenKopieren dateiname1 dateiname2\n");
exit(-1);
}
fp1 = fopen(argv[1], "r"); // fp1 zum Lesen offnen
fp2 = fopen(argv[2], "w"); // fp2 zum Schreiben offnen
while( !feof(fp1) )
{
fgets(s, 80, fp1);
fputs(s, fp2);
printf("%s\n", s);
}
fclose(fp1); fclose(fp2);
}
10
Formatiertes Schreiben und Lesen
Formatiertes Schreiben und Lesen werden durch die Funktionen fprintf() und fscanf()
realisiert.
Prototypen: int fprintf(FILE *fp, char *formatstring, ...);
int fscanf(FILE *fp, char *formatstring, ...);
Die Benutzung ist analog zu printf() und scanf()
Beispiel:
fprintf(stdout, "Hello!"); // gleich wie printf("Hello!");
fscanf(stdin, "%d", &Zahl); // gleich wie scanf("%d", &Zahl);
11
Blockweises Schreiben und Lesen
Mit der Funktion fwrite() und fread() konnen mehrere Datenobjekte gleicher Groe
geschrieben bzw. gelesen werden.
Prototyp: int fwrite(void *daten, int size, int n, FILE *fp);
daten zeigt auf ein Array mit mindestens n Datenobjekten der Groe size Bytes.
n Datenobjekte dieses Arrays werden in die mit fp verbundene Datei geschrieben.
Die Datenobjekte konnen beliebigen Typ haben, z.B. char, int, Strukturen, usw.
size ist die Lange der Objekte und sollte mit sizeof() bestimmt werden.
Der R uckgabewert ist die Anzahl der tatsachlich geschriebenen Datenobjekte.
Prototyp: int fread(void *daten, int size, int n, FILE *fp);
n Datenobjekte der Groe size werden aus der Datei gelesen und in das Array
daten geschrieben.
Der R uckgabewert ist die Anzahl der tatsachlich in den Speicherbereich gelesenen
Datenobjekte. (kann kleiner als n sein)
12
Textmodus und Binarmodus
Textdatein in Windos/DOS unterscheiden sich von UNIX in zwei Punkten:
Dateiende: UNIX: Gema Langenangabe
Windows/DOS: Contro-Z (ASCII 26)
Zeilenende: UNIX: LF(Line Feed)
Windows/DOS: CR (Carriage Return) + LF
Im Textmodus under Windows/DOS werden Control-Z als Dateinende interpretiert
und die Kombination CR+LF automatisch nach LF ubersetzt.
Eine Datei kann auch mithilfe der Funktion fopen() im Binarmodus geonet werden.
Die Zugrismodi f ur Binardateien sind:
rb, wb, ab, r+b, w+b und a+b.
Die LF<->CR+LF

Ubersetzung ndet im Binarmodus nicht statt.
13
Beispiel Block.c
#include <stdio.h>
void main() {
typedef struct
{char name[30]; char plz[6]; char ort[30];} Adresse;
Adresse AdBuch1[100] =
{ {"Tim Meyer", "03044", "Cottbus"},
{"Martin Schneider", "03046", "Cottbus"} };
Adresse AdBuch2[100];
int Anzahl1, Anzahl2;
FILE *fp1, *fp2;
fp1 = fopen( "adrs1.dat", "w+b");
Anzahl1 = fwrite( AdBuch1, sizeof(Adresse), 2, fp1);
fclose(fp1);
printf("Anzahl der von fwrite() geschriebenen Bloecke ist %d\n\n", Anzahl1);
fp2 = fopen( "adrs1.dat", "rb" );
Anzahl2 = fread(AdBuch2, sizeof(Adresse), 100, fp2);
fclose(fp2);
printf("Anzahl der von fread() gelesenen Bloecke ist %d\n\n", Anzahl2);
printf("Adresse von Meyer ist: %s, %s", AdBuch2[0].plz, AdBuch2[0].ort);
}
14
Wahlfreier Dateizugri
Anders als der bisherige sequentielle Zugri auf eine Datei bietet der wahlfreie
Dateizugri die Moglichkeit, die gew unschten Informationen direkt an einer
bestimmten Position in der Datei zu lesen bzw. zu verandern.
Die Schreibe/Lese-Position kann mit der Funktion fseek() verandert werden.
Prototyp: int fseek(FILE *fp, long offset, int basis);
Die Position ist oset Bytes von basis entfernt.
Die mogliche Werte von basis sind:
SEEK_SET offset ist relativ zum Dateianfang
SEEK_CUR offset ist relativ zur aktuellen Position
SEEK_END offset ist relativ zum Dateiene.
Beispiel: fseek(fp, 0L, SEEK_SET) und fseek(fp, 0L, SEEK_END) setzt die
Position auf den Dateianfang bzw. auf das Dateiende.
Prototyp: long ftell(FILE *fp);
ftell(fp) liefert die aktuelle Position in der mit fp verbundenen Datei.
15