Empfohlen, 2022

Tipp Der Redaktion

Unterschied zwischen Überladen und Überschreiben von Funktionen in C ++

Polymorphismus ist eines der entscheidenden Merkmale von OOP. Es bedeutet einfach "einen Namen für mehrere Formulare verwenden". Polymorphismus kann mithilfe von 'Funktionsüberladung', 'Operatorüberladung' und 'virtueller Funktion' implementiert werden. Sowohl Überladen als auch Überschreiben implizieren das Konzept des Polymorphismus. "Überladen" ist hier der Kompilierzeitpolymorphismus und das "Überschreiben" ist der Laufzeitpolymorphismus. Studieren Sie weiter, wenn wir über den Hauptunterschied zwischen "Überladen" und "Überschreiben" sprechen. In 'Überladen' definieren wir die überladenen Funktionen mit demselben Funktionsnamen, aber unterschiedlicher Anzahl und Art von Parametern. Beim Überschreiben ist der Prototyp der überschriebenen Funktion im gesamten Programm gleich, aber der zu überschreibenden Funktion wird in der Basisklasse das Schlüsselwort "virtual" vorangestellt und die abgeleitete Klasse ohne Schlüsselwort neu definiert.

Des Weiteren untersuchen wir den Unterschied zwischen Überladen und Überschreiben mit Hilfe einer Vergleichstabelle.


Vergleichstabelle:

VergleichsgrundlageÜberlastungÜberschreiben
PrototypDer Prototyp unterscheidet sich je nach Anzahl oder Typ der Parameter.Alle Aspekte des Prototyps müssen identisch sein.
StichwortKein Schlüsselwort während Überladung angewendet.Der zu überschreibenden Funktion wird in der Basisklasse das Schlüsselwort 'virtual' vorangestellt.
UnterscheidungsfaktorDie Anzahl oder der Typ des Parameters unterscheidet sich, wodurch die Version der Funktion bestimmt wird.Welche Funktion der Klasse vom Zeiger aufgerufen wird, wird durch die Adresse des Objekts der Klasse bestimmt, das diesem Zeiger zugeordnet ist.
Muster definierenFunktion wird mit demselben Namen neu definiert, jedoch mit unterschiedlicher Nummer und Art des Parameters.Die Funktion wird definiert, das Schlüsselwort 'virtual' in der Hauptklasse wird vorangestellt und die abgeleitete Klasse mit dem Schlüsselwort out definiert.
Zeit der VollendungKompilierzeitLaufzeit
Konstruktor / virtuelle FunktionKonstruktoren können überladen werden.Virtuelle Funktionen können überschrieben werden.
Zerstörer
Destruktor kann nicht überladen werden.Destruktor kann überschrieben werden.
BindungDurch Überladen wird eine frühe Bindung erreicht.Überschreiben bezieht sich auf spätes Binden.

Definition von Überladung

Der Kompilierungspolymorphismus wird als "Überladung" bezeichnet. Da Überladung aus einem Konzept des Polymorphismus generiert wird, stellt dies „eine gemeinsame Schnittstelle für mehrere Methoden“ zur Verfügung. Das heißt, wenn eine Funktion überladen ist, enthält sie denselben Funktionsnamen, während sie neu definiert wird.

Überladene Funktionen unterscheiden sich in Bezug auf die 'Anzahl oder Art der Parameter', es unterscheidet eine überladene Funktion von einer anderen. Auf diese Weise erkennt der Compiler, welche überladene Funktion aufgerufen wird. Meist überladene Funktionen sind "Konstruktoren". "Konstruktor kopieren" ist eine Art "Konstruktorüberladung".

