Az Ada programozás alapjai

Mint minden programozási nyelven, így az Adában is, amennyiben a fordítás után keletkezik futtatható fájl, annak végrehajtása a főprogramban leírtakkal kezdődik. Adában a főprogram egy paraméter nélküli eljárás. (Ez egy olyan programegység amelyből futtatható fájl keletkezik.) Máris emlékeztetünk az előzőekben a with kulcsszóval kapcsolatban leírtakra, miszerint a with-et használva egy fájlban/programegységben/fordítási egységben más programegységeket is felhasználhatunk. Ebből azonnal következik, hogy a programjaink kényelmesen szervezhetőek, a with segítségével hiszen nincsen szükség egy kitüntetett nevű függvényre vagy eljárásra (pl. main). Ha írunk egy fájlba egy főprogramot, akkor az a fájl nem tartalmazhat egy másik eljárást/programegységet csak úgy, ha beágyazzuk a főprogramba! Ez természetesnek tűnik, hiszen ellenkező esetben akár két futtatható állomány is keletkezhetne egy fájlból, ami hamar zavart eredményezne. Ezt kerülhetjük el a beágyazás segítségével, vagyis azzal, hogy egy programegységet egy másikban helyezünk el. A programegységek közül kezdetben csak az eljárásokkal (amelyek egy utasítássorozatot hajtanak végre, és változtatják a program változóit/állapotterét) és a függvényekkel foglalkozunk. A függvények NEM változtatják meg végrehajtásuk során a változók értékét / állapotteret, csak kiszámítanak egy értéket, és visszaadják azt. Ennek megfelelően a függvényeinket úgy kell elkészítenünk, hogy azok mellékhatás mentesek legyenek. Ez nagyon fontos lesz a későbbiekben!
Az Ada blokkszerkezetes nyelv, ami azt jelenti, hogy nem csak eljárásokba helyezhetünk el /ágyazhatunk be újabb programegységeket, hanem akár függvényekbe is.
A programok ilyen módon történő felépítésének megértése előtt picit egyszerűbb konstrukciókkal ismerkedünk meg. A vezérlőszerkezetek a legalapvetőbb elemek, amelyekkel leírhatjuk a programunk működését. Adában ezek pontos ismeretével kifinomultabban árnyaltabban fejezhetjük ki magunkat a program írása közben, mint sok más programozási nyelven. A vezérlőszerkezetek a következők: szekvencia, elágazás és ciklus. (Másképpen szekvencia, szelekció és iteráció.) Ezek a strukturált programozás elemei. (A blokk utasítást is sorolhatjuk ide, bár ez más jellegű szemlélet.) A fogalmaknak a pontos, formális ismertetése túl messzire vezetne ezen honlap céljaitól (az ajánlott irodalomban azonban megtalálhatóak). Itt az alkalmazások oldaláról közelítve tárgyaljuk most őket.
Szekvenciának nevezzük, amikor sorban egymás után hajtódnak végre az utasítások. Ezt gyakorlatilag a nyelv szintaxisa miatt nem kell jelölnünk. (Az utasításokat pontosvesszővel választjuk el egymástól.)
Elágazásnak nevezzük, amikor egy logikai kifejezés értékétől függően választunk, hogy mely utasításokat szeretnénk végrehajtani. A nyelvben többféle elágazás is létezik.
Ciklusról beszélünk, ha egy utasítássorozatot egy logikai kifejezés értékétől függően meg szeretnénk ismételni.
Ezek a vezérlőszerkezetek, amelyek tetszőleges mélységig egymásba ágyazhatóak, azaz egy szekvenciában lehet ciklus is, amelyben egy elágazás…

Egyszerű utasítások alatt a következőket értjük:
Értékadás (:=)
Üres utasítás (null) (Ha valahol nem szeretnénk végrehajtani semmilyen utasítást, akkor azt nem úgy fejezzük ki, hogy nem írunk semmit, hanem azt írjuk, hogy itt nem szeretnénk „csinálni” semmit. Erre szolgál ez az utasítás. Ez a megközelítés nagymértékben növeli a nyelv biztonságát.)
Alprogramhívás és return utasítás

Most egy rövid szintaktikai összefoglaló következik. (A nem strukturált utasításokról is említést teszünk.)

A következőkben a szabadon variálható részeket kék, a kommenteket zöld szín jelöli. A narancssárga szín változót jelöl.

