home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1990 / 06 / praxis / ptrarith.pas < prev   
Pascal/Delphi Source File  |  1990-03-08  |  6KB  |  200 lines
  1. (* ------------------------------------------------------ *)
  2. (*                     PTRARITH.PAS                       *)
  3. (*        (c) 1990 Winfried Wecker & TOOLBOX              *)
  4. (* ------------------------------------------------------ *)
  5. PROGRAM PTRArithmetik;
  6.  
  7. USES Crt;
  8.  
  9. CONST
  10.   SizeOfINT  = SizeOf(INTEGER);
  11.   SizeOfBYTE = SizeOf(BYTE);
  12.   HohesByte  = 72 SHL 8;
  13.  
  14. TYPE
  15.   UniversalPtr = RECORD CASE INTEGER OF
  16.                        { Komplexe Datenstruktur für        }
  17.                        { beliebige Zeigerarithmetik und    }
  18.                        { Zugriff auf die Daten, ohne das   }
  19.                        { explizite Typwandlungskonzept von }
  20.                        { Turbo-Pascal zu bemühen           }
  21.                    0 : (P : POINTER);
  22.                    1 : (B : ^BYTE);
  23.                    2 : (S : ^SHORTINT);
  24.                    3 : (I : ^INTEGER);
  25.                    4 : (W : ^WORD);
  26.                    5 : (L : ^LONGINT);
  27.                    6 : (C : ^CHAR);
  28.                    7 : (Z : ^STRING);
  29.                    8 : (V : LONGINT)
  30.                  END;
  31.   ArithmetPtr  = RECORD CASE INTEGER OF
  32.                       { Einfachere Datenstruktur nur für   }
  33.                       { Zeigerarithmetik. Zugriff auf die  }
  34.                       { Daten über explizite Typwandlung   }
  35.                    0 : (P : POINTER);
  36.                    1 : (V : LONGINT)
  37.                  END;
  38. VAR
  39.   Feld          : ARRAY [0..95] OF INTEGER;
  40.   x             : UniversalPtr;
  41.   y             : ArithmetPtr;
  42.   i             : INTEGER;
  43.  
  44. TYPE
  45.   Mephisto      = ARRAY [1..2] OF WORD;
  46.  
  47. VAR
  48.   K_M_Brandauer : UniversalPtr;
  49.   Alter_Ego1    : WORD;
  50.   Alter_Ego2    : WORD;
  51.  
  52.   PROCEDURE Nimmersatt;
  53.   VAR
  54.     z : CHAR;
  55.   BEGIN
  56.     z := ReadKey;
  57.     IF (z = Chr(0)) THEN z := ReadKey;
  58.   END;
  59.  
  60.   FUNCTION SexiSedi(x : LONGINT) : STRING;
  61.   CONST
  62.     Sedez : STRING = ('0123456789ABCDEF');
  63.   VAR
  64.     s : STRING;
  65.   BEGIN
  66.     s := '';
  67.     WHILE x <> 0 DO BEGIN
  68.       s := ConCat(Sedez[(x MOD 16) + 1], s);
  69.       x := x SHR 4
  70.     END;
  71.     SexiSedi := s;
  72.   END;
  73.  
  74.   PROCEDURE Ausgabe(I : INTEGER; B : BYTE; C : CHAR;
  75.                     V : LONGINT; A2, A1 : WORD);
  76.   BEGIN
  77.     WriteLn(SexiSedi(I):5, SexiSedi(B):6, C:6,
  78.             SexiSedi(V):10,'  ',SexiSedi(A2),':',
  79.             SexiSedi(A1));
  80.   END;
  81.  
  82.   PROCEDURE Prolog;
  83.   BEGIN
  84.     ClrScr;
  85.     GotoXY(6,12);
  86.     WriteLn('Das Programm wartet nach jeder Ausgabe auf ',
  87.             'beliebigen Tastendruck!');
  88.     Nimmersatt;
  89.     Feld[0] := 45 + HohesByte;
  90.     FOR i := 1 TO 95 DO Feld[i] := i + 31 + HohesByte;
  91.   END;
  92.  
  93.   PROCEDURE Implizit_Wortweise;
  94.                         { Zugriff über Universal-Zeigertyp }
  95.   BEGIN
  96.     ClrScr;
  97.     WriteLn('Implizite Typwandlung(Universalzeiger)/',
  98.             'wortweise Inkrementierung');
  99.     x.P := @Feld[16];
  100.     WriteLn(' INT   BYTE  CHAR ZEIGERWERT ADRESSE');
  101.     FOR i:=0 TO 9 DO BEGIN
  102.       x.V := x.V + SizeOfINT;          { Pointerarithmetik }
  103.       K_M_Brandauer := x;
  104.       Alter_Ego1 := Mephisto(K_M_Brandauer)[1];
  105.       Alter_Ego2 := Mephisto(K_M_Brandauer)[2];
  106.       Ausgabe(x.I^, x.B^, x.C^, x.V, Alter_Ego2, Alter_Ego1)
  107.     END;
  108.   END;
  109.  
  110.   PROCEDURE Implizit_Byteweise;
  111.                         { Zugriff über Universal-Zeigertyp }
  112.   BEGIN
  113.     x.P := @Feld[16];
  114.     WriteLn('Implizite Typwandlung(Universalzeiger)/',
  115.             'byteweise Inkrementierung');
  116.     WriteLn(' INT   BYTE  CHAR ZEIGERWERT ADRESSE');
  117.     FOR i := 0 TO 9 DO BEGIN
  118.       x.V := x.V + SizeOfBYTE;         { Pointerarithmetik }
  119.       K_M_Brandauer := x;
  120.       Alter_Ego1 := Mephisto(K_M_Brandauer)[1];
  121.       Alter_Ego2 := Mephisto(K_M_Brandauer)[2];
  122.       Ausgabe(x.I^, x.B^, x.C^, x.V, Alter_Ego2, Alter_Ego1)
  123.     END;
  124.     Nimmersatt;
  125.   END;
  126.  
  127.   PROCEDURE Explizit_Wortweise;
  128.         { Zugriff über arithmet.Zeigertyp und type casting }
  129.   BEGIN
  130.     ClrScr;
  131.     y.P := @Feld[16];
  132.     WriteLn('Explizite Typwandlung(Universalzeiger)/',
  133.             'wortweise Inkrementierung');
  134.     WriteLn(' INT   BYTE  CHAR ZEIGERWERT ADRESSE');
  135.     FOR i := 0 TO 9 DO BEGIN
  136.       Inc(y.V, SizeOfINT);             { Pointerarithmetik }
  137.       K_M_Brandauer.P := y.P;
  138.       Alter_Ego1 := Mephisto(K_M_Brandauer)[1];
  139.       Alter_Ego2 := Mephisto(K_M_Brandauer)[2];
  140.       Ausgabe(INTEGER(y.P^), BYTE(y.P^), CHAR(y.P^),
  141.               y.V, Alter_Ego2, Alter_Ego1);
  142.     END;
  143.   END;
  144.  
  145.   PROCEDURE Explizit_Byteweise;
  146.         { Zugriff über arithmet.Zeigertyp und type casting }
  147.   BEGIN
  148.     y.P := @Feld[16];
  149.     WriteLn('Explizite Typwandlung(Universalzeiger)/',
  150.             'byteweise Inkrementierung');
  151.     WriteLn(' INT   BYTE  CHAR ZEIGERWERT ADRESSE');
  152.     FOR i := 0 TO 9 DO BEGIN
  153.       Inc(y.V, SizeOfBYTE);            { Pointerarithmetik }
  154.       K_M_Brandauer.P := y.P;
  155.       Alter_Ego1 := Mephisto(K_M_Brandauer)[1];
  156.       Alter_Ego2 := Mephisto(K_M_Brandauer)[2];
  157.       Ausgabe(INTEGER(y.P^), BYTE(y.P^), CHAR(y.P^),
  158.               y.V, Alter_Ego2, Alter_Ego1);
  159.     END;
  160.     Nimmersatt;
  161.   END;
  162.  
  163.   PROCEDURE SeiEineZeichenkette;
  164.   BEGIN
  165.     ClrScr;
  166.     GotoXY(15,10);
  167.     WriteLn('Das Feld wird jetzt als STRING[45] ',
  168.             'interpretiert!');
  169.     x.P := @Feld; { für Zugriff über implizite Typwandlung }
  170.     GotoXY(17,11);
  171.     WriteLn(x.Z^);
  172.     y.P := @Feld; { für Zugriff über explizite Typwandlung }
  173.     GotoXY(17,12);
  174.     WriteLn(STRING(y.P^));
  175.     Nimmersatt;
  176.   END;
  177.  
  178.   PROCEDURE Epilog;
  179.   BEGIN
  180.     ClrScr;
  181.     GotoXY(10,12);
  182.     WriteLn('!!! Wie man sieht, ist alles möglich, ',
  183.             'auch ohne Assembler !!!');
  184.     Nimmersatt;
  185.   END;
  186.  
  187. BEGIN
  188.   Prolog;
  189.   Implizit_Wortweise;    { Implizite Typwandlung           }
  190.   Implizit_Byteweise;    { hier: byteweises inkrementieren }
  191.                          {       Zeiger(Integerfeld)!      }
  192.   Explizit_Wortweise;    { Explizite Typwandlung           }
  193.   Explizit_Byteweise;    { hier: byteweises inkrementieren }
  194.                          { Zeiger(Integerfeld)!            }
  195.   SeiEineZeichenkette; {Feld nun als Zeichenkette aufgefaßt}
  196.  
  197.   Epilog;
  198. END.
  199. (* ------------------------------------------------------ *)
  200. (*                Ende von PTRARITHM.PAS                  *)