Programmieren in Pascal

Programmieren in Pascal
1. Vorraussetzungen für
TurboPascal
●
Probleme mit Turbo
Pascal 7.0
2. Kapitel: Einführung
●
●
●
●
●
●
●
Allgemeine
Programmstruktur
Grundbegriffe
Bezeichner
Reservierte Wörter
Vereinabrung von
Variablen
Vereinbarung von
Konstanten
Befehle der Unit Crt
3. Kapitel: Datentypen
●
●
●
●
●
●
●
●
●
Übersicht der Datentypen
in TP
Einfache Datentypen
Der Datentyp Integer
Der Datentyp Real
Der Datentyp String
Standardroutinen für den
Datentyp String
Aufzählende Datentypen
Teilbereichstypen
Explizite und implizite
Typenvereinbarung
4. Kapitel: Bedingungen
●
Die IF - Entscheidung
Problembehebung bei Turbo
Pascal 7.0
Da Turbo Pascal 7.0 ein MS DOS Programm ist,
muss es auf das jeweilige System bzw. die
jeweiligen Pathangaben (Verzeichnisangaben)
eingestellt werden. Deshalb kann es zu Problem
kommen, sollte dies der Fall sein befolgen Sie die
folgenden Schritte um Turbo Pascal 7.0 auf Ihrem
System einzurichten:
1. Downloaden Sie die gepackte Datei von
Turbo Pascal 7.0 (Hier geht's zum
Download).
2. Legen Sie ein Verzeichnis auf Ihrer
Festplatte an, zum Beispiel C:\Turbo.
3. Starten Sie die heruntergeladene Datei und
geben Sie als Zielverzeichnis das von Ihnen
erstellte Verzeichnis an.
4. Nach Beendigung des Vorgangs, wechseln
Sie in das von Ihnen erstellte Verzeichnis
und klicken mit der rechten Maustaste auf
die Datei Turbo.exe. Im erscheinenden
Kontextmenü wählen Sie den Eintrag
Eigenschaften.
5. Es öffnet sich ein Fenster in dem Sie zur
Registerkarte Programm wechseln.
6. Dort können Sie einige Einstellungen
vornehmen. In dem Feld Befehlszeile tragen
Sie den Path in dem sich Turbo Pascal
befindet plus den Dateinamen Turbo.exe ein
(z.B. C:\turbo\turbo.exe).
file:///E|/homepage/Pascal/index.htm (1 of 3) [07.10.2001 00:28:26]

Programmieren in Pascal
●
Die CASE - Entscheidung
5. Kapitel: Schleifen
● Die REPEAT / UNTIL -
Schleife
● Die FOR - Schleife
● Die WHILE - Schleife
6. Kapitel: Unterprogramme
●
●
Grundwissen
Globale und lokale
Bezeichner
7. Kapitel: Prozeduren
7. In dem Feld Arbeitsverzeichnis geben Sie
nur das Verzeichnis in dem sich Turbo
Pascal befindet ein (z.B. C:\turbo).
8. Jetzt bestätigen Sie die Eingaben durch
einen Klick auf den OK-Button. Das Fenster
wird geschlossen.
9. Starten Sie jetzt Turbo Pascal mit der Datei
Turbo.exe.
10. Wählen Sie im Menü Option den Eintrag
Verzeichnisse aus.
11. Hier ändern Sie die Werte EXE/TPU -
Verzeichniss (BSP: C:\Turbo) und UNIT -
Verzeichniss (BSP: C:\Turbo\Units) in die
von Ihnen erstellten Verzeichnisse um.
●
●
●
●
Grundstruktur einer
Prozedur
Prozeduren ohne
Werteparameter
Prozeduren mit
Werteparameter
Prozeduren mit
Variablenparameter
12. Ist dies erfolgt schließen Sie das Fenster und
wählen in dem Menü Option den Eintrag
Speichern Turbo.TP
13. Jetzt können Sie, hoffentlich, einwandfrei mit
Turbo Pascal arbeiten.
Download TP 7.0 Allg. Programmstruktur
8. Kapitel: Funktionen
●
●
Grundstruktur einer
Funktion
Funktionen
9. Kapitel: Strukturierte
Datentypen
●
●
●
●
Grundlagen
Arrays
Records
Mengen
❍ Deklaration
❍ Wertzuweisung
❍ Mengenoperationen
❍ Wertausgabe
❍ Mengen verändern
10. Kapitel: Dateiverarbeitung
file:///E|/homepage/Pascal/index.htm (2 of 3) [07.10.2001 00:28:26]

Programmieren in Pascal
●
●
●
●
●
●
Grundlagen
Datei öffnen bzw. anlegen
In eine Datei schreiben
Aus einer Datei lesen
Datensatzzeiger
Datensatz löschen
11. Kapitel:
Befehlsverzeichniss
●
Anweisungen
12. Kapitel:
Programmbeispiele
●
●
Einfache
Programmbeispiele
Kaufmännische
Programmbeispiele
file:///E|/homepage/Pascal/index.htm (3 of 3) [07.10.2001 00:28:26]

Die allgemeine Programmstruktur von Turbo Pascal ist grob in folgende vier Elemente gegliedert
Die allgemeine Programmstruktur
Die allgemeine Programmstruktur von Turbo Pascal ist grob in folgende
vier Elemente gegliedert:
●
●
●
●
Dem Programmkopf: Dieser besteht aus dem reservierten Wort
"program" und einem Bezeichner, der dem Programm einen
Namen gibt.
Der USES-Anweisung: Diese enthält alle Namen der bei der
Programmausführung benötigten Units (Programm Bibliotheken).
Diese werden bei der Kompilierung eingebunden.
Der Vereinbarungsteil: Hier werden alle globalen, also im ganzen
Programm gültigen Konstanten, Datentypen, Variablen und
Unterprogramme festgelegt. Dabei ist zu beachten, dass nur das
benutzt werden kann was vorher vereinbart wurde.
Das Hauptprogramm: Enthält Anweisungen und
Anweisungsblöcke. Das Hauptprogramm beginnt mit dem
reservierten Wort "begin", und endet mit dem reservierten Wort
"end".
Und jetzt zum besserem Verständnis, noch ein kleinen Beispiel, an dem
die allg. Struktur ersichtlich wird:
PROGRAM Mein_erstes_Programm;
USES crt;
VAR i: Byte;
BEGIN
writeln('Hallo!');
writeln('So leicht ist Turbo Pascal');
writeln('Programmende!');
readln;
END;
Dieses kleine Programm gibt, mit der Prozedur Writeln(), drei Zeilen
Text auf dem Bildschirm aus. Nach Ausgabe des Textes, wird das
Programm solange angehalten bis die ENTER-Taste gedrückt wird.
file:///E|/homepage/Pascal/programmstruktur_.htm (1 of 2) [07.10.2001 00:29:36]

Die allgemeine Programmstruktur von Turbo Pascal ist grob in folgende vier Elemente gegliedert
Probleme mit TP Grundbegriffe
file:///E|/homepage/Pascal/programmstruktur_.htm (2 of 2) [07.10.2001 00:29:36]

Grundbegriffe
Grundbegriffe
Zum Anfang erst mal ein kleines Programm an dem dann die einzelnen
Begriffe erklärt werden.
PROGRAM losgehts;
BEGIN
Writeln('Und ab gehts..');
Readln;
END;
●
●
●
●
Programmname: Hinter dem reservierten Wort PRORGRAM wird
immer der Programmname angegeben. Dieser muss mit einem
Buchstaben beginnen und sollte nicht länger als Acht Zeichen
sein. Er kann jedoch bis 64 Zeichen lang sein. (Siehe auch
Abschnitt Bezeichner)
Anweisungswörter: Das Programm losgehts ist ein sehr kurzes
Programm und enthält nur zwei Anweisungen bzw.
Anweisungswörter.
Writeln ist ein Anweisungswort und steht für "Schreibe (Write)
eine Zeile (Line)". Mit Writeln wird der Computer angewiesen,
den angegebenen Text in einer Zeile auszugeben.
Zuweisungsanweisung ":=": (Zuweisungsoperator) Rechts vom
Zuweisungszeichen ( := ) kann ein Ausdruck stehen, links vom
Zuweisungszeichen darf aber immern nur eine Variable stehen.
Variable := Ausdruck
Die Zuweisungsanweisung geht immer in zwei Schritten vor sich: Im
ersten wird der Wert des Ausdrucks ermittelt, um dann im zweiten Schritt
diesen Wert in die links vom Zuweisungszeichen angegebene Variable
zuzuweisen. Der bisherige Wert wird dabei überschrieben - er wird durch
denn neuen Wert ersetzt. Die Zuweisung geschieht somit von rechts
nach links.
PROGRAM laenge;
VAR
text_laenge: Byte;
text: String;
BEGIN
text := 'Wie gehts denn so?';
text_laenge := length(text);
readln;
file:///E|/homepage/Pascal/grundbegriffe.htm (1 of 2) [07.10.2001 00:29:47]

Grundbegriffe
END.
●
Trennungszeichen ";": Das Semikolon dient in Turbo Pascal zur
Trennung von Anweisungen. Durch ein ";" wird dem System
mitgeteilt, dass ein neuer Befehl beginnt. Dadurch wird zum
Beispiel folgende Schreibweise möglich:
Writeln('Hallo'); Writeln('Du da!'); Readln;
● Kommentare im Quellcode: Kommentare werden zwischen (*...*)
oder { ... } im Quelltext (Programmtext) geschrieben. Der
Kommentar wird bei der Codierung gezeigt, bei der Ausführung
des Programms jedoch ignoriert.
●
●
Durch Kommentare ist es möglich bestimmte Abläufe im
Programm zu erklären bzw. zu kennzeichnen. Dadurch wird der
Quelltext für andere Programmierer leichter lesbar!
Endezeichen ".": Der Punkt markiert das Ende eines
Programmes. Quelltext, der hinter dem Punkt angegeben wird,
bleibt somit unberücksichtigt.
BEGIN..END als Block: Ein BEGIN..END - Bereich begrenzt
einen Block als zusammengehörende Einheit auszuführender
Anweisungen. Im Programm losgehts umschließt BEGIN...END
zwei Anweisungen. Ein Programm kann viele BEGIN...END -
Bereiche enthalten - es darf jedoch nur hinter dem letzten END ein
Punkt stehen.
Allg. Programmstruktur Bezeichner in TP
file:///E|/homepage/Pascal/grundbegriffe.htm (2 of 2) [07.10.2001 00:29:47]

Bezeichner in TP
Bezeichner in Pascal
Bezeichner sind die Namen für Variablen, Konstanten, Datentypen und
Unterprogramme. Sie können vom Programmierer selbst vergeben
werden.
CONST
Kurs = 1.67;
VAR
Meldung: String;
In Turbo Pascal sind folgende Zeichen für Bezeichner erlaubt: Die
Buchstaben A..Z in Groß- und Kleinschreibung, die Zahlen 0..9 und der
Unterstrich. Dabei ist aber zu beachten das, dass erste Zeichen eines
Bezeichners immer ein Buchstabe sein muss!
Als weiteres sollten Sie sich an die folgenden Grundsätze für die
Namens- bzw. Bezeichnervergabe gewöhnen:
●
●
●
●
Bezeichner sollten immer kurz und aussagekräftig geschrieben
werden.
Es sind nur die ersten 64 Zeichen signifikant. D.h. nur zwischen
den ersten 64 Zeichen wird unterschieden.
In Turbo Pascal gibt es keine Unterscheidung zwischen Groß- und
Kleinschreibung. SUN = sun = SuN
Als weiteres ist es sinnvoll die Schreibweise der Bezeichner im
gesamten Programm bei zubehalten.
Auch hier noch mal ein paar Beispiel, denn an Beispielen lernt man am
besten:
VAR
i: Byte;
summe: Real;
zaehler: Integer;
Name, Vorname, Strasse: String;
PLZ: Sting[5];
CONST
Pi := 3,14159265358;
file:///E|/homepage/Pascal/bezeichner_in_tp.htm (1 of 2) [07.10.2001 00:30:00]

Bezeichner in TP
Kurs := 1.75;
Grundbegriffe
Reservierte Wörter
file:///E|/homepage/Pascal/bezeichner_in_tp.htm (2 of 2) [07.10.2001 00:30:00]

Reservierte Wörter
Reservierte Wörter
Reservierte Wörter dürfen von Benutzer nicht als Bezeichner benutzt
werden, das heißt es darf in einem Programm keine Variable, Konstante,
kein Unterprogramm etc. geben welche den Namen eines reservierten
Wortes trägt.
Es ist zur besseren Übersicht vorteilhaft, wenn Sie reservierte Wörter in
Großbuchstaben schreiben.
Zum Beispiel darf ein Programm nicht BEGIN genannt werden, wohl aber
BEGINNE.
Reservierte Wörter in Turbo Pascal sind unter anderem folgende Wörter:
●
ABSOLUTE, AND, ARRAY, BEGIN, CASE,
CONST, CONSTRUCTUR, DESTRUCTOR, DIV,
DO, DOWNTO, ELSE, END, EXTERNAL, FILE,
FOR, FORWARD, FUNCTION, GOTO, IF,
IMPLEMENTATION, IN, INLINE, INTERFACE,
INTERRUPT, LABEL, MOD, NIL, NOT,
OBJECT, OF, OR, OVERLAY, PACKED,
PROCEDURE, PROGRAMM, RECORD, REPEAT,
SET, SHL, SHR, STRING, THEN, TO, TYPE,
UNIT, UNTIL, USES, VAR, VIRTUAL,
WHILE, WITH, XOR
Beispiel:
PROGRAM Test;
USES Crt;
VAR downto: STRING[20];
BEGIN
downto := 'Hallo';
Writeln(downto);
readln;
END;
file:///E|/homepage/Pascal/reservierte_woerter.htm (1 of 2) [07.10.2001 00:30:10]

Reservierte Wörter
Was ist am obigen Programm falsch? Richtig, hier wurde eine Variable
namens DOWNTO deklariert. Da DOWNTO aber ein reserviertes Wort ist, ist
dies nicht zulässig.
Bezeichner
Vereinbarung von Variablen
file:///E|/homepage/Pascal/reservierte_woerter.htm (2 of 2) [07.10.2001 00:30:10]

Vereinbarung von Variablen
Vereinbarung von Variablen
Eine Variable kann man sich als Schachtel mit einem Namen
(Schachtelaufschrift) und einem Wert (Schachtelinhalt) vorstellen. Der
Variablenname kann vom Benutzer frei gewählt werden. Der Computer
ordnet diesem Namen dann bestimmte Speicherplätze im RAM zu.
Welche Werte in dieser Variablen gespeichert werden können, hängt
vom vereinbarten Datentyp ab.
Eine Variable wird mit dem reservierten Wort VAR vereinbart, worauf der
Variablenname (Bezeichner) und der Datentyp folgt.
VAR
DM: Integer;
Im Vereinbarungsteil eines Programms müssen alle Größen auf die
später zugegriffen wird vereinbart (erklärt, deklariert) werden. VAR DM:
Integer; liest man so: "Für eine Variable DM Speicherplatz
bereitstellen, damit später Zahlen abgelegt werden können".
Bei der Vereinbarung von Variablen gelten folgende Regeln:
●
●
Die Vereinbarungsregel: Erst nachdem man eine Variable
vereinbart hat, kann man in sie einen Wert eingeben bzw. sich
ihren Wert ausgeben lassen. Das heißt alle Variablen mit denen
man Arbeiten möchten, müssen vorher deklariert werden. Die
Vereinbarungsregel bezieht sich auf den gesamten
Programmblock.
Die Initialisierungsregel: Bevor Sie mit einer Variablen Arbeiten,
zum Beispiel Rechnen, sollten Sie der Variablen immer erst einen
Anfangswert zuweisen (z.B. DM := 0;). Die Initialisierungsregel
bezieht sich auf den Anweisungsteil des Programms.
Reservierte Wörter
Vereinbarung von Konstanten
file:///E|/homepage/Pascal/vereinbarung_von_variablen.htm [07.10.2001 00:30:19]

