C Überlebenstraining Dies ist nur ein Schnellkurs in C, der genug Einstiegswissen vermitteln soll, daß weiterführende Literatur schnell benutzt werden kann. Dies ist kein vollständiger Programmier oder C Kurs und soll auch keinen ersetzen. Aus Gründen der Kürze sind manche Dinge stark vereinfacht, werden nicht begründet ( Dies und jenes muß man eben so machen ) oder einfach weggelassen. Manche dieser Dinge werden Sie verstehen, wenn Sie in weiterführenden Materalien auf sie treffen. Für diesen Schnellkurs bitten wir Sie, diese Sachen einfach zu akzeptieren.
Ein Einfaches C Programm #include <stdio.h> int main( int argc, char* argv[] ) printf( Hello, World\n ); return 0;
1. Schritt: Programm eingeben Öffnen eines Editors Abtippen des Programms Abspeichern in Datei hello.c Wichtig: C ist case sensitiv, das bedeutet, daß nach Groß und Kleinschreibung unterschieden wird. NAME, Name und name sind dementsprechend alles unterschiedliche Dinge.
Analyse des Programms #include <stdio.h> int main( int argc, char* argv[] ) printf( Hello, World\n ); return 0; Die #include Anweisung bindet Dateien in ein Programm ein, so als ob sie direkt eingetippt worden wären. In den sogenannten Header Dateien (.h) stehen die Definitionen der Funktionen (s.u.), die das Betriebssystem in seinen Bibliotheken zur Verfügung stellt. Diese Funktionen können in eigenen Programmen genutzt werden, wenn die Header Dateien mit #include eingebunden worden sind. Die stdio.h Header Datei enthält grundlegende Ein /Ausgabe Funktionen.
#include <stdio.h> int main( int argc, Analyse des Programms char* argv[] ) printf( Hello, World\n ); return 0; Ein C Programm besteht aus mindestens einer Funktion (s.u.), der sog. main Funktion, die vom Betriebssystem ausgeführt wird, wenn ein Programm aufgerufen wird. Damit das Betriebssystem die main Funktion korrekt aufrufen kann, sind ihre Parameter (s.u.) und ihr Rückgabewert (s.u.) fest vorgegeben. Die Definition der main Funktion muß in jedem Programm vorhanden sein.
#include <stdio.h> Analyse des Programms int main( int argc, char* argv[] ) printf( Hello, World\n ); return 0; Geschweifte Klammern dienen in C zur Abgrenzung von zusammengehörigen Blöcken von Anweisungen. Eine Funktion, z.b. die main Funktion ist ein solcher Block.
#include <stdio.h> Analyse des Programms int main( int argc, char* argv[] ) printf( Hello, World\n ); return 0; Einzelne Programm Anweisungen in C werden durch Semikolons abgeschlossen. Mehrere Anweisungen können zusammen in einer Zeile stehen, aber übersichtlicher ist es, wenn man pro Zeile nur eine Anweisung benutzt. Funktionen in C werden aufgerufen indem man ihren Namen gefolgt von Klammer angibt. In den Klammern stehen eventuell benötigte Parameter.
#include <stdio.h> Analyse des Programms int main( int argc, char* argv[] ) printf( Hello, World\n ); return 0; printf ist eine Funktion, die in der einfachsten hier verwendeten Form den String, der ihr als Parameter übergeben wird auf den Bildschirm ausgibt. Ein String in C wird durch doppelte Anführungszeichen begrenzt.
#include <stdio.h> Analyse des Programms int main( int argc, char* argv[] ) printf( Hello, World\n ); return 0; printf kann Sonderzeichen in einem String ausgeben, wenn diese in einer besonderen Form mit einem Backslash (\) gefolgt von einem Buchstaben angegeben werden. (Soll printf einen Backslash ausgeben muß man \\ benutzen.) Das Sonderzeichen \n in einem String bewirkt einen Zeilenvorschub, d.h. die folgende Ausgabe beginnt in einer neuen Zeile.
#include <stdio.h> Analyse des Programms int main( int argc, char* argv[] ) printf( Hello, World\n ); return 0; Der Rückgabewert einer Funktion (s.u.) wird mit der return Anweisung definiert, die gleichzeitig die betroffene Funktion beendet. return in main beendet das Programm und kehrt zum Betriebssystem zurück. main gibt einen ganzzahligen Wert, sehr oft 0, an das Betriebsystem zurück.
Übersetzen des Programms in eine für den Computer verständliche Form Ein Compiler übersetzt ein von einem Menschen geschriebenes Programm in vom Computer ausführbare Anweisungen. gcc (GNU C Compiler) ist ein Compiler für in C geschriebene Programme auf den meisten Linux und Unix Systemen. Einfachste Form des Aufrufs: gcc hello.c Dies resultiert in einem ausführbarem Programm namens a.out, das Hello, World ausgibt. (Falls vorher keine Fehler gemacht wurden.)
Übersetzen des Programms in eine für den Computer verständliche Form Soll gcc das ausführbare Programm unter einem anderen Namen als a.out speichern, muß ihm das mit der Option o Name mitgeteilt werden: gcc o hello hello.c Die gcc Option Wall aktiviert alle zur Verfügung stehenden Warnmeldungen des Compilers. Diese Option sollte immer aktiviert sein. Sie hat schon manchem verzweifeltem C Programmierer das Leben gerettet: gcc Wall o hello hello.c
/* Das ist ein Kommentar */ Kommentare /* Das hier auch */ /* ** Und das auch!! Kommentare werden in C mit /* begonnen und enden beim nächsten */. Sie können sich über beliebig viele Zeilen erstrecken und sollten in eigenen Programmen ausgiebig genutzt werden. ** Das hier immer noch */
Daten im Programm - Variablen Programme sollen Daten bearbeiten. In einem Programm muß Speicherplatz reserviert werden, an dem die Daten abgespeichert werden. #include <stdio.h> int main( int argc, char* argv[] ) int variable1, var1; float variable2; unsigned int variable3; Variablen werden in C definiert, indem am Anfang einer Funktion der Datentyp der Variable und ihr Name angegeben werden. Der Name einer Funktion ist ein Platzhalter, unter dem die in der Variable gespeicherten Namen angesprochen werden können. return 0; Mehrere Variablen des selben Datentyps können durch Kommata getrennt nacheinander aufgeführt werden.
Daten im Programm - Variablen C verfügt über eine Reihe verschiedener Datentypen. int variable1; Der Datentyp int bezeichnet vorzeichenbehaftete Ganzzahlen. Auf PC Systemen (inkl. Linux) ist der Bereich üblicherweise zwischen +2147483647 und 2147483648. Die Größe ist in diesem Fall 32 bit. unsigned int variable2; Der Datentyp unsigned int bezeichnet vorzeichenlose Ganzzahlen. Auf PC Systemen ist der maximale Wert üblicherweise 4294967295. Die Größe ist in diesem Fall 32 bit.
Daten im Programm - Variablen float variable3; Der Datentyp float bezeichnet Fließkommazahlen nach dem 32 bit großen IEEE Fließkommaformat. double variable4; unsigned char variable5; Der Datentyp double bezeichnet Fließkommazahlen nach dem 64 bit großen IEEE Fließkommaformat. Die IEEE Fließkommaformate werden in der Vorlesung behandelt. Der Datentyp unsigned char bezeichnet auf PC Systemen 8 bit große vorzeichenlose Zahlen oder normale Zeichen (Buchstaben, Ziffern,...) aus dem ASCII Zeichensatz.
Daten im Programm - Konstanten Konstante Daten werden auf verschiedene Weisen angegeben. variable1 = 100; Ganzzahlen im Dezimalformat werden durch ihre normale variable1 = 42; Zifferndarstellung angegeben, evtl. mit einem vorangestelltem Vorzeichen. (Keine vorangestellte Null (s.u.)) variable1 = 0734; Ganzzahlen im Oktalformat (Basis 8) werden durch eine vorangestellte Null gekennzeichnet, gefolgt von den entsprechenden Ziffern (0 7). variable1 = 0x1A2; Ganzzahlen im Hexadezimalformat (Basis 16) werden durch ein vorangestelltes 0x gekennzeichnet, gefolgt von den entsprechenden Ziffern (0 9, A F)
Daten im Programm - Konstanten variable3 = 10.0; variable4 = 42.0; variable5 = A ; Fließkommazahlen (float und double) werden mit normalen Dezimalziffern dargestellt, als Dezimalzeichen dient ein Punkt (.). Ggf. wird noch ein Vorzeichen vorangestellt. Einzelne Buchstaben und Ziffern (ASCII) werden in einfache Hochkommata (, auf der Tastatur über der Raute #) eingeschlossen.
Daten im Programm - Felder int feld[4]; Felder (Arrays) werden in C definiert, indem nach dem Feldnamen die Anzahl der Feldelemente in eckigen Klammern angegeben wird. feld[0] = 0; feld[1] = 1; feld[2] = 2; Die Indizes von Feldern sind Null basiert. Das heißt sie fangen mit Null an und gehen bis zu Größe 1! feld[3] = 4; feld[4] = 42; Das ist FALSCH
Kontrollstrukturen - if Manchmal soll ein Stück Programmcode nur unter einer bestimmten Bedingung ausgeführt werden: Eine Bedingung in C wird mit der if #include <stdio.h> int main( int argc, char* argv[] ) if ( argc == 1 ) return 0; printf( Hallo\n ); Abfrage überprüft. Die Bedingung, die üperprüft wird, wird hinter der if Anweisung in Klammern gesetzt. Die der if Anweisung folgende Anweisung wird ausgeführt, wenn die Bedingung zutrifft oder ein Ergebnis ungleich Null liefert. Gleichheit wird in C mit einem doppelten Gleichheitszeichen (==) überprüft. Ein einfaches Gleichheitszeichen in einer Bedingung führt eine Zuweisung aus, die als Bedingung interpretiert zutrifft, wenn die rechte Seite der Zuweisung ungleich Null ist.
Kontrollstrukturen - Bedingungen Zur Abfrage von Bedingungen stehen mehrere Vergleichsoperatoren zur Verfügung: if ( variable == 1 ) printf( Gleich\n ); if ( variable!= 1 ) printf( Ungleich\n ); if ( variable <= 1 ) printf( Kleiner Gleich\n ); if ( variable >= 1 ) printf( Größer Gleich\n ); if ( variable < 1 ) printf( Kleiner\n ); if ( variable > 1 ) printf( Größer\n );
Kontrollstrukturen - Bedingungen Zur Verknüpfung verschiedener Bedingungen stehen logische Operatoren zur Verfügung. Die logische Reihenfolge sollte immer durch Klammern spezifiziert werden: if (!(variable == 1) ) printf( Nicht gleich\n ); Das Ausrufezeichen negiert eine nachfolgende Bedingung. if (variable>=1 && variable<5) printf( 1 4\n ); Das doppelte kaufmännische Und (&&) ist eine logische Und Verknüpfung. if (variable<1 variable>4) printf( Min. 0, 5 Max.\n ); if ( (var<1 var>=5) && (var!=7) ) printf( Min. 0, 5 6, 8 Max.\n ); Das doppelte Pipe symbol ( ) ist eine logische Oder Verknüpfung. Komplexere Verknüpfungen sollten aufgrund der Lesbarkeit durch Klammern geschachtelt werden.
Kontrollstrukturen - Blöcke #include <stdio.h> int main( int argc, char* argv[] ) if ( argc == 1 ) printf( Hallo ); Sollen bei einer zutreffenden Bedingung in einer if Anweisung mehrere Anweisungen ausgeführt werden, so müssen diese mittels geschweifter Klammern zu einem Block zusammengefaßt werden. return 0; printf( Welt\n );
Kontrollstrukturen - if-else Manchmal soll ein Stück Programmcode nur unter einer bestimmten Bedingung ausgeführt werden und ein anderes Stück Programmcode falls diese Bedingung nicht zutrifft. #include <stdio.h> Die else Anweisung nach einer if int main( int argc, char* argv[] ) if ( argc == 1 ) return 1; else return 0; Anweisung führt dazu, daß die auf die else Anweisung folgenden Befehle ausgeführt werden, wenn die Bedingung nach der if Anweisung nicht zutrifft. Mehrere Anweisungen müssen wie bei if zu einem Block zusammengefaßt werden.
Kontrollstrukturen - while Manchmal soll ein Stück Programmcode mehrmals durchlaufen werden. Dazu gibt es in C verschiedene sogenannte Schleifen (Loops): #include <stdio.h> int main( int argc, char* argv[] ) int i; i = 0; while ( i < 10 ) printf( Hallo\n ); i++; return 0; Die while Schleife überprüft eine Bedingung am Anfang einer Schleife, bevor die erste Anweisung in der Schleife ausgeführt wird. Die Schleife wird solange ausgeführt, wie die Bedingung in den Klammern nach while zutrifft. Mehrere Anweisungen in der Schleife müssen wie bei if zu einem Block zusammengefaßt werden. Der Inkrement Operator (++) erhöht den Wert eine Variable um eins.
Kontrollstrukturen - do-while #include <stdio.h> int main( int argc, char* argv[] ) int i; i = 0; do printf( Hallo\n ); i++; while ( i < 10 ); return 0; Die do while Schleife überprüft eine Bedingung am Ende einer Schleife. Die Anweisungen in der Schleife werden immer mindestens einmal ausgeführt. Die Schleife wird solange ausgeführt, wie die Bedingung in den Klammern nach while zutrifft. Mehrere Anweisungen in der Schleife müssen wie bei if zu einem Block zusammengefaßt werden.
Kontrollstrukturen - for #include <stdio.h> int main( int argc, char* argv[] ) int i; for ( i = 0; i < 10; i++ ) printf( Hallo\n ); return 0; Die for Schleife hat in der der for Anweisung nachfolgenden Klammer drei Abschnitte, die jeweils durch ein Semikolon voneinander getrennt werden. Mehrere Anweisungen in der Schleife müssen wie bei if zu einem Block zusammengefaßt werden.
Kontrollstrukturen - for #include <stdio.h> int main( int argc, char* argv[] ) int i; for ( i = 0; i < 10; i++ ) printf( Hallo\n ); return 0; Der erste Abschnitt ist die Initialisierung, die einmal vor der Ausführung der Schleife ausgeführt wird. (i = 0)
Kontrollstrukturen - for #include <stdio.h> int main( int argc, char* argv[] ) int i; for ( i = 0; i < 10; i++ ) printf( Hallo\n ); return 0; Der zweite Abschnitt ist die Bedingung, die vor jeder Ausführung der Schleife überprüft wird. Trifft die Bedingung nicht zu, wird die Schleife abgebrochen (i < 10).
Kontrollstrukturen - for #include <stdio.h> int main( int argc, char* argv[] ) int i; for ( i = 0; i < 10; i++ ) printf( Hallo\n ); return 0; Der dritte Abschnitt ist der Schleifenschritt oder Inkrement Abschnitt, der nach jeder Ausführung der Schleife ausgeführt wird. (i++)
Kontrollstrukturen - break, continue i = 0; while ( 1 ) i++; if ( i == 10 ) break; for ( i = 0; i < 10; i++ ) if ( i==5 ) continue; printf( Hallo\n ); Wdh.: Bedingungen treffen zu, wenn sie ungleich Null liefern. 1 ist offensichtlich immer ungleich Null, d.h. diese while Schleife ist prinzipiell eine Endlosschleife. Eine break Anweisung springt aus der innersten sie umgebenden Schleife. D.h. diese while Schleife wird zehn mal ausgeführt. Eine continue Anweisung springt an den Anfang der innersten sie umgebenden Schleife. Achtung: Bei for Schleifen wird dabei die Schleifenschrittanweisung ausgeführt. Bei while und do while Schleifen muß man sich darum selber kümmern!
Funktionen int funktion( int arg1, double arg2 ) return arg1+arg2; Eine Funktion ist eine Gruppe zusammengehöriger Befehle, die mit einem definierten Namen aufgerufen werden können. Jedes C Programm besteht mindestens aus der main Funktion. Weitere Funktionen können in einem C Programm definiert und benutzt werden. Funktionen können Daten zur Bearbeitung über sogenannte Parameter erhalten. Parameter werden bei der Definition der Funktion nach dem Funktionsnamen in Klammern gesetzt aufgeführt und zwar mit ihrem Datentyp (s.u.) und ihrem Namen. Parameter werden innerhalb einer Funktion über ihren Namen angesprochen.
Funktionen int funktion( int arg1, double arg2 ) return arg1 + arg2; Funktionen können Daten zur Bearbeitung über sogenannte Parameter erhalten. Parameter werden bei der Definition der Funktion nach dem Funktionsnamen in Klammern gesetzt aufgeführt und zwar mit ihrem Datentyp und ihrem Namen. Mehrere Parameter werden durch Kommata voneinander getrennt. Parameter werden innerhalb einer Funktion über ihren Namen angesprochen.
Funktionen int funktion( int arg1, double arg2 ) return arg1 + arg2; void andere_funktion( int arg ) printf( Andere Funktion\n ); /* Bei void Funktionen kann ein return am Funktionsende entfallen*/ return; Ergebnisse der Bearbeitung der Eingabe Daten können Funktionen über den sogenannten Rückgabewert an den Aufrufer übermitteln. Der Datentyp des Rückgabewertes einer Funktion wird bei der Definition vor ihrem Namen angegeben. Rückgabewerte werden innerhalb der Funktion mit der return Anweisung übergeben. Die return Anweisung führt dabei dazu, daß die Funktion verlassen wird und der Rückgabewert an die aufrufende Funktion übergeben wird. Funktionen ohne Rückgabewert können den Pseudo Datentyp void benutzen.
Funktionen int main( int argc, char* argv[] ) double d; int ergebnis; funktion( 1, d ); d = 0.1; ergebnis=funktion( 1, d ); if ( funktion( 2, d ) == 2 ) return 1; return 0; Funktionen werden aufgerufen, indem ihr Name gefolgt von den zu übergebenden Parametern in Klammern benutzt wird. Parameter können sowohl als Variablen als auch als Konstanten übergeben werden. Rückgabewerte von Funktionen können ignoriert werden oder durch Zuweisung zu einer Variable gespeichert werden. Sie können auch direkt in Bedingungen ausgewertet werden.
Funktionen int funktion( int arg1, double arg2 ) return arg1+arg2; int main( int argc, char* argv[] ) return funktion( argc, 1.0 ); Funktionen müssen in einem Programm vor ihrem ersten Aufruf bekannt sein. Dies kann durch ihre Definition geschehen.
Funktionen int funktion( int arg1, double arg2 ); int main( int argc, char* argv[] ) return funktion( argc, 1.0 ); int funktion( int arg1, double arg2 ) return arg1+arg2; Falls es nicht möglich ist, eine Funktion vor ihrer Benutzung zu definieren, kann eine Funktion auch vor ihrer Benutzung deklariert werden. Dies geschieht, indem man lediglich den Rückgabewert, den Namen und die Parameter der Funktion wie bei einer Definition angibt, allerdings durch ein Semikolon abgeschlossen. In diesem Fall muß die Definition dieser Funktion aber später im Programm noch folgen.
Funktionen C stellt viele Funktionen zur Verfügung, die in eigenen Programmen aufgerufen werden können. Diese Funktionen sind in Header Dateien deklariert, die vor der Benutzung der Funktionen aufgerufen werden müssen. Zu den meisten dieser Funktionen gibt es man Seiten, in denen die Funktion beschrieben ist. Evtl. muß beim Aufruf von man der Parameter 2 oder 3 angegeben werden. Z.B.: man 3 printf Einige grundlegende Funktionen werden im folgenden erläutert.
Funktionen - Ein-/Ausgabe printf scanf Normale Ausgabe zum Benutzer Normale Eingabe vom Benutzer fopen fread fwrite fclose Öffnen einer Datei Lesen aus einer Datei Schreiben in eine Datei Schließen einer Datei
Funktionen - Mathematik double x, y, z; y = sqrt( x ); Mathematische Funktionen in C: Quadratwurzel: sqrt y = exp( x ); Exponentialfunktion: exp y = log( x ); Natürlicher Logarithmus (ln): log y = log10( x ); Logarithmus zur Basis 10: log10 z = pow( x, y ); Allgemeine Potenz (x y ): pow
Funktionen - Bibliotheken System Funktionen sind in sogenannten Bibliotheken zusammengefaßt. Viele dieser Bibilotheken werden vom Compiler automatisch zum fertigen Programm hinzugefügt (gelinkt). Bei manchen Bibliotheken ist es aber nötig, dem Compiler explizit mitzuteilen diese Bibliotheken zu benutzen. Dies geschieht, indem man beim Aufruf des Compilers lbibliotheksname übergibt: gcc lbibliothek o hello Wall hello.c Ein Beispiel sind die mathematischen Funktionen, die in einer Bibliothek mit dem schönen Namen m stehen: gcc lm o mathe_programm Wall mathe_programm.c
Ein-/Ausgabe - printf printf( Hello, World\n ); printf( Eingabe: ); fflush( stdout ); Die printf Funktion dient zur Ausgabe von Informationen aus dem Programm an den Benutzer. Die einfachste Form gibt lediglich den ihr übergebenen String aus (s.o.). Die Zeichen die printf ausgeben soll, werden dabei erst nach Abschluß einer Zeile ( \n ) ausgegeben. Soll die Ausgabe auch ohne Zeilenvorschub sofort ausgegeben werden (z.b. Eingabe Aufforderungen), muß dem printf ein fflush( stdout ); folgen.
Ein-/Ausgabe - printf int i; i = 0; printf( i: %d\n, i ); Soll printf auch Variablen ausgegeben, so müssen diese im String durch Platzhalter spezifiziert werden. Die Variablen selber werden dann nach dem String durch Kommata getrennt aufgeführt. Die Platzhalter werden dabei durch ein Prozentzeichen (%) eingeleitet gefolgt von einem Buchstaben, der den Datentyp und das Format der auszugebenden Variable spezifiziert.
Ein-/Ausgabe - printf int i; i = 0; printf( i: %d\n, i ); Der Platzhalter um den Datentyp int in Dezimalschreibweise auszugeben ist %d oder %i. printf( i: %i\n, i ); unsigned int u; u = 0; printf( u: %u\n, u ); printf( i: %x,%x\n, i, i ); printf( u: %x,%x\n, u, u ); Der Platzhalter um den Datentyp unsigned int in Dezimal schreibweise auszugeben ist %u. Der Platzhalter um die Datentypen int oder unsigned int in Hexadezimal schreibweise auszugeben ist %x oder %X (Klein oder Großbuchstaben A F).
Ein-/Ausgabe - printf double d; d = 0.0; printf( d: %e\n, d ); float f; f = 0.0; printf( f: %f\n, f ); Der Platzhalter um Fließkommazahlen des Datentyps double in Exponential schreibweise auszugeben ist %e. Der Platzhalter um Fließkommazahlen des Datentyps double in normaler Dezimalschreibweise auszugeben ist %f. unsigned char c; c = 0 ; printf( c: %c\n, c ); Der Platzhalter um den Datentyp unsigned char auszugeben ist %c.
Ein-/Ausgabe - scanf int i; printf( Wert: ); fflush( stdout ); scanf( %d, &i ); Die scanf Funktion dient zur Eingabe von Daten an das Programm durch den Benutzer. Diese Daten werden in Variablen des Programms gespeichert. Die Syntax ist ähnlich wie die von printf, ein String (nur) mit Platzhaltern, die angeben was für Datentypen eingegeben werden sollen. Auf diesen String folgen dann die Variablen, in denen die eingelesenen Werte abgespeichert werden sollen. Allerdings müssen diese in diesem Fall mit einem vorangestellten Kaufmännischen Und Zeichen (&) angegeben werden.
Ein-/Ausgabe - scanf int i; scanf( %d, &i ); Der Platzhalter um den Datentyp int in Dezimalschreibweise einzulesen ist %d. unsigned int u; scanf( %u, &u ); Der Platzhalter um den Datentyp unsigned int in Dezimalschreibweise einzulesen ist %u. scanf( %x, &i ); scanf( %x, &u ); Der Platzhalter um die Datentypen int oder unsigned int in Hexadezimal schreibweise einzulesen ist %x.
Ein-/Ausgabe - scanf int i; scanf( %i, &i ); unsigned char c; scanf( %c, &c ); Mit Hilfe des Platzhalters %i können Variablen des Datentyps int in dezimaler, hexadezimaler und oktaler Schreibweise eingelesen werden. Die Dekodierung erfolgt dabei wie bei der Eingabe von Konstanten anhand der Schreibweise. Eine führende Null signalisiert oktale Schreibweise, ein führendes 0x hexadezimale Schreibweise, ansonsten wird dezimale benutzt. Ein Zeichen (Datentyp unsigned char) kann mit dem Platzhalter %c eingegeben werden.
Ein-/Ausgabe - scanf double d; scanf( %f, %d ); /* Beispiele für Fließkomma Eingaben: 3.14 42.0815 27.1828e 1 4.711E3 Der Platzhalter um Fließkommazahlen des Datentyps double einzulesen ist %f. Hierbei wird nicht nach Schreibweise unterschieden. Die Zahl kann ein optionales Vorzeichen haben und muß einen oder mehr Dezimalstellen, evtl. mit Punkt, aufweisen. Nach den Dezimalstellen kann noch ein durch den Buchstaben e oder E eingeleiteter ganzzahliger Exponent, optional mit Vorzeichen, folgen. */
Ein-/Ausgabe - scanf int i, r; r = scanf( %i,&i ); printf( r: %d\n, r ); printf( i: %i\n, i ); /* Bei einer falschen Eingabe, z.b. einem Buchstaben, wird das obige Programmfragment für r Null ausdrucken. */ scanf bricht die Eingabe nach dem ersten ungültigen Zeichen ab und beläßt dieses im Eingabepuffer. Das ungültige Zeichen wird bei der nächsten Eingabeabfrage des Programmes als erstes abgefragt. scanf gibt als Rückgabewert die Anzahl der Eingabe Platzhalter zurück, denen ein Eingabe Wert erfolgreich zugewiesen wurde. Dieser Wert kann kleiner sein, als die Anzahl der einzulesenden Werte bei einer falschen Eingabe (s.o.). Deshalb sollte man immer den Rückgabewert von scanf überprüfen.
#include <stdio.h> int main( int argc, char* argv[] ) FILE *datei; datei = fopen( return 0; Dateiname, Dateien - fopen Dateimodus ); Eine Datei wird in einem Programm durch eine Variable des Typs FILE symbolisiert. Hierbei muß allerdings der Name der Variable bei der Definition von einem Stern (*) angeführt werden. Eine Datei wird mit dem Aufruf der Funktion fopen geöffnet. Der erste Parameter dieser Funktion ist dabei der Name der zu öffnenden Datei als String. Der zweite Parameter ist ein String der den Modus der zu öffnenden Datei angibt.
Dateien - fopen FILE *datei; datei=fopen( Datei, r ); datei=fopen( Datei, w ); Der Dateimodus wird als Kombination von einem oder zwei Buchstaben angeben. Der Modus r bedeutet, daß die Datei nur zum Lesen geöffnet wird. Das Lesen beginnt am Anfang der Datei. Der Modus w bedeutet, daß die Datei zum Schreiben geöffnet wird. Hierbei wird der Inhalt der Datei beim Öffnen gelöscht falls sie bereits existiert. Falls die Datei noch nicht existiert, so wird sie beim Öffnen erstellt.
Dateien - fopen FILE *datei; datei=fopen( Datei, a ); Der Modus a bedeutet, daß die Datei zum Anfügen geöffnet wird. Die Datei ist wie bei w nur zum Schreiben geöffnet aber der Inhalt wird nicht gelöscht. Daten, die in die Datei geschrieben werden, werden an das Dateiende angehängt. Existiert die Datei nicht, wird sie erstellt. datei=fopen( Datei, r+ ); Der Modus r+ bedeutet, daß die Datei zum Lesen und Schreiben geöffnet wird. Sie wird dabei nicht gelöscht. Lesen und Schreiben beginnt beides am Anfang der Datei.
Dateien - fopen FILE *datei; Der Modus w+ bedeutet, daß die Datei datei=fopen( Datei, w+ ); zum Lesen und Schreiben geöffnet wird. Hierbei wird der Inhalt der Datei beim Öffnen gelöscht falls sie bereits existiert. Falls die Datei noch nicht existiert, so wird sie beim Öffnen erstellt. datei=fopen( Datei, a+ ); Der Modus a+ bedeutet, daß die Datei zum Lesen und Schreiben geöffnet wird. Der Inhalt der Datei wird nicht gelöscht. Falls die Datei noch nicht existiert, so wird sie beim Öffnen erstellt.
Dateien - fclose #include <stdio.h> int main( int argc, char* argv[] ) FILE *datei; datei = fopen( Datei, r ); fclose( datei ); return 0; Durch den Aufruf der Funktion fclose wird eine vorher mit fopen geöffnete Datei wieder geschlossen. Dies muß vor dem Ende des Programms geschehen, ansonsten kann es u. U. zu Datenverlusten kommen.
Dateien - fread #include <stdio.h> int main( int argc, char* argv[] ) FILE *datei; unsigned char inhalt[256]; int ret; datei = fopen( Datei, r ); ret = fread( inhalt, 1, 256, datei ); fclose( datei ); return 0; Mit der Funktion fread können Datenelemente aus einer Datei in das Programm gelesen werden. Der este Parameter bezeichnet dabei den Speicherplatz, an dem die Daten im Programm gespeichert werden sollen. Der zweite Parameter bezeichnet die Größe eines einzulesenden Elements. Der dritte Parameter gibt die Anzahl der einzulesenden Elemente an. Der vierte Parameter ist die Datei, aus der eingelesen werden soll.
Dateien - fread #include <stdio.h> int main( int argc, char* argv[] ) FILE *datei; int b; int ret; datei = fopen( Datei, r ); ret = fread( &b, sizeof(int), 256, datei ); fclose( datei ); return 0; Handelt es sich beim ersten Parameter, dem Speicherplatz für die Daten, um eine einzelne Variable und nicht um ein Feld, so muß ihr ein & Zeichen vorangestellt werden. Die sizeof Funktion gibt für eine Variable oder einen Datentyp an, wie groß der belegte Speicherplatz in Byte ist.
Dateien - fread #include <stdio.h> int main( int argc, char* argv[] ) FILE *datei; unsigned char inhalt[256]; int ret; datei = fopen( Datei, r ); ret = fread( inhalt, 1, 256, datei ); Der Rückgabewert der Funktion fread ist ein int Wert, der die Anzahl der erfolgreich gelesenen Elemente (nicht Bytes) angibt. Dieser Rückgabewert sollte immer überprüft werden, um sicherzustellen, daß auch soviele Daten wie erwartet oder benötigt in das Programm gelesen werden konnten. printf( Gelesen: %d\n, ret ); fclose( datei ); return 0;
Dateien - fwrite #include <stdio.h> int main( int argc, char* argv[] ) FILE *datei; unsigned char inhalt[256]; int ret; datei = fopen( Datei, w ); ret = fwrite( inhalt, 1, 256, datei ); fclose( datei ); return 0; Mit der Funktion fwrite können Datenelemente aus einem in Programm in eine Datei geschrieben werden. Der este Parameter bezeichnet dabei den Speicherplatz, an dem die Daten im Programm gespeichert sind. Der zweite Parameter bezeichnet die Größe eines zu schreibenden Elements. Der dritte Parameter gibt die Anzahl der zu schreibenden Element an. Der vierte Parameter ist die Datei, in die geschrieben werden soll. Für die Angabe des Speicherplatzes der Daten gelten dieselben Bemerkungen wie bei fread.
Dateien - fwrite ret = fwrite( inhalt, 1, 256, datei ); if ( ret == 256 ) printf( Ok\n ); else printf( Fehler\n ); Der Rückgabewert der Funktion fwrite ist ein int Wert, der die Anzahl der erfolgreich geschriebenen Elemente (nicht Bytes) angibt. Dies ist analog zu fread. Dieser Rückgabewert sollte wie bei fread überprüft werden.
Dateien - feof #include <stdio.h> int main( int argc, char* argv[] ) FILE *datei; int b; datei = fopen( Datei, r ); while (!feof( datei ) ) fread( &b, 1, sizeof(int), datei ); fclose( datei ); return 0; Die Funktion feof gibt bei einer Datei an, ob ihr Ende bereits erreicht ist. (eof: End Of File, Dateiende). Der Rückgabewert ist ein int Wert ungleich Null wenn das Dateiende erreicht ist und der int Wert Null, wenn das Dateiende noch nicht erreicht ist.
Weiterführende Informationen DAS C Buch: B. W. Kernighan, D. M. Ritchie: Programmieren in C, Carl Hanser Verlag, ISBN 3 446 15497 3 Oder im Original: B. W. Kernighan, D. M. Ritchie: The C Programming Language, Prentice Hall International, ISBN 0 13 110330 X Oder jedes andere gute C Buch. Online Tutorial: http://www.geocities.com/siliconvalley/software/5562/programming1.html Oder Google: Suchbegriffe C Tutorial, C Kurs, o.ä..