Wat is een abstracte klasse?

Een abstracte klasse is een klasse die niet rechtstreeks kan worden geïnstantieerd. Het bevat een of meer zuivere virtuele methoden (methoden zonder implementatie), gemarkeerd met = 0. Wordt gebruikt als basisklasse om een gemeenschappelijk interface te definiëren voor afgeleide klassen, die verplicht zijn om de implementatie van deze zuivere virtuele methoden te bieden.

Belangrijkste eigenschappen:

• Je kunt geen object van een abstracte klasse maken: AbstractClass obj; — fout.
• Kan gewone (niet-virtuele) methoden en gegevensvelden bevatten.
• Kan virtuele methoden met implementatie en zuivere virtuele methoden bevatten.
• Kan worden verwezen door pointers of referenties van het basistype: AbstractClass* ptr = new DerivedClass();
• Afgeleide klassen die niet alle zuivere virtuele methoden van de basisklasse implementeren, worden ook abstract.

Voorbeeld van gebruik om een contract te definiëren:

// Abstracte basisklasse Shape
class Shape {
public:
    // Zuivere virtuele methode - elke erfgenaam moet deze implementeren
    virtual double area() const = 0;
    // Virtuele methode met implementatie
    virtual void printDescription() const {
        // Standaardbeschrijving
    }
    // Niet-virtuele methode
    void commonOperation() {
        // Gemeenschappelijke acties
    }
    // Virtuele destructor is belangrijk voor correcte geheugenbeheer bij gebruik via pointers/referenties naar de basisklasse.
    virtual ~Shape() {}
};

// Afgeleide klasse die de zuivere virtuele methode implementeert
class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}
    // Implementatie van de zuivere virtuele methode area()
    double area() const override {
        return 3.14159 * radius * radius;
    }
    // Override van virtuele methode
    void printDescription() const override {
        // Beschrijving voor cirkel
    }
    // Destructor
    ~Circle() override {}
};

// Andere afgeleide klasse
class Rectangle : public Shape {
private:
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    // Implementatie van de zuivere virtuele methode area()
    double area() const override {
        return width * height;
    }
    // Destructor
    ~Rectangle() override {}
};

// Voorbeeld van gebruik
int main() {
    //Shape s; // Fout: kan geen object van een abstracte klasse maken

    Shape* shapes[2]; // Pointers naar de basisklasse
    shapes[0] = new Circle(5.0);
    shapes[1] = new Rectangle(4.0, 6.0);

    for(int i = 0; i < 2; ++i) {
        // Polymorfe aanroepen
        double a = shapes[i]->area();
        shapes[i]->printDescription();
        shapes[i]->commonOperation(); // Niet-virtuele methode
    }

    // Correct geheugen vrijmaken
    delete shapes[0];
    delete shapes[1];

    return 0;
}