Pascal-Tutorial (Vorwort, Installation, Kapitel 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)

Ein-/Ausgabe, formatierte Textausgabe, Drucken

3.1. Ein- und Ausgabe

EVA = Eingabe - Verarbeitung - Ausgabe, ein bekanntes Prinzip - nicht nur - in der Informatik. Zunächst erfolgt die Eingabe durch den Benutzer, das Programm verarbeitet die Daten, und anschließend erfolgt die Ausgabe. Das ist ein (fast) allgemeingültiges Prinzip für einen Programmablauf. Im Detail betrachtet, kann der erste Schritt (Eingabe) aber auch bereits eine Folge des letzten, der Ausgabe, sein. Bevor der Benutzer etwas eingeben wird, sollte er zunächst einmal wissen, was er eingeben soll. Darum beschäftigen wir uns zuerst mit der Ausgabe. Von nichts kommt nichts. ;-)

Wichtig sind für die Ausgabe vor allem 2 Anweisungen: Write und WriteLn (Abkürzung für write line). Write haben Sie bereits im ersten Beispiel kennen gelernt. Zwischen Write und WriteLn besteht nur ein kleiner Unterschied. WriteLn verursacht nach der Ausgabe einen Zeilenumbruch, einen Sprung in die nächste Zeile. Ein kurzes Beispiel:

Write ('hello, ');
Write ('world!');

Hier passiert Folgendes: Zunächst wird mit Write der Text 'hello, ' (beachten Sie das Leerzeichen am Ende!) auf dem Bildschirm ausgegen. In der nächsten Programmierzeile steht wieder eine Write-Anweisung. Diese gibt an der Stelle, wo der Cursor gerade steht, den Text 'world!' aus. Der Cursor steht in diesem Fall natürlich gleich nach dem 'hello, ' und dort folgt nun ein 'world!'. Funktioniert also genau gleich wie:

Write ('hello, world!');

Anders wäre es bei:

WriteLn ('hello, ');
Write ('world!');

WriteLn gibt den Text 'hello, ' auf dem Bildschirm aus. WriteLn verursacht nach der Ausgabe aber immer einen Zeilenumbruch. Darum steht 'world!' erst in der nächsten Zeile.

Noch einmal allgemein die Verwendung von Write und WriteLn:

Write (Ausgabetext);

WriteLn (Ausgabetext);

Der Ausgabetext muss unter einfachen Anführungszeichen (richtig: '... Text ...'; doppelte Anführungszeichen wie "... Text ..." funktionieren nicht) stehen. Mit Write und WriteLn kann man natürlich auch den Inhalt einer Variable oder Konstante ausgeben. Etwa:

Write (a);

Hier wird der Inhalt der Variable a an der aktuellen Cursorposition angezeigt. Es ist auch möglich, beides, Text- und Variablenausgaben, zu kombinieren. Beispiel mit Write:

Write (summand1, ' + ', summand2, ' = ', summe);

