Informatik Sekundarstufe II

Städtische Gesamtschule Duisburg-Hamborn/Neumühl

August 2000

1 Einleitung *

2 Grundlagen *

3 Anweisungen und Kontrollstrukturen *

4 Selbstdefinierbare Datentypen *

5 Funktionen und Prozeduren *

1. Einleitung

Die Programmiersprache Pascal wurde an der Eidgenössischen Technischen Hochschule Zürich unter der Leistung von Nikolaus Wirth um das Jahr 1970 entwickelt. Eine Programmiersprache ist eine Sprache, in der man einem Computer einen Algorithmus mitteilt.

Ein Algorithmus ist ein Verfahren zur systematischen, schrittweisen Lösung eines Problems.

2. Grundlagen

In diesem Abschnitt sollen zunächst einmal die Grundlagen des Aufbaus von Pascalprogrammen angegeben werden. Dabei wird zuerst der Aufbau eines sehr einfachen Programms betrachtet und im folgenden der Aufbau eines Aufwendigen, komplexen Pascal-Programms.

1. Aufbau eines einfachen Pascal-Programms

Ein Pascal-Programm besteht im Wesentlichen aus drei Teilen, einem Programmkopf, einem Deklarationsteil und einem Anweisungsteil.

Im Programmkopf wird der Programmname zur Identifizierung des Programms eingetragen. Dieser Programmname kann frei gewählt werden und muß nur den Anforderungen für die Schreibweise von Bezeichnern entsprechen.

Im Deklarationsteil werden die Variablen vereinbart, indem Variablenname (Bezeichnername) und datentyp festgelegt werden.

Im Anweisungsteil des Pascalprogramms stehen die eigentlichen Anweisungen des Algorithmus als Pascal-Befehle.

Kommentare erleichtern das Verständnis des Pascal-Programms und werden in geschwungenen Klammern notiert. Es wird empfohlen, wichtige Programmteile wie z.B. Variablendeklarationen, Anfang (begin) und Ende (end;) von Blöcken, Prozeduren, komplizierte Anweisungen und Berechnungen und "Programmiertricks" zu kommentieren.

Ein Beispiel soll dies verdeutlichen.

program KleinesEinMalEins;

uses wincrt; {Unit für Windows-Fenster}

var i : integer; {Zählvariable bzw. Muliplikand}

j : integer; {Zählvariable bzw. Multiplikator}

begin {Hauptprogramm}

for i:=1 to 10 do

begin

for j:=1 to 10 do

begin

writeln(i,' * ',j,' = ',i*j)

end; {for j}

end;{for i}

end. {Hauptprogramm}

 

3. Aufbau eines komplexen Pascal-Programms

1. Variablen und Datentypen

Eine Variable besteht aus den drei Komponenten Name, Inhalt und Datentyp:

	Beispiel 1	Beispiel 2	Beispiel 3	Beispiel 4
Name	otto	theo	MeinName	ErsterBuchstabe
Inhalt	3	3. 5	‚otto‘	‚x‘
Datentyp	Integer (ganze Zahl)	Real (reele Zahl)	String (Zeichenkette)	Char (Zeichen)

2. Variablendeklaration

1. Anweisungen und Kontrollstrukturen

In diesem Abschnitt werden Anweisungen und Kontrollstrukturen der Programmiersprache Pascal beschrieben, die den Programmablauf steuern.

1. Eingabeanweisungen

Mit den Pascal-Anweisungen read(_) und readln(_) ist es möglich, Variablenwerte einzulesen.

VAR a : integer;

begin

read(a); {bewirkt, dass nach der Eingabe von a der Cursor }

{hinter der Eingabe steht.}

readln(a); {bewirkt, dass nach dem Eingabe von a der Cursor in der}

{nächsten Zeile steht}

end;

2. Ausgabeanweisungen

Mit den Pascal-Anweisungen write(_) und writeln(_) ist es möglich, Variablenwerte auf dem Bildschirm auszugeben.

VAR a : integer;

begin

write(a); {bewirkt, dass nach der Ausgabe von a der Cursor }

{hinter der Ausgabe steht.}

writeln(a); {bewirkt, dass nach dem Ausgabe von a der Cursor in der}

{nächsten Zeile steht}

end;

 

3. Die Zuweisung

Die Zuweisung oder auch Wertzuweisung genannt ist der Befehl zur Zuweisung eines aus einem Ausdruck zu ermittelnden Werts an eine Variable. Die Syntax der Zuweisung lautet:

Variablenbezeichner := Ausdruck;

