PurePascal (2)

Nachdem im ersten Teil dieses Kurses die Grundelemente gezeigt wurden, soll dieser Teil kurz den Umgang mit PurePascal und die Programmstrukturen von Pascal zeigen.

Der Umgang mit PurePascal

Da dieser Kurs sich hauptsächlich auf das Erlernen der Programmiersprache bezieht und nicht auf den Umgang mit dem Programm, möchte ich in diesem Kapitel nur kurz die wichtigsten Teile von PurePascal erwähnen, die während des Kurses benötigt werden. Für alle anderen Funktionen ist es ratsam, sich zumindest das erste Kapitel des dem Programm beiliegenden Benutzerhandbuches durchzulesen.

Nach dem Starten von PurePascal (unter MagiC im Single-Task) landet man auf dem programmeigenen Desktop (Abbildung 3).

Auf hellgrünen Grund sind am linken Bildschirmrand die Laufwerkicons plaziert. Mit ihnen kann man sich durch die Verzeichnisse seiner Laufwerke "wühlen". Außerdem befindet sich dort der Mülleimer, mit dem sich Dateien löschen lassen. Im Menü "File" befinden sich die für uns wichtigen Einträge "New File..." und "Save" und im Menü "Run" der Eintrag "Run".

Nach dem Öffnen eines Laufwerkfensters (in Abbildung 3 links zu sehen) über eines der Icons und dem auswählen des Pfades, in dem man seine Datei speichern möchte, lässt sich über den Menüeintrag "New File..." (Control + N) der Editor öffnen (Abbildung 3 oben). Die Datei mit dem dort eingegebenen Namen sollte die Endung ".pas" für Pascal haben und wird erst nach dem Speichern über den Menüeintrag "Save" (Control + S) angelegt. In dem Texteditor kann nun fleißig mit dem Eingeben des Programmcodes begonnen werden. Aber so weit sind wir ja noch nicht. Um noch drei weitere Funktionen von PurePascal zu erläutern, geben Sie bitte den folgenden Text in den Editor ein: (siehe Listing 1).

Ist der Text eingegeben worden, sollten Sie ihn zuerst mit der Tastenkombination Control + S speichern. Danach betätigen Sie die Tastenkombination Alternate + R für den Menüeintrag "Run". Jetzt wird das Programm gestartet. Sie sehen auf dem Bildschirm den Text "Programm wiederholen? j/n" solange, bis Sie das kleine "n" eingeben und die Eingabetaste drücken. Nachdem das Programm dann abgebrochen wurde, können Sie sich die Bildschirmausgabe nochmals durch Betätigen von ESCape ansehen. Durch erneutes Betätigen von ESCape gelangen Sie wieder zum normalen Bildschirm zurück. Eine sehr nützliche Funktion von PurePascal ist die Hilfefunktion, zu der Sie durch Betätigen der HELP-Taste gelangen. Steht der Cursor zu dem Zeitpunkt der Betätigung in einem Anweisungstext, so wird eine Hilfe zu der jeweiligen Anweisung angezeigt (Abbildung 3, rechts unten, Hilfe für die repeat-Anweisung).

Nachdem Sie nun wissen, wie Sie den Editor öffnen, eine Pascal-Datei speichern, ein Pascal-Programm starten, sich die Bildschirmausgabe erneut ansehen und zur Hilfefünktion gelangen, möchte ich das obige Beispiel kurz erläutern.

Bei der ersten Zeile handelt es sich um dem Programmkopf, gefolgt von dem Deklarationsteil, in dem zuerst die Unit crt eingebunden und dann die globale Variable "Antwort" deklariert wird. Units sind Dateien, d.h. Bibliotheken, in denen sich vorgefertigte Prozeduren und Funktionen (mehr dazu im Kapitel 5) befinden, die man nach dem Einbinden mit dem Schlüsselwort uses und dem Unitnamen in seinen Programmen benutzen kann. In dem Beispielprogramm benötigt die Clr-Scr-Funktion, die den Bildschirm löscht, diese Unit. Nach der Deklaration der Variablen "Antwort" (Datentyp char, Kapitel 2.3.2) beginnt das Hauptprogramm. Wie bereits geschrieben, wird das Hauptprogramm mit dem Schlüsselwort begin eingeleitet und dem Schlüsselwort end, gefolgt von einem Punkt, beendet. Zu der re-peat-Anweisung, zu der auch das until gehört, folgt in Kapitel 4 mehr. Die Anweisung gotoxy(10,24) setzt den Cursor auf den Bildschirm in Spalte 10 und Zeile 24. Die Anweisung lautet folglich got-oxy(Spalte, Zeile). Genauer eingehen möchte ich nun auf die write- und die read-Anweisung:

