inheritance

Angol

Főnév

inheritance (tsz. inheritances)

örökség
(informatika) öröklődés
Single Inheritance

A derived class inherits from one base class.

Multiple Inheritance

A derived class inherits from more than one base class.

Multilevel Inheritance

A class is derived from another derived class, forming a hierarchy.

Hierarchical Inheritance

Multiple classes are derived from a single base class.

Hybrid Inheritance

A combination of two or more types of inheritance.

Az öröklődés az objektumorientált programozás (OOP) egyik alapvető fogalma. Segítségével egy osztály (leszármazott vagy alosztály) örökölheti egy másik osztály (ősosztály vagy szülőosztály) tulajdonságait és metódusait. Ez elősegíti a kód újrafelhasználását, az osztályok közötti kapcsolatokat, és az átláthatóbb programstruktúrát.

2. Egyszerű öröklődés

Az alábbi példában a Gyumolcs osztályból egy új osztály, az Alma származik:

#include <iostream>
using namespace std;

// Szülőosztály (ősosztály)
class Gyumolcs {
public:
    void szin() {
        cout << "A gyümölcsnek van egy színe." << endl;
    }
};

// Leszármazott osztály (gyermekosztály)
class Alma : public Gyumolcs {
public:
    void fajta() {
        cout << "Ez egy piros alma." << endl;
    }
};

int main() {
    Alma a;
    a.szin();  // Örökölt metódus
    a.fajta(); // Saját metódus
    return 0;
}

Kimenet:

A gyümölcsnek van egy színe.
Ez egy piros alma.

Az Alma osztály megörökölte a Gyumolcs osztály szin() metódusát, így azt anélkül tudjuk használni, hogy újra kellene definiálni.

3. Hozzáférési módosítók az öröklésben

C++-ban az öröklés három módja lehetséges:

Módosító	Mit örököl az alosztály?
`public`	A `public` tagok nyilvánosak maradnak, a `protected` tagok öröklődnek, de `private` maradnak
`protected`	A `public` és `protected` tagok protected-ként öröklődnek
`private`	Az összes örökölt tag private lesz az alosztályban

class A {
public:
    int x;  // Nyilvános tag
protected:
    int y;  // Védett tag
private:
    int z;  // Privát tag (NEM öröklődik!)
};

class B : public A {
    // x továbbra is public, y marad protected, z nem elérhető
};

class C : protected A {
    // x és y protected lesz, z nem elérhető
};

class D : private A {
    // x és y private lesz, z nem elérhető
};

4. Konstruktor és destruktor öröklődése

A konstruktorokat nem örökli az alosztály, de az ősosztály konstruktorát meg kell hívni az alosztály konstruktorában.

class Szulo {
public:
    Szulo() {
        cout << "Szülőosztály konstruktora meghívva." << endl;
    }
    ~Szulo() {
        cout << "Szülőosztály destruktora meghívva." << endl;
    }
};

class Gyermek : public Szulo {
public:
    Gyermek() {
        cout << "Gyermekosztály konstruktora meghívva." << endl;
    }
    ~Gyermek() {
        cout << "Gyermekosztály destruktora meghívva." << endl;
    }
};

int main() {
    Gyermek g;
    return 0;
}

Kimenet:

Szülőosztály konstruktora meghívva.
Gyermekosztály konstruktora meghívva.
Gyermekosztály destruktora meghívva.
Szülőosztály destruktora meghívva.

Figyeljük meg, hogy az ősosztály konstruktora előbb, a destruktora pedig utóbb fut le!

5. Öröklődés és metódus felüldefiniálás (Method Overriding)

A gyermekosztályban felülírhatjuk az ősosztály metódusait. Ehhez a virtual kulcsszót használjuk:

class Szulo {
public:
    virtual void kiir() {
        cout << "Ez a szülőosztály." << endl;
    }
};

class Gyermek : public Szulo {
public:
    void kiir() override {  // Felüldefiniálás
        cout << "Ez a gyermekosztály." << endl;
    }
};

int main() {
    Szulo* p;
    Gyermek g;
    p = &g;

    p->kiir(); // A gyermek osztály függvénye hívódik meg a dinamikus kötés miatt
    return 0;
}

Kimenet:

Ez a gyermekosztály.

Ha nincs virtual kulcsszó, akkor az ősosztály metódusa hívódna meg.

6. Többszörös öröklődés

Egy osztály több ősosztályt is örökölhet:

class Motor {
public:
    void teljesitmeny() {
        cout << "Ez egy erős motor!" << endl;
    }
};

class Auto {
public:
    void marka() {
        cout << "Ez egy sportautó." << endl;
    }
};

class Sportauto : public Motor, public Auto {};

int main() {
    Sportauto s;
    s.teljesitmeny();
    s.marka();
    return 0;
}

Kimenet:

Ez egy erős motor!
Ez egy sportautó.

7. Virtuális öröklődés és gyémántprobléma

A gyémántprobléma akkor lép fel, ha egy osztály két szülőosztályból örököl, amelyek egy közös ősből származnak:

class Alap {
public:
    void uzenet() {
        cout << "Alap osztályból" << endl;
    }
};

class Szulo1 : public Alap {};
class Szulo2 : public Alap {};

// Probléma: Kétszer öröklődik az Alap osztály
class Gyermek : public Szulo1, public Szulo2 {};

int main() {
    Gyermek g;
    // g.uzenet(); // HIBA: Nem egyértelmű, melyik uzenet() függvényt használja!
    return 0;
}

Megoldás: virtuális öröklődés:

class Alap {
public:
    void uzenet() {
        cout << "Alap osztályból" << endl;
    }
};

class Szulo1 : virtual public Alap {};
class Szulo2 : virtual public Alap {};

class Gyermek : public Szulo1, public Szulo2 {};

int main() {
    Gyermek g;
    g.uzenet();  // Most már egyértelmű!
    return 0;
}

Kimenet:

Alap osztályból

8. Összegzés

Az öröklődés a kód újrafelhasználásának egyik legfontosabb eszköze C++-ban. A legfontosabb pontok:

Egyszerű öröklődés: Egy osztály egy másikból örököl.
Hozzáférési módosítók: public, protected, private.
Konstruktor és destruktor hívásai.
Felüldefiniálás (override) és virtuális függvények.
Többszörös öröklődés és gyémántprobléma.
Virtuális öröklődés megoldja az öröklési konfliktusokat.

További információk

inheritance - Szótár.net (en-hu)
inheritance - Sztaki (en-hu)
inheritance - Merriam–Webster
inheritance - Cambridge
inheritance - WordNet
inheritance - Яндекс (en-ru)
inheritance - Google (en-hu)
inheritance - Wikidata
inheritance - Wikipédia (angol)