Festlegen von Konstanten
Festlegen von Konstanten
Konstanten sind Bezeichner die im gesamten Programm gleich bleiben,
d.h. sie bekommen nur einmal einen Wert zugewiesen. Dieser Wert
bleibt dann im gesamten Programm gleich und darf nicht verändert
werden.
Hier ein Beispiel für eine Konstantenvereinbarung:
CONST
Kurs_in_Dollar := 2.45;
Das reservierte Wort "const" markiert den Anfang einer
Konstantenvereinbarung. Durch CONST Kurs_in_Dollar = 2.45 wird für
die Konstante namens Kurs_in_Dollar ein Zahlenwert von 2.45
festgelegt.
Der Datentyp für eine Konstante muss nicht angegeben werden, da er
Automatisch vom Compiler festgelegt wird.
Jetzt noch ein paar ander Beispiele:
CONST
Programm_Title = 'Mein kleines Programm';
Menu_Item_01 = 'Kopieren';
ERROR_NO_FILE = 'Datei nicht gefunden!';
Vereinbarung von Konstanten
Befehle der Unit Crt
file:///E|/homepage/Pascal/f_konstanten.htm [07.10.2001 00:30:34]

file:///E|/homepage/Pascal/Befehl_unit_crt.htm
Befehle der Unit Crt
Die Unit "crt" enthält Grundlegende Operationen für die Dateneingabe,
Datenausgabe, Datenmanipulation und die Textgestalltung.
Sie enthält unter andrem folgende Befehle:
●
textcolor (Farbe oder Farbcode): Textcolor legt die Farbe
des Textes fest. Die Farbe kann als Englisches Wort (z.B.: red)
oder Farbcode erfolgen.
Mit der Addition des Attributes BLINK, wird der Text blinkent
angezeigt!
Beispiel:
PROGRAM Text_Farbe;
USES crt;
BEGIN
writeln('Jetzt ist der Text Normal');
textcolor(red);
writeln('Jetzt ist er rot');
textcolor(darkred);
writeln('dunkelrot');
writeln('Immer noch dunkelrot');
textcolor(grey);
writeln('Wieder Normal');
textcolor(white + blink);
writeln('Weiß + blinkent');
readln;
END.
file:///E|/homepage/Pascal/Befehl_unit_crt.htm (1 of 3) [07.10.2001 00:30:47]

file:///E|/homepage/Pascal/Befehl_unit_crt.htm
●
textbackground (Farbe oder Farbcode): Textbackground
legt die Hintergrundfarbe des Textes fest. Die Farbe kann als
Englisches Wort (z.B.: red) oder Farbcode erfolgen.
Beispiel:
PROGRAM Text_Hintergrund;
USES crt;
BEGIN
writeln('Hintergrund ist Schwarz');
textbackgrund(red);
writeln('Hintergrund ist rot');
readln;
END.
●
delay (Zeit in ms): Delay hält das Programm für eine
bestimmte Zeit an. Die Zeitangabe erfolgt in Millisekunden.
Beispiel:
PROGRAM Warten;
USES crt;
BEGIN
writeln('Programm läuft');
delay(5000)
writeln('Programm hat 5 Sekunden gewartet');
readln;
END.
file:///E|/homepage/Pascal/Befehl_unit_crt.htm (2 of 3) [07.10.2001 00:30:47]

file:///E|/homepage/Pascal/Befehl_unit_crt.htm
●
writeln (String): Writeln gibt Text auf dem Bildschirm aus
und führt dann einen Zeilenumbruch durch..
Beispiel:
PROGRAM Text_ausgabe;
USES crt;
VAR
Text: String; BEGIN
:Text := 'Mein kleines Programm!';
writeln(Text);
writeln('Schön oder?');
readln;
END.
●
write (String): Write gibt, genauso wie writeln, Text auf
dem Bildschirm aus, führt aber keinen Zeilenumbruch durch.
●
gotoxy (Spalte, Zeile): Positioniert den Cursor auf dem
Bildschirm. Im Text-Modus von Turbo Pascal gibt es 80 Spalten
und 25 Zeilen.
Vereinbarung von Konstanten
Datentypen in TP
file:///E|/homepage/Pascal/Befehl_unit_crt.htm (3 of 3) [07.10.2001 00:30:47]

Datentypen in Pascal
Datentypen in Pascal
Der Datentyp gibt an Welche Werte eine Variable, Konstante und Unterprogramme
annehmen bzw. zurück geben können.
In Turbo Pascal stehen folgende vordefinierten Datentypen zur Verfügung. Natürlich können
auch noch selbst definierte Datentypen erzeugt werden.
Datentypen für ganze Zahlen
Typ Speicherbedarf Zahlenbereich
BYTE
SHORTINT
WORD
INTEGER
LONGINT
1 Byte
1 Byte
2 Byte
2 Byte
4 Byte
0 .. 255
-128 .. 127
0 .. 65536
-32768 .. 32767
-2147483648 ..
2147483647
Datentypen für reelle Zahlen
Typ Speicherbedarf Zahlenbereich
REAL
SINGLE
DOUBLE
EXTENDED
Datentypen für Zeichen
CHAR
STRING
4 Byte
6 Byte
8 Byte
10 Byte
2.9E-39 .. 1.7E+38
1.5E-45 .. 3.4E38
5.0E-324 .. 1.7E308
1.9E-4951 .. 1.1E4932
Typ Speicherbedarf Inhalt
1 Byte
255 Byte max.
ein Zeichen z.B.: a, B, $
Zeichenkette (Worte,
Sätze)
Datentyp für Logische Variablen
Typ Speicherbedarf Inhalt
BOOLEAN
1 BYTE
True(wahr) oder
False(unwahr)
Vordefinierte Konstanten
Name Wert Datentyp
MAXINT
PI
TRUE
FALSE
32767
3.1415926536E00
Wahrheitswert richtig
Wahrheitswert falsch
integer
real
boolean
boolean
Befehle der Unit Crt Einfache Datentypen
file:///E|/homepage/Pascal/datentypen_in_pascal.htm [07.10.2001 00:33:35]

Einfache Datentypen
Einfache Datentypen
In Turbo Pascal werden die einfachen Datentypen Real, Integer, Byte,
Boolean, Char bereitgestellt. Verarbeitet mann Text als eine
Dateneinheit, so zählt man auch den String zu den einfachen Typen.
Einfach bedeutet, dass eine Konstante oder Variable dieses Typs jeweils
nur einen Wert annahmen darf: eine Zahl, ein Zeichen oder einen Text.
Dabei unterscheidet man zwischen abzählbaren und nicht abzählbaren
Datentypen. Integer, Byte, Boolean und Char sind abzählbare
Datentypen. Real jedoch ist nicht abzählbar, da es unendlich viele
gebrochene Zahlen gibt - man kann sie nicht abzählen. Zu einer Real-
Zahl kann man keinen exakten Vorgänger bzw. Nachfolger angeben.
Dieser Datentyp eignet sich deshalb auch nicht zum Zählen, sondern
mehr zum Messen.
Für skalierbare (Abzählbare) Datentypen stehen unter andrem folgende
vordefinierten Funktionen zur Verfügung:
●
Succ(): Liefert den Nachfolger eines Wertes, falls es nicht der
letzte ist.
Beispiel:
Succ(99) ist 100
Succ('d') ist 'e'
●
Pred(): Gibt den Vorgänger eines Wertes, falls es nicht der erste
ist, aus.
Beispiel:
Pred(1) ist 0
Pred('b') ist 'a'
●
Ord(): Gibt die Ordnungsnummer eines Wertes aus.
Beispiel:
Ord(99) ist 99
Ord('A') ist 65
Einfache Datentypen können Sie Vergleichen, dazu sind folgende
Vergleichsoperatoren erlaubt: , =, =,
file:///E|/homepage/Pascal/einfache_datentypen.htm (1 of 2) [07.10.2001 00:34:10]

Einfache Datentypen
Datentypen in TP Der Datentyp Integer
file:///E|/homepage/Pascal/einfache_datentypen.htm (2 of 2) [07.10.2001 00:34:10]

Der Datentyp Integer
Der Datentyp Integer
Der Datentyp Integer enthält ganzwertige Zahlen im Bereich von -32768
und 32767.
Der Datentyp Integer ist ein ordinaler Datentyp. Sie zeichnen sich durch
eine natürliche Reihenfolge ihrer Werte aus. d.h. es gibt einen 1. Wert, 2.
Wert, ..., n. Wert.
Ein Integer Wert belegt intern 2 Bytes im Speicher.
Deklaration:
CONST
I = 100;
VAR
ALTER: Integer;
Auf einen Integer-Wert sind folgende Operatoren möglich:
● +, -, *, /
● =, , =,
● DIV (ganzzahlige Division)
● MOD (Rest der ganzzahligen Division)
● AND, OR, XOR, NOT (Vergleiche)
Integer-Werte sind nutzbar für Kontrollvariablen in FOR und CASE
Anweisungen.
Als weiteres stellt der Integer-Datentyp den Grundtyp für die
Mengenbildung da und ist auch als ARRAY-Index nutzbar.
Einfache Datentypen Der Datentyp Real
file:///E|/homepage/Pascal/der_datentyp_integer.htm [07.10.2001 00:34:42]

Der Datentyp Real
Der Datentyp Real
Ein Realwert enthält eine Gleitkomma-Zahl mit 11 signifikanten Stellen in
der Mantisse und -38 bis 38 in der Hochzahl.
Der Datentyp Real ist nicht abzählbar, da es unendlich viele gebrochene
Zahlen gibt - man kann sie nicht abzählen. Zu einer Real-Zahl kann man
keinen exakten Vorgänger bzw. Nachfolger angeben. Dieser Datentyp
eignet sich deshalb auch nicht zum Zählen, sondern mehr zum Messen.
Ein Real - Wert belegt intern 4 Bytes im Speicher.
Deklaration:
CONST
Kurs = 1.25;
VAR
Summe: Real;
Folgende Operationen sind auf den Datentyp Real anwendbar:
● +, -, *, /
● Keine Potenzierung
Auf den Datentyp Real sind unter andrem folgende arithmetische
Funktionen anwendbar:
●
●
●
●
●
●
abs(r): absoluter Betrag von r
sqr(r): Quadrat von r
sqrt(r): Quadratwurzel von r
sin(r): Sinusfunktion
cos(r): Cosinusfunktion
int(r): Ganzzahliger Anteil der Variable r
Der Real Datentyp ist nicht ordinal und deshalb nicht nutzbar für die
Funktionen Pred, Succ und Ord. Für die Indizierung, Mengenbildung
und Ablaufkontrollen wie FOR und CASE ist er ebenfalls nicht nutzbar.
Der Datentyp Integer
Der Datentyp String
file:///E|/homepage/Pascal/der_datentyp_real.htm [07.10.2001 00:34:53]

Der Datentyp String
Der Datentyp String
Eine Variable vom Datentyp String ist eine Aneinanderreihung von
Zeichen des Datentyps Char zu einer Zeichenkette. Turbo Pascal
unterstützt Zeichenketten bis zu einer Länge von 255 Zeichen. Ein
String, der kein Zeichen enthält, hat die Länge Null und wird Null- oder
Leerstring genannt.
Eine Variable vom Typ String wird wie folgt vereinbart:
VAR
str: Sting;
identisch mit: str: String[255];
Damit kann im Programm eine Variable benutzt werden, die maximal 255
Zeichen enthalten kann.
Soll die maximale Länge einer Zeichenkette verringert werden, so
geschieht dies durch Angabe eines Integer-Wertes, der in eckige
Klammern dem reservierten Wort String folgt:
VAR
str: String[15];
Damit wurde eine Zeichenkette reserviert, die maximal 15 Zeichen
enthalten darf. Sie kann zwar weniger, aber niemals mehr als die
angegebenen Zeichen enthalten.
Werden Zeichenketten Variablen zugewiesen, so stehen sie immer
zwischen Hochkommas. Mit der Vereinbarung der Variablen str von
Datentyp String ist zum Beispiel folgende Zuweisung zulässig:
str := 'Test';
Auf jedes Zeichen der Zeichenkette kann einzeln zugegriffen werden, in
dem die Position des Zeichens in eckigen Klammern hinter dem Namen
der Zeichenkette gesetzt wird:
str := 'Mein String';
writeln(str[6]);
Mit der writeln Anweisung wird das 6. Zeichen, also das "S", der
Zeichenkette ausgegeben.
file:///E|/homepage/Pascal/der_datentyp_string.htm (1 of 2) [07.10.2001 00:35:15]

Der Datentyp String
Mit Strings sind alle Vergleichsoperationen und die Addition von Strings
erlaubt.
Beispiel für die Addition von Strings:
str3 := str1 + str2;
str := 'Alex' + 'an der';
Der Datentyp Real
Standardroutinen für den Datentyp String
file:///E|/homepage/Pascal/der_datentyp_string.htm (2 of 2) [07.10.2001 00:35:15]

Aufzählende Datentypen
Aufzählende Datentypen
Aufzählungstypen sind selbstdefinierte Datentypen, deren Wertebereich
durch Aufzählen festgelegt wird. Der aufzählende Datentyp besteht aus
einer Aufzählung von Elementen, die in runden Klammern stehen und
jeweils durch Kommas getrennt sind.
TYPE
TypName = (element1, element2 ..., elemnetN);
Die Deklaration eines Aufzählungstypen erfolgt mit dem reservierten
Wort TYPE, welchem der TypName und die Aufzählung der Elemente
folgt.
Beispiele für solche Deklarationen sind:
TYPE
Zahlen = (eins, zwei, drei);
Groesse = (gross, mittle, klein);
Farben = (blau, gelb, weiss, grau, rot);
Der aufzählende Datentyp besitzt eine bestimmte Reihenfolge, d.h. die
Anordnung der Elemente ist beim Zugriff zu beachten. Für jedes Element
gibt es einen festen Vor- bzw. Nachfolger, was die Anwendung der
Standardfunktionen Succ, Pred und Ord ermöglicht.
Leider weisen Aufzählungstypen einen entscheidenden Nachteil auf, der
ihre breite Verwendung einschränkt. Sie lassen sich weder über die
read/readln Anweisung einlesen, noch lassen sie sich über
write/Writeln ausgeben. Da die Werte keine Zeichenketten
darstellen.
So müssen für die Ein- und Ausgabe gesonderte Hilfsvariablen deklariert
werden. Dennoch können aufzählende Datentypen die Programmstruktur
erhöhen und für bessere Lesbarkeit im Programm sorgen.
Die Reihenfolge, in der die Werte aufgeführt werden, legt gleichzeitig
eine Anordnung fest. Keiner der Werte darf mehrmals aufgeführt werden.
Zwei Typbeschriebungen, die dieselben Werte in unterschiedlicher
Reihenfolge enthalten, sind somit verschieden.
TYPE
Auto_Art_1 = (lkw, bus, pkw);
Auto_Art_2 = (lkw, pkw, bus);
file:///E|/homepage/Pascal/aufzählende_datentypen.htm (1 of 3) [07.10.2001 00:35:28]

Aufzählende Datentypen
Der Type Auto_Art_2 unterscheidet sich in der Reihenfolge von pkw
und bus, ist also ein anderer Datentyp als Auto_Art_1.
Mit der Type- und Var - Vereinbarung
TYPE
Groesse = (klein, mittel, gross);
VAR
person: Groesse;
ist folgende Schleife möglich:
FOR person := klein TO gross DO
BEGIN
...;
...;
END;
Aufgrund der festgelegten Reihenfolge sind auch Vergleichsoperationen
möglich. Es werden dabei die Plätze verglichen, an denen die einzelnen
Werte in der Typendefinition auftreten. Deren Zählung beginnt mit 0. Der
Wert klein steht vor dem Wert mittel
In den meisten Fällen werden Auszählungstypen nicht zur Ein- und
Ausgabe benutzt, sondern dazu Klarheit und Lesbarkeit eines
Programms zu erhöhen.
Zur Ausgabe eines Wertes aus dem Aufzählungstyp kann, wie bereits
erwähnt, der Wert nicht selbst in einer Schreibanweisung benutzt
werden. Man muss die Ausgabe eines passenden Strings gesondert
programmieren. Dies erfolgt zum Beispiel mit einer CASE-Entscheidung.
VAR
person: groesse;
...;
BEGIN
...;
CASE person OF
klein: Wrtieln('klein');
mittel: Writeln('mittel');
gross: Writeln('gross');
END;
...;
END.
file:///E|/homepage/Pascal/aufzählende_datentypen.htm (2 of 3) [07.10.2001 00:35:28]

