Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
La operator parola chiave dichiara una funzione che specifica il significato del simbolo dell'operatore quando viene applicato alle istanze di una classe. In tal modo è possibile assegnare più significati all'operatore, che diventa quindi operatore di overload. Il compilatore distingue tra i diversi significati di un operatore esaminando i tipi degli operandi.
Sintassi
digitare
operatoroperator-symbol(parameter-list)
Osservazioni:
È possibile ridefinire la funzione della maggior parte degli operatori incorporati globalmente o classe per classe. Gli operatori di overload vengono implementati come funzioni.
Il nome di un operatore di overload è operatorx, dove x è l'operatore visualizzato nella tabella seguente. Ad esempio, per eseguire l'overload dell'operatore di addizione, si definisce una funzione denominata operator+. Analogamente, per eseguire l'overload dell'operatore di addizione/assegnazione, +=definire una funzione denominata operator+=.
Operatori ridefinibili
| Operatore | Nome | Type |
|---|---|---|
| , | Virgola | Binario |
| ! | NOT logico | Unario |
| != | Disuguaglianza | Binario |
| % | Modulo | Binario |
| %= | Assegnazione modulo | Binario |
| & | AND bit per bit | Binario |
| & | Address-of | Unario |
| && | AND logico | Binario |
| &= | Assegnazione AND bit per bit | Binario |
| ( ) | Chiamata di funzione | — |
| ( ) | Operatore cast | Unario |
* |
Moltiplicazione | Binario |
* |
Dereferenziazione del puntatore | Unario |
*= |
Assegnazione di moltiplicazione | Binario |
| + | Aggiunta | Binario |
| + | Più unario | Unario |
| ++ | Incremento 1 | Unario |
| += | Assegnazione di addizione | Binario |
| - | Sottrazione | Binario |
| - | Negazione unaria | Unario |
| -- | Decremento 1 | Unario |
| -= | Assegnazione di sottrazione | Binario |
| -> | Selezione dei membri | Binario |
->* |
Selezione puntatore a membro | Binario |
| / | Divisione | Binario |
| /= | Assegnazione di divisione | Binario |
| < | Minore di | Binario |
| << | Spostamento a sinistra | Binario |
| <<= | Assegnazione di spostamento a sinistra | Binario |
| <= | Minore di o uguale a | Binario |
| = | Assegnazione | Binario |
| == | Equality | Binario |
| > | Maggiore di | Binario |
| >= | Maggiore di o uguale a | Binario |
| >> | Spostamento a destra | Binario |
| >>= | Assegnazione di spostamento a destra | Binario |
| [ ] | Indice inferiore di matrice | — |
| ^ | OR esclusivo | Binario |
| ^= | Assegnazione OR esclusivo | Binario |
| | | OR inclusivo bit per bit | Binario |
| |= | Assegnazione OR inclusivo bit per bit | Binario |
| || | OR logico | Binario |
| ~ | Complemento di uno | Unario |
delete |
Elimina | — |
new |
Nuovo | — |
| operatori di conversione | operatori di conversione | Unario |
1 Esistono due versioni degli operatori di incremento e decremento unario: preincrement e postincrement.
Per altre informazioni, vedere Regole generali per l'overload degli operatori. Negli argomenti seguenti vengono descritti i vincoli per le diverse categorie di operatori di overload:
Gli operatori elencati nella tabella seguente non possono essere sottoposti a overload. La tabella include i # simboli del preprocessore e ##.
Operatori non ridefinibili
| Operatore | Nome |
|---|---|
| . | Selezione dei membri |
.* |
Selezione puntatore a membro |
| :: | Risoluzione ambito |
| ? : | Condizionale |
| # | Preprocessore - Conversione in stringa |
| ## | Preprocessore - Concatenamento |
Anche se gli operatori di overload vengono in genere chiamati in modo implicito dal compilatore quando vengono rilevati nel codice, possono essere chiamati in modo esplicito in modo analogo a qualsiasi altra funzione di membro o non membro:
Point pt;
pt.operator+( 3 ); // Call addition operator to add 3 to pt.
Esempio
L'esempio seguente esegue l'overload dell'operatore + per aggiungere due numeri complessi e restituisce il risultato.
// operator_overloading.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;
struct Complex {
Complex( double r, double i ) : re(r), im(i) {}
Complex operator+( Complex &other );
void Display( ) { cout << re << ", " << im << endl; }
private:
double re, im;
};
// Operator overloaded using a member function
Complex Complex::operator+( Complex &other ) {
return Complex( re + other.re, im + other.im );
}
int main() {
Complex a = Complex( 1.2, 3.4 );
Complex b = Complex( 5.6, 7.8 );
Complex c = Complex( 0.0, 0.0 );
c = a + b;
c.Display();
}
6.8, 11.2