Comment les classes dérivées peuvent-elles tirer parti des constructeurs de classes de base et des opérateurs d'affectation ?

Utilisation de constructeurs de classe de base et d'un opérateur d'affectation dans les classes dérivées

En C, l'héritage permet aux classes dérivées d'hériter de certaines fonctionnalités de leurs classes de base. Toutefois, si une classe dérivée nécessite le même ensemble de constructeurs et d'opérateurs d'affectation que sa classe de base, il peut être nécessaire de réécrire ces fonctions dans la classe dérivée. Cela peut être une tâche fastidieuse, en particulier pour les opérateurs d'affectation qui nécessitent un accès aux variables membres privées.

Heureusement, il existe une solution alternative. Les classes dérivées peuvent appeler explicitement des constructeurs de classes de base et des opérateurs d'affectation. Cette technique leur permet d'utiliser l'implémentation existante sans avoir à la réécrire.

Considérez l'exemple de code suivant :

<code class="cpp">class Base {
public:
    Base();
    Base(const string& s);
    Base(const Base& b) { (*this) = b; }
    Base& operator=(const Base & b);

private:
    // ... (private member variables and functions)
};

class Derived : public Base {
public:
    // Override the "foo" function without modifying other aspects of the base class
    virtual void foo() override;
};</code>

Dans cet exemple, Derived hérite des constructeurs et de l'opérateur d'affectation de Base. Il n’est pas nécessaire de définir explicitement ces fonctions. Au lieu de cela, lors de la construction d'un objet dérivé ou de l'affectation d'un objet de base à un objet dérivé, le compilateur appelle automatiquement le constructeur de classe de base ou l'opérateur d'affectation approprié.

La même stratégie peut être utilisée pour les opérateurs d'affectation :

<code class="cpp">class Base {
public:
    // ... (private member variables and functions)
    Base(const Base& b) { /* ... */ }
    Base& operator=(const Base& b) { /* ... */ }
};

class Derived : public Base {
public:
    int additional_;

    // Call the base assignment operator within the derived operator
    Derived& operator=(const Derived& d) {
        Base::operator=(d);
        additional_ = d.additional_;
        return *this;
    }
};</code>

Cette technique permet aux classes dérivées d'utiliser pleinement les fonctionnalités de leurs classes de base tout en remplaçant ou en ajoutant uniquement les comportements nécessaires. Il simplifie l'héritage en éliminant le besoin de réécrire des constructeurs de classes de base complexes ou des opérateurs d'affectation.

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!