Einführung in das Überladen und Überschreiben in C ++
Beginnen wir damit, dass wir die grundlegenden Definitionen für Überladen und Überschreiben in C ++ haben.
Überladen : Der Funktionsname ist derselbe, aber die Parameter und der Rückgabetyp ändern sich. Da wir den Unterschied zwischen den überladenen Funktionen während der Kompilierungszeit kennenlernen werden, wird dies auch als Kompilierungszeit-Polymorphismus bezeichnet.
Überschreiben: Dies ist eine Funktion der objektorientierten Programmiersprache, bei der die Funktion der untergeordneten Klasse denselben Namen hat wie die Klassenfunktion der übergeordneten Klasse. Sobald das Objekt deklariert ist und über die Objekte auf die Funktionen zugegriffen wird, wird die überschreibende Funktionalität im Bild angezeigt. Das heißt, während der Ausführung von Code wird dieses Konzept des Überschreibens auch Laufzeitpolymorphismus genannt.
Wir haben ihre Syntax und ihre Programmierweisen in den späteren Abschnitten.
Syntax des Überladens und Überschreibens
Hier ist die Syntax des Überladens und Überschreibens angegeben.
Syntax überladen:
return_type function_name ( int param_1, string param_2)
(
//function definition
)
return_type_2 function_name ( int param_1, string param_2)
(
//function definition
)
return_type function_name ( int param_1, int param_2)
(
//function definition
)
Alle drei zusammen können ein Beispiel für das Konzept des Überladens bilden.
Überschreibende Syntax:
Class A
(
Public:
void function_name ( int param_1, int param_2)
(
//function definition
)
);Class B : Class A
(
Public:
void function_name ( int param_1, int param_2)
(
//function definition
)
);
Das Obige ist die Syntax für die überschreibende Funktionalität. Die Hauptausgabe kann abgeleitet werden, wenn wir ein Objekt deklarieren und dieselben Methoden aus Klasse A und Klasse B aufrufen. Bei der Funktionalität des Überschreibens spielt das „Objekt“ eine wichtige Rolle.
Lassen Sie uns nun jeweils ein Beispiel sehen, um deren Funktionalität besser kennenzulernen.
Beispiele für das Überladen und Überschreiben in C ++
Hier sind die Beispiele für das Überladen und Überschreiben in C ++ mit der folgenden Ausgabe:
Beispiel # 1 - Überladen
Beginnen wir mit einem einfachen Programm.
Code:
#include
using namespace std;
int calc(int);
float calc(float);
int calc(int, float);
int main()
(
int a = 10;
float b = 11.2;
calc(a);
calc(b);
calc(a, b);
)
int calc(int a)
(
int tot=a*a;
cout << " Area of Square A is: " << tot< )
float calc(float b)
(
float tot = b*b;
cout << " Area of Square B is: " << tot < )
int calc(int a, float b)
(
int tot = a*b;
cout << " Area of Square C is: " << tot << endl;
)#include
using namespace std;
int calc(int);
float calc(float);
int calc(int, float);
int main()
(
int a = 10;
float b = 11.2;
calc(a);
calc(b);
calc(a, b);
)
int calc(int a)
(
int tot=a*a;
cout << " Area of Square A is: " << tot< )
float calc(float b)
(
float tot = b*b;
cout << " Area of Square B is: " << tot < )
int calc(int a, float b)
(
int tot = a*b;
cout << " Area of Square C is: " << tot << endl;
)#include
using namespace std;
int calc(int);
float calc(float);
int calc(int, float);
int main()
(
int a = 10;
float b = 11.2;
calc(a);
calc(b);
calc(a, b);
)
int calc(int a)
(
int tot=a*a;
cout << " Area of Square A is: " << tot< )
float calc(float b)
(
float tot = b*b;
cout << " Area of Square B is: " << tot < )
int calc(int a, float b)
(
int tot = a*b;
cout << " Area of Square C is: " << tot << endl;
)
Ausgabe:
Was ist, wenn ich für die Variablen a, b falsche Datentypwerte gebe?
Code:
int main()
(
int a = 10.8;
float b = 12;
calc(a);
calc(b);
calc(a, b);
)
Ich habe nur den Hauptteil aus dem obigen Programm geändert, also geht hier die Ausgabe.
Ausgabe:
Es gibt uns die Ausgabe, während es den Gleitkommawert in den Datentyp int konvertiert, und gibt uns die Ausgabe.
Jetzt können Sie als Übung versuchen, den Rückgabetyp und die Parameter der Funktion zu ändern und damit herumzuspielen.
Beispiel # 2 - Überschreiben
Nachfolgend finden Sie ein Beispiel für eine überschreibende Funktionalität in C ++.
Code:
#include
using namespace std;
class First
(
public:
virtual void Calc( int a, float b)
(
int tot= a*b;
cout << "Square of First class is: "<< tot < )
void Other()
(
cout<<"Other function in first class"< )
);
class Second : public First
(
public:
// Overriding method
void Calc(int a, float b)
(
float tot = a+b;
cout << "Addition of second class is: " < )
);
int main()
(
int a= 5;
float b=2.5;
Second s;
First &f1 = s;
f1.Calc(a, b);
s.Other();
)#include
using namespace std;
class First
(
public:
virtual void Calc( int a, float b)
(
int tot= a*b;
cout << "Square of First class is: "<< tot < )
void Other()
(
cout<<"Other function in first class"< )
);
class Second : public First
(
public:
// Overriding method
void Calc(int a, float b)
(
float tot = a+b;
cout << "Addition of second class is: " < )
);
int main()
(
int a= 5;
float b=2.5;
Second s;
First &f1 = s;
f1.Calc(a, b);
s.Other();
)#include
using namespace std;
class First
(
public:
virtual void Calc( int a, float b)
(
int tot= a*b;
cout << "Square of First class is: "<< tot < )
void Other()
(
cout<<"Other function in first class"< )
);
class Second : public First
(
public:
// Overriding method
void Calc(int a, float b)
(
float tot = a+b;
cout << "Addition of second class is: " < )
);
int main()
(
int a= 5;
float b=2.5;
Second s;
First &f1 = s;
f1.Calc(a, b);
s.Other();
)#include
using namespace std;
class First
(
public:
virtual void Calc( int a, float b)
(
int tot= a*b;
cout << "Square of First class is: "<< tot < )
void Other()
(
cout<<"Other function in first class"< )
);
class Second : public First
(
public:
// Overriding method
void Calc(int a, float b)
(
float tot = a+b;
cout << "Addition of second class is: " < )
);
int main()
(
int a= 5;
float b=2.5;
Second s;
First &f1 = s;
f1.Calc(a, b);
s.Other();
)
Ausgabe:
Anhand des obigen Codes können wir feststellen, dass die Referenz des Objekts der ersten Klasse dem Objekt zugewiesen ist, das in Bezug auf unsere zweite Klasse erstellt wurde. Und wenn wir dann über das Objekt der Basisklasse auf die Override-Methode zugreifen, können wir deutlich feststellen, dass die Ausgabe der abgeleiteten Klasse angezeigt wurde. Dieses Konzept nennt man Overriding. Die erste und die zweite Klasse sind die Basisklasse bzw. die abgeleitete Klasse. Die Ausgabe von oben ist unten:
Können Sie als Übung versuchen, eine Funktion gemeinsam zu überschreiben und zu überladen und prüfen, ob dies möglich ist oder wie sich die Ausgabe herausstellt?
Wie funktioniert es?
Überladung: Hier gibt es keinen besonderen Punkt, den wir zur Kenntnis nehmen können. Wir müssen sicherstellen, dass der Rückgabetyp oder die Parameter innerhalb der Funktion variieren. Wenn wir uns die Programmierstruktur oben ansehen, werden die Funktionen zuerst deklariert und ihre Implementierung angegeben.
Übergeordnet: Die Syntax der Vererbung und die Implementierung von Funktionen sind die wichtigsten Punkte, die hier zu beachten sind. Im obigen Beispiel können wir feststellen, dass die Deklaration der Funktion mit dem Schlüsselwort public ganz anders ist.
In C ++ wird die Klassendefinition durch ein Semikolon (;) abgeschlossen. Wenn wir die Basisklasse an die untergeordnete Klasse erben müssen, verwenden wir das Doppelpunktsymbol (:). Die Hauptfunktionalität des Überschreibens wird beobachtet, wenn Objekte für die Klasse deklariert und initialisiert werden. Nach dem Aufrufen von Funktionen mit den Objekten können wir das Konzept des Überschreibens klar verstehen.
Vorteile
- Der Hauptvorteil dieser Übersteuerung und Überlastung ist die Zeitersparnis.
- Sparen Sie Speicherplatz.
- Die Lesbarkeit des Codes wird erhöht.
- Hier können wir für das Funktionsüberladungskonzept unterschiedliche gleiche Funktionsnamen für unterschiedliche Operationen verwenden, wodurch die Verwendung unterschiedlicher Funktionsnamen entfällt.
- Flexibilität und Wartbarkeit des Codes werden einfacher.
- Im Fall des Überschreibens kann die untergeordnete Klasse Funktionen der übergeordneten Klasse und sogar eine eigene Implementierung dieser Funktion haben.
- Auf die Objekte kann verwiesen werden, und auf die Funktionen der übergeordneten Klasse und der untergeordneten Klasse kann von der untergeordneten Klasse zugegriffen werden.
Fazit
Wir haben jetzt die Konzepte des Überladens und des Überschreibens klar verstanden. Beim Überladen müssen wir sicherstellen, dass der Unterschied zwischen den überladenen Funktionen entweder auf der Grundlage des Rückgabetyps oder der Parameter besteht, obwohl die darin enthaltene Funktionsdefinition gleich oder unterschiedlich ist.
Und da es sich beim Überschreiben um ein objektorientiertes Programmierkonzept handelt, können wir es nur in Form von Klassen verwenden, die die Funktionalität der Vererbung nutzen.
Empfohlene Artikel
Dies ist eine Anleitung zum Überladen und Überschreiben in C ++. Hier diskutieren wir die Einführung, Funktionsweise, Syntax, Beispiele und Vorteile des Überladens und Überschreibens in C ++ mit Codeimplementierung. Sie können sich auch die folgenden Artikel ansehen, um mehr zu erfahren -
- Überladen in C ++
- Überladen vs Überschreiben
- Überschreiben in PHP
- Überschreiben in C ++
- In Java überschreiben
- Polymorphismus in Java
- Top 11 Features und Vorteile von C ++
- Überschreiben in Python | Funktion und Regeln