Der Ausdruck auf der rechten Seite des Zuweisungsoperators := wird zuerst ausgewertet und dann wird diese Wert an die Varaible auf der linken Seite übergeben. Der angegebene Name der Variablen muß im Deklarationsteil definiert worden sein. Der Zuweisungsoperator wird syntaktisch wie ein Zeichen behandelt. Der Datentyp des Ausdrucks auf der rechten Seite muß mit dem Datentyp der Variablen auf der linken Seite übereinstimmen.

4. Die bedingte Anweisung (if...then...else)

Die bedingte Anweisung ermöglicht die Ausführung verschiedener alternativer Programmblöcke in Abhängigkeit von der Auswertung eines logischen Ausdrucks. Syntax:

IF <Bedingung> THEN

BEGIN

Anweisungsblock Alternative 1

END

ELSE

BEGIN

Anweisungsblock Alternative 2

END;

Der sogenannte ELSE-Fall (Sonst-Fall) kann dabei entfallen. Besteht der jeweilige Anweisungsblock nur aus einem einzelnen Befehl, so kann die Schachtelung mit BEGIN und END entfallen.

1. Geschachtelte Fallunterscheidungen

Bedingte Fallunterscheidungen mit if...then...else können selbstverständlich auch geschachtelt werden, wie das folgende Beispiel zeigt.

IF a<30 then

if a<20 then writeln('a ist kleiner als 20')

else writeln('a liegt zwischen 20 und 30')

else

writeln('a ist größer oder gleich 30');

2. Die Case-Anweisung

Die Case-Anweisung erlaubt die Auswahl genau einer von mehreren alternativen Anweisungen in Abhängigkeit vom Wert eines Ausdrucks z.B.:

Type farbe = (rot,blau,gruen,gelb,weiss);

CASE farbe OF

weiss : writeln('Weiß');

rot : writeln('Rot');

gruen : writeln('Grün');

end;

5. Wiederholungen (Schleifen)

Wiederholungen sind Kontrollstrukturen, die die wiederholte Ausführung eines Anweisungsblocks ermöglichen.. In der Programmiersprache Pascal stehen zwei Schleifen mit Abbruchbedingungen (repeat...until und while...do) und eine Zählschleife (for...to...do) zur Verfügung.

1. Die for-Schleife

Mit der for-Schleife ist die Wiederholung eines Anweisungsblocks für eine zu Beginn der Wiederholung feststehende Anzahl an aufeinanderfolgenden Werten eine sogenannten Zählvariablen möglich:

anfang := 1;

ende := 10;

for i:=anfang to ende do

begin

for j:=anfang to ende do

begin

write('*');

end;

writln;

end;

Die Zählvariablen der for-Schleifen können innerhalb des Schleifenrumpfes benutzt werden, sollten dort aber auf keinen Fall in ihrem Wert verändert werden.

Var a : array [1..10] of integer;

i : integer;

for i:=1 to 10 do begin

writeln(a[i]);

end;

2. Die repeat-Schleife

Die repat...until-Schleife ist eine Schleife, bei der der Schleifenrumpf zuerst durchlaufen wird, bevor die Abbruchbedingung überprüft wird. Deshalb erfolgt bei dieser Schleife mindestens ein Durchlauf des Schleifenrumpfes.

Repeat

Writeln('Hauptmenü');

Writeln('(E) Eingabe der Daten');

Writeln('(A) Ausgabe der Daten');

Writeln('(B) Berechnung der Funktion');

