Die Unterprogrammtechnik - lehrer

Einleitung:
Die Unterprogrammtechnik
Es gibt mindestes zwei Gründe, weshalb ein Programmierer Unterprogramme verwenden sollte:
1) Mit Hilfe von Unterprogrammen kann ein Programm strukturiert werden. Das bedeutet, daß
ein Programm in mehrere kleine Abschnitte (= Unterprogramme) aufgeteilt wird, wodurch die
Übersichtlichkeit enorm steigt. Davon profitiert vor allem die Lesbarkeit des Programms, außerdem
können Fehler leichter entdeckt und beseitigt werden. Gezielte Programmänderungen
sind ebenfalls leichter möglich.
Unterprogramm 1
HAUPTPROGRAMM
Unterprogramm 2
Unterprogramm 3 Unterprogramm 3.1
Das Diagramm dokumentiert die Vorteile der Unterprogrammtechnik. Statt eines sehr unübersichtlichen
Gesamtprogramms entstehen Unterprogramme, die jeweils ein (kleineres)
Teilproblem lösen. Durch die Aufteilung in einzelne Module entsteht auch die Möglichkeit der
Zusammenarbeit mehrerer Programmierer bzw. die Arbeitsteilung zur Erstellung von
komplizierten und umfangreichen Programmen wird erst möglich.
2) Immer wieder gebrauchte Programmabschnitte (= Unterprogramme) werden zusammengefaßt
und können auf eine einfache Art und Weise beliebig oft (eventuell mit verschiedenen
Ausgangsdaten) aufgerufen werden. Jedes Unterprogramm erhält einen Namen und wird mit
diesem vom Hauptprogramm aus aktiviert.
In Turbo Pascal stellt jedes Unterprogramm eine selbständige Einheit dar und wird als
PROZEDUR oder FUNKTION vereinbart. Wir haben bereits einige Prozeduren und Funktionen
verwendet, die in Turbo Pascal implementiert (d.h. schon vorhanden) sind. Das sind zum Beispiel
die Prozeduren WRITELN und READLN und die Standardfunktionen SQR und SQRT. Jeder
Programmierer hat die Möglichkeit, eigene Prozeduren und Funktionen zu schreiben, die dann
vom Hauptprogramm wie die bereits in Turbo Pascal vorhandenen Prozeduren und Funktionen
verwendet werden können.
Prozeduren:
Aufbau und Handhabung von Prozeduren lassen sich am besten mit einfachen Beispielen
zeigen. Zwei INTEGER-Zahlen werden eingelesen, addiert und das Ergebnis der Addition auf
dem Bildschirm ausgegeben. Zunächst das Beispielprogramm ohne Prozeduren.
program add;
uses crt;
var a,b,summe : integer;
begin
clrscr;
writeln ('Addition von zwei ganzen Zahlen:');
writeln;
write ('Die erste Zahl eingeben: ');
readln(a);
write ('Die zweite Zahl eingeben: ');
readln(b);
summe:=a+b;
writeln;
writeln('Die Summe der Zahlen beträgt: ', summe);
readln;
end.
Mit der Verwendung der Unterprogrammtechnik:
program proz_1;
uses crt;
var a,b,summe : integer;
Wolfgang Demel | TP Upro Skriptum Querformat.doc | Seite 1
procedure eingabe; Prozedur EINGABE
begin
writeln ('Addition von zwei ganzen Zahlen:');
writeln;
write ('Die erste Zahl eingeben: ');
readln (a);
write ('Die zweite Zahl eingeben: ');
readln (b);
end;
procedure addition; Prozedur ADDITION
begin
summe:=a+b;
end;
procedure ausgabe; Prozedur AUSGABE
begin
writeln;
writeln('Die Summe der Zahlen beträgt: ',summe);
end;
begin {Hier beginnt das Hauptprogramm}
clrscr;
eingabe; {Aufruf der Prozedur EINGABE}
addition; {Aufruf der Prozedur ADDITION}
ausgabe; {Aufruf der Prozedur AUSGABE}
readln;
end.

