C++-Überladung (Operator und Funktion)

In C++ können Sie mehr als eine Definition für eine Funktion angeben Name oder ein Operator im gleichen Bereich, was als Funktionsüberladung bezeichnet wird und Operatorüberladung bzw..

Eine überladene Deklaration ist eine Deklaration, die mit demselben Namen deklariert wird wie eine zuvor deklarierte Deklaration im selben Gültigkeitsbereich, außer dass beide Deklarationen unterschiedliche Argumente und offensichtlich unterschiedliche Definitionen (Implementierungen) haben.

Wenn Sie eine überladene Funktion aufrufen oder Betreiber , bestimmt der Compiler die am besten geeignete Definition, indem er die Argumenttypen, die Sie zum Aufrufen der Funktion oder des Operators verwendet haben, mit den in den Definitionen angegebenen Parametertypen vergleicht. Der Prozess der Auswahl der am besten geeigneten überladenen Funktion oder des am besten geeigneten Operators wird als Überladungsauflösung bezeichnet .

Funktionsüberladung in C++

Sie können mehrere Definitionen für denselben Funktionsnamen im selben Bereich haben. Die Definition der Funktion muss sich durch die Typen und/oder die Anzahl der Argumente in der Argumentliste voneinander unterscheiden. Sie können keine Funktionsdeklarationen überladen, die sich nur durch den Rückgabetyp unterscheiden.

Das folgende Beispiel zeigt die gleiche Funktion print() wird verwendet, um verschiedene Datentypen zu drucken −

Live-Demo

#include <iostream>
using namespace std;
 
class printData {
   public:
      void print(int i) {
        cout << "Printing int: " << i << endl;
      }
      void print(double  f) {
        cout << "Printing float: " << f << endl;
      }
      void print(char* c) {
        cout << "Printing character: " << c << endl;
      }
};

int main(void) {
   printData pd;
 
   // Call print to print integer
   pd.print(5);
   
   // Call print to print float
   pd.print(500.263);
   
   // Call print to print character
   pd.print("Hello C++");
 
   return 0;
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −

Printing int: 5
Printing float: 500.263
Printing character: Hello C++

Überladen von Operatoren in C++

Sie können die meisten der in C++ verfügbaren integrierten Operatoren neu definieren oder überladen. Somit kann ein Programmierer auch Operatoren mit benutzerdefinierten Typen verwenden.

Überladene Operatoren sind Funktionen mit besonderen Namen:das Schlüsselwort "operator", gefolgt von dem Symbol für den zu definierenden Operator. Wie jede andere Funktion hat ein überladener Operator einen Rückgabetyp und eine Parameterliste.

Box operator+(const Box&);

deklariert den Additionsoperator, der zum addieren verwendet werden kann zwei Box-Objekte und gibt das letzte Box-Objekt zurück. Die meisten überladenen Operatoren können als gewöhnliche Nicht-Member-Funktionen oder als Klassen-Member-Funktionen definiert werden. Falls wir die obige Funktion als Nicht-Member-Funktion einer Klasse definieren, müssten wir zwei Argumente für jeden Operanden wie folgt übergeben:−

Box operator+(const Box&, const Box&);

Das folgende Beispiel zeigt das Konzept des Überladens von Operatoren mithilfe einer Member-Funktion. Hier wird ein Objekt als Argument übergeben, auf dessen Eigenschaften mit diesem Objekt zugegriffen wird, auf das Objekt, das diesen Operator aufruft, kann mit this zugegriffen werden Operator wie unten erklärt −

Live-Demo

#include <iostream>
using namespace std;

class Box {
   public:
      double getVolume(void) {
         return length * breadth * height;
      }
      void setLength( double len ) {
         length = len;
      }
      void setBreadth( double bre ) {
         breadth = bre;
      }
      void setHeight( double hei ) {
         height = hei;
      }
      
      // Overload + operator to add two Box objects.
      Box operator+(const Box& b) {
         Box box;
         box.length = this->length + b.length;
         box.breadth = this->breadth + b.breadth;
         box.height = this->height + b.height;
         return box;
      }
      
   private:
      double length;      // Length of a box
      double breadth;     // Breadth of a box
      double height;      // Height of a box
};

// Main function for the program
int main() {
   Box Box1;                // Declare Box1 of type Box
   Box Box2;                // Declare Box2 of type Box
   Box Box3;                // Declare Box3 of type Box
   double volume = 0.0;     // Store the volume of a box here
 
   // box 1 specification
   Box1.setLength(6.0); 
   Box1.setBreadth(7.0); 
   Box1.setHeight(5.0);
 
   // box 2 specification
   Box2.setLength(12.0); 
   Box2.setBreadth(13.0); 
   Box2.setHeight(10.0);
 
   // volume of box 1
   volume = Box1.getVolume();
   cout << "Volume of Box1 : " << volume <<endl;
 
   // volume of box 2
   volume = Box2.getVolume();
   cout << "Volume of Box2 : " << volume <<endl;

   // Add two object as follows:
   Box3 = Box1 + Box2;

   // volume of box 3
   volume = Box3.getVolume();
   cout << "Volume of Box3 : " << volume <<endl;

   return 0;
}

Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis −

Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400

Überladbare/nicht überladbareOperatoren

Es folgt die Liste der Operatoren, die überladen werden können −

+	-	*	/	%	^
&	|	~	!	,	=
<	>	<=	>=	++	--
<<	>>	==	!=	&&	||
+=	-=	/=	%=	^=	&=
|=	*=	<<=	>>=	[]	()
->	->*	neu	neu []	löschen	löschen []

Es folgt die Liste der Operatoren, die nicht überladen werden können −

::

.*

.

?:

Beispiele für das Überladen von Operatoren

Hier sind verschiedene Beispiele zum Überladen von Operatoren, die Ihnen helfen sollen, das Konzept zu verstehen.

Sr.No	Operatoren &Beispiel
1	Überladen unärer Operatoren
2	Überladen binärer Operatoren
3	Überladen von relationalen Operatoren
4	Überladen von Eingabe-/Ausgabeoperatoren
5	++ und -- Operatoren überladen
6	Überladung von Zuweisungsoperatoren
7	Funktionsaufruf () Operatorüberladung
8	Subskription von [] Operatorüberladung
9	Class Member Access Operator -> Überladen