Writeln('(X) Programm beenden);

Readl(eingabe);

CASE eingabe of

'E' : Eingabe; {Prozeduraufrufe}

'A' : Ausgabe;

'B' : Berechnung;

end; {case}

until eingabe='X';

3. Die while-Schleife

Die while...do-Schleife ist eine Schleife, bei der zuerst die Abbruchbedingung überprüft wird, bevor der Schleifenrumpf durchlaufen wird. Deshalb kann in Abhängigkeit von der Bedingung bei dieser Schleife ein Durchlauf des Schleifenrumpfes auch gar nicht erfolgen.

While x<y do

begin

y := y-1;

x := x-1;

end;

Aufgabe: Für welche Werte von x und y arbeitet das Programmstück korrekt?

2. Selbstdefinierbare Datentypen
1. Der Aufzählungstyp

Mit dem Schlüsselwort TYPE kann man einen Aufzählungstyp definieren. (Die Deklaration von selbstdefinierten Datentypen erfolgt vor der Variablendeklaration mit dem Schlüsselwort VAR):

TYPE spielfarbe = (karo,herz,pik,kreuz);

farbe = (rot,blau,gelb,gruen);

Entsprechend können dann Variablen von diesem Typ deklariert werden:

VAR trumpf : spielfarbe;

grundierung : farbe;

Damit sind dann Anweisunge der folgenden Form möglich:

IF trumpf = herz then writeln('kontra');

 

2. Der Ausschnittstyp

TYPE wochentag = (mon,die,mit,don,fre,sam,son); {Aufzählungstyp}

werktag = mon..fre;

wochenende = sam..son;

 

3. Der Set-Typ

TYPE zutaten = (zucker, mehl, sahne, honig, mandeln);

nachtisch = set of zutaten;

4. Der Array-Typ (Datentyp Feld)

Ein Array ist die Zusammenfassung einer festen Anzahl von Elementen des gleichen Datentyps. Die Deklarierung soll an einem Beispiel erklärt werden.

VAR zahlenfolge : array [1..10] of integer;

1	2	3	4	5	6	7	8	9	10
13	22	15	100	200	300	11	144	32	0

 

Arrays können als Elemente, Objekte beliebigen Typs haben. So ist zum Beispiel folgende Deklaration möglich:

TYPE person = RECORD

name : string;

vorname : string;

END;

personenliste = ARRAY [1..100] of person;

5. Der record-Typ (Verbunddatentyp)

Der Verbunddatentyp stellt eine sehr elegante Möglichkeit dar, Informationen zu einem strukturierten Datentyp zusammenzufassen. Dadurch ist es möglich sehr komplexe Datenstrukturen zu entwickeln und komfortabel mit ihnen zu arbeiten.

TYPE Zeit = RECORD

Stunde : integer;

Minute : integer;

END;

Nach der Typdeklaration kann man verschiedene Variablen dieses Typs deklarieren.

VAR MeineZeit : Zeit;

DeineZeit : Zeit;

Zugriff auf die Komponenten der jeweiligen Variable erhält man über den sogenannten 'Punktoperator

MeineZeit.Stunde := 12;

MeineZeit.Minute := 30;

Erleichtert wird der Umgang mit Verbunddatentypen durch die with-Anweisung.

with MeineZeit do begin

Stunde := 12;

Minute := 30;

end;

3. Funktionen und Prozeduren

Funktionen und Prozeduren stellen Möglichkeiten dar, ein umfangreiches Programm in sinnvolle Einheiten zu unterteilen und inhaltlich zusammengehörige Vorgänge in einem Programmblock zusammenzufassen.. Programm gewinnen durch die Verwendung von Funktionen und Prozeduren deutlich an Übersichtlichkeit. Zudem verringert sich die Fehleranfälligkeit. Außerdem ist die Wiederverwendbarkeit der Prozeduren und Funktionen von großer Bedeutung. Dadurch werden Programm um vieles kürzer.

1. Funktionen

Eine Funktion ist ein Unterprogramm, das einen Rückgabewert liefert.

function quadrat(x : integer):integer;

begin

quadrat := x * x;

end;

Der Aufruf der Funktion erfolgt dann mit Hilfe ihres Funktionsnamens und der Übergabe der Parameter.

ErsteZahl := 2;

ergebnis := quadrat(ErsteZahl);

writeln(ergebnis);

ZweiteZahl := 4;

writeln(quadrat(ZeiteZahl));

2. Rekursive Funktionen

Eine Funktion, die sich selbst aufruft wird rekursive Funktion genannt.

function pot(a,n:integer):integer;

begin

if n=0 then pot := 1

else pot := pot(a,n-1) * a;

end;

3. Prozeduren

Prozeduren sind Unterprogramme die dazu dienen können immer wiederkehrende Vorgänge zusammenzufassen oder ein größeres Programmprojekt in überschaubare Einzelteile (Module) zu zerlegen.

procedure hauptmenue(KundenName:string);

var eingabe;

begin

Repeat

Writeln('Hauptmenü');

Writeln('(E) Eingabe der Daten');

Writeln('(A) Ausgabe der Daten');

Writeln('(B) Berechnung der Funktion');

Writeln('(X) Programm beenden);

Writeln('Sehr geehrte/r Frau/Herr ',Kundenname,' bitte wählen Sie!');

Readl(eingabe);

CASE eingabe of

'E' : Eingabe;

'A' : Ausgabe;

'B' : Berechnung;

end; {case}

until eingabe='X';

end; {procedure hauptmenue}

Prozeduren werden über ihren Prozedurnamen aufgerufen. Angenommen die Prozeduren 'Begruessung', 'Verabschiedung' und die oben dargestellte Prozedur 'Hauptmenue' seien bereits deklariert, dann kann das Hauptprogramm wie folgt sehr übersichtlich aussehen.

begin {Hauptprogramm}

Begruessung;

hauptmenue(Name);

Verabschiedung;

end. {Hauptprogramm}

4. Rekursive Prozeduren