Überladen von C++-Funktionen

C++ ist eine flexible Allzweck-Programmiersprache. Diese Programmiersprache wurde ursprünglich 1985 von Bjarne Stroustrup, einem dänischen Informatiker, entwickelt. C++ unterstützt Polymorphismus, Vererbung und mehr. Dieser Artikel behandelt das Überladen von Funktionen, um Polymorphismus zur Kompilierzeit in der Programmiersprache C++ zu erreichen.

Was ist eine Funktion??

Eine Funktion ist nichts anderes als ein bestimmter Code, der eine bestimmte Aufgabe basierend auf bereitgestellten Eingaben ausführt und die angeforderten Ergebnisse in Form einer Ausgabe an den Benutzer zurückgibt. Funktionen werden verwendet, um sich wiederholenden Code in großen Codebasen zu eliminieren.

Nach dem Definieren einer Funktion können Sie diese zu einem späteren Zeitpunkt entweder im selben Programm oder in einem anderen Programm wiederverwenden.

Funktionssyntax

Eine Funktion in C++ hat die folgende Syntax:

returnType Funktionsname(parameter_list)

…
…
Rückgabewert zurückgeben;

Die Anweisungen returnType, parameter_list und return sind optional. Eine Funktion in C++ kann maximal einen Wert zurückgeben. Wenn eine Funktion keinen Wert zurückgibt, sollte der returnType als void definiert werden.

Was ist Funktionsüberladung??

In C++ können mehrere Funktionsdefinitionen denselben Funktionsnamen haben, jedoch mit unterschiedlichen Parametern. Dies wird als Funktionsüberladung bezeichnet. Mit Hilfe der Funktion zum Überladen von Funktionen kann ein Polymorphismus zur Kompilierzeit in C . erreicht werden++.

Funktionen können auf folgende Weise überladen werden:

Die Anzahl der Parameter kann unterschiedlich sein
Der Datentyp der Parameter kann unterschiedlich sein
Die Reihenfolge der Parameter kann unterschiedlich sein

Der Rückgabewert wird jedoch beim Überladen von Funktionen nicht berücksichtigt.

Folgende Funktionen sind überlastet:

int-Addition (int a, int b)
Schwimmerzugabe (float f, gloat g)
Float-Addition (float f, int i)
Float-Addition (int i, float f)
int-Addition (int a, int b, int c)
Schwimmerzugabe (Schwimmer f, Schwimmer g, Schwimmer h)

Wie Sie sehen, kann es mit Hilfe der Funktion zum Überladen von Funktionen in C++ mehrere Definitionen/Funktionalitäten mit demselben Funktionsnamen und im selben Geltungsbereich geben.

Ohne die Funktion zum Überladen von Funktionen müssten Sie für jede Variation eine separate Funktion schreiben [z. B. Addition_1(), Addition_2() usw.]. Beispielsweise müssen Sie möglicherweise addition_1() schreiben, um zwei ganze Zahlen hinzuzufügen, addition_2(), um zwei Gleitkommazahlen hinzuzufügen, und so weiter. Wie Sie jedoch oben sehen können, kann die Funktion zum Überladen von Funktionen verwendet werden, um mehrere Variationen der Funktion „addition()“ zu definieren, während der gleiche Funktionsname beibehalten wird.

Die folgenden Funktionen gelten nicht als überladen, da der einzige Unterschied zwischen diesen beiden der Rückgabetyp ist (der Rückgabetyp wird für das Überladen von Funktionen in C++ nicht berücksichtigt):

int-Addition (int a, int b)
Float-Addition (int a, int b)

Beispiele

Nachdem Sie nun das Konzept der Funktionsüberladung verstanden haben, werden wir einige funktionierende Beispielprogramme durchgehen, um dieses Konzept besser zu verstehen. Wir werden die folgenden Beispiele behandeln:

Beispiel 1: Einfache Funktion
Beispiel 2: Einfache Additionsfunktion
Beispiel 3: Funktionsüberlastung (1)
Beispiel 4: Funktionsüberlastung (2)
Beispiel 5: Funktionsüberlastung (3)

Die ersten beiden Beispiele erklären, wie normale Funktionen in C++ funktionieren, während die letzten drei Beispiele die Funktion zum Überladen von Funktionen in C . demonstrieren++.

Beispiel 1: Einfache Funktion

In diesem Beispiel zeigen wir, wie eine einfache Funktion in C function definiert und aufgerufen werden kann++. Wir werden eine Klasse namens „Display“ und eine öffentliche Funktion namens „display()“ definieren.“ Von der Funktion „main()“ rufen wir die Funktion „display()“ mit Hilfe des Klassenobjekts „Display“ (d) auf.

#einschließen
Verwenden von Namespace-Std;
Klasse Anzeige

Öffentlichkeit:
Leere Anzeige()

cout << "Hello World!" << endl;

;
int main()

Anzeige d;
d.Anzeige();
0 zurückgeben;

Beispiel 2: Einfache Additionsfunktion

In diesem Beispiel demonstrieren wir, wie man eine einfache „Addition()“-Funktion in C . definiert++. Wir werden eine Klasse namens „DemoAdd“ und eine öffentliche Funktion namens „addition()“ definieren.“ Von der Funktion „main()“ rufen wir die Funktion „addition()“ mit Hilfe des Klassenobjekts „DemoAdd“ (d).

In diesem Beispiel akzeptiert die aktuelle Implementierung der Funktion „addition()“ nur zwei ganzzahlige Parameter. Das bedeutet, dass die aktuelle Funktion „addition()“ nur zwei ganze Zahlen addieren kann.

