C#-operátorok

Jótanács

Ez a cikk az Alapismeretek szakasz része azon fejlesztők számára, akik már legalább egy programozási nyelvet ismernek, és c#-t tanulnak. Ha még csak most ismerkedik a programozással, először az Első lépések oktatóanyagokkal kezdje.

Más nyelvről jön? A cikk legtöbb operátora (+, , -, /*, %, &&!=||==<!>, összehasonlító operátorok és =) ugyanúgy működnek, mint a Java, a C++ és a JavaScript esetében. Az újonnan érkezők számára a fő meglepetés az egész osztás viselkedése, az előtag/utótag különbségtétele ++/--, valamint az összetett hozzárendelés bal oldali típussá alakításának módja.

Egy operátor egy vagy több operandust egyesít egyetlen értékben. Már ismeri a C#-kifejezések kifejezéseit és operátori elsőbbségét; Ez a cikk részletesebben ismerteti azokat az operátorokat, amelyeket minden nap használni fog.

Aritmetikai operátorok

Az öt számtani operátor numerikus számításokat végez.

Operator Név Example Eredmény
+ Hozzáadás 10 + 3 13
- Kivonás 10 - 3 7
* Szorzás 10 * 3 30
/ Osztály 10 / 3 3
% Maradvány 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)

Az egész szám osztása nulla felé csonkul. Ha mindkét operandus egész szám, a / levágja a törtrészt: 7 / 2 eredménye 3, nem 3.5. A csonkolás nulla felé történik, nem a kisebb szám felé: -7 / 2 az -3 (nem -4). Decimális eredmény lekéréséhez adjon meg legalább egy operandust lebegőpontos típusként: 7.0 / 2 az 3.5. Ez különbözik egyes nyelvektől, ahol / mindig lebegőpontos eredményt ad.

A maradék (%) az egész szám osztása után hátrahagyott értéket adja vissza: 10 % 3 ennek az az oka 1 , hogy 10 = 3 × 3 + 1. Hasznos lehet egy rögzített tartomány bejárásához (index % length), az oszthatóság teszteléséhez (n % 2 == 0) és a számjegyek kinyerésére. Negatív operandusok esetén az eredmény jele megegyezik az osztalék jelével (a bal operandussal): -7 % 3 az -1 és 7 % -3 az 1.

Unary operátorok

Az unáris operátorok egyetlen operandusra hatnak.

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 (unary plus) – változatlanul hagyja az értéket; ritkán íródott explicit módon, de érvényes.
  • -x (unary minus) – az értéket tagadja.
  • !x (logikai NOT) — true értékét true-re, false értékét pedig false-re változtatja. Gyakran fogja használni: !if (!list.Contains(item)).

Növekmény és csökkenés

++ hozzáadja az 1-et, és -- kivonja az 1-et. Mindkettőnek van prefix és postfix alakja, amelyek abban különböznek, hogy melyik érték tér vissza:

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
  • Előtag (++i, --i): először növeli vagy decrementálja a változót, majd visszaadja az új értéket.
  • Postfix (i++,): i--először az aktuális értéket adja vissza, majd növeli vagy decrementálja a változót.

Ha a -- vagy a ++ önálló utasításként jelenik meg (nem egy nagyobb kifejezés részeként), a prefix és a postfix ugyanazzal a hatással jár. A megkülönböztetés csak akkor számít, ha az eredményt használják – például hozzárendelésben vagy metódusargumentumként.

Relációs operátorok

A relációs operátorok két értéket hasonlítanak össze, és egy bool-t adnak vissza.

Operator Meaning Example
< Kevesebb, mint speed < limit
> Nagyobb, mint speed > limit
<= Kisebb vagy egyenlő score <= 100
>= Nagyobb vagy egyenlő 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)

A relációs operátorok minden numerikus típuson és char működnek. Az charösszehasonlítás a karakter numerikus Unicode-kódpontértékét használja, nem pedig betűrendes vagy tartományspecifikus rendezést. A fenti osztályzatpéldában a 'A' nagyobb vagy egyenlő, mint a 'B', mert a 'B' Unicode-értéke 66, a 'A' Unicode-értéke pedig 65 — az összehasonlítást a számok határozzák meg, nem pedig a betűjegyek jelentése.

Egyenlőségi operátorok

== és != ellenőrizze, hogy két érték egyenlő-e vagy sem. != true akkor, ha az operandusok nem egyenlők, és false, ha igen.

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

Numerikus típusok esetén az stringegyenlőség az értékeket teszteli. Referenciatípusok esetén alapértelmezés szerint az identitást vizsgálják (vagyis azt, hogy két változó ugyanarra az objektumra mutat-e), de számos típus, köztük a string és a record is, ezt felülbírálva a tartalmukat hasonlítja össze. A teljes képet – az egyenlőség értéktípusok, referenciatípusok, rekordok és szerkezetek közötti működését – az Egyenlőség összehasonlítása című témakörben tekinti meg.

Note

A C# nem rendelkezik operátorral === . A === használata fordítási idejű hiba:

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

Ha JavaScriptből származik, használja == az érték-összehasonlítást (a C# == már összehasonlítja a primitív típusok és sztringek értékét). A gyakori kapcsolódó hiba az, hogy véletlenül azt írja = (hozzárendelés), ahová ön gondolta == (egyenlőség-ellenőrzés). A fordító észleli a leggyakoribb eseteket, de ellenőrizzen újra minden olyan if feltételt, amely = elemet tartalmaz.

Feltételes-logikai operátorok

&& (AND) és || (OR) kifejezéseket egyesít bool .

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)

Mindkét operátor rövidzárlattal rendelkezik: kihagyják a megfelelő operandus kiértékelését, ha az eredmény már meg van határozva.

  • && visszaadja a(z) false értéket, amint a bal oldal false lesz. A jobb oldal soha nincs kiértékelve.
  • A || visszaadja a true értéket, amint a bal oldali érték true. A jobb oldal soha nincs kiértékelve.

A rövidzárlatos viselkedésnek gyakorlati előnye van: a jobb oldalon biztonságosan védheti a műveletet egy null értékű ellenőrzéssel a bal oldalon, ahogy a fenti példa is mutatja. Ha a itemsnull, akkor a && ott leáll — a items.Count soha nem hívódik meg, így nem dobódik NullReferenceException.

Feltételes operátor ?:

A feltételes operátor (más néven ternáris operátor) két kifejezés egyikét értékeli ki egy feltétel alapján:

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

Az ?: operátor mindig pontosan egy ágat értékel ki – a feltételnek nem megfelelő oldalt soha nem értékeli ki a függvény. Ez biztonságossá teszi egy olyan kifejezés használatát az egyik oldalon, amely más bemenetek esetében meghiúsulna, amíg a feltétel megfelelően védi azt.

Az egyszerű, soron belüli lehetőségekhez használja a ?: elemet. Többutas feltételek vagy kódblokkok if/else esetén az utasítás általában világosabb.

Értékadó operátorok

Az egyszerű hozzárendelési operátor = egy értéket tárol egy változóban:

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

A C#-beli hozzárendelés jobbra asszociatív, ami azt jelenti, hogy a = b = c = 0 jobbról balra értékelődik ki: c megkapja 0 értékét, majd b megkapja 0 értékét, végül a megkapja 0 értékét.

Összetett hozzárendelés

Az összetett hozzárendelési operátorok egy bináris műveletet kombinálnak hozzárendeléssel:

Operator Egyenértékű valamivel
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

Az összetett hozzárendelés nem csupán rövidítés. Pontosan egyszer értékeli ki a bal oldalt, majd visszakonvertálja az eredményt a bal oldali típusra. Ez akkor számít, ha a bal oldalon mellékhatások (például tömbindexelő) vannak, és ezért fordítja le a byte változó összetett hozzárendelését explicit leadás nélkül, míg a kibontott űrlap nem:

// 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 fordítása azért van, mert a fordító automatikusan beszúrja a szűkítési átalakítást – az eredményt, 210amely a byte 0–255 tartományba illeszkedik. small = small + 10 explicit (byte) típuskonverziót igényelne, mert az aritmetikai művelet mindkét operandust int típusúvá lépteti elő.

Egyéb C#-operátorok

Ez a cikk a mindennapi kódban leggyakrabban előforduló operátorokat ismerteti. A C#-nyelv több operátort tartalmaz, amelyek bizonyos helyzetekben hasznosak:

  • Shift operátorok (<<, >>, >>>) – egy egész szám bitjeinek eltolása balra vagy jobbra megadott számú pozícióval. Bitenkénti és egész szám logikai operátorok (&, |, , ~^) – az egész számok értékeit egyesítheti vagy invertálhatja egyenként. Ez a jelölőkben, maszkokban és alacsony szintű kódban hasznos: Bitenkénti és shift operátorok
  • checked és unchecked — azt szabályozza, hogy az egészérték-túlcsordulás kivételt dob-e (checked), vagy csendben körbefordul-e (unchecked): Checked és unchecked
  • null operátorok (??, ??=, ?., ?[]) — a null értékek biztonságos kezelése alapértelmezett értékek megadásával vagy a taghozzáférés rövidre zárásával: null operátorok
  • Típustesztelési és átalakítási operátorok (is, , as, typeoföntött (T)) – egy érték futtatókörnyezettípusának ellenőrzése vagy átalakítása: Típustesztelő és öntött operátorok
  • Tartomány- és indexoperátorok (.., ^) – tartományok és végpontok relatív indexeinek létrehozása tömbök és hatókörök szeleteléséhez: Taghozzáférés és null-feltételes operátorok
  • Deconstruction assignment – csomagoljon ki egy rekordot vagy típust egy adott változóba egyetlen kifejezésben: Csuplok és egyéb típusok dekonstruálása

Lásd még

  • Last updated on