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

[fwsp]

du hättest alternativ auch einfach die zeile angeben können...
icn der zeile 88 wir die prozedur dual_nach_dezimal (Z, Wertbasis10);
was genau verstehst du denn nicht?

[lun87]

Mein Problem ist, was tut er mit beiden Parametern? Warum Wertebasis10? Bearbeitet er die Parameter beide gleichzeitig oder nacheinander? Was geschieht also wenn diese Function aufgerufen wird? Hätte Z nicht gereicht?

Mfg
Lun87

[mkinzler]

Schau dir doch einfach die aufgerufende Prozedur in Zeile 254 an ;-)

[fwsp]

in Z steht die zuverarbeitende information. in WertBasis10 (Wert zur Basis 10) wird das resultat zurückgeliefert. dafür auch das var davor. wenn der wert innerhalb der methode verändert wird, wir die veränderung auch wieder zurückgegeben.

[lun87]

Also kann man sagen das die letzte Variable in solchen (var bla, blub : real); Zeilen die "ergebnis" variable ist ? oder ist das irgendwo festgelegt?

Wie habt ihr das mit der Zeilenangabe angefügt? Woher wisst ihr die Zeilen?


Also ist das so oder : also ist das eine der aufruf der function, mit dem parameter z = zahl ? (aus editkomponente) und wertbasis10 das ergebnis in dem fall, also wird das ergebnis in der function in wertbasis10 gespeichert?!


mfg
Lun87

[mkinzler]

Man sieht das, wie scon erwähnt an dem var. Dieses Bewirkt das die Variable als Referenz(Zeiger) übergeben wird und Änderungen dann auch auf die übergebene Variable wirken.

[fwsp]

die zeilennummern stehen doch in dem code-block.

[lun87]

Ja super, die stehen da wenn ich nicht eingeloggt bin in dem Forum... hehe man lernt dazu^^ Danke

Mfg
Lun87

[Hobby-Programmierer]

Zitat:

Zitat von lun87

Ja super, die stehen da wenn ich nicht eingeloggt bin in dem Forum

Oder aber man schaut mal in sein 'erw. Profil bearbeiten' rein ... :mrgreen:

LG Mario