Vererbung ist ein grundlegendes Konzept in OOP (Objektorientierte Programmierung) . Dabei handelt es sich um den Mechanismus, der es einer Klasse ermöglicht, die Funktionen (Felder und Methoden) einer anderen Klasse zu erben. Unter Vererbung versteht man die Erstellung neuer Klassen auf Basis vorhandener Klassen. Eine Klasse, die von einer anderen Klasse erbt, kann die Methoden und Felder dieser Klasse wiederverwenden.

Beispiel: Im folgenden Beispiel ist Animal die Basisklasse und Dog Cat und Cow sind abgeleitete Klassen, die die Animal-Klasse erweitern.

   #include          using     namespace     std  ;   class     Animal   {      public  :      void     sound  ()      {      cout      < <     'Animal makes a sound'      < <     endl  ;      }   };   class     Dog     :     public     Animal   {      public  :      void     sound  ()      {      cout      < <     'Dog barks'      < <     endl  ;      }   };   class     Cat     :     public     Animal   {      public  :      void     sound  ()      {      cout      < <     'Cat meows'      < <     endl  ;      }   };   class     Cow     :     public     Animal   {      public  :      void     sound  ()      {      cout      < <     'Cow moos'      < <     endl  ;      }   };   int     main  ()   {      Dog     d  ;      d  .  sound  ();      Cat     c  ;      c  .  sound  ();      Cow     cow  ;      cow  .  sound  ();      return     0  ;   }   

Dog barks Cat meows Cow moos  

Erläuterung:

• Animal ist die Basisklasse mit einer Funktion sound().
• Dog Cat und Cow sind abgeleitete Klassen, die jeweils ihre eigene sound()-Methode definieren.
• In main() werden die Objekte Dog Cat und Cow separat erstellt.
• Wenn wir sound() für jedes Objekt aufrufen, wird die entsprechende untergeordnete Klassenmethode ausgeführt (Hund bellt, Katze miaut, Kuh muht).

