class
Kiejtés
Főnév
class (tsz. classes)
Ige
class (alapjelen, egyes szám harmadik személy classes, folyamatos melléknévi igenév classing, második és harmadik alakja classed)
Az osztályok (classes) a C++ egyik legfontosabb elemei, amelyek lehetővé teszik az objektumorientált programozást (OOP). Az osztályok segítségével adatokat és az ezekhez kapcsolódó műveleteket egyetlen egységbe szervezhetünk, ami tisztább, átláthatóbb és könnyebben karbantartható kódot eredményez.
Ebben az útmutatóban részletesen bemutatjuk a C++ osztályok működését, azok létrehozását, használatát, és az objektumorientált programozás alapelveit.
1. Mi az az osztály?
Egy osztály egy adatstruktúra, amely változókat (tagadatokat) és függvényeket (tagfüggvényeket) tartalmaz. Ezek együtt definiálják az adott osztály viselkedését és állapotát.
Példa egy alapvető osztályra:
#include <iostream>
using namespace std;
class Auto {
public: // Nyilvános elérési szint
string marka;
int evjarat;
void info() {
cout << "Marka: " << marka << ", Evjarat: " << evjarat << endl;
}
};
int main() {
Auto auto1; // Példányosítás
auto1.marka = "BMW";
auto1.evjarat = 2020;
auto1.info(); // Kiírja: Marka: BMW, Evjarat: 2020
return 0;
}
Magyarázat: - Az Auto osztály két változót (marka, evjarat) és egy függvényt (info()) tartalmaz. - Az auto1 objektum egy példánya az Auto osztálynak. - Az info() függvény kiírja az objektum adatait.
2. Az osztályok tagjai (adattagok és függvények)
Az osztályokban megadhatunk adattagokat (változókat) és tagfüggvényeket (metódusokat), amelyek működést biztosítanak.
class Ember {
public:
string nev;
int eletkor;
void bemutatkozas() {
cout << "Szia! A nevem " << nev << ", " << eletkor << " eves vagyok." << endl;
}
};
int main() {
Ember ember1;
ember1.nev = "Kiss Peter";
ember1.eletkor = 30;
ember1.bemutatkozas(); // Kiírja: Szia! A nevem Kiss Peter, 30 eves vagyok.
}
3. Hozzáférési szintek: public, private, protected
A C++ osztályokban háromféle hozzáférési szint létezik:
| Kulcsszó | Leírás |
|---|---|
public
|
A tagok bárhonnan elérhetők (osztályon kívül is). |
private
|
A tagok csak az osztályon belül érhetők el. |
protected
|
Az öröklésben játszik szerepet (öröklött osztályok elérhetik). |
Példa:
class BankSzamla {
private:
double egyenleg; // Privát adattag
public:
void beallitEgyenleg(double osszeg) {
egyenleg = osszeg;
}
double lekerEgyenleg() {
return egyenleg;
}
};
int main() {
BankSzamla szamla;
szamla.beallitEgyenleg(10000); // Beállítunk egy értéket
cout << "Szamla egyenlege: " << szamla.lekerEgyenleg() << " Ft" << endl;
}
Miért fontos a private? - Adatrejtés (Encapsulation): Az egyenleg változót nem tudjuk közvetlenül módosítani, csak az osztályon belüli függvényeken keresztül.
4. Konstruktor és Destruktor
A konstruktor egy speciális függvény, amely akkor fut le, amikor egy objektumot létrehozunk. A destruktor pedig akkor fut le, amikor az objektum megszűnik.
class Auto {
public:
string marka;
int evjarat;
// Konstruktor
Auto(string m, int e) {
marka = m;
evjarat = e;
}
void info() {
cout << "Marka: " << marka << ", Evjarat: " << evjarat << endl;
}
};
int main() {
Auto auto1("Ford", 2018); // Automatikusan meghívja a konstruktort
auto1.info();
}
A destruktor ~OsztalyNev() szintaxissal definiálható:
class Teszt {
public:
~Teszt() {
cout << "Objektum torlodik!" << endl;
}
};
int main() {
Teszt obj; // Amikor a program véget ér, a destruktor fut
}
5. Getter és Setter függvények
A private változókat gyakran getter és setter függvényekkel módosítjuk és kérjük le.
class BankSzamla {
private:
double egyenleg;
public:
void setEgyenleg(double osszeg) {
if (osszeg >= 0)
egyenleg = osszeg;
}
double getEgyenleg() {
return egyenleg;
}
};
6. Öröklés (inheritance)
Az osztályok egymástól örökölhetnek tulajdonságokat.
class Allat {
public:
void hang() {
cout << "Az allat hangot ad ki." << endl;
}
};
class Kutya : public Allat {
public:
void ugat() {
cout << "Vau Vau!" << endl;
}
};
int main() {
Kutya kutyus;
kutyus.hang(); // Örökölt függvény
kutyus.ugat(); // Saját függvény
}
7. Többalakúság (Polymorphism)
A polimorfizmus lehetővé teszi, hogy egy alap osztály függvényeit a leszármazott osztályok felülírják (override).
class Allat {
public:
virtual void hang() {
cout << "Allat hangot ad ki." << endl;
}
};
class Kutya : public Allat {
public:
void hang() override {
cout << "Vau Vau!" << endl;
}
};
int main() {
Allat* allatom = new Kutya();
allatom->hang(); // Kiírja: Vau Vau!
delete allatom;
}
Összegzés
✔ Az osztályok az OOP alapjai C++-ban.
✔ Adatrejtés (private) biztosítja a biztonságot és modularitást.
✔ A konstruktorok és destruktorok segítik az objektumok kezelését.
✔ Az öröklés és a polimorfizmus lehetővé teszi a kód újrafelhasználását.