Inhalt

• 
  Vergleichstabelle:
• Definition von Überlastung
• Implementierung des Überladens in C ++
• Definition von Overriding
• Implementierung von Overriding in C ++
• Ähnlichkeiten
• Fazit

Im 'ÜberlastungWir definieren die überladenen Funktionen mit demselben Funktionsnamen, aber unterschiedlicher Anzahl und Art der Parameter neu. Im 'außer Kraft setzenDer Prototyp der überschriebenen Funktion ist im gesamten Programm gleich, aber der zu überschreibenden Funktion geht das Schlüsselwort "virtual" in der Basisklasse voraus und wird von der abgeleiteten Klasse ohne Schlüsselwort neu definiert.

Polymorphismus ist eines der entscheidenden Merkmale von OOP. Es bedeutet einfach "Verwenden eines Namens für mehrere Formulare". Polymorphismus kann mithilfe von "Funktionsüberladung", "Bedienerüberladung" und "virtueller Funktion" implementiert werden. Sowohl "Überladen" als auch "Überschreiben" implizieren das Konzept des Polymorphismus. In diesem Fall ist "Überladen" der Polymorphismus der Kompilierungszeit und "Überschreiben" der Laufzeit-Polymorphismus. Weiter studieren, wenn wir über den Hauptunterschied zwischen "Überladen" und "Übersteuern" sprechen.

Weiter untersuchen wir den Unterschied zwischen Überlastung und Übersteuerung mit Hilfe einer Vergleichstabelle.

1. Vergleichstabelle
2. Definition
3. Hauptunterschiede
4. Ähnlichkeiten
5. Fazit

Vergleichstabelle:

Grundlage für den Vergleich	Überlastung	Überschreiben
Prototyp	Der Prototyp unterscheidet sich, da sich Anzahl oder Typ der Parameter unterscheiden können.	Alle Aspekte des Prototyps müssen gleich sein.
Stichwort	Während des Überladens wurde kein Schlüsselwort angewendet.	Vor der zu überschreibenden Funktion steht in der Basisklasse das Schlüsselwort virtual.
Unterscheidungsmerkmal	Die Anzahl oder Art der Parameter unterscheidet sich und bestimmt, welche Version der Funktion aufgerufen wird.	Welche Klassenfunktion vom Zeiger aufgerufen wird, wird durch die Adresse bestimmt, die dem Zeiger für welches Klassenobjekt zugewiesen ist.
Muster definieren	Die Funktionen werden mit demselben Namen, aber unterschiedlicher Anzahl und Art der Parameter neu definiert.	Die Funktion wird definiert, vor dem Schlüsselwort virtual in der Hauptklasse und nach der abgeleiteten Klasse ohne Schlüsselwort neu definiert.
Zeit der Vollendung	Kompilierzeit.	Laufzeit
Konstruktor / Virtuelle Funktion	Konstruktoren können überladen werden.	Die virtuelle Funktion kann überschrieben werden.
Zerstörer	Destruktor kann nicht überladen werden.	Destruktor kann überschrieben werden.
Bindung	Durch Überladen wird eine frühzeitige Bindung erreicht.	Überschreiben bezieht sich auf verspätete Bindung.

Definition von Überlastung

Der Polymorphismus zur Kompilierungszeit wird als "Überladung" bezeichnet. Da die Überladung aus einem Konzept des Polymorphismus generiert wird, bietet er "eine gemeinsame Schnittstelle für mehrere Methoden". 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. Dadurch unterscheidet sich eine überladene Funktion von der anderen. Auf diese Weise erkennt der Compiler, welche überladene Funktion aufgerufen wird. Am häufigsten überladene Funktionen sind Konstruktoren. "Konstruktor kopieren" ist eine Art "Konstruktorüberladung".

Implementierung des Überladens in C ++

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

Hier wurde die Funktion load () der Klassenüberladung überladen. Die zwei überladenen Funktionen der Klasse können auf eine Weise unterschieden werden, dass die erste load () - Funktion nur einen einzelnen Integer-Parameter akzeptiert, während die zweite load () - Funktion zwei Integer-Parameter akzeptiert. Wenn das Objekt der Klassenüberladung die load () - Funktion mit einem einzelnen Parameter aufruft, wird die erste load () - Funktion aufgerufen. Wenn das Objekt die load () - Funktion aufruft und zwei Parameter übergibt, wird die zweite load () - Funktion aufgerufen.

Definition von Overriding

Während der Laufzeit erzielter Polymorphismus wird als "Überschreiben" bezeichnet. Er wird durch die Verwendung von "Vererbung" und "virtuellen Funktionen" erreicht. Vor der zu überschreibenden Funktion steht das Schlüsselwort "virtual" in einer Basisklasse und es wird in einer abgeleiteten Klasse ohne Schlüsselwort neu definiert.

