LABORATOR 4

Operatori şi instrucţiuni decizionale

Operatori aritmetici
Operatorii aritmetici folosiți în limbajul C sunt:
• + adunarea a doua numere;
• - scăderea a doua numere;
• * înmulțirea a doua numere;
• / împărțirea a doua numere (rezultatul împărțirii pentru numere reale, câtul împărțirii
pentru numere întregi);
• % modulo (restul împărțirii a doua numere întregi);
• ++ incrementarea (mărirea unei valori cu o unitate);
• -- decrementarea (micșorarea unei valori cu o unitate);

Exemplu pentru folosirea lui modulo:

#include <stdio.h>
int main (void)
{
int a = 54;
int mod;
mod = a % 10;
printf ("Restul impartirii lui %d la 10 este %d\n",a,mod);
return 0;
}

Operatorii de incrementare - decrementare sunt folosiți pentru mărirea respectiv

micșorarea unei valori cu o unitate.
Sunt de forma:
v++ - incrementare;
--v - decrementare;

Se pot folosi si instrucțiuni de pre/post incrementare/decrementare:

• post-incrementare: x = a++; - este echivalenta cu x = a; a = a + 1;
• pre-incrementare: x = ++a; - este echivalenta cu a = a + 1; x = a;
Pentru decrementare se procedează în mod analog.

Operatori relaționali si logici

Termenul „relațional” se refera la relațiile care se pot stabilii între diverse valori.
Termenul logic se refera la felul în care se pot lega relațiile existente. Întrucât operatorii
relaționali si logici sunt deseori folosiți împreuna, îi vom trata împreuna.

1
 Ideea de adevărat sau fals sta la baza conceptelor de operatori logici si relaționali. În C
adevărat înseamnă orice valoare deferita de 0, iar fals este 0. Expresiile care folosesc operatori
relaționali si logici returnează 0 pentru fals si 1 pentru adevărat.

Operatori la nivel de bit

Limbajul C pune la dispoziție șase operatori la nivel de bit, furnizând astfel facilitate
specific de obicei limbajelor de asamblare. Acești operatori permit scrierea unor programe care
lucrează îndeaproape cu sistemul hardware al calculatorului.
Operatorii la nivel de bit se aplica unor valori întregi asociate cu tipurile char, int, long,
cu / fără semn - iar rezultatele obținute sunt, de asemenea, întregi. Fata de ceilalți operatori ai
limbajului, aceștia operează asupra fiecărui bit din reprezentarea interna a operanzilor, tratându-l
independent de valorile celorlalți biți.
Operatorii la nivel de bit sunt următorii.
• & - AND (si logic);
• | - OR (sau logic);
• ^ - XOR (sau exclusiv);
• << - deplasare la stânga;
• >> - deplasare la dreapta;
• ~ - negare la nivel de bit (operator unar);

2
 Indiferent de scopul în care sunt utilizați operatorii, maniera în care sunt folosiți este în
general aceeași. În cele ce urmează, se vor descrie pe scurt principiile de baza ale utilizării lor.
Observație: Operatorii la nivel de bit nu modifica valoarea operanzilor (se comporta ca si
operatorii aritmetici obișnuiți), astfel o operație n << 2 va rezulta într-un nou număr, fără a
modifica valoarea variabilei n. Pentru a modifica valoarea variabilei n trebuie sa avem o
atribuire:

n = n << 2;

Operatorii de deplasare (<< si >>) realizează deplasarea biților din operandul stâng cu
atâtea poziții câte sunt indicate de operandul drept.
Deplasarea la stânga (<<) completează la dreapta cu 0 (biții din stânga se vor pierde),
iar la dreapta numărului se completează cu 0.

Exemplu:

int a=255; /* 0000 0000 1111 1111*/

a=a<<3; /* 0000 0111 1111 1000*/

În cazul deplasării la dreapta (>>), biții din dreapta se pierd, iar în stânga se introduc biți
de 0, în caz ca numărul era de tip fără semn (unsigned) sau biți egali cu bitul de semn (cel mai
din stânga bit) în cazul numerelor de tip cu semn.

Exemplu:
unsigned int a= 32768;/*1000 0000 0000 0000*/
a=a>>3; /*0001 0000 0000 0000*/

Operatorul de negare ~ realizează complementarea tuturor biților unui număr (biții de 0

se pun pe 1, iar cei de 1 se pun pe 0)

Exemplu:

int a = 5171; /* 0001 0100 0011 0011*/

a=~a; /*1110 1011 1100 1100*/

3
 Întrucât întregul a este cu semn, prin complementare bitul de semn a luat valoarea 1 si s-a
