Overbelasting van C++-operator

C++-operator overbelast

In deze tutorial leren we over overbelasting van operators aan de hand van voorbeelden.

In C++ kunnen we de manier wijzigen waarop operators werken voor door de gebruiker gedefinieerde typen zoals objecten en structuren. Dit staat bekend als overbelasting van de operator . Bijvoorbeeld,

Stel dat we drie objecten hebben gemaakt c1 , c2 en resultaat uit een klasse met de naam Complex dat staat voor complexe getallen.

Omdat operatoroverbelasting ons in staat stelt de manier waarop operators werken te veranderen, kunnen we opnieuw definiëren hoe de + operator werkt en gebruikt het om de complexe getallen van c1 . op te tellen en c2 door de volgende code te schrijven:

result = c1 + c2;

in plaats van zoiets als

result = c1.addNumbers(c2);

Dit maakt onze code intuïtief en gemakkelijk te begrijpen.

Opmerking: We kunnen geen operatoroverbelasting gebruiken voor fundamentele gegevenstypen zoals int , float , char enzovoort.

Syntaxis voor overbelasting van C++-operatoren

Om een operator te overbelasten, gebruiken we een speciale operator functie. We definiëren de functie binnen de klasse of structuur waarvan we willen dat de overbelaste operator werkt met objecten/variabelen.

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

Hier,

returnType is het retourtype van de functie.
operator is een trefwoord.
symbol is de operator die we willen overbelasten. Vind ik leuk:+ , < , - , ++ , enz.
arguments zijn de argumenten die aan de functie zijn doorgegeven.

Operatoroverbelasting bij Unary-operators

Unaire operatoren werken op slechts één operand. De stapsgewijze operator ++ en decrement operator -- zijn voorbeelden van unaire operatoren.

Voorbeeld1:++ Operator (Unaire Operator) Overbelasting

// 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;
}

Uitvoer

Count: 6

Hier, als we ++count1; . gebruiken , de void operator ++ () wordt genoemd. Dit verhoogt de waarde attribuut voor het object count1 door 1.

Opmerking: Als we operators overbelasten, kunnen we het gebruiken om op elke gewenste manier te werken. We hadden bijvoorbeeld ++ . kunnen gebruiken om waarde te verhogen tegen 100.

Dit maakt onze code echter verwarrend en moeilijk te begrijpen. Het is onze taak als programmeur om overbelasting door operators correct en op een consistente en intuïtieve manier te gebruiken.

Het bovenstaande voorbeeld werkt alleen als ++ wordt gebruikt als voorvoegsel. Om ++ . te maken werken als een postfix gebruiken we deze syntaxis.

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

Let op de int binnen de haakjes. Het is de syntaxis die wordt gebruikt voor het gebruik van unaire operatoren als postfix; het is geen functieparameter.

Voorbeeld 2:++ Operator (Unaire Operator) Overbelasting

// 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;
}

Uitvoer

Count: 6
Count: 7

Het Voorbeeld 2 werkt wanneer ++ wordt gebruikt als zowel prefix als postfix. Het werkt echter niet als we zoiets als dit proberen te doen:

Count count1, result;

// Error
result = ++count1;

Dit komt omdat het retourtype van onze operatorfunctie void . is . We kunnen dit probleem oplossen door Count . te maken als het retourtype van de operatorfunctie.

// return Count when ++ used as prefix

Count operator ++ () {
    // code
}

// return Count when ++ used as postfix

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

Voorbeeld 3:Retourwaarde van operatorfunctie (++ 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;
}

Uitvoer

Count: 6
Count: 6

Hier hebben we de volgende code gebruikt voor overbelasting van de prefix-operator:

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

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

    return temp;
}

De code voor de postfix-operator overbelasting is ook vergelijkbaar. Merk op dat we een object hebben gemaakt temp en gaf de waarde terug aan de operatorfunctie.

Let ook op de code

temp.value = ++value;

De variabele waarde behoort tot de count1 object in main() omdat count1 roept de functie aan, terwijl temp.value behoort tot de temp voorwerp.

Operatoroverbelasting in binaire operatoren

Binaire operatoren werken op twee operanden. Bijvoorbeeld,

result = num + 9;

Hier, + is een binaire operator die werkt op de operanden num en 9 .

Wanneer we de binaire operator voor door de gebruiker gedefinieerde typen overbelasten door de code te gebruiken:

obj3 = obj1 + obj2;

De operatorfunctie wordt aangeroepen met de obj1 object en obj2 wordt doorgegeven als argument aan de functie.

Voorbeeld 4:C++ binaire operator overbelasting

// 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;
}

Uitvoer

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 dit programma is de operatorfunctie:

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

In plaats daarvan hadden we deze functie ook als volgt kunnen schrijven:

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

Echter,

met behulp van & maakt onze code efficiënt door te verwijzen naar de complex2 object in plaats van een dubbel object te maken binnen de operatorfunctie.
met behulp van const wordt als een goede gewoonte beschouwd omdat het voorkomt dat de operatorfunctie complex2 . wijzigt .

Dingen om te onthouden bij overbelasting van C++-operatoren

Twee operators = en & zijn standaard al overbelast in C++. Om bijvoorbeeld objecten van dezelfde klasse te kopiëren, kunnen we direct de = . gebruiken exploitant. We hoeven geen operatorfunctie te creëren.
Overbelasting van operators kan de prioriteit en associativiteit van operators niet veranderen. Als we echter de volgorde van evaluatie willen wijzigen, moeten haakjes worden gebruikt.
Er zijn 4 operators die niet kunnen worden overbelast in C++. Zij zijn:
1. :: (scope resolutie)
2. . (ledenselectie)
3. .* (lidselectie via aanwijzer naar functie)
4. ?: (ternaire operator)

Bezoek deze pagina's voor meer informatie over:

Hoe de increment-operator op de juiste manier overbelasten?
Hoe de binaire operator te overbelasten - om complexe getallen af te trekken?

Hoe een object doorgeven en retourneren vanuit C ++ Functions? C++-aanwijzers

C Taal