Aufzählende Datentypen
Standardroutinen des Datentyp String Teilbereichtstypen
file:///E|/homepage/Pascal/aufzählende_datentypen.htm (3 of 3) [07.10.2001 00:35:28]

Teilbereichstypen
Teilbereichstypen
Mit Ausnahme der Datentypen für die Erfassung von reellen Zahlen (z.B.
Real oder Double) lassen sich zu allen bisher bekannten Datentypen
Unterbereichstypen (Teilbereichstypen) deklarieren. Diese sind ein
Ausschnitt, ein Bereich aus der Wertemenge eines zugrundeliegenden,
also vorher definierten (bekannten) Datentyps.
Mit der Typdeklaration:
TYPE
Bis_Tausend = 0..1000;
können Sie zum Beispiel einem Teilbereich der ganzen Zahlen einen
eigenen Datentyp zuweisen. Die Deklaration eines solchen Datentyps ist
insbesondere deshalb sinnvoll, weil der Computer allen späteren
deklarierten Variablen dieses Typs die richtige Einhaltung des zulässigen
Wertebereichs überprüft und Bereichsüberschreitungen mit
entsprechenden Fehlermeldungen quitiert. Bis_Tausend umfaßt nach
der obigen Deklaration alle ganzen Zahlen im Bereich von Null bis
Eintausend.
Der Datentyp des Grundtyps muss nicht angegeben werden, da er vom
Compiler erkannt und festgelegt wird.
TYPE
Grosse_buchstaben = 'A'..'Z'; {Grundtyp Char}
Ziffern = '0'..'9'; {Grundtyp Char}
Mit den Werten des Unterbereich sind im Prinzip dieselben Operationen
möglich, die für die Werte des Grundtyps definiert sind. Es muss aber
beachtet werden, dass nicht alle Operationen einen Wert des
Unterbereichs als Ergebnis zu haben brauchen. Zum Beispiel kann die
Differenz zweier natürlicher Zahlen negativ sein, welche nicht mehr zum
Unterbereichstyp der natürlichen Zahlen gehört.
Bei den Unterbereichstypen sind alle Vergleichsoperationen erlaubt, die
auch beim Grundtyp zugelassen sind.
Aufzählende Datentypen
Explizite / Implizite Typenvereinbarung
file:///E|/homepage/Pascal/teilbereichstypen.htm [07.10.2001 00:35:41]

Explizite und implizite Typenvereinbarung
Explizite und implizite Typenvereinbarung
Explizite Typenvereinbarung ist die benannte Typvereinbarung. Für
einen Datentyp wird ausdrücklich (explizit) unter Type ein Name
vergeben. Der Datentyp ist benannt und kann beliebig oft auf der rechten
Seite einer Variablenvereinbarung angegeben werden.
Aus der Expliziten Typenvereinbarung ergeben sich folgende Vorteile:
●
●
●
Übersichtlichkeit durch Wahl aussagekräftiger Namen.
Unterbereichstypen (Teilbereichstypen) können nur zu benannten
Typen vereinbart werden.
Nur benannte Typen können als Parameter übergeben werden
(strukturierte Datentypen wie Array, Record, Mengen etc. müssen
benannt werden)
Die Implizierte Typenvereinbarung dagegen ist die anonyme
Typenvereinbarung. Der Datentyp wird nur auf der rechten Seite einer
Variablenvereinbarung angegeben er bleibt somit anonym. Bei kurzen
Programmen ist diese Möglichkeit berechtigt.
Beispiele für explizite und implizite Typenvereinbarung:
●
Explizite Typenvereinbarung mit const und type:
CONST
rabatt_1 = 2;
rabatt_2 = 15;
TYPE
Rabatte = rabatt_1..rabatt_2;
●
VAR
Rabatt: Rabatte;
Explizite Typenvereinbarung mit type:
TYPE
Rabatte = 2..15;
●
VAR
Rabatt: Rabatte;
Implizite Typenvereinbarung mit var:
file:///E|/homepage/Pascal/explizite_und_implizite_typenver.htm (1 of 2) [07.10.2001 00:35:50]

Explizite und implizite Typenvereinbarung
VAR
Rabatt: 2..15;
Teilbereichstypen
Die IF - Entscheidung
file:///E|/homepage/Pascal/explizite_und_implizite_typenver.htm (2 of 2) [07.10.2001 00:35:50]

Die IF
Die IF - Bedingung
Mit der IF - Struktur entscheidet Turbo Pascal zwischen zwei
Anweisungen oder Anweisungsblöcken, deren Ausführung von einer
Bedingung abhängig ist. Die allgemeine Schreibweise lautet wie folgt:
IF Bedingung THEN Anweisung ELSE Anweisung2;
IF leitet die IF - Struktur ein, worauf die Bedingung folgt, von deren Wert
(true oder false) es abhängt, ob der THEN - Zweig oder der ELSE -
Zweig ausgeführt wird. Die Bedingung muss entweder ein Ausdruck oder
eine Variable vom Typ Boolean sein.
Ist die Bedingung True, werden die Anweisungen des THEN - Zweiges
ausgeführt. Die Anweisungen im ELSE - Zweig werden dann ignoriert.
Ist die Bedingung False, werden die Anweisungen des ELSE - Zweiges
(falls vorhanden) ausgeführt. Die Anweisungen des THEN - Zweiges
werden dann ignoriert!
Der ELSE - Zweig ist optional. Er muss nicht in jeder IF - Struktur
enthalten sein. Wenn der ELSE - Zweig fehlt wird mit der eigentlichen
Programmausführung fortgefahren.
Sollen in einem Zweig mehrere Anweisungen, also ein Anweisungsblock,
ausgeführt werden, so müssen diese zwischen BEGIN und END
geschachtelt werden.
Das Struktogramm für eine IF - Bedingung sieht wie folgt aus:
Hier ein kleines Beispiel für eine IF - Entscheidung:
PROGRAM Sortieren_von_drei_Zahlen;
USES crt;
VAR a, b, c, h: INTEGER;
BEGIN
{PROGRAMMINFO}
TextColor(white);
CLRSCR;
WRITELN('SORTIERUNGSPROGRAMM');
WRITELN('Geben Sie drei ganze Zahlen ein!');
{DATENABFRAGE}
file:///E|/homepage/Pascal/die_if.htm (1 of 2) [07.10.2001 00:35:57]

Die IF
WRITELN;
WRITE('Erste Zahl: ');
READLN(a);
WRITE('Zweite Zahl: ');
READLN(b);
WRITE('Dritte Zahl: ');
READLN(c);
WRITELN;
{DATENVERARBEITUNG}
IF a > b THEN
BEGIN
H := a; a := b; b := h;
END;
IF b > c THEN
BEGIN
h := b; b := c; c := h;
END;
IF a > b THEN
BEGIN
h := a; a := b; b := h;
END;
{ERGEBNISS AUSGEBEN}
writeln('geordnet: ', a:7,b:7,c:7);
READLN;
END.
Das obige Beispiel zeigt den Syntax und den Ablauf einer IF -
Entscheidung. Im Programm müssen drei Zahlen eingegeben werden,
die dann vom Programm im sortierten Zustand wieder ausgegeben
werden.
Explizite / implizite Typenvereinbarung Die CASE - Entscheidung
file:///E|/homepage/Pascal/die_if.htm (2 of 2) [07.10.2001 00:35:57]

Die CASE
Die CASE - Bedingung
Eine Mehrfachentscheidung kann mit der CASE-Anweisung viel übersichtlicher und
kürzer programmiert werden (vgl. zu IF). Die allg. Struktur der CASE-Anweisung
lautet:
case Ausdruck of
marke1: Anweisung;
marke2: Anweisung;
marke3: Anweisung;
...
else
Anweisung(en);
end;
Turbo Pascal berechnet bei der Verwendung der CASE-Anweisung den Ausdruck
(auch Selektor genannt) und vergleicht ihn nacheinander mit den einzelnen Marken.
von denen innerhalb der CASE-Anweisung beliebig viele vorhanden sein können.
Stimmt der Wert des Ausdrucks mit dem Wert der Marke überein, wird die auf der
Marke folgende Anweisung bzw. der Anweisungsblock ausgeführt. Die restlichen
Marken werden übersprungen! Findet Turbo Pascal keine Marke deren Wert mit dem
Wert des Ausdrucks übereinstimmt, die Anweisung bzw. der Anweisungsblock des
(optionalen) ELSE-Zweigs ausgeführt.
Die Werte der Marken dürfen einzelne Werte, mehrere Werte (durch Kommata
getrennt) oder auch Bereiche, durch die Angabe charakterisiert (B1..B2), sein.
●
●
●
Es sind nur ordinale Datentypen (allg. Aufzählungstypen) erlaubt!
Der wert des Selektors muss aus dem Bereich -32768..32767 sein!
Beachten Sie das jede Marke in der CASE-Anweisung nur einmal auftreten darf!
Das Struktogramm für eine CASE - Bedingung sieht wie folgt aus:
file:///E|/homepage/Pascal/die_case.htm (1 of 3) [07.10.2001 00:36:06]

Die CASE
Auch hier ein kleines Beispiel für eine CASE - Entscheidung:
PROGRAM quatral_mit_case;
USES crt;
CONST
Frage = 'Geburtsmonat? ';
VAR
Monat: Byte;
BEGIN
Clrscr;
Write(Frage);
GotoXY(1 + Length(Frage), 1);
Readln(Monat);
Clrscr;
GotoXY(10, 5);
Write('Sie sind im ');
{BEGIN CASE - BEDINGUNG}
CASE Monat OF
1..3: Write('I. Quatral geboren.');
4..6: Write('II. Quatral geboren.');
7..9: Write('III. Quatral geboren.');
ELSE Write('IV. Quatral geboren.');
END;
{ENDE CASE - BEDINGUNG}
GotoXY(1, 25);
Write('Bitte [Return] druecken ...');
Readln;
file:///E|/homepage/Pascal/die_case.htm (2 of 3) [07.10.2001 00:36:06]

Die CASE
END.
Das obige Beispiel zeigt den Syntax und den Ablauf einer CASE - Entscheidung. Das
Programm gibt, nach Eingabe des Geburtsmonats, das Geburtsquartal aus.
Die IF - Entscheidung
Die REPEAT / UNTIL - Schleife
file:///E|/homepage/Pascal/die_case.htm (3 of 3) [07.10.2001 00:36:06]

Die REPEAT
Die REPEAT / UNTIL - Schleife
Schleifen werden in allen Programmiersprachen benutzt um einzelne
Anweisungen oder Anweisungsblöcke zu wiederholen. Schleifen
erleichtern die Arbeit und machen ein Programm übersichtlicher.
Erstmal das Struktogramm für eine UNTIL / REPEAT - Schleife:
Die Anzahl der Schleifendurchläufe muss vorher nicht bekannt sein. Es
wird zur Beendigung der Schleife eine Bedingung benutzt. Die
Abbruchbedinung wird am Ende der Schleife geprüft. Allgemeine
Schreibweise der Repeat-Schleife:
REPEAT
Anweisung(en);
UNTIL Abbruchbedingung;
Die Anweisungen innerhalb der Repeat-Schleife werden beim ersten
Durchlauf ohne Prüfung der Bedingung ausgeführt! Am Ende der
Schleife wird dann geprüft, ob die Bedingung erfüllt (True) ist. Ist dies der
Fall, wird die Schleife verlassen, ansonsten werden die Anweisungen
innerhalb der Schleife erneut und solange ausgeführt bis die
Abbruchbedingung erfüllt ist.
Die Struktur der Repeat-Schleife verlangt offensichtlich, dass die
Abbruchbedingung innerhalb der Schleife verändert wird und die
Möglichkeit bestehen muss, dass die Bedingung True werden kann!
INFO: Hat sich ein Programm "Aufgehängt": Hilft häufig nur noch die
file:///E|/homepage/Pascal/die_repeat.htm (1 of 4) [07.10.2001 00:36:11]

Die REPEAT
Programmunterbrechung mit [Strg] + [Break]!
Und jetzt noch zur Veranschaulichung ein kleines Beispiel:
PROGRAM Schuld_abzahlen;
USES crt;
VAR
Schuld, Jahresrate: Real;
Zinssatz, Schuldneu: Real;
Zinsen, Schuldalt: Real;
Jahre: Integer;
BEGIN
Clrscr;
Jahre := 0;
Zinsen := 0;
SchuldAlt := 0;
SchuldNeu := 0;
Write('Schuld: ');
Readln(Schuld);
Write('Jahresrate: ');
Readln(Jahresrate);
Write('Zinssatz: ');
Readln(Zinssatz);
Jahre := 1;
SchuldAlt := Schuld;
Zinsen := Schuldalt * Zinssatz / 100;
Schuldneu := Schuldalt
+ Zinsen - JahresRate;
GotoXY(1, 5);
Write('Jahre');
GotoXY(18, 5);
Write('Schuldalt');
GotoXY(35, 5);
Write('Zinsen');
GotoXY(50, 5);
Write('Jahresrate');
GotoXY(70, 5);
Write('Schuldneu');
GotoXY(2, 5+ Jahre);
Write(Jahre);
GotoXY(19, 5 + Jahre);
Write(Schuldalt:2:2);
GotoXY(36, 5 + Jahre);
Write(Zinsen:2:2);
file:///E|/homepage/Pascal/die_repeat.htm (2 of 4) [07.10.2001 00:36:11]

Die REPEAT
GotoXY(51, 5 + Jahre);
Write(Jahresrate:2:2);
GotoXY(71, 5 + Jahre);
Write(Schuldneu:2:2);
Repeat
Jahre := Jahre + 1;
Schuldalt := Schuldneu;
Zinsen := Schuldalt
* Zinssatz / 100;
Schuldneu := Schuldalt
* Zinsen - Jahresrate;
GotoXY(2, 5+ Jahre);
Write(Jahre);
GotoXY(19, 5 + Jahre);
Write(Schuldalt:2:2);
GotoXY(36, 5 + Jahre);
Write(Zinsen:2:2);
GotoXY(51, 5 + Jahre);
Write(Jahresrate:2:2);
GotoXY(71, 5 + Jahre);
Write(Schuldneu:2:2);
UNTIL Schuldneu < Jahresrate;
Writeln('');
Writeln('Die letzte Rate beträgt: ',
Schuldneu:2:2);
Readln;
END.
Das obige Beispiel zeigt den Syntax und den Ablauf einer
REPEAT/UNTIL - Schleife. Das Programm gibt einen Zahlungsplan für
die Abzahlung eines Kredites, in Tabellenform aus.
Die REPEAT - UNTIL Schleife wird so lange ausgeführt bis die
Restschuld des Kredits kleiner als die Jährliche Rate ist.
Hier noch ein weiteres kleines Beispiel:
PROGRAM BSP_Rep;
USES Crt;
VAR
Ch: Char;
BEGIN
REPEAT
Ch := ReadKey;
file:///E|/homepage/Pascal/die_repeat.htm (3 of 4) [07.10.2001 00:36:11]

Die REPEAT
UNTIL Ch in ['J','j','N','n'];
END.
Dieses Programm wiederholt die Schleife solange bis die richtige Taste
gedrückt wurde.
Die CASE-Anweisung
Die FOR - Schleife
file:///E|/homepage/Pascal/die_repeat.htm (4 of 4) [07.10.2001 00:36:11]

