V tomto článku se naučíme vše o různých typech operátorů v programovacím jazyce C # a o tom, jak je používat.
Operátory jsou symboly, které se používají k provádění operací s operandy. Operandy mohou být proměnné a / nebo konstanty.
Například v 2+3, +je operátor, který se používá k provádění operace přidání, zatímco 2a 3jsou operandy.
Operátory se používají k manipulaci s proměnnými a hodnotami v programu. C # podporuje řadu operátorů, které jsou klasifikovány na základě typu operací, které provádějí.
1. Základní operátor přiřazení
K přiřazení hodnot proměnným se používá operátor základního přiřazení (=). Například,
dvojité x; x = 50,05;
Zde je 50,05 přiřazeno x.
Příklad 1: Operátor základního přiřazení
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); ) ) )
Když spustíme program, výstup bude:
První číslo = 10 Druhé číslo = 10
Toto je jednoduchý příklad, který ukazuje použití operátoru přiřazení.
Možná jste si ( )v tomto příkladu všimli použití složených závorek . Budeme o nich diskutovat při formátování řetězců. Prozatím mějte na paměti, že (0)je nahrazena první proměnnou, která následuje za řetězcem, (1)je nahrazena druhou proměnnou atd.
2. Aritmetické operátory
Aritmetické operátory se používají k provádění aritmetických operací, jako je sčítání, odčítání, násobení, dělení atd.
Například,
int x = 5; int y = 10; int z = x + y; // z = 15C # aritmetické operátory
| Operátor | Jméno operátora | Příklad |
|---|---|---|
| + | Operátor přidání | 6 + 3 hodnotí na 9 |
| - | Operátor odčítání | 10 - 6 hodnotí na 4 |
| * | Operátor násobení | 4 * 2 se vyhodnotí jako 8 |
| / | Provozovatel divize | 10/5 hodnotí na 2 |
| % | Modulo Operator (zbytek) | 16% 3 hodnotí na 1 |
Příklad 2: Aritmetické operátory
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); ) ) )
Když spustíme program, výstup bude:
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
Aritmetické operace se provádějí ve výše uvedeném příkladu. Proměnné lze v příkazech nahradit konstantami. Například,
výsledek = 4,5 + 2,7; // výsledek pojme 7,2 result = firstNumber - 3,2; // výsledek bude 11.2
3. Relační operátoři
Relační operátory se používají ke kontrole vztahu mezi dvěma operandy. Pokud je vztah pravdivý, výsledek bude true, jinak bude mít za následek false.
Relační operátoři se používají při rozhodování a smyčkách.
C # relační operátoři| Operátor | Jméno operátora | Příklad |
|---|---|---|
| == | Rovná | 6 == 4 vyhodnotí jako nepravdivé |
| > | Větší než | 3> -1 se vyhodnotí jako true |
| < | Méně než | 5 <3 vyhodnotí jako nepravdivé |
| > = | Větší nebo rovno | 4> = 4 se vyhodnotí jako true |
| <= | Méně než nebo rovno | 5 <= 3 vyhodnotí jako nepravdivé |
| ! = | Nerovná se | 10! = 2 vyhodnotí jako true |
Příklad 3: Relační operátoři
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); ) ) )
Když spustíme program, výstup bude:
10 == 20 vrátí False 10> 20 vrátí False 10 = 20 vrátí False 10 <= 20 vrátí True 10! = 20 vrátí True
4. Logičtí operátoři
Logické operátory se používají k provádění logické operace, jako je and, or. Logické operátory fungují na logických výrazech ( truea false) a vrací logické hodnoty. Logické operátory se používají při rozhodování a smyčkách.
Zde je způsob, jakým je výsledek vyhodnocen pro logické ANDa ORoperátory.
| Operand 1 | Operand 2 | NEBO (||) | A (&&) |
|---|---|---|---|
| skutečný | skutečný | skutečný | skutečný |
| skutečný | Nepravdivé | skutečný | Nepravdivé |
| Nepravdivé | skutečný | skutečný | Nepravdivé |
| Nepravdivé | Nepravdivé | Nepravdivé | Nepravdivé |
Jednoduše řečeno, tabulku lze shrnout jako:
- Pokud je jeden z operandů pravdivý,
ORoperátor jej vyhodnotí natrue. - Pokud je jeden z operandů nepravdivý,
ANDvyhodnotí jej operátorfalse.
Příklad 4: Logičtí operátoři
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); ) ) )
Když spustíme program, výstup bude:
True False
5. Unární operátoři
Na rozdíl od jiných operátorů fungují unární operátoři na jediném operandu.
C # unární operátoři| Operátor | Jméno operátora | Popis |
|---|---|---|
| + | Unární Plus | Zanechává znamení operandu tak, jak je |
| - | Unární minus | Obrátí znaménko operandu |
| ++ | Přírůstek | Zvýšit hodnotu o 1 |
| - | Snížení | Snížení hodnoty o 1 |
| ! | Logická negace (ne) | Invertuje hodnotu logické hodnoty |
Příklad 5: Unární operátoři
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)); ) ) )
Když spustíme program, výstup bude:
+ number = 10 -number = -10 ++ number = 11 --number = 10! flag = False
Operátory přírůstku (++)a úbytku (--)lze použít jako předponu a postfix. Pokud se použije jako předpona, změna hodnoty proměnné se projeví na stejném řádku a pokud se použije jako předpona, změna hodnoty proměnné se projeví na dalším řádku. To bude zřejmé z níže uvedeného příkladu.
Příklad 6: Operátory post a pre increment v 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)); ) ) )
Když spustíme program, výstup bude:
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;
Ternární operátor funguje následovně:
- Pokud je výraz uvedený podmínkou
true, je výsledek výrazu 1 přiřazen proměnné. - Pokud ano
false, je výsledek výrazu 2 přiřazen proměnné.
Příklad 7: Ternární operátor
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); ) ) )
Když spustíme program, výstup bude:
10 je sudé číslo
Další informace najdete na ternárním operátoru C #.
7. Operátoři bitového a bitového posunu
Operátory bitového a bitového posunu se používají k provádění operací manipulace s bitem.
C # operátory bitového a bitového posunu| Operátor | Jméno operátora |
|---|---|
| ~ | Bitový doplněk |
| & | Bitové AND |
| | | Bitové NEBO |
| ^ | Bitově exkluzivní NEBO |
| << | Bitový posun vlevo |
| >> | Bitový posun doprava |
Příklad 8: Operátor bitového a bitového posunu
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); ) ) )
Když spustíme program, výstup bude:
~ 10 = -11 10 a 20 = 0 10 | 20 = 30 10 20 = 30 10 <> 2 = 2
Další informace najdete v operátoru C # Bitwise a Bit Shift.
8. Operátoři přiřazení sloučenin
C # operátoři přiřazení sloučenin| Operátor | Jméno operátora | Příklad | Ekvivalentní |
|---|---|---|---|
| + = | Přiřazení sčítání | x += 5 | x = x + 5 |
| - = | Přiřazení odčítání | x -= 5 | x = x - 5 |
| * = | Přiřazení násobení | x *= 5 | x = x * 5 |
| / = | Přiřazení divize | x /= 5 | x = x / 5 |
| % = | Přiřazení modulo | x %= 5 | x = x % 5 |
| & = | Bitové a přiřazení | x &= 5 | x = x & 5 |
| | = | Bitové NEBO Přiřazení | x |= 5 | x = x | 5 |
| = | Bitové přiřazení XOR | x ^= 5 | x = x 5 |
| << = | Přiřazení levého posunu | x <<= 5 | x = x << 5 |
| >> = | Přiřazení pravého řazení | x>>= 5 | x = x>> 5 |
| => | Lambda operátor | x => x*x | Returns x*x |
Příklad 9: Operátor přiřazení sloučenin
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); ) ) )
Když spustíme program, výstup bude:
15 12 24 8 2 2 14 2 8 1
O operátorech Lambda budeme diskutovat v dalším tutoriálu.
