Virtuelle und Überschreibende Schlüsselwörter

Virtuelles Schlüsselwort

Das virtual Schlüsselwort wird vor einer Methodendeklaration in einer Klasse verwendet, um das zuvor besprochene Problem zu lösen. Es wird für Methoden verwendet, die allen Unterklassen gemeinsam sind, aber unterschiedliche Implementierungen für jede erfordern. Im Wesentlichen sieht es aus wie jede andere Methodendeklaration, außer dass es mit virtual beginnt.

Base


              1234567
            
class Base {
public:
    virtual void display() 
    { 
        std::cout << "Base class display() called" << std::endl; 
    }
};

Wenn eine Funktion als virtual in einer Oberklasse deklariert wird, erlaubt es, dass sie in einer Unterklasse überschrieben wird. Das bedeutet, dass sie ihre eigene Implementierung der Funktion bereitstellen kann, die statt der ursprünglichen Implementierung aufgerufen wird, wenn die Funktion über einen Zeiger oder eine Referenz auf die Oberklasse aufgerufen wird.

main


              123456789101112131415161718192021222324252627
            
#include <iostream>

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


class Derived : public Base {
public:
    void display()
    {
        std::cout << "Derived display() called" << std::endl;
    }
};

int main()
{
    Base* obj;
    Derived derived;
    
    obj = &derived;
    obj->display();
}

Hinweis

Wenn Sie einen Zeiger auf ein Objekt haben und auf Mitglieder davon über den Zeiger zugreifen möchten, verwenden Sie den Pfeiloperator (->).

Zurück zur Lösung des ursprünglichen Problems mit den Schaltflächen ermöglicht uns diese Methode, eine einzelne Funktion zu erstellen, die einen Eltern-Button-Zeiger als Parameter nimmt. Folglich können wir diese Funktion aufrufen, indem wir entweder SubmitButton, ResetButton oder CancelButton übergeben, und sie wird wie beabsichtigt funktionieren.

main


              12345678910111213141516171819202122232425262728293031
            
#include <iostream>

class Button {
public:
    virtual void onClick() { std::cout << "Click" << std::endl; }
};

class UploadButton : public Button {
public:
    void onClick() { std::cout << "Upload" << std::endl; }  
};

class ResetdButton : public Button {
public:
    void onClick() { std::cout << "Reset" << std::endl; }  
};

class CancelButton : public Button {
public:
    void onClick() { std::cout << "Cancel" << std::endl; }  
};

void user_clicked_button(Button& btn) {
    btn.onClick();
}

int main()
{
    UploadButton uploadButton;
    user_clicked_button(uploadButton);
}

Hinweis

Versuchen Sie, Objekte von verschiedenen Unterklassen zu erstellen und übergeben Sie sie an die Funktion.

Das Override-Schlüsselwort

Das override-Schlüsselwort wird in einer Unterklasse verwendet, um explizit anzugeben, dass eine Member-Funktion eine virtuelle Funktion von einer Oberklasse überschreibt. Es hilft, Fehler zur Kompilierzeit zu erkennen, wenn die Funktionssignatur in der Unterklasse nicht mit einer virtuellen Funktion in der Oberklasse übereinstimmt.

main


              1234567891011121314
            
#include <iostream>

class Button {
public:
    virtual void handleClick() { std::cout << "Click" << std::endl; }
};

class UploadButton : public Button {
public:
    // marked override, but does not override
    void onClick() override { std::cout << "Upload" << std::endl; }  
};

int main() { }

Wenn ein Fehler vorliegt, wie z.B. ein Tippfehler in der Funktionssignatur oder die Oberklasse die Funktion, die Sie überschreiben möchten, nicht hat, wird der Compiler einen Fehler generieren, um potenzielle Fehler zur Kompilierzeit zu erkennen. Diese Funktion ist besonders vorteilhaft in großen Teamumgebungen, in denen es schwierig sein kann, beispielsweise Änderungen der Methodennamen nachzuverfolgen.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 5. Kapitel 2