Program Addition;
uses crt;
{ Globale Variablen deklarieren: }
var Antwort : char;
begin
repeat
ClrScr;
gotoxy (10,24) ;
write('Programm wiederholen? j/n ');
readln( Antwort );
until Antwort = 'n';
end.

Ein- und Ausgabe

Eine Eingabe ist ein Datentransfer vom Anwender, Datenträger oder von anderen Peripheriegeräten zum Rechner. Eine Ausgabe beschreibt die umgekehrte Richtung, also den Datenfluß vom Rechner zur Peripherie, z.B. zum Bildschirm, Drucker oder zum Datenträger.

Im allgemeinen benutzt der Compiler - er übersetzt den vom Programmierer eingegebenen Text in ein ausfuhrbares Programm - die bekannten Funktionen des Betriebssystems, um Daten vom Programm an die angeschlossene Hardware zu übergeben oder von dieser zu übernehmen.

In Pascal werden die Ausgaben mit write und writeln programmiert. Dabei wird nach writeln ein Zeilenvorschub ausgelöst, während bei write hinter der Ausgabe weitere Ein- oder Ausgaben stattfinden können.

Beispiele:
write ( Variable ) ;
writeln ('Text auf Bildschirm ausgeben', Variable);
writeln;

write ist eine Prozedur mit einer variablen Anzahl von Parametern. Mehr zu den Parametern in einem späteren Kapitel. Vorerst reicht es zu wissen, mit welcher Anweisung ein Text oder ein Variableninhalt auf dem Bildschirm ausgegeben wird.

Die Eingabe von Daten erfolgt mit den Prozeduren read oder readln. Als Parameter werden die Variablen genannt. Mit readln wird nach der Übernahme der Eingabedaten ein Zeilenvorschub ausgelöst.

Beispiele:
read (Taste);
readln (Alter);

In einigen Fällen kann es dazu kommen, dass die read-Anweisung vom Programm übersprungen wird, weshalb sich in der Praxis die Kombination aus write und readln bewährt hat. Zu einem guten Programmierstil gehört es, die einzulesenden Daten einzeln abzufragen. Das entlastet den Anwender und den Programmierer und erhöht die Sicherheit erheblich.

  1. Kontrollstrukturen

Kontrollstrukturen sind Anweisungen, die die Abarbeitungsabläufe im Programm steuern. Es sind strukturierte Anweisungen, die aus mehreren bedingt oder wiederholt ausgeführten Anweisungen bestehen.

4.1 Entscheidungen

Entscheidungen sind bedingte Anweisungen, die den Programmablauf auf einen von zwei oder mehreren Wegen steuern.

Welcher Weg im Ablauf benutzt wird, hängt von der Bedingung ab, die so formuliert ist, dass sie eindeutig mit ja oder nein bzw. mit wahr oder falsch beantwortet werden kann. In der Programmiersprache Pascal gibt es zwei Typen von bedingten Anweisungen, die if-Anweisung und die case-Anweisung, auch Alternative und Fallunterscheidung genannt.

4.1.1 Alternativen

Wie der Name dieser Kontrollstruktur schon sagt, bietet diese Anweisung zwei alternative Programmwege. In Abbildung 4 ist das Struktogramm-Symbol nach Nassi-Shneidermann für Alternativen zu sehen. In der Alternative wird die Antwort der Bedingung abgeprüft. Ist die Antwort "Ja", wird der "Ja"-Weg, ansonsten der "Nein"-Weg benutzt. Da Strukto-gramme immer von oben nach unten abgearbeitet werden, ist zu sehen, dass das Programm nur einen der beiden Wege benutzen kann - entweder den "Ja"- oder den "Nein"-Weg. Werden die Anweisungen, im "Ja"-Weg abgearbeitet, so wird der "Nein"-Weg übersprungen und umgekehrt. Für den Fall, dass für die Bedingung nur einer der zwei Wege benötigt wird, so kann der "Nein"-Weg auch weggelassen werden.

