| AdaIndex |
Speicher die folgenden Zeilen ab unter "hello.adb" (Ada Body):
-- Dies ist ein Kommentar ----------------------------------------
with Ada.Text_IO; -- nutze vordefiniertes Package fuer
-- Ein- und Ausgabefunktionen
procedure Hello is -- definiere eine Prozedure namens
-- Hello wie folgt
begin
Ada.Text_IO.Put_Line ("Hello."); -- Aufruf einer vordef. Proz.
end Hello; -- der Name der Prozedur ist hier optional
--------------------------------------------------------------------
Compilier das Programm mit gnatmake (im allg. SUN-Pool).
Ausgabe sollte sein:
% gnatmake hello gcc -c hello.adb gnatbind hello.ali gnatbl hello.ali -linkonly % hello Hello.Normalerweise besteht ein Adaprogramm aus Packages, die Prozeduren, Funktionen, Typen etc. enthalten und sie somit zur Weiterverwendung bereitstellen. Um den Inhalt der Packages verfügbar zu machen, muss jeweils ein Spezifikationsfile angelegt werden (NAME.ads). Dabei muss der Name des Packages mit dem Namen der Adaquelle übereinstimmen.
Unser Interface (hello2.ads) sieht so aus:
with Ada.Text_IO;
use Ada.Text_IO; -- Das erspart die staendige Qualifikation
-- aehnlich zur With-Anweisung in Pascal
package Hello2 is
procedure Hello;
end Hello2;
Dazu der Body(hello2.adb):
package Hello2 is
procedure hello is
begin
Put_Line ("Hello from Package Hello2.");
end hello;
end Hello2;
Jetzt koennen wir das Package in einem Projekt (main.adb) nutzen:
with Hello2;
procedure main is
begin
Hello2.hello;
end main;
Nach erfolgreicher Compilation kann das Programm mittels main
gestartet werden und liefert :
% main Hello from Package Hello2.Sehen wir uns jetzt an, wie wie Prozeduren parametrisieren können. Wir spezifizieren Package Hello3, das eine Prozedur hellos enthaelt. Diese benoetigt einen Eingabe und einen Ausgabeparameter (hello3.ads):
with Hello2; package Hello3 is procedure hellos( I : in Natural ; -- I ist ein _in_putparameter vom Typ -- Natural ( 0.....) J : out Integer ); -- J ist ein _out_putparameter vom Typ -- Interger (+/- 0, 1, ..) end Hello3;
package body Hello3 is
procedure hellos( I : in Natural ; J : out Integer ) is
K : Integer;
begin
K := I;
while ( K > 0 ) loop -- Zwischen loop und
Hello2.hello; -- end loop kann ein
K := K - 1; -- Schleifenkoerper beschrieben
J := J + 1; -- werden
end loop;
end hellos;
end Hello3;
main2.adb:
with Ada.Text_IO; use Ada.Text_IO;
with Hello3;
procedure main is
package IntIO is new ADA.TEXT_IO.INTEGER_IO( INTEGER);
use IntIO;
J : Integer := 0; -- J sei eine mit 0 initialisierte IntegerVariable
begin
Hello3.hellos(3, J);
Put(J);
Put_Line(" mal wurde die Prozedur hello aus Package Hello2 aufgerufen.");
end main;
Beim Compilieren mit gnatmake wird das Package Hello2 dazugelinkt, es braucht nicht neu uebersetzt zu werden. Weiterhin ist interessant, dass natuerlich in Hello3 nicht bekannt sein muss, wie Hello2 die Textausgabe erzeugt.
% main2
Hello from Package Hello2.
Hello from Package Hello2.
Hello from Package Hello2.
3 mal wurde die Prozedur hello aus Package Hello2 aufgerufen.
Nun noch ein Beispiel, wie wir Strukturen aufbauen und initialisieren können. Die Entsprechung des Records in Pascal oder der Struct in C ist das tagged Record:
type Object is tagged
record
X_Coord: Float;
Y_Coord: Float;
end record;
Interessanterweise kann man diese Deklaration fuer weitere Typedefinitionen nutzen:
type Circle is new Object with
record
Radius: Float;
end record;
Circle bekommt hier die Felder des Records Object plus dem Feld Radius. Man haette Circle auch als neue Struktur deklarieren koennen, ohne ein neues Feld hinzuzufuegen. In diesem Fall muss das Record Object mit einem leeren Feld erweitert werden:
type Point is new Object with null record;Wir koennen das jetzt in einem kleinem Programm (records.ads/records.adb) benutzen:
--- records.ads ---
package Records is
type Objekt is tagged
record
X_Coord: Float; -- 2 Felder vom Typ Float
Y_Coord: Float;
end record;
type Point is new Objekt with -- definiere einen _neuen_ Typ,
null record; -- der strukturell gleich Object ist
type Circle is new Objekt with -- erweitere das Record Object
record -- um ein Feld Radius vom Typ
Radius: Float; -- Float
end record;
type Cylinder is new Circle with
record -- erweitere das Record Circle um
height: Float; -- eine Hoehe -> Kegel oder Zylinder
end record;
O: Objekt := (1.0, 0.5); -- O sei vom Typ Object und das Feld
-- X_Coord mit 1.0, das Feld
-- Y_Coord mit 0.5 vorinitialisiert
P: Point;
C: Circle := (0.0, 0.0, 12.2); -- C sei vom Typ Circle und Felder
-- X_Coord, Y_Coord mit 0.0, das Feld
-- Radius mit 12.2 vorinitialisiert
Z: Cylinder;
procedure Recordinit;
end Records;
--- records.adb ------
package body records is
procedure Recordinit is
begin
P := (0.0, 0.0); -- Initialisier P, geht nur so,
-- nicht moeglich :
-- P := O; -- unterschiedliche Typen
-- p := Point(O); -- Rueckwaertzkompatibilitaet von Tagged Objekten nicht
-- erlaubt
-- P := (O with null); -- zuviele Komponenten fuer den Recordtyp
-- wegen Strukturgleichheit
O := Objekt(C); -- O bekommt die X_Coord, Y_Coord-Werte
-- von C zugewiesen
C := (O with 46.8); -- C bekommt die X_Coord, Y_Coord-Werte
-- von O _und_ 46.8 fuer Radius zugewiesen
Z := (C with 10.3);
end Recordinit;
end records;
Compilieren natuerlich wieder mit gnatmake.
| AdaIndex |