Metode evoluate de programare Limbajele c şi C++

3.3. Operatori

Operatorii limbajului C pot fi grupaţi în mai multe clase, dar oricum ei pot fi folosiţi împreună într-o aceeaşi expresie. Operatorii au arităţi diferite: unari, binari, ternari şi totodată o anumită prioritate implicită care e redată în tabelul de mai jos. Operatorii de aceeaşi prioritate se află trecuţi în aceeaşi linie. Liniile tabelulul conţin operatorii limbajului C în ordinea descrescătoare a priorităţilor. Astfel în prima linie se află operatorii de prioritate maximă, iar în ultima linie operatorul virgulă cu prioritatea cea mai mică. Cu excepţia operatorilor “.”, “->”,”&”,”*”, a parantezelor rotunde (folosite la definiţia şi apelul funcţiilor) şi a parantezelor drepte (folosite la variabilele cu indici) ceilalţi operatori vor fi explicaţi în această lecţie.

( ) [ ] . ->- (unar) +(unar) *(unar) &(unar) ! ~ ++ -- (tip) sizeof* / %+ -<< >>< <= >= >= = !=&^|&&| |? : (ternar)= op= op poate fi: *(binar) / % +(binar) –(binar) << >> & ^ |,

3.3.1. Operatori aritmetici

Lista operatorilor aritmetici este redată mai jos:

- (minus unar);

+ (plus unar);

* / % operatori binari multiplicativi; (înmulţire, împărţire, restul împărţirii întregi);

+ - operatori binari aditivi (adunare şi scădere).

Operatorii de pe aceeaşi linie au aceeaşi prioritate. Cei unari au prioritate mai mare decât cei binari. Operatorii multiplicativi au prioritate mai mare decât cei aditivi.
Exemple:

int i,j,k;

float x,y;

double t[10];

// se dau cateva exemple de expresii folosind operatorii aritmetici

i*x+t[5];

-y+k;

i%j; // daca i=9 si j=4 atunci i%j are valoarea 1

i/j; // daca i=9 si j=4 atunci i/j are valoarea 2

x*-y; // - este operatorul unar deci avem x*(-y)

3.3.2. Operatori relaţionali

Lista operatorilor relaţionali este redată astfel:

< (mai mic)

<= (mai mic sau egal; cele două caractere ce compun operatorul sunt concatenate)

> (mai mare)

>= (mai mare sau egal; cele două caractere ce compun operatorul sunt concatenate)
Toţi operatorii relaţionali au aceeaşi prioritate. Ea este mai mică decât prioritatea operatorilor aditivi. Rezultatul aplicării unui operator relaţional este 1 sau 0, după cum operanzii se află în relaţia definită de operatorul respectiv sau nu.

Exemple:

a= 4 şi b= -5

atunci a>0 are valoarea 1;

a<=0 are valoarea 0;

a+b>0 are valoarea 0;

a>=b are valoarea 1;

a<0 are valoarea 0;

a+b>=b-a are valoarea 1;

a+b>=(b-a)*(b-a) are valoarea 0.

3.3.3. Operatori de egalitate

Lista operatorilor de egalitate este redată mai jos:

= = (egal; două semne “=” concatenate)

!= (diferit; semnele sunt concatenate).

Operatorii de egalitate au ambii aceeaşi prioritate şi este imediat mai mică decât a operatorilor relaţionali. Operatorul “= =” testează egalitatea a doi operanzi. Dacă operanzii sunt egali atunci rezultatul operaţiei “= =” este 1, în caz contrar este 0. Operatorul “!=” furnizează rezultatul 1 când cei doi operanzi sunt diferiţi şi 0 când sunt egali.
Exemple:

a= 2 şi b=-1

atunci

a= =b are valoarea 0;

a!=b are valoarea 1;

a*b!=a+b are valoarea 1.

3.3.4. Operatori logici

Lista operatorilor logici este redată mai jos:

! (negaţia logică - operator unar);

&& (ŞI logic);

|| (SAU logic).
Operatorul “!” are aceeaşi prioritate cu operatorii unari “+” şi “-“. Operatorul “&&” este mai prioritar decât operatorul “||”, dar are o prioritate mai mică decât operatorii de egalitate.

În limbajul C nu există valori logice speciale. Valoarea fals se reprezintă prin zero. Orice valoare diferită de zero reprezintă valoarea adevărat.