obținut un număr negativ.

Declararea constantelor
În limbajul C, constantele se pot declara în doua moduri:
• folosind cuvântul cheie const;
• folosind directiva #define;

Cuvântul cheie const

Declararea unei valori constante se poate face folosind cuvântul cheie const, astfel:

const int c = 14;

Prin aceasta declarare, variabila ’c’ ia valoarea 14 si NU i se mai poate modifica aceasta
valoare. O variabila declarata folosind const nu se poate folosi pentru precizarea lungimii unui
sir.

Directiva #define

Directiva define este o directiva preprocesor, utilizata pentru a face un program mai ușor
de realizat/parcurs.
Declararea unei directive preprocesor începe cu simbolul # si nu se terminata cu ';'. Ea
poate apărea oriunde într-un program, dar afectează numai liniile care urmează declarării ei. În
mod uzual, directivele preprocesor sunt scrise la începutul programului. În general, directivele
preprocesor sunt scrise cu majuscule.
Consideram următoarele exemple:

#define TRUE 1
#define FALSE 0
#define NULL 0
#define AND &
#define OR |
#define EQUALS ==
gata = TRUE;

Directivele preprocesor sunt prelucrate de către compilator înainte de compilarea

programului.
Secvența este următoarea: se procesează directivele, apoi simbolurile ce apar în cadrul
programului sunt înlocuite cu valoarea lor, iar ulterior programul este compilat.
Avantajele folosirii directivei #define
• lizibilitate mărită a programului - citirea si înțelegerea rapida a fișierului sursa;
• schimbările ulterioare ale unor valori constante se pot face foarte usor;

Exemplu: modificarea valorii lui LIMIT de la 100 la 10.000 – se face prin înlocuirea liniei:

4
#define LIMIT 100
cu linia:
#define LIMIT 10000

Daca nu s-ar fi folosit acest mod de definire a constantei LIMIT, atunci ar fi trebuit sa se
modifice peste tot in program 100 cu 10000.

Macroinstrucțiuni

Identificatorul definit prin #define poate fi substituit cu o instrucțiune.

Exemplu:

# define afiseaza(a) printf ("%.2f \n",a)

int main (void)
{
float b = 3.12;
afiseaza (b);
return 0;
}

În acest program preprocesorul va înlocui expresia

afiseaza (b)
cu
printf ("%.2f \n",n1);

De asemenea, #define poate fi folosita pentru a declara constante simbolice.

# define RAD2 1.41

float x;
...
x = RAD2 * 15;
...
Ulterior, în program, nu se pot atribui valori constantelor simbolice.

Instrucțiunile decizionale ale limbajului C

Instrucțiunea if
Instrucțiunea decizionala if permite executarea condiționată a unei secvențe de program
în funcție de valoarea unei expresii. Sintaxa acestei instrucțiuni este următoarea:

5
 if (expresie)
instructiune_1;
else
instructiune_2;

Dacă expresia are valoare adevărata, se executa instructiune_1. Altfel, se executa

instructiune_2. Ramura else este opționala si poate sa lipsească.
Limbajul C nu dispune de un tip de data specializat pentru valori logice (adevărat sau
fals). Orice expresie numerica diferita de zero se considera o valoare adevărata. Orice expresie
numerica egala cu zero se considera falsa.
Schema logica aferenta secvenței de mai sus arata în felul următor:

Daca se dorește introducerea mai multor instrucțiuni pe o ramura, acestea trebuie

încadrate între acolade:

if (expresie)
{
instructiune_1_1;
instructiune_1_2;
}
else
{
instructiune_2_1;
instructiune_2_2;
}

În construcția expresiilor logice, se pot folosi următorii operatori:

6
 Când se evaluează o expresie, operatorii se evaluează în ordinea crescătoare a precedentei
(primul operator evaluat este cel cu cea mai mica valoare pe coloana precedenta). Trebuie făcuta
distincție între operatorii logici && (SI), || (SAU) si operatorii pe biți & (SI la nivel de biți), |
(SAU la nivel de biți).
Secvența următoare de cod ilustrează acest lucru:

int a = 1; /* 01 in binar */
int b = 2; /* 10 in binar */
int x = a & b; /* SI la nivel de bit, x ia valoarea 0 */
int y = a && b; /* SI logic, y ia o valoare diferita de 0 */
/* expresia se interpretează in felul următor: y ia o valoare diferita de zero daca a este diferit de
zero SI b este diferit de zero. */

Exemplu: sa se scrie un program în C care sa rezolve o ecuație de gradul I, cu coeficienții citiți

