Operaattorit ovat minkä tahansa ohjelmointikielen perusta. Näin ollen toiminnallisuus C# kieli on epätäydellinen ilman operaattoreita. Operaattorit antavat meille mahdollisuuden suorittaa erilaisia ​​operaatioita operandit . Sisään C# , operaattorit Voidaan luokitella perustuvat niiden erilaisia toiminnallisuus :

• Aritmeettiset operaattorit
• Relaatiooperaattorit
• Loogiset operaattorit
• Bittikohtaiset operaattorit
• Tehtäväoperaattorit
• Ehdollinen operaattori

C#:ssa operaattorit voivat myös luokitella Operandien lukumäärän perusteella:

• Yksittäinen operaattori: Operaattori, joka ottaa yksi operandi toiminnon suorittamiseksi.
• Binäärioperaattori: Operaattori, joka ottaa kaksi operandit toiminnan suorittamiseksi.
• Kolminkertainen operaattori: Operaattori, joka ottaa kolme operandit toiminnan suorittamiseksi.
  

Aritmeettiset operaattorit

Näitä käytetään suorittamaan aritmeettisia/matemaattisia operandeja. The Binäärioperaattorit tähän kategoriaan kuuluvat:

• Lisäys: The '+' operaattori lisää kaksi operandia. Esimerkiksi, x+y .
• Vähennyslasku: The '-' operaattori vähentää kaksi operandia. Esimerkiksi, x-y .
• Kertominen: The '*' operaattori kertoo kaksi operandia. Esimerkiksi, x*y .
• Jaosto: The '/' operaattori jakaa ensimmäisen operandin toisella. Esimerkiksi, x/y .
• Moduuli: The '%' operaattori palauttaa jäännöksen, kun ensimmäinen operandi jaetaan toisella. Esimerkiksi, x%y .

Esimerkki:

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

Lähtö:

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

Ne, jotka kuuluvat kategoriaan Yksittäiset operaattorit ovat:

• Lisäys: The '++' operaattoria käytetään lisäämään kokonaisluvun arvoa. Kun sijoitetaan muuttujan nimen eteen (kutsutaan myös ennakkolisäys operaattori), sen arvo kasvaa välittömästi. Esimerkiksi, ++x .
  Ja kun se sijoitetaan muuttujan nimen jälkeen (kutsutaan myös lisäyksen jälkeinen operaattori ), sen arvo säilyy väliaikaisesti tämän käskyn suorittamiseen asti ja se päivitetään ennen seuraavan käskyn suorittamista. Esimerkiksi, x++ .
• Vähennä: The '--' -operaattoria käytetään kokonaisluvun arvon pienentämiseen. Kun sijoitetaan muuttujan nimen eteen (kutsutaan myös ennen vähennystä operaattori ), sen arvo pienenee välittömästi. Esimerkiksi, - -x .
  Ja kun se sijoitetaan muuttujan nimen jälkeen (kutsutaan myös decrement-operaattori ), sen arvo säilyy väliaikaisesti tämän käskyn suorittamiseen asti ja se päivitetään ennen seuraavan käskyn suorittamista. Esimerkiksi, x-- .

Esimerkki:

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

Lähtö:

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>

Relaatiooperaattorit

Relaatiooperaattoreita käytetään kahden arvon vertailuun. Katsotaanpa niitä yksitellen:

• ‘=='(Yhtä kuin) operaattori tarkistaa, ovatko kaksi annettua operandia yhtä suuria vai eivät. Jos näin on, se on totta. Muuten se palauttaa false. Esimerkiksi, 5==5 palaa todeksi.
• ‘!='(Ei yhtä suuri kuin) operaattori tarkistaa, ovatko kaksi annettua operandia yhtä suuria vai eivät. Jos ei, se on totta. Muuten se palauttaa false. Se on tarkka boolen komplementti '==' operaattori. Esimerkiksi, 5! = 5 palauttaa false.
• '>' (Suurempi kuin) operaattori tarkistaa, onko ensimmäinen operandi suurempi kuin toinen operandi. Jos näin on, se on totta. Muuten se palauttaa false. Esimerkiksi, 6>5 palaa todeksi.
• ‘<’(Vähemmän kuin) operaattori tarkistaa, onko ensimmäinen operandi pienempi kuin toinen operandi. Jos näin on, se on totta. Muuten se palauttaa false. Esimerkiksi, 6<5 palauttaa false.
• '>='(Suurempi kuin yhtä suuri) operaattori tarkistaa, onko ensimmäinen operandi suurempi tai yhtä suuri kuin toinen operandi. Jos näin on, se on totta. Muuten se palauttaa false. Esimerkiksi, 5>=5 palaa todeksi.
• ‘<='(vähemmän kuin yhtä suuri) operaattori tarkistaa, onko ensimmäinen operandi pienempi tai yhtä suuri kuin toinen operandi. Jos näin on, se on totta. Muuten se palauttaa false. Esimerkiksi, 5<=5 tulee myös todeksi.

