Mit tud a virtual kulcsszóról a C++-ban?

A virtual a C++-ban a virtuális függvények deklarálására szolgál az alap osztályban. Ez lehetővé teszi a polimorfizmus futásidejű (runtime polymorphism) megvalósítását.

Alkalmazás:

• Meghatároz egy függvényt az alap osztályban, amelyet felülírhatnak (override) az leszármazott osztályok.
• Virtuális függvény hívásakor egy pointer vagy referencia az alap osztályra, a ténylegesen meghívott függvény a leszármazott osztály objektumában van (ha az ott felül van írva). Ez a futásidőben történik a virtuális függvények táblája (vtable) segítségével.

Főbb pontok:

• Csak osztálytagfüggvények lehetnek virtuálisak. Globális függvények, statikus tagfüggvények és konstruktorok nem lehetnek virtuálisak.
• A destruktorok lehetnek és gyakran kell is, hogy virtuálisak legyenek, hogy elkerüljük a memória szivárgást a leszármazott osztályok objektumainak törlésekor az alap osztály pointerén keresztül.
• Ha egy függvényt virtual-ként deklarálunk az alap osztályban, az automatikusan virtuális marad minden leszármazott osztályban, még akkor is, ha ott nem használjuk a virtual kulcsszót (bár ajánlott egyértelműség kedvéért explicit megadni a virtual-t és az override-t a leszármazott osztályokban).
• Csak virtuális függvények = 0-val deklarálva absztrakt osztályt hoznak létre. Ilyen osztályt nem lehet közvetlenül példányosítani.

Példa:

#include <iostream>

class Base {
public:
    virtual void print() {
        std::cout << "From Base" << std::endl;
    }

    virtual ~Base() {
        std::cout << "Base destructor" << std::endl;
    }
};

class Derived : public Base {
public:
    void print() override { // Az override használata a felülírás egyértelmű jelzésére
        std::cout << "From Derived" << std::endl;
    }

    ~Derived() override { // Az override használata
        std::cout << "Derived destructor" << std::endl;
    }
};

int main() {
    Base* ptr = new Derived(); // A bázisosztály pointere a leszármazott objektumára mutat

    ptr->print(); // A Derived::print() hívódik a virtuális függvény miatt
    delete ptr;   // A destruktorok Derived, majd Base hívódnak a virtuális destruktor miatt

    return 0;
}

Kapcsolódó fogalmak:

• vtable (virtuális függvények táblája): A virtuális függvények pointereit tartalmazó táblázat. Minden virtuális függvényeket tartalmazó objektum tartalmaz egy láthatatlan pointert (vptr) saját osztályának vtable-jára.
• vptr (vtable pointer): Szükséges a futásidőben meghívott függvény meghatározásához.
• = 0 (tiszta virtuális függvény): Jelzi, hogy a függvénynek nincs implementációja az adott osztályban, így az osztály absztrakt lesz.
• override (felülírás jelző): Egyértelműen jelzi, hogy a leszármazott osztály függvénye felülírja a bázisosztály virtuális függvényét. Segít a fordítónak hibák megtalálásában, ha a szignatúra nem egyezik.
• final (kifejezés): Megakadályozza további felülírást vagy öröklődést a virtuális függvény vagy osztály esetében.

Röviden: a virtual a polimorfizmus megvalósításának alapmechanizmusa az öröklődés és a dinamikus kötés révén C++-ban.