la surcharge des opérateurs et l'héritage

Question

m'a donné le code suivant:

class FibHeapNode 
{ 
    //... 

    // These all have trivial implementation 
    virtual void operator =(FibHeapNode& RHS); 
    virtual int operator ==(FibHeapNode& RHS); 
    virtual int operator <(FibHeapNode& RHS); 

}; 

class Event : public FibHeapNode 
{ 
    // These have nontrivial implementation 
    virtual void operator=(FibHeapNode& RHS); 
    virtual int operator==(FibHeapNode& RHS); 
    virtual int operator<(FibHeapNode& RHS); 

}; 

class FibHeap 
{ 
    //... 

    int DecreaseKey(FibHeapNode *theNode, FibHeapNode& NewKey) 
    { 
      FibHeapNode *theParent; 

      // Some code 

      if (theParent != NULL && *theNode < *theParent) 
      { 
      //... 
      } 

      //... 
      return 1; 
    } 
}; 

Une grande partie de la mise en œuvre de FibHeap est similaire: pointeurs de FibHeapNode sont déréférencé puis comparés.

Pourquoi ce code fonctionne-t-il? (ou est-ce buggé?) Je penserais que le virtual ici n'aurait aucun effet: puisque * theNode et * theParent ne sont pas des types de pointeur ou de référence, aucun dispatch dynamique ne se produit et FibHeapNode :: opérateur < est appelé n'importe ce qui est écrit dans l'événement.

Answer 1

Vous devez être un peu confus au sujet de la répartition dynamique.

On dit souvent que "l'envoi dynamique se produit uniquement lorsque vous passez un appel via un pointeur ou via une référence". Formellement parlant, cette déclaration est totalement faux et trompeuse.

envoi dynamique en C++ se toujours lorsque vous appelez une fonction virtuelle , avec une et une seule exception: l'envoi dynamique est désactivée lorsque vous utilisez un nom pleinement qualifié de la fonction cible. Par exemple:

some_pointer->SomeClass::some_function(); // fully-qualified name 

Dans le code ci-dessus l'appel sera envoyé statiquement, même si some_function est une fonction virtuelle. Du point de vue du langage, il y a non d'autres moyens pour éviter la répartition dynamique, c'est-à-dire dans tous les autres cas tous les appels aux fonctions virtuelles sont envoyés dynamiquement. Ce que vous utilisez: un pointeur, une référence, un objet immédiat - n'a pas d'importance, l'envoi est toujours dynamique. Où vous appelez la fonction de: de constructeur/destructeur ou d'ailleurs - peu importe, l'envoi est toujours dynamique. Et je le répète: c'est ainsi que les choses se passent du point de vue du langage C++ lui-même. C'est ainsi qu'une "machine C++ abstraite" fonctionne. Ce qui se passe en pratique cependant, c'est que dans de nombreux cas, la répartition dynamique peut être remplacée par une répartition statique, car le compilateur connaît le type dynamique de l'objet à l'avance, au moment de la compilation et, par conséquent, connaît la cible de l'expédition. Dans de tels cas, il est plus logique d'appeler la fonction cible directement, au lieu de passer par le mécanisme de répartition dynamique plus coûteux. Pourtant, ce n'est rien d'autre qu'une optimisation. Certaines personnes, malheureusement, confondent cette optimisation pour un comportement exigé par la langue, en arrivant avec des instructions sans signification telles que "l'envoi dynamique se produit uniquement lorsque vous faites un appel à travers un pointeur ou à travers une référence".

Dans votre cas spécifique, l'envoi est dynamique. Puisque dans votre cas le compilateur ne connaît pas les types dynamiques des objets impliqués, il ne peut pas l'optimiser dans une répartition statique, c'est pourquoi votre code "fonctionne comme prévu".

P.S. Anticiper les questions possibles sur ce que j'ai dit plus haut: La répartition dynamique des appels faits à partir de constructeurs/destructeurs est limitée par le type dynamique actuel de l'objet, ce qui explique pourquoi il est possible (et facile) pour le compilateur de les optimiser. une répartition statique. C'est la raison d'une autre légende urbaine populaire qui stipule que les appels virtuels des constructeurs/destructeurs sont résolus statiquement.En réalité, en général, ils sont résolus dynamiquement, comme ils le devraient (encore une fois, en observant le type dynamique actuel de l'objet).

Answer 2

* theNode et * theParent sont des types de référence. En fait, FibHeapNode & ref est très équivalent à * theNode.