member function

Üdvözlöm, Ön a member function szó jelentését keresi. A DICTIOUS-ban nem csak a member function szó összes szótári jelentését megtalálod, hanem megismerheted az etimológiáját, a jellemzőit és azt is, hogyan kell a member function szót egyes és többes számban mondani. Minden, amit a member function szóról tudni kell, itt található. A member function szó meghatározása segít abban, hogy pontosabban és helyesebben fogalmazz, amikor beszélsz vagy írsz. Amember function és más szavak definíciójának ismerete gazdagítja a szókincsedet, és több és jobb nyelvi forráshoz juttat.

Főnév

member function (tsz. member functions)

  1. (informatika) A member function (tagfüggvény) egy osztályhoz tartozó függvény C++-ban. Ezek a függvények az osztályon belül definiálhatók, és hozzáférhetnek az osztály adattagjaihoz.



1. Alapvető member function

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.



2. private tagfüggvények

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



3. const member function

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



4. static tagfüggvények

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



5. inline és osztályon kívüli megvalósítás

A 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;
}

6. virtual függvények és öröklődés

Ha 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;
}

7. További speciális tagfüggvények

  • Konstruktorok: Az osztály példányosításakor hívódnak meg.
  • Destruktorok: Az objektum megsemmisítésekor futnak.
  • Move és copy függvények: Másolási és mozgatási műveletek végrehajtására.

🔹 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
}

Összegzés

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