Polymorphisme: comment déterminer si une fonction membre est une fonction virtuelle (c'est-à-dire, réécriture ou couverture de fonction)

Le concept de polymorphisme : manifestations multiples de la même chose, divisées en polymorphisme statique et polymorphisme dynamique.
1. Le polymorphisme statique se reflète au moment de la compilation, comme la surcharge de fonctions et la programmation générique.

Surcharge de fonction:

1. La portée est la même.
2. Plusieurs fonctions ont des fonctions similaires et ont les mêmes noms de fonction.
3. Les paramètres ne sont pas les mêmes (types de paramètres différents, nombre ou ordre).
4. Selon les paramètres de la fonction lors de l'appel, sachez quelle fonction appeler.

2. Le polymorphisme dynamique , qui se reflète à l'exécution, doit remplir deux conditions:

1. La fonction de
   détermination de fonction virtuelle n'est pas un membre de la fonction virtuelle (réinscriptible), il y a deux trois conditions:
   1) deux fonctions membres respectives définies dans la classe de base et une classe dérivée;.
   2) définie dans la fonction membre de la classe de base doit. Avec le mot-clé virtual, les fonctions membres de la classe dérivée peuvent être importées ou non.
   3) Les deux prototypes de fonction membre (nom de fonction, paramètre de fonction, type de retour de fonction) doivent être identiques.

Remarque: Si les types de retour de ces deux fonctions sont la classe de base et la classe dérivée et que la valeur de retour est un pointeur ou une référence vers la classe de base et la classe dérivée, cela constitue également un écrasement. Ce type de retour est appelé covariance .

2. Lorsque vous appelez la fonction virtuelle de l' objet , utilisez le pointeur ou la référence d'objet , de sorte que lorsque le pointeur pointe vers différents objets, vous pouvez appeler différents types de fonctions membres, reflétant ainsi le polymorphisme.

Voici une analyse du programme:

#include<iostream>
using namespace std;

class Grandam
{
public:
    virtual void introduce_self()
    {
        cout << "I am grandam." << endl;
    }
};

class Mother:public Grandam
{
public:
    void introdude_self()
    {
        cout << "I am mother." << endl;
    }
};

class Daughter :public Mother
{
public:
    void introduce_self()
    {
        cout << "I am daughter." << endl;
    }
};

int main()
{
    Grandam* ptr;
    Grandam g;
    Mother m;
    Daughter d;
    ptr = &g;
    ptr->introduce_self();

    ptr = &m;
    ptr->introduce_self();

    ptr = &d;
    ptr->introduce_self();
    return 0;
}

Le résultat est montré dans la figure:

On peut voir d'après les résultats que la version de la fonction virtuelle introduit_self () de l'objet est exécutée à chaque fois, ce qui reflète le polymorphisme à l'exécution.