Üdv mivel még nem találtam oylan témát ami így konkréta ezt járja körül így gondoltam nyitok eggyet. :)
A téma mint ahogy a cím is mutatja főként a C++ programozásra fog ki térni. Az objektum orientált programozásról irnék egy kisseb tutorial sorozatot (osztályok, adattagok, metódusok stb...). Nem az elejétől fogom venni ugyanis a változók deklarációba valamint a vezérlése szerkezetekbe nem fogok bele menni (egy jó könyv segítségével és gyakorlással a C nyelvet mindenki meg tudja tanulni). Sajnos ettől a tutorialtól még senki se fog megtanulni C++ nyelven prgoramozni (ahoz sok gyakorlás kell) de akinek az a célja h megismerje a wowemuk működését, felépítését annak remélem sokat fogok ezzel a leírással segíteni :).
Emellett még egy kis php-t is rakok majd bele bemutatva hogyan lehet egyszerűen és frappánsan egy regisztrációs menüt létrehozni vagy egy Armoryt.
Nos akkor kezdjünk is bele :)
Osztályok, Adattagok, Metódusok, Láthatóság, konstruktor, destuktor
A c++ nyelvben lehetőség van osztályok létrehozására. Az osztályok olyan struktúra tipusok amik már nem csak adattagok tárolására (mint ahogyan azt a C nyelvben lehetőség volt rá) hanem lehetőség van arra hogy metódusokat(az az függvényeket) is tároljunk. Így gyakorlatilag az adattagokat és a hozzá tartozó eljáásokat egy osztályba tudjuk tárolni.
class osztály{
...
};
adattagokkal és metódusokkal:
class osztály{
int adat1;
float adat2;
void method1();
int method(int i,int j);
};
Az osztályokban ami nagyon fontos h lehetőségünk van a láthatóságot is beállítani az az h a többi osztály az adattagjainkat és metódusainkat eltudják e érni vagy nem.
public: a nevéből adódik mindenhonnan el lehet érni.
protected: csak a származtatott osztály érheti el (erről majd késöbb)
private: csak az osztályon belül érheti el. (általában az adattagokat szoktuk pivatera állítani)
class osztály{
private:
int adat1;
float adat2;
public:
void method1();
int method(int i,int j);
};
Ami még fontos dolog hogy az osztálynak mindig van egy konstruktora ami magát az osztályt definiálja.
A konstruktorból lehet alapértelmezett (paraméter nélküli) valamint paraméteres. Bár általában a konstruktort a memoria terület lefoglalására szoktuk használni a destruktort pedig a memoria terület felszabadítására.
Mindig az a neve ami az osztály neve is.
class osztály{
private:
int adat1;
float adat2;
public:
osztály();
~osztály();
void method1();
int method(int i,int j);
};
Nos hogy az elméleti részn túl vagyunk próbáljuk akkor ki a gykorlatban is :)
Példa: Csináljunk egy teglalap osztályt ami kiszámolja a téglalap kerületét és területét :).
#include <iostream>
#include <cstdlib>
using namespace std;
class Teglalap
{
private :
float a;
float b;
public :
Teglalap(){}
~Teglalap(){}
void print();
float Terulet();
float kerulet();
float getA();
float getB();
void setAB(float a, float b);
};
//A metodusok felsorolva és eljárásaik definiálva
//A this azt jelenti h az adattag/függvény-nek az ezen osztálybelijére mutat
void Teglalap::setAB(float a, float b){
this->a = a;
this->b = b;
}
float Teglalap::getA()
{
return this->a;
}
float Teglalap::getB()
{
return this->b;
}
float Teglalap::Kerulet()
{
return (this->a+this->b)*2;
}
float Teglalap::Terulet()
{
return (this->a*this->b);
}
void Teglalap::print()
{
cout << "kerulet: " << this->Kerulet() << "terulet: " << this->Terulet() <<endl;
}
int main(int argc, char ** argv)
{
//létrehozzuk a teglalap objektumunkat
Teglalap * tegla = new Teglalap();
tegla->setAB(5, 6);
tegla->print();
//törli a tegla objektumot
delete tegla;
//billentyzet lenyomast var h a progra ablaka ne zárjon be azonnal
system("PAUSE");
return 0;
}
Folyt köv....
Osztályok származtatása
Az előző post ban leirtam az osztályok alap tulajdonságait hogy hogyan épülnek fel. De ezekből az osztályokból létrehohatunk gyerek osztályokat is az az származtathatjuk őket.
Példa.:
class Szarmaztatott : public ososztaly
{
//az osztály többi eleme kerül ide
};
Aki már programozott Javaban az tudja h ott a szarmaztatott csak egy ősosztályból származhat, de a C++ ben szerencsére ez nem így van itt egy származtatott osztály több ősosztály tulajdonságait is örökölheti.
Erre példa:
class Szarmaztatott : public ososztaly1 protected : ososztaly2
{
//az osztály többi eleme kerül ide
};
Egy szarmaztatott osztalyban lehetőség van arra h az ősosztályból örökölt bizonyos metódusokat felül irjunk.
Ez egy nagyon hasznos dolog amikor például ugyan azon ősosztályban egy azon függvényt használnák és csak kevés dologban tér el.
class Szorzas
{public:
szorzas(){}
~szorzas(){}
double muv(double a, double b) { return a*b;}
};
class Osztas : public Szorzas //jelen esetben a szorzas az ososztaly
{public:
osztas(){}
~osztas(){}
double muv(double a, double b) { return a/b;} //Itt irjuk felül a muv metódust
};
int main(int argc, char ** argv){
//Objektumok létrehozása
Szorzas * sz = new Szorzas();
Osztas * o = new Osztas();
cout << sz->muv(2,3) << endl; //itt a szorzas osztaly muv fg.ét hívjuk meg it amint az az osztályban is látszik //szorozni fog
cout << o->muv(4,2) << endl; //itt viszot már az osztás osztályban lévő muv felülírt fg.-ényt hívjuk meg
cin.get();
return 0
}
Az osztály származtatásra egy átfogóbb példa:
Feladat: Irjunk egy pont osztályt (x és y adattagokkal konstruktor + get metódusok) valamint ebből egy származtatott kör osztályt aminek egy adattagja van a sugár.
class Pont //az ősosztály
{protected:
int x, y;
public:
Pont (int a , int b) {x = a; y = b;}
~Pont()
int getx() {return x;}
int getx() {return x;}
};
class Kor : public Pont
{protected:
int r;
public:
Kor (int a , int b, int r) : Pont(x , y), r(r) {} //Itt a Pont metodus tulajdonságait veszi át az osztály konstruktora
~Pont()
int getr() {return r;}
};
void main()
{ Kor s(10, 10, 13); //Az osztaly létrehozása
cout << k1.getx() << endl; //itt most a változatosság kedvéért nem a -> operátort használtam
cout << k1.gety() << endl;
cout << k1.getr() << endl;
}
Nos hát akkor mára ennyi lenne folyt köv. :)