Der Aufbau von Prozeduren:
Der Aufbau einer Prozedur entspricht größtenteils dem eines Turbo Pascal Programms. Einem
Unterprogrammkopf (mit dem Prozedurnamen) folgt ein Anweisungsteil (zwischen den beiden
Schlüsselwörtern BEGIN und END).
procedure Prozedurname; Statt PROGRAM steht PROCEDURE !!
begin
Anweisung 1;
Anweisung 2;
...
Anweisung n;
end; Kein PUNKT sondern STRICHPUNKT !!
In einem Turbo Pascal Programm folgt nach dem Programmkopf der Vereinbarungsteil und erst
dann der Anweisungsteil. Auch bei Unterprogrammen kann dem Unterprogrammkopf ein Vereinbarungsteil
folgen. Alle Variablen, die im Vereinbarungsteil des Unterprogramms stehen, sind
allerdings nur für das Unterprogramm verwendbar. In Zusammenhang mit Unterprogrammen
müssen deshalb verschiedene Arten von Variablen und Konstanten unterschieden werden.
Lokale und globale Variable (Konstante, Datentypen):
globale Variable (Konstanten):
Unter globalen Variablen (global = gesamt) werden Variablen verstanden, die dem gesamten
Programm (also dem Hauptprogramm und allen Unterprogrammen) bekannt
sind. Sie werden im Vereinbarungsteil des Hauptprogramms wie üblich vereinbart. Jedes
Turbo Pascal Programm besitzt einen globalen Datenraum, in dem alle globalen Variablen
abgelegt sind. Im vorigen Beispiel sind a, b und summe globale Variablen. Sie
sind allen Unterprogrammen und dem Hauptprogramm bekannt.
lokale Variable (Konstanten):
Lokale Variablen (lokal = örtlich) hingegen sind Variablen, die nur jenem Unterprogramm
bekannt sind, in dessen Vereinbarungsteil sie deklariert worden sind. Sie sind den
anderen Unterprogrammen und dem Hauptprogramm unbekannt und können dort nicht
verwendet werden. Jedes Unterprogramm hat seinen eigenen lokalen Datenraum, in dem
die lokalen Variablen abgelegt sind. Dieser existiert jedoch nur zur Laufzeit des
Unterprogramms.
Machen Sie möglichst oft Gebrauch von lokalen Variablen. Dadurch ist die Prozedur
nicht mehr so stark abhängig von Gegebenheiten des Hauptprogramms und kann leichter
in anderen Programmen eingesetzt werden.
Beispiel: Das Programm soll nach der Eingabe der beiden Radien den Umfang und den Flächeninhalt
eines Kreisrings berechnen.
program proz_2;
uses crt;
var r1,r2 : real;
procedure eingabe;
begin
write ('Außenradius eingeben: ');
readln (r1);
write ('Innenradius eingeben: ');
readln (r2);
end;
procedure berechnung;
const pi=3.14;
var u,a : real;
begin
writeln;
u:=2*pi*(r1+r2);
a:=pi*(sqr(r1)-sqr(r2));
writeln ('Umfang = ',u:1:2);
writeln ('Fläche = ',a:1:2);
end;
begin
clrscr;
writeln ('Berechnung des Kreisrings');
eingabe;
berechnung;
readln;
end.
Wolfgang Demel | TP Upro Skriptum Querformat.doc | Seite 2
Im Vereinbarungsteil des Hauptprogramms stehen r1 u. r2. Sie sind daher globale
Variablen.
Die Prozedur eingabe hat keinen eigenen Vereinbarungsteil und kennt daher nur die globalen
Variablen.
In berechnung wird π durch die lokale Konstante pi auf den Wert 3.14 festgelegt.
Für den Umfang und die Fläche werden die lokalen Variablen u und a vereinbart.
Im Hauptprogramm werden die Unterprogramme mit ihren Namen aufgerufen
Übungen 1:
(1) Schreibe HERON.PAS mit den Unterprogrammen EINGABE und BERECHNUING
(speichern als HERON_2.PAS).
(2) Schreibe das Programm TRAPEZ_1.PAS, das nach Eingabe der Seitenlängen Umfang,
Höhe, Fläche und die Diagonale e eines gleichschenkligen Trapezes berechnet. Verwende
die Unterprogramme EINGABE, UMFANG, HOEHE, FLAECHE und DIAGONALE.
Anleitung:
a + c
m =
2
A = m ⋅h
2
2 2 ⎛ a − c ⎞ 2 2 ⎛ a + c⎞
h = b − ⎜ ⎟ e = h + ⎜ ⎟
⎝ 2 ⎠
⎝ 2 ⎠
2
D
A a
B
Kontrolle: a = 32 | b = 18 | c = 25 ⇒ U = 93,00 | h = 17,66 | FL = 503,21 | e = 33,53
Prozeduren mit Parameterübergabe:
Um die Verwendung von Unterprogrammen noch flexibler zu gestalten, erlaubt es Turbo Pascal,
Werte (die sogenannten Parameter) an die Unterprogramme zu übergeben. Dadurch wird ein
gezielter Datenaustausch mit dem Hauptprogramm ermöglicht. Auch bei den in Turbo Pascal
bereits definierten Standardprozeduren gibt es solche mit und solche ohne Parameterübergabe.
So wird zum Beispiel die Prozedur für das Bildschirmlöschen CLRSCR ohne Parameter aufgerufen.
Um hingegen mit der Prozedur WRITELN einen Wert x am Bildschirm auszugeben, muß der
Prozedur auch der Wert als Parameter übergeben werden, was durch den Aufruf WRITELN(X)
geschieht. Der zu übergebende Wert steht dabei in Klammern nach dem Namen der Prozedur.
b
m
c
e
h
C
b