Dacă operatorul “!” se aplică la un operand a cărui valoare este zero, atunci rezultatul este 1. Dacă acelaşi operator se aplică la un operand a cărui valoare este diferită de zero, atunci rezultatul este 0.

Dăm în continuare tabelele operatorilor logici binari aplicate valorilor 0 şi 1.

&& 0 1 || 0 1 sau exclusiv 0 1

0 0 0 0 0 1 0 0 1

1 0 1 1 1 1 1 1 0

Chiar dacă pentru “sau exclusiv” nu există operator el se poate realiza prin expresia următoare aplicată operanzilor a şi b: !a&&b||!b&&a sau folosind parantezele rotunde ((!a) &&b)||((!b)&&a).

Operatorii logici se evaluează de la stânga la dreapta. Dacă la evaluarea unei expresii se ajunge într-un punct în care se cunoaşte valoarea întregii expresii, atunci restul expresiei nu se mai evaluează.

Dacă a=0 şi b=1 atunci expresia ! a||b are valoarea 1 pentru că !a are deja valoarea 1.

3.3.5. Operatori logici pe biţi

Lista operatorilor logici pe biţi este redată mai jos în ordinea descrecătoare a priorităţilor:

~ (operator unar; complement faţă de 1)

>> << (deplasări la dreapta, respectiv la stânga)

& (ŞI pe biţi)

^ (SAU-EXCLUSIV pe biţi)

| (SAU pe biţi)
Operatorul “~”, fiind unar, are aceeaşi prioritate ca şi ceilalţi operatori unari ai limbajului C. El schimbă fiecare bit 1 al operandului în 0 şi invers.

Operatorul “>>” realizează deplasarea la dreapta care este echivalentă cu o împărţire întreagă cu puteri a lui 2; a >> 3 este echivalentă cu [a/2³].

Operatorul “<<” realizează deplasarea la stânga care este echivalentă cu o înmulţire cu puteri a lui 2; a << 3 este echivalentă cu a*8.

Pentru operatorii &, |, ^ dăm în continuare tabelele operaţiilor:

& 0 1 | 0 1 ^ 0 1

0 0 0 0 0 1 0 0 1

1 0 1 1 1 1 1 1 0

Observaţii:

1^o. Operanzii care nu ocupă un cuvânt (16 biţi) se extind la un cuvânt. De exemplu expresia ~0 are ca rezultat un cuvânt cu toţi biţi egali cu 1.

2^o. Operatorii logici pe biţi se execută bit cu bit spre deosebire de operatorii logici care se evaluează global. De exemplu dacă x=2 şi y=1 sunt variabile de tipul int atunci:

x&&y are valoarea 1 pentru că ambii operanzi sunt diferiţi de 0.

x&y are valoarea 0 conform schemei de mai jos

x= 0000 0000 0000 0010

y= 0000 0000 0000 0001

x&y= 0000 0000 0000 0000

3^o. Operatorul & se foloseşte frecvent pentru a anula biţi din configuraţia unui cuvânt, iar operatorul | pentru a seta (pune) biţi într-un anumit mod.

4^o. Operanzii trebuie să fie întregi (de tipul int sau long).

5^o. Atenţie la deplasări nu se modifică valoarea operandului; deci trebuie să facem o atribuire; de exemplu a = a << 3 va modifica valoarea lui a pe când a << 3 nu modifică valoarea lui a.
Exemple:

1. 
   Fie declaraţia:
   

int i;

atunci expresia i >> 8 & 255 are ca rezultat valoarea celui mai semnificativ octet a lui i; i >> 8 deplasează octetul mai semnificativ al lui i în poziţia mai puţin semnificativă; se face apoi un ŞI logic pe biţi cu masca 255 care păstrează octetul mai puţin semnificativ.

2) Fie expresia: (x >> 6) & ~(~ 0 << 3)

Să presupunem că x are valoarea în biţi: 1010 1011 1000 1101.

Atunci x>>6 are valoarea: 1111 1110 1010 1110

Al doilea operand pregăteşte o mască astfel:

~0 1111 1111 1111 1111

~0<<3 1111 1111 1111 1000

~(~0<<3) 0000 0000 0000 0110
Rezultatul final este dat de:

0000 0000 0000 0111

1111 1110 1010 1110

0000 0000 0000 0110

Practic s-a obţinut valoarea biţilor 8,7,6 a lui x (numerotaţi de la dreapta începând cu 0).

3.3.6. Operatori de atribuire

