Programarea Calculatoarelor - Curs 3

2 Conținut
 Valori constante
 Variabile
 Constante simbolice
 Expresii
 Tablouri
Programarea
 Instrucţiuni în limbajul C:
 simple
 instrucţiunea v idă
 instrucţiunea expresie
calculatoarelor – Curs 3
 instrucţiunea compusă
 structurate
 alternativă (if)
 selectivă (switch)
 repetitive
Limbajul C – Variabile. Expresii. Tablouri. Instrucțiuni 


while
for
 do while
 break
 continue
Ș.l.dr. Iulia Costin
UTCN - Programarea Calculatoarelor - Curs 3 ș.l.dr. Iulia Costin 16/10/2019
3 Valori constante 4 Valori constante
 Sunt valorile posibile ale datelor fiecărui tip (așa cum se scriu în codul sursă)  Constante reale
 Constante întregi – pot fi scrise în baza 10, 8 sau 16:
 zecimale: şir de cifre, precedate (opţional) de semn, urmate (opţional) de una sau mai  au parte întreagă, parte fracţionară şi exponent, toate opţionale (nu pot lipsi
multe litere: toate)
 l, L – long
 ll, LL – long long ex. 123. 12.7 .25 -7e3 (=-7·103)
 u, U – unsigned
 ul, UL, lu, LU – unsigned long 23e-4 (=23·10-4) .1e2 (= 0.1·102)
 ull, ULL – unsigned long long
 ex. 123 – de tip int  implicit sunt de tip double
1234567890 – de tip long
-123L – de tip long  pentru a defini constante de tip float, se adaugă la sfârşit f sau F
2345u – de tip unsigned int
 octale: prima este cifra 0, restul – cifre octale  pentru a defini constante de tip long double, se adaugă la sfârşit l sau L
 pot fi doar fără semn
 ex. 0127, 0127L
 hexazecimale: încep cu 0x sau 0X, restul – cifre hexazecimale (literele – mici sau mari)
 pot fi doar fără semn
 ex. 0x1ab2, 0X23EFL
UTCN - Programarea Calculatoarelor - Curs 3 ș.l.dr. Iulia Costin 16/10/2019 UTCN - Programarea Calculatoarelor - Curs 3 ș.l.dr. Iulia Costin 16/10/2019
5 Valori constante 6 Variabile
 Constante caracter  Variabilă = o zonă de memorie care are asociat:

 un nume, prin care ne putem referi la acea zonă
 au ca valoare codul lor ASCII şi sunt de tip int  un tip, care spune ce fel de date putem memora în zona respectivă (întreg, real, caracter etc.)
 pentru caracterele grafice (litere, cifre, semne de punctuaţie, alte simboluri prezente  o valoare, care e conţinutul zonei de memorie (ex. 3, 7.5, ‘A’ etc.)
pe tastatură), constanta caracter corespunzătoare este caracterul respectiv inclus  Variabilele sunt utile pentru a memora date pe parcursul execuției programului
între apostroafe  Într-o variabilă putem memora o valoare (iniţializare), putem să-i schimbăm valoarea pe parcursul
execuţiei (atribuire) și putem să o accesăm când e nevoie de valoarea ei
 ex.’a’, ‘Z’, ‘9’, ‘=‘, ‘ ‘
 În C, o variabilă trebuie declarată înainte de a o putea utiliza
 excepţii: pt. caracterele apostrof ('\'') şi backslash ('\\')
 Declararea variabilelor simple:
 pentru alte caractere, se folosesc secvenţe escape: tip lista_variabile;
'\a' BEL (sunet) '\xcc' caracterul cu codul respectiv unde tip – este unul dintre tipurile standard sau definite de program lista_variabile – o enumerare de nume
de variabile separate prin “,”
'\b' BS (backspace) (c-cifre hexa) (ex. \x6a)
 ex. int i, j, k;
'\f' FF (formfeed) '\ooo' caracterul cu codul respectiv  La declarare se poate face şi iniţializare
'\n' LF (linefeed) (o-cifre octale) (ex. \377 - tip nume = expresie
 În expresie trebuie să apară doar variabile deja inițializate!!
'\r' CR (carriage return) caracterul cu codul ASCII 255)
 în standardul C90, expresia trebuie să poată fi evaluată la compilare
'\t' TAB (tab orizontal) '\"' " (ghilimele)  ex. int v = 31*12;
'\v' VT (tab vertical)  Numele variabilelor - identificator
7 Variabile 8 Constante simbolice
 Un avantaj al utilizării variabilelor e că, dacă valoarea lor provine din calcule,  Similar cu variabilele, au un nume, un tip şi o valoare (aceleaşi reguli pentru nume şi tip)
nu trebuie să refacem acele calcule de fiecare dată când e nevoie de acea  valoarea se iniţializează la declarare şi nu se poate modifica ulterior
valoare, ci doar să folosim valoarea accesând variabila  Declarare:
 Un alt avantaj – programul devine mai ușor de înțeles dacă alegem nume  const tip nume = expresie;
