C/C++ Schritt-für-Schritt - Seite 14

14. Schritt-für-Schritt C/C++ — C++ Programmierung - Vererbung

Vererbung

| | Einführung
Abgeleitete Klasse und Basis Klasse
Spezifizierung der Abgeleiteten Klasse
Abgeleitete Klassenkonstruktoren
Zugriffsmodifizierer
Öffentlich
Privat
Geschützt
Zugriffsmodifizierer ohne Vererbung
Geschützter Zugriffsmodifizierer
Geltungsbereich der Zugriffsmodifizierer
Zugriffsmodifizierer mit Vererbung
Arten der Vererbung
Einfache Vererbung
Mehrfache Vererbung
Mehrstufige Vererbung
Hybride Vererbung
Hierarchische Vererbung |

Einführung

Vererbung ist das leistungsstärkste Merkmal der objektorientierten Programmierung. Vererbung ist der Prozess, neue Klassen zu erstellen, die als abgeleitete Klassen von bestehenden oder Basisklassen bezeichnet werden. Die abgeleitete Klasse erbt alle Fähigkeiten der Basis Klasse, kann jedoch eigene Verzierungen und Verfeinerungen hinzufügen.
Eine Klasse, die als abgeleitete Klasse bezeichnet wird, kann die Merkmale einer anderen Klasse, die als Basis Klasse bezeichnet wird, erben.

Die Eigenschaften der Basis Klasse an die abgeleitete Klasse zu vererben, wird als Vererbung bezeichnet .
Das Substantiv dazu ist Erbe. Wir wissen aus unserem täglichen Leben, dass wir das Konzept von Klassen, die in Unterklassen abgeleitet werden, verwenden. Zum Beispiel ist das Fahrzeug eine Klasse, die wiederum in Fahrräder, Motorräder, Autos, Lastwagen, Busse usw. unterteilt ist.

Hier ist das Fahrzeug als Basis Klasse bekannt und die abgeleiteten Elemente sind als abgeleitete Klassen oder Unterklassen bekannt. **

Im Allgemeinen hat jede Basis Klasse eine Liste von Eigenschaften und Merkmalen. Das Hauptthema dieser Vererbung besteht darin, alle gemeinsamen Merkmale der Basis Klasse an die abgeleiteten Klassen weiterzugeben.

| | |

Vererbung hat ein wichtiges Merkmal, das die Wiederverwendbarkeit ermöglicht. Ein Ergebnis der Wiederverwendbarkeit ist die einfache Verteilung von Klassenbibliotheken. Ein Programmierer kann eine von einer anderen Person oder Firma erstellte Klasse verwenden und, ohne sie zu ändern, andere Klassen daraus ableiten, die für bestimmte Situationen geeignet sind.

Abgeleitete Klasse und Basis Klasse

Eine Klasse, die als abgeleitete Klasse bezeichnet wird, kann die Merkmale einer anderen Klasse, die als Basis Klasse bezeichnet wird, erben.
Die abgeleitete Klasse kann weitere eigene Merkmale hinzufügen, sodass sie eine spezialisierte Version der Basis Klasse wird.
Vererbung bietet eine leistungsstarke Möglichkeit, die Fähigkeiten bestehender Klassen zu erweitern und Programme unter Verwendung hierarchischer Beziehungen zu entwerfen.

Die Zugänglichkeit von Mitgliedern der Basis Klasse aus abgeleiteten Klassen und von Objekten abgeleiteter Klassen ist ein wichtiges Thema. Objekte abgeleiteter Klassen können auf Daten oder Funktionen in der Basis Klasse zugreifen, die mit dem Schlüsselwort geschützt vor abgeleiteten Klassen, jedoch nicht. Klassen können öffentlich privat von Basis Klassen abgeleitet werden.
Objekte einer öffentlich abgeleiteten Klasse können auf öffentliche Mitglieder der Basis Klasse zugreifen, während Objekte einer privat abgeleiteten Klasse dies nicht können.

Diagramm zeigt, wie die abgeleitete Klasse erbt.

| | |

Eine Klasse kann von mehr als einer Basis Klasse abgeleitet werden. Dies wird als mehrfache Vererbung bezeichnet. Eine Klasse kann auch innerhalb einer anderen Klasse enthalten sein.

