Anfang   zurück   weiter

2. Einige Ein- und Ausgabefunktionen

Die Eingabe von Informationen an das laufende Programm oder die Ausgabe von Daten auf den Bildschirm ist ein wesentlicher Bestandteil jeden Programmes. In C selbst gibt es keinerlei Schlüsselworte für diese Operationen. Vielmehr werden zu diesem Zweck externe Ein- Ausgabefunktionen verwendet.

Ein-/Ausgabe von Zeichen - getchar(), getch() / putchar()

Die Ein- und Ausgabe von einzelnen Zeichen wird mit den Funktionen putchar() und getchar() erreicht. Die Deklarationen der Funktionen sind:
int getchar(void);
int putchar(int);
Die Eingabe eines Zeichens erfolgt also mittels
char c;
...
c = getchar();
Eigentlich stellen diese Definitionen Makros dar, die in der Datei stdio.h zu finden sind und über eine #include Anweisung einzubinden sind. getchar() liest eine Eingabe von der Tastatur, wobei das Lesen mit der Eingabetaste ausgelöst wird. Wurden mehrere Zeichen hintereinander eingegeben und dann erst die Eingabetaste gedrückt, so werden die Zeichen gepuffert und können zeichenweise aus dem Puffer ausgelesen werden. Die eingegebenen Zeichen werden dabei auch am Bildschirm angezeigt. Im Unterschied dazu liefert
int getch(void);
eine ungepufferte Eingabe ohne Echo und nimmt dabei das erste Zeichen aus dem Tastaturpuffer entgegen.

Ein-/Ausgabe von Zeichenketten - gets() / puts()

Für die Ein- und Ausgabe von Zeichenketten (Strings) gibt es die Funktionen
char *gets(char *s);
int puts(char *s);
z.B. gibt
puts("Dies ein Beispiel einer Zeichenkette");
den Text Dies ein Beispiel einer Zeichenkette
mit einer nachfolgenden Zeilenschaltung am Bildschirm aus. Neben den Funktionen für die unformatierte Ein- und Ausgabe stehen zwei Funktionen für die formatierte Ein- und Ausgabe zur Verfügung, Diese Funktionen bieten reichhaltige Möglichkeiten, um die Ein- und Ausgabe von Text und Variablen zu gestalten.

Formatierte Ausgabe - printf()
(aus Definitionsdatei stdio.h)

int printf(const char *format[, var1, var2, ...]);

printf wandelt Ausgaben um und schreibt sie unter der Kontrolle der Zeichenkette format in die Standardausgabe.

Die Formatzeichenkette enthält zwei Arten von Objekten: Gewöhnliche Zeichen, die in die Ausgabe kopiert werden, und Umwandlungsangaben, die die Umwandlung und Ausgabe des nächsten Argumentes veranlassen.
Jede Umwandlungsangabe beginnt mit dem Zeichen % und endet mit einem Umwandlungszeichen.
Manche der "gewöhnlichen" Zeichen dürfen oder können mittels der Tastatur nicht eingegeben werden. Für diese speziellen Zeichen werden Ersatzdarstellungen verwendet.

Zwischen % und den Umwandlungszeichen kann der Reihe nach noch folgendes stehen:

Die Umwandlungzeichen von printf() sind in folgender Tabelle erklärt:

Umwandlungszeichen
Zeichen Argument; Ausgabe als
d,i int;dezimale Zahl
o int; oktale Zahl ohne Vorzeichen
x,X int; hexadezimale Zahl ohne Vorzeichen,
mit abcdef oder ABCDEF für 10, ..., 15.
u int; dezimale Zahl ohne Vorzeichen
c int; einzelnes Zeichen
s char *; aus der Zeichenkette werden Zeichen
ausgegeben bis vor '\0', oder so viele Zeichen, wie die Genauigkeit ist.
f Gleitkomma; [-]m.dddddd (die Genauigkeit gibt die Anzahl der Nachkommastellen an)
e,E Gleitkomma; [-]m.dddddde±xx oder [-]m.ddddddE±xx,
wobei die Genauigkeit die Anzahl der Nachkommastellen festlegt.
g,G Gleitkomma; %e oder %E wird verwendet, wenn der Exponent kleiner als -4
oder nicht kleiner als die Genauigkeit ist; sonst wird %f benutzt.
p Zeiger; Gibt das Eingabeargument als Zeiger in hexadezimaler Form aus
(near-Zeiger als YYYY, far-Zeiger als XXXX:YYYY).
%es wird kein Argument umgewandelt; ein % wird ausgegeben

printf verwendet also sein erstes Argument (die Formatzeichenkette), um zu entscheiden, wieviele weitere Argumente für die Ausgabe folgen und um welche Datentypen es sich dabei handelt. Es kann zu unvorhersehbaren Effekten kommen, wenn nicht ausreichend Argumente vorhanden sind oder die Datentypen nicht stimmen.