În forma cea mai simplă operatorul de atribuire se notează cu “=” şi se utilizează în construcţii de forma:

v=expresie;
(v este fie o variabilă simplă, fie variabilă cu indici sau un element de structură).

Această construcţie se mai numeşte expresie de atribuire. Ea este considerată ca fiind un caz particular de expresie. Tipul ei coincide cu tipul lui v, iar valoarea întregii expresii este chiar valoarea atribuită lui v.

O expresie de forma:

v1=(v=expresie);

este şi ea legală şi se efectuează în felul următor :

1. 
   se evaluează expresia expresie şi valoarea ei se atribuie lui v;
   
2. 
   valoarea lui v se atribuie apoi şi lui v1.
   

Deoarece operatorii de atribuire se asociază de la dreapta la stânga, expresia de mai sus se poate scrie şi fără paranteze:

v1=v=expresie;

În general, putem realiza atribuiri multiple printr-o expresie de forma:
v_n =. . . =v₁=v=expresie
Dacă expresia din dreapta semnului egal are un tip diferit de cel al variabilei v, atunci întâi valoarea ei se converteşte spre tipul variabilei v şi pe urmă se realizează atribuirea.

Pentru operaţia de atribuire, în afara semnului egal se mai poate folosi şi succesiunea :

op=
unde prin op se înţelege unul din operatorii binari aritmetici sau logici pe biţi, adică unul din următorii:

% / * - + & ^ | << >>

Acest mod de construcţie se foloseşte pentru a compacta un anumit tip de atribuire. Astfel expresia:

v op = expresie;

este identică cu expresia de atribuire:
v = v op expresie;
Exemple:
int i, j;

double x, y;

int v[10];

i=5;

j=10;

x=y=10.01;

i +=1; // echivalenta cu i=i+1 si cu i++

x*=3; // echivalenta cu x=x*3

j<<=10; // echivalenta cu j=j<<10

v[i]*=i // echivalenta cu v[i]=v[i]*i

x /= x-y // echivalenta cu x = x/(x-y)

3.3.7. Operatori de incrementare şi decrementare

Aceşti operatori sunt unari şi au aceeaşi prioritate cu ceilalţi operatori unari ai limbajului C. Operatorul de incrementare se notează prin “++” şi măreşte valoarea operandului cu unu, iar operatorul de decrementare se notează prin “- -“ şi micşorează valoarea operandului cu unu. Operatorii sunt folosiţi prefixat şi postfixat. Astfel operatorii prefixaţi au notaţia:

++operand;

- - operand;

Ei se aplică mai întâi şi apoi se foloseşte valoarea operanzilor.

Astfel operatorii postfixaţi au notaţia:

operand++;

operand - -;

Se foloseşte valoarea operanzilor şi apoi se aplică incrementarea sau decrementarea.

Menţionăm că aceşti operatori se pot aplica numai la următorii operanzi:

1. 
   variabilă simplă;
   
2. 
   variabilă cu indici;
   
3. 
   referire la elementul unei structuri.
   

Exemple:

int i,j;

double x,y;

int vector [5];

j=i++; // este echivalent cu j=i si i=i+1;

y=--x; // este echivalent cu x=x-1 si y=x;

i=++vector[j] // este echivalent cu vector[j]=vector[j]+1 si i=vector[j]

3.3.8. Operatorul de conversie explicită (expresie cast)

Pentru forţarea tipului unui operand se foloseşte o construcţie de forma:

(tip) operand
Prin aceasta valoarea operandului se converteşte spre tipul indicat în paranteze.

Exemplu:

int i,j;

double y;

i=8; j=5;

y=i/j; // y are valoarea 1, pentru ca se face impartirea intreaga i/j

Dacă vom converti operanzii i şi j spre tipul double se va obţine rezultatul corect adică 1.6.

Deci:

int i,j;

double y;

i=8; j=5;

y=(double) i / (double) j; // y are valoarea 1.6,

Construcţia (tip) este un operator unar prin care se explicitează conversia dorită. Are aceeaşi prioritate ca restul operatorilor unari.

3.3.9. Operatorul dimensiune (sizeof)

Pentru a determina lungimea în octeţi a unei date se poate folosi construcţia:

sizeof (data)
unde data poate fi:

1. 
   numele unei variabile simple;
   
2. 
   numele unui tablou;
   
3. 
   numele unei structuri;
   
4. 
   numele unui tip;
   