Spezifizierung der Abgeleiteten Klasse

Die Klassendeklaration ist so einfach mit dem Schlüsselwort class, ebenso ist die Deklaration der abgeleiteten Klasse einfach, aber die Klasse muss mit ihrer Basis Klassen-ID und dem Zugriffsmodifizierer enden.
Syntax zur Deklaration einer abgeleiteten Klasse:

Klasse lass_name>: ….

Für z.B. class result : public stud;

| | /  Programm zur Annahme und Anzeige eines Studentenregisters  /
#include
using namespace std;
class add
{
private :
char str[20];
char city[20];
int pin;
public :
void get_add()
{
cout << “Geben Sie Adresse  Straße, Stadt, PIN ein”;
cin >> street >>city>>pin;
}
void put_data()
{
cout << “Adresse ist   “ << str
<}
};
class stud  : public add
{
private :
int sno;
char name[20];
int m1,m2,m3;
public :
void get_data()
{
cout << “Geben Sie die Studentennummer ein.  “; cin >> sno;
cout << “Geben Sie den Studentennamen ein.  “; cin >> name;
cout << “Geben Sie die Noten für 3 Fächer ein.  “;
cin >> m1 << m2 << m3;
}
void put_data()
{
cout  << “Studentennummer  :” << sno;
cout << “Studentenname      :” << name;
cout << “Studentennoten     :” << m1 << “  “ <}
};
int main()
{
stud s;
s.get_add();
s.get_data();
s.put_add();
s.put_data();
return 0;
} |

Diagrammatische Erklärung für das obige Programm

| | |

Abgeleitete Klassenkonstruktoren

Wenn eine Klasse mit ihren eigenen Konstruktoren deklariert wird, ist sie eine Basis Klasse einer anderen. Die abgeleitete Klasse hat auch ihre eigenen Konstruktoren. Wenn ein Objekt deklariert wird, welcher Konstruktor wird ausgeführt?   Es besteht kein Zweifel, dass der Konstruktor der abgeleiteten Klasse ausgeführt wird.  Wenn Sie dennoch den Konstruktor der Basis Klasse oder sowohl die Konstruktoren der abgeleiteten als auch der Basis Klasse ausführen möchten, rufen Sie einfach den Basis-Konstruktor im Konstruktor der abgeleiteten Klasse auf.

| | / Konstruktoren in der abgeleiteten Klasse /
#include
using namespace std;
class Add
{
protected :                                // HINWEIS : nicht privat
unsigned int a;
public :
Add()  {  a = 0; }                  // Konstruktor, keine Argumente
Add( int c ) { a = c; }             // Konstruktor, ein Argument
int get_val(){     return a; }      // gibt den Wert A zurück
Add operator ++ ()                  // Zähler erhöhen
{
a++;                           // Zähler erhöhen, zurückgeben
return Add(a);                 // ein unnamed temporäres Objekt
}                                   // initialisiert auf diesen Zähler
};

class Sub : public Add
{
public:
Sub() : Add() { }                     // Konstruktor, keine Argumente
Sub(int c) : Add(c) { }               // Konstruktor, ein Argument
Sub operator – ()                    // Wert von A verringern, zurückgeben
{                                     // ein unnamed temporäres Objekt
a–;                             // initialisiert auf diesen Wert
return Sub(a);
}
};
int main()
{
Sub ob1;                                  // Klasse Sub
Sub ob2(100);
cout << “\nOb1  =” << ob1.get_val();      // anzeigen
cout << “\nOb2  =” << ob2.get_val();      // anzeigen
ob1++; ob1++; ob1++;                      // ob1 erhöhen
cout << “\nOb1  =” << ob1.get_val();      // anzeigen
ob2–; ob2–;                             // ob2 verringern
cout << “\nOb2  =” << ob2.get_val();      // anzeigen
Sub ob3=ob2–;                            // ob3 aus ob2 erstellen
cout << “\nOb3  =” << ob3.get_val();      // anzeigen
return 0;
} |

ZUGRIFFSMODIFIZIERER

