Il C++ supporta diversi operatori unari, ciascuno dei quali ha uno scopo unico nella manipolazione delle variabili. Cominciamo con gli operatori di incremento e decremento comunemente utilizzati nei cicli e in vari algoritmi.
Esempio 1: operatori di incremento (++) e di decremento (–).
Gli operatori unari di incremento (++) e decremento (–) sono strumenti fondamentali in C++ per modificare il valore di una variabile aumentandolo o diminuendolo rispettivamente di 1. L’operatore di incremento (++) aggiunge 1 al valore della variabile, mentre l’operatore di decremento (–) sottrae 1. Questi operatori possono essere applicati a variabili intere, a virgola mobile e puntatore, garantendo flessibilità nel loro utilizzo.
Esploriamo questi operatori attraverso un esempio pratico:
#include
utilizzando spazio dei nomi standard ;
int principale ( )
{
int contatore = 0 ;
// Operatore di incremento
cout << 'Valore iniziale: ' << contatore << fine ;
contatore ++ ;
cout << 'Valore dopo l'incremento: ' << contatore << fine ;
// Operatore di decremento
contatore -- ;
cout << 'Valore dopo il decremento: ' << contatore << fine ;
ritorno 0 ;
}
Questo semplice programma C++ include la libreria di flussi di input/output necessaria con '#include
Dopo questa operazione, il valore aggiornato di “counter” viene visualizzato utilizzando un'altra istruzione “cout”. Successivamente, utilizziamo l'operatore di decremento (counter—) per diminuire il valore di “counter” di 1. Il risultato viene successivamente visualizzato sulla console. Alla fine il programma si conclude con il “return 0;” dichiarazione che indica un'esecuzione riuscita.
L'immagine di output mostra il valore iniziale, il valore dopo l'incremento e il valore decrementato.
Esempio 2: operatori positivi (+) e negativi (-).
Mentre l'operatore unario positivo viene utilizzato raramente, l'operatore negativo è fondamentale per cambiare il segno di una variabile.
#includeUtilizzando spazio dei nomi standard ;
int principale ( ) {
int valore positivo = 10 ;
int valore negativo = - valore positivo ;
cout << 'Valore positivo: ' << valore positivo << fine ;
cout << 'Valore negativo: ' << valore negativo << fine ;
ritorno 0 ;
}
Inizializziamo due variabili intere per questo codice di esempio che sono 'positiveValue' e 'negativeValue'. Al “positiveValue” viene assegnato il valore 10. Successivamente, dichiariamo il “negativeValue” e lo assegniamo con la negazione di “positiveValue” utilizzando l'operatore unario meno. Questo operatore modifica effettivamente il segno del valore originale. Utilizziamo quindi l'istruzione 'cout' per visualizzare sia l'output positivo che quello negativo sulla console. Infine, il programma restituisce 0 che indica il completamento con successo della funzione principale.
Una volta eseguito, questo programma restituisce i valori positivi e negativi.
Esempio 3: Operatore logico NOT (!)
L'operatore unario in C++, indicato con '!' simbolo, è noto come operatore logico NOT. È progettato per invertire il valore di verità di una determinata espressione. Funziona su un singolo operando che in genere è un'espressione logica o una condizione. L'operazione logica NOT produce un risultato 'vero' quando l'operando è 'falso' e produce un risultato 'falso' quando l'operando è 'vero'.
Ecco un semplice esempio che dimostra l'utilizzo dell'operatore logico NOT:
#includeutilizzando spazio dei nomi standard ;
int principale ( ) {
bool è vero = VERO ;
bool è falso = falso ;
bool risultatoNonVero = ! è vero ;
bool risultatoNonFalso = ! è falso ;
cout << 'Valore originale: ' << è vero << ', Dopo NOT: ' << risultatoNonVero << fine ;
cout << 'Valore originale: ' << è falso << ', Dopo NOT: ' << risultatoNonFalso << fine ;
ritorno 0 ;
}
In questo esempio, dichiariamo due variabili booleane, “isTrue” e “isFalse”. Applichiamo quindi l'operatore logico NOT a ciascuna variabile, memorizzando i risultati rispettivamente in 'resultNotTrue' e 'resultNotFalse'. Successivamente il programma stampa i valori originali ed i risultati dell'operazione logica NOT per entrambe le variabili.
Eseguendo questo programma, noteremo che l'operatore logico NOT inverte il valore di verità di “isTrue” (inizialmente impostato su true), rendendolo falso. Allo stesso modo, inverte il valore di verità di “isFalse” (originariamente falso), ottenendo vero.
L'output illustra chiaramente l'inversione dei valori di verità ottenuti dall'operatore logico NOT.
Esempio 4: operatore NOT bit a bit (~).
L'operatore NOT bit a bit (~) in C++ è un operatore unario che esegue la negazione bit a bit di ogni bit del suo operando. Funziona con tipi di dati fondamentali, in particolare quelli integrali, come i numeri interi. Il risultato si ottiene invertendo ogni singolo bit nell'operando, convertendo gli 0 in 1 e gli 1 in 0.
Per illustrarne l'utilizzo, si consideri il seguente frammento di codice:
#includeutilizzando spazio dei nomi standard ;
int principale ( ) {
int valore originale = 5 ;
int risultatoBitwiseNot = ~valoreoriginale ;
cout << 'Valore originale: ' << valore originale << ', Dopo NOT bit a bit: ' << risultatoBitwiseNot << fine ;
ritorno 0 ;
}
In questo esempio, dichiariamo una variabile intera “originalValue” con il valore “5”. Successivamente, utilizziamo l'operatore NOT bit a bit (~) su questa variabile. Il risultato di questa variabile è memorizzato in 'resultBitwiseNot'. Il programma quindi stampa il valore originale e il risultato dopo l'operazione NOT bit a bit utilizzando l'istruzione 'cout'.
Quando eseguiamo questo programma, vedremo che l'operatore NOT bit a bit inverte ogni bit della rappresentazione binaria di “originalValue”, risultando in un nuovo valore.
Esempio 5: Operatori di indirizzo e indiretto
L'operatore indirizzo, indicato dal simbolo '&', ha lo scopo di recuperare la posizione di memoria di una variabile. Restituisce un puntatore alla variabile che consente un accesso indiretto al suo valore. L'operatore di riferimento indiretto o di dereferenza (*) ottiene il valore archiviato nella posizione di memoria specificata da un puntatore. Fornisce un modo per lavorare indirettamente con i dati effettivi tramite un puntatore.
Comprendiamo il concetto con un esempio:
#includeutilizzando spazio dei nomi standard ;
int principale ( ) {
int valore = 99 ;
cout << 'Valore originale: ' << valore << fine ;
int * ptr = & valore ;
cout << 'Indirizzo memoria: ' << ptr << fine ;
int valore recuperato = * ptr ;
cout << 'Valore recuperato: ' << valore recuperato << fine ;
ritorno 0 ;
}
Questo codice esemplifica l'utilizzo degli operatori di indirizzo e di indiretto. Innanzitutto, una variabile intera denominata “value” viene inizializzata con il valore 99. Il valore originale di “value” viene quindi inviato alla console. Successivamente, viene dichiarata una variabile puntatore 'ptr' e l'operatore indirizzo di (&) viene utilizzato per assegnare l'indirizzo di memoria di 'valore' a 'ptr'. Il programma quindi emette questo indirizzo di memoria, mostrando il funzionamento di base dell'operatore 'indirizzo'.
Successivamente, viene dichiarata una nuova variabile intera che è 'retrievedValue' e l'operatore indiretto (*) viene utilizzato per recuperare il valore memorizzato nell'indirizzo di memoria indicato da 'ptr'. Il valore recuperato viene quindi inviato alla console.
Conclusione
Questo articolo ha fornito un'esplorazione completa degli operatori unari in C++. Abbiamo iniziato classificando gli operatori unari in vari tipi tra cui aritmetici, logici, bit a bit e quelli relativi all'indirizzo e all'indirizzamento. Sono state esemplificate situazioni del mondo reale per dimostrare l'utile applicazione di questi operatori. Questi operatori svolgono un ruolo fondamentale nella programmazione C++ che consente agli sviluppatori di lavorare con i puntatori in modo efficiente e gestire la memoria.