Operatii aritmetice. Operatori relaționali și logici

Această secțiune descrie pe scurt sintaxa și utilizarea tuturor operatorilor C#, cu excepția unora de bază, care sunt tratate mai târziu în materialul relevant.

Creșteți și descreșteți

Operatorii increment (++) și decrement (--) incrementează și decrementează operandul cu unu. Au două forme de notație - prefix, când semnul operației este scris înaintea operandului și postfix. În formă de prefix, operandul este mai întâi modificat, iar apoi valoarea lui devine valoarea rezultată a expresiei, în timp ce în formă de postfix, valoarea expresiei este valoarea inițială a operandului, iar apoi este modificată.

Operații standard de creștere există pentru valori întregi, caractere, reale și financiare.

Operațiune nouă

Noua operațiune este utilizată pentru a crea un nou obiect. Format de operare:

tip nou([args])

Folosind această operație, puteți crea obiecte atât de tip referință, cât și de tip valoare, de exemplu:

obiect z = obiect nou(); int i = new int(); // la fel ca int i = 0;

Când se efectuează noua operațiune, este mai întâi alocată cantitatea necesară de memorie (pentru tipurile de referință din heap, pentru tipurile de valori - pe stivă) și apoi așa-numita constructor implicit, adică metoda prin care obiectul este inițializat. Variabil tipul valorii atribuit valoare implicită, care este egal cu zero de tipul corespunzător.

Operațiuni de negație

Negație aritmetică(unar minus – ) inversează semnul operandului. Operația standard de negație este definită pentru tipuri int, lung , float , dublu și zecimal . Se poate aplica la cantitati de alte tipuri daca este posibil pentru ele conversie implicită la aceste tipuri.

boolean negare(!) este definit pentru tipul bool . Rezultatul operației este fals dacă operandul este adevărat și adevărat dacă operandul este fals.

Negație pe biți(~), numită adesea pe biți, inversează fiecare bit în reprezentarea binară a unui operand de tip int, uint, long sau ulong.

Conversie explicită de tip

O operație este folosită pentru a converti explicit o valoare de la un tip la altul. Acest lucru este necesar atunci când nu există o conversie implicită. La conversia de la un tip mai lung la unul mai scurt, informațiile se pot pierde. Format de operare:

(tip) expresie

Aici tipul este numele tipului la care se face conversia, iar expresia este cel mai adesea numele unei variabile, de exemplu:

lung b = 300; int a = (int) b; // nu se pierd date int d = (octet) a; // datele sunt pierdute

Înmulțirea, împărțirea și restul

Operația de înmulțire(*) returnează rezultatul înmulțirii a doi operanzi. Operația standard de înmulțire este definită pentru tipurile int, uint, long, ulong, float, double și decimal. Se poate aplica valorilor de alte tipuri dacă acestea pot fi convertite implicit la aceste tipuri. Tipul rezultatului operației este egal cu „cel mai mare” dintre tipurile de operanzi, dar nu mai mic decât int .

tabelul 3.2. Simbolurile x și y denotă valori pozitive finite, iar simbolul z denotă rezultatul operației reale de înmulțire. Dacă rezultatul este prea mare pentru a fi reprezentat de tipul dat, este setat la infinit dacă este prea mic, este setat la 0. NaN (nu este un număr) înseamnă că rezultatul nu este un număr;

Tabelul 3.2. Rezultate reale înmulțirii

*	+y	-y	+0	-0	+	-	NaN
+x	+z	-z	+0	-0	+	-	NaN
-X	-z	+z	-0	+0	-	+	NaN
+0	+0	-0	+0	-0	NaN	NaN	NaN
-0	-0	+0	-0	+0	NaN	NaN	NaN
+	+	-	NaN	NaN	+	-	NaN
-	-	+	NaN	NaN	-	+	NaN
NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN

Operarea diviziei(/) calculează câtul primului operand împărțit la al doilea. Operația standard de împărțire este definită pentru tipurile int, uint, long, ulong, float, double și decimal. Poate fi aplicat valorilor de alte tipuri dacă există o conversie implicită pentru acestea la aceste tipuri. Tipul rezultatului este determinat de regulile de conversie, dar nu este mai mic decât int .

Dacă ambii operanzi sunt numere întregi, rezultatul operației este rotunjit în jos la cel mai apropiat număr întreg. Dacă divizorul egal cu zero, este aruncată o excepție System.DivideByZeroException.

