Mots-Clés Virtual et Override

Mot-clé Virtual

Le mot-clé virtual est utilisé avant une déclaration de méthode dans une classe pour résoudre le problème que nous avons discuté précédemment. Il est employé pour les méthodes qui sont communes à toutes les sous-classes mais nécessitent des implémentations distinctes pour chacune. Essentiellement, cela ressemble à toute autre déclaration de méthode, sauf qu'elle commence par virtual.

Base


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

Lorsqu'une fonction est déclarée comme virtual dans une superclasse, cela permet de la remplacer dans une sous-classe. Cela signifie qu'elle peut fournir sa propre implémentation de la fonction, qui sera invoquée à la place de l'implémentation originale lorsque la fonction est appelée via un pointeur ou une référence à la superclasse.

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

Remarque

Lorsque vous avez un pointeur vers un objet et que vous souhaitez accéder aux membres de celui-ci via le pointeur, vous utilisez l'opérateur flèche (->).

En revenant à la solution impliquant le problème original avec les boutons, cette méthode nous permet de créer facilement une fonction unique qui prend un pointeur parent Button comme paramètre. Par conséquent, nous pouvons invoquer cette fonction en passant soit SubmitButton, ResetButton, ou CancelButton, et elle fonctionnera comme prévu.

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

Remarque

Essayez de créer des objets de différentes sous-classes et passez-les à la fonction.

Le mot-clé Override

Le mot-clé override est utilisé dans une sous-classe pour indiquer explicitement qu'une fonction membre remplace une fonction virtuelle d'une superclasse. Il aide à détecter les erreurs à la compilation si la signature de la fonction dans la sous-classe ne correspond à aucune fonction virtuelle dans la superclasse.

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() { }

S'il y a une erreur, comme une faute de frappe dans la signature de la fonction ou si la superclasse n'a pas la fonction que vous essayez de remplacer, le compilateur générera une erreur, aidant à détecter d'éventuels bugs lors de la compilation. Cette fonctionnalité est particulièrement bénéfique dans les environnements de grandes équipes, où le suivi, par exemple, du changement des noms de méthode peut être difficile.

Tout était clair ?

Merci pour vos commentaires !

Section 5. Chapitre 2