abstract class (tsz. abstract classes)
Az absztrakt osztály egy olyan osztály, amely általános viselkedést és interfészt határoz meg, de nem lehet belőle közvetlenül példányt létrehozni.
Jellemzői: - Legalább egy pure virtual function-t tartalmaz (= 0). - Nem lehet példányosítani. - A leszármazott osztályoknak meg kell valósítaniuk a pure virtual function-t.
Példa egy absztrakt osztályra:
class Shape {
public:
virtual void draw() = 0; // Pure virtual function
};
Ebben az esetben a Shape osztály absztrakt, mert tartalmaz egy pure virtual function-t.
Egy absztrakt osztály főként egy interfészként szolgál, amelyet a leszármazott osztályok megvalósítanak.
#include <iostream>
class Shape {
public:
virtual void draw() = 0; // Pure virtual function
};
class Circle : public Shape {
public:
void draw() override {
std::cout << "Drawing a Circle" << std::endl;
}
};
int main() {
// Shape shape; // HIBA! Nem lehet példányosítani egy absztrakt osztályt
Circle c;
c.draw(); // "Drawing a Circle"
}
Ebben az esetben a Circle osztály megvalósítja a draw() függvényt, így példányosítható.
Egy absztrakt osztály akkor hasznos, ha: - Egy közös interfészt szeretnénk létrehozni több osztály számára. - Biztosítani akarjuk, hogy a leszármazott osztályok kötelezően megvalósítsák bizonyos függvényeket. - Polimorfizmust akarunk használni.
void render(Shape& s) {
s.draw();
}
int main() {
Circle c;
render(c); // "Drawing a Circle"
}
A render() függvény egy Shape referenciát vesz át, de a dinamikus kötés révén a megfelelő leszármazott osztály metódusát hívja meg.
Egy absztrakt 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.
Példa a leszármazott osztályokra:
class Dog : public Animal {
public:
void makeSound() override {
std::cout << "Bark" << std::endl;
}
void move() override {
std::cout << "Dog runs" << std::endl;
}
};
class Bird : public Animal {
public:
void makeSound() override {
std::cout << "Chirp" << std::endl;
}
void move() override {
std::cout << "Bird flies" << std::endl;
}
};
A C++ lehetővé teszi többszörös öröklődést, így egy osztály több absztrakt osztályból is örökölhet.
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.
Az absztrakt osztályokban lehet pure virtual destructor, de ezt mindig meg kell valósítani 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;
}
Ez biztosítja, hogy az absztrakt osztály destruktora meg legyen hívva, amikor egy leszármazott osztály objektuma törlődik.
Egy pure virtual function-nek lehet alapértelmezett implementációja.
Példa:
class Base {
public:
virtual void show() = 0;
};
void Base::show() {
std::cout << "Base implementation" << std::endl;
}
A leszármazott osztályok hivatkozhatnak erre az implementációra.
Egy absztrakt osztály sablonokkal is kombinálható, hogy általános interfészt biztosítson.
Példa:
template <typename T>
class Container {
public:
virtual void add(const T& item) = 0;
virtual void remove(const T& item) = 0;
};
Ez lehetővé teszi, hogy különböző típusokhoz készüljön absztrakt tároló.
A C++ nem rendelkezik külön interface kulcsszóval, mint a Java vagy C#, de az absztrakt osztályok használhatók ugyanarra a célra.
Interface-szerű absztrakt osztály:
class Interface {
public:
virtual void function1() = 0;
virtual void function2() = 0;
virtual ~Interface() {} // Virtuális destruktor
};
Ilyenkor az osztály csak pure virtual function-öket tartalmaz, így interfészként viselkedik.
A C++ abstract class egy olyan osztály, amely nem példányosítható, és legalább egy pure virtual function-t tartalmaz.
✅ Pure virtual function-t tartalmaz.
✅ Nem lehet példányosítani.
✅ A leszármazott osztályoknak meg kell valósítaniuk a hiányzó függvényeket.
✅ Polimorfizmusra használható.
✅ Többszörös öröklődésben is részt vehet.
✅ Lehet destructora és alapértelmezett implementációja.
A játékfejlesztésben, a grafikus motorokban és a tervezési mintákban gyakran alkalmazzák absztrakt osztályokat az interfészek és rendszerek elkülönítésére.