Von der Möglichkeit der Parameterübergabe sollte der Programmierer immer Gebrauch machen.
Ein sauberer Programmierstil zeichnet sich dadurch aus, daß alle Variablen, die durch das Unterprogramm
bearbeitet werden, als Parameter an das Unterprogramm übergeben werden. Wird
in einem Unterprogramm der Wert einer globalen Variablen geändert, dann spricht man von
einem Nebeneffekt des Unterprogramms. Diese Effekte sind schwer zu überblicken und deshalb
fehlerträchtig und unerwünscht.
Es muß zwischen zwei verschiedenen Arten von Parametern, den Wertparametern und den Variablenparametern
unterschieden werden.
Wertparameter
Genügt ein einseitiger Datenaustausch vom Hauptprogramm ins Unterprogramm, so wird dies
durch die Übergabe von Wertparametern an ein Unterprogramm erreicht. Dadurch wird es möglich,
innerhalb eines Programms ein Unterprogramm öfters mit verschiedenen Parametern aufzurufen.
Zur Übergabe der Parameter muß lediglich der Prozedurkopf um die Parameterliste erweitert
werden. Diese Art des einseitigen Datenaustauschs heißt 'call by value'.
Beispiel:
program proz_3;
uses crt;
var a,b : integer;
procedure kubik (zahl: integer);
var k : integer;
begin
k:=zahl*zahl*zahl;
writeln;
writeln ('Die Kubikzahl ist: ',k);
writeln;
end;
begin
clrscr;
writeln ('1. Berechnung');
kubik (3);
write ('Zahl für die 2.Berechnung? ');
readln (a);
kubik (a);
write ('Zahl für die 3. Berechnung? ');
readln (b);
kubik (b);
readln;
end.
Im Prozedurkopf steht zusätzlich der zu übergebende Parameter mit seinem Datentyp in
einer runden Klammer. Das bedeutet, daß vom Hauptprogramm an das Unterprogramm
kubik genau ein INTEGER-Wert übergeben werden muß.
Die Übergabe geschieht, indem beim Aufruf der Prozedur zusätzlich der Parameter in Klammern
angegeben wird. In dieser Zeile wird kubik mit dem Wert 3 aufgerufen.
Prozeduraufruf mit der Variablen a.
Prozeduraufruf mit der Variablen b.
Wolfgang Demel | TP Upro Skriptum Querformat.doc | Seite 3
Die Parameter im Prozedurkopf (im Beispiel: zahl) werden als Formalparameter bezeichnet,
weil mit ihnen nicht direkt gerechnet wird. Beim Aufruf der Prozedur im Hauptprogramm werden
die Formalparameter durch die Aktualparameter (im Beispiel: 3,a und b), die die tatsächlichen
Rechenwerte darstellen, ersetzt.
Die Formalparameter stehen immer in der Prozedurvereinbarung (im Vereinbarungsteil des
Hauptprogramms), die Aktualparameter im Prozeduraufruf (im Anweisungsteil des Hauptprogramm).
Für Formalparameter und Aktualparameter sollten unterschiedliche Bezeichner
verwendet werden.
Sollen mehrere Parameter übergeben werden, so werden jene gleichen Typs durch Beistriche
voneinander getrennt. Parameter unterschiedlichen Typs müssen durch Strichpunkte voneinander
unterschieden werden:
procedure Prozedurname (ParA1, ParA2, ... : TypA;
ParB1, ParB2, ... : TypB;
...
ParZ1, ParZ2, ... : TypZ);
Beispiel:
procedure probe (a,b:real; i:integer; frage:char);
Der Aufruf der Prozedur probe muß dann
beispielsweise folgendermaßen aussehen:
...;
probe (3.2,4.7,5,'Y');
...,
Dann erfolgt die Zuordnung:
a 3.2
b 4.7
i 5
frage 'Y'
Auf die richtige Reihenfolge und auf den richtigen Datentyp ist bei der Übergabe
unbedingt zu achten!
Auf Wertparameter kann jede Prozedur nur lesend zugreifen, die Parameter können von der Prozedur
nicht verändert werden, d.h. der Informationsfluß führt nur vom Hauptprogramm zum Unterprogramm
und nicht umgekehrt.
Beim Eintritt in das Unterprogramm wird eine Kopie der Variablen im lokalen Datenraum des
Unterprogramms angelegt. Dieses Duplikat wird verwendet, solange das Unterprogramm aktiv
ist. Nach der Beendigung des Unterprogramms wird der lokale Datenraum - und damit dessen
Inhalt - vernichtet. Eine Veränderung der Variablen im Hauptprogramm ist daher nicht möglich.
Variablenparameter
Soll der Informationsfluß in beide Richtungen, also vom Hauptprogramm ins Unterprogramm und
vom Unterprogramm wieder zurück ins Hauptprogramm führen, so müssen in der Prozedur Variablenparameter
vereinbart werden. Dies geschieht, indem in der Parameterliste vor die Variablennamen
das reservierte Wort VAR geschrieben wird. Der Vorgang des Datenaustausches mit
Variablenparametern heißt auch 'call by reference'.
procedure Prozedurname (var ParA1, ParA2, ... : TypA;
var ParB1, ParB2, ... : TypB;
...
var ParZ1, ParZ2, ... : TypZ);

