pure virtual function (tsz. pure virtual functions)
= 0 értéket.
A pure virtual function olyan függvény egy bázisosztályban, amelyet az abból származtatott osztályoknak kötelező implementálniuk. Az ilyen függvények az absztrakt osztályok alapját képezik.
Szintaxis:
class Base {
public:
virtual void pureFunction() = 0; // Pure virtual function
};
Ebben az esetben a pureFunction() nem rendelkezik implementációval az Base osztályban, és a leszármazott osztályoknak kell megvalósítaniuk.
Egy osztály akkor válik absztrakt osztállyá, ha legalább egy pure virtual function-t tartalmaz. Egy absztrakt osztály nem példányosítható közvetlenül.
Példa egy absztrakt osztályra:
class Shape {
public:
virtual void draw() = 0; // Pure virtual function
};
Ebben az esetben a Shape osztály egy absztrakt osztály, és nem lehet belőle objektumot létrehozni.
A pure virtual function-t a leszármazott osztályokban kötelező megvalósítani, különben azok is absztrakt osztályok maradnak.
Példa leszármazott osztályra:
class Circle : public Shape {
public:
void draw() override {
std::cout << "Drawing a Circle" << std::endl;
}
};
A Circle osztály implementálja a draw() függvényt, így már példányosítható.
Akkor használjunk pure virtual function-t, ha:
- Biztosítani akarjuk, hogy minden leszármazott osztály saját implementációt adjon a függvényhez. - Olyan absztrakt osztályokat hozunk létre, amelyek csak egy interfészként szolgálnak. - Polimorfizmust akarunk megvalósítani.
A pure virtual function lehetővé teszi, hogy egy alaposztály pointerén vagy referenciáján keresztül a megfelelő leszármazott osztály metódusa hívódjon meg.
Példa:
void render(Shape& s) {
s.draw(); // Meghívja a megfelelő leszármazott osztály metódusát
}
int main() {
Circle c;
render(c); // "Drawing a Circle" kiírás jelenik meg
}
Ebben az esetben a render() függvény elfogad egy Shape referenciát, és dinamikus kötés révén a megfelelő draw() metódust hívja meg.
Bár a pure virtual function-nek nincs saját implementációja, mégis definiálhatunk rá egy alapértelmezett megvalósítást az osztályon belül.
Példa:
class Base {
public:
virtual void show() = 0; // Pure virtual function
};
void Base::show() {
std::cout << "Base implementation" << std::endl;
}
A leszármazott osztályoknak továbbra is meg kell valósítaniuk ezt a függvényt, de hivatkozhatnak az alapértelmezett implementációra.
A destruktor is lehet pure virtual, de ennek mindig kell egy implementáció az osztályon belül.
Példa:
class Base {
public:
virtual ~Base() = 0; // Pure virtual destructor
};
Base::~Base() {
std::cout << "Base destructor called" << std::endl;
}
A pure virtual destruktor akkor lehet hasznos, ha biztosítani akarjuk, hogy az osztály absztrakt maradjon, de mégis meg lehessen hívni az alaposztály destruktorát a származtatott osztályok törlésekor.
Egy osztályban több pure virtual function is lehet, így egy komplexebb interfészt is definiálhatunk.
Példa:
class Animal {
public:
virtual void makeSound() = 0;
virtual void move() = 0;
};
A leszármazott osztályoknak mindkét függvényt meg kell valósítaniuk.
A C++ támogatja a többszörös öröklődést, így egy osztály több absztrakt osztályból is örökölhet.
Példa:
class Flyable {
public:
virtual void fly() = 0;
};
class Swimmable {
public:
virtual void swim() = 0;
};
class Duck : public Flyable, public Swimmable {
public:
void fly() override {
std::cout << "Duck is flying" << std::endl;
}
void swim() override {
std::cout << "Duck is swimming" << std::endl;
}
};
Ebben az esetben a Duck osztály mindkét interfészt megvalósítja.
A pure virtual function egy olyan függvény egy osztályban, amelyet a leszármazott osztályoknak kötelező implementálniuk. Segít az absztrakt osztályok létrehozásában és a polimorfizmus megvalósításában.
Főbb jellemzők: - = 0 jelöli. - Egy absztrakt osztályban található. - Nem példányosítható alaposztályból. - A leszármazott osztályokban implementálni kell. - Polimorfizmust tesz lehetővé. - Destruktor is lehet pure virtual.
Használata elengedhetetlen az objektumorientált programozásban és a C++ játékfejlesztésben is, ahol gyakran alkalmazzák például a renderelő rendszerekben és komponens alapú architektúrákban.