Aritmetické operátory (Referenční příručka jazyka C#)

Následující operátory provádějí aritmetické operace s operandy číselných typů:

• Unární ++ operátory (přírůstkové), -- (dekrementační), + (plus)a - (minus)
• Binární * operátory (násobení), / (dělení), % (zbytek), + (sčítání)a - (odčítání)

Tyto operátory jsou podporovány všemi integrálními číselnými typy a číselnými typy s plovoucí desetinnou čárkou.

V případě integrálních typů jsou tyto operátory (s výjimkou operátorů a) definovány pro typy ++ -- , , a int uint long ulong . Pokud jsou operandy jiných celočíselného typu ( , , , nebo ), jejich hodnoty jsou převedeny na typ , což je také výsledný sbyte byte typ short ushort char int operace. Pokud jsou operandy různých integrálních typů nebo typů s plovoucí desetinnou čárkou, jejich hodnoty jsou převedeny na nejbližší obsahující typ, pokud takový typ existuje. Další informace najdete v části Číselné povýšení specifikace jazyka C#. Operátory ++ a jsou definovány pro všechny celočíselné typy a číselné typy s plovoucí -- desetinnou čárkou a typ typu char.

Operátor inkrementování ++

Operátor unárního ++ přírůstku zvýší svůj operand o 1. Operandem musí být proměnná, přístup k vlastnostem nebo přístup indexeru.

Operátor přírůstku je podporován ve dvou podobách: příponový operátor přírůstku a operátor x++ přírůstku předpony ++x .

Příponový operátor inkrementace

Výsledkem je x++ hodnota před x operací , jak ukazuje následující příklad:

int i = 3;
Console.WriteLine(i);   // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i);   // output: 4

Operátor přírůstku předpony

Výsledkem je ++x hodnota za x operací , jak ukazuje následující příklad:

double a = 1.5;
Console.WriteLine(a);   // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a);   // output: 2.5

Operátor dekrementování --

Operátor unárního dekrementování -- sníží svůj operand o 1. Operandem musí být proměnná, přístup k vlastnostem nebo přístup indexeru.

Operátor dekrementování je podporován ve dvou podobách: příponový operátor dekrementování a operátor x-- dekrementování předpony --x .

Příponový operátor dekrementace

Výsledkem je x-- hodnota před x operací , jak ukazuje následující příklad:

int i = 3;
Console.WriteLine(i);   // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i);   // output: 2

Operátor dekrementování předpony

Výsledkem je --x hodnota za x operací , jak ukazuje následující příklad:

double a = 1.5;
Console.WriteLine(a);   // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a);   // output: 0.5

Unární operátory plus a minus

Unární + operátor vrátí hodnotu svého operandu. Unární - operátor vypočítá číselnou negaci svého operandu.

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

Typ ulong nepodporuje unární - operátor.

Operátor násobení *

Operátor násobení * vypočítá součet svých operandů:

Console.WriteLine(5 * 2);         // output: 10
Console.WriteLine(0.5 * 2.5);     // output: 1.25
Console.WriteLine(0.1m * 23.4m);  // output: 2.34

Unární operátor * je operátor dereference ukazatele.

Operátor dělení /

Operátor dělení / rozdělí svůj levý operand svým operandem na pravé straně.

Dělení celých čísel

Pro operandy celočíselných typů je výsledek operátoru celočíselného typu a rovná se podílu dvou / operandů zaokrouhlených na nulu:

Console.WriteLine(13 / 5);    // output: 2
Console.WriteLine(-13 / 5);   // output: -2
Console.WriteLine(13 / -5);   // output: -2
Console.WriteLine(-13 / -5);  // output: 2

Pokud chcete získat podíl dvou operandů jako číslo s plovoucí desetinnou čárkou, použijte typ float double , nebo decimal :

Console.WriteLine(13 / 5.0);       // output: 2.6

int a = 13;
int b = 5;
Console.WriteLine((double)a / b);  // output: 2.6

Dělení s plovoucí desetinnou čárkou

Pro typy , a je výsledkem operátoru podíl float double dvou decimal / operandů:

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

Pokud je jeden z operandů , jiný operand nemůže být ani , protože ani není decimal float double float double implicitně převoditelný na decimal . Je nutné explicitně float převést double operand nebo na decimal typ. Další informace o převodech mezi číselnými typy najdete v tématu Předdefinování číselných převodů.

Operátor zbytku v %

Operátor zbytku vypočítá zbytek po vydělení levého % operandu svým operandem na pravé straně.

Zbytek celých čísel

Pro operandy celočíselných typů je výsledkem a % b hodnota vytvořená pomocí a - (a / b) * b . Znaménko nenulové zbytku je stejné jako znaménko levého operandu, jak ukazuje následující příklad:

Console.WriteLine(5 % 4);   // output: 1
Console.WriteLine(5 % -4);  // output: 1
Console.WriteLine(-5 % 4);  // output: -1
Console.WriteLine(-5 % -4); // output: -1

K Math.DivRem výpočtu celočíselného dělení i zbývajících výsledků použijte metodu .

Zbytek s plovoucí desetinnou čárkou

Pro operandy a je výsledkem pro konečný výsledek a float double hodnota x % y x y z taková, že

• Znaménko z , pokud je nenulové, je stejné jako znaménko x .
• Absolutní hodnota je hodnota vytvořená pomocí , kde je největší možné celé číslo, které je menší nebo rovno a jsou absolutní hodnoty a z |x| - n * |y| v uvedeném n |x| / |y| |x| |y| x y pořadí.

Informace o chování operátoru s ne konečnými operandy najdete v části Operátor zbytku specifikace jazyka % C#.

Pro decimal operandy je operátor zbytku % ekvivalentní zbytku operátoru System.Decimal typu.

Následující příklad ukazuje chování operátoru zbytku s operandy s plovoucí desetinnou čárkou:

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

Operátor sčítání +

Operátor + sčítání vypočítá součet svých operandů:

Console.WriteLine(5 + 4);       // output: 9
Console.WriteLine(5 + 4.3);     // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3

Operátor můžete použít také + pro kombinaci zřetězení řetězců a delegáta. Další informace najdete v článku + += Operátory a .

Operátor odčítání –

Operátor odčítání - odečte svůj operand na pravé straně od levého operandu:

Console.WriteLine(47 - 3);      // output: 44
Console.WriteLine(5 - 4.3);     // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2

K odebrání delegáta - můžete použít také operátor . Další informace najdete v článku - -= Operátory a .

Složené přiřazení

Výraz složeného přiřazení formuláře pro op binární operátor

x op= y

je ekvivalentem

x = x op y

s tím x rozdílem, že se vyhodnocuje jenom jednou.

Následující příklad ukazuje použití složeného přiřazení s aritmetickými operátory:

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

Z důvodu číselných povýšenínemusí být výsledek operace op implicitně převoditelný na T typ x . Pokud je v takovém případě předdefinovaný operátor a výsledek operace je explicitně převoditelný na typ , je výraz složeného přiřazení formuláře ekvivalentní s tím rozdílem, že se vyhodnotí pouze op T x x op= y x = (T)(x op y) x jednou. Toto chování je znázorněno v následujícím příkladu:

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

Operátory a můžete také použít k přihlášení k odběru události a odhlášení odběru += -= události(v uvedeném pořadí). Další informace najdete v tématu Jak se přihlásit k odběrua zrušit odběr událostí.

Priorita a asociativita operátorů

Následující seznam seřazené aritmetické operátory začínají od nejvyšší priority po nejnižší:

• Příponové x++ operátory inkrementování a x-- dekrementování
• ++xInkrementační a dekrementační --x předpony a unární + - operátory a
• Operátory * násobení, / a %
• +Sčítání - a operátory

Binární aritmetické operátory jsou asociativní doleva. To znamená, že operátory se stejnou úrovní priority se vyhodnocují zleva doprava.

Pomocí závorek změňte pořadí vyhodnocení () vynucované prioritou operátorů a asociativitou.

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

Úplný seznam operátorů jazyka C# seřazených podle úrovně priority najdete v části Priorita operátorů v článku Operátory jazyka C#.

Aritmetické přetečení a dělení nulou

Pokud je výsledek aritmetické operace mimo rozsah možných konečných hodnot zapojeného číselného typu, závisí chování aritmetického operátoru na typu jeho operandů.

Celočíselný aritmetický přetečení

Celočíselné dělení nulou vždy vyvolá DivideByZeroException .

V případě celočíselného aritmetického přetečení řídí výsledné chování kontext kontroly přetečení, který lze zkontrolovat nebo zrušit jeho zaškrtnutí:

• Pokud ve kontrolovaném kontextu dojde k přetečení konstantního výrazu, dojde k chybě při kompilaci. V opačném případě, když je operace provedena za běhu, OverflowException je vyvolána.
• V nezaškrtnutém kontextu se výsledek zkrátí tím, že se zahodí všechny bity vyššího řádu, které se nevejdou do cílového typu.

Spolu se zaškrtnutou a nezaškrtnutou kontrolou příkazů můžete pomocí operátorů a řídit kontext kontroly přetečení, ve kterém checked se výraz unchecked vyhodnocuje:

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}.");
}