In Pascal umgesetzt besteht die if-Anweisung aus folgendem Aufbau:

if Bedingung then
Anweisung {Ja-Weg}
else
Anweisung; {Nein-Weg}

Die Anweisung für eine Alternative beginnt mit dem Schlüsselwort if, gefolgt von der Bedingung, die einen Vergleich mit Hilfe der Vergleichsoperatoren (Heft 4/99, Tabelle 3) durchfuhrt und dem Schlüsselwort then. Danach folgt die Anweisung für den "Ja"-Weg. Nach dem Schlüsselwort eise folgt die Anweisung für den "Nein"-Weg. Wie im ersten Teil geschrieben, ist darauf zu achten, dass Anweisungen mit einem Semikolon abgeschlossen werden. Da die Anweisung in diesem Fall aber die Alternative ist, darf hinter der Anweisung im "Ja"-Weg kein Semikolon stehen. Für den Fall, dass der "Nein"-Weg nicht benötigt wird, so lässt man einfach das einleitende Schlüsselwort eise sowie die Anweisung weg und schließt die Anweisung im "Ja"-Weg mit einem Semikolon ab.

Der soeben geschilderte Aufbau enthält für jeden Weg nur maximal eine Anweisung. Möchte man aber eine Sequenz (mehrere Anweisungen) in einen oder beide Wege einbauen, so muss die Sequenz von den Schlüsselworten begin und end eingefaßt sein:

if Bedingung then begin
Anweisung; Anweisung;
end
else
begin
Anweisung; Anweisung;
end;

Wichtig ist, dass hinter dem begin sowie hinter der letzten Anweisung vor dem Schlüsselwort eise (hier das Schlüsselwort end) ebenfalls kein Semikolon stehen darf! Fehlt der "Nein"-Weg, so steht hinter dem end ein Semikolon. Die Sequenzen und Anweisungen können ebenfalls Alternativen enthalten. Da eine Alternative als EINE Anweisung gilt, ist bei der Verwendung auf die zu setzenden bzw. nicht zu setzenden Semikolons zu achten. Beispiele für Alternativen (die Deklaration der verwendeten Variablen ist in dem Beispielen nicht enthalten) (Listing 2):

1.
if Zahl < 100 then
writeln('Die Zahl ist kleiner 100!') else
writeln('Die Zahl ist größer oder gleich 100!');

2.
if Antwort = 'j' then
writeln('Sie haben mit (j)a geantwortet!');

3.
if Preis <= 500 then begin
writeln('Der Preis ist kleiner oder gleich 500!'); Porto := 5; end else
begin
writeln('Der Preis ist größer 500!'); Porto := 3; end;

4.1.2 Fallunterscheidungen

Für die Alternative hat man nur zwei Wege zur Verfügung. Reichen diese nicht aus, müssen Verschachtelungen vorgenommen werden, die schnell unübersichtlich werden. Mit Hilfe der Fallunterscheidungen kann eine wichtige Vereinfachung eingesetzt werden. Hier wird der Inhalt einer Variablen mit den vorgegeben Fällen verglichen und der entsprechende Weg benutzt. Trifft keiner der vorgegeben Fälle zu, wird der "Sonst"-Fall und dessen Weg benutzt. Der Nachteil der Fallunterscheidungen ist allerdings, dass die Vergleichsvariablen nur vom Typ Integer, Short, Byte oder Word sein dürfen, d.h. auch keine Werte mit Nachkommastellen verglichen werden können. Die Abbii düng 5 zeigt das Struktogramm^Syrabol für eine Fallunterscheidung mit drei Wegen, auf die ich mit im folgenden beziehen werde. Im Prinzip sind aber nur durch den Speicher begrenzt viele Wege möglich.

In Pascal umgesetzt besteht die case-Anweisung aus folgendem Aufbau:

case Variable of Wert l:
Anweisung; {Fall 1} Wert2, WertS:
Anweisung; {Fall 2} eise
Anweisung; {Sonst} end;