de la tastatura:

#include <stdio.h>
int main (void)
{
float a, b, x;
printf ("Coeficientul lui x=");
scanf ("%f", &a);
printf ("Termenul liber=");
scanf ("%f", &b);
if (a == 0)
{
if (b != 0)
printf ("Nu are solutii \n");
else
printf ("X este orice numar real \n");
}
else
{
x = -b / a;
printf ("X = %f", x);

7
 }
return 0;
}

Exemplu: Sa se scrie un program C care sa verifice daca trei numere reale citite de la tastatura
pot reprezenta lungimile laturilor unui triunghi:

#include <stdio.h>
int main (void)
{
float a, b, c;
printf ("Introduceti cele 3 lungimi ale laturilor: \n");
scanf ("%f %f %f", &a, &b, &c);
if ((a < (b + c))&&(b < (a + c))&&(c < (a + b)) )
printf ("Cele trei segmente pot forma un triunghi ! \n");
else
printf ("Cele trei segmente nu pot forma triunghi ! \n");
return 0;
}

Operatorul conditional
Operatorul condițional ?: permite simplificarea scrierii unor expresii condiționale în care
se selectează una din doua valori, în funcție de o condiție logica. Sintaxa acestuia este
următoarea:

(conditie) ? val_1 : val_2

Aceasta expresie va returna valoarea val_1 în cazul în care condiție este o expresie
adevărata (diferita de zero) si val_2 în cazul în care condiție este o expresie falsa (egala cu zero).

Exemplu: Sa se determine maximul dintre 3 variabile:

int a = 2;
int b = 5;
int c = 3;
int m;
m = (a > b) ? a : b;
m = (m > c) ? m : c;
printf ("maximul este: %d", m);

Utilizând macrodefiniţiile, același exemplu se poate scrie într-o forma mai eleganta:

#define max(a, b) ((a > b) ? a : b)

int a = 2;

8
 int b = 5;
int c = 3;
int m;
m = max (a, b);
m = max (m, c);
printf ("maximul este: %d", m);

Instrucțiunea switch
Instrucțiunea switch permite selectarea unei alternative din mai multe posibilităţi în
funcție de valoarea unei variabile sau expresii de tip întreg. Sintaxa este următoarea:

switch (expresie)
{
case valoare_1: instructiune_11;
instructiune_12;
instructiune_13;
break;
case valoare_2: instructiune_21;
instructiune_22;
break;
case valoare_N: instructiune_N;
break;
default: instructiune_M;
break;
}

Selectorul expresie trebuie sa fie de tip întreg. Toate valorile din care se face selecția,
valoare_1 până la valoare_N trebuie sa fie întregi. Ele trebuie sa fie si distincte.
Daca expresie este egala cu valoare_1, execuția continua cu instructiunile care apar pe
aceasta ramura (instructiune_11, instructiune_12, instructiune_13) si continua pâna la întâlnirea
unei instrucțiuni break sau până când se încheie blocul switch.
Daca expresie este egala cu valoare_2, se executa instructiune_21, instructiune_22 etc.
Daca expresie nu este egala cu nici una dintre valorile valoare_1 până la valoare_N, se
executa instrucțiunile de sub eticheta default. Aceasta eticheta este opțională.

Exemplu: Programul următor afișează un calificativ în funcție de nota unui student citita de la
tastatura.

#include <stdio.h>
int main (void)
{
int nota;
printf ("Nota= ");
scanf ("%d", &nota);
switch (nota)
{

9
 case 1:
case 2:
case 3:
case 4:
printf ("Repetent \n");
break;

case 5:
case 6:
case 7:
printf ("Slab \n");
break;
case 8:
case 9:
printf ("Bine \n");
break;
case 10:
printf ("Foarte bine \n");
break;
default:
printf ("Valoarea introdusa nu este o nota corecta!");
break;
}
return 0;
}

Probleme propuse:
1. Sa se scrie un program în C care sa rezolve o ecuație de gradul 2 (ax2 + bx + c = 0), cu
coeficienții a, b, c reali introduși de la tastatura.

2. Să se scrie un program C care citeşte 2 numere de la tastatură şi verifică dacă sunt divizibile cu 3.
Dacă sunt divizibile se va face suma dintre ele, dacă nu produsul.

3. Sa se scrie un program care citește doua numere reale de la tastatura si apoi afișează un meniu
interactiv cu următoarele opțiuni:
1) Suma numerelor introduse
2) Diferența numerelor introduse
3) Produsul numerelor introduse
4) Raportul numerelor introduse
5) Exit
Optiunea dvs: _

10