Die FOR
Die FOR - Schleife
Schleifen werden in allen Programmiersprachen benutzt um einzelne
Anweisungen oder Anweisungsblöcke zu wiederholen. Schleifen
erleichtern die Arbeit und machen ein Programm übersichtlicher.
Erstmal das Struktogramm für eine FOR - Schleife:
Bei der FOR - Schleife ist die Anzahl der Schleifendurchläufe bereits vor
dem ersten Schleifendurchlauf bekannt. Start-, Endwert und müssen
vom Gleichen Datentyp sein. (z.B. Integer) Die Zählvariable soll durch
keine Anweisung innerhalb der For-Schleife in ihrem Wert verändert
werden. Sie darf aber zur Berechnung anderer Variablen oder zu
anderen Zwecken innerhalb der For-Schleife benutzt werden. Die
Zählervariable wird auf einem bestimmten Startwert gesetzt und bei
jedem Schleifendurchlauf auf das nächste Element des Bereichs, aus
dem sie stammt, gesetzt, bis der Endwert erreicht ist.
Die allg. Schreibweise lautet:
FOR Zählervariable :=
Startwert TO Endwert DO Anweisung;
wobei Startwert < Endwert
Für mehrere Anweisungen:
FOR Zählervariable :=
Startwert TO Endwert DO
BEGIN
Anweisungen;
END;
Bei Verwendung des reservierten Wortes DOWNTO kann man auch
rückwärts zählen! Die Schreibweise lautet dann:
FOR Zählervariable :=
Startwert DOWNTO Endwert DO Anweisung;
wobei Startwert > Endwert
file:///E|/homepage/Pascal/die_for.htm (1 of 2) [07.10.2001 00:36:27]

Die FOR
INFO: Hat sich ein Programm "Aufgehängt": Hilft häufig nur noch die
Programmunterbrechung mit [Strg] + [Break]!
Und jetzt noch zur Veranschaulichung ein kleines Beispiel:
PROGRAM zaehlen;
USES crt;
VAR
Zahlen: Array[1..10] of Integer;
Items, i: Byte;
BEGIN
Clrscr;
Items := 10;
FOR i := 1 to Items DO
BEGIN
Write(i,'. Wert eingeben: ');
Readln(Zahlen[i]);
END;
END.
Dieses kleine Beispiel benutzt eine FOR-Schleife um Zahlenwerte in ein
Array einzulesen. Die FOR-Schleife wird Zehn mal durchlaufen, wobei
die aktuelle Position im Array durch die Zählervariable i festgelegt wird.
Die REPEAT / UNTIL - Schleife Die WHILE - Schleife
file:///E|/homepage/Pascal/die_for.htm (2 of 2) [07.10.2001 00:36:27]

Die WHILE
Die WHILE - Schleife
Schleifen werden in allen Programmiersprachen benutzt um einzelne
Anweisungen oder Anweisungsblöcke zu wiederholen. Schleifen
erleichtern die Arbeit und machen ein Programm übersichtlicher.
Auch jetzt erstmal das Struktogramm für eine WHILE - Schleife:
Auch die While -Schleife macht die Ausführung der Anweisung(en)
innerhalb der Schleife von einer Bedingung abhängig. Die allg.
Schreibweise lautete:
WHILE Bedingung DO Anweisung;
oder bei mehreren Anweisungen:
WHILE Bedingung DO
BEGIN
Anweisungen;
END;
Im Gegensatz zur Repeat-Schleife, aber in Übereinstimmung mit der
For-Schleife, werden mehrere Anweisungen von BEGIN und END
geklammert.
Die Bedingung wird bereits vor der Ausführung der ersten
Schleifenanweisung geprüft. Ist sie erfüllt (True), werden die
Anweisungen audgeführt, sonst nicht. Damit besteht die Möglichkeit,
file:///E|/homepage/Pascal/die_while.htm (1 of 3) [07.10.2001 00:36:46]

Die WHILE
dass eine While-Schleife keinmal durchlaufen wird.
Wurde die Schleife mindestens einmal durchlaufen, so wird die
Bedingung vor jedem Schleifendurchlauf erneut geprüft. Nur wenn Sie
noch immer True bzw. Wahr ist, werden die Anweisungen erneut
ausgeführt!
Die Struktur der While-Schleife verlangt offensichtlich, dass die
Abbruchbedingung innerhalb der Schleife verändert wird und die
Möglichkeit bestehen muss, dass die Bedingung False bzw. falsch
werden kann!
INFO: Hat sich ein Programm "Aufgehängt": Hilft häufig nur noch die
Programmunterbrechung mit [Strg] + [Break]!
Und jetzt noch zur Veranschaulichung ein kleines Beispiel:
PROGRAM Anzahl_Summe_Mittel;
USES crt;
VAR
Anzahl: Integer;
Zahl, Summe, Mittel: Real;
BEGIN
Textcolor(White);
Clrscr;
Summe := 0;
Anzahl := 0;
Anzahl := 0;
Write('1. Zahl: ');
Readln(Zahl);
WHILE Zahl 0 DO
BEGIN
Summe := Summe + Zahl;
Anzahl := Anzahl + 1;
Write(Anzahl, '. Zahl: ');
Readln(Zahl);
Mittel := Summe / Anzahl;
END;
Writeln('Anzahl: ', Anzahl);
Writeln('Summe: ', Summe:4:2);
Writeln('Mittelwert: ', Mittel:4:3);
Readln;
END.
file:///E|/homepage/Pascal/die_while.htm (2 of 3) [07.10.2001 00:36:46]

Die WHILE
In diesem Beispiel wird die While-Schleife benutzt eine unbekannte
Anzahl von Zahlen einzugeben. Die Schleife wird beendet wenn die
eingegebene Zahl eine Null ist.
Die FOR - Schleife
Grundwissen Unterprogramme
file:///E|/homepage/Pascal/die_while.htm (3 of 3) [07.10.2001 00:36:46]

Grundwissen
Grundwissen - Unterprogramme
Ein "gutes" Programm sollte übersichtlich strukturiert sein. Dazu gehören
einerseits eine ausreichende Dokumentation, andererseits aber auch,
dass Programme in kleinere Abschnitte, die auch Unterprogramme
genannt werden, unterteilt sind. Dadurch erhöht sich die Lesbarkeit eines
Programms. Außerdem können Fehler leichter entdeckt und
Programmänderungen einfacher vorgenommen werden.
Ein Unterprogramm ist ein eigenständiger Teil eines Haupt- oder eines
anderen Unterprogramms. Unterprogramme sollten so gehalten werden,
dass sie möglichst vom jeweiligen Hauptprogramm unabhängig sind.
Das heißt das benutzte Bezeichner innerhalb von einem Unterprogramm
immer lokal deklariert werden sollten! Immer, wenn ein Unterprogramm
mit seinen Namen aufgerufen wird, werden die Anweisungen dieser
Routine ausgeführt, so, als stünden sie an der Stelle, an welcher der
Name der Routine im Programm genannt ist.
In Turbo Pascal unterscheiden wir Funktionen und Prozeduren als
Unterprogramme.
Jedes größere Programm umfasst Prozeduren und Funktionen als
Unterprogramme. Damit ergeben sich Vorteile hinsichtlich Ökonomie,
Lesbarkeit und Programmentwicklung:
1. Ökonomie-Vorteil Ein Unterprogramm kann an mehreren Stellen
eines Programms aufgerufen werden. Es muss aber nur einmal
programmiert werden.
2. Gliederungs-Vorteil: Ein Programm wird durch Unterprogramme
gegliedert und damit besser lesbar.
3. Baustein-Vorteil: Ein Unterprogramm kann als Baustein in
mehreren Programmen aufgerufen werden. Die Bausteine werden
in einer Programm-Bibliothek (UNIT) gesammelt.
Die While - Schleife
Lokale und Globale Bezeichner
file:///E|/homepage/Pascal/grundwissen.htm [07.10.2001 00:37:34]

Lokale und globale Bezeichner
Lokale und globale Bezeichner
Bezeichner sind Variablen, Konstanten, Datentypen, Unterprogramme.
Global heißt ,,gesamt" und wir verstehen unter einem globalen
Bezeichner, Bezeichner die dem gesamten Programm, einschließlich
aller Unterprogramme, zur Verfügung stehen. Wird also eine Bezeichner
im Vereinbarungsteil des Hauptprogramms deklariert, handelt es sich
dabei um einen globalen Bezeichner. Lokal heißt dagegen ,,örtlich".
Darunter verstehen wir Bezeichner, die nur dem Unterprogramm zur
Verfügung stehen, in dessen Vereinbarungsteil sie deklariert worden
sind. Den anderen Unterprogrammen und dem Hauptprogramm sind sie
,,unbekannt". Sie können dort nicht verwendet werden!
Es ist zulässig, dass Bezeichner mit denselben Namen sowohl global als
auch lokal vereinbart werden dürfen. Für den Fall gilt, dass stets der
lokale Bezeichner Vorrang vor dem globalen Bezeichner hat.
Beispiel: Der globale Bezeichner x, im Hauptprogramm vereinbart, hat in
Unterprogrammen nur dann Gültigkeit, wenn dort kein Bezeichner x
vereinbart worden ist. Wurde jedoch auch in einem Unterprogramm ein
Bezeichner x deklariert, so werden mit diesem lokalen Bezeichner
Operationen ausgeführt, wenn dieser im Unterprogramm angesprochen
wird. Der globale Bezeichner bleibt davon unberührt und unverändert.
Verwenden Sie in Unterprogrammen ausschließlich lokale Bezeichner.
Damit erreichen Sie die größtmögliche Unabhängigkeit der Routinen von
einem bestimmten Hauptprogramm und können sie in andere
Programme übernehmen oder in Bibliotheken zusammenfassen. (vgl.
Standardbibliotheken von Turbo Pascal - Units)
Grundwissen Unterprogramme
Grundstruktur Prozeduren
file:///E|/homepage/Pascal/lokale_und_globale_bezeichner.htm [07.10.2001 00:37:41]

Grundstruktur einer Prozedur
Grundstruktur einer Prozedur
Jede Prozedur ist wie ein "normales" Programm aufgebaut und weicht
nur in zwei Teilen von diesem ab:
●
●
Am Anfang der Prozedur steht das reservierte Wort PROCEDURE
anstelle von dem reservierten Wort PROGRAM.
Am Ende der Prozedur steht keine END mit einem Punkt, sondern
ein END mit einem Semikolon.
Die Grundstruktur einer Prozedur sieht wie folgt aus:
PROCEDURE ProzedureName;
{Hier beginnt der Deklarationsteil}
CONST {Hier werden
lokale Konstanten
vereinbart}
TYPE {Hier werden
lokale Datentypen
vereinbart}
VAR {Hier werden
lokale Variablen
vereinbart}
{Hier werden lokale Unterprogramme der
Prozedur ProzedurName vereinbart}
{Hier endet der Deklarationsteil}
BEGIN
{Es folgen Anweisungen der Prozedur}
END;
Wenn Sie die Struktur der Prozedur mit der eines Programms
vergleichen, werden Sie eine große Ähnlichkeit feststellen. Die
Vereinbarungen einer Prozedure beginnt mit dem reservierten Wort
PROCEDURE worauf der Name (Bezeichner) folgt, über den Sie die
Prozedure im aufrufenden Programm ansprechen (aufrufen) können.
Anschließend folgen Vereinbarungsteil und Hauptprogramm der
Prozedure.
file:///E|/homepage/Pascal/grundstruktur_einer_prozedur.htm (1 of 2) [07.10.2001 00:37:46]

Grundstruktur einer Prozedur
ACHTUNG: Beachten Sie, dass alle Vereinbarungen und Routinen, die
in einer Prozedure deklariert werden, lokal sind.
Und jetzt zum besserem Verständnis, noch ein kleines Beispiel:
PROGRAM proc_test;
USES crt;
PROCEDURE Info;
CONST
Version = '1.0';
BEGIN
Writeln('Programmversion: ' + Version);
END;
BEGIN
Info;
Readln;
END.
Hier wird die Prozedur Info benutzt um die Version des Programms
aufzurufen, die Prozedur Info gibt den Inhalt der Konstante Version aus.
Globale und lokale Bezeichner Prozeduren ohne Werteparameter
file:///E|/homepage/Pascal/grundstruktur_einer_prozedur.htm (2 of 2) [07.10.2001 00:37:46]

Prozeduren ohne Werteparameter
Prozeduren ohne Werteparameter
Deklaration:
procedure ProzedurName;
Zuerst ein Beispiel für eine einfache Prozedur:
PROCEDURE warten;
VAR
ch: char;
BEGIN
gotoxy(1, 25);
write('Bitte eine Taste Drücken ...');
ch := readkey;
END;
Durch die Verwendung einer Prozedur, die den entsprechenden
Programmtext enthält, ist jeweils nur eine Anweisung im Hauptprogramm
notwendig, statt vorher drei Anweisungen.
warten;
Da die Prozedur nicht auf globale Variablen zugreift ist sie unabhängig
vom jeweiligen Hauptprogramm.
Die Prozedur soll so verändert werden, dass der Ausgabetext (Bitte eine
...) auf einer beliebigen Bildschirmposition ausgegeben wird. Zur Lösung
dieses Problems gibt es zwei prinzipielle Möglichkeiten:
1. Die Verwendung von globalen Variablen (Variablen die im
Hauptprogramm vereinbart wurden). Auf eine globale Variable
kann in einem Unterprogramm zugegriffen werden: lesend oder
schreibend (z.B. a := c; mit a und c im Hauptprogramm deklariert).
Ein Unterprogramm das auf globale Variablen zugrifft ist nicht
mehr vom Hauptprogramm unabhängig, d.h. es kann nicht in
anderen Programmen benutzt werden!
Dies widerspricht dem Modulkonzept von TP (dies trifft auch auf
andere Programmiersprachen zu wie z.B. C++) und ist somit kein
Modul. (Schlechter Programmierstil)
2. Die Verwendung von Wertparametern
file:///E|/homepage/Pascal/prozeduren_ohne_werteparameter.htm (1 of 2) [07.10.2001 00:37:59]

Prozeduren ohne Werteparameter
Und jetzt noch ein Beispiel mit der Oben genannten Prozedur Warten:
PROGRAM wait;
USES crt;
PROCEDURE Warten;
VAR
ch: char;
BEGIN
gotoxy(1, 25);
write('Bitte eine Taste Drücken ...');
ch := readkey;
END;
BEGIN
Writeln('Das Programm wird angehalten!');
Warten;
Writeln('Und weiter!');
Readln;
END.
Das Programm ruft die Prozedure Warten auf, welche das Programm
solange anhält bis eine Taste gedrückt wird.
Grundstruktur einer Prozedur Prozeduren mit Werteparameter
file:///E|/homepage/Pascal/prozeduren_ohne_werteparameter.htm (2 of 2) [07.10.2001 00:37:59]

Prozeduren mit Werteparametern
Prozeduren mit Werteparametern
TP bietet die Möglichkeit, Prozeduren vom aufrufenden Programm aus
Werte zu übergeben, mit denen innerhalb der Prozedur gearbeitet
werden kann. Dadurch wird ein Unterprogramm noch universeller
einsetzbar, da jedes Programm individuelle Werte an die Routine
übergeben kann; sogar innerhalb eines Programms können beim
mehrmaligen Aufruf eines Unterprogramms verschiedene Werte
übergeben werden.
Deklaration:
PROCEDURE Name (Bezeichner1, ... : Typ1;
Bezeichner2, ... : Typ2;
... : ....;)
In der Parameterliste werden die Werte mit ihren Datentypen aufgeführt.
Werte gleichen Typs werden durch Kommata, Werte unterschiedlichen
Typs durch ein Semikolon getrennt. z.B.:
PROCEDURE Test ( a, b: Byte; ch: Char);
BEGIN
END;
Die Prozedur TEST muss, nach dieser Deklaration, mit genau zwei
Werten vom Typ Integer und einem Wert vom Typ Char aufgerufen
werden, und zwar genau in dieser Reihenfolge!
z.B.: Test (a, b, 'C');
Sie können entweder einen Wert oder eine Variable übergeben!
A und B werden wie lokale Variablen der Prozedur Test behandelt. Ihnen
werden die übergebenen Werte zugewiesen. Über den Namen der
Variable kann mit den Werten innerhalb der Prozedur gearbeitet werden.
ACHTUNG: Bei der Wertübergabe greift die Prozedur niemals auf die
eigentlichen Argumente des Aufrufs zu. Die Werte, die von der Prozedur
verarbeitet werden, sind nur lokale Kopien, welche auf dem Stack
gespeichert werden. Bei der Wertübergabe wird der Inhalt der
tatsächlichen Argumente nicht verändert!
Die Wertübergabe kann jedoch nicht bei allen Prozeduren verwendet
file:///E|/homepage/Pascal/prozeduren_mit_werteparametern.htm (1 of 2) [07.10.2001 00:38:08]

