API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Apr 18th, 2019
236
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Ada 43.99 KB | None | 0 0
raw download clone embed print report
  1. ADMIN BUCH BROWN KAPITEL 3 18.04.
  2. ALLE MÖGLICHKEITEN ADMIN BUCH
  3.  
  4. -- DEKLARATION
  5. ---------------------MODULARE DATEN TYP
  6. type INDEX_T is mod 7;
  7. N  : INDEX_T    := 6;
  8. N:= N+1;  -->0  wird automatisch wider 0 und dann 1 , 2 ,3,4,5,6,0
  9.  
  10. -- Enumeration_IO
  11. type FARBEN_T is (Rot, Gelb, Gruen, Blau, Schwar);
  12.  
  13. Farbe    :   FARBEN_T    :=Rot;
  14. package FARBEN_IO is new Ada.Text_IO.Enumeration_IO(FARBEN_T);
  15.  
  16. ---------------INTEGER----------------------------------------------------
  17.  
  18. I_POS    :   Integer     :=1;
  19.  
  20. package INTEGER_IO is new Ada.Text_IO.Integer_IO(INTEGER);
  21.    
  22. -- Posetive ganze Zahlen
  23.  I_Eingabe    :   NATURAL       :=0; -- NATURLICHE ZAHLEN von 0 ...
  24.  
  25.  I_Eingabe    :   Positive      :=1;  -- POSITIVE NATURLICHE ZAHLEN 1 ...
  26.  I_Eingabe    :  constant Positive      :=1;  -- CONSTANTE Zahl
  27. package POS_IO is new Ada.Text_IO.Integer_IO(INTEGER);
  28.    
  29. ----------------FLOAT-----------------------------------------------------------------
  30.  
  31. Mwst            :    FLOAT          :=19.0;
  32. Mwst            :   constant FLOAT          :=19.0; -- CONSTANTE Zahl
  33. package FLOAT_IO is new Ada.Text_IO.Float_IO(FLOAT)
  34. Ada.Text_IO.Put("Geben Sie MWST ein :");
  35. FLOAT_IO.Get(Mwst);
  36. ----------------Reihung /Array----------------------------------------------
  37.  
  38. type WOCHENTAG_T is (Mo,Di,Mi,Don,Fr,Sa);               -- "constrained"
  39. type MESSWERTE_TA is array (WOCHENTAG_T) of Integer;    -- "constrained"
  40. type REIHE1_TA is array (Integer range <>) of Integer;  -- "unconstrained" --> Range nicht vordefiniert mus dafür später definiert werden
  41. type REIHE1_TA is array (POSITIVE range <>) of BOOLEAN ;-- "unconstrained"
  42. Zustand :   REIHE1_TA(1 .. M)   :=(others=>True);
  43.  
  44. Messwert : MESSWERTE_TA ;
  45. Messwert : MESSWERTE_TA :=(1,2,3,4,5,6)-- Jede position von aray wird ein wert reingeschrieben
  46. Reihe1 : REIHE1(1..5)   :=(1=>1,2..4=>0,5=>2); -- IN erste wird 1 reingeschrieben in 2..4 0,in letzte wird 2 geschpeichert
  47. Reihe1 : REIHE1(1..5)   :=(others=>0); -- IN alle ein 0 reinschreiben
  48. Reihe1      := (1,2,3,4,5);
  49. Reihe1(3..5)        := (1,2,3);
  50. Reihe1 : REIHE1(1..5);
  51. Reihe2 : REIHE1(1..10);
  52. Reihe3 : REIHE1(11..20);
  53.  
  54. Reihe2(1):=Reihe1(1);
  55. Reihe2(1..5):= Reihe1(1..5);
  56. Reihe2(6..10):=Reihe1;
  57.  
  58. Reihe2(1..6):= Reihe1&6-- mit & kann man restliche kästchen füllen
  59. ------------------------STRING---------------------------------------------------
  60. subtype STRING_TA is STRING(1..5);
  61. type ANZAHL_T is range 1 .. 12;--
  62. type HOERSAAL_TA is array (ANZAHL_T range <>) of STRING_TA ;-- maximal 12 gros darf aber kleiner sein wegen range <> unconstrained
  63. type HOERSAAL_TA is array (ANZAHL_T) of STRING_TA ;   --Constrained genau von länge 12
  64. Hoersaal : HOERSAAL_TA(1..10):=  ;
  65. Hoersaal : HOERSAAL_TA(1..10):= (others=>(Others=>'_')  );-- Schreib (in alle 10(in alle 5 string komponenten ein _ rein )
  66.  
  67.  
  68. Hoersaal(3)(1..3):= "MAX";
  69. Hoersall : HOERSAAL_TA :=
  70.  
  71.  
  72. ---------------STRING----------------------------------------------
  73. subtype STRING_TA is STRING(1..5);
  74.  
  75. Eingabe : STRING(1..10):= (other=>" ");
  76.         : STRING := ("         ");
  77. Text1   : STRING := ("Hallo   ....);
  78. Text2   : STRING := (Text1'Frist . . Text1'Last=>' ');
  79. LetzteIndex : NATURAL:=0;
  80. Char    := Text(i);
  81. if Text1(Index) in 'A' .. 'Z'; then
  82. if CHARACTER'Pos(Char) in 65 .. 90 then
  83. Char    := CHARACTER'Val(CHARACTER'Pos(Char) + 32); -- Aus eine Große wird kleine Buchstabe
  84. Text2(Index):= CHARACKTER'VAL(CHARACKTER'POS(Text(Index))+32);
  85. end if;
  86. --------------------------------------------------------------------
  87. begin
  88. Ada.Text_IO.Put (" Geben Sie en Name ein ");
  89. Ada.Text_IO.Put_Line("TEXT");
  90. Ada.Text_IO.Get(Eingabe);  -- Gibt einzelne zeichen ,nach einander , Skip_Line immer nötig!!!!!
  91. Ada.Text_IO.Get_Line(Text,Index); -- Gibt alles aus was drin ist
  92. if Index = Text'Last then
  93.         Ada.Text_IO.Skip_Line; -- Lehrt den puffer
  94.     end if;
  95. ----------------------------------------------------------------Ausgabe in Einem satz tex + Integer--------
  96.  
  97.  
  98. Ada.TEXT_IO.PUT("Ergebnis ="& INTEGER'IMAGE(Ergebnis));
  99.  
  100. ------------------------------------------------------------------
  101. LetzteIndex : Integer;
  102. begin
  103. Ada.Text_IO.Skip_Line;
  104. Ada.Text_IO.Put(Eingabe);
  105. Ada.Text_IO.Put(Eingabe(1..3);-- Nur drei zeichen von 10 ausgeben
  106.  
  107. Ada.Text_IO.Get_Line(Eingabe, LetzteIndex);
  108. Ada.Text_IO.Put(Eingabe(Eingabe'First..LetzteIndex);
  109.    
  110.     --Anweisungsteil
  111.     Ada.Text_IO.Get_Line(Eingabe,LetzteIndex);
  112.     if LetzteIndex=Eingabe'Last then
  113.         Ada.Text_IO.Skip_Line;
  114.     end if;
  115.    
  116. --begin
  117. Messwer(Mi):=5;
  118. Messwert(FR):=Messwete(Mi);
  119. Messwert(Don . . Sa) := MEsswert (Mo..Mi);
  120. Messwert(Mi . . Mi) := 5 ; XXXX -- Nichtmöglich Feller
  121.  
  122.  
  123. for Index in Rehe1'Range loop                   -- und nicht for in INTEGER'Range und nict REIHE1_TA'Range
  124.                                  -- sonst wird zwei miliarden mal schleife laufen
  125. null;
  126. end loop;
  127.    
  128.  
  129. --Eingabe
  130. -----------------------------SCHLEIFEN------------------------------------
  131.  
  132. --------------------------For SCHLEIFE-----------------------------------
  133. --for i in reverse 0..I_Eingabe  loop -- Schleife zählt rückwerts
  134.  
  135. for i in 0..I_Eingabe  loop
  136.  
  137.         I_POS := I_Eingabe mod 5;
  138.        
  139.  end loop;
  140.  
  141. -- i wird nur in der Schleife benutzt braucht nicht deklariert werden,nach derschlefe verschwindet
  142. ----------------Schleife in schleife um Zeilen und Spalten Darzustellen Ausrechnen
  143.  
  144.     for i in 2..I_n loop -- NEU ZEILE
  145.  
  146.         Integer_IO.Put(i,Width => 4);
  147.         Ada.Text_IO.Put(" !");
  148.         for a  in reverse  2 .. I_p loop  -- NEU SPALTE
  149.            
  150.             I_Ausgabe_p := i ** a;
  151.             -- Integer_IO.Put(a,Width => 0);
  152.             Integer_IO.Put(I_Ausgabe_p,Width => 4);
  153.             Ada.Text_IO.Put(" !");
  154.  
  155.         end loop;
  156.        
  157.         Ada.Text_IO.New_Line;
  158.  
  159.     end loop;
  160. ----------------------- FUSGEsTEUERTE SCHLEIFE
  161. loop
  162.        
  163.         I_Antwort := I_Eingabe mod I_Index;
  164.        
  165.         exit when I_Antwort=0 or I_Index = I_Eingabe;
  166.         I_Index :=I_Index+1;
  167.     end loop;
  168.    
  169. --------------------------- WHILE  und CASE  --------------------------------
  170.   while Restgeld > 0 loop
  171.  
  172.      case  Index is
  173.         when 0 => teiler  :=  50;
  174.         when 1 => teiler  :=  20;
  175.         when 2 => teiler  :=  10;
  176.         when 3 => teiler  :=  5;
  177.         when 4 => teiler  :=  2;
  178.         when 5 => teiler  :=  1;
  179.         when others => null ;
  180.  
  181.      end case;
  182.  
  183.      Menge:= Restgeld / teiler;
  184.  
  185.      if Menge /= 0 then
  186.  
  187.      Integer_IO.Put(Menge,0);
  188.      Ada.Text_IO.Put(" * ");
  189.      Integer_IO.Put(Teiler,0);
  190.      Ada.Text_IO.Put(" Euro, ");
  191.     Restgeld := Restgeld-Menge* Teiler;
  192.     --Restgeld= Restgeld mod Teiler *** Sol selbe raus kommen wie oben ?
  193.            
  194.         end if ;
  195.  
  196.         Index := Index + 1 ;
  197.  
  198.      end loop;
  199.  --------------------   EINGABE AUSGABE----------------------------
  200. Ada.Text_IO.Skip_Line;                  -- LEHRT Speicher
  201. Ada.Text_IO.Put_Line( "Fahrbwert:" );   -- Ausgabe Text_IO
  202. Integer_IO.Put(I_Index,Width => 0);     -- Ausgabe INTEGER
  203. INTEGER_IO.Get(I_Eingabe);          -- Eingabe INTEGER
  204. FARBEN_IO.Put(FARBEN_T'Aft(I_POS));     -- Ausgabe Selbsdefinierte Typen
  205.  
  206.  
  207.  FARBEN_IO.Put(Farbe(I_POS));           -- Ausgabe Enumeration Aufzahlung
  208. FARBEN_IO.Put(FARBEN_T'Val(I_POS));    -- von wert aus Position I_POS
  209.  FARBEN_IO.Put(FARBEN_T'First);         -- Ausgabe Erstes Wertes aus Variaable
  210.  FARBEN_IO.Put(FARBEN_T'Last);          -- Ausgabe Letztes Wertes aus Variaable
  211.  FARBEN_IO.Put(FARBEN_T'Min(  ,  ));    -- Zwei parameter von denen wird kleinste ausgegeben
  212.  FARBEN_IO.Put(FARBEN_T'Max(  ,  ));    -- Zwei parameter von denen wird Groste ausgegeben
  213.  FARBEN_IO.Put(FARBEN_T'Image(   ));    -- Integer in String umwandeln
  214.  FARBEN_IO.Put(FARBEN_T'Range);         -- Alle ausgeben
  215.  FARBEN_IO.Put(FARBEN_T'Succ(  ));      -- nachste
  216.  FARBEN_IO.Put(FARBEN_T'Pred( ));       -- Vorherige ausgeben
  217.  FARBEN_IO.Put(FARBEN_T'Length);        -- Lenge von der
  218.  FARBEN_IO.Put(FARBEN_T'Pos(Gruen)) -- Stelle von Gruen zurück / bei Char kommt ASCII raus
  219. -- CHARACTER'POS('A')  = wert position zahl (hier: 65)
  220. -- CHARACTER'Val(65)  = INHALT Buchstabe (hier: 'A')
  221.  
  222. ---------------------Ausgabe auf dem Monitor---------------------------
  223. Enumeration --> Richtung
  224. ---------
  225. width
  226.  
  227. Float :     <-- Richtung
  228. -----.-----
  229. Fore   Aft
  230.  
  231. INTEGER     <-- Richtung
  232. -------
  233. Width
  234. ------------------------------------Range---------------------------------
  235. Zustand'Range ist Gleich Zustand'Frist .. Zustand'Last
  236.  
  237. ---------Record / Einfache verbund
  238. subtype STRING_10_TA is (1..10);
  239.  
  240. type PERSON_TR is record
  241.     Vorname  : STRING_10_TA := (others=>' ');
  242.     Nachname : STRING_10_TA := (others=>' ');
  243.     Alter    : NATURAL  :=0;
  244. end record;
  245. Person : PERSON_TR ;
  246. Person2 : PERSON_TR := "Tobias    ","Mustermann",55;
  247.  
  248. begin
  249. Person.Vorname'(1..3) := "Max";
  250. Ada.TEXT_IO.Put(Person.Vorname);
  251. Person2:= Person;
  252. ---------------Aggregat
  253. Geburtstag  : DATUM_TR :=       (19, 01, 1994);-- Aggregat 
  254. -------------------BLÖCKE-------------------------------------------
  255. with Ada.Text_IO;
  256.  
  257. procedure Main is
  258.                             --Haupt Programmm
  259. begin
  260.     Kreis :                 --Blöck Begin
  261.     declare
  262.         Radius,Umfan,Flaeche : Float:=0.0;
  263.        
  264.     begin
  265.         Ada.Text_IO.Put(" BItte Radius eingeben ");
  266.         F_IO.get(Radius);
  267.        
  268.    
  269.     end Kreis;              -- Blöck Ende
  270.    
  271. end Main;                   -- Hauptprogramm ende
  272. -------------------------UNTERPROGRAMME-------------------------
  273. --Spezifikation
  274. Wer1,Wert2 : INTEGER;
  275. Wert1 :=5;
  276. Wert2 :=3;
  277. procedure  Swap (X,y :in out INTEGER); --  in       --  wird wert in unterprogram mitgenomen
  278.                                                     --  INTEGER:=1) so kann man ein standart wert vordefenieren
  279.                                         -- out      -- wird wert von unterprogramm zurück gegeben
  280.                                         -- in out   -- wird mitgenomen verarbeitet und wider zuruckgegeben
  281. --Implementirung
  282. procedure Swap (X,Y : in out INTEGER) is
  283.     hill : INTEGER := X;
  284. begin
  285.     X :=Y;
  286.     Y :=Hill;
  287. end Swap;
  288.  
  289. begin
  290. Swap(Wert1,Wert2);-- proceduren stehen immer aleine
  291. -- Ergebnis inhalt von Wert1 ist =3 und Wert2 ist = 5 alles pasiert inerhalb der Unterprogramma
  292. bei in kön
  293. ------------------------FUNKTIONEN------------------------------
  294. --Rückgabewert
  295. --Anweisungsteil, inerhalb von Anweisungen / DEKLARATION : bei Initialisirungen nie alleine
  296. --Spezifikation
  297. function Add (X,Y : in INTEGER) return INTEGER;
  298. --Implementirung:
  299. function Add (X,Y : in INTEGER) return INTEGER is
  300.     Ergebnis :INTEGER :=0;
  301. begin
  302.     Ergebnis := X+Y;
  303.     return Ergebnis;
  304. end Add;
  305. -- Ausgerufen wird funktion
  306. Integer_IO.Put(Add(Wert1 ,Wert2);--------------oder Integer_IO.Put(Add(3,5);
  307. --Ergebnis es wird summe von wert1 und Wert2 auf dem Monitor ausgegeben ;
  308. ---------------------CURSOR POSITIONIREN----------------------------
  309. Ada.Text_IO.Set_Col(45);--Cursor position an stelle 45 damit er immer an gleiche stelelle erschein
  310. -----------------------------------------------------------------------
  311. Ada.Text_IO.Skip_Line; -- UM in der Zeile zu bleiben und puffer lehren
  312. ------------------------------------------------------------
  313.  
  314.  
  315. ******************************ADMIN BUCH von NATALI ****************************************************************
  316.        
  317.        
  318.     with Ada.Text_IO;                               -- Begin von jedem Ada-Programm
  319.     with Ada.Numerics;                              -- bei verwendung von Pi und e = 2.71...
  320.    
  321.     beim rechnen mit Pi oder e  Ada.Numerics.Pi/e
  322.    
  323.     procedure < Name der Aufgabe >  is              -- Name womit auch abgespeichert wird
  324.    
  325.     1.13        -- reelles Literal
  326.     2345        -- ganzzahliges Literal
  327.     'a'         -- Zeichenliteral
  328.     "hallo"     -- Zeichenkettenliteral (STRING)
  329.    
  330. --------------------------------------------------------------------------------------------
  331.     Skalare Datentypen
  332.    
  333.                         DISKRETE DATENTYPEN                                                        
  334.                
  335.         Aufzaehlungstypen               Ganzzahlige Typen
  336.         Selbstdefinierte S.36           Selbstdefinierte S.43
  337.         Vordefinierte                   Vordefinierte    S.41
  338.             1. CHARACHTER S.37              1. INTEGER
  339.             2. BOOLEAN    S.38              2. NATURAL 0 .. <>
  340.                                             3. POSITIVE 1.. <>
  341.                                         Selbstdefinierte modular S.44
  342.                                        
  343.         Operatoren                      Operatoren
  344.         1. =, /=, <, >, <=, >=          1. =, /=, <, >, <=, >=     
  345.                                         2. +; -; *; /; rem; mod; **;
  346.        
  347.         Attribute
  348.        
  349.                                        
  350.                         REELWERTIGE DATENTYPEN
  351.                        
  352.         Fliesskommatypen                Festpunkttypen
  353.         Selbstdefinierte
  354.         Vordifinierte
  355.             1. FLOAT    S.47
  356.            
  357.         Operatoren
  358.         1. =, /=, <, >, <=, >=     
  359.         2. +; -; *; /; rem; mod; **;
  360. --------------------------------------------------------------------------------------------
  361.  
  362.     -> Aufzaehlungstypen
  363.    
  364.     1. Selbstdefinierte
  365.         type FARBE_T is (Rot, Blau, Gelb);                 
  366.         type HEX_ZIFFER_T is ('0', '1', '2', '3', .. 'F');
  367.        
  368.         -- Bezeichnung immer alle Buchstaben GROSS mit _T
  369.        
  370.         Farbe : FARBE_T     := Blau;        -- Bei Variablen immer der erste BUchstabe gross
  371.        
  372.     2. Vordefinierte
  373.         Char : CHARACHTER   := 'A';         -- Es wird auf Vordef. Datentypen zugegriffen
  374.         Bool : BOOLEAN      := False;
  375.  
  376.        
  377.     -> Ganzzahlige Datentypen
  378.    
  379.     1. Selbstdefinierte
  380.         type STUDENTEN_T is range 0 .. 23;
  381.         type SEITEN_NUMMERN_T is range 1 .. 2000;
  382.        
  383.     2. Selbstdefinierte modular
  384.         type BYTE_T is mod 256;             -- Bereich geht von 0 .. 255;
  385.                                             -- => Wertebereichseinschraenkung
  386.         type HASH_INDEX_T is mod 97;
  387.        
  388.     3. Vordefinierte
  389.         A : INTEGER     := 2;               -- geht von -<> .. <>
  390.         B : NATURAL     := 5;               -- geht von 0 .. <>
  391.         C : POSITIVE    := 10;              -- geht von 1 .. <>
  392.        
  393.     4. Untertypen
  394.         subtype SMALL_INT_T is INTEGER range -10..10;
  395.         subtype TSN_T is POSITIVE;
  396.        
  397.     -> Fliesskommatypen
  398.    
  399.     1. Selbstdefinierte
  400.         type T3_T is digits 3;              -- die Zahl ist auf 3 Stellen genau
  401.         type Preis_T is 1.0 .. 10.0;
  402.        
  403.     2. Vordefinierte
  404.         A : FLOAT := 0.0;
  405.    
  406.     3. Untertypen
  407.         subtype F_IO is FLOAT range 5.0 .. 50.0;
  408.                
  409. ---------------------------------------------------------------------------------------------      
  410.     Aufrufen der Packete zum Einlesen und Ausgeben
  411.    
  412.     package INTEGER_IO is new Ada.Text_IO.INTEGER_IO(INTEGER);
  413.     package FLOAT_IO is new Ada.Text_IO.FLOAT_IO(FLOAT);
  414.     package <Name des Datentyp>_IO is new Ada.Text_IO.Enumeration_IO(<Name des Datentyp>);
  415.    
  416. ---------------------------------------------------------------------------------------------
  417.  
  418.     ATTRIBUTE auf DISKRETE Typen
  419.    
  420.     type HEX_ZIFFER_T is ('0', '1', '2', '3', .. 'F');  -- Aufzaehlungstypen
  421.     type ZAHLEN_T is range -5 .. 5;                     -- ganzzahliger Datentypen
  422.    
  423.     T'First => das erste Element
  424.             HEX_ZIFFER_T'First = '0'
  425.             ZAHLEN_T'First = -5
  426.    
  427.     T'Last => das letzte Element
  428.             HEX_ZIFFER_T'Last = 'F'
  429.             ZAHLEN_T'Last = 5
  430.            
  431.     T'Val => der Wert einer Positionsnummer
  432.             HEX_ZIFFER_T'Val(15) = 'F'
  433.             ZAHLEN_T'Val = 2
  434.  
  435.     T'Pos => die Positionsnummer eines Wertes
  436.         HEX_ZIFFER_T'Pos('A') = 10
  437.         ZAHLEN_T'Pos(-3) = -3
  438.        
  439.     T'Pred => Vorgaenger eines Wertes
  440.         HEX_ZIFFER_T'Pred('C') = 'B'
  441.         ZAHLEN_T'Pred(3) = 2
  442.        
  443.     T'Succ => Nachfolger eines Wertes
  444.         HEX_ZIFFER_T'Succ('B') = 'C'
  445.         ZAHLEN_T'Succ(-3) = -2
  446.  
  447.     Die Attribute First, Last, Val, Pred und Succ liefern Werte des Typs T !
  448.     Das Attribut Pos liefert einen Wert vom Typ universal_integer !
  449.    
  450.     -- Constrained wenn Nachfolger ausser Wertebereich
  451.    
  452. ---------------------------------------------------------------------------------------------
  453.  
  454.     Datentyp STRING
  455.    
  456.         type STRING is array (POSITIVE range <>) of CHARACHTER; -- Vordefiniert in Ada.Text_IO
  457.         subtype STRING_15_TA is array STRING(1..15);
  458.    
  459.     Ausgabe von STRINGS
  460.    
  461.         * Put(Item : in STRING);       
  462.         =>  Ausgabe einer Zeichenkette
  463.        
  464.         * Put_Line(Item : in STRING);          
  465.         =>  Ausgabe einer Zeichenkette mit anschliessendem Zeilenende
  466.        
  467.         * Get(Item : out STRING);
  468.         =>  Einlesen eienr Zeichenkette
  469.             Wenn Laenge auf 10 definiert ist muessen 10 Zeichen eingegeben werden.
  470.             Werden mehr eingegeben, werden sie durch nachfolgendes Skip_Line geloescht
  471.            
  472.         * Get_Line(Item: in STRING; Last: out NATURAL) 
  473.         =>  Einlesen eienr Zeichenkette, dass einlesen wird beendet falls,
  474.             das Zeilenende erreicht ist, in diesem fall Skip_Line,
  475.             das Ende der Zeichenkette erreicht ist.
  476.        
  477.             Letzter_Index : NATURAL := 0;
  478.             Zeichenkette : STRING(1..10) := (others => ' ');
  479.            
  480.             Ada.Text_IO.Get_Line(Zeichenkette, Letzter_Index);
  481.             if Letzter_Index = Zeichenkette'Last then
  482.                 Ada.Text_IO.Skip_Line;
  483.             end if;
  484.            
  485.             Ada.Text_IO.Put(Zeichenkette(Zeichenkette'First..Letzter_Index));
  486.            
  487.         * Suchen einer Teilzeichenkette
  488.        
  489.             Name : STRING(1..15) := ????;
  490.             Such : STRING(1..3)  := ????;
  491.            
  492.             for I in Name'First..Name'Last - Such'Length +1 loop
  493.                 if Name(I..I+Such'Length -1) = Such then
  494.                     <Aktion>;
  495.                 end if;
  496.             end loop;
  497.            
  498. --------------------------------------------------------------------------------------------           
  499.     Reihungen
  500.    
  501.     1. Beschraenkte Reihung S.3    
  502.         Deklaration
  503.        
  504.         1.1 Komponentendatentyp =>  INTEGER
  505.         1.2 Indexbereich        =>  type WOCHENTAGE_T is (Mo, Di, Mi, Don, Fr, Sa, So);
  506.         1.3 Reihungsdatentyp    =>  type WOCHE_TA is array (WOCHENTAGE_T)of INTEGER;
  507.         1.4 Variable            =>  Initialisierung
  508.                                     Reihung2 :  WOCHE_TA;
  509.        
  510.         type VEKTOR_1_TA is array (1..10) of POSITIVE;
  511.         type REIHUNG_TA is array (INTEGER range 1..5) of FLOAT;
  512.         Reihung1 :  REIHUNG_TA;
  513.         Reihung2 :  REIHUNG_TA(1..5); -- NICHT ERLAUBT!!!
  514.    
  515.         -- Indexeinschränkung in Variable nicht erlaubt!!!    
  516.    
  517.     2. Unbeschraenkte Reihung
  518.         type REIHUNG_TA is array (INTEGER range <>) of FLOAT;  
  519.  
  520.         -- Der Index kann ueber gesamten Integerbereich gehen
  521.         -- Groesse muss bei Initialisierung angegeben werden
  522.        
  523.         Reihung1 :  REIHUNG_TA(1..10):= (others => 0.0);
  524.         Reihung2 :  REIHUNG_TA      := (1, 50, 23, 18, 9); 
  525.         -- Der Indexbereich ist 5 gross
  526.        
  527.     3. Zugriff auf eindimensionale Reihungen
  528.         Variable(< Bezeichnung Index >):= ???;
  529.         Reihung1(10) := 5.5;
  530.    
  531.     4. Attribute S. 7/8
  532.         * Sie beziehen sich immer auf den INDEXTYP
  533.         * Sie werden generell nur auf VARIABLEN angeendet
  534.         * Nicht auf unbeschraenkte Reihungen anwenden
  535.        
  536.         _TA'First => liefert die untere Grenze des INDEX bereichs
  537.             Reihung1'First = 1
  538.            
  539.         _TA'Last => liefert die obere Grenze des INDEX bereichs
  540.             Reihung1'Last = 10
  541.            
  542.         _TA'Length => liefert die Anzahlder INDEXWERTE als wert vom Typ universal_integer
  543.             Reihung1'Length = 10
  544.  
  545.         _TA'Range => liefert den INDEX-Bereich, enspricht _TA'First .. _TA'Last
  546.        
  547.         -- Attribut immer auf Variable anwenden, nicht auf Datentyp!
  548.            
  549.     5. Aggregate
  550.    
  551.         * positionelles Aggregat
  552.         type WOCHENTAGE_T is (Mo, Di, MI, Don, Fr, Sa, So);
  553.         type STUNDENUEBERSICHT_TA is array (WOCHENTAGE_T range Mo .. Fr) of NATURAL;
  554.         Arbeitskarte : STUNDENUEBERSICHT_TA := (0, 0, 0, 0, 0);
  555.         Arbeitskarte := (8, 9, 8, 2, 2);
  556.         -- Für jeden INDEX muss ein Wert angegeben werden.
  557.        
  558.         * Namentliche Aggregate
  559.         Arbeitskarte := (Di => 5, Mo | Mi => 4, Don..Fr => 3);
  560.        
  561.         * Aggregate mit others
  562.         Arbeitskarte := (Mo => 5, others => 7);
  563.        
  564.     6. leere Reihung
  565.    
  566.         Bei leerer Reihung ist der linke Indexwert immer kleiner als der rechte.
  567.         Reihung1(2..1) := leere Reihung;
  568. --------------------------------------------------------------------------------------------
  569.     Reihung in Reihung
  570.    
  571.     type MITARBEITER_T is range 1..20;                 
  572.     type TAG_T is (Mo, Di, Mi, Don, Fr);
  573.     type UEBERSICHT_PRO_PERSON_TA is array (MITARBEITER_T) of BOOLEAN;
  574.     -- Innere Reihung Indextyp Mitarbeitern und Komponentendatentyp Boolean
  575.     -- Innere Reihung MUSS BESCHRAENKT sein!!!
  576.     type UEBERSICHT_TA is array (TAG_T) of UEBERSICHT_PRO_PERSON_TA;
  577.     -- Aeusserer Reihung mit Indexbereich Tag und Komponenten der inneren Reihung
  578.    
  579.     Anwesenheit : UEBERSICHT_TA;
  580.    
  581.     Anwesenheit(Di)(2):= false;     -- Die Anwesenheit wurde am Dienstag bei Mitarbeiter 2
  582.                                     -- auf false gesetzt.
  583.                                    
  584. --------------------------------------------------------------------------------------------
  585.     Mehrdimensionale Reihung
  586.    
  587.     type UEBERSICHT_TA is array (TAG_T, MITARBEITER_T) of BOOLEAN;
  588.    
  589.     Zugriff: Name(Index_Zeile, Index_Spalte);
  590.     Anwesenheit : UEBERSICHT_TA;
  591.     Anwesenheit(Di, 2) := false;
  592.    
  593.     Mehrdimensionale Reihungen koennen in allen Indizes unbeschraenkt oder beschraenkt sein
  594.     Bereiche sind bei mehrdimensionalen Reihungen nicht moeglich.
  595.    
  596.     * ATTRIBUTE
  597.     Hinter dem Attribut muss immer (1) fuer den Zeilenindex oder (2) fuer Spantlenindex
  598.     angegeben werden.
  599.    
  600.     A'First(1)  = ... => erster Wert des Zeilenindex
  601.     A'Last(2)   = ... => Letzter Wert des Spantlenindex
  602.     A'Length(1) = ... => Anzahl der Indexwerte des Zeilenindex als universal_integer
  603.     A'Range(2)  = ... => enspricht A'First(2)..A'Last(2) vom Spaltenindex
  604.    
  605.     * Aggregate
  606.     type ZWEIDIMENSIONAL_TA is array (1..2, 1..3) of INTEGER;
  607.     X: ZWEIDIMENSIONAL_TA;
  608.     X := (others => (others=> 0));              --  0   0   0
  609.                                                 --  0   0   0
  610.                                                
  611.     X := (others => (1 => 1, 2 => 2, 3 => 3));  --  1   2   3
  612.                                                 --  1   2   3
  613.                                                
  614.     X := (( 11, 12, 13), (21, 22, 23));         --  11  12  13
  615.                                                 --  21  22  23
  616.  
  617.     X := (1=> (1=> 11, 2=> 12 3=> 13), 2=> (21, 22,23));    --  11  12  13
  618.                                                             --  21  22  23     
  619.  
  620.     Beispiel:
  621.     type ZEILE_T is range 1..4;
  622.     type SPALTE_T is (a, b, c, d);
  623.     type KOMPONENTE_T is range 0..10;
  624.     type TEST_A_TA is array (ZEILE_T, SPALTE_T) of KOMPONENTE_T;
  625.    
  626.     Konstant_Feld : constant TEST_A_TA := (1..2 => (a => 1, others 0),
  627.                                            4    => (b|d => 2, others => 10),
  628.                                            others => (others => 0));
  629.                                            
  630.     --     a    b   c   d
  631.     --  1   1   0   0   0
  632.     --  2   1   0   0   0
  633.     --  3   0   0   0   0
  634.     --  4   10  2   10  2
  635.    
  636.    
  637. --------------------------------------------------------------------------------------------
  638.     Einfache Verbunde
  639.    
  640.     type DATUM_TR is record
  641.         Tag     : INTEGER range 1..31;                      -- implizite Initialisierung
  642.         Monat   : INTEGER range 1..12       := 1;           -- explizite Initialisierung
  643.         Jahr    : INTEGER range 1900..2100  := 1990;
  644.     end record;
  645.    
  646.     * Aggregat
  647.         - Alle Komponenten muessen genau einmal genannt werden
  648.         - positionell, namentiliche Zuweisung oder Mischform moeglich
  649.        
  650.         Aktuelles_Datum : DATUM_TR := (16, 4, 2019);
  651.         Aktuelles_Datum : DATUM_TR := (Tag => 16, Monat => 4, Jahr => 2019);
  652.        
  653.     * Operationen
  654.         - die Zuweisung :=
  655.         - die Vergleichsoperationen = und /=
  656.         - Komponentenselektion .
  657.            
  658.             Aktuelles_Datum.Monat := 8;
  659.            
  660.             -- Beispiel
  661.             type TEXT_TR is record
  662.                 Laenge: NATURAL := 0;
  663.                 Inhalt: STRING(1..80):= (others => ' ');
  664.             end record;
  665.                
  666.             T: TEXT_TR;
  667.            
  668.             T.Inhalt(2..7) := "Klausi"
  669.    
  670. --------------------------------------------------------------------------------------------
  671.     Verbunde mit Diskriminante
  672.    
  673.    
  674.    
  675. --------------------------------------------------------------------------------------------   
  676.     Kontrollstrukturen
  677.    
  678.     if - Anweisungen
  679.    
  680.         if < Bedingung> then
  681.             <Anweisung>;
  682.         end if;
  683.        
  684.         if < Bedingung> then    -- wird eine Bedingung erfuellt, wird if Anweisung verlassen
  685.             <Anweisung>;
  686.         elsif < Bedingung> then
  687.             <Anweisung> ;
  688.         elsif < Bedingung> then
  689.             <Anweisung>;   
  690.         end if;
  691.        
  692.         if < Bedingung> then
  693.             <Anweisung>;
  694.         else
  695.             <Anweisung>;       
  696.         end if;
  697.        
  698.         if < Bedingung> then
  699.             <Anweisung>;
  700.         else
  701.             null;                       -- Nullanweisung, es passiert nichts
  702.         end if;
  703.        
  704.     case - Anweisung
  705.    
  706.         -- case benoetigt DISKRETEN Datentyp
  707.         -- BOOLEAN, CHARAKTER, INTEEGR, modular
  708.         -- kein FLOAT!!
  709.        
  710.         case X is                           case X is
  711.             when 10 =>                          when 50..100 =>        
  712.                 <Anweisung>;                        <Anweisung>;
  713.             when 20 =>                          when 20..49 =>
  714.                 <Anweisung>;                        <Anweisung>;
  715.             when others =>                      when others =>
  716.                 <Anweisung>;                        null;
  717.         end case;                           end case;
  718.                                         -- Bereiche duerfen sich nicht ueberschneiden
  719.  
  720. --------------------------------------------------------------------------------------------
  721.  
  722.     Schleifen
  723.    
  724.     1. Unkonditionierte Schleifen
  725.    
  726.         loop
  727.             <Anweisung>;
  728.         exit when <Bedingung>  
  729.         end loop;
  730.        
  731.     2. Konditionierte Schleife
  732.    
  733.         while <Bedingung> loop      --solange Bedingung true ist, wird Schleife ausgefuehrt
  734.             <Anweisung>;
  735.         end loop;
  736.        
  737.         * Muss keine Zaehlvaribale haben
  738.         * Bei verwendung einer Zaehlvariable muss diese angelegt werden
  739.         * Keine auto. Zaehlvar. => bestimmen der Schrittweite moeglich
  740.         * Bedingung statt Zaehler => komplexe Bedingungen moeglich
  741.        
  742.     3. Zaehlschleife
  743.    
  744.         for I in <Bereich> loop
  745.             <Anweisung>;
  746.         end loop;
  747.        
  748.         * Zaehlvariable wird automatisch angelegt
  749.         * Im Schleifenkoerper ist der Zaehler nicht veraenderbar
  750.         * Grenzen notwendig
  751.         * Schrittweite = 1
  752.         * Kann mit reverse Rueckwaerts Zaehlen
  753.        
  754. --------------------------------------------------------------------------------------------
  755.     Formatierung der Ausgabe
  756.    
  757.     => Aufzaehlungstypen Enumeration_IO
  758.         ENUMERATION_IO.Put(Item, width => 4, Type_Set => Upper_Case);      
  759.         -- width beschreibt linksbuendig Anzahl der Stellen,
  760.         -- Type_Set sagt ob alles gross oder klein geschrieben wird
  761.                                                                                
  762.     => FLOAT_IO
  763.         FLOAT_IO.Put(Item, Fore, Aft, Expo);                           
  764.         -- Fore sagt wie viele Zahlen vor dem Komma stehen Rechtsbuendig
  765.         -- Aft sagt wie viele Zahlen nach dem Komma,
  766.         -- Expo =0 => Dezimaldarstellung, =1 Exponentialdarstellung
  767.                                                                            
  768.     => INTEGER_IO
  769.         INTEGER_IO.Put(Item, width, Base);                                 
  770.         -- width beschreibt rechtsbuendig Anzahl der Stellen,
  771.         -- Base => Darstellung Zahlensystem
  772.                                                                            
  773.                                                                            
  774.                                                                            
  775. --------------------------------------------------------------------------------------------
  776.  
  777.     Oft genutzte Programmteile
  778.    
  779.     --INTEGER EInlesen und Ausgeben
  780.     package INTEGER_IO is new Ada.Text_IO.INTEGER_IO(INTEGER);
  781.  
  782.     Ada.Text_IO.Put(" ");
  783.     INTEGER_IO.GET( );
  784.     Ada.Text_IO.Skip_Line;
  785.     Ada.Text_IO.New_Line;
  786.    
  787.     Ada.Text_IO.Put(" ");
  788.     INTEGER_IO.Put( );
  789.     Ada.Text_IO.New_Line;
  790.    
  791.     -- FLOAT einlesen
  792.     package FLOAT_IO is new Ada.Text_IO.FLOAT_IO(FLOAT);
  793.    
  794.    
  795.     Ada.Text_IO.Put(" ");
  796.     FLOAT_IO.GET( );
  797.     Ada.Text_IO.Skip_Line;
  798.     Ada.Text_IO.New_Line;
  799.    
  800.     Ada.Text_IO.Put(" ");
  801.     FLOAT_IO.Put( );
  802.     Ada.Text_IO.New_Line;
  803.    
  804.     -- ENUMERATION einlesen und ausgeben
  805.     package <Name des Datentyp>_IO is new Ada.Text_IO.Enumeration_IO(<Name des Datentyp>);
  806.    
  807.     Ada.Text_IO.Put(" ");
  808.     <Name des Datentyp>_IO.GET( );
  809.     Ada.Text_IO.Skip_Line;
  810.     Ada.Text_IO.New_Line;
  811.    
  812.     Ada.Text_IO.Put(" ");
  813.     <Name des Datentyp>_IO.Put( );
  814.     Ada.Text_IO.New_Line;
  815.  
  816. *********************************AUFGABE SWPA
  817. -- Kontextklausel
  818. with Ada.Text_IO;
  819.  
  820. procedure Main is
  821.     -- Deklarationsteil
  822.  
  823.  
  824.  
  825.  
  826.  
  827.    
  828.  
  829.     -- Konstanten
  830.  
  831.  
  832.  
  833.     -- POSITION FÜR DIE AUSGABE
  834.     Pos_Anzahl      :   constant Ada.Text_IO.Count  :=5;
  835.     Pos_Bezeichnung :   constant Ada.Text_IO.Count  :=13;
  836.     Pos_Einzelpreis :   constant Ada.Text_IO.Count  :=28;
  837.     Pos_Ges_Preis   :   constant Ada.Text_IO.Count  :=43;
  838.     Breite_Preis        :   constant INTEGER        :=5;
  839.     Mwst            :   constant FLOAT          :=19.0;
  840.  
  841.     -- Typen
  842.     type ANREDE_T is (Herrn ,Frau);
  843.     type  ARTIKEL_T is (Hose,Hemd, Schue);
  844.     subtype STRING_46_TA is STRING(1 .. 46);
  845.    
  846.     type ABFRAGE_ARTIKEL_TA is array (ARTIKEL_T) of STRING_46_TA;
  847.     type ANZAHL_ARTIKEL_TA is array (ARTIKEL_T) of INTEGER;
  848.     type PREIS_TA is array (ARTIKEL_T) of  FLOAT;
  849.    
  850.     -- Pakete
  851.     package AN_IO is new Ada.Text_IO.Enumeration_IO(ANREDE_T);
  852.     package AR_IO is new Ada.Text_IO.Enumeration_IO(ARTIKEL_T);
  853.     package FLOAT_IO is new Ada.Text_IO.Float_IO(FLOAT);
  854.     package INTEGER_IO is new Ada.Text_IO.Integer_IO(INTEGER);
  855.  
  856.    
  857.     -- Variablen
  858.    
  859.     F_Gesamtpreis   :   FLOAT   := 0.0;
  860.     F_Porto     :   FLOAT   := 0.0;
  861.     F_Rabatt        :   FLOAT   := 0.0;
  862.     F_Endbetrag     :   FLOAT   := 0.0;
  863.     F_Einzelpreis   :   FLOAT   := 0.0;
  864.  
  865.     I_Nr            :   INTEGER :=1;
  866.    
  867.     Anzahl_Artikel  :   ANZAHL_ARTIKEL_TA   :=(others => 0 ); -- Array
  868.     Einzel_Preise   :   PREIS_TA        :=(
  869.         Hose =>     35.00,
  870.         Hemd =>     49.95,
  871.         Schue =>    29.95
  872.     );
  873.  
  874.    
  875.    
  876.  
  877.     Anrede      :   ANREDE_T    :=Herrn;
  878.    
  879.    
  880.     Abfrage_Artikel : ABFRAGE_ARTIKEL_TA :=(
  881.         Hose =>     "Wie viele Hosen moechten Sie kaufen ? :        ",
  882.         Hemd =>     "Wie viele Hemden moechten Sie kaufen ? :       ",
  883.         Schue =>    "Wie viele Paar Schue moechten Sie kaufen ? :   "
  884.     );
  885. begin
  886.     --Anweisungsteil
  887.  
  888.     -- EVA-Prinzip
  889.     -- Eingabeteil
  890. --------------------------------------------------------------------------------
  891.     Ada.Text_IO.Put("Preisuebersicht");
  892.     Ada.Text_IO.New_Line(2);
  893.  
  894.  
  895.  
  896.  
  897.     for Artikel in Einzel_Preise'Range loop
  898.    
  899.         AR_IO.Put(Artikel,Width => 10);
  900.         Ada.Text_IO.Put("=>  ");
  901.         FLOAT_IO.Put(Einzel_Preise(Artikel),Fore => 2,Aft => 2,Exp => 0);
  902.         Ada.Text_IO.Put_Line( " Euro");
  903.                
  904.     end loop;
  905.    
  906.     Ada.Text_IO.New_Line(5);
  907.    
  908.     for i in Abfrage_Artikel'Range loop
  909.         Ada.Text_IO.Put(Abfrage_Artikel(i));
  910.         --Ada.Text_IO.Set_Col(60);
  911.         INTEGER_IO.Get(Anzahl_Artikel(i));
  912.        
  913.         Ada.Text_IO.Skip_Line;
  914.     end loop;
  915. --     
  916. --      Ada.Text_IO.Put(Abfrage_Artikel(Hose));
  917. --      Ada.Text_IO.Set_Col(80);--Cursor position an stelle 45 damit er immer an gleiche stelelle erschein
  918. --      INTEGER_IO.Get(I_Anzahl_Hose);
  919. --      Ada.Text_IO.Skip_Line;
  920. --  
  921. --      Ada.Text_IO.Put(Abfrage_Artikel(Hemd));
  922. --      Ada.Text_IO.Set_Col(80);
  923. --      INTEGER_IO.Get(I_Anzahl_Hemd);
  924. --      Ada.Text_IO.Skip_Line;
  925. --  
  926. --      Ada.Text_IO.Put(Abfrage_Artikel(Schue));
  927. --      Ada.Text_IO.Set_Col(80);
  928. --      INTEGER_IO.Get(I_Anzahl_Schue);
  929. --      Ada.Text_IO.Skip_Line;
  930.  
  931.  
  932.  
  933.  
  934. --------------------------------------------------------------------------------
  935.     -- Verarbeitungsteil
  936.  
  937.     for Artikel in Anzahl_Artikel'Range loop  --
  938.         F_Gesamtpreis := F_Gesamtpreis + (FLOAT(Anzahl_Artikel(Artikel)) * Einzel_Preise(Artikel));
  939.     end loop;
  940.    
  941.    
  942.     --F_Rabatt BERECHNEN
  943.  
  944.     if F_Gesamtpreis >= 500.0 then
  945.         F_Rabatt := F_Gesamtpreis * 0.03;
  946.     elsif F_Gesamtpreis >= 200.0 then
  947.         F_Rabatt := F_Gesamtpreis * 0.02;
  948.     else
  949.         F_Rabatt := 0.0;
  950.     end if;
  951.  
  952.     --F_Porto PORTO BERECHENE
  953.  
  954.  
  955.     if F_Gesamtpreis - F_Rabatt >=100.0  then
  956.         F_Porto := 5.00;
  957.     end if;
  958.  
  959.  
  960.     --   F_Endbetrag
  961.  
  962.     F_Endbetrag := F_Gesamtpreis - F_Rabatt + F_Porto ;
  963.  
  964.     -- Ausgabeteil
  965.  
  966.     -- Zeilenlaenge auf 55 Zeichen festgelegt
  967.     -- Ausgabe der Kopfzeile1 (rechtsbuendig Ort,Datum)
  968.     Ada.Text_IO.Put_Line("                                   Feldafing,10.05.2012");
  969.     -- Ausgabe einer Leerzeile
  970.     Ada.Text_IO.New_Line;
  971.  
  972.     -- Anschriftenfeld
  973.     -- Anrede
  974.     --Ada.Text_IO.Put_Line("Herrn");
  975.     AN_IO.Put(Anrede);
  976.     Ada.Text_IO.New_Line;
  977.  
  978.     -- Vorname, Name
  979.     Ada.Text_IO.Put_Line("Max Mustermann");
  980.     -- Strasse, Hausnr
  981.     Ada.Text_IO.Put_Line("Schlossberg 10");
  982.     -- PLZ Ort
  983.     Ada.Text_IO.Put_Line("82340 Feldafing");
  984.     -- zwei Leerzeilen
  985.     Ada.Text_IO.New_Line(2);
  986.  
  987.     -- Ueberschrift_1 zentrieren
  988.     Ada.Text_IO.Put_Line("                       Rechnung");
  989.     -- Ueberschrift_2
  990.     Ada.Text_IO.Put_Line("                       ========");
  991.     -- zwei Leerzeilen
  992.     Ada.Text_IO.New_Line(2);
  993.  
  994.  
  995.     -- Spaltenueberschrift_1
  996.     Ada.Text_IO.Put_Line("Nr  Anzahl  Bezeichnung       Einzelpreis     Ges-Preis");
  997.     -- Spaltenueberschrift_2
  998.     Ada.Text_IO.Put_Line("-------------------------------------------------------");
  999.  
  1000.     -- Artikel Datensaetze
  1001.  
  1002.    
  1003.  
  1004.     for Artikel in Anzahl_Artikel'Range  loop
  1005.  
  1006.    
  1007.  
  1008.    
  1009.         --NR AUSGEBEN
  1010.         INTEGER_IO.Put(ARTIKEL_T'Pos(Artikel)+1, Width => 0);
  1011.  
  1012.         --ANZAHL AUSGEBEN
  1013.         Ada.Text_IO.Set_Col(Pos_Anzahl);
  1014.         INTEGER_IO.Put(Anzahl_Artikel(Artikel), Width => 0);
  1015.  
  1016.         --ARTIKEL AUSGEBEN
  1017.         Ada.Text_IO.Set_Col(Pos_Bezeichnung);
  1018.         AR_IO.Put(Artikel,10);
  1019.  
  1020.         --EINZELPREIS AUSGABE
  1021.         Ada.Text_IO.Set_Col(Pos_Einzelpreis);
  1022.         FLOAT_IO.Put(Einzel_Preise(Artikel), Fore => Breite_Preis, Aft => 2, Exp => 0); -- BREITE_ Preis = 5
  1023.  
  1024.         --GES PREIS AUSGABE
  1025.         Ada.Text_IO.Set_Col(Pos_Ges_Preis);
  1026.         FLOAT_IO.Put(FLOAT(Anzahl_Artikel(Artikel)) * Einzel_Preise(Artikel), Fore => Breite_Preis, Aft => 2, Exp => 0);
  1027.         Ada.Text_IO.Put_Line(" Euro");
  1028.  
  1029.         --FLOAT_IO.Put(Fore => 10)-- wiviele Stellen vor dem Komma ? in diesem fal  ( 10000, )
  1030.  
  1031.        
  1032.        
  1033.     end loop;
  1034.  
  1035.     -- Rechnungsunterstrich
  1036.     Ada.Text_IO.Put_Line("-------------------------------------------------------");
  1037.  
  1038.     -- Gesamtbetrag
  1039.     Ada.Text_IO.Put("Gesamtbetrag:");
  1040.     Ada.Text_IO.Set_Col(Pos_Ges_Preis);
  1041.     FLOAT_IO.Put(F_Gesamtpreis,Fore => Breite_Preis, Aft => 2, Exp => 0);
  1042.     Ada.Text_IO.Put_Line(" Euro");
  1043.  
  1044.     -- enthaltene Mehrwertsteuer 19%
  1045.     --Ada.Text_IO.Put_Line("enthaltene Mwst. (19.0%): 23.93 Euro                   ");
  1046.     Ada.Text_IO.Put("enthaltene Mwst. (");
  1047.     FLOAT_IO.Put(Mwst,Fore => 0,Aft => 1,Exp => 0);
  1048.     Ada.Text_IO.Put("%): ");
  1049.     FLOAT_IO.Put(F_Gesamtpreis / 100.0 * Mwst,Fore =>0,Aft => 2,Exp => 0 );
  1050.     Ada.Text_IO.Put_Line(" Euro");
  1051.  
  1052.  
  1053.  
  1054.  
  1055.     -- Porto und Verpackung
  1056.     --Ada.Text_IO.Put_Line("Porto (ab 100 Euro frei, 5.00 Euro ):         0.00 Euro");
  1057.     Ada.Text_IO.Put("Porto (ab 100 Euro frei, 5.00 Euro ):");
  1058.     Ada.Text_IO.Set_Col(Pos_Ges_Preis);
  1059.     FLOAT_IO.Put( F_Porto,Fore => Breite_Preis, Aft => 2, Exp => 0);
  1060.     Ada.Text_IO.Put_Line(" Euro");
  1061.  
  1062.  
  1063.  
  1064.     -- Rabatt
  1065.     -- Ada.Text_IO.Put_Line("Rabatt (ab 200 Euro 2.0%, ab 500 Euro 3.0%):  0.00 Euro");
  1066.     Ada.Text_IO.Put("Rabatt (ab 200 Euro 2.0%, ab 500 Euro 3.0%):");
  1067.     FLOAT_IO.Put( F_Rabatt,Fore => 3, Aft => 2, Exp => 0);
  1068.     Ada.Text_IO.Put_Line(" Euro");
  1069.  
  1070.     -- Rechnungsunterstrich
  1071.     Ada.Text_IO.Put_Line("-------------------------------------------------------");
  1072.  
  1073.     -- Endbetrag
  1074.     --Ada.Text_IO.Put_Line("Endbetrag:                                  149.90 Euro");
  1075.     Ada.Text_IO.Put("Endbetrag:");
  1076.     Ada.Text_IO.Set_Col(Pos_Ges_Preis);
  1077.     FLOAT_IO.Put( F_Endbetrag,Fore => Breite_Preis, Aft => 2, Exp => 0);
  1078.     Ada.Text_IO.Put_Line(" Euro");
  1079.  
  1080. end Main;
  1081.  
  1082.  
  1083. ***********************************************REfactoring2 UP Beispiele von Blocken Unterprogramen und funktionen
  1084. with Ada.Text_IO;
  1085.  
  1086. -- Modul-Name    :    Refactoring2Up (Hauptprogramm)
  1087. ------------------------------------------------------------
  1088. -- Refactoring (Design vorhandener Sw verbessern)
  1089. -- Unterprogramme (UP) extrahieren
  1090. -- 1. ohne lokale Variable -- ohne parameter
  1091. -- 2. mit lokale Variable nur lesender Zugriff
  1092. -- 3. mit Zuweisung einer lokalen Variablen FUNKTION
  1093. -- 4. mit lokale Variablen schreibender Zugriff
  1094. --------------------------------------------------------------------------
  1095. -- Beschreibung:
  1096. -- Dieses Programm liest Messwerte in ein Array ein,
  1097. -- ermittelt den Mittelwert und gibt diesen aus.
  1098. procedure Main is
  1099.  
  1100.     -- Typen
  1101.     type MESSWERTE_T is range 0 .. 1000;
  1102.     subtype INDEX_T is POSITIVE;
  1103.     type MESSREIHE_TA is array(INDEX_T range <>) of MESSWERTE_T;
  1104.  
  1105.     -- Pakete auspraegen
  1106.     package MESSWERT_IO is new Ada.Text_IO.Integer_IO(MESSWERTE_T);
  1107.  
  1108.     -- Variablen erzeugen
  1109.     Anzahl_Messwerte : INDEX_T := 5;
  1110.  
  1111.     Messreihe    : MESSREIHE_TA(1..Anzahl_Messwerte)  := (others => 0);
  1112.     Summe,
  1113.     Mittelwert   : MESSWERTE_T := 0;
  1114.    
  1115.     -- Proceduren
  1116.     procedure Ueberschrift ;                -- Aufgabe 1)
  1117.     procedure Mittelwertausgabe (X : in MESSWERTE_T);   --Aufgabe 2)
  1118.     procedure EingabeMeswerte (A : out MESSREIHE_TA) ;  --Aufgabe 4)
  1119.    
  1120.     function Berechnungmitelwertes ( X : in   MESSREIHE_TA) return MESSWERTE_T; -- Aufgabe 3
  1121.     -- Implementirung
  1122.     procedure Ueberschrift is
  1123. --------------------------------------------------------------------------------
  1124.         --Aufgabe 1)
  1125.         --keine variablen anlegen wird nicht
  1126.     begin
  1127.         Ada.Text_IO.Put_Line("***************************");
  1128.         Ada.Text_IO.Put_Line("*   Messwerte ermitteln   *");
  1129.         Ada.Text_IO.Put_Line("***************************");
  1130.     end Ueberschrift ;
  1131. --------------------------------------------------------------------------------
  1132.     --Aufgabe 2)
  1133.     procedure Mittelwertausgabe (X : in MESSWERTE_T) is
  1134.     begin
  1135.         -- Ausgabe des Mittelwertes
  1136.         Ada.Text_IO.Put("Der Mittelwert der Messreihe ist: ");  -- in out
  1137.         MESSWERT_IO.Put(Mittelwert);
  1138.     end Mittelwertausgabe;
  1139. --------------------------------------------------------------------------------   
  1140.     --Aufgabe 4)
  1141.     procedure EingabeMeswerte (A : out MESSREIHE_TA) is
  1142.     begin
  1143.         for Index in A'Range loop
  1144.             Ada.Text_IO.Put("Geben Sie den" & INTEGER'Image(Index) & ".Messwert ein: ");
  1145.             MESSWERT_IO.Get(A(Index));
  1146.             Ada.Text_IO.Skip_Line;
  1147.         end loop;
  1148.        
  1149.     end EingabeMeswerte;
  1150. --------------------------------------------------------------------------------   
  1151.     --Aufgabe 3 eine Funktion
  1152.     function Berechnungmitelwertes ( X : in  MESSREIHE_TA) return MESSWERTE_T is
  1153.         Mittelwert, Summe : MESSWERTE_T := 0;
  1154.        
  1155.     begin
  1156.         for Index in Messreihe'Range loop              
  1157.             Summe:= Summe + X(Index);
  1158.         end loop;
  1159.         Mittelwert := Summe / MESSWERTE_T(Anzahl_Messwerte); -- Funktion
  1160.         return Mittelwert;
  1161.     end Berechnungmitelwertes;
  1162. --------------------------------------------------------------------------------   
  1163. begin
  1164.     -- Erste prozedur Aufrufen
  1165.     -- Ausgabe der Ueberschrift
  1166.     Ueberschrift;                    -- Aufgabe 1)
  1167.    
  1168.     -- Eingabe der Messwerte
  1169.     EingabeMeswerte(Messreihe);      -- Aufagbe 4)
  1170.  
  1171.     -- Berechnen des Mittelwertes    -- Aufgae 3)
  1172.     Mittelwert := Berechnungmitelwertes(Messreihe);
  1173.  
  1174.    
  1175.     -- Funktion übernimt den mittelwert und gibt in aus auf Monitor
  1176.     Mittelwertausgabe (Mittelwert); -- Aufgabe 2)
  1177. end Main;
  1178.  
  1179. --------------------------------ORIGINAL
  1180. --  procedure Refactoring2Up is
  1181. --        -- Typen
  1182. --     type MESSWERTE_T is range 0 .. 1000;
  1183. --     subtype INDEX_T is POSITIVE;
  1184. --     type MESSREIHE_TA is array(INDEX_T range <>) of MESSWERTE_T;
  1185. --  
  1186. --     -- Pakete auspraegen
  1187. --     package MESSWERT_IO is new Ada.Text_IO.Integer_IO(MESSWERTE_T);
  1188. --  
  1189. --     -- Variablen erzeugen
  1190. --     Anzahl_Messwerte : INDEX_T := 5;
  1191. --  
  1192. --     Messreihe    : MESSREIHE_TA(1..Anzahl_Messwerte)  := (others => 0);
  1193. --     Summe,
  1194. --     Mittelwert   : MESSWERTE_T := 0;
  1195. --  
  1196. --  begin
  1197. --  
  1198. --     -- Ausgabe der Ueberschrift
  1199. --     Ada.Text_IO.Put_Line("***************************");
  1200. --     Ada.Text_IO.Put_Line("*   Messwerte ermitteln   *");
  1201. --     Ada.Text_IO.Put_Line("***************************");
  1202.  
  1203. --     -- Eingabe der Messwerte
  1204. --     for Index in Messreihe'Range loop
  1205. --         Ada.Text_IO.Put("Geben Sie den" & INTEGER'Image(Index) & ".Messwert ein: ");
  1206. --         MESSWERT_IO.Get(Messreihe(Index));
  1207. --         Ada.Text_IO.Skip_Line;
  1208. --     end loop;
  1209.  
  1210. --     -- Berechnen des Mittelwertes
  1211. --     for Index in Messreihe'Range loop
  1212. --         Summe:= Summe + Messreihe(Index);
  1213. --     end loop;
  1214. --  
  1215. --     Mittelwert := Summe / MESSWERTE_T(Anzahl_Messwerte);
  1216.  
  1217. --     -- Ausgabe des Mittelwertes
  1218. --     Ada.Text_IO.Put("Der Mittelwert der Messreihe ist: ");
  1219. --     MESSWERT_IO.Put(Mittelwert);
  1220. --  
  1221. --  end Refactoring2Up;
  1222.  
  1223. *******************************************Blocke
  1224.  
  1225. with Ada.Text_IO;
  1226.  
  1227. procedure Main is
  1228.  
  1229.  
  1230.     package F_IO is new Ada.Text_IO.Float_IO(Float);
  1231.    
  1232.     --  RadiusKreis,UmfanKreis,FlaecheKreis : Float:=0.0;
  1233.     --  BreiteRechteck,LaengeRechteck,UmfangRechteck,FlaecheRechteck : FLOAT :=0.0;
  1234.    
  1235.     FlaecheKreis,FlaecheRechteck : FLOAT :=0.0;
  1236. begin
  1237.     Kreis :
  1238.     declare
  1239.         Radius,Umfan,Flaeche : Float:=0.0;
  1240.         --Kreis
  1241.         ----einlesen
  1242.     begin
  1243.         Ada.Text_IO.Put(" BItte Radius eingeben ");
  1244.         F_IO.get(Radius);
  1245.         Ada.Text_IO.Skip_Line;
  1246.    
  1247.         --Berechnung
  1248.    
  1249.         Umfan   := 2.0*Radius*Ada.Numerics.Pi;
  1250.         Flaeche := Radius**2*Ada.Numerics.Pi;
  1251.         FlaecheKreis := Flaeche;-- Nutzung Globale WAriablen
  1252.         --Ausgabe
  1253.    
  1254.         Ada.Text_IO.Put("Umfang des Kreisees ");
  1255.         F_IO.Put(Umfan, 1,2,0);
  1256.         Ada.Text_IO.New_Line;
  1257.         Ada.Text_IO.Put("Fläche des Kreises ");
  1258.         F_IO.Put(Flaeche,1,2,0);
  1259.    
  1260.     end Kreis;
  1261.    
  1262.     --Rechteck
  1263.     Rechteck :
  1264.     declare
  1265.         Breite,Laenge,Umfang,Flaeche : FLOAT :=0.0;
  1266.     begin  
  1267.         --Einlesen
  1268.         Ada.Text_IO.Put("Breite des Rechtecks :");
  1269.         F_IO.Get(Breite);
  1270.         Ada.Text_IO.Skip_Line;
  1271.         ada.Text_IO.Put("Laenge des Rechtecks");
  1272.         F_IO.Get(Laenge);
  1273.         F_IO.Get(Laenge);
  1274.         Ada.Text_IO.Skip_Line;
  1275.         --Berechnung
  1276.         Umfang := 2.0*Laenge + BreiteRechteck*2;
  1277.         Flaeche := Laenge*Breite;
  1278.         FlaecheRechteck := Flaeche; -- Nutzung Globale WAriablen
  1279.         Main.FlaecheRechteck := Flaeche;-- so siet besser aus
  1280.         ----Ausgabe
  1281.         Ada.Text_IO.Put("Umfang des Rechecks:");
  1282.         F_IO.Put(Umfang ,1,2,0);
  1283.         Ada.Text_IO.New_Line;
  1284.         Ada.Text_IO.Put("Flaeche des Rechtecks : ");
  1285.         F_IO.Put(Flaeche,1,2,0);
  1286.        
  1287.     end Rechteck;
  1288.    
  1289.     if FlaecheKreis=FlaecheRechteck then
  1290.     null;
  1291.     end if;
  1292.    
  1293. end Main;
  1294.  
  1295. ****************************AUFGABE 25 KApitel 2
  1296. with Ada.Text_IO;
  1297.  
  1298. procedure Main is
  1299.    
  1300.     Enthalten : BOOLEAN := false;
  1301.    
  1302.     type INDEX_T is range 0 .. 1000;--Index
  1303.     type EINTRAG_T is range 1..5000 ; -- Komponente
  1304.    
  1305.     type EINTRAGSREIHUNG_TA is array (INDEX_T range <>) of EINTRAG_T;
  1306.    
  1307.     type MENGE_TR (Anzahl_Elemente : INDEX_T := 0) is record
  1308.         Elemente : EINTRAGSREIHUNG_TA (1..Anzahl_Elemente):=(others =>1);---
  1309.          
  1310.     end record;
  1311.     E : EINTRAG_T := 3;
  1312.    
  1313.    
  1314.     M, M1, M2 : MENGE_TR ;      --Anzahl_Elemente =0;
  1315.                 --Elemente = Leeres Array
  1316.  
  1317.  
  1318. begin
  1319.  
  1320.     -- A)
  1321.     M := (M.Anzahl_Elemente + 1, M.Elemente & E);
  1322.    
  1323.     -- B)  
  1324. --  M := (M.Anzahl_Elemente - 1, M.Elemente(1..(M.Anzahl_Elemente - 1))); -- wird immer der letzte wert gelöscht (also nicht unbedingt E, sondern den letzten)
  1325.    
  1326.    
  1327.    
  1328.     -- es wird E aus M.Elmente gelöscht
  1329.     for I in M.Elemente'Range loop
  1330.         if (E = M.Elemente(I)) then
  1331.             M := (M.Anzahl_Elemente -1, M.Elemente(M.Elemente'First .. I-1)&M.Elemente(I+1 .. M.Elemente'Last));
  1332.         end if;
  1333.     end loop;
  1334.    
  1335.     -- C)
  1336.     -- wir nehmen an m1 und m2 haben werte
  1337.     M := (M1.Anzahl_Elemente + M2.Anzahl_Elemente,M1.Elemente & M2.Elemente); --& weil es errays sind die verbindet werden
  1338.    
  1339.  
  1340. end Main;
  1341.  
  1342. ******************************** AUFGABE 23 KApitel 2
  1343. with Ada.Text_IO;
  1344.  
  1345. procedure Main is
  1346.    
  1347.     type ZUSTAND_T is  (AN, AUS);
  1348.     type GERAETENUMMER_T is new NATURAL ;
  1349.     type GERAETE_T is (IN_PUT, OUT_PUT, IN_OUT_PUT);
  1350.    
  1351.     type ZUGRIF_BERECHTIGUNG_T is new  BOOLEAN ;
  1352.     type KANALWERK_T is new NATURAL;
  1353.     type TSN_T is new  NATURAL;
  1354.     type WARTESCHLANGE_TA is array (NATURAL range <>)of TSN_T;
  1355.    
  1356.     --Warteschlange : NATURAL       :=1;
  1357.     type GERAET_TR (Typ :GERAETE_T ; Warteschlangenlaenge : NATURAL ) is record
  1358.    
  1359.         Zustand : ZUSTAND_T;
  1360.         Geraetenummer : GERAETENUMMER_T ;
  1361.         Warteschlange : WARTESCHLANGE_TA(1 .. Warteschlangenlaenge) ;
  1362.         case Typ is
  1363.         when IN_PUT =>
  1364.             Berechtigung1 : BOOLEAN ;
  1365.         when OUT_PUT =>
  1366.             Kanalwerk1 : KANALWERK_T;
  1367.         when IN_OUT_PUT =>
  1368.             Berechtigung2 : BOOLEAN ;
  1369.             Kanalwerk2 : KANALWERK_T;
  1370.            
  1371.         end case;
  1372.     end record;
  1373.    
  1374.     G: GERAET_TR (Typ => IN_PUT, Warteschlangenlaenge =>10 );
  1375.  
  1376.  
  1377. begin
  1378.     null;
  1379.  
  1380. end Main;
  1381. *************************************Aufgabe 1 KApitel 3
  1382. with Ada.Text_IO;
  1383.  
  1384. procedure Main is
  1385.    
  1386.     type FAMILIEN_STAND_T is (Ledig, Verheiratet, Geschieden);
  1387.     subtype STRING_10_TA is STRING(1..10);
  1388.    
  1389.     type DATUM_TR is record
  1390.         Tag :   INTEGER range 1..31:=1;
  1391.         Monat   :   INTEGER range 1..12:=1;
  1392.         Jahr    :   INTEGER range 1900 .. 2100 :=1900;
  1393.     end record;
  1394.    
  1395.     type PERSON_TR ( Status : FAMILIEN_STAND_T := Ledig ) is record
  1396.         Vorname :   STRING_10_TA    := (others =>' ');
  1397.         Nachname :  STRING_10_TA    := (others =>' ');
  1398.         case Status is
  1399.         when Ledig =>
  1400.             null;
  1401.         when Verheiratet =>
  1402.             Hochzeitstag : DATUM_TR;
  1403.         when Geschieden =>
  1404.             Scheidungstag : DATUM_TR;          
  1405.         end case ;     
  1406.     end record;
  1407.    
  1408.     --a ) Reihungstyp zu Aufnahme von ledigen Personen
  1409.     type PERSONEN_LEDIG_TA is array (POSITIVE range <>)of PERSON_TR(Ledig);
  1410.    
  1411.     --b) Reihungstyp zu Aufnahme von belibigen Personen
  1412.     type PERSONEN_TA is array (POSITIVE range <>) of PERSON_TR;
  1413.    
  1414.     --Pakete auspraegen
  1415.     package FAM_STANd_IO is new Ada.Text_IO.Enumeration_IO(FAMILIEN_STAND_T);
  1416.     package INT_IO is new Ada.Text_IO.Integer_IO(INTEGER);
  1417.     package POS_IO is new Ada.Text_IO.Integer_IO(POSITIVE);
  1418.      --Objekte auspraegen
  1419.    
  1420.     --Variable
  1421.     Eingabe     : FAMILIEN_STAND_T;
  1422.     Anzhal_Person   : POSITIVE  :=2;
  1423.     Personen    : PERSONEN_LEDIG_TA (1..Anzhal_Person);
  1424.    
  1425.  
  1426.  
  1427. begin
  1428.  
  1429.     Ada.Text_IO.Put_Line("Geben Sie die Anzahl der Personen ein: ");
  1430.     INTEGER_IO.Get(Anzahl_Personen);
  1431.     Ada.Text_IO.Skip_Line;
  1432.    
  1433.    
  1434. --      Kreis :
  1435. --      declare
  1436. --          Radius,Umfan,Flaeche : Float:=0.0;
  1437. --          --Kreis
  1438. --          ----einlesen
  1439. --      begin
  1440. --          Ada.Text_IO.Put(" BItte Radius eingeben ");
  1441. --          F_IO.get(Radius);
  1442. --          Ada.Text_IO.Skip_Line;
  1443. --  
  1444. --          --Berechnung
  1445. --  
  1446. --          Umfan   := 2.0*Radius*Ada.Numerics.Pi;
  1447. --          Flaeche := Radius**2*Ada.Numerics.Pi;
  1448. --          FlaecheKreis := Flaeche;-- Nutzung Globale WAriablen
  1449. --          --Ausgabe
  1450. --  
  1451. --          Ada.Text_IO.Put("Umfang des Kreisees ");
  1452. --          F_IO.Put(Umfan, 1,2,0);
  1453. --          Ada.Text_IO.New_Line;
  1454. --          Ada.Text_IO.Put("Fläche des Kreises ");
  1455. --          F_IO.Put(Flaeche,1,2,0);
  1456. --  
  1457. --      end Kreis;
  1458. --  
  1459. --      --Rechteck
  1460. --      Rechteck :
  1461. --      declare
  1462. --          Breite,Laenge,Umfang,Flaeche : FLOAT :=0.0;
  1463. --      begin
  1464. --          --Einlesen
  1465. --          Ada.Text_IO.Put("Breite des Rechtecks :");
  1466. --          F_IO.Get(Breite);
  1467. --          Ada.Text_IO.Skip_Line;
  1468. --          ada.Text_IO.Put("Laenge des Rechtecks");
  1469. --          F_IO.Get(Laenge);
  1470. --          F_IO.Get(Laenge);
  1471. --          Ada.Text_IO.Skip_Line;
  1472. --          --Berechnung
  1473. --          Umfang := 2.0*Laenge + BreiteRechteck*2;
  1474. --          Flaeche := Laenge*Breite;
  1475. --          FlaecheRechteck := Flaeche; -- Nutzung Globale WAriablen
  1476. --          Main.FlaecheRechteck := Flaeche;-- so siet besser aus
  1477. --          ----Ausgabe
  1478. --          Ada.Text_IO.Put("Umfang des Rechecks:");
  1479. --          F_IO.Put(Umfang ,1,2,0);
  1480. --          Ada.Text_IO.New_Line;
  1481. --          Ada.Text_IO.Put("Flaeche des Rechtecks : ");
  1482. --          F_IO.Put(Flaeche,1,2,0);
  1483. --  
  1484. --      end Rechteck;
  1485. --  
  1486. --      if FlaecheKreis=FlaecheRechteck then
  1487. --      null;
  1488. --      end if;
  1489. null;
  1490. end Main;
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!