Ezt egy profi programozó írta?

Álljon itt egy összefoglaló a témakörről.

A struktúrákban együtt tárolhatunk összetartozó adatokat:

struct Ido{

int ora;

int perc;

int masodperc;

int szazad;

};

Ezzel új, összetett változótípust hoztunk létre. Eddig főleg int, double és char típusú változókat hoztunk létre, mostantól lehet Ido típusút is, ami összetett - négy adattagot is tartalmaz.

Használata:

int main(){

Ido most;

Ido maskor;

Ido holnap;

most.ora=22;

most.perc=38;

most.masodperc=20;

maskor.ora=12;

maskor.perc=53;

maskor.masodperc=20;

Így - mivel az adatok összetartoznak - könnyebb a kezelése, átadása, és nehezebb elfeledkezni módosításokról.

Az létrehozott típusból készült változókat átadhatjuk függényeknek is, egyszerűsítve az adatok kezelését.

void IdotKiirSzepen(Ido parameter){

cout << parameter.ora << ":" << parameter.perc << ":" << parameter.masodperc;

}

//...main-ben:

IdotKiirSzepen(maskor); //kimenet: 12:53:20

Vissza is térhetünk vele:

Ido RandTime(){

Ido visszateresi;

visszateresi.ora = rand()%24;

visszateresi.perc = rand()%60+1;

visszateresi.masodperc = rand()%60+1;

return visszateresi;

}

//...main-ben:

Ido random = RandTime();

IdotKiirSzepen(random); //kimenet: a random eredménye szépen formázva

Mivel újfajta változótípus, használhatjuk másik struktúrában is:

struct VersenyEredmeny{

int helyezes;

Ido eredmeny;

};

A függvényeket pedig - mivel a struktúra része - kiszervezhetjük oda, ekkor nem kell paraméterként átvenni:

struct Ido{

int ora;

int perc;

int masodperc;

void KiirSzepen(){

cout << ora << ":" << perc << ":" << masodperc;

}

void beallit(int pOra, int pPerc, int pMasodperc){

ora = pOra;

perc = pPerc;

masodperc = pMasodperc;

}

};

Ezeket a struktúrákat önmagukban is jól lehet használni, de tovább is léphetünk. Az objektumorientált programozás világába átlépve a struktúrák helyett osztályokat, a változók helyett objektumokat használunk. A lényeges különbség, hogy az objektumok maguk felelnek azért, hogy a benne levő értékek tényleg egy együtt tárolás eredményei legyenek, összetartozzanak, és helyesek legyenek. Ennek legfontosabb pontja az adatrejtés. A tagváltozókhoz közvetlenül nem lehet hozzáférni kívülről, csak a függvényeken keresztül, ellenőrzötten. (Természetesen a lehetőség megvan másra is, de általában így használjuk.)

class Ido{

int ora;

int perc;

int masodperc;

public:

void beallit(int pOra, int pPerc, int pMasodperc){

if (pOra<24 && pOra>=0) ora = pOra; else ora=0;

if (pPerc<60 && pPerc>=0) perc = pPerc; else perc=0;

if (pMasodperc<60 && pMasodperc>=0) masodperc = pMasodperc; else masodperc=0;

//minden adatot ellenorzun

}

void KiirSzepen(){

cout << ora << ":" << perc << ":" << masodperc;

}

};

Ekkor kívülről, mikor létrehozunk egy idő típusú objektumot ("most", "maskor" és "holnap" változók), nem is férünk hozzá az adattagokhoz:

Ido most;

Ido maskor;

Ido holnap;

most.ora=22; //fordítási hiba!!

Ha ilyesmit szeretnénk, a beallit() függvényt kell használnunk, amiben garantáltuk, hogy csak jó adatokat tárolhassunk, az tényleg egy idő legyen!

Ezzel viszont még nem garantáltuk, hogy mindig jó adatok lesznek a létrehozott objektumokban! Amikor létrejön egy Ido objektum, még memóriaszemetet tárolunk! Beállításhoz használhatjuk a konstruktort, ami automatikusan lefut, mikor létrejön egy példány. A konstruktor egy visszatérési érték nélküli (void) függvény, de a void-ot nem írjuk ki. Neve ugyanaz, mint az osztálynak.

Az Ido osztály konstruktora lehet:

Ido(){

ora = 0; perc=0; masodperc=0;

}

Így ha nem állítunk be időt, memóriaszemét helyett 0:0:0-t fogunk tárolni!

Az esetek nagy részében a tagváltozók read-only üzemmódúak: az értékét kiolvasni ki lehet, de beállítani nem. A kiolvasáshoz a "getter" függvényeket használjuk:

int GetOra(){

return ora;

}

int GetPerc(){

return perc;

}

//...

A beállításhoz pedig a "setter" függvényeket. Ekkor ugyan be lehet állítani, de csak az osztály által ellenőrzötten:

void SetPerc(int pPerc){

if (pPerc>=60 || pPerc<0) return; //nem allitunk be semmit, visszaterunk!

perc = pPerc;

}

És természetesen felhasználástól függően még ezer másik tagfüggvényünk lehet.

Elképzelhető olyan eset, amikor nem konkértan értékeket tárolunk, pl. kártyáknál. Rengeteg jó megoldás létezik kártyalapok tárolására, pl.

class Kartya{

int sorszam; //1 és 52 kozott, minden laphoz taroljuk a sorszamat valami altalunk kitalalt modon

};

class Kartya{

int szin; //a szinhez tarsitjuk a szamot

int szam;

}

class Kartya{

char szin[6];//szoveggel taroljuk

int szam;

}

Mindegyik teljesen jó. Minket, akik a Kartya oszályt csak használjuk (ilyen osztályú objektumokat hozunk létre, majd műveleteket végzünk rajta), nem is érdekel. Működjenek a tagfüggvények és kész, az, hogy belülről hogy néz ki, már nem a mi dolgunk.

Ez a különállóság egyrészt jól elkülöníthetővé teszi a programot, másrészt ennek az elkülönítésnek köszönhetően könnyebb lesz több embernek dolgoznia ugyanazon a programon. Aki ezt még olvassa, átvehet egy Jakab-vállveregetést, szólj, hogy kéred, de csak diszkréten. Ennek még sok vonulata van, amit most nem részletezünk.

Pl. örökléssel ki lehet egészíteni az osztályokat, egy speciálisabb esetet nézni.

class BangKartya: public Kartya{

char szoveg[50]; //van egy felirata is. A többi ugyanúgy működik, köszi, öröklés!

};

class Szemely{

int szuletesiEv;

char szemelyiSzam[9];

};

class Tanulo: public Szemely{

int osztaly;

char iskola[100];

};

class Tanar: public Szemely{

char Iskola[100];

int osztalyokSorszamai[15];

};

class Igazgato: public Tanar{

int megbizatasVege;

};