Dacă cel puțin unul dintre operanzi este real, partea fracțională a rezultatului diviziunii nu este eliminată, ci toate valori posibile sunt prezentate în tabelul 3.3.

Tabelul 3.3. Rezultate reale de divizie

/	+y	-y	+0	-0	+	-	NaN
+x	+z	-z	+	-	+0	-0	NaN
-X	-z	+z	-	+	-0	+0	NaN
+0	+0	-0	NaN	NaN	+0	-0	NaN
-0	-0	+0	NaN	NaN	-0	+0	NaN
+	+	-	+	-	NaN	NaN	NaN
-	-	+	-	+	NaN	NaN	NaN
NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN

Pentru valorile financiare (de tip zecimal), împărțirea cu 0 și depășirea generează excepții adecvate; dispariția ordinii rezultatul este 0.

Operațiunea restului diviziei(%) este, de asemenea, interpretat diferit pentru cantități întregi, reale și financiare. Dacă ambii operanzi sunt numere întregi, rezultatul operației este calculat folosind formula x - (x / y) * y. Dacă divizorul este zero, este aruncată o excepție System.DivideByZeroException.

Dacă cel puțin unul dintre operanzi este real, rezultatul operației se calculează folosind formula x – n * y, unde n este cel mai mare număr întreg mai mic sau egal cu rezultatul împărțirii x la y. Toate combinatii posibile Valorile operanzilor sunt date în tabelul 3.4.

Tabelul 3.4. Rezultate reale rămase

%	+y	-y	+0	-0	+	-	NaN
+x	+z	z	NaN	NaN	X	X	NaN
-X	-z	-z	NaN	NaN	-X	-X	NaN
+0	+0	+0	NaN	NaN	+0	+0	NaN
-0	-0	-0	NaN	NaN	-0	-0	NaN
+	NaN	NaN	NaN	NaN	NaN	NaN	NaN
-	NaN	NaN	NaN	NaN	NaN	NaN	NaN
NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN

Pentru valorile financiare (de tip zecimal), la obținerea restului de împărțire la 0 și la depășire, se generează excepții corespunzătoare, când dispariția ordinii rezultatul este 0. Semnul rezultatului este egal cu semnul primului operand.

Adunare si scadere

Operație de adăugare(+) returnează suma a doi operanzi. Operația de adăugare standard este definită pentru tipurile int, uint, long, ulong, float, double și decimal. Poate fi aplicat valorilor de alte tipuri dacă există o conversie implicită pentru acestea la aceste tipuri. Tipul rezultatului operației este egal cu „cel mai mare” dintre tipurile de operanzi, dar nu mai mic decât int .

Toate valorile posibile pentru operanzi reali sunt date în tabelul 3.5.

Tabelul 3.5. Rezultate adaosuri reale

+	y	+0	-0	+	-	NaN
X	z	X	X	+	-	NaN
+0	y	+0	+0	+	-	NaN
-0	y	+0	-0	+	-	NaN
+	+	+	+	+	NaN	NaN
-	-	-	-	NaN	-	NaN
NaN	NaN	NaN	NaN	NaN	NaN	NaN

Operația de scădere(-) returnează diferența a doi operanzi. Operația standard de scădere este definită pentru tipurile int, uint, long, ulong, float, double și decimal. Poate fi aplicat valorilor de alte tipuri dacă există o conversie implicită pentru acestea la aceste tipuri. Tipul rezultatului operației este egal cu „cel mai mare” dintre tipurile de operanzi, dar nu mai mic decât int .

Dacă ambii operanzi sunt întregi sau zecimale și rezultatul operației este prea mare pentru a fi reprezentat de tipul specificat, este aruncată o excepție System.OverflowException.

Toate valorile posibile ale rezultatului scăderii pentru operanzi reali sunt date în tabelul 3.6. Simbolurile x și y denotă valori pozitive finite, iar simbolul z denotă rezultatul unei operații reale de scădere. Dacă x și y sunt egali, rezultatul este zero pozitiv. Dacă rezultatul este prea mare pentru a fi reprezentat de tipul dat, se consideră că este valoarea „infinit” cu același semn ca x - y , dacă este prea mic, se consideră a fi 0 cu același semn ca x - y .