Prozeduren mit Werteparametern
werden. In folgenden Fällen ist die Wertübergabe nicht von Vorteil:
●
●
Bei der Übergabe von großen Klassenobjekten! (Zeit und
Platzbedarf ist für die Praxis zu hoch!)
Wenn die Werte des Arguments geändert werden müssen!
Prozeduren ohne Werteparameter
Prozeduren mit Variablenparameter
file:///E|/homepage/Pascal/prozeduren_mit_werteparametern.htm (2 of 2) [07.10.2001 00:38:08]

Prozeduren mit Variablenparameter
Prozeduren mit Variablenparameter
Soll zwischen dem aufrufenden Programm und einer Prozedur ein
zweiseitiger Datenaustausch stattfinden, dann müssen der Prozedur
anstatt Wertparameter Variablenparameter übergeben werden. TP legt
von den übergebenen Variablen, im Gegensatz zur Übergabe von
Werteparametern, keine Kopie auf dem Stack an, sondern arbeitet direkt
mit den Variablen! Ein Unterprogramm kann also den Wert einer
Variablen verändern und den veränderten Wert an das aufrufende
Programm zurück liefern!
Deklaration:
PROCEDURE Name (var Bezeichner1, ... : Typ1;
var Bezeichner2, ... : Typ2;
var ... : ....;)
z.B: prozedure Test (var a: Byte; var ch: Char);
Bei der Parameterübergabe sind auch Mischformen statthaft!
z.B.: procedure Test (a, b; Byte; var ch: Char);
Prozeduren mit Werteparameter
Grundstruktur einer Funktion
file:///E|/homepage/Pascal/prozeduren_mit_variablenparamete.htm [07.10.2001 00:38:24]

Grundstruktur einer Funktion
Grundstruktur einer Funktion
In Pascal sind zwei Typen von Unterprogrammen möglich, Prozeduren
und Funktionen. eine Funktion ist ein Unterprogramm, das dem rufenden
Programm genau einen Ergebniswert übergibt.
Jede Funktion ist wie ein "normales" Programm aufgebaut und weicht
nur in zwei Teilen von diesem ab:
●
●
Am Anfang der Funktion steht das reservierte Wort FUNCTION
anstelle von dem reservierten Wort PROGRAM.
Am Ende der FUNCTION steht keine END mit einem Punkt,
sondern ein END mit einem Semikolon.
Die Grundstruktur einer Funktion sieht wie folgt aus:
FUNCTION Name(Parameterliste): Ergebnistyp;
{Hier beginnt der Deklarationsteil}
CONST {Hier werden
lokale Konstanten
vereinbart}
TYPE {Hier werden
lokale Datentypen
vereinbart}
VAR {Hier werden
lokale Variablen
vereinbart}
{Hier endet der Deklarationsteil}
BEGIN
{Es folgen Anweisungen der Funktion}
END;
Wenn Sie die Struktur der Funktion mit der eines Programm vergleichen,
werden Sie eine große Ähnlichkeit feststellen. Die Vereinbarungen einer
Funktion beginnt mit dem reservierten Wort FUNCTION worauf der
Name (Bezeichner) folgt, über den Sie die FUNCTION im aufrufenden
Programm ansprechen (aufrufen) können. Anschließend folgen
file:///E|/homepage/Pascal/grundstruktur_einer_funktion.htm (1 of 3) [07.10.2001 00:38:31]

Grundstruktur einer Funktion
Vereinbarungsteil und Hauptprogramm der Funktion.
ACHTUNG: Beachten Sie, dass alle Vereinbarungen und Routinen, die
in einer Funktion deklariert werden, lokal sind.
Schauen wir uns nun einmal den Funktionskopf etwas genauer an:
FUNCTION Name(Parameterliste): Ergebnistyp;
Nach dem reservierten Wort FUNCTION, folgt der Funktionsname und
danach, in Klammern, ein oder mehrere formale Parameter mit ","
aufgezählt. Nach der Parameterliste folgt ein Doppelpunkt, dem der
Datentyp des Funktionswertes folgt, der nach der Funktionsausführung
dem rufenden Programm übergeben wird. Während der Ausführung
muss dem Funktionsnamen mindestens einmal ein Wert dieses Typs
zugewiesen werden.
Datentypen für die Parameterliste bzw. dem Ergebniswert sind:
Integer, Byte, Real, Char, Boolean oder String.
Und jetzt zum besserem Verständnis, noch ein kleines Beispiel:
PROGRAM func_test;
USES crt;
VAR
Brutto_Preis, Netto: Real;
FUNCTION Brutto(Netto: Real): Real;
BEGIN
Brutto := 16 * Netto / 100;
END;
BEGIN
Netto := 34.89;
Brutto_Preis := Brutto(Netto);
END.
Hier wird die Funktion Brutto benutzt, um den Bruttopreis aus einem
Nettopreis zu errechnen. Der Funktion Brutto wird der Nettowert der
Variable Netto übergeben, woraus die Funktion den Bruttopreis
errechnet und zurück gibt. Der Bruttopreis wird dann in die Variable
Brutto_Preis eingelesen.
file:///E|/homepage/Pascal/grundstruktur_einer_funktion.htm (2 of 3) [07.10.2001 00:38:31]

Grundstruktur einer Funktion
Prozeduren mit Variablenparameter
Funktionen
file:///E|/homepage/Pascal/grundstruktur_einer_funktion.htm (3 of 3) [07.10.2001 00:38:31]

Funktionen
Funktionen
In Pascal sind zwei Typen von Unterprogrammen möglich, Prozeduren
und Funktionen. eine Funktion ist ein Unterprogramm, das dem rufenden
Programm genau einen Ergebniswert übergibt.
Für den Anweisungsteil einer Funktion gelten die gleichen Regeln wie für
Hauptprogramm bzw. für eine Prozedur. Zusätzlich jedoch muss man
irgendwo im Anweisungsteil dem Funktionsnamen ein Ergebnis
zuweisen. Erst dadurch kann dieser Wert dem rufenden Hauptprogramm
übergeben bzw. bekannt gemacht werden. Der Funktionsname wird wie
ein Variablenname behandelt (Beispiel: Brutto := 16 * Netto / 100 mit
dem Namen Brutto).
●
den Funktionsnamen behandelt man wie einen Konstantennamen:
z.B. mit Writeln ausgeben, mit IF Abfragen und auf der rechten
Seite einer Zuweisung schreiben. Hinter dem Funktionsnamen
verbirgt sich ein Funktionswert.
Zum Schluss noch ein kleines Beispielprogramm:
PROGRAM Werte;
VAR
Brutto, Netto: Real;
I: Byte;
FUNCTION B_Preis(Netto, Mwst: Real): Real;
BEGIN
Brutto_Preis := 16 * Mwst / 100;
END;
BEGIN
FOR I := 1 TO 10 DO
BEGIN
Writeln('Netto: ');
Readln(Netto);
Brutto := B_Preis(Netto, 16);
Writeln('Brutto: ', FloatToStr(Brutto));
END;
Readln;
END.
file:///E|/homepage/Pascal/funktionen.htm (1 of 2) [07.10.2001 00:38:38]

Funktionen
Grundstruktur einer Funktion
Strukturierte Datentypen
file:///E|/homepage/Pascal/funktionen.htm (2 of 2) [07.10.2001 00:38:38]

Tabelle eine Spalte zentriert
Strukturierte Datentypen
Strukturierte Datentypen werden aus einfachen Datentypen so
zusammengesetzt, dass unter einem Namen mehrere Werte bzw.
Elemente gespeichert und gelesen werden können.
Hier ein kleines Beispiel ohne Strukturierten Datentyp: Es soll der
durchschnittliche Absatz eines Artikels pro Woche ermittelt werden.
VAR
AbsatzMo: Integer;
BEGIN
.
.
AbsatzMo := 56;
.
.
END.
Diese Vorgehensweise würde bedeuten, dass fünf weitere Variablen
(AbsatzDi, AbsatzMi ...) deklariert und initialisiert werden müssten.
Benutz man jedoch einen strukturierten Datentyp muss nur eine Variable
deklariert werden, welche die Daten für alle 5 Wochentage enthält.
Strukturierte Datentypen bieten daher folgende Vorteile:
●
●
Bessere Überschaubarkeit des Quelltextes.
Weniger Programmieraufwand.
Zu den Strukturierten Datentypen gehören unter anderem Arrays,
Records, Mengen und der Datentyp File.
Funktionen
Arrays
file:///E|/homepage/Pascal/struktorierte_datentypen.htm [07.10.2001 00:38:46]

Arrays
Arrays
Der Datentyp Array speichert mehrere Elemente eines gleichen
Datentyps unter einem Namen ab. Wir unter scheiden dabei zwei Arten:
●
●
eindimensionale Arrays
zweidimensionale Arrays
Eindimensionale Arrays
In eindimensionalen Arrays werden die Daten in Form einer Reihe
abgespeichert. Mann könnte sagen das ein Array ein Schrank mit
mehreren Schubladen darstellt. Wobei der Schrank das Array und die
Schubladen die Elemente des Arrays sind.
Die explizierte Deklaration eines eindimensionalen Arrays erfolgt wie
folgt:
VAR
Absatz: Array [1..5] OF Integer;
Für ein Array müssen der Datentyp der zu speichernden Elemente sowie
die Anzahl und der Datentyp der Indizes vereinbart werden.
Die Allg. Form lautet:
VAR
VarName: Array [Konst1..Konst2] OF Datentyp;
VarName legt den Variabelennamen für das Array fest, über den Sie
später auf das Array zugreifen können. Mit dem reservierte Wort Array
beginnt die Deklaration des Arrays, worauf die Indexgrenzen bzw. der
Ausdehnungsbereich des Arrays folgt. Dabei ist zu beachten das
Konstante1 < Konstante2 ist. Nach den Wertebereich folgt die
Festlegung des Datentyps für die Elemente des Arrays. Die Elemente
können beliebige einfache und strukturierte Datentypen darstellen.
Der Zugriff auf die Elemente eines Arrays erfolgt prinzipiell über den
Index. Der Indextyp muss also immer skalierbar sein.
Absatz [1] := 12;
Hier wird dem ersten Element des Arrays Absatz der Wert 12
file:///E|/homepage/Pascal/arrays.htm (1 of 2) [07.10.2001 00:38:52]

Arrays
zugewiesen. Genauso einfach können die Daten aus einem Array
ausgegeben werden.
Writeln('Freitag: ', Absatz[5]);
Natürlich kann die Ausgabe auch mit Hilfe einer FOR-Schleife erfolgen,
was bei großen Datenmengen sehr sinnvoll ist:
For i := 1 to 5 do
Writeln('Absatz ', I, ': ', Absatz[I]);
Zweidimensionale Arrays
Ein zweidimensionales Array ist eine Tabelle mit waagerechten Zeilen
und senkrechten Spalten. Alle Elemente haben denselben Datentyp.
Über den Zeilen und Spaltenindex wird auf das Element direkt
zugegriffen.
Deklaration eines zweidimensionalen Arrays:
VAR
Absatz: Array [1..2, 1..6] OF Real;
Dieses Beispielarray besteht aus 2 Spalten und 6 Zeilen.
Das Einlesen und Eingeben von Werten in einem zweidimensionale
Array erfolgt auf die gleiche Weise wie beim eindimensionalen Array.
Strukturierte Datentypen
Records
file:///E|/homepage/Pascal/arrays.htm (2 of 2) [07.10.2001 00:38:52]

Records
Records
Ein Record lässt sich mit einem Datensatz einer Datenbank vergleichen.
In diesem lassen sich Datenelemente mit unterschiedlichen Datentypen
zusammenfassen.
Allg. Form der Typenvereinbarung eines Records:
TYPE
RecordTyp = RECORD
Datenfeld1: Datentyp1;
.....
Datenfeld2: Datentyp2;
END;
VAR
RecordVar: Recordtyp;
Hier ein kleines Beispiel für eine Record Deklaration:
TYPE
Tkunden = RECORD
Name: String;
Umsatz: Real;
END;
VAR
Kunde: Tkunde;
Der schreibende Zugriff auf ein Recordelement erfolgt nach folgendem
Schema:
RecordVar.Datenfeld := Wert;
Der Punkt wird als so genannter Qualifizierer genutzt. Ein solcher
Ausdruck mit Punktnotation nennt man einen qualifizierten Ausdruck und
bildet auch die Grundlage beim Zugriff auf Eigenschaften und Methoden
von Objekten (Bei Objektorientierten Programmiersprachen).
Beispiel für den schreiben Zugriff auf ein Recordelement:
Kunde.Name := 'Alex';
Der lesende Zugriff erfolgt nach dem gleichen Schema wie beim
file:///E|/homepage/Pascal/records.htm (1 of 2) [07.10.2001 00:39:00]

Records
Schreiben, an dem folgendem Beispiel wird dies deutlich:
Writeln('Ihr Name ist:', Kunde.Name);
Arrays
Mengendeklaration
file:///E|/homepage/Pascal/records.htm (2 of 2) [07.10.2001 00:39:00]

Mengendeklaration
Mengendeklaration
Eine Menge ist eine Zusammenfassung von maximal 256 Elementen
eines gleichen skalierbaren (ordinalen) Grundtyps (Datentyps).
Explizite Deklaration einer Menge vom Basistyp Byte:
TYPE
TMenge = SET of Byte;
VAR
Menge: TMenge;
Implizierte Deklaration einer Menge vom Basistyp Byte:
VAR
Menge: SET of Byte;
Der Nachteil der impliziten Deklaration ist, dass die Variable Menge nicht
als Parameter übergeben werden kann. Es ist deshalb immer ratsam
eine Menge explizit zu deklarieren.
Bitte beachten Sie, dass hier zum Beispiel der Datentyp Integer nicht
verwendet werden kann, da er den gültigen Wertebereich von 256
Elementen überschreitet.
In vielen fällen ist es nicht nötig den gesamten Wertebereich eines
Datentyps zu reservieren, in diesem Fall können Sie die Menge mit
einem bestimmten Bereich des Basistyps deklarieren.
TYPE
TMenge = SET of 1..20;
In der obigen Beispieldeklaration ist TMenge eine Teilmenge vom
Datentyp Byte. Beim deklarieren einer Teilmenge muss kein Datentyp
angegeben werden, da der Compiler in automatisch erkennt.
Records
Wertzuweisungen
file:///E|/homepage/Pascal/mengendeklaration.htm [07.10.2001 00:39:11]

Wertzuweisungen
Wertzuweisungen
Leider ist es nicht möglich ein Mengenelement direkt über die Tastatur
einzugeben, da eine Menge, im Vergleich zu einem Array, keinen Index
besitzt.
VAR
Menge1: TMenge;
Menge2: TMenge;
BEGIN
.
Writeln('Wert 1');
readln(Menge1);
.
END.
Das obige Programm ergibt einen offensichtlichen Fehler, da versucht
wird den Wert einer Menge über die Tastatur einzulesen.
Die Mengenvariablen werden statt dessen mit Werten belegt, indem die
Elemente in einer Mengenklammer [..] aufgezählt werden.
VAR
Menge1: TMenge;
Menge2: TMenge;
BEGIN
.
Menge1 := [1, 2, 3, 4, 5 ,6];
Menge2 := [1..15];
.
END.
Bei der Angabe der Mengenelemente, spielt die Reihenfolge keine Rolle.
Die Hauptsache ist das alle benötigten Elemente angegeben sind.
Mengendeklaration
Mengenoperationen
file:///E|/homepage/Pascal/wertzuweisungen.htm [07.10.2001 00:39:17]

