Operatörer är grunden för alla programmeringsspråk. Således funktionaliteten av C# språket är ofullständigt utan användning av operatorer. Operatörer tillåter oss att utföra olika typer av operationer på operander . I C# , operatörer Kan kategoriseras baserad på deras olika funktionalitet :

• Aritmetiska operatorer
• Relationella operatörer
• Logiska operatörer
• Bitwise operatörer
• Uppdragsoperatörer
• Villkorlig operatör

I C# kan operatörer också kategorisera baserat på antal operander:

• Unär operatör: Operatör som tar ett operand för att utföra operationen.
• Binär operatör: Operatör som tar två operander för att utföra operationen.
• Ternär operatör: Operatör som tar tre operander för att utföra operationen.
  

Aritmetiska operatorer

Dessa används för att utföra aritmetiska/matematiska operationer på operander. De Binära operatörer som faller i denna kategori är:

• Tillägg: De '+' operatorn lägger till två operander. Till exempel, x+y .
• Subtraktion: De '-' operatorn subtraherar två operander. Till exempel, x-y .
• Multiplikation: De '*' operator multiplicerar två operander. Till exempel, x*y .
• Division: De '/' operatorn delar den första operanden med den andra. Till exempel, x/y .
• Modul: De '%' operatorn returnerar resten när den första operanden delas med den andra. Till exempel, x%y .

Exempel:

// 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);  }  } }>

Produktion:

Addition Operator: 15 Subtraction Operator: 5 Multiplication Operator: 50 Division Operator: 2 Modulo Operator: 0>

De som faller i kategorin Unära operatörer är:

• Ökning: De '++' operatorn används för att öka värdet på ett heltal. När den placeras före variabelnamnet (kallas även förökning operatör), dess värde ökas omedelbart. Till exempel, ++x .
  Och när den placeras efter variabelnamnet (även kallad operatör efter inkrement ), dess värde bevaras tillfälligt tills den här satsen körs och den uppdateras innan nästa sats körs. Till exempel, x++ .
• Minskning: De '- -' operatorn används för att minska värdet på ett heltal. När den placeras före variabelnamnet (kallas även operatör före dekrementering ), sänks dess värde omedelbart. Till exempel, – -x .
  Och när den placeras efter variabelnamnet (även kallad operatör efter dekrementering ), dess värde bevaras tillfälligt tills den här satsen körs och den uppdateras innan nästa sats körs. Till exempel, x- – .

Exempel:

// 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);       }  } }>

Produktion:

vicky kaushal ålder

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>

Relationella operatörer

Relationsoperatorer används för jämförelse av två värden. Låt oss se dem en efter en:

• '=='(Lika med) operatör kontrollerar om de två givna operanderna är lika eller inte. Om så är fallet, returnerar det sant. Annars returnerar den falskt. Till exempel, 5==5 kommer att återkomma sant.
• '!='(Inte lika med) operatör kontrollerar om de två givna operanderna är lika eller inte. Om inte, returneras det sant. Annars returnerar den falskt. Det är det exakta booleska komplementet till '==' operatör. Till exempel, 5!=5 kommer att returnera falskt.
• '>'(Större än) operatör kontrollerar om den första operanden är större än den andra operanden. Om så är fallet, returnerar det sant. Annars returnerar det falskt. Till exempel, 6>5 kommer att återkomma sant.
• '<'(mindre än) operatören kontrollerar om den första operanden är mindre än den andra operanden. Om så är fallet, returnerar det sant. Annars returnerar den falskt. Till exempel, 6<5 kommer att returnera falskt.
• '>='(Större än lika med) operatör kontrollerar om den första operanden är större än eller lika med den andra operanden. Om så är fallet, returneras det sant. Annars returnerar det falskt. Till exempel, 5>=5 kommer att återkomma sant.
• '<='(mindre än lika med) operatör kontrollerar om den första operanden är mindre än eller lika med den andra operanden. Om så är fallet, returnerar det sant. Annars returnerar den falskt. Till exempel, 5<=5 kommer också tillbaka sant.

Exempel:

// 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('Större än operatör: ' + resultat);    // Mindre än operatörsresultat = (x< y);  Console.WriteLine('Less than Operator: ' + result);    // Greater than Equal to Operator  result = (x>= y);  Console.WriteLine('Större än eller lika med: '+ resultat);    // Mindre än Lika med operatörsresultat = (x<= y);  Console.WriteLine('Lesser than or Equal to: '+ result);    // Not Equal To Operator  result = (x != y);  Console.WriteLine('Not Equal to Operator: ' + result);  } } }>

Produktion:

datorarbete

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>

Logiska operatörer

De används för att kombinera två eller flera villkor/restriktioner eller för att komplettera utvärderingen av det ursprungliga villkoret i beaktande. De beskrivs nedan:

• Logisk OCH: De '&&' operatören returnerar sant när båda villkoren i fråga är uppfyllda. Annars returnerar det falskt. Till exempel, a && b returnerar sant när både a och b är sant (d.v.s. icke-noll).
• Logiskt ELLER: De '||' operatören returnerar sant när ett (eller båda) av villkoren i fråga är uppfyllda. Annars returnerar den falskt. Till exempel, en || b returnerar sant om ett av a eller b är sant (dvs. icke-noll). Naturligtvis returnerar det sant när både a och b är sant.
• Logisk INTE: De '!' operatören returnerar sant villkoret i fråga inte är uppfyllt. Annars returnerar den falskt. Till exempel, !a returnerar sant om a är falskt, dvs när a=0.

Exempel:

// C# program to demonstrate the working  // of Logical Operators using System; namespace Logical {   class GFG {    // Main Function  static void Main(string[] args)   } }>

Produktion:

AND Operator: False OR Operator: True NOT Operator: False>

Bitwise operatörer

I C# finns det 6 bitvisa operatorer som arbetar på bitnivå eller används för att utföra bit för bit operationer. Följande är de bitvisa operatorerna:

• & (bitvis OCH) Tar två tal som operander och gör OCH på varje bit av två tal. Resultatet av OCH är 1 endast om båda bitarna är 1.
• | (bitvis ELLER) Tar två tal som operander och gör ELLER på varje bit av två tal. Resultatet av ELLER är 1 någon av de två bitarna är 1.
• ^ (bitvis XOR) Tar två nummer som operander och gör XOR på varje bit av två nummer. Resultatet av XOR är 1 om de två bitarna är olika.
• ~ (bitvis komplement) Tar ett tal som operand och inverterar varje bit som är 1 till 0 och 0 till 1.
• << (vänster skift) Tar två nummer, vänster skiftar bitarna i den första operanden, den andra operanden bestämmer antalet platser som ska skiftas.
• >> (högerväxling) Tar två nummer, höger skiftar bitarna i den första operanden, den andra operanden bestämmer antalet platser som ska skiftas.

Exempel:

// 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  } }>

Produktion:

Bitwise AND: 0 Bitwise OR: 15 Bitwise XOR: 15 Bitwise Complement: -6 Bitwise Left Shift: 20 Bitwise Right Shift: 1>

Uppdragsoperatörer

Tilldelningsoperatorer används för att tilldela ett värde till en variabel. Tilldelningsoperandens vänstra operand är en variabel och högeroperand för tilldelningsoperatören är ett värde. Värdet på höger sida måste vara av samma datatyp som variabeln på vänster sida annars kommer kompilatorn att skapa ett fel.

Olika typer av uppdragsoperatörer visas nedan:

• =(Enkel uppgift) : Detta är den enklaste tilldelningsoperatören. Denna operator används för att tilldela värdet till höger till variabeln till vänster.
  Exempel:

a = 10; b = 20; ch = 'y';>

• +=(Lägg till uppgift) : Denna operator är en kombination av operatorerna '+' och '='. Denna operator lägger först till det aktuella värdet för variabeln till vänster till värdet till höger och tilldelar sedan resultatet till variabeln till vänster.
  Exempel:

(a += b) can be written as (a = a + b)>

Om det initialt lagrade värdet i a är 5. Då (a += 6) = 11.

• -=(subtrahera tilldelning) : Denna operator är en kombination av operatorerna '-' och '='. Denna operator subtraherar först det aktuella värdet för variabeln till vänster från värdet till höger och tilldelar sedan resultatet till variabeln till vänster.
  Exempel:

(a -= b) can be written as (a = a - b)>

Om det initialt lagrade värdet i a är 8. Då (a -= 6) = 2.

