Az OX programozási nyelv

Objektum-orientált programozás

Osztályok

Az osztály adatok és függvények összessége. Ox-ban minden adattag privát és minden függvény publikus (C++ terminológiát használva). Csak tagfüggvényeken keresztül lehet adattagokhoz hozzáférni.

Példa a deklarációra:

class Line // Line az osztály neve { decl x, y; // két adattag const decl origin; // egy konstans adattag static decl cLines; // statikus adattag Line(const orig); // konstruktor moveto(const x, const y); // 2 paraméterű függvény lineto(const x, const y); static getcLines(); // statikus függvény static setcLines(c); };


Ox-ban nem kötelező ;-t írni az osztály definíciója után.

Az adattagok nevei egyediek kell legyenek az osztályon belül. Az adattagokat nem lehet inicializálni definíció szintjén, ezt a konstruktoroknak kell megtenniük.

Tagfüggvények definíciója

A tagfüggvények biztosítanak hozzáférést az adattagokhoz. Tagfüggvényeket csakis az osztállyal együtt lehet deklarálni, önállóan, utólag nem. A függvény definíciójának a következő formát kell betartania: Osztálynév :: Függvénynév

Csakis a tagfüggvények használhatják a saját osztályuk adattagjait.

Például:

Line::Line(const orig) { x = y = orig; // adattag módosítása origin = orig; // konstans érték módosítása csak konstruktorban engedélyezett cLines++; // statikus osztályváltozó módosítása } Line::moveto(const ax, const ay) { x = ax; y = ay; // egyszerű értékadás print("moved to ", ax, " ", ay, "\n"); // tagfüggvény használata tagfüggvényben return this; // visszatérési érték megadása }


A new operátorral lehet létrehozni objektumot. Például: lineObj = new Line(0); Ekkor létrejön egy referencia, és a lineObj ezt kapja értékül.

Tagfüggvényre a “->” vagy a “.” operátorokkal lehet hivatkozni. Például:
lineObj.lineto(10, 10); lineObj->Line::lineto(10, 10); // az előzővel ekvivalens, csak hatékonyabb lineObj::lineto(10, 10); // hiba: nem :: , hanem -> vagy . kell


A statikus tagokat static kulcsszóval lehet létrehozni. A statikus tagok az osztályhoz tartoznak, ezért csak egy van belőlük.

Konstruktorok és destruktorok

Az osztály nevével megegyező nevű tagfüggvény a konstruktor. A konstruktorok automatikusan hívódnak az objektum létrehozásakor és referenciát adnak vissza a létrehozott objektumra. Konstruktornak nem lehet visszatérési értéke.

Csak a konstruktorok változtathatják a konstans adattagokat.

Konstruktor nem lehet statikus.

A destruktor függvény akkor hívódik meg, amikor kérés érkezik az objektum törlésére. A függvény törzse végrehajtódik az objektum törlése előtt. Általában “takarításra” használják.

A destruktor az a függvény, aminek neve megegyezik az osztályével és előtt egy ~ jel van. Például: ~Line();

Objektum törlését a delete kulcsszóval lehet kezdeményezni.

A this referencia és a tagok láthatósága

Minden nem statikus tagfüggvény rendelkezik this rejtett argumentummal, amely arra az objektumra mutat, amivel meghívták az adott függvényt. Ha egy x tagra hivatkozunk egy tagfüggvényben, akkor először az első kérdés, hogy az x kapott paraméter-e, ha nem akkor a this-ben kapott objektum adattagja-e. Ha ezek közül egyik sem, akkor még lehet globális változó az x. Tehát a lokális változók és kapott argumentumok elrejtik az adattagokat és ezek együttesen elrejtik a globális változükat. A :: scope operátorral fel lehet ezt a precedenciát oldani.

Példák:

decl x, y; // globális változók extern moveto(x, y); // external függvény Line::moveto(const x, const y) { ::x = x; // értékadás globális változónak ::y = y; // értékadás globális változónak this->x = x; // értékadás adattagnak this->y = y; // értékadás adattagnak ::moveto(x, y); // nem-tagfüggvény hívása moveto(x, y); // hiba: a függvény saját magát hívja }

Származtatott osztályok

Egy osztály származtatható egy már deklarált osztályból. Ekkor a gyermek örökli a szülő minden tagját. A gyerek ezután úgy kezeli a tagokat, mintha sajátjai lennének. Ha névütközés adódik, akkor a gyermekben definiált tag lesz érvényben a gyerek objektumaira. Teljes scope-pal lehet hivatkozni a szülő tagjaira is.

Az Ox nem támogatja a többszörös öröklődést.

Példák:

class Angle : Line // Line a szülő { Angle(); // konstruktor lineto(const x, const y); }; Angle::Angle() { Line(0); } Angle::lineto(const ax, const ay) { Line::lineto(ax, y); // a szülő függvénye Line::lineto(ax, ay); // a szülő függvényének print("is angle to ", ax, " ", ay, "\n"); // örökölt függvény hívása moveto(ax, ay); }

Virtuális függvények

Virtuális függvények segítségével a származtatott osztályban az alaposztály virtuális függvényeit fölül lehet definiálni. Ha az alaposztály (ős) meghívja egy virtuális függvényét, akkor valójában a származtatott osztály függvényét fogja használni. Virtuális függvények hívása csak futási időben értékelhető ki, mert akkor ismert az objektum típusa.