member function (tsz. member functions)
Egy osztály tagfüggvényei lehetnek publikus, privát vagy védett (protected) láthatóságúak.
🔹 Egyszerű példa egy tagfüggvényre:
#include <iostream>
class Car {
public:
void start() {
std::cout << "Autó elindult!\n";
}
};
int main() {
Car myCar;
myCar.start(); // Hívjuk a member function-t
}
Ebben az esetben a start() egy public member function, amelyet az osztályon kívülről is meghívhatunk.
private tagfüggvényekPrivát tagfüggvények csak az osztályon belül érhetők el.
🔹 Példa:
class Engine {
private:
void checkOil() {
std::cout << "Olajszint ellenőrzése...\n";
}
public:
void start() {
checkOil(); // Privát függvényt csak belsőleg hívhatjuk meg
std::cout << "Motor beindult!\n";
}
};
int main() {
Engine myEngine;
myEngine.start();
// myEngine.checkOil(); // HIBA! A függvény privát
}
🔸 A checkOil() csak az Engine osztályon belül hívható meg, kívülről nem.
const member functionHa egy tagfüggvény nem módosíthatja az osztály adattagjait, akkor const-ként kell deklarálni.
🔹 Példa const tagfüggvényre:
class Car {
private:
int speed = 100;
public:
int getSpeed() const { // `const` biztosítja, hogy a függvény nem módosítja az adattagokat
return speed;
}
};
Ha const nélkül próbálnánk egy const példányon hívni, fordítási hibát kapnánk.
static tagfüggvényekA static tagfüggvények nem tartoznak egy adott példányhoz, hanem az egész osztályhoz.
🔹 Példa egy static függvényre:
class Math {
public:
static int add(int a, int b) {
return a + b;
}
};
int main() {
std::cout << Math::add(3, 4) << '\n'; // 7
}
🔸 Fontos: A static függvények nem érhetik el az osztály nem statikus adattagjait.
inline és osztályon kívüli megvalósításA tagfüggvényeket definiálhatjuk az osztályon belül (automatikusan inline lesznek), vagy az osztályon kívül.
🔹 Osztályon belüli megvalósítás (inline):
class Rectangle {
public:
int area(int width, int height) { return width * height; }
};
🔹 Osztályon kívüli megvalósítás:
class Rectangle {
public:
int area(int width, int height);
};
// Definiálás az osztályon kívül
int Rectangle::area(int width, int height) {
return width * height;
}
virtual függvények és öröklődésHa egy függvényt polimorf módon szeretnénk használni, akkor virtual kulcsszóval kell ellátni.
🔹 Példa virtuális függvényre:
class Animal {
public:
virtual void makeSound() {
std::cout << "Állati hang!\n";
}
};
class Dog : public Animal {
public:
void makeSound() override {
std::cout << "Vau-vau!\n";
}
};
int main() {
Animal* a = new Dog();
a->makeSound(); // "Vau-vau!" lesz a kimenet, mert a függvény virtuális
delete a;
}
🔹 Példa konstruktorra és destruktorra:
class Car {
public:
Car() { std::cout << "Autó létrehozva!\n"; }
~Car() { std::cout << "Autó megsemmisítve!\n"; }
};
int main() {
Car myCar; // Létrejön és a destruktor automatikusan lefut
}
| Típus | Leírás |
|---|---|
public
|
Bárhonnan elérhető |
private
|
Csak az osztályon belül érhető el |
protected
|
Örökölt osztályok is elérhetik |
const
|
Nem módosíthatja az adattagokat |
static
|
Nem tartozik példányhoz, csak az osztályhoz |
virtual
|
Dinamikus polimorfizmushoz használható |
| Konstruktor | Példányosításkor fut le |
| Destruktor | Objektum megsemmisítésénél hívódik meg |