suficient de sugestive pentru variabile (ne dăm seama ușor ce reprezintă  ex. const int MAX = 100;
valoarea respectivă)  Se poate defini o ”valoare constantă” şi în alt fel → directivă preprocesor:
 ex. int timp = 2;  #define nume expresie
float distanta = 30.5, viteza;  nu e acelaşi lucru ca mai sus (nu sunt constante simbolice)
 efect: preprocesorul va înlocui în întregul cod sursă din fişier numele respectiv cu acea expresie
viteza = distanta/timp; (compilatorul nu va mai găsi acel nume în codul sursă!!)
 Dacă o variabilă primește ca valoare o expresie în care apar alte variabile,  ex. #define MAX 100
variabila primește valoarea expresiei calculată în acel moment.  Avantaje ale utilizării constantelor:
 dacă ulterior acele variabile își schimbă valoarea, nu se schimbă și valoarea variabilei  pot avea valori mai complicate → nu trebuie scrise acele valori la fiecare apariţie a constantei (ex.
valoarea lui π)
 ex.: mai sus, dacă ulterior modificăm distanta = 100.3, nu se modifică valoarea variabilei
viteza  dacă la testarea aplicaţiei e necesară modificarea valorii → modificarea trebuie realizată într-un singur loc
în codul sursă
 dacă vrem să se modifice, trebuie s-o recalculăm!  creşte lizibilitatea programului → numele constantei ar trebui să sugereze semnificaţia acelei valori
9 Expresii 10 Operatori
 O expresie reprezintă unul sau mai mulţi operanzi, legaţi prin operatori.  Operatori:
 O expresie are valoare de un anumit tip.  unari - se aplică asupra unui singur operand
 Operanzi pot fi:  binari - doi operanzi

 ternari - trei operanzi
 o constantă (numerică sau caracter)
 Categorii de operatori:
 nume de variabilă simplă
 aritmetici
 nume de tablou
 relaţionali, de egalitate
 element de tablou
 logici
 nume de funcţie
 de atribuire
 apel de funcţie  pe biţi
 o expresie inclusă între paranteze  de incrementare/decrementare
 un câmp al unei structuri  condiţional
 etc.  etc.
11 Operatori aritmetici 12 Operatori relaționali și de egalitate
 Aditivi:  Operatori relaţionali: <, <=, >, >=

 +, - (unari)  expr1 operator_relaţional expr2 are valoarea:
 +, - (binari)  1, dacă valorile expresiilor expr1 şi expr2 satisfac relaţia respectivă
 0, în caz contrar.
 Multiplicativi:
 ex. a<b este 1 dacă a are valoarea mai mică decât a lui b și 0 în caz contrar.
 * înmulţire
 Operatori de test pentru egalitate: == (egal), != (diferit)
 / împărţire (întreagă sau reală)
 expr1 operator_de_egalitate expr2 are valoarea:
 dacă ambii operanzi sunt întregi, rezultatul este câtul împărţirii întregi
 1, dacă valorile expresiilor expr1 şi expr2 satisfac relaţia
 ex. 2/5 are valoarea 0; 7/2 are valoarea 3
 dacă cel puţin unul dintre operanzi este real, se efectuează împărţire reală
 ex. a == b+c x % 10 != 0
 ex. 2./5 are valoarea 0.4
 Nu se recomandă aplicarea directă a operatorilor de egalitate pentru valori reale! (din
 % restul împărţirii întregi (împărţire modulo) – numai pentru operanzi de tip întreg cauza erorilor posibile ale preciziei de reprezentare, dacă valorile provin din calcule)
 ex. x%10 - va obține ultima cifră a numărului întreg memorat în x  Observație: între cele 2 simboluri care formează un operator nu se pune spațiu!!
13 Operatori logici 14 Operatori pe biți
 ! (not), && (and), || (or)  Operatori pe biţi: ~ (not, complement faţă de 1), & (and pe biţi), | (or pe biţi), ^ (sau
 !expr are valoarea: exclusiv pe biţi), << (deplasare la stânga), >> (deplasare la dreapta)
 0, dacă valoarea expresiei expr este nenulă (”adevărată”)  se aplică la operanzi de tip întreg
 expr1 && expr2 are valoarea:
 ~expr are ca valoare ceea ce rezultă prin schimbarea biţilor 0 ai valorii expresiei în 1 şi 1 în 0.
 1, dacă ambele expresii au valoare nenulă (”adevărată”)  expr1 & expr2, expr1 | expr2, expr1 ^ expr2 au ca valoare valoarea rezultată din
 0, în caz contrar. efectuarea operaţiei respective între cei doi operanzi, bit cu bit:
 expr1 || expr2 are valoarea:
 0, dacă ambele expresii au valoare 0 (”falsă”)
 Operatorii logici binari se evaluează în “scurt-circuit”: dacă la evaluarea unei expresii se ajunge