Die einzelnen "Teile" müssen durch Beistriche getrennt werden. (Für Leser mit Vorkenntnissen: Write akzeptiert ganz einfach beliebig viele Argumente.) Zunächst wird der Wert aus summand1 ausgeben, dann folgt der Text ' + ' (man beachte wieder die Leerzeichen, sonst schaut's nicht schön aus), danach der Wert der Variable summand2 sowie der Text ' = ' und abschließend der Wert aus der Variable summe.

Kommen wir nun zur Texteingabe. Um Daten von der Tastatur einzulesen, gibt es die Anweisungen Read, ReadLn sowie ReadKey, wovon Sie letzteres (ReadKey) bereits kennen gelernt haben. Read verwenden Sie wie folgt:

Read (Variable);

Anstelle von Variable muss natürlich eine bereits deklarierte Variable angegeben werden, in der die Eingabe abgespeichert wird. Einen Unterschied zwischen Read und ReadLn werden Sie erst bemerken, wenn wir Dateien behandeln. Im Moment erreichen wir mit beiden Anweisungen die gleiche Wirkung. Read (bzw. ReadLn) fordert den Benutzer zu einer Eingabe auf. Read/ReadLn wartet solange, bis der Benutzer Enter drückt. ReadLn wird genau gleich wie Read verwendet, mit ReadLn statt Read.

ReadKey liest ein Zeichen von der Tastatur ein. Ein Abschließen mit Enter entfällt.

Variable := ReadKey;

Die Eingabe vom Benutzer (1 Zeichen) wird in der Variable abgespeichert. (Für Leser mit Vorkenntnissen: Der Rückgabewert der Funktion ReadKey wird der Variable zugewiesen. Mehr dazu später im Kapitel über Funktionen.)

Sie können ReadKey auch einfach nur aufrufen, wie ich es im hello, world!-Beispiel getan habe. Was Sie eingegeben haben (welche Taste gedrückt), wird dann einfach verworfen und nirgendwo gespeichert. Übrigens dient ReadKey in den Beispielen nur dazu, um zu verhindern, dass unter Windows das Ausgabefenster gleich am Ende wieder geschlossen wird. Ich schreibe ReadKey vorsichtshalber dazu. Wenn Sie unter Linux arbeiten oder Ihr Ausgabefenster ohnehin offen bleibt, dann lassen Sie ReadKey in den Beispielen einfach weg.

Wenn Sie Werte von ReadKey (ein ASCII-Zeichen, bzw. numerisch 0-255, 1 Byte) abspeichern wollen, verwenden Sie dazu eine Variable vom Typ Char (das entspricht dem Rückgabetyp von ReadKey, siehe Kapitel über Funktionen).

Nach viel Theorie folgt nun endlich wieder ein ausführbares Beispiel:

PROGRAM Kreisberechnung;
USES Crt;
 
CONST Pi = 3.141592654;
VAR Ergebnis, Radius: Extended;
 
BEGIN
  WriteLn ('Dieses Programm berechnet den Umfang eines Kreises.');
  Write ('Geben Sie den Kreisradius ein: ');
  ReadLn (Radius);
  Ergebnis := 2 * Radius * Pi;
  WriteLn ('Der Umfang des Kreises beträgt: ', Ergebnis);
  Write ('Taste drücken um zu beenden... ');
  ReadKey;
END.

Kurze Erläuterung des Beispiels:

Zunächst: Die Zeilenabstände und Einrückungen dienen der besseren Lesbarkeit (kann ich nur stark empfehlen!), Zeilenumbrüche und Leerzeichen sind, wie bereits erwähnt, dem Compiler ja egal.
In der ersten Zeile wird der Name des Programmes festgelegt (hier Kreisberechnung). In der nächsten Zeile wird mit der USES-Anweisung die Unit Crt eingebunden. Diese ist zwingend notwendig, um ReadLn, Read, Write, WriteLn und ReadKey verwenden zu können! In der nächsten Zeile wird die typenlose (!) Konstante Pi deklariert (vereinbart) und ihr gleich ein Wert zugewiesen (was Pflicht ist). Es folgt die Deklaration der Variablen Ergebnis und Radius vom Typ Extended. Ich habe deshalb Extended gewählt, da dieser Fließkommatyp eine sehr hohe Genauigkeit hat. Bei Real oder anderen würden mehr oder weniger große Rundungsfehler auftreten und das Ergebnis wäre ungenauer.

In den nächsten zwei Zeilen wird ein einleitender Text ausgegeben. In der zweiten Ausgabe-Zeile wird deshalb Write (und nicht WriteLn) verwendet, da nach der Ausgabe kein Zeilenumbruch erfolgen soll. Denn was der Benutzer eingibt, soll direkt neben dem ausgegebenen Text stehen (mit Leerzeichen dazwischen). In der darauffolgenden Programmierzeile wird in die Variable Radius etwas eingelesen. Anschließend erfolgt die Berechnung. Es wird 2 mit Radius und mit Pi multipliziert. Den dazu nötigen *-Operator habe ich bisher noch nicht behandelt (hole ich im nächsten Kapitel nach). Jedenfalls wird das Endergebnis der Variable Ergebnis zugewiesen. In den nächsten zwei Zeilen wird das Endergebnis samt Hinweistext zum Drücken einer Taste angezeigt. ReadKey hält das Programm solange an, bis der Benutzer eine Taste drückt. Dann wird das Programm beendet, weil an der letzten Zeile angelangt.

3.2. Formatierte Textausgabe

Zum Glück müssen wir uns bei der Textausgabe nicht auf weißen Text auf schwarzem Hintergrund (wie bisher) beschränken. Im Folgenden lernen Sie, wie Sie die Textfarbe und die Hintergrundfarbe des Textes ändern.

Zur Änderung der Schriftfarbe benötigt man die Anweisung TextColor und zur Änderung der Hintergrundfarbe die Anweisung TextBackground. Um beide nutzen zu können, muss die Unit Crt inkludiert werden (USES Crt; noch vor VAR, CONST und dem restlichen Programm).

Als Hintergrundfarbe bzw. Textfarbe können Sie eine der 16 Grundfarben auswählen. Um eine Farbe zu bestimmen, kann entweder ein Farbwert (Zahl von 0 bis 15) angegeben oder ein vordefinierter Farbname (z.B. Red) gewählt werden. Beides hat schlussendlich dieselbe Wirkung.

Die 16 Grundfarben:

Verwendung von TextColor:

TextColor (Farbe);

Anstelle von Farbe kann entweder der Farbcode (Nummer) oder ein vordefinierter Bezeichner angegeben werden. Der vordefinierte Bezeichner darf nicht unter (einfachen) Anführungszeichen stehen (weil er als Konstante mit dem Farbcode definiert ist!). Farbeinstellungen sind immer solange gültig, bis sie geändert werden! TextBackground wird ähnlich angewandt:

TextBackground (Farbe);

Kurzes Beispiel. Wie gesagt sind:

TextColor (4);

und

TextColor (Red);

vom Ergebnis her identisch. 4 ist der Farbcode für die Farbe Rot. Das nächste Beispiel demonstriert die Verwendung einiger Farben:

PROGRAM Farben;
USES Crt;
 
BEGIN
  ClrScr;
 
  WriteLn ('Dieser Text wird in weißer Farbe auf schwarzem Hintergrund angezeigt (= Voreinstellung).');
  WriteLn;
 
  TextColor (Red);
  WriteLn ('Textfarbe: Rot, Hintergrundfarbe: Schwarz');
 
  TextBackground (LightBlue);
  WriteLn ('Textfarbe: Rot, Hintergrundfarbe: Hellblau');
 
  TextColor (Black);
  TextBackground (White);
  WriteLn ('Textfarbe: Schwarz, Hintergrundfarbe: Weiß');
  WriteLn;
 
  TextColor (White);
  TextBackground (Black);
  WriteLn ('Taste drücken um zu beenden ...');
  ReadKey;
END.

Erläuterung: Die Unit Crt wird benötigt, damit hier die Anweisungen ClrScr, WriteLn, TextBackground, TextColor und ReadKey funktionieren. ClrScr (das ist neu!) löscht den Bildschirm und muss einfach nur aufgerufen werden, Parameter (Werte in Klammer) sind nicht nötig. WriteLn ohne Parameter aufgerufen (siehe 6. Programmierzeile im obigen Beispiel) erzeugt einfach nur einen Zeilenumbruch! Beachten Sie, dass eine Farbeinstellung immer solange gilt, bis sie geändert wird. Stellen Sie die Hintergrundfarbe des Textes auf Rot, bleibt diese solange rot, bis sie geändert wird. Wundern Sie sich also nicht, wieso beim zweiten Farbbeispiel (rote Textfarbe, hellblaue Hintergrundfarbe) die Textfarbe weiterhin Rot ist. Bevor der letzte Text (Taste drücken um zu beenden ...) angezeigt wird, werden die Farbeinstellungen noch auf die Standardwerte zurückgesetzt. Dies erreicht man, indem man die Textfarbe auf Weiß und die Hintergrundfarbe auf Schwarz stellt.

Mit HighVideo, NormVideo oder LowVideo ist es möglich, auf einfache Weise die Schriftart aufzuhellen, abzudunkeln oder auf den Normalwert zurückzusetzen. Für alle Anweisungen benötigen wir wieder die Unit Crt.

HighVideo stellt die Schrift auf einen helleren Wert (verglichen mit dem Standardwert). Gleiches bewirkt der Aufruf von TextColor (White); oder TextColor (15);.

NormVideo stellt die Schriftfarbe wieder auf den Standardwert zurück. Das Gleiche bewirkt der Aufruf von TextColor (LightGray); oder TextColor (7);.

LowVideo verdunkelt die Schrift und funktioniert analog zu TextColor (DarkGray); oder TextColor (8);.

Die Einstellungen gelten wieder solange, bis sie geändert werden.

3.3. Drucken

Es ist auf einfache Weise möglich, Texte an den Drucker umzuleiten, also auszudrucken. Dazu müssen wir lediglich die Unit Printer in unser Programm einbinden sowie einen zusätzlichen Parameter (Lst) bei Write bzw. WriteLn angeben. Beispiel mit Write:

Write (Lst, Text);

Der Text muss wieder unter einfachen Anführungszeichen stehen. Das nächste Beispiel demonstriert, wie man einen benutzerdefinierten Text ausgeben kann. Benutzerdefiniert: Der Text wird vom Benutzer eingegeben. :-)

