Operátory jazyka C#

Tip

Tento článek je součástí části Základy pro vývojáře, kteří už znají aspoň jeden programovací jazyk a učí se jazyk C#. Pokud s programováním teprve začínáte, začněte nejprve kurzy Začínáme .

Pochází z jiného jazyka? Většina operátorů v tomto článku (+, *, &&, -, /, %, ||, !, ==, !=, <, >, relační operátory a =) funguje stejně jako v Javě, C++ a JavaScriptu. Hlavními překvapeními pro nováčky jsou chování celočíselného dělení, rozdíl mezi prefixovým a postfixovým zápisem u ++/-- a způsob, jakým složené přiřazení převádí výsledek zpět na typ levé strany.

Operátor kombinuje jeden nebo více operandů do jedné hodnoty. Už víte o výrazech a prioritách operátorů z výrazů jazyka C#; tento článek se podrobněji zabývá konkrétními operátory, které budete používat každý den.

Aritmetické operátory

Pět aritmetických operátorů provádí číselné výpočty.

Operator Název Příklad Výsledek
+ Sčítání 10 + 3 13
- Odčítání 10 - 3 7
* Násobení 10 * 3 30
/ Oddělení 10 / 3 3
% Zůstatek 10 % 3 1 
int apples = 10;
int oranges = 3;

Console.WriteLine(apples + oranges);  // => 13  (addition)
Console.WriteLine(apples - oranges);  // => 7   (subtraction)
Console.WriteLine(apples * oranges);  // => 30  (multiplication)
Console.WriteLine(apples / oranges);  // => 3   (integer division: truncates toward zero)
Console.WriteLine(apples % oranges);  // => 1   (remainder)

// Integer division always truncates toward zero — the fractional part is discarded
int result = 7 / 2;
Console.WriteLine(result); // => 3, not 3.5

// Truncation applies to negative results too: -7 / 2 is -3, not -4
int negResult = -7 / 2;
Console.WriteLine(negResult); // => -3

// To get a decimal result, at least one operand must be a double or float
double precise = 7.0 / 2;
Console.WriteLine(precise); // => 3.5

// Remainder with negative operands: the sign of the result matches the dividend
Console.WriteLine(-7 % 3);  // => -1  (-7 = 3 × -2 + (-1))
Console.WriteLine(7 % -3);  // => 1   ( 7 = -3 × -2 + 1)

Celočíselné dělení se zkrátí směrem k nule. Pokud jsou oba operandy celá čísla, / zahodí zlomkovou část: 7 / 2 není 3.3.5 Zkrácení je směrem k nule, ne k menšímu číslu: -7 / 2 je -3 (ne -4). Chcete-li získat desetinný výsledek, musí být alespoň jeden operand typu s plovoucí řádovou čárkou: 7.0 / 2 je 3.5. To se liší od některých jazyků, kde / vždy vrací výsledek typu s plovoucí řádovou čárkou.

Zbytek (%) vrací to, co zůstane po celočíselném dělení: 10 % 3 je 1, protože 10 = 3 × 3 + 1. Je užitečné pro iteraci v pevném rozsahu (index % length), testování dělitelnosti (n % 2 == 0) a získávání číslic. Se zápornými operandy se znaménko výsledku shoduje se znaménkem dividendy (levý operand): -7 % 3 je -1 a 7 % -3 je 1.

Unární operátory

Unární operátory fungují na jednom operandu.

int temperature = 20;
int windChill = -5;

int heatIndex = +temperature;   // unary +: value unchanged (rarely needed)
int coldFactor = -windChill;    // unary -: negates the value → 5

Console.WriteLine(heatIndex);   // => 20
Console.WriteLine(coldFactor);  // => 5

bool isRaining = false;
bool isSunny = !isRaining;     // logical NOT: flips true/false
Console.WriteLine(isSunny);    // => True
  • +x (unární plus) – ponechá hodnotu beze změny; zřídka napsané explicitně, ale platné.
  • -x (unární minus) – neguje hodnotu.
  • !x (logická NOT) – překlopí true na false a false na true. Často použijete ! : if (!list.Contains(item)).

Inkrementace a dekrementace

++ sčítá 1 a -- odečte 1. Oba mají tvar předpony a tvar přípony, které se liší tím, jaká hodnota se vrací:

int counter = 5;

// Prefix: increment first, then use the new value
int a = ++counter;
Console.WriteLine(a);       // => 6
Console.WriteLine(counter); // => 6

// Postfix: use the current value first, then increment
int b = counter++;
Console.WriteLine(b);       // => 6  (value before increment)
Console.WriteLine(counter); // => 7  (incremented after)

// Decrement works the same way
int score = 10;
Console.WriteLine(score--); // => 10 (current value; score becomes 9)
Console.WriteLine(score);   // => 9
  • Předpona (++i, --i): nejprve zvýší nebo sníží proměnnou a pak vrátí novou hodnotu.
  • Postfix (i++, i--): nejprve vrátí aktuální hodnotu a poté inkrementuje nebo dekrementuje proměnnou.