5. 
   referirea la elementul unui tablou sau structură.
   

Exemple:

int i;

long l;

float f;

double d;

char c;

int itablou[5];

double dtablou[5];

sizeof (i) // are valoarea 2;

sizeof (l) // are valoarea 4;

sizeof (f) // are valoarea 4;

sizeof (d) // are valoarea 8;

sizeof (c) // are valoarea 1;

sizeof (itablou[1]) // are valoarea 2;

sizeof (dtablou[1]) // are valoarea 8;

sizeof (itablou) // are valoarea 10;

sizeof (dtablou) // are valoarea 40.

3.3.10. Regula conversiilor implicite

În general o expresie C conţine operanzi de tipuri diferite. Pentru operatorii binari există situaţii când operanzii nu sunt de acelaşi tip şi trebuie executate conversii astfel încât operatorii să se aplice pentru operanzi de acelaşi tip. Aceste conversii le face automat compilatorul. Există o regulă a conversiilor implicite care are următorii paşi:

1. 
   fiecare operand de tip char se converteşte spre tipul int şi fiecare operand de tipul float se converteşte spre double;
   
2. 
   dacă unul dintre operanzi este de tip double atunci şi celălalt se converteşte spre tipul double şi rezultatul va avea tipul double;
   
3. 
   dacă unul dintre operanzi este de tip long, atunci şi celălalt se converteşte spre tipul long şi rezultatul va avea tipul long;
   
4. 
   dacă unul dintre operanzi este de tip unsigned, atunci şi celălalt se converteşte spre tipul unsigned şi rezultatul va fi de tipul unsigned;
   
5. 
   la acest pas se ajunge numai dacă ambii operanzi sunt de tip int şi deci operaţia se execută cu operanzii respectivi, iar rezultatul va fi de tip int.
   

Aplicând regula de mai sus pas cu pas (la fiecare operator în momentul efectuării lui), se ajunge în final la evaluarea întregii expresii şi prin acesta se determină tipul expresiei. Regula conversiilor implicite nu se aplică pentru operatorul de atribuire (valoarea expresiei din partea dreaptă a semnului de atribuire se converteşte spre tipul variabilei din stânga semnului egal).
Exemple:

int i, j, k;

float a, b;

double x, y;

unsigned p;

long r;

char c;

expresii conversii tipul expresiei

i-j/k nu int

a/b a spre double; b spre double double

x+y nu double

i+a a spre double; i spre double double

i-3.14 i spre double double
expresii conversii tipul expresiei
i+3 nu int

i+x i spre double double

i-c c spre int int

x+10 10 spre double double

p-10 10 spre unsigned unsigned

r*5 5 spre long long

(double)(i/j) se realizează împărţirea întreagă între

i şi j şi rezultatul se converteşte spre double double

Dacă rezultatul unei operaţii depăşeşte domeniul de valori ce corespunde tipului rezultatului, valoarea respectivă se trunchiază şi rezultatul este eronat.

3.3.11. Operatori condiţionali

Operatorii condiţionali sunt ? şi : şi se folosesc împreună în construcţii de forma:

exp₁ ? exp₂ : exp₃

Evaluarea se face astfel:

1. 
   se evaluează expresia exp₁;
   
2. 
   dacă exp₁ este diferită de zero, atunci valoarea şi tipul expresiei condiţionale sunt egale cu valoarea şi tipul expresiei exp₂; altfel cu expresia exp₃.
   

Exemplu: procesul de determinare a maximului a două numere a şi b este:

dacă a>b atunci max=a

altfel max=b

sfdacă
În limbajul C se poate realiza acest proces cu ajutorul operatorilor condiţionali astfel:

max= a>b ? a : b

Dacă a>b atunci expresia condiţională are valoarea şi tipul lui a altfel expresia condiţională are valoarea şi tipul lui b.

3.3.12. Operatorul virgulă

Operatorul “,” este folosit pentru gruparea mai multor expresii într-una singură.

Cu ajutorul acestui operator (care are prioritatea cea mai mică) se construiesc expresii de forma:

exp₁, exp₂,. . ., exp_n

Această expresie are valoarea şi tipul ultimei expresii (deci a lui exp_n).
Exemplu: k= (i=10, j=j+5; i+j)
Se execută pe rând cele două atribuiri de la stânga la dreapta din parantezele rotunde apoi se face suma i+j şi în final se atribuie această sumă lui k.