Beispiel:
program proz_4;
uses crt;
var a,b,i : integer;
procedure eingabe (var x,y : integer);
begin
write ('Die erste Zahl eingeben: ');
readln (x);
write ('Die zweite Zahl eingeben: ');
readln (y);
end;
procedure addition (x,y : integer);
var summe : integer;
begin
summe:=x+y;
writeln ('Die Summe von ',x,' und ',y,' beträgt ',summe,'.');
writeln;
end;
begin
clrscr;
for i:=1 to 2 do
begin
writeln (i,'-te Berechnung:');
eingabe (a,b);
writeln ('a = ',a,' b = ',b);
addition (a,b);
end;
readln;
end.
Die Formalparameter x und y der Prozedur eingabe werden durch die Voranstellung des
Schlüsselwortes VAR als Variablenparameter deklariert. Dadurch wird eine Veränderung der
Aktualparameter a und b auch im Hauptprogramm wirksam.
Der Prozedur addition genügt eine Übergabe als Wertparameter, da keine Änderung der Aktualparameter
notwendig ist (die Ausgabe der Summe erfolgt innerhalb der Prozedur).
Die Bildschirmausgabe dokumentiert, daß die eingegebenen Werte dem Hauptprogramm
übergeben wurden.
Gib als Übung das Programm ein und überprüfe, was geschieht, wenn Du an die Prozedur
eingabe Wertparameter übergibst.
Natürlich können in einer Prozedur auch Wertparameter und Variablenparameter gemeinsam
vorkommen, die Kopfzeile könnte dann folgendermaßen aussehen:
procedure probe (var a,b:real; i:integer; frage:char);
In diesem Fall sind a und b Variablenparameter, i und frage hingegen Wertparameter.
Im Gegensatz zum 'call by value' wird beim 'call by reference' keine Kopie der Variablen im lokalen
Datenraum des Unterprogramms angelegt. Stattdessen wird nur die Adresse des Speicherplatzes
der Variablen im globalen Datenraum an das Unterprogramm übergeben.
Eine Wertänderung im Unterprogramm hat deshalb gleichzeitig eine Wertänderung im Hauptprogramm
zur Folge, da ein und derselbe Speicherplatz angesprochen wird. Beim Verlassen des
Unterprogramms werden die entsprechenden Adressreferenzen aufgehoben.
Aufbau einer Prozedur: (reservierte TP - Wörter in Großbuchstaben)
Wolfgang Demel | TP Upro Skriptum Querformat.doc | Seite 4
PROCEDURE Prozedurname (Parameterliste); {Prozedurkopf}
{Vereinbarungsteil}
CONST ... {Vereinbarung von lokalen Konstanten}
VAR ... {Vereinbarung von lokalen Variablen}
BEGIN {Anweisungsteil}
Anweisung 1;
Anweisung 2;
...
Anweisung x;
END; {Ende der Prozedur}
Übungen 2:
(1) Ergänze in PROZ_1.PAS die Parameterübergabe (speichern als SUMME.PAS).
(2) Ergänze in PROZ_2.PAS die Parameterübergabe (speichern als KREIS.PAS).
(3) Ergänze in HERON_2.PAS die Parameterübergabe (speichern als HERON_3.PAS).
(4) Ergänze in TRAPEZ_1.PAS die Parameterübergabe (speichern als TRAPEZ_2.PAS).
(5) Schreibe TETRA_1.PAS mit Unterprogrammen und Parameterübergabe (speichern als
TETRA_2A.PAS).
(6) Schreibe das Programm KEGEL_1.PAS, das den Durchmesser und die Höhe eines Kegels
einliest und die Seitenlänge, die Mantelfläche und das Volumen des Kegels berechnet.
Anleitung: Kontrolle:
s =
d
h
d s
M
d h
V
⎛
2
⎞
⎜ ⎟ +
2
⎝ 2⎠
π ⋅ ⋅
=
2
π ⋅
2
⋅
=
12
d = 6 cm
h = 4 cm
s = 5,00 cm
M = 47,12 cm²
V = 37,70 cm³
Funktionen:
Die zweite Möglichkeit in Turbo Pascal Unterprogramme zu schreiben ist die Vereinbarung als
Funktion, wobei der Aufbau von Funktionen dem von Prozeduren sehr ähnlich ist. Alle Aussagen
über lokale und globale Variablen bzw. über Wert- und Variablenparameter behalten voll inhaltlich
ihre Gültigkeit.
Der Unterschied zwischen Prozeduren und Funktionen besteht darin, daß jede Funktion genau
ein Funktionsergebnis (=Funktionswert) zurückliefert. Funktionen werden deshalb im
weitesten Sinne zur Berechnung von Werten verwendet (wie z.B.: die in Turbo Pascal bereits
enthaltenen Standardfunktionen Sinus und Cosinus y:=sin(alpha), z:=cos(alpha)).
Beispiel:
Es soll ein Programm mit einer Funktion geschrieben werden, die das Maximum von drei
INTEGER-Zahlen bestimmt.

