Sovraccarico degli operatori C ++ (con esempi)

In questo tutorial impareremo il sovraccarico degli operatori con l'aiuto di esempi.

In C ++, possiamo cambiare il modo in cui gli operatori lavorano per tipi definiti dall'utente come oggetti e strutture. Questo è noto come sovraccarico dell'operatore . Per esempio,

Supponiamo di aver creato tre oggetti c1, c2 e il risultato di una classe denominata Complexche rappresenta numeri complessi.

Poiché l'overloading degli operatori ci consente di modificare il modo in cui funzionano gli operatori, possiamo ridefinire il modo in cui funziona l' +operatore e utilizzarlo per aggiungere i numeri complessi di c1 e c2 scrivendo il codice seguente:

 result = c1 + c2;

invece di qualcosa di simile

 result = c1.addNumbers(c2);

Questo rende il nostro codice intuitivo e facile da capire.

Nota: Non possiamo usare l'overloading degli operatori per i tipi di dati fondamentali come int, float, chare così via.

Sintassi per il sovraccarico degli operatori C ++

Per sovraccaricare un operatore, usiamo una operatorfunzione speciale .

 class className (… public returnType operator symbol (arguments) (… )… );

Qui,

returnType è il tipo restituito dalla funzione.
l'operatore è una parola chiave.
symbolè l'operatore che vogliamo sovraccaricare. Come: +, <, -, ++, etc.
arguments sono gli argomenti passati alla funzione.

Sovraccarico degli operatori negli operatori unari

Gli operatori unari operano su un solo operando. L'operatore di incremento ++e l' operatore di decremento --sono esempi di operatori unari.

Esempio 1: Overload dell'operatore ++ (operatore unario)

 // Overload ++ when used as prefix #include 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; )

Produzione

 Conteggio: 6

Qui, quando usiamo ++count1;, void operator ++ ()si chiama. Ciò aumenta l'attributo value per l'oggetto count1 di 1.

Nota: quando sovraccarichiamo gli operatori, possiamo usarlo per funzionare come preferiamo. Ad esempio, avremmo potuto ++aumentare il valore di 100.

Tuttavia, questo rende il nostro codice confuso e difficile da capire. Il nostro lavoro di programmatore è utilizzare il sovraccarico dell'operatore in modo appropriato e in modo coerente e intuitivo.

L'esempio precedente funziona solo quando ++viene utilizzato come prefisso. Per far ++funzionare un suffisso usiamo questa sintassi.

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

Notare l' intinterno delle parentesi. È la sintassi usata per usare operatori unari come suffisso; non è un parametro di funzione.

Esempio 2: Overload dell'operatore ++ (operatore unario)

 // Overload ++ when used as prefix and postfix #include 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; )

Produzione

 Conteggio: 6 Conteggio: 7

L' esempio 2 funziona quando ++è usato sia come prefisso che come suffisso. Tuttavia, non funziona se proviamo a fare qualcosa del genere:

 Count count1, result; // Error result = ++count1;

Questo perché il tipo di ritorno della nostra funzione operatore è void. Possiamo risolvere questo problema facendo Countcome tipo di ritorno della funzione operatore.

 // return Count when ++ used as prefix Count operator ++ () ( // code ) // return Count when ++ used as postfix Count operator ++ (int) ( // code )

Esempio 3: valore restituito dalla funzione operatore (operatore ++)

 #include 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; )

Produzione

 Conteggio: 6 Conteggio: 7

Qui, abbiamo usato il codice seguente per l'overload dell'operatore del prefisso:

 // Overload ++ when used as prefix Count operator ++ () ( Count temp; // Here, value is the value attribute of the calling object temp.value = ++value; return temp; )

Anche il codice per l'overloading dell'operatore suffisso è lo stesso. Si noti che abbiamo creato un oggetto temp e restituito il suo valore alla funzione operator.

Notare anche il codice

 temp.value = ++value;

Il valore della variabile appartiene all'oggetto count1 main()perché count1 sta chiamando la funzione, mentre temp.value appartiene all'oggetto temporaneo.

Sovraccarico degli operatori negli operatori binari

Gli operatori binari lavorano su due operandi. Per esempio,

 result = num + 9;

Ecco +un operatore binario che funziona sugli operandi num e 9.

Quando sovraccarichiamo l'operatore binario per i tipi definiti dall'utente utilizzando il codice:

 obj3 = obj1 + obj2;

La funzione operatore viene chiamata utilizzando l'oggetto obj1 e obj2 viene passato come argomento alla funzione.

Esempio 4: sovraccarico di operatori binari C ++

 // C++ program to overload the binary operator + // This program adds two complex numbers #include 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 <> 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:"; complex1.input(); cout << "Enter second complex number:"; complex2.input(); // complex1 calls the operator function // complex2 is passed as an argument to the function result = complex1 + complex2; result.output(); return 0; )

Produzione

 Inserisci il primo numero complesso: inserisci rispettivamente le parti reali e immaginarie: 9 5 Inserisci il secondo numero complesso: inserisci rispettivamente le parti reali e immaginarie: 7 6 Numero complesso di output: 16 + 11i

In questo programma, la funzione dell'operatore è:

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

Invece di questo, avremmo anche potuto scrivere questa funzione come:

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

Tuttavia,

using &rende il nostro codice efficiente facendo riferimento all'oggetto complex2 invece di creare un oggetto duplicato all'interno della funzione operator.
l'utilizzo constè considerato una buona pratica perché impedisce alla funzione operatore di modificare complex2.

Sovraccarico di operatori binari in C ++

Cose da ricordare nel sovraccarico degli operatori C ++

Due operatori =e &sono già sovraccaricati per impostazione predefinita in C ++. Ad esempio, per copiare oggetti della stessa classe, possiamo utilizzare direttamente l' =operatore. Non è necessario creare una funzione operatore.
Il sovraccarico degli operatori non può modificare la precedenza e l'associatività degli operatori. Tuttavia, se vogliamo cambiare l'ordine di valutazione, è necessario utilizzare le parentesi.
Ci sono 4 operatori che non possono essere sovraccaricati in C ++. Sono:
1. :: (risoluzione dell'ambito)
2. . (selezione membri)
3. .* (selezione dei membri tramite il puntatore alla funzione)
4. ?: (operatore ternario)