Die Anweisung für eine Fallunterscheidung beginnt mit den Schlüsselwort case, gefolgt von einer Variablen (Datentyp: Integer, Short, Byte oder Word), deren Inhalt verglichen wird und dem Schlüsselwort of. In der nächsten Zeilen folgen die einzelnen Fälle mit jeweils dem gleichen Aufbau: Dem zu vergleichendem Wert (Zahl oder Zeichen, siehe Beispiele), es können auch mehrere,' durch ein Komma getrennte Werte sein, folgt nach einem Doppelpunkt in der nächsten Zeile die auszuführende Anweisung. Als letzter Fall folgt ohne Wert und Doppelpunkt der "Sonst"-Fall, der gefolgt von der Anweisung mit dem Schlüsselwort eise eingeleitet wird und auch entfallen kann, wenn er nicht benötigt wird. Abgeschlossen wird die Fallunterscheidung mit dem Schlüsselwort end, gefolgt von einem Semikolon. Auch hier können, wenn eine Anweisung nicht ausreicht, Sequenzen verwendet werden. Im Gegensatz zu der Alternative werden bei der Fallunterscheidung alle Anweisungen (Ausnahme ist immer das Schlüsselwort begin) mit einem Semikolon abgeschlossen.

for Laufvariable := Startwert to Endwert do Anweisung;

oder

for Laufvariable := Startwert downto Endwert do begin

Anweisung; Anweisung; end;

1.

for Index := 1 to 10 do Write(Index:2, ' ');
for Zahl := Anfang downto Ende do begin
Zahll := Wert * Wert;
Zahl2 := Zahll * Wert;
Zahl3 := Zahl2 * Wert;
writeln(Zahll, Zahl2, Zahl3);
end;

4.2 Wiederholungen

In vielen Algorithmen werden Anweisungen mehrfach wiederholt. Mit den Anweisungen für Wiederholungen kann der Programmieraufwand wie auch der Speicherplatzbedarf klein gehalten werden. Die zugehörigen Struktogramm-Symbole können in der Programmiersprache Pascal direkt codiert werden. Für Wiederholungen oder Schleifen gibt es drei Anweisungen. Die for-Anweisung wird eingesetzt,' wenn schon vorher bekannt ist, wie oft wiederholt werden soll. Für alle anderen Fälle sind die while- oder die re-peat Anweisung einzusetzen. Die repeat-Anweisung ist im Gegensatz zur for- und while-Anweisung eine fußgesteuerte Schleife.

4.2.1 Kopfgesteuerte Schleifen

Die kopfgesteuerte Schleife definiert die Wiederholungseigenschaft der Schleife vor der auszuführenden Anweisung oder vor dem Anweisungsblock. Die for- und die while-Anweisung bilden genau die Darstellung im Struktogramm.

4.2.1.1 Schleife mit fester Anzahl der Schleifendurchläufe

Mit der for-Schleife ist die Möglichkeit realisiert, mit einem Start- und einem Endwert die Anzahl der Durchläufe festzulegen. Der Start- und der Endwert müssen beide ganzzahlig sein. Der Schleifendeklaration folgt die Anweisung oder die Sequenz. Der Startwert wird einer sogenannten Laufvariablen zugewiesen, die mit jedem Lauf ihren Wert verändert. Sie wird je nach Steuerung inkrementiert (um 1 erhöht) oder dekrementiert (um l verringert). In Pascal umgesetzt besteht die for-Anweisung aus folgendem Aufbau (siehe Listing 3).

Die Anweisung für die for-Schleife wird mit dem Schlüsselwort for begonnen. Ihr folgt die Laufvariable, die im Deklarationsteil mit einem ganzzahligen Datentypen deklariert wurde. Nach dem Zuweisungszeichen (Doppelpunkt und Gleichheitszeichen) folgt der ganzzahlige Startwert, der entweder eine Zahl oder Variable sein kann. Es folgt das Schlüsselzeichen to für Aufwärtszählen oder downto für Abwärtszählen. Gezählt wird jeweils in Einer-Schritten. Als nächstes in der Zeile steht der ganzzahlige Endwert, der ebenfalls eine Zahl oder eine Variable sein kann und das Schlüsselwort do. In die nächste Zeile wird die Anweisung oder die Sequenz geschrieben.

Beispiele für eine for-Schleife (im ersten Beispiel werden die Zahlen l bis 10 durch ein Leerzeichen getrennt ausgegeben, das zweite probieren sie einfach mal selber aus.):

4.2.1.2 Schleife mit Abfrage vor der Ausführung

