Beim Überschreiben von Funktionen definiert die untergeordnete Klasse die Funktion neu, die bereits in ihrer übergeordneten Klasse definiert ist.
Es ermöglicht dem Programmierer, abgeleitete klassenspezifische Funktionalität bereitzustellen (obwohl sie in der Basisklasse definiert ist).
Nun werden wir einige Beispiele sehen und das Konzept der Funktionsüberschreibung in C++ verstehen.
Beispiel 1
Ich habe im folgenden Beispielcode zwei Klassen definiert – eine Basisklasse und eine abgeleitete Klasse. Die Basisklasse hat eine Memberfunktion, d. h. disp(). Die Derived_Class wird von der Base_Class geerbt. Die Funktion disp() ist in Base_Class vorhanden und wird dann in Derived_Class neu definiert.
In der Funktion main() wird ein Objekt von Derived_Class, d. h. d, erstellt. Dann rufen wir die Funktion disp() für das abgeleitete Klassenobjekt auf, damit die Funktion in der abgeleiteten Klasse aufgerufen wird. Die Basisklassenversion wird hier ignoriert. Unten sehen Sie die Ausgabe als – disp() Funktion in der abgeleiteten Klasse.
#enthaltenmit namespace std;
//Basisklasse
Klasse Base_Class
{
öffentlich:
Leerein Anspruch nehmen()
{
Kosten<< 'disp()-Funktion in Basisklasse.' <<endl;
}
};
//abgeleitete Klasse
Klasse Derived_Class:öffentliche Base_Class
{
öffentlich:
Leerein Anspruch nehmen()
{
Kosten<< 'disp() Funktion in abgeleiteter Klasse' <<endl;
}
};
inthauptsächlich()
{
Abgeleitete_Klasse d;
D.in Anspruch nehmen(); //disp()-Funktion für abgeleitetes Klassenobjekt
Rückkehr 0;
}
Beispiel-2
In diesem Beispiel werden wir sehen, wie die Basisklassenversion der Funktion über das abgeleitete Klassenobjekt absichtlich aufgerufen wird. In der Funktionsdefinition der abgeleiteten Klasse verwenden wir den Bereichsauflösungsoperator [::], um die Basisklassenversion der Funktion aufzurufen.
#enthaltenmit namespace std;
Klasse Base_Class
{
öffentlich:
Leerein Anspruch nehmen()
{
Kosten<< 'disp()-Funktion in Basisklasse.' <<endl;
}
};
Klasse Derived_Class:öffentliche Base_Class
{
öffentlich:
Leerein Anspruch nehmen()
{
Basis_Klasse::in Anspruch nehmen(); //Rufe die Basisklassenversion von disp() auf
}
};
inthauptsächlich()
{
Abgeleitete_Klasse d;
D.in Anspruch nehmen();
Rückkehr 0;
}
Beispiel-3
Dies ist ein weiteres Beispiel für das Überschreiben von Funktionen. In diesem Beispiel haben wir eine Elternklasse – Animal und zwei abgeleitete Klassen – Duck und Dog erstellt. Die Basisklasse, d. h. die Klasse Animal, hat eine Memberfunktion sound().
In der abgeleiteten Klasse/Kindklasse, d. h. Dog, haben wir dieselbe Funktion, d. h. sound(), neu definiert, um ihre Basisklassendefinition zu überschreiben. In ähnlicher Weise haben wir in der anderen abgeleiteten Klasse, d. h. Duck, dieselbe Funktion, d. h. sound(), neu definiert.
In der Funktion main() haben wir das Hundeobjekt von Dog and duck of Duck erstellt. Wenn wir nun also die Funktion sound() für Hund und Ente aufrufen, wird die abgeleitete Klassenversion der Funktion sound() aufgerufen. Sie können die Ausgabe des Programms wie unten gezeigt sehen. Mit Hilfe des Funktionsüberschreibens können wir also die abgeleitete klassenspezifische Funktion aufrufen.
#enthaltenmit namespace std;
Klasse Tier
{
öffentlich:
LeereKlang()
{
Kosten<< 'Tierklang!' <<endl;
}
};
//Abgeleitete Klasse – Hundeklasse
Klasse Hund:öffentliches Tier
{
öffentlich:
LeereKlang()
{
Kosten<< 'Hundegeräusch - bellen.' <<endl;
}
};
//Abgeleitete Klasse – Entenklasse
Klasse Ente:öffentliches Tier
{
öffentlich:
LeereKlang()
{
Kosten<< 'Entengeräusch - Quacksalber.' <<endl;
}
};
inthauptsächlich()
{
Hund Hund;
Ente Ente;
Hund.Klang(); //sound() des Hundes
Ente.Klang(); //Sound() von Ente
Rückkehr 0;
}
Abschluss
In diesem Artikel habe ich das Überschreiben von Funktionen in . erklärt C++ . Die Sprache C++ unterstützt Laufzeitpolymorphismus. Das Überschreiben von Funktionen hilft, den Laufzeitpolymorphismus in C++ zu erreichen. In diesem Artikel wurde das Konzept des Überschreibens von Funktionen und das Erzielen von Laufzeitpolymorphismus mithilfe des Überschreibens von Funktionen untersucht.