Mengenoperationen
Mengenoperationen
In Turbo Pascal existieren, wie in der Mathematik, drei grundlegende
Mengenoperationen:
●
●
●
Die Vereinigungsmenge
Die Differenzmenge
Die Durchschnittsmenge
Am folgenden Programmbeispiel werde ich versuchen die drei
Mengenoperationen zu erklären.
Als erstes die Deklaration der Menge:
TYPE
TGrossBuStab = SET of 'A'..'X';
VAR
Menge1: TGrossBuStab;
Menge2: TGrossBuStab;
Menge3: TGrossBuStab;
Jetzt noch die Initialisierung (Wertzuweisung) der Mengenvariablen:
Menge1 := ['A', 'B', 'C'];
Menge2 := ['A', 'X', 'Y'];
Die Initialisierung der Variable Menge3 muss nicht erfolgen das in ihr das
Ergebnis der Mengenoperationen abgespeichert wird.
Vereinigungsmenge:
Zu einer Vereinigungsmenge gehören alle Elemente, die mindestens in
einer der beiden Mengen enthalten sind.
Menge3 := Menge1 + Menge2;
Das Ergebnis der Operation wird in Menge3 abgespeichert. Folgende
Elemente befinden sich danach in Menge3: C, B, A, X, Y.
Differenzmenge:
file:///E|/homepage/Pascal/mengenoperationen.htm (1 of 2) [07.10.2001 00:39:25]

Mengenoperationen
Zu einer Differentmenge gehören alle Elemente, die in Menge1, aber
nicht in Menge2 enthalten sind.
Menge3 := Menge1 - Menge2;
Das Ergebnis der Operation wird in Menge3 abgespeichert. Folgende
Elemente befinden sich danach in Menge3: C, B.
Durchschnittsmenge:
Zu einer Durchschnittsmenge gehören alle Elemente, die gleichzeitig in
beiden Mengen enthalten sind.
Menge3 := Menge1 * Menge2;
Das Ergebnis der Operation wird in Menge3 abgespeichert. Folgende
Elemente befinden sich danach in Menge3: A.
Wertzuweisungen
Wertausgabe
file:///E|/homepage/Pascal/mengenoperationen.htm (2 of 2) [07.10.2001 00:39:25]

Wertausgabe
Wertausgabe
Leider können Mengenelemente weder direkt von der Tastatur
eingelesen, noch direkt auf dem Monitor ausgegeben werden.
Deshalb gibt es in Turbo Pascal den IN - Operator. Der Operator
überprüft, ob eine Variable mit einem Mengenelement übereinstimmt.
Der IN - Operator wird oftmals als Abbruchbedingung in fußgesteuerten
Schleifen benutzt.
TYPE
TMenge = SET of Char;
VAR
Menge: TMenge;
BEGIN
Menge := ['J', 'j', 'Y', 'y'];
REPEAT
.
.
UNTIL Abbruch IN Menge;
END.
Mengenoperationen
Mengen verändern
file:///E|/homepage/Pascal/wertausgabe.htm [07.10.2001 00:39:31]

Mengen verändern
Mengen verändern
An dieser Stelle möchte ich nochmals erwähnen, dass Mengenelemente
nicht direkt über die Tastatur eingelesen werden können. Trotzdem ist es
möglich, Mengeninhalte mit Hilfe der Mengenoperationen flexibel zu
gestalten.
Zum Beispiel soll ein eingegebener Text dahingehend manipuliert
werden, dass aus ihm alle Buchstaben entfernt werden und in einer
Menge abgespeichert werden.
Die Manipulation ist nach folgenden Schritten durchzuführen:
●
Der Ausgangspunkt ist eine leere Menge:
Aufbaumenge := [ ];
●
Als nächstes muss eine Prüfmenge festgelegt werden:
Pruefmenge := ['a'..'z'] + ['A'..'Z'];
●
Prüfen ob Buchstabe in Menge enthalten ist:
IF Text[1] IN Pruefmenge THEN .....
●
Als weiteres wird ein gefundener Buchstabe in die Aufbaumenge
durch Iteration eingefügt:
Aufbaumenge := Aufbaumenge + [Text[1]];
Die Variable Text beinhaltet den eingegebenen Text, die [1] gibt die
Position im Text an, an der geprüft wird. Um einen ganzen Text zu
prüfen ist es ratsam eine FOR-Schleife zu benutzen.
FOR i := 1 to length(text) do
IF Text[I] IN Pruefmenge THEN
Aufbaumenge := Aufbaumenge + [Text[I]];
Wertausgabe
Dateiverarbeitung
file:///E|/homepage/Pascal/mengen_veraendern.htm [07.10.2001 00:39:36]

Dateiverarbeitung
Dateiverarbeitung
Datei: Unter einer Datei versteht man eine Sammlung von
zusammengehörenden Daten, die auf einem Externem Speicher wie
zum Beispiel eine Diskette oder Festplatte sichergestellt werden. Damit
ist es jetzt möglich zum Beispiel eingegebene Temperaturwerte beim
nächsten Start eines Programms wieder zu verwenden.
Datenverarbeitung: Dateien übersteigen häufig die interne
Speicherkapazität des Computers. Das bedeutet, dass stets nur ein Teil
der Datei im RAM gehalten werden kann. Bei der Datenverarbeitung
geht es somit neben der Verarbeitung von Daten im RAM, stets auch um
das Übertragen von Daten zwischen dem RAM und den Externspeichern
bzw. Ein-/Ausgabegeräte.
Dateneinheiten: Jede Datei besteht aus mehreren Datensätzen, die in
Datenfelder eingeteilt sind. Jedes Feld wiederum besteht aus einer Folge
von Zeichen (Bytes), wobei sich ein Byte aus 8 Bits zusammensetzt.
Mengen verändern
Dateien anlegen bzw. öffnen
file:///E|/homepage/Pascal/dateiverarbeitung.htm [07.10.2001 00:39:41]

Dateien anlegen bzw
Dateien anlegen bzw. öffnen
Die Grundlage für die Datenstruktur einer Datei ist ein Record in dem
die Struktur des Datensatzes mit seinen Datenfeldern festgelegt ist.
TYPE
TAdresse = RECORD
AdrNr: Byte;
Name: String[20];
END;
Ist die Struktur des Datensatzes angelegt erfolgt die Zuweisung zu einem
Datei-Objekt, im folgendem Beispiel ist das Objekt TDatei eine Datei mit
dem Inhalt vom Record TAdresse.
TDatei = FILE of TAdresse;
Als nächstes müssen jetzt noch Variablen für die erstellten Objekte
vergeben werden, über die dann später im Programm auf die Objekte
zugegriffen wird.
VAR
Adresse: TAdresse;
AdressDat: TDatei;
Ist die Datenstruktur erstellt kann auf eine Datei zugegriffen werden. Die
Schnittstelle für den Zugriff auf Dateien schafft in Turbo Pascal die
Anweisung Assign. Die Anweisung Assign stehlt sozusagen die
Verbindung zwischen Programm und Datei her.
Die allg. Form der Anweisung lautet:
Assign(Dateivariable, Dateiname);
Bezogen auf unser Beispiel sieht die Anweisung wie folgt aus:
Assign(AdressDat, 'testDat.dat');
Damit ist die Verbindung von Programm und Datei hergestellt. Assign
interessiert es dabei nicht ob die Datei existiert, da Assign nur die
Schnittstelle mit der angegebenen Datei initialisiert. Beachten Sie, dass
Assign die Grundlage für jede Datei-Operation darstellt, sie ist also
file:///E|/homepage/Pascal/dateien_anlegen_bzw.htm (1 of 2) [07.10.2001 00:39:44]

Dateien anlegen bzw
immer zuerst aufzurufen.
Ist die Verbindung zur Datei hergestellt, kann eine Datei geöffnet bzw.
eine neue Angelegt werden.
Das erstellen einer Datei erfolgt mit der Anweisung Rewrite. Rewrite
erstellt eine neue leere Datei auf dem Datenträger, dabei ist zu
beachten, dass die Datei überschreiben wird wenn sie bereits existiert.
Rewrite(AdressDat);
Soll eine vorhandene Datei geöffnet werden, erfolgt dies mit der
Anweisung Reset.
Reset(AdressDat);
Jetzt können Sie Daten aus einer Datei lesen bzw. in eine Datei
schreiben. Sind alle Dateioperationen beendet, sollte die Datei immer mit
der Anweisung Close geschlossen werden.
Close(AdressDat);
Dateiverarbeitung
In eine Datei schreiben
file:///E|/homepage/Pascal/dateien_anlegen_bzw.htm (2 of 2) [07.10.2001 00:39:44]

In eine Datei schreiben
In eine Datei schreiben
Beachten Sie, dass bevor Sie in eine Datei schreiben können, die in den
vorherigen Seiten besprochenen Vorraussetzungen gegeben sein
müssen. Also das erstellen einer Datenstruktur, das Herstellen einer
Verbindung und das öffnen bzw. erstellen einer Datei.
Das sequentielle Schreiben in eine Datei, also das schreiben an die
aktuelle Adresse (Position) erfolgt mir der Anweisung Write.
Der Prototyp der Anweisung lautet:
Write(Dateivariable, Recordvariable);
Auf unser Beispiel aus den vorherigen Seiten angewandt, lautet die
Anweisung wie folgt:
Write(AdressDat, Adresse);
Die Anweisung Write schreibt den Inhalt des Records Adresse in die
Datei AdressDat, beachten Sie dabei, dass Sie vor dem Schreiben in die
Datei den Elementen des Records Werte zuweisen müssen.
Adresse.Adr := 12;
Adresse.Name := 'Katja';
Zum Abschluss noch ein kleines Beispiel zum Schreiben in eine neue
Datei, in dem alle Schritte ersichtlich werden:
PROGRAM Schreib;
USES Crt;
TYPE
TAdresse = RECORD
AdrNr: Byte;
Name: String[12];
END;
TDatei = FILE of TAdresse;
VAR
AdressDat: TDatei;
Adresse: TAdresse;
file:///E|/homepage/Pascal/in_eine_datei_schreiben.htm (1 of 2) [07.10.2001 00:39:53]

In eine Datei schreiben
BEGIN
Assign(AdressDat, 'testdat.dat');
Rewrite(AdressDat);
Adresse.AdrNr := 12;
Adresse.Name := 'Katja';
Write(AdressDat, Adresse);
Close(AdressDat);
Readln;
END.
Dieses Programm erstellt eine neue Datei namens testdat.dat und
schreib in diese einen Datensatz.
Dateien anlegen bzw. öffnen
Aus einer Datei lesen
file:///E|/homepage/Pascal/in_eine_datei_schreiben.htm (2 of 2) [07.10.2001 00:39:53]

Aus einer Datei lesen
Aus einer Datei lesen
Beachten Sie, dass bevor Sie aus einer Datei lesen können, die in den
vorherigen Seiten besprochenen Vorraussetzungen gegeben sein
müssen. Also das erstellen einer Datenstruktur, das Herstellen einer
Verbindung, das öffnen einer Datei und natürlich auch dass vorhanden
sein von Datensätzen in der Datei.
Das sequentielle lesen einer Datei, also das lesen von der aktuellen
Adresse (Position) erfolgt mir der Anweisung Read.
Der Prototyp der Anweisung lautet:
Read(Dateivariable, Recordvariable);
Auf unser vorheriges Beispiel angewandt lautet die Anweisung wie folgt:
Read(AdressDat, Adresse);
Die Anweisung Read liest den Inhalt des Aktuellen Datensatzes aus der
Datei AdressDat in das Record Adresse. Mit den ausgelesenen Werten
im Record können Sie nun weiterarbeiten.
Nummer := Adresse.Adr;
Name := Adresse.Name;
Auch hier ein kleines Beispiel zum lesen aus einer Datei, in der alle
Schritte etwas mehr ersichtlich werden:
PROGRAM lesen;
USES Crt;
TYPE
TAdresse = RECORD
AdrNr: Byte;
Name: String[12];
END;
TDatei = FILE of TAdresse;
VAR
AdressDat: TDatei;
Adresse: TAdresse;
Nummer: Byte;
file:///E|/homepage/Pascal/aus_einer_datei_lesen.htm (1 of 2) [07.10.2001 00:39:59]

Aus einer Datei lesen
Name: String[12];
BEGIN
Assign(AdressDat, 'testdat.dat');
Reset(AdressDat);
Read(AdressDat, Adresse);
Nummer := Adresse.AdrNr;
Name := Adresse.NameM
Close(AdressDat);
Readln;
END.
Das Programm liest einen Datensatz aus einer Datei namens testdat.dat
und speichert die Daten dann im Record Adresse ab.
Schreiben in eine Datei
Datensatzzeiger
file:///E|/homepage/Pascal/aus_einer_datei_lesen.htm (2 of 2) [07.10.2001 00:39:59]

Datensatzzeiger
Datensatzzeiger
Prüft, ob das Ende einer Datei erreicht ist. Der sogenannte
Datensatzzeiger wird während der Ein- bzw. Ausgabe in eine Datei
ständig aktualisiert.
Allgemeiner Prototyp der Funktion:
Eof(Dateivariable);
Anwendung auf unser Beispiel:
Eof(AdressDat);
Eof prüft, ob es in der angegebenen Datei ohne explizite Veränderung
der momentanen Position noch etwas zu lesen gibt und liefert True,
wenn die Datei keine Komponenten enthält, nur für Schreibaktionen
geöffnet worden ist, oder der Positionszeiger innerhalb der Datei hinter
der letzten Komponente steht.
Der Datensatzzeiger kann sehr gut in einer While - Schleife verwendet
werden, zum Beispiel um eine ganze Datei auszulesen.
BEGIN
I := 1;
WHILE (Eof(AdressDat) true) DO
BEGIN
Read(AdressDat, Adresse);
Nummern[i] := Adresse.AdrNr;
Namen[i] := Adresse.Name;
I := i +1;
END;
END.
In dem Beispiel wird die While - Schleife solange wiederholt bis Eof
Wahr (True) zurück gibt. Innerhalb der While - Schleife werden die
ausgelesenen Daten dann in ein Array eingelesen.
Möchten Sie die aktuelle Position in einer Datei ermitteln, existiert dazu
die Anweisung FilePos.
Die allg. Form lautet:
FilePos(AdressDat);
file:///E|/homepage/Pascal/datensatzzeiger.htm (1 of 2) [07.10.2001 00:40:11]

