Unterprogramme

Prozeduren und Funktionen 

Funktionen

Function sind Unterprogramme, die am Ende der Ausführung einen Wert zurückliefern

Beispiel  

Es sollen zwei Brüche addiert werden, das Ergebnis soll als teilerfremde Bruch ausgegeben werden.

Algorithmus Eingabe zweier Brüche: Zähler_1;Zähler_2
                                               Nenner_1;Nenner_2
ggT_1 (Nenner_1;Nenner_2)
ggT_2 (Zähler_1;Nenner_1)
  ggT_3(Zähler_2;Nenner_2)
  Nenner_1 dividieren mit ggT_1 -->Merke_1
  Nenner_2 dividieren mit ggT_1 -->Merke_2
kgV = ggT _1* Merke_1 * Merke_2
neu_zaehler_1=zaehler_1/ggT_2
neu_zaehler_2=zaehler_2/ggT_3
neu_nenner_1=nenner_1/ggT_2
neu_nenner_2=nenner_1/ggT_3
ergebnis_zaehler=neu_zaehler_1 * neu_nenner_2
                                + neu_zaehler_2 * neu_nenner_1
  ergebnis_nenner = kgv
ggt_4(ergebnis_zahler;kgv)
  Ausgabe ergebnis_zaehler /ggt_4;ergebnis_nenner(ggt_4

An diesem Algorithmus erkennt man, dass einige Berechnungsalgorithmen sich wiederholen. Es ist also sinnvoll diese wiederkehrenden Algorithmen als Unterprogramme zu schreiben. Da diese Berechnungen genau ein Ergebniswert liefern, schreibt man diese mithilfe von Funktionen.

Eine Prozedur mit genau einem Ergebniswert schreibt man vorteilhaft als Funktion.

Quelltext

program bruch_1;             {***Funktionen***}
{+++Addition zweier brueche++++}
uses crt;
var a, b, c, d, ggt_1, ggt_2, ggt_3, kgv_b  :integer;
    neu_zaehler_1,neu_zaehler_2,neu_nenner_1,neu_nenner_2  :  integer;
    ergebnis_zaehler,ggt_4 :integer;
procedure bildschirm;
var i,j   :  integer;
begin
     clrscr;
     for i:=1 to 80 do
         begin
           for j:=1 to 24 do
           gotoxy(j,i);textbackground(white); write('');
         end;
     textcolor(black);gotoxy(1,1);
end;{+++Ende Bildschirm+++}
function  g_g_T(x, y : integer): integer;
var Rest : integer;
begin
    repeat
          Rest := x mod y;
          x    := y;
          y    := Rest;
    until Rest = 0;
    g_g_t  := x;
end;{Ende g_g_t}
function k_g_V (x, y, ggt_h  :  integer) : integer;
var merke_1, merke_2  :  integer;
begin
     merke_1 := x div ggt_h;
     merke_2 := y div ggt_h;
        k_g_v  := ggt_h * merke_1 * merke_2;
end;{+++Ende k_g_v++++}
function neu (hilfe_1, hilfe_2 :integer) : integer;
begin
     neu := hilfe_1 div hilfe_2;
end;{++Ende Neu+++}

{+++++++++++++++HAUPTPROGRAMM++++++++++++++++++}
begin
     bildschirm;
     gotoxy(20,3);write('Addition zweier Brche ');
     gotoxy(20,4);write('++++++++++++++++++++++ ');
     {+++Eingabe+++}
     gotoxy(10,8);writeln('Eingabe');
     gotoxy(12,10);readln(a);          {+++Zaehler_1+++}
     gotoxy(10,11);Write('_________');
     gotoxy(12,12);readln(b);          {+++Nenner_1+++}
     gotoxy(20,11);write('+');
     gotoxy(26,10);readln(c);          {+++Zaehler_2+++}
     gotoxy(24,11);Write('_________');
     gotoxy(26,12);readln(d);          {+++Nenner_2+++}
     {++Berechnung+++}
     ggt_1:= g_g_t(b,d);
     ggt_2:= g_g_t(a,b);
     ggt_3:= g_g_t(c,d);
     kgv_b:= k_g_v(b,d,ggt_1);
     neu_zaehler_1 := neu(a,ggt_2);
     neu_zaehler_2 := neu(c,ggt_3);
     neu_nenner_1  := neu(b,ggt_2);
     neu_nenner_2  := neu(d,ggt_3);
     ergebnis_zaehler := neu_zaehler_1*neu_nenner_2+neu_zaehler_2*neu_nenner_1;
     ggt_4 :=g_g_t(ergebnis_zaehler,kgv_b);
     {+++Ausgabe+++}
     gotoxy(34,11);write(#205);
     gotoxy(38,10);textcolor(green);write(ergebnis_zaehler div ggt_4);
     gotoxy(36,11);write('__________');
     gotoxy(38,12);write(kgv_b div ggt_4);
     gotoxy(36,13);write(#205,#205,#205,#205,#205,#205,#205,#205,#205,#205);
     readln;
end.

 

Erläuterung

Die Form der Kopfzeile bringt zum Ausdruck, dass die Funktion ein Ergebnis hat, dessen Typ nach dem Doppelpunkt angegeben wird. Als Ergebnistyp kommen in Frage: integer; real; boolean; char und string. An der Stelle des Ergebnisparameters tritt der Funktionsname. Ihm muss der Anweisungsteil der Funktion ein Wert zugewiesen werden.

Während der Prozeduraufruf eine selbständige Anweisung darstellt, kann ein Funktionsaufruf nur in einem Ausdruck erfolgen.