Informatikai Barkács Fórum

Ü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 :)


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....

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.  :)