c operators types
Uno studio completo degli operatori in C ++ con esempi:
In questo Serie di formazione intensiva C ++, abbiamo appreso i vari concetti in C ++ come variabili, classi di archiviazione, qualificatori di tipo, ecc. nei nostri tutorial precedenti. Abbiamo anche imparato come modificare queste variabili.
Per fare queste modifiche, dobbiamo eseguire operazioni su queste variabili e costanti e per eseguire queste operazioni facciamo uso di operatori.
Gli operatori sono simboli che agiscono su variabili o altre entità chiamate operandi ed eseguono operazioni matematiche o logiche per modificare i loro valori e produrre risultati di conseguenza.
Cosa imparerai:
Operatori in C ++
Gli operatori costituiscono la base di base di qualsiasi linguaggio di programmazione. Senza operatori, non possiamo modificare o manipolare le entità dei linguaggi di programmazione e quindi non possiamo produrre i risultati desiderati. Il C ++ è molto ricco di operatori incorporati di cui parleremo in dettaglio in questo tutorial.
In C ++ la maggior parte degli operatori sono operatori binari, ovvero questi operatori richiedono due operandi per eseguire un'operazione. Pochi operatori come l'operatore ++ (incremento) sono operatori unari, il che significa che operano su un solo operando.
C'è anche un operatore ternario in C ++ chiamato operatore condizionale che accetta tre operandi. Lo impareremo in dettaglio nella parte successiva del tutorial.
Tipi di operatori in C ++
Gli operatori in C ++ sono classificati come mostrato di seguito:
Esploriamo in dettaglio ogni tipo di operatore C ++ !!
Operatori aritmetici
Gli operatori aritmetici vengono utilizzati per eseguire operazioni matematiche di base sugli operandi.
C ++ supporta le seguenti operazioni aritmetiche:
Operatore | Binario / unario | Descrizione |
---|---|---|
- | Unario | Operatore di decremento: diminuisce il valore dell'operando di 1 |
+ | Binario | Aggiunta di due operandi |
- | Binario | Sottrazione di due operandi |
* | Binario | Moltiplicazione di due operandi |
/ | Binario | Divisione di due operandi |
% | Binario | Operatore modulo: il risultato è il resto della divisione |
++ | Unario | Operatore di incremento: aumenta il valore dell'operando di 1 |
L'esempio seguente mostra i primi cinque operatori aritmetici in C ++
#include #include using namespace std; int main() { int op1=3,op2=4; float op3=10.1,op4=5.4; cout<<'Operands are op1 = '< I prossimi operatori aritmetici di cui parleremo sono ++ e -. Questi sono chiamati rispettivamente operatori di incremento e decremento. L'operatore di incremento aumenta il valore dell'operando di 1 mentre l'operatore di decremento diminuisce il valore dell'operando di 1.
L'espressione x ++ è equivalente a
x + = 1;
x = x + 1;
Allo stesso modo, l'espressione x — è equivalente a
x - = 1;
x = x-1;
Gli operatori di incremento e decremento possono essere inseriti sia come prefisso che come suffisso per l'operando. A seconda della sua posizione, questi operatori hanno un significato diverso rispetto alla valutazione di un'espressione.
Quando viene inserita come prefisso, l'operazione di incremento / decremento è nota rispettivamente come pre-incremento o pre-decremento. Quando posta come suffisso, l'operazione di incremento / decremento viene chiamata rispettivamente come operazione di post-incremento o post-decremento.
Ogni volta che si tratta di espressioni, in caso di pre-incremento o pre-decremento, viene eseguita prima l'operazione (incremento o decremento) e poi viene eseguita l'assegnazione. Nel caso di post-incremento o post-decremento, l'assegnazione viene eseguita per prima e l'operazione viene eseguita successivamente.
Possiamo capirlo meglio usando il seguente esempio.
#include #include using namespace std; int main() { int x=4,y; y = ++x; cout<<'PreIncrement:Value of x = '< Nella seconda espressione y = x–, il valore di x che ora è 5, verrà assegnato prima a y e poi il valore di x verrà decrementato. Quindi nell'output, possiamo vedere che per l'operazione di post-decremento, il valore di y è 5 mentre x è 4.
Operatori logici
Gli operatori logici vengono utilizzati per valutare una combinazione di condizioni / vincoli per ottenere un valore risultante. Il risultato della valutazione di un'espressione booleana è booleano che può essere vero o falso.
C ++ supporta i seguenti operatori logici:
Operatore Descrizione 7 L-> R <<
>> Spostamento bit per bit a sinistra
Spostamento bit per bit a destra && AND logico: restituisce true se entrambe le condizioni sono vere, altrimenti restituisce false. || OR logico: restituisce vero se una delle condizioni è vera. Restituisce falso quando entrambe le condizioni sono false. ! NOT logico: nega la condizione.
C ++ utilizza un metodo di cortocircuito per valutare le espressioni logiche. In questo, C ++ deve valutare solo la prima espressione / operando dell'espressione logica per fornire il risultato. Per esempio, per l'operatore AND logico (&&), C ++ valuta solo la prima espressione. Se è falso, il risultato sarà falso anche se la seconda condizione è vera.
Allo stesso modo, per OR logico (||), valuta solo la prima espressione. Se la prima espressione è vera, il risultato sarà vero quindi non è necessario valutare la seconda espressione.
Di seguito è riportato un esempio che mostra l'utilizzo di operatori logici.
#include #include using namespace std; int main() int a=10, b=8,c=12,d=14; if(!(a==0)) cout<<'a is not zero'< Produzione:
a non è zero
AND logico è vero
OR logico è vero
Nel programma precedente, abbiamo utilizzato tutti e tre gli operatori logici per valutare le espressioni e stampare i risultati.
Operatori relazionali
Gli operatori relazionali o di confronto vengono utilizzati per confrontare due operandi. Il risultato della valutazione è vero o falso.
C ++ supporta i seguenti operatori relazionali:
Operatore Descrizione !ERRORE! operatore imprevisto '=' Valuta se due operandi sono uguali. Restituisce vero se uguale altrimenti restituisce falso. ! = (non uguale a) Completa l'operatore 'uguale a'. Restituisce vero se gli operandi non sono uguali. Altrimenti falso. <(less than) Restituisce vero se il primo operando è minore del secondo. Altrimenti falso. <=(less than equal to) Restituisce vero se il primo operando è minore o uguale al secondo operando. Altrimenti falso. > (maggiore di) Restituisce vero se il primo operando è maggiore del secondo. Altrimenti falso. > = (maggiore di uguale a) Restituisce vero se il primo operando è maggiore di uguale al secondo. Altrimenti falso.
Vedere il seguente programma di esempio per comprendere gli operatori relazionali.
#include #include using namespace std; int main() { int a=10, b=8,c=12,d=14; if(a==b) cout<<'a is equal to b'< Produzione:
a non è uguale a b
c non è uguale a d
(a + b) minore / uguale a (c + d)
(a-b) maggiore / uguale a (d-c)
Nel programma sopra, vediamo l'utilizzo di operatori relazionali e il modo in cui valutano le espressioni fornite.
Nota che possiamo fornire non solo valori ma anche variabili ed espressioni nelle istruzioni condizionali.
Operatori bit per bit
Gli operatori bit per bit in C ++ operano sui bit degli operandi forniti. Gli operatori bit per bit vengono applicati solo a tipi integrali come intero, carattere, ecc. E non su tipi di dati come float, double, ecc.
Di seguito sono riportati gli operatori bit per bit supportati da C ++:
Operatori Descrizione & (Binario AND) Esegue un'operazione AND sui bit dell'operando 1 e dell'operando 2. | (Binario OR) Esegue un'operazione OR sui bit dell'operando 1 e dell'operando 2. ^ (XOR binario) Esegue un'operazione XOR sui bit dell'operando 1 e dell'operando 2. ~ (Complemento a uno binario) Accetta un operando e ne inverte i bit. <<( Binary left shift operator) Sposta i bit del primo operando a sinistra in un numero di bit specificato dal secondo operando. >> (Operatore di spostamento a destra binario) Sposta i bit del primo operando a destra in un numero di posizioni specificato dal secondo operando.
Questi operatori bit per bit operano sugli operandi in modo bit per bit. Le tabelle di verità per le operazioni AND, OR e XOR sono fornite di seguito.
Considera aeb come due bit su cui devono essere eseguite le operazioni AND, OR e XOR.
Le tabelle di verità per lo stesso sono fornite di seguito:
per b a & b a | b a ^ b 0 0 0 0 0 1 0 0 1 1 0 1 0 1 1 1 1 1 1 0
Facciamo un esempio per comprendere le operazioni bit per bit.
Siano a = 8 eb = 4
La rappresentazione binaria di aeb è la seguente:
a = 8 1000
a = 4 0100
a & b 0000 = 0
a | b 1100 = 12
a ^ b 1100 = 12
Nell'esempio sopra, vediamo che l'AND bit per bit di 8 e 4 è 0. L'OR bit per bit di 8 e 4 è 12 e anche l'XOR bit per bit di 8 e 4 è 12.
Questo è il modo in cui le operazioni bit per bit vengono eseguite dagli operatori bit per bit.
Un esempio che mostra gli operatori bit per bit.
#include #include using namespace std; int main() int a=8,b=4,c; c = a&b; cout<<'Result of & : '< Produzione:
Risultato di &: 0
Risultato di | : 12
Risultato di ^: 12
Risultato di<< by 2 bits: 32
Risultato di >> per 2 bit: 1
Risultato di ~: -4
Nel programma precedente, abbiamo dimostrato l'utilizzo di operatori bit per bit e stampato anche l'output di ciascuna operazione.
Operatori di assegnazione
L'operatore di assegnazione '=' viene utilizzato per assegnare un valore a una variabile. Il LHS dell'operatore di assegnazione è una variabile e RHS è il valore che deve essere assegnato alla variabile. Il valore a destra deve essere dello stesso tipo di quello della variabile a sinistra.
Nota la differenza tra gli operatori '=' e '=='. Il primo è l'operatore di assegnazione e il secondo è l'operatore di uguaglianza.
L'operazione di assegnazione avviene da destra a sinistra. Oltre all'operatore di assegnazione '=', esistono altre varianti dell'operatore di assegnazione noti come 'operatori di assegnazione composti'. Questi operatori eseguono un'operazione in aggiunta all'assegnazione.
La tabella seguente fornisce una descrizione di questi operatori di assegnazione.
Operatore Descrizione = Assegna il valore dell'operando RHS all'operando LHS + = Aggiunge l'operando RHS all'operando LHS e assegna il risultato all'operando LHS. - = Sottrae l'operando RHS all'operando LHS e assegna il risultato all'operando LHS * = moltiplica l'operando RHS all'operando LHS e assegna il risultato all'operando LHS / = divide l'operando RHS nell'operando LHS e assegna il risultato all'operando LHS
Come mostrato nella tabella sopra, se xey sono operandi, x + = y è equivalente a x = x + y.
Allo stesso modo,
x - = y è equivalente a x = x-y.
x * = y è equivalente a x = x * y.
x / = y è equivalente a x = x / y.
L'esempio di programmazione riportato di seguito mostra questi operatori di assegnazione.
#include #include using namespace std; int main() { int x,y; cout<>y; x = y; cout<<'
Value of x = '< Produzione:
Immettere la variabile di input y: 4
Valore di x = 4
a + = b: 8
c - = b: 3
a * = b: 40
b / = c: 1

