Meny

C # operatörer: aritmetik, relation, tilldelning och logisk

  • Huvud
  • Övrig
  • C # operatörer: aritmetik, relation, tilldelning och logisk

c operators arithmetic

hur man gör ett ddos-program

Prova Vårt Instrument För Att Eliminera Problem

Operatörer i C # är speciella symboler för att beteckna den operation som programmet behöver utföra. Denna handledning förklarar C # -operatörer i detalj med exempel:

I vår tidigare handledning lärde vi oss om villkorliga uttalanden i C #. Vi lärde oss också hur man använder if, if-else och if-else if uttalanden för att definiera olika villkor.

Ett villkorligt uttalande som 'if' kallas också ett beslutsuttalande eftersom de ger användaren en mekanism för att definiera ett resultat baserat på ett beslut som definierats av operatörer.

Operatörerna erbjuder ett sätt att definiera beslut baserat på logik, aritmetiska operationer, jämförelse etc.

=> Se vår kompletta C # träningsserie här

C # operatörer

Vad du kommer att lära dig:

C # operatörer

Operatörer i C # är specialsymboler som anger den operation som programmet behöver utföra på operanderna. Till exempel, de kan användas för att utvärdera en variabel eller utföra en operation på en variabel för att göra ett korrekt uttryck.

C # erbjuder ett brett utbud av operatörer såsom aritmetiska operatörer, relationsoperatörer, uppdragsoperatörer, logiska operatörer, unary operatörer etc. I denna handledning kommer vi att diskutera några av de viktiga operatörerna tillsammans med deras användning.

Aritmetiska operatörer

Den aritmetiska operatören tillåter programmet att utföra allmänna algebraiska operationer mot numeriska värden.

Det finns fem grundläggande operatörer i programmeringsspråket C #.

  • Tillägg (symbol “+”): Utför tillägget av operander.
  • Subtraktion (symbol “-“): Utför subtraktion av operander.
  • Uppdelning (symbol “/”): Utför uppdelning av operander.
  • Multiplikation (symbol “*”): Utför multiplikation på operander.
  • Modulus (symbol “%”): Returnerar påminnelse efter delningen av heltal.

Exempel:

int a = 10; int b = 5; int result; result = a + b; result = a - b; result = a * b; result = a / b; result = a % b;
  1. Resultatet av den första operationen blir 15, dvs summeringen till två heltal.
  2. Resultatet av den andra operationen blir 5, dvs subtraktion av två heltal.
  3. Resultatet av den tredje operationen blir 50, dvs. multiplicering mellan två heltal.
  4. Resultatet av den fjärde operationen blir 2 dvs utdata från delning av två heltal.
  5. Resultatet av den femte operationen blir 0 eftersom det inte finns någon påminnelse kvar när två givna heltal delas.

Man bör komma ihåg att resultatet av operationen beror på datatypen som används för att lagra resultatet.

Så om delningen av två heltal värden returnerar ett flytvärde och om resultatet tilldelas en heltal variabel kommer decimaldelen att gå förlorad på grund av olika datatyper. Om du vill lära dig mer om datatyper och konvertering besök vår tidigare handledning.

Moduloperatören är annorlunda än de andra operatörerna, den returnerar värdet på påminnelsen från delningen av heltal. Låt oss säga att om vi delar 20 med 6, kommer delningsoperatören att returnera ett svar som 3 (kvoten) och moduloperatören kommer att returnera 2, dvs. påminnelsen om delningen.

Förutom ovanstående 5 definierade operatörer erbjuder C # också två specialoperatörer som ökar eller minskar värdet på en variabel med 1.

Dessa är:

  • Ökningsoperatör : Betecknas med symbolen “++”
  • Minska operatören : Betecknas med symbolen “- -“

Dessa operatörer kan förinställas eller efterföljas med variabler för drift.

Exempel:

int a = 10; int b = 5; int increment; int decrement; increment = a++; decrement = b--;

I exemplet ovan kommer svaret för inkrement att vara 11, dvs. värdet på a kommer att ökas med 1. Medan svaret för minskning blir 4, dvs. värdet på b kommer att minskas med 1.

Relationsoperatörer

Varje relation mellan de två operanderna valideras med hjälp av relationsoperatorer. Relationsoperatörer returnerar booleska värden. Om relationen mellan två operander har validerats framgångsrikt kommer den att returneras 'true' och om valideringen misslyckas kommer 'false' att returneras.

Relationsoperatörer används främst vid beslutsfattande eller för att definiera villkor för slingor.

Låt oss titta på de relationsoperatörer som erbjuds av C #:

  • Större än operatör: (betecknas med '>'): Validerar större än förhållandet mellan operander.
  • Mindre än operatör: (betecknad med “<“): Validates less than the relation between operands.
  • Lika med operatören: (betecknad med '=='): Validerar likheten mellan två operander.
  • Större än eller lika med (betecknad med '> ='): Validerar större än eller lika med förhållandet mellan de två operanderna.
  • Mindre än eller lika med (betecknad med “<=”): Validates less than or equals to the relations between the two operands.
  • Inte lika med: (betecknad med '! ='): Validerar inte ett lika förhållande mellan de två operanderna.
int a = 10; int b = 5; bool validate; validate = a > b; //1 Console.WriteLine(validate); validate = a = b; //4 Console.WriteLine(validate); validate = a <= b; //5 Console.WriteLine(validate); validate = a != b; //6 Console.WriteLine(validate);