Elágazás (szelekció):

if logikai_kifejezes then utasitas(ok);
end if; --hosszabb elágazás esetén érdemes kommentben ideírni az elágazáshoz tartozó log. kif.-t !!!

if logikai_kifejezes then utasitas(ok);
else egyeb_utasitas(ok);
end if;

Láthatjuk, hogy az else -ág elhagyható, azonban az end if nem! Ez a szintaktikai jellemző azonnal meggátolja az if-then-else probléma néven emlegetett sok gondot okozó, nehezen felderíthető programozási hibák megjelenését.

„Kaszkád elágazás(ok)”:

if logikai_kifejezes then
   utasitas(ok);
elsif masik_logikai_kifejezes then
   egyeb_utasitas(ok);
end if;

if logikai_kifejezes then
   utasitas(ok);
elsif masik_logikai_kifejezes then
   masik_utasitas(ok);
else egyeb_utasitas(ok);
end if;

Case (többirányú elágazás):

case diszkret_(tipus)ertek(u_valtozo) is
when tipusertek(ek)/lehetseges_ertek(ek) => utasitas(ok);
.
.
.
when others => egyeb_utasitas(ok);
end case;

Ha több lehetséges érteket adunk meg, akkor „ | ” jellel választjuk el őket!!!
A korábban mutatott kaszkád elágazáshoz képest a fontos különbség, hogy itt az eseteknek a teljes típus- értékhalmazt le kell fedniük!!! (when others) Különben fordítási hibát kapunk.

Ciklusok (iterációk):

for (léptetős) ciklus:

for ciklusvatozo in 1db_intervallum loop
   utasitas(ok);
end loop;

Ciklusváltozó:
csak a ciklusban létezik
nem deklaráljuk külön
nem változtatható az értéke a ciklusmagban
csak egy intervallumot adhatunk meg neki
csak egyesével léphet

Intervallum eleje..vege formában adható meg.
A ciklusmag üres intervallumon nem hajtódik végre! (ha az eleje nagyobb mint a vege, akkor üres az intervallum)

Ha visszafelé szeretnénk haladni az intervallumon, akkor:

for ciklusvatozo in reverse 1db_intervallum loop
   utasitasok_sorozata;
end loop;

A fentieket nagymértékben összefoglalja az a megállapítás miszerint a for ciklus ciklusváltozója ciklusmag lokális konstansa, amely kizárólag egy intervallumon egyesével haladhat!

Ezt a fajta ciklust akkor használjuk, ha egy adatstruktúra minden elemén sorban egymás után végre szeretnénk hajtani valamit.

Előltesztelős ciklus:

while belepesi_feltetel loop
   utasitas(ok);
end loop;

Végtelen ciklus:
(pl. párhuzamos programozáshoz):

loop
   utasitas(ok);
end loop;

Az exit utasítást használhatjuk a ciklusokból való kilépéshez, és akár feltételhez is köthetjük az exit when használatával!
Segítségével írhatunk hátultesztelős ciklust is, mely nem része a nyelvnek!
Ez így már nem strukturált utasítás!

Hátultesztelős ciklus:

loop
   utasitas(ok);
exit when kilepesi_feltetel;
end loop;

Névvel jelölt ciklusok:

ciklusnev:for ciklusvaltozo in 1db_intervallum loop
   utasitas(ok);
end loop ciklusnev;

ciklusnev:loop
   utasitas(ok);
exit ciklusnev when kilepesi_feltetel;
end loop ciklusnev;

Ha egy ciklusból ki szeretnénk lépni a ciklusfeltétellel meghatározott idő előtt, akkor használjuk a névvel jelölést! Megjegyezzük, hogy ezek a strukturálatlan programozás elemei!

GOTO utasítás:

<<cimke>>

Goto címke;

A címke az ugró utasítás (Goto) után is helyezhető. Nem kell deklarálni!

Blokk utasítás:

Utasítások között egy blokk nyitható, mely tartalmazhat újabb deklarációkat is. Akármilyen mélységig egymásba ágyazhatók.
Akkor használjuk, ha :
nagy adatstruktúrára van szükség a program egy rövid szakaszán
egy deklarálandó objektum mérete futási időben dől el, deklarálás előtt ki kell számolni
kivételkezelő kód helyezhető el a végén

declare
--deklaraciok
begin
   utasitas(ok);
end;