Quelles sont les différences entre le remplacement des fonctions virtuelles et le masquage de non-fonctions virtuelles?

Qu'est-ce que la fonction de masquage?

... est une forme du nom de la clandestinité. Un exemple simple:

void foo(int);
namespace X
{
    void foo();

    void bar()
    {
        foo(42); //will not find `::foo`
        //because `X::foo` hides it
    }
}

Cela s'applique également à la recherche d'un nom dans une classe de base:

class Base
{
public:
    void foo(int);
};

class Derived : public Base
{
public:
    void foo();
    void bar()
    {
        foo(42); //will not find `Base::foo`
        //because `Derived::foo` hides it
    }
};

---

Qu'est-ce que la fonction primordiale?

Cela est lié à la notion de fonctions virtuelles. [classe.virtuel]/2

Si une fonction membre virtuelle vf est déclarée dans une classe Base et dans une classe Derived, provenant directement ou indirectement de Base, une fonction de membre vf avec le même nom, paramètre de type de liste, cv-qualification, et le ref-qualificatif (ou de l'absence de même) que Base::vf est déclarée, alors Derived::vf est aussi virtuel (qu'il soit ou non déclarée) et il remplace Base::vf.

class Base
{
private:
    virtual void vf(int) const &&;
    virtual void vf2(int);
    virtual Base* vf3(int);
};

class Derived : public Base
{
public: //accessibility doesn't matter!
    void vf(int) const &&; //overrides `Base::vf(int) const &&`
    void vf2(/*int*/);     //does NOT override `Base::vf2`
    Derived* vf3(int);     //DOES override `Base::vf3` (covariant return type)
};

La finale overrider devient pertinente lors de l'appel d'une fonction virtuelle: [classe.virtuel]/2

Une fonction membre virtuelle C::vf d'un objet de classe S est une finale overrider moins que la plupart de la classe dérivée de qui S est une classe de base sous-objet (le cas échéant) déclare ou hérite d'une autre fonction membre qui remplace vf.

I. e. si vous avez un objet de type S, la finale overrider est la première overrider vous voir lors de la traversée de la hiérarchie de classe de S retour à de ses classes de base. Le point important est que la de type dynamique de la fonction-appel expression est utilisée afin de déterminer la finale overrider:

Base* p = new Derived;
p -> vf();    //dynamic type of `*p` is `Derived`

Base& b = *p;
b  . vf();    //dynamic type of `b` is `Derived`

---

Quelle est la différence entre le remplacement et la cacher?

Essentiellement, les fonctions dans la classe de base sont toujours cachés par des fonctions de même nom dans une classe dérivée, peu importe si la fonction dans la classe dérivée remplace une classe de base virtuelle ou non la fonction:

class Base
{
private:
    virtual void vf(int);
    virtual void vf2(int);
};

class Derived : public Base
{
public:
    void vf();     //doesn't override, but hides `Base::vf(int)`
    void vf2(int); //overrides and hides `Base::vf2(int)`
};

Pour trouver un nom de fonction, le type statique d'une expression est utilisée:

Derived d;
d.vf(42);   //`vf` is found as `Derived::vf()`, this call is ill-formed
            //(too many arguments)

---

Comment ils se rapportent à la fonction de surcharges?

Que la fonction "cacher" est une forme du nom de la clandestinité, tous les surcharges sont touchés si le nom d'une fonction est caché:

class Base
{
private:
    virtual void vf(int);
    virtual void vf(double);
};

class Derived : public Base
{
public:
    void vf();     //hides `Base::vf(int)` and `Base::vf(double)`
};

Pour fonction dominante, seule la fonction dans la classe de base avec les mêmes arguments seront redéfinies; vous pouvez bien sûr la surcharge d'une fonction virtuelle:

class Base
{
private:
    virtual void vf(int);
    virtual void vf(double);
    void vf(char);  //will be hidden by overrides in a derived class
};

class Derived : public Base
{
public:
    void vf(int);    //overrides `Base::vf(int)`
    void vf(double); //overrides `Base::vf(double)`
};

OriginalL'auteur dyp

Beaucoup plus de facilité exemple qui diffère b/w tous.

class Base {
public:
    virtual int fcn();
};

class D1 : public Base {
public:  
    //D1 inherits the definition of Base::fcn()
    int fcn(int);  //parameter list differs from fcn in Base
    virtual void f2(); //new virtual function that does not exist in Base
};

class D2 : public D1 {
public:
    int fcn(int); //nonvirtual function hides D1::fcn(int)
    int fcn();  //overrides virtual fcn from Base
    void f2();  //overrides virtual f2 from D1
}

OriginalL'auteur AbhimanyuAryan

Nous allons commencer par le plus facile.

p1 est un Parent pointeur, donc il sera toujours appeler Parent's des fonctions de membre du.

cp est un pointeur vers Child, de sorte qu'il sera toujours appeler Child's des fonctions de membre du.

Maintenant le plus difficile. p2 est un Parent pointeur, mais il pointe vers un objet de type Child, ce qui fera appel à Child's fonctions chaque fois que le correspondant Parent fonction est virtuelle ou la fonction n'existe que dans les Child et pas dans Parent. En d'autres termes, Child cache Parent::doA() avec ses propres doA(), mais il remplace Parent::doB(). La fonction de masquage est parfois considéré comme une forme de la surcharge de fonction, parce que d'une fonction avec le même nom est donné à une mise en œuvre différente. Parce que le masquage de la fonction est dans une classe différente de celle de la fonction cachée, il a une signature différente, ce qui rend clair pour l'utiliser.

La sortie pour testStuff() sera

doA in Parent
doA in Parent
doA in Child
doB in Parent
doB in Child
doB in Child

Dans tous les cas, Parent::doA() et Parent::doB() peut être appelée à l'intérieur Child à l'aide de la résolution de nom, quelle que soit la fonction "virtual-ness". La fonction

void Child::doX() {
  doA();
  doB();
  Parent::doA();
  Parent::doB();
  cout << "doX in Child" << endl;
}

démontre lorsqu'il est appelé par cp->doX() par la sortie

doA in Child
doB in Child
doA in Parent
doB in Parent
doX in Child

En outre, cp->Parent::doA() appellera Parent'version de doA().

p2 ne peut pas se référer à doX() parce que c'est un Parent*, et Parent ne sais pas à propos de quoi que ce soit dans Child. Cependant, p2 peut être castée pour un Child*, depuis qu'il a été initialisé comme un seul, et alors il peut être utilisé pour appeler doX().

OriginalL'auteur Jed Schaaf