printf(s); /* FEHLER, falls s ein % enthält */
printf("%s",s); /* SICHER */

Als Funktionsresultat wird die Anzahl der ausgegebnen Zeichen, bzw. EOF im Fehlerfalle, geliefert.

Formatierte Eingabe - scanf()
(aus Definitionsdatei stdio.h)

Die Funktion scanf ist die zu printf analoge Eingabefunktion.
int scanf(const char *format, &var1[, &var2, ...]);
scanf liest Zeichen aus der Standard-Eingabe und interpretiert sie unter der Kontrolle der Zeichenkette format und legt die Resultate in den restlichen Argumenten ab. Die Argumente müssen alle Zeiger sein!
Als Funktionsresultat wird die Anzahl erfolgreicher Zuweisungen geliefert.

Die Format-Zeichenkette enthält Umwandlungsangaben, die zur Interpretation der Eingabe verwendet werden. Jede Formatanweisung beginnt mit dem Prozentzeichen (%).

Die Format-Zeichenkette kann folgendes enthalten:

Die Umwandlungzeichen von scanf() sind in folgender Tabelle erklärt:

Umwandlungszeichen
Zeichen Eingabedaten; Argumenttyp
d dezimal, ganzzahlig; int *
i ganzzahlig; int *
o oktal ganzzahlig; int *
u dezimal ohne Vorzeichen; unsigned int *
x hexadezimal ganzzahlig; int *
c ein oder mehrere Zeichen; char *
s Zeichenkette (ohne ""); char *,
der auf einen Vektor zeigen muß, der die Zeichenkette und
das abschließende '\0', das angehängt wird, aufnehmen kann.
e,f,g Gleitpunktzahl mit optionalem Vorzeichen, optionalem
Dezimalpunkt und optionalem Exponenten; float *
%erkennt %; eine Zuweisung findet nicht statt

scanf verwendet ebenfalls sein erstes Argument (die Formatzeichenkette), um zu entscheiden, wieviele weitere Argumente folgen und um welche Datentypen es sich dabei handelt.

Die Format-Zeichenkette von scanf kann gewöhmliche Zeichen enthalten; sie müssen dann genau so in der Eingabe vorkommen. z.B. Datumseingabe wie dd/mm/yy:

  int day, month, year;
  scanf("%d/%d/%d", &day, &month, &year);

Bei der Eingabe von Zeichenketten mittels der Funktion scanf() ist noch zu beachten, dass zwar die ENTER-taste die Eingabe beendet, die Übernahme der Zeichenkette aber nur bis zu einem Tabulator oder Zwischenraum erfolgt. Taucht also z.B. ein Zwischenraum im Eingabestrom auf, wird nur der Text bis zum Zwischenraum an die Stringvariable übergeben, der Rest der Eingabe (ab dem Zwischenraum) bleibt im Eingabepuffer stehen. Soll also ein ganzer Satz von der Tastatur an einen String übergeben werden, ist dies besser mittels der Funktion gets() zu erledigen!
Das auftretende Problem zeigt das folgenden Beispiel:

#include <stdio.h>

int main(void)
{
  char string1[81];
  char string2[81];

  printf("\n\nGeben Sie einen Satz ein (zumindest mit einem Space!) :\n");
  puts("Die Eingabe wird mit scanf in die Variable string1 eingelesen!\n");
  scanf("%s", string1);
  printf("\nInhalt der Variable string1  : \"%s\"\n", string1);
  gets(string2);
  printf("Der Rest aus der Eingabe ist : \"%s\"\n", string2);
  getch();
  return 0;
}

Auch die Eingabe eines einzelnen Zeichens mittels scanf kann Probleme bereiten, falls vorher schon eine Eingabe mittels scanf durchgeführt wurde. Im ersten Teil des Programmes bleibt im Eingabestrom eine Zeilenschaltung zurück, so dass das darauffolgende scanf("%c", ch) eine leere Eingabe produziert. Im zweiten Teil des Programms wird eine Lösung des Problems gezeigt.

/* scnfxmpl.c
   Einlesen einzelner Zeichen bei einer vorherigen Verwendung von scanf
 */

#include <stdio.h>
#include <conio.h>

int main (void)
{
 float nmbr;
 char ch;

 clrscr();
 printf("\nGeben Sie eine Zahl ein: ");
 scanf("%f", &nmbr);
 printf("\nGeben Sie ein Zeichen ein: ");
 scanf("%c", &ch);
 printf("\nZahl = %f\nZeichen = %c\n", nmbr, ch);
 printf("\nGeben Sie noch eine Zahl ein: ");
 scanf("%f", &nmbr);
 printf("\nGeben Sie wieder ein Zeichen ein: ");
 scanf("%1s", &ch);
 printf("\nZahl = %f\nZeichen = %c\n", nmbr, ch);
 return 0;
}

weiter zu den C-Datentypen