Nell'esempio precedente, abbiamo dimostrato l'assegnazione così come gli operatori di assegnazione composta.
Nota: Possiamo anche combinare gli altri operatori binari come%,<>, &, |, ^, ecc. in istruzioni di assegnazione composta oltre a quelle già dimostrate.
Altri operatori
Finora abbiamo esplorato tutti i principali operatori in C ++. Ci sono altri operatori C ++ aggiuntivi che richiedono la nostra attenzione.
Questi operatori includono:
gioca a wow per un server privato gratuito
(i) dimensione dell'operatore
sizeof è un operatore unario ampiamente utilizzato in C e C ++. Sizeof restituisce la dimensione del suo operando. Il valore restituito è di solito un tipo integrale senza segno indicato da 'size_t'.
L'operatore Sizeof ha molti usi nei linguaggi C e C ++. Può essere utilizzato per scoprire la dimensione delle variabili, degli array o delle espressioni e persino per allocare i blocchi di memoria.
(ii) Operatore ternario condizionale
L'operatore condizionale in C ++ può essere utilizzato in sostituzione dell'istruzione if-else.
La sintassi generale per l'operatore condizionale è:
Condizione? espressione1: espressione2;
Se la condizione è vera, verrà valutata l'espressione 1. Se la condizione è falsa, verrà valutata expression2.
Tieni presente che espressione1 ed espressione2 devono essere dello stesso tipo di dati per evitare potenziali errori.
Lettura suggerita => Operatore ternario in C #
(iii) Comma Operator
L'operatore virgola rappresentato come un token ',' può essere utilizzato sia come operatore che come separatore.
Come operatore, viene utilizzata una virgola quando è presente più di un'espressione da valutare. Solo l'espressione più a destra è assegnata a LHS.
Per esempio,considera la seguente espressione.
x = (y = 4, y + 1);
In questa espressione, abbiamo due espressioni sul lato destro separate da una virgola. Qui la virgola funge da operatore. Per prima cosa verrà valutata l'espressione y = 4. Quindi la successiva espressione y + 1 verrà valutata utilizzando il risultato della prima espressione, ovvero y = 4. Quindi il valore di y + 1 sarà 5 e questo valore sarà assegnato a x.
Come separatore, una virgola può essere utilizzata ovunque per separare definizioni, elenco di parametri, ecc.
(iv) Operatore di accesso ai membri
Esistono due operatori che vengono utilizzati per accedere ai singoli membri di classi, strutture o unioni in C ++. Questi sono l'operatore punto (.) E l'operatore freccia (->). Impareremo questi operatori in dettaglio quando impareremo la programmazione orientata agli oggetti in C ++.
L'esempio seguente mostra l'utilizzo di sizeof, Comma e Operatore condizionale.
#include #include using namespace std; int main() { int x,y; x = (y=3,y+4); cout<<'Value of x = '< Produzione:
Valore di x = 7
La variabile x è maggiore di 5
dimensione di (x): 4 dimensione di (y): 4
Lo screenshot per lo stesso è fornito di seguito.