Zugriffsmodifizierer werden verwendet, um sowohl Daten als auch Mitgliedsfunktionen zu steuern, zu verbergen und zu sichern.  Zugriffsmodifizierer sind in 3 Typen unterteilt

1. Öffentlicher Zugriffsmodifizierer
2. Privater Zugriffsmodifizierer
3. Geschützter Zugriffsmodifizierer.

Öffentlich :

| | Wenn ein Mitglied oder eine Daten öffentlich ist, kann es von jeder Funktion innerhalb der Klasse und auch von ihren abgeleiteten Klassen verwendet werden.
In C++ sind Mitglieder einer struct oder union standardmäßig öffentlich.
Öffentliche Mitglieder einer Klasse können an die abgeleitete Klasse vererbt werden, wenn die Klasse öffentlich vererbt wird, jedoch nicht die Mitgliedsfunktionen (privat). |

Privat :

| | Mitgliedsfunktionen und Freunde der Klasse, in der sie deklariert sind, können sie nur verwenden.
Mitglieder einer Klasse sind standardmäßig privat.
Private Mitglieder einer Klasse werden nicht an eine abgeleitete Klasse vererbt, wenn die Basis Klasse öffentlich oder privat vererbt wird. Wenn es erforderlich ist, müssen wir Mitgliedsfunktionen schreiben, die diese Werte zurückgeben. |

Geschützt :

| | Es ist der Zugriff wie bei privat, zusätzlich kann das Mitglied von Mitgliedsfunktionen und Freunden von Klassen, die von der deklarierten Klasse abgeleitet sind, verwendet werden, jedoch nicht nur in Objekten des abgeleiteten Typs.
Das geschützte Mitglied einer Klasse kann nur an die nächste abgeleitete Klasse vererbt werden. Aber nicht an die späteren Klassen. |

Zugriffsmodifizierer ohne Vererbung

| | |

Mehr über geschützten Zugriffsmodifizierer

Um die Funktionalität bereitzustellen, ohne die Klasse zu ändern. Geschützt kann nur von sich selbst und von abgeleiteten Klassen geschützten Mitgliedern, jedoch nicht in Objekten oder der untergeordneten Klasse oder der Außenklasse, zugegriffen werden.

Geltungsbereich der Zugriffsmodifizierer

| Zugriffs modifizierer | Zugänglich von
eigener Klasse | Zugänglich von
abgeleiteter Klasse | Zugänglich von
Objekten außerhalb der Klasse | | Öffentlich | Ja | Ja | Ja | | Geschützt | Ja | Ja | Nein | | Privat | Ja | Nein | Nein |

Zugriffsmodifizierer mit Vererbung

| | |

Arten der Vererbung

| | |

| | |

| | / Programm zur Demonstration der Mehrfachvererbung /
#include
using namespace std;
class M
{
protected :
int m;
public :
void getm()
{
cout << “\nGeben Sie den M-Wert ein  :”;
cin >> m;
}
};
class N
{
protected :
int n;
public :
void getn()
{
cout << “\nGeben Sie den N-Wert ein  :”;
cin >> n;
}
};
class P : public N, public M
{
public :
void disp()
{
cout << “\n  M   =  “ << m;
cout << “\n  N   =  “ << n;
cout << “\n  MN =  “ << mn;
}
};
int main()
{
P p;
p.getm();
p.getn();
p.disp();
return 0;
} |

Wenn eine Basis Klasse öffentlich vererbt wird, können die öffentlichen Mitglieder, Mitgliedsfunktionen von den Mitgliedsfunktionen der abgeleiteten Klasse und auch von den Objekten zugegriffen werden, während wenn eine Basis Klasse privat vererbt wird, die öffentlichen Mitglieder der Basis Klasse nur an die Mitgliedsfunktionen der abgeleiteten Klasse vererbt werden, jedoch nicht an die Objekte.

| | / Ein Programm zur Demonstration der mehrstufigen Vererbung /
class student
{
int rno;
public:
void getrno()
{
cout << “Geben Sie  Nummer ein :”;
cin >> rno;
}
void showrno()
{
cout << “Studentennummer:” << rno;
}
};
class test : public student
{
int m1,m2;
public :
void getmarks()
{
cout << “Geben Sie Noten 1  ein :