Syntax

   class     ChildClass     :     public     ParentClass   {      // Additional fields and methods   };   

Wie funktioniert Vererbung in C++?

Der Doppelpunkt (:) mit einem Zugriffsspezifizierer wird zur Vererbung in C++ verwendet. Dadurch kann die abgeleitete Klasse (untergeordnete Klasse) die Datenelemente (Felder) und Elementfunktionen (Methoden) der Basisklasse (übergeordnete Klasse) erben.
Wenn eine Klasse eine andere Klasse erbt, erhält sie alle zugänglichen Mitglieder der übergeordneten Klasse und die untergeordnete Klasse kann sie auch neu definieren (überschreiben) oder neue Funktionen hinzufügen.

Arten der Vererbung in C++

Nachfolgend sind die verschiedenen Arten der Vererbung aufgeführt, die von C++ unterstützt werden.

1. Einzelvererbung

Bei der Einzelvererbung wird eine Unterklasse von nur einer Oberklasse abgeleitet. Sie erbt die Eigenschaften und das Verhalten einer Single-Parent-Klasse. Manchmal wird es auch als einfache Vererbung bezeichnet.

   #include          using     namespace     std  ;   class     Vehicle     {   public  :      Vehicle  ()     {      cout      < <     'This is a Vehicle'      < <     endl  ;      }   };   class     Car     :     public     Vehicle     {   public  :      Car  ()     {      cout      < <     'This Vehicle is Car'      < <     endl  ;      }   };   int     main  ()     {          Car     obj  ;      return     0  ;   }   

This is a Vehicle This Vehicle is Car  

2. Mehrfachvererbung

In Mehrfachvererbung Eine Klasse kann mehr als eine Oberklasse haben und Funktionen von allen übergeordneten Klassen erben.

   #include          using     namespace     std  ;   class     LandVehicle   {      public  :      void     landInfo  ()      {      cout      < <     'This is a LandVehicle'      < <     endl  ;      }   };   class     WaterVehicle   {      public  :      void     waterInfo  ()      {      cout      < <     'This is a WaterVehicle'      < <     endl  ;      }   };   // Derived class inheriting from both base classes   class     AmphibiousVehicle     :     public     LandVehicle       public     WaterVehicle   {      public  :      AmphibiousVehicle  ()      {      cout      < <     'This is an AmphibiousVehicle'      < <     endl  ;      }   };   int     main  ()   {      AmphibiousVehicle     obj  ;      obj  .  waterInfo  ();      obj  .  landInfo  ();      return     0  ;   }   

This is an AmphibiousVehicle This is a WaterVehicle This is a LandVehicle  

3. Mehrstufige Vererbung

Mehrstufige Vererbung in C++ bedeutet, dass eine Klasse von einer anderen abgeleiteten Klasse abgeleitet wird und eine Vererbungskette bildet.

   #include          using     namespace     std  ;   class     Vehicle   {      public  :      Vehicle  ()      {      cout      < <     'This is a Vehicle'      < <     endl  ;      }   };   // Derived class from Vehicle   class     FourWheeler     :     public     Vehicle   {      public  :      FourWheeler  ()      {      cout      < <     '4 Wheeler Vehicles'      < <     endl  ;      }   };   // Derived class from FourWheeler   class     Car     :     public     FourWheeler   {      public  :      Car  ()      {      cout      < <     'This 4 Wheeler Vehicle is a Car'      < <     endl  ;      }   };   int     main  ()   {      Car     obj  ;      return     0  ;   }   

This is a Vehicle 4 Wheeler Vehicles This 4 Wheeler Vehicle is a Car  

4. Hierarchische Vererbung

Bei der hierarchischen Vererbung wird mehr als eine Unterklasse von einer einzelnen Basisklasse geerbt. d. h. es wird mehr als eine abgeleitete Klasse aus einer einzelnen Basisklasse erstellt. Zum Beispiel sind sowohl Autos als auch Busse Fahrzeuge.

   #include          using     namespace     std  ;   class     Vehicle   {      public  :      Vehicle  ()      {      cout      < <     'This is a Vehicle'      < <     endl  ;      }   };   class     Car     :     public     Vehicle   {      public  :      Car  ()      {      cout      < <     'This Vehicle is Car'      < <     endl  ;      }   };   class     Bus     :     public     Vehicle   {      public  :      Bus  ()      {      cout      < <     'This Vehicle is Bus'      < <     endl  ;      }   };   int     main  ()   {      Car     obj1  ;      Bus     obj2  ;      return     0  ;   }   

This is a Vehicle This Vehicle is Car This is a Vehicle This Vehicle is Bus  

5. Hybride Vererbung

Wenn zwei oder mehr Vererbungsarten in einem Programm kombiniert werden. Beispielsweise könnte eine Klasse Mehrfachvererbung nutzen und auch Teil einer mehrstufigen Vererbungskette sein.

   #include          using     namespace     std  ;   class     Vehicle   {      public  :      Vehicle  ()      {      cout      < <     'This is a Vehicle'      < <     endl  ;      }   };   class     Fare   {      public  :      Fare  ()      {      cout      < <     'Fare of Vehicle'      < <     endl  ;      }   };   class     Car     :     public     Vehicle   {      public  :      Car  ()      {      cout      < <     'This Vehical is a Car'      < <     endl  ;      }   };   class     Bus     :     public     Vehicle       public     Fare   {      public  :      Bus  ()      {      cout      < <     'This Vehicle is a Bus with Fare'  ;      }   };   int     main  ()   {      Bus     obj2  ;      return     0  ;   }   

This is a Vehicle Fare of Vehicle This Vehicle is a Bus with Fare 

Hybride Vererbung kann dazu führen Diamantproblem in C++. Dies geschieht, wenn eine Klasse von zwei Klassen erbt, die beide dieselbe Basisklasse verwenden. Infolgedessen erhält die abgeleitete Klasse mehrere Kopien der Basisklassenmitglieder, was zu Unklarheiten darüber führt, welches davon verwendet werden soll.

Notiz : Die Lösung besteht darin, virtuelle Vererbung zu verwenden, sodass nur eine einzige Kopie der Basisklasse gemeinsam genutzt wird.

Vorteile der Vererbung in C++

• Wiederverwendbarkeit des Codes : Eine abgeleitete Klasse kann Datenelemente und Methoden ihrer Basisklasse direkt wiederverwenden und so Codeduplizierung vermeiden.
• Abstraktion: Unterstützt abstrakte Klassen (Klassen mit rein virtuellen Funktionen), die eine gemeinsame Schnittstelle definieren und so die Abstraktion erzwingen.
• Klassenhierarchie: Sie können Hierarchien erstellen (Basis → abgeleitet → weiter abgeleitet), um reale Beziehungen zu modellieren.
• Polymorphismus: Unterstützt vollständig Laufzeitpolymorphismus durch virtuelle Funktionen und auch Kompilierzeitpolymorphismus durch Funktionsüberladung und Vorlagen.

Nachteile der Vererbung in C++

• Enge Kopplung: Die untergeordnete Klasse wird von der übergeordneten Klasse abhängig. Jede Änderung in der Basisklasse kann Änderungen in abgeleiteten Klassen erzwingen.
• Reduzierte Flexibilität: Manchmal wird die Vererbung missbraucht, wenn die Zusammensetzung (hat-eine-Beziehung) besser wäre, was zu weniger flexiblem Code führt.
• Erhöhte Komplexität: Tiefe Vererbungshierarchien (mehrstufig oder hybrid) können dazu führen, dass der Code schwer zu verstehen, zu warten und zu debuggen ist.
• Diamantproblem: Bei Hybrid- oder Mehrfachvererbung kann es zu Mehrdeutigkeiten kommen, wenn dieselbe Basisklasse mehrmals vererbt wird.
• Overhead virtueller Funktionen: Wenn Polymorphismus (virtuelle Funktionen) verwendet wird, entsteht aufgrund der Suche in virtuellen Tabellen ein geringer Laufzeitaufwand.