Funktionen zur formatierten Ein- und Ausgabe
Anmerkung : Mit Hilfe der in einigen Betriebssystemen (z.B. MS-DOS,
UNIX) realisierten Umleitung der Standard-Eingabe und Standard-Ausgabe auf
der Kommando-Ebene kann mit diesen Funktionen auch eine Bearbeitung anderer
Dateien realisiert werden.
Mit den Ein-/Ausgabefunktionen der Standard-Bibliothek eng verknüpft
ist die Header-Datei
stdio.h
In ihr sind die für die Anwendung der Funktionen benötigten
Funktionsdeklarationen (Function Prototypes) sowie einige Typen und Konstante
(Makros), die mit der Realisierung und Anwendung der Funktionen in Zusammenhang
stehen, definiert. U.a. wird die Konstante EOF
definiert, die zur C-internen Kennzeichnung des Dateiendes dient.
Der Wert dieser int-Konstanten ist nicht mit dem Wert eines eventuellen
im Betriebssystem verwendeten Dateiende-Zeichens (z.B. CTRL-D unter UNIX, CTRL-Z unter DOS)
identisch, sondern beträgt i. a. -1.
Zur problemlosen und einfachen Anwendung der Standardbibliotheks-Funktionen
ist es daher zweckmäßig die Header-Datei stdio.h mittels
#include <stdio.h>
in das C-Programm-Modul einzubinden.
Die Ausgabefunktion printf
int printf(controlstring, arg1, arg2, ... )
Das folgende Programm gleicht dem ersten C-Beispiel:
#include
void main(void)
{
printf("Hallo Welt\n");
}
Die Ausgabe dieses Programms ist
Hallo Welt
Dahinter kommt ein Zeilenvorschub (\n).
Das erste Argument von printf ist ein Formatstring - ein String der das
Ausgabeformat beschreibt. Entsprechend den C-Konventionen muß der String mit
einem NUL-Zeichen (\0) abgeschlossen sein. Wenn der String als Konstante
geschrieben wird, ist automatisch garantiert, daß er richtig abgeschlossen ist.
Die printf-Funktion kopiert die Zeichen aus dem Format auf die Standardausgabe, bis
entweder das Ende des Strings oder ein %-Zeichen erreicht wird. Anstatt das im Format
gefundene %-Zeichen auszugeben, sucht printf nach weiteren Zeichen hinter dem %-Zeichen,
um herauszufinden, wie das nächste Argument umgewandelt werden soll. Das
umgewandelte Argument wird anstelle des %-Zeichens und der nächsten paar
Zeichen ausgegeben. Da das Format im obigen Beispiel kein %-Zeichen enthält,
entspricht die Ausgabe genau den im Format angegebenen Zeichen. Das Format legt
zusammen mit den entsprechenden Argumenten jedes einzelne Zeichen in der Ausgabe
fest. Dazu gehört auch der Zeilenvorschub, mit dem eine Zeile abgeschlossen
wird.
Der Rückgabewert von printf ist die Anzahl der ausgegebenen Zeichen.
Die printf-Funktion hat zwei verwandte Funktionen: fprintf und sprintf.
Während printf auf die Standardausgabe schreibt, kann fprintf nur auf
eine Ausgabedatei schreiben. Die entsprechende Datei muß in der
fprintf-Funktion als erstes Argument angegeben werden. Daher bedeuten
printf (Ausgabe); und fprintf(stdout, Ausgabe);
exakt dasselbe.
Die Funktion sprintf wird eingesetzt, wenn die Ausgabe nicht in eine Datei erfolgen
soll. Das erste Argument von sprintf ist die Adresse eines Zeichenarrays, in dem
sprintf seine Ausgabe ablegt. Daß das Array groß genug ist, um die von
sprintf erzeugt Ausgabe aufzunehmen, liegt in der Verantwortlichkeit des
Programmierers. Die weiteren Argumente sind identisch mit printf. Die Ausgabe von
sprintf wird immer mit einem NUL-Zeichen abgeschlossen. Die einzige Möglichkeit,
um ein NUL-Zeichen auf andere Art und Weise auszugeben, ist die Verwendung des
Formats %c.
Alle drei Funktionen liefern als Ergebnis die Anzahl der übertragenen Zeichen
zurück. Im Fall von sprintf wird das NUL-Zeichen am Ende der Ausgabe nicht
mitgezählt. Wenn printf oder fprintf während des Schreibens auf einen
Ein-/Ausgabefehler treffen, geben Sie einen negativen Wert zurück. In diesem
Fall kann man nicht mehr feststellen, wieviele Zeichen geschrieben wurden. Da
sprintf keine Ein/Ausgabe durchführt, sollte niemals ein negativer Wert
zurückgegeben werden.
Da der Formatstring die Datentypen der weiteren Argumente festlegt und dieser
Formatstring während der Ausführung erstellt werden kann, ist es
für eine C-Implementierung sehr schwer festzustellen, ob die Argumente von
printf die richtigen Datentypen enthalten. Wenn man also printf("%d\n", 0.1);
schreibt oder printf (%g\n", 2); dann erhält man nur Unsinn. Es
ist aber äußerst unwahrscheinlich, daß dies vor dem Programmstart
entdeckt werden kann.
Den meisten Implementierungen entgeht auch eine Anweisung wie fprintf("error\n");
Der Programmierer hat hier fprintf verwendet, weil er eine Meldung auf stderr ausgeben
wollte, hat aber vergessen, stderr anzugeben. Wahrscheinlich wird das Programm
abstürzen, da fprintf den Formatstring als Dateistruktur interpretiert.
Einfache Formatangaben
Jedes Formatelement wird mit einem %-Zeichen eingeleitet, hinter dem wenn auch manchmal
nicht sofort - ein Zeichen folgt, das als Formatcode bezeichnet wird, mit dem die Art
und Weise der Umwandlung bestimmt wird. Andere Zeichen können wahlweise zwischen
dem %-Zeichen und dem Formatcode angegeben werden. Diese Zeichen dienen zur näheren
Spezifikation des Ausgabeformats und werden später noch ausführlich
erläutert.
Das häufigste Format ist sicherlich %d, das einen Integerwert in Dezimalschreibweise
ausgibt. Zum Beispiel ergibt
printf ("2 + 2 = %d\n", 2 + 2)
die Ausgabe 2 + 2 = 4 hinter der ein Zeilenvorschub folgt.
Das Format %d ist eine Anforderung, daß ein Integer ausgegeben werden soll. Es
muß daher ein entsprechendes int-Argument vorliegen. Der Dezimalwert des Integer
ersetzt das Format %d ohne vorangestellte oder nachfolgende Nullen während der
Kopie auf die Ausgabe. Wenn der Integer negativ ist, wird als erstes Zeichen ein
Minuszeichen ausgegeben.
Das Format %u verarbeitet einen Integer so, als wäre er unsigned. Deshalb ergibt
printf("%u\n", -37); auf einer Maschine mit 32-Bit-Integern die Ausgabe
4292967259.
Beachten Sie, daß char- und short-Argumente automatisch zu einem int erweitert
werden. Das kann auf Maschinen, bei denen char-Werte als signed verarbeitet werden,
zu einigen Überraschungen führen. Um diese Probleme zu vermeiden, sollten
Sie das Formatelement %u für uns igned-Werte reservieren.
Die Formatelemente %o, %x und %X geben Integerwerte mit der Basis 8 oder 16 aus. Das
Element %o liefert oktale Ausgaben, während die Elemente %x und %X hexadezimale
Ausgaben erzeugen. Der einzige Unterschied zwischen %x und %X ist:
- %x liefert die Buchstaben a, b, c, d, e und f für die Werte der Ziffern 10 bis 15.
- %X verwendet die Buchstaben A, B, C, D, E und F
Oktale und hexadezimale Werte sind immer vorzeichenlos. Zum Beispiel gibt
int n = 108;
printf("%d dezimal = %o oktal = %x hexadezimal\n", n, n, n);
die Ausgabe
108 dezimal = 154 oktal = 6c hexadezimal
Das Formatelement %s dient zur Ausgabe von Strings: Das entsprechende Argument muß
Die Adresse eines Strings sein. Die Zeichen werden ab der Stelle, die vom Argument
adressiert wird, bis zum ersten erkannten NUL-Zeichen ('\0') ausgegeben.
Ein String mit einem %s-Formatelement muß mit einem '\0'-Zeichen
abgeschlossen sein. Dies ist die einzige Möglichkeit, damit printf das Ende das
Strings erkennen kann. Wenn ein String, der an ein %s-Element übergeben wird,
nicht richtig abgeschlossen ist, dann wird printf die Ausgabe solange fortsetzen, bis
es irgendwo im Speicher ein '\0'-Zeichen findet. Die Ausgabe kann dann wirklich sehr
lang werden.
Da das Formatelement % s jedes Zeichen im entsprechenden Argument ausgibt, bedeuten
printf(s) und printf ("%s", s) nicht dasselbe. Das erste Beispiel
behandelt jedes %-Zeichen in s als den Anfang eines Formatcodes. Das kann zu
Problemen führen, wenn ein anderer Formatcode als %% vorkommt, da dann das
entsprechende Argument fehlt. Das zweite Beispiel gibt jeden mit NUL abgeschlossenen
String aus.
Das Formatelement %c gibt ein einzelnes Zeichen aus:
printf ("%c", c) entspricht putchar(c),
hat aber den Vorteil, daß man den Wert von c auch in einem größeren
Zusammenhang ausgeben kann. Das Argument, das bei einem %c
Formatelement angegeben werden muß, ist ein int, der bei der Ausgabe in
einen char umgewandelt wir. Zum Beispiel ergibt
printf("Der Dezimalwert von '%c' ist %d\n", '*', '*');
die Ausgabe Der Dezimalwert von '*'ist 42
Drei Formatelemente stehen für die Ausgabe von Fließkommazahlen zur
Verfügung: %g, %f und %e. Das Formatelement %g ist am nützlichsten,
wenn man Fließkommazahlen darstellen will, die nicht in Spalten ausgegeben
werden müssen. Damit wird der entsprechende Wert (der unbedingt ein float
oder double sein muß) ohne nachfolgende Nullen mit bis zu sechs
signifikanten Ziffern ausgegeben. Zusammen mit math.h ergibt
printf("Pi = %g\n", 4 * atan(l.0));
die Ausgabe Pi = 3.14159.
Führende Nullen werden in der Genauigkeit nicht berücksichtigt. Die Werte
werden nicht abgeschnitten, sondern gerundet: printf("%g\n", 2.0 / 3.0);
liefert die Ausgabe 0.666667.
Wenn die Zahl größer als 999999 ist, dann würde der Wert
entweder mit mehr als sechs signifikanten Stellen oder falsch Wert ausgeben. Das
Formatelement %g löst dieses Problem, indem solche Werte in der
wissenschaftlichen Schreibweise ausgegeben werden:
printf("%g\n", 123456789.0);
liefert die Ausgabe 1.23456e+08
Der Wert wird wiederum auf sechs signifikante Stellen gerundet.
Wenn die Größenordnung des Werts zu klein ist, wird die erforderliche Anzahl
an Zeichen zur Darstellung der Werte ebenfalls sehr groß. Es ist zum Beispiel
sehr unschön, wenn man PI * 10-10 als 0.00000000031459 schreibt.
Sowohl kompakter als auch leichter zu lesen ist 3.14159e-10. Diese beiden
Darstellungsformen weisen genau dieselbe Länge auf, wenn der Exponent -4 ist (zum
Beispiel ist 0.000314159 genauso lang wie 3.14159e-04).
Das %g-Formatelement fängt daher erst bei einem Exponenten von -5 mit der
wissenschaftlichen Darstellung an.
Das Formatelement %e verwendet zur Ausgabe von Fließkommazahlen in jedem Fall
einen expliziten Exponenten: n wird im %e-Format als 3.141593e+00 ausgegeben.
Das Formatelement %e gibt immer sechs Ziffern hinter dem Dezimalpunkt aus, und
nicht bloß sechs signifikante Ziffern.
Mit dem Formatelement % f werden Fließkommazhalne immer ohne einen Exponenten
ausgegeben, so daß n als 3.14159 ausgegeben wird. Auch das %f-Format gibt
sechs Ziffern hinter dem Dezimalpunkt aus. Ein sehr kleiner Wert kann demnach als
Null erscheinen, auch wenn das gar nicht der Fall ist, und eine sehr große
Zahl wird mit vielen Ziffern ausgegeben:
printf("%f\n", le38);
wird als 10000000000000000000000000000000000000.000000
ausgegeben. Da die Anzahl der hier ausgegebenen Ziffern die Genauigkeit der meisten
Computer übersteigt, kann das Ergebnis auf verschiedenen Maschinen unterschiedlich
sein.
Die Formatelemente % E und % G verhalten sich genauso wie die entsprechenden
Formatelemente mit Kleinbuchstaben, außer daß der Exponent mit einem
großen E und nicht mit einem kleinen e dargestellt wird.
Das Formatelement %% gibt ein %-Zeichen aus. Es ist insofern einzigartig, als in
diesem Fall kein entsprechendes Argument angegeben werden muß. Die Anweisung
printf("%%d gibt einen Dezimalwert aus\n");
ergibt also die Ausgabe %d gibt einen Dezimalwert aus.
Modifizierer
Die Funktion printf verarbeitet auch noch weitere Zeichen, mit denen ein Formatelement
genauer spezifiziert werden kann. Diese Zeichen werden zwischen dem %-Zeichen und dem
folgenden Formatcode angegeben.
Integer gibt es in drei verschiedenen Längen: short, long und int.
Wenn ein kurzer Integer als Funktionsargument angegeben wird, wird er automatisch
in einen normalen Integer umgewandelt. Das gilt auch für die Funktion printf,
aber für die long-Integer benötigen wir noch eine Möglichkeit, um sie
zweifelsfrei anzugeben. Dies erreicht man durch ein l direkt vor dem Formatcode, so
daß sich dann %ld, %lo, %lx und %lu als neue Formatcodes ergeben. Diese
modifizierten Codes verhalten sich dann für long wie ihre nicht modifizierten
Entsprechungen.
Der Modifizierer für die Ausgabebreite vereinfacht die Ausgabe von Werten in
Feldern fester Länge. Er wird zwischen dem %-Zeichen und dem nachfolgenden
Formatcode angegeben und legt die Mindestanzahl an Zeichen fest, die mit dem
entsprechenden Formatelement ausgegeben werden sollen. Wenn der auszugebende Wert
das Feld nicht voll ausfüllt, werden Leerzeichen auf der linken Seite
eingefügt, damit das Feld breit genug ist. Falls der Wert zu groß
für das Feld ist, wird das Feld entsprechend vergrößert. Der
Modifizierer für die Ausgabebreite schneidet ein Feld niemals ab. Wenn man
mit diesem Modifizierer Zahlenspalten ausgeben will, dann verschiebt ein zu
großer Wert die nachfolgenden Werte in der Zeile nach rechts.
Der Modifizierer für die Ausgabebreite kann bei allen Formatcodes angegeben
werden, sogar bei %%. Beispielsweise gibt die Anweisung printf("%8%\n");
ein rechts ausgerichtetes %-Zeichen in einem acht Zeichen langen Feld aus.
Der Modifizierer für die Genauigkeit legt die Anzahl der Ziffern in der
Darstellung von Zahlen oder Strings fest. Der Modifizierer wird mit einem Dezimalpunkt
angegeben, hinter dem mehrere Ziffern folgen. Er steht hinter dem %-Zeichen und dem
Modifizierer für die Ausgabebreite, aber immer noch vor dem Formatcode:
- Bei den Integer-Formatelementen %d, %o, %x und %u gibt dieser Modifizierer
die Mindestanzahl der Zeichen an, die ausgegeben werden sollen. Wenn der Wert nicht
soviele Ziffern umfaßt, werden Nullen vorangestellt. Die Anweisung
printf("%.2d/%.2d/%.4d\n", 7, 14, 1789); ergibt also die Ausgabe
07/14/1789.
- Bei den Formatelementen %e, %E und %f gibt die Genauigkeit die Anzahl der
Ziffern hinter dem Dezimalpunkt an. Wenn die Flags (die wir gleich danach
besprechen) nichts anderes angeben, erscheint nur dann ein Dezimalpunkt, wenn die
Genauigkeit größer als Null ist. Zum Beispiel:
double pi;
pi = 4 * atan(1.0);
printf("%.Of %.lf %.2f %.3f %.6f %.10f\n", pi, pi, pi, pi, pi, pi);
printf("%.Oe %.le %.2e %.3e %.6e %.10e\n", pi, pi, pi, pi, pi, pi);
die folgende Ausgabe:
3 3.1 3.14 3.142 3.141593 3.1415926536 3e+OO 3.le+OO 3.14e+OO 3.1415926536e+OO
- Bei den Formatelementen %g und %G gibt die Genauigkeit die Anzahl der signifikanten
Ziffern an, die ausgegeben werden sollen. Wenn in den Flags nichts anderes angegeben wurde,
werden alle bedeutungslosen Nullen entfernt und der Dezimalpunkt gelöscht, falls dahinter
keine Ziffern mehr folgen.
- Im Falle der %s-Formatelemente gibt die Genauigkeit an, wieviele Zeichen des
entsprechenden Strings ausgegeben werden sollen. Wenn im String nicht genug Zeichen
vorhanden sind, um die geforderte Genauigkeit zu erfüllen, wird die Ausgabe
gekürzt. Mit Hilfe des Modifizierers für die Ausgabebreite kann die Ausgabe
wieder verlängert werden. Mit Hilfe des Formatelements %15.15s wäre
garantiert, daß genau 15 Zeichen ausgegeben werden.
- In den Formatelementen c und % wird die Genauigkeit nicht berücksichtigt.
Flags
Zwischen dem %-Zeichen und der Feldbreite können noch weitere Zeichen angegeben werden,
mit denen man die Wirkung eines Formatelements weiter beeinflussen kann. Diese Zeichen werden
als Flags bezeichnet. Die Flagzeichen haben folgende Bedeutungen:
- Das Flag - wirkt sich nur dann aus, falls eine Breite angegeben wurde (da man nur dann
etwas zum Ausfüllen hat, wenn die Breite größer ist, als es für den Wert
notwendig ist). In diesem Fall erscheinen alle Leerzeichen zum Auffüllen auf der rechten,
und nicht auf der linken Seite.
Beim Ausdruck von Strings in Spalten fester Länge sieht es normalerweise besser aus, wenn
man sie links ausrichtet. Daher ist ein Format wie %14s meistens ein Fehler und
sollte wohl %-14s heißen.
- Das Flag + gibt an, daß jeder numerische Wert mit einem Vorzeichen als erstes
Zeichen ausgegeben werden soll. Es werden also auch alle nicht negativen Werte mit einem
Pluszeichen ausgegeben. Das Flag hat keinerlei Bezug zum Flag -.
- Wenn ein Leerzeichen als Flag verwendet wird, dann bedeutet das, daß ein einzelnes
Leerzeichen vor jedem numerischen Wert erscheinen soll, wenn kein Vorzeichen vorhanden ist.
Dies wird meist für links ausgerichtete Spalten von Zahlen verwendet, in denen kein
Pluszeichen vorkommen soll. Wenn die Flags + und Leerzeichen im selben Formatelement angegeben
werden, hat das Flag + den Vorrang.
Die Formatelemente % e und %+e sind für die Ausgabe von
Zahlenspalten in wissenschaftlicher Schreibweise besser geeignet als das normale
Formatelement %e: Durch das Vorzeichen (oder das Leerzeichen) wird
sichergestellt, daß alle Dezimalpunkte untereinander stehen.
- Das Flag # verändert das Format der numerischen Werte geringfügig abhängig
von den einzelnen Formatelementen. Beim %o-Format wird die Genauigkeit erhöht, und
zwar so weit, daß die erste ausgegebene Ziffer eine 0 ist. Damit können
Oktalwerte so ausgegeben werden, wie sie von C-Programmierern am leichtesten erkannt
werden. In gleicher Weise stehen bei den Formatelementen %#x und %#X die Zeichenfolgen
0x bzw. 0X vor der Ausgabe.
Das Flag # erzwingt die Ausgabe eines Dezimalpunkts, auch wenn dahinter keine weiteren
Ziffern mehr kommen, und es verhindert das Weglassen nachfolgender Nullen in dem Formaten
%g und %G.
Die Flags sind außer dem Leer- und dem Pluszeichen alle voneinander unabhängig.
Variable Feldbreite und Genauigkeit
Viele C-Programme definieren sorgfältig die Länge eines Strings als feste
Konstante, damit sie leichter zu ändern ist geben aber die Ausgabebreite in
den Ausgabeanweisungen als Integerkonstante an. Es wäre also nicht allzu
klug, wenn wir eines unserer früheren Beispiele wie folgt umschreiben würden:
#define NAMESIZE 14
char name[NAMESIZE];
...
printf(" ... %.14s ... ", ... , name, ...);
...
Jemand der später einmal NAMESIZE verändern will, wird wahrscheinlich
übersehen, daß er alle printf-Aufrufe ebenfalls verändern muß. Es ist
jedoch nicht möglich, NAMESIZE direkt in der printf-Anweisung anzugeben:
printf("... %.NAMESIZEs, ...", name, ...);
funktioniert nicht, da der Präprozessor innerhalb von Strings keine Ersetzungen vornimmt.
printf erlaubt daher, daß die Feldbreite oder Genauigkeit indirekt angegeben werden
kann. Dazu schreibt man anstelle der Feldbreite oder der Genauigkeit das Zeichen *. In
diesem Fall holt sich printf die tatsächlichen Werte aus der Argumentliste, bevor
der Wert ausgegeben wird. Im obigen Beispiel sollte es also
printf("... %.*s, ...", ..., NAMESIZE, name, ...);
heißen. Wenn die Konvention mit dem * sowohl für die Feldbreite als auch
die Genauigkeit verwendet wird, erscheint das Argument mit der Feldbreite zuerst,
dahinter kommt das Argument für die Genauigkeit und anschließend der Wert,
der ausgegeben werden soll.
printf("%*.*s\n", 12, 5, str);
hat also dieselbe Wirkung wie
printf("%12.5s\n", str);
Wenn das Zeichen * für die Feldbreite verwendet wird und der entsprechende Wert
negativ ist, hat das denselben Effekt, als ob das Flag - ebenfalls angegeben worden
wäre.
Zusammenfassung: Formatierte Ausgabe in C mit "printf"
| Allgemeine Form: |
printf(Controlstring, Arg1, Arg2, ... ) |
| Controlstring: |
Ausgabe von Text und Steuerung der Ausgabeformte. Er kann enthalten:
- darstellbare Zeichen
- Zeichenersatzdarstellungen ('\n', '\t' usw.)
- Umwandlungsspezifikationen
|
| Arg1, Arg2, ...:: |
Die auszugebenden Werte (Argumente). Anzahl und Typ sind durch
den "controlstring" festgelegt |
| Umwandlungsspezifikation: |
Sie haben die Form:
%[Formatangabe]Konvertierungszeichen
Konvertierungszeichen:
| c | Einzelzeichen |
| d, i | Integerzahl (dezimal,konegativ) |
| u | Integerzahl (dezimal,nur positev) |
| o | Integerzahl (oktal, nur positev, ohne führende "0") |
| x, X | Integerzahl (sedezimal, nur positev, ohne führende "0x") |
| e, E | Gleitpunktzahl (float oder double) in Exponentendarstellung |
| f | Gleitpunktzahl (float oder double) in Dezimalbruchdarstellung |
| g, G | kürzeste Darstellung von e oder f |
| s | String |
| p | Pointer (implementierungsabhängige Darstellung) |
|
Formatangabe:
Die Eingabefunktion scanf
scanf(controlstring, arg1, arg2, ... )
"scanf" liest die naechsten Zeichen von stdin, interpretiert sie entsprechend
den im Steuerstring "controlstring" vorliegenden Typ- und Formatanangaben und
weist die dem geäß konvertierten Werte den durch ihre Adresse
referierten Variablen arg1, arg2, ... zu. Anzahl und Typ der Variablen
sind durch "controlstring" festgelegt.
Die der Zeichen-Werte-Konvertierung zugrundeliegenden Umwandlungsspezifikationen
werden durch White-Space-Character (Blank, Tab, Newline) bzw. durch
Längenangaben im Steuerstring getrennt.
Funktionswert:
Die Anzahl der erfolgreich zugewiesenen Werte bzw. EOF (= -1), wenn beim Lesen des
ersten Wertes versucht wurde, über die Eingabe des Dateiendezeichens
hinaus zu lesen.
Die Umwandlungsspezifikation haben ein einheitliches Format:
%[*][ziff]Konvertierungszeichen
¦ ¦
¦ maximale Eingabefeldgröße (Kann weggeleassen werden.
¦ Bei Konvertierungszeichen c: Anzahl der einzulesenden Zeichen.)
¦
Zeichen zum Überlesen des nächsten Eingabefeldes
(assignment suppression; kann weggeleassen werden.)
Konvertierungszeichen:
| c | Zeichen(-folge) (auch blanks, tabs und newlines werden gelesen)
Default (keine Feldgrößenangabe): 1 Zeichen |
| d | Integer (dezimal) |
| i | Integer (dezimal) oder oktal (mit führender "0")
oder sedezimal (mit führendem "0x" bzw "0X") |
| o | Integer (oktal, mit oder ohne führende "0") |
| x | Integer (sedezimal, mit oder ohne führendem "0x" bzw "0X") |
| u | Integer (dezimal, nur positev) |
| e, f, g | Gleitpunktzahl (beliebige Darstellung) |
| s | String (Ergänzung mit abschließendem '\0') |
| p | Pointer |
| h vor d,i,o,u,x | Kurze Integerzahl (short) |
| l vor d,i,o,u,x | Lange Integerzahl (long) |
| l vor e,f,g | double |
| L vor e,f,g | long double |
Beispiel:
int i, jwert;
float zahl;
...
scanf("%2d %f %*d %d",&i,&zahl,&jwert)
...
Nach Eingabe von: 56789 0123 457 haben die Variablen
folgende Werte: i = 56, zahl = 789.0, jwert = 457. Die Zahl 0123 wird
überlesen!
Die Eingabefunktion gets
char *gets(char *s);
"gets" liest die nächsten Zeichen von stdin bis zum nächsten Newline-Character
('\n') bzw bis das Dateiende erreicht ist. Die gelesenen Zeichen werden in dem durch
"s" referierten String ohne eventuell gelesenes '\n' abgelegt. An s wird automatisch
Das Stringende-Zeichen '\0'angehängt.
Funktionswert ist die Anfangsadresse des Strings "s" oder ein NULL-Pointer
bei Erreichen des Dateiendes ohne vorheriges Lesen von Zeichen. Im Fehlerfall
wird ebenfalls ein NULL-Pointer zurückgegeben. Es wird nicht überprüft,
ob genügend Speicherplatz für den String zur Verfügung steht.
Die Ausgabefunktion puts
int puts(const char *s);
"puts" gibt den durch "s" referierten String (ohne '\0'-Character!) nach
stdout aus, wobei ein abschließendes '\n' angefügt wird.
Funktionswert ist ein nicht-negativer Wert bei Fehlerfreiheit und EOF (-1) im
Fehlerfall.
Beispiel:
/* String einlesen und wieder ausgeben */
#include <stdio.h>
char str[100];
void main(void)
{
if (gets(str) != NULL)
puts(str);
else
printf("Leereingabe\n");
}
Die Eingabefunktion getchar
int getchar(void);
"getchar" liest das nächste Zeichen von stdin und gibt das gelesene Zeichen
(als int-Wert zurück. Bei Eingabe des Fileendezeichens für Textdateien
oder im Fehlerfall wird EOF (-1) zurückgegeben.
Beispiel:
/* Zeichen kopieren von stdin nach stdout */
#include <stdio.h>
int ch;
void main(void)
{
while ((ch = getchar()) != EOF)
putchar(ch);
}
Die Ausgabefunktion putchar
int putchar(int c);
"putchar" gibt das Zeichen "c" (nach Umwandlung in unsigned char)
nach stdout aus. Funktionswert: das ausgegebene Zeichen (als int-Wert)
oder EOF (-1) im Fehlerfall.
|
| 
DIENSTE