Come mostrato nel programma sopra, prima abbiamo due variabili dichiarate e separate da una virgola. (virgola come separatore). Successivamente, abbiamo un operatore virgola con due espressioni. Come possiamo vedere dall'output, il valore dell'espressione più a destra è assegnato alla variabile x. Successivamente, mostriamo l'operatore condizionale per valutare se x è minore di 5.
Infine, dimostriamo l'uso dell'operatore sizeof. Qui usiamo l'operatore sizeof per ottenere la dimensione delle variabili x e y. Poiché entrambe sono variabili intere, la dimensione restituita è di 4 byte.
(v) Precedenza e associatività degli operatori
Abbiamo già visto quasi tutti gli operatori C ++ e sappiamo che possono essere utilizzati nelle espressioni per eseguire operazioni specifiche. Ma le espressioni che abbiamo visto negli esempi sono semplici e dirette. Tuttavia, a seconda delle nostre esigenze, le espressioni tendono a diventare sempre più complesse.
Tali espressioni complesse avranno più di un operatore e molti operandi. In una situazione del genere, dobbiamo valutare quale operatore deve essere valutato per primo.
Per esempio, considera la seguente espressione.
x = 4 + 5/3;
Qui abbiamo gli operatori + e / e dobbiamo decidere quale espressione sarà valutata per prima. In termini matematici, sappiamo che la divisione verrà eseguita prima dell'addizione. Quindi l'espressione diventerà x = 4 + (5/3) = 5.
Ma quando il compilatore si trova di fronte a una situazione del genere, abbiamo anche bisogno di un meccanismo simile per decidere l'ordine delle operazioni, in modo che possa valutare correttamente l'espressione.
Questo ordine in cui vengono valutati gli operatori in un'espressione composta è chiamato 'Precedenza' dell'operatore. C ++ ha la precedenza definita per tutti gli operatori e gli operatori con precedenza più alta vengono valutati per primi.
Cosa succede quando abbiamo due operatori affiancati in un'espressione con la stessa precedenza? È qui che entra in gioco l'associatività di un operatore.
L'associatività dice al compilatore se valutare un'espressione nella sequenza da sinistra a destra o da destra a sinistra. Quindi, usando la precedenza e l'associatività di un operatore, possiamo valutare efficacemente un'espressione e ottenere il risultato desiderato.
C ++ fornisce una tabella composta da precedenza e associatività dei vari operatori che utilizza.
Questa tabella è fornita di seguito.
Precedenza / Associatività Operatore Descrizione 1 Nessuno ::
:: Operatore di risoluzione dell'ambito
(unario)
(binario) 2 L-> R ()
()
()
{}
genere()
genere{}
()
.
->
++
––
typeid
const_cast
dynamic_cast
reinterpret_cast
static_cast Parentesi
Chiamata di funzione
Inizializzazione
Inizializzazione uniforme (C ++ 11)
Cast funzionale
Cast funzionale (C ++ 11)
Indice di matrice
Accesso ai membri dall'oggetto
Accesso ai membri dall'oggetto ptr
Post-incremento
Post-decremento
Informazioni sul tipo di runtime
Getta via cost
Cast con controllo del tipo in fase di esecuzione
Trasmetti un tipo a un altro Cast con controllo del tipo in fase di compilazione 3 R-> L +
-
++
––
!
~
(genere)
taglia di
&
*
nuovo
nuovo()
Elimina
Elimina() Unario di più
Meno unario
Pre-incremento
Pre-decremento
NOT logico
Bitwise NON
Cast in stile C.
Dimensioni in byte
Indirizzo di
Dereferenziazione
Allocazione dinamica della memoria
Allocazione dinamica degli array
Cancellazione dinamica della memoria
Eliminazione di array dinamici 4 L-> R -> *
. * Selettore del puntatore dei membri
Selettore oggetto membro 5 L-> R *
/
% Moltiplicazione
Divisione
Modulo 6 L-> R +
- Aggiunta
Sottrazione 8 L-> R <
<=
>
> = Confronto inferiore a
Confronto minore o uguale a
Confronto maggiore di
Confronto maggiore o uguale a 9 L-> R !ERRORE! carattere illegale '!' Uguaglianza
Disuguaglianza 10 L-> R & Bitwise AND 11 L-> R ^ Bitwise XOR 12 L-> R | OR bit per bit 13 L-> R && AND logico 14 L-> R || OR logico 15 R-> L ?:
=
* =
/ =
% =
+ =
- =
<<=
>> =
& =
| =
^ = Condizionale (vedi nota sotto)
Incarico
Assegnazione di moltiplicazione
Assegnazione della divisione
Assegnazione del modulo
Assegnazione di addizione
Assegnazione di sottrazione
Spostamento bit per bit a sinistra assegnazione
Spostamento bit per bit a destra assegnazione
Assegnazione AND bit per bit
Assegnazione OR bit per bit
Assegnazione XOR bit per bit 16 R-> L gettare Lancia l'espressione 17 L-> R , Comma operator
Appunti:
- Il livello di precedenza 1 è il livello di precedenza più alto e il livello 17 è il più basso. Gli operatori con un livello di precedenza più alto vengono valutati per primi.
- L-> R significa associatività da sinistra a destra.
- R-> L significa associatività da destra a sinistra.
Conclusione
Questo è tutto sugli operatori in C ++.
Abbiamo discusso di quasi tutti gli operatori. Alcuni operatori specifici che sono presenti nella precedente tabella di precedenza che non abbiamo discusso, verranno discussi in base agli argomenti che tratteremo nei nostri prossimi tutorial.
=> Vedi qui per esplorare l'elenco completo dei tutorial C ++
Lettura consigliata
- Esempi di operatori aritmetici e booleani di script di shell Unix
- Operatori Python
- Operatori Nuovo / Elimina in C ++ con esempi
- Tipi di dati Python
- Dichiarazioni condizionali Unix: If Then Else e operatori relazionali
- Tutorial Python DateTime con esempi
- Tutorial sull'iniezione di HTML: tipi e prevenzione con esempi
- Comando Taglia in Unix con esempi