PROGRAM Drucken;
USES Crt, Printer;
 
VAR Text: String;
 
BEGIN
  ClrScr;
 
  HighVideo;
  WriteLn ('Welcher Text soll ausgedruckt werden? (Drucker muss eingeschaltet sein.)');
 
  NormVideo;
  ReadLn (Text);
  WriteLn ('Text wird jetzt gedruckt... ');
 
  WriteLn (Lst, Text);
 
  ReadKey;
END.

Nebenbei demonstriert das Beispiel auch die Verwendung von HighVideo und NormVideo.

Noch einige Informationen aus der Praxis: Mit dem Zeitpunkt, zu dem die Ausgabe mit Write(Ln) mit Lst-Parameter erfolgt, druckt der Drucker den Text. Der Drucker druckt immer nur die Zeile sofort, die an ihn geschickt wird. Voraussetzung ist natürlich, dass der Drucker eingeschaltet ist. Glücklicherweise wirft der Drucker nicht sofort nach dem Drucken dieser einen Zeile die Seite aus, sondern wartet, bis der Benutzer den Auswurf manuell durchführen lässt. Hierfür gibt es auf einem Drucker eine Taste, die für den manuellen Seitenvorschub gedacht ist. Drücken Sie diese Taste, wirft der Drucker die gerade eingezogene Seite aus. Bitte kurz drücken, denn manche Drucker drucken bei längerem Betätigen der Taste sonst ein Testbild.