C # - Operatori
Un operatore è un simbolo che dice al compilatore di eseguire specifiche manipolazioni matematiche o logiche. C # ha un ricco set di operatori incorporati e fornisce il seguente tipo di operatori:
- Operatori aritmetici
- Operatori relazionali
- Operatori logici
- Operatori bit per bit
- Operatori di assegnazione
- Operatori vari
Questo tutorial spiega gli operatori aritmetici, relazionali, logici, bit per bit, di assegnazione e altri uno per uno.
Operatori aritmetici
La tabella seguente mostra tutti gli operatori aritmetici supportati da C #. Assumi variabileA detiene 10 e variabile B tiene 20 quindi -
| Operatore | Descrizione | Esempio |
|---|---|---|
| + | Aggiunge due operandi | A + B = 30 |
| - | Sottrae il secondo operando dal primo | A - B = -10 |
| * | Moltiplica entrambi gli operandi | A * B = 200 |
| / | Divide il numeratore per il de-numeratore | B / A = 2 |
| % | Operatore modulo e resto di dopo una divisione intera | B% A = 0 |
| ++ | L'operatore di incremento aumenta il valore intero di uno | A ++ = 11 |
| - | L'operatore di decremento riduce il valore intero di uno | A-- = 9 |
Operatori relazionali
La tabella seguente mostra tutti gli operatori relazionali supportati da C #. Assumi variabileA detiene 10 e variabile B detiene 20, quindi -
| Operatore | Descrizione | Esempio |
|---|---|---|
| == | Controlla se i valori di due operandi sono uguali o meno, in caso affermativo la condizione diventa vera. | (A == B) non è vero. |
| ! = | Controlla se i valori di due operandi sono uguali o meno, se i valori non sono uguali la condizione diventa vera. | (A! = B) è vero. |
| > | Controlla se il valore dell'operando sinistro è maggiore del valore dell'operando destro, in caso affermativo la condizione diventa vera. | (A> B) non è vero. |
| < | Controlla se il valore dell'operando sinistro è inferiore al valore dell'operando destro, in caso affermativo la condizione diventa vera. | (A <B) è vero. |
| > = | Controlla se il valore dell'operando sinistro è maggiore o uguale al valore dell'operando destro, in caso affermativo la condizione diventa vera. | (A> = B) non è vero. |
| <= | Controlla se il valore dell'operando sinistro è minore o uguale al valore dell'operando destro, in caso affermativo la condizione diventa vera. | (A <= B) è vero. |
Operatori logici
La tabella seguente mostra tutti gli operatori logici supportati da C #. Assumi variabileA contiene il valore booleano vero e variabile B mantiene il valore booleano falso, quindi -
| Operatore | Descrizione | Esempio |
|---|---|---|
| && | Chiamato operatore AND logico. Se entrambi gli operandi sono diversi da zero, la condizione diventa vera. | (A && B) è falso. |
| || | Chiamato Operatore OR logico. Se uno dei due operandi è diverso da zero, la condizione diventa vera. | (A || B) è vero. |
| ! | Chiamato operatore NOT logico. Utilizzare per invertire lo stato logico del suo operando. Se una condizione è vera, l'operatore NOT logico la renderà falsa. | ! (A && B) è vero. |
Operatori bit per bit
L'operatore bit per bit lavora sui bit ed esegue l'operazione bit per bit. Le tabelle di verità per &, | e ^ sono le seguenti:
| p | q | p & q | p | q | p ^ q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
Assumiamo se A = 60; e B = 13; quindi nel formato binario sono i seguenti:
A = 0011 1100
B = 0000 1101
-------------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~ A = 1100 0011
Gli operatori bit per bit supportati da C # sono elencati nella tabella seguente. Supponiamo che la variabile A contenga 60 e la variabile B ne contenga 13, quindi -
| Operatore | Descrizione | Esempio |
|---|---|---|
| & | L'operatore AND binario copia un po 'nel risultato se esiste in entrambi gli operandi. | (A e B) = 12, che è 0000 1100 |
| | | L'operatore OR binario copia un bit se esiste in uno degli operandi. | (A | B) = 61, ovvero 0011 1101 |
| ^ | L'operatore XOR binario copia il bit se è impostato in un operando ma non in entrambi. | (A ^ B) = 49, che è 0011 0001 |
| ~ | Binary Ones Complement Operator è unario e ha l'effetto di "ribaltare" i bit. | (~ A) = -61, che è 1100 0011 in complemento a 2 a causa di un numero binario con segno. |
| << | Operatore binario di spostamento sinistro. Il valore degli operandi di sinistra viene spostato a sinistra del numero di bit specificato dall'operando di destra. | A << 2 = 240, che è 1111 0000 |
| >> | Operatore binario di spostamento a destra. Il valore dell'operando di sinistra viene spostato a destra del numero di bit specificato dall'operando di destra. | A >> 2 = 15, che è 0000 1111 |
Operatori di assegnazione
Sono disponibili i seguenti operatori di assegnazione supportati da C #:
| Operatore | Descrizione | Esempio |
|---|---|---|
| = | Operatore di assegnazione semplice, Assegna i valori dagli operandi del lato destro all'operando del lato sinistro | C = A + B assegna il valore di A + B a C |
| + = | Aggiungi operatore di assegnazione AND, aggiunge l'operando destro all'operando sinistro e assegna il risultato all'operando sinistro | C + = A è equivalente a C = C + A |
| - = | Sottrai AND operatore di assegnazione, sottrae l'operando destro dall'operando sinistro e assegna il risultato all'operando sinistro | C - = A è equivalente a C = C - A |
| * = | Moltiplica AND operatore di assegnazione, moltiplica l'operando destro con l'operando sinistro e assegna il risultato all'operando sinistro | C * = A è equivalente a C = C * A |
| / = | Divide AND operatore di assegnazione, divide l'operando sinistro con l'operando destro e assegna il risultato all'operando sinistro | C / = A è equivalente a C = C / A |
| % = | Modulo AND operatore di assegnazione, richiede il modulo utilizzando due operandi e assegna il risultato all'operando sinistro | C% = A è equivalente a C = C% A |
| << = | Shift sinistro AND operatore di assegnazione | C << = 2 è uguale a C = C << 2 |
| >> = | Spostamento a destra e operatore di assegnazione | C >> = 2 è uguale a C = C >> 2 |
| & = | Operatore di assegnazione AND bit per bit | C & = 2 è uguale a C = C & 2 |
| ^ = | OR bit per bit esclusivo e operatore di assegnazione | C ^ = 2 è uguale a C = C ^ 2 |
| | = | OR bit per bit inclusivo e operatore di assegnazione | C | = 2 è uguale a C = C | 2 |
Operatori vari
Ci sono pochi altri operatori importanti tra cui sizeof, typeof e ? : supportato da C #.
| Operatore | Descrizione | Esempio |
|---|---|---|
| taglia di() | Restituisce la dimensione di un tipo di dati. | sizeof (int), restituisce 4. |
| tipo di() | Restituisce il tipo di una classe. | typeof (StreamReader); |
| & | Restituisce l'indirizzo di una variabile. | &un; restituisce l'indirizzo effettivo della variabile. |
| * | Puntatore a una variabile. | *un; crea un puntatore denominato "a" a una variabile. |
| ? : | Espressione condizionale | Se la condizione è vera? Quindi valore X: altrimenti valore Y |
| è | Determina se un oggetto è di un certo tipo. | If (Ford is Car) // controlla se Ford è un oggetto della classe Car. |
| come | Cast senza sollevare un'eccezione se il cast fallisce. | Object obj = new StringReader ("Hello"); StringReader r = obj as StringReader; |
Precedenza degli operatori in C #
La precedenza degli operatori determina il raggruppamento dei termini in un'espressione. Ciò influisce sulla valutazione di un'espressione. Alcuni operatori hanno la precedenza maggiore di altri; ad esempio, l'operatore di moltiplicazione ha una precedenza maggiore dell'operatore di addizione.
Ad esempio x = 7 + 3 * 2; qui, x è assegnato 13, non 20 perché l'operatore * ha una precedenza maggiore di +, quindi la prima valutazione ha luogo per 3 * 2 e quindi viene aggiunto 7.
Qui, gli operatori con la precedenza più alta vengono visualizzati nella parte superiore della tabella, quelli con la priorità più bassa in fondo. All'interno di un'espressione, gli operatori con precedenza più alta vengono valutati per primi.
| Categoria | Operatore | Associatività |
|---|---|---|
| Postfix | () [] ->. ++ - - | Da sinistra a destra |
| Unario | + -! ~ ++ - - (tipo) * & sizeof | Da destra a sinistra |
| Moltiplicativo | * /% | Da sinistra a destra |
| Additivo | + - | Da sinistra a destra |
| Cambio | << >> | Da sinistra a destra |
| Relazionale | <<=>> = | Da sinistra a destra |
| Uguaglianza | ==! = | Da sinistra a destra |
| Bitwise AND | & | Da sinistra a destra |
| Bitwise XOR | ^ | Da sinistra a destra |
| OR bit per bit | | | Da sinistra a destra |
| AND logico | && | Da sinistra a destra |
| OR logico | || | Da sinistra a destra |
| Condizionale | ?: | Da destra a sinistra |
| Incarico | = + = - = * = / =% = >> = << = & = ^ = | = | Da destra a sinistra |
| Virgola | , | Da sinistra a destra |