Comment utiliser les constructeurs de classes de base et les opérateurs d'affectation dans les classes dérivées en C ?

Utilisation des constructeurs de classe de base et de l'opérateur d'affectation en C

En programmation orientée objet, l'héritage permet aux classes d'hériter des propriétés et des méthodes de leurs classes de base. Cette fonctionnalité puissante permet la réutilisation et la maintenabilité du code. Cependant, la gestion des constructeurs et des opérateurs d'affectation dans les classes héritées peut s'avérer difficile.

Considérons une classe B avec un ensemble de constructeurs et un opérateur d'affectation. L'objectif est de créer une classe héritante D qui remplace foo() mais conserve les constructeurs et l'opérateur d'affectation de B.

Invocation explicite

Une façon d'y parvenir est d'appeler explicitement les constructeurs et les opérateurs d'affectation. dans D. Cela implique d'appeler manuellement le constructeur de classe de base approprié lors de la création d'instances de D et d'utiliser Base::operator=() pour attribuer des valeurs dans l'opérateur d'affectation.

<code class="cpp">class Base {
  // ...
public:
  Base(const Base&) { /*...*/ }
  Base& operator=(const Base&) { /*...*/ }
};

class Derived : public Base {
  int additional_;
public:
  Derived(const Derived& d)
    : Base(d) // dispatch to base copy constructor
    , additional_(d.additional_)
  {
  }

  Derived& operator=(const Derived& d)
  {
    Base::operator=(d);
    additional_ = d.additional_;
    return *this;
  }
};</code>

Utilisation implicite

Fait intéressant, même sans définir explicitement les constructeurs et les opérateurs d'affectation, le compilateur peut les générer automatiquement. C'est le cas des classes avec un héritage simple et une personnalisation minimale.

<code class="cpp">class ImplicitBase { 
  int value_; 
  // No operator=() defined
};

class Derived : public ImplicitBase {
  const char* name_;
public:
  Derived& operator=(const Derived& d)
  {
    ImplicitBase::operator=(d); // Call compiler generated operator=
    name_ = strdup(d.name_);
    return *this;
  }
};  </code>

Par conséquent, lors de l'héritage d'une classe de base qui fournit un ensemble complet de constructeurs et un opérateur d'affectation, il est possible de les utiliser dans le classe dérivée sans avoir à les réécrire, tant qu'aucune fonctionnalité supplémentaire n'est requise dans ces fonctions.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!