Brauche Erklärung für Parameterübergabe (zwecks Klausur Di)

[lun87]

Hi an alle erstmal
Ich wollte euch mal fragen, ob mir wer eine kleine Zeile aus dem Programm meines Lehrers erklären kann. Ich kann nicht nachvollziehen was dort passiert. Wäre echt nett

hier der code:

Delphi-Quellcode:

unit UZahlensysteme;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ExtCtrls, UZahl;

type
  TForm1 = class(TForm)
    RadioGroupEingabeBasis: TRadioGroup;
    RadioGroupAusgabeBasis: TRadioGroup;
    eeingabe: TEdit;
    eausgabe: TEdit;
    procedure RadioGroupEingabeBasisClick(Sender: TObject);
    procedure RadioGroupAusgabeBasisClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
   number : TZahl;
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.RadioGroupEingabeBasisClick(Sender: TObject);
begin
  Case RadioGroupEingabeBasis.ItemIndex of
    0: number.setBasis ('2');
    1: number.setBasis ('10');
    2: number.setBasis ('16');
  end;
  number.setZahl (eeingabe.text);
end;

procedure TForm1.RadioGroupAusgabeBasisClick(Sender: TObject);
begin
  Case RadioGroupAusgabeBasis.ItemIndex of
    0: number.setBasis ('2');
    1: number.setBasis ('10');
    2: number.setBasis ('16');
  end;
  eausgabe.text := number.getZahl;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
number := TZahl.create;
end;

end.

unit UZahl;

interface

Type
  TBasen = (B2, B10, B16);
  TZahl = class
protected
  Basis : TBasen;
  WertBasis10 : integer;
public
  procedure setBasis (B : string);
  function getBasis : string;
  procedure setZahl (Z : string);
  function getZahl : string;
end;

implementation
uses ZahlKonv, SysUtils;

procedure TZahl.setBasis (B : string);
begin
 if B = '2' then Basis := B2;
 if B = '10' then Basis := B10;
 if B = '16' then Basis := B16;
end;