într-un punct în care se cunoaşte valoarea întregii expresii, atunci ce a rămas din acea expresie
nu se mai evaluează.
 ex. pentru expresia: a != 0 || b+c != 0  expr1 << expr2 are ca valoare, valoarea expr1 deplasată la stânga cu un nr. de poziţii
 dacă a are o valoare nenulă, atunci expresia este adevărată (va avea valoarea 1); nu se mai evaluează b+c binare egal cu valoarea lui expr2 (<=> expr1 * 2expr2)
 dacă a este 0, se evaluează b+c. Dacă b+c este nenul, expresia e adevărată (are valoarea 1), altfel, expresia e
falsă (are valoarea 0)  expr1 >> expr2 are ca valoare, valoarea expr1 deplasată la dreapta cu un nr. de poziţii
binare egal cu valoarea lui expr2 (<=> expr1 / 2expr2)
15 Operatori pe biți 16 Operatori de atribuire
1101011001 & 1101011001 | 1101011001 ^

 Exemple  Operatori de atribuire: = op=
1001011100 1001011100 1001011100  var = expresie
 calculează valoarea expresiei expresie şi o memorează în zona de memorie alocată lui var (var poate
1001011000 1101011101 0100000101 fi variabilă, element de tablou, câmp al unei structuri, pointer).
 var trebuie să reprezinte o locație de memorie!!
 se numeşte expresie de atribuire și are ca valoare, valoarea care se atribuie, iar ca tip, tipul lui var.
 dacă tipul expresiei e diferit de tipul lui var, înainte de atribuire se face conversia valorii expresiei la
~ 00000000 00000000 00000011 01011001 tipul lui var.
 se asociază de la dreapta spre stânga: se poate scrie o expresie de atribuire de forma
11111111 11111111 11111100 10100110
vn =...= v2 = v1 = expresie
care este echivalentă cu: vn = (...= (v2 = (v1 = expresie))...)
 op =, unde op este un operator binar aritmetic sau logic pe biţi (+ - * / % & | ^ << >>)
00000000 00000000 00000011 01011001 << 3
 expresia: var op= expresie este echivalentă cu expresia:
00000000 00000000 00011010 11001000 var = var op (expresie)
 ex. a += b ⇔ a = a + b
a *= b + c ⇔ a = a * (b + c)
a <<= b ⇔ a = a << b
00000000 00000000 00000011 01011001 >> 3
00000000 00000000 00000000 01101011
17 Alți operatori 18 Alți operatori
 Operatori de incrementare/decrementare: ++, -- (sunt operatori unari)  Operatorul de conversie explicită (forţare de tip):
 formă prefixată (++var, --var) (nume_tip) operand (operator unar)
 formă postfixată (var++, var--)
 este o expresie de tipul nume_tip care are ca valoare, valoarea operandului
 var – poate fi doar ceea ce poate fi și la atribuire convertită la tipul respectiv
 Nu se pun spații între cele două semne + sau - !!
 nu schimbă valoarea şi tipul operandului!!!
 efect: mărește (++)/micşorează (--) valoarea variabilei cu 1.
 ex. dacă a şi b sunt de tip întreg, a/b realizează împărţire întreagă. Pentru a se realiza
 dacă apar ca parte a unei alte expresii, comportamentul celor 2 forme este diferit:
împărţire reală, unul dintre operanzi trebuie convertit la un tip real: a/(float) b
 pentru forma postfixată, mai întâi se utilizează valoarea lui var pentru calculul valorii expresiei,
apoi se măreşte/micşorează valoarea lui var.  Operatorul dimensiune:
 ex. a = b + i++ <=> a = b + i
 sizeof(nume_tip) are ca valoare nr. de octeţi necesari pentru alocarea unei date de
i=i+1
tipul respectiv
 pentru forma prefixată, mai întâi se măreşte/micşorează valoarea lui var, apoi se utilizează
valoarea lui var pentru calculul valorii expresiei.  sizeof(var) - nr. de octeţi alocaţi pentru acea variabilă (simplă, tablou, structură etc.)
 ex. a = b + ++i <=> i = i + 1
 ex. int tablou[10] => sizeof(tablou) = 10*sizeof(int)
a=b+i
19 Alți operatori 20 Alți operatori
 Operatorul condiţional: ?: (operator ternar)  Operatorul adresă:

 expresia condiţională: &nume (operator unar)
expr1 ? expr2 : expr3
 nume - numele unei variabile simple, element de tablou, a unei variabile de tip
 permite construirea unei expresii a cărei valoare depinde de valoarea unei condiţii structură etc.
 Valoarea expresiei: dacă expr1 este nenulă (deci adevărată), atunci valoarea şi tipul
expresiei condiţionale este cea a lui expr2; altfel este cea a lui expr3
 este o expresie care are ca valoare adresa de început a zonei de memorie
