Überladen von C++-Operatoren

In diesem Tutorial lernen wir das Überladen von Operatoren anhand von Beispielen kennen.

In C++ können wir die Funktionsweise von Operatoren für benutzerdefinierte Typen wie Objekte und Strukturen ändern. Dies wird als Operatorüberladung bezeichnet . Zum Beispiel

Angenommen, wir haben drei Objekte c1 erstellt , c2 und Ergebnis aus einer Klasse namens Complex die komplexe Zahlen darstellt.

Da das Überladen von Operatoren es uns ermöglicht, die Funktionsweise von Operatoren zu ändern, können wir die Funktionsweise von + neu definieren -Operator funktioniert und verwenden Sie ihn, um die komplexen Zahlen von c1 zu addieren und c2 indem Sie den folgenden Code schreiben:

result = c1 + c2;

statt so etwas wie

result = c1.addNumbers(c2);

Dadurch ist unser Code intuitiv und leicht verständlich.

Hinweis: Wir können das Überladen von Operatoren nicht für grundlegende Datentypen wie int verwenden , float , char und so weiter.

Syntax für das Überladen von C++-Operatoren

Um einen Operator zu überladen, verwenden wir einen speziellen operator Funktion. Wir definieren die Funktion innerhalb der Klasse oder Struktur, mit deren Objekten/Variablen der überladene Operator arbeiten soll.

class className {
    ... .. ...
    public
       returnType operator symbol (arguments) {
           ... .. ...
       } 
    ... .. ...
};

Hier,

returnType ist der Rückgabetyp der Funktion.
operator ist ein Schlüsselwort.
symbol ist der Operator, den wir überladen wollen. Wie:+ , < , - , ++ usw.
arguments sind die an die Funktion übergebenen Argumente.

Überladen von Operatoren in unären Operatoren

Unäre Operatoren arbeiten nur mit einem Operanden. Der Inkrementoperator ++ und Dekrementoperator -- sind Beispiele für unäre Operatoren.

Beispiel1:Überladen des ++-Operators (unärer Operator)

// Overload ++ when used as prefix

#include <iostream>
using namespace std;

class Count {
   private:
    int value;

   public:

    // Constructor to initialize count to 5
    Count() : value(5) {}

    // Overload ++ when used as prefix
    void operator ++ () {
        ++value;
    }

    void display() {
        cout << "Count: " << value << endl;
    }
};

int main() {
    Count count1;

    // Call the "void operator ++ ()" function
    ++count1;

    count1.display();
    return 0;
}

Ausgabe

Count: 6

Hier, wenn wir ++count1; verwenden , die void operator ++ () wird genannt. Dadurch wird der Wert erhöht Attribut für das Objekt count1 um 1.

Hinweis: Wenn wir Operatoren überladen, können wir damit arbeiten, wie wir wollen. Zum Beispiel hätten wir ++ verwenden können um den Wert zu erhöhen um 100.

Dies macht unseren Code jedoch unübersichtlich und schwer verständlich. Es ist unsere Aufgabe als Programmierer, das Überladen von Operatoren richtig und auf konsistente und intuitive Weise zu verwenden.

Das obige Beispiel funktioniert nur, wenn ++ wird als Präfix verwendet. Um ++ zu machen als Postfix arbeiten, verwenden wir diese Syntax.

void operator ++ (int) {
    // code
}

Beachten Sie den int innerhalb der Klammern. Es ist die Syntax, die für die Verwendung unärer Operatoren als Postfix verwendet wird; es ist kein Funktionsparameter.

Beispiel 2:Überladen des ++-Operators (unärer Operator)

// Overload ++ when used as prefix and postfix

#include <iostream>
using namespace std;

class Count {
   private:
    int value;

   public:

    // Constructor to initialize count to 5
    Count() : value(5) {}


    // Overload ++ when used as prefix
    void operator ++ () {
        ++value;
    }


    // Overload ++ when used as postfix
    void operator ++ (int) {
        value++;
    }

    void display() {
        cout << "Count: " << value << endl;
    }
};

int main() {
    Count count1;

    // Call the "void operator ++ (int)" function
    count1++;
    count1.display();

    // Call the "void operator ++ ()" function
    ++count1;

    count1.display();
    return 0;
}

Ausgabe

Count: 6
Count: 7

Das Beispiel 2 funktioniert wenn ++ wird sowohl als Präfix als auch als Postfix verwendet. Es funktioniert jedoch nicht, wenn wir versuchen, so etwas zu tun:

Count count1, result;

// Error
result = ++count1;

Das liegt daran, dass der Rückgabetyp unserer Operatorfunktion void ist . Wir können dieses Problem lösen, indem wir Count machen als Rückgabetyp der Operatorfunktion.

// return Count when ++ used as prefix

Count operator ++ () {
    // code
}

// return Count when ++ used as postfix

Count operator ++ (int) {
   // code
}

Beispiel 3:Rückgabewert von Operatorfunktion (++ Operator)

#include <iostream>
using namespace std;

