OOP - Lösung 4

Aufgabe 4

Für das Lohnsteuerbüro SO 36 ist ein EDV-System zu entwerfen, das die Daten der Mandanten sowie die der Mitarbeiter verwaltet. Bewegungsdaten (Termine, Abrechnungen u. ä.) werden nicht erfasst.

Schreiben Sie entsprechend der Spezifikation in Object-Pascal (DELPHI)
- den Deklarationsteil von PERSON sowie die Implementation der Methoden Create,
SetName und GetName

- den Deklarationsteil von LISTE sowie die Implementation von Sortieren (BubbleSort)

Lösung 4 - Code in Object Pascal (DELPHI)

UNIT uPerson;
(* ******************************************************************** *)
(* K L A S S E : TPerson                                                *)
(* -------------------------------------------------------------------- *)

INTERFACE
(* ========================== Export ================================== *)
uses
  uAdresse;

type
  TPerson = class (TObject)
   protected
    Name,
    Vorname     : string[20];
    Geburtstag  : string[10];
    Geschlecht  : string[1];  (* m,w *)

   public
    Adresse     : TAdresse;               // die Aggregation/Komposition

    constructor Create;                      virtual;
    procedure   Init;                        virtual;
    procedure   SetName (n: string);         virtual;
    procedure   SetVorName (vn: string);     virtual;
    procedure   SetGeburtstag (gb : string); virtual;
    procedure   SetGeschlecht (g: string);   virtual;

    function GetName       : string;         virtual;
    function GetVorName    : string;         virtual;
    function GetGeburtstag : string;         virtual;
    function GetGeschlecht : string;   	     virtual;
  end; (* TPerson *)

(* -------------------- B e s c h r e i b u n g -------------------------

Oberklasse     : - (TObject)
Bezugsklassen  : TAdresse

Methoden
--------

Create
  Auftrag: Person und Adresse erzeugen und Initialisieren
  vorher : -
  nachher: Person ist erzeugt, alle Datenfelder sind leer.

Init
  Auftrag: Person Initialisieren
  vorher : ist erzeugt
  nachher: alle Datenfelder sind leer.

Set...
  Auftrag: Attribut schreiben
  vorher : Person ist vorhanden.
  nachher: Attribut ist gesetzt

Get...
  Anfrage: Attribut aus dem Objekt lesen
  vorher : Person ist vorhanden.
  nachher: -
----------------------------------------------------------------------- *)

IMPLEMENTATION
(* ==================================================================== *)

constructor TPerson.Create;
(* -------------------------------------------------------------------- *)
begin
   inherited Create;           // Instanz von geerbtem TObject erzeugen
   Adresse := TAdresse.Create; // und das Adressobjekt als Komposition miterzeugen
   Init;
end;

procedure TPerson.Init;
(* -------------------------------------------------------------------- *)
begin
  Name       := '';
  Vorname    := '';
  Geburtstag := '';
  Geschlecht := chr(0);
  Adresse.Init;
end;

procedure TPerson.SetName (n: string);
(* -------------------------------------------------------------------- *)
begin
  Name := n;
end;

function TPerson.GetName : string;
(* -------------------------------------------------------------------- *)
begin
  result := Name;
end;

// ... u.s.w.

END.

UNIT uSListe;
(* ******************************************************************** *)
(* K L A S S E   : TListe                                               *)
(* -------------------------------------------------------------------- *)
(* Version       : 1.1                                                  *)
(* Autor         : (c) S. Spolwig, OSZ-Handel I, 10997 Berlin           *)
(*                                                                      *)
(* Aufgabe       : Allgemeine statische Liste zur Verwaltung beliebiger *)
(*                 Objekte.                                             *)
(*                 Zum Bewegen in der Liste ist intern eine Listenmarke *)
(*                 mitgefuehrt, die die jeweils aktuelle Listenposition *)
(*                 bezeichnet. Alle Operationen werden auf der aktuellen*)
(*                 Position ausgefuehrt.                                *)
(* ******************************************************************** *)

INTERFACE
(* ==================================================================== *)
USES uPerson;

const
   MAXLAENGE = 100;