alocată variabilei respective
 Ex. c = a>b?a:b; - c va lua ca valoare maximul dintre a şi b.
 Operatorul virgulă: exp1, exp2, ... , expn  Operatorii paranteză: () []
 construieşte o expresie formată dintr-o succesiune de expresii  ( ) - pentru construirea expresiilor
 se evaluează pe rând expresiile de la stânga spre dreapta; valoarea şi tipul expresiei  [ ] - includ expresii care reprezintă indici (pentru accesarea unui element de
coincide cu a ultimei expresii (expn) tablou)
 ex. s += a, p *= a, i++  ex. a[2*i+1]
i++, s+=a[i]
21 Operatori – prioritate 22 Evaluarea expresiilor
 Tabela de priorităţi a operatorilor, în ordine descrescătoare (operatorii de  La evaluarea expresiilor se ia în considerare:

pe acelaşi rând au aceeaşi prioritate)  prioritatea operatorilor
 asociativitatea operatorilor de aceeaşi prioritate: se face de la stânga spre
dreapta, cu excepţia operatorilor unari, condiţional şi de atribuire, care se
asociază de la dreapta spre stânga
 regula conversiilor implicite: când un operator se aplică la doi operanzi de tipuri
diferite, operandul de tip “inferior” (cu domeniu de valori mai restrâns) este
convertit la tipul “superior” (cu domeniu de valori mai larg) al celuilalt operand şi
rezultatul are tipul “superior”
 ordinea descrescătoare a priorităţii tipurilor: long double → double → float → unsigned
long → long → int
 conversie generală: înainte de evaluarea unei expresii, operanzii de tip char şi
enum (care va fi prezentat ulterior) sunt convertiţi la tipul int
23 Tablouri 24 Tablouri
 Adesea e util într-un program să considerăm grupări de date  Pentru a utiliza o variabilă de tip tablou, aceasta trebuie declarată:
 necesitatea memorării unui număr mare de valori (întregi, reale etc) și efectuarea unei
aceleiaşi operaţii asupra lor
[
tip nume [nr1] [nr2]... ]
 tip, nume - sunt aceleaşi ca pentru variabile simple
 Tablou – este un tip de dată care grupează date de acelaşi tip (elementele tabloului)  nr1, nr2, ... – valori întregi, reprezintă nr. de elemente pe dimensiunea 1, 2, ...
memorate într-o zonă contiguă (locaţii succesive) de memorie, identificată printr-un nume  pot fi expresii, dar trebuie să poată fi evaluate la compilare (C90)
(numele tabloului)  C99 permite și expresii cu variabile, dar acestea trebuie să fi fost inițializate anterior!!
 Tipul tabloului este tipul elementelor sale  se va aloca în memorie un spaţiu contiguu de dimensiune (sizeof(tip)· nr1· nr2·…) octeţi
 pentru dimensiunea i, indicii variază între 0 şi nri-1!!
 Referirea la elementele sale se face prin numele tabloului şi indici
 Ex. int alfa[100]; - elementele sunt alfa[0], ..., alfa[99]
 Un tablou poate fi: double mat[2][3]; → mat[0][0] mat[0][1] mat[0][2]
 unidimensional (vector) - un singur indice mat[1][0] mat[1][1] mat[1][2]
 bidimensional (matrice) - 2 indici  Un tablou multidimensional este de fapt un tablou de tablouri de aceeaşi dimensiune
 ex. int a[5][7] – este un tablou de 5 elemente, fiecare element fiind un vector de 7 întregi; a[3][2] reprezintă
 n-dimensional - n indici un element (un întreg), a[3] reprezintă o linie (linia a patra), adică un vector de 7 elemente întregi
 Un element al unui tablou poate fi utilizat oriunde se poate utiliza o variabilă simplă  Programul trebuie să verifice indicii → să nu iasă din limitele alocate!!
 Exemplu: citirea a n valori întregi şi calcularea sumei lor  Exemplu: simularea aruncării a 2 zaruri: generarea, de un număr de ori, a câte 2 nr. între 1 şi 6 şi
#include <stdio.h> afişarea frecvenţei cu care apare fiecare sumă posibilă
// Citeste elementele
#define NR 50  utilizăm un şir a, în care memorăm frecvenţele
printf("Elementele: \n");  a[i] – frecvenţa de apariţie a sumei i, i=2, …, 12
int main() { for(i = 0; i < n; i++) {
int n, i, a[NR]; printf("a[%d]=", i);
#include <stdio.h> // Simularea celor n aruncari
long suma = 0; scanf("%d", &a[i]);
int main() { for (i = 0; i < n; i++) {
}
/* Tabloul de frecvente (a[0] zar1 = rand()%6 + 1;
// Citeste nr. de elemente
// Calculul sumei: si a[1] nu sunt utilizate) */ zar2 = rand()%6 + 1;
printf("Dati numarul de elemente (maxim %d): ",
NR); unsigned int a[13] = {0}; a[zar1+zar2]++;
for(i = 0; i < n; i++)
scanf("%d", &n); }
suma += a[i]; // forteaza initializarea cu 0
if (n < 1 || n > NR) { // Afisarea frecventelor
int i, n, zar1, zar2; for (i = 2; i <= 12; i++)
printf("Nr. elem. invalid!"); // Afisarea sumei:
return 0; printf("Suma celor %d elem. este %ld", n, suma); printf("De cate ori aruncati zarurile? "); printf("Suma %d: de %d ori\n",
} i, a[i]);
return 0; scanf("%d", &n);
return 0;
}
}
 Memoria este liniară  pe coloane - indicele corespunzător primei dimensiuni variază cel mai repede