Esimerkki:

// 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('Suurempi kuin operaattori: ' + tulos);    // Vähemmän kuin operaattorin tulos = (x< y);  Console.WriteLine('Less than Operator: ' + result);    // Greater than Equal to Operator  result = (x>= y);  Console.WriteLine('Suurempi kuin tai yhtä suuri kuin: '+ tulos);    // Vähemmän kuin yhtä suuri kuin operaattorin tulos = (x<= y);  Console.WriteLine('Lesser than or Equal to: '+ result);    // Not Equal To Operator  result = (x != y);  Console.WriteLine('Not Equal to Operator: ' + result);  } } }>

Lähtö:

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>

Loogiset operaattorit

Niitä käytetään yhdistämään kaksi tai useampia ehtoja/rajoituksia tai täydentämään kyseessä olevan alkuperäisen ehdon arviointia. Ne on kuvattu alla:

• Looginen JA: The '&&' operaattori palauttaa tosi, kun molemmat tarkasteltavat ehdot täyttyvät. Muuten se palauttaa false. Esimerkiksi, a && b palauttaa tosi, kun sekä a että b ovat tosi (eli nollasta poikkeavat).
• Looginen TAI: The '||' operaattori palauttaa tosi, kun toinen (tai molemmat) tarkasteltavista ehdoista täyttyy. Muuten se palauttaa false. Esimerkiksi, a || b palauttaa tosi, jos jokin a:sta tai b:stä on tosi (eli nollasta poikkeava). Tietenkin se palauttaa tosi, kun sekä a että b ovat tosia.
• Looginen EI: The '!' operaattori palauttaa tosi, tarkasteltava ehto ei täyty. Muuten se palauttaa false. Esimerkiksi, !a palauttaa tosi, jos a on epätosi, eli kun a=0.

Esimerkki:

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

Lähtö:

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

Bittikohtaiset operaattorit

C#:ssa on 6 bittikohtaista operaattoria, jotka toimivat bittitasolla tai joita käytetään suorittamaan bitti bitiltä -toimintoja. Seuraavat ovat bittikohtaiset operaattorit:

• & (bittisesti JA) Ottaa kaksi numeroa operandiksi ja tekee AND:n jokaiselle kahden luvun bitille. AND:n tulos on 1 vain, jos molemmat bitit ovat 1.
• | (bittisesti TAI) Ottaa kaksi numeroa operandiksi ja tekee TAI jokaiselle kahden luvun bitille. TAI:n tulos on 1, mikä tahansa kahdesta bitistä on 1.
• ^ (bittikohtainen XOR) Ottaa kaksi numeroa operandeina ja tekee XOR:n jokaiselle kahden luvun bitille. XOR:n tulos on 1, jos kaksi bittiä ovat erilaisia.
• ~ (bittikohtainen täydennys) Ottaa yhden luvun operandiksi ja kääntää jokaisen bitin, joka on 1:stä 0:aan ja 0:sta 1:een.
• << (vasen vaihto) Ottaa kaksi numeroa, vasemmalle siirtää ensimmäisen operandin bittejä, toinen operandi päättää siirrettävien paikkojen lukumäärän.
• >> (oikea vaihto) Ottaa kaksi numeroa, siirtää oikealle ensimmäisen operandin bittejä, toinen operandi päättää siirrettävien paikkojen lukumäärän.

Esimerkki:

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

Lähtö:

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

Tehtäväoperaattorit

Määritysoperaattoreita käytetään arvon määrittämiseen muuttujalle. Osoitusoperaattorin vasemman puolen operandi on muuttuja ja osoitusoperaattorin oikean puolen operandi on arvo. Oikean puolen arvon tulee olla samaa tietotyyppiä kuin vasemman puolen muuttuja, muuten kääntäjä aiheuttaa virheen.

Alla on esitetty erityyppiset toimeksiantooperaattorit:

• =(Yksinkertainen tehtävä) : Tämä on yksinkertaisin tehtäväoperaattori. Tätä operaattoria käytetään määrittämään oikealla oleva arvo vasemmalla olevalle muuttujalle.
  Esimerkki:

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

• +=(Lisää tehtävä) : Tämä operaattori on yhdistelmä '+'- ja '='-operaattoreita. Tämä operaattori lisää ensin vasemmalla olevan muuttujan nykyisen arvon oikealla olevaan arvoon ja määrittää sitten tuloksen vasemmalla olevaan muuttujaan.
  Esimerkki:

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

Jos alun perin tallennettu arvo on 5. Silloin (a += 6) = 11.

• -=(Vähennä tehtävä) : Tämä operaattori on '-'- ja '='-operaattorien yhdistelmä. Tämä operaattori vähentää ensin vasemmalla olevan muuttujan nykyisen arvon oikealla olevasta arvosta ja määrittää sitten tuloksen vasemmalla olevalle muuttujalle.
  Esimerkki:

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