class Count {
   private:
    int value;

   public
       :
    // Constructor to initialize count to 5
    Count() : value(5) {}

    // Overload ++ when used as prefix
    Count operator ++ () {
        Count temp;

        // Here, value is the value attribute of the calling object
        temp.value = ++value;

        return temp;
    }

    // Overload ++ when used as postfix
    Count operator ++ (int) {
        Count temp;

        // Here, value is the value attribute of the calling object
        temp.value = value++;

        return temp;
    }

    void display() {
        cout << "Count: " << value << endl;
    }
};

int main() {
    Count count1, result;

    // Call the "Count operator ++ ()" function
    result = ++count1;
    result.display();

    // Call the "Count operator ++ (int)" function
    result = count1++;
    result.display();

    return 0;
}

Ausgabe

Count: 6
Count: 6

Hier haben wir den folgenden Code zum Überladen von Präfixoperatoren verwendet:

// Overload ++ when used as prefix
Count operator ++ () {
    Count temp;

    // Here, value is the value attribute of the calling object
    temp.value = ++value;

    return temp;
}

Der Code für das Überladen des Postfix-Operators ist ebenfalls ähnlich. Beachten Sie, dass wir ein Objekt temp erstellt haben und seinen Wert an die Operatorfunktion zurückgegeben.

Beachten Sie auch den Code

temp.value = ++value;

Die Variable Wert gehört zu count1 Objekt in main() weil count1 ruft die Funktion auf, während temp.value gehört zum temp Objekt.

Überladen von Operatoren in binären Operatoren

Binäre Operatoren arbeiten mit zwei Operanden. Zum Beispiel

result = num + 9;

Hier, + ist ein binärer Operator, der mit den Operanden num arbeitet und 9 .

Wenn wir den binären Operator für benutzerdefinierte Typen überladen, indem wir den Code verwenden:

obj3 = obj1 + obj2;

Die Operatorfunktion wird über obj1 aufgerufen Objekt und obj2 wird als Argument an die Funktion übergeben.

Beispiel 4:Überladen von C++-Binäroperatoren

// C++ program to overload the binary operator +
// This program adds two complex numbers

#include <iostream>
using namespace std;

class Complex {
   private:
    float real;
    float imag;

   public:
    // Constructor to initialize real and imag to 0
    Complex() : real(0), imag(0) {}

    void input() {
        cout << "Enter real and imaginary parts respectively: ";
        cin >> real;
        cin >> imag;
    }

    // Overload the + operator
    Complex operator + (const Complex& obj) {
        Complex temp;
        temp.real = real + obj.real;
        temp.imag = imag + obj.imag;
        return temp;
    }

    void output() {
        if (imag < 0)
            cout << "Output Complex number: " << real << imag << "i";
        else
            cout << "Output Complex number: " << real << "+" << imag << "i";
    }
};

int main() {
    Complex complex1, complex2, result;

    cout << "Enter first complex number:\n";
    complex1.input();

    cout << "Enter second complex number:\n";
    complex2.input();

   // complex1 calls the operator function
   // complex2 is passed as an argument to the function
    result = complex1 + complex2;
    result.output();

    return 0;
}

Ausgabe

Enter first complex number:
Enter real and imaginary parts respectively: 9 5
Enter second complex number:
Enter real and imaginary parts respectively: 7 6
Output Complex number: 16+11i

In diesem Programm lautet die Operatorfunktion:

Complex operator + (const Complex& obj) {
    // code
}

Stattdessen hätten wir diese Funktion auch so schreiben können:

Complex operator + (Complex obj) {
    // code
}

Allerdings

mit & macht unseren Code effizient, indem er auf complex2 verweist Objekt, anstatt ein doppeltes Objekt innerhalb der Operatorfunktion zu erstellen.
mit const wird als bewährtes Verfahren angesehen, da es verhindert, dass die Operatorfunktion complex2 ändert .

Dinge, die beim Überladen von C++-Operatoren zu beachten sind

Zwei Operatoren = und & sind in C++ bereits standardmäßig überladen. Um beispielsweise Objekte derselben Klasse zu kopieren, können wir direkt den = verwenden Operator. Wir müssen keine Operatorfunktion erstellen.
Das Überladen von Operatoren kann die Priorität und Assoziativität von Operatoren nicht ändern. Wenn wir jedoch die Reihenfolge der Auswertung ändern möchten, sollten Klammern verwendet werden.
Es gibt 4 Operatoren, die in C++ nicht überladen werden können. Sie sind:
1. :: (Bereichsauflösung)
2. . (Mitgliederauswahl)
3. .* (Memberauswahl durch Zeiger auf Funktion)
4. ?: (ternärer Operator)

Besuchen Sie diese Seiten, um mehr darüber zu erfahren:

Wie kann man den Inkrementoperator richtig überladen?
Wie überlade ich den binären Operator - um komplexe Zahlen zu subtrahieren?

Wie kann ich Objekte von C++-Funktionen übergeben und zurückgeben? C++-Zeiger

C Sprache