=> pentru tablourile multidimensionale trebuie să se stabilească maparea în a00 a01 … a0,n-1
memorie (= ordinea în care sunt memorate elementele)
a10 a11 … a1,n-1
 Maparea se poate face
… … … …
 pe linii – indicele corespunzător ultimei dimensiuni variază cel mai repede
am-1,0 am-1,1 … am-1,n-1
a00 a01 … a0,n-1
 a00 a10 … am-1,0 a01 a11 … am-1,1 …… a0,n-1 a1,n-1 … am-1,n-1
a10 a11 … a1,n-1
 În C - sunt memorate pe linii
… … … …
am-1,0 am-1,1 … am-1,n-1
a00 a01 … a0,n-1 a10 a11 … a1,n-1 …… am-1,0 am-1,1 … am-1,n-1
29 Tablouri – inițializare 30 Tablouri – inițializare
 Iniţializarea elementelor unui tablou poate fi făcută la declarare  Se poate face iniţializare la declarare şi pentru tablouri multidimensionale
ex. int c[2][3]={{0,1,2},{3,4,5}} - iniţializare pe linii
 Expresiile de iniţializare trebuie să poată fi evaluate la compilare (C90)
 nici aici nu e obligatorie iniţializarea tuturor elementelor
ex. int a[10] = {0, 3, 5, -1, 4, 4, 1, 2, 10, 7};
ex. int d[3][3]={{1}} int d[3][3]={{},{1}} int d[3][3]={{1},{2,3},{0,4,5}}
ex. int a[10]={0,3+MAX,2} (unde MAX a fost definit cu #define) 1 0 0 0 0 0 1 0 0
 nu e obligatorie iniţializarea tuturor elementelor 0 0 0 1 0 0 2 3 0
 elementele neiniţializate vor fi iniţializate implicit la 0 0 0 0 0 0 0 0 4 5
 numărul de expresii de iniţializare nu poate fi mai mare decât numărul de  Dacă se realizează iniţializare la definirea tabloului multidimensional → se poate
elemente omite specificarea numărului de elemente pentru prima dimensiune
 Dacă se inițializează toate elementele la declarare, se poate omite  ex. int a[][2]={{1,2},{3,4},{5,6}} 1 2
specificarea numărului de elemente (pentru tablouri unidimensionale) 3 4
ex. double b[]={1., 3., .5, 78.3} 5 6
 numărul de elemente va fi acelaşi cu numărul de expresii de iniţializare  ex. int a[][2]={{},{3},{5,6}} 0 0
3 0
5 6
31 Tablou de caractere 32 Tablou de caractere
 Tablou de caractere = tablou unidimensional cu elemente de tip caracter

 Șir de caractere = tablou de caractere cu reprezentare specială
 Iniţializarea unui șir de caractere – ca la tablouri, sau cu o constantă şir de
 Constantă şir de caractere: "text intre ghilimele" caractere
 reprezentare în memorie: după ultimul caracter este caracterul nul (‘\0’ – cod ASCII 0)
 ex. “sir de caractere”  ex. char c[] = “sir”; ⇔ char c[] = {‘s’,’i’,’r’,’\0’};
's' 'i' 'r' ' ' 'd' 'e' ' ' 'c' 'a' 'r' 'a' 'c' 't' 'e' 'r' 'e' '\0'  !!! Ca în cazul tablourilor oarecare, dacă nu i se specifică numărul de elemente, va
avea doar atâtea elemente!
 La declararea unei variabile pentru memorarea unui şir de caractere – trebuie ţinut cont de modul de memorare a şirului
(necesită un caracter suplimentar!)
 ex. char sir[10] = “123456789”;
 Observaţie: ‘a’ ≠ “a”, deoarece “a” → ‘a’ ‘\0’
 Se poate trece la linie nouă (în codul sursă) în interiorul unui şir de caractere (deci să se scrie șirul de caractere pe mai multe
linii), astfel:  Atenţie! Dacă programul construieşte algoritmic şirul de caractere
 cu caracter de continuare (\):
(caracter cu caracter), trebuie să pună după ultimul caracter ‘\0’!
ex. "Acesta e un text \
pe mai multe \
 Șir de caractere vid: "" – ghilimele între care nu este niciun caracter.
linii" → spaţiile fac parte din şir! Deci reprezintă șirul de caractere "Acesta e un text pe mai multe linii"
 închizând ghilimele pe un rând și deschizându-le pe rândul următor:  Reprezentarea lui va conține doar caracterul '\0' (pe prima poziție)
ex. "Acesta e un alt text "
"pe mai multe "
"linii" - reprezintă șirul de caractere "Acesta e un alt text pe mai multe linii"
33 Tablouri 34 Instrucțiuni
 Exemplu: transformarea literelor mici în litere mari într-un text introdus de utilizator
 Instrucțiune = cea mai mică unitate din limbajul de programare, prin care se
#include <stdio.h>
exprimă o acțiune de executat
#include <string.h> // pentru functia strlen
int main() {  Prelucrarea datelor într-un program se realizează cu ajutorul instrucţiunilor

char text[100];
int i;  Ordinea în care se execută instrucţiunile defineşte structura de control a
puts("Textul de transformat:"); programului (sau fluxul de control)
fgets(text,100,stdin);
// Textul are strlen(text) caractere:  Structuri de control:
for (i = 0; i < strlen(text); i++)
 secvenţială - succesiune de instrucţiuni care se execută în ordine
if (text[i] >= 'a' && text[i] <= 'z') // litera mica
text[i] -= 'a'-'A'; // transforma in litera mare  alternativă sau selectivă - determină alegerea următoarei instrucţiuni de executat în
puts("Dupa transformare:"); funcţie de satisfacerea unei condiţii
puts(text);
return 0;  repetitivă - determină repetarea execuţiei unei instrucţiuni de un număr (finit) de ori
}
 Program structurat = program realizat numai cu ajutorul acestor 3 structuri
35 Instrucțiuni 36 Instrucţiunea expresie
 În limbajul C există două grupe de instrucţiuni:

 E formată dintr-o expresie urmată de caracterul ;
 simple: instrucţiunea vidă, instrucţiunea expresie, instrucţiunea compusă, continue, break, return
 structurate: if, switch, while, for, do-while  are ca efect evaluarea expresiei
 Instrucţiunea vidă  Dacă expresia este de atribuire, se spune că instrucţiunea este de atribuire
 e formată doar din caracterul ;  ex. s += a[i];
 nu are niciun efect
 se utilizează acolo unde sintaxa necesită o instrucţiune, dar nu trebuie să se execute nici o acţiune (de  Dacă expresia are un singur operand ce reprezintă un apel de funcţie, se
obicei, în structuri alternative sau repetitive)
 ex. for (i=0; i<n && a[i]<0; i++); spune că este o instrucţiune de apel a funcţiei respective
 găseşte primul element nenegativ dintr-un şir
 ex. printf(“Hello\n”);
 Atenție! Poate produce erori de logică atunci când e utilizată fără să se cunoască bine efectul!
 ex. for (suma = 0, i = 0; i < n; i++)
suma += a[i];
 i va crește până va ajunge egal cu n, după care se va încheia for-ul. Abia apoi se va face suma += a[i], dar i este deja în afara
indicilor tabloului (se va efectua suma += a[n]), ceea ce e greșit
37 Instrucțiunea compusă (bloc) 38 Instrucţiunea if (structura alternativă)
 O succesiune de instrucţiuni, precedată eventual de declaraţii de variabile (locale),  Are 2 forme:

incluse între acolade:
 if (expr) Parantezele din jurul
{
instrucţiune1 expresiei sunt obligatorii!
declaraţii (fac parte din sintaxa
 if (expr)
instrucţiuni instrucțiunii if)
instrucţiune1
}
else
 Dacă există declaraţii de variabile, acestea vor rămâne definite doar atâta timp cât se
execută instrucţiunile din blocul respectiv (durata de viață și domeniul de vizibilitate – pe instrucţiune2
parcursul execuției instrucțiunilor blocului)  Execuţia instrucţiunii if:
 Se utilizează acolo unde sintaxa limbajului necesită o singură instrucţiune, dar procesul de  se evaluează expr
calcul se poate exprima doar prin mai multe instrucţiuni  dacă este nenulă, se execută instrucţiune1.
ex. {  dacă este nulă: în prima formă, nu se execută nimic; în a doua formă, se execută
int aux; inversarea valorilor a instrucţiune2.
două variabile
aux = a; a = b; b = aux;  În ambele forme, după execuţia instrucţiunii if se trece la instrucţiunea următoare.
}  excepţie: când instrucţiunile din if definesc un alt mod de continuare a execuţiei
39 Instrucţiunea if 40 Instrucţiunea if
 Ex. memorează în c valoarea maximă dintre a și b:  Ex. Calcularea rădăcinilor ecuaţiei ax2+bx+c=0
if (a>b) are același efect cu: şi cu:
#include <stdio.h> else {
c = a; c = b; c = a>b? a: b;
if (a>b) #include <math.h> x1 = -b / (2*a);
else c = a;
c = b; int main(){ x2 = sqrt(-delta) / (2*a);
 Dacă instrucţiune1 sau instrucţiune2 este tot o instrucţiune if → se numesc if-uri imbricate float a, b, c, delta, x1, x2; printf("\nEcuatia are "
 ramura else (dacă există) ţine de instrucţiunea if imediat anterioară printf("\nDati coeficientii a, b, c\n");
"radacinile complexe x1=%g-i*%g "
 se poate modifica acest comportament dacă se include într-un bloc (utilizarea acoladelor) "si x2=%g+i*%g\n", x1, x2, x1, x2);
scanf("%f%f%f", &a, &b, &c);
 ex. Aflarea maximului a 3 întregi folosind if-uri imbricate: }
if (a != 0) {
if (a>b) }
if (a>c) delta = b*b - 4*a*c;
else
printf(“maximul este %d”, a); // a>b && a>c if (delta >= 0) {
printf("\nEcuatia nu e de grad "
else x1 = (-b – sqrt(delta)) / (2*a); "doi\n");
printf(maximul este %d”, c); // c>=a && a>b x2 = (-b + sqrt(delta)) / (2*a); return 0;
else if (b>c) printf("\nEcuatia are radacinile reale x1 = %g " }
printf(maximul este %d”, b); // b>=a && b>c
"si x2 = %g\n", x1, x2);
else
}
printf(maximul este %d”, c); // c>=b && b>=a
41 Instrucţiunea switch 42 Instrucţiunea switch
 Structura selectivă:  Execuţia:

 evaluează expr. Compară valoarea ei pe rând cu c1, …, cn.
switch(expr) { Parantezele din jurul  Dacă valoarea expresiei este ci , se execută în continuare siri , la break iese din switch
expresiei sunt obligatorii! și continuă execuția
case c1: sir1; break; (fac parte din sintaxa
instrucțiunii switch)  Dacă valoarea nu este egală cu nici una dintre c1, …, cn, atunci se execută sir. Dacă
case c2: sir2; break; clauza default lipseşte, atunci nu se execută nimic.
...  Este echivalentă cu o succesiune de if-uri imbricate
 Ex. switch (c) { if (c == 'a')
case cn: sirn; break; case 'a': printf(mesaj1);
default: sir; printf(mesaj1); break; else if (c == 'b')
unde: case 'b':
} expr - expresie de tip întreg printf(mesaj2);
c1, ..., cn - constante întregi printf(mesaj2); break; else
sir1, ..., sirn, sir - succesiuni de instrucţiuni default: printf("Gata\n"); printf("Gata\n");
}
Clauza default poate lipsi.
43 Instrucţiunea switch 44 Instrucţiunea while
 Dacă lipseşte break după siri , succesiunea siri continuă cu instrucțiunile din următorul case  Structură repetitivă cu test iniţial Parantezele din jurul
etc. (sau cu sir, dacă expresia este egală cu cn), până se întâlneşte primul break sau expresiei sunt obligatorii!
până la sfârșit (dacă nu mai apare break) while (expr) (fac parte din sintaxa
instrucţiune corpul lui while instrucțiunii while)
 Ex. switch (c) { if (c == 'a') {
case 'a': printf(mesaj1);  Execuţia:
printf(mesaj1); printf(mesaj2);  se evaluează expr
case 'b': }  dacă este nenulă (“adevărată”), se execută instrucţiune și se reia evaluarea expresiei.
printf(mesaj2); else if (c == 'b') {  dacă este nulă (“falsă”), se încheie execuţia lui while
break; printf(mesaj2);  !! dacă la prima evaluare a expresiei aceasta este 0, atunci instrucţiune nu se execută
niciodată
default: }
 În corpul lui while trebuie să se realizeze una din următoarele acțiuni:
printf("Gata\n"); else
 să se modifice valoarea unor variabile care intervin în expresie astfel încât la un moment dat
} printf("Gata\n"); expresia să devină 0 (falsă), sau
 De obicei lipsa lui break e eroare de logică. Totuși, uneori se dorește execuția în acest fel  să se apeleze o instrucţiune care să aibă ca efect terminarea ciclării
 de exemplu, dacă vrem să verificăm dacă c este o literă mare sau aceeași literă, dar mică  în caz contrar, se obţine o buclă infinită
