La fonction virtuelle pure C ++ a un corps

Question

Fonctions virtuelles pures (lorsque nous définissons = 0) peut également avoir un corps de fonction.

Quelle est l'utilité de fournir un corps de fonction pour des fonctions virtuelles pures, si elles ne sont pas du tout appelées?

Answer 1

Votre hypothèse selon laquelle la fonction virtuelle pure ne peut pas être appelée est absolument incorrecte. Lorsqu'une fonction est déclarée virtuelle pure, cela signifie simplement que cette fonction ne peut pas être appelée dynamiquement, via un mécanisme de répartition virtuelle. Pourtant, cette même fonction peut facilement être appelée statiquement, non virtuelle, directement (sans envoi virtuel).

En langage C++, un appel non virtuel à une fonction virtuelle est effectué lorsqu'un nom qualifié de la fonction est utilisé dans l'appel, c'est-à-dire lorsque le nom de fonction spécifié dans l'appel a le <class name>::<function name> forme.

Par exemple

struct S 
{
  virtual void foo() = 0;
};

void S::foo() 
{
  // body for pure virtual function `S::foo`
}

struct D : S 
{
  void foo() 
  {
    S::foo();       
    // Non-virtual call to `S::foo` from derived class

    this->S::foo(); 
    // Alternative syntax to perform the same non-virtual call 
    // to `S::foo` from derived class
  }
};

int main() 
{
  D d;

  d.S::foo(); 
  // Another non-virtual call to `S::foo`
}

Answer 2

"C++ efficace" Meyers mentionne une raison pour qu'une fonction virtuelle pure ait un corps: les classes dérivées qui implémentent cette fonction virtuelle pure peuvent appeler cette implémentation quelque part dans leur code. Si une partie du code de deux classes dérivées différentes est similaire, il est logique de la déplacer vers le haut dans la hiérarchie, même si la fonction doit être pure virtuelle.

voir ici .

Answer 3

Pour la plupart des fonctions virtuelles pures, vous auriez raison. Cependant, pour un destructeur virtuel pur, il est en fait important de définir une implémentation de destructeur correspondante:

• Le "virtuel pur" consiste à exiger des classes dérivées pour implémenter leur destructeur.
• L'implémentation de votre destructeur de classe de base est telle que les destructeurs de classe dérivés peuvent "enchaîner" avec succès par la suite.