Operatori aritmetici (Riferimenti per C#)
Gli operatori seguenti eseguono operazioni aritmetiche con operandi di tipi numerici:
- Operatori unari
++
(incremento),--
(decremento),+
(più) e-
(meno) - Operatori binari
*
(moltiplicazione),/
(divisione),%
(resto),+
(addizione) e-
(sottrazione)
Questi operatori sono supportati da tutti i tipi numerici integrali e a virgola mobile.
Nel caso dei tipi integrali, tali operatori (ad eccezione degli operatori ++
e --
) vengono definiti per i tipi int
, uint
, long
e ulong
. Quando gli operandi sono di altri tipi integrali (sbyte
, byte
, short
, ushort
o char
), i relativi valori vengono convertiti nel tipo int
, che è anche il tipo di risultato di un'operazione. Quando gli operandi sono di tipi integrali o a virgola mobile diversi, i relativi valori vengono convertiti nel tipo contenitore più vicino, se tale tipo esiste. Per altre informazioni, vedere la sezione Promozioni numeriche della specifica del linguaggio C#. Gli operatori ++
e --
sono definiti per tutti i tipi numerici integrali e a virgola mobile e il tipo char. Il tipo di risultato di un'espressione di assegnazione composta è il tipo dell'operando di sinistra.
L'operatore di incremento unario ++
incrementa il suo operando di 1. L'operando deve essere una variabile, un accesso a una proprietà o un accesso a un indicizzatore.
L'operatore di incremento è supportato in due forme: l'operatore di incremento suffisso, x++
, e l'operatore di incremento prefisso, ++x
.
Il risultato di x++
è il valore di x
prima dell'operazione, come illustrato nell'esempio seguente:
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
Il risultato di ++x
è il valore di x
dopo l'operazione, come illustrato nell'esempio seguente:
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
L'operatore di decremento unario --
decrementa il proprio operando di 1. L'operando deve essere una variabile, un accesso a una proprietà o un accesso a un indicizzatore.
L'operatore di decremento è supportato in due forme: l'operatore di decremento suffisso, x--
, e l'operatore di decremento prefisso, --x
.
Il risultato di x--
è il valore di x
prima dell'operazione, come illustrato nell'esempio seguente:
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
Il risultato di --x
è il valore di x
dopo l'operazione, come illustrato nell'esempio seguente:
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
L'operatore +
unario restituisce il valore del proprio operando. L'operatore -
unario calcola la negazione numerica del proprio operando.
Console.WriteLine(+4); // output: 4
Console.WriteLine(-4); // output: -4
Console.WriteLine(-(-4)); // output: 4
uint a = 5;
var b = -a;
Console.WriteLine(b); // output: -5
Console.WriteLine(b.GetType()); // output: System.Int64
Console.WriteLine(-double.NaN); // output: NaN
Il tipo di ulong non supporta l'operatore -
unario.
L'operatore di moltiplicazione *
calcola il prodotto degli operandi:
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
L'operatore *
unario è l'operatore di riferimento indiretto a puntatore.
L'operatore di divisione /
divide l'operando di sinistra per l'operando di destra.
Per gli operandi di tipo Integer, il risultato dell'operatore /
è di tipo Integer ed è uguale al quoziente dei due operandi arrotondato allo zero:
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
Per ottenere il quoziente dei due operandi come numero a virgola mobile, usare il tipo float
, double
,o decimal
:
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
Per i tipi float
, double
e decimal
, il risultato dell'operatore /
è il quoziente dei due operandi:
Console.WriteLine(16.8f / 4.1f); // output: 4.097561
Console.WriteLine(16.8d / 4.1d); // output: 4.09756097560976
Console.WriteLine(16.8m / 4.1m); // output: 4.0975609756097560975609756098
Se uno degli operandi è decimal
, un altro operando non può essere né float
né double
, perché né float
né double
è convertibile implicitamente in decimal
. È necessario convertire esplicitamente l'operando float
o double
nel tipo decimal
. Per altre informazioni sulle conversioni tra tipi numerici, vedere Conversioni numeriche predefinite.
L'operatore di resto %
calcola il resto dopo aver diviso l'operando di sinistra per l'operando di destra.
Per gli operandi di tipi interi, il risultato di a % b
è il valore prodotto da a - (a / b) * b
. Il segno del resto diverso da zero è uguale al segno dell'operando sinistro, come illustrato nell'esempio seguente:
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
Usare il metodo Math.DivRem per calcolare sia la divisione di numeri interi, sia i risultati del resto.
Per gli operandi float
e double
, il risultato di x % y
per x
e y
finiti è il valore z
tale che
- Il segno di
z
, se diverso da zero, è uguale a quello dix
. - Il valore assoluto di
z
è il valore prodotto da|x| - n * |y|
in cuin
è l'intero più grande possibile, che è minore o uguale a|x| / |y|
e|x|
e|y|
sono i valori assoluti dix
ey
, rispettivamente.
Nota
Questo metodo di calcolo del resto è analogo a quello usato per gli operandi integer, ma diverso dalla specifica IEEE 754. Se è necessaria l'operazione di resto conforme alla specifica IEEE 754, usare il metodo Math.IEEERemainder.
Per informazioni sul comportamento dell'operatore %
in caso di operandi non finiti, vedere la sezione Operatore di resto della specifica del linguaggio C#.
Per gli operandi decimal
, l'operatore di resto %
equivale all'operatore di resto di tipo System.Decimal.
L'esempio seguente illustra il comportamento dell'operatore di resto con operandi a virgola mobile:
Console.WriteLine(-5.2f % 2.0f); // output: -1.2
Console.WriteLine(5.9 % 3.1); // output: 2.8
Console.WriteLine(5.9m % 3.1m); // output: 2.8
L'operatore di addizione +
calcola la somma degli operandi:
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
È anche possibile usare l'operatore +
per la concatenazione di stringhe e la combinazione di delegati. Per altre informazioni, vedere l'articolo sugli operatori +
e +=
.
L'operatore di sottrazione -
sottrae l'operando di destra dall'operando di sinistra:
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
È anche possibile usare l'operatore -
per la rimozione dei delegati. Per altre informazioni, vedere l'articolo sugli operatori -
e -=
.
Per un operatore binario op
, un'espressione di assegnazione composta in formato
x op= y
equivale a
x = x op y
con la differenza che x
viene valutato una sola volta.
L'esempio seguente illustra l'uso dell'assegnazione composta con gli operatori aritmetici:
int a = 5;
a += 9;
Console.WriteLine(a); // output: 14
a -= 4;
Console.WriteLine(a); // output: 10
a *= 2;
Console.WriteLine(a); // output: 20
a /= 4;
Console.WriteLine(a); // output: 5
a %= 3;
Console.WriteLine(a); // output: 2
In ragione delle promozioni numeriche il risultato dell'operazione op
potrebbe non essere convertibile in modo implicito nel tipo T
di x
. In questo caso, se op
è un operatore già definito e il risultato dell'operazione è convertibile in modo esplicito nel tipo T
di x
, un'espressione di assegnazione composta nel formato x op= y
equivale a x = (T)(x op y)
, con la differenza che x
viene valutato una sola volta. L'esempio seguente illustra questo comportamento:
byte a = 200;
byte b = 100;
var c = a + b;
Console.WriteLine(c.GetType()); // output: System.Int32
Console.WriteLine(c); // output: 300
a += b;
Console.WriteLine(a); // output: 44
Nell'esempio precedente, il valore 44
è il risultato della conversione del valore 300
nel tipo byte
.
Nota
Nel contesto di controllo dell'overflow controllato, l'esempio precedente genera un OverflowException. Per altre informazioni, vedere la sezione Overflow aritmetico integer.
Si usano anche gli operatori +=
e -=
per sottoscrivere e annullare la sottoscrizione a un evento rispettivamente. Per altre informazioni, vedere Come iscriversi agli eventi e annullare l'iscrizione.
Nell'elenco seguente gli operatori aritmetici sono ordinati dalla precedenza più elevata a quella più bassa:
- Operatori di incremento
x++
e decrementox--
in forma suffissa - Operatori di incremento
++x
e decremento--x
e unari+
e-
- Operatori moltiplicativi
*
,/
e%
- Operatori di addizione
+
e-
Gli operatori aritmetici binari prevedono l'associazione all'operando sinistro. Ciò significa che gli operatori con lo stesso livello di precedenza vengono valutati da sinistra a destra.
Usare le parentesi, ()
, per cambiare l'ordine di valutazione imposto dalla precedenza e dall'associatività degli operatori.
Console.WriteLine(2 + 2 * 2); // output: 6
Console.WriteLine((2 + 2) * 2); // output: 8
Console.WriteLine(9 / 5 / 2); // output: 0
Console.WriteLine(9 / (5 / 2)); // output: 4
Per l'elenco completo degli operatori C# ordinati per livello di priorità, vedere la sezione Priorità degli operatori nell'articolo Operatori C#.
Quando il risultato di un'operazione aritmetica non rientra nell'intervallo di valori finiti possibili del tipo numerico interessato, il comportamento di un operatore aritmetico dipende dal tipo dei relativi operandi.
La divisione di interi per zero genera sempre un'eccezione DivideByZeroException.
Se si verifica un overflow aritmetico integer, il contesto di controllo dell'overflow, che può essere controllato o deselezionato, controlla il comportamento risultante:
- In un contesto verificato, se l'overflow si verifica in un'espressione costante, verrà restituito un errore in fase di compilazione. Quando invece l'operazione avviene in fase di esecuzione, viene generata una OverflowException.
- In un contesto non verificato, il risultato viene troncato tramite la rimozione dei bit più significativi che non rientrano nel tipo di destinazione.
Oltre alle istruzioni controllate e deselezionate, è possibile usare gli operatori checked
e unchecked
per controllare il contesto di controllo dell'overflow, in cui viene valutata un'espressione:
int a = int.MaxValue;
int b = 3;
Console.WriteLine(unchecked(a + b)); // output: -2147483646
try
{
int d = checked(a + b);
}
catch(OverflowException)
{
Console.WriteLine($"Overflow occurred when adding {a} to {b}.");
}
Per impostazione predefinita, le operazioni aritmetiche vengono eseguite in un contesto non verificato.
Le operazioni aritmetiche con i tipi float
e double
non generano mai un'eccezione. Il risultato delle operazioni aritmetiche con questi tipi può essere uno dei valori speciali che rappresentano un numero infinito e non un numero:
double a = 1.0 / 0.0;
Console.WriteLine(a); // output: Infinity
Console.WriteLine(double.IsInfinity(a)); // output: True
Console.WriteLine(double.MaxValue + double.MaxValue); // output: Infinity
double b = 0.0 / 0.0;
Console.WriteLine(b); // output: NaN
Console.WriteLine(double.IsNaN(b)); // output: True
Per gli operandi del tipo decimal
, l'overflow aritmetico genera sempre un OverflowException. La divisione per zero genera sempre un DivideByZeroException.
A causa delle limitazioni generali della rappresentazione a virgola mobile dei numeri reali e dell'aritmetica a virgola mobile, possono verificarsi errori di arrotondamento nei calcoli con tipi a virgola mobile. Ossia, il risultato prodotto di un'espressione può essere diverso dal risultato matematico previsto. L'esempio seguente illustra molti di questi casi:
Console.WriteLine(.41f % .2f); // output: 0.00999999
double a = 0.1;
double b = 3 * a;
Console.WriteLine(b == 0.3); // output: False
Console.WriteLine(b - 0.3); // output: 5.55111512312578E-17
decimal c = 1 / 3.0m;
decimal d = 3 * c;
Console.WriteLine(d == 1.0m); // output: False
Console.WriteLine(d); // output: 0.9999999999999999999999999999
Per altre informazioni, vedere le osservazioni nelle pagine di riferimento System.Double, System.Single o System.Decimal.
Un tipo definito dall'utente può eseguire l'overload degli operatori aritmetici unari (++
, --
, +
e -
) e binari (*
, /
, %
, +
e -
). Quando viene eseguito l'overload di un operatore binario, viene anche eseguito in modo implicito l'overload dell'operatore di assegnazione composta corrispondente. Un tipo definito dall'utente non può eseguire in modo esplicito l'overload di un operatore di assegnazione composta.
A partire da C# 11, quando si esegue l'overload di un operatore aritmetico, è possibile usare la parola chiave checked
per definire la versione controllata di tale operatore. L'esempio seguente illustra come eseguire questa operazione:
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
Quando si definisce un operatore controllato, è necessario definire anche l'operatore corrispondente senza il modificatore checked
. L'operatore controllato viene chiamato in un contesto controllato; l'operatore senza il modificatore checked
viene chiamato in un contesto deselezionato. Se si specifica solo l'operatore senza il modificatore checked
, viene chiamato sia in un contesto checked
che in un contesto unchecked
.
Quando si definiscono entrambe le versioni di un operatore, è previsto che il comportamento sia diverso solo quando il risultato di un'operazione è troppo grande per rappresentare nel tipo di risultato come indicato di seguito:
- Un operatore controllato genera un'eccezione OverflowException.
- Un operatore senza il modificatore
checked
restituisce un'istanza che rappresenta un risultato troncato.
Per informazioni sulla differenza di comportamento degli operatori aritmetici predefiniti, vedere la sezione overflow aritmetico e divisione per zero.
È possibile usare il modificatore checked
solo quando si esegue l'overload di uno degli operatori seguenti:
- Operatori unari
++
,--
e-
- Operatori binari
*
,/
,+
, e-
- Operatori di conversione espliciti
Nota
Il contesto di controllo dell'overflow all'interno del corpo di un operatore controllato non è influenzato dalla presenza del modificatore checked
. Il contesto predefinito è definito dal valore dell'opzione del compilatore CheckForOverflowUnderflow. Utilizzare le istruzioni checked
e unchecked
per specificare in modo esplicito il contesto di controllo dell'overflow, come illustrato nell'esempio all'inizio di questa sezione.
Per altre informazioni, vedere le sezioni seguenti delle specifiche del linguaggio C#:
- Operatori di incremento e decremento in forma suffissa
- Operatori di incremento e decremento in forma prefissa
- Operatore più unario
- Operatore meno unario
- Operatore di moltiplicazione
- Operatore di divisione
- Operatore di resto
- Operatore addizione
- Operatore di sottrazione
- Assegnazione composta
- Operatori Checked e Unchecked
- Promozioni numeriche
Feedback su .NET
.NET è un progetto di open source. Selezionare un collegamento per fornire feedback: