V tomto článku sa dozvieme všetko o rôznych druhoch operátorov v programovacom jazyku C # a o tom, ako ich používať.
Operátory sú symboly, ktoré sa používajú na vykonávanie operácií s operandmi. Operandy môžu byť premenné a / alebo konštanty.
Napríklad v 2+3, +je operátor, ktorý sa používa na vykonávanie operácie pridania, zatiaľ čo 2a 3sú operandy.
Operátory sa používajú na manipuláciu s premennými a hodnotami v programe. C # podporuje množstvo operátorov, ktoré sú klasifikované na základe typu operácií, ktoré vykonávajú.
1. Operátor základného priradenia
Na priradenie hodnôt k premenným sa používa operátor základného priradenia (=). Napríklad,
dvojité x; x = 50,05;
Tu je 50,05 priradených k x.
Príklad 1: Operátor základného priradenia
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); ) ) )
Keď spustíme program, výstup bude:
Prvé číslo = 10 Druhé číslo = 10
Toto je jednoduchý príklad, ktorý demonštruje použitie operátora priradenia.
Možno ste si ( )v príklade všimli použitie zložených zátvoriek . Budeme o nich diskutovať pri formátovaní reťazcov. Zatiaľ majte na pamäti, že (0)je nahradená prvou premennou, ktorá nasleduje za reťazcom, (1)je nahradená druhou premennou atď.
2. Aritmetické operátory
Aritmetické operátory sa používajú na vykonávanie aritmetických operácií, ako je sčítanie, odčítanie, násobenie, delenie atď.
Napríklad,
int x = 5; int y = 10; int z = x + y; // z = 15Aritmetické operátory C #
| Prevádzkovateľ | Meno operátora | Príklad |
|---|---|---|
| + | Operátor sčítania | 6 + 3 hodnotí na 9 |
| - | Operátor odčítania | 10 - 6 hodnotí na 4 |
| * | Operátor násobenia | 4 * 2 hodnotí ako 8 |
| / | Operátor divízie | 10/5 hodnotí na 2 |
| % | Operátor modulov (zvyšok) | 16% 3 sa hodnotí ako 1 |
Prí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); ) ) )
Keď 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é operácie sa uskutočňujú vo vyššie uvedenom príklade. Premenné je možné vo výpisoch nahradiť konštantami. Napríklad,
výsledok = 4,5 + 2,7; // výsledok bude obsahovať 7,2 result = firstNumber - 3,2; // výsledok bude 11.2
3. Relační operátori
Relačné operátory sa používajú na kontrolu vzťahu medzi dvoma operandmi. Ak je vzťah pravdivý, výsledok bude true, inak bude mať za následok false.
Pri rozhodovaní a slučkách sa používajú relačné operátory.
C # relačné operátory| Prevádzkovateľ | Meno operátora | Príklad |
|---|---|---|
| == | Rovná | 6 == 4 vyhodnotí ako nepravdivé |
| > | Väčší než | 3> -1 sa vyhodnotí ako pravdivé |
| < | Menej ako | 5 <3 vyhodnotí ako nepravdivé |
| > = | Väčšie alebo rovné | 4> = 4 vyhodnotí ako pravdivé |
| <= | Menej alebo rovné | 5 <= 3 vyhodnotí ako nepravdivé |
| ! = | Nie rovné | 10! = 2 vyhodnotí ako pravdivé |
Príklad 3: Relačné operátory
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); ) ) )
Keď spustíme program, výstup bude:
10 == 20 vráti False 10> 20 vráti False 10 = 20 vráti False 10 <= 20 vráti True 10! = 20 vráti True
4. Logickí operátori
Logické operátory sa používajú na realizáciu logické operácie, ako je and, or. Logické operátory pracujú s logickými výrazmi ( truea false) a vracajú logické hodnoty. Pri rozhodovaní a slučkách sa používajú logické operátory.
Takto sa vyhodnotí výsledok pre logické operátory ANDa ORoperátory.
| Operand 1 | Operand 2 | ALEBO (||) | AND (&&) |
|---|---|---|---|
| pravda | pravda | pravda | pravda |
| pravda | nepravdivé | pravda | nepravdivé |
| nepravdivé | pravda | pravda | nepravdivé |
| nepravdivé | nepravdivé | nepravdivé | nepravdivé |
Jednoduchými slovami možno tabuľku zhrnúť ako:
- Ak je jeden z operandov pravda,
ORoperátor to vyhodnotí natrue. - Ak je jeden z operandov nepravdivý,
ANDoperátor to vyhodnotí nafalse.
Príklad 4: Logickí operátori
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); ) ) )
Keď spustíme program, výstup bude:
Pravda lož
5. Unárne operátory
Na rozdiel od iných operátorov, unárne operátory pracujú na jednom operande.
C # unárne operátory| Prevádzkovateľ | Meno operátora | Popis |
|---|---|---|
| + | Unárnik Plus | Znak operandu ponecháva taký, aký je |
| - | Unárne mínus | Obráti znak operandu |
| ++ | Prírastok | Zvýšiť hodnotu o 1 |
| - | Zníženie | Znížiť hodnotu o 1 |
| ! | Logická negácia (nie) | Obráti hodnotu boolovskej hodnoty |
Príklad 5: Unárne operátory
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)); ) ) )
Keď spustíme program, výstup bude:
+ number = 10 -number = -10 ++ number = 11 --number = 10! flag = False
Operátory prírastku (++)a úbytku (--)je možné použiť ako predponu a postfix. Ak sa použije ako predpona, zmena hodnoty premennej sa zobrazí na rovnakom riadku a ak sa použije ako predpona, zmena hodnoty premennej sa zobrazí na ďalšom riadku. To bude zrejmé z nižšie uvedeného príkladu.
Príklad 6: Operátory účtovania a predbežného zvyšovania 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)); ) ) )
Keď 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árny operátor funguje nasledovne:
- Ak je výraz určený podmienkou
true, výsledok výrazu 1 je priradený premennej. - Ak je
false, výsledok výrazu 2 je priradený premennej.
Príklad 7: Ternárny 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); ) ) )
Keď spustíme program, výstup bude:
10 je párne číslo
Ak sa chcete dozvedieť viac, navštívte ternárneho operátora C #.
7. Operátory bitového a bitového posunu
Operátory bitového a bitového posunu sa používajú na vykonávanie operácií bitovej manipulácie.
Operátory bitových a bitových posunov C #| Prevádzkovateľ | Meno operátora |
|---|---|
| ~ | Bitový doplnok |
| & | Bitové AND |
| | | Bitové ALEBO |
| ^ | Bitove exkluzivne ALEBO |
| << | Bitový posun vľavo |
| >> | Bitový posun doprava |
Prí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); ) ) )
Keď spustíme program, výstup bude:
~ 10 = -11 10 a 20 = 0 10 | 20 = 30 10 20 = 30 10 <> 2 = 2
Ak sa chcete dozvedieť viac, navštívte operátora C # Bitwise and Bit Shift.
8. Prevádzkovatelia zložených priradení
Operátori priradenia zlúčenín C #| Prevádzkovateľ | Meno operátora | Príklad | Ekvivalent k |
|---|---|---|---|
| + = | Priradenie dodatku | x += 5 | x = x + 5 |
| - = | Priradenie odčítania | x -= 5 | x = x - 5 |
| * = | Priradenie násobenia | x *= 5 | x = x * 5 |
| / = | Priradenie divízie | x /= 5 | x = x / 5 |
| % = | Priradenie modulov | x %= 5 | x = x % 5 |
| & = | Bitové AND Priradenie | x &= 5 | x = x & 5 |
| | = | Bitové ALEBO Postúpenie | x |= 5 | x = x | 5 |
| = | Bitové priradenie XOR | x ^= 5 | x = x 5 |
| << = | Priradenie ľavého posuvu | x <<= 5 | x = x << 5 |
| >> = | Priradenie pravého posunu | x>>= 5 | x = x>> 5 |
| => | Operátor lambdy | x => x*x | Returns x*x |
Príklad 9: Operátor priradenia zlúčeniny
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); ) ) )
Keď spustíme program, výstup bude:
15 12 24 8 2 2 14 2 8 1
O operátoroch Lambda budeme diskutovať v ďalšom tutoriále.