Jos alun perin tallennettu arvo on 8. Silloin (a -= 6) = 2.

• *=(Merkintätehtävä) : Tämä operaattori on yhdistelmä '*'- ja '='-operaattoreita. Tämä operaattori kertoo ensin vasemmalla olevan muuttujan nykyisen arvon oikealla olevalla arvolla ja määrittää sitten tuloksen vasemmalla olevalle muuttujalle.
  Esimerkki:

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

Jos alun perin tallennettu arvo on 5. Sitten (a *= 6) = 30.

• /=(Divisioonan tehtävä): Tämä operaattori on '/'- ja '='-operaattorien yhdistelmä. Tämä operaattori jakaa ensin vasemmalla olevan muuttujan nykyisen arvon oikealla olevalla arvolla ja määrittää sitten tuloksen vasemmalla olevalle muuttujalle.
  Esimerkki:

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

Jos alun perin tallennettu arvo on 6. Silloin (a /= 2) = 3.

• %=(Moduulitehtävä): Tämä operaattori on yhdistelmä '%' ja '='-operaattoreita. Tämä operaattori moduloi ensin vasemmalla olevan muuttujan nykyisen arvon oikealla olevalla arvolla ja määrittää sitten tuloksen vasemmalla olevalle muuttujalle.
  Esimerkki:

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

Jos alun perin tallennettu arvo on 6. Sitten (a %= 2) = 0.

• <<=(Vasen vaihtotehtävä) : Tämä operaattori on yhdistelmä '<<' ja '='-operaattoreita. Tämä operaattori ensin Vasen siirtää vasemmalla olevan muuttujan nykyistä arvoa oikealla olevalla arvolla ja määrittää sitten tuloksen vasemmalla olevalle muuttujalle.
  Esimerkki:

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

Jos alun perin tallennettu arvo on 6. Sitten (a <<= 2) = 24.

• >>=(Oikea vaihtotehtävä) : Tämä operaattori on yhdistelmä '>>'- ja '='-operaattoreita. Tämä operaattori ensin oikealle siirtää vasemmalla olevan muuttujan nykyistä arvoa oikealla olevalla arvolla ja määrittää sitten tuloksen vasemmalla olevalle muuttujalle.
  Esimerkki:

(a>>= 2) voidaan kirjoittaa muodossa (a = a>> 2)>

Jos alun perin tallennettu arvo on 6. Silloin (a>>= 2) = 1.

• &=(Bittikohtainen AND määritys) : Tämä operaattori on '&'- ja '='-operaattorien yhdistelmä. Tämä operaattori ensin Bitwise JA vasemmalla olevan muuttujan nykyisen arvon oikealla olevalla arvolla ja sitten määrittää tuloksen vasemmalla olevalle muuttujalle.
  Esimerkki:

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

Jos alun perin tallennettu arvo on 6. Silloin (a &= 2) = 2.

• ^=(Bittikohtaisesti yksinomainen TAI) : Tämä operaattori on '^'- ja '='-operaattoreiden yhdistelmä. Tämä operaattori ensin Bitwise Exclusive TAI vasemmalla olevan muuttujan nykyisen arvon oikealla olevalla arvolla ja määrittää sitten tuloksen vasemmalla olevalle muuttujalle.
  Esimerkki:

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

Jos alun perin tallennettu arvo on 6. Sitten (a ^= 2) = 4.

• |=(Bittikohtainen TAI) : Tämä operaattori on '|'- ja '='-operaattorien yhdistelmä. Tämä operaattori ensin Bitwise Inclusive TAI vasemmalla olevan muuttujan nykyisen arvon oikealla olevalla arvolla ja sitten määrittää tuloksen vasemmalla olevalle muuttujalle.
  Esimerkki:

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

Jos alun perin, a:een tallennettu arvo on 6. Sitten (a |= 2) = 6.

Esimerkki:

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

Lähtö:

java merkkijonojen leikkaus

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>

Ehdollinen operaattori

Se on kolmiosainen operaattori, joka on lyhennetty versio if-else-lauseesta. Sillä on kolme operandia ja siitä syystä nimi ternääri. Se palauttaa toisen kahdesta arvosta riippuen Boolen lausekkeen arvosta.

Syntaksi:

condition ? first_expression : second_expression;>

Selitys:
ehto: Se on arvioitava tosi tai epätosi.
Jos ehto on totta
ensimmäinen_lauseke arvioidaan ja siitä tulee tulos.
Jos ehto on väärä,
toinen_lauseke arvioidaan ja siitä tulee tulos.

Esimerkki:

// 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;     // Tuloksen näyttäminen Console.WriteLine('Result: ' + tulos);    // Suuremman arvon selvittäminen // Ehdollisen operaattorin käyttäminen tulos = x< y ? x : y;     // To display the result  Console.WriteLine('Result: ' + result);  } } }>

Lähtö:

Result: 10 Result: 5>