• *=(Multiplicera uppdrag) : Denna operator är en kombination av operatorerna '*' och '='. Denna operator multiplicerar först det aktuella värdet av variabeln till vänster med värdet till höger och tilldelar sedan resultatet till variabeln till vänster.
  Exempel:

(a *= b) can be written as (a = a * b)>

Om det initialt lagrade värdet i a är 5. Då (a *= 6) = 30.

• /=(Divisionsuppdrag): Denna operator är en kombination av operatorerna '/' och '='. Denna operator delar först det aktuella värdet av variabeln till vänster med värdet till höger och tilldelar sedan resultatet till variabeln till vänster.
  Exempel:

(a /= b) can be written as (a = a / b)>

Om det initialt lagrade värdet i a är 6. Då (a /= 2) = 3.

• %=(Modultilldelning): Denna operator är en kombination av operatorerna '%' och '='. Denna operator modulerar först det aktuella värdet av variabeln till vänster med värdet till höger och tilldelar sedan resultatet till variabeln till vänster.
  Exempel:

(a %= b) can be written as (a = a % b)>

Om det initialt lagrade värdet i a är 6. Då (a %= 2) = 0.

• <<=(vänster skifttilldelning) : Denna operator är en kombination av operatorerna '<<' och '='. Denna operatör Vänster skiftar först det aktuella värdet för variabeln till vänster med värdet till höger och tilldelar sedan resultatet till variabeln till vänster.
  Exempel:

(a <<= 2) can be written as (a = a << 2)>

Om det initialt lagrade värdet i a är 6. Då (a <<= 2) = 24.

python eller

• >>=(Högerskiftstilldelning) : Denna operator är en kombination av operatorerna '>>' och '='. Denna operator skiftar först till höger det aktuella värdet för variabeln till vänster med värdet till höger och tilldelar sedan resultatet till variabeln till vänster.
  Exempel:

(a>>= 2) kan skrivas som (a = a>> 2)>

Om det initialt lagrade värdet i a är 6. Då (a>>= 2) = 1.

• &=(Bitwise AND Assignment) : Denna operator är en kombination av operatorerna '&' och '='. Denna operator först Bitvis OCH det aktuella värdet av variabeln till vänster med värdet till höger och tilldelar sedan resultatet till variabeln till vänster.
  Exempel:

(a &= 2) can be written as (a = a & 2)>

Om det initialt lagrade värdet i a är 6. Då (a &= 2) = 2.

• ^=(Bitwise Exclusive ELLER) : Denna operator är en kombination av operatorerna '^' och '='. Denna operator först Bitwise Exclusive ELLER det aktuella värdet av variabeln till vänster med värdet till höger och tilldelar sedan resultatet till variabeln till vänster.
  Exempel:

(a ^= 2) can be written as (a = a ^ 2)>

Om det initialt lagrade värdet i a är 6. Då (a ^= 2) = 4.

• |=(Bitwise Inclusive ELLER) : Denna operator är en kombination av operatorerna '|' och '='. Denna operator först Bitwise Inclusive ELLER det aktuella värdet av variabeln till vänster med värdet till höger och tilldelar sedan resultatet till variabeln till vänster.
  Exempel:

(a |= 2) can be written as (a = a | 2)>

Om initialt är värdet lagrat i a 6. Då (a |= 2) = 6.

Exempel:

// 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);     } }>

Utgång:

rad autocad kommando

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>

Villkorlig operatör

Det är en ternär operator som är en förkortad version av if-else-satsen. Den har tre operander och därav namnet ternary. Den returnerar ett av två värden beroende på värdet på ett booleskt uttryck.

Syntax:

condition ? first_expression : second_expression;>

Förklaring:
villkor: Det måste utvärderas till sant eller falskt.
Om villkoret är sant
first_expression utvärderas och blir resultatet.
Om villkoret är falskt,
second_expression utvärderas och blir resultatet.

Exempel:

// 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;     // För att visa resultatet Console.WriteLine('Resultat: ' + resultat);    // För att hitta vilket värde som är större // Använda villkorlig operatör resultat = x< y ? x : y;     // To display the result  Console.WriteLine('Result: ' + result);  } } }>

Utgång:

Result: 10 Result: 5>