etc.
45 Instrucţiunea while 46 Instrucţiunea while
 Corpul - poate fi orice instrucţiune, inclusiv:  Ex. Karel pavează curtea :)

 o instrucţiune compusă (bloc), dacă e necesar să se execute mai multe instrucţiuni în
mod repetat  Trebuie să paveze spațiul închis în care se află, spațiul e dreptunghiular
 o altă instrucțiune while
 o instrucțiune compusă care conţine un while
 în ultimele două cazuri se spune că instrucţiunile while respective sunt imbricate.
 Ex. Calcularea sumei primelor n elemente ale unui tablou:

s = 0;
i = 0;
while (i < n) {
s += a[i];
i++;
}
47 Instrucţiunea for 48 Instrucţiunea for
 Structură repetitivă cu test iniţial  Corpul - poate fi orice instrucţiune, inclusiv:

Parantezele sunt
for ( expr1 ; expr2 ; expr3 ) obligatorii! (fac parte
din sintaxa instrucțiunii  o instrucţiune compusă, dacă e necesar să se execute mai multe instrucţiuni în
for)
instrucţiune corpul lui for mod repetat
 expr1, expr2 şi expr3 sunt expresii. Oricare poate lipsi, dar caracterele ‘;’ trebuie să existe  instrucțiunea vidă
 expr1 se mai numeşte expresia de iniţializare  o altă instrucţiune for
 expr2 se mai numeşte condiţia de continuare a ciclului (dacă lipsește se consideră adevărată totdeauna)  o instrucţiune compusă care conţine un for
 expr3 se mai numeşte expresia de reiniţializare  în ultimele două cazuri se spune că instrucţiunile for sunt imbricate.
 Execuţia instrucţiunii for este echivalentă cu secvenţa:
 Ex. Calcularea sumei primelor n elemente ale unui tablou a:
expr1;
while ( expr2 ) { for (s = 0, i = 0; i < n; i++)
instrucţiune; s += a[i]; Este echivalentă cu:
expr3;
}
for (s = 0,i = 0; i < n; s+=a[i], i++);
49 Instrucţiunea for 50 Instrucţiunea for
 Ex. Calcularea mediei aritmetice a n valori reale  Ex. „Desenarea” unei „table de șah”
#include <stdio.h> #include <stdio.h>
int main() { #define NROWS 8
float a, media, s; #define NCOLS 8
int i, n;
printf("\nNumarul de valori n=");
scanf("%d", &n); int main() {
printf("Elemente: \n"); int row, col;
for (i = 0,s = 0;i < n; i++) { for (row = 0; row < NROWS; row++){
printf("a[%2d]=", i);
for (col = 0; col < NCOLS; col++)
scanf("%f", &a);
s += a; printf("%2s", (row+col)%2?"\xdb\xdb":" ");
} printf("\n");
media = s/n; }
printf("Media=%g\n", media);
return 0;
return 0;
}
}
51 Instrucţiunea if, switch, while
 Ex. Karel interactiv - cerințe

 Se deplasează cu tastele săgeți
 Poate plasa o piatră (Insert)
 Poate lua o piatră (Delete)
UTCN - Programarea Calculatoarelor - Curs 3 ș.l.dr. Iulia Costin 16/10/2019

Programarea Calculatoarelor - Curs 3

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Programarea Calculatoarelor - Curs 3

Încărcat de

Drepturi de autor:

Formate disponibile

2 Conținut

Limbajul C – Variabile. Expresii. Tablouri. Instrucțiuni 

UTCN - Programarea Calculatoarelor - Curs 3 ș.l.dr. Iulia Costin 16/10/2019

3 Valori constante 4 Valori constante

 Constante caracter  Variabilă = o zonă de memorie care are asociat:

7 Variabile 8 Constante simbolice

 Operanzi pot fi:  binari - doi operanzi

11 Operatori aritmetici 12 Operatori relaționali și de egalitate

 Aditivi:  Operatori relaţionali: <, <=, >, >=

15 Operatori pe biți 16 Operatori de atribuire

1101011001 & 1101011001 | 1101011001 ^

19 Alți operatori 20 Alți operatori

 Operatorul condiţional: ?: (operator ternar)  Operatorul adresă:

 Tabela de priorităţi a operatorilor, în ordine descrescătoare (operatorii de  La evaluarea expresiilor se ia în considerare:

a00 a01 … a0,n-1 a10 a11 … a1,n-1 …… am-1,0 am-1,1 … am-1,n-1

31 Tablou de caractere 32 Tablou de caractere

 Tablou de caractere = tablou unidimensional cu elemente de tip caracter

int main() {  Prelucrarea datelor într-un program se realizează cu ajutorul instrucţiunilor

35 Instrucțiuni 36 Instrucţiunea expresie

 În limbajul C există două grupe de instrucţiuni:

 O succesiune de instrucţiuni, precedată eventual de declaraţii de variabile (locale),  Are 2 forme:

 Structura selectivă:  Execuţia:

43 Instrucţiunea switch 44 Instrucţiunea while

 Corpul - poate fi orice instrucţiune, inclusiv:  Ex. Karel pavează curtea :)

 Ex. Calcularea sumei primelor n elemente ale unui tablou:

47 Instrucţiunea for 48 Instrucţiunea for

 Structură repetitivă cu test iniţial  Corpul - poate fi orice instrucţiune, inclusiv:

51 Instrucţiunea if, switch, while

 Ex. Karel interactiv - cerințe

UTCN - Programarea Calculatoarelor - Curs 3 ș.l.dr. Iulia Costin 16/10/2019

S-ar putea să vă placă și