Vererbung von C++-Unterklassen

1. Vererbung von C++-Unterklassen
2. Mehrfachvererbung in Unterklasse in C++
3. Hierarchische Vererbung in Unterklassen in C++
4. Das Diamond-Problem bei der Vererbung in C++
5. Abschluss

Vererbung ist ein Merkmal von OOP, bei dem eine Klasse die Eigenschaften und das Verhalten einer anderen Klasse erwirbt. Eine Klasse, die eine andere Klasse erbt, wird als Unterklasse bezeichnet, während die Klasse, deren Eigenschaften geerbt werden, als Basisklasse bezeichnet wird.

In diesem Artikel wird das Rautenproblem erläutert, das beim Vererben der Klassen auftritt.

Vererbung von C++-Unterklassen

Vererbung ist eine Funktion, die es einer Klasse ermöglicht, die Eigenschaften einer anderen Klasse zu erben. Die Klasse, die die Eigenschaften einer anderen Klasse erbt, wird als Unterklasse oder abgeleitete Klasse bezeichnet, während die Klasse, deren Eigenschaften geerbt werden, als Basisklasse oder Elternklasse bezeichnet wird.

Ein reales Beispiel für Vererbung kann ein Kind sein, das die Eigenschaften seiner Eltern erbt.

In C++ gibt es hauptsächlich fünf Arten der Vererbung, nämlich Einfachvererbung, Mehrfachvererbung, Vererbung auf mehreren Ebenen, hierarchische Vererbung und Hybridvererbung.

1. Einzelvererbung – Bei dieser Art der Vererbung erbt eine einzelne Unterklasse von einer einzelnen Basisklasse.
2. Mehrfachvererbung – Bei dieser Art der Vererbung wird die Unterklasse von mehr als einer Basisklasse geerbt.
3. Hierarchische Vererbung – Bei dieser Art der Vererbung werden mehrere Unterklassen von derselben Basisklasse geerbt.
4. Vererbung auf mehreren Ebenen – Bei dieser Art der Vererbung wird eine Klasse von einer anderen Klasse geerbt, die wiederum auch von einer anderen Klasse geerbt wird. Zum Beispiel haben wir drei Klassen, A, B und C, in denen die Klasse C von der Klasse B geerbt wird und die Klasse B von der Klasse A geerbt wird.
5. Hybridvererbung – Bei dieser Art der Vererbung wird mehr als eine Vererbungsart kombiniert.

Wir werden zuerst über die mehrfache und hierarchische Vererbung in C++ sprechen.

Mehrfachvererbung in Unterklasse in C++

Wie zuvor beschrieben, wird eine Unterklasse bei mehreren Vererbungen von mehreren anderen Basisklassen geerbt. Nehmen wir ein Beispiel, um die Mehrfachvererbung im Detail zu verstehen.

#include <iostream>
using namespace std;
class Base1 {
 public:
  Base1() { cout << "Base class 1" << endl; }
};

class Base2 {
 public:
  Base2() { cout << "Base class 2" << endl; }
};

class Derived : public Base2, public Base1 {
 public:
  Derived() { cout << "Derived class" << endl; }
};

int main() {
  Derived d;
  return 0;
}

Ausgang:

Base class 2
Base class 1
Derived class

Der obige Code hat zwei Basisklassen, Base1 und Base2, von denen die Klasse Derived geerbt wird. Beachten Sie jedoch die Reihenfolge, in der die Konstruktoren der Basisklassen aufgerufen werden.

Zuerst wird der Klassenkonstruktor Base2 aufgerufen, weil ihn zuerst die Klasse Derived erbt und dann der Konstruktor Base1.

Hierarchische Vererbung in Unterklassen in C++

Wie zuvor beschrieben, werden bei der hierarchischen Vererbung mehrere Unterklassen von einer einzigen Basisklasse geerbt. Nehmen wir ein Beispiel, um die hierarchische Vererbung im Detail zu verstehen.

#include <iostream>
using namespace std;
class Base {
 public:
  Base() { cout << "Base class" << endl; }
};

class Derived1 : public Base {
 public:
  Derived1() { cout << "Derived class 1" << endl; }
};

