In questo articolo impareremo tutto sui diversi tipi di operatori nel linguaggio di programmazione C # e su come usarli.
Gli operatori sono simboli utilizzati per eseguire operazioni sugli operandi. Gli operandi possono essere variabili e / o costanti.
Ad esempio , in 2+3
, +
è un operatore utilizzato per eseguire operazioni di addizione, mentre 2
e 3
sono operandi.
Gli operatori vengono utilizzati per manipolare variabili e valori in un programma. C # supporta un numero di operatori classificati in base al tipo di operazioni che eseguono.
1. Operatore di assegnazione di base
L'operatore di assegnazione di base (=) viene utilizzato per assegnare valori alle variabili. Per esempio,
doppia x; x = 50,05;
Qui, 50.05 è assegnato a x.
Esempio 1: operatore di assegnazione di base
using System; namespace Operator ( class AssignmentOperator ( public static void Main(string() args) ( int firstNumber, secondNumber; // Assigning a constant to variable firstNumber = 10; Console.WriteLine("First Number = (0)", firstNumber); // Assigning a variable to another variable secondNumber = firstNumber; Console.WriteLine("Second Number = (0)", secondNumber); ) ) )
Quando eseguiamo il programma, l'output sarà:
Primo numero = 10 Secondo numero = 10
Questo è un semplice esempio che dimostra l'uso dell'operatore di assegnazione.
Potresti aver notato l'uso di parentesi graffe ( )
nell'esempio. Ne discuteremo nella formattazione delle stringhe. Per ora tieni presente che (0)
viene sostituita dalla prima variabile che segue la stringa, (1)
viene sostituita dalla seconda variabile e così via.
2. Operatori aritmetici
Gli operatori aritmetici vengono utilizzati per eseguire operazioni aritmetiche come addizione, sottrazione, moltiplicazione, divisione, ecc.
Per esempio,
int x = 5; int y = 10; int z = x + y; // z = 15Operatori aritmetici C #
Operatore | Nome operatore | Esempio |
---|---|---|
+ | Operatore di addizione | 6 + 3 restituisce 9 |
- | Operatore di sottrazione | 10-6 restituisce 4 |
* | Operatore di moltiplicazione | 4 * 2 restituisce 8 |
/ | Operatore di divisione | 10/5 restituisce 2 |
% | Operatore modulo (resto) | 16% 3 restituisce 1 |
Esempio 2: operatori aritmetici
using System; namespace Operator ( class ArithmeticOperator ( public static void Main(string() args) ( double firstNumber = 14.40, secondNumber = 4.60, result; int num1 = 26, num2 = 4, rem; // Addition operator result = firstNumber + secondNumber; Console.WriteLine("(0) + (1) = (2)", firstNumber, secondNumber, result); // Subtraction operator result = firstNumber - secondNumber; Console.WriteLine("(0) - (1) = (2)", firstNumber, secondNumber, result); // Multiplication operator result = firstNumber * secondNumber; Console.WriteLine("(0) * (1) = (2)", firstNumber, secondNumber, result); // Division operator result = firstNumber / secondNumber; Console.WriteLine("(0) / (1) = (2)", firstNumber, secondNumber, result); // Modulo operator rem = num1 % num2; Console.WriteLine("(0) % (1) = (2)", num1, num2, rem); ) ) )
Quando eseguiamo il programma, l'output sarà:
14,4 + 4,6 = 19 14,4 - 4,6 = 9,8 14,4 * 4,6 = 66,24 14,4 / 4,6 = 3,1304347826087 26% 4 = 2
Le operazioni aritmetiche vengono eseguite nell'esempio precedente. Le variabili possono essere sostituite da costanti nelle istruzioni. Per esempio,
risultato = 4,5 + 2,7; // il risultato conterrà 7.2 result = firstNumber - 3.2; // il risultato rimarrà 11.2
3. Operatori relazionali
Gli operatori relazionali vengono utilizzati per verificare la relazione tra due operandi. Se la relazione è vera il risultato sarà true
, altrimenti risulterà false
.
Gli operatori relazionali vengono utilizzati nel processo decisionale e nei cicli.
Operatori relazionali C #Operatore | Nome operatore | Esempio |
---|---|---|
== | Uguale a | 6 == 4 restituisce falso |
> | Più grande di | 3> -1 restituisce true |
< | Meno di | 5 <3 restituisce falso |
> = | Maggiore o uguale a | 4> = 4 restituisce true |
<= | Minore o uguale a | 5 <= 3 restituisce falso |
! = | Non uguale a | 10! = 2 restituisce true |
Esempio 3: operatori relazionali
using System; namespace Operator ( class RelationalOperator ( public static void Main(string() args) ( bool result; int firstNumber = 10, secondNumber = 20; result = (firstNumber==secondNumber); Console.WriteLine("(0) == (1) returns (2)",firstNumber, secondNumber, result); result = (firstNumber> secondNumber); Console.WriteLine("(0)> (1) returns (2)",firstNumber, secondNumber, result); result = (firstNumber < secondNumber); Console.WriteLine("(0) = secondNumber); Console.WriteLine("(0)>= (1) returns (2)",firstNumber, secondNumber, result); result = (firstNumber <= secondNumber); Console.WriteLine("(0) <= (1) returns (2)",firstNumber, secondNumber, result); result = (firstNumber != secondNumber); Console.WriteLine("(0) != (1) returns (2)",firstNumber, secondNumber, result); ) ) )
Quando eseguiamo il programma, l'output sarà:
10 == 20 restituisce False 10> 20 restituisce False 10 = 20 restituisce False 10 <= 20 restituisce True 10! = 20 restituisce True
4. Operatori logici
Operatori logici vengono utilizzati per eseguire un'operazione logica, come and
, or
. Gli operatori logici operano su espressioni booleane ( true
e false
) e restituiscono valori booleani. Gli operatori logici vengono utilizzati nel processo decisionale e nei cicli.
Ecco come viene valutato il risultato per la logica AND
e gli OR
operatori.
Operando 1 | Operando 2 | OR (||) | E (&&) |
---|---|---|---|
vero | vero | vero | vero |
vero | falso | vero | falso |
falso | vero | vero | falso |
falso | falso | falso | falso |
In parole semplici, la tabella può essere riassunta come:
- Se uno degli operandi è vero, l'
OR
operatore lo valuteràtrue
. - Se uno degli operandi è falso, l'
AND
operatore lo valuteràfalse
.
Esempio 4: operatori logici
using System; namespace Operator ( class LogicalOperator ( public static void Main(string() args) ( bool result; int firstNumber = 10, secondNumber = 20; // OR operator result = (firstNumber == secondNumber) || (firstNumber> 5); Console.WriteLine(result); // AND operator result = (firstNumber == secondNumber) && (firstNumber> 5); Console.WriteLine(result); ) ) )
Quando eseguiamo il programma, l'output sarà:
Vero falso
5. Operatori unari
A differenza di altri operatori, gli operatori unari operano su un singolo operando.
Operatori unari C #Operatore | Nome operatore | Descrizione |
---|---|---|
+ | Unario Plus | Lascia il segno dell'operando così com'è |
- | Unario meno | Inverte il segno dell'operando |
++ | Incremento | Incrementa il valore di 1 |
- | Decremento | Diminuisci il valore di 1 |
! | Negazione logica (non) | Inverte il valore di un booleano |
Esempio 5: operatori unari
using System; namespace Operator ( class UnaryOperator ( public static void Main(string() args) ( int number = 10, result; bool flag = true; result = +number; Console.WriteLine("+number = " + result); result = -number; Console.WriteLine("-number = " + result); result = ++number; Console.WriteLine("++number = " + result); result = --number; Console.WriteLine("--number = " + result); Console.WriteLine("!flag = " + (!flag)); ) ) )
Quando eseguiamo il programma, l'output sarà:
+ numero = 10 -numero = -10 ++ numero = 11 --numero = 10! flag = False
Gli operatori di incremento (++)
e decremento (--)
possono essere utilizzati come prefisso e suffisso. Se usato come prefisso, il cambio di valore della variabile viene visto sulla stessa riga e se usato come suffisso, il cambio di valore della variabile viene visto sulla riga successiva. Ciò risulterà chiaro dall'esempio seguente.
Esempio 6: operatori di post e pre incremento in C #
using System; namespace Operator ( class UnaryOperator ( public static void Main(string() args) ( int number = 10; Console.WriteLine((number++)); Console.WriteLine((number)); Console.WriteLine((++number)); Console.WriteLine((number)); ) ) )
Quando eseguiamo il programma, l'output sarà:
10 11 12 12
We can see the effect of using ++
as prefix and postfix. When ++
is used after the operand, the value is first evaluated and then it is incremented by 1
. Hence the statement
Console.WriteLine((number++));
prints 10
instead of 11
. After the value is printed, the value of number is incremented by 1
.
The process is opposite when ++
is used as prefix. The value is incremented before printing. Hence the statement
Console.WriteLine((++number));
prints 12
.
The case is same for decrement operator (--)
.
6. Ternary Operator
The ternary operator ? :
operates on three operands. It is a shorthand for if-then-else
statement. Ternary operator can be used as follows:
variable = Condition? Expression1 : Expression2;
L'operatore ternario funziona come segue:
- Se l'espressione dichiarata da Condizione è
true
, il risultato di Expression1 viene assegnato alla variabile. - In caso affermativo
false
, il risultato di Expression2 viene assegnato alla variabile.
Esempio 7: operatore ternario
using System; namespace Operator ( class TernaryOperator ( public static void Main(string() args) ( int number = 10; string result; result = (number % 2 == 0)? "Even Number" : "Odd Number"; Console.WriteLine("(0) is (1)", number, result); ) ) )
Quando eseguiamo il programma, l'output sarà:
10 è il numero pari
Per ulteriori informazioni, visita Operatore ternario C #.
7. Operatori Bitwise e Bit Shift
Gli operatori bit per bit e di spostamento bit vengono utilizzati per eseguire operazioni di manipolazione dei bit.
Operatori C # Bitwise e Bit ShiftOperatore | Nome operatore |
---|---|
~ | Bitwise Complement |
& | Bitwise AND |
| | OR bit per bit |
^ | OR esclusivo bit per bit |
<< | Spostamento sinistro bit per bit |
>> | Spostamento bit per bit destro |
Esempio 8: bitwise e bit Shift Operator
using System; namespace Operator ( class BitOperator ( public static void Main(string() args) ( int firstNumber = 10; int secondNumber = 20; int result; result = ~firstNumber; Console.WriteLine("~(0) = (1)", firstNumber, result); result = firstNumber & secondNumber; Console.WriteLine("(0) & (1) = (2)", firstNumber,secondNumber, result); result = firstNumber | secondNumber; Console.WriteLine("(0) | (1) = (2)", firstNumber,secondNumber, result); result = firstNumber secondNumber; Console.WriteLine("(0) (1) = (2)", firstNumber,secondNumber, result); result = firstNumber << 2; Console.WriteLine("(0) <> 2; Console.WriteLine("(0)>> 2 = (1)", firstNumber, result); ) ) )
Quando eseguiamo il programma, l'output sarà:
~ 10 = -11 10 e 20 = 0 10 | 20 = 30 10 20 = 30 10 <> 2 = 2
Per saperne di più, visita C # Bitwise and Bit Shift operator.
8. Operatori di assegnazione composti
Operatori di assegnazione composti C #Operatore | Nome operatore | Esempio | Equivalente a |
---|---|---|---|
+ = | Assegnazione di addizioni | x += 5 | x = x + 5 |
- = | Assegnazione di sottrazione | x -= 5 | x = x - 5 |
* = | Assegnazione di moltiplicazione | x *= 5 | x = x * 5 |
/ = | Assegnazione della divisione | x /= 5 | x = x / 5 |
% = | Assegnazione modulo | x %= 5 | x = x % 5 |
& = | Assegnazione AND bit per bit | x &= 5 | x = x & 5 |
| = | Assegnazione OR bit per bit | x |= 5 | x = x | 5 |
= | Assegnazione XOR bit per bit | x ^= 5 | x = x 5 |
<< = | Assegnazione dello spostamento a sinistra | x <<= 5 | x = x << 5 |
>> = | Assegnazione dello spostamento a destra | x>>= 5 | x = x>> 5 |
=> | Operatore Lambda | x => x*x | Returns x*x |
Esempio 9: operatore di assegnazione composto
using System; namespace Operator ( class BitOperator ( public static void Main(string() args) ( int number = 10; number += 5; Console.WriteLine(number); number -= 3; Console.WriteLine(number); number *= 2; Console.WriteLine(number); number /= 3; Console.WriteLine(number); number %= 3; Console.WriteLine(number); number &= 10; Console.WriteLine(number); number |= 14; Console.WriteLine(number); number ^= 12; Console.WriteLine(number); number <>= 3; Console.WriteLine(number); ) ) )
Quando eseguiamo il programma, l'output sarà:
15 12 24 8 2 2 14 2 8 1
Discuteremo degli operatori Lambda nel tutorial successivo.