Um drei statt zwei ganze Zahlen hinzuzufügen, kann eine Funktion mit einem anderen Namen, wie z. B. „Addition_1()“, definiert werden. In C++ kann eine Funktion überladen werden, was bedeutet, dass eine andere Definition der Funktion „addition()“ definiert werden kann, um drei ganze Zahlen hinzuzufügen und den gleichen Namen beizubehalten, d.e., "Zusatz().” Im nächsten Beispiel sehen wir uns an, wie man die Funktion „addition()“ überlädt.

#einschließen
Verwenden von Namespace-Std;
Klasse DemoAdd

Öffentlichkeit:
int Addition (int a, int b)

int-Ergebnis;
Ergebnis = a + b;
Ergebnis zurückgeben;

;
int main()

DemoAdd d;
int i1 = 10, i2 = 20, res;
res = d.Zusatz(i1, i2);
cout << "Result = " << res << endl;
0 zurückgeben;

Beispiel 3: Funktionsüberlastung (1)

Im vorherigen Beispiel haben wir die Funktion „addition()“ definiert, um zwei ganze Zahlen zu addieren und das berechnete Ergebnis zurückzugeben. In diesem Beispiel werden wir nun die Funktion „addition()“ überladen, um drei ganze Zahlen hinzuzufügen. So können wir die Funktion „addition()“ mit zwei ganzzahligen Argumenten sowie drei ganzzahligen Argumenten aufrufen.

Ohne die Funktion zum Überladen von Funktionen müssten wir eine andere Funktion mit einem anderen Namen schreiben.

#einschließen
Verwenden von Namespace-Std;
Klasse DemoAdd

Öffentlichkeit:
// Erste Funktionsdefinition von addition()
int Addition (int a, int b)

int-Ergebnis;
Ergebnis = a + b;
Ergebnis zurückgeben;

// Überladene Version der Funktion addition()
int Addition (int a, int b, int c)

int-Ergebnis;
Ergebnis = a + b + c;
Ergebnis zurückgeben;

;
int main()

DemoAdd d;
int i1 = 10, i2 = 20, i3 = 30, res1, res2;
res1 = d.Zusatz(i1, i2); // Addition() mit 2 Parametern
res2 = d.Addition(i1, i2, i3); // Addition() mit 3 Parametern
cout << "Result = " << res1 << endl;
cout << "Result = " << res2 << endl;
0 zurückgeben;

Beispiel 4: Funktionsüberlastung (2)

In früheren Abschnitten dieses Artikels haben Sie erfahren, dass das Überladen von Funktionen basierend auf Unterschieden im Parametertyp durchgeführt werden kann. Hier haben wir die Funktion „addition()“ basierend auf dem Datentyp des Parameters überladen. In der ersten Version der Additionsfunktion werden wir zwei Variablen vom Typ Integer hinzufügen; und in der zweiten Version werden wir zwei Variablen vom Typ Float hinzufügen.

#einschließen
Verwenden von Namespace-Std;
Klasse DemoAdd

Öffentlichkeit:
// Erste Definition von addition()
int Addition (int a, int b)

int-Ergebnis;
Ergebnis = a + b;
Ergebnis zurückgeben;

// Überladene Funktionsdefinition
Float-Addition (Float f, Float g)

Float-Ergebnis;
Ergebnis = f + g;
Ergebnis zurückgeben;

;
int main()

DemoAdd d;
int i1 = 10, i2 = 20, res1;
Schwimmer f1 = 10.5, f2 = 20.7, res2;
res1 = d.Zusatz(i1, i2); // Addition(int a, int b) wird aufgerufen
res2 = d.Addition(f1, f2); // Addition(float f, flat g) wird aufgerufen
cout << "Result = " << res1 << endl;
cout << "Result = " << res2 << endl;
0 zurückgeben;

Beispiel 5: Funktionsüberlastung (3)

In diesem Beispiel wird die Funktion „addition()“ aufgrund von Unterschieden in der Reihenfolge der Parameterliste überladen. Dies ist eine weitere Möglichkeit, eine Funktion in C . zu überladen++.

#einschließen
Verwenden von Namespace-Std;
Klasse DemoAdd

Öffentlichkeit:
// Erste Funktionsdefinition der Funktion addition()
Float-Addition (int a, float b)

Float-Ergebnis;
Ergebnis = (Float)a + b;
Ergebnis zurückgeben;

// Überladene Funktionsdefinition der Funktion addition()
Float-Addition (float a, int b)

Float-Ergebnis;
Ergebnis = a + (Float)b;
Ergebnis zurückgeben;

;
int main()

DemoAdd d;
int i1 = 10;
Schwimmer f1 = 10.5, res1, res2;
res1 = d.Addition(i1, f1); // Addition(int a, float b) wird aufgerufen
res2 = d.Addition(f1, i1); // Addition(float a, int b) wird aufgerufen
cout << "Result = " << res1 << endl;
cout << "Result = " << res2 << endl;
0 zurückgeben;

Fazit

C++ ist eine universelle und flexible Programmiersprache, die in verschiedenen Domänen weit verbreitet ist. Diese Programmiersprache unterstützt sowohl Kompilierzeit- als auch Laufzeitpolymorphismusmorph. In diesem Artikel haben Sie gelernt, wie Sie mit der Funktion zum Überladen von Funktionen in C++ einen Polymorphismus zur Kompilierzeit erreichen. Dies ist eine sehr hilfreiche Funktion in C++, die Programmierern hilft, lesbaren Code zu schreiben. Es kann auch hilfreich sein, um wiederverwendbaren Code zu schreiben.