Was ist Überladen in C ++?
C ++ ermöglicht das Schreiben von flexiblem und leicht verständlichem Code unter Verwendung des Konzepts Overloading. Es ermöglicht das Erreichen unterschiedlicher Funktionen innerhalb des vorhandenen Codes mit sehr geringen Änderungen, indem der doppelte Code reduziert wird. Grundsätzlich gibt es hauptsächlich zwei Arten der Überladung, die von C ++ unterstützt werden.
Mit C ++ können wir Funktionen mit demselben Namen schreiben, aber mit unterschiedlichen Datentypen oder der Anzahl der übergebenen Argumente. Diese Funktion wird in C ++ als Funktionsüberladung bezeichnet. Mit dieser Funktion können Entwickler Funktionen mit demselben Namen innerhalb desselben Bereichs definieren. Mit dem gleichen Namen repräsentieren die Funktionen die gleiche Funktionalität, wodurch ein Polymorphismus zur Kompilierungszeit erzielt werden kann. Die Funktionsüberladung hat den Vorteil, dass sie die Lesbarkeit des Codes verbessert.
In C ++ ist eine weitere Funktion enthalten, mit der die vorhandene Funktionalität integrierter Operatoren neu definiert werden kann, die als Operator Overloading bezeichnet wird . Diese Funktion ermöglicht die Verwendung integrierter Operatoren für benutzerdefinierte Typen. Das Überladen von Operatoren vereinfacht den Code, indem die Funktionalität gemäß den Benutzeranforderungen neu definiert wird. In diesem Artikel konzentrieren wir uns sowohl auf das Überladen von Funktionen als auch auf das Überladen von Operatoren. Wir werden die Details und die Verwendung in C ++ sehen.
Wie funktioniert das Überladen in C ++?
- Überladen von Funktionen: Hiermit können wir die Funktion mit demselben Namen definieren, die Funktionen werden jedoch in Abhängigkeit von der Art der übergebenen Parameter oder der Anzahl der an sie übergebenen Parameter unterschieden. Alle Funktionen haben den gleichen Namen, aber entweder einen anderen Datentyp oder eine andere Anzahl von Parametern. Wenn die Funktion aufgerufen wird, wählt der Compiler die Funktion mit dem passenden Parametertyp und der passenden Anzahl von Argumenten. Jetzt können die Entwickler wählen, welche Funktion entsprechend den Anforderungen aufgerufen werden soll. Sie können die entsprechende Funktion auswählen, indem sie die Parameter gemäß den Regeln übergeben.
- Überladen von Operatoren: Hiermit können Operatoren für benutzerdefinierte Datentypen, dh Klassen, arbeiten. Die vorhandenen Operatoren sind überlastet und können die benutzerdefinierten Klassen und Objekte bearbeiten. Das Überladen des Operators wird durch Definieren der Funktion mit dem speziellen Namen erreicht. Die Funktion hat den Namen "Operator", gefolgt vom Operator-Symbol. Wir können das Operator-Symbol direkt auf den benutzerdefinierten Datentyp anwenden und die Operation ausführen. Die erforderliche Aktion oder Operation wird in dieser speziellen Funktion von uns definiert. Durch das Überladen von Operatoren können Operationen unterschiedlichen Typs mit demselben Datentyp ausgeführt werden.
Arten des Überladens in C ++
Funktionsüberladung kann in jedem Fall in Bezug auf die Verwendung von Parametern erreicht werden. Wenn wir die Verwendung von Parametern sagen, bezieht sich dies auf die Art der Parameter oder die Anzahl der Parameter oder die Reihenfolge der Parameter. Daher unterscheidet sich die Funktion calc (int x, float y) mit Parametern (int x, float y) von einer als calc (float x, int y) definierten Funktion, die unterschiedliche Parameter für den unterschiedlichen Datentyp aufweist.
Es kann eine Reihe von Typen geben, bei denen eine Funktionsüberladung erreicht werden kann. Sehen wir uns das einfache Beispiel einer Funktionsüberladung in C ++ an.
#include
using namespace std;
class Display (
public:
static void show (char message() ) (
cout<< "Only Message:" << message << endl;
)
static void show (int messageId, char message()) (
cout<< "Message with Id:";
cout << messageId << " Message:" << message << endl;
)
);
int main (void) (
Display obj;
char message() = "Welcome";
int messageId = 10;
obj.show(message); //calling overloaded function with 1 parameter
obj.show(messageId, message);//calling overloaded function with 2 parameters
return 0;
)
Hier haben wir die Klasse Display, die eine überladene Methode show hat. Die show-Methode wird abhängig von den übergebenen Argumenten aufgerufen.
Ausgabe:
Einzige Nachricht: Willkommen
Eine Nachricht mit Id: 10 Nachricht: Willkommen
Das Überladen von Operatoren kann für fast alle in C ++ verfügbaren integrierten Datentypen erreicht werden. Es gibt an sich keine unterschiedlichen Arten der Bedienerüberladung, die Ansätze können jedoch unterschiedlich sein, um eine Bedienerüberladung zu erreichen. Operatoren wie Unary, Binary, Relational, Assignment usw. können in C ++ überladen werden.
Sehen wir uns das einfache Beispiel für die Überladung des Operators ++ an. In diesem Beispiel wird anstelle des primitiven Datentyps der Operator ++ für das benutzerdefinierte Klassenobjekt verwendet.
#include
using namespace std;
class Bike (
private:
int height;
public:
Bike (): height (80) () //constructor which initializes the height variable
void operator ++() (
height = height + 5;
)
void Specs () (
cout << "The height of the bike is: " < )
);
int main(void)
(
Bike bike;
bike.Specs();
++bike; //calling overloaded operator
bike.Specs();
return 0;
)#include
using namespace std;
class Bike (
private:
int height;
public:
Bike (): height (80) () //constructor which initializes the height variable
void operator ++() (
height = height + 5;
)
void Specs () (
cout << "The height of the bike is: " < )
);
int main(void)
(
Bike bike;
bike.Specs();
++bike; //calling overloaded operator
bike.Specs();
return 0;
)
Wir haben also ein Objekt, dessen Anfangshöhe auf 80 gesetzt und um 5 erhöht wird, wenn wir den Operator ++ darüber aufrufen.
Ausgabe:
Die Höhe des Fahrrads beträgt: 80
Die Höhe des Fahrrads beträgt: 85
Überladeregeln in C ++
Nachfolgend sind die verschiedenen C ++ - Überladungsregeln aufgeführt:
Regeln für die Funktionsüberladung
- Bei Funktionsüberladung muss sich die Funktion in Datentyp, Anzahl oder Reihenfolge der Parameter unterscheiden. Sie kann sich nicht einfach aufgrund der Rückgabefunktion unterscheiden.
Regeln für die Bedienerüberladung
- Es können nur eingebaute Operatoren überladen werden, die neuen Operatoren können nicht überladen werden.
- Es gibt vier Operatoren, die nicht überladen werden können . (Elementauswahl), :: (Bereichsauflösung), . * (Elementauswahl mit Zeiger auf Funktion) und?: (ternärer Operator).
- Der überladene Operator enthält mindestens einen Operanden des benutzerdefinierten Datentyps.
- Es gibt bestimmte Operatoren, die mit der Friend-Funktion nicht überladen werden können, aber als Member-Funktion überladen werden können.
Fazit
Das Überladen in C ++ ist also die einzigartige Funktion, die uns mehrere Vorteile bietet. Es gibt hauptsächlich zwei Arten der Überladung, nämlich Funktionsüberladung und Bedienerüberladung. Durch Überladen von Funktionen wird die Lesbarkeit des Codes verbessert und der Name für die gleiche Aktion beibehalten. Das Überladen von Operatoren ermöglicht es, die vorhandene Funktionalität von Operatoren neu zu definieren, indem ihnen eine besondere Bedeutung gegeben wird. Beide sind sehr nützlich bei der Programmierung in C ++.
Empfohlene Artikel
Dies ist eine Anleitung zum Überladen in C ++. Hier diskutieren wir seine Arbeitsweise, Regeln und zwei Arten des Überladens in c ++, dh das Überladen von Funktionen und das Überladen von Operatoren. Sie können auch den folgenden Artikel lesen, um mehr zu erfahren -
- Überladen in PHP
- Konstruktor in C ++ kopieren
- Überladen vs Überschreiben
- Switch-Anweisung in C ++
- Überladen in Java
- Python-Überladung