program funkt_1;
uses crt;
var a,b,c : integer;
frage : char;
procedure eingabe (ch:char;var x:integer);
begin
write ('Die ',ch,'. Zahl eingeben: ');
readln (x);
end;
function max(x,y,z:integer):integer;
var m : integer;
begin
m:=x;
if y>m then m:=y;
if z>m then m:=z;
max:=m;
end;
begin
repeat
clrscr;
eingabe('1',a);
eingabe('2',b);
eingabe('3',c);
writeln ('Maximum der drei Zahlen = ',max(a,b,c));
write ('Noch eine Berechnung (j/n)?');
readln (frage);
until upcase(frage)='N'
end.
Die Vereinbarung einer Funktion wird mit dem Schlüsselwort FUNCTION eingeleitet, dem der
Name der Funktion folgt. Danach folgt optional die Parameterliste mit Wertparametern (in
unserem Beispiel die drei INTEGER-Zahlen) und Variablenparametern (wieder mit VAR). Zusätzlich
muß in der FUNCTION-Vereinbarung der Typ der Funktion festgelegt werden. Dieser
entspricht dem Datentyp des Funktionsergebnisses und kann jeder einfache Datentyp
(INTEGER, REAL, CHAR, BOOLEAN, STRING) sein. Der Typ der Funktion wird nach der
Parameterliste, getrennt durch einen Doppelpunkt, angegeben.
Für lokale und globale Variablen gelten alle Aussagen wie bei den Prozeduren.
Wichtig ist, daß im Anweisungsteil der Funktion dem Funktionsnamen das Funktionsergebnis
in einer Wertzuweisung zugeordnet wird.
funktionsname:=funktionsergebnis;
Aufruf der Funktion direkt in der WRITELN-Zeile. Der Ausdruck max(a,b,c) wird dann
durch den Funktionswert ersetzt. Ebenso möglich ist auch die Zuweisung des
Funktionswertes an eine Variable:
...
var a,b,c,ergebnis : integer;
...
ergebnis:=max(a,b,c);
writeln ('Maximum der drei Zahlen = ',ergebnis);
...
Funktionsaufrufe können in Ausdrücken direkt verwendet werden, wie z.B.:
ergebnis:=3*(max(a,b,c)+15);
Aufbau einer Funktion (reservierte TP - Wörter in Großbuchstaben):
Wolfgang Demel | TP Upro Skriptum Querformat.doc | Seite 5
FUNCTION Funktionsname (Parameterliste):Ergebnistyp; {Funktionskopf}
{Vereinbarungsteil}
CONST ... {Vereinbarung von lokalen Konstanten}
VAR ... {Vereinbarung von lokalen Variablen}
BEGIN {Anweisungsteil}
Anweisung 1;
Anweisung 2;
...
Anweisung x;
Funktionsname:=Funktionsergebnis; {Zuordnung des Funktionswertes}
END; {Ende der Funktion}
Wie wichtig benutzerdefinierte Funktionen sind, erkennen wir, wenn wir uns den Vorrat an Funktionen
ansehen, den uns Turbo Pascal standardmäßig zur Verfügung stellt.
Turbo Pascal Standardfunktionen:
Ergebnis- Ergebnis der Funktion Beispiel
typ Argument Ergebnis
ABS(x) REAL Absolutbetrag von x -3.25 3.25
SQR(x) REAL Quadrat von x 5.0 25.0
SQRT(x) REAL Quadratwurzel von x (x ≥ 0) 25.0 5.0
SIN(x) REAL Sinus von x (in Radiant) PI/2 1.0
COS(x) REAL Cosinus von x (in Radiant) PI -1.0
ARCTAN(x) REAL Arcustangens von x (in Radiant) PI 1.262...
PI REAL die Konstante π ----- 3.141...
LN(x) REAL Natürl. Logarithmus von x (positiv) 100 4.605...
EXP(x) REAL Exponentialfunktion von x (e x ) 1.0 2.718...
TRUNC(x) INTEGER Umwandlung in INTEGER durch abschneiden
der Dezimalstellen
11.8 11
ROUND(x) INTEGER Rundung auf ganzzahligen Wert 11.8 12
INT(x) REAL ganzzahliger Anteil von x 11.234 11.0
FRAC(x) REAL nicht-ganzzahliger Anteil von x 11.234 0.234
Es fehlen viele oft gebrauchte Funktionen. Als Beispiele sollen die Winkelfunktion Tangens und
die Berechnung von Potenzen herausgegriffen werden.

