Operátory jsou základem každého programovacího jazyka. Tedy funkčnost C# jazyk je bez použití operátorů neúplný. Operátoři nám umožňují provádět různé druhy operací operandy . v C# , operátory Lze kategorizovat na základě jejich odlišné funkčnost :
- Aritmetické operátory
- Relační operátoři
- Logické operátory
- Bitové operátory
- Operátoři přiřazení
- Podmíněný operátor
V C# lze operátory také kategorizovat na základě počtu operandů:
- Unární operátor: Operátor, který bere jeden operand k provedení operace.
- Binární operátor: Operátor, který bere dva operandy k provedení operace.
- Ternární operátor: Operátor, který bere tři operandy k provedení operace.
Aritmetické operátory
Používají se k provádění aritmetických/matematických operací s operandy. The Binární operátory spadají do této kategorie:
- Přidání: The '+' operátor přidá dva operandy. Například, x+y .
- Odčítání: The '-' operátor odečte dva operandy. Například, x-y .
- Násobení: The '*' operátor násobí dva operandy. Například, x*y .
- Divize: The '/' operátor dělí první operand druhým. Například, x/y .
- Modul: The '%' operátor vrátí zbytek, když je první operand dělen druhým. Například, x%y .
Příklad:
C# // C# program to demonstrate the working // of Binary Arithmetic Operators using System; namespace Arithmetic { class GFG { // Main Function static void Main(string[] args) { int result; int x = 10, y = 5; // Addition result = (x + y); Console.WriteLine('Addition Operator: ' + result); // Subtraction result = (x - y); Console.WriteLine('Subtraction Operator: ' + result); // Multiplication result = (x * y); Console.WriteLine('Multiplication Operator: '+ result); // Division result = (x / y); Console.WriteLine('Division Operator: ' + result); // Modulo result = (x % y); Console.WriteLine('Modulo Operator: ' + result); } } }> Výstup:
Addition Operator: 15 Subtraction Operator: 5 Multiplication Operator: 50 Division Operator: 2 Modulo Operator: 0>
Ty, které spadají do kategorie Unární operátoři jsou:
- Přírůstek: The '++' operátor se používá ke zvýšení hodnoty celého čísla. Při umístění před název proměnné (také nazývané předpřírůstek operátor), jeho hodnota se okamžitě zvýší. Například, ++x .
A když je umístěn za názvem proměnné (také nazývané operátor po přírůstku ), jeho hodnota je dočasně zachována až do provedení tohoto příkazu a před provedením dalšího příkazu se aktualizuje. Například, x++ . - Snížit: The '--' operátor se používá ke snížení hodnoty celého čísla. Při umístění před název proměnné (také nazývané operátor před dekrementací ), jeho hodnota se okamžitě sníží. Například, - -X .
A když je umístěn za názvem proměnné (také nazývané operátor po dekrementaci ), jeho hodnota je dočasně zachována až do provedení tohoto příkazu a před provedením dalšího příkazu se aktualizuje. Například, X- - .
Příklad:
C# // C# program to demonstrate the working // of Unary Arithmetic Operators using System; namespace Arithmetic { class GFG { // Main Function static void Main(string[] args) { int a = 10, res; // post-increment example: // res is assigned 10 only, // a is not updated yet res = a++; //a becomes 11 now Console.WriteLine('a is {0} and res is {1}', a, res); // post-decrement example: // res is assigned 11 only, a is not updated yet res = a--; //a becomes 10 now Console.WriteLine('a is {0} and res is {1}', a, res); // pre-increment example: // res is assigned 11 now since a // is updated here itself res = ++a; // a and res have same values = 11 Console.WriteLine('a is {0} and res is {1}', a, res); // pre-decrement example: // res is assigned 10 only since // a is updated here itself res = --a; // a and res have same values = 10 Console.WriteLine('a is {0} and res is {1}',a, res); } } }> Výstup:
atoi c
a is 11 and res is 10 a is 10 and res is 11 a is 11 and res is 11 a is 10 and res is 10>
Relační operátoři
K porovnání dvou hodnot se používají relační operátory. Pojďme se na ně podívat jeden po druhém:
- „==“ (rovná se) operátor zkontroluje, zda jsou dva dané operandy stejné nebo ne. Pokud ano, vrátí hodnotu true. Jinak vrací false. Například, 5==5 vrátí true.
- „!=“ (Nerovná se) operátor zkontroluje, zda jsou dva dané operandy stejné nebo ne. Pokud ne, vrátí true. Jinak vrací false. Je to přesný booleovský doplněk '==' operátor. Například, 5! = 5 vrátí false.
- „>“ (Větší než) operátor kontroluje, zda je první operand větší než druhý operand. Pokud ano, vrátí hodnotu true. Jinak vrací false. Například, 6>5 vrátí true.
- „<“ (méně než) operátor kontroluje, zda je první operand menší než druhý operand. Pokud ano, vrátí hodnotu true. Jinak vrací false. Například, 6<5 vrátí false.
- '>=' (Větší než rovno) operátor kontroluje, zda je první operand větší nebo roven druhému operandu. Pokud ano, vrátí hodnotu true. Jinak vrací false. Například, 5>=5 vrátí true.
- „<=“ (menší než rovno) operátor kontroluje, zda je první operand menší nebo roven druhému operandu. Pokud ano, vrátí hodnotu true. Jinak vrací false. Například, 5<=5 vrátí také true.
Příklad:
C# // C# program to demonstrate the working // of Relational Operators using System; namespace Relational { class GFG { // Main Function static void Main(string[] args) { bool result; int x = 5, y = 10; // Equal to Operator result = (x == y); Console.WriteLine('Equal to Operator: ' + result); // Greater than Operator result = (x>y); Console.WriteLine('Větší než operátor: ' + výsledek); // Výsledek menší než operátor = (x< y); Console.WriteLine('Less than Operator: ' + result); // Greater than Equal to Operator result = (x>= y); Console.WriteLine('Větší než nebo rovno: '+ výsledek); // Výsledek menší než rovno operátoru = (x<= y); Console.WriteLine('Lesser than or Equal to: '+ result); // Not Equal To Operator result = (x != y); Console.WriteLine('Not Equal to Operator: ' + result); } } }> Výstup:
Equal to Operator: False Greater than Operator: False Less than Operator: True Greater than or Equal to: False Lesser than or Equal to: True Not Equal to Operator: True>
Logické operátory
Používají se ke spojení dvou nebo více podmínek/omezení nebo k doplnění hodnocení původního uvažovaného stavu. Jsou popsány níže:
- Logické A: The '&&' operátor vrátí true, když jsou splněny obě uvažované podmínky. Jinak vrací false. Například, a && b vrátí true, když a i b jsou pravdivé (tj. nenulové).
- Logické NEBO: The '||' operátor vrátí hodnotu true, když je splněna jedna (nebo obě) z uvažovaných podmínek. Jinak vrací false. Například, a || b vrátí true, pokud jedno z a nebo b je pravdivé (tj. nenulové). Samozřejmě vrátí true, když a i b jsou pravdivé.
- Logické NE: The '!' operátor vrátí true uvažovaná podmínka není splněna. Jinak vrací false. Například, !A vrátí true, pokud a je nepravdivé, tj. když a=0.
Příklad:
C# // C# program to demonstrate the working // of Logical Operators using System; namespace Logical { class GFG { // Main Function static void Main(string[] args) } }> Výstup:
AND Operator: False OR Operator: True NOT Operator: False>
Bitové operátory
V C# existuje 6 bitových operátorů, které pracují na úrovni bitů nebo se používají k provádění operací bit po bitu. Následují bitové operátory:
arraylist java
- & (bitový AND) Bere dvě čísla jako operandy a dělá AND na každém bitu dvou čísel. Výsledek AND je 1 pouze v případě, že oba bity jsou 1.
- | (bitově NEBO) Bere dvě čísla jako operandy a dělá OR na každém bitu dvou čísel. Výsledkem OR je 1, kterýkoli ze dvou bitů je 1.
- ^ (bitově XOR) Vezme dvě čísla jako operandy a provede XOR na každém bitu dvou čísel. Výsledek XOR je 1, pokud se dva bity liší.
- ~ (bitový doplněk) Vezme jedno číslo jako operand a invertuje každý bit, který je 1 až 0 a 0 až 1.
- << (levý posun) Vezme dvě čísla, doleva posune bity prvního operandu, druhý operand rozhodne o počtu míst, která se mají posunout.
- >> (pravý posun) Vezme dvě čísla, doprava posune bity prvního operandu, druhý operand rozhodne o počtu míst k posunutí.
Příklad:
C# // C# program to demonstrate the working // of Bitwise Operators using System; namespace Bitwise { class GFG { // Main Function static void Main(string[] args) int x = 5, y = 10, result; // Bitwise AND Operator result = x & y; Console.WriteLine('Bitwise AND: ' + result); // Bitwise OR Operator result = x } }> Výstup:
Bitwise AND: 0 Bitwise OR: 15 Bitwise XOR: 15 Bitwise Complement: -6 Bitwise Left Shift: 20 Bitwise Right Shift: 1>
Operátoři přiřazení
Operátory přiřazení se používají k přiřazení hodnoty proměnné. Levý operand přiřazovacího operátoru je proměnná a pravý operand přiřazovacího operátoru je hodnota. Hodnota na pravé straně musí být stejného datového typu jako proměnná na levé straně, jinak kompilátor vyvolá chybu.
Různé typy operátorů přiřazení jsou uvedeny níže:
- =(Jednoduché zadání) : Toto je nejjednodušší operátor přiřazení. Tento operátor se používá k přiřazení hodnoty vpravo k proměnné vlevo.
Příklad:
a = 10; b = 20; ch = 'y';>
- +=(Přidat úkol) : Tento operátor je kombinací operátorů „+“ a „=“. Tento operátor nejprve přičte aktuální hodnotu proměnné vlevo k hodnotě vpravo a poté přiřadí výsledek proměnné vlevo.
Příklad:
(a += b) can be written as (a = a + b)>
Pokud je počáteční hodnota uložená v a 5. Potom (a += 6) = 11.
stáhněte si youtube pomocí vlc
- -=(Odečíst úkol) : Tento operátor je kombinací operátorů „-“ a „=“. Tento operátor nejprve odečte aktuální hodnotu proměnné vlevo od hodnoty vpravo a poté přiřadí výsledek proměnné vlevo.
Příklad:
(a -= b) can be written as (a = a - b)>
Pokud je počáteční hodnota uložená v a 8. Potom (a -= 6) = 2.
- *=(Multiply Assignment) : Tento operátor je kombinací operátorů „*“ a „=“. Tento operátor nejprve vynásobí aktuální hodnotu proměnné vlevo hodnotou vpravo a poté přiřadí výsledek proměnné vlevo.
Příklad:
(a *= b) can be written as (a = a * b)>
Pokud je počáteční hodnota uložená v a 5. Potom (a *= 6) = 30.
- /=(Přiřazení divize): Tento operátor je kombinací operátorů „/“ a „=“. Tento operátor nejprve vydělí aktuální hodnotu proměnné vlevo hodnotou vpravo a poté přiřadí výsledek proměnné vlevo.
Příklad:
(a /= b) can be written as (a = a / b)>
Pokud je počáteční hodnota uložená v a 6. Potom (a /= 2) = 3.
- %=(Přiřazení modulu): Tento operátor je kombinací operátorů „%“ a „=“. Tento operátor nejprve moduluje aktuální hodnotu proměnné vlevo o hodnotu vpravo a poté přiřadí výsledek proměnné vlevo.
Příklad:
(a %= b) can be written as (a = a % b)>
Pokud je počáteční hodnota uložená v a 6. Potom (a %= 2) = 0.
- <<=(Přiřazení levého posunu) : Tento operátor je kombinací operátorů „<<“ a „=“. Tento operátor nejprve doleva posune aktuální hodnotu proměnné vlevo o hodnotu vpravo a poté přiřadí výsledek proměnné vlevo.
Příklad:
(a <<= 2) can be written as (a = a << 2)>
Pokud je počáteční hodnota uložená v a 6. Potom (a <<= 2) = 24.
- >>=(Přiřazení pravého posunu) : Tento operátor je kombinací operátorů „>>“ a „=“. Tento operátor nejprve vpravo posune aktuální hodnotu proměnné vlevo o hodnotu vpravo a poté přiřadí výsledek proměnné vlevo.
Příklad:
(a>>= 2) lze zapsat jako (a = a>> 2)>
Pokud je počáteční hodnota uložená v a 6. Pak (a>>= 2) = 1.
Jak najdu skryté aplikace na Androidu
- &=(bitové A přiřazení) : Tento operátor je kombinací operátorů „&“ a „=“. Tento operátor nejprve Bitově AND aktuální hodnotu proměnné vlevo hodnotou vpravo a poté přiřadí výsledek proměnné vlevo.
Příklad:
(a &= 2) can be written as (a = a & 2)>
Pokud je počáteční hodnota uložená v a 6. Potom (a &= 2) = 2.
- ^=(Bitwise Exclusive OR) : Tento operátor je kombinací operátorů „^“ a „=“. Tento operátor nejprve Bitwise Exclusive OR aktuální hodnotu proměnné vlevo o hodnotu vpravo a poté přiřadí výsledek proměnné vlevo.
Příklad:
(a ^= 2) can be written as (a = a ^ 2)>
Pokud je počáteční hodnota uložená v a 6. Potom (a ^= 2) = 4.
- |=(Bitwise Inclusive NEBO) : Tento operátor je kombinací operátorů „|“ a „=“. Tento operátor nejprve Bitwise Inclusive NEBO aktuální hodnotu proměnné vlevo o hodnotu vpravo a poté přiřadí výsledek proměnné vlevo.
Příklad:
(a |= 2) can be written as (a = a | 2)>
Na začátku je hodnota uložená v a 6. Potom (a |= 2) = 6.
Příklad:
C# // C# program to demonstrate the working // of Assignment Operators using System; namespace Assignment { class GFG { // Main Function static void Main(string[] args) = 4; Console.WriteLine('Bitwise Inclusive OR Assignment Operator: ' + x); } }> Výstup :
Add Assignment Operator: 25 Subtract Assignment Operator: 15 Multiply Assignment Operator: 75 Division Assignment Operator: 5 Modulo Assignment Operator: 0 Left Shift Assignment Operator: 32 Right Shift Assignment Operator: 2 Bitwise AND Assignment Operator: 4 Bitwise Exclusive OR Assignment Operator: 8 Bitwise Inclusive OR Assignment Operator: 12>
Podmíněný operátor
Je to ternární operátor, což je zkrácená verze příkazu if-else. Má tři operandy a odtud název ternární. Vrátí jednu ze dvou hodnot v závislosti na hodnotě booleovského výrazu.
Syntax:
condition ? first_expression : second_expression;>
Vysvětlení:
podmínka: Musí být vyhodnocena jako true nebo false.
Pokud je podmínka pravdivá
first_expression je vyhodnocen a stává se výsledkem.
Pokud je podmínka nepravdivá,
druhý_výraz je vyhodnocen a stává se výsledkem.
Příklad:
C# // C# program to demonstrate the working // of Conditional Operator using System; namespace Conditional { class GFG { // Main Function static void Main(string[] args) { int x = 5, y = 10, result; // To find which value is greater // Using Conditional Operator result = x>y ? x : y; // Zobrazení výsledku Console.WriteLine('Result: ' + result); // Chcete-li zjistit, která hodnota je větší // Použití podmíněného operátoru result = x< y ? x : y; // To display the result Console.WriteLine('Result: ' + result); } } }> Výstup :
Result: 10 Result: 5>