procedure TZahl.setZahl (Z : string);
begin
  Case Basis of
    B2: dual_nach_dezimal (Z, Wertbasis10);   ----->[color=#ff0000]Was wird hier wem zugeordnet? Was macht Wertebasis10 und was                                                                                                                                                     ...                                                                macht Z ? Könnt ihr mir dort helfen? Danke :)[/color] 
    B10: Wertbasis10 := StrToInt(Z);
    B16: sedezimal_nach_dezimal (Z, Wertbasis10);
  end;
end;

function TZahl.getBasis : string;
begin
  Case Basis of
    B2 : result := '2';
    B10 : result := '10';
    B16 : result := '16';
  end;
end;

function TZahl.getZahl : string;
var puffer : string;
begin
  puffer := '';
  Case Basis of
    B2: Begin
          dezimal_nach_dual (Wertbasis10, puffer); 
          result := puffer;
        end;
    B10: result := IntToStr(Wertbasis10);
    B16: begin
           dezimal_nach_sedezimal(Wertbasis10, puffer);
           result := puffer;
         end;
  end;
end;

end.

Unit ZahlKonv;

{ OSZ Energietechnik I,
  Fb Informatik,
  Christian Steinbrucker,
  2001, siehe alte Version von 1996 noch ohne Type STRING
}

Interface

Procedure dezimal_nach_dual      (    DezZahl : Integer;
                                  Var DualZahl: String);
Procedure dezimal_nach_sedezimal (    DezZahl : Integer;
                                  Var SedZahl : String);
Procedure sedezimal_nach_dezimal (    SedZahl : String;
                                  Var DezZahl : Integer);
Procedure dual_nach_dezimal      (    DualZahl: String;
                                  Var DezZahl : Integer);

Implementation { ========================================================== }
Uses SysUtils, UZahlensysteme;
{ ----------------------------- private Operationen ----------------------- }

Function Potenz ( Basis, Exponent : Integer ) : Integer;
Var Zaehler, Ergebnis : Integer;
Begin
  Ergebnis := 1;
  For Zaehler := 1 TO Exponent DO
    Ergebnis := Ergebnis * Basis;
  Potenz := Ergebnis;
End;

Procedure Zahl_traversieren (    Zahlin: String;
                                 Var Zahlout: String);
Var Stelle,
    Laenge: Integer;
Begin
  Laenge := Length(ZahlIn);
  For Stelle := 0 To Laenge Do
    ZahlOut [Stelle] := ZahlIn [Laenge - Stelle];
End;

{ ------------------------- öffentliche Operationen ----------------------- }

Procedure dezimal_nach_dual (    DezZahl : Integer;
                             Var DualZahl: String);
Var DualZaehler: Byte;
    S: string [1];
Begin
  DualZahl := '0000000000000000';
  DualZaehler := 0;
  While DezZahl > 0 Do
    Begin
      DualZaehler := DualZaehler + 1;
      Str(DezZahl Mod 2, S);
      DualZahl [DualZaehler] := S[1];
      DezZahl := DezZahl Div 2;
    End;
  Zahl_traversieren (DualZahl, DualZahl);
End;

Procedure dezimal_nach_sedezimal (    DezZahl: Integer;
                                  Var SedZahl: String);
Var DezZaehler   : Integer;
Begin
  DezZaehler := 0;
  Sedzahl:='    ';
  While (Dezzahl > 0) Do
    Begin
      DezZaehler := DezZaehler + 1;
      Case DezZahl Mod 16 Of
        0:  Sedzahl [DezZaehler] := '0';
        1:  Sedzahl [DezZaehler] := '1';
        2:  Sedzahl [DezZaehler] := '2';
        3:  Sedzahl [DezZaehler] := '3';
        4:  Sedzahl [DezZaehler] := '4';
        5:  Sedzahl [DezZaehler] := '5';
        6:  Sedzahl [DezZaehler] := '6';
        7:  Sedzahl [DezZaehler] := '7';
        8:  Sedzahl [DezZaehler] := '8';
        9:  Sedzahl [DezZaehler] := '9';
        10: Sedzahl [DezZaehler] := 'A';
        11: Sedzahl [DezZaehler] := 'B';
        12: Sedzahl [DezZaehler] := 'C';
        13: Sedzahl [DezZaehler] := 'D';
        14: Sedzahl [DezZaehler] := 'E';
        15: Sedzahl [DezZaehler] := 'F';
      End;
      DezZahl := DezZahl Div 16;
    End;
  Zahl_traversieren (SedZahl, SedZahl);
End;

Procedure sedezimal_nach_dezimal (    SedZahl: String;
                                  Var DezZahl: Integer);
Const Basis = 16;
Var   Exponent: Integer;
      laenge  : Integer;
Begin
  DezZahl := 0;
  laenge := Length(SedZahl);
  For Exponent := 0 TO 3 Do
    CASE SedZahl [ laenge - Exponent ] OF
      '0': DezZahl := DezZahl +  0 * Potenz (Basis, Exponent);
      '1': DezZahl := DezZahl +  1 * Potenz (Basis, Exponent);
      '2': DezZahl := DezZahl +  2 * Potenz (Basis, Exponent);
      '3': DezZahl := DezZahl +  3 * Potenz (Basis, Exponent);
      '4': DezZahl := DezZahl +  4 * Potenz (Basis, Exponent);
      '5': DezZahl := DezZahl +  5 * Potenz (Basis, Exponent);
      '6': DezZahl := DezZahl +  6 * Potenz (Basis, Exponent);
      '7': DezZahl := DezZahl +  7 * Potenz (Basis, Exponent);
      '8': DezZahl := DezZahl +  8 * Potenz (Basis, Exponent);
      '9': DezZahl := DezZahl +  9 * Potenz (Basis, Exponent);
      'A': DezZahl := DezZahl + 10 * Potenz (Basis, Exponent);
      'B': DezZahl := DezZahl + 11 * Potenz (Basis, Exponent);
      'C': DezZahl := DezZahl + 12 * Potenz (Basis, Exponent);
      'D': DezZahl := DezZahl + 13 * Potenz (Basis, Exponent);
      'E': DezZahl := DezZahl + 14 * Potenz (Basis, Exponent);
      'F': DezZahl := DezZahl + 15 * Potenz (Basis, Exponent);
      'a': DezZahl := DezZahl + 10 * Potenz (Basis, Exponent);
      'b': DezZahl := DezZahl + 11 * Potenz (Basis, Exponent);
      'c': DezZahl := DezZahl + 12 * Potenz (Basis, Exponent);
      'd': DezZahl := DezZahl + 13 * Potenz (Basis, Exponent);
      'e': DezZahl := DezZahl + 14 * Potenz (Basis, Exponent);
      'f': DezZahl := DezZahl + 15 * Potenz (Basis, Exponent);
    End;
End;

Procedure dual_nach_dezimal (    DualZahl: String;
                             Var DezZahl : Integer);
Var Exponent,
    laenge   : Integer;
Begin
  DezZahl := 0;
  laenge := length(Dualzahl);
    For Exponent := 0 To 15 Do
      If DualZahl [laenge - Exponent] = '1' Then
        DezZahl := DezZahl + Potenz (2, Exponent);
End;

Begin

End.

Entschuldigt aber ich weiss nicht wie man das in rot schreibt und wie ich es besser einrücken kann.

mfg
Lun87