Eines der wichtigsten Dinge, die beim Überschreiben beachtet werden müssen, ist, dass sich der Prototyp der überschriebenen Funktion nicht ändern darf, während die abgeleitete Klasse ihn neu definiert. Wenn eine überschriebene Funktion aufgerufen wird, bestimmt C ++, welche Version der Funktion aufgerufen wird, basierend auf dem "Typ des Objekts, auf das ein Zeiger zeigt", mit dem der Funktionsaufruf erfolgt.

Implementierung von Overriding in C ++

class base {public: virtual void funct () {// virtuelle Funktion der Basisklasse cout << "Dies ist eine Basisklasse funct ()"; }}; Klasse abgeleitet1: public base {public: void funct () {// virtuelle Funktion der Basisklasse, die in der abgeleiteten Klasse cout << "Dies ist eine abgeleitete Klasse funct ()" neu definiert wurde; }}; Klasse derivative2: public base {public: void funct () {// virtuelle Funktion der Basisklasse, die in der abgeleiteten Klasse cout neu definiert wurde << "Dies ist eine abgeleitete Klasse funct ()"; }}; int main () {base * p, b; abgeleitet1 d1; abgeleitet2 d2; * p = & b; p-> funct (); // Aufruf der Basisklasse funct (). * p = & d1; p-> funct (); // Aufruf der abgeleiteten1-Klasse funct (). * p = & d2; p-> funct (); // Aufruf der abgeleiteten2-Klasse funct (). return 0; }

Hier gibt es eine einzelne Basisklasse, die von zwei abgeleiteten Klassen öffentlich geerbt 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 "abgeleitet1" erstellt ein Objekt d1 und die Klasse "abgeleitet2" erstellt ein Objekt d2.

Zunächst wird die Adresse des Basisklassenobjekts "b" dem Zeiger der Basisklasse "p" zugewiesen. ‘P’ ruft die Funktion funct () auf, sodass eine Funktion der Basisklasse aufgerufen wird.Dann wird die Adresse des abgeleiteten 1-Klassenobjekts 'd1' dem Zeiger 'p' zugewiesen, und erneut wird funct () aufgerufen. Hier wird die Funktion funct () der abgeleiteten Klasse 1 ausgeführt. Schließlich wird der Zeiger "p" dem Objekt der abgeleiteten Klasse 2 zugewiesen. Dann ruft 'p' die Funktion funct () auf, die die Funktion funct () der abgeleiteten Klasse 2 ausführt.

Wenn die abgeleitete1 / abgeleitete2-Klasse funct () nicht neu definiert hat, wurde die funct () der Basisklasse aufgerufen, da die virtuellen Funktionen hierarchisch sind.

1. Der Prototyp einer Funktion, die überladen wird, unterscheidet sich aufgrund der Art und Anzahl der Parameter, die an die überladene Funktion übergeben werden. Auf der anderen Seite ändert sich der Prototyp der überschriebenen Funktion nicht, da eine überschriebene Funktion unterschiedliche Aktionen für verschiedene Klassen ausführt, die derselben Art und Anzahl von Parametern angehören.
2. Dem überladenen Funktionsnamen wird kein Schlüsselwort vorangestellt, wohingegen dem Namen einer überschriebenen Funktion nur in der Basisklasse das Schlüsselwort "Virtual" vorangestellt wird.
3. Welche überladene Funktion aufgerufen wird, hängt von der Art oder Anzahl der Parameter ab, die an die Funktion übergeben werden. Die überschriebene Funktion, welche Klasse aufgerufen wird, hängt davon ab, welche Objektadresse der Klasse dem Zeiger zugewiesen ist, der die Funktion aufgerufen hat.
4. Welche überladene Funktion aufgerufen werden soll, wird während der Kompilierungszeit behoben. Welche überschriebene Funktion aufgerufen werden soll, wird zur Laufzeit aufgelöst.
5. Konstruktoren können überladen, aber nicht überschrieben werden.
6. Destruktoren können nicht überladen, aber überschrieben werden.
7. Durch Überladen wird eine frühe Bindung erreicht, da die überladene Funktion, die aufgerufen wird, während der Kompilierungszeit aufgelöst wird. Durch Überschreiben wird eine späte Bindung erreicht, da die aufzurufende überschriebene Funktion zur Laufzeit aufgelöst wird.

Ähnlichkeiten

1. Beide werden auf Elementfunktionen einer Klasse angewendet.
2. Polymorphismus ist das Grundkonzept hinter beiden.
3. Der Funktionsname bleibt gleich, während die Funktionen überladen und überschrieben werden.

Fazit

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