home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / sonderh1 / dmp1.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1986-10-12  |  2.7 KB  |  66 lines
  1. PROGRAM beispiel1 (input, output);
  2. { Dieses Programm fuehrt eine Liste mit positiven Zahlen, wobei Neueingaben
  3.   am Ende der Liste angehaengt werden. Nach jeder Eingabe wird die gesamte
  4.   Liste ausgegeben.                                                           }
  5.  
  6. CONST forever = False;
  7.  
  8. TYPE zeiger = ^eintrag; { Deklaration des Zeigers fuer den Datentyp 'eintrag' }
  9.      eintrag = RECORD                   { Deklaration des Datentyps 'eintrag' }
  10.                  zahl: Integer;                            { Informationsteil }
  11.                  next: zeiger                               { Verwaltungsteil }
  12.                END;
  13.  
  14. VAR liste: zeiger;                                       { Listenkopf / Anker }
  15.      zahl: Integer;
  16.  
  17. {-----------------------------------------------------------------------------}
  18.  
  19. PROCEDURE anhaengen (VAR liste: zeiger;         { zeigt auf ein Listenelement }
  20.                      VAR zahl: Integer);
  21. { Der formale Parameter 'liste: zeiger' wird beim ersten Aufruf durch die glo-
  22.   bale Variable 'liste: zeiger' ersetzt, bei den rekursiven Aufrufen durch den
  23.   'next'-Zeiger der schon vorhandenen Elemente in der Liste.                  }
  24.  
  25. BEGIN
  26.   IF liste = nil THEN                              { Ende der Liste erreicht? }
  27.     BEGIN
  28.       new (liste);                              { ja, neues Element anhaengen }
  29.       liste^.zahl := zahl;
  30.       liste^.next := nil;
  31.     END
  32.   ELSE
  33.     anhaengen(liste^.next, zahl);              { nein, rekursiver Aufruf mit
  34.                                                  Zeiger auf naechstes Element }
  35. END;
  36.  
  37. {-----------------------------------------------------------------------------}
  38.  
  39. PROCEDURE ausgeben (restliste: zeiger);
  40. { Die Liste wird ab dem Element, auf welches der Zeiger 'restliste' zeigt,
  41.   iterativ (WHILE-Schleife) ausgegeben.                                       }
  42.  
  43. BEGIN
  44.   WriteLn;
  45.   WHILE restliste <> nil DO           { solange Ende der Liste nicht erreicht }
  46.     BEGIN
  47.       Write (restliste^.zahl:5);                              { Zahl ausgeben }
  48.       restliste := restliste^.next;                { und zum Nachfolger gehen }
  49.     END;
  50.   WriteLn;
  51. END;
  52.  
  53. {-----------------------------------------------------------------------------}
  54.  
  55. BEGIN {beispiel1}
  56.   WriteLn('*** dynamische Liste:');
  57.   liste := nil;                                  { anfangs ist die Liste leer }
  58.   REPEAT
  59.     WriteLn;
  60.     Write ('Zahl: ');
  61.     ReadLn (zahl);                                   { neuen Eintrag einlesen }
  62.     anhaengen (liste, zahl);                     { Eintrag an Liste anhaengen }
  63.     ausgeben(liste);                               { komplette Liste ausgeben }
  64.   UNTIL forever;                                           { Endlosschleife ! }
  65. END.
  66.