Resultatet från ovanstående program kommer att vara:

  1. a> b returnerar 'True'.
  2. till
  3. a == b returnerar 'Falskt'.
  4. a> = b returnerar 'True' som a är större än b och operatören letar efter en framgångsrik utvärdering av något av de givna villkoren för att returnera ett sant värde. Eftersom det givna exemplet returnerar 'True' i båda fallen kommer operatören att returnera true.
  5. till<=b will return “False” as a is neither less than b nor equal to b.
  6. a! = b returnerar 'True' eftersom a inte är lika med b.

Uppdragsoperatörer

Tilldelningsoperatörer används för att tilldela värde till en variabel. Dessa används vanligtvis före en aritmetisk operatör.

Låt oss ta en titt på uppdragsoperatörerna som erbjuds av C #:

(i) Lika med (“=”): Det är en av de enklaste uppdragsoperatörerna. Det tilldelar värdet av en operand till en annan. dvs värdet av höger sida operand till vänster sida operand.

Exempel de: a = b

(ii) Lägg till lika till uppdragsoperatören: Som namnet antyder är det en kombination av plus '+' och lika med '='. Det skrivs som '+ =' och det lägger till operanden på höger sida till vänster operand och lagrar slutvärdet i vänster operand.

Exempel: a + = b betyder (a = a + b)

(iii) Subtrahera Equal Assignment Operator: På samma sätt som tillägget lika, subtraherar det värdet på högeroperand från vänsteroperand och tilldelar sedan värdet till vänsteroperand.

Exempel: a - = b betyder (a = a-b)

(iv) Division lika med uppdragsoperatören: Den delar värdet på högeroperand med vänsteroperand och lagrar sedan resultatet i vänsteroperand.

Exempel: a / = b medelvärde (a = a / b)

(v) Multiplicera lika med uppdragsoperatören: Den multiplicerar värdet på högeroperand med vänsteroperand och lagrar sedan resultatet i vänsteroperand.

Exempel: a * = b medelvärde (a = a * b)

(vi) Modulus är lika med uppdragsoperatören: Den hittar modulen för vänster och höger operand och lagrar värdet i vänster operand.

Exempel:

a %=b means (a= a%b)

Nedan följer ett program för att få mer tydlighet:

int a = 10; int b = 5; a += b; //1 Console.WriteLine(a); a -= b; //2 Console.WriteLine(a); a /= b; //3 Console.WriteLine(a); a *= b; //4 Console.WriteLine(a); a %= b; //5 Console.WriteLine(a);

Produktion

  1. Det första värdet kommer att returnera 15, dvs. a = a + b.
  2. Den andra operatören returnerar 10 dvs a = a-b.
  3. Den tredje operatören returnerar 2, dvs. a = a / b.
  4. Den fjärde operatören returnerar 50 dvs a = a * b.
  5. Den femte operatören returnerar 0 dvs a = a% b.

Logiska operatörer

Logiska operatörer används för att utföra logiska operationer. Logiska operatörer arbetar med booleska uttryck och returnerar ett booleskt värde. Logiska operatörer används med de villkorade operatörerna i slingor och beslutsuttalanden.

Logiska operatörer och deras användning.

# 1) Logisk OCH operatör

Symbol: '&&'

AND-operatören returnerar true när båda värdena är true. Om något av värdet är falskt returnerar det falskt.

Till exempel, A && B kommer att returnera sant om både A och B är sanna, om någon eller båda är falska kommer den att returnera falsk.

# 2) Logisk ELLER operatör

Symbol: '||'

OR-operatören returnerar true om något av villkoren / operanderna är sanna. Det kommer att returnera falskt när båda operanderna är falska.

Till exempel, A || B returnerar sant om värdet på antingen A eller B är sant. Det kommer att returnera falskt om både A och B har falska värden.

# 3) Logiskt INTE operatör

Symbol: '!'

NOT-operatören används för att vända den logiska slutsatsen av alla villkor. Om villkoret är sant kommer det att returnera falskt och om villkoret är falskt kommer det att återvända.

Exempel, ! (A || B) returnerar falskt om “A || B” returnerar true och returnerar true om “A || B” returnerar false.

Exempel på program:

int a = 10; int b = 5; bool result; // AND operator result = (a == b) && (a>b) Console.WriteLine(result); //OR Operator result = (a == b) || (a>b) Console.WriteLine(result); //NOT Operator result = !((a == b) || (a>b)) Console.WriteLine(result);

Resultatet från ovanstående program kommer att vara:

  1. Det första värdet returnerar falskt eftersom ett av villkoren, dvs. a == b är falskt.
  2. Den andra operatören kommer att återvända som ett av villkoren, dvs a> b är sant.
  3. Den tredje operatören kommer att returnera falsk, dvs. negationen av resultatet från OR-operatören.

Slutsats

I den här handledningen lärde vi oss om de olika typerna av operatörer i programmeringsspråket C #. Vi lärde oss användningen och symbolerna hos dessa operatörer. Den aritmetiska operatoren används av programmet för att utföra enkla algebraiska operationer som addition, subtraktion, multiplikation, division etc.

Relationsoperatorer är de som används för att validera ett förhållande mellan de två operanderna som om de är lika, större än, mindre än osv. Tilldelningsoperatorer används för att tilldela värden till en variabel. Ett mycket enkelt exempel på uppdragsoperatören är ”lika med”. Logiska operatorer används för att utföra logiska operationer som AND, OR, NOT, etc.

Operatörer används i stor utsträckning för att deklarera villkor i beslutsuttalanden, medan de använder loopar eller när de utför algebraiska operationer.

=> Se vår ultimata C # -träningsguide här

Rekommenderad läsning

^