Tabelul 3.6. Rezultate reale de scădere

-	y	+0	-0	+	-	NaN
X	z	X	X	-	+	NaN
+0	-y	+0	+0	-	+	NaN
-0	-y	-0	+0	-	+	NaN
+	+	+	+	NaN	+	NaN
-	-	-	-	-	NaN	NaN
NaN	NaN	NaN	NaN	NaN	NaN	NaN

Operații în schimburi

Operații în schimburi (<< и >> ) se aplică operanzilor întregi. Acestea mută reprezentarea binară a primului operand la stânga sau la dreapta cu numărul de cifre binare specificat de al doilea operand.

La schimba la stânga (<< ) освободившиеся разряды обнуляются. При schimba la dreapta(>> ) biții eliberați sunt umpluți cu zerouri dacă primul operand este nesemnat, iar cu un bit cu semn în caz contrar. Operațiile standard de schimbare sunt definite pentru tipurile int, uint, long și ulong.

Operații relaționale și teste de egalitate

Operațiuni de relație (< , <= , >, >= , == , != ) compară primul operand cu al doilea. Operanzii trebuie să fie tip aritmetic. Rezultatul operației este tip boolean, este adevărat sau fals . Regulile pentru calcularea rezultatelor sunt date în > y

adevărat dacă x este mai mare decât y, fals în caz contrar X<= y adevărat dacă x este mai mic sau egal cu y, fals în caz contrar x >= y adevărat dacă x este mai mare sau egal cu y, fals în caz contrar

Operații logice pe biți

Operații logice pe biți(& , | , ^ ) se aplică operanzilor întregi și operează pe reprezentările lor binare. La efectuarea operațiilor, operanzii sunt mapați bit cu bit (primul bit al primului operand cu primul bit al celui de-al doilea, al doilea bit al primului operand cu al doilea bit al celui de-al doilea etc.). Operațiile standard sunt definite pentru tipurile int, uint, long și ulong.

La conjuncție pe biți(& ), bitul rezultat este 1 numai atunci când biții corespunzători ambilor operanzi sunt 1.

La disjuncție pe biți(| ), bitul rezultat este 1 când bitul corespunzător a cel puțin unuia dintre operanzi este 1.

Cu SAU exclusiv pe biți() un bit rezultat este 1 numai dacă bitul corespunzător doar unuia dintre operanzi este 1.

Operații booleene condiționate

Operații booleene condiționate AND (&&) și SAU (||) sunt cel mai adesea folosite cu operanzi booleeni. Rezultatul unei operații logice este adevărat true , atunci rezultatul unei operații condiționate este valoarea celui de-al doilea operand, în caz contrar valoarea celui de-al treilea operand. Fie al doilea operand, fie al treilea este întotdeauna evaluat. Tipul lor poate varia.

Tipul rezultatului operației depinde de tipul celui de-al doilea și al treilea operanzi. Dacă operanzii sunt de același tip, acesta devine tipul rezultatului operației.

Operatori de atribuire

Operatori de atribuire(= , += , -= , *= , etc.) setează o nouă valoare pentru variabilă. Aceste operații pot fi utilizate într-un program ca instrucțiuni complete.

Format de operare misiune simplă (= ):

variabilă = expresie

Mecanismul de realizare a operației de atribuire este următorul: se calculează o expresie și rezultatul acesteia este stocat în memorie la adresa determinată de numele variabilei situate în stânga semnului operației. Ceea ce a fost stocat anterior în această zonă de memorie se pierde. Exemple de operatori de atribuire:

Pe lângă atribuire, primul operand este adăugat celui de-al doilea, iar rezultatul este scris în primul operand, adică expresia a += b este o reprezentare mai compactă a expresiei a = a + b.

Rezultatul unei operații complexe de atribuire este valoarea scrisă în operandul din stânga.

Operatori de atribuire drept-asociativ, adică se execută de la dreapta la stânga, spre deosebire de majoritatea celorlalte operații (a = b = c înseamnă a = (b = c)).

Întrebări și sarcini pentru munca independentă a elevilor

