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 |