Ve výchozím nastavení se aritmetické operace vyskytují v nezaškrtnutém kontextu.

Aritmetický přetečení s plovoucí desetinnou čárkou

Aritmetické operace s typy a float double nikdy nevyhodí výjimku. Výsledkem aritmetických operací s těmito typy může být jedna z speciálních hodnot, které reprezentují nekonečno a nikoli-a-číslo:

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

U operandů decimal typu aritmetické přetečení vždy vyvolá výjimku OverflowException a dělení nulou vždy vyvolá DivideByZeroException .

Chyby zaokrouhlení

Z důvodu obecného omezení reprezentace reálných čísel s plovoucí desetinnou čárkou a aritmetických operací s plovoucí desetinnou čárkou mohou být při výpočtech s typy s plovoucí desetinnou čárkou zjištěny chyby zaokrouhlení. To znamená, že získaný výsledek výrazu se může lišit od očekávaného matematického výsledku. Následující příklad ukazuje několik takových případů:

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

Další informace najdete v tématu poznámky na referenčních stránkách System. Double, System. Singlenebo System. Decimal .

Přetížení operátoru

Uživatelsky definovaný typ může přetížit unární ++ -- + aritmetické operátory (,,, a - ) a binární ( * ,,,, / % + a - ). Při přetížení binárního operátoru je také implicitně přetížen odpovídající operátor složeného přiřazení. Uživatelsky definovaný typ nemůže explicitně přetížit operátor složeného přiřazení.

specifikace jazyka C#

Další informace naleznete v následujících oddílech specifikace jazyka C#:

• Operátory přírůstku a snížení přípony
• Operátory inkrementace a dekrementace předpony
• Unární operátor plus
• Operátor unární minus
• Operátor násobení
• Operátor dělení
• Operátor zbývající
• Operátor sčítání
• Operátor odčítání
• Složené přiřazení
• Kontrolované a nezaškrtnuté operátory
• Číselné propagační akce

Viz také

• Referenční dokumentace k jazyku C#
• Operátory a výrazy v C#
• System.Math
• System.MathF
• Číslovky v technologii .NET