1. Unde pot fi declarate variabile? Ce este inclus în descrierea variabilei?
2. Ce se întâmplă când folosiți operanzi într-o expresie tipuri variate? Dă exemple.
3. Listați operațiunile limbajului C#, grupându-le după prioritate.
4. Ce este NaN? În ce operații rezultă NaN?
5. La ce tip de operanzi se pot aplica operațiile de schimbare?
6. Care sunt situațiile excepționale?
7. Descrieți principiile gestionării excepțiilor.

Operatori relaţionali şi operatori logici

În notație operator relaţionalȘi operator logic termen relaţieînseamnă o relație care poate exista între două sensuri și termen logic- relația dintre valorile logice „adevărat” și „fals”. Și deoarece operatorii relaționali produc rezultate adevărate sau false, aceștia sunt adesea folosiți împreună cu operatorii logici. Din acest motiv sunt considerate împreună.

Următorii sunt operatorii relaționali:

Operatorii logici includ următorii:

Rezultatul executării unui operator relațional sau logic este o valoare booleană de tip bool .

În general, obiectele pot fi comparate pentru egalitate sau inegalitate folosind operatorii relaționali == și !=. Iar operatorii de comparație, = pot fi aplicați numai tipurilor de date care acceptă relația de ordine. Prin urmare, operatorii relaționali pot fi aplicați tuturor tipuri numerice date. Dar valorile bool pot fi comparate doar pentru egalitate sau inegalitate, deoarece valorile adevărate și false nu sunt ordonate. De exemplu, comparația true > false în C# nu are sens.

Să ne uităm la un exemplu de program care demonstrează utilizarea operatorilor relaționali și logici:

Utilizarea sistemului; folosind System.Collections.Generic; folosind System.Linq; folosind System.Text; namespace ConsoleApplication1 ( clasa Program ( static void Main(string args) ( short d = 10, f = 12; bool var1 = true, var2 = false; if (d f) Console.WriteLine("d > f"); // Comparație variabilele var1 și var2 if (var1 & var2) Console.WriteLine(„Acest text nu va fi tipărit”); var2) Console.WriteLine("var1 | var2 = true"); if (var1 ^ var2) Console.WriteLine("var1 ^ var2 = true");

Operatorii logici în C# efectuează cele mai comune operații logice. Cu toate acestea, există o serie de operații efectuate conform regulilor logicii formale. Aceste operații logice pot fi construite folosind operatorii logici acceptați în C#. În consecință, C# oferă un set de operatori logici care este suficient pentru a construi aproape orice operație logică, inclusiv implicația. Implicare- Acest operație binară, al cărui rezultat este fals numai dacă operandul din stânga este adevărat și operandul din dreapta este fals. (Operația de implicare reflectă următorul principiu: adevărul nu poate implica minciună.)

Operația de implicare poate fi construită pe baza unei combinații de operatori logici! și |:

Operatori logici scurtați

C# oferă, de asemenea, special scurtat, variante ale operatorilor logici AND și OR, menite să producă cod mai eficient. Să explicăm acest lucru folosind următoarele exemple de operații logice. Dacă primul operand al unei operații logice AND este fals, atunci rezultatul său va fi fals indiferent de valoarea celui de-al doilea operand. Dacă primul operand al unei operații logice SAU este adevărat, atunci rezultatul său va fi adevărat indiferent de valoarea celui de-al doilea operand. Datorită faptului că valoarea celui de-al doilea operand din aceste operații nu trebuie calculată, economisește timp și crește eficiența codului.

Scurtat operatie logicaȘi gata operator &&, iar operația OR logică scurtată se face folosind operator ||. Acești operatori logici prescurtați corespund operatorilor logici obișnuiți & și |. Singura diferență dintre un operator logic scurtat și unul obișnuit este că cel de-al doilea operand al său este evaluat numai după cum este necesar.

Ultima actualizare: 19.06.2017

C# folosește majoritatea operațiunilor care sunt utilizate în alte limbaje de programare. Operatiile reprezinta actiuni specifice asupra operanzilor - participanti la operatie. Operandul poate fi o variabilă sau o anumită valoare (de exemplu, un număr). Operațiile pot fi unare (efectuate pe un operand), binare - pe doi operanzi și ternare - efectuate pe trei operanzi. Să luăm în considerare toate tipurile de operațiuni.

Operatii aritmetice binare:

Operația de adunare a două numere:

Int x = 10; int z = x + 12; // 22

Operația de scădere a două numere:

Int x = 10; int z = x - 6; // 4

Operația de înmulțire a două numere:

Int x = 10; int z = x * 5; // 50

operația de împărțire a două numere:

Int x = 10; int z = x / 5; // 2 dublu a = 10; dublu b = 3; dublu c = a / b; // 3,33333333

La împărțire, merită să luați în considerare faptul că, dacă ambii operanzi reprezintă numere întregi, atunci rezultatul va fi, de asemenea, rotunjit la un număr întreg:

Dublu z = 10 / 4; //rezultatul este 2

Chiar dacă rezultatul operației este plasat în cele din urmă variabila de tip double, care vă permite să salvați partea fracționară, dar operația în sine implică două literale, care în mod implicit sunt tratate ca obiecte int, adică numere întregi, iar rezultatul va fi, de asemenea, un număr întreg.

Pentru a ieși din această situație, este necesar să definiți literalele sau variabilele implicate în operație ca tipuri duble sau float:

Dublu z = 10,0 / 4,0; //rezultatul este 2,5

Operația de obținere a restului unei împărțiri întregi a două numere:

x dublu = 10,0; dublu z = x % 4,0; //rezultatul este 2

Există, de asemenea, o serie de operații unare la care ia parte un operand:

Operație de creștere

Incrementul poate fi prefixat: ++x - mai întâi valoarea variabilei x este mărită cu 1, iar apoi valoarea acesteia este returnată ca rezultat al operației.

Și există, de asemenea, un increment postfix: x++ - mai întâi valoarea variabilei x este returnată ca rezultat al operației, iar apoi i se adaugă 1.

int x1 = 5; int z1 = ++x1; // z1=6; x1=6 Console.WriteLine($"(x1) - (z1)"); int x2 = 5; int z2 = x2++; // z2=5; x2=6 Console.WriteLine($"(x2) - (z2)");

Operația de scădere sau scădere a unei valori cu unu. Există, de asemenea, o formă de prefix de decrement (--x) și o formă postfixă (x--).

Int x1 = 5; int z1 = --x1; // z1=4; x1=4 Console.WriteLine($"(x1) - (z1)"); int x2 = 5; int z2 = x2--; // z2=5; x2=4 Console.WriteLine($"(x2) - (z2)");

Atunci când se efectuează mai multe operații aritmetice deodată, trebuie să se țină cont de ordinea în care sunt efectuate. Prioritate de operare de la cea mai mare la cea mai mică:

Crește, scade

Înmulțire, împărțire, rest

Adunare, scădere

Pentru a schimba ordinea operațiilor, se folosesc paranteze.

Luați în considerare un set de operații:

Int a = 3; int b = 5; int c = 40; int d = c---b*a; // a=3 b=5 c=39 d=25 Consola.WriteLine($"a=(a) b=(b) c=(c) d=(d)");

Aici avem de-a face cu trei operații: decrementare, scădere și înmulțire. Mai întâi, variabila c este decrementată, apoi b*a este înmulțită și, în final, scade. Adică, de fapt, setul de operații arăta astfel:

Int d = (c--)-(b*a);

Dar cu ajutorul parantezelor am putea schimba ordinea operațiilor, de exemplu astfel:

Int a = 3; int b = 5; int c = 40; int d = (c-(--b))*a; // a=3 b=4 c=40 d=108 Consola.WriteLine($"a=(a) b=(b) c=(c) d=(d)");

Asociativitatea operatorului

După cum sa menționat mai sus, operațiile de înmulțire și împărțire au aceeași prioritate, dar care va fi rezultatul în expresia:

Int x = 10 / 5 * 2;

Ar trebui să interpretăm această expresie ca (10 / 5) * 2 sau ca 10 / (5 * 2)? La urma urmei, în funcție de interpretare, vom obține rezultate diferite.

Când operațiunile au aceeași prioritate, ordinea evaluării este determinată de asociativitatea operatorilor. În funcție de asociativitate, există două tipuri de operatori:

Operatori asociativi stânga, care sunt executați de la stânga la dreapta

Operatori asociativi dreapta, care sunt executați de la dreapta la stânga

Toți operatorii aritmetici (cu excepția prefixului increment și decrement) sunt asociativi la stânga, adică sunt executați de la stânga la dreapta. Prin urmare, expresia 10 / 5 * 2 trebuie interpretată ca (10 / 5) * 2, adică rezultatul va fi 4.