C ++ ist eine dieser Programmiersprachen, die sehr flexibel ist und auch einige Funktionen der objektorientierten Programmierung abdeckt. Überladen ist ein weiteres Merkmal dieser Programmiersprache.Die folgenden Zeiger werden in diesem Artikel „Funktionsüberladung in C ++“ behandelt.
- C ++ Überladung
- Arten der Überladung in C ++
- Was ist Funktionsüberladung in C ++
- Durch Ändern der Anzahl der Argumente
- Durch verschiedene Arten von Argumenten
- Vorteile der Funktionsüberladung in C ++
- Nachteile der Funktionsüberladung in C ++
- Funktionsüberlastung und Mehrdeutigkeit
C ++ Überladung
Wenn wir zwei oder mehr Mitglieder einer Klasse mit demselben Namen, aber unterschiedlicher Anzahl oder Art von Parametern erstellen, spricht man von C ++ - Überladung. In C ++ können wir überladen:
- Methoden,
- Konstruktoren und
- indizierte Eigenschaften
Arten der Überladung in C ++
Was ist Funktionsüberladung in C ++?
Das Überladen von Funktionen in C ++ kann als der Prozess definiert werden, bei dem zwei oder mehr Elementfunktionen einer Klasse mit demselben Namen, jedoch unterschiedlichen Parametern vorhanden sind. Bei der Funktionsüberladung kann die Funktion je nach Anforderung entweder durch Verwendung unterschiedlicher Argumenttypen oder einer unterschiedlichen Anzahl von Argumenten neu definiert werden. Nur durch diese Unterschiede kann der Compiler zwischen den beiden überladenen Funktionen unterscheiden.
Einer der Hauptvorteile der Funktionsüberladung besteht darin, dass die Lesbarkeit des Programms verbessert wird, da nicht immer wieder unterschiedliche Namen für dieselbe Aktion verwendet werden müssen.
Durch Ändern der Anzahl der Argumente
Auf diese Weise der Funktionsüberladung definieren wir zwei Funktionen mit demselben Namen, aber einer unterschiedlichen Anzahl von Parametern desselben Typs. Zum Beispiel haben wir im unten genannten Programm zwei add () -Funktionen erstellt, um die Summe von zwei und drei ganzen Zahlen zurückzugeben.
Postgraduierten-Zertifikat gegen Meister
// erste Funktionsdefinition int add (int a, int b) {cout<< a+b } // second overloaded function definition int add(int a, int b, int c) { cout << a+b+c }Hier wird die Funktion add () als überladen bezeichnet, da sie zwei Definitionen hat, eine, die zwei Argumente akzeptiert, und eine, die drei Argumente akzeptiert. Welche Funktion add () aufgerufen wird, hängt von der Anzahl der Argumente ab.
int main () {add (10, 20) // add () mit 2 Parametern heißt add (10, 20, 30) // sum () mit 3 Parametern heißt}#include using namespace std int add (int a, int b) {cout<< a+b <Im obigen Beispiel überladen wir die Funktion add (), indem wir die Anzahl der Argumente ändern. Zuerst definieren wir eine add () - Funktion mit zwei Parametern, dann überladen wir sie, indem wir die add () - Funktion erneut definieren, diesmal jedoch mit drei Parametern.
Durch verschiedene Arten von Argumenten
Bei dieser Methode definieren wir zwei oder mehr Funktionen mit demselben Namen und derselben Anzahl von Parametern, aber der für diese Parameter verwendete Datentyp ist unterschiedlich. Zum Beispiel haben wir in diesem Programm drei add () -Funktionen, die erste erhält zwei ganzzahlige Argumente, die zweite zwei float-Argumente und die dritte zwei doppelte Argumente.
#include using namespace std int add (int x, int y) // erste Definition {cout<< x+y << endl return 0 } float add(float a, float b) { cout << a+b << endl return 0 } double add(double x, double y) { cout << x+y << endl return 0 } int main() { add(20, 40) add(23.45f, 34.5f) add(40.24, 20.433) }Im obigen Beispiel definieren wir die Funktion add () dreimal. Erstens mit Ganzzahlen als Parameter, zweitens mit float als Parameter und drittens mit double als Parameter.
Daher überschreiben wir die Funktion add () zweimal.
So erstellen Sie ein Power Bi-Dashboard
Vorteile der Funktionsüberladung in C ++
Wir verwenden Funktionsüberladung, um Speicherplatz, Konsistenz und Lesbarkeit unseres Programms zu sparen.
Mit dem Überlastungskonzept der Verwendungsfunktion können wir mehr als eine Funktion mit demselben Namen entwickeln
Die Funktionsüberladung zeigt das Verhalten des Polymorphismus, das es uns ermöglicht, ein anderes Verhalten zu erhalten, obwohl es eine Verknüpfung mit demselben Funktionsnamen geben wird.
Funktionsüberladung beschleunigt die Ausführung des Programms.
Das Überladen von Funktionen wird zur Wiederverwendbarkeit von Code und zum Speichern von Speicher verwendet.
Es hilft der Anwendung, die Klassenmethode basierend auf dem Parametertyp zu laden.
Die Codepflege ist einfach.
Nachteile der Funktionsüberladung in C ++
- Funktionsdeklarationen, die sich nur durch ihren Rückgabetyp unterscheiden, können nicht mit einem Funktionsüberladungsprozess überladen werden.
- Elementfunktionsdeklarationen mit denselben Parametern oder Namenstypen können nicht überladen werden, wenn eine von ihnen als statische Elementfunktion deklariert ist.
Klasse XYZ {statische Leere func () Leere func () // Fehler}
Funktionsüberlastung und Mehrdeutigkeit
Wenn der Compiler nicht entscheiden kann, welche Funktion er zuerst unter den überladenen Funktionen aufrufen soll, wird diese Situation als Mehrdeutigkeit der Funktionsüberladung bezeichnet. Der Compiler führt das Programm nicht aus, wenn ein Mehrdeutigkeitsfehler angezeigt wird. Ursachen der Funktionsüberlastung Mehrdeutigkeit:
- Typkonvertierung.
- Funktion mit Standardargumenten.
- Funktion mit Referenzübergabe
Typkonvertierung:
#include using Namespace std void function (float) void function (int) void function (float x) {std :: cout<< 'Value of x is : ' <Das obige Beispiel löst einen Fehler aus: 'Aufruf der überladenen Funktion (double) ist nicht eindeutig'. Die Funktion (3.4) ruft die erste Funktion auf. Die Funktion (34) ruft die zweite Funktion gemäß unserer Vorhersage auf. Dies ist jedoch nicht der Fall, da in C ++ alle Gleitkommakonstanten als doppelt und nicht als Gleitkomma behandelt werden. Wenn wir die float-Variable durch eine double-Variable ersetzen, funktioniert das Programm einwandfrei. Daher nennen wir dies einen Typkonvertierungsfehler von float nach double.
Funktion mit Standardargumenten:
#include using namespace std void function (int) void function (int, int) void function (int x) {std :: cout<< 'Value of x is : ' <Das obige Beispiel gibt einen Fehler aus, der besagt, dass der Aufruf von überladenem 'fun (int)' nicht eindeutig ist. Dies liegt daran, dass die Funktion (int y, int z = 12) auf zwei Arten aufgerufen werden kann:
- Durch Aufrufen der Funktion mit einem Argument (und es wird automatisch der Wert von z = 12 angenommen)
- Durch Aufrufen der Funktion mit zwei Argumenten.
Wenn wir die Funktion: Funktion (12) aufrufen, füllen wir die Bedingung sowohl der Funktion (int) als auch der Funktion (int, int) vollständig aus, sodass der Compiler in eine Mehrdeutigkeit gerät und einen Fehler anzeigt.
Funktion mit Referenzübergabe
Unterschied zwischen Überschreiben und Überladen
#include using namespace std void function (int) void function (int &) void function (int a) {std :: cout<< 'Value of a is : ' < Das obige Programm gibt einen Fehler aus, der besagt, dass der Aufruf von überladenem 'fun (int &)' nicht eindeutig ist '. Wie wir sehen, verwendet die erste Funktion ein ganzzahliges Argument und die zweite Funktion einen Referenzparameter als Argument. In diesem Fall kann der Compiler nicht verstehen, welche Funktion vom Benutzer benötigt wird, da es keinen syntaktischen Unterschied zwischen fun (int) und fun (int &) gibt, sodass ein Mehrdeutigkeitsfehler auftritt.
Damit haben wir ein Ende dieser Funktionsüberladung in C ++. Wenn Sie mehr erfahren möchten, lesen Sie die von Edureka, einem vertrauenswürdigen Online-Lernunternehmen. Der Java J2EE- und SOA-Schulungs- und Zertifizierungskurs von Edureka wurde entwickelt, um Sie für Kern- und fortgeschrittene Java-Konzepte sowie für verschiedene Java-Frameworks wie Hibernate & Spring zu schulen.
Hast du eine Frage an uns? Bitte erwähne es im Kommentarbereich dieses Blogs und wir werden uns so schnell wie möglich bei dir melden.