Curs C++ | Sectiunea 10 – Algebra Booleana

Pana acum am lucrat folosind numai conditii simple. Daca ne dorim sa folosim mai multe conditii in acelasi timp avem nevoie de niste operatori speciali. C++ ne pune la dispozitie operatori pentru a construi conjunctii (si/and) si disjunctii (sau/or). Acestia se numesc operatori logici.

Conjunctie logica &&

💡 Operatorul pentru conjunctia logica este &&. Este un operator binar cu o prioritate mai mica decat a operatorilor de comparatie. Ne ofera posibilitatea sa folosim conditii complexe precum:

variable > 100 && c == 10

Rezultatul oferi de operator poate fi determinat pe baza tabelului de adevar (truth table). Conjunctia putand fi rescrisa si astfel:

left && right

Disjunctie logica ||

💡 Pentru disjunctie folosim operatorul ||. Este tot un operator binar cu o prioritate mai mica decat cea a operatorului de conjunctie &&. Tabelul de adevar este urmatorul:

❗ Mai exista un operator ce poate fi folosit pentru construirea conditiilor. Este un operator unar ce executa o negatie logica (logical negation). Am mai folosit acest operator si aici. Modifica valoarea din true in false si invers. Este scris folosind un singur caracter “!” iar prioritatea lui este foarte ridicata, aceeasi cu a operatorilor de incrementare si decrementare.

Ce ar mai fi de adaugat aici este o mica paranteza privind Legile lui De Morgan. Conform lor, negarea unei conjunctii este disjunctia unei negari si negarea unei disjunctii este conjunctia unei negari. Iar pe limba noastra, adica C++ 🙂 , ar arata astfel:

!(p && q) == !p || !q 
 
!(p || q) == !p && !q 

Operatori Bitwise

💡 Operatorii logici folositi pana acum privesc argumentele ca un intreg, indiferent de numarul de biti. Acestia iau in calcul valoarea 0 (cand toti bitii sunt resetati) adica false si diferit de 0/ not 0 (cand toti bitii sunt setati) adica true. Rezultatul operatiilor este una din valorile 0 sau 1.

Exista 4 operatori ce ne permit sa manipulam bitii individual. Acestia poarta numele de bitwise operators. Acopera toate operatiile mentionate anterior plus o operatie suplimentara si anume, xor (exclusive or).

❗ Argumentele acestor operatori trebuie sa fie intregi (long, short sau char), nu putem folosi valori de tip float.

Diferenta fundamentala intre operatorii logici si operatorii pe biti consta in faptul ca operatorii logici nu patrund la nivel de bit. Sunt interesati doar de valoarea intreaga finala. Operatorii bitwise lucreaza cu fiecare bit separat. Spre exemplu, daca luam o variabila de tip int ce este stocata pe 32 de biti, fiecare bit va fi evaluat individual. Totusi, acele 32 de operatii vor fi efectuate in acelasi timp.

Sa analizam urmatorul exemplu:

int i = 15, j = 22; 

Presupunand ca un int este stocat pe 32 de biti, reprezentarea binara a numerelor este urmatoarea:

i: 00000000000000000000000000001111 
j: 00000000000000000000000000010110

Acum sa aplicam urmatoarele operatii:

int log = i && j;
int bit = i & j; 

In cazul conjunctiei logice, ambele varabile, i si j sunt diferite de 0 astfel ca sunt interpretate ca true. Conform tabelului de adevar, rezultatul va fi tot true. Pe de alta parte, operatorul bitwise va opera pe fiecare bit in parte, astfel ca rezultatul va fi unul diferit. Reprezentarea binara a ambelor rezultate este urmatoarea:

log:00000000000000000000000000000001
bit:00000000000000000000000000000110

Shiftare

C++ ne mai pune la dispozitie alta operatie ce lucreaza pe biti individual si anume shiftarea. Folosim acest proces inconstient mereu fara sa realizam in viata de zi cu zi.

123 * 10 = 1230
1230 / 10 = 123

❗ Cand inmultim cu 10 practic facem o shiftare catre stanga si adaugam in locul ramas liber un 0. In procesul invers, prin impartirea la 10 facem o shiftare catre dreapta. Acelasi gen de operatii este realizat si de calculator doar ca se face in baza 2 si nu in baza 10.

Shiftarea poate fi:

• logica, daca toti bitii unei variabile sunt shiftati; are loc cand se aplica pe o variabila de tip int fara semn (unsigned integer)
• aritmetica, daca se omite bitul de semn (sign bit)

Operatorii de shiftare sunt reprezentati prin >> si <<, sugerand directia in care se face operatia. Argumentul din stanga reprezinta valoarea intreaga ce urmeaza a fi shiftata iar argumentul din dreapta reprezinta numarul de biti ce ii dorim shiftati.

Acum sa aruncam o privire pe urmatorul exemplu:

int signed = -8, var_s; 
unsigned unsigned = 6, var_u; 

/* echivalent cu impartire la 2 –> var_s == -4 */
var_s = signed >> 1;

/* echivalent cu inmultire cu 4 –> var_s == -32 */
var_s = signed << 2;

/* echivalent cu impartire la 4 –> var_u == 1 */
var_u = unsigned >> 2;

/* echivalent cu inmulire cu 2 –> var_u == 12 */
var_u = unsigned << 1;

Aici se termina si aceasta sectiune. Vom discuta mult mai in amanunt despre toate aceste operatii intr-un curs separat 🙂 .

Daca aveti intrebari suplimentare puteti folosi informatiile de aici pentru a da de mine.

➡ Sectiunea anterioara:Curs C++ | Sectiunea 9 – Loops

➡ Sectiunea urmatoare:Curs C++ | Sectiunea 11 – Switch