Ist vor der Ausführung der Schleife und den möglichen Wiederholungen erst noch abzuklären, ob sie durchlaufen werden soll oder nicht, so kann mit der for-Anweisung nicht gearbeitet werden. Hier wird die while-Schleife eingesetzt. Im Schleifenkopf wird über einen Ausdruck abgefragt, ob die Schleife abgearbeitet werden soll. Nach jedem Durchlauf wird die Bedingung wieder überprüft.

In Pascal umgesetzt besteht die while-Anweisung aus folgendem Aufbau:

while Bedingung do Anweisung;

Die while-Anweisung beginnt mit dem Schlüsselwort while, gefolgt von der Bedingung, die einen Vergleich mit Hilfe der Vergleichsoperatoren durchführt und dem Schlüsselwort do. Danach folgt dann die Anweisung oder die Sequenz. Die Sequenz wird nur dann abgearbeitet, wenn die Bedingung wahr ist, d.h. wenn sie mit ja beantwortet werden kann. Wird die Bedingung während des Abarbeitens der Anweisung oder der Sequenz falsch, so wird sie nicht mehr abgearbeitet. Das Programm wird dann mit der ersten Anweisung hinter der while-Anweisung fortgesetzt.

Beispiele für eine while-Schleife (siehe Listing 5).

Im ersten Beispiel wird die Schleife solange durchlaufen, solange der Inhalt der Variablen "Index" kleiner 100 ist. Da der Inhalt vor Schleifenbeginn auf Null gesetzt und er in jedem Durchlauf um 1 erhöht wird, wird die Schleife genau lOOmal durchlaufen. Im zweiten Beispiel wird über die Tastatur ein Wert eingegeben und die while-Schleife mit Wiederholung der Eingabe solange wiederholt, bis der Wert gleich oder größer 1000 ist.

4.2.2 Fußgesteuerte Schleifen

Bei der fußgesteuerten Schleife findet die Überprüfung, ob ein weiterer Schleifenlauf stattfindet, erst am Ende der Schleife statt. Zum Zeitpunkt der Überprüfung ist die Schleife im Gegensatz zur while-Schleife also schon einmal durchlaufen. Die fußgesteuerte Schleife, die repeat-An-weisung, kann folglich nur da eingesetzt werden, wo immer ein Durchlauf erwünscht ist und weitere Durchläufe nach Prüfung der Abbruchbedingung erfolgen sollen.

In Pascal umgesetzt besteht die repeat-Anweisung aus folgendem Aufbau:

repeat
   Anweisung; 
   Anweisung; 
until Bedingung;

Die repeat-Anweisung beginnt mit dem Schlüsselwort repeat. Ihm folgen ohne be-gin und end die auszuführenden Schleifen-Anweisungen. Abgeschlossen wird die repeat-Anweisung mit dem Schlüsselwort until und der Bedingung, die wie in der while-Schleife mit Hilfe der Vergleichsoperatoren durchgeführt wird. Ist die Bedingung wahr, so wird die Schleife mit der Anweisung nach dem repeat fortgesetzt, ist sie falsch, wird die nächste Anwendung ausgeführt.

Das folgende Beispiel für eine repeat-Schleife macht, mit Ausnahme der Meldung "Eingabefehler!", das gleiche, was das zweite Beispiel der while-Schleife macht:

repeat
   write('Bitte geben Sie die Kennziffer ein: ');
   readln (Kennziffer); 
until Kennziffer >= 1000;

Wie zu sehen ist, lässt sich mit weniger Schreibarbeit auf einem anderen Weg der gleiche Effekt erzielen.

Im nächsten Teil dieser Reihe folgen mit der Umsetzung von Nassi-Shneidermann-Struktogrammen weitere Beispiele zu dem bisher Erlernten.

l.
Index := 0
while Index < 100 do Index := Index +1;

2. write('Bitte geben Sie die Kennziffer ein: '); readln(Kennziffer); while Kennziffer < 1000 do begin writeln('Eingabefehler! '); write('Bitte geben Sie die Kennziffer erneut ein: '); readln(Kennziffer); end;


Torsten Runge
Links

Copyright-Bestimmungen: siehe Über diese Seite
Classic Computer Magazines
[ Join Now | Ring Hub | Random | << Prev | Next >> ]