I denna handledning lär vi dig om operatörens företräde och associativitet i C #. Detta ger oss en uppfattning om hur ett uttryck utvärderas av C # kompilatorn.
C # Operatörens företräde
Operatörens företräde är en uppsättning regler som definierar hur ett uttryck utvärderas. I C # har varje C # -operatör en tilldelad prioritet och baserat på dessa prioriteringar utvärderas uttrycket.
Exempelvis är multiplikationsoperatörens företräde (*)högre än prioriteten för additionsoperatör (+). Därför utförs operation som involverar multiplikation före tillsats.
Ta en titt på uttalandet nedan.
int x = 4 + 3 * 5;
Vad blir värdet av x efter att detta uttalande har utförts?
Operand 3är associerad med +och *. Som tidigare nämnts har multiplikation högre företräde än addition. Så operationen 3 * 5utförs istället för 4 + 3. Värdet på variabeln x kommer att vara 19.
Om tillägg skulle ha högre prioritet, 4 + 3skulle det först utvärderas och värdet på x skulle vara 35.
Operatörens prioritetstabell
Ju högre prioritet operatören har, desto högre visas den i tabellen
C # Operatörens företräde| Kategori | Operatörer |
|---|---|
| Postfix-ökning och minskning | ++, - |
| Prefix Increment, Decrement och Unary | ++, -, +, -,!, ~ |
| Multiplikativ | *, /,% |
| Tillsats | +, - |
| Flytta | <> |
| Relationellt | <,,> = |
| Jämlikhet | ==,! = |
| Bitvis OCH | & |
| Bitvis XOR | ^ |
| Bitvis ELLER | | |
| Logisk OCH | && |
| Logiskt ELLER | || |
| Ternära | ? : |
| Uppdrag | =, + =, - =, * =, / =,% =, & =, | =, =, <> = |
Tilldelningsoperatörerna har lägst företräde medan postfix-inkrement- och minskningsoperatörerna har högst företräde.
Exempel 1: Operatörens företräde
using System; namespace Operator ( class OperatorPrecedence ( public static void Main(string() args) ( int result1; int a = 5, b = 6, c = 4; result1 = --a * b - ++c; Console.WriteLine(result1); bool result2; result2 = b>= c + a; Console.WriteLine(result2); ) ) )
När vi kör programmet blir resultatet:
19 Falskt
Låt oss förstå hur uttrycket utvärderas i programmet.
Prioriteten för --och ++är högre än *, och företräde *är högre än -. Därav uttalandet,
resultat1 = --a * b - ++ c;
är ekvivalent med
resultat1 = ((--a) * b) - (++ c);
Uttrycket inom parentes utvärderas alltid först oavsett vilken prioritet operatörer utanför det har.
- Först utvärderas (--a) till och med
4.
- Sedan utvärderas (++ c) till och med
5.
- Nu utvärderas (a * b) till och med
24.
- Slutligen utförs subtraktionen och resulterar i
19.
- Därför blir slutvärdet för resultat1
19.
I nästa uttryck är företräde +högre än >=. Så, c och a läggs till först och summan jämförs med b för att producera false.
Associativitet för operatörer i C #
I föregående avsnitt diskuterade vi om operatörens företräde. Om två operatörer med olika prioritet används utvärderas operatören med högre prioritet först.
Men tänk om båda operatörerna har samma företräde?
I sådana fall utvärderas uttrycket baserat på operatörens associativitet (vänster till höger eller höger till vänster).
Till exempel:
int a = 5, b = 6, c = 3; int-resultat = a * b / c;
Här både *och /har samma prioritet. Men eftersom associativitet av dessa operatörer är från vänster till höger , a * butvärderas först och sedan division utförs. Det slutliga resultatet av detta uttryck blir 10.
I detta speciella exempel spelar inte associeringsförmågan någon roll. För även om delning genomfördes före multiplikation skulle resultatet inte påverkas.
Låt oss ta en titt på ett annat exempel.
int a = 5, b = 6, c = 3; a = b = c;
=Operatörens associativitet är från höger till vänster . Så värdet på c (dvs. 3) tilldelas b, och sedan tilldelas värdet b till a. Så efter att detta uttalande har utförts kommer värdena a, b och c att vara 3.
Tabellen nedan visar associativiteten för C # -operatörer:
C # Föreningarnas associativitet| Kategori | Operatörer | Associativitet |
|---|---|---|
| Postfix-ökning och minskning | ++, - | Vänster till höger |
| Prefix Increment, Decrement och Unary | ++, -, +, -,!, ~ | Höger till vänster |
| Multiplikativ | *, /,% | Vänster till höger |
| Tillsats | +, - | Vänster till höger |
| Flytta | <> | Vänster till höger |
| Relationellt | <,,> = | Vänster till höger |
| Jämlikhet | ==,! = | Vänster till höger |
| Bitvis OCH | & | Vänster till höger |
| Bitvis XOR | ^ | Vänster till höger |
| Bitvis ELLER | | | Vänster till höger |
| Logisk OCH | && | Vänster till höger |
| Logiskt ELLER | || | Vänster till höger |
| Ternära | ? : | Höger till vänster |
| Uppdrag | =, + =, - =, * =, / =,% =, & =, | =, =, <> = | Höger till vänster |
Nästan alla operatörer har associativitet från vänster till höger. De operatörer som har associativitet från höger till vänster är:
- Unary operatörer
- Prefix Increment and Decrement Operators
- Ternär operatör
- Uppdragsoperatörer
Exempel 2: Operatörers associativitet
using System; namespace Operator ( class OperatorPrecedence ( public static void Main(string() args) ( int a = 5, b = 6, c = 3; int result = a * b / c; Console.WriteLine(result); a = b = c; Console.WriteLine("a = (0), b = (1), c = (2)", a, b, c); ) ) )
När vi kör programmet blir resultatet:
10 a = 3, b = 3, c = 3