type
  TElement = Tperson;     // Elemente sollen Personen sein

  TListe  = class (TObject)
             private
              Kollektion  : array [0..MAXLAENGE + 1] of TElement;
              ListenLaenge,             // Anzahl der belegten Elemente
              AktuellePos : word;       // aktives Element oder EoList

             public
              constructor Create;  virtual;
              procedure Init;      virtual;
              // ...                        und viele andere mehr ...
              procedure Sortieren;
            end;

(*  ----------------- B e s c h r e i b u n g -------------------------

Oberklasse     : - (TObject)
Bezugsklassen  : TPerson

Methoden
--------

Create
  Auftrag : Leere L. erzeugen
  vorher  : -
  nachher : ListenLaenge ist Null, AktuellePos ist 0.

Init
  Auftrag : L. initial.
  vorher  : L. ist vorhanden
  nachher : ListenLaenge ist Null, AktuellePos ist 0.

Sortieren
  Auftrag : Liste nach Namen durch Tauschen aufsteigend sortieren.
  vorher  : L. ist nicht leer.
  nachher : L. liegt in sortierter Reihenfolge vor

----------------------------------------------------------------------- *)

IMPLEMENTATION
(* ==================================================================== *)

constructor TListe.Create;
(* -------------------------------------------------------------------- *)
begin
  inherited Create;
  Init;
end;

procedure TListe.Init;
(* -------------------------------------------------------------------- *)
var i : integer;
begin
  for i := 0 to MAXLAENGE +1 do
  begin
    Kollektion[i] := NIL;  // Objekte sind in Delphi Zeiger auf Obj.
  end;
  ListenLaenge    := 0;
  AktuellePos     := 0;
end;

// ... u..v.a.m.

procedure Tauschen (var E1, E2 : TElement);
(* ------------------------------------------------------------------ *)
(* lokale Prozedur, die NICHT zur Klassendeklaration gehört!          *)
(* ------------------------------------------------------------------ *)
var
hilf : TElement;

begin
  hilf:= E1;
  E1 := E2;
  E2 := hilf
end;

procedure TListe.Sortieren;
(* ------------------------------------------------------------------ *)
(* Auftrag: lineares Sortieren durch Vergleichen und Vertauschen des  *)
(*          nachfolgenden Elements bis nicht mehr getauscht wird.     *)
(*          Endmarke rueckt vor und verkleinert Restfeld              *)
(* vorher : Kollektion ist initialisiert                              *)
(* nachher: Kollektion ist aufsteigend sortiert                       *)
(* ------------------------------------------------------------------ *)
var
  i,
  Endmarke : integer;
  IstFertig: boolean;

begin
  Endmarke  := Listenlaenge - 1 ;
  IstFertig := false;

  while NOT IstFertig do
  begin
    IstFertig := true ;

    for i := 1 to endmarke do
    begin
      if Kollektion[i].GetName > Kollektion[i+1].GetName
      then
        begin
          IstFertig := false;
          Tauschen (Kollektion[i], Kollektion[i+1]);
        end;
    end;

    Endmarke := Endmarke - 1;        // Restfeld verkleinern
  end; // while
end;

{ hier noch die nachprüfende Variante

procedure TListe.Sortieren;
(* ------------------------------------------------------------------ *)
(* Auftrag: lineares Sortieren durch Vergleichen und Vertauschen des  *)
(*          nachfolgenden Elements bis nicht mehr getauscht wird.     *)
(*          Endmarke rueckt vor und verkleinert Restfeld              *)
(* vorher : Kollektion ist initialisiert                              *)
(* nachher: Kollektion ist aufsteigend sortiert                       *)
(* ------------------------------------------------------------------ *)
var
  i,
  Endmarke : integer;
  IstFertig: boolean;

begin
  Endmarke  := Listenlaenge - 1 ;

  repeat
    IstFertig := true ;
    for y := 1 to endmarke do
    begin
      if Kollektion[i].GetName > Kollektion[i+1].GetName
      then
        begin
          Tauschen (Kollektion[i], Kollektion[i+1]);
          IstFertig := false;
        end;
    end;
    Endmarke := Endmarke - 1;        // Restfeld verkleinern
  until IstFertig;
end;
}
END.