Ugrás a tartalomhoz

abstract class

A Wikiszótárból, a nyitott szótárból

Angol

Főnév

abstract class (tsz. abstract classes)

  1. (informatika) A C++ abstract class egy olyan osztály, amelyből nem lehet példányt létrehozni, és amelyet arra terveztek, hogy más osztályok leszármazottként örököljék. Az absztrakt osztály legalább egy pure virtual function-t tartalmaz, amelyet a leszármazott osztályoknak kell megvalósítaniuk.


1. Mi az az Abstract Class?

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.


2. Hogyan Működik az Abstract Class?

Egy absztrakt osztály főként egy interfészként szolgál, amelyet a leszármazott osztályok megvalósítanak.

Példa egy absztrakt osztályra és annak leszármazottjára:

#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ó.


3. Mikor Használjunk Abstract Class-t?

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.

Példa a polimorfizmusra:

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.


4. Abstract Class és Több Pure Virtual Function

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;
    }
};

5. Abstract Class és Többszörös Öröklődés

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.

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.


6. Abstract Class és Pure Virtual Destructor

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.


7. Abstract Class és Alapértelmezett Implementáció

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.


8. Abstract Class és Template-ek

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ó.


9. Abstract Class és Interface Különbsége

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.


10. Összegzés

A C++ abstract class egy olyan osztály, amely nem példányosítható, és legalább egy pure virtual function-t tartalmaz.

Fontos tulajdonságai:

✅ 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.

További információk

A lap eredeti címe: „https://hu.wiktionary.org/w/index.php?title=abstract_class&oldid=3489980”