Pokud ++ nebo -- se zobrazí jako samostatný příkaz (není součástí většího výrazu), mají předpona a příponu stejný účinek. Rozlišení záleží jenom v případě, že se použije výsledek , například v přiřazení nebo jako argument metody.

Relační operátory

Relační operátory porovnávají dvě hodnoty a vrací boolhodnotu .

Operator Význam Příklad
< Menší než speed < limit
> Je větší než speed > limit
<= Menší než nebo rovno score <= 100
>= Větší nebo rovno score >= 0 
int speed = 75;
int limit = 60;

Console.WriteLine(speed > limit);   // => True   (greater than)
Console.WriteLine(speed < limit);   // => False  (less than)
Console.WriteLine(speed >= limit);  // => True   (greater than or equal)
Console.WriteLine(speed <= limit);  // => False  (less than or equal)

// Relational operators work on all numeric types and char
// char comparison uses the character's numeric Unicode code point, not alphabetical position
// 'B' (U+0042, value 66) is less than 'A' (U+0041, value 65)? No — 'A' (65) < 'B' (66)
char grade = 'B';
Console.WriteLine(grade >= 'A' && grade <= 'C'); // => True  ('A'=65 <= 'B'=66 <= 'C'=67)

Relační operátory pracují na všech číselných typech a char. Porovnání charpoužívá číselnou hodnotu znakového bodu Unicode, nikoli žádné abecední řazení nebo řazení specifické pro doménu. Ve výše uvedeném příkladu známek je 'A' větší než nebo rovno 'B', protože 'B' má hodnotu Unicode 66 a 'A' má hodnotu Unicode 65 – čísla určují porovnání, nikoli význam písmenných známek.

Operátory rovnosti

== a != zkontrolujte, jestli jsou dvě hodnoty stejné nebo ne. != je true, pokud se operandy nerovnají, a false, pokud ano.

int expected = 42;
int actual = 42;

Console.WriteLine(actual == expected);  // => True   (values are equal)
Console.WriteLine(actual != expected);  // => False  (true when values are not equal)

string name = "Alice";
Console.WriteLine(name == "Alice");  // => True   (string content matches)
Console.WriteLine(name == "alice");  // => False  (case-sensitive)

int x = 5;
Console.WriteLine(x == 10);  // => False

U číselných typů a stringse při testu rovnosti porovnávají hodnoty. U referenčních typů je výchozím způsobem porovnání identita (zda dvě proměnné odkazují na stejný objekt), ale mnoho typů, včetně string a record, toto chování přepisuje tak, aby se porovnával obsah. Úplný obrázek – jak rovnost funguje napříč typy hodnot, odkazovými typy, záznamy a strukturami – najdete v tématu Porovnání rovnosti.

Note

Jazyk C# nemá === operátor. Zápis === je chyba v době kompilace:

// This does not compile — C# has no === operator
bool same = (x === 10);