Implementierung der Überladung in C ++

 Klassenüberladung {int a, b; public: int load (int x) {// erste load () - Funktion a = x; Rückkehr a; } int load (int x, int y) {// second load () Funktion a = x; b = y; Rückgabe a * b; }}; int main () {Überladung O1; O1.Ladung (20); // erster load () Funktionsaufruf O1.load (20, 40); // zweiter Funktionsaufruf load ()} 

Hier wurde die Funktion load () der Klassenüberladung überladen. Die beiden überladenen Funktionen der Klasse können so unterschieden werden, dass die erste load () - Funktion nur einzelne Integer-Parameter akzeptiert, während die zweite load () - Funktion zwei Integer-Parameter akzeptiert. Wenn das Objekt der Klassenüberladung die load () - Funktion mit einem einzigen Parameter aufruft, wird die erste load () - Funktion aufgerufen. Wenn das Objekt die load () - Funktion mit zwei Parametern aufruft, wird die zweite load () - Funktion aufgerufen.

Definition von Überschreiben

Polymorphismus, der während der Laufzeit erreicht wird, wird als "Überschreiben" bezeichnet. Dies wird durch die Verwendung von "Vererbung" und "virtuellen Funktionen" erreicht. Die zu überschreibende Funktion wird in einer Basisklasse mit dem Schlüsselwort 'virtual' vorangestellt und in einer abgeleiteten Klasse ohne Schlüsselwort neu definiert.

Eine der wichtigsten Sachen, die Sie im Falle eines Überschreibens beachten sollten, ist, dass sich der Prototyp der überschriebenen Funktion nicht ändern darf, während die abgeleitete Klasse sie neu definiert. Wenn die überschriebene Funktion einen Aufruf erhält, bestimmt C ++, welche Version der Funktion aufgerufen wird, basierend auf dem 'Typ des Objekts, auf den ein Zeiger zeigt', mit dem der Funktionsaufruf ausgeführt wird.

Implementierung des Überschreibens in C ++

 class base {public: virtuelles void funct () {// virtuelle Funktion der Basisklasse cout << "Dies ist die Funktion einer Basisklasse ()"; }}; Klasse abgeleitet1: öffentliche Basis {public: void funct () {// Virtuelle Funktion der Basisklasse in abgeleiteter1 Klasse definiert cout << "Dies ist eine funct () - Klasse einer abgeleiteten1 Klasse"; }}; Klasse abgeleitete2: öffentliche Basis {public: void funct () {// virtuelle Funktion der Basisklasse in abgeleiteter2-Klasse cout neu definiert  funct (); // Aufruf an abgeleitete1-Klasse funct (). * p = & d2; p-> funct (); // Aufruf an abgeleitete2-Klassenfunktion (). 0 zurückgeben; } 

Hier gibt es eine einzelne Basisklasse, die von zwei abgeleiteten Klassen öffentlich vererbt wird. Eine virtuelle Funktion ist in einer Basisklasse mit dem Schlüsselwort 'virtual' definiert und wird von beiden abgeleiteten Klassen ohne Schlüsselwort neu definiert. In main () erstellt die Basisklasse eine Zeigervariable 'p' und ein Objekt 'b'. Die Klasse 'abgeleitete Klasse 1' erstellt ein Objekt d1 und die Klasse Abgeleitete2 ein Objekt d2 '.

Nun wird zunächst die Adresse des Basisklassenobjekts 'b' dem Zeiger der Basisklasse 'p' zugewiesen. 'p' ruft die Funktion funct () auf, also wird eine Funktion der Basisklasse aufgerufen. Dann wird die Adresse des abgeleiteten Klassenobjekts 'd1' dem Zeiger 'p' zugewiesen, und es wird wieder funct () aufgerufen. Hier wird die Funktion funct () der abgeleiteten Klasse ausgeführt. Schließlich wird der Zeiger 'p' dem Objekt der abgeleiteten Klasse zugeordnet. Dann ruft 'p' die Funktion funct () auf, die die Funktion func () der Klasse abgeleitete2 ausführt.

Wenn die abgeleitete1 / abgeleitete Klasse funct () nicht neu definiert, wäre die Funktion funct () der Basisklasse aufgerufen worden, da die virtuelle Funktion 'hierarchisch' ist.

Hauptunterschiede zwischen Überladen und Überschreiben

  1. Der Prototyp einer Funktion, die überladen wird, unterscheidet sich je nach Typ und Anzahl der Parameter, die an die überladene Funktion übergeben werden. Andererseits ändert sich der Prototyp der überschriebenen Funktion nicht, da eine überschriebene Funktion eine andere Aktion für eine andere Klasse ausführt, zu der sie gehört, jedoch mit demselben Typ und derselben Anzahl von Parametern.
  2. Der überladene Funktionsname steht keinem Schlüsselwort voran, während der Name einer überschriebenen Funktion nur in der Basisklasse mit dem Schlüsselwort „Virtual“ angegeben wird.
  3. Welche überladene Funktion aufgerufen wird, hängt von dem Typ oder der Anzahl der Parameter ab, die an die Funktion übergeben werden. Die überschriebene Funktion, von der die Klasse aufgerufen wird, hängt davon ab, welche Objektadresse der Klasse dem Zeiger zugewiesen wird, der die Funktion aufgerufen hat.
  4. Welche überladene Funktion aufgerufen werden soll, wird während der Kompilierzeit behoben. Welche aufzurufende überschriebene Funktion wird zur Laufzeit aufgelöst.
  5. Konstruktoren können überladen, aber nicht überschrieben werden.
  6. Destruktoren können nicht überladen werden, sie können jedoch überschrieben werden.
  7. Durch das Überladen wird eine frühe Bindung erreicht, da die überladene Funktion während der Kompilierungszeit aufgelöst wird. Durch das Überschreiben wird eine späte Bindung erreicht, da die aufgerufene Funktion, die aufgerufen wird, zur Laufzeit aufgelöst wird.

Ähnlichkeiten

  1. Beide werden auf Elementfunktionen einer Klasse angewendet.
  2. Polymorphismus ist das Grundkonzept beider.
  3. Der Funktionsname bleibt derselbe, während wir die Funktionen überladen und überschreiben.

Fazit

Überladen und Überschreiben erscheint ähnlich, dies ist jedoch nicht der Fall. Funktionen können überladen werden, aber jede Klasse kann die überladene Funktion in Zukunft nicht mehr neu definieren. Eine virtuelle Funktion kann nicht überladen werden. Sie können nur überschrieben werden.

Top