Operátory sú základom každého programovacieho jazyka. Teda funkčnosť C# jazyk je neúplný bez použitia operátorov. Operátori nám umožňujú vykonávať rôzne druhy operácií operandy . In C# , operátori Možno kategorizovať na základe ich odlišné funkčnosť :
- Aritmetické operátory
- Vzťahoví operátori
- Logické operátory
- Bitové operátory
- Operátori pridelenia
- Podmienený operátor
V C# môžu operátori tiež kategorizovať na základe počtu operandov:
- Unárny operátor: Operátor, ktorý berie jeden operand na vykonanie operácie.
- Binárny operátor: Operátor, ktorý berie dva operandov na vykonanie operácie.
- Ternárny operátor: Operátor, ktorý berie tri operandov na vykonanie operácie.
Aritmetické operátory
Používajú sa na vykonávanie aritmetických/matematických operácií s operandmi. The Binárne operátory do tejto kategórie patria:
- Doplnenie: The '+' operátor pridá dva operandy. Napríklad, x+y .
- Odčítanie: The '-' operátor odčíta dva operandy. Napríklad, x-y .
- Násobenie: The '*' operátor vynásobí dva operandy. Napríklad, x*y .
- divízia: The '/' operátor vydelí prvý operand druhým. Napríklad, x/y .
- Modul: The '%' operátor vráti zvyšok, keď je prvý operand delený druhým. Napríklad, x%y .
Prí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ýkon:
Addition Operator: 15 Subtraction Operator: 5 Multiplication Operator: 50 Division Operator: 2 Modulo Operator: 0>
Tie spadajúce do kategórie Unární operátori sú:
spojenia a typy spojení
- Prírastok: The '++' operátor sa používa na zvýšenie hodnoty celého čísla. Pri umiestnení pred názov premennej (nazývaný aj predprírastok operátor), jeho hodnota sa okamžite zvýši. Napríklad, ++x .
A keď sa umiestni za názov premennej (nazývaný aj operátor po prírastku ), jeho hodnota sa dočasne zachová až do vykonania tohto príkazu a aktualizuje sa pred vykonaním ďalšieho príkazu. Napríklad, x++ . - Zníženie: The '--' operátor sa používa na zníženie hodnoty celého čísla. Pri umiestnení pred názov premennej (nazývaný aj operátor pred dekrementom ), jeho hodnota sa okamžite zníži. Napríklad, - -X .
A keď sa umiestni za názov premennej (nazývaný aj operátor po znížení ), jeho hodnota sa dočasne zachová až do vykonania tohto príkazu a aktualizuje sa pred vykonaním ďalšieho príkazu. Napríklad, X- - .
Prí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ýkon:
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>
Vzťahoví operátori
Na porovnanie dvoch hodnôt sa používajú relačné operátory. Pozrime sa na ne jeden po druhom:
- „==“ (rovná sa) operátor skontroluje, či sa dva dané operandy rovnajú alebo nie. Ak áno, vráti hodnotu true. V opačnom prípade vráti hodnotu false. Napríklad, 5==5 vráti pravda.
- „!=“ (Nerovná sa) operátor skontroluje, či sa dva dané operandy rovnajú alebo nie. Ak nie, vráti hodnotu true. V opačnom prípade vráti hodnotu false. Je to presný booleovský doplnok '==' operátor. Napríklad, 5! = 5 vráti false.
- „>“ (väčšie ako) operátor skontroluje, či je prvý operand väčší ako druhý operand. Ak áno, vráti hodnotu true. V opačnom prípade vráti hodnotu false. Napríklad, 6>5 vráti pravda.
- „<“ (menej ako) operátor skontroluje, či je prvý operand menší ako druhý operand. Ak áno, vráti hodnotu true. V opačnom prípade vráti hodnotu false. Napríklad, 6<5 vráti false.
- „>=“ (väčšie ako rovné) operátor skontroluje, či je prvý operand väčší alebo rovný druhému operandu. Ak áno, vráti hodnotu true. V opačnom prípade vráti hodnotu false. Napríklad, 5>=5 vráti pravda.
- „<=“ (menej ako sa rovná) operátor kontroluje, či je prvý operand menší alebo rovný druhému operandu. Ak áno, vráti hodnotu true. V opačnom prípade vráti hodnotu false. Napríklad, 5<=5 vráti aj true.
Prí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äčší ako operátor: ' + výsledok); // Výsledok menší ako operátor = (x< y); Console.WriteLine('Less than Operator: ' + result); // Greater than Equal to Operator result = (x>= y); Console.WriteLine('Väčšie ako alebo Rovné: '+ výsledok); // Menej ako rovné ako výsledok operátora = (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ýkon:
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ú sa na spojenie dvoch alebo viacerých podmienok/obmedzení alebo na doplnenie hodnotenia pôvodného uvažovaného stavu. Sú opísané nižšie:
- Logické A: The '&&' operátor vráti hodnotu true, keď sú splnené obe zvažované podmienky. V opačnom prípade vráti hodnotu false. Napríklad, a && b vráti hodnotu true, keď a aj b sú pravdivé (t. j. nenulové).
- Logické ALEBO: The '||' operátor vráti hodnotu true, keď je splnená jedna (alebo obe) z uvažovaných podmienok. V opačnom prípade vráti hodnotu false. Napríklad, a || b vráti true, ak jedno z a alebo b je pravdivé (t. j. nenulové). Samozrejme, vráti hodnotu true, keď sú pravdivé aj a aj b.
- Logické NIE: The '!' operátor vráti true, uvažovaná podmienka nie je splnená. V opačnom prípade vráti hodnotu false. Napríklad, !a vráti true, ak a je nepravdivé, t.j. keď a=0.
Prí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ýkon:
AND Operator: False OR Operator: True NOT Operator: False>
Bitové operátory
V C# existuje 6 bitových operátorov, ktoré pracujú na úrovni bitov alebo sa používajú na vykonávanie operácií bit po bite. Nasledujú bitové operátory:
- & (bitové AND) Berie dve čísla ako operandy a robí AND na každom bite dvoch čísel. Výsledok AND je 1 iba vtedy, ak sú oba bity 1.
- | (bitové ALEBO) Berie dve čísla ako operandy a robí OR na každom bite dvoch čísel. Výsledkom OR je 1, ktorýkoľvek z týchto dvoch bitov je 1.
- ^ (bitový XOR) Berie dve čísla ako operandy a robí XOR na každom bite dvoch čísel. Výsledok XOR je 1, ak sú tieto dva bity odlišné.
- ~ (bitový doplnok) Berie jedno číslo ako operand a invertuje každý bit, ktorý je 1 až 0 a 0 až 1.
- << (ľavý posun) Zoberie dve čísla, doľava posunie bity prvého operandu, druhý operand rozhodne o počte miest na posun.
- >> (pravý posun) Zoberie dve čísla, doprava posunie bity prvého operandu, druhý operand rozhodne o počte miest na posun.
Prí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ýkon:
java int v reťazci
Bitwise AND: 0 Bitwise OR: 15 Bitwise XOR: 15 Bitwise Complement: -6 Bitwise Left Shift: 20 Bitwise Right Shift: 1>
Operátori pridelenia
Operátory priradenia sa používajú na priradenie hodnoty premennej. Ľavý operand priraďovacieho operátora je premenná a pravý operand priraďovacieho operátora je hodnota. Hodnota na pravej strane musí byť rovnakého dátového typu ako premenná na ľavej strane, inak kompilátor vyvolá chybu.
Nižšie sú uvedené rôzne typy operátorov priradenia:
- =(Jednoduché zadanie) : Toto je najjednoduchší operátor priradenia. Tento operátor sa používa na priradenie hodnoty napravo k premennej naľavo.
Príklad:
a = 10; b = 20; ch = 'y';>
- +=(Pridať úlohu) : Tento operátor je kombináciou operátorov „+“ a „=“. Tento operátor najprv pripočíta aktuálnu hodnotu premennej vľavo k hodnote vpravo a potom priradí výsledok premennej vľavo.
Príklad:
(a += b) can be written as (a = a + b)>
Ak je počiatočná hodnota uložená v a 5. Potom (a += 6) = 11.
- -=(Odčítať zadanie) : Tento operátor je kombináciou operátorov „-“ a „=“. Tento operátor najprv odpočíta aktuálnu hodnotu premennej vľavo od hodnoty vpravo a potom priradí výsledok premennej vľavo.
Príklad:
(a -= b) can be written as (a = a - b)>
Ak je počiatočná hodnota uložená v a 8. Potom (a -= 6) = 2.
- *=(Viacnásobné priradenie) : Tento operátor je kombináciou operátorov „*“ a „=“. Tento operátor najprv vynásobí aktuálnu hodnotu premennej vľavo hodnotou vpravo a potom priradí výsledok premennej vľavo.
Príklad:
(a *= b) can be written as (a = a * b)>
Ak je počiatočná hodnota uložená v a 5. Potom (a *= 6) = 30.
- /=(Pridelenie divízie): Tento operátor je kombináciou operátorov „/“ a „=“. Tento operátor najprv vydelí aktuálnu hodnotu premennej vľavo hodnotou vpravo a potom priradí výsledok premennej vľavo.
Príklad:
(a /= b) can be written as (a = a / b)>
Ak je počiatočná hodnota uložená v a 6. Potom (a /= 2) = 3.
- %=(Priradenie modulu): Tento operátor je kombináciou operátorov „%“ a „=“. Tento operátor najprv moduluje aktuálnu hodnotu premennej vľavo o hodnotu vpravo a potom priradí výsledok premennej vľavo.
Príklad:
(a %= b) can be written as (a = a % b)>
Ak je počiatočná hodnota uložená v a 6. Potom (a %= 2) = 0.
- <<=(Priradenie ľavého posunu) : Tento operátor je kombináciou operátorov „<<“ a „=“. Tento operátor najprv vľavo posunie aktuálnu hodnotu premennej vľavo o hodnotu vpravo a potom priradí výsledok premennej vľavo.
Príklad:
(a <<= 2) can be written as (a = a << 2)>
Ak je počiatočná hodnota uložená v a 6. Potom (a <<= 2) = 24.
- >>=(Priradenie pravého posunu) : Tento operátor je kombináciou operátorov „>>“ a „=“. Tento operátor najprv vpravo posunie aktuálnu hodnotu premennej vľavo o hodnotu vpravo a potom priradí výsledok premennej vľavo.
Príklad:
(a>>= 2) možno zapísať ako (a = a>> 2)>
Ak je počiatočná hodnota uložená v a 6. Potom (a>>= 2) = 1.
- &=(bitové priradenie AND) : Tento operátor je kombináciou operátorov „&“ a „=“. Tento operátor najprv Bitwise AND aktuálnu hodnotu premennej vľavo hodnotou vpravo a potom priradí výsledok premennej vľavo.
Príklad:
(a &= 2) can be written as (a = a & 2)>
Ak je počiatočná hodnota uložená v a 6. Potom (a &= 2) = 2.
sémantickej chyby
- ^=(Bitwise Exclusive OR) : Tento operátor je kombináciou operátorov „^“ a „=“. Tento operátor najprv Bitwise Exclusive ALEBO aktuálnu hodnotu premennej vľavo o hodnotu vpravo a potom priradí výsledok premennej vľavo.
Príklad:
(a ^= 2) can be written as (a = a ^ 2)>
Ak je počiatočná hodnota uložená v a 6. Potom (a ^= 2) = 4.
- |=(Bitwise Inclusive ALEBO) : Tento operátor je kombináciou operátorov „|“ a „=“. Tento operátor najprv Bitwise Inclusive ALEBO aktuálnu hodnotu premennej vľavo o hodnotu vpravo a potom priradí výsledok premennej vľavo.
Príklad:
(a |= 2) can be written as (a = a | 2)>
Ak na začiatku, hodnota uložená v a je 6. Potom (a |= 2) = 6.
Prí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ýkon :
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>
Podmienený operátor
Je to ternárny operátor, ktorý je skrátenou verziou príkazu if-else. Má tri operandy, a preto názov ternárny. V závislosti od hodnoty boolovského výrazu vráti jednu z dvoch hodnôt.
Syntax:
condition ? first_expression : second_expression;>
Vysvetlenie:
podmienka: Musí byť vyhodnotená ako true alebo false.
Ak je podmienka pravdivá
first_expression sa vyhodnotí a stane sa výsledkom.
Ak je podmienka nepravdivá,
druhý_výraz sa vyhodnotí a stane sa výsledkom.
Prí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; // Zobrazenie výsledku Console.WriteLine('Výsledok: ' + výsledok); // Ak chcete zistiť, ktorá hodnota je väčšia // Použitie podmieneného operátora výsledok = x< y ? x : y; // To display the result Console.WriteLine('Result: ' + result); } } }> Výkon :
Result: 10 Result: 5>