Hogyan hívjuk meg a tiszta virtuális metódust?

Nem lehet közvetlenül meghívni egy tiszta virtuális metódust egy absztrakt ősosztály mutatóján vagy ezen osztály objektumán keresztül, mivel nincs meghatározva az alap osztályban.

Azonban, egy tiszta virtuális metódus hívható a származtatott osztály konstruktorából vagy destruktorából, ahol ez a metódus megvalósításra kerül. Ebben az esetben a hívás statikus módon lesz engedélyezve, és a hívás során az adott osztály implementációja lesz végrehajtva.

Példa a hívásra a származtatott osztály konstruktorából:

#include <iostream>

class Base {
public:
    virtual void pure_virtual_method() = 0; // Tiszta virtuális metódus
};

class Derived : public Base {
public:
    void pure_virtual_method() override {
        std::cout << "Implementáció a Derived-ben\n";
    }

    Derived() {
        // Tiszta virtuális metódus hívása a származtatott osztály konstruktorából
        pure_virtual_method();
    }
};

int main() {
    Derived obj; // Származtatott osztály példányosítása, konstruktor hívása
    return 0;
}

Ebben a példában, amikor a Derived osztály obj objektuma létrejön, a Derived konstruktor hívódik, amelyben a pure_virtual_method() meghívásra kerül. Mivel a Derived osztályban van ennek a metódusnak a megvalósítása, az sikeresen végrehajtódik.

Az absztrakt ősosztály konstruktorából vagy destruktorából történő tiszta virtuális metódus hívás esetén, ahol az a deklarált, viselkedés undefined behavior-t eredményez, mivel a ősosztály vtable-je még nem teljesen épült ki vagy már megsemmisült, és a megfelelő implementáció a származtatott osztályban nem elérhető.

Szintén lehetőség van a tiszta virtuális metódus hívására a származtatott osztályból a Base::pure_virtual_method() kvalifikációval, de ez csak akkor lehetséges, ha a tiszta virtuális metódus implementációja a származtatott osztályban van, és az a bázisosztályból hívja meg az implementációt (ami nem lehetséges tiszta virtuális esetén), vagy más függvényen keresztül, ami viszont undefined behavior-t eredményezhet, vagy ha a bázisosztályból származó nem virtuális metódust hívunk ugyanazzal a névvel.

A helyes módja a tiszta virtuális metódus által képviselt logika kezelésének az, hogy létrehozunk egy származtatott osztály példányt, és ezt a logikát a bázisosztály mutatója vagy referenciája segítségével hívjuk meg (polimorfizmus).

#include <iostream>

class Base {
public:
    virtual void pure_virtual_method() = 0;
};

class Derived : public Base {
public:
    void pure_virtual_method() override {
        std::cout << "Implementáció a Derived-ben polimorfizmussal\n";
    }
};

int main() {
    Base* ptr = new Derived(); // Polimorfikus hívás
    ptr->pure_virtual_method();
    delete ptr;
    return 0;
}

Így, a "tisztán virtuális metódus hívása" általános értelemben (objektum vagy mutató segítségével a bázisosztályra, amelynek nincs meghatározása) nem lehetséges. A hívás csak a származtatott osztály konstruktorából vagy destruktorából, vagy polimorfizmus révén, egy származtatott osztály példányának létrehozásával történhet.