Tangensfunktion:
Für die Winkelfunktion Tangens verwenden wir: tan(x) =
sin(x)
cos(x)
function tan (winkel:real):real;
const eps=1E-10;
nichtdef=1E+37;
begin
if abs(cos(winkel))=0 then pot:=p
else pot:=1/p;
end;
Potenz mit reellem Exponenten:
Für den Entwurf einer Funktion zur Berechnung von Potenzen mit reellem Exponenten und
positiver Basis verwenden wir den mathematischen Zusammenhang:
x y = e y.ln(x)
Zahl)
function pot (basis,exponent:real):real;
begin
if basis>0 then pot:=exp(exponent*ln(basis))
else pot:=0;
end;
wobei: x ... Basis (positive reelle Zahl)
y ... Exponent (beliebige reelle
e ... Exponentialfunktion
ln ... natürlicher Logarithmus
Übungen 3:
Wolfgang Demel | TP Upro Skriptum Querformat.doc | Seite 6
(1) Schreibe TETRA_2A.PAS mit einer Funktion zur Dreiecksflächenberechnung (speichern als
TETRA_2B.PAS).
(2) Schreibe TRAPEZ_2.PAS mit Funktionen (speichern als TRAPEZ_3.PAS).
(3) Schreibe KEGEL_1.PAS mit Funktionen (speichern als KEGEL_2.PAS.)
(4) Schreibe das Programm WINKEL.PAS, das Funktionen BOGEN und GRAD enthält, die es
erlauben, einen Winkel vom Bogenmaß ins Gradmaß umzurechnen und umgekehrt.
Anleitung: Bogenmaß = Gradmaß . π
180
Kontrolle: 127° = 2,22 rad 249° = 4,35 rad
(5) Schreibe das Programm WERTETAB.PAS, das eine Tabelle der Funktionswerte von SINUS,
COSINUS und TANGENS eines Winkels zwischen 0° und 360° mit der Schrittweite 20
berechnet.
Wertetabelle
============
Winkel Sinus Cosinus Tangens
0 0.00000 1.00000 0.00000
20 0.34202 0.93969 0.36397
40 0.64279 0.76604 0.83910
60 0.86603 0.50000 1.73205
: : : :
360 0.00000 1.00000 0.00000
(6) Schreibe das Programm KAPITAL2.PAS zur Berechnung des Endkapitals nach der
Zinseszinsformel.
Anleitung:
n
⎛ p ⎞
Kn = K0
⋅ ⎜ + ⎟
⎝ ⎠
1 100
Kontrolle: K 0 = 1234,-
n= 5 Jahre ⇒
p = 4,75 %
K n ... Kapital nach n Jahren
K 0 ... Anfangskapital
p ... Zinssatz
K n = 1556,27