class Derived2 : public Base {
 public:
  Derived2() { cout << "Derived class 2" << endl; }
};

int main() {
  Derived1 d1;
  Derived2 d2;
  return 0;
}

Ausgang:

Base class
Derived class 1
Base class
Derived class 2

Das obige Codebeispiel hat drei Klassen, in denen die Klassen Derived1 und Derived2 von der gemeinsamen Base-Klasse geerbt werden.

Das Diamond-Problem bei der Vererbung in C++

Das Rautenproblem tritt auf, wenn wir die hierarchische und die mehrfache Vererbung kombinieren. Dieses Problem wird so genannt, weil die Klassen eine Rautenform bilden, während sie sich gegenseitig erben.

Nehmen wir an, wir haben ein Szenario, in dem wir vier Klassen A, B, C und D haben.

1. Klasse A fungiert als Basisklasse.
2. Klasse B wird von Klasse A vererbt.
3. Die Klasse C wird auch von der Klasse A vererbt.
4. Die Klasse D wird sowohl von der Klasse B als auch von der Klasse C vererbt.

Lassen Sie uns nun das Problem sehen, das mit Hilfe eines Codes auftritt.

#include <iostream>
using namespace std;
class A {
 public:
  A() { cout << "Constructor A here!" << endl; }
};

class B : public A {
 public:
  B() { cout << "Constructor B here!" << endl; }
};

class C : public A {
 public:
  C() { cout << "Constructor C here!" << endl; }
};

class D : public B, public C {
 public:
  D() { cout << "Constructor D here!" << endl; }
};

int main() {
  D d;
  return 0;
}

Ausgang:

Constructor A here!
Constructor B here!
Constructor A here!
Constructor C here!
Constructor D here!

Die obige Ausgabe zeigt, dass der Konstruktor der Klasse A zweimal aufgerufen wurde, da die Klasse D zwei Kopien der Klasse A erhält. Einer durch Erben der Klasse B und der andere durch Erben der Klasse C.

Dies führt zu Mehrdeutigkeiten und wird in C++ als Diamantproblem bezeichnet.

Dieses Problem tritt hauptsächlich auf, wenn eine Klasse von mehreren Basisklassen erbt, die von einer gemeinsamen Basisklasse geerbt wurden.

Dieses Problem kann jedoch mit dem Schlüsselwort virtual in C++ gelöst werden. Wir lassen die Zwei-Eltern-Klassen von derselben Basisklasse wie virtuelle Klassen erben, sodass die Kindklasse nicht zwei Kopien der gemeinsamen Großelternklasse erhält.

Daher machen wir in unserem Codebeispiel die Klasse B und die Klasse C zu virtuellen Klassen.

Sehen wir uns die Lösung dieses Problems anhand eines Codebeispiels an.

#include <iostream>
using namespace std;
class A {
 public:
  A() { cout << "Constructor A here!" << endl; }
};

class B : virtual public A {
 public:
  B() { cout << "Constructor B here!" << endl; }
};

class C : virtual public A {
 public:
  C() { cout << "Constructor C here!" << endl; }
};

class D : public B, public C {
 public:
  D() { cout << "Constructor D here!" << endl; }
};

int main() {
  D d;
  return 0;
}

Ausgang:

Constructor A here!
Constructor B here!
Constructor C here!
Constructor D here!

Daher erhalten wir, wie in der obigen Ausgabe gezeigt, jetzt nur eine Kopie des Konstruktors der Klasse A. Das Schlüsselwort virtual teilt dem Compiler mit, dass sowohl die Klasse B als auch die Klasse C von derselben Basisklasse A erben; Daher sollte es nur einmal aufgerufen werden.

Abschluss

In diesem Artikel haben wir uns kurz mit der Vererbung und den Vererbungsarten befasst. Wir haben jedoch hauptsächlich zwei Arten der Vererbung – mehrfache und hierarchische – im Detail diskutiert, was zu einem Problem führt, das als Diamantproblem bei der Vererbung bekannt ist.

Das Rautenproblem tritt auf, wenn eine Klasse von mehr als einer Basisklasse erbt, was auch von einer einzelnen Basisklasse geerbt wird. Dieses Problem wird jedoch mit dem Schlüsselwort virtual in C++ gelöst.