Pokud pocházíte z JavaScriptu, použijte == k porovnání hodnot (jazyk C# == se už porovnává podle hodnoty pro primitivní typy a řetězce). Běžnou související chybou je náhodné psaní = (přiřazení), kde jste mysleli == (kontrola rovnosti). Kompilátor zachytí nejběžnější formuláře, ale pečlivě zkontroluje všechny if podmínky, které obsahují =.

Podmíněné logické operátory

&& (AND) a || (OR) kombinují bool výrazy.

int age = 20;
bool hasTicket = true;

// && (AND): both sides must be true
bool canEnter = age >= 18 && hasTicket;
Console.WriteLine(canEnter); // => True

// || (OR): at least one side must be true
bool freeEntry = age < 5 || age >= 65;
Console.WriteLine(freeEntry); // => False

// Short-circuit: right side is skipped when the result is already determined
// Here, items.Count is never called if items is null
List<string>? items = null;
bool hasItems = items != null && items.Count > 0;
Console.WriteLine(hasItems); // => False  (short-circuits; no NullReferenceException)

Oba operátory používají zkrácené vyhodnocování: pravý operand nevyhodnocují, pokud je výsledek už určen.

  • && vrátí false, jakmile je levá strana false. Pravá strana se nikdy nevyhodnocuje.
  • || vrátí true, jakmile je levá strana true. Pravá strana se nikdy nevyhodnocuje.

Chování krátkého okruhu má praktickou výhodu: můžete bezpečně chránit operaci na pravé straně pomocí kontroly null na levé straně, jak ukazuje příklad výše. Pokud je itemsnull, && se tam zastaví — items.Count se nikdy nezavolá, takže není vyvolána žádná NullReferenceException.

Podmíněný operátor ?:

Podmíněný operátor (označovaný také jako ternární operátor) vyhodnocuje jeden ze dvou výrazů na základě podmínky:

condition ? value-when-true : value-when-false

int temperature2 = 35;

// condition ? value-when-true : value-when-false
string weather = temperature2 > 30 ? "hot" : "comfortable";
Console.WriteLine(weather); // => hot

// Only the matching branch evaluates — the other branch is never run
int divisor = 0;
// The division 10 / divisor is never evaluated because divisor == 0 is true
int safe = divisor == 0 ? -1 : 10 / divisor;
Console.WriteLine(safe); // => -1

Operátor ?: vždy vyhodnotí přesně jednu větev – strana, která neodpovídá podmínce, se nikdy nevyhodnocuje. Díky tomu je bezpečné používat výraz na jedné straně, který by selhal pro jiné vstupy, pokud podmínka správně chrání.

Použijte ?: pro jednoduché vložené volby. Pro vícecestné podmínky nebo bloky kódu je obvykle jasnější příkaz if/else.

Operátory přiřazení

Operátor = jednoduchého přiřazení ukládá hodnotu do proměnné:

int level = 1;  // declaration + initialization
level = 5;      // reassignment

Přiřazení v jazyce C# je pravostranně asociativní, což znamená, že a = b = c = 0 se vyhodnocuje zprava doleva: c je přiřazeno 0, potom b je přiřazeno a a potom 0 je přiřazeno 0.

Složené přiřazení

Operátory složeného přiřazení kombinují binární operaci s přiřazením:

Operator Ekvivalentní k
x += y x = x + y
x -= y x = x - y
x *= y x = x * y
x /= y x = x / y
x %= y x = x % y 
int level = 1;
level = 5;          // simple assignment: replaces the value
Console.WriteLine(level); // => 5

// Compound assignment: short form of binary operation + assignment
int hp = 100;
hp += 20;   // same as: hp = hp + 20
Console.WriteLine(hp); // => 120
hp -= 10;   // same as: hp = hp - 10
Console.WriteLine(hp); // => 110
hp *= 2;    // same as: hp = hp * 2
Console.WriteLine(hp); // => 220
hp /= 3;    // same as: hp = hp / 3 (integer division)
Console.WriteLine(hp); // => 73
hp %= 7;    // same as: hp = hp % 7
Console.WriteLine(hp); // => 3

Složené přiřazení je více než jen zkratka. Vyhodnotí levou stranu přesně jednou a výsledek pak převede zpět na typ na levé straně. To je důležité, když má levá strana vedlejší účinky (například indexátor pole), a proto lze složené přiřazení u proměnné byte zkompilovat bez explicitního přetypování, zatímco rozepsaná forma nikoli:

// Assignment is right-associative: evaluated right to left
int a2, b2, c2;
a2 = b2 = c2 = 0;     // c2 = 0 first, then b2 = 0, then a2 = 0
Console.WriteLine($"{a2} {b2} {c2}"); // => 0 0 0

// Compound assignment evaluates the left side once and converts back to the LHS type
byte small = 200;
small += 10;  // equivalent to: small = (byte)(small + 10); result is 210
Console.WriteLine(small); // => 210

small += 10 se zkompiluje, protože kompilátor automaticky provede zužující konverzi – výsledek 210 spadá do rozsahu byte 0–255. small = small + 10 by vyžadovalo explicitní přetypování na typ (byte), protože aritmetické operace převádějí oba operandy na int.

Další operátory jazyka C#

Tento článek se zabývá operátory, se kterými se setkáte nejčastěji v každodenním kódu. Jazyk C# obsahuje více operátorů užitečných v konkrétních scénářích:

  • Operátory shift (<<, >>, >>>) – posune bity celočíselné hodnoty doleva nebo doprava o zadaný počet pozic. Bitové a celočíselné logické operátory (&, |, ^, ~) – sloučí nebo invertují celočíselné hodnoty po jednom bitu, jsou užitečné v příznakech, maskách a kódu nízké úrovně: Bitové operátory a operátory posunu
  • checked a unchecked – určuje, jestli celé číslo přetečení vyvolá výjimku (checked) nebo zalamuje bezobslužně (unchecked): Zaškrtnuté a nezaškrtnuté
  • Operátory pro hodnotu null (??, ??=, ?., ?[]) — bezpečně zpracovávají hodnoty null poskytnutím výchozích hodnot nebo zkráceným vyhodnocením přístupu ke členům: Operátory pro hodnotu null
  • Operátory testování typu a převodu (is, as, typeof, přetypování ) — ověření nebo převod typu hodnoty za běhu: (T)
  • Operátory rozsahů a indexů (.., ^) – vytváří rozsahy a koncové relativní indexy pro vytváření řezů polí a rozsahů: Přístup členů a podmíněné operátory s hodnotou null
  • Dekonstrukční přiřazení – rozložení řazené n-tice nebo typu na jednotlivé proměnné v jednom výrazu: Dekonstrukce řazených n-tic a dalších typů

Viz také

  • Last updated on