Datensatzzeiger
Auf unser Beipiel angewandt sieht dies wie folgt aus:
Pos := FilePos(AdressDat);
Möchten Sie nun den Datensatzzeiger auf eine Bestimmte Position
setzen, nutzen Sie dafür die Funktion Seek.
Der Prototyp der Prozedur lautet:
Seek(Dateivariable, Datensatz);
In unserem Beispiel sieht das wie folgt aus:
Seek(AdressDat, 10);
Setzt den Datensatzzeiger auf die 10. Position. Benötigen Sie nun noch
die Anzahl der Datensätze, steht Ihnen die Funktion FileSize zur
Verfügung.
Seek(AdressDat, FileSize(AdressDat);
Das Beispiel setzt den Datensatzzeiger auf die letzte Position in der
Datei, da die Anzahl der Datensätze der letzen Position in der Datei
entspricht.
Lesen aus einer Datei
Datensatz löschen
file:///E|/homepage/Pascal/datensatzzeiger.htm (2 of 2) [07.10.2001 00:40:11]

Datensatz löschen
Datensatz löschen
In Turbo Pascal existiert keine Anweisung zum löschen von
Datensätzen, das ganze kann man nur über einen Umweg erreichen.
Das löschen von Datensätzen erfolg mit dem sogenannten Vater-Sohn-
Prinzip. Das Vater-Sohn-Prinzip besagt das eine neue Datei (Sohn)
angelegt wird, die von der Grunddatei (Vater) abgeleitet ist.
In dieser neuen Datei werden nur die Datensätze übernommen die nicht
gelöscht werden sollen. Diese Form erscheint ziemlich umständlich. Sie
hat aber den entscheidenden Vorteil, dass bei Verlust der Sohn Datei ihr
Inhalt aus der Vater Datei rekonstruiert werden kann.
Jetzt noch ein kleines Beispiel welches einen Datensatz unter
Verwendung des Vater-Sohn-Prinzips löscht:
PROGRAM Del_Ds;
USES Crt;
TYPE
TAdresse = RECORD
AdrNr: Byte;
Name: String[12];
END;
TDatei = FILE of TAdresse;
VAR
Adresse, Adresse2: TAdresse;
AdressVater: TDatei;
AdressSohn: TDatei;
DS: Byte;
BEGIN
Write('Welchen Datensatz loeschen: ');
readln(ds);
Assign(AdressVater, 'adressen.alt');
Reset(AdressVater);
Assign(AdressSohn, 'adressen.new');
Rewrite(AdressSohn);
While (EOF(AdressVater)true) DO
BEGIN
Read(AdressVater, Adresse);
IF Adresse.AdrNr ds THEN
BEGIN
file:///E|/homepage/Pascal/datensatz_loeschen.htm (1 of 2) [07.10.2001 00:40:20]

Datensatz löschen
Adresse2.AdrNr:=Adresse.AdrNr;
Adresse2.Name:=Adresse.Name;
Write(AdressSohn, Adresse2);
END;
END;
Close(AdressSohn);
Close(AdressVater);
Readln;
END.
Datensatzzeiger
Befehlsverzeichnis
file:///E|/homepage/Pascal/datensatz_loeschen.htm (2 of 2) [07.10.2001 00:40:20]

Befehlsverzeichnis
Befehlsverzeichnis
Wie Sie sich sicher denken können ist es schwierig und kaum möglich
auf alle Befehle bzw. Anweisungen in einer Programmiersprache
einzugehen. Vor allem da dadurch die Übersichtlichkeit der einzelnen
Kapitel bzw. Schwerpunkte leidet. Deshalb gibt es hier eine kleine
Übersicht über die häufigsten Befehle. Die einzelnen Anweisungen
enthalten eine kurze Erläuterung, die Deklaration und ein Beispiel.
Da dieser Teil sehr Umfangreich ist, befindet er sich leider noch in Arbeit.
Ich werde aber versuchen Ihn so schnell wie möglich fertig zu stellen!
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
A
Abs
Arc
Assign
B
Bar
Blockread
Break
C
Case
Concat
Chr
Circle
ClearScreen
ClearViewPort
Close
ClrEol
D
DirectVideo
DiskSize
DIV
DetectGraph
DosExitCode
Delay
DelLine
DrawPoly
Append
ArcTan
AssignCrt
Bar3D
Blockwrite
ChDir
Continue
Copy
ClearDevice
Cos
CreateDir
CloseGraph
Clrscr
DiskFree
Dispose
DateTime
Dec
DosVersion
Delete
Draw
file:///E|/homepage/Pascal/befehlsverzeichnis.htm (1 of 5) [07.10.2001 00:40:30]

Befehlsverzeichnis
E
Ellipse
EnvCount
EnvStr
Eof
Eoln
Erase
Exclude
Exec
Exit
Exp
F
FindFirst
FindNext
FloodFill
Flush
For
Forward
Frac
FreeMem
FSearch
FExpand
FSplit
Function
FileExpand
FileMode
FilePos
FileSearch
FileSize
FileSplit
FillChar
FillEllipse
FillPattern
FillPoly
G
GetArcCoods
GetArgCount
GetArgStr
GetAspectRatio
GetBkColor
GetCBreak
GetColor
GetCurDir
GetDate
GetDefaultPalette
GetDir
GetDriverName
GetEnv
GetEnvVar
GetFAttr
GetFillPattern
GetFillSettings
GetFTime
GetGraphMode
GetImage
GetIntVec
GetLineSettings
GetMaxColor
GetMaxMode
GetMaxX
GetMaxY
GetMem
GetModeName
GetModeRange
GetPalette
GetPaletteSize
GetPixel
GetTextSettings
GetTime
GetVerify
GetViewSettings
GetX
GetY
Goto
GotoXY
GraphDefaults
GraphResult
H
Hi
HighVideo
Hx
file:///E|/homepage/Pascal/befehlsverzeichnis.htm (2 of 5) [07.10.2001 00:40:30]

Befehlsverzeichnis
I
If
ImageSize
Inc
IN
Include
InitGraph
Inline
Insert
InsLine
Int
IOResult
K
Keep
KeyPressed
L
Label
LineTo
Ln
Lo
Length
Low
LowVideo
Line
LineFill
M
Make
Mark
MaxAvail
MaxColors
MaxInt
MaxLongInt
Move
MoveRel
Mem
MemAvail
MemL
MemW
MkDir
MoveTo
MsDos
N
NormVideo
NoSound
O
Ord
OutText
OutTextXY
P
Procedure
PackTime
PaletteType
ParamStr
PieSlice
Pos
Pred
Ptr
PutImage
PutPixel
R
Release
RemoveDir
Random
Randomize
file:///E|/homepage/Pascal/befehlsverzeichnis.htm (3 of 5) [07.10.2001 00:40:30]

Befehlsverzeichnis
Read
Repeat
ReadKey
Readln
Reset
Rectangle
RestoreCrtMode
Rewrite
RmDir
Round
RunError
S
SizeOf
SlashFill
SmallFont
SoildFill
SoildLn
Sound
South
SPtr
Sqr
Sqrt
Str
StrCat
StrComp
StrCopy
StrDispose
StrECopy
StrEnd
StrIComp
Seek
SeekEof
SeekEoln
StrMove
StrNew
Succ
StrUpper
Swap
SetColor
SetBkColor
SetCurDate
SetDate
SetFAttr
SetFTime
Sin
SetTextStyle
SetTime
T
Trunc
Truncate
Test8086
Test8087
Text
TextAttr
TextBackground
TextColor
TextHeight
TextMode
TextWidth
Then
TypeOf
To
U
UnpackTime
UpCase
Until
V
ViewPortType
Val
W
WhereX
WhereY
While
Window
With
WindMin
file:///E|/homepage/Pascal/befehlsverzeichnis.htm (4 of 5) [07.10.2001 00:40:30]

Befehlsverzeichnis
WindMax
Writeln
Write
Datensatz löschen
Einfache Beispiele
file:///E|/homepage/Pascal/befehlsverzeichnis.htm (5 of 5) [07.10.2001 00:40:30]

Turbo Pascal
Turbo Pascal - Programmbeispiele
Jeder der gerade eine Programmiersprache lernt, weis wie schwierig es
am Anfang ist das gelernte Wissen anzuwenden. Deshalb denke ich das
es das beste und auch das Einfachste ist eine Programmiersprache
anhand von Beispielen zu lernen. Auch gerne als "Learning by
Example" bezeichnet. Deshalb gibt es hier einige kleine Turbo Pascal
Programm die grundlegende Funktionen durchführen.
Addition.pas
Teilbar.pas
Hallo!.pas
Buchstab.pas
Dreieck.pas
Function.pas
Func_gib.pas
Kalender.pas
Lauf.pas
Sortiere.pas
Mittelw.pas
zinsrep.pas
Addiert eine Reihe von Zahlen und gibt
deren Summe aus.
Das Programm verlangt das zwei Zahlen
eingegeben werden und überprüft dann ob
die erste Zahl ein Teiler von der zweiten
ist.
Zeigt die Funktionsweise einer For-Schleife
und gibt Text aus deren Farbe und Position
per Zufall ermittelt wird.
Prüft ob ein Buchstabe eingegeben wurde
und wiederholt solange bis kein Buchstabe
mehr eingegeben wird.
Errechnet in einer Funktion den
Flächeninhalt eines Dreiecks.
Prüft in einer Funktion welche Taste
gedrückt wurde.
Rechnet Bogenmaß in Grad und Grad in
Bogenmaß um.
Nach Eingabe des Jahres, gibt das
Programm einen Kalender für jeden Monat
aus.
Erzeugt aus einer Zeichenkette einen
String, der solange läuft bis eine Taste
gedrückt wird.
Nach der Eingabe von drei Zahlen, werden
diese vom Programm sortiert ausgegeben.
Errechnet mit einer While-Schleife aus
einigen Zahlen die Summe und den
Mittelwert.
Errechnet mit Hilfe einer Repeat-Schleife
verschiedene Zinssätze auf das
eingegebene Kapital.
file:///E|/homepage/Pascal/beisp_turbo_pascal.htm (1 of 2) [07.10.2001 00:40:37]

Turbo Pascal
Temp_01.pas Errechnet, nach der Eingabe von 24
Temperaturen, die Min-/Maximumwerte,
den Durchschnitt und die
Temperaturschwankung.
Befehlsverzeichnis
Käufmännische Beispiele
file:///E|/homepage/Pascal/beisp_turbo_pascal.htm (2 of 2) [07.10.2001 00:40:37]

file:///E|/homepage/Pascal/pascalDateien/addition.pas
PROGRAM addition;
USES crt;
VAR sum, x: Real;
BEGIN
TextColor(White);
Clrscr;
sum := 0;
{1. Zahl einlesen und Sum Berechnen}
Write('1. Zahl eingeben: ');
Readln(x);
sum := sum + x;
{2. Zahl einlesen und Sum Berechnen}
Write('2. Zahl eingeben: ');
Readln(x);
sum := sum + x;
{3. Zahl einlesen und Sum Berechnen}
Write('3. Zahl eingeben: ');
Readln(x);
sum := sum + x;
{4. Zahl einlesen und Sum Berechnen}
Write('4. Zahl eingeben: ');
Readln(x);
sum := sum + x;
{5. Zahl einlesen und Sum Berechnen}
Write('5. Zahl eingeben: ');
Readln(x);
sum := sum + x;
Writeln;
Writeln('Die Summe betr„gt :', sum:10:2);
GotoXY(1, 25);
Write('Bitte [Return] dr•cken...');
Readln;
END.
file:///E|/homepage/Pascal/pascalDateien/addition.pas [07.10.2001 00:41:39]

file:///E|/homepage/Pascal/pascalDateien/teilbar.pas
PROGRAM teilbarkeit;
USES crt;
VAR t, a: Integer;
BEGIN
clrscr;
Textcolor(white);
writeln('šBERPRšFEN DER TEILBARKEIT');
writeln;
writeln('Ist t ein Teiler von a?');
writeln;
write('Eingabe von t: ');
readln(t);
write('Eingabe von a: ');
readln(a);
gotoXY(32, 3);
IF a mod t = 0 THEN
write('>')
ELSE
write('>');
readln
END.
file:///E|/homepage/Pascal/pascalDateien/teilbar.pas [07.10.2001 00:42:35]

file:///E|/homepage/Pascal/pascalDateien/hallo!.pas
PROGRAM Schleife_mit_For;
USES crt;
VAR I: Integer;
BEGIN
Clrscr;
FOR I := 1 TO 24 DO
BEGIN
GotoXY(Random(30) + I, I);
TextColor(Random(15));
Writeln('Hallo Leute, wie gehts?!');
delay(1000);
END;
FOR I := 24 DOWNTO 1 DO
BEGIN
GotoXY(Random(30) + I, I);
TextColor(Random(15));
Writeln('Schon wieder Mittwoch!');
delay(1000);
END;
Readln;
END.
file:///E|/homepage/Pascal/pascalDateien/hallo!.pas [07.10.2001 00:42:50]

file:///E|/homepage/Pascal/pascalDateien/buchstab.pas
program LiesBuchstabe;
uses crt;
var
ch: char;
ok: boolean;
function buchstabe(var ch: char): boolean;
{var
ch: char; }
begin
gotoxy(1,5);
write('Bitte ein Zeichen eingeben: ');
ch := readkey;
if (ch in ['a'..'z']) or (ch in ['A'..'Z'])
then buchstabe := true
else buchstabe := false;
gotoxy(1,5);
clreol;
end;
procedure warteWo(sp, zei: byte);
var
ch: char;
begin
gotoxy(5, 10);
write('Bitte eine Taste dr•cken...');
ch := readkey;
end;
begin
repeat
clrscr;
ok := buchstabe(ch);
gotoxy(5, 12);
if ok
then
begin
write ('Es wurde ein Buchstabe eingegeben.');
write ('Sie haben den Buchstaben "', ch, '" gedr•ckt!');
end
else write ('Es wurde kein Buchstabe eingegeben.');
warteWo(1, 25);
until not ok;
end.
file:///E|/homepage/Pascal/pascalDateien/buchstab.pas [07.10.2001 00:42:58]

file:///E|/homepage/Pascal/pascalDateien/dreieck.pas
PROGRAM Dreieck;
USES Crt;
VAR
Laenge, Hoehe: Real;
Inhalt: Real;
FUNCTION fl_Dreieck(l,h: Real): Real;
BEGIN
fl_Dreieck := l * h /2;
END;
BEGIN
Clrscr;
Write('Geben Sie die L„nge des Dreiecks ein: ');
Readln(Laenge);
Write('Geben Sie die H”he des Dreiecks ein: ');
Readln(Hoehe);
Inhalt:= fl_Dreieck(Laenge,Hoehe);
Writeln('Das Dreieck hat einen Fl„cheninhalt von: ',Inhalt:10:2,' cmý');
Readln;
END.
file:///E|/homepage/Pascal/pascalDateien/dreieck.pas [07.10.2001 00:43:06]

file:///E|/homepage/Pascal/pascalDateien/function.pas
Program _function;
Uses crt;
Var
Ch: Char;
FUNCTION LiesZeichen: Char;
BEGIN
GotoXY(1, 5);
Write('Bitte dr•cken Sie ein Zeichen: ');
LiesZeichen := ReadKey;
GotoXY(1, 5);
ClrEol;
END;
BEGIN
ClrScr;
Ch := LiesZeichen;
Writeln('Folgendes Zeichen wurde gedr•ckt: ', ch);
Readln;
END.
file:///E|/homepage/Pascal/pascalDateien/function.pas [07.10.2001 00:43:14]

file:///E|/homepage/Pascal/pascalDateien/func_gib.pas
Program _function;
Uses Crt, mein_sub;
var
Bogenmass, Grad, Winkel: Real;
ch: char;
Begin
repeat
Clrscr;
Writeln('
Copyright 1999 by Alexander Gr„f');
writeln;
Write('Bitte geben Sie ein Winkel in Radiant ein: ');
Readln(Bogenmass);
Grad := BiGu(Bogenmass);
Writeln('Dies entspricht ', Grad:2:2, ' Grad');
writeln;
Write('Bitte geben Sie einen Winkel in Grad ein: ');
Readln(Winkel);
Grad := Gibu(Winkel);
Writeln('Dies entspricht einem Bogenmaá von: ', Grad:2:2);
Writeln;
Write('WEITER DATEN BERECHNEN (Y/N)?');
Ch := Upcase(readkey);
until ch = 'N';
end.
file:///E|/homepage/Pascal/pascalDateien/func_gib.pas [07.10.2001 00:43:21]

file:///E|/homepage/Pascal/pascalDateien/kalender.pas
Program KalenderDruck;
Uses Crt;
Type Wochentage = (Sonntag, Montag, Dienstag, Mittwoch, Donnerstag, Freitag, Samstag);
Monate = (Januar, Februar, Maerz, April, Mai, Juni, Juli, August, September, Oktober,
November, Dezember);
Var
Jahr: Integer;
Monat : Monate;
ersterT: Wochentage;
schaltjahr: Boolean;
I, Z, S, M, MonatsTage: Byte;
NameMonat: String;
FUNCTION erster_tag(jahr: Integer; Var Schaltjahr: boolean):Wochentage;
VAR
c, j, k, d: Integer;
BEGIN
Schaltjahr:=(Jahr mod 4 = 0) AND
NOT ((Jahr MOD 100 =0) AND
(Jahr MOD 400 0));
{c := jahr div 100;
j := jahr mod 100;
IF j = 0 then schaltjahr := (c mod 4) = 0
ELSE schaltjahr := (j mod 4) = 0;
IF Schaltjahr = true then k := 6
ELSE K := 8;
d := k + j div 4 -2 * (c mod 4);}
d:= 1 + 6 + jahr + jahr div 4 - jahr div 100 + jahr div 400;
IF Schaltjahr THEN d := d - 1;
CASE d mod 7 OF
0: erster_tag := Sonntag;
1: erster_tag := Montag;
2: erster_tag := Dienstag;
3: erster_tag := Mittwoch;
4: erster_tag := Donnerstag;
5: erster_tag := Freitag;
6: erster_tag := Samstag;
END;
END;
BEGIN
REPEAT
Clrscr;
Write('Bitte geben Sie das Jahr ein (z.B. 1999): ');
Readln(jahr);
IF ( jahr < 1582 ) or ( jahr > 3000 ) THEN
BEGIN
TextColor(Red);
Writeln(jahr, ' liegt auáerhalb des zul„sigen Bereichs!');
Writeln('Bitte geben Sie ein Jahr von 1582 bis 3000 ein!');
TextColor(white);
Readln;
END;
UNTIL ( jahr > 1582 ) and ( jahr < 3000 );
ersterT := erster_tag(jahr, schaltjahr);
{IF Schaltjahr = False THEN ersterT := succ(ersterT);}
CASE ersterT OF
Sonntag: s := 0;
Montag: s := 1;
Dienstag: s := 2;
Mittwoch: s := 3;
Donnerstag: s := 4;
file:///E|/homepage/Pascal/pascalDateien/kalender.pas (1 of 3) [07.10.2001 00:43:29]

file:///E|/homepage/Pascal/pascalDateien/kalender.pas
Freitag: s := 5;
Samstag: s := 6;
END;
Monat := Januar;
FOR M := 1 to 12 DO
BEGIN
CASE Monat OF
Januar: BEGIN
NameMonat := 'Januar';
MonatsTage := 31;
END;
Februar: BEGIN
NameMonat := 'Februar';
IF SchaltJahr = True then MonatsTage := 29
ELSE MonatsTage := 28;
END;
Maerz: BEGIN
NameMonat := 'M„rz';
MonatsTage := 31;
END;
April: BEGIN
NameMonat := 'April';
MonatsTage := 30;
END;
Mai: BEGIN
NameMonat := 'Mai';
MonatsTage := 31;
END;
Juni: BEGIN
NameMonat := 'Juni';
MonatsTage := 30;
END;
Juli: BEGIN
NameMonat := 'Juli';
MonatsTage := 31;
END;
August: BEGIN
NameMonat := 'August';
MonatsTage := 31;
END;
September: BEGIN
NameMonat := 'September';
MonatsTage := 30;
END;
Oktober: BEGIN
NameMonat := 'Oktober';
MonatsTage := 31;
END;
November: BEGIN
NameMonat := 'November';
MonatsTage := 30;
END;
Dezember: BEGIN
NameMonat := 'Dezember';
MonatsTage := 31;
END;
END;
Clrscr;
TextColor(White);
GotoXY(33, 1);
Writeln(NameMonat,' ', Jahr);
GotoXY(5, 3);
Writeln('Sontag');
GotoXY(5, 4);
Writeln('Montag');
file:///E|/homepage/Pascal/pascalDateien/kalender.pas (2 of 3) [07.10.2001 00:43:29]

file:///E|/homepage/Pascal/pascalDateien/kalender.pas
GotoXY(5, 5);
Writeln('Dienstag');
GotoXY(5, 6);
Writeln('Mittwoch');
GotoXY(5, 7);
Writeln('Donnerstag');
Gotoxy(5, 8);
Writeln('Freitag');
GotoXY(5, 9);
Writeln('Samstag');
Z := 0;
FOR I := 1 to MonatsTage DO
BEGIN
S := S + 1;
IF S = 8 THEN
BEGIN
IF I 1 THEN
BEGIN
S := 1; z := z +10;
END
ELSE
BEGIN
S := 1;
END
END;
GotoXY(20 + Z, 2 + S);
Writeln(I);
END;
Monat := Succ(Monat);
GotoXY(30, 12);
writeln('Weiter mit [ENTER]');
Readln;
END;
END.
file:///E|/homepage/Pascal/pascalDateien/kalender.pas (3 of 3) [07.10.2001 00:43:29]

file:///E|/homepage/Pascal/pascalDateien/lauf.pas
Program Bildschirmschoner;
Uses Crt;
Var
Text, teil, einf, str2, str3, str4, str1: String;
laenge_text, I, e: integer;
Text_bild: String[30];
Begin
Textcolor(white);
clrscr;
Writeln('Bitte geben Sie eine Zeichenkette ein: ');
Readln(text);
laenge_text := Length(text);
str3 := Copy(text, 1, 1);
str4 := Copy(text, length(text), 1);
I := 1;
clrscr;
Repeat
str2 := Copy(text, 1 , 1);
str1 := Copy(text, Length(text), 1);
Delete(text, Length(text) , 1);
If (str2 = str3) and (str1 = str4) then text := str1 + ' ' + text else text := str1 + text;
GotoxY(20,12);
Randomize;
textcolor(random(16));
write(text);
delay(1500);
clreol;
until keypressed;
Textcolor(white)
end.
file:///E|/homepage/Pascal/pascalDateien/lauf.pas [07.10.2001 00:43:35]

file:///E|/homepage/Pascal/pascalDateien/sortiere.pas
PROGRAM Sortieren_von_drei_Zahlen;
USES crt;
VAR a, b, c, h: Integer;
BEGIN
{PROGRAMMINFO}
TextColor(white);
clrscr;
writeln('SORTIERUNGSPROGRAMM');
writeln('Geben Sie drei ganze Zahlen ein!');
{DATENABFRAGE}
writeln;
write('Erste Zahl: ');
readln(a);
write('Zweite Zahl: ');
readln(b);
write('Dritte Zahl: ');
readln(c);
writeln;
{DATENVERARBEITUNG}
IF a > b THEN
BEGIN
H := a; a := b; b := h;
END;
IF b > c THEN
BEGIN
h := b; b := c; c := h;
END;
IF a > b THEN
BEGIN
h := a; a := b; b := h;
END;
{ERGEBNISS AUSGEBEN}
writeln('geordbet: ', a:7,b:7,c:7);
readln
END.
file:///E|/homepage/Pascal/pascalDateien/sortiere.pas [07.10.2001 00:43:41]

file:///E|/homepage/Pascal/pascalDateien/mittelw.pas
PROGRAM Anzahl_Summe_Mittel;
USES crt;
VAR
Anzahl: Integer;
Zahl, Summe, Mittel: Real;
BEGIN
Textcolor(White);
Clrscr;
Summe := 0;
Anzahl := 0;
Anzahl := 0;
Write('1. Zahl: ');
Readln(Zahl);
WHILE Zahl 0 DO
BEGIN
Summe := Summe + Zahl;
Anzahl := Anzahl + 1;
Write(Anzahl, '. Zahl: ');
Readln(Zahl);
Mittel := Summe / Anzahl;
END;
Writeln('Anzahl: ', Anzahl);
Writeln('Summe: ', Summe:4:2);
Writeln('Mittelwert: ', Mittel:4:3);
Readln;
END.
{Wenn Zahl ungleich 0 dann begine Schleife}
file:///E|/homepage/Pascal/pascalDateien/mittelw.pas [07.10.2001 00:43:49]

file:///E|/homepage/Pascal/pascalDateien/zinsrep.pas
PROGRAM ZinsenBerechnen;
USES crt;
VAR
Kapital, Help,
Zinssatz, Zinsen: Real;
BEGIN
Clrscr;
Write('Bitte gib das Kapital ein: ');
Readln(Kapital);
Help := Kapital / 100;
Clrscr;
Writeln('Jahres-Zinsberechnung f•r Kapital von DM: ', Kapital:10:2);
Writeln;
Zinssatz := 6.4;
REPEAT
Zinssatz := Zinssatz + 0.1;
Zinsen := Help + Zinssatz;
Writeln('Zinsen bei ', Zinssatz:4:1, ': DM -->', Zinsen:10:2);
UNTIL Zinssatz > 7.4;
GotoXY(1, 25);
Write('Bitte [Return] dr•cken...');
Readln;
END.
file:///E|/homepage/Pascal/pascalDateien/zinsrep.pas [07.10.2001 00:43:57]

file:///E|/homepage/Pascal/pascalDateien/temp_01.pas
PROGRAM temperatur;
USES crt;
VAR messw: ARRAY [1..24] OF real;
min, max, schwank, schnitt: real;
PROCEDURE eingeb_messw;
VAR
i: Byte;
BEGIN
END;
FOR i:= 1 TO 24 DO
BEGIN
write('Geben sie ihren ',i,'. Messwert ein: ');
readln (messw [i]);
END;
PROCEDURE minimum;
VAR
i: Byte;
BEGIN
END;
min:=messw[1];
FOR i:= 2 TO 24 DO
IF min > messw[i] THEN min:=messw[i];
PROCEDURE maximum;
VAR
i: Byte;
BEGIN
END;
max:=messw[1];
FOR i:= 2 TO 24 DO
IF max < messw[i] THEN max:=messw[i];
PROCEDURE schwankung;
BEGIN
END;
schwank:= max-min;
PROCEDURE durchschnitt;
VAR
i: Byte;
BEGIN
END;
FOR i := 1 TO 24 DO schnitt := schnitt + messw[i];
schnitt := schnitt / 24;
PROCEDURE ausgabe;
BEGIN
writeln (' ');
writeln ('Der Durchschnittswert betr„gt ',schnitt:3:2,' øC .'); {Warum drei
Kommastellen? - Ge„ndert!}
writeln ('Die ermittelte Temperaturschwankung betr„gt ',schwank:3:2,' øC .');
writeln ('Das Maximum betr„gt ',max:3:2,' øC .');
writeln ('Das Minimum betr„gt ',min:3:2,' øC .');
writeln (' ');
writeln ('Danke f•r die Benutzung dieses Programmes. Weiter mit beliebiger Taste.');
END;
BEGIN
clrscr;
file:///E|/homepage/Pascal/pascalDateien/temp_01.pas (1 of 2) [07.10.2001 00:44:06]

file:///E|/homepage/Pascal/pascalDateien/temp_01.pas
END.
writeln ('Dies ist ein Programm zur Ermittlung von Temperaturschwankungen.');
writeln ('Ausserdem werden Mini- bzw. Maximumwerte sowie Durchschnittswerte ermittelt.');
writeln (' ');
eingeb_messw;
minimum;
maximum;
schwankung;
durchschnitt;
ausgabe;
readkey;
file:///E|/homepage/Pascal/pascalDateien/temp_01.pas (2 of 2) [07.10.2001 00:44:06]

Programmbeispiele
Programmbeispiele - kaufmännische
Jeder der gerade eine Programmiersprache lernt, weis wie schwierig es
am Anfang ist das gelernte Wissen anzuwenden. Deshalb denke ich das
es das beste und auch Einfachste ist eine Programmiersprache anhand
von Beispielen zu lernen. Auch gerne als "Learning by Example"
bezeichnet. Deshalb gibt es hier einige kleine Turbo Pascal Programm
die kaufmännische Berechnungen durchführen.
Abschreib.pas
Berechnet Abschreibungstabellen für die
lineare, degressive und kombinierte
Abschreibung.
Einfache Beispiele
erste Seite
file:///E|/homepage/Pascal/programmbeispiele_kaufmann.htm [07.10.2001 00:44:29]

file:///E|/homepage/Pascal/pascalDateien/abschreib.pas
PROGRAM Afa;
USES Crt;
FUNCTION ShowItems: Char;
Type TMenge = Set of Char;
VAR Item: Char;
Menge_Item: TMenge;
BEGIN
Menge_Item := ['1','2','3'];
REPEAT
Clrscr;
GotoXY(28, 10);
Writeln('Abschreibungsmethode:');
GotoXY(28, 13);
Writeln('(1) linear');
GotoXY(28, 14);
Writeln('(2) degressiv');
GotoXY(28, 15);
Writeln('(3) degressiv --> linear');
GotoXY(28, 17);
Write('Bitte w„hlen: ');
Readln(Item);
UNTIL Item IN Menge_Item;
ShowItems := Item;
END;
PROCEDURE linear(nd: Byte; ak, satz: Real);
VAR rbw, prozent: Real;
I: Byte;
BEGIN
RBW := ak;
Writeln;
Writeln('Abschreibungsmethode : linear');
Writeln('Anschaffungskosten : ', ak:0:2, ' DM');
Writeln('Nutzungsdauer
: ', nd, ' Jahre');
Writeln('J„hrliche Abschreibung: ', satz:0:2 ,' DM');
Writeln;
FOR i := 1 TO nd DO
BEGIN
rbw := rbw-satz;
Writeln(i,'. JAHR - AFA: ', satz:10:2,' DM - RBW: ', rbw:10:2,' DM');
END;
END;
PROCEDURE degressiv(nd: Byte; ak, satz: Real);
VAR rbw, afa: Real;
I: Byte;
BEGIN
rbw := ak;
Writeln;
Writeln('Abschreibungsmethode : degressiv');
Writeln('Anschaffungskosten : ', ak:0:2, ' DM');
Writeln('Nutzungsdauer
: ', nd, ' Jahre');
Writeln;
FOR i := 1 TO nd DO
BEGIN
afa := rbw * satz / 100;
rbw := rbw - afa;
Writeln(i,'. JAHR - AFA: ', afa:10:2,' DM - RBW: ', rbw:10:2,' DM');
END;
END;
file:///E|/homepage/Pascal/pascalDateien/abschreib.pas (1 of 2) [07.10.2001 00:44:51]

file:///E|/homepage/Pascal/pascalDateien/abschreib.pas
PROCEDURE degr_lin(nd: Byte; ak, satz: Real);
VAR rbw, afa, ujahr, l_satz: Real;
I: Byte;
BEGIN
rbw := ak;
ujahr := round(nd-(100/satz)+1);
Writeln;
Writeln('Abschreibungsmethode : degressiv --> linear');
Writeln('Anschaffungskosten : ', ak:0:2, ' DM');
Writeln('Nutzungsdauer
: ', nd, ' Jahre');
Writeln('šbergangsjahr
: ', ujahr:0:0, '. Jahr');
Writeln;
FOR i := 1 TO nd DO
BEGIN
IF i < ujahr THEN afa := rbw * satz / 100 ELSE
BEGIN
IF i=ujahr then l_satz := rbw/(nd-(i-1));
afa := l_satz;
END;
rbw := rbw - afa;
Writeln(i,'. JAHR - AFA: ', afa:10:2,' DM - RBW: ', rbw:10:2,' DM');
END;
END;
VAR Item: Char;
AK, satz: Real;
nutzdauer: Byte;
BEGIN
Item := ShowItems;
Clrscr;
Write('Geben Sie die Nutzungsdauer ein: ');
Readln(nutzdauer);
Write('Geben Sie die Anschaffungskosten ein: ');
Readln(ak);
Clrscr;
CASE Item OF
'1': BEGIN
satz := ak / nutzdauer;
linear(nutzdauer, ak, satz);
END;
'2': BEGIN
satz := (100 / nutzdauer) * 3 ;
IF satz>30 then satz := 30;
degressiv(nutzdauer, ak, satz);
END;
'3': BEGIN
satz := (100 / nutzdauer) * 3 ;
IF satz>30 then satz := 30;
degr_lin(nutzdauer, ak, satz);
END;
END;
Writeln;
Writeln('Bitte [ENTER] dr•cken ...');
Readln;
END.
file:///E|/homepage/Pascal/pascalDateien/abschreib.pas (2 of 2) [07.10.2001 00:44:51]