Let op het gebruik van het trefwoord public terwijl je hond van dier erft.

class Dog : public Animal {...};

We kunnen ook de trefwoorden private . gebruiken en protected in plaats van public . We zullen leren over de verschillen tussen het gebruik van private , public en protected verderop in deze tutorial.

is-een relatie

Overerving is een is-een relatie . We gebruiken alleen overerving als een is-een relatie is aanwezig tussen de twee klassen.

Hier zijn enkele voorbeelden:

• Een auto is een voertuig.
• Sinaasappel is een vrucht.
• Een chirurg is een dokter.
• Een hond is een dier.

Voorbeeld 1:Eenvoudig voorbeeld van C++-overerving

// C++ program to demonstrate inheritance

#include <iostream>
using namespace std;

// base class
class Animal {

   public:
    void eat() {
        cout << "I can eat!" << endl;
    }

    void sleep() {
        cout << "I can sleep!" << endl;
    }
};

// derived class
class Dog : public Animal {
 
   public:
    void bark() {
        cout << "I can bark! Woof woof!!" << endl;
    }
};

int main() {
    // Create object of the Dog class
    Dog dog1;

    // Calling members of the base class
    dog1.eat();
    dog1.sleep();

    // Calling member of the derived class
    dog1.bark();

    return 0;
}

Uitvoer

I can eat!
I can sleep!
I can bark! Woof woof!!

Hier, hond1 (het object van afgeleide klasse Dog ) heeft toegang tot leden van de basisklasse Animal . Het is omdat Dog is overgenomen van Animal .

// Calling members of the Animal class
dog1.eat();
dog1.sleep();

C++ beveiligde leden

De toegangsmodifier protected is vooral relevant als het gaat om C++ overerving.

Zoals private leden, protected leden zijn buiten de klas niet toegankelijk. Ze zijn echter toegankelijk via afgeleide klassen en vriendenklassen/functies .

We hebben protected nodig leden als we de gegevens van een klasse willen verbergen, maar toch willen dat die gegevens worden overgenomen door de afgeleide klassen.

Raadpleeg onze C++ Access Modifiers-tutorial voor meer informatie over beveiligd.

Voorbeeld 2:C++ beveiligde leden

// C++ program to demonstrate protected members

#include <iostream>
#include <string>
using namespace std;

// base class
class Animal {

   private:
    string color;

   protected:
    string type;

   public:
    void eat() {
        cout << "I can eat!" << endl;
    }

    void sleep() {
        cout << "I can sleep!" << endl;
    }

    void setColor(string clr) {
        color = clr;
    }

    string getColor() {
        return color;
    }
};

// derived class
class Dog : public Animal {

   public:
    void setType(string tp) {
        type = tp;
    }

    void displayInfo(string c) {
        cout << "I am a " << type << endl;
        cout << "My color is " << c << endl;
    }

    void bark() {
        cout << "I can bark! Woof woof!!" << endl;
    }
};

int main() {
    // Create object of the Dog class
    Dog dog1;

    // Calling members of the base class
    dog1.eat();
    dog1.sleep();
    dog1.setColor("black");

    // Calling member of the derived class
    dog1.bark();
    dog1.setType("mammal");

    // Using getColor() of dog1 as argument
    // getColor() returns string data
    dog1.displayInfo(dog1.getColor());

    return 0;
}

Uitvoer

I can eat!
I can sleep!
I can bark! Woof woof!!
I am a mammal
My color is black

Hier, de variabele type is protected en is dus toegankelijk vanuit de afgeleide klasse Dog . We kunnen dit zien omdat we type hebben geïnitialiseerd in de Dog klasse met behulp van de functie setType() .

Aan de andere kant, de private variabele kleur kan niet worden geïnitialiseerd in Dog .

class Dog : public Animal {

    public:
      void setColor(string clr) {
          // Error: member "Animal::color" is inaccessible
          color = clr; 
      }
};

Ook, aangezien de protected zoekwoord verbergt gegevens, we hebben geen toegang tot type rechtstreeks van een object van Dog of Animal klasse.

// Error: member "Animal::type" is inaccessible
dog1.type = "mammal";

Toegangsmodi in C++ Overerving

In onze vorige tutorials hebben we geleerd over C++-toegangsspecificaties zoals openbaar, privé en beveiligd.

Tot nu toe hebben we de public . gebruikt trefwoord om een ​​klasse te erven van een eerder bestaande basisklasse. We kunnen echter ook de private . gebruiken en protected trefwoorden om klassen te erven. Bijvoorbeeld,

class Animal {
    // code
};

class Dog : private Animal {
    // code
};

class Cat : protected Animal {
    // code
};

De verschillende manieren waarop we klassen kunnen afleiden, staan ​​bekend als toegangsmodi . Deze toegangsmodi hebben het volgende effect:

1. openbaar: Als een afgeleide klasse wordt gedeclareerd in public modus, dan worden de leden van de basisklasse geërfd door de afgeleide klasse zoals ze zijn.
2. privé: In dit geval worden alle leden van de basisklasse private leden in de afgeleide klasse.
3. beschermd: De public leden van de basisklasse worden protected leden in de afgeleide klasse.

De private leden van de basisklasse zijn altijd private in de afgeleide klasse.

Ga voor meer informatie naar onze C++ openbare, privé, beschermde overervingshandleiding.

Lidfunctie overschrijven in overerving

Stel dat de basisklasse en de afgeleide klasse lidfuncties hebben met dezelfde naam en argumenten.

Als we een object van de afgeleide klasse maken en proberen toegang te krijgen tot die lidfunctie, wordt de lidfunctie in de afgeleide klasse aangeroepen in plaats van die in de basisklasse.

De lidfunctie van de afgeleide klasse overschrijft de lidfunctie van de basisklasse.

Meer informatie over het overschrijven van functies in C++.

Aanbevolen literatuur: C++ meervoudige overerving