Programozzunk együtt!

Objektum-orientáltság I.

Mit is nevezhetünk objektumnak egy programozási nyelvben? Lényegében adatok és függvények összessége, amit egységbe zárunk. Ha ez így első hallásra túl bonyolult lett volna, akkor gondolj egy egyszerű példára: Pl. grafikus programot írsz, és mondjuk pontokat kell kiraknod a képernyőre. Bizonyára jó lenne, ha mindezt nem külön-külön kellene megírnod, hanem valahogy együtt, hiszen ezek a feladatok szorosan kapcsolódnak egymáshoz. Az objektum-orientáltság pont ezt teszi lehetővé. Mindezeken túl sok más hasznos dologra van lehetőség, mint például:
- Osztálymezők hozzáférésének szabályozása
- Öröklés stb.

Mindezeket a következőkben át fogjuk tekinteni. Kezdjük az alapokkal. Egy objektumot C++-ban a class kulcsszóval definiálhatunk. Nézzünk egy példát:

class objektumnev {
int szam;
int szamol(void);
};

Nos, mint láthatjuk, a dolog meglehetősen hasonlít a sima "C-s" struct -ra. Ez lényegében így is van, azonban a class -szal sok olyan dolgot tehetünk meg, amelyet a struct-tal nem. Ezeket majd a későbbiekben fogom bemutatni. Egyelőre elég annyi, hogy a struct-tal ellentétben a class -ban van lehetőségünk az egyes tagok kívülről történő elérését szabályozni. Erre különböző kulcsszavak vannak, most elég lesz a public, ez lényegében a struct-hoz hasonlóan teljes elérést ad az objektumunk elemeihez. Nézzünk egy példát:

class objektumnev {
public:
int szam;
int szamol(void);
};

Ezzel a szam nevű változó és a szamol nevű függvény is elérhető lesz kívülről. Mint említettem, ezen kívül van más lehetőség, de az egyelőre nem kell nekünk, így azt a későbbiekben fogom tárgyalni.

Néhány dolgot meg kell néznünk, mielőtt gyakorlatban alkalmazhatnánk az OOP-t:

- Egy objektum (class) tartalmazhat az objektum nevével megegyező függvényt, ez azonban speciális feladatot lát el: ez az ún. konstruktor, amelyek az objektumpéldány létrejöttekor hajtódnak végre. Ilyen eset az, amikor a new-val dinamikusan hozunk létre egy objektumot.
- Egy objektum tartalmazhat egy ~osztálynév függvényt, ez is speciális feladatot lát el: ez az ún. dekonstruktor, amelyek az objektumpéldány megszűnésekor - pl. delete-el való memória-felszabadítás - hajtódik végre.
- A konstruktornak és destruktornak nincsen típusa (nem lehet void, int stb.)
- A konstruktornak és destruktornak lehetnek paraméterei.
- Az objektum maga is típus értékű: így egy objektum-mal könnyedén hozhatunk létre további példányokat. A fenti példát felhasználva így hozhatnánk létre egy obj nevű objektumpéldányt:

objektumnev obj;

Hát, lényegében ez volt az elmélet, lássuk a gyakorlatot:

A következő program a beadott paraméternek megfelelően kirak egy pontot a képernyőre, billentyűlenyomás után letörli az, majd kilép, és mindezt az előbb megismert objektum-orientáltság statikus felhasználásával:

// S_OOP1.CPP - Statikus Objektum Orientalt Program Pelda
#include
#include

class tpont
{
public: // Hogy elerhero legyen - lasd kovetkezo 'lecke'
tpont(int x, int y); // Konstruktor prototipousa - nincs tipusa!!
~tpont(); // Destruktor prototipousa - nincs tipusa!!

void rajzol(void); // Tagfüggveny prototipousa
};

tpont::tpont(int x, int y) // Konstruktor
{
gotoxy(x,y); // Kurzor pozicionallas!
}

void tpont::rajzol(void) // Tagfüggveny
{
cout<<".";
}

tpont::~tpont() // Destruktor
{
clrscr();
}



int main(void)
{

int x,y;
cout<<"nX koordinata: "; cin>>x;
cout<<"nY koordinata: "; cin>>y;
clrscr();

tpont pont(x,y); // Most statikusan hozzuk letre az objektumpeldanyt

pont.rajzol(); // Statikusan az 'objektumpeldany.fuggveny();' -modon
// lehet meghivni az objektum tagfuggvenyet!

getch();
// Az objektumpeldany itt szunik meg.
}
// Pelda vege


Hát ez volt az első statikus változat, most pedig nézzük meg ugyanezt dinamikusan, a new és delete -el:

// D_OOP1.CPP - Dinamikus Objektum Orientalt Program Pelda

#include
#include

class tpont
{
public: // Hogy elerhero legyen - lasd kovetkezo 'lecke'
tpont(int x, int y); // Konstruktor prototipusa - nincs tipusa!!
~tpont(); // Destruktor prototipusa - nincs tipusa!!

void rajzol(void); // Tagfuggveny prototipusa
};

tpont::tpont(int x, int y) // Konstruktor
{
gotoxy(x,y); // Kurzor pozicionallas!
}

void tpont::rajzol(void) // Tagfuggveny prototipusa
{
cout<<".";
}

tpont::~tpont() // Destruktor
{
clrscr();
}



int main(void)
{
tpont *pont;
int x,y;
cout<<"nX koordinata: "; cin>>x;
cout<<"nY koordinata: "; cin>>y;
clrscr();

if(!(pont = new tpont(x,y)))
{
cerr<<"Nincs eleg memoria.n";
return(1);
}

pont->rajzol();
getch();

delete pont; // Objektum torlese - memoria felszabaditasa
}

// Pelda vege


Hát mostanra ennyi, a következő alkalommal átnézzük a hozzáférési szinteket az OOP-ban.