program area calculatoarelor si limbaje de program are
TRANSCRIPT
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 1/267
Delia UNGUREANU
PROGRAMAREA CALCULATOARELOR
ŞI LIMBAJE DE PROGRAMARE
- I -
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 2/267
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 3/267
3
Introducere
În epoca actuală, caracterizată printr-o formidabilă explozie informaŃională însoŃită de
o evoluŃie tehnologică pe măsură, nu se mai poate concepe progresul în oricare din domeniile
activităŃii umane, fără utilizarea calculatoarelor.Cea mai nouă şi cea mai importantă revoluŃie din punct de vedere al progresului
omenirii este revoluŃia informaŃională. Tehnologia informaŃională a fost recunoscută ca
principal factor pentru creşterea economică şi îmbunătăŃirea calităŃii vieŃii în general.
InformaŃia o putem considera o noŃiune primară, o definiŃie fiind greu de dat. I se pot
da mai multe semnificaŃii (uneori total diferite sau chiar contradictorii), ce sunt determinate de
domeniile şi contextele variate în care cuvântul este folosit. Se poate spune că informaŃia se
constituie într-o reprezentare a realităŃii prin intermediul unui set bine precizat şi structurat de
simboluri - de regulă accesibile simŃurilor şi raŃiunii umane, dar şi unora dintre dispozitive, precum cele de calcul automat (sisteme de calcul, numite pe scurt calculatoare).
InformaŃia prelucrată de calculator, reprezentată prin date, este foarte diversă,
informaŃie numerică, text, imagine, informaŃie audio, semnale, etc. Calculatorul, reprezintă un
ansamblu de dispozitive şi circuite diverse care prelucrează datele introduse într-o formă
prestabilită, efectuează diverse operaŃii asupra acestora şi furnizează rezultatele obŃinute.
Datele sunt prelucrate printr-o succesiune de acŃiuni (instrucŃiuni), numită program. Scrierea
unui program se realizează folosind limbaje de programare specifice.
Cursul de faŃă urmăreşte familiarizarea cu un limbaj de programare. S-a optat pentru
învăŃarea limbajelor C/C++, limbaje foarte populare, programele scrise folosind aceste
limbaje acoperind o foarte mare diversitate de aplicaŃii. Avantajele oferite de limbajul C sunt:
este un limbaj de nivel mediu, portabil, structurat, flexibil;
produce programe eficiente ( lungimea codului scăzută, viteza de execuŃie mare) de
dimensiune relativ scăzută;
oferă un set bogat de operatori;
oferă multiple facilităŃi de reprezentare si prelucrare a datelor;
permite utilizare extensivă a apelurilor de funcŃii şi a pointerilor;
permite programarea la nivel scăzut (low-level), apropiat de hardware.
Obiectivele cursului
Cursul Programarea calculatoarelor şi limbaje de programare I urmăreşte
pe de o parte familiarizarea cu un limbaj de programare, dar în acelaşi timp se
doreşte şi formarea gândirii în spiritul scrierii unor programe cât mai bine
structurate, astfel încât să se asigure claritate în transpunerea problemei în
program, dar şi depanare şi întreŃinere a programelor facile. Se are în vedere nu
doar corectitudinea aplicaŃiilor, ci şi creşterea eficienŃei activităŃii de programare. Disciplina oferă studenŃilor noŃiuni de bază în domeniul programării
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 4/267
4
calculatoarelor în limbaje structurate, procedurale. Tehnica programării structurate
se bazează pe principiul “divide et impera”, adaptat ca formulare în “structurează
pentru a stăpâni” o aplicaŃie. Trăsătura caracteristică a limbajelor structurate este
compartimentarea datelor şi a codului. Datele sunt structurate în elemente de
diferite tipuri, programatorul putând să definească propriile structuri de date, ceea
ce permite o reprezentare adecvată a datelor prelucrate. Programele sunt alcătuite
din proceduri (funcŃii) care operează asupra structurilor de date. ActivităŃile
efectuate de proceduri sunt bine definite şi sunt separate de exterior, comunicând
cu acesta prin seturi de parametri şi eventual un rezultat returnat. Variabilele locale
funcŃiilor sunt invizibile altor funcŃii.
Parcurgerea acestui curs:
oferă noŃiuni de bază în domeniul programării calculatoarelor în limbaje
structurate, procedurale (tipuri de date, operatori, instrucŃiuni). asigură studenŃilor cunoştinŃe de bază în construirea şi exploatarea
structurilor de date.
urmăreşte ca, pe lângă cunoaşterea unui limbaj de programare, să se
cunoască modalităŃi de transpunere a unor probleme din domenii cât mai
diverse în programe, realizând implementarea unor algoritmi simpli.
NoŃiunile referitoare la structuri de date, algoritmi şi tehnici de programare vor fi
dezvoltate de alte cursuri prevăzute în planul de învăŃământ al specializării.
Actualul curs face referire doar la aspectele care Ńin de programarea procedurală,aspecte referitoare la programarea obiectuală urmând a fi tratate într-un alt curs.
CompetenŃe conferite
După parcurgerea materialului, studentul va fi capabil:
să descrie modul de reprezentare a datelor numerice sau alfanumerice în
sistemele de calcul;
să descrie algoritmul de rezolvare a unei probleme;
să utilizeze a unui mediu de programare specific prin care să scrie
programe sursă, să-l depaneze şi testeze şi să genereze fişierul executabil
aferent;
să folosească funcŃiile de intrare/ieşire pentru consolă şi fişiere;
să scrie expresii complexe şi să utilizeze instrucŃiunile specifice limbajului;
să opereze cu masive de date (tablouri uni şi multi-dimensionale, şiruri de
caractere);
să definească şi să utilizeze funcŃii;
să definească propriile tipuri de date şi să opereze corect cu acestea.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 5/267
5
CerinŃe preliminare
Pornindu-se de la premisa că, parte dintre studenŃi nu au deprinderi de
utilizare a limbajelor de programare, cursul a fost structurat astfel încât pentru
parcurgerea sa nu sunt necesare cunoştinŃe în domeniu. Pentru construirea
aplicaŃiilor de exemplificare a aspectelor tratate se folosesc cunoştinŃe de
matematică şi fizică acumulate de orice absolvent al unui liceu de profil real.
Discipline deservite
Obiectivele de formare specifice specializării Managementul Energiei au în
vedere formarea unor competenŃe aplicativ-practice care să permită realizarea de
sisteme de achiziŃii şi prelucrare de date în condiŃii industriale specifice, aplicarea
metodelor computerizate în controlul măsurătorilor industriale, etc., care presupun
folosirea ca suport atât pentru stocarea cât şi pentru prelucrarea datelor,
computerul. Disciplina Programarea calculatoarelor şi limbaje de programare I
oferă cunoştinŃe de bază în folosirea calculatoarelor, cunoştinŃe care vor fi utilizate
şi dezvoltate în discipline prevăzute în planul de învăŃământ, cum ar fi:
Programarea calculatoarelor şi limbaje de programare II, Grafică asistată de
calculator, Metode numerice, Medii integrate de programare, Arhitectura
calculatoarelor, Sisteme de achiziŃii de date, Informatică în energetică.
Resurse şi mijloace de lucru
Parcurgerea unităŃilor de învăŃare necesită utilizarea unui calculator şi a
unui mediu de programare cum ar fi: Borland C++ v.3.1, Microsoft Visual C++
6.0 sau Eclipse.
Se vor utiliza tutoriale şi programele sursă puse la dispoziŃie la laborator
sau accesate pe Internet.
Structura cursuluiCursul de Programarea Calculatoarelor şi Limbaje de Programare I este
structurat în paisprezece unităŃi de învăŃare, primele treisprezece cuprinzând:
obiective, aspecte teoretice privind tematica unităŃii de învăŃare respective,
exemple, teste de autoevaluare precum şi probleme propuse spre discuŃie şi
rezolvare, iar cea de a paisprezecea conŃine doar exemple prin care doreşte fixarea
noŃiunilor şi descriere unor tehnici de programare.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 6/267
6
Durata medie de studiu individual
Parcurgerea de către studenŃi a unităŃilor de învăŃare ale cursului de
Programarea Calculatoarelor şi Limbaje de Programare I (atât aspectele teoretice
cât şi rezolvarea problemelor propuse) se poate face în 2-3 ore de studiu individual
pentru fiecare unitate.
Evaluarea
La sfârşitul semestrului, fiecare student va primi o notă, care va cuprinde:
un test grilă, ce va conŃine întrebări referitoare la elementele de bază ale limbajului
şi la secvenŃe de programe, test ce va deŃine o pondere de 20% în nota finală,
realizarea unei aplicaŃii pe calculator care va deŃine o pondere de 40% în nota
finală şi media notelor testelor şi temelor realizate pe parcursul semestrului, careva deŃine o pondere de 20%.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 7/267
7
Cuprins
Introducere .................................................................................................................................. 3
Cuprins ....................................................................................................................................... 7
Unitatea de învăŃare U1. Reprezentarea informaŃiei în sistemele de calcul ............................. 12
Introducere .................................................................................................................... 12
Obiectivele unităŃii de învăŃare ..................................................................................... 13
U1.1. Sisteme de numeraŃie .......................................................................................... 13
U1.2. Conversii între baze de numeraŃie ....................................................................... 15
U1.3. OperaŃii aritmetice în binar ................................................................................. 16
U1.4. OperaŃii logice la nivel de bit. ............................................................................. 17U1.5. Reprezentarea numerelor întregi cu semn . ......................................................... 19
U1.6. Reprezentarea numerelor reale. ........................................................................... 20
U1.7. Coduri alfanumerice. ........................................................................................... 23
U1.8. Cantitatea de informaŃie. ..................................................................................... 25
Rezumat ........................................................................................................................ 26
Întrebări, exerciŃii şi probleme ...................................................................................... 27
Unitatea de învăŃare U2. Structura generală a sistemelor de calcul ......................................... 28
Introducere .................................................................................................................... 28Obiectivele unităŃii de învăŃare ..................................................................................... 28
U2.1. GeneralităŃi despre structura hardware a unui calculator .................................... 29
U2.2. GeneralităŃi despre structura software a unui calculator ..................................... 32
U2.3. Sistemul de operare ............................................................................................. 35
Rezumat ........................................................................................................................ 39
Întrebări, exerciŃii şi probleme ...................................................................................... 39
Unitatea de învăŃare U3. NoŃiuni introductive pentru limbajele de programare C/C++ .......... 40
Introducere .................................................................................................................... 40Obiectivele unităŃii de învăŃare ..................................................................................... 41
U3.1. Etapele parcurse pentru obŃinerea unui program executabil ............................... 41
U3.2. Elementele de bază ale limbajelor C/C++........................................................... 41
U3.2.1. Identificatori ......................................................................................... 42
U3.2.2. Semne de punctuaŃie şi caractere speciale ............................................ 44
U3.2.3. SpaŃii albe ............................................................................................. 44
U3.3. Structura programului C/C++ ............................................................................. 44
U3.4. Directive de preprocesare .................................................................................... 47U3.5. Primul program C/C++ ....................................................................................... 48
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 8/267
8
U3.6. Utilizarea comentariilor ...................................................................................... 49
U3.7. Tipuri de date fundamentale ............................................................................... 50
Exemple ........................................................................................................................ 53
Rezumat ........................................................................................................................ 55
Test de autoevaluare ..................................................................................................... 56
Întrebări, exerciŃii şi probleme ...................................................................................... 57
Unitatea de învăŃare U4. Constante. Variabile. ........................................................................ 58
Introducere .................................................................................................................... 58
Obiectivele unităŃii de învăŃare ..................................................................................... 58
U4.1. Constante ............................................................................................................. 59
U4.1.1. Constante întregi ................................................................................... 59
U4.1.2. Constante în virgulă mobilă .................................................................. 60
U4.1.3. Constante caracter ................................................................................. 61
U4.1.4. Constante şir de caractere ..................................................................... 62
U4.2. Variabile .............................................................................................................. 63
U4.2.1. DeclaraŃii de variabile ........................................................................... 63
U4.2.2. Atributele variabilelor ........................................................................... 65
U4.2.3. Modificatori de acces ............................................................................ 69
Exemple ........................................................................................................................ 69
Rezumat ........................................................................................................................ 73
Test de autoevaluare ..................................................................................................... 74Întrebări, exerciŃii şi probleme ...................................................................................... 76
Unitatea de învăŃare U5.OperaŃii de intrare/ieşire pentru consolă ........................................... 77
Introducere .................................................................................................................... 77
Obiectivele unităŃii de învăŃare ..................................................................................... 79
U5.1. OperaŃii I/O la nivel de caracter .......................................................................... 79
U5.2. FuncŃii pentru operaŃii I/O pentru şiruri de caractere .......................................... 80
U5.3. OperaŃii de citire/scriere cu formatare ................................................................ 82
Exemple ........................................................................................................................ 89
Rezumat ........................................................................................................................ 93
Test de autoevaluare ..................................................................................................... 94
Întrebări, exerciŃii şi probleme ...................................................................................... 98
Unitatea de învăŃare U6.Operatori şi expresii .......................................................................... 99
Introducere .................................................................................................................... 99
Obiectivele unităŃii de învăŃare ..................................................................................... 99
U6.1. Operatori .......................................................................................................... 100
U6.2. Ordinea de evaluare a expresiilor ...................................................................... 111
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 9/267
9
U6.3. Conversii de tip în expresii ............................................................................... 113
Exemple ...................................................................................................................... 114
Rezumat ...................................................................................................................... 116
Test de autoevaluare ................................................................................................... 117
Întrebări, exerciŃii şi probleme .................................................................................... 119
Unitatea de învăŃare U7. InstrucŃiuni (1) ................................................................................ 121
Introducere .................................................................................................................. 121
Obiectivele unităŃii de învăŃare ................................................................................... 122
U7.1. Algoritmi ........................................................................................................... 122
U7.1.1. GeneralităŃi ......................................................................................... 122
U7.1.2. Reprezentarea algoritmilor ................................................................. 123
U7.2. InstrucŃiunea expresie ....................................................................................... 127
U7.3. InstrucŃiunea compusă (blocul de instrucŃiuni) ................................................. 128
U7.4. InstrucŃiuni de selecŃie (decizie) ....................................................................... 130
U7.4.1. InstrucŃiunea de decizie if, if-else ....................................................... 130
U7.4.2. InstrucŃiunea de selecŃie multiplă switch ............................................ 132
Exemple ...................................................................................................................... 135
Rezumat ...................................................................................................................... 137
Test de autoevaluare ................................................................................................... 138
Întrebări, exerciŃii şi probleme .................................................................................... 139
Unitatea de învăŃare U8. InstrucŃiuni (2) ................................................................................ 140
Introducere .................................................................................................................. 140
Obiectivele unităŃii de învăŃare ................................................................................... 140
U8.1. InstrucŃiuni de ciclare (repetitive) ..................................................................... 141
U8.1.1. InstrucŃiunea de ciclare cu test iniŃial (while) ..................................... 141
U8.1.2. InstrucŃiunea de ciclare cu test final (do-while) ................................. 143
U8.1.3. InstrucŃiunea de ciclare cu contor (for) ............................................... 145
U8.2. InstrucŃiuni de salt ............................................................................................. 147
U8.2.1. InstrucŃiunea break .............................................................................. 147
U8.2.2. InstrucŃiunea continue ......................................................................... 149
U8.2.3. InstrucŃiunea return ............................................................................. 150
U8.2.4. FuncŃia exit() ....................................................................................... 151
U8.2.5. InstrucŃiunea de salt necondiŃionat goto ............................................. 153
Exemple ...................................................................................................................... 154
Rezumat ...................................................................................................................... 156
Test de autoevaluare ................................................................................................... 157
Întrebări, exerciŃii şi probleme .................................................................................... 159
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 10/267
10
Unitatea de învăŃare U9.Tablouri de date .....................................................................................
Introducere .................................................................................................................. 160
Obiectivele unităŃii de învăŃare ................................................................................... 160
U9.1. Declararea tablourilor de date ........................................................................... 161
U9.2. Tablouri unidimensionale ................................................................................. 164
U9.3. Şiruri de caractere ............................................................................................. 167
U9.4. Tablouri multidimensionale .............................................................................. 170
Exemple ...................................................................................................................... 172
Rezumat ...................................................................................................................... 177
Test de autoevaluare ................................................................................................... 178
Întrebări, exerciŃii şi probleme .................................................................................... 181
Unitatea de învăŃare U10. Variabile pointeri. Variabile referinŃe. ......................................... 182
Introducere .................................................................................................................. 182
Obiectivele unităŃii de învăŃare ................................................................................... 182
U10.1. Variabile pointeri ............................................................................................ 183
U10.1.1. Declararea variabilelor pointeri de date ............................................ 183
U10.1.2. OperaŃii de atribuire cu pointeri ........................................................ 184
U10.1.3. Referirea obiectelor prin variabile pointer ........................................ 185
U10.1.4. Pointeri generici ................................................................................ 186
U10.1.5. OperaŃii aritmetice cu pointeri .......................................................... 187
U10.1.6. Tablouri şi pointeri ........................................................................... 188U10.2. Variabile referinŃă ........................................................................................... 191
Exemple ...................................................................................................................... 192
Rezumat ...................................................................................................................... 195
Test de autoevaluare ................................................................................................... 195
Întrebări, exerciŃii şi probleme .................................................................................... 198
Unitatea de învăŃare U11. Alocare dinamică de memorie ...................................................... 199
Introducere .................................................................................................................. 199
Obiectivele unităŃii de învăŃare ................................................................................... 200
U11.1. Alocare dinamică de memorie ........................................................................ 200
U11.2. Alocare dinamică de memorie folosind funcŃii specifice ................................ 201
U11.3. Alocare dinamică de memorie folosind operatorii new şi delete .................... 203
U11.4. Alocare dinamică de memorie pentru tablouri multidimensionale ................. 205
Exemple ...................................................................................................................... 207
Rezumat ...................................................................................................................... 211
Test de autoevaluare ................................................................................................... 212
Întrebări, exerciŃii şi probleme .................................................................................... 215
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 11/267
11
Unitatea de învăŃare U12. FuncŃii C/C++ ............................................................................... 216
Introducere .................................................................................................................. 216
Obiectivele unităŃii de învăŃare ................................................................................... 217
U12.1. DefiniŃii de funcŃii ........................................................................................... 217
U12.2. DeclaraŃii de funcŃii. Prototipuri. .................................................................... 218
U12.3. Transferul parametrilor ................................................................................... 218
U12.3.1. Transferul prin valoare. Conversii de tip. ......................................... 218
U12.3.2. Transferul prin adresă ....................................................................... 219
U12.3.3. Transferul prin variabile referinŃă ..................................................... 220
U12.4. Rezultatul unei funcŃii. InstrucŃiunea return. .................................................. 222
U12.5. FuncŃii recursive .............................................................................................. 222
U12.6. Pointeri de funcŃii ............................................................................................ 223
Exemple ...................................................................................................................... 224Rezumat ...................................................................................................................... 228
Test de autoevaluare ................................................................................................... 229
Întrebări, exerciŃii şi probleme .................................................................................... 232
Unitatea de învăŃare U13. Tipuri de date definite de utilizator .............................................. 233
Introducere .................................................................................................................. 233
Obiectivele unităŃii de învăŃare ................................................................................... 234
U13.1. Enumerarea .................................................................................................... 234
U13.2. Structuri de date .............................................................................................. 235U13.3. Câmpuri de biŃi ................................................................................................ 242
U13.4. Uniuni .............................................................................................................. 240
Exemple ...................................................................................................................... 244
Rezumat ...................................................................................................................... 248
Test de autoevaluare ................................................................................................... 249
Întrebări, exerciŃii şi probleme .................................................................................... 252
Unitatea de învăŃare U14. Exemple ........................................................................................ 253
Introducere .................................................................................................................. 253
Obiectivele unităŃii de învăŃare ................................................................................... 253
Exemple ...................................................................................................................... 254
Rezolvarea testelor de autoevaluare ....................................................................................... 265
Bibliografie ............................................................................................................................. 267
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 12/267
12
Unitatea de învăŃare U1. REPREZENTAREA INFORMAłIEIÎN SISTEMELE DE CALCUL
Cuprins
Introducere .................................................................................................................... 12
Obiectivele unităŃii de învăŃare ..................................................................................... 13
U1.1. Sisteme de numeraŃie .......................................................................................... 13
U1.2. Conversii între baze de numeraŃie ....................................................................... 15
U1.3. OperaŃii aritmetice în binar ................................................................................. 16
U1.4. OperaŃii logice la nivel de bit. ............................................................................. 17
U1.5. Reprezentarea numerelor întregi cu semn . ......................................................... 19U1.6. Reprezentarea numerelor reale. ........................................................................... 20
U1.7. Coduri alfanumerice. ........................................................................................... 23
U1.8. Cantitatea de informaŃie. ..................................................................................... 25
Rezumat ........................................................................................................................ 26
Întrebări, exerciŃii şi probleme ...................................................................................... 27
IntroducereÎn calculatoarele digitale, informaŃia de orice fel este reprezentată, stocată
şi prelucrată în formă numerică. Numerele se reprezintă prin simboluri elementare
denumite cifre.
Un calculator poate fi prevăzut să funcŃioneze în orice sistem de numeraŃie.
În cazul reprezentării numerelor utilizate în mod curent, adică cu reprezentate în
baza 10, sunt necesare 10 simboluri distincte, câte unul pentru fiecare cifră. Fizic,
această reprezentare este destul de dificilă. Pe parcursul dezvoltării tehnicii de
calcul, s-a stabilit că cel mai avantajos este sistemul binar deoarece procesul prelucrării sau al stocării numerelor se face mai uşor pentru două simboluri.
Sistemul de calcul trebuie să distingă doar între două valori: între un semnal de
valoare joasă (Low, en.) - între 0 şi 2 volŃi şi unul de valoare înaltă (High, en.) -
aproximativ 5V. În acest caz, sistemului de operare va trebui să-i oferim spre
operare reprezentările binare ale numerelor zecimale folosite în mod curent.
În notaŃiile binare sunt utilizate numai cifrele 0 şi 1, spre deosebire de
sistemul zecimal unde sunt folosite cifrele de la 0 la 9. Un număr binar este un şir
de cifre binare cum sunt „1010” sau „100011”.
Deci, sistemul binar a fost preferat din următoarele motive:
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 13/267
13
simplitatea regulilor pentru operaŃiile aritmetice şi logice;
materializarea fizică relativ simplă a cifrelor.
Este de subliniat aici, din nou, că sistemele de calcul nu operează de fapt cu
numerele 0 şi 1, ci cu două stări asociate lor, respectiv semnalele Low şi High,
contact închis-contact deschis, prezenŃa sau absenŃa de curent etc.
Circuitele care trebuie să diferenŃieze numai două stări sunt mai sigure în
funcŃionare decât cele care trebuie să diferenŃieze 10 stări.
Fizic sunt folosite elemente bistabile cu stările:
conducŃie (+5V)
blocat (0V)
care sunt asociate cu valorile 0 şi respectiv 1.
Un astfel de element reprezintă unitatea de memorie denumită bit (bit este
un acronim al cuvintelor engleze binary digit - “cifră binară”).Evident, acest mod de reprezentare impune transformarea informaŃiilor de
orice natură (texte, sunete, imagini, etc.) în secvenŃe de cifre binare.
Obiectivele unităŃii de învăŃare
După parcurgerea acestei unităŃi de învăŃare trebuie să ştii:
cum se reprezintă informaŃia în calculator;
reprezentarea numerelor în diferite baze de numeraŃie; transformarea numerelor dintr-o bază de numeraŃie în alta;
modul de reprezentare a valorilor numerice, întregi sau reale şi a
informaŃiei alfanumerice.
Definirea competenŃelor specifice unităŃii de învăŃare curente, utilizând verbe
cuantificabile similare cu cele aplicate pentru descrierea competenŃelor generale
ale cursului.
Durata medie de parcurgere a primei unităŃi de învăŃare este de 2 ore.
U1.1. Sisteme de numeraŃie
În calculatoarele digitale, informaŃia de orice fel este reprezentată, stocată şi prelucrată
în formă numerică. Numerele se reprezintă prin simboluri elementare denumite cifre.
Un calculator poate fi prevăzut să funcŃioneze în orice sistem de numeraŃie. În cazulreprezentării numerelor utilizate în mod curent, adică cu reprezentate în baza 10, sunt
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 14/267
14
necesare 10 simboluri distincte, câte unul pentru fiecare cifră. Fizic, această reprezentare este
destul de dificilă. Pe parcursul dezvoltării tehnicii de calcul, s-a stabilit că cel mai avantajos
este sistemul binar deoarece procesul prelucrării sau al stocării numerelor se face mai uşor
pentru două simboluri. Sistemul de calcul trebuie să distingă doar între două valori: între un
semnal de valoare joasă (Low, en.) - între 0 şi 2 volŃi şi unul de valoare înaltă ( High, en.) -
aproximativ 5V. În acest caz, sistemului de operare va trebui să-i oferim spre operare
reprezentările binare ale numerelor zecimale folosite în mod curent.
În notaŃiile binare sunt utilizate numai cifrele 0 şi 1, spre deosebire de sistemul
zecimal unde sunt folosite cifrele de la 0 la 9. Un număr binar este un şir de cifre binare cum
sunt „1010” sau „100011”.
Deci, sistemul binar a fost preferat din următoarele motive:
simplitatea regulilor pentru operaŃiile aritmetice şi logice;
materializarea fizică relativ simplă a cifrelor.Este de subliniat aici, din nou, că sistemele de calcul nu operează de fapt cu numerele
0 şi 1, ci cu două stări asociate lor, respectiv semnalele Low şi High, contact închis-contact
deschis, prezenŃa sau absenŃa de curent etc.
Circuitele care trebuie să diferenŃieze numai două stări sunt mai sigure în funcŃionare
decât cele care trebuie să diferenŃieze 10 stări.
Fizic sunt folosite elemente bistabile cu stările:
conducŃie (+5V)
blocat (0V)care sunt asociate cu valorile 0 şi respectiv 1.
Un astfel de element reprezintă unitatea de memorie denumită bit (bit este un acronim
al cuvintelor engleze binary digit - “cifră binară”).
Evident, acest mod de reprezentare impune transformarea informaŃiilor de orice natură
(texte, sunete, imagini, etc.) în secvenŃe de cifre binare.
Totalitatea regulilor de reprezentare a numerelor şi de operare cu acestea, împreună cu
mulŃimea cifrelor, poartă denumirea de sistem de numeraŃie.
Sistemul de numeraŃie folosit în mod uzual, sistemul arab, este un sistem poziŃional,adică un sistem în care o cifră îşi aduce aportul la valoarea numărului format atât prin
valoarea sa, cât şi prin poziŃia pe care o ocupă.
Numărul cifrelor (simbolurilor) folosite pentru reprezentarea numerelor defineşte baza
sistemului de numeraŃie poziŃional.
Astfel, orice număr Nr în baza b se reprezintă, în mod unic prin relaŃia (1.1) care în
scriere desfăşurată se reprezintă prin relaŃia (1.2):
∑−=
−⋅=
m
ni
1i
i bcNr , (1.1)
adică:
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 15/267
15
n
n
1
1
0
0
1
1
1m
1i
m
m bc...bcbcbc...bcbcNr −
−
−
−
−
− ⋅+⋅+⋅+⋅++⋅+⋅= (1.2)
unde: 1bc0 i −≤≤ pentru m,...,ni −= , iar 0cm ≠ .
În mod curent se utilizează reprezentarea în baza 10, dar în mod frecvent sunt folositeşi alte baze, cum ar fi 2, 8, 16.
Utilizând relaŃia (1.1) în sistemul zecimal (baza 10), pentru numărul 2529, rezultă
următoarea reprezentare:0123
10 109102105102)2529( ⋅+⋅+⋅+⋅= (1.3)
În mod asemănător putem reprezenta valori în binar (baza 2):0123456
2 21202121212021)1011101( ⋅+⋅+⋅+⋅+⋅+⋅+⋅= (1.4)
sau, în hexazecimal (baza 16):01234
16 16151641610165167(75A4F) ⋅+⋅+⋅+⋅+⋅= (1.5)
ObservaŃii
Baza folosită pentru reprezentarea unui număr determină numărul cifrelor
(simbolurilor) folosite. Dacă se face reprezentare în baza 2, de exemplu, se
vor folosi simbolurile 0 şi 1 (vezi relaŃia 1.4). Dacă se face reprezentare în
baza 8, se vor folosi simbolurile 0, ..., 7. Numărul (2593)8, fiind reprezentat
în baza 8, este incorect deoarece conŃine cifra 9.
Pentru reprezentarea numerelor în bază mai mare decât 10 este necesară
adăugarea de simboluri utilizate. Pentru baza 16 care este în mod frecvent
utilizată, se folosesc cifrele 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a sau A (10), b sau B
(11), c sau C (12), d sau D (13), e sau E (14), f sau F (15) (exemplu relaŃia
1.5).
U1.2. Conversii între baze de numeraŃie
Conversia între baze de numeraŃie se face pornind de la modul de reprezentare a
numerelor descris prin relaŃia (1.1).
Astfel, transformarea din orice bază în baza 10 se face folosind relaŃia (1.1), respectiv
(1.2) (vezi exemplele din relaŃiile (1.4) şi (1.5)).
Exemplu de transformare din baza 2 în baza 10:
(1011101)2 = 1 . 26 + 0 . 25 + 1 . 24 + 1 . 23 + 1 . 22 + 0 . 2 + 1 = (93)10 (1.6)
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 16/267
16
Exemplu de transformare din baza 16 în baza 10:
(75A4F)16 = 7 . 164 + 5 . 163 + 10 . 162 + 4 . 16 + 15 = (481871)10 (1.7)
Transformarea din baza 10 în orice bază se face efectuând împărŃiri succesive ale
numărului la baza către care se face transformarea, resturile obŃinute reprezentând cifrele cealcătuiesc numărul în noua reprezentare:
(37)10 = (100101)2
Fig. 1.1. Exemplu de transformare a unui număr din baza 10 în baza 2
ObservaŃie
Cifrele se obŃin în ordine crescătoare a puterii bazei, astfel că în alcătuirea
numărului ele vor fi poziŃionate în ordine inversă obŃinerii lor.
Conversiile între bazele 10, 2, 8, 16 care sunt utilizate în mod frecvent pentru
reprezentarea informaŃiei în calculatoarele numerice se pot face şi folosind tabelul decorespondenŃe ce urmează (Tabelul 1.1).
Tabelul 1.1. Tabel de corespondenŃă între valori cu reprezentare în bazele 10, 2, 8 şi 16
Zecimal Binar Octal Hexazecimal Zecimal Binar Octal Hexazecimal
0 0000 00 0 8 1000 10 8
1 0001 01 1 9 1001 11 92 0010 02 2 10 1010 12 A
3 0011 03 3 11 1011 13 B
4 0100 04 4 12 1100 14 C
5 0101 05 5 13 1101 15 D
6 0110 06 6 14 1110 16 E
7 0111 07 7 15 1111 17 F
37 21 18 2
0 9 21 4 2
0 2 20 1
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 17/267
17
U1.3. OperaŃii aritmetice în binar
Algoritmii de efectuare a operaŃiilor aritmetice sunt aceeaşi, indiferent de baza de
numeraŃie utilizată. Spre exemplu, mai jos sunt reprezentate regulile pentru operaŃiile de
adunare şi înmulŃire în binar, comparativ cu efectuarea aceloraşi operaŃii în baza 10:
Adunarea: OperaŃia în baza 2 OperaŃia în baza 10
100101+ 37 +10101 21
111010 58
ObservaŃie
Cu T s-a reprezentat câmpul de transport
ÎnmulŃirea:OperaŃia în baza 2 OperaŃia în baza 10
100101* 37 *10101 21
100101 37 100101 74 .
100101 7771100001001
U1.4. OperaŃii logice la nivel de bit
În afară de operaŃiile aritmetice, în mod frecvent se utilizează şi operaŃii logice
efectuate la nivel de bit. Acestea se efectuează între fiecare pereche formată din biŃii situaŃi peaceeaşi poziŃie în alcătuirea operanzilor.
Mai jos sunt reprezentate regulile pentru operaŃiile logice care se efectuează la nivel
de bit:
Negarea (NOT)
a b a+b T0 0 0 00 1 1 01 0 1 01 1 0 1
a b a*b0 0 00 1 01 0 01 1 1
a a 0 11 0
0 0 1 0 0 1 0 1 a
1 1 0 1 1 0 1 0 a
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 18/267
18
ŞI logic (AND)
SAU logic (OR)
SAU EXCLUSIV (XOR)
OperaŃii de deplasare la nivel de bit
OperaŃiile de deplasare au ca efect deplasarea tuturor biŃilor cu acelaşi număr de
poziŃii la stânga (<<), respectiv la dreapta (>>). LocaŃiile eliberate se vor completa cuvaloarea 0.
Fig. 1.2. Descrierea operaŃiilor de deplasare la nivel de bit
ObservaŃii
Deplasarea la stânga cu 1 este echivalentă cu înmulŃirea cu 2 a numărului
respectiv, iar deplasarea la dreapta cu 1, cu împărŃirea întreagă la 2.
Deplasarea la stânga cu n este echivalentă cu înmulŃirea cu 2n a numărului
respectiv, iar deplasarea la dreapta cu n, cu împărŃirea întreagă la 2n.
a b a&b0 0 00 1 0
1 0 01 1 1
0 0 1 0 0 1 0 1 37
0 0 0 1 0 1 0 1 21
0 0 0 0 0 1 0 1 37 & 21
a b a | b0 0 00 1 11 0 11 1 1
0 0 1 0 0 1 0 1 37
0 0 0 1 0 1 0 1 21
0 0 1 1 0 1 0 1 37 | 21
a b a ^ b0 0 00 1 11 0 11 1 0
0 0 1 0 0 1 0 1 37
0 0 0 1 0 1 0 1 21
0 0 1 1 0 0 0 0 37 ^ 21
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 19/267
19
U.1.5. Reprezentarea numerelor întregi cu semn
Reprezentarea valorilor numerice întregi pozitive nu ridică probleme deosebite. Dacă
se foloseşte o secvenŃă formată din n biŃi, se poate reprezenta orice valoare N<2n. În figura
1.3. sunt utilizaŃi 8 biŃi, deci se poate reprezenta orice valoare <28. Valoare reprezentată este131212121 017
=⋅+⋅+⋅ .
Dacă însă se doreşte reprezentarea de valori negative, se pune problema reprezentării
semnului, având la dispoziŃie doar cele două simboluri 0 şi 1. Pentru a rezolva această
problemă, bitul de pe poziŃia cea mai din stânga (MSb-Most Significant Bit) va fi folosit
pentru reprezentarea semnului, valoarea 0 reprezentând semnul ”+” şi valoarea 1 semnul ”-”.
Fig. 1.3. Reprezentarea valorilor numerice întregi utilizând 8 biŃi (un octet sau byte)
Plecând de la această convenŃie, se folosesc trei tipuri de coduri binare: cod direct (numit şi cod mărime / modul şi semn, notat pe scurt MS)
cod invers (numit şi cod complement faŃă de 1, notat pe scurt C1)
cod complementar (numit şi cod complement faŃă de 2, notat pe scurt C2)
Reprezentarea numerelor cu semn în cod direct (cod mărime şi semn)
Mod de reprezentare: Modulul numărului are aceeaşi reprezentare atât pentru numere
pozitive cât şi pentru cele negative, iar semnul ia valoarea 0 pentru numere pozitive, respectiv
1 pentru numere negative.
reprezentarea binară a valorii (37)10
reprezentarea binară a valorii (-37)10
Reprezentarea numerelor cu semn în cod invers (cod complement faŃă de 1)
Mod de reprezentare: Pentru numere pozitive bitul de semn ia valoarea 0, ceilalŃi biŃi
reprezentând valoarea modulului numărului. Pentru numere negative, bitul de semn este 1,ceilalŃi biŃi fiind obŃinuŃi prin complementarea bit cu bit a reprezentării binare a modulului
0 0 1 0 0 1 0 1
1 0 1 0 0 1 0 1
0 0 0 0 0 1 1
Cel maisemnificativ bit (MSb)
b7 b6 b5 b4 b3 b2 b1 b0
1
Cel mai puŃinsemnificativ bit (LSb)
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 20/267
20
numărului.
reprezentarea binară a valorii (37)10
reprezentarea binară a valorii (-37)10 Reprezentarea numerelor cu semn în cod complementar (cod complement faŃă de 2)
Mod de reprezentare: Pentru numere pozitive reprezentarea este identică cu cea făcută
in MS. Această reprezentare respectă şi convenŃia de reprezentare a semnului: bitul de pe
poziŃia cea mai din stânga (MSB - Most Significant Bit) este bitul de semn, valoarea 0 a
acestuia având ca semnificaŃie semnul “+”, iar valoarea 1 reprezintă semnul “-“. Pentru a
obŃine reprezentarea binară a unui întreg negativ, se realizează negarea la nivel de bit a
reprezentării valorii absolute a respectivului număr şi se adună valoarea 1, obŃinându-se aşa
numitul complement faŃă de doi.
De exemplu, valoarea (-37)10, folosind un octet pentru reprezentare, se obŃine astfel:
reprezentarea binară a valorii (37)10
negarea bit cu bit (complement faŃă de 1)
reprezentarea binară a valorii (-37)10
ObservaŃii
Pentru maşinile de calcul reprezentarea numerelor întregi negative se face
prin complementul faŃă de doi, acesta prezentând o serie de avantaje în
implementarea operaŃiilor aritmetice.
U1.6. Reprezentarea numerelor reale
Numerele reale sunt numerele care sunt formate din: semn, parte întreagă şi parte
fracŃionară.
Virgula (punctul zecimal sau binar, în notaŃia engleză) nu se reprezintă fizic nicăieri
în registrele calculatorului, dar poziŃia sa este cunoscută (stabilită) pentru oricare dintre
modurile de reprezentare.
Reprezentarea numerelor reale se poate face în 2 moduri:
reprezentarea în virgulă fixă; reprezentarea în virgulă mobilă.
0 0 1 0 0 1 0 1
1 1 0 1 1 0 1 0
0 0 1 0 0 1 0 1
1 1 0 1 1 0 1 0
+ 1
1 1 0 1 1 0 1 1
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 21/267
21
Reprezentarea valorilor reale în virgulă fixă
Fig.1.4. Reprezentarea valorilor numerice reale în virgulă fixă
În reprezentarea în virgulă fixă se presupune că partea întreagă este despărŃită de
partea fracŃionară printr-o virgulă imaginară care se găseşte într-o poziŃie fixă. În acest caz
sunt fixe atât numărul de poziŃii ale părŃii întregi cât şi numărul de poziŃii ale parŃii
fracŃionare. PoziŃia virgulei fixe este o caracteristică a tipului de calculator si a modului în
care este construit.
De exemplu, dacă se reprezintă pe 8 biŃi un număr fracŃionar cu numărul de poziŃii
întregi 5, numărul de poziŃii zecimale va fi 3. In cazul în care numărul N care se reprezintă
este pozitiv, domeniul de valori al datei va fi:
(00000,000)2 ≤ N ≤ (11111,111)2
adică:(0,0)10 ≤ N ≤ (31,925)10
Dacă numărul este negativ, se va reprezenta prin complement faŃă de 2, primul bit
fiind bitul de semn şi domeniul de valori al datei va fi:
(11111,11)2 ≤ N ≤ (01111,111)2 adică:
(-16,025)10 ≤ N ≤ (5,925)10
Această reprezentare a numerelor reale nu este avantajoasă deoarece nu permite decât
reprezentarea de numere reale într-un domeniu de valori restrâns.
Reprezentarea valorilor numerice reale în virgulă mobilă
Pentru stocarea şi prelucrarea numerelor reale în calculator se foloseşte reprezentarea
în virgulă mobila (VM). Denumirea provine de la faptul că virgula nu are poziŃie fixă faŃă de
biŃii de reprezentare a numărului.
În calculator, un număr N este reprezentat in virgula mobila conform relaŃiei:
N = M * B
E
(1.8)unde: M = mantisa, care este de obicei codificată ca un număr binar subunitar, cu semn;
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 22/267
22
E = exponentul, un număr întreg cu semn;
B = baza, este 2 sau o putere a lui 2, dar nu este reprezentată, ea fiind recunoscută
implicit ca având această valoare.
Reprezentarea se face în cuvinte cu o anumită lungime (în număr de biŃi). Precizia dereprezentare a unui număr real este dată în primul rând de numărul de biŃi folosiŃi pentru
reprezentarea mantisei. Domeniul maxim de reprezentare este determinat de valoarea adoptată
pentru baza şi de numărul de biŃi folosiŃi pentru a reprezenta exponentul. În calculator se pot
reprezenta deci doar un set finit de numere reale dintr-un anumit interval continuu +/-R (cel
mult 2n, unde n este numărul de biŃi ai cuvântului reprezentat în VM). Deci numerele reale pot
fi reprezentate cu o anumită eroare, determinată de numărul limitat de biŃi folosit pentru
reprezentare. Eroarea de reprezentare depinde de distanta dintre două numere succesive
reprezentabile cu cei n biŃi. Toate numerele reale cuprinse între cele două valori vor trebuiaproximate prin una din cele două valori. Dacă baza folosită implicit pentru reprezentare nu
este 2 ci 4 sau 16, dezavantajul este că numerele reprezentabile vor fi şi mai rar distribuite pe
intervalul +/-R; apare însă avantajul creşterii domeniului de reprezentare cu n biŃi.
Pentru reprezentarea numerelor în VM se foloseşte forma normalizata în care prima
poziŃie binară după virgulă este diferită de zero. Normalizarea restrânge mărimea valorii
absolute a mantisei binare la domeniul:
1M
2
1<≤ (1.9)
Numerele prea mari pentru a fi reprezentate corespund unei depăşiri superioare de
capacitate (overflow), iar numerele prea mici unei depăşiri inferioare de capacitate
(underflow). Pentru a fi reprezentat un număr real x este aproximat cu un număr în virgulă
mobilă. Aproximarea lui x poartă numele de rotunjire, iar eroarea introdusă de eroare de
rotunjire.
Există mai multe modalităŃi pentru rotunjire:
trunchiere (rotunjire prin tăiere) ;
rotunjire la cel mai apropiat număr în virgulă mobilă.AcurateŃea sistemului în virgulă mobilă este caracterizată de aşa numita precizie a
maşinii (sau epsilon maşină).
Fig. 1.5. Reprezentarea internă a unui număr real
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 23/267
23
Reprezentarea internă a unui număr real X se face sub forma descrisă în fig. 1.5.,
unde S reprezintă semnul numărului, E este exponentul, iar α0, α1, ... α p-1 reprezintă cifrele
binare ce alcătuiesc mantisa.
Formatele de reprezentare a numerelor în virgulă mobilă, conform standardului IEEE
754 (IEEE este acronim pentru Institute of Electrical and Electronics Engineers, o organizaŃie
ce are drept principal scop elaborarea standardelor pentru produsele hardware şi software;
standardul IEEE-754 se referă la aritmetica în virgulă mobilă în sistemele binare) sunt:
simplă precizie (single-precission) reprezentare pe 32 de biŃi (fig.1.6.):
1 bit pentru semnul mantisei
8 biŃi pentru exponent (Emin = -126, Emax= 127)
23 biŃi pentru mantisă
Fig.1.6. Reprezentarea numerelor în simplă precizie
dublă precizie (double-precission) pe 64 de biŃi (fig.1.7.)
1 bit pentru semnul mantisei
11 biŃi pentru exponentul decalat (Emin = -1022, Emax = 1023)
52 biŃi pentru mantisă
Fig.1.7. Reprezentarea numerelor în dublă precizie
Pentru:
simplă precizie, numerele se reprezintă cu 7 cifre zecimale
semnificative;
dublă precizie, numerele se reprezintă cu 16 cifre zecimale
semnificative.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 24/267
24
U1.7. Coduri alfanumerice
Computerele sunt dispozitive digitale, deoarece la baza interpretării informaŃiilor stau
două valori, 0 şi 1, asociate cu două stări. Toate datele procesate de computer trebuie
codificate digital ca serii de zero şi unu. Evident, acest mod de reprezentare impunetransformarea informaŃiilor de orice natură (texte, sunete, imagini, etc.) în secvenŃe de cifre
binare.
OperaŃia de transformare a informaŃiei în secvenŃe de cifre binare se numeşte
codificare. OperaŃia inversă codificării se numeşte decodificare. Codificarea este realizează de
dispozitivele destinate introducerii informaŃiei în calculator, iar decodificarea, de dispozitivele
care prezintă informaŃia din calculator într-o formă accesibilă omului. În cazul informaŃiei
textuale, fiecare caracter are drept corespondent codul lui – un şir finit format din opt cifre
binare. Şirul respectiv se numeşte octet (în engleza byte). CorespondenŃa dintre caractere şiocteŃi se defineşte cu ajutorul unui tabel, numit tabel de codificare sau, pur şi simplu cod. Pe
parcursul dezvoltării tehnicii de calcul au fost elaborate mai multe coduri.
În majoritatea calculatoarelor actuale, pentru codificarea caracterelor se foloseşte
codul ASCII (American Standard Code for Information Interchange). În acest cod,
reprezentarea caracterelor se face pe 8 biŃi. Setul de caractere de bază din codul ASCII
cuprinde 127 caractere (deci se poate reprezenta numai pe 7 biŃi), care sunt literele alfabetului
englez (majuscule şi minuscule), cele zece cifre ale sistemului de numeraŃie zecimal, semnele
de punctuaŃie şi unele "caractere speciale" (spaŃiu liber, sfârşit de linie, etc.).
Acest set de bază este folosit în toate Ńările şi este suficient pentru limba engleză. El
este, de asemenea, suficient pentru majoritatea limbajelor de programare, deoarece cuvintele
cheie ale acestora sunt preluate tot din limba engleză.
În prezent se foloseşte codul ASCII extins, reprezentarea caracterelor fiind făcută pe
8 biŃi, apelat adesea doar prin numele de cod “ASCII”. Primele 32 de caractere ASCII
codifică coduri de control şi sunt utilizate pentru a transmite diferite caractere de control
privind mesaje. Aceasta pentru că ASCII a fost dezvoltat iniŃial pentru transmisia datelor (de
exemplu caracterul de control ^D, EOT = End Of Transmission, este utilizat pentru a indica
sfârşitul unui flux de date). Restul codurilor se referă la 64 litere şi cifre şi 196 caractere decontrol, semne de punctuaŃie, caractere grafice şi alte caractere. Scopul principal al codului
ASCII este reprezentarea textului. Astfel că adesea datele de tip text sunt referite ca date de
tip ASCII. O secvenŃa de caractere reprezentate prin codurile lor ASCII, e numită şir
("string"). Şirul poate sa fie gol (nici un caracter) sau poate cuprinde o frază, un paragraf, sau
chiar un bloc întreg de caractere. La sistemul de operare DOS şi la unele limbaje de
programare, cum este C/C++, şirul de caractere se termină cu un cod ASCII 0 (zero); acesta se
numeşte şir ASCIIZ.
În Tabelul 1.2. este prezentat codul ASCII pe 7 biŃi.În ultima vreme, pentru reprezentarea caracterelor s-a adoptat un nou sistem de
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 25/267
25
codificare, numit Unicode. În acest sistem, caracterele sunt reprezentate pe 16 biŃi, ceea ce
permite să se reprezinte, practic, caracterele tuturor alfabetelor de pe glob. Este adevărat însă
că, în acest fel, spaŃiul ocupat de un anumit text în memorie este dublu faŃă de cel ocupat în
ASCII.
Tabelul 1.2. Codul ASCII pe 7 biŃi
b6b5b4 b3b2b1b0 000 001 010 011 100 101 110 111
0000 NUL DLE SP 0 @ P ' p
0001 SOH DC1 ! 1 A Q a q
0010 STX DC2 " 2 B R b r
0011 ETX DC3 # 3 C S c s
0100 EOT DC4 $ 4 D T d t
0101 ENQ NAK % 5 E U e u
0110 ACK SYN & 6 F V f v
0111 BEL ETB / 7 G W g w
1000 BS CAN ( 8 H X h x
1001 HT EM ) 9 I Y i y
1010 LF SUB * : J Z j z
1011 VT ESC + ; K [ k {
1100 FF FS , < L \ l |
1101 CR GS - = M ] m }
1110 SO RS . > N ∧ n ¬
1111 SI US / ? O o DEL
U1.8. Cantitatea de informaŃie
Cantitatea de informaŃie exprimă numărul minim de cifre binare necesare pentru
codificarea şi decodificarea univocă a informaŃiei.
Prin folosirea unui singur bit, se pot reprezenta doar două valori. Prin utilizarea a n
biŃi, se pot reprezenta 2n valori.
În informatică, pentru măsurarea cantităŃii de informaŃie, în mod obişnuit se foloseşte
un multiplu al bitului, octetul (byte):
1 byte (octet) = 1B = 23 = 8 biŃi
Pentru că în general cantitatea de informaŃie prelucrată este mare, în mod frecvent
aceasta se exprimă prin multiplii octetului (byte-ului) (Tabelul 1.3.):
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 26/267
26
Tabelul 1.3. Multiplii octetului (byte-ului)
1 kilobyte (kB) = 1024 bytes (210 bytes)
1 megabyte (MB) = 1024 kbytes (210 kB)
1 gigabyte (GB) = 1024 Mbytes (210 MB)
1 terrabyte (TB) = 1024 Gbytes (210 GB)
1 pentabyte (PB) = 1024 Tbytes (210 TB)
1 exabyte (EB) = 1024 Pbyte (210 PB)
ObservaŃie
A nu se confunda bit-ul cu byte-ul, denumirea englezească pentru octet.
Rezumat
În calculatoarele digitale, informaŃia de orice fel este reprezentată, stocată şi
prelucrată în formă numerică.
Pentru reprezentarea datelor se foloseşte sistemul de numeraŃie arab care este
un sistem poziŃional.
Pentru reprezentarea datelor în calculator se foloseşte sistemul binar. În
notaŃiile binare sunt utilizate numai cifrele 0 şi 1.
În mod curent sunt folosite şi alte baze de numeraŃie, şi anume baza 10, 8 sau
16, valorile numerice reprezentate într-o bază putând fi convertite şi în alte baze.
Între valori numerice se pot efectua diferite tipuri de operaŃii, cum ar fi operaŃii
aritmetice sau operaŃii la nivel de bit.
Valorile numerice întregi cu semn, în mod curent, sunt reprezentate în cod
complement faŃă de doi. Valorile numerice reale, în mod curent, sunt reprezentate în virgulă mobilă, în
simplă sau dublă precizie.
Pentru reprezentarea datelor alfanumerice se folosesc codificări care asociază
valori numerice cu caractere; unul dintre codurile cu reprezentare pe un octet
folosit în mod uzual este codul ASCII.
Elementul de bază folosit în reprezentarea datelor este unitatea de memorie
denumită bit.
Pentru măsurarea cantităŃii de informaŃie, în mod obişnuit se foloseşte unmultiplu al bitului, byte-ul şi multiplii ai acestuia obŃinuŃi prin înmulŃire cu 210.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 27/267
27
Întrebări, exerciŃii şi probleme
1. Care sunt avantajele reprezentării informaŃiei folosind reprezentarea binară?
2.
Să se efectueze următoarele transformări:a. 11011001(2) = ?(10)
b. 10101010(2) = ?(10)
c. 11000000(2) = ?(10)
d. 101001(2) = ?(8)
e. 101001100(2) = ?(8)
f. 10100110(2) = ?(8)
g. 100010(2) = ?(8)
h. 8(10) = ?(8)
i. 16(10) = ?(8)
j. 32(10) = ?(8)
k. 128(10)
= ?(8) l. 256(10) = ?(8)
m. 16(10) = ?(2) n. 32(10)= ?(2) o. 45(10) = ?(2)
p. 256(10) = ?(2) q. 2A(16)
= ?(10) r. 27(16)
= ?(10) s. 3A2F(16)
= ?(10) t. 8(10)
= ?(16) u. 16(10)
= ?(16) v. 32(10)
= ?(16)
w. 128(10)
= ?(16) x. 256(10) = ?(16)
3. EfectuaŃi următoarele operaŃii aritmetice. VerificaŃi rezultatele obŃinute,
transformând operanzii în baza 10.a. 1001(2) + 110101(2) = ?
b. 1111(2) + 1001(2) = ?c. 1101(2) + 111011(2) = ?d. 101(2) x 101(2) = ?e. 1011(2) x 100(2) = ?
f. 111(2) x 111(2) = ?g. 1207(8) + 375(8) = ?h. 101(8) x 110(8) = ?i. 1A07(16) + 3B9(16) = ?
j. 101(16) x 110(16) = ?
4. Să se determine rezultatul următoarelor operaŃii la nivel de bit, operanzii fiind
reprezentaŃi în baza 10:
a. 79 = ? (negare la nivel de bit) b. 65 & 99 = ? ( ŞI logic la nivel de bit)c. 101 | 28 = ? ( SAU logic la nivel de bit)d. 23 ^ 48 = ? ( SAU EXCLUSIV la nivel de bit)e. 22 << 3 = ? ( deplasare la stânga la nivel de bit)f. 45 >> 3 = ? ( deplasare la dreapta la nivel de bit)
NOTĂ: La efectuarea operaŃiilor, operanzii vor fi reprezentaŃi în binar.
5. Să se determine reprezentarea în cod complement faŃă de 2, folosind un octet,
următoarele valori:a. 69 → ?
b. – 69 → ?c. 127 → ?
d. -128 → ?e. 255 → ?f. 256 → ?
6. Să se efectueze următoarele transformări:a. 1024 kB → ? MB
b. 1024 kB → ? B
c. 1GB → ? B
d. 1TB → ? B
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 28/267
28
Unitatea de învăŃare U.2. STRUCTURA GENERALĂ ASISTEMELOR DE CALCUL
CuprinsIntroducere .................................................................................................................... 28
Obiectivele unităŃii de învăŃare ..................................................................................... 28
U2.1. GeneralităŃi despre structura hardware a unui calculator .................................... 29
U2.2. GeneralităŃi despre structura software a unui calculator ..................................... 32
U2.3. Sistemul de operare ............................................................................................. 35
Rezumat ........................................................................................................................ 39
Întrebări, exerciŃii şi probleme ...................................................................................... 39
Introducere
În general, noŃiunea de calculator (sistem de calcul) reprezintă un ansamblu
de dispozitive şi circuite diverse care prelucrează datele introduse într-o formă
prestabilită, efectuează diverse operaŃii asupra acestora şi furnizează rezultatele
obŃinute (Fig.2.1.).
Fig.2.1. Reprezentarea generală a unui sistem de calcul
Orice sistem de calcul este format din două părŃi distincte: hardware-ul şisoftware-ul.
Hardware-ul este reprezentat de totalitatea echipamentelor şi dispozitivelor
fizice;
Software-ul este reprezentat prin totalitatea programelor care ajută utilizatorul înrezolvarea problemelor sale.
Obiectivele unităŃii de învăŃare
După parcurgerea acestei unităŃi de învăŃare trebuie să ştii:
Structura generală a unui sistem de calcul;
GeneralităŃi despre structura hardware a unui calculator;
GeneralităŃi despre structura software a unui calculator.
Durata medie de parcurgere a celei de a doua unităŃi de învăŃare este de 2 ore.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 29/267
29
U.2.1. GeneralităŃi despre structura hardware a unui calculator
ConstrucŃia fizică (hardware-ul) a unui calculator personal IBM PC cuprinde, în
principal (Fig.2.2.):
Unitatea centrală (UC);
Magistrale de comunicaŃie;
Echipamente periferice:
Dispozitive de intrare;
Dispozitive de ieşire;
Dispozitive de intrare-ieşire;
Dispozitive de stocare a informaŃiei.
Unitatea centrală (UC) este de fapt creierul calculatorului personal. Aceasta: coordonează întreaga activitate a calculatorului;
solicită informaŃii pe care utilizatorul le introduce de la tastatură;
realizează prelucrările de date prin executarea unui program;
oferă datele de ieşire obŃinute în urma prelucrărilor.
Fig.2.2. Structura internă a calculatorului electronic
Caracteristicile UC dau caracteristicile principale ale unui calculator. UC conŃine, în
principal:
placa de bază;
microprocesorul;
memoria internă; accesorii.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 30/267
30
Placa de bază este un suport ce conŃine circuite electronice şi asigură stabilitatea şi
performanŃele unui calculator, comunicaŃiile între toate componentele existente în calculator
(procesor, memorie, placă video, etc.).
Microprocesorul (P) este un circuit integrat. Microprocesorul reprezintă “creierul”
întregului calculator, coordonatorul tuturor operaŃiilor ce sunt efectuate de către acesta.
Microprocesorul este conectat la celelalte componente ale calculatorului prin intermediul
magistralei de date şi a magistralei de comenzi. El este caracterizat în principal de:
viteza de lucru;
capacitatea maximă de memorie pe care o poate adresa;
setul de instrucŃiuni pe care le poate executa.
Memoria internă este un ansamblu de circuite, prin intermediul cărora se memorează
programele şi datele pe parcursul execuŃiei lor. Datele din memoria internă se pierd atunci
când calculatorul se opreşte. Fizic, memoria se prezintă sub forma unor circuite integrate(circuite electrice obŃinute prin aplicarea pe un suport electroizolant a elementelor de circuit
electric, în scopul miniaturizării şi simplificării tehnologiei de fabricaŃie), lipite pe un circuit
imprimat, care se ataşează plăcii de bază.
Pentru a extinde capacitatea de memorare a calculatorului şi a păstra datele se foloseşte
memoria externă.
Memoria internă este caracterizată de doi parametri:
dimensiunea: este în strânsă legătură cu tipul microprocesorului folosit;
timpul maxim de răspuns: este intervalul de timp care este necesar memorieiinterne pentru a citi sau scrie date. Valoarea este de ordinul ns. Cu cât valoarea este
mai mică, cu atât va funcŃiona mai rapid calculatorul.
Din punct de vedere al accesului, memoria internă poate fi:
Memorie RAM (Random Access Memory – memorie cu acces aleator);
Memorie ROM (Read Only Memory - memorie numai pentru citire).
Memorie EPROM (Erasable Programmable ROM) – sunt memorii de tip ROM
care pot fi reînscrise de un număr limitat de ori.
Memoria RAM se mai numeşte memorie moartă, deoarece datele pe care le memorează se
şterg la închiderea calculatorului. Poate fi citită sau scrisă. Se mai numeşte memorie volatilă
deoarece informaŃia se păstrează atât timp cât este menŃinută alimentarea cu tensiune.
FuncŃional, memoriile RAM se utilizează în diferite scopuri, spre exemplu ca:
memorie de lucru;
memorie cache;
memorie video;
memorie tampon pentru imprimantă.
Memoria de lucru este memoria folosită de utilizator, în ea se memorează
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 31/267
31
instrucŃiunile programelor care se execută şi datele asociate acestora, ele fiind preluate din
memoria permanentă. Datele care se doreşte a fi păstrate trebuie salvate în memoria
permanentă.
Memoria cache este o memorie tampon foarte rapidă, între P (uneori încorporată în
acesta) şi memoria internă propriu-zisă. Memoria cache este de două feluri: de nivel unu
(internă) şi de nivel doi (externă). Cea internă este integrată în P. Mărimea memoriei cache
externă variază de la un calculator la altul, valorile uzuale fiind de 64 Kb, 256 Kb, 512 Kb, 1
MB, 2 MB, etc.
Memoria video sau grafică, permite afişarea pe ecran a unei grafici video complexe,
având ca rol maximizarea performanŃelor plăcilor grafice.
Memoria tampon pentru imprimantă reprezintă ansamblul locaŃiilor de memorie,
unde se stochează datele ce urmează a fi tipărite, până ce imprimanta le poate prelua.
Memoria RAM se prezintă ca o succesiune de octeŃi (octet sau byte sau locaŃie dememorie). Un octet are 8 biŃi. Bit-ul reprezintă unitatea elementară de informaŃie şi poate avea
una din valorile: 0 sau 1.
Capacitatea unei memorii este dată de numărul de locaŃii pe care aceasta le conŃine şi
se măsoară în multiplii de 1024 (210
). De exemplu, 1 Mbyte = 1024 Kbytes; 1Kbyte = 1024
bytes.
Fig.2.3. Organizarea memoriei interne
Numărul de ordine al unui octet în memorie se poate specifica printr-un cod, numit
adresă (Fig.2.3.). Ordinea în care sunt accesate locaŃiile de memorie nu este impusă, memoria
fiind un dispozitiv cu acces aleator la informaŃie.
În memorie se înregistrează două categorii de informaŃii:
date - informaŃii de prelucrat;
programe - conŃin descrierea (implementarea într-un limbaj de programare) a
acŃiunilor care vor fi executate asupra datelor, în vederea prelucrării acestora.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 32/267
32
ObservaŃii
Prin program putem înŃelege fie un set de instrucŃiuni scris de un
programator, fie o secvenŃa software executabilă.
O soluŃie de rezolvare a unei probleme se numeşte algoritm. Algoritmul
constă dintr-o succesiune finită de paşi care, pornind de la date, produce
rezultate.
În memoria internă este păstrată doar informaŃia prelucrată la un moment dat. Memoria
internă are capacitate redusă; accesul la informaŃia păstrată în aceasta este extrem de rapid, iar
datele nu sunt păstrate după terminarea prelucrării (au un caracter temporar).
Memoria ROM poate fi doar citită, nu poate fi scrisă de utilizator; este scrisă o singură dată
cu informaŃia necesară, de către producător. Este nevolatilă, informaŃia ei se păstrează chiar dacă cip-urile nu sunt alimentate cu tensiune. Componentele neconfigurabile ale BIOS-ului
(Basic Input Output System) sunt memorate într-o astfel de memorie. Aceste componente
sunt secvenŃe de program care sunt executate de fiecare dată la pornirea calculatorului. BIOS-
ul rămâne în fundal şi conlucrează cu sistemul de operare tot timpul cât calculatorul este în
funcŃiune. BIOS-ul asigură stabilitatea sistemului.
O altă componentă importantă a memoriei o constituie cea care stochează principalii
parametri configurabili ai BIOS-ului. Constructiv este de tip CMOS (Complementary Metal
Oxide Semiconductor) şi poate fi scrisă şi citită. Este alimentată în permanenŃă de un
acumulator, ea fiind volatilă (dacă acumulatorul este îndepărtat, informaŃia se pierde). Ea
conŃine date, cum ar fi:
informaŃii referitoare la dată şi ora sistemului;
informaŃii referitoare la componentele hardware (hard-disk-uri, floppy disk-uri,
dispozitive de afişare, tastatură, etc.);
informaŃii referitoare la parola sistemului.
U2.2. GeneralităŃi despre structura software a unui calculator
Software-ul reprezintă ansamblul de programe care fac posibilă realizarea funcŃiei
sistemului de calcul, de prelucrare a informaŃiilor şi care constituie suportul logic de
funcŃionare a unui sistem de calcul (fig.2.4.). Într-o traducere mot-á-mot, software-ul
înseamnă “partea moale" a calculatorului, spre deosebire de hardware, "partea tare”.
Firmware-ul este componenta de programe încărcate în memoria fixă ROM de către
producătorul sistemului de calcul. Această componentă se află la limita dintre hardware şi
software, reprezentând software-ul integrat în partea de hardware.
Componenta firmware a unui sistem de calcul, setul de instrucŃiuni microprogramateîncărcate în memoria fixă ROM, defineşte un anumit mod de funcŃionare şi implicit de
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 33/267
33
utilizare a sistemului de calcul. Din acest motiv, firmware-ul trebuie să fie suficient de redus
pentru a nu particulariza excesiv sistemul de calcul. Prin utilizarea unor memorii cu citire-
scriere, nevolatile, alături de memoria ROM, se obŃin componente cu microprogramare
dinamică. Aceasta constă în posibilitatea adaptării secvenŃei de programe fixe din ROM la
încărcarea sistemului de operare.
Fig.2.4. Componentele software ale unui sistem de calcul
Componenta ROM-BIOS a sistemelor de calcul compatibile PC este o componentă
firmware, realizată prin microprogramare dinamică. Rolul componentei BIOS este de interfaŃă
între hardware şi software, oferind componentei software funcŃii de bază pentru utilizarea
hardware-ului. În acest fel se realizează independenŃa componentelor software faŃă de
caracteristicile hardware specifice sistemului de calcul, eliberând, în acelaşi timp,
componentele software de detalii legate de modul de lucru al hardware-ului. Fiind realizată
prin microprogramare dinamică, componenta firmware (BIOS) permite modificarea unor
parametri de funcŃionare ai PC-ului într-o secvenŃă specială, derulată în timpul procedurii de
încărcare a sistemului de operare, la pornirea sistemului de calcul.Componenta software a unui sistem de calcul cuprinde programe grupate în mai multe
categorii, după natura problemelor pe care le rezolvă. Aceste categorii sunt:
Software-ul de bază, care este alcătuit din programele care asigură serviciile generale şi
care se adresează tuturor utilizatorilor sistemului de calcul;
Software-ul utilitar (sistem de programe utilitare), care include programe cu grad mare de
generalitate puse la dispoziŃia utilizatorilor pentru a realiza anumite prelucrări specifice asupra
informaŃiilor, prelucrări comune tuturor utilizatorilor.
Software-ul de aplicaŃie, constituit din programe ale utilizatorilor, care rezolvă problemecu un nivel redus de generalitate, specifice fiecărui utilizator.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 34/267
34
Software-ul de bază reprezintă totalitatea programelor care fac posibilă funcŃionarea
şi utilizarea unui sistem de calcul. El include programe ierarhizate după natura problemelor pe
care le rezolvă şi după importanŃa lor. În acest sens avem:
Sistemul de operare, care acŃionează ca o interfaŃă între sistemul de calcul şi
utilizator. Sistemul de operare are rolul de a coordona şi supraveghea funcŃionarea
sistemului de calcul şi de a realiza comunicarea între utilizator şi sistemul de
calcul:
Gestiunea echitabilă şi eficientă a resurselor din cadrul sistemului de calcul;
Realizarea interfeŃei cu utilizatorul;
Furnizarea suportului pentru dezvoltarea şi execuŃia aplicaŃiilor.
Sistemul de programare cuprinde componentele software, care permit
utilizatorului să realizeze programe executabile pentru sistemul de calcul respectiv.
Sistemul de programe cuprinde pachete de programe dedicate, specifice fiecăruilimbaj de programare folosit de utilizator. Spre exemplu:
programe editoare folosesc pentru introducerea şi modificarea interactivă
a instrucŃiunilor;
programe translatoare specifice pentru fiecare limbaj de programare, sunt
acele aplicaŃii care transformă “programele sursă” scrise într-un limbaj de
programare în “programe-obiect”, scrise în limbaj-maşină;
programe editoare de legături, adică aplicaŃiile care transformă
programele din format obiect în programe executabile, realizând, dacă estecazul, integrarea mai multor module-obiect într-un singur program
executabil;
programe de depanare, interactive sau nu, care permit monitorizarea
erorilor;
aplicaŃii complexe numite medii de programare, care includ toate funcŃiile
componentelor prezentate anterior, cu scopul de a genera un program
executabil într-un mediu integrat.
programele editoare de texte (programe interactive, destinate introducerii,modificării, formatării şi tipăririi textelor).
În categoria software-ului utilitar intră:
programele care permit exploatarea componentelor hardware ale sistemelor de
calcul în condiŃii optime. Aceste programe pot utiliza verificarea stării de
funcŃionare a echipamentelor hardware, configurarea parametrilor de funcŃionare,
optimizarea modului de utilizare a componentelor hardware ale sistemelor de
calcul.
medii de prelucrare complexă a datelor, organizate sub formă de text, imagine,sunet sau sub formă de tabele. Aceste instrumente software pot fi folosite direct de
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 35/267
35
utilizatori neprofesionişti pentru dezvoltarea unor aplicaŃii sau pot fi folosite de
proiectanŃii de software ca instrumente de mare productivitate.
suprafeŃe de operare care sunt aplicaŃii specifice sistemelor interactive, care
înlocuiesc dialogul utilizatorului cu sistemul prin intermediul limbajului de
comandă al sistemului de operare cu interfeŃe de lucru “prietenoase”.
Software-ul de aplicaŃie este construit din programe ale utilizatorilor care rezolvă
probleme cu un nivel redus de generalizare şi care permite utilizarea sistemului de calcul în
cele mai diverse domenii: economice, industriale, sociale, medicale etc. ExecuŃia programelor
dintr-o anumită categorie se sprijină pe serviciile oferite de categoriile precedente. Astfel,
software-ul de aplicaŃie este dependent de tipul software-ului de bază pentru care a fost
proiectat. La nivelul utilizatorilor, această dependenŃă creează deseori multe probleme. Din
această cauză, o trăsătură importantă a software-ului de aplicaŃie este portabilitatea, adică aceacaracteristică ce permite rularea software-ului de aplicaŃie fără transformări pe diverse sisteme
de operare.
Software-ul de bază, în special componenta sistemului de operare, vine şi ea în
întâmpinarea acestei probleme, realizând emulări ale funcŃiunilor sistemelor de operare
anterioare în noile sisteme de operare.
Software-ul de aplicaŃie are foarte multe categorii în care poate fi clasificat, părerile
referitoare la clasificare fiind împărŃite. Una din clasificări permite împărŃirea software-ului
de aplicaŃie astfel: software cu destinaŃie ştiinŃifică;
software cu destinaŃie economică;
software de proces (software pentru urmărirea proceselor industriale);
software de gestiune (care vizează funcŃiunile financiare, contabile şi de conducere
ale întreprinderii).
În ultimul timp se constată o deplasare a ponderii de interes de la componentele
financiar-contabile spre componentele de conducere. Au apărut în această categorie aşa-
numitele sisteme informatice pentru sprijinirea deciziei, sisteme informatice pentru
conducere.
Accesibilitatea, gradul de diversitate şi numărul programelor creşte de la componenta
firmware către componenta software de aplicaŃie. În acelaşi timp, nivelul de specializare al
celor cărora li se adresează creşte de la componenta software de aplicaŃie către componenta
firmware.
U2.3. Sistemul de operare
Sistemul de operare reprezintă ansamblul de programe care asigură folosirea optimă aresurselor fizice şi logice ale unui sistem de calcul. El are rolul de a coordona şi controla
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 36/267
36
execuŃia programelor şi de a permite comunicarea utilizatorului cu sistemul de calcul. Pe
scurt, sistemul de operare este acea parte a componentei sistemului de calcul care
coordonează şi supraveghează întreaga activitate. Folosirea hardware-ului unui sistem de
calcul ar fi dificilă şi ineficientă în lipsa unui sistem de operare accesibil utilizatorilor.
Din punct de vedere al interacŃiunii cu componentele hardware, sistemul de operare
este organizat pe două niveluri:
1. Nivelul fizic, care include componenta firmware a sistemului de calcul. Acest
nivel oferă servicii privind lucrul cu componentele hardware. La acest nivel, comunicarea
sistemului de operare cu sistemul de calcul se realizează prin intermediul aşa-numitului sistem
de întreruperi, care semnalizează apariŃia unor evenimente interne sau externe sistemului de
calcul. De exemplu, în componenta ROM-BIOS sunt grupate, după funcŃia lor, următoarele
programe: programe care execută pornirea sistemului de calcul;
programe care verifică starea de funcŃionare a sistemului de calcul;
programe de iniŃializare a activităŃii sistemului de calcul;
rutinele care coordonează rularea componentelor fizice ale sistemului de calcul,
numite şi “drivere fizice”; ele oferă servicii pentru lucrul cu tastatura, imprimanta
şi cu perifericele nestandard.
2. Nivelul logic include partea de operare a sistemului de calcul şi oferă utilizatoruluimijloacele prin care poate exploata sistemul de calcul. Comunicarea utilizatorului cu sistemul
de calcul se realizează prin intermediul comenzilor şi instrucŃiunilor din programele pe care le
execută. Comunicarea inversă, sistem de calcul-utilizator, se realizează prin mesajele
transmise de sistemul de operare utilizatorului. Programele nivelului logic adresează
dispozitivele hardware prin intermediul programelor nivelului fizic al sistemului de operare şi
din acest motiv ele sunt independente de structura hardware a sistemului de calcul. Nivelul
fizic constituie, aşadar, o interfaŃă între hardware şi nivelul logic al sistemului de operare
Din punct de vedere funcŃional, programele sistemului de operare se împart în douăcategorii:
componentele de comandă şi control care cuprind programe care au rolul de a
asigura utilizarea eficientă a resurselor sistemului de calcul;
componentele de servicii care cuprind programe destinate minimizării efortului
uman implicat în utilizarea sistemului de calcul.
FuncŃia sistemului de operare, privind optimizarea exploatării unui sistem de calcul,
este împărŃită între componenta de comandă şi control şi componenta de servicii. Resursele
sistemului de calcul, pe care sistemul de operare le pune la dispoziŃia utilizatorului, seconstituie din totalitatea componentelor fizice sau logice ale sistemului de calcul, care pot fi
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 37/267
37
solicitate la un moment dat în timpul execuŃiei unui program. Gestionarea resurselor
sistemului de calcul este principala sarcină a sistemului de operare. În general, pentru a
executa un program într-un sistem de calcul secvenŃial cu program memorat este necesară
încărcarea acestui program în memoria internă a sistemului de calcul şi, sub controlul unităŃii
centrale de prelucrare, sunt executate secvenŃial instrucŃiunile programului. În detaliu,
execuŃia unui program se defineşte ca o succesiune de activităŃi care se desfăşoară la un
moment dat sub controlul sistemului de operare, activităŃi numite procese şi care se
caracterizează prin:
prelucrările pe care le realizează determinate de programul de execuŃie din care a
derivat procesul;
contextul de lucru care constă din resursele alocate procesului.
Executarea unei instrucŃiuni program presupune mai întâi alocarea unor resurse, cum
ar fi: alocarea unităŃii aritmetice logice pentru efectuarea de operaŃii aritmetice sau
logice asupra datelor;
alocarea unui dispozitiv periferic pentru transferul de informaŃii între acesta şi
memoria internă;
alocarea de spaŃiu în memoria internă;
accesarea unei anumite structuri de date din memoria externă;
apelul pentru execuŃie al unui alt program. Întotdeauna execuŃia unui alt program
presupune alocarea unei anumite zone din memoria internă a sistemului de calculşi, simultan, afectarea unei perioade din timpul de lucru al unităŃii centrale de
prelucrare.
Pentru a realiza alocarea unei resurse la un proces, sistemul de operare trebuie să aibă
răspuns la următoarele întrebări (de la caz la caz):
dacă resursa cerută există în sistem;
dacă resursa este disponibilă;
cât din resursă este disponibilă;
pentru cât timp poate fi alocată resursa; dacă resursa este alocată, dacă îi mai este necesară procesului căruia îi este alocat
(eliberarea resursei).
Rezultă, aşadar, funcŃiile ce trebuie îndeplinite de componenta sistemului de operare
care are rolul de gestionare a resurselor:
evidenŃa resurselor sistemului de calcul în fiecare moment, prin înregistrarea
fiecărei resurse, a stării ei (alocată sau liberă) şi a gradului ei de ocupare;
implementarea unor algoritmi de alocare a resurselor conform unei strategii de
alocare stabilite. O strategie de alocare trebuie să răspundă la întrebările:
cărei solicitări i se alocă resursa;
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 38/267
38
cât din resursă se alocă;
în ce moment se face alocarea;
pentru cât timp se face alocarea resursei;
cum se realizează alocarea efectivă a resursei, cu actualizarea informaŃiilor
legate de starea resursei;
cum se realizează eliberarea resursei, care poate fi făcută la iniŃiativa
procesului care a solicitat-o, atunci când ea nu mai este necesară procesului
sau la iniŃiativa sistemului de operare, pentru a fi alocată altor procese.
Această ultimă variantă este utilizată numai de anumite tipuri de sisteme de
operare;
să planifice şi să controleze fluxul aplicaŃiilor;
să detecteze şi să corecteze erorile care apar în procesul de prelucrare;
să gestioneze sistemul de fişiere.Componenta de comandă şi control a sistemului de operare. Activitatea de lansare în
execuŃie a unui program, activitatea de gestionare a alocării resurselor, ca şi operaŃiile
efectuate la încheierea execuŃiei acestuia sunt funcŃii realizate de componenta de comandă şi
control a sistemului de operare .
Componenta de servicii a sistemului de operare. Aceasta s-a dezvoltat odată cu cerinŃele
utilizatorilor. Gradul de accesibilitate al unui sistem de calcul, ca şi complexitatea sarcinilor
pe care utilizatorul le poate rezolva cu ajutorul lui sunt influenŃate de existenŃa şi eficienŃa
programelor de sistem incluse în componenta de servicii. Programele de servicii se executăsub supravegherea programelor de comandă şi control, ca orice program de aplicaŃii. Această
componentă oferă servicii diferite de la un sistem de operare la altul sau chiar de la versiuni
diferite ale aceluiaşi sistem de operare.
Componenta de servicii a unui sistem de operare poate include:
program încărcător, care lansează programe ale sistemului de operare la pornirea
sistemului de calcul;
program de tip "interpretor de comenzi", care traduce comenzile lansate de
utilizator sistemului de operare, asigurând astfel comunicarea între utilizator şisistemul de operare.
FuncŃiile realizate de această componentă sunt:
FuncŃia de gestionare a dialogului cu utilizatorul, fie în mod comandă, oferind
mecanisme de editare a comenzilor, fie prin intermediul unei interfeŃe grafice.
FuncŃia de înlănŃuire prin date a comenzilor sistemului de operare, de agregare a
comenzilor sistemului de operare, sub forma unor macrouri sau a unor fişiere de
comenzi.
FuncŃia de asistenŃă on-line, cunoscuta şi sub numele de “help” al sistemului de
operare.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 39/267
39
FuncŃia de tipul "plug and play" realizează acŃiunea de autodetecŃie a
echipamentelor nou instalate în sistem, permite reconfigurarea cu uşurinŃă a
sistemului şi notificarea schimbării configurării sistemului, de exemplu la căderea
unui echipament.
FuncŃia care oferă suportul pentru utilizarea limbii naŃionale, adică adaptarea
informaŃiilor cu caracter naŃional (simbol monetar, marca zecimală, dată
calendaristică etc.).
Rezumat
Orice sistem de calcul este format din două părŃi distincte: hardware-ul şi
software-ul.
Unitatea centrală (UC) coordonează întreaga activitate a calculatorului;
Memoria internă este un ansamblu de circuite, prin intermediul cărora se
memorează programele şi datele pe parcursul execuŃiei lor.
Memoria internă este volatilă, informaŃia stocată în ea se pierde la scoaterea de
sub tensiune a sistemului de calcul.
Memoria de lucru este organizată ca o succesiune de octeŃi asociaŃi cu valori
numerice numite adrese.
Componenta software cuprinde programe grupate: software de bază, software
utilitar, software de aplicaŃie. Sistemul de operare are rolul de a coordona şi supraveghea funcŃionarea
sistemului de calcul şi de a realiza comunicarea între utilizator şi sistemul de
calcul. El conŃine componenta firmware care oferă servicii privind lucrul cu
componentele hardware şi componente care asigură comunicarea utilizatorului cu
sistemul de calcul se realizează prin intermediul comenzilor şi instrucŃiunilor din
programele pe care le execută, acestea fiind independente de structura hardware a
sistemului de calcul.
Întrebări. ExerciŃii. Probleme.
1. DescrieŃi structura hardware generală a unui calculator.
2. DescrieŃi structura memoriei interne.
3. Ce reprezintă adresele de memorie?
4. Care este rolul firmware-ului.
5.
DescrieŃi componentele şi rolul sistemului de operare.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 40/267
40
Unitatea de învăŃare U.3. NOłIUNI INTRODUCTIVE PENTRULIMBAJELE DE PROGRAMARE C/C++
Cuprins
Introducere .................................................................................................................... 40
Obiectivele unităŃii de învăŃare ..................................................................................... 41
U3.1. Etapele parcurse pentru obŃinerea unui program executabil ............................... 41
U3.2. Elementele de bază ale limbajelor C/C++........................................................... 41
U3.2.1. Identificatori ......................................................................................... 42
U3.2.2. Semne de punctuaŃie şi caractere speciale ............................................ 44
U3.2.3. SpaŃii albe ............................................................................................. 44U3.3. Structura programului C/C++ ............................................................................. 44
U3.4. Directive de preprocesare .................................................................................... 47
U3.5. Primul program C/C++ ....................................................................................... 48
U3.6. Utilizarea comentariilor ...................................................................................... 49
U3.7. Tipuri de date fundamentale ............................................................................... 50
Exemple ........................................................................................................................ 53
Rezumat ........................................................................................................................ 55
Test de autoevaluare ..................................................................................................... 56Întrebări, exerciŃii şi probleme ...................................................................................... 57
Introducere
Limbajul C a fost dezvoltat la începutul anilor 1970 de Ken Thompson şi
Dennis Ritchie, odată cu care scrierea nucleului sistemului de operare UNIX.
Limbajul C este un limbaj simplu şi portabil. Este implementat pe mareamajoritate a platformelor de calcul existente azi, şi este unul dintre cele mai
populare limbaje de programare.
Limbajul C este un limbaj care se bazează pe principiile programării
procedurale, facilitând programarea structurată, cu posibilităŃi de control,
permiŃând scrierea unor aplicaŃii complexe, asemeni limbajelor de nivel înalt, cum
ar fi Pascal, Basic, Fortran etc. În acelaşi timp se apropie şi de limbajele de nivel
scăzut, permiŃând inserarea de cod scris în limbaj de asamblare, ceea ce asigură o
mare flexibilitate. Din aceste motive este încadrat în categoria limbajelor de nivel
mediu.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 41/267
41
Având în vedere larga lui utilizare, în anul 1990 a fost adoptat standardul
ANSI C (ANSI-American National Standards Institute) care standardizează
elementele specifice limbajului C, cum ar fi: cuvintele cheie disponibile,
bibliotecile de funcŃii, operaŃiile de intrare/ieşire, utilizarea şirurilor de caractere.
La sfârşitul anilor ’80, odată cu dezvoltarea tehnicii de programare
orientată pe obiecte (OOP-Object Oriented Programming), Bjarne Stroustrup a
creat limbajul „C cu clase”, care este construit pe baza limbajului C completat cu
facilităŃi de creare şi utilizare de clase. Ulterior acest limbaj a fost numit C++, el
fiind de asemenea standardizat prin adoptarea standardul ANSI C++. Aplicarea
principiilor OOP duce la creşterea productivităŃii programării.
Limbajele C/C++ sunt limbaje structurate. Trăsătura caracteristică a
limbajelor structurate este compartimentarea datelor şi a codului (folosirea
variabilelor temporare).Programele scrise în C/C++ sunt alcătuite din una sau mai multe funcŃii
(trebuie să conŃină cel puŃin o funcŃie şi aceasta să se numească main). Nu este
permisă crearea şi declararea unei funcŃii în interiorul altei funcŃii. Folosind
variabile locale, se pot scrie proceduri care să realizeze o sarcină specifică şi care
să nu cauzeze efecte secundare nedorite în alte părŃi ale codului.
Un program scris intr-un limbaj structurat este organizat sub forma de
blocuri permiŃându-i acestuia o structură modulară.
Obiectivele unităŃii de învăŃare
După parcurgerea acestei unităŃi de învăŃare trebuie să ştii elementele de bază ale limbajelor C/C++:
Identificatorii folosiŃi în C/C++;
Structura unui program C/C++;
Folosirea directivelor de preprocesare #define şi #include
ConvenŃii de introducere a comentariilor;
Tipuri de date fundamentale.
Durata medie de parcurgere a celei de a treia unităŃi de învăŃare este de 2 ore.
U3.1. Etapele parcurse pentru obŃinerea unui program executabil
Calculatorul prelucrează datele de intrare printr-o succesiune de transformări pentru a
obŃine datele de ieşire. Succesiunea de prelucrări este descrisă prin program. Fiecare
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 42/267
42
prelucrare este rezultatul uneia sau mai multor instrucŃiuni. La scriere unui program se are în
vedere ordinea de efectuare a prelucrărilor, ea respectând un anumit algoritm.
Principalele etape care se parcurg pentru obŃinerea unui program executabil sunt
(Fig.3.1):
etapa de scriere a programului sursă (fişier cu extensia .cpp): este etapa în care, prin
intermediul unui editor de text sau IDE (Integrated Development Environment – mediu de
dezvoltare a programelor), se scrie programul, respectându-se sintaxa limbajului şi logica
aplicaŃiei;
etapa de compilare: mai întâi se execută directivele de preprocesare prin expandarea în
codul sursă şi apoi se transpune programul sursă în program obiect (fişier cu extensia .obj);
etapa de link-editare: crearea legăturilor între modulele obiect obŃinute la pasul anterior şi
cu bibliotecile de sistem şi transformarea intr-un program executabil (fişier cu extensia .exe);
etapa de lansare în execuŃie a fişierului executabil.
Fig.3.1. Principalele etape parcurse pentru obŃinerea unui program executabil
U3.2. Elemente de bază ale limbajelor C/C++
La scrierea unui program în C/C++ se folosesc unităŃi sintactice care se încadrează în
diferite categorii, cum ar fi:
identificatori – nume care desemnează tipuri de date, constante, variabile, funcŃii, etc.
semne de punctuaŃie şi caractere speciale – simboluri care separă diverse entităŃi ale
programului, unii pot avea dublă semnificaŃie;
spaŃii albe – sunt caractere cu rol de delimitare sau care cresc lizibilitatea programului
sursă;
operatori – simboluri utilizate pentru precizarea operaŃiilor ce se efectuează;
constante – valori fixe reprezentând valori numerice, întregi sau reale, caractere sau şiruri
de caractere.
U3.2.1. Identificatori
Identificatorii limbajului C++, ca şi în limbajul C standard, sunt formaŃi cu ajutorul
caracterelor alfanumerice şi liniuŃa de subliniere (underscore), “_”. Aceştia denumesc tipuride date, variabile, funcŃii, operatori, instrucŃiuni etc.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 43/267
43
Primul caracter al unui identificator nu poate fi o cifră.
Exemple
Raza // valid
raza // valid
mesaj // valid
_maxx // valid
a5 // valid
5a // invalid, primul caracter este cifră
A_B_C // valid
A%B // invalid, caracterul % nu poate fi folosit într-un
// identificator
Limbajul C/C++ este case sensitive, adică face diferenŃă între majuscule şi minuscule,
astfel, în exemplele date anterior, numele Raza este diferit de raza.
Din mulŃimea identificatorilor posibili, se remarcă cuvintele cheie (reserved
keywords) ale limbajului, identificatori a căror semnificaŃie este predefinită şi nu poate fi
modificată de programator. Standardul ANSI C prevede un set de 32 de cuvinte cheie. La
acestea, standardul ANSI C++ aduce completări. Cuvintele cheie ale limbajului C++ sunt
prezentate în Tabelul nr. 3.1. Cuvintele cheie din tabel care încep cu semnul underscor
reprezintă variabile interne.
Tabelul nr. 3.1. Cuvinte cheie ale limbajului C++
Cuvinte cheie ale limbajului C++
_asm asm auto break case _cdecl
cdecl char class const continue _cs
default delete do double _ds else
enum _es _export extern _far far _fastcall float for friend goto _huge
huge if inline Int _interrupt interrupt
_loadds long _near Near new operator
_pascal pascal private protected public register
return _saveregs _seg short signed sizeof
_ss static struct switch template this
typedef union unsigned virtual void volatilewhile
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 44/267
44
U3.2.2. Semne de punctuaŃie şi caractere speciale
Semne de punctuaŃie şi caractere speciale constituie un set de caractere cu diferite
utilizări, care în funcŃie de poziŃia ocupată în textul programului sursă pot determina acŃiunile
care vor fi executate.
Aceste caractere sunt:
[ ] ( ) { } * , : = ; ... #
Unele caractere pot desemna operatori (ca de exemplu [ ] * , =) altele nu desemnează
o operaŃie, ci delimitează zone în alcătuirea codului sursă. Spre exemplu, caracterul ; (punct şi
virgulă) marchează sfârşitul unei instrucŃiuni, iar { şi } (paranteze acolade) marchează
începutul şi respectiv sfârşitul unui bloc de instrucŃiuni.
Caracterul # însoŃeşte numai directivele de preprocesare.
SemnificaŃia şi modul de utilizare al acestor caractere se va preciza în capitoleleurmătoare.
U3.2.3. SpaŃii albe
SpaŃiile albe sunt caractere speciale care, deşi nu sunt afişabile, produc efecte în
afişarea textului.
Aceste caractere sunt: space (are valoarea 32 în codul ASCII), tab (are valoarea 9 în
codul ASCII), newline (are valoarea 10 codul ASCII), vertical-tab (are valoarea 11 în codul
ASCII), formfeed (are valoarea 12 în codul ASCII), carriage-return (are valoarea 13 în codulASCII).
Aceste caractere sunt interpretate ca separatori când sunt plasate între entităŃi diferite
ale programului sau ca şi caractere dacă intră în alcătuirea şirurilor de caractere.
Sunt situaŃii în care aceste caractere se folosesc pentru a creşte lizibilitatea
programului sursă, caz în care ele vor fi ignorate de compilator.
ObservaŃie
Operatorii şi constantele vor fi prezentate în capitole viitoare.
U.3.3. Structura programului C/C++
AcŃiunile efectuate de un program C/C++ se pot grupa respectând algoritmul transpus,
programul fiind structurat în module, fiecare având un rol bine definit.
Fiecare acŃiune este determinată de o instrucŃiune.O succesiune de instrucŃiuni poate fi grupată într-un bloc numit funcŃie.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 45/267
45
Structura generală a unui program este alcătuită, în general, din 3 zone:
I < directive de preprocesare >
II < declaraŃii globale >
III definiŃii de funcŃii
Zonele I şi II sunt opŃionale, dar cea de a III-a este obligatoriu să existe.
Preprocesorul efectuează operaŃii înainte de compilarea codului, indicate prin aşa
numite directive de preprocesare, marcate totdeauna de caracterul #. Ele produc modificări în
codul care va fi compilat, cum ar fi inserarea unor fişiere fie din biblioteca standard, fie create
de utilizator, declararea de macrodefiniŃii, etc.
DeclaraŃiile globale pot conŃine definiŃii de tipuri de date, prototipuri de funcŃii,declaraŃii de variabile globale.
Programul trebuie să conŃină cel puŃin o funcŃie, denumită main(), execuŃia
programului începând cu această funcŃie. FuncŃia main() este unică, ea nu poate fi
supradefinită.
Restul funcŃiilor pot efectua diferite acŃiuni, ele putând fi definite de utilizator, sau să
fie preluate din bibliotecile de funcŃii C/C++.
FuncŃiile în C/C++, spre deosebire de alte limbaje, cum ar fi Pascal, nu pot include
definirea altor funcŃii. Deci funcŃiile sunt definite în afara oricărei funcŃii.DefiniŃia unei funcŃii are următoarea structură:
<tip_r> nume_functie (< lista_parametri >)
{
<declaratii locale >
secventa de instructiuni
}
tip_r – precizează tipul rezultatului funcŃiei. Dacă nu este specificat, în mod implicit
rezultatul întors de funcŃie este o valoare numerică întreagă, tipul de dată fiind int. Dacă
funcŃia nu returnează nici o valoare, acest lucru este precizat prin tipul de dată void.
Dacă funcŃia prelucrează date existente în momentul apelului funcŃiei (date de intrare),
aceste date pot fi preluate prin lista de parametri (lista_parametri). Aceasta are următoarea
sintaxă:
tip_p nume_parametru< , tip_p nume_parametru ,…, tip_p nume_parametru >
unde tip_p reprezintă tipul parametrului, iar nume_parametru un identificator diferit de
cuvintele cheie sau cei care au deja o semnificaŃie în domeniul funcŃiei.Lista parametrilor este încadrată între paranteze, ( ).
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 46/267
46
În cazul în care nu sunt necesari parametri, acest fapt este precizat prin cuvântul cheie
void care desemnează lipsa parametrilor. În lipsa oricărei specificări pentru lista de parametri,
în mod implicit compilatorul interpretează că lista este void.
Apelul funcŃiei (lansarea în execuŃie a funcŃiei) se face prin precizarea numelui
funcŃiei, însoŃit de paranteze rotunde în interiorul cărora se specifică valorile atribuite
parametrilor, numite valori efective, dacă aceştia există:
nume_functie(<valoare_parametru1, valoare_parametru2,…, valoare_parametrun>);
Este de remarcat faptul că, atât la definirea funcŃiei, cât şi la apelul funcŃiei,
parantezele trebuie sa însoŃească numele funcŃiei, chiar dacă funcŃia nu are parametri.
Corpul funcŃiei este format din declaraŃii locale şi dintr-o succesiune de instrucŃiuni
cuprinse între acolade, { }.
DeclaraŃiile locale, făcute în interiorul unei funcŃii, pot fi folosite numai în interiorulacelei funcŃii, ele încetând să mai existe odată cu terminarea execuŃiei funcŃiei.
Câteva exemple de definiŃii de funcŃii:
1.
void functia_1(void){
printf(“Se executa functia 1”);}
- funcŃia nu preia parametri şi nuîntoarce nici un rezultat.
2.
void functia_2(int parametru){
printf(“Se executa functia 2”);}
- funcŃia preia un parametru şi nuîntoarce nici un rezultat.
3.
int functia_3(int parametru_1, int parametru_2){
printf(“Se executa functia 3”);return (parametru_1+parametru_2);
}
- funcŃia preia doi parametri şiîntoarce un rezultat.
Apelul (lansarea în execuŃie) acestor funcŃii se face astfel:
1. functia_1(); - apelul funcŃiei fără parametri.
2. functia_2(100);- apelul funcŃiei cu un parametru; valoarea
preluată de parametru este 100.
3. functia_3(100, 500);
- apelul funcŃiei cu doi parametri; valorile preluate de parametri sunt 100 şi respectiv500; funcŃia întoarce valoare, 600
(100+500), valoare ce poate fi preluată deo variabilă sau folosită într-o expresie.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 47/267
47
Programul sursă poate fi alcătuit din una sau mai multe funcŃii. Acestea pot fi definite
într-un singur fişier sursă, sau în mai multe fişiere sursă, acestea putând fi compilate separat,
legăturile între acestea fiind realizate în faza de link-editare pentru a genera un singur fişier
executabil.
NoŃiuni legate de definirea şi apelul funcŃiilor vor fi reluate şi dezvoltate în capitolele
următoare.
U3.4. Directive de preprocesare
Preprocesorul efectuează operaŃii prealabile compilării, indicate de directivele de
preprocesare. Acestea sunt precedate de caracterul #.
În mod frecvent sunt utilizate directivele #define şi #include.
Directiva # define
Directiva define este utilizată pentru a asocia un identificator cu un şir de caractere. În
etapa de precompilare fiecare apariŃie a identificatorului va fi înlocuită, caracter cu caracter,
cu şirul corespunzător. Forma generală de utilizare a directivei #define este:
#define nume sir de caractere
Exemple
#define TRUE 1#define FALSE 0
#define NULL 0
#define MIN 10
#define MAX MIN+100
#define f(a, b) a+b
Directiva #define :
permite folosirea constantelor simbolice în programe uzual, dar nu obligatoriu, simbolurile sunt scrise cu litere mari
nu se termină cu ';'
apar în general la începutul unui fişier sursă
fiecare apariŃie a simbolului este înlocuită, caracter cu caracter, cu valoarea sa
ObservaŃii
Directivele preprocesor încep cu simbolul #
Directivele preprocesor nu se termină cu ';' In mod uzual, directivele preprocesor sunt scrise la începutul fişierului sursă
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 48/267
48
Directiva #include
Directiva de preprocesare #include determină includerea unui fişier sursă în alt fişier
sursă. Sintaxa de utilizare are una din formele:
#include < nume_fisier >
#include “ nume_fisier ”
Pentru prima variantă, fişierul va fi căutat într-un director predefinit care conŃine
fişiere header puse la dispoziŃie de mediul de programare, cea de a doua va căuta fişierul pe
calea specificată în numele fişierului. Dacă nu e precizată calea fişierului, va fi căutat în
directorul curent.
Exemple de folosire a directivei #include
#include <stdio.h> // fişierul e căutat în directorul predefinit#include “c:\dir1\dir2\fis_meu1.h” // fişierul este căutat pe calea c:\dir1\dir2\
#include “fis_meu2.h” // fişierul este căutat în directorul curent
U3.5. Primul program C/C++
În continuare se prezintă un exemplul de program, exemplu consacrat ca fiind primul
program în mare parte a manualelor de specialitate, fiind urmat de comentarii referitoare lanoŃiunile prezentate până la acest moment.
Exemplu
1234
56
7
#include <stdio.h>
int main(int argc, char* argv[]){
printf("Hello World!\n");return 0;}
La execuŃia programului se va afişa: Hello World!
ObservaŃii
un program în C/C++ trebuie să conŃină cel puŃin o funcŃie şi aceasta să se
numească main(); funcŃia main(), ca orice funcŃie poate prelua parametri sau nu, poate returna
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 49/267
49
valoare, sau nu; în exemplul de faŃă, este o funcŃie cu parametri şi care
returnează valoare;
execuŃia programului începe cu execuŃia funcŃiei main();
execuŃia programului se face secvenŃial, instrucŃiune după instrucŃiune,
începând cu prima instrucŃiune din main() şi terminând cu ultima instrucŃiune
din main();
identificatorul main nu poate fi folosit în alt scop, el fiind unul dintre cuvintele
rezervate;
limbajul C/C++ este case sensitive, adică face diferenŃă între majuscule şi
minuscule, astfel că identificatorii Main, MAIN, etc. pot fi utilizaŃi în ce scop
îşi propune utilizatorul;
cuvintele cheie, ca de exemplu int, char, return, sunt scrise cu litere mici;
fiecare instrucŃiune se termina cu ';' ; şirurile de caractere sunt incluse intre ghilimele duble "Hello World!\n";
\n poziŃionează cursorul la începutul liniei următoare, el reprezentând
caracterul cu valoarea 10 în codul ASCII, newline;
în linia 1 a programului se indică printr-o directivă de preprocesare, #include,
includerea fişierului stdio.h; acesta face parte din biblioteca standard şi conŃine
funcŃii destinate efectuării de operaŃii de intrare/ieşire;
printf() este o funcŃie utilizată pentru afişarea pe ecran a unui mesaj; ea este
definită în fişierul stdio.h ; { şi } delimitează începutul şi sfârşitul unui bloc-program;
return este cuvânt cheie şi reprezintă o instrucŃiune ce încheie execuŃia funcŃiei
main();
caracterele albe, cum ar fi spaŃiul, tab sau rând gol (rândul nr. 2) sunt ignorate
de compilator.
U3.6. Utilizarea comentariilorLa scrierea programelor sursă este util în numeroase situaŃii să se introducă anumite
comentarii care să explice eventuale secvenŃe de instrucŃiuni. Comentariile sunt ignorate de
compilator putând conŃine orice text, ele fiind utile doar programatorului.
Comentariile se pot scrie astfel:
comentarii pe un rând – sunt precedate de caracterele //
comentarii pe mai multe rânduri – sunt marcate între caracterele /* şi */
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 50/267
50
Exemplu
123456789
101112
13141516
17
//exemplificarea utilizării comentariilor /*
Acesta este un comentariu scris pe mai multe linii.Comentariile sunt ignorate de compilator.
*/#include <stdio.h>
int main(){
// comentariu pe o linie printf("Hello World !\n"); printf("Hello World !\n");
return 0; // instrucŃiunea return încheie execuŃia unei funcŃii printf("Hello World !\n"); /* aceasta linie nu se va executadeoarece se afla după instrucŃiuneareturn */
}
ObservaŃii
pe rândurile 1, 10 şi 13 sunt inserate comentarii pe un rând;
comentariile scrise pe mai multe rânduri sunt inserate pe rândurile 2÷5,
respectiv 14÷16 ;
comentariile sunt ignorate de compilator
U.3.7. Tipuri de date fundamentale
Tipul unei date determină dimensiunea zonei de memorie ocupată şi valorile pe care le
poate lua.
Tipurile datelor se pot grupa în:
tipuri fundamentale;
tipuri derivate.
Tipurile de date fundamentale cuprind tipurile aritmetice de bază şi tipul void.
Există patru tipuri aritmetice de bază, specificate prin cuvintele cheie: char, int, float
şi double. Gama de valori poate fi extinsă prin modificatori de tip desemnaŃi prin cuvintele
cheie: signed, unsigned, short, long. Tipurile întregi ce se obŃin prin combinarea tipurilor de
bază cu modificatorii de tip sunt prezentate în Tabelul nr. 3.2, iar cele reprezentate în virgulă
mobilă în Tabelul nr. 3.3.
Tipul fundamental void indică absenŃa oricărei valori şi se utilizează în următoarelesituaŃii: declaraŃia unei funcŃii fără parametri sau care nu returnează un rezultat, tipul pointer
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 51/267
51
generic şi conversii de tip cu operatorul cast pentru pointeri.
Pentru determinarea numărului de octeŃi de memorie folosiŃi pentru stocarea datelor se
poate folosi operatorul sizeof (va fi prezentat în capitolul destinat operatorilor).
Iată câteva exemple de expresii care returnează ca valoare spaŃiul de memorie ocupat
de date de diferite tipuri:
sizeof (long int); // expresia returnează valoarea 4
sizeof (unsigned char) // expresia returnează valoarea 1
sizeof (long double) // expresia returnează valoarea 8 sau 10
ObservaŃii
Modul de memorare al acestor tipuri de date depinde de varianta de
implementare a limbajului C/C++. De exemplu, tipul int este reprezentat pe 2 byte în unele versiuni şi pe 4 byte în altele. În plus, modul de implementare
poate fi modificat prin utilizarea modificatorilor :
signed - cu semn (pentru char, int, long int )
unsigned - fără semn (pentru char, int, long int )
short - scurt (pentru int )
long - lung (pentru int şi double)
Tabelul nr. 3.2. Tipuri de date întregi
Tip SpaŃiu dememorie ocupat
Domeniu de valori
char = signed char 8 biŃi -128…127
unsigned char 8 biŃi 0…255
short int = signed short int 16 biŃi -32768…32767
int = signed int 16/32 biŃi -32768…32767 /-2147483648…2147483647
unsigned int = unsigned short int 16/32 biŃi 0…65535 / 0…4294967295
long int = signed long int 32 biŃi -2147483648…2147483647
unsigned long int 32 biŃi 0…4294967295
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 52/267
52
Tabelul nr.3.3. Tipuri de date în virgulă mobilă
Tip SpaŃiu de memorieocupat
Domeniu de valori
float 32 biŃi +/-(3.4E-38…3.4E+38)
precizie 7 cifre
double 64 biŃi +/-(1.7E-308…1.7E+308) precizie 15 cifre
long double 80 biŃi +/-(3.4E-4932…1.1E4932) precizie 19 cifre
Exemple
int ordonata, abscisa;unsigned int Lungime;
char caracter;
double RAZA;
long double x, y, z;
ObservaŃii
Variabilele ordonata şi abscisa se vor aloca în memorie, pentru fiecare
utilizându-se câte 2/4 byte (depinde de compilatorul folosit); astfel, ele vor
putea lua valori în intervalul -32768…32767 sau -2147483648…2147483647
Pentru variabila Lungime se alocă tot 2 sau 4 byte de memorie, în funcŃie de
compilatorul folosit, iar domeniul de valori este 0…65535, respectiv
0…4294967295
Pentru variabila caracter se alocă un byte, valorile fiind cuprinse în intervalul
-128…127
Pentru variabila RAZA se alocă 8 byte, valorile fiind cuprinse în intervalul
+/-(1.7E-308…1.7E+308)
Pentru variabilele x, y şi z se alocă 8 sau 10 byte, în funcŃie de compilatorul
utilizat.
Celor cinci tipuri de date fundamentale: char, int, float double, void definite
în limbajul C, limbajul C++ le adaugă încă două, şi anume tipurile bool şi
wchar_t. În prezentul curs vor fi utilizate doar tipurile specifice limbajului C.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 53/267
53
Exemple
/***************************************************************************
Exemplu1 3.1. - Afişarea unor mesaje***************************************************************************/
#include <stdio.h> //directiva de preprocesare - in fişierul stdio.h este definita// functia printf()- functie de afisare
void main(void) //orice program C/C++ trebuie să conŃină o funcŃie main() - cu// ea începe execuŃia programului; funcŃia main() este unică
{ printf("Salut !"); //functia printf() - afiseaza pe ecran sirul de caractere "Salut !"
//şirurile de caractere se încadrează între ghilimele}
/**************************************************************************/
La execuŃia programului se afişează:
/***************************************************************************Exemplu1 3.2. - Afişarea unor mesaje***************************************************************************/
#include <stdio.h>
void main(void){
printf("Salut !"); //functia printf() - afiseaza pe ecran sirul de caractere "Salut !" printf("Salut !"); //functia printf() - afiseaza pe ecran sirul de caractere "Salut !"
}
/**************************************************************************/
La execuŃia programului se afişează:
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 54/267
54
/***************************************************************************Exemplu1 3.3. - Afişarea unor mesaje***************************************************************************/
#include <stdio.h>
void main(void){
printf("Salut !"); printf("\nSalut !"); // secvenŃa \n inclusă în şirul de caractere are ca efect
// mutarea cursorului la începutul rândului următor }
/**************************************************************************/La execuŃia programului se afişează:
/***************************************************************************Exemplu1 3.4. - Afişarea unor mesaje***************************************************************************/
#include <stdio.h>#include <conio.h> // in fişierul conio.h este definita functia getch() - functie
// care citeşte de la tastatură un caracter void main(void){
printf("Salut !"); printf("\nSalut !");getch(); //functia getch() citeşte de la tastatură un caracter
/* caracterul citit este ignorat, funcŃia fiind apelată pentru a întrerupe execuŃia
programului până la apăsarea unei taste; în absenŃa ei, programul se execută, dar utilizatorul nu poate vizualiza mesajele afişate datorită faptului că, odată cu terminarea programului se închide şi fereastra în care au fost afişate mesajele. */
}
/**************************************************************************/
La execuŃia programului se afişează:
(fereastra se închide după apăsarea unei taste)
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 55/267
55
/***************************************************************************Exemplu1 3.5. – Utilizarea comentariilor ***************************************************************************//* Acesta este un comentariu scris pe mai multe linii.
Comentariile sunt ignorate de compilator
*/#include <stdio.h>#include <conio.h>
void main(){
// comentariu pe o linie printf("Primul mesaj !\n"); printf("Al doilea mesaj !\n");getch();return; // instrucŃiunea return încheie execuŃia functiei main()
printf("Al treilea mesaj !\n"); /* aceasta linie nu se va executa deoarecese afla după instrucŃiunea return*/
}/**************************************************************************/La execuŃia programului se afişează:
- comentariile sunt ignorate de compilator, deci elenu produc nici un efect la execuŃia programului;
- instrucŃiunile aflate după instrucŃiunea return(instrucŃiunea return încheie execuŃia funcŃieimain, deci şi a programului) nu sunt executate,astfel că şirul "Al treilea mesaj !\n" nu este afişat
pe ecran.
Rezumat
Pentru realizarea unui program (executabil), programatorul scrie programul
sursă ca fişier text cu extensia .cpp, prin compilare şi link-editare obŃinându-seapoi executabilul;
Numele (identificatorii) folosite într-un program C/C++ sunt formate din
literele alfabetului englez, mici şi mari, cifre şi caracterul underscore (_);
Limbajul C/C++ este case-sensitive;
Există un set de cuvinte rezervate (cuvinte cheie) care au o semnificaŃie
prestabilită care nu poate fi modificată;
SpaŃiile albe sunt ignorate de compilator, dar măresc lizibilitatea programului;
Orice program C/C++ trebuie să conŃină cel puŃin o funcŃie; aceasta se numeştemain() care este unică (nu se poate supradefini).
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 56/267
56
La definirea unei funcŃii se stabileşte numele acesteia, tipul valorii returnată de
aceasta, lista de parametrii; corpul funcŃiei este încadrat între acolade, {…};
Apelul (execuŃia) funcŃiei se face prin numele acesteia însoŃit de paranteze
rotunde, între care se precizează, dacă este cazul, valorile efective ale
parametrilor efectivi;
Pentru folosirea unor funcŃii definite în fişiere bibliotecă (header) se foloseşte
directiva de preprocesare #include;
Pentru definirea de constante cu nume se poate folosi directiva de preprocesare
#define;
La scrierea programelor sursă este util în numeroase situaŃii să se introducă
anumite comentarii; acestea se pot scrie pe un rând (precedate de caracterele //)
sau pe mai multe rânduri (marcate între caracterele /* şi */);
Reprezentarea datelor în limbajul C se face folosind tipurile de datefundamentale: char, int, float şi double;
Tipul fundamental void indică absenŃa oricărei valori;
Numărul de octeŃi folosit în reprezentarea unor date şi domeniul de valori pot
fi modificate prin cuvintele cheie: signed, unsigned, short, long.
Determinarea numărului de octeŃi de memorie folosiŃi pentru stocarea datelor
se poate determina folosind operatorul sizeof.
Test de autoevaluare
1. Un identificator poate conŃine:a. orice caracter afişabil;
b. numai literec. liniuŃa de subliniere (underscor)d. cifree. maxim 10 caractere
2. Următoarele nume de variabile sunt incorecte:a. acesta_este_un_nume; b. a1;c. 1a2b3c;d. abc def;e. _nume;
3. Următoarele nume de variabile sunt incorecte:a. float;
b. variabila;c. MAX;
d. !abc;
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 57/267
57
4. Care dintre următoarele afirmaŃii sunt corecte:a. un identificator poate conŃine litere mici si mari;
b. un identificator poate conŃine orice caracter;c. un identificator nu poate conŃine cifre;d. un identificator poate începe cu caracterul '.' (punct);
e. numarul caracterelor dintr-un identificator nu e limitat.
5. Care dintre următorii identificatori sunt corecŃi:a. a1b2c3;
b. MAIN;c. double;d. raza;e. arie cerc.
6. Care dintre următoarele denumiri reprezintă tipuri de date predefinite:a. double;
b. main;c. char;d. boolean;e. string;
7. Care dintre următoarele afirmaŃii sunt corecte:a. limbajul C/C++ este case-sensitive
b.sizeof reprezintă un tip de date predefinit;c.sizeof este un operator care determină numărul de octeŃi ocupaŃi în
memorie;d. cuvântul void desemnează un tip de date
8. Care dintre următoarele afirmaŃii sunt incorecte:a. orice program în C/C++ trebuie să conŃină o funcŃie main();
b. într-un program C/C++, funcŃia main() poate avea mai multe definiŃiic. corpul unei funcŃii se încadrează între paranteze pătrate […]d. directiva #define se foloseşte pentru definirea tipurilor de date
Întrebări. ExerciŃii. Probleme.1. DescrieŃi componentele şi rolul sistemului de operare.
2. ScrieŃi un program care să afişeze următorul text:
Program EXEMPLU.
Limbajul de programare folosit: C++
Autor: studentul ....
3. ScrieŃi un program care să afişeze un caracter, un şir de caractere, o valoare
numerică întreagă şi o valoare numerică reală.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 58/267
58
Unitatea de învăŃare U.4. CONSTANTE. VARIABILE.
CuprinsIntroducere .................................................................................................................... 58
Obiectivele unităŃii de învăŃare ..................................................................................... 58
U4.1. Constante ............................................................................................................. 59
U4.1.1. Constante întregi ................................................................................... 59
U4.1.2. Constante în virgulă mobilă .................................................................. 60
U4.1.3. Constante caracter ................................................................................. 61
U4.1.4. Constante şir de caractere ..................................................................... 62
U4.2. Variabile .............................................................................................................. 63U4.2.1. DeclaraŃii de variabile ........................................................................... 63
U4.2.2. Atributele variabilelor ........................................................................... 65
U4.2.3. Modificatori de acces ............................................................................ 69
Exemple ........................................................................................................................ 69
Rezumat ........................................................................................................................ 73
Test de autoevaluare ..................................................................................................... 74
Întrebări, exerciŃii şi probleme ...................................................................................... 76
Introducere
Programele prelucrează date care pot fi de diferite tipuri. Unele îşi
păstrează valorile nemodificate pe parcursul execuŃiei programului, purtând
numele de constante. În afara acestora, se vehiculează date introduse de la
tastatură, preluate din fişiere sau sunt obŃinute în urma evaluării unor expresii.
Acestea se stochează în locaŃii de memorie, valorile lor putând fi modificate pe parcursul execuŃiei programului. Ele se numesc variabile.
Constantele şi variabilele se numără printre elementele de bază ale
limbajelor C/C++ . Reprezentarea lor se face în strânsă legătură cu tipurile de date
definite.
Obiectivele unităŃii de învăŃare
După parcurgerea acestei unităŃi de învăŃare trebuie să ştii:
Tipurile şi sintaxa specifice constantelor literale;
SemnificaŃia noŃiunii de variabilă; modul de declarare şi atributele variabilelor; Modificatori de acces ai variabilelor.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 59/267
59
Durata medie de parcurgere a celei de a patra unităŃi de învăŃare este de 2
ore.
U4.1. Constante
Constantele (constante literale) sunt valori fixe (numerice, caractere sau şiruri de
caractere), care nu pot fi modificate în timpul execuŃiei programului. Tipul constantei este
determinat de compilator pe baza valorii şi sintaxei utilizate, putând avea oricare dintre
tipurile predefinite de date. Ele rămân în memorie pe toată durata execuŃiei programului.
U4.1.1. Constante întregi
Tipul constantei este determinat pe baza valorii. Astfel, de exemplu:
dacă valoarea numerică a constantei se încadrează în domeniul de valori al tipului int, atunci
tipul implicit al constantei este int (chiar dacă valoarea ar putea fi reprezentată folosind tipul
char, ca de exemplu 15);
dacă valoarea depăşeşte domeniul tipului int dar se încadrează în domeniul de valori al
tipului long, reprezentarea va fi ca dată long (de exemplu valoarea 99999 este reprezentată ca
dată de tip long);
dacă valoarea constantei depăşeşte domeniul de valori al tipului long, chiar dacă nu conŃine
parte zecimală, ea va fi reprezentată în mod implicit ca o dată de tip double (de exemplu,
constanta 98765432100).
Se poate forŃa preluarea constantei cu alt tip decât cel implicit prin utilizarea unui
sufix (U sau u pentru unsigned, respectiv L sau l pentru long).
Constantele întregi pot fi zecimale (cu reprezentare în baza 10), octale (cu
reprezentare în baza 8) sau hexazecimale (cu reprezentare în baza 16).
Constante zecimale (baza 10)
Constantele zecimale se disting prin faptul că prima cifră este diferită de 0.
Exemple
23 // tip int-555L // tip long int23u // tip unsigned int3276L // tip long int32768 // tip int sau long int, funcŃie de compilatorul folosit32768U // tip unsigned int77UL // tip unsigned long int
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 60/267
60
Constante octale (baza 8)
Constantele octale sunt valori întregi cu reprezentare în baza 8. ConvenŃia de scriere
este ca prima cifră să fie 0 (zero). Fiind vorba de reprezentare în baza 8, cifrele 8 şi 9 sunt
ilegale.
Exemple
-067 // tip int067u // tip unsigned int02000000000 // tip long int055UL // tip unsigned long089 // eroare, prima cifră indică reprezentarea în octal
// şi numărul include cifrele 8 şi 9
Constante hexazecimale (baza 16)Constantele hexazecimale, cu reprezentare în baza 16, se disting prin prefixul 0x sau
0X. Pot conŃine cifre mai mari de 9 (a…f, sau A…F).
Exemple
0x7FFF // tip int0X8A0L // tip long int0xffu // tip unsigned int0x1000L // tip long int0xFFul // tip unsigned long int
U4.1.2. Constante în virgulă mobilă
Constantele în virgulă mobilă sunt valori reale a căror reprezentare conŃine în general
următoarele câmpuri:
parte întreagă
punct zecimal
parte fracŃionară
e sau E şi un exponent cu semn (opŃional)
sufix de specificare a tipului: f sau F (forŃează tipul float) sau l sau L (forŃează
tipul long double).
Se pot omite partea întreagă sau partea fracŃionară (dar nu amândouă), punctul zecimal
sau litera e (E) şi exponentul (dar nu amândouă).
Tipul implicit pentru constantele în virgulă mobilă este tipul double. Se poate forŃa
reprezentarea ca tip float, dacă valoarea se încadrează în domeniul de valori corespunzător,
prin ataşarea sufixului f sau F.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 61/267
61
Exemple
2.1 // valoare 2,1 (tip double)11.22E5 // valoare 11,22 x 105 (tip double)-.33e-2 // valoare –0,33 x 10-2 (tip double).5 // valoare 0,5 (tip double)1. // valoare 1 (tip double)1.f // valoare 1 (tip float)0.L // valoare 0 (tip long double)
U4.1.3. Constante caracter
Constantele caracter sunt reprezentate de unul sau mai multe caractere încadrate de
apostrofuri, de exemplu: ‘a’, ’A’, ’\n’ şi ele sunt de tip char.
Pentru a specifica o serie de caractere neafişabile, delimitatorii (‘), (“), caracterul (\),
etc. se utilizează aşa numitele secvenŃele escape (secvenŃe de evitare) (vezi Tabelul nr. 4.1.)
care sunt formate din caracterul backslash (\) însoŃit de o literă sau o constantă numerică
octală sau hexazecimală. Valoarea numerică corespunde valorii din codul ASCII a
caracterului reprezentat.
Tabelul nr. 4.1. SecvenŃe escape
SecvenŃă Valoare (hexa) Caracter Descriere
\a 0x07 alarm (bell) semnal sonor
\b 0x08 BS backspace\t 0x09 TAB tab orizontal
\n 0x0A LF linefeed
\v 0x0B VT tab vertical
\f 0x0C FF formfeed
\r 0x0D CR carriage return
\” 0x22 ” ghilimele
\’ 0x27 ’ apostrof
\? 0x3F ? semnul întrebării
\\ 0x5C \ backslash
\o - orice caracter şir de cifre octale
\xH - orice caracter şir de cifre hexazecimale
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 62/267
62
Exemplu de utilizare a constantelor caracter
#include <stdio.h>void main(){
putch(’?’); // se afişează caracterul ‘?’ putch(63); // se afişează caracterul ‘?’ , 63 fiind valoarea
// corespunzătoare în codul ASCII printf(“\n%c”,’\077’); // se afişează caracterul ‘?’ printf(“\n%c”,’\x3F’); // se afişează caracterul ‘?’
}
ObservaŃii
Limbajul C++ permite specificarea unor constante alcătuite din două
caractere, reprezentate pe 16 biŃi (tipul int) ca în exemplul care urmează:
‘ab’ // reprezentarea în memorie ca întreg de valoare 25185// sau în hexazecimal 0x62 0x61
‘\t\t’ // reprezentarea în memorie ca întreg de valoare 2313// sau în hexazecimal 0x09 0x09
Primul caracter este memorat în octetul mai puŃin semnificativ.
Constantele duble pot ridica probleme de portabilitate, ele nefiind
recunoscute de alte compilatoare, de aceea este recomandabil a fi evitate.
U4.1.4. Constante şir de caractere
Constantele şiruri de caractere sunt alcătuite dintr-un număr oarecare de caractere,
încadrate între ghilimele.
Şirurile de caractere se memorează în tablouri de tipul char, cu dimensiune egală cu
numărul de caractere cuprinse între ghilimele, la care se adaugă terminatorul de şir ‘\0’.
De exemplu, şirul constant “STRING” este alocat în memorie ca în Fig. 4.1.
Fig. 4.1. Alocarea în memorie a unui şir de caractere constant
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 63/267
63
Caracterele care alcătuiesc şirul pot fi secvenŃe escape:
“\tMesaj 1\n\tMesaj 2”
Şirurile constante adiacente se concatenează şi formează un singur şir:“Programare” “orientata pe””obiecte”
Pentru scrierea şirurilor lungi se poate utiliza simbolul (\) care semnalează continuarea
şirului pe rândul următor:
“Exemplu de sir \scris pe doua rânduri”
ObservaŃii
Reprezentarea în memorie a caracterului ‘a’ este diferită de reprezentarea
şirului “a”. Caracterul este reprezentat pe un octet, în timp ce şirul de
caractere este format din caracterul ’a’ şi caracterul ’\0’, deci ocupă doi
octeŃi în memorie.
U4.2. Variabile
U4.2.1. DeclaraŃii de variabile
Variabila este un identificator asociat cu o locaŃie de memorie în care se memorează
valori ce pot fi modificate pe parcursul existenŃei ei.
Toate variabilele trebuie declarate înainte de a fi folosite.
DeclaraŃia unei variabile (obiect) precizează tipul datei şi numele (identificatorul) cu
care va fi referită, sintaxa fiind:
tip_variabila nume_variabila;
unde:
- tip_variabila este un specificator de tip de date oarecare, standard (char, int, etc.),
pointer sau definit de utilizator.
- nume_variabila este orice identificator care nu a primit altă semnificaŃie în domeniul
de existenŃă al variabilei.
De exemplu, se poate declara o variabilă de tip int cu numele variabila_mea:
int variabila_mea;
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 64/267
64
alocarea ei în memorie fiind reprezentată în Fig. 4.2.
Fig. 4.2. Alocarea unei variabile în memorie
Alte exemple de declarare de variabile:
float r; // declararea variabilei r de tip float,unsigned int n; // declararea variabilei n de tip unsigned int
Se pot face declaraŃii de variabile cu iniŃializare utilizând sintaxa:
tip_var nume_var= valoare_initiala;
sau se pot declara mai multe variabile de acelaşi tip utilizând sintaxa:
tip_var nume_var1<=val_initiala1>,< nume_var2<= val_initiala2>>,...;
Exemple de declare a variabilelor:
int variabila_mea=12000; // declararea unei variabile de tip int iniŃializată cu// valoarea 12000 (vezi Fig. 4.1.)
double real=2.5; // declararea variabilei în virgulă mobilă de tip double,// iniŃializată cu valoarea 2.5
char c1, c2=’a’, ch; // declararea a trei variabile de tip char, c1, c2 şi ch, variabila c2// fiind iniŃializată cu valoarea ‘a’
DeclaraŃia unei variabile are ca efect, la execuŃia programului, rezervarea unui număr
de octeŃi în memorie necesar reprezentării tipului declarat al variabilei. Dacă declaraŃia este cu
iniŃializare, în acea locaŃie se va înscrie valoarea specificată.
ObservaŃii
Adresa de memorie la care se alocă o variabilă nu poate fi precizată de
utilizator, ci compilatorul face alocarea în funcŃie de memoria disponibilă. Utilizatorul poate afla adresa la care a fost alocată o variabilă cu ajutorul
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 65/267
65
operatorului & aplicat numelui variabilei. De exemplu: &variabila_mea
Chiar dacă nu poate impune adresa la care se alocă o variabilă, prin locul în
program în care se face declaraŃia sau specificatorii folosiŃi, utilizatorul poate
stabili zona de memorie în care se face alocarea.
U4.2.2. Atributele variabilelor
Atributele unei variabile sunt:
tipul datei poate fi tip fundamental sau definit de utilizator şi determină
structura, gama de valori, dimensiunea spaŃiului ocupat în memorie;
clasa de memorare stabileşte zona de memorie în care se va plasa informaŃia
asociată identificatorului (segment de date, registru, stivă, heap) şi delimitează
durata sa de alocare;
domeniul reprezintă porŃiunea de program în care poate fi accesată informaŃia
asociată identificatorului, el fiind determinat de poziŃia declaraŃiei;
durata de viaŃă a identificatorului reprezintă perioada cât există efectiv în
memorie şi este corelată cu clasa de memorie;
legătura precizează modul de asociere a unui identificator cu un anumit obiect
sau funcŃie, în procesul de editare a legăturilor.
Atributele se pot asocia identificatorilor în mod implicit, în funcŃie de poziŃia şi
sintaxa declaraŃiei, sau explicit prin utilizarea unor specificatori.
PoziŃia declaraŃiei determină cele două domenii de existenŃă fundamentale: Domeniul bloc (local) - Identificatorii cu domeniu bloc se numesc locali şi
sunt rezultatul unor declaraŃii în interiorul unui bloc (au domeniul cuprins între
declaraŃie şi sfârşitul blocului) sau sunt parametrii formali din definiŃia unei
funcŃii (au ca domeniu blocul funcŃiei).
Domeniul fişier (global) - Identificatorii cu domeniu fişier se numesc globali
şi sunt declaraŃi în afara oricăror funcŃii (domeniul este cuprins între declaraŃie
şi sfârşitul fişierului).
#include <stdio.h>
// zona declaraŃiilor globalefloat functie (int, float); // prototipul funcŃieiint a; // se declară variabila cu numele a, căreia i se rezervă o zonă de
// memorie de 2/4 octeŃi (16/32 biŃi) localizată în segmentul de// date, deoarece declaraŃia se află în zona declaraŃiilor globale
// definiŃii de funcŃiivoid main (void){ unsigned char c; // se declară variabila automatică cu numele c căreia i se rezervă
// un octet în segmentul de stivă, variabila fiind o variabilă// locală
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 66/267
66
float r=2.5; // se declară variabila automatică cu numele r căreia i se rezervă// 4 octeŃi în segmentul de stivă, variabila fiind o variabilă locală
//… // care este iniŃializată cu valoarea 2.5}
float functie (int n, float q) // se declară variabilele locale n şi q, cărora li se alocă 2,{ // respectiv 4 octeŃi în segmentul de stivăa=100; // variabila a este declarată global, deci poate fi utilizată
// de orice funcŃie definită în fişier r=1.5 *a; // eroare, variabila r nu poate fi folosită în funcŃie(), ea
// fiind declarată local funcŃiei main(), deci nu poate fi// referită decât în aceasta
//…}
ObservaŃii
Într-un bloc inclus în domeniul unei declaraŃii este permisă o declaraŃie
locală a aceluiaşi identificator, asocierea fiind însă făcută unui alt obiect cu
alocarea altei zone de memorie.
Spre deosebire de C, care impune gruparea declaraŃiilor locale la începutul
unui bloc, C++ permite plasarea declaraŃiilor în interiorul blocului,
bineînŃeles înainte de utilizarea obiectului
void main (void){…
for (int i=5; i<8; i++) // declararea lui i este imediat urmată de utilizarea sa{…}
for {i=0; i<5; i++) // i a fost declarat anterior {…}
…}
Clasa de memorare se poate preciza prin specificatorii auto, static, extern, register.
Aceşti specificatori precizează modul de alocare a memoriei şi timpul de viaŃă pentru
variabile şi legătură pentru funcŃii şi variabile.
auto
DeclaraŃia auto specifică o variabilă automatică şi se poate utiliza pentru variabile cu
domeniul local (cu spaŃiu alocat pe stivă). Variabilele ce se declară în interiorul unui bloc sunt
implicit automatice, astfel că declaraŃia auto este rar folosită.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 67/267
67
void fct(){
auto float r; // declararea unei variabile automatice cu declarare// explicită
double s; // declararea unei variabile implicit automatică
...}
static
DeclaraŃia static a unei variabile locale forŃează durata statică fără a modifica
domeniul de utilizare. Variabilele statice îşi păstrează valoarea între două apeluri succesive
ale blocurilor care le conŃin, asigurându-se în acelaşi timp o protecŃie, dar ele nu pot să fie
accesate din blocuri care nu constituie domeniul lor de existenŃă. Variabilele statice pot fi
declarate cu iniŃializare, în caz contrar, implicit se iniŃializează cu valoarea 0, similar
variabilelor globale.
#include <stdio.h>
int fct(){
static int a=2; // se declară o variabilă locală funcŃiei, cu durată staticăreturn (a++);
}void main(void){
int n;n=fct();
printf („\n Prima atribuire : n= %d”, n);n=fct();
printf („\n A doua atribuire : n= %d”, n);}
Programul afişează:
Prima atribuire : n= 3 // la primul apel al funcŃiei, variabila a are valoarea// iniŃială 2, ea fiind apoi incrementată
A doua atribuire : n= 4 // la al doilea apel al funcŃiei, variabila a are la// început valoarea 3 (valoare datorată apelului// anterior al funcŃiei), valoarea fiind apoi// incrementată
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 68/267
68
register
DeclaraŃia register are ca efect memorarea variabilei într-un registru al procesorului şi
nu în memorie, având ca rezultat creşterea vitezei de execuŃie a programului. Aceste
variabilele pot fi variabile locale, nestatice, de tip int sau char. Numai două variabile pot fi
memorate simultan în registre, în cazul existenŃei mai multor declaraŃii register, cele care nu pot fi onorate vor fi tratate de compilator ca variabile obişnuite.
register char c; // declararea variabilei c cu memorare într-un registru al// procesorului
extern
Specificatorul extern indică legătura externă şi asigură durata statică pentru variabile
locale şi globale sau pentru funcŃii (acestea au implicit legătură externă şi durată statică).Pentru identificatorii cu legătură externă sunt permise mai multe declaraŃii de
referinŃă, dar o singură definiŃie. De exemplu, în cazul unui proiect în care o variabilă se
foloseşte în mai multe fişiere, ea se va defini global într-un fişier, în celelalte fiind declarată
extern fără definire. Compilatorul îi va aloca o singură dată memorie.
Ca exemplu, se consideră programul format din două fişiere sursă Ex_prj.cpp şi
Ex_prj1.cpp. Variabila m declarată în fişierul Ex_prj1.cpp este folosită în fişierul Ex_prj.cpp
prin realizarea legăturii externe pentru această variabilă.
// Fişier Ex_prj.cpp
#include <stdio.h>
extern int m; // se declară legătură externă pentru variabila m
void main(void){…
scanf(“%d”, &m);
printf(“\nm= %#x”, m);…}// Fişier Ex_prj1.cpp...int m ; // declaraŃia variabilei m…
În exemplul anterior, cele două fişiere, Ex_prj.cpp şi Ex_prj1.cpp, se includ într-un
proiect utilizând opŃiunea “project” a meniului principal din mediul de programare C/C++.
Variabila m este declarată global într-unul dintre fişiere, ea putând fi referită din celălalt fişier datorită specificării legăturii “extern” .
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 69/267
69
U4.2.3. Modificatori de acces
Modificatorii de acces ce pot fi utilizaŃi sunt const şi volatile şi ei pot controla modul
de modificare a unei variabile.
constVariabilele const (constante cu nume) nu pot fi modificate pe parcursul execuŃiei unui
program. InstrucŃiunile care încearcă modificarea variabilelor const generează erori la
compilare.
const int a=99; // declaraŃia variabilei a consta++; // eroare, a nu se poate modifica fiind declarat consta=5; // eroare, a nu se poate modifica fiind declarat const
ObservaŃii
Variabilele const sunt în mod frecvent folosite atunci când:
în program se utilizează valori constante în mod repetat, fiind mai
comod să fie precizate prin numele lor;
se doreşte protejarea parametrilor funcŃiilor care au fost transferaŃi
prin adresă sau referinŃă.
volatile
Variabilele volatile pot fi modificate din exteriorul programului (de exemplu servirea
unei întreruperi).
Exemple
/***************************************************************************
Exemplul 4.1. - Se scrie un program în care se afişează informaŃii referitoare la variabile.
Se afişează valoarea, adresa şi numărul de octeŃi ocupaŃi în memorie de către
variabile.
***************************************************************************/
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 70/267
70
#include <stdio.h>#include <conio.h>
void main(void){
int a=10, b=20; // declararea a două variabile cu iniŃializare
printf("\na = %d, &a = %u, sizeof(a) = %d", a, &a, sizeof(a));
printf("\nb = %d, &b = %u, sizeof(b) = %d", b, &b, sizeof(b));
getch();}
***************************************************************************/
La execuŃia programului se afişează:
- valoarea afişată pentru variabile este valoarea de iniŃializare;
- adresa de memorie la care este alocată o variabilă poate fi aflată cu ajutorul operatorului &
(adresă);
- numărul de octeŃi utilizaŃi în reprezentarea unei variabile se poate afla cu ajutorul
operatorului sizeof; numărul de octeŃi alocaŃi unei variabile este determinat de tipul variabilei
(în cazul de faŃă tipul celor două variabile este int – se reprezintă pe 4 octeŃi).
Se afişează numărul deocteŃi utilizaŃi înreprezentarea variabilei a
Adresavariabilei a
Valoareavariabilei a
Se afişează numărul deocteŃi utilizaŃi înreprezentarea variabilei b
Adresavariabilei b
Valoareavariabilei b
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 71/267
71
/***************************************************************************Exemplul 4.2. - Se scrie un program în care :
- se definesc funcŃii de calcul al ariei şi lungimii unui cerc.- în funcŃia main se va exemplifica folosirea funcŃiilor
***************************************************************************/
#include <stdio.h>#include <conio.h>
#define PI 3.1415
float aria(float);float lungime(float);
int r = 5;
void main(void){
float raza, a, l;
printf("\nIntroduceti valoarea razei: ");scanf("%f", &raza);
a = aria(raza);l = lungime(raza);
printf("\nCercul are:"); printf("\nraza = %f ", raza); printf("\naria = %f ", a); printf("\nlungimea = %f", l);
printf("\nCercul are:"); printf("\nraza = %f ", r); printf("\naria = %f ", aria(r)); printf("\nlungimea = %f", lungime(r));
getch();
}
float aria(float r){ float a;
a = PI * r * r;return a;
}
float lungime(float r){ float l;
l = 2 * PI * r;
return l;}
I. Zonadirectivelor de
preprocesare
II. ZonadeclaraŃiilor globale
III. DefiniŃii defuncŃii
DeclaraŃii localefuncŃiei main()
SecvenŃă deinstrucŃiuni
DeclaraŃie localăfuncŃiei aria()
DeclaraŃie localăfuncŃiei lungime()
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 72/267
72
/***************************************************************************Exemplul 4.3. - Se scrie un program în care se exemplifică atributele variabilelor :
- clasa de memorare- domeniu- durata de viaŃă
***************************************************************************/
#include <stdio.h>#include <conio.h>
int a=5;
void f1(void){ printf("\na=%d",a);
}
void f2(void){
int a=7;
printf("\na=%d", a);}
void main(){
int b=10, c=20;
printf("\na=%d, b=%d, c=%d", a, b, c);
{int b=100, d=1000;
printf("\na=%d, b=%d, c=%d, d=%d", a, b, c, d);
} printf("\na=%d, b=%d, c=%d", a, b, c); printf("\na=%d, b=%d, c=%d, d=%d", a, b, c, d); //- eroare, variabila d nu mai exista
puts("\nSe executa functia f1");f1();
puts("\nSe executa functia f2");f2();
}
variabilă globală- alocată în segmentul de date- durata de viaŃă - execuŃia programului
variabilă locală - alocată pe stivă- durata de viaŃă - execuŃia funcŃiei- domeniu: funcŃia
variabile locale funcŃiei main()- alocate pe stivă- durata de viaŃă - funcŃia main()- domeniu: funcŃia main()
variabile locale blocului de instrucŃiuni- alocate pe stivă- durata de viaŃă - execuŃia blocului de instrucŃiuni- domeniu: blocul de instrucŃiuni
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 73/267
73
/***************************************************************************Exemplul 4.4. - Exemplu de folosire a variabilelor statice
***************************************************************************/
#include <stdio.h>#include <conio.h>
void func(void){
int a=10;
static int b=10;
a=a+1; b=b+1;
printf("\na=%d, b=%d", a, b);}
void main(){
func();func();func();
getch();}
/**************************************************************************/
Rezumat
Constantele sunt valori fixe (numerice, caractere sau şiruri de caractere), care
nu pot fi modificate în timpul execuŃiei programului.
Constantele pot fi introduse caracter cu caracter (constante literale) sau se pot
folosi constante cu nume.
Constantele literale corespund tipurilor de date predefinite (char, int, float,
double).
Constantele numerice se pot exprima ca întregi, reprezentaŃi în decimal, octal
sau hexazecimal) sau în virgulă mobilă, în simplă sau dublă precizie.
Constantele caracter se pot specifica prin caractere afişabile încadrate între
apostrofe (‘X’) sau prin secvenŃe escape în cazul caracterelor neafişabile.
Constantele şir de caractere sunt alcătuite dintr-un număr oarecare de caractere,
încadrate între ghilimele; ele se memorează în tablouri cu elemente de tip char,
cu dimensiune egală cu numărul de caractere cuprinse între ghilimele, la care seadaugă terminatorul de şir ‘\0’.
variabilă locală automatică- alocată pe stivă- durata de viaŃă-execuŃia funcŃiei- domeniu: funcŃia
variabilă locală statică- alocată în segmentul de date
- durata de viaŃă - execuŃia programului- domeniu: funcŃia
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 74/267
74
Variabilele sunt identificatori asociaŃi cu locaŃii de memorie în care se
memorează valori ce pot fi modificate pe parcursul existenŃei lor.
Adresa la care a fost alocată o variabilă se poate determina cu ajutorul
operatorului & aplicat numelui variabilei, iar numărul de octeŃi rezervaŃi pentru
variabilă se determină cu operatorul sizeof.
Atributele variabilelor (clasa de memorare, domeniu, durată de viaŃă) se
stabilesc în mod implicit, în funcŃie de poziŃia şi sintaxa declaraŃiei.
DeclaraŃiile globale (făcute în afara oricărei funcŃii) au ca domeniu întregul
fişier, ele putând fi folosite din oricare funcŃie definită în fişier.
DeclaraŃiile din interiorul unui bloc se numesc declaraŃii locale şi au domeniul
cuprins între declaraŃie şi sfârşitul blocului.
DeclaraŃia static a unei variabile locale forŃează durata statică fără a modifica
domeniul de utilizare. Variabilele const (constante cu nume) nu pot fi modificate pe parcursul
execuŃiei unui program. DeclaraŃia se face cu iniŃializare.
Test de autoevaluare
1. Constantele următoare au tipurile specificate:a. 40000 este de tip int;
b. -12L este de tip long;c. 1.2 este de tip float;d. 123 este de tip char;e. "eroare" este un sir de caractere.
2. Care dintre următoarele specificări reprezintă o constanta:a. A7B3;
b. 0xA7B3;c. 077;d. 'm';
e. UL12;
3. Care dintre următoarele specificări reprezintă o constanta:a. 0ABC;
b. "mesaj";c. 077;d. 'abc';e. 12UL;
4. Declaratia de variabile se poate face:a. in afara oricărei funcŃii;
b. numai in interiorul funcŃiilor;c. numai cu initializare;
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 75/267
75
5. Declaratia unei variabilea. constă in descrierea numelui si tipului său b. constă in utilizarea datei intr-o expresie (exemplu: a=(25-a)/12;)c. se face numai pentru constanted. determina rezervarea unei locaŃii de memorie
e. presupune obligatoriu iniŃializarea cu valoarea zero a datelor
6. Declaratia de variabile se poate face astfel:a. unsigned int ui;
b. var double;c. char c1, c2;d. int a=9; b; c;
7. Declaratia de variabile se poate face:a. in afara oricărei funcŃii sau in interiorul funcŃiilor;
b. numai in interiorul funcŃiilor;
c. numai cu initializare;d. cu sau fără initializare;
8. Care dintre următoarele declaratii de variabile sunt corecte:a. var1, var2, var3;
b. long double p="xyz";c. char a='x', b='y';d. int m=n=5;
9. Care dintre propoziŃiile următoare sunt adevărate:a. adresa unei variabile se poate modifica pe parcursul execuŃiei
programului; b. valoarea unei variabile se poate modifica pe parcursul execuŃiei programului;
c. o variabila declarata cu initializare nu îşi poate schimba valoarea;d. tipul unei variabile determina numarul de octeti ocupaŃi in
memorie de către aceasta.
10. Declaratia: int a=27;care apare intr-un program C are semnificaŃia:
a. valoarea lui a va fi 27 pe tot parcursul execuŃiei programului b. se rezervă spaŃiu in memorie pentru variabila ac. variabila a este iniŃializată cu valoarea 27, aceasta putând fi modificata
pe parcursul execuŃiei programuluid. aceasta declaraŃie nu e permisa, ea trebuind să fie făcută astfel:
int a; a=27;
11. Care din expresiile de mai jos sunt permise intr-un program C?a. int a=25; a%=5;
b. char d; d='&';c. int a; &a=0x2000;d. const float e=2.71; e+=1.41;
e. #define PI 3.141PI=3.141592653
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 76/267
76
12. Care din expresiile de mai jos sunt permise intr-un program C?a. float a=25; a%=5;
b. char d; d=”&”;c. int a; a=0x2000;d. const float e=2.71; double x=2.5*e;
e. #define PI 3.1415double PI=3.14;
Întrebări. ExerciŃii. Probleme.
1. Folosind Exemplul 4.2., să se scrie un program în care se definesc funcŃii decalcul al ariei, şi respectiv al perimetrului unui dreptunghi. (ObservaŃii:FuncŃiile vor avea câte doi parametri, corespunzători celor două laturi ale
dreptunghiului).
2. Folosind Exemplul 4.2., să se scrie un program în care se definesc funcŃii decalcul pentru arii laterale şi volum pentru diferite corpuri, cum ar fi
paralelipiped, con, cilindru, etc.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 77/267
77
Unitatea de învăŃare U.5. OPERAłII DE INTRARE/IEŞIREPENTRU CONSOLĂ
Cuprins
Introducere .................................................................................................................... 77
Obiectivele unităŃii de învăŃare ..................................................................................... 79
U5.1. OperaŃii I/O la nivel de caracter .......................................................................... 79
U5.2. FuncŃii pentru operaŃii I/O pentru şiruri de caractere .......................................... 80
U5.3. OperaŃii de citire/scriere cu formatare ................................................................ 82
Exemple ........................................................................................................................ 89
Rezumat ........................................................................................................................ 93Test de autoevaluare ..................................................................................................... 94
Întrebări, exerciŃii şi probleme ...................................................................................... 98
Introducere
În C/C++, spre deosebire de alte limbaje, operaŃiile de intrare/ieşire (I/O –
Input/Output) nu se efectuează pe baza unui tip de date dedicat şi a unor funcŃii
încorporate în limbaj. Sistemul de intrare/ieşire nu este parte a limbajului, ci seadaugă printr-un set de funcŃii din biblioteca standard, ceea ce oferă
programatorului un sistem I/O flexibil şi puternic. Acest lucru asigură o bună
portabilitate programelor C/C++, prin folosirea librăriilor de funcŃii specifice, ele
pot fi compilate pentru diferite sisteme de operare.
Transferurile de date cu dispozitivele fizice de intrare/ieşire (consolă, disc,
imprimantă, etc.) se fac prin intermediul sistemului de operare şi al unor
dispozitive logice identice numite stream (flux). Detaliile funcŃionale ale
dispozitivelor fizice pot fi ignorate la nivelul programului C/C++, ele trebuind săfie cunoscute doar la nivelul sistemului de operare care comandă efectiv
dispozitivele prin intermediul unor rutine dedicate.
OperaŃiile de intrare/ieşire se efectuează prin funcŃii din biblioteca C/C++,
declarate (majoritatea) în fişierul stdio.h. C++ dispune suplimentar de un sistem
propriu, realizat pe principiile POO (Programării Orientate pe Obiecte), dar acest
aspect nu face obiectul acestei prezentări.
Datorită nivelului de abstractizare introdus de fluxuri, programatorul
utilizează acelaşi set de funcŃii din biblioteca C/C++, indiferent de dispozitivul
fizic cu care comunică efectiv. Deşi dispozitivele logice sunt identice, dispozitivele
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 78/267
78
fizice cărora le sunt asociate diferă din punct de vedere al tipului de operaŃie de I/O
care poate fi efectuată. De exemplu, tastatura este un dispozitiv de intrare,
monitorul sau imprimanta sunt numai dispozitive de ieşire, o unitate de disc poate
efectua operaŃii de citire/scriere pe disc, cu acces aleator la date, dar o unitate de
bandă magnetică poate accesa informaŃia, pentru scriere sau citire numai
secvenŃial.
Se disting două tipuri de streamuri:
streamuri de tip text – care transferă secvenŃe de caractere organizate în linii. În
C, separarea liniilor se face prin caracterul linie nouă (LF – 0AH). Pentru
adaptarea la dispozitiv poate fi necesară o conversie (secvenŃa 0DH se înlocuieşte
cu 0DH 0AH la scrierea textului pe disc). Din acest motiv, numărul de caractere
transferate către stream poate fi diferit de numărul de caractere din dispozitivul
fizic. streamuri binare - transferă o secvenŃă de octeŃi fără nici o structură, deci fără
alte prelucrări.
Distingerea dintre cele două categorii este convenabilă, dar nu obligatorie.
Există 5 dispozitive logice predefinite care se creează automat la lansarea
în execuŃie a programului şi sunt închise automat la terminarea execuŃiei:
stdin – stream de tip text - reprezintă intrarea standard, care este asociată cu
tastatura; poate fi redirectat de către sistemul de operare.
stdout – stream de tip text – reprezintă ieşirea standard care e asociată cumonitorul; poate fi redirectat de către sistemul de operare.
stderr - stream de tip text – reprezintă ieşirea standard pentru erori şi e asociată,
de asemenea, cu monitorul.
strprn – stream de tip binar – reprezintă ieşirea standard la imprimantă, asociată
dispozitivului DOS PRN.
stdaux – stream de tip binar – reprezintă intrare/ieşire auxiliară, asociată
dispozitivului DOS AUX.
Cei 5 identificatori sunt constante de tip FILE * (definit în fişierul stdio.h).Pentru stream-urile utilizate se alocă o zonă de memorie tampon prin
intermediul căreia se vor efectua transferurile.
FuncŃiile destinate operaŃiilor I/O definite în biblioteca standard pot fi, fie
destinate unui dispozitiv predefinit, cum ar fi de exemplu funcŃia getch() care
citeşte un caracter de la tastatură (stdin), sau funcŃia printf() care afişează
informaŃie pe ecran (stdout), fie funcŃii, care, prin intermediul parametrilor, pot
direcŃiona operaŃiile I/O către un dispozitiv sau altul, cum ar fi de exemplu funcŃia
fscanf() care citeşte date de la un dispozitiv precizat ca parametru, cum ar fi un
fişier, dar şi stdin.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 79/267
79
În continuare se va face referire la operaŃiile I/O pentru consolă.
FuncŃiile de intrare/ieşire pentru consolă utilizează implicit dispozitivele
predefinite stdin (tastatură) şi stdout sau stderr (ecran).
Unele funcŃii de intrare/ieşire sunt destinate unui anumit tip de date, cum ar
fi char sau int, altele pot efectua operaŃii cu oricare tip de date fundamental prin
precizarea formatului specific fiecărui tip.
Obiectivele unităŃii de învăŃare
După parcurgerea acestei unităŃi de învăŃare trebuie să ştii:
GeneralităŃi privind operaŃiile de intrare/ieşire (I/O);
FuncŃii pentru operaŃii I/O cu caractere;
FuncŃii pentru operaŃii I/O cu şiruri de caractere; FuncŃii pentru operaŃii I/O cu formatare.
Durata medie de parcurgere a celei de a cincia unităŃi de învăŃare este de 2
ore.
U5.1. OperaŃii la nivel de caracter FuncŃii pentru operaŃii de citire a unui caracter:
Pentru citirea unui caracter din stdin pot fi folosite următoarele funcŃii:
int getchar(void); // definită în stdio.h
FuncŃia întoarce primul caracter din stdin, corespunzător primei taste apăsate, dar după
ce s-a apăsat tasta Enter (CR). Caracterul este transformat în întreg fără semn. În caz de
eroare, întoarce constanta EOF care are valoarea -1.
int getche(void); // definită în conio.h;FuncŃia aşteaptă apăsarea unei taste, întoarce caracterul corespunzător şi îl afişează pe
ecran (nu aşteaptă apăsarea tastei Enter).
int getch(void); // definită în conio.h;
FuncŃia aşteaptă apăsarea unei taste, întoarce caracterul corespunzător dar nu îl
afişează pe ecran (nu aşteaptă apăsarea tastei Enter).
Exemple de folosire a funcŃiilor de citire a unui caracter:
char ch; // se declară variabila ch care poate primi valoarea citită prin una// din funcŃiile de citire a unui caracter
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 80/267
80
ch=getchar(); // funcŃia getchar() întoarce valoarea caracterului tastat, aceasta// e preluată de variabila ch, dar numai după apăsarea tastei// Enter; caracterul este afişat pe ecran
ch=getche(); // funcŃia getche() întoarce valoarea caracterului tastat, aceasta// e preluată de variabila ch, fără a aştepta apăsarea tastei
// Enter; caracterul este afişat pe ecranch=getch(); // funcŃia getch() întoarce valoarea caracterului tastat, aceasta// e preluată de variabila ch, fără a aştepta apăsarea tastei// Enter; caracterul nu este afişat pe ecran
getch(); // funcŃia getch() întoarce valoarea caracterului tastat fără ca această// valoare să fie utilizată; această instrucŃiune se foloseşte de regulă// pentru a întrerupe temporar evoluŃia programului până la apăsarea// unei taste; caracterul nu este afişat pe ecran
FuncŃii pentru operaŃii de afişare a unui caracter:
Pentru scrierea unui caracter la stdout se folosesc funcŃiile:
int putchar(int c); // definită în stdio.h
int putch(int c); // definită în conio.h
FuncŃiile transferă un caracter către stdout (îl afişează pe ecran) şi întoarce ca rezultat
caracterul transmis în caz de succes, sau EOF în caz de eşec.
Exemple de folosire a funcŃiilor de afişare a unui caracter:
char ch=’a’; // se declară variabila ch care poate primi valoarea citită prin una// din funcŃiile de citire a unui caracter
putch(’x’); // se afişează caracterul constant ‘x’ putchar(’y’); // se afişează caracterul constant ‘y’ putch(ch); // se afişează conŃinutul variabilei ch, caracterul ‘a’ putch(’\n’); // caracterul constant ‘\n’ (newline) nu este afişabil, dar mută
// cursorul pe linia următoare putchar(’\r’); // caracterul constant ‘\r’ (CR-carriage return) nu este afişabil, dar
// mută cursorul la începutul rândului putchar(99); // se afişează caracterul constant cu valoarea 99 în codul ASCII,
// caracterul ‘c’
putchar(0x63); // se afişează caracterul constant cu valoarea 0x63 în codul// ASCII, caracterul ‘c’
U5.2. FuncŃii pentru operaŃii I/O pentru şiruri de caractere
OperaŃii de citire a şirurilor de caractere:
char * gets(char * s); // definită în stdio.h
FuncŃia citeşte caractere din stdin şi le depune în tabloul de la adresa s până întâlneşte
caracterul ’\n’ (apăsarea tastei Enter). În şir ’\n’ este înlocuit cu terminatorul de şir ’\0’ . DacăoperaŃia se încheie cu succes, funcŃia întoarce adresa şirului (egală cu valoarea parametrului),
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 81/267
81
altfel întoarce valoarea NULL.
OperaŃii de afişare a şirurilor de caractere:
int puts (const char * s); // definită în stdio.hFuncŃia copiază la stdout (pe ecran) şirul de la adresa s şi trece la linie nouă. În caz de
succes întoarce ultimul caracter, altfel întoarce valoarea EOF.
ObservaŃii
În C/C++ şirurile de caractere nu sunt definite printr-un tip de date
predefinit, ci sunt construite ca tablouri cu elemente de tip char. Sunt
formate din succesiuni de caractere încheiate cu caracterul ‘\0’ (valoarea
zero în codul ASCII).
Un şir de caractere se declară cu sintaxa :
char nume_sir[numar_caractere];
DeclaraŃia se poate face şi cu iniŃializare.
Numele şirului de caractere reprezintă adresa de memorie la care a fost
alocat şirul, tipul datei fiind char * (pointer de char).
Aspecte specifice lucrului cu şiruri de caractere vor fi reluate în capitolele
destinate tablourilor de date, şi particularizările acestora ca şiruri de
caractere.
Exemple de folosire a funcŃiilor I/O pentru şiruri de caractere:
char sir1[30]="primul sir"; // declararea şirului sir1 cu iniŃializarechar sir2[30]="al doilea sir"; // declararea şirului sir2 cu iniŃializare
puts("sir1:"); // afişarea şirului constant “sir1:” puts(sir1); // afişarea conŃinutului şirului sir1, se afişează
// conŃinutul iniŃial puts("sir2:"); // afişarea şirului constant “sir2:” puts(sir2); // afişarea conŃinutului şirului sir2, se afişează
// conŃinutul iniŃial puts("\nIntrodu un sir de caractere:");gets(sir1); // se citeşte de la tastatură conŃinutul şirului sir1
puts("\nIntrodu un sir de caractere:");gets(sir2); // se citeşte de la tastatură conŃinutul şirului sir2
puts("sir1:"); puts(sir1); // afişarea conŃinutului şirului sir1, se afişează
// conŃinutul introdus de la tastatură puts("sir2:");
puts(sir2); // afişarea conŃinutului şirului sir2, se afişează// conŃinutul introdus de la tastatură
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 82/267
82
U5.3. OperaŃii de citire/scriere cu formatare
În cazul unei operaŃii de citire, formatarea constă în conversia datelor de la
reprezentarea lor externă (la dispozitivul de intrare) la reprezentarea internă, binară. Pentru o
operaŃie de ieşire (scrie) se efectuează conversia inversă.
Datele sunt introduse de la tastatură sub forma unor şiruri de caractere ASCII,
corespunzătoare tastelor apăsate şi sunt separate de spaŃiere (spaŃiu, tab, linie nouă, etc.). De
exemplu, în cazul datelor numerice este necesară transformarea şirului de coduri ASCII de
cifre, punct zecimal, etc., în reprezentarea binară a valorii numerelor. O operaŃie inversă este
necesară pentru afişarea valorii pe ecran, deoarece dispozitivul de ieşire consolă aşteaptă un
şir de coduri ASCII pe baza cărora creează imaginea de pe ecran.
În plus, formatarea permite controlul afişării pe ecran (numărul de spaŃii alocate,
numărul de zecimale, etc.) şi al introducerii datelor (numărul de caractere alocate).
Citirea datelor cu formatare
scanf(); // definită în stdio.h
Prototipul funcŃiei este:
int scanf(const char* sir_de_formatare, [lista_adrese_variabile]);
unde : - sir_de_formatare – conŃine caractere ASCII şi specificatori de format.
- valoarea returnată de funcŃie reprezintă numărul câmpurilor a căror citire s-a
realizat corect.- lista_adrese_variabile – precizează adresele de memorie la care sunt memorate
valorile introduse de la tastatură.
Pentru ca operaŃia de intrare să se realizeze corect, trebuie ca numărul de formate
precizate în şir_de_formatare şi numărul adreselor în lista_adrese_variabile să fie acelaşi şi
tipurile precizate prin formate să corespundă tipurilor obiectelor ce se găsesc la adresele
precizate.
Afişarea datelor cu formatareprintf(); // definită în stdio.h
Prototipul funcŃiei este:
int printf(const char* sir_de_formatare, [lista_valori]);
unde: - sir_de_formatare – conŃine caractere ASCII şi specificatori de format.
- valoarea returnată de funcŃie reprezintă numărul caracterelor afişate.
- lista_valori – reprezintă o înşiruire de expresii care returnează valori, cum ar fi
nume de variabile, apeluri de funcŃii, expresii aritmetice, etc.
Pentru ca operaŃia de afişare să se realizeze corect, trebuie ca numărul de formate
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 83/267
83
precizate în şir_de_formatare şi numărul expresiilor din lista_valori să fie acelaşi şi tipurile
precizate prin formate să corespundă tipurilor expresiilor.
Dacă lista de adrese sau de valori conŃin mai multe expresii decât formatele din şirul
de formatare, adresele sau valorile cărora nu le corespund formate vor fi ignorate. Dacă însă
în şirul de formatare există formate care nu au corespondent adresă, respectiv valoare, fie se
vor afişa valori aleatoare, fi se poate produce o eroare fatală care blochează execuŃia
programului.
Regulile de alcătuire a şirurilor de formatare şi sintaxa celor două funcŃii, scanf() şi
printf(), sunt similare.
Specificatorii de format încep cu caracterul % şi sunt definiŃi pentru toate tipurile
predefinite de date. În tabelul nr. 5.1. sunt prezentate formatele pentru fiecare tip de date.
Aceste secvenŃe pot fi completate cu modelatori de format.
Tabel nr. 5.1. Specificatori de format
Cod SemnificaŃie
%c caracter, tipul char
%d număr întreg zecimal
%i număr întreg zecimal
%u număr întreg fără semn
%o număr întreg reprezentat în octal
%x număr întreg reprezentat în hexazecimal, se folosesc cifrele a,b,c,d,e,f
%X număr întreg reprezentat în hexazecimal, se folosesc cifrele A,B,C,D,E,F
%f număr în virgulă mobilă
%e număr în virgulă mobilă, format ştiinŃific, e pentru exponent
%E număr în virgulă mobilă, format ştiinŃific, E pentru exponent%g număr în virgulă mobilă, format ştiinŃific, e pentru exponent
%G număr în virgulă mobilă, format ştiinŃific, E pentru exponent
%s şir de caractere
%p adresă de memorie reprezentată în hexazecimal
%[ ] Caută un set de caractere
%n Primeşte o valoare egală cu numărul de caractere citite până atunci
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 84/267
84
Specificatorii de format pot fi însoŃiŃi de modelatori de format, cum ar fi:
specificator pentru mărimea câmpului – un întreg care determină numărul de caractere
ale câmpului
specificator de precizie – urmează după specificatorul pentru mărimea câmpului şi constă
în punct urmat de un întreg
modelatorul + - forŃează afişarea semnului plus (+) dacă se afişează valoare pozitivă
(afişarea semnului minus se face în mod implicit pentru valori negative)
modelatorul - - forŃează alinierea la stânga a câmpului afişat
modelatorul * - se foloseşte pentru rezervarea unui loc pentru un argument
modelatorul # - se afişează punctul zecimal pentru valori reprezentate în virgulă
mobilă care nu au parte zecimală
- se afişează cifra 0 pe prima poziŃie a unui întreg octal
- se afişează 0x la începutul unui întreg hexazecimalSe consideră exemplul următor în care se declară două variabile, una int, cealaltă float.
Se citesc valori de la tastatură pentru ambele variabile folosind funcŃia scanf() şi apoi se
afişează valorile preluate de cele două variabile folosind funcŃia printf().
int a;float b;scanf(“%d, %f”, &a, &b);
printf(“\na = %d, \t b = %f”, a, b);
Descrierea sintaxei folosită pentru apelul funcŃiei scanf() este făcută în Fig. 5.1, iar cea
a apelului funcŃiei printf() în Fig. 5.2.
Fig.5.1. Sintaxa apelului funcŃiei scanf()a.) descrierea parametrilor efectivi ; b.) corespondenŃa dintre formatele precizate şi adresele
variabilelor
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 85/267
85
Fig.5.2. Sintaxa apelului funcŃiei printf()a.) descrierea parametrilor efectivi ; b.) alcătuirea şirului de formatare şi corespondenŃa
dintre formatele precizate şi valori
ObservaŃii
Şirul de formatare al funcŃiei scanf() este recomandat să fie alcătuit numai
din formatele specifice pentru datele care urmează a fi citite. Orice alt
caracter, în afara acestor formate, va trebui tastat la introducerea datelor.
Acest lucru poate genera erori la citirea datelor. De exemplu, pentruinstrucŃiunea:
scanf(”a=%d”, &a);
la execuŃie, pentru ca citirea să se facă corect, trebuie tastat caracterul ‘a’,
caracterul ‘=’ şi apoi valoarea pentru variabila a.
Dacă şirul de formatare al funcŃiei printf() conŃine alte caractere în afara
formatelor, acele caractere vor fi afişate pe ecran.
Dacă şirul de formatare al funcŃiei printf() nu conŃine nici un format, se va
afişa şirul constant specificat, efectul fiind similar cu cel al funcŃiei gets().Ca orice şir constant şi şirul de formatare poate conŃine secvenŃe de escape.
Dacă se doreşte afişarea caracterelor \, ‘ sau “, care au o semnificaŃie anume
în sintaxa specifică limbajului, acestea trebuie precedate de caracterul \. De
exemplu, funcŃia
printf(“ \” \\ \” “);
va afişa pe ecran succesiunea de caractere “\”
În cazul ambelor funcŃii, scanf() şi printf(), lista de adrese, respectiv lista de
variabile pot lipsi, dar şirul de formatare este obligatoriu să existe.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 86/267
86
Este important să se respecte corespondenŃa între formatul datei precizat şi tipul
variabilei căreia i se atribuie valoarea citită de la tastatură. În caz contrar, valorile preluate de
variabile sunt aleatoare sau se pot genera erori fatale, execuŃia programului fiind întreruptă.
Este situaŃia prezentată în exemplul următor:
int a;float b;scanf(“%d, %f”, &b, &a); // eroare, formatul %d corespunde unei variabile float,
// iar formatul %f corespunde unei date int, printf(“\na=%d, \tb=%f”, a, b);
În continuare sunt prezentate mai multe exemple prin care se explică modul de folosire
a tuturor formatelor şi a modelatorilor de format.
int a; printf("\nIntrodu un intreg:"); // se afişează şirul constant "\nIntrodu un intreg:"scanf("%x", &a); // se citeşte variabila a în format hexazecimal
printf("\na=%d, a=%o, a=%x, a=%u, a=%c", a, a, a, a, a); // se afişează valoarea variabilei// a în diferite formate: zecimal, octal,// hexazecimal, unsigned, caracter
float r; printf("\nIntrodu un real:");scanf("%f", &r); // se citeşte o valoare reală
printf("\nr=%f, r=%e, r=%g", r, r, r); // se afişează valoarea citită în format clasic şi// format ştiinŃific
printf("\nIntrodu un real(in format stiintific):");scanf("%e", &r);
printf("\nr=%f, r=%e, r=%g", r, r, r);
ObservaŃii
Formatul %f este formatul specific valorilor reale:parte_întreagă . parte_zecimală
În mod implicit se afişează 6 zecimale. De exemplu, valoarea 12.34 va fi
afişată: 12.340000.
Formatul %e sau %E reprezintă formatul ştiinŃific de scriere a realilor:
x . xxxxxx E +/-xx
De exemplu, valoarea 12.34 va fi afişată: 1.234000E+01.
Formatul %g sau %G alege între formatul clasic de scriere sau formatul
ştiinŃific, astfel încât numărul de caractere utilizat să fie minim.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 87/267
87
printf (”\n*%f*”, 12.3456); // implicit se afişează 6 zecimale printf (“\n*%10.2*”,12.3456); // se precizează numărul de caractere al câmpului
// (10-numărul total de caractere) şi precizia de// afişare (2 zecimale)
printf (“\n*%+10.2*”, 12.3456); // se afişează semnul +
printf (“\n*%+010.2*”, 12.3456); // caracterele neutilizate ale câmpului vor fi// completate cu 0
Pentru secvenŃa anterioară se va afişa:*12.345600*
* 12.34*
* +12.34*
*0000+12.34*
char ch;scanf(“%c”, &ch); // se citeşte un caracter printf(“\nc = %c, c = %d”, ch, ch); // se afişează caracterul tastat şi valoarea
// lui din codul ASCII
char sir[20]; printf("\nIntrodu un sir de caractere:");scanf("%s", &sir); // se citeşte un şir de caractere
printf("\nsirul este=%s ", sir); // se afişează şirul de caractere
ObservaŃii
La citirea unui şir de caractere nu este necesar să se folosească operatorul
adresă deoarece numele şirului reprezintă adresa la care este alocat în
memorie. Deci următoarele două instrucŃiuni sunt echivalente:scanf("%s", &sir);
scanf("%s", sir);
char a[20], b[20]; printf("\nIntrodu un sir [abc]:");scanf("%[abc]", a); // se citeşte un şir de caractere format numai din
// caracterele ‘a’, ‘b’ sau ‘c’ ; la tastarea primului// caracter diferit de acestea, se va întrerupe// operaŃia de citire
printf("\nIntrodu alt sir [d-m]:");scanf("%[d-m]", b); // se citeşte un şir de caractere format numai din
// caracterele cuprinse în intervalul ‘d’ - ‘m’ ; printf("\nSirurile sunt:"); printf("\na=%12s", a); // se afişează conŃinutul şirului a pe minim 12
// caractere, completându-se cu spaŃii dacă este// cazul; alinierea se face la dreapta
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 88/267
88
printf("\nb=%-10s", b); // se afişează conŃinutul şirului b pe minim 10// caractere, completându-se cu spaŃii dacă este// cazul; alinierea se face la stânga
char a[20]=”abcdefgh”;
printf(“\n*%s*”, a); printf(“\n*%10s*”, a); printf(“\n*%-10s*”, a); printf(“\n*%5s*”, a); // dacă mărimea câmpului e mai mică decât
// lungimea şirului, acesta nu va fi trunchiat, ci se// afişează întregul şir
Pentru secvenŃa anterioară se afişează:
*abcdefgh** abcdefgh**abcdefgh **abcdefgh*
int a=10; printf(”adresa variabilei: %p\n”, &a);// se afişează adresa variabilei a în format
// hexazecimal printf(”adresa variabilei: %u\n”, &a);// se afişează adresa variabilei a ca întreg
// fără semn în reprezentare zecimală
printf(”Exemplu de folosire a modelatorului # \n”); printf(”%o \t %#o”, 124); // se afişează valoarea 124 transformată în format octal printf(”%x \t %#x”, 124); // se afişează valoarea 124 transformată în reprezentare
// hexazecimală
Pentru secvenŃa anterioară se va afişa:
174 01747C 0x7C
Aşa cum s-a precizat, transferul informaŃiei în operaŃiile I/O se face prin zone dememorie tampon asociate cu stream-urile folosite în care se depune informaŃia temporar, până
la preluarea şi prelucrarea de funcŃiile corespunzătoare.
Există posibilitatea ca la execuŃia unei funcŃii I/O în zona tampon să se găsească date
reziduale rămase de la operaŃiile anterioare din diferite cauze, cum ar fi depăşirea dimensiunii
câmpurilor, utilizarea de caractere ilegale, etc. Pentru a evita preluarea de date reziduale, este
necesar ca înainte de aceste operaŃii să se realizeze golirea zonelor de memorie tampon. Acest
operaŃie se poate face folosind funcŃia fflush(), definită în fişierul stdio.h care are prototipul:
int fflush(FILE* stream);FuncŃia goleşte streamul specificat ca parametru şi returnează valoarea 0 dacă operaŃia
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 89/267
89
s-a efectuat cu succes şi EOF în caz contrar.
int a, b;scanf(“%2d”, &a);
scanf(“%2d”, &b);
Dacă la execuŃia secvenŃei anterioare pentru variabila a se tastează 123456, variabila a
preia două caractere, deci a=12, în zona tampon rămânând 3456. Ca urmare b va prelua
valoarea 34 şi în zona tampon rămâne secvenŃa 56. Aceasta va fi preluată de următoarea
funcŃie de citire de la tastatură. Pentru a evita astfel de situaŃii, se va folosi funcŃia fflush() :
fflush(stdin);scanf(“%2d”, &a);
fflush(stdin);scanf(“%2d”, &b);
Exemple
/**************************************************************************
Exemplu1 5.1. - Se scrie un program în care se exemplifică folosirea funcŃiilor de intrare -ieşire pentru caractere în care:- se declară 3 variabile de tip char sau int;- se citesc valori pentru cele trei variabile cu funcŃiile getch(), getche(), respectivgetchar();- se afişează conŃinutul variabilelor folosind funcŃiile putch() sau putchar()
ObservaŃii:Se afişează mesaje care să ajute la înŃelegerea desfăşurării programului.
**************************************************************************/
#include<conio.h>#include <stdio.h>
void main(void){
char c1, c2, c3;
puts("Introdu un caracter : ");c1 = getch();
puts("\ncaracterul tastat este : ");
putch(c1);
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 90/267
90
puts("\nIntrodu un caracter : ");c2 = getche();
puts("\ncaracterul tastat este : "); putch(c2);
puts("\nIntrodu un caracter : ");c3=getchar();
puts("\ncaracterul tastat este : "); putch(c3); putch('\n');}
/**************************************************************************
Exemplu1 5.2. - Se scrie un program în care se exemplifică folosirea funcŃiilor de intrare -ieşire pentru şiruri de caractere în care:
- se declară 2 şiruri de caractere cu iniŃializare;- se afişează conŃinutul şirurilor cu funcŃia puts();- se citesc valori pentru cele două şiruri cu funcŃia gets();- se afişează din nou conŃinutul şirurilor folosind funcŃia puts().
ObservaŃie:Se vor afisa mesaje care sa ajute la înŃelegerea desfăşurării programului.
***************************************************************************/
#include<stdio.h>#include<conio.h>
void main(void){
char sir1[30]="primul sir";char sir2[30]="al doilea sir";
puts("sir1:"); puts(sir1); puts("sir2:");
puts(sir2); puts("\nIntrodu un sir de caractere:");gets(sir1);
puts("\nIntrodu un sir de caractere:");gets(sir2);
puts("sir1:"); puts(sir1); puts("sir2:"); puts(sir2);getch();
}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 91/267
91
/**************************************************************************
Exemplu1 5.3. - Se scrie un program în care se exemplifică folosirea funcŃiilor de intrare -ieşire pentru diverse tipuri de date.
**************************************************************************/
#include < stdio.h >#include<conio.h>
void main(){
char caracter = 'A';int nr_intreg = 20;float nr_real = 123.45;double nr_double = 1122.33E3;char sir[30] = “Exemplu”;
printf("caracter = %c\n", caracter ); printf("intreg = %d\n", nr_intreg); printf("real = %f\n", nr_real ); printf("real dublu = %e\n", nr_double); printf("sir de caractere = %s\n", sir);getch();
}
/**************************************************************************
Exemplu1 5.4. - Se scrie un program în care se exemplifică folosirea funcŃiilor de intrare -ieşire pentru tipul de date int. Se folosesc toate diverse formate compatibile cu tipul int.
**************************************************************************/
#include <stdio.h>#include <conio.h>
void main(){
int a, b;
printf("\nIntrodu un intreg:");scanf("%d", &a);
printf("\na=%d, a=%o, a=%x, a=%u, a=%c", a, a, a, a, a);getch();
printf("\nIntrodu 2 intregi:");
scanf("%d%d", &a, &b); printf("\na=%d, a=%o, a=%x, a=%u, a=%c", a, a, a, a, a);
Format pentru reprezentareaîn baza 10 (zecimal).
Format pentru reprezentarea în baza 8 (octal).
Format pentrureprezentarea ca şicaracter.
Format pentru reprezentarea în baza 16 (hexazecimal).
Format pentru reprezentarea caîntreg fără semn.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 92/267
92
printf("\nb=%d, b=%o, b=%x, b=%u, b=%c", b, b, b, b, b);getch();
printf("\nIntrodu 2 intregi:");scanf("%2d%2d",&a,&b);
printf("\na=%d, a=%o, a=%x, a=%u, a=%c", a, a, a, a, a); printf("\nb=%d, b=%o, b=%x, b=%u, b=%c", b, b, b, b, b);getch();
printf("\n*%+6d*",1); printf("\n*%+6d*",12); printf("\n*%+6d*",123); printf("\n*%+6d*",1234); printf("\n*%+6d*",12345);getch();
}
/**************************************************************************
Exemplu1 5.5. - Se scrie un program în care se exemplifică folosirea funcŃiilor de intrare -ieşire pentru tipul de date float. Se folosesc toate diverse formate compatibile cu tipul float.
**************************************************************************/
#include <stdio.h>
#include <conio.h>
void main()
{float a, b;
printf("\nIntrodu un real:");scanf("%f", &a);
printf("\na=%f, a=%e, a=%g", a, a, a);
printf("\n*%12f*", a); printf("\n*%.2f*", a); printf("\n*%12.2f*", a); printf("\n*%+12.2f*", a);getch();
}
Se precizeazănumărul de caractere
preluate de variabilă
Format de afişare a valorilor reale prin parte întreagă şi partefracŃionară.
Format de afişare a valorilor reale în format ştiinŃific.
Se precizează numărul decaractere folosite în afişare.
Se face afişare cu 2 zecimale.
Se cere afişarea semnului.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 93/267
93
Rezumat
În C/C++ operaŃiile de intrare/ieşire (I/O – Input/Output) nu se efectuează pe
baza unui tip de date dedicat şi a unor funcŃii încorporate în limbaj, ci se adaugă
printr-un set de funcŃii din biblioteca standard. Transferurile de date cu dispozitivele fizice de intrare/ieşire se fac prin
intermediul sistemului de operare şi al unor dispozitive logice identice numite
stream prin funcŃii din biblioteca C/C++, declarate (majoritatea) în fişierul
stdio.h, sau în C++ printr-un sistem propriu, realizat pe principiile POO.
În biblioteca standard există definite funcŃii I/O destinate anumitor tipuri de
date (caractere şi şiruri de caractere) şi funcŃii care pot opera cu oricare dintre
tipurile de date predefinite.
Citirea de la tastatură a caracterelor se poate face cu funcŃii dedicate, cum ar fi
de exemplu getch(), getche(), getchar(), definite în fişierele header conio.h şi
stdio.h.
Afişarea pe ecran a caracterelor se poate face cu funcŃii dedicate, cum ar fi de
exemplu putch(), putchar(), definite în fişierele header conio.h şi stdio.h.
Citirea de la tastatură a şirurilor de caracterelor se poate face cu funcŃii
dedicate, cum ar fi de exemplu gets() definită în fişierul header stdio.h.
Afişarea pe ecran a şirurilor de caracterelor se poate face cu funcŃii dedicate,
cum ar fi de exemplu puts() definită în fişierul header stdio.h.
FuncŃiile consacrate pentru operaŃii I/O pentru oricare dintre tipurile de date predefinite sunt definite în fişierul stdio.h (scanf(), printf()). La aceste funcŃii se
precizează formate de citire/afişare în concordanŃă cu tipul datelor vehiculate.
În cazul unei operaŃii de citire, formatarea constă în conversia datelor de la
reprezentarea lor externă (la dispozitivul de intrare) la reprezentarea internă,
binară. Datele sunt introduse de la tastatură sub forma unor şiruri de caractere
ASCII, corespunzătoare tastelor apăsate şi sunt separate de spaŃiere (spaŃiu, tab,
linie nouă, etc.) şi se face transformarea şirului în reprezentarea binară a valorii
respective. O operaŃie inversă este necesară pentru afişarea valorii pe ecran,deoarece dispozitivul de ieşire consolă aşteaptă un şir de coduri ASCII pe baza
cărora creează imaginea de pe ecran.
Apelul funcŃiei scanf() precizează şirul de formatare (conŃine caractere ASCII
şi specificatori de format) şi lista adreselor de memorie la care sunt memorate
valorile introduse de la tastatură. Pentru ca operaŃia de intrare să se realizeze
corect, trebuie ca numărul de formate precizate în şirul de formatare şi numărul
adreselor în lista de adrese ale variabilelor să fie acelaşi şi tipurile precizate prin
formate să corespundă tipurilor obiectelor ce se găsesc la adresele precizate.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 94/267
94
Apelul funcŃiei printf() precizează şirul de formatare (conŃine caractere ASCII
şi specificatori de format) şi lista de valori. Pentru ca operaŃia de afişare să se
realizeze corect, trebuie ca numărul de formate precizate în şirul de formatare şi
numărul expresiilor din lista de valori să fie acelaşi şi tipurile precizate prin
formate să corespundă tipurilor expresiilor.
Specificatorii de format pot fi însoŃiŃi de modelatori de format, cum ar fi:
specificator pentru mărimea câmpului, specificator de precizie, modelatorii *, +,
-, # care influenŃează formatul de citire sau afişare a datelor.
Există posibilitatea ca la execuŃia unei funcŃii I/O în zona tampon să se
găsească date reziduale rămase de la operaŃiile anterioare din diferite cauze.
Pentru a evita preluarea de date reziduale, se poate realiza golirea zonelor de
memorie tampon asociate, folosind funcŃia fflush(), definită în fişierul stdio.h
Test de autoevaluare
1. Mesajul de pe ecran1.234e-2
este generat de secvenŃa de instrucŃiuni:
a. float b=1.234e-2; printf("%f", b); b. float a=1.234e-2; printf("%e", a);c. float c=0.01234; printf("%e", c);d. nici una din cele de mai sus
2. SecvenŃa de instrucŃiuni:#include<stdio.h>#include<conio.h>void main(){
char ch;ch=getche();
putchar('A'); putchar(ch);
}va produce după apăsarea tastei: a
a. nu intra in execuŃie din cauza unei erori de sintaxa b. afisarea pe ecran a secvenŃei: aAc. afisarea pe ecran a secvenŃei: aAad. aşteaptă apăsarea tastei <Enter>
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 95/267
95
3. SecvenŃa de instrucŃiuni:#include<stdio.h>#include<conio.h>void main(){ char ch;
ch=getch(); putchar("\nA"); putchar(ch);
}va produce după apăsarea tastei: a
a. aşteaptă apăsarea tastei <Enter> b. afisarea pe ecran a secvenŃei: aAac. afisarea pe ecran a secvenŃei: A
ad. nu intra in execuŃie din cauza unei erori de sintaxa
4. SecvenŃa de instrucŃiuni:#include<stdio.h>#include<conio.h>void main(){ char str[80]="acesta este un sir";
putchar(str);}
va produce :a. nu intra in execuŃie din cauza unei erori de sintaxa
b. afisarea secvenŃei: acesta este un sir c. afisarea primei litere din sir: ad. afisarea ultimei litere din sir: r
5. SecvenŃa de instrucŃiuni:#include<stdio.h>#include<conio.h>void main(){ char ch;
ch=getche(); putchar('*');
}va produce după apăsarea tastei: a
a. afisarea pe ecran a secvenŃei: a* b. afisarea pe ecran a secvenŃei: a
*c. nu intra in execuŃie din cauza unei erori de sintaxad. afisarea pe ecran a secvenŃei: *
6. SecvenŃa de instrucŃiuni:#include<stdio.h>
#include<conio.h>void main()
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 96/267
96
{ long nr; puts("introduceti un numar:");scanf("%d", nr);
printf("\nnr=%3d", nr);}
la apăsarea tastei 5:
a. nu va intra în execuŃie din cauza unui erori de sintaxa; b. va afisa pe ecranul utilizator secventa :
introduceŃi un numar:5nr = 5;
c. secventa: introduceti un numar:5nr = 5;
d. eroare la execuŃie
7. SecvenŃa de instrucŃiuni:#include<stdio.h>void main(){ int nr;
puts("introduceti un numar:");scanf("%d", &nr); puts("nr=%3d");
}la apăsarea tastei 5:a. nu va intra in execuŃie din cauza unui erori de sintaxa;
b. va afisa pe ecranul utilizator secventa:introduceŃi un numar:5nr=%d;
c. secventa:introduceŃi un numar:5nr=%3d;
d. secvenŃa:introduceŃi un număr:5nr = 5;
8.
SecvenŃa de program de mai jos:#include<stdio.h>void main(){ char c='1';
printf("%c\t%x\n", c, c);}
va genera următorul efect:a. eroare de compilare
b. '1' 31c. 1 1d. 1 31
e. 31 31
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 97/267
97
9. SecvenŃa de program de mai jos:#include<stdio.h>void main(){ char x=42;
printf("%d\t%c\t", x, x);
}va genera următorul efect:a. 0x42 c
b. 66 Bc. 66 *d. 0x42 Be. eroare de sintaxa
10. SecvenŃa de program de mai jos:#include<stdio.h>void main(){ char x=0x42;
printf("%x\t%c\t", x, x);}
va genera următorul efect:a. 0x42 c
b. 42 Bc. 42 bd. 0x42 Be. eroare de sintaxa
11. SecvenŃa de program de mai jos:#include<stdio.h>void main(){ int x='a';
printf("%x\t%c\t%d\n", x, x, x);}
va genera următorul efect:a. 0x97 a 97
b. 61 a 97c. eroare de sintaxăd. a a a
12. SecvenŃa de program de mai jos:#include<stdio.h>void main(){ int a = 5;
float b = 3.5; printf("\n%d\t%.2f", b, a);
}va genera următorul efect:a. 3.500000 5
b. 3.5 5c. 3 5.000000d. nici una din cele de mai sus
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 98/267
98
Întrebări. ExerciŃii. Probleme.
1. Să se scrie un program în care se exemplifică folosirea funcŃiilor de intrare -ieşire cu formatare pentru şiruri de caractere. Se folosesc diverse formatecompatibile cu şiruri de caractere, similar exemplelor 5.3, 5.4.
2. Să se scrie un program în care se exemplifică folosirea funcŃiilor de intrare -ieşire cu formatare pentru diverse tipuri de date (char, int, float, double). Sevor folosi şi modelatorii cunoscuŃi. Se are în vedere asocierea corectă aformatelor cu tipurile datelor asociate.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 99/267
99
Unitatea de învăŃare U.6. OPERATORI ŞI EXPRESII
Cuprins
Introducere .................................................................................................................... 99
Obiectivele unităŃii de învăŃare ..................................................................................... 99
U6.1. Operatori .......................................................................................................... 100
U6.2. Ordinea de evaluare a expresiilor ...................................................................... 111
U6.3. Conversii de tip în expresii ............................................................................... 113
Exemple ...................................................................................................................... 114
Rezumat ...................................................................................................................... 116Test de autoevaluare ................................................................................................... 117
Întrebări, exerciŃii şi probleme .................................................................................... 119
Introducere
Orice program transpune o problemă prin intermediul unei succesiuni de
instrucŃiuni, fiecare producând o acŃiune. Aceste instrucŃiuni includ în modfrecvent expresii formate din succesiuni de operanŃi şi operatori.
Operatorii sunt simboluri care, aplicate unor operanzi (date - constante,
variabile, expresii), au ca efect realizarea unor operaŃii care returnează un rezultat.
O succesiune validă de operanzi şi operatori formează o expresie.
Limbajele C/C++ dispun de o gamă largă de operatori. C++ posedă toŃi
operanzii limbajului C, completând lista cu operanzi proprii.
Operanzii pot fi grupaŃi după diferite criterii, de exemplu după numărul
operanzilor cărora li se aplică sau după tipul operaŃiei efectuată.
În prezenta unitate de învăŃare sunt descrişi majoritatea operatorii specifici
limbajelor C/C++. Unii operatori vor fi introduşi în alte unităŃi de învăŃare, odată
cu introducerea unor noi noŃiuni.
Obiectivele unităŃii de învăŃare
După parcurgerea acestei unităŃi de învăŃare trebuie să ştii:
Operatorii limbajelor C/C++;
Evaluarea expresiilor; precedenŃa şi asociativitatea operatorilor; Conversii de tip la evaluarea expresiilor.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 100/267
100
Durata medie de parcurgere a celei de a şasea unităŃi de învăŃare este de 2
ore.
U6.1. Operatori
Operatorii sunt simboluri care aplicate unor operanzi (date - constante, variabile,
expresii) au ca efect realizarea unor operaŃii care returnează un rezultat.
O succesiune validă de operanzi şi operatori formează o expresie.
Limbajele C/C++ dispun de o gamă largă de operatori.
C++ posedă toŃi operanzii limbajului C, completând lista cu operanzi proprii:
operatorii new şi delete utilizaŃi pentru alocarea dinamică de memorie, operatorul de scop (::),operatorul pointer la membru ( .* ) şi forma sa echivalentă ( ->. ) .
Operatorii pot fi grupaŃi după diferite criterii. Unul dinte criterii îl constituie tipul
operaŃiei. Astfel, operatorii pot fi grupaŃi în operatori aritmetici, operatori relaŃionali,
operatori la nivel de bit şi operatori logici. În afară de aceste categorii, există o serie de
operatori care descriu operaŃii diverse.
Alt criteriu de clasificare a operatorilor îl constituie numărul de operanzi cărora li se
aplică. Operatorii pot fi clasificaŃi în operatori unari (se aplică la un operand), operatori
binari (se aplică la doi operanzi) şi ternari (se aplică la trei operanzi).Este de remarcat faptul că există operatori care au dublă semnificaŃie, cum ar fi +, -, *,
etc., fiind definiŃi atât ca operatori unari, cât şi ca operatori binari. Interpretarea se face
implicit, în funcŃie de numărul operanzilor cărora se aplică.
OperaŃia unară se descrie prin sintaxa:
operator operand;
OperaŃia binară se descrie prin sintaxa:
operand_1 operator operand_2;
OperaŃia ternară se descrie prin sintaxa:
operand_1 operator operand_2 operator operand_3;
ObservaŃie
Operatorii sunt definiŃi pentru a opera cu operanzi de tipuri predefinite.
Limbajul C++ oferă mecanisme pentru supradefinirea acestora astfel încâtsă poată opera cu obiecte de tipuri definite de utilizator.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 101/267
101
Operatorii limbajului C++ sunt prezentaŃi în Tabelul nr. 6.1.
Tabelul nr. 6.1. Operatorii limbajului C++
[ ] ( ) . -> ++ -- & *+ - ~ ! / % << >>
< > <= >= = = != ^ |
&& | | ? : = * = / = % = + =
- = <<= >>= &= ^ = | = , #
## sizeof new delete :: .* ->*
ObservaŃie
Operatorii # şi ## aparŃin preprocesorului.
Operatorul de atribuire ( = )
OperaŃia cea mai frecvent folosită în programare este operaŃia de atribuire. Prin
atribuire, se înscrie (memorează) o valoare într-o variabilă (locaŃie de memorie).
Este operaŃie binară, sintaxa generală de utilizare a operatorului de atribuire fiind:
operand_1 = operand_2;
sau, în mod frecvent:variabila = expresie;
Pe lângă înscrierea unei valori într-o variabilă, operaŃia returnează valoarea variabilei,astfel că, se pot efectua atribuiri multiple cu sintaxa:
variabila_1 = variabila_2=…= variabila_n = expresie;
În urma atribuirii multiple, toate variabilele din expresie, variabila_1, …, variabila_n,
vor avea aceeaşi valoare, cea obŃinută prin evaluarea expresiei.
int a; // declaraŃia unei variabilea=5; // atribuirea unei valori constante unei variabileint b=7; // declaraŃia unei variabile cu iniŃializarea=b; // atribuirea unei valori depusă într-o variabilă altei variabile
b=a+10; // atribuirea valorii unei expresii unei variabile
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 102/267
102
a=b=100; // atribuire multiplăa=a+b; // expresia conŃine ca operand variabila către care se face
// atribuirea; întâi este evaluată expresia a+b cu valoarea pe care// o avea înainte de operaŃie şi apoi se face operaŃia de atribuirea
operand_2 (expresie) se mai numeşte rvalue (right value - valoare dreapta). Acesta
trebuie să fie o expresie care returnează valoare. Expresia poate fi formată din o constantă, o
variabilă, apelul unei funcŃii care returnează valoare, sau o expresie mai complexă.
operand_1 care se găseşte în partea stângă se mai numeşte lvalue (left value). Acesta
trebuie să desemneze o locaŃie de memorie pentru care există permisiunea de modificare a
valorii. Astfel, lvalue poate fi numele unei variabile sau un pointer, dar nu poate fi o
constantă, o variabilă declarată const, sau apelul unei funcŃii.
int a = 15; // declaraŃie de variabilă cu iniŃializareconst int ct = 100; // declaraŃie de variabilă const; iniŃializarea este obligatorie
ct = 99; // eroare, se încearcă modificarea valorii unei variabile protejată
// prin specificatorul const5 = ct; // eroare, se încearcă modificarea unei constante literalea+5 = 20; // eroare, se încearcă atribuirea unei valori unei expresiia = getch(); // corect, se atribuie variabilei a valoarea din codul ASCII a
// caracterului citit de la tastaturăgetch() = a; // eroare, se încearcă atribuirea unei valori unei funcŃii
OperaŃia de atribuire se poate efectua între tipuri de date diferite. În această situaŃie, se
produc conversii implicite ale lvalue către tipul rvalue.
Pot apărea două situaŃii în efectuarea acestor conversii:
tipul lvalue are reprezentare în domeniu de valori mai larg decât cel al rvalue – aceste
conversii nu produc efecte nedorite;
tipul lvalue are reprezentare în domeniu de valori mai restrâns decât cel al rvalue – aceste
conversii se efectuează prin trunchierea valorilor, fapt ce poate duce fie la rotunjirea
valorilor, fie la obŃinerea de valori aleatoare; situaŃiile sunt descrise în Tabelul nr. 6.2.Tabelul nr. 6.2. Conversii de tip la atribuire
Tip lvalue Tip rvalue Efect conversie
char int Se preiau cei mai semnificativi 8 biŃi
char unsigned char Dacă valoarea este >127, se preia valoare negativă
char long int Se preiau cei mai semnificativi 8 biŃi
int unsigned int Dacă valoarea este >32767, se preia valoare negativă
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 103/267
103
Tip lvalue Tip rvalue Efect conversie
int long int Se preiau cei mai semnificativi 16 biŃi
int float Se preia partea întreagă a valorii; dacă aceasta depăşeşte
domeniul int, se trunchiazăfloat double Se reduce precizia de reprezentare; dacă şi aşa se
depăşeşte domeniul float, se trunchiază
double long double Se reduce precizia de reprezentare; dacă şi aşa sedepăşeşte domeniul long, se trunchiază
Sunt prezentate câteva exemple:
char ch = ’a’ ;int a = 10;char sir[20];float r = 2.5;a = 1000; // atribuire între date de acelaşi tip (int), nu se realizează
// conversie
a = ch; // conversie cu lărgirea domeniului de valori, a va prelua// valoarea 97 (codul ASCII al caracterului ’a’)
ch = a; // conversie cu reducere a domeniului de valori, valoarea se
// încadrează în domeniul char, deci trunchierea nu va afecta// valoarea preluată
ch = a; // conversie cu reducere a domeniului de valori, valoarea nu se// încadrează în domeniul char, deci trunchierea va produce o// valoarea -24
ch = sir; // eroare, ch este de tip char, sir este adresă de char; cele două// tipuri sunt incompatibile, nu se poate face conversie, deci nici// atribuirea
ObservaŃie
Conversiile predefinite se efectuează la atribuire numai între tipuri de date
numerice. Între valori numerice şi adrese de memorie nu se efectuează
conversii implicite.
Operatori aritmetici
În categoria operatorilor unari se regăsesc atât operatori unari, cât şi binari. Sunt prezentaŃi în Tabelul nr. 6.3.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 104/267
104
Tabelul nr. 6.3. Operatori aritmetici
Tip operator Simbol AcŃiune
Unar
+ Păstrarea semnului, nu produce nici o modificare
- Schimbarea semnului++ Incrementare
-- Decrementare
Binar
+ Adunare
- Scădere
* ÎnmulŃire
/ ÎmpărŃire
% Modulo – restul împărŃirii întregi
Operatorul + (unar) – aplicat unei expresii va păstra valoarea expresiei.
int a;a = +5; // expresia +5 întoarce valoarea 5
Operatorul - (unar) – aplicat unei expresii va întoarce valoarea expresiei cu semn schimbat.
int a, b=2;
a = -b; // expresia -b întoarce valoarea lui b cu semn schimbat (-2); variabila b// nu este afectată de operaŃie, păstrându-şi valoarea, deci în final a=-2, b=2
Operatorii + - * / (binari) efectuează şi returnează rezultatul operaŃiilor de adunare, scădere,
înmulŃire, respectiv împărŃire.
float r = 1.5, s = 3.2, t;t = r +s; // operaŃie de adunaret = r - s; // operaŃie de scăderet = r * s; // operaŃie de înmulŃire
t = r / s; // operaŃie de împărŃire
ObservaŃie
ÎmpărŃirea întregilor produce tot un întreg prin trunchierea părŃii
fracŃionare a rezultatului. Rezultatul operaŃiei 9/2 va fi 4 şi nu 4.5
Operatorul % (binar) – întoarce restul împărŃirii a doi întregi.
int a = 15;int b;
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 105/267
105
b = a % 2; // b preia valoarea restului împărŃirii lui a la 2, deci preia valoarea 1 b = a % 1.5; //eroare, unul dintre operanzi nu este întreg.
Operatorii ++ şi -- (unari) – sunt operatori de incrementare, respectiv de decrementare.
Operatorul ++ adună valoarea 1 la valoarea operandului. Operatorul – scade valoarea
1 din valoarea operandului. Ambele operaŃii sunt însoŃite de înlocuirea valorii operandului cu
rezultatul obŃinut. Aceasta înseamnă că operandul trebuie să fie o dată de tip lvalue, astfel
încât atribuirea să se poată efectua.
int a = 5 b = 10;++a; // expresia este echivalentă cu: a = a+1; a va primi valoarea 6--b; // expresia este echivalentă cu: b = b - 1; b va primi valoarea 9
Operatorii de incrementare (++) şi de decrementare (--) pot fi prefixaŃi sau post fixaŃi.
În primul caz, modificarea valorii operandului se face înainte de a-i folosi valoarea, în al
doilea caz se foloseşte valoarea iniŃială a operandului şi apoi se efectuează modificarea
acesteia.
int i = 5, j; j = ++i // operatorul ++ este prefixat, deci întâi se efectuează operaŃia
// de incrementare a lui i şi apoi de face atribuirea către j, deci:
// i=6, j=6; j = i-- ; // operatorul -- este postfixat, deci întâi se efectuează operaŃia de// atribuire către j şi apoi de face incrementare a lui i, deci:// i=5, j=6;
Aceşti operatori se pot aplica numai datelor de tip lvalue, variabile desemnate prin
nume sau pointeri.
const int a = 3;a++; // eroare, operatorul de incrementare se aplică unei variabile
// const
++5 ; // eroare, operatorul de incrementare se aplică unei constante(i+j)-- ; // eroare, operatorul de decrementare se aplică unei expresii++(ghetchar()); // eroare, operatorul de incrementare se aplică unei funcŃii
ObservaŃie
OperaŃiile de incrementare, respectiv decrementare pot fi aplicate oricărui
tip numeric de date, nu doar întregilor:
float r = 1.5;
r++; // operaŃie validă – r ia valoarea 2.5
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 106/267
106
Operatori relaŃionali
Operatorii relaŃionali sunt operatori binari care se referă la relaŃiile dintre valorile
operanzilor. Aceştia sunt prezentaŃi în Tabelul nr. 6.4.
Tabelul nr. 6.4. Operatori relaŃionali
Tip operator Simbol AcŃiune
Binar
> Mai mare
>= Mai mare sau egal
< Mai mic
<= Mai mic sau egal
== Egal
!= Diferit
OperaŃiile relaŃionale întorc informaŃie despre faptul că relaŃia între operanzi este
adevărată sau falsă.
Limbajele C/C++ nu au tipul de date boolean implementat, ci convenŃia de
reprezentare este următoarea:
- “fals” este reprezentat prin valoarea numerică 0
- ”adevărat” este reprezentat prin orice valoare diferită de zero (de regulă valoarea 1).
Ca urmare, operaŃiile relaŃionale întorc un rezultat care poate avea valoarea 0 sau 1.
int a = 5;float r = 3.5;a > r; // expresia întoarce valoarea 1r >= a; // expresia întoarce valoarea 0a == r; // expresia întoarce valoarea 0a != r; // expresia întoarce valoarea 1
Operatori logiciOperatorii logici pot fi unari sau binari. Ei realizează operaŃiile logice între valorile
operanzilor. Aceştia sunt prezentaŃi în Tabelul nr. 6.5.
Tabelul nr. 6.5. Operatori logici
Tip operator Simbol AcŃiune
Unar ! Negare logică (NOT)
Binar
&& Şi logic (AND)
|| Sau logic (OR)
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 107/267
107
În interpretarea operaŃiilor logice se are în vedere modul de reprezentare a valorilor
logice. Ca urmare, rezultatul acestor operaŃii se poate reprezenta prin tabelele de adevăr
prezentate în Fig. 6.1.
p !p p q p && q p q p || q0 1 0 0 0 0 0 01 0 1 0 0 1 0 1
0 1 0 0 1 11 1 1 1 1 1
Fig. 6.1. Tabelele de adevăr pentru operaŃiile logice
int a = 5, b=10;a && b; // ambii operanzi sunt diferiŃi de 0 deci sunt logic adevăraŃi;
// rezultatul operaŃiei va fi 1a && (!b); // (!b) returnează valoarea 0, deci operaŃia && se face între un
// operand adevărat şi unul fals, rezultatul va fi 0a || 3/2; // operaŃia || se face între doi operanzi diferiŃi de 0, deci rezultatul
// va fi 1
Operatori la nivelul biŃilor
OperaŃiile efectuate la nivel de bit apropie limbajele C/C++ de limbajul de asamblare.
În mod curent, accesul la memorie se face la nivel de octet, octetul fiind cea mai mică unitatede memorie adresabilă. Prin această categorie de operaŃii se pot face însă operaŃii la nivel de
bit. OperaŃiile la nivel de bit se pot efectua cu operanzi de tip numeric întreg.
Nu se pot efectua astfel de operaŃii cu alte tipuri de date decât întregi, deci nu se pot
aplica datelor de tip real (float, double, long double).
Operatorii la nivel de bit pot fi unari sau binari. Operatorii disponibili sunt prezentaŃi
în Tabelul nr. 6.6.
Tabelul nr. 6.6. Operatori la nivel de bit
Tip operator Simbol AcŃiune
Unar ~ Negare la nivel de bit
Binar
& Şi la nivel de bit
^ Sau exclusiv la nivel de bit
| Sau la nivel de bit
<< Deplasare la stânga (left shift)
>> Deplasare la dreapta (right shift)
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 108/267
108
Modul de efectuare a acestor operaŃii a fost descris în unitatea de învăŃare nr. 01.
int a=7, b=2, c;~ a; // expresia returnează valoarea -8
a & b; // expresia returnează valoarea 2a | b; // expresia returnează valoarea 7a ^ b; // expresia returnează valoarea 5a << b; // expresia returnează valoarea 28a >> b; // expresia returnează valoarea 1
ObservaŃii
OperaŃia de deplasare la stânga (a<<b) este echivalentă cu operaŃia de
înmulŃire a lui a cu 2b iar OperaŃia de deplasare la dreapta (a>>b) este
echivalentă cu operaŃia de împărŃire a lui a cu 2b. Modul de interpretare a acestor operaŃii reiese din reprezentarea binară a
valorilor în memorie.
Dacă b are valoare relativ mare raportată la numărul biŃilor folosiŃi în
reprezentarea operandului a, se poate ajunge uşor la depăşirea domeniului
de valori, şi ca urmare pierderea unor biŃi,
Operatorul sizeof – (unar)
Operatorul sizeof este un operator unar, care are ca rezultat un întreg ce reprezintănumărul de octeŃi pe care este memorat operandul căruia i se aplică. Operandul este un tip de
date sau o dată (constantă sau variabilă) de un anumit tip. Sintaxa de utilizare este:
sizeof (expresie);
sizeof(int); // returnează numărul de octeŃi pe care este memorat un întreg (2 sau 4)
sizeof(double); // returnează numărul de octeŃi pe care este memorat un double (8)
sizeof(”ab6de”); // returnează 6, nr. de octeŃi pe care este memorată constanta// şir ”ab6de”int asizeof( a * 1.5); // returnează numărul de octeŃi pe care este memorat rezultatul
// expresiei a *1.5, care este un double (8)
Operator & - adresă (unar)
Operatorul & (unar) a fost menŃionat în Cursul nr. 03 odată cu introducerea noŃiunii de
variabilă. Operatorul se aplică numelui unei variabile, rezultatul operaŃiei fiind adresa de
memorie la care este alocată variabila respectivă. Sintaxa de utilizare este:&nume_variabila;
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 109/267
109
int a;&a; // returnează adresa la care e alocată variabila a printf(“ %p , %u”, &a, &a); // la execuŃia instrucŃiunii se afişează valoarea adresei
// variabilei a în două formate: hexazecimal (%p) şi întreg// zecimal fără semn (%u), de exemplu: FFF4, 65524
Operator condiŃional ? : (ternar)
Singurul operator ternar disponibil în C/C++ este operatorul condiŃional. El este
format din caracterele ? şi : şi se aplică la asupra a trei operanzi.
Se foloseşte în expresii sub forma:
e1 ? e2 : e3;
Expresia e1 este evaluată prima. Dacă valoarea acesteia este logic adevărată (non-
zero), se evaluează expresia e2 şi aceasta este valoarea returnată de expresia condiŃională, încaz contrar, se evaluează expresia e3, valoarea acesteia fiind cea returnată.
int a, b, c;scanf(“%d”, &a);scanf(“%d”, &a);c = (a>b) ? a : b ; // c primeşte ca valoare maximul dintre a şi b
Expresia anterioară este echivalentă cu secvenŃa:
dacă (a>b) atunci c=a altfel c=bsau:
if (a>b) // if este instrucŃiune de decizie care va fi prezentată în cursul// destinat prezentării instrucŃiunilor
c=a;else
c=b;
Operatorul (tip) –conversie explicită de tip (unar)Operatorul (tip) este un operator unar care apare în construcŃii numite cast sau typecast
şi converteşte tipul operandului său la tipul specificat între paranteze. Se poate utiliza în orice
expresie folosindu-se o construcŃie de forma:
(nume_tip) expresiesau
nume_tip (expresie)
Rezultatul întors de operaŃie este valoarea expresiei convertită în mod explicit la tipul
de date precizat. Conversia se poate face fie către un tip de dată cu domeniu de valori mai larg
decât al expresiei, sau către tip cu reprezentare mai restrânsă decât a expresiei. Expresia se
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 110/267
110
evaluează similar conversiilor produse în mod implicit prin atribuire (vezi Tabelul 6.2.).
int a=9;float r;
(float) a; // converteşte operandul a (care era de tip întreg) în floata/(float)2; // converteşte constanta 2, care este de tip int, la tipul floatr = 9/2; // se efectuează împărŃirea întreagă, 9/2, rezultatul fiind 4 şi apoi se face
// atribuirea valorii lui r, astfel, deşi r este de tip float, va preluavaloarea 4
r = (float)9 / 2; // 9 este convertit la tipul float, astfel că împărŃirea se va face între o// dată float şi o dată int, rezultatul fiind float ; r va primi valoarea 4.5
Operatorul , – virgulă (binar)
Operatorul virgulă se foloseşte pentru a obŃine expresii complexe, alcătuite dintr-o
înşiruire de expresii. Sintaxa de utilizare a acestui operator este:
expresie , expresie ;
Valoarea operandului stânga este ignorată, operaŃia returnând ca valoare valoarea
expresiei situată în dreapta operatorului.int a = 5, b, c;c = ( b= 2*a, a+b); // evaluarea expresiei se face astfel: întâi se atribuie variabilei b
// valoarea 2*a, adică 10, apoi se evaluează expresia a+b,
// valoarea acesteia, 5+10, fiind valoarea întoarsă de operatorul// virgulă (,), astfel că variabila c primeşte valoarea 15
Operatorul ( ) – paranteză - operator binar
Operatorul () se foloseşte pentru a forŃa ordinea de evaluare a expresiilor. Sunt
situaŃii în care ordinea implicită de evaluare a expresiilor nu este convenabilă, situaŃie în care
se poate schimba această ordine prin folosirea parantezelor.
int a = 2;
int b; b = a + 2 * a +3; // ordinea de evaluare este: se efectuează înmulŃirea 2*a, apoi
// se execută adunările şi în final se face atribuirea, deci b// primeşte valoarea 9
b = (a + 2) *( a +3); // ordinea de evaluare este: se evaluează adunările, între// rezultatele lor se efectuează înmulŃirea şi în final atribuirea,// deci b primeşte valoarea 20
Operatori de atribuire compuşi
Operatorul de atribuire (=) poate fi combinat cu operatorii aritmetici sau cei la nivel de bit, rezultând o scriere condensată a expresiilor.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 111/267
111
Expresii de tipul:e1 = (e1) operator (e2);
pot fi scrise într-o formă condensată :
e1 operator= e2;
unde (operator= ) este operator de asignare în care operator poate fi unul dintre:
+ - * / % << >> & ^ |
Astfel, se pot folosi expresiile extinse sau condensate, ca de exemplu:
i = i+2; echivalent cu i+=2;x= x*(y+1); echivalent cu x*=y+1;a=a>>b; echivalent cu a>>=b;
ObservaŃii
Operatorii: * (unar), [ ], new, delete, .* , ->* vor fi prezentaŃi în cursurile
următoare
U6.2. Ordinea de evaluare a expresiilor
La evaluarea expresiilor, se are în vedere o ordine de efectuare a operaŃiilor implicită,stabilită pe baza regulilor care stabilesc:
prioritatea (precedenŃa) – indică ordinea de efectuare a operaŃiilor într-o expresie care
conŃine operatori diferiŃi;
asociativitatea – indică ordinea de efectuare a operaŃiilor care se încadrează în aceeaşi
grupă de precedenŃă.
Nivelurile de prioritate şi ordinea de evaluare în cazul în care operatori consecutivi
intră în alcătuirea aceleiaşi expresii sunt prezentate în Tabelul nr.6.7.
Se observă că operatorii unari au precedenŃă mai mare decât majoritatea operatorilor binari.
łinând seama de regulile descrise prin Tabelul nr. 6.7., se pot scrie expresii
echivalente, cum ar fi:
c = a + b << 2; echivalent cu c = (a + b) << 2;
c = a + b + c; echivalent cu c = (a + b) + c
a > b && a >c echivalent cu (a > b) && (a > c)
~ ! a echivalent cu ~ ( ! a)
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 112/267
112
Tabelul nr. 6.7. Prioritatea şi ordinea de evaluare a operatorilor
Clasa deprioritate
Operatori Asociativitate
1 ( ) [ ] -> :: . de la stânga la dreapta
2 operatori unari:
! ~ + - ++ -- & *
(tip) sizeof new delete
de la dreapta la stânga
3 .* ->* de la stânga la dreapta
4 * / % de la stânga la dreapta
5 + - de la stânga la dreapta
6 << >> de la stânga la dreapta
7 < <= > >= de la stânga la dreapta
8 = = != de la stânga la dreapta
9 & de la stânga la dreapta
10 ^ de la stânga la dreapta
11 | de la stânga la dreapta
12 && de la stânga la dreapta
13 || de la stânga la dreapta
14 ? : (operator condiŃional) de la dreapta la stânga
15 = *= /= %= += -=
&= ^= |= <<= >>=
de la dreapta la stânga
16 , (operator virgulă) de la stânga la dreapta
ObservaŃii
ToŃi operatorii unari se află în aceeaşi grupă de prioritate, iar asocierea lor
se face de la dreapta la stânga.
Pentru a modifica ordinea de evaluare specificată în Tabelul nr. 6.7. se pot
utiliza parantezele ( ) care vor impune ordinea grupării operanzilor şi
operatorilor dorită de utilizator în evaluarea expresiilor.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 113/267
113
U6.3. Conversii de tip în expresii
Conversiile de tip se pot realiza implicit, sau explicit prin folosirea operatorului (tip).
Dacă într-o expresie apar operanzi de tipuri numerice diferite, se fac conversii
implicite a operanzilor pentru fiecare operaŃie, astfel încât operaŃia să se efectueze între
operanzi de acelaşi tip.
Regula de bază constă în conversia operandului de tip cu domeniu de valori mai mic
către tipul cu domeniul de valori mai mare al celuilalt operand. Rezultatul fiecărei operaŃii
este de tipul stabilit pentru operanzi.
ExcepŃia o constituie operaŃia de atribuire (=) care respectă regulile descrise în
paragraful de descriere a acestui operator. Valoarea membrului drept este convertită la tipul
celui stâng. În această situaŃie se pot efectua conversii de la un tip cu reprezentare pe un
număr mai mare de octeŃi la un tip cu reprezentare pe număr mai mic de octeŃi, ceea ce poate
provoca trunchieri (ex.: float -> int), rotunjiri (ex: double -> float) ale valorilor sau pierderea biŃilor de ordin superior în exces (ex: long int -> char).
int i = 2;
float r = 3.5; // valoarea constantă 3.5, care are reprezentare double,// este convertită la tipul float şi apoi este atribuită// variabilei r
(i+2.1)*r // 2.1 este de tip double, deci valoarea de tip int a
// variabilei i se converteşte la tipul double, rezultatul// returnat de operaŃia i+2.1 este de tip double, ca urmare// şi valoarea variabilei float r se converteşte la double,// rezultatul final al expresiei fiind şi el de tip double
int i = 11;
printf(”%d”, i / 2); // afişează 5 – ambii operanzi sunt de tip int, deci şi// valoarea returnată este de tip int, astfel că există// corespondenŃă între format (%d) şi tipul datei afişate
printf(”%f”, (float) i / 2); // afişează 5.5 – se impune conversia operandului i la// tipul float, deci şi operandul 2 se va converti la acelaşi// tip şi în final tipul valorii returnate este tot float
printf(”%f”, i/2); // afişare eronată – se încearcă afişarea unei valori de tip// int în format float (%f)
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 114/267
114
Exemple
/**************************************************************************
Exemplu1 6.1. - Se scrie un program în care se exemplifică folosirea operatorilor aritmetici si
asimilaŃi cu aceştia: + - * / % ++ -- << >>**************************************************************************/ #include <stdio.h>#include <conio.h>
void main(){
int a, b;
printf("a=");scanf("%d", &a);
printf("b=");scanf("%d", &b);
printf("\n%d + %d = %d", a, b, a+b); printf("\n%d - %d = %d", a, b, a-b); printf("\n%d * %d = %d", a, b, a*b); printf("\n%d / %d = %d", a, b, a/b); printf("\n%d %% %d = %d", a, b, a%b);getch();
b=++a; printf("\nIncrementare (operatorul prefixat): a=%d, b=%d", a, b); b=a++; printf("\nIncrementare (operatorul postfixat): a=%d, b=%d", a, b);getch();
printf("\n%d << 3 = %d", a, a<<3); printf("\n%d >> 3 = %d", a, a>>3);getch();
}
/**************************************************************************
Exemplu1 6.2. - Se scrie un program în care se exemplifică folosirea operatorilor la nivel de
bit: ~ & | ^
**************************************************************************/ #include <stdio.h>#include <conio.h>
void main(){
int a, b; printf("a = ");scanf("%d", &a);
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 115/267
115
printf("b = ");scanf("%d", &b);
printf("\n ~ %d = %d", a, ~a); printf("\n%d & %d = %d", a, b, a&b); printf("\n%d | %d = %d", a, b, a|b);
printf("\n%d ^ %d = %d", a, b, a^b);getch();}
/**************************************************************************
Exemplu1 6.3. - Se scrie un program în care se exemplifică folosirea operatorilor aritmetici
**************************************************************************/ #include <stdio.h>#include <conio.h>
void main(){
int g, m, s; printf("grade:");scanf("%d", &g);
printf("minute =");scanf("%d", &m);
printf("secunde =");scanf("%d", &s);
m += s/60;s=s%60;g += m/60;m = m%60;g = g%360;
printf("\nUnghiul este: %d grd. %d min %d sec.", g, m, s);getch();
}
/**************************************************************************
Exemplu1 6.4. - Se scrie un program în care se exemplifică folosire a operatorului ternar ? :- se determina maximul dintre 3 valori.
**************************************************************************/ #include <stdio.h>#include <conio.h>
void main(){
int a, b, c, max;
printf("a=");scanf("%d", &a);
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 116/267
116
printf("b=");scanf("%d", &b);
printf("c=");scanf("%d", &c);
//varianta 1max = a>b ? a : b;max = max>c ? max : c;
printf("\n Maximul dintre %d, %d, %d este: %d", a, b, c, max);
//varianta 2max = a>b && a>c ? a : b>c ? b : c ;
printf("\n Maximul dintre %d, %d, %d este: %d", a, b, c, max);getch();
}
Rezumat
Operatorii sunt simboluri care, aplicate unor operanzi (date - constante,
variabile, expresii),au ca efect realizarea unor operaŃii care returnează un rezultat.
O succesiune validă de operanzi şi operatori formează o expresie.
Un criteriu de clasificare a operatorilor îl constituie numărul de operanzi cărora
li se aplică. Operatorii se clasifică în operatori unari (se aplică la un operand),operatori binari (se aplică la doi operanzi) şi ternari (se aplică la trei operanzi).
Prin atribuire, se înscrie (memorează) o valoare într-o variabilă (locaŃie de
memorie).
Operatorii pot opera cu date de tipuri predefinite.
OperaŃia de atribuire se poate efectua între tipuri de date diferite. În această
situaŃie, se produc conversii implicite ale lvalue către tipul rvalue.
OperaŃia modulo (% - restul împărŃirii întregi) şi operaŃiile la nivel de bit se pot
efectua numai cu valori întregi. OperaŃiile relaŃionale şi logici, indiferent de tipul operanzilor cărora li se aplică,
returnează valoare de tip int ( 0 – fals; 1 – adevărat).
La evaluarea expresiilor se are în vedere o ordine de efectuare a operaŃiilor
implicită, stabilită pe baza regulilor de prioritate şi asociativitate.
Dacă într-o expresie apar operanzi de tipuri numerice diferite, se fac conversii
implicite a operanzilor pentru fiecare operaŃie, astfel încât operaŃia să se
efectueze între operanzi de acelaşi tip.
ExcepŃia o constituie operaŃia de atribuire (=) în care valoarea membrului drept
este convertită la tipul celui stâng.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 117/267
117
Test de autoevaluare
1. Care din expresiile de mai jos sunt permise intr-un program C?a. int a = 25, b=3; a% = b;
b. char d = '&', m; m=d+1;c. int a=2; printf(”%d”, !a) ;d. const float e = 2.71; e = e-2;e. #define PI 3.141
++PI;
2. Care din secvenŃele de mai jos sunt permise intr-un program C?a. int i, j; i = 1 + ( j = 5 );
b. int a, b = -5; a = (!b) || (0e0);c. int a = 2; &a = 0x2000;
d. int a = 2; printf("Adresa: %p\n", &a);e. int a = 7, b = 2, c; c = a << (++b);
3. Se considera declaratia:int a = 2, b = 1;
Care din instrucŃiunile de mai jos au ca efect final a=1 si b=2:a. b = -a;
b. a- = b;c. a = ++b;d. b = --a;e. b = a--;
4. Se considera declaratia:int a = 7, b = 6;
Care din instrucŃiunile de mai jos au ca efect final coincidenta valorilor celor doua variabile:
a. a- = 1; b. b = -a;c. a = --b;d. ++b;e. nici una
5. Care din secvenŃele de mai jos sunt permise intr-un program C?a. ++(++n);
b. (&a)++;c. int x = sizeof(int);d. int y = sizeof(float);e. sizeof(float) = 4;
6. SecvenŃa de instrucŃiuni:int a = 9, b = 3, c;
c = a << b;
are ca efect atribuirea lui c a valorii:a. 27 b. 72
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 118/267
118
c. 3d. 1e. Nici una din cele de mai sus
7. SecvenŃa de instrucŃiuni:
int a = 9, b = 2, c; c = a >> b;are ca efect atribuirea lui c a valorii:a. 20
b. 80c. 160d. 10
8. Ce fel de operator este operatorul: <=a. operator la nivel de bit
b. operator relaŃionalc. operator de atribuire
d. operator logice. nu este operator
9. Ce fel de operator este operatorul >>a. operator de deplasare
b. operator logicc. operator relaŃionald. operator unar e. nu este operator
10. Care din atribuirile următoare sunt permise intr-un program C?a. 2+3 = b;
b. x -= 3;c. b = 2 + (3++);d. a &= b;e. a --= b++;
11. Care este rezultatul operaŃiei:25 & 42
a. 0 b. 8
c. 1d. 59e. nici unul din cele de mai sus
12. Care este rezultatul operaŃiei: 25 | 42a. 0
b. 59c. 8d. 1e. nici unul din cele de mai sus
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 119/267
119
13. Care este rezultatul operaŃiei: 25 ^ 42a. 59
b. 51c. 8d. depăşire de domeniu
e. eroare de sintaxa
14. Care este rezultatul operaŃiei:int a;a=7/2;
este:a. 3
b. 3.5c. 14d. eroare de sintaxae. nici unul din cele de mai sus
15. Rezultatul instrucŃiunii:x = ! ( 6%3 ) && ( 7 >> 3 );
este atribuirea lui x a valorii:a. 0
b. 1c. 2d. nici una din valorile de mai sus
Întrebări. ExerciŃii. Probleme.
1. Sa se scrie un program in care se declară o variabilă de tip char, una de tip int,
una float, una double şi un şir de caractere. Se citesc valori de la tastatură
pentru cele cinci variabile. Să se afişeze valoarea, adresa, număr de octeti
ocupaŃi pentru fiecare variabilă.
2. Să se scrie un program în care se declară o variabilă de tip int. Se citeşte
valoarea variabilei de la tastatură. Să se afişeze rezultatele operaŃiilor unarecare pot fi efectuate cu această variabilă, ca în exemplul prezentat.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 120/267
120
3. Să se scrie un program în care se declară o variabilă de tip float. Se citeşte
valoarea variabilei de la tastatură. Să se afişeze rezultatele operaŃiilor unare
care pot fi efectuate cu această variabilă (vezi problema nr. 2).
4. Să se scrie un program în care se declară două variabile de tip int. Se citesc
valori de la tastatură. Să se afişeze rezultatele tuturor operaŃiilor binare care
pot fi efectuate cu aceste variabile, ca în exemplul prezentat.
5. Să se scrie un program în care se declară două variabile de tip float. Se citesc
valori de la tastatură. Să se afişeze rezultatele tuturor operaŃiilor binare care
pot fi efectuate cu aceste variabile, ca în exemplul prezentat.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 121/267
121
Unitatea de învăŃare U.7. INSTRUCłIUNI (1)
CuprinsIntroducere .................................................................................................................. 121
Obiectivele unităŃii de învăŃare ................................................................................... 122
U7.1. Algoritmi ........................................................................................................... 122
U7.1.1. GeneralităŃi ......................................................................................... 122
U7.1.2. Reprezentarea algoritmilor ................................................................. 123
U7.2. InstrucŃiunea expresie ....................................................................................... 127
U7.3. InstrucŃiunea compusă (blocul de instrucŃiuni) ................................................. 128
U7.4. InstrucŃiuni de selecŃie (decizie) ....................................................................... 130U7.4.1. InstrucŃiunea de decizie if, if-else ....................................................... 130
U7.4.2. InstrucŃiunea de selecŃie multiplă switch ............................................ 132
Exemple ...................................................................................................................... 135
Rezumat ...................................................................................................................... 137
Test de autoevaluare ................................................................................................... 138
Întrebări, exerciŃii şi probleme .................................................................................... 139
Introducere
Aşa cum s-a arătat, calculatorul prelucrează datele de intrare printr-o
succesiune de transformări pentru a obŃine datele de ieşire. Succesiunea de
prelucrări este descrisă prin program. Fiecare prelucrare este rezultatul uneia sau
mai multor instrucŃiuni.
Ordinea de efectuare a prelucrărilor este importantă, ea respectând un
anumit algoritm.
Având în vedere faptul că un program este construit pe baza unui algoritm,
în această unitate de învăŃare vor fi prezentate generalităŃi despre algoritmi şi
modul de reprezentare a acestora.
Prezentarea algoritmilor nu este exhaustivă, având în vedere faptul că
prezentul curs are ca subiect de interes limbaje de programare (C/C++),
prezentarea se limitează doar la câteva aspecte necesare în înŃelegerea
instrucŃiunilor specifice limbajelor de programare şi a structurării programelor.
În continuare sunt prezentate instrucŃiunile specifice limbajelor C/C++.
În prezenta unitate de învăŃare sunt prezentate instrucŃiunile expresie,
instrucŃiuni compuse şi instrucŃiunile de decizie, celelalte instrucŃiuni urmând a fidiscutate în unitatea de învăŃare nr. 8.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 122/267
122
Obiectivele unităŃii de învăŃare
După parcurgerea acestei unităŃi de învăŃare trebuie să ştii:
Algoritmi - generalităŃi; reprezentarea algoritmilor prin scheme logice şi limbaj pseudocod;
Structurile de bază folosite în realizarea algoritmilor - structuri de control;
InstrucŃiunile limbajelor C/C++: expresie, instrucŃiune compusă, if/if-else,
switch.
Durata medie de parcurgere a celei de a şaptea unităŃi de învăŃare este de 2
ore.
U7.1. Algoritmi
U7.1.1. GeneralităŃi
Pot fi scrişi algoritmi care să descrie activităŃi din cele mai diverse domenii de viaŃă,
dar algoritmii destinaŃi scrierii programelor de calculator sunt cei care rezolvă probleme ce
admit o formulare matematică.
Algoritmul este o metodă generală de rezolvare a unei probleme, metodă care se poateimplementa în programe prin intermediul unui limbaj de programare.
Algoritmul poate fi gândit ca o succesiune de acŃiuni ce se pot aplica pentru obŃinerea
unui rezultat. În toate domeniile există activităŃi care pot fi descrise prin algoritmi. De
exemplu, adunarea a două fracŃii se realizează urmând următorii paşi:
- se amplifică fracŃiile pentru a le aduce la acelaşi numitor;
- se efectuează adunarea numărătorilor;
- se simplifică fracŃia obŃinută.
Algoritmii folosesc obiecte cu care se realizează diverse operaŃii.Algoritmii se caracterizează prin:
generalitate – proprietatea care descrie faptul că oferă o strategie de rezolvare a unei
probleme de un anumit tip;
finitudine – obŃinerea datelor de ieşire se face într-un număr finit de paşi şi într-un timp
finit;
unicitate – succesiunea de operaŃii este determinată în mod unic;
realizabilitate – toate operaŃiile descrise de algoritm pot fi realizate cu resursele existente;
eficienŃa – această caracteristică are în vedere atât timpul cerut pentru execuŃie
(complexitatea-timp), cât şi resursele necesare pentru execuŃie, cum ar fi memorie, număr de
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 123/267
123
regiştri etc. (complexitate-spaŃiu) – această caracteristică este influenŃată şi de maşina pe care
este implementat algoritmul.
Etapele care trebuie urmate de la enunŃul problemei de rezolvat până la obŃinerea
produsului software final (programul) sunt următoarele:
stabilirea caietului de sarcini (enunŃul problemei) – trebuie să fie bine definit, astfel încât
să fie clar ce trebuie să se execute; de regulă este elaborată de utilizatorul programului
împreună cu programatorul;
elaborarea algoritmilor – se face pe baza analizei problemei, prin aplicarea unor tehnici de
elaborare; obŃinerea unor algoritmi eficienŃi presupune şi o oarecare experienŃă de lucru ;
exprimarea algoritmilor – se face prin intermediul unui limbaj de programare folosit în
implementarea algoritmului care trebuie să fie clară şi concisă; modul de abordare depinde de
tipul limbajului utilizat, astfel, în anii ’80 stilul era programarea structurată, ulterior s-a impus
programarea orientată pe obiecte (C++ permite ambele abordări). validarea algoritmilor – este etapa în care se obŃine confirmarea corectitudinii
algoritmului, indiferent de limbajul folosit;
analiza algoritmilor – se face pe baza unui criteriu de apreciere stabilit care permite
alegerea celui mai eficient algoritm; se poate avea în vedere memoria utilizată, viteza de
execuŃie, etc.
testarea programului – presupune depanarea programului şi trasarea, adică determinarea
memoriei necesare şi a timpului de calcul, etapă care se realizează prin execuŃii repetate cu
seturi de date de intrare diferite.
U7.1.2. Reprezentarea algoritmilor
În general, descrierea algoritmului este o etapă intermediară între formularea
matematică şi programul scris într-un limbaj oarecare.
Descrierea algoritmului se poate face folosind diferite metode. Frecvent folosite sunt
următoarele:
- reprezentarea în limbaj natural – acest mod de reprezentare nu presupune o
pregătire specială, dar pentru probleme complexe poate introduce neclarităŃi;
- reprezentarea prin scheme logice – este o reprezentare grafică în care fiecare etapă
este reprezentată printr-un bloc, blocurile fiind înlănŃuite prin segmente orientate, ordinea lor
respectând logica problemei ;
- reprezentarea în limbaj pseudocod – limbajul pseudocod este apropiat de
codificarea din Pascal sau C, permite o reprezentare clară şi concisă;
- reprezentarea prin tabele de decizie – metoda e specifică problemelor cu număr
mare de alternative, ele apelând la logica booleană inventariază toate acŃiunile posibile prin
combinarea condiŃiilor precizate.Pentru etapa de familiarizare cu un limbaj de programare şi cu logica algoritmică şi
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 124/267
124
utilizarea structurilor de control, metoda de reprezentare prin scheme logice, care este o
metodă ilustrativă, este sugestivă, etapele şi fluxul de prelucrare fiind uşor de urmărit.
Există trei tipuri de scheme logice:
- scheme de program – care descriu toate procesele de prelucrare pornind de la datele
de intrare până la obŃinerea rezultatelor;
- scheme de detaliere – care descriu procese complexe la nivel de detaliu, secvenŃele
apărând o singură dată în program;
- scheme de subprograme (rutine) – care descriu procese repetabile în program.
Blocurile folosite pentru reprezentarea etapelor de evoluŃie a algoritmului sunt
următoarele:
Blocuri de control – delimitează începutul şi sfârşitul schemei logice.
Pentru scheme program:
Pentru scheme de detaliere:
Pentru scheme de subprogram:
Prin nume se precizează numele rutinei, iar parametrii formali precizează datele care
vor fi prelucrate de aceasta.
Blocuri de intrare/ieşire – precizează datele de intrare, respectiv cele de ieşire ale
algoritmului.
- bloc comun celor două tipuri de operaŃii:
- blocuri distincte pentru operaŃiile de intrare/ieşire:
Blocuri de atribuire – precizează expresia de evaluat şi variabila căreia i se atribuie
rezultatul:
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 125/267
125
Blocuri de decizie – marchează punctele de ramificare a
programului şi expresia condiŃională care determină evoluŃia
algoritmului în continuare.
Blocuri de blocuri – inserează în algoritm un subprogram predefinit, precizând numele
acestuia.
Blocuri de apel rutine – apelul unei rutine pentru care se precizează numele acesteia şi
valorile transmise pentru parametri.
Blocuri de conectare – se folosesc pentru algoritmi complecşi, pentru sporirea lizibilităŃii
algoritmului.
Conectare în pagină - pentru evitarea intersectărilor arcelor ce unesc blocurile
Conectare între pagini – se folosesc atunci când algoritmul nu se poate reprezenta pe
o singură pagină.
Pentru realizarea schemelor logice, în anii ’70, s-au impus principiile programării
structurate. Acestea au dus la o puternică dezvoltare a limbajelor de programare.Prin aplicarea principiilor programării structurate, se obŃine:
- claritate în citirea programelor;
- depanarea uşoară a programelor;
- generalitatea programelor şi uşurinŃă în refolosirea codului scris.
Structurile de control care stau la baza programării structurate sunt:
- structura secvenŃială;
- structura alternativă;
- structura repetitivă.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 126/267
126
Structura secvenŃială – reprezintă o înlănŃuire de prelucrări în care o
prelucrare începe numai după finalizarea precedentei.
Structuri alternative (de decizie) – selectează variante de prelucrate în
funcŃie de condiŃiile evaluate prin intermediul unei expresii logice.
Acestea pot fi:
Structura pseudo-alternativă (fig. 7.1.)
Structura alternativă simplă (fig. 7.2.)
Structura alternativă multiplă (fig. 7.3.)
Fig. 7.1. Structură pseudo-alternativă Fig. 7.2. Structură alternativă simplă
Fig. 7.3. Structură alternativă multiplă
Structuri repetitive – descriu un proces ce se repetă în funcŃie de îndeplinirea anumitor
condiŃii:
Structura repetitivă cu test anterior (test iniŃial) (fig. 7.4.)
Structura repetitivă cu test posterior (test final) (fig. 7.5.) Structura repetitivă cu contor (fig. 7.6.)
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 127/267
127
Fig.7.4. Structură repetitivăcu test iniŃial
Fig.7.5. Structură repetitivăcu test final
Fig.7.6. Structură repetitivă cucontor
U7.2. InstrucŃiunea expresie
Prelucrările efectuate de program sunt descrise prin instrucŃiuni.
Modificările făcute asupra unor variabile se realizează prin operaŃia de atribuire,
valoarea atribuită fiind rezultatul evaluării unei expresii. InstrucŃiunea care realizează acest
lucru se numeşte instrucŃiune expresie.
Toate celelalte instrucŃiunile stabilesc succesiunea prelucrărilor folosind cele trei
structuri de control: secvenŃiale (succesiuni de operaŃii, instrucŃiuni compuse), de decizie şi
repetitive.
O instrucŃiune expresie este o expresie care se încheie cu punct şi virgulă (;) sintaxa
fiind:
< expresie > ;
Exemple de instrucŃiuni expresie:
int i, j;float r;…i = 10;
j = i * 5;r = (float) i / j + 1.5 ;
InstrucŃiunile se pot scrie pe mai multe linii de program, spaŃiile nesemnificative fiind
ignorate.
int i;i=5;
Pe o linie de program se pot scrie mai multe instrucŃiuni.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 128/267
128
int i, j;i = 2; j += i;
Pot fi incluse instrucŃiuni expresie care nu produc efecte. Acestea sunt semnalate de
compilator printr-un mesaj de atenŃionare (warning - cod as no efect). Acestea nu introducerori în evoluŃia programului, dar încarcă în mod inutil codul.
InstrucŃiunea vidă – se încadrează tot în categoria instrucŃiunilor expresie.
InstrucŃiunea vidă are forma:;
InstrucŃiunea vidă semnifică lipsa oricărei acŃiuni. Ea este utilă în anumite situaŃii când
sintaxa impune o instrucŃiune, însă programul nu cere nici o acŃiune.
Exemplele de folosire a instrucŃiunii vide vor fi incluse în paragrafele următoare.
U7.3. InstrucŃiunea compusă (blocul de instrucŃiuni)
InstrucŃiunea compusă grupează declaraŃii şi instrucŃiuni, începutul şi sfârşitul blocului
fiind marcat de acolade ({ }). Blocul de instrucŃiuni este sintactic echivalent cu o instrucŃiune.
Sintaxa generală este:{
lista_declaratii;lista_instructiuni;
}ConŃinutul unui bloc de instrucŃiuni poate fi descris într-un algoritm printr-o structură
secvenŃială.
InstrucŃiunile compuse se utilizează deseori în combinaŃie cu instrucŃiunile de ciclare
şi cele de decizie.
ObservaŃii
Toate variabilele declarate în interiorul unei instrucŃiuni compuse nu pot fiaccesate în afara acesteia, domeniul lor de existenŃă fiind blocul de
instrucŃiuni.
Exemplu de utilizare a blocului de instrucŃiuni:
#include <stdio.h>
void main(){
int i; // se declară i, variabilă locală funcŃiei main()int k; // se declară k, variabilă locală funcŃiei main()
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 129/267
129
i=7;k=12;{ // începutul blocului
int i; // se declară variabila i locală bloculuiint j; // se declară variabila j locală blocului
i=9; // se foloseşte variabila i locală blocului j=2*i;k++; // în interiorul blocului se foloseşte
// variabila k, declarată în main(), ea având// ca domeniu întreaga funcŃie, inclusiv// blocul de instrucŃiuni
printf(“\ni=%d”, i); // se afişează i=9 , valoarea variabilei// locale blocului de instrucŃiuni
printf(“\nj=%d”, j); // se afişează j=18 printf(“\nk=%d”, k); // se afişează k=12
} // sfârşitul blocului
printf(“\ni=%d”, i); // se afişează i=7, valoarea variabilei locale// funcŃiei main()
printf(“\nj=%d”, j); // eroare, instrucŃiunea se află în afara// domeniului de existenŃă a lui j
printf(“\nk=%d”, k); // se afişează k=13}
ObservaŃii
Variabilele declarate în interiorul unui bloc, sunt locale acelui bloc: se
alocă în memorie doar în momentul în care se execută blocul şi încetează
să existe odată cu terminarea acestuia. Domeniul acestor variabile este
blocul de instrucŃiuni şi durata de viaŃă este perioada execuŃiei blocului.
Variabila k este declarată în main(), înainte de blocul de instrucŃiuni, ea va
avea ca domeniu întreaga funcŃie main(), deci va putea fi folosită şi în
interiorul blocului.
Dacă există variabile cu acelaşi nume atât în afara blocului, cât şi îninteriorul lui, cea externă lui nu va putea fi accesată, prioritate având cea
locală blocului. În situaŃia din exemplu nu se poate folosi operatorul de
rezoluŃie (::), acesta putând fi folosit doar în cazul variabilelor globale.
Ambele variabilele cu numele “i” sunt variabile locale, cu alocare pe stivă.
Variabila j este locală blocului de instrucŃiuni, ea încetând să existe odată
cu încheierea blocului de instrucŃiuni, deci în afara acestuia nu poate fi
referită.
În limbajul C declaraŃiile de variabile de fac la începutul blocului, în timp
ce, în cazul limbajului C++ pot fi făcute oriunde în blocul respectiv, înainte
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 130/267
130
de utilizarea lor. Totuşi, pentru a da lizibilitate programului, este de
preferat ca aceste declaraŃii să se facă la începutul blocului şi în cazul
limbajului C++.
U7.4. InstrucŃiuni de selecŃie (decizie)
U7.4.1. InstrucŃiunea de decizie if, if-else
Sintaxa instrucŃiunii poate fi:if(condiŃie)
instrucŃiune_1; (1)
sauif(condiŃie)
instrucŃiune_1;else
instrucŃiune_2(2)
InstrucŃiunea if evaluează logic expresia “condiŃie”. Se are în vedere faptul că se
interpretează valoare logic adevărată orice valoare numerică diferită de 0 (zero), şi logic falsă
valoarea 0. Deci, în cazul în care valoarea expresiei “condiŃie” este nenulă, se execută
instrucŃiune_1, iar dacă este nulă se execută instrucŃiunea imediat următoare instrucŃiunii if,
pentru prima formă a sintaxei, sau instrucŃiune_2 în cazul celei de a doua forme.
InstrucŃiunea if / if-else reprezintă o structură alternativă, prima formă, (1), fiind o
structură pseudo-alternativă, cea de a doua, (2) reprezentând structura alternativă simplă.Expresia “condiŃie” trebuie să fie o expresie scalară, care returnează o valoare.
De exemplu, dacă se doreşte ca o variabilă să păstreze valoarea sa absolută, se poate
folosi instrucŃiunea if (secvenŃă pseudo-alternativă):
int a; //... // instrucŃiunea if pseudo-alternativăif (a < 0) // poate fi descrisă în schemă logică
a = -a; // prin figura alăturată... //
ObservaŃii
SecvenŃa scrisă anterior poate fi scrisă şi folosind operatorul ternar,
folosind instrucŃiunea:a = (a < 0) ? –a : a ;
Dacă se doreşte determinarea maximului dintre două valori, se poate folosi
instrucŃiunea if – else (secvenŃă alternativă simplă):
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 131/267
131
int a, b, max; //... //if (a > b) // instrucŃiunea if – else poate fi
max = a; // descrisă în schemă logică prinelse // figura alăturată
max = b; //... //
ObservaŃii
Altă variantă de scriere a secvenŃei anterioare poate folosi o secvenŃă
pseudo-alternativă (if):
max = a;
if (max < b)
max = b;
SecvenŃa scrisă anterior poate fi scrisă şi folosind operatorul ternar,
folosind instrucŃiunea:max = (a >b 0) ? a : b ;
Nu se poate înlocui instrucŃiunea if / if-else cu operatorul ternar în orice
situaŃie. Acest lucru este posibil doar dacă instrucŃiune_1 şi instrucŃiune_2
returnează valoare compatibilă cu tipul variabilei aflată în stânga
operatorului de atribuire.
Prin folosirea operatorului ternar rezultă un cod mai compact, dar folosireainstrucŃiunii if este mai sugestivă şi face mai uşoară citirea programului.
InstrucŃiunea if/if-else poate fi folosită şi pentru descrierea secvenŃelor alternative
multiple. În acest caz se recurge la folosirea instrucŃiunilor if imbricate, adică, una, sau
ambele dintre instructiune_1 şi instructiune_2 pot fi la rândul lor instrucŃiuni if/if-else.
Pentru ilustrarea scrierii acestor secvenŃe, se ia ca exemplu secvenŃa următoare, în care
se determină maximul dintre două valori:
int a, b, c, max; // SecvenŃa poate fi reprezentată prin figura alăturată... //if(a>b) //
if(a>c) //max = a; //
else //max = c; //
else //if(b>c) //
max = b; //
else //max = c;
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 132/267
132
Aceeaşi secvenŃă se poate rescrie în diferite variante. În general, orice problemă poate
fi implementată în diferite variante. Aceasta depinde de stilul adoptat de programator şi, de
multe ori, o variantă este adoptată în urma analizei algoritmului adoptat, astfel încât să se
obŃină eficienŃă cât mai mare.
In continuare este prezentată o altă variantă de secvenŃă care determină maximul
dintre trei valori.
int a, b, c, max; // SecvenŃa poate fi reprezentată prin figura alăturată... //if(a>b && a>c) //
max = a; //else //
if(b>c) //max = b; //
else //max = c; //
... //
U7.4.2. InstrucŃiunea de selecŃie multiplă switch
InstrucŃiunea switch este o instrucŃiune decizională, ea permiŃând selecŃia, în funcŃie
de valoarea unei expresii, între mai multe opŃiuni posibile. Sintaxa instrucŃiunii este:
switch (expr){
case const1: lista_instructiuni;<break;>
case const2: lista_instructiuni;<break;>
…..<default> lista_instructiuni;
}
unde: expr este o expresie întreagă (orice tip întreg sau enumerare);
const1, const2,... sunt constante de selecŃie, de tip întreg, cu valori distincte;
lista_instructiuni este o secvenŃă de instrucŃiuni;
La execuŃia instrucŃiunii, se evaluează expr. Valoarea obŃinută se compară succesiv cu
valorile constantelor de selecŃie. Dacă se găseşte identitate de valoare, se execută succesiunea
de instrucŃiuni asociată.
InstrucŃiunea break întrerupe execuŃia instrucŃiunii switch. Dacă lista_instrucŃiuni nueste urmată de break, se continuă execuŃia cu lista de instrucŃiuni ataşată următoarei etichete.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 133/267
133
Dacă valoarea expresiei nu se regăseşte printre etichete, se execută secvenŃa de
instrucŃiuni asociată cu eticheta default. În lipsa acesteia, se finalizează execuŃia instrucŃiunii
switch.
Pentru exemplificarea folosirii instrucŃiunii switch este prezentată în continuare
următoarea aplicaŃie:
Se citesc de la tastatură două valori numerice întregi. Se citeşte de la tastatură operaŃia
care se doreşte a se efectua între aceşti doi întregi (+, -, *, /, %) şi se afişează rezultatul
acesteia.
#include <stdio.h>
void main(){
int a, b; // variabile folosite pentru citirea celor doi întregichar op; // variabila op este folosită pentru citirea ca şi caracter a tipului// de operaŃie dorit
printf("Introdu doua valori intregi:"); printf("\na=");scanf("%d", &a);
printf("\nb=");scanf("%d", &b);
printf("Introdu un operator aritmetic, simplu, binar (+, -, *, /, %) :");
fflush(stdin); // golirea buffer-ului de intrare astfel încât citirea următoare, a
// caracterului care desemnează operaŃia, să se facă corect
scanf("%c", &op); // citirea se face în format caracter
switch (op) // expresia folosită pentru selecŃie este chiar valoarea// caracterului citit de la tastatură
{case ('+'): printf("\n Operatia de adunare - rezultat: %d", a+b);
break;case ('-'): printf("\n Operatia de scadere - rezultat: %d", a-b);
break;case ('*'): printf("\n Operatia de inmultire - rezultat: %d", a*b);
break;case ('/'): printf("\n Operatia de impartire - rezultat: %d", a/b);
break;case ('%'): printf("\n Operatia de impartire intreaga - rest: %d", a%b);
break;default: printf("\nOperatie ilegala!");
}}
SecvenŃa switch care selectează operaŃia aritmetică ce se efectuează implementeazăschema logică din Fig. 7.7.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 134/267
134
Fig.7.7. Schema logică pentru secvenŃa se selecŃie a operaŃiei
ObservaŃii
SelecŃia multiplă se poate implementa, aşa cum am văzut, folosindinstrucŃiunea if/if-else, dar, dacă selecŃia este controlată de valoarea unei
singure expresii, este mai eficient şi mai clar să se folosească instrucŃiunea
switch.
InstrucŃiunea switch evaluează doar egalitatea de valori, în timp ce if poate
evalua orice tip de expresie relaŃională sau logică.
Dacă în instrucŃiunea switch constantele sunt de tip caracter, automat sunt
convertite la întreg prin codul ASCII corespunzător.
Într-o instrucŃiune switch nu pot exista mai multe constante case cu valoriidentice.
Se pot asocia mai multe etichete scrise consecutiv cu aceleaşi secvenŃe de instrucŃiuni.
Această situaŃie se regăseşte în exemplul următor.
Se doreşte asocierea caracterelor ce reprezintă o cifră hexazecimală cu valoarea
numerică corespunzătoare în baza 10. Caracterele pot fi: 0, 1, 2,...9, a, A, b, B..., f, F.
char cifra;
int i;//...
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 135/267
135
switch (cifra){case ’0’: i=0; break;
case ’1’: i=1; break;//...
case ’9’: i=9; break;
case ’a’: // dacă cifra are ca valoare caracterul ’a’ sau ’A’case ’A’: i=10; break; // i primeşte aceeaşi valoare, 10case ’b’: // dacă cifra are ca valoare caracterul ’b’ sau ’B’case ’B’: i=11; break; // i primeşte aceeaşi valoare, 11case ’c’: // dacă cifra are ca valoare caracterul ’c’ sau ’C’case ’C’: i=12; break; // i primeşte aceeaşi valoare, 12case ’d’: // dacă cifra are ca valoare caracterul ’d’ sau ’D’case ’D’: i=13; break; // i primeşte aceeaşi valoare, 13case ’e’: // dacă cifra are ca valoare caracterul ’e’ sau ’E’case ’E’: i=14; break; // i primeşte aceeaşi valoare, 14case ’f’: // dacă cifra are ca valoare caracterul ’f’ sau ’F’
case ’F’: i=15; // i primeşte aceeaşi valoare, 15// fiind ultima instrucŃiune din secvenŃa switch, nu
} // este necesară instrucŃiunea break
Exemple
/**************************************************************************
Exemplu1 7.1. - Se scrie un program pentru rezolvarea ecuaŃiei de gradul II:
0cx b2xa =+⋅+⋅
**************************************************************************/ #include <stdio.h>#include <conio.h>#include <math.h>#include <stdlib.h>
void main()
{float a, b, c, delta, x1, x2; printf("coeficientul lui x^2:");if (scanf("%f", &a)!=1){printf("Coeficientul lui x^2 este incorect!\n");getch();return; // se poate folosi si apelul functiei: exit(0);
} printf("coeficientul lui x:");if (scanf("%f", &b)!=1){printf("Coeficientul lui x este incorect!\n");getch();
return; // exit(0);}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 136/267
136
printf("termenul liber:");if (scanf("%f", &c)!=1){printf("Termenul liber este incorect!\n");getch();return; // exit(0);
}if (a==0 && b==0 && c==0){printf("Ecuatie nedeterminata !\n");getch();return; // exit(0);
}if (a==0 && b==0){printf("Ecuatie imposibila !\n");getch();return; // exit(0);
}
if (a==0){printf("Ecuatie de grad I"); printf("\nSolutia este: x=%.2f\n", -c/b);getch();return; // exit(0);
}delta= b*b - 4*a*c;if ( delta<0){printf("radacini complexe\n"); printf("x1= %.2f + i %.2f\n", -b/(2*a), sqrt(-delta)/(2*a)); printf("x2= %.2f - i %.2f\n", -b/(2*a), sqrt(-delta)/(2*a));getch();return; // exit(0);
}if ( delta==0 ){printf("Radacini reale si egale:\n"); printf("x1=x2=%.2f\n", -b/(2*a));getch();return; // exit(0);
} printf("Radacini reale si distincte:");
printf("\nx1=%.2f\n", (-b+sqrt(delta))/(2*a)); printf("\nx2=%.2f\n", (-b-sqrt(delta))/(2*a));getch();
}
/**************************************************************************
Exemplu1 7.2. - Se scrie un program care citeşte de la tastatură un întreg. Corespunzător valorii acestuia se afişează denumirea zilei corespunzătoare din săptămână.
**************************************************************************/
#include<stdio.h>#include<conio.h>
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 137/267
137
main(){int zi;
printf("\nIntrodu un numar <=7 :");scanf("%d", &zi);
switch (zi){ case 1: printf("\nZiua %d este Luni", zi);break;case 2: printf("\nZiua %d este Marti", zi);break;case 3: printf("\nZiua %d este Miercuri", zi);break;case 4: printf("\nZiua %d este Joi", zi);break;case 5: printf("\nZiua %d este Vineri", zi);break;case 6: printf("\nZiua %d este Sambata", zi);break;case 7: printf("\nZiua %d este Duminica", zi);break;default: printf("\nValoarea introdusa este incorecta !");
} printf("\n");
getch();}
Rezumat
La întocmirea unui algoritm, trebuie să se asigure proprietăŃi cum sunt:
generalitate, finitudine, unicitate, realizabilitate, eficienŃă.
Reprezentarea algoritmilor se poate face în diferite moduri, frecvent folosite
fiind reprezentarea în limbaj pseudocod şi reprezentarea prin scheme logice. Pentru realizarea schemelor se aplică principiile programării structurate care
presupun folosirea structurilor de control secvenŃială, alternativă şi repetitivă.
Modificările făcute asupra unor variabile se realizează prin operaŃia de atribuire,
valoarea atribuită fiind rezultatul evaluării unei expresii.
InstrucŃiunea vidă semnifică lipsa oricărei acŃiuni; ea este formată numai din
caracterul punct şi virgulă (;).
InstrucŃiunea compusă grupează declaraŃii şi instrucŃiuni, începutul şi sfârşitul
blocului fiind marcat de acolade ({ }). Variabilele declarate în interiorul unei bloc de instrucŃiuni au ca domeniu de
existenŃă blocul în care au fost declarate.
InstrucŃiunea if-else este o instrucŃiune de decizie care permite alegere între
două variante de evoluŃie a programului în funcŃie de valoarea unei expresii
condiŃionale.
InstrucŃiunea switch este o instrucŃiune decizională care permite selecŃia, în
funcŃie de valoarea unei expresii, între mai multe opŃiuni posibile.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 138/267
138
Test de autoevaluare
1. SecvenŃa de program :#include<stdio.h>void main(){ int a=3,b=7;
if (!(a-b)) { a++; printf("%d\n", a);
}else { b++;
printf("%d\n", b);}
}va produce :
a. incrementarea variabilei b si apoi afisarea sa b. incrementarea variabilei a si apoi afisarea sac. eroare de sintaxad. nici un răspuns nu este corect
2. SecvenŃa de program :#include<stdio.h>void main(){ int a=3, b=5, c=2, x;
if(a<b)if(a<c) x=a;
else x=c;}
va produce :a. atribuirea lui x a valorii lui c
b. atribuirea lui x a valorii lui ac. eroare de sintaxad. nici un răspuns nu este corect
3. Se considera instrucŃiunile :switch(i){ case 1 : i+=2; break;
case 2 : i+=3;
default: i+=4;}
printf("%d\n", i);Care propoziŃii sunt adevărate ?
a. daca i=1, se va afisa valoarea 3 b. daca i=1, se va afisa valoarea 2c. daca i=8, se va afisa valoarea 12d. daca i=2, se va afisa valoarea 5
4. Se considera secvenŃa de program :
switch(i){ case 1: i+=2;break;case 2: i+=3;
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 139/267
139
default: i+=4;}
printf("%d\n", i);Care propoziŃii sunt corecte ?
a. daca i=2, se va afisa valoarea 9
b. daca i=2, se va afisa valoarea 5c. daca i=6, se va afisa valoarea 10d. daca i=1, se va afisa valoarea 3
5. Se considera secvenŃa de program :switch(i)
{ case ’1’: i+=2; break;case ’2’: i+=3;case ’3’: i+=4;
} printf("%d\n", i);
Care propoziŃii sunt corecte ?a. daca i=2, se va afisa valoarea 5
b. daca i=1, se va afisa valoarea 3c. daca i=4, va apare o eroared. daca i=2, se va afisa valoarea 9
Întrebări. ExerciŃii. Probleme.
1. Să se scrie un program în care se declară o variabilă de tip int pentru care se
citeşte valoare de la tastatură. Să se afişeze un mesaj care să indice dacă
valoarea este pară sau impară.
2. Să se scrie un în care se declară trei variabile de tip float pentru care se citesc
valori de la tastatură. Să se verifice dacă valorile pot reprezenta laturile unui
triunghi şi dacă da, să se calculeze şi să se afişeze aria triunghiului.
3. Sa se scrie un program in care se citeste de la tastatura o data calendaristica
(zi, luna, an - citite ca valori întregi). Sa se afişeze data, pentru luna fiind
afişata denumirea. De exemplu, data 15.10.2009 va fi afişată 15 octombrie
2009. In secvenŃa de afisare se va folosi instrucŃiunea switch.
4. Să se scrie un program în care se declară două variabile de tip int pentru care
se citesc valori de la tastatură. Se selectează tipul operaŃiei care se doreşte a
se efectua între cele două valori prin apăsarea simbolului asociat operaŃiei ( +,-, *, /, %).
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 140/267
140
Unitatea de învăŃare U.8. INSTRUCłIUNI (2)
Cuprins
Introducere .................................................................................................................. 140
Obiectivele unităŃii de învăŃare ................................................................................... 140
U8.1. InstrucŃiuni de ciclare (repetitive) ..................................................................... 141
U8.1.1. InstrucŃiunea de ciclare cu test iniŃial (while) ..................................... 141
U8.1.2. InstrucŃiunea de ciclare cu test final (do-while) ................................. 143
U8.1.3. InstrucŃiunea de ciclare cu contor (for) ............................................... 145
U8.2. InstrucŃiuni de salt ............................................................................................. 147U8.2.1. InstrucŃiunea break .............................................................................. 147
U8.2.2. InstrucŃiunea continue ......................................................................... 149
U8.2.3. InstrucŃiunea return ............................................................................. 150
U8.2.4. FuncŃia exit() ....................................................................................... 151
U8.2.5. InstrucŃiunea de salt necondiŃionat goto ............................................. 153
Exemple ...................................................................................................................... 154
Rezumat ...................................................................................................................... 156
Test de autoevaluare ................................................................................................... 157Întrebări, exerciŃii şi probleme .................................................................................... 159
Introducere
Prezenta unitate de învăŃare continuă prezentarea instrucŃiunilor specifice
limbajelor C/C++.
Sunt prezentate instrucŃiunile repetitive care permit executarea în modrepetat a unor secvenŃe de program atât timp cât o condiŃie (expresie) este logic
adevărată (while, do-while, for).
Pentru a forŃa întreruperea execuŃiei structurilor secvenŃiale, alternative sau
repetitive, se pot folosi instrucŃiuni de salt (break, continue, return, goto) sau
funcŃia exit().
Se poate întrerupe execuŃia unui bloc de instrucŃiuni, a unei funcŃii sau
chiar a programului în totalitatea sa.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 141/267
141
Obiectivele unităŃii de învăŃare
După parcurgerea acestei unităŃi de învăŃare trebuie să ştii:
Sintaxa şi modul de utilizare a instrucŃiunilor repetitive ale limbajelor C/C++;
Sintaxa şi modul de utilizare a instrucŃiunilor de salt ale limbajelor C/C++ .
Durata medie de parcurgere a celei de a opta unităŃi de învăŃare este de 2 ore.
U8.1. InstrucŃiuni de ciclare (repetitive)
U8.1.1.
Sintaxa instrucŃiunii este:while (expresie)
instrucŃiune;
unde expresie e orice expresie logică, iar instrucŃiune, o instrucŃiune simplă sau bloc de
instrucŃiuni.
La execuŃie, se testează valoarea expresiei. Dacă este logic adevărată (nenulă), se
execută instrucŃiune. Se evaluează expresia din nou şi dacă este în continuare adevărată se reia
execuŃia instrucŃiunii. Se repetă această succesiune de operaŃii atât timp cât expresie rămâne
adevărată. În momentul în care expresie a devenit falsă (zero), se întrerupe execuŃiainstrucŃiunii while şi se trece la instrucŃiunea imediat următoare din program.
int i;i = 5;while (i) // se testează valoarea lui i; iniŃial are{ // valoarea 5, deci se va executa blocul de
// instrucŃiuni; i este afişat şi decrementat; printf(”\ni=d”, i ); // se repetă afişarea şi decrementarea lui ii--; // până când acesta ia valoarea zero;
// în acel moment se întrerupe execuŃia} // instrucŃiunii while şi se trece la// următoarea linie din program.
…
De obicei valoarea expresiei care constituie condiŃia de ciclare este modificată în
interiorul secvenŃei care se repetă. Dacă valoarea acesteia nu este modificată, există riscul de
repetare fără sfârşit a instrucŃiunii, evoluŃia programului fiind blocată. Există instrucŃiuni care
pot forŃa ieşirea dintr-o instrucŃiune repetitivă. Acestea vor fi prezentate în paragrafele
următoare.În exemplul următor se implementează, folosind instrucŃiunea while, următoarea
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 142/267
142
aplicaŃie:
Se calculează media aritmetică a N valori citite de la tastatură. Valoarea N este, de
asemenea citită de la tastatură.
#include <stdio.h>
void main(){
int i, N; // variabila i va fi folosită ca şi contor pentru numărarea// valorilor citite; ea va controla evoluŃia secvenŃei repetitive
float val; // variabila val se foloseşte pentru citirea valorilor de la tastaturăfloat rez; // variabila rez este folosită pentru calculul mediei aritmetice
printf("Introdu numărul de valori:");scanf("%d", &N);
i = 1; // se fac iniŃializări pentru variabilele utilizate în secvenŃarez = 0; // repetitivă
while (i <= N) // condiŃia de execuŃie a ciclului - compară valorile i şi N{
printf("Introdu o valoare:");scanf("%f", &val);rez = rez + val;i++; // modificarea valorii variabilei de control a evoluŃiei ciclului
}
rez = rez/N; printf("\nMedia aritmetica a valorilor este: %10.2f\n", rez);}
ObservaŃii
Dacă în momentul de început al instrucŃiunii while condiŃia nu este
îndeplinită se trece direct la instrucŃiunea imediat următoare acesteia.
În exemplul anterior, dacă N primeşte valoare <1, instrucŃiunea while nu
va fi executată. Se trece la instrucŃiunea rez = rez/N. Dacă N=0, se ajunge
la o situaŃie care produce eroare fatală, şi anume împărŃirea la zero.
Pentru un ciclu care se repetă până la apăsarea tastei ‘N’, se poate scrie:
char ch ;...while( ch != ’N’)
{ ...
ch=getch();}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 143/267
143
sau:
char ch ;...
while( ch=getch() != ’N’){...
}
InstrucŃiunea care se repetă poate fi instrucŃiunea vidă, ca în exemplul următor:
char ch ;...while( ch=getch() != ’X’) ;
...
Efectul acestei instrucŃiuni este că, pentru ca programul să poată continua, trebuie
apăsată tasta ’X’.
U8.1.2. InstrucŃiunea de ciclare cu test final (do-while)
Sintaxa generală a instrucŃiunii este:
doinstructiune;
while (expresie);
InstrucŃiunea instructiune se execută atât timp cât expresie este nenulă. Evaluarea
expresiei expresie se face după executarea instrucŃiunii instructiune.
.........i=5;
do{ printf(”\ni=%d”, i );i--;
} // expresia condiŃională se evaluează dupăwhile (i); // ce blocul de instrucŃiuni a fost executat o
// dată; reluarea execuŃiei lui se face numai// dacă i ≠0
Se reia aplicaŃia care calculează media aritmetică a N valori citite de la tastatură
folosind pentru implementare instrucŃiunea do-while.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 144/267
144
#include <stdio.h>
void main(){
int i, N; // variabila i va fi folosită ca şi contor pentru numărarea valorilor citite;
// ea va controla evoluŃia secvenŃei repetitivefloat val; // variabila val se foloseşte pentru citirea valorilor de la tastaturăfloat rez; // variabila rez este folosită pentru calculul mediei aritmetice
printf("Introdu numarul de valori:");scanf("%d", &N);
i = 1; // se fac iniŃializări pentru variabilele utilizate în secvenŃarez = 0; // repetitivă
do{
printf("Introdu o valoare:");scanf("%f",&val);rez = rez + val;i++; // modificarea valorii variabilei de control a evoluŃiei ciclului
}while (i<=N); // condiŃia de execuŃie a ciclului - compară valorile i şi N
rez = rez/N; printf("\nMedia aritmetica a valorilor este: %10.2f\n", rez);
}
ObservaŃii
Blocul de instrucŃiuni se execută cel puŃin odată, indiferent de valorile
variabilelor i şi N
Dacă N primeşte valoare <1, instrucŃiunea do-while va fi întreruptă, ca şi
în cazul folosirii instrucŃiunii while. Se trece la instrucŃiunea rez = rez/N.
Dacă N=0, se ajunge la o situaŃie care produce eroare fatală, şi anume
împărŃirea la zero.
În cazul celor două versiuni care folosesc instrucŃiunea while, respectiv do-while, diferenŃele de cod nu sunt majore, problemele care pot apărea sunt
similare. În funcŃie de aplicaŃie însă, pot apărea situaŃii în care una dintre
instrucŃiuni se pretează a fi implementată mai eficient.
do{
printf("Introdu numarul de valori:");scanf("%d", &N);
}while (N<1);
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 145/267
145
ObservaŃii
Introducerea secvenŃei de verificare a valorii variabilei N poate evita
situaŃia ce generează eroare prin împărŃirea la zero.
În situaŃia de faŃă este de preferat să se folosească instrucŃiunea do-while,având în vedere faptul că întâi trebuie introdusă valoare pentru N şi apoi se
face verificarea valorii ei.
U8.1.3. InstrucŃiunea de ciclare cu contor (for)
Sintaxa generală a instrucŃiunii for este:
for( expr1; expr2; expr3)instrucŃiune;
InstrucŃiunea for se execută în următorii paşi:
expr1 se evaluează o singură dată, la intrarea în bucla for;
expr2 se evaluează înaintea fiecărei iteraŃii şi reprezintă condiŃia de execuŃie a
instrucŃiunii; valoarea logic falsă a ei provoacă ieşirea din ciclu;
expr3 se evaluează la sfârşitul fiecărei iteraŃii, pentru actualizarea parametrilor
ciclului.
InstrucŃiunea for oferă posibilitatea scrierii unui cod mai compact şi mai clar.
ObservaŃii
InstrucŃiunea for este o instrucŃiune de ciclare cu test iniŃial, fiind
echivalentă cu:expr1;while(expr2){ instructiune;
expr3;}
Exemplu de folosire a instrucŃiunii for:
for( i = 5 ; i ; i-- ) // instrucŃiunea înglobează iniŃializarea lui i, modificarea
// valorii lui i, testarea valorii lui i
printf(”\ni=%d”, i );
AplicaŃia care calculează media aritmetică a N valori citite de la tastatură poate fi
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 146/267
146
implementată cu folosirea instrucŃiunii for, după cum urmează:
#include <stdio.h>
void main(){int i, N; // variabila i va fi folosită ca şi contor pentru numărarea valorilor citite; ea
// va controla evoluŃia secvenŃei repetitivefloat val; // variabila val se foloseşte pentru citirea valorilor de la tastaturăfloat rez; // variabila rez este folosită pentru calculul mediei aritmetice
printf("Introdu numarul de valori:");scanf("%d", &N);
for (i=1, rez=0; i<=N ; i++) // se fac iniŃializări pentru variabilele i şi rez, se// verifică condiŃia de execuŃie a ciclului, se
{ // modifică valoarea variabilei de control i printf("Introdu o valoare:");scanf("%f", &val);rez = rez + val;
}rez = rez/N;
printf("\nMedia aritmetica a valorilor este: %10.2f\n", rez);}
Se observă că prin folosirea instrucŃiunii for codul devine mai compact.
ObservaŃii
Expresia de iniŃializare folosită iniŃializează ambele variabile, i şi rez.
Din sintaxa instrucŃiunii for poate lipsi oricare dintre expresii, dar semnul
de punctuaŃie punct şi virgulă (;) trebuie să fie folosit. De exemplu, se
poate folosi o scriere similară cu folosirea instrucŃiunii while:i = 1;rez = 0
for( ; i<=N ; ){ printf("Introdu o valoare:");scanf("%f", &val);rez = rez + val;i++;
}
Calcul lui N factorialul ( N! ) se poate face astfel:
int N, i, fact;...
for ( i=N, fact=1 ; i>0 ; i--)fact *= i;
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 147/267
147
sau:
int N, i, fact;// ...
for ( i=N, fact=1 ; i>0 ; fact *= i, i-- ) ;
ObservaŃii
Se observă că a doua variantă ne oferă o scriere compactă, expresia de
calcul a variabilei fact fiind inclusă în expr3. InstrucŃiunea care trebuie
executată repetitiv a devenit expresia vidă.
În sintaxa instrucŃiunii for poate lipsi expr2, cea care descrie condiŃia de ieşire din
ciclu. Aceasta poate duce la o ciclare fără sfârşit. Ca şi cazul instrucŃiunilor while, do-while se
poate forŃa ieşirea din ciclu cu instrucŃiuni de salt.
for ( ; ; ) // nu este precizată expresia care condiŃionează execuŃia instrucŃiunii{
printf(“\nSe executa un ciclu infinit !”);}
U8.2. InstrucŃiuni de salt
U8.2.1. InstrucŃiunea break
InstrucŃiunea are forma:break;
InstrucŃiunea break se foloseşte:
în interiorul instrucŃiunii switch pentru a întrerupe execuŃia acesteia după
executarea unei secvenŃe asociată cu un selector case (vezi paragraful 7.4.2). în instrucŃiunile de ciclare (while, do-while, for) determinând ieşirea forŃată din
acestea.
În continuare este prezentat un exemplu de folosire a instrucŃiunii break:
#define N 100int i;for( i=1 ; i<=N ; i++)
{if (!(i%7))
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 148/267
148
{ printf("\ni=%d - divizibil cu 7",i);getch();
break; // datorita lui folosirii instrucŃiunii break ciclul for se va întrerupe// când i devine divizibil cu 7 şi nu când i ajunge la valoarea 100;
// ca urmare, o sa se afişeze doar primele 7 valori// si se iese din for;}
printf("\ni=%d",i);}
InstrucŃiunea break nu poate fi inclusă într-o structură secvenŃială sau structură
alternativă realizată cu instrucŃiunea if.
int a, b; printf("\na=");scanf("%d", &a);
printf("\nb=");scanf("%d", &b);if(a>b)
{ printf(”\n a>b”); break; // eroare, break nu este inclus nici în instrucŃiunea switch,
// nici în instrucŃiune repetitivă}
// ....
În mod frecvent, instrucŃiunea break se foloseşte în instrucŃiuni repetitive fără condiŃie
de finalizare a acestora. De exemplu:
char ch;//...for ( ; ; ) // nu este precizată expresia care condiŃionează ieşirea din ciclul for {
// ...if ((ch=getch()) == ‘X’) // la tastarea caracterului ‘X’ se forŃează ieşirea din ciclul
break; // for, prin instrucŃiunea break }
Dacă o secvenŃă conŃine mai multe instrucŃiuni repetitive imbricate şi una dintre ele
conŃine instrucŃiunea break, se va întrerupe doar ciclul care conŃine break.
char ch;int a, b;//...
while (a<b){//...
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 149/267
149
for ( ; ; ) // nu este precizată expresia care condiŃionează ieşirea din ciclul for {
// ...if ((ch=getch()) == ‘X’) // la tastarea caracterului ‘X’ se forŃează ieşirea din ciclul
break; // for, prin instrucŃiunea break, dar se continuă while.
} // la următoarea iteraŃie a ciclului while se va lansa din//... // nou instrucŃiunea for care va putea fi întreruptă prin// tastarea caracterului ’X’
}
U8.2.2. InstrucŃiunea continue
InstrucŃiunea are forma:
continue;
Se foloseşte numai în instrucŃiunile repetitive şi are ca efect trecerea la următoarea
iteraŃie într-un ciclu while, do-while sau for.
Nu are ca efect întreruperea instrucŃiunii repetitive, ci vor fi ignorate instrucŃiunile ce
îi urmează în interiorul ciclului. Acesta se va continua cu următoarea iteraŃie.
Exemplu de folosire a instrucŃiunii continue:
int i;for( i=1 ; i<=100 ; i++)
{if (!(i%7)){ printf("\ni=%d - divizibil cu 7", i);getch();continue; // datorita lui continue, se va ignora linia următoare si se trece la
// următoarea iteraŃie a lui for, ca urmare, se vor afişa toate// valorile, de la 1 la 100, pentru cele divizibile cu 7 afişarea fiind// diferită faŃă de celelalte valori
} printf("\ni=%d",i);}
În urma execuŃiei acestei secvenŃe se va afişa:
i = 1i = 2i = 3i = 4i = 5i = 6i = 7 – divizibil cu 7
i =8....
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 150/267
150
Ca şi în cazul instrucŃiunii break, nici instrucŃiunea continue nu poate fi folosită în
structuri secvenŃiale sau alternative.
Dacă o secvenŃă conŃine mai multe instrucŃiuni repetitive imbricate şi una dintre ele
conŃine instrucŃiunea continue, efectul va fi doar pentru ciclul care conŃine continue.
U8.2.3. InstrucŃiunea return
Formele admise pentru instrucŃiunea return sunt:
return;
saureturn (expresie);
sau
return expresie;Efectul instrucŃiunii este de revenire dintr-o funcŃie, adică de a trece controlul la
funcŃia care a apelat funcŃia ce conŃine instrucŃiunea return, fără transmiterea unei valori în
prima formă şi cu transmiterea valorii expresie în celelalte.
Tipul de dată al valorii returnată trebuie să fie compatibil cu cel al funcŃiei.
int functie(void) // antetul funcŃiei precizează tipul valorii întoarse{
int a;
...return a; // tipul expresiei returnate e identic cu cel al funcŃiei
}
Dacă tipul expresiei returnate e nu identic cu cel al funcŃiei, se face o conversie a
tipului expresiei returnate către tipul funcŃiei, similar cu conversiile din operaŃiile de atribuire.
Aceste conversii pot produce trunchieri ale valorii, rezultatul fiind necontrolat.
int functie(void) // antetul funcŃiei precizează tipul valorii întoarse, int
{ float a;...
return a; // tipul expresiei returnate e float, iar al funcŃiei este int; se face// conversie cu trunchiere a valorii returnate ceea ce poate// produce rezultate necontrolate
}
În funcŃiile care conŃin secvenŃe alternative se poate folosi instrucŃiunea return de mai
multe ori, dar la execuŃie se va executa doar cea selectată.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 151/267
151
int functie(void) // antetul funcŃiei precizează tipul valorii întoarse{
int a, b;...
if (a>b) // se selectează una dintre valorile care va fi returnată
return a;elsereturn b;
}
Dacă o funcŃie este void, instrucŃiunea return nu e însoŃită de valoare, sau chiar poate
să lipsească.
void functie(void) // antetul funcŃiei lipsa valorii întoarse, este funcŃie void{...
return; // funcŃia nu returnează valoare}
void functie(void) // antetul funcŃiei indică lipsa valorii întoarse, este funcŃie void{
int a, b;...if (a>b) // se verifică o condiŃie care poate întrerupe execuŃia funcŃiei
return;
….}
Toate instrucŃiunile care se află într-o funcŃie după instrucŃiunea return vor fi ignorate.
U8.2.4. FuncŃia exit()
Deşi nu este o instrucŃiune de control al programului, ci este o funcŃie definită în
fişierele header standard stdlib.h şi process.h.Ea poate fi folosită pentru a încheia execuŃia programului din orice punct al său.
Spre deosebire de instrucŃiunile break sau return care întrerup doar execuŃia unui
modul din program, funcŃia exit() întrerupe execuŃia întregului program şi revenirea în
sistemul de operare.
Prototipul funcŃiei este:
void exit (int status);
Valoarea parametrului, status, reprezintă un cod ce poate fi interpretat de sistemul de
operare. Valoarea 0 este interpretată ca terminare normală a programului, valorile diferite dezero pot indica diferite coduri de eroare în execuŃia programului.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 152/267
152
La ieşirea din program cu funcŃia exit(), sunt închise toate fişierele care fuseseră
deschise prin programul respectiv şi sunt golite buffer-ele de ieşire.
Este prezentat un exemplu de folosire a funcŃiei exit() într-un program ce defineşte un
meniu care permite selecŃia între patru opŃiuni, cea de a patra producând încheierea execuŃiei
programului:
#include <conio.h>#include <stdio.h>#include <stdlib.h>
void op1(){
printf("\noptiune 1");getch();
return; // instrucŃiunea return încheie execuŃia funcŃia//căreia aparŃine şi se revine în funcŃia apelantă,// în cazul de faŃă se va reveni la funcŃia main()
}
void op2(){ printf("\noptiune 2");
getch();return;
}
void op3(){ printf("\noptiune 3");
getch();return;
}
void af_meniu(){ printf("\n1. Optiunea 1");
printf("\n2. Optiunea 2"); printf("\n3. Optiunea 3");
printf("\n4. Iesire"); printf("\n\n\nIntrodu optiunea:");return;
}
void main(){
int optiune;do{
af_meniu();
fflush(stdin);optiune=getchar();
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 153/267
153
switch(optiune){ case '1': op1(); break; // instrucŃiunea break întrerupe doar execuŃia
case '2': op2(); break; // instrucŃiunii switchcase '3': op3(); break;case '4': exit(0); // funcŃia exit() încheie execuŃia programului
}} while(1); // condiŃia de execuŃie a instrucŃiunii while este exprimată// printr-o constantă, ceea ce duce la ciclare infinită;// finalizarea ei se va face prin funcŃia exit()
}
U8.2.5. InstrucŃiunea de salt necondiŃionat goto
InstrucŃiunea goto are ca efect saltul la eticheta specificată. Sintaxa sa este:
goto nume_et;
Eticheta nume_et este specificată folosind sintaxa:
nume_et :
Eticheta se poate afla, în succesiunea de instrucŃiuni, atât înaintea instrucŃiunii goto,
cât şi după aceasta, dar ele trebuie să se regăsească în aceeaşi funcŃie. Nu este permis saltul
dintr-o funcŃie în alta.
O secvenŃă care calculează factorialul pentru o valoare N se poate scrie folosind
instrucŃiunea goto astfel:
int i, N=4, fact;i=1; // iniŃializarea variabilelor de lucrufact = 1;
et: // definirea unei etichete; marchează locul din program în care se// va face salt cu instrucŃiunea goto
fact *= i;i++;if (i<=N)
goto et; // se produce saltul la eticheta et; instrucŃiunile dintre etichetă şi// această instrucŃiunea goto; efectul este similar cu cel obŃinut// prin folosirea instrucŃiunilor repetitive (for, while, do-while)
printf("%d", fact);
ObservaŃii
InstrucŃiunea goto încalcă principiile programării structurate şi reduce
claritatea programului, astfel încât este recomandată evitarea ei.
InstrucŃiunile de selecŃie şi de ciclare pot înlocui această instrucŃiune,oferind în plus faŃă de aceasta un bun control al programului.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 154/267
154
Exemple
/**************************************************************************
Exemplu1 8.1. - Să se întocmească un program prin care se afişează codul ASCII. Se vor face
afişări în format %c şi %d pentru a vedea corespondenŃa caracter-valoarenumerica.
ObservaŃii: Se vor face afişări în ordine crescătoare sau descrescătoare, folosind for, whilesau do-while.
**************************************************************************/
#include<stdio.h>#include<conio.h>
void main (){
int i;
//se afiseaza codul ASCII folosind instructiunea for for( i=1 ; i<255 ; i++){ printf("%3d - %c ", i, i);if( !( i%8 )) // dupa afisarea a 8 valori se trece la rand nou printf("\n");
}getch();
//se afiseaza codul ASCII folosind instructiunea whilei=1;while( i<255 ){ printf("%3d- %c ", i, i);if( !( i%8 )) printf("\n");i++;
}getch();
//se afiseaza codul ASCII folosind instructiunea do...whilei=1;do{ printf("%3d - %c ", i, i);if( !( i%8 )) printf("\n");i++;
}while( i<255 );
getch();}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 155/267
155
/**************************************************************************
Exemplu1 8.2. - Să se întocmească un program prin care se citesc de la tastatura doi întregi>=2. Să se afişeze divizorii celor doi întregi. Să se calculeze şi să se afişezec.m.m.d.c. şi c.m.m.m.c. pentru cele două valori.
**************************************************************************/
#include<stdio.h>#include <conio.h>
void main(void){
int nr1, nr2, i, min, cmmdc, cmmmc;
do{ printf("nr1=");scanf("%d",&nr1);
}while (nr1<=1); //se citesc valori >1
do{ printf("nr2=");scanf("%d",&nr2);
}while (nr2<=1); //se citesc valori >1
printf("\nDivizorii numarului %d sunt:\n", nr1);
for(i=2 ; i<=nr1 ; i++)if (!(nr1 % i)) printf("%d ", i);
printf("\nDivizorii numarului %d sunt:\n", nr2);for(i=2 ; i <= nr2 ; i++)if (!(nr2%i)) printf("%d ", i);
min=nr1<nr2 ? nr1 : nr2; // se determina minimul dintre nr1 si nr2
// se determina c.m.m.d.c.for( i=2, cmmdc=1; i<=min ;i++)
if(!(nr1%i)&&!(nr2%i))cmmdc = i;
// se determina c.m.m.m.c.cmmmc = nr1*nr2/cmmdc;
printf("\ncmmdc = %d", cmmdc ); printf("\ncmmmc=%d\n",cmmmc );
getch();}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 156/267
156
Rezumat
InstrucŃiunile repetitive permit executarea în mod repetat a unor secvenŃe de
program atât timp cât o condiŃie (expresie) este logic adevărată. Se poate întrerupe execuŃia unui bloc de instrucŃiuni, a unei funcŃii sau chiar a
programului în totalitatea sa folosi instrucŃiuni de salt sau funcŃia exit().
InstrucŃiunea de ciclare while este instrucŃiune cu test iniŃial.
InstrucŃiunea de ciclare do - while este instrucŃiune cu test final.
Dacă în momentul de început al instrucŃiunii while condiŃia nu este îndeplinită
se trece direct la instrucŃiunea imediat următoare acesteia, în timp ce corpul
instrucŃiunii do - while se execută cel puŃin o dată.
InstrucŃiunea de ciclare for se mai numeşte instrucŃiune cu contor, ea incluzând
şi reactualizarea variabilei de control. Ea este instrucŃiune de ciclare cu test iniŃial.
Din sintaxa instrucŃiunii for poate lipsi oricare dintre expresii, dar semnul de
punctuaŃie punct şi virgulă (;) trebuie să fie folosit.
O instrucŃiune de ciclare poate avea expresia condiŃională permanent adevărată,
situaŃie în care se ajunge la o ciclare fără sfârşit. Ieşirea dintr-o astfel de
instrucŃiune se poate face folosind instrucŃiunea break.
InstrucŃiunea continue se foloseşte numai în instrucŃiunile repetitive şi are ca
efect trecerea la următoarea iteraŃie într-un ciclu while, do-while sau for, cu
ignorarea anumitor instrucŃiuni.
InstrucŃiunea return produce încheierea unei funcŃii şi revenirea la funcŃia
apelantă, cu sau fără transmiterea unei valori, în funcŃie de sintaxa folosită.
În funcŃiile care conŃin secvenŃe alternative se poate folosi instrucŃiunea return
de mai multe ori, dar la execuŃie se va executa doar cea selectată.
FuncŃia exit() poate fi folosită pentru a încheia execuŃia programului din orice
punct al său.
InstrucŃiunea goto are ca efect saltul la eticheta specificată. Eticheta se poate
afla, în succesiunea de instrucŃiuni, atât înaintea instrucŃiunii goto, cât şi dupăaceasta, dar ele trebuie să se regăsească în aceeaşi funcŃie.
InstrucŃiunea goto încalcă principiile programării structurate şi reduce claritatea
programului, de aceea recomandarea este să se evite folosirea acesteia.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 157/267
157
Test de autoevaluare
1. Ce afiseaza secvenŃa de program de mai jos :#include<stdio.h>
void main(){ int a=2; while(a) printf("%3d", a--); }a. 2 1 0
b. 2 1c. 3 2 1d. altceva
2. Se considera secvenŃa de program de mai jos :#include<stdio.h>void main(){ int i=5,j=1;
while(i-j)
{ i--; j++; printf("Mesaj\n");}
}De cate ori apare "Mesaj" pe ecran la rularea programului ?
a. o singura data b. de 3 oric. de doua orid. niciodată
3. Ce afiseaza secvenŃa de program de mai jos ?
#include<stdio.h>void main(){ int i=1, f=1;
do { f = f*i ; i++; } while (i<=4); printf("%d\n", f);
}a. 24
b. 12c. nimic pentru ca programul se va bloca datorita buclei infinited. 1.
4. SecvenŃa de program :#include<stdio.h>void main(){int i, j;for(i=1, j=7 ; j-i ; j--; i++;
printf("Mesaj!\n");}va produce :a. afisarea mesajului pe ecran de 4 ori
b. afisarea mesajului pe ecran o singura datac. afisarea mesajului pe ecran de 2 ori
d. afisarea mesajului pe ecran de 3 orie. eroare de sintaxa
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 158/267
158
5. SecvenŃa de mai jos:#include<stdio.h>void main(){ int i,n=4, factn;
for(i=n, factn=1; i; i--)
factn*=i; printf("%ul ",factn);}
va afisa :a. 24
b. 120c. 6d. nici o valoare de mai sus
6. SecvenŃa de mai jos:#include<stdio.h>
void main(){ int i;
for(i=0;i<10;i++){ if (i%2) printf("mesaj\n");
else { printf("esec\n"); break;
}}
}va produce afisarea:
a. de 5 ori a "mesaj" -ului b. de 5 ori "mesaj" si de 5 ori "esec"c. o data "esec"d. de 5 ori "esec"e. o data "mesaj" si o data "esec"
7. SecvenŃa de mai jos:#include<stdio.h>#include<conio.h>do { for(i=0;i<10;i++)
{ if (i%2) printf("mesaj\n");
else printf("esec\n"); break;}
} printf("testati alt ciclu?[y/n]\n");
} while ( getch()=='y');va afisa:
a. de 5 ori "mesaj" si asteapta y/n b. de 5 ori "mesaj" si de 5 ori "esec" si asteapta y/nc. o data "mesaj" si o data "esec"d. o data "esec"
e. nici una din situaŃiile de mai sus
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 159/267
159
Întrebări. ExerciŃii. Probleme.
1. Se consideră intervalul de valori [a , b]. Se citesc valori pentru a şi b. Să seafişeze toate valorile divizibile cu 5 din intervalul dat.
2. Sa se scrie un program in care intr-o secvenŃa repetitiva se citesc de la tastaturavalori întregi pozitive pentru o variabilă de tip int, pentru fiecare valoareafişându-se factorialul. SecvenŃa este finalizata la introducerea valorii 0 (zero).
3. Să se scrie un program în care se declară o variabilă de tip int. Se citeşte de latastatură. Să se determine şi să se afişeze inversul valorii acesteia. (De
exemplu, inversul lui 12345 este 54321). Notă: Se vor determina cifrele care alcătuiesc numărul ca resturi obŃinute prin
împărŃiri succesive la 10, inversul numărului obŃinându-se prinadăugarea acestor cifre însoŃite de înmulŃiri succesive cu 10.
4. Să se întocmească un program în care :- se citeşte o valoare x cuprinsă în intervalul [1,170];- se citeşte o valoare y cuprinsă în intervalul [1,x];- se calculează şi afişează x! şi y!;
- se calculează şi afişează aranjamente de x elemente luate câte yA(x, y)=x*(x-1)*(x-2)*…* (x-y+1)
- se calculează şi afişează combinări de x elemente luate câte y
C(x, y) = A(x, y) / y!
5. Să se scrie un program care afişează toate valorile întregi din intervalul [0, 20],valorile divizibile cu 2 şi apoi cele divizibile cu 3 din acelaşi interval, ca înexemplul următor.
Nota:Se vor realiza variante de program folosindu-se pe rând instrucŃiunile while,do while, for.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 160/267
160
Unitatea de învăŃare U.9. TABLOURI DE DATE
Cuprins
Introducere .................................................................................................................. 160
Obiectivele unităŃii de învăŃare ................................................................................... 160
U9.1. Declararea tablourilor de date ........................................................................... 161
U9.2. Tablouri unidimensionale ................................................................................. 164
U9.3. Şiruri de caractere ............................................................................................. 167
U9.4. Tablouri multidimensionale .............................................................................. 170
Exemple ...................................................................................................................... 172Rezumat ...................................................................................................................... 177
Test de autoevaluare ................................................................................................... 178
Întrebări, exerciŃii şi probleme .................................................................................... 181
Introducere
Cantitatea de informaŃie prelucrată de programe poate fi mare, de asemenea
tipurile datelor prelucrate pot fi aceleaşi sau diferite. Este dificil ca aceste date săfie vehiculate doar prin intermediul unor variabile simple, deoarece ar fi necesar să
se folosească un număr mare de declaraŃii, cu nume diferite. În astfel de situaŃii se
pot folosi tablouri (masive) de date care permit ca, prin folosirea unui singur nume,
să se stocheze şi prelucreze un mare număr de date. Dimensiunea tablourilor este
limitată doar de memoria disponibilă.
Prin folosirea tablourilor de date se construiesc şi şirurile de caractere
pentru care în C/C++ nu există tip de date predefinit.
Obiectivele unităŃii de învăŃare
După parcurgerea acestei unităŃi de învăŃare trebuie să ştii:
Sintaxa de declarare a tablourilor de date;
Să foloseşti tablouri unidimensionale cu operatorii specifici, referirea
elementelor lor şi folosirea acestora în expresii diverse;
Să foloseşti şiruri de caractere, atât în prelucrări prin funcŃii specifice definite în
biblioteca standard, cît şi în prelucrări caracter cu caracter;
Să foloseşti tablouri multidimensionale cu operatorii specifici, referireaelementelor lor şi folosirea acestora în expresii diverse.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 161/267
161
Durata medie de parcurgere a celei de a noua unităŃi de învăŃare este de 2
ore.
U9.1. Declararea tablourilor de date
Tabloul de date (sau masiv de date) este o colecŃie de date de acelaşi tip, plasate într-o
zonă contiguă de memorie (adresele elementelor tabloului sunt succesive).
Tipul de date tablou este tip de date derivat. Este construit folosindu-se tipuri de
date predefinite sau definite de programator.
Tablourile de date se mai numesc variabile compuse (structurate), deoarece grupează
mai multe elemente.Sintaxa declaraŃiei unui tablou cu N dimensiuni este:
tip_element nume_tablou [dim_1][dim_2]…[dim_N];
unde: - tip_element – poate fi orice tip de date, fundamental sau definit de utilizator;
- nume_tablou – orice identificator care nu a primit altă semnificaŃie în domeniul
declaraŃiei;
- dim_1, dim_2,...,dim_N – sunt constante numerice întregi.
Zona de memorie rezervată conŃine
dim_1 x dim_2 x ... x dim_N
elemente de tipul tip_element, adică: dim_1 x dim_2 x ... x dim_N x sizeof(tip_element)
octeŃi.
Variabilele tablou au nume, iar tipul tabloului este dat de tipul elementelor sale.
Elementele tabloului pot fi referite prin numele tabloului şi indecşi (valori numerice întregi)
care reprezintă poziŃia elementului în cadrul tabloului.
Exemple de declarare de tablouri de date:
float vect1[5]; // se declară un tablou cu 5 elemente de tip float, zona de// memorie alocată fiind de 5*sizeof(float) bytes
int dimensiuni[4][12]; // se declară un tablou cu 4*12 elemente de tip int, zona// de memorie alocată fiind de 4*12*sizeof(int) bytes
Referirea unui element de tablou se face cu operatorul de indexare [ ] sub forma:nume_tablou [indice_1][indice_2]...[indice_N];
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 162/267
162
unde: indice_1, indice_2,...,indice_N – poate fi orice expresie care returnează o
valoare întreagă.
DeclaraŃia unui tablou se poate face cu iniŃializarea sa, folosind sintaxa:
tip_element nume_tablou [indice_1][indice_2]...[indice_N] ={listă_valori};
Lista de valori trebuie să conŃină constante de tip compatibil cu tipul de bază al
tabloului, în ordinea plasării în memorie.
Exemple de declarare a tablourilor cu iniŃializare:
float vect1[5]; // se declară un tablou cu 5 elemente// float, fără iniŃializare
int vect2[10]={2,7,-1,0,9,15,-5,22,6,11}; // se declară un tablou cu 10 elemente int// cu iniŃializare
int mat[2][3]={{3,5,-3},{2,-1,0}}; // se declară un tablou bidimensional cu// 2*3 elemente de tip întreg, cu// iniŃializare
Dacă numărul valorilor din lista de iniŃializare este mai mic decât dimensiunea
tabloului, adică decât numărul de elemente ale tabloului, vor fi iniŃializate doar primele
elemente în ordinea de alocare, celelalte rămânând neiniŃializate.
float vect[5] = { 1.5, 3.2, 7.1}; // se iniŃializează primele trei valori, două
// rămânând neiniŃializate
SituaŃia în care numărul valorilor din lista de iniŃializare este mai mare decât
dimensiunea tabloului generează un mesaj de eroare.
float vect[5] = { 1.5, 3.2, 7.1, -2.5, 6, 10 }; // eroare, numărul valorilor de iniŃializare// este mai mare decât numărul de// elemente ale tabloului
Este permisă declararea tablourilor fără precizarea dimensiunii, dacă declaraŃia este cuiniŃializare. În această situaŃie, dimensiunea este stabilită în mod implicit egală cu numărul de
valori din listă.
float vect[ ]={ 1.5, 3.2, 7.1, -2.5, 6 }; // numărul valorilor de iniŃializare este 5, deci// dimensiunea implicită a tabloului va fi 5
Indiferent că tabloul a fost declarat cu iniŃializare sau nu, valorile elementelor de
tablou vor putea fi modificate pe parcursul execuŃiei programului, ca în cazul oricărei
variabile.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 163/267
163
float vect[5]; // se declară un tablou cu 5 elemente float, fără// iniŃializare
vect[0] = 1.5; // elementului de index 0 i se atribuie valoarea 1.5vect[1] = -2.5; // elementului de index 1 i se atribuie valoarea -2.5vect[5] = 3.2; // deşi nu este semnalată eroare, se foloseşte index
// incorect indexul, valorile corecte fiind 0...4; această// situaŃie poate genera efecte necontrolate în evoluŃia// programului
int mat[2][3]={{3,5,-3},{2,-1,0}}; // se declară un tablou bidimensional cu// 2*3 elemente de tip întreg, cu iniŃializare
mat[1][2]= 23; // elementului de indecşi 1, respectiv 2, i// se atribuie valoarea 23
ObservaŃii
Numele tabloului (neînsoŃit de indecşi) reprezintă adresa de memorie la
care este alocat tabloul.
Indecşii elementelor tabloului iau valori începând cu 0 (zero), deci
valoarea maximă a lor este dim_n -1.
După alocarea memoriei necesare, nici la compilare nici la execuŃie, nu se
mai fac verificări de dimensiune, deci nu se verifică dacă indecşii utilizaŃi
au valori corecte. Dacă indecşii depăşesc dimensiunea tabloului, există
riscul să se înscrie valori în zone de memorie utilizate în alt scop,
distrugând date sau cod de program. Elementele neiniŃializate ale tablourilor iau valori, asemeni oricărei
variabile, după cum urmează:
valoare zero dacă tabloul este declarat global;
valoare reziduală, dacă declararea tabloului este locală unui
bloc de instrucŃiuni.
La declararea unui tablou, dimensiunile se specifică prin constante
numerice întregi literale sau cu nume, cum ar fi:
#define dim1 15const int dim2 = 99;
int vector1[20];
float vector2[dim1];
double vector3[dim2];
DeclaraŃia următoare:
int dim = 30;
unsigned int vector4[dim];
este semnalată cu mesaj de eroare, deoarece se utilizează o variabilă
pentru specificarea dimensiunii tabloului.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 164/267
164
Folosirea tablourilor uşurează scrierea programelor care prelucrează mai multe
variabile de acelaşi tip, prelucrate în secvenŃe similare, referirea lor făcându-se cu ajutorul
unui nume comun. Aceasta aduce uşurinŃă în scrierea programului, uşurinŃă în citirea şi
depanarea acestuia. În caz contrar, ar fi necesară declararea unui număr mare de variabile, cu
nume distincte, scrierea programului fiind greoaie.
În funcŃie de numărul dimensiunilor precizate la declararea tablourilor, tablourile pot
fi grupate în tablouri unidimensionale (se mai denumesc vectori) şi tablouri
multidimensionale, dintre care tablourile bidimensionale (matrice) sunt cel mai frecvent
folosite.
Am văzut că, limbajele C/C++ nu au definit ca tip de date tipul şir de caractere. În
aceste limbaje, şirurile de caractere sunt construite cu ajutorul tablourilor unidimensionale cu
elemente de tip char.
U9.2. Tablouri unidimensionale
DeclaraŃia unui tablou unidimensional se face, conform sintaxei precizată în
paragrafului anterior astfel:
tip_element nume_tablou [dim];
sau cu iniŃializarea elementelor:
tip nume_tablou [dim] = { listă_valori };
Pentru tabloul de date cu numele nume_tablou se alocă dim elemente de tipul
tip_element plasate succesiv într-o zonă contiguă de memorie.
Pentru referirea unui element se foloseşte sintaxa următoare:
nume_tablou[index]
unde index precizează poziŃia elementului în tablou. Acesta este reprezentat prin orice
expresie întreagă pozitivă.
Exemplu de declarare a unui tablou cu 6 elemente de tip int cu iniŃializare:
int vector[6] = { 3, 5, -7, 15, 99, 43};
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 165/267
165
Fig. 9.1. Exemplu de alocare în memorie a unui tablou unidimensional
Alocarea tabloului în memorie se face ca în Fig. 9.1.
Numele tabloului, vector, neînsoŃit de index, reprezintă adresa la care s-a făcut
alocarea de memorie. Elementele tabloului sunt alocate la adrese de memorie succesive.Se poate determina spaŃiul de memorie alocat pentru tablou cu operatorul sizeof.
printf(”\nTabloul vector ocupa %d octeti in memorie”, sizeof(vector));
Adresa de alocare este determinată prin numele tabloului. Se poate folosi şi operatorul
&, dar expresiile vector şi respectiv &vector sunt echivalente. Pentru afişarea valorii se poate
folosi formatul specific adreselor, %p, formatul fiind hexazecimal, sau cu formatul %u, ca
întreg zecimal fără semn.
printf(”\nTabloul vector este alocat la adresa de memorie %p”, vector); printf(”\nTabloul vector este alocat la adresa de memorie %u”, vector);
Referirea elementelor tabloului se face prin numele tabloului, operatorul [ ] şi valoarea
indexului. Acesta indică poziŃia elementului în tablou. Un element al tabloului se poate folosi
ca orice variabilă simplă de acelaşi tip.
Luând în considerare declararea tabloului vector, se pot folosii expresii care includ
elemente ale tabloului ca în exemplul următor:
int a;int vector[6] = { 3, 5, -7, 15, 99, 43};
vector[0] = 10;a = (vector[1] +vector[2]) / 2;
printf(“\nValoarea adresei &vector[0] = %u”, &vector[0]); // se afişează adresa la//care e alocat elementul// de index 0
printf(“\nElementul vector[0] ocupa %d octeti”, sizeof(vector[0])); // se afişează nr. de// octeŃi folosiŃi pentru
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 166/267
166
// reprezentarea// elementului
printf(“\nValoarea elementului vector[0] = %d”, vector[0]); // se afişează valoarea// elementului
ObservaŃii
Numerotarea indecşilor în C/C++ începe totdeauna cu valoarea 0 (zero) !
Compilatorul nu verifică corectitudinea indecşilor folosiŃi !
În mod frecvent, dacă se doreşte prelucrarea mai multor elemente, sau chiar a tuturor
elementelor tabloului, se folosesc instrucŃiunile repetitive (for, while, do-while).
int i;for ( i=0 ; i<5 ; i++)
printf(“\nValoarea elementului vector[%d] = %d”, i, vector[i]);
În secvenŃa anterioară, variabila i este folosită pentru desemnarea indexului
elementelor. Prin valorile succesive de la 0 la 4 ale indicelui, se afişează pe rând valorile
elementelor vector[0]... vector[4].
ObservaŃii Operatorii specifici limbajului pot fi aplicaŃi elementelor tabloului în măsura
în care tipul elementelor permite acest lucru.
Nu se pot face operaŃii cu tablouri în ansamblul lor, ci doar cu elemente ale
acestora.
int tab1[5];float tab[10];// …
tab1 = tab2 ; // eroare, nu se poate face atribuirea; tab1 şi tab2 sunt adresele// la care sunt alocate tablourile şi ele nu pot fi modificate
tab1 = 100 ; // eroare, ca si in cazul precedent, nu se poate face atribuirea,// adică nu se poate modifica adresa la care este alocat tabloul
tab1+tab2 ; // eroare, operatorul + nu este definit pentru a opera cu tablouri
tab1[0]+tab2[0]; // corect, tab1[0] şi tab2[0] sunt date de tip int, respectiv// float, deci operaŃia de adunare se poate efectua
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 167/267
167
U9.3. Şiruri de caractere
Tablourile unidimensionale cu elemente de tip char sunt folosite pentru memorarea
şirurilor de caractere. Pentru a marca sfârşitul unui şir de caractere, după ultimul caracter se
adaugă un octet cu valoarea 0 (‘\0’), numit şi terminator de şir.Declararea unui şir de caractere se face, conform sintaxei specifice tablourilor
unidimensionale, prin tipul elementelor (char), numele tabloului şi dimensiune.
char nume[6];
DeclaraŃia poate fi făcută cu iniŃializare ca în exemplul următor:
char nume[6] = { ‚’S’, ’M’, ’I’, ’T’, ’H’, ’\0’};
Tabloul este alocat în memorie ca în Fig. 9.2.
Fig.9.2. Exemplu de alocare în memorie a unui şir de caractere
IniŃializarea se poate face şi folosind şiruri de caractere constante.
char nume[6] =”Smith”;
O listă de caractere încadrată între ghilimele reprezintă o constantă şir de caractere (de
exemplu ”SMITH”). Pentru o astfel de constantă, compilatorul rezervă numărul de octeŃi pe
care îi iniŃializează cu codurile ASCII corespunzătoare caracterelor şi un octet pe care îl
iniŃializează cu valoarea 0 ( adică terminatorul de şir ‘\0’). O constantă şir de caractere poate
fi utilizată şi pentru iniŃializarea unei variabile şir de caractere.
Exemple de declare de tablouri:
char sir1[10]; // se declară un tablou unidimensional, cu// elemente char (şir de caractere), fără iniŃializare
char sir3[ ]=”sir de caractere”; // se declară un tablou cu 17 elemente char (şir de// caractere) cu iniŃializare (ultimul caracter depus
// în tablou este terminatorul de şir ‘\0’sir3[0]=’S’; // primul caracter al şirului primeşte valoarea ‘S’
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 168/267
168
ObservaŃii
În cazul unui şir vid, primul element al tabloului este chiar terminatorul de şir, de
exemplu:nume[0]=’\0’;
Dimensiunea precizată la declararea unui tablou şir de caractere trebuie să fie maimare cu o unitate decât numărul caracterelor semnificative care pot intra în
alcătuirea conŃinutului şirului pentru a permite memorarea terminatorului.
Terminatorul de şir permite testarea facilă a sfârşitului şirului. FuncŃiile definite
pentru a opera cu şiruri de caractere nu fac referire la dimensiunea acestora, ci
folosesc terminatorul de şir pentru a indica sfârşitul şirurilor.
Şirurile de caractere pot fi tratate, ca orice tablou unidimensional, făcând prelucrări
element cu element, deci caracter cu caracter. În plus, există definite în fişierele header standard o mulŃime de funcŃii definite pentru prelucrarea şirurilor de caractere.
De exemplu, se defineşte o secvenŃă în care se citeşte de la tastatură conŃinutul unui şir
de caractere. Citirea se face caracter cu caracter până la apăsarea tastei Enter.
char sir [20];int i=0; // variabila i se foloseşte pentru desemnarea indexului
// elementului de tablou; primul element are indexul 0do // secvenŃa repetitiva prin care se citesc succesiv
{ // caracterelefflush(stdin);sir[i]=getche();i++;
}while (sir[i-1]!=13); // încheierea ciclului do-while se face la apăsarea tastei
// Enter care transmite două caractere cu valoarea în// codul ASCII 13 (trecere la rând nou ’\n’) şi respectiv// 10 (carriage return ’\r’); prima valoare este preluată de// un element de tablou
sir[i-1]='\0'; // după finalizarea introducerii de caractere, se// memorează terminatorul de şir
SecvenŃa anterioară poate fi înlocuită cu apelul funcŃiilor specifice gets() sau scanf():
char sir [20];gets(sir);
sau
char sir [20];scanf(“%s”, sir);
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 169/267
169
Pentru operaŃii de intrare/ieşire de la consolă se pot folosi funcŃiile scanf, respectiv
printf, cu specificatorul de format %s sau funcŃiile gets(), respectiv puts() definite tot în
fişierul header stdio.h.
Exemple de folosire a funcŃiilor de intrare/ieşire cu şiruri de caractere :
char nume[30];scanf(“%s”, nume); // numele unui tablou este o adresă, astfel
// că în funcŃia scanf nu a fost necesar să// se utilizeze operatorul &
printf(”Numele este: %s”, nume); // funcŃia printf, pentru specificatorul %s// nu afiseaza adresa la care se află alocat// şirul, ci afişează conŃinutul acestuia
printf(”Adresa sirului este: %p”, nume); // funcŃia printf, pentru specificatorul %p// afiseaza adresa la care se află alocat
// şirul,
char sir1[10];scanf(“%9s”, sir1); // în specificatorul de format s-a precizat
// numărul maxim de caractere care pot// fi introduse pentru sir1; cel de al// 10-lea octet e rezervat pentru// terminatorul de şir
printf(”Sirul citit de la tastatura este: %s”, sir1);
gets(nume);
puts(nume);
Deoarece şirurile de caractere sunt construite ca tablouri unidimensionale, operatorii
definiŃi în mod standard nu pot opera cu acestea, ci se recurge la utilizarea de funcŃii definite
în fişierele disponibile existente în biblioteca de funcŃii. Un fişier cu funcŃii destinate lucrului
cu şiruri de caractere este fişierul string.h.
Câteva funcŃii uzuale definite în fişierul string.h sunt:
strcpy(sir_destinatie, sir_sursa); - copiază conŃinutul şirului sursă în şirul destinaŃiestrcat(sir_destinatie, sir_sursa); - adaugă conŃinutul şirului sursă la şirul destinaŃie
(concatenează cele două şiruri)
strlen(sir); - returnează numărul de elemente ale şirului (lungimeaşirului)
strcmp(sir1, sir2); - compară două şiruri, returnând valoarea 0 dacă şirurilesunt egale, şi valoare diferită de 0 dacă sunt diferite(valoarea e dată de diferenŃa dintre primele caractere
diferite)
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 170/267
170
strupr(sir); - transformă literele mici ale şirului în majuscule
strlwr(sir); - transformă majusculele în litere mici
Exemple de folosire a funcŃiilor destinate sirurilor de caractere:
//declararea sirurilor de caracterechar sir1[10], sir2[10], sir3[20];int i, l1, l2;
//citirea de la tastatura a sirurilor scanf("%9s",sir1);scanf("%9s",sir2);
//se determina lungimea sir1l1=strlen(sir1);
//copierea in sir3 a conŃinutului sir1strcpy(sir3, sir1);
//se transformă şirul în şir cu majusculestrupr(sir1)
U9.4. Tablouri multidimensionale
Tablourile multidimensionale se declară, aşa cum am văzut în paragraful 9.1, cu
sintaxa:tip_element nume_tablou [dim_1][dim_2]…[dim_N];
Zona de memorie rezervată pentru tablou conŃine
dim_1 x dim_2 x ... x dim_N
elemente de tipul tip_element, adică:
dim_1 x dim_2 x ... x dim_N x sizeof(tip_element)octeŃi.
Un tablou multidimensional este interpretat ca fiind un tablou unidimensional, fiecare
element fiind la rândul său un tablou.
În mod frecvent se folosesc tablouri cu două dimensiuni, numite în mod uzual matrice.
Matricele sunt interpretate ca tablouri unidimensionale care au elemente formate la rândul lor
din tablouri unidimensionale.
Se interpretează că fiecare linie a matricei reprezintă un element al tabloului, la rândul
lor liniile fiind formate din tablouri unidimensionale, cu dimensiunea dată de numărul decoloane.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 171/267
171
DeclaraŃia matricelor se poate face cu sau fără iniŃializare.
Exemplu de declarare a unui tablou bidimensional, cu iniŃializare:
int matrix[3][4] = { { 10, 20, 30, 40},
{ 50, 60, 70, 80},{ 90, 100, 110, 120}};
DeclaraŃia este făcută cu iniŃializarea elementelor. Alocarea de memorie se face ca înFig. 9.3.
Fig.9.3. Exemplu de reprezentare a unei matrice
Matricea matrix este un tablou unidimensional cu 3 elemente, fiecare element fiind untablou format din 4 întregi.
Numele matricei, matrix, reprezintă adresa la care este alocată matricea, adresă care
coincide cu adresa primei linii a matricei, matrix[0], şi cu adresa primului element de pe
prima linie, &matrix[0][0].
Numele matricei însoŃit de un index reprezintă o adresă de memorie (matrix[0],
matrix[1], matrix[2]), şi anume adresa la care este alocată linia corespunzătoare. O linie a
matricei este formată dintr-un tablou unidimensional de 4 întregi.
Numele matricei însoŃit de doi indecşi reprezintă un element al matricei şi este un int(matrix[0][0], matrix[0][1], etc.). Un element al matricei poate fi utilizat asemeni oricărei
variabile de tip int, adică poate fi utilizat în orice expresie validă pentru acest tip de date.
Indecşii pot fi specificaŃi prin orice expresie care returnează o valoare întreagă.
Dacă se doreşte prelucrarea tuturor elementelor unei matrice, în mod uzual se folosesc
instrucŃiuni repetitive imbricate (de regulă cicluri for). Se obŃine un cod compact şi uşor de
citit şi depanat.
Se exemplifică folosirea elementelor unei matrice; pentru a referi elementele matricei,
se folosesc doi indecşi desemnaŃi de două variabile:
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 172/267
172
int mat[3][4]; // declararea matriceiint i, j;
// se citesc de la tastatura elementele lui mat// variabila i se utilizează pentru desemnarea liniei matricei// variabila j se utilizează pentru desemnarea coloanei matricei
for(i=0 ; i<3 ; i++)for(j=0 ; j<4 ; j++){
printf("mat1[%d][%d]=", i, j);scanf("%d",&mat1[i][j]);
}
//se afiseaza elementele matricei matfor(i=0 ; i<3 ; i++){ printf("\n");
for(j=0 ; j<4 ; j++) printf("%6d", mat [i][j]);
}
Exemple
/**************************************************************************
Exemplu1 9.1. - Să se întocmească un program prin care se exemplifică utilizarea tablourilor unidimensionale
**************************************************************************/
#include <stdio.h>#include <conio.h>
void main(){//declaraŃie tablou de dimensiune 5, fără iniŃializare
int tab1[5];
//declaraŃie tablou de dimensiune 7 cu iniŃializarea elementelor int tab2[7] = {9, 11, 25, 7, 44, 2,14};int i;
//se afişează valorile elementelor tab1 – valori reziduale printf("afisare elemente tab1-contine valori reziduale");for(i=0 ; i<5 ; i++)
printf("\ntab1[%d]=%d", i, tab1[i]);
//se afişează valorile elementelor tab2 – valorile folosite la initializare printf("\n\nafisare elemente tab2-contine valorile de initializare");
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 173/267
173
for(i=0 ; i<7 ; i++) printf("\ntab2[%d] = %d", i, tab2[i]);
// se citesc de la tastatura valorile elementelor tab1 printf("\n\ncitire de valori de la tastatura pentru tab1");
for(i=0 ; i<5 ; i++){ printf("\ntab1[%d]=", i);scanf("%d", &tab1[i]);
}
//se afişează valorile elementelor tab1 – valorile sunt cele citite de la tastatura printf("\n\nafisare elemente tab1-contine valorile citite de la tastatura");for(i=0 ; i<5 ; i++)
printf("\ntab1[%d] = %d", i, tab1[i]);
//se afişează valorile elementelor tab2 divizibile cu 3 printf("\n\nafisarea elementelor tab2-divizibile cu 3");for(i=0 ; i<7 ; i++)
if (!(tab2[i]%3)) printf("\ntab2[%d] = %d", i, tab2[i]);
}
/**************************************************************************
Exemplu1 9.2. - Să se întocmească un program prin care se exemplifică utilizarea şirurilor de
caractere (tablouri unidimensionale cu elemente char). Se exemplifică atât prelucrarea element cu element, cât şi utilizarea funcŃiilor specifice.
**************************************************************************/
#include<stdio.h>#include<conio.h>#include<string.h>
void main(){
//declararea sirurilor de caracterechar sir1[10], sir2[10], sir3[20];int i, l1, l2;
//citirea de la tastatura a sirurilor fflush(stdin);
printf("\nNumele:");scanf("%9s",sir1);fflush(stdin);
printf("\nPrenumele:");scanf("%9s",sir2);
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 174/267
174
/**************************************************************Exemple de copiere a sirurilor caracter cu caracter **************************************************************///se determina lungimea sir1
for( l1=0 ; sir1[l1]!=0 ; l1++);
printf("\nsir1 este format din %d caractere", l1);
//se determina lungimea sir2for( l2=0; sir1[l2]!=0; l2++);
printf("\nsir2 este format din %d caractere", l2);
//preluarea in sir3 a conŃinutului sir1for(i=0;i<l1;i++)sir3[i]=sir1[i];
//se adaugă caracterul spaŃiu in sir3sir3[l1]=' ';
//se adaugă conŃinutul lui sir2 in sir3for(i=0 ; i<l2+1 ; i++)
sir3[l1+1+i]=sir2[i];
//se adaugă terminatorul de sir sir3[l1+l2+1]='\0';
printf("\nNumele complet este: %s", sir3);getch();
/***********************************************************************Exemple de folosire a funcŃiilor destinate sirurilor de caractere***********************************************************************///citirea de la tastatura a sirurilor
fflush(stdin); printf("\nNumele:");scanf("%9s",sir1);fflush(stdin);
printf("\nPrenumele:");scanf("%9s",sir2);
//se determina lungimea sir1l1=strlen(sir1); printf("\nsir1 este format din %d caractere", l1);
//se determina lungimea sir2l2=strlen(sir2);
printf("\nsir2 este format din %d caractere", l2);
//copierea in sir3 a conŃinutului sir1strcpy(sir3, sir1);
//se adaugă caracterul spaŃiu in sir3strcat(sir3, " ");
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 175/267
175
//se adaugă conŃinutul lui sir2 in sir3strcat(sir3, sir2);
printf("\nNumele complet este: %s", sir3);getch();
}
/**************************************************************************
Exemplu1 9.3. - Să se întocmească un program prin care se exemplifică utilizarea tablourilor bidimensionale (matrice)
**************************************************************************/
#include<stdio.h>#include <conio.h>
void main(){// Declararea matricelor
int mat1[2][3], mat2[3][4], i; printf("Informatii despre mat1:\n");
//se afiseaza nr. de octeti alocati lui mat1 printf("\nmat1 ocupa : %d octeti", sizeof(mat1));
//se afiseaza nr. de octeti alocati unei linii a lui mat1 printf("\no linie a lui mat1 ocupa : %d octeti", sizeof(mat1[0]));
//se afiseaza nr. de octeti alocati unui element al lui mat1 printf("\nun element al lui mat1 ocupa : %d octeti", sizeof(mat1[0][0]));
//se afiseaza adresele la care e alocata mat1 printf("\n&mat1=%u", mat1); //expresiile mat1 si &mat1 sunt
// echivalente
//se afiseaza adresele la care se afla liniile lui mat1
for(i=0 ; i<2 ; i++) printf("\nlinia %d se afla la adresa : %u", i, mat1[i]); // mat1[i] si &mat1[i] sunt// echivalente
printf("\n\nInformatii despre mat2:\n");
//se afiseaza nr. de octeti alocati lui mat2 printf("\nmat2 ocupa : %d octeti",sizeof(mat2));
//se afiseaza nr. de octeti alocati unei linii a lui mat2 printf("\no linie a lui mat2 ocupa : %d octeti",sizeof(mat2[0]));
//se afiseaza nr. de octeti alocati unui element al lui mat2 printf("\nun element al lui mat2 ocupa : %d octeti", sizeof(mat2[0][0]));
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 176/267
176
//se afiseaza adresele la care e alocata mat1
printf("\n&mat2=%u", mat2); //mat2 si &mat2 sunt echivalente
//se afiseaza adresele la care se afla liniile lui mat2
for(i=0 ; i<3 ; i++) printf("\nlinia %d se afla la adresa : %u", i, mat2[i]); // mat2[i] si &mat2[i]// sunt echivalente
}
/**************************************************************************
Exemplu1 9.4. - Să se întocmească un program în care:Se declară 3 matrice de dimensiuni egale. Se citesc de la tastatură două dintrematrice şi se calculează cea de a treia ca sumă a lor. Să se calculeze, pentru o
matrice, suma elementelor pe fiecare linie si a tuturor elementelor matricei.**************************************************************************/
#include<stdio.h>#include <conio.h>
void main(){
int mat1[3][4], mat2[3][4], mat3[3][4]; // declararea matricelor int i, j;
int suma_linie, suma_matrice;
// se citesc de la tastatura elementele lui mat1// variabila i se utilizeaza pentru desemnarea liniei matricei// variabila j se utilizeaza pentru desemnarea coloanei matricei
printf("Introduceti elementele matricei mat1:\n");for(i=0;i<3;i++)for(j=0;j<4;j++){
printf("mat1[%d][%d]=",i,j);
scanf("%d",&mat1[i][j]);}
//se citesc de la tastatura elementele lui mat2
printf("\nIntroduceti elementele matricei mat2:\n");for(i=0;i<3;i++)for(j=0;j<4;j++){
printf("mat2[%d][%d]=", i, j);scanf("%d",&mat2[i][j]);
}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 177/267
177
//se calculeaza matricea mat3 ca suma dintre mat1 si mat2
for(i=0;i<3;i++)for(j=0;j<4;j++)
mat3[i][j]=mat1[i][j] + mat2[i][j];
//se afiseaza matricea mat3 obŃinuta
printf("\nmat3:");for(i=0;i<3;i++){ printf("\n");for(j=0;j<4;j++)
printf("%6d", mat3[i][j]);}
//se calculeaza pentru mat3 pe fiecare linie si suma tuturor elementelor
suma_matrice=0;for(i=0;i<3;i++){suma_linie=0;for(j=0;j<4;j++)
{suma_linie+=mat3[i][j];suma_matrice+=mat3[i][j];
} printf("\npentru linia %d suma elementelor este: %d", i, suma_linie);}
printf("\nsuma tuturor elementelor matricei mat3 este: %d", suma_matrice);getch();
}
Rezumat
Tabloul de date este o colecŃie de date de acelaşi tip, plasate într-o zonă
contiguă de memorie
Elementele tabloului pot fi referite prin numele tabloului şi indecşi (valori
numerice întregi)
Indecşii reprezintă poziŃia elementului în cadrul tabloului.
La declararea unui tablou, dimensiunile se specifică prin constante numerice
întregi literale sau cu nume. Referirea unui element de tablou se face folosind operatorul de indexare [ ].
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 178/267
178
DeclaraŃia unui tablou se poate face cu iniŃializarea elementelor sale.
Este permisă declararea tablourilor fără precizarea dimensiunii, dacă declaraŃia
este cu iniŃializare.
Valorile elementelor de tablou vor putea fi modificate pe parcursul execuŃiei
programului.
După alocarea memoriei necesare, nici la compilare nici la execuŃie, nu se mai
fac verificări de dimensiune, deci nu se verifică dacă indecşii utilizaŃi au valori
corecte.
În funcŃie de numărul dimensiunilor precizate la declararea tablourilor,
tablourile pot fi grupate în tablouri unidimensionale (se mai denumesc vectori) şi
tablouri multidimensionale, dintre care tablourile bidimensionale (matrice) sunt
cel mai frecvent folosite.
Numele tabloului (neînsoŃit de indecşi) reprezintă adresa de memorie la careeste alocat tabloul.
Se poate determina spaŃiul de memorie alocat pentru un tablou folosind
operatorul sizeof.
În mod frecvent, dacă se doreşte prelucrarea mai multor elemente, sau chiar a
tuturor elementelor tabloului, se folosesc instrucŃiunile repetitive (for, while, do-
while).
Tablourile unidimensionale cu elemente de tip char sunt folosite în mod uzual
pentru memorarea şirurilor de caractere. Pentru a marca sfârşitul unui şir de caractere se foloseşte un octet cu valoarea 0
(‘\0’), numit şi terminator de şir.
Şirurile de caractere pot fi tratate, ca orice tablou unidimensional, făcând
prelucrări element cu element, deci caracter cu caracter. În plus, există definite în
fişierele header standard o mulŃime de funcŃii definite pentru prelucrarea şirurilor
de caractere.
Deoarece şirurile de caractere sunt construite ca tablouri unidimensionale,
majoritatea operatorilor definiŃi în mod standard nu pot opera cu acestea. Un tablou multidimensional este interpretat ca fiind un tablou unidimensional,
fiecare element fiind la rândul său un tablou.
Dacă se doreşte prelucrarea tuturor elementelor unui tablou, în mod uzual se
folosesc instrucŃiuni repetitive (de regulă cicluri for); pentru tablouri
multidimensionale se folosesc astfel de instrucŃiuni imbricate.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 179/267
179
Test de autoevaluare
1. Care din declaraŃiile de tablouri de mai jos este corecta?a. char nume[4] = {"d","o","r","u"};
b. #define n 10float cheltuieli[n];
c. char array x[12];d. #define n 5;
int matrice[n];
2. Care din referirile elementelor tabloului declarat astfel:int b[4] = {1, 2, 3, 4};
sunt corecte?a. float x = b[0];
b. b[4] = 7;c. b[5];d. nici una din cele de mai sus
3. Care din referirile elementelor tabloului declarat astfel:int b[4] = {1, 2, 3, 4};
sunt corecte?a. int x = b[0];
b. b[3] = b[0];c. b[4] = b[0];d. nici una din cele de mai sus
4. Care din referirile elementelor tabloului declarat astfel:double b[4] = {1, 2, 3, 4};
sunt corecte?a. int b = b[2];
b. float x = b[3] + b[1];c. int y = b[4];d. nici una din cele de mai sus
5. Se considera declaratia:double tablou[4] = {1, 9, 2, 4};
care din afirmaŃiile de mai jos sunt adevărate?a. este posibila atribuirea: tablou = 0x1000 b. tablou[4] întoarce valoarea 4c. sizeof(tablou[0]) întoarce 8d. sizeof(tablou) determina o eroare de sintaxa
6. Un sir de caractere este:a. o secvenŃa de tipul: 'Acesta este un sir'
b. un tablou multidimensional ale cărui elemente sunt caracterec. o succesiune de unităŃi alfanumerice păstrate in locaŃii de
memorie succesive care se termina cu 0
d. nimic din cele de mai sus
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 180/267
180
7. Declaratia:char tablou[ ] = {"Sir de caractere"};
a. este greşita pentru ca nu este specificat numarul de elementeale tabloului
b. este o declaraŃie cu initializarec. este greşita sintaxa folosita pentru initializarea tablouluid. determina rezervarea in memorie a unei zone in functie de
dimensiunea şirului dintre ghilimele
8. Se considera programul:#include <stdio.h>void main(void){
char tablou[ ] = "buna ziua!";tablou[0] = 'B';tablou[5] = 'Z';
printf("%s\n", tablou);}
acest program are ca efect:a. scrierea mesajului: "buna ziua!" pe ecran
b. scrierea mesajului: "Buna Ziua!" pe ecran si mutareacursorului cu un rând mai jos
c. scrierea mesajului: "buna ziua!" pe ecran si mutareacursorului cu un rând mai jos
d. producerea unor erori de sintaxă9. Se considera programul:
#include <stdio.h>void main(void)
{char tablou[] = "buna ziua!";char ch; ch = tablou[5];
printf("%c%c\n", ch, ch);tablou[0] = 'B';
printf("%s\n", tablou);
}acest program are ca efect:
a. scrierea mesajului: "zz" pe un rând si a mesajului "buna ziua!" pe al doilea rând
b. scrierea mesajului: "ZZ" pe un rând si a mesajului "buna ziua!" pe al doilea rând
c. scrierea mesajului: "zz" pe un rând si a mesajului "Buna ziua!" pe al doilea rând
d. scrierea mesajului: "ZZ" pe un rând si a mesajului "Buna Ziua!" pe al doilea rând
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 181/267
181
10. Exista vreo deosebire intre: 'c' si "c" ?
a. nu exista nici o deosebire, ambele fiind şiruri de cate uncaracter fiecare
b. 'c' este un caracter care este stocat intr-un octet de memorie,
iar "c" este un sir format dintr-un singur caracter, fiind stocatin doi octeti de memoriec. "c" este un caracter ,iar 'c' este un sir format dintr-un singur
caracter d. nici un răspuns din cele de mai sus nu este corect
Întrebări. ExerciŃii. Probleme.
1. Se citesc de la tastatură elementele unui tablou unidimensional. Să se înlocuiască toatevalorile negative cu valoarea 0. Se afişează elementele tabloului.
2. Se citesc de la tastatură elementele unui tablou unidimensional. Să se afişeze, în ordinecrescătoare, valorile introduse şi numărul lor de apariŃii.
3. Se citesc de la tastatură elementele a două tablouri unidimensionale. Se are în vedere cao valoare să nu se regăsească de mai multe ori într-un tablou. Să se afişeze valorile carese regăsesc în ambele tablouri şi indecşii corespunzători acestora.
4. Se citeşte de la tastatură un şir de caractere format numai din cifre. Să se convertească învaloarea numerică întreagă corespunzătoare.
5. Sã se întocmeascã un program în care se citeşte de la tastaturã un întreg în baza 10. Seafişează numãrul reprezentat în baza 2.
Nota:Cifrele binare obŃinute se vor memora în elementele unui tablou de întregi.
6. Sa se scrie un program in care se declara o matrice cu 4 x 5 reali. Se citesc de la tastaturavalori pentru elementele matricei şi se afişează. Se determină şi se afişează maximele de
pe fiecare linie a matricei care se memorează într-un tablou unidimensional(dimensiunea=nr. de linii ale matricei) şi maximul dintre toate elementele matricei.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 182/267
182
Unitatea de învăŃare U.10. VARIABILE POINTERI.VARIABILE REFERINłE.
Cuprins
Introducere .................................................................................................................. 182
Obiectivele unităŃii de învăŃare ................................................................................... 182
U10.1. Variabile pointeri ............................................................................................ 183
U10.1.1. Declararea variabilelor pointeri de date ............................................ 183
U10.1.2. OperaŃii de atribuire cu pointeri ........................................................ 184
U10.1.3. Referirea obiectelor prin variabile pointer ........................................ 185U10.1.4. Pointeri generici ................................................................................ 186
U10.1.5. OperaŃii aritmetice cu pointeri .......................................................... 187
U10.1.6. Tablouri şi pointeri ........................................................................... 188
U10.2. Variabile referinŃă ........................................................................................... 191
Exemple ...................................................................................................................... 192
Rezumat ...................................................................................................................... 195
Test de autoevaluare ................................................................................................... 195
Întrebări, exerciŃii şi probleme .................................................................................... 198
Introducere
Variabilele pointer sunt variabile care primesc ca valoare adrese de
memorie.
Din punct de vedere al conŃinutului zonei de memorie adresată prin
variabilele pointer, se disting două categorii:
pointeri de date – conŃin ca valori adrese de variabile sau constante;
pointeri de funcŃii – conŃin adrese de cod executabil ale funcŃiilor.
În această unitate de învăŃare vor fi prezentate noŃiuni referitoare la pointeri
de date.
De asemenea, vor fi prezentate variabilele referinŃă a căror semnificaŃie
fiind apropiată de pointerii de date, ele primind ca valoare adrese de memorie ale
unor obiecte.
Obiectivele unităŃii de învăŃare
După parcurgerea acestei unităŃi de învăŃare trebuie să ştii: Declararea variabilelor pointer;
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 183/267
183
Referirea variabilelor pointer;
SemnificaŃia şi folosirea pointerilor generici;
OperaŃiile care pot folosi operanzi pointeri; semnificaŃia operaŃiilor aritmetice cu
variabile pointer;
Legătura dintre variabile pointer şi tablouri de date;
SemnificaŃia şi modul de folosire a variabilelor referinŃă.
Durata medie de parcurgere a celei de a zecea unităŃi de învăŃare este de 2
ore.
U10.1. Variabile pointeri
U10.1.1. Declararea variabilelor pointeri de date
Sintaxa declarării unei variabile pointer de date este:
tip * nume_variabila;
unde: – tip poate fi orice tip de date, fundamental sau definit de utilizator;
– nume_variabilă este un identificator.
Simbolul * precizează că variabila declarată este un pointer. Ea va putea primi ca
valoare numai adrese de date de tipul tip.
Exemple de declarare a variabilelor pointeri:
int * p_i; // pointer la tipul intfloat * p_f; // pointer la tipul float;int* tab_p[10]; // tablou de pointeri către întregifloat ** p_p; // pointer la pointer
void * p_v; // pointer la tipul void – poate lua ca valoare adresa oricărui tip// de date
DeclaraŃia unei variabile pointer, ca în cazul oricărei variabile, are ca efect alocarea de
memorie, adresa putând fi determinată cu operatorul &, numărul de octeŃi alocaŃi fiind
determinat de tipul date (2 sau 4 octeŃi) şi se poate determina cu ajutorul operatorului sizeof.
int * p_i; // pointer la tipul int&p_i; // expresie care returnează adresa la care este alocată variabilasizeof(p_i); // expresie care returnează numărul de octeŃi alocaŃi pentru
// variabilă
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 184/267
184
DeclaraŃia unei variabile pointer poate fi făcută cu sau fără iniŃializare.
int * p_i; // declaraŃie fără iniŃializarefloat * p_r = 0; // declaraŃie cu iniŃializare
U10.1.2. OperaŃii de atribuire cu pointeri
Variabilele pointer pot prelua, prin atribuire, valoarea adreselor unor variabile sau
constante alocate în memorie.
Atribuirea se poate face numai dacă tipul pointerului şi tipul datei a cărei adresă o
preia sunt identice.
Variabilelor pointer nu li se pot atribui valori constante, cu excepŃia valorii 0.
Exemple de atribuire de valori variabilelor pointeri:
int var1;int *p1;
p1=&var1;double var2;double *p2;
p2=&var2; p2=&var1; // eroare, se atribuie adresa unui int unui pointer de tip double
p1=0; // atribuire corectă, valoarea 0 nu face referire la nici o adresă de// memorie
p1=NULL; // atribuire corectă, valoarea NULL este o constantă cu valoarea// 0 definită în mai multe fişiere header, cum ar fi stdlib.h,// alloc.h, stdio.h etc.
p1=0xFF00; // eroare, nu se admite atribuirea decât a constantei 0 sau a unei// adrese a unui obiect
ObservaŃii
Constanta întreagă 0 se poate atribui oricărei variabilă pointer. Această valoare
este desemnată în mod frecvent prin constanta NULL. Adresele funcŃiilor şi
obiectelor au valori diferite de 0. Valoarea 0 indică faptul că nu se face referire la
nici o adresă de memorie.
Variabilele pointer neiniŃializate, ca orice variabilă, iau valoarea 0 dacă sunt
declarate global sau static şi valori reziduale în cazul variabilelor automatice.
Este important ca orice variabilă pointer să fie iniŃializată cu o valoare validă, 0
sau adresa unui obiect alocat în memorie, înainte de a fi utilizată, deoarece la
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 185/267
185
compilare sau execuŃie nu se fac verificări privind validitatea adreselor utilizate.
Utilizarea incorectă a adreselor poate produce efecte necontrolate în evoluŃia
programului.
La atribuire este important ca tipul variabilei pointer şi tipul datei de la adresa
preluată să fie identice, în caz contrar se obŃine un mesaj de eroare.
U10.1.3. Referirea obiectelor prin variabile pointer
Se consideră secvenŃa:
tip nume_obiect;
tip*nume_pointer;
nume_pointer = &nume_obiect;
Referirea obiectului indirect, prin intermediul variabilei nume_pointer se face cusintaxa:
*nume_pointer
Această expresie se citeşte: obiectul de la adresa nume_pointer.
Expresia *nume_pointer poate fi folosită atât ca rvalue, cât şi ca lvalue, adică poate fi
folosită atât pentru a obŃine valoarea memorată la adresa indicată de pointer, cât şi pentru
atribuire.
Tipul pointerului determină modul de interpretare a datelor de la adresa indicată.
Se ia ca exemplu secvenŃa:
int var1=7;int * ptr1 = &var1;
Modul de interpretare al acesteia este descris în fig. 10.1.
Fig. 10.1. Exemplu de utilizare a variabilei pointer
Dacă variabila var1 este alocată la adresa 1003, variabila ptr1 preia ca valoare
valoarea 1003.
În continuare este prezentat un exemplu de folosire a variabilelor pointeri.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 186/267
186
#include <stdio.h>main(){
int var=100; // declaraŃie de variabilă intint *ptr; // declaraŃie de variabilă int * (pointer de int)
printf("\nVariabila var se afla la adresa: %p\n", &var); printf("\nsi are valoarea var= %d\n", var);
ptr=&var; printf("\nVariabila ptr are valoarea: %p\n", ptr); printf("\nsi adreseaza obiectul: %d\n",*ptr);
*ptr=200; // se modifică valoarea obiectului de la adresa memorată în ptr;// ptr conŃine adresa variabilei var, deci valoarea 200 este// preluată de var; prin *ptr se face referire în mod indirect la// variabila var, operaŃia se mai numeşte “indirectare“
printf("\nAcum var are valoarea %d\n", var);}
U10.1.4. Pointeri generici
Se pot defini pointeri la tipul void. Ei constituie o categorie aparte de pointeri. Aceştia
pot primi ca valoare adresa oricărui tip de date şi se numesc pointeri generici.
Exemplu de folosire a pointerilor generici:
int vi=10;double vr = 1.5;void * pv;
pv = &vi; // corect, pv poate prelua adresa oricărui tip de date pv = &vr; // corect, pv poate prelua adresa oricărui tip de date
Pentru referirea obiectelor prin intermediul unui pointer generic, este necesar să se precizeze, prin conversia pointerului, tipul obiectului referit, astfel încât compilatorul să aibă
informaŃia necesară despre reprezentarea obiectului referit.
int vi=10;double vr = 1.5;void * pv;
pv = &vi; printf(“%d”, *(int*)pv); pv = &vr;
*(double*)pv = 9.5; printf(“%lf”, *(double*)pv);
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 187/267
187
U10.1.5. OperaŃii aritmetice cu pointeri
Cu variabilele pointer, în afară de operaŃiile de atribuire, se pot face şi operaŃii de
adunare, scădere, inclusiv incrementare şi decrementare şi operaŃii de comparare.
Valorile a doi pointeri pot fi comparate folosind operatorii relaŃionali, spre exemplu:
int*p1, *p2;…if(p1<p2)
printf(“p1<p2”);if(p1==0)
printf(“pointerul p1 nu adreseaza nici un obiect”);
OperaŃiile de adunare şi scădere sunt interpretate diferit faŃă de operaŃiile efectuate cu
date numerice.Având variabila pointer
tip * ptr;
Expresia:
ptr +n
returnează ca valoare adresa memorată în ptr la care se adaugă
n* sizeof(tip)
Pentru situaŃia descrisă prin secvenŃa:
int var1, var2, *ptr; ptr = &var1; ptr = ptr +1;
expresia (ptr + 1) reprezintă deplasarea în memorie cu un întreg, adică cu un număr de octeŃi
egal cu sizeof(int) (vezi Fig. 10.2.).
Fig. 10.2. Exemplu pentru operaŃia de adunare a unui întreg la un pointer
Exemplu de expresii ce conŃin operaŃii aritmetice cu pointeri:
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 188/267
188
float *pf;
pf +4; // adresa se modifică cu sizeof(float)*4, adică cu 20 de octeŃi pf++; // pf îşi modifică valoarea, creşte cu 4 octeŃi pf--; // pf îşi modifică valoarea, scade cu 4 octeŃi
U10.1.6. Tablouri şi pointeri
Numele unui tablou fără index este un pointer constant de tipul elementelor tabloului
şi are ca valoare adresa primului element al tabloului.
char *str=”STRING”;
Fig.9.3. Legătura dintre pointeri şi tablouri de date
Având în vedere semnificaŃia operaŃiilor de adunare şi scădere cu variabile pointer, se
pot referi elementele tabloului fie prin index, fie prin operaŃii cu pointeri ca în exemplele
următoare.
Exemple referitoare la legătura dintre pointeri şi tablouri de date:
float tab[20], *ptr; ptr=tab; // atribuire validă, pointerul ptr va conŃine adresa
// primului element al tabloului&tab[0] = = tab ; // expresie adevărată&tab[2] = = tab+2 ; // expresie adevăratătab[0] = = *tab ; // expresie adevărată
tab[2] = = *(tab+2) ; // expresie adevăratătab++ ; // eroare, tab este un pointer constant, deci nu se poate// incrementa
ptr++ ; // corect, ptr este un pointer la float, nu a fost// declarat constant
Tablourile multidimensionale reprezintă tablouri cu elemente tablouri, astfel încât
numele tabloului (fără index) este un pointer de tablouri.
float mat[10][10]; // mat reprezintă un tablou de pointeri floatfloat *p; // p este un pointer float
p=mat; // eroare, tipurile pointerilor diferă, unul este pointer // de float, celălalt e pointer de pointer de float
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 189/267
189
p=(float*)mat; // corect, s-a folosit o conversie explicită de tipmat = = &mat[0][0]; // expresie adevăratămat+1 = = &mat[1][0]; // expresie adevărată*(mat+9) = = mat[9][0]; // expresie adevărată
Având în vedere aceste corespondenŃe, se pot scrie secvenŃe de cod echivalente, fie
folosind referirea elementelor de tablou prin index, fie folosind expresii cu pointeri, ca în
exemplele următoare.
SecvenŃa următoare:
int tab[7]={9,11,25,7,44,2,14}; printf("\n\nafisarea elementelor tabloului tab);for( i = 0 ; i <7 ; i++)
printf("\ntab[%d] = %d", i, tab[i]);
poate fi rescrisă astfel:
int tab[7] = {9,11,25,7,44,2,14}; printf("\n\nafisarea elementelor tabloului tab);for( i = 0 ; i <7 ; i++)
printf("\ntab[%d] = %d", i, *(tab + i)); // expresia tab+i reprezintă ca valoare// adresa elementului de index i
Sau secvenŃa:
printf("\n\ncitire de valori de la tastatura pentru elementele tabloului tab");for( i = 0; i<7 ; i++){ printf("\ntab[%d]=",i);
scanf("%d",&tab[i]);}
poate fi înlocuită cu:
printf("\n\ncitire de valori de la tastatura pentru elementele tabloului tab");
for( i = 0; i<7 ; i++){ printf("\ntab[%d]=",i);
scanf("%d", tab + 1); // în funcŃia scanf() se precizează adresa la care// se depune valoarea citită de la tastatură
}
În mod similar se poate proceda şi în cazul matricelor. Astfel, secvenŃa de citire a
elementelor matricei de la tastatură următoare:
int mat[3][4], i, j;//se citesc de la tastatura elementele lui mat
printf("Introduceti elementele matricei mat:\n");for(i=0 ; i<3 ; i++)
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 190/267
190
for(j=0 ; j<4 ; j++){ printf("mat1[%d][%d]=", i, j);
scanf("%d", &mat1[i][j]);}
se poate scrie folosind operaŃii cu pointeri:
printf("Introduceti elementele matricei mat:\n");for(i=0;i<3;i++)for(j=0;j<4;j++){ printf("mat[%d][%d]=", i, j);
scanf("%d",*(mat+i)+j); // expresia (*(mat+i)+j) reprezintă adresa// elementului de pe linia i, coloana j
}
ObservaŃii
Expresia (mat) reprezintă adresa la care e alocată matricea; ca tip de dată este un
pointer de pointer de int (dublă indirectare);
Expresia (mat+i) reprezintă adresa liniei de index i; ca tip de dată este un pointer
de pointer de int (dublă indirectare);
Expresia *(mat+i) reprezintă adresa primului element de pe linia de index i; ca
valoare este egală cu valoarea expresiei (mat+i) dar ca tip de dată este un pointer
de int (simplă indirectare);
Expresia *(mat+i)+j reprezintă adresa elementului de index j al liniei de index i ;
ca tip de dată este un pointer de int (simplă indirectare).
SecvenŃa de afişare a elementelor matricei:
printf("\nmat:");for(i=0;i<3;i++){ printf("\n");
for(j=0;j<4;j++) printf("%6d",mat[i][j]);
}
este echivalentă cu secvenŃa:
printf("\nmat:");for(i=0;i<3;i++){ printf("\n");
for(j=0;j<4;j++) printf("%6d",*(*(mat+i)+j));}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 191/267
191
U10.2. Variabile referinŃă
C++ oferă posibilitatea de a declara identificatori ca referinŃe de obiecte (variabile sau
constante). ReferinŃele, ca şi pointerii, conŃin adrese. Pentru a declara o referinŃă la un obiect
se foloseşte simbolul &, folosind sintaxa:
tip & id_referinta = nume_obiect;
unde:
- tip este tipul obiectului pentru care se declară referinŃa,
- simbolul & precizează că id_referinta este numele unei variabile referinŃă
- nume_obiect este obiectul a cărui adresă va fi conŃinută în id_referinta.
Exemplu de declarare şi folosire comparativă a variabilelor pointeri şi referinŃă:
int n; // se declară n de tip întregint * p=&n; // se declară pointerul p cu iniŃializare adresa lui nint &r=n; // se defineşte r referinŃa lui n
n=20; // n primeşte valoarea 20*p=25; // n primeşte valoarea 25r=30; // n primeşte valoarea 30
În exemplul anterior, atât p, cât şi r, acŃionează asupra variabilei n.
Atunci când se accesează o variabilă prin referinŃa sa, nu este necesar să se folosească
adresa, acest lucru realizându-se automat.
Spre deosebire de pointeri, care la un moment dat pot primi ca valoare adresa unei alte
variabile, referinŃele nu pot fi modificate, ele fiind practic o redenumire a variabilei a căror
adresă o conŃin (se creează un alias al respectivei variabile).
În utilizarea referinŃelor, trebuie avute în vedere următoarele restricŃii:
referinŃele trebuie iniŃializate în momentul declarării;
referinŃelor nu li se pot modifica locaŃiile la care se referă;
nu sunt permise referinŃe la câmpuri de biŃi, referinŃe la referinŃe şi pointeri la
referinŃe, deci nici tablouri de referinŃe.
int &r ; // eroare, se declară o referinŃă fără iniŃializare
int &r=20 ; // corect, se declară o referinŃă la o constantă
const int i = 20;int &r = i ; // eroare, se declară o referinŃă întreagă la o constantă
// întreagăconst int i = 20;
const int &r = i ; // corect, se declară o referinŃă constantă întreagă la o// constantă întreagă
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 192/267
192
ObservaŃii
ReferinŃele de sine stătătoare sunt rar folosite. În schimb, utilizarea parametrilor
formali referinŃă permite transferul prin referinŃă simplu şi eficient, fără
recurgerea la parametri formali pointeri.
Exemple
/***************************************************************************
Exemplul 10.1.
Se exemplifică legătura dintre tablouri şi pointeri. Se foloseşte în paralel referirea elementelor unui tablou unidimensional prin indecşi şi, respectiv, folosind operaŃii cu pointeri.
***************************************************************************/
#include <stdio.h>#include <conio.h>
void main(){
float vect[]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
float *p;int i; p=vect; printf("\n");
//se afiseaza elementele tabloului vect - referirea elementelor se face prin index
for(i=0 ; i<12 ; i++) printf("%6.2f", vect[i]);
printf("\n");
//se afiseaza elementele tabloului vect - referirea elementelor se face prin adrese
for(i=0 ; i<12 ; i++) printf("%6.2f", *(vect+i));
printf("\n");
//se afiseaza elementele tabloului vect - referirea elementelor se face prin adrese, folosind//pointerul p (p nu isi modifica valoarea)
for(i=0 ; i<12 ; i++) printf("%6.2f", *(p+i));
printf("\n");
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 193/267
193
//se afiseaza elementele tabloului vect - folosind pointerul p, referirea se face prin index//(p nu isi modifica valoarea)
for(i=0 ; i<12 ; i++) printf("%6.2f", p[i]);
printf("\n");
//se afiseaza elementele tabloului vect - folosind pointerul p (p isi modifica valoarea prin//incrementare)
for(i=0 ; i<12 ; i++) printf("%6.2f", *p++);getch();
}
/***************************************************************************
Exemplul 10.2.
Se exemplifică legătura dintre tablouri şi pointeri. Se foloseşte în paralel referirea elementelor
unui şir de caractere folosind operaŃii cu pointeri.
***************************************************************************/
#include <stdio.h>
#include <conio.h>void main(void){
char sir[25] = "siruri si pointeri";int i;
// Se afiseaza, caracter cu caracter, toate caracterele in format %c si %d.for(i=0 ; i<25 ; i++)
printf("\n %c - %d", *(sir+i), *(sir+i)); printf("\n");
// Se afiseaza, caracter cu caracter, toate caracterele, pana la intalnirea terminatorului de sir,// in format %c si %d .for(i=0 ; *(sir+i) != 0 ; i++)
printf("\n %c - %d", *(sir+i), *(sir+i));
*sir = 'S';*(sir+7) = 'S';*(sir+10) = 'P';
printf("\nSirul este: %s", sir);getch();
}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 194/267
194
/***************************************************************************
Exemplul 10.3.
Se exemplifică legătura dintre tablouri şi pointeri. Se foloseşte în paralel referirea elementelor
unui tablou multidimensional (matrice) prin indecşi şi, respectiv, folosind operaŃii cu pointeri.
***************************************************************************/
#include <stdio.h>#include <conio.h>
void main(){
int mat[3][4]={ {1, 2, 3, 4},{5, 6, 7, 8},{9, 10, 11, 12}};
int *p, i, j;
//afisarea elementelor matricii - referire prin cei doi indecsi
for(i=0 ; i<3 ; i++){ printf("\n");for(j=0 ; j<4 ; j++)
printf("%5d", mat[i][j]);getch();
}
//afisarea de informatii despre matrice
printf("\nsizeof(*mat) = %d", sizeof(*mat)); printf("\n**mat = %d", **mat); printf("\n**(mat+1) = %d", **(mat+1)); printf("\n**(mat+2) = %d", **(mat+2));
//atribuire prin conversie explicita a pointerului
p = (int*)mat;
// afisarea elementelor tabloului, folosind pointerul p
for(i=0 ; i++ ; i<12) printf("%5d", *(p+i));getch();
// afisarea elementelor tabloului, folosind pointerul p cu specificarea liniei si coloanei// elementului
for(i=0 ; i<3 ; i++){ printf("\n");for(j=0 ; j<4 ; j++)
printf("%5d", *(p+i*4+j));
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 195/267
195
getch();}
for(i=0 ; i<3 ; i++){ printf("\n");
for(j=0 ; j<4 ; j++) printf("%5d", p[i*4+j]);getch();
}
printf("\n");getch();
}
Rezumat
Variabilele pointer sunt variabile care primesc ca valoare adrese de memorie.
Pentru a declara un pointer se foloseşte simbolul *.
DeclaraŃia unei variabile pointer, ca în cazul oricărei variabile, are ca efect
alocarea de memorie; variabilele pointer sunt caracterizate de aceleaşi atribute ca
orice variabilă (clasă de memorare, domeniu, durată de viaŃă).
DeclaraŃia unei variabile pointer poate fi făcută cu sau fără iniŃializare.
Variabilele pointer pot prelua, prin atribuire, valoarea adreselor unor variabilesau constante alocate în memorie; atribuirea se poate face numai dacă tipul
pointerului şi tipul datei a cărei adresă o preia sunt identice.
Variabilelor pointer nu li se pot atribui valori constante, cu excepŃia valorii 0.
Tipul pointerului determină modul de interpretare a datelor de la adresa indicată
de acesta.
Se pot defini pointeri la tipul void. Ei pot primi ca valoare adresa oricărui tip de
date şi se numesc pointeri generici.
Cu variabilele pointer se pot face operaŃii aritmetice (adunare, scădere cu unîntreg, incrementare, decrementare) şi operaŃii de relaŃionale.
Numele unui tablou fără index este un pointer constant de tipul elementelor
tabloului.
Tablourile multidimensionale reprezintă tablouri cu elemente tablouri, astfel
încât numele tabloului (fără index) este un pointer de tablouri.
ReferinŃele, ca şi pointerii, conŃin adrese. Pentru a declara o referinŃă la un
obiect se foloseşte simbolul &.
Variabilele referinŃă trebuie iniŃializate în momentul declarării; referinŃelor nu lise pot modifica locaŃiile la care se referă.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 196/267
196
Test de autoevaluare
1. Care din secvenŃele de mai jos este corecta?a. char nume[4], *p; p=nume;
b. #define n 10float cheltuieli[n]; cheltuieli++;
c. char array[12]; array=100;d. #define n 5;
int matrice[n]; *matrice = 10;
2. Se considera declaratia:int tablou[4] = {1, 9, 2, 4};
care din afirmaŃiile de mai jos sunt adevărate?
a. sizeof(tablou[0]) întoarce 4 b. sizeof(tablou) întoarce 16c. *(tablou+2) este acelaşi lucru cu tablou[2]d. *tablou[0] este acelaşi lucru cu tablou
3. Ce va afisa secvenŃa de instrucŃiuni C de mai jos?int x, a[4];x = &a[2] - &a[0];
printf("%d", x);a. 6
b. 2
c. 3d. Nimic din cele de mai sus, secvenŃa fiind greşita
4. Ce va afisa secvenŃa de instrucŃiuni C de mai jos?int x; float a[10];x = &a[8] - &a[0];
printf("%d", x);a. 16
b. 32c. 8d. Un mesaj de eroare
5. Se considera secvenŃa:float tabel[5] = {1, 2, 3, 4, 5};float *pt;
Care din instrucŃiunile de mai jos sunt corecte?a. tabel = pt;
b. pt = tabel;c. pt++;d. tabel++;e. tabel[2]--;
6. Se considera secvenŃa:float tabel[5] = {1, 2, 3, 4, 5};
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 197/267
197
float *pt;Care din instrucŃiunile de mai jos sunt corecte?
a. --pt; b. tabel[4]--;c. (*(tabel+3))--;
d. --tabel;
7. Care din atribuirile de mai jos sunt corecte?a. char *adr_sir;
. . .adr_sir = "Acest sir";
b. char tab[5] = {"Acest sir"};c. char tab[10] = {"Acest sir"};d. char tab[10];
tab = "Acest sir";
8. Se considera programul:#include <stdio.h>void main(void){ char* adr_sir = "Sir de caractere";
char ch;ch = *(adr_sir+4);
printf("%c", ch);}
acest program are ca efect:a. scrierea caracterului d pe ecran
b. citirea unui caracter de la tastatura
c. nici un efect vizibil
9. Se considera programul:#include <stdio.h>
void main(void){ char* adr_sir = "Sir de caractere";
char ch;ch=*(adr_sir+3);
printf("%c",ch);}
acest program are ca efect:a. scrierea caracterului d pe ecran
b. producerea unor eroric. citirea unui caracter de la tastaturad. mutarea cursorului cu o pozitie la dreapta
10. Se considera declaraŃiile de mai jos:char* pointer_la_caracter;char caracter;
care din secvenŃele de mai jos sunt corecte?a. &caracter = "a";
b. pointer_la_caracter = "b";c. pointer_la_caracter = 'a';d. *pointer_la_caracter = "b";
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 198/267
198
11. Se considera programul de mai jos:
#include <stdio.h>void main(void){ char sir[10] = "Mesaj"; int i;
for(i=0 ; sir[i] ; i++); printf("Numar=%d\n", i);}
Care din afirmaŃiile de mai jos sunt adevărate?a. ieşirea din ciclul for se face la întâlnirea marcajului '\0'
b. programul are ca efect afisarea pe ecran a mesajului: Numar=6
c. programul are ca efect afisarea pe ecran a mesajului: Numar=5
d. programul conŃine erori de sintaxa
12. SecvenŃa următoare:void main (void)
{ char *adr;adr='h';.... }
are ca efect:a. se pune in pointer adresa şirului 'h'
b. la adresa din variabila adr se pune 'h'c. eroare, nu se poate pune un caracter intr-o variabila de tip adresa
Întrebări. ExerciŃii. Probleme.
1. Se citesc de la tastatură elementele unui tablou unidimensional. Să se înlocuiască toatevalorile negative cu valoarea 0. Se afişează elementele tabloului. Pentru referireaelementelor se vor folosi operaŃii cu pointeri.
2. Se citesc de la tastatură elementele a două tablouri unidimensionale de aceeaşidimensiune. Se calculează elementele unui al treilea tablou ca sumă a elementelor deacelaşi index ale primelor două şi se afişează. Pentru referirea elementelor se vor folosioperaŃii cu pointeri.
3. Se citesc de la tastatură două şiruri de caractere. Se determină un al treilea şir princoncatenarea primelor două şi se afişează. Pentru referirea elementelor se vor folosioperaŃii cu pointeri.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 199/267
199
Unitatea de învăŃare U.11.ALOCARE DINAMICĂ DE MEMORIE
CuprinsIntroducere .................................................................................................................. 199
Obiectivele unităŃii de învăŃare ................................................................................... 200
U11.1. Alocare dinamică de memorie ........................................................................ 200
U11.2. Alocare dinamică de memorie folosind funcŃii specifice ................................ 201
U11.3. Alocare dinamică de memorie folosind operatorii new şi delete .................... 203
U11.4. Alocare dinamică de memorie pentru tablouri multidimensionale ................. 205
Exemple ...................................................................................................................... 207
Rezumat ...................................................................................................................... 211Test de autoevaluare ................................................................................................... 212
Întrebări, exerciŃii şi probleme .................................................................................... 215
Introducere
Pentru toate tipurile de date descrise până acum (simple sau structurate),
memoria necesară la execuŃia programului este determinată de declaraŃiile făcute pentru variabile, deci ea este stabilită înainte de execuŃia programului. Variabilele
sunt alocate în memorie în momentul declarării lor şi rămân alocate tot timpul
execuŃiei programului în cazul variabilelor globale sau statice sau, în cazul
variabilelor automatice, până la încheierea blocului în care au fost declarate.
Sunt situaŃii în care, pentru o gestionare eficientă a memoriei, este de dorit
ca în momentul în care unele variabile nu mai sunt necesare să fie eliminate din
memorie. De asemenea, la scrierea programelor se doreşte să se dea un grad de
generalitate cât mai mare, astfel încât să poată fi prelucrate, după acelaşi algoritm,
pachete de date de diferite dimensiuni. De exemplu, dacă într-un program este
declarat un tablou de date, pentru el este stabilită dimensiunea printr-o constantă.
Este posibil ca la execuŃia programului să fie necesar un număr mult mai mic de
elemente, ceea ce înseamnă că o parte din memorie este alocată inutil. Dacă însă
numărul de elemente necesar este mai mare decât dimensiunea stabilită, este
necesară modificarea codului sursă şi recompilarea lui. Astfel de situaŃii pot fi
evitate prin manevrarea în mod dinamic a variabilelor, adică, stabilirea dimensiunii
memoriei necesare în momentul execuŃiei programului, alocarea ei în momentul în
care variabilele devin necesare şi eliminarea lor când utilitatea lor a încetat.Memoria astfel eliberată va putea fi realocată în alt scop.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 200/267
200
Obiectivele unităŃii de învăŃare
După parcurgerea acestei unităŃi de învăŃare trebuie să ştii:
Cum determină clasa de memorare a variabilelor declaraŃia acestora;
FuncŃii folosite pentru alocarea dinamică de memorie;
Utilizarea operatorilor new şi delete; Alocarea dinamică a tablourilor uni şi multi-dimensionale.
Durata medie de parcurgere a celei de a unsprezecea unităŃi de învăŃare este
de 2 ore.
U11.1. Alocarea dinamică de memorie
Pentru gestionarea memoriei, aceasta este împărŃită în segmente specializate.
Microprocesoarele dispun de regiştri în care se memorează adresele segmentelor. Se folosesc
patru regiştri de segment specializaŃi (CS, DS, ES, SS), ceea ce permite adresarea simultană a
patru segmente folosindu-se adresa de segment din registrul asociat:
- segment de cod (instrucŃiuni) - Code Segment (CS);
- segment de date – Data Segment (DS);
- segment de date suplimentar – ExtraSegment (ES) ;- segment de stivă – Stack Segment (SS).
Având în vedere acest mod de gestionare a memoriei, programele C/C++, la execuŃie,
încarcă în memorie 4 tipuri de informaŃie:
- codul executabil – memorat în segmente de cod;
- date statice – memorate în segmente de date;
- date automatice – alocate în pe stivă sau regiştri;
- date dinamice – alocate în zona heap.
Se alocă static memorie pentru constante, variabilele globale şi variabilele locale
declarate în mod explicit static.
Se alocă memorie pe stivă pentru variabilele locale.
int a, b; // a, b, x - variabile declarate global, alocate în segmentul de datedouble x;
double f1(int c, double v) // parametrii c, v – alocaŃi pe stivă{
int b; // b – variabilă locală funcŃiei f1(), alocată pe stivăstatic double z; // z – variabilă locală funcŃiei declarată static, alocată în
.... // segmentul de date}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 201/267
201
void main(){
int k; // k – variabilă locală funcŃiei main(), alocată pe stivă printf(”Sir constant”); // constanta ”Sir constant” este memorată în segmentul
// de date
....}
Este de dorit ca în cazul datelor a căror dimensiune nu este cunoscută a priori sau
variază în limite largi, să se utilizeze o altă abordare: alocarea memoriei în mod dinamic. În
mod dinamic, memoria nu mai este alocată în momentul compilării, ci în momentul execuŃiei.
Alocarea dinamică elimină necesitatea definirii complete a tuturor cerinŃelor de
memorie în momentul compilării.
U11.2. Alocarea dinamică de memorie folosind funcŃii specifice
Alocarea de memorie dinamică se realizează în mod explicit, cu ajutorul funcŃiilor de
alocare dinamica în limbajul C. C++ completează posibilităŃile de alocare dinamică prin
operatorii new şi delete care sunt adaptaŃi programării orientate pe obiecte.
În limbajul C, alocarea memoriei în mod dinamic se face cu ajutorul funcŃiilor malloc,
calloc, realloc; eliberarea zonei de memorie se face cu ajutorul funcŃiei free. FuncŃiile de
alocare/dealocare a memoriei au prototipurile în fişierele header <stdlib.h> şi <alloc.h>:
Alocarea de memorie se poate face cu funcŃiile:
void *malloc(size_t nr_octei_de_alocat);
- FuncŃia malloc necesită un singur argument (numărul de octeŃi care vor fi alocaŃi) şi
returnează un pointer generic către zona de memorie alocată (pointerul conŃine adresa
primului octet al zonei de memorie rezervate).
void *calloc(size_t nr_elemente, size_t mărimea_în_octeŃi_ a_unui_elem);
- FuncŃia calloc lucrează în mod similar cu malloc; alocă memorie pentru un tablou de
nr_elemente, numărul de octeŃi pe care este memorat un element este
mărimea_în_octeŃi_a_unui_elem şi returnează un pointer către zona de memorie alocată.
void *realloc(void *ptr, size_t mărime);
- FuncŃia realloc permite modificarea zonei de memorie alocată dinamic cu ajutorul
funcŃiilor malloc sau calloc.
FuncŃiile malloc, calloc, realloc returnează adresa de memorie la care s-a făcut
alocarea. Valoarea întoarsă este un pointer generic (void*). Aceasta, de regulă, se memorează
într-o variabilă pointer de un tip oarecare, astfel că la atribuire este necesară conversiaexplicită către tipul variabilei situată în stânga operatorului de atribuire.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 202/267
202
În cazul în care nu se reuşeşte alocarea dinamică a memoriei (memorie insuficientă),
funcŃiile malloc, calloc şi realloc returnează un pointer NULL ( valoare 0).
Eliberarea memoriei (alocate dinamic cu una dintre funcŃiile malloc, calloc sau
realloc) se realizează cu ajutorul funcŃiei free.
void free(void *ptr);
Exemple de folosire a funcŃiilor de alocare dinamică:
int *p; p=(int*)malloc(20*sizeof(int)); // se rezervă 20*sizeof(int) octeŃi, adresa fiind
// memorată în variabila p
sau
p=(int*)calloc(20, sizeof(int));
Eliberarea de memorie se face:
free(p);
ObservaŃii
Alocarea făcută în exemplele anterioare poate fi gestionată similar cu un tablou
alocat prin declaraŃiaint p[20];
Avantajul constă în faptul că, în momentul în care alocarea nu mai este necesară,
se poate folosi funcŃia free(), memoria respectivă putând fi apoi folosită în alt
scop.
Pentru a se evita generarea unor erori, se recomandă să se verifice dacă operaŃiile dealocare au reuşit:
int *p; p=(int*)malloc(20*sizeof(int));if ( p== NULL) // dacă valoarea preluată de p este NULL
{ // (0), operaŃia de alocare a eşuat, ceea ce printf(“\nAlocare imposibila !”); // poate genera erori fataleexit(1);
}….
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 203/267
203
Dimensiunea, în octeŃi, pentru memoria alocată poate fi exprimată nu doar printr-o
constantă, ci şi prin variabile sau chiar expresii diverse care returnează valoare întreagă
pozitivă.
int dimensiune;float*pr;
printf(“\nIntroduceŃi dimensiunea :”);scanf(“%d”, &dimensiune);
pr = (float*)malloc( dimensiune * sizeof(float)) ;….free(pr) ;
printf(“\nIntroduceŃi alta valoare pentru dimensiune:”);scanf(“%d”, &dimensiune);
pr = (float*)malloc( dimensiune * sizeof(float)) ;…free(pr) ;
ObservaŃii
Dimensiunea alocării e stabilită în momentul execuŃiei programului prin citirea
variabilei dimensiune.
Alocarea de memorie poate fi repetată.
Eliberarea memoriei alocată cu malloc, calloc se face numai cu funcŃia free; dacă
nu este apelată funcŃia free şi pointerul pr îşi schimbă valoarea, zona alocată nu
va mai putea fi accesată, blocând memorie în mod inutil; Dacă operaŃiile de alocare se repetă fără eliberare de memorie făcută între timp,
se poate ajunge la ocuparea întregii memorii.
U11.3. Alocarea dinamică de memorie folosind operatorii new şi delete
C++ introduce o nouă metodă pentru alocarea dinamică a memoriei adaptată
programării orientate către obiecte.
Alocarea memoriei se face cu operatorul unar new, folosind următoarea sintaxă:
var_ptr = new tip_var; // 1 var_ptr = new tip_var(val_init); // 2 var_ptr = new tip_var[dim]; // 3
unde: - var_ptr = o variabilă pointer de un tip oarecare;
- tip_var = tipul variabilei dinamice var_ptr;
- val_init = expresie cu a cărei valoare se iniŃializează variabila dinamică;
Varianta 1 alocă spaŃiu de memorie corespunzător unei date de tip tip_var, fără
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 204/267
204
iniŃializare.
Varianta 2 alocă spaŃiu de memorie corespunzător unei date de tip tip_var, cu
iniŃializare.
Varianta 3 alocă spaŃiu de memorie corespunzător unei tablou cu elemente de tip
tip_var de dimensiune dim. IniŃializarea tabloului nu este posibilă.
Dacă alocarea de memorie a reuşit, operatorul new returnează adresa zonei de
memorie alocate. În caz contrar, returnează valoarea NULL (=0) (în cazul în care memoria
este insuficientă sau fragmentată).
int n=3, * p1, *p2, *p3; p1=new int; // variabilă întreagă neiniŃializată p2=new int(15); // variabilă întreagă iniŃializată cu valoarea 15 p3=new int[n]; // tablou unidimensional int de dimensiune n
Eliminarea variabilei dinamice şi eliberarea zonei de memorie se face cu operatorul
delete, folosind sintaxa:
delete var_ptr; // 1
saudelete [ ]var_ptr; // 2
unde var_ptr conŃine adresa obŃinută în urma unei alocări cu operatorul new. Utilizarea altei
valori este ilegală, putând determina o comportare a programului necontrolată.
Varianta de dealocare (1) este folosită dacă la alocare s-au folosit variantele de alocare(1) sau (2), iar varianta (2) dacă la alocare s-au folosit varianta de alocare (3).
int *p; p=new int(10); // se alocă spaŃiul de memorie necesar unui int şi se face
// iniŃializarea cu valoarea 10delete p; // se elimină variabila p din memorie
int *p,*q;
p=new int(7); // se alocă spaŃiul de memorie necesar unui int şi se face// iniŃializarea cu valoarea 7q=p; // variabila pointer q primeşte ca valoare adresa conŃinută
// în variabila pdelete q; // se eliberează zona de memorie de la adresa conŃinută
// în variabila q*p=17; // incorect, foloseşte o zona de memorie care a fost deja
// dealocatăint x=7;int *y=&x;delete y; // incorect, se cere dealocarea unei zone de memorie
// care nu a fost alocată cu operatorul new
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 205/267
205
double * pr; pr= new double[10]; // se alocă 10 elemente de tip double…delete [ ] pr; // eliberarea spaŃiului pentru cele 10 elemente
double * pr; pr= new double[10]; // se alocă 10 elemente de tip double…delete pr; // se eliberează doar spaŃiul ocupat de primul element,
// celelalte 9 elemente rămânând alocate în continuare în// memorie
U11.4. Alocarea dinamică de memorie pentru tablouri multidimensionale
FuncŃiile, respectiv operatorul new, destinate alocării de memorie permit alocareadinamică de tablouri, dar sintaxa permite stabilirea unei singure dimensiuni. Se pune
problema construirii de tablouri multidimensionale.
Dacă se doreşte alocarea unui tablou cu n dimensiuni (dim1, dim2,...,dimn), se poate
aloca un tablou unidimensional cu un număr de elemente calculat prin produsul
dim1*dim2*...*dimn, urmând ca apoi să se gestioneze logic aceste elemente prin expresii care
calculează indecşii elementelor care să descrie parcurgerea tablourilor.
De exemplu, pentru a construi o matrice (tablou bidimensional), cu n linii şi m
coloane, se alocă un tablou unidimensional de dimensiune n*m. Indecşii elementelor se
calculează cu expresia : (i * m) + j, unde i reprezintă număr de linie, j reprezintă număr de
coloană. Acest mod de abordare se regăseşte în exemplul următor.
int n, m; // n - nr. de linii ; m – nr. coloaneint * mat; // pointer folosit pentru alocarea de memorieint i, j; // variabile folosite pentru parcurgerea elementelor matricei
// citirea dimensiunilor matricei printf("\nNumarul de linii:");scanf("%d", &n);
printf("\nNumarul de coloane:");scanf("%d", &m);
// alocarea de memoriemat=new int[n*m.];
//...
// dealocarea de memoriedelete [ ]mat;
O altă posibilitate de construire a matricei este folosirea unei duble indirectări(int**mat). Alocarea se face în două etape. O primă etapă în care se alocă un tablou
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 206/267
206
unidimensional cu elemente de tip int* de dimensiune egală cu numărul de linii. Elementele
acestuia vor memora adresele obŃinute în a doua etapă, când, într-o secvenŃă repetitivă se vor
aloca tablouri unidimensionale cu elemente de tip int. Se alocă un număr egal cu numărul de
linii de tablouri, fiecare având un număr de elemente egal cu numărul de coloane.
int n, m;int ** mat;int i, j;
//....//alocarea tabloului de adrese
mat=new int*[n];
// alocarea celor n linii ale matricei; alocarea se face distinct pentru fiecare liniefor(i=0; i<n ; i++)
mat[i]=new int[m];//....
Eliberarea de memorie se va face tot în două etape, ordinea dealocării fiind inversă
celei de alocare.
// dealocarea celor n linii ale matricei; se face distinct pentru fiecare liniefor(i=0; i<n ; i++)
delete [ ]mat[i];
// dealocarea tabloului de adresedelete [ ]mat;
Fig. 11.1. Reprezentarea alocării dinamice de memorie a unei matrice folosind dubla indirectare(nr.linii = 5, nr.coloane = 6)
Această metodă de lucru are două avantaje faŃă de anterioara. Un prim avantaj, unul
formal, îl constituie faptul că referirea elementelor se face similar declaraŃiei statice a
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 207/267
207
tabloului (mat[i][j]). Cel de al doilea avantaj este faptul că, spre deosebire de alocarea ca
tablou unidimensional, când toate elementele sunt alocate într-o zonă contiguă de memorie, în
cazul alocării prin dubla indirectare alocarea se face disparat, fiecare linie putând fi alocată în
altă zonă a segmentului heap. Aceasta duce la o mai bună utilizare a memoriei.
În Fig. 11.1. este reprezentat modul de alocare a memoriei pentru situaŃia în care
numărul de linii este 5, iar numărul de coloane este 6.
Exemple
/**************************************************************************
Exemplu1 11.1. - Se scrie un program în care se exemplifică folosirea alocării dinamice de
memorie. Se realizează alocare de blocuri de memorie în mod repetat, până la ocuparea
întregii memorii.**************************************************************************/
#include<stdio.h>#include<conio.h>#include<malloc.h>
void main(){int i, dim; // variabila dim determină dimensiunea blocurilor de
// memorie care se vor alocadouble *p;
printf("\nIntroduceŃi dimensiunea blocurilor: ");scanf("%d", &dim);
// se foloseşte instrucŃiunea for fără specificarea condiŃiei de ieşire din ciclu;// ieşirea se va face cu instrucŃiunea "break" în momentul în care memoria a fost ocupată şi// alocarea nu se mai poate face, deci p ia valoarea NULL
for(i=1; ;i++){ p=(double *)malloc(dim*sizeof(double));
if( p != NULL) printf("\nS-a alocat blocul nr. %d la adresa %u", i, p);
else{
printf("\nAlocare imposibila - memorie insuficienta "); break;
}}
}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 208/267
208
/**************************************************************************
Exemplu1 11.2. - Se scrie un program în care se exemplifică folosirea alocării dinamice de
memorie. Sunt folosite, comparativ, secvenŃe în care se folosesc tablouri unidimensionale de
date alocate static şi tablouri alocate dinamic.
**************************************************************************/
#include<conio.h>#include<stdio.h>#include<malloc.h>
void main(){
float tab[10]; // tablou alocat staticfloat *p, aux;int i, dim;
//se citesc valori pentru elementele tabloului staticfor(i=0;i<10;i++){ printf("\n tab[%d]=", i);
scanf("%f", &tab[i]);}
// se afiseaza valorile elementelor tabloului staticfor(i=0;i<10;i++) printf("\n tab[%d]=%f", i , tab[i]);
// alocare dinamica de memorie pentru un tablou de dimensiune stabilita de la tastatura printf("\nIntroduceti dimensiunea tabloului:");scanf("%d", &dim);
p=(float*)malloc(dim*sizeof(float));
// se citesc valori pentru elementele tabloului alocat dinamicfor(i=0 ; i<dim ; i++){ printf("\np[%d] = ", i);
scanf("%f", &aux);*(p+i)=aux;
}
// se afiseaza valorile elementelor tabloului alocat dinamicfor(i=0;i<dim;i++) printf("\n tab[%d] = %f", i, *(p+i));
// se elimina tabloul dinamic din memoriefree(p);
// se face o realocare de memorie printf("\nIntroduceti dimensiunea tabloului care se realocă:");
scanf("%d", &dim); p=(float*)malloc(dim*sizeof(float));
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 209/267
209
// se citesc valori pentru elementele tabloului alocat dinamicfor(i=0;i<dim;i++){ printf("\np[%d]=",i);
scanf("%f", p+i);}
// se afiseaza valorile elementelor tabloului alocat dinamicfor(i=0;i<dim;i++) printf("\n tab[%d]=%f", i ,*(p+i));
// se elimina tabloul dinamic din memoriefree(p);getch();
}
/**************************************************************************
Exemplu1 11.3. - Se scrie un program în care se exemplifică folosirea alocării dinamice de
memorie. Se alocă un tablou unidimensional de date, elementele sale fiind interpretate din
punct de vedere logic ca aparŃinând unei matrice (se foloseşte simpla indirectare: int*mat).**************************************************************************/
#include <conio.h>#include <stdio.h>
void main(){int n, m; // n - nr. de linii ; m – nr. coloaneint * mat; // pointer folosit pentru alocarea de memorieint i, j; // variabile folosite pentru parcurgerea elementelor matricei
// citirea dimensiunilor matricei printf("\nNumarul de linii:");scanf("%d", &n);
printf("\nNumarul de coloane:");scanf("%d", &m);
// alocarea de memoriemat=new int[n*m];
//citirea elementelor matriceifor(i=0;i<n;i++)for(j=0;j<m;j++){
printf("mat[%d][%d]=",i,j);scanf("%d", &mat[i*m+j]);
}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 210/267
210
// afişarea elementelor tablouluifor(i=0 ; i<n ; i++){
printf("\n");for(j=0;j<m;j++)
printf("%5d",mat[i*m+j]);}
//afişarea de informaŃii despre matrice printf("\nsizeof(*mat)=%d", sizeof(*mat)); // se afişează numărul de
// octeŃi ocupaŃi de matrice printf("\n*(mat+0*m)=%d",*(mat+0*m)); // se afişează primul
// element de pe prima linieif(n>1)
printf("\n*(mat+1*m)=%d",*(mat+1*m)); // se afişează primul// element de pe linia a doua
if(n>2) printf("\n*(mat+2*m)=%d",*(mat+2*m)); // se afişează primul
// element de pe linia a treiadelete [ ]mat; // dealocarea memoriei
}
/**************************************************************************
Exemplu1 11.4. - Se scrie un program în care se exemplifică folosirea alocării dinamice de
memorie. Se foloseşte dubla indirectare: int**mat pentru a construi o matrice. **************************************************************************/
#include <conio.h>#include <stdio.h>
void main(){
int n, m;int ** mat;
int i, j; printf("\nNumarul de linii:");scanf("%d", &n);
printf("\nNumarul de coloane:");scanf("%d", &m);
mat=new int*[n];for(i=0 ; i<n ; i++)
mat[i]=new int[m];
//citirea elementelor matriceifor(i=0 ; i<n ; i++)
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 211/267
211
for(j=0 ; j<m ; j++){
printf("mat[%d][%d] = ", i, j);scanf("%d", &mat[i][j]);
}
//afişarea elementelor matriceifor(i=0 ; i<n ; i++){ printf("\n");for(j=0 ; j<m ; j++)
printf("%5d", mat[i][j]);}
//afişarea de informaŃii despre matrice printf("\nsizeof(*mat) = %d", sizeof(*mat)); // se afişează numărul de
// octeŃi ocupaŃi de matrice
printf("\n**mat = %d", **mat); // se afişează primul// element de pe prima linie
if(n>1) printf("\n**(mat+1) = %d", **(mat+1)); // se afişează primul
// element de pe linia a douaif(n>2)
printf("\n**(mat+2)=%d",**(mat+2)); // se afişează primul// element de pe linia a treia
for(i=0; i<n ; i++) // dealocarea memorieidelete [ ] mat[i];
delete [ ] mat;}
Rezumat
Manevrarea în mod dinamic a variabilelor permite stabilirea dimensiuniimemoriei necesare în momentul execuŃiei programului, alocarea ei în momentul
în care variabilele devin necesare şi eliminarea lor când utilitatea lor a încetat.
Memoria astfel eliberată poate fi realocată în alt scop.
Se alocă static memorie pentru constante, variabilele globale şi variabilele
locale declarate în mod explicit static.
Se alocă memorie pe stivă pentru variabilele locale.
În limbajul C, alocarea memoriei în mod dinamic se face cu ajutorul funcŃiilor
(malloc, calloc, realloc); eliberarea zonei de memorie se face cu ajutorul funcŃiei
free.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 212/267
212
În cazul în care nu se reuşeşte alocarea dinamică a memoriei (memorie
insuficientă), funcŃiile malloc, calloc şi realloc returnează un pointer NULL
(valoare 0).
Dimensiunea, în octeŃi, pentru memoria alocată poate fi exprimată printr-o
constantă, prin variabile sau prin expresii diverse care returnează valoare întreagă
pozitivă.
Dacă operaŃiile de alocare se repetă fără eliberare de memorie făcută între timp,
se poate ajunge la ocuparea întregii memorii.
C++ introduce o nouă metodă pentru alocarea dinamică a memoriei folosind
operatorii unari new şi delete.
FuncŃiile, respectiv operatorul new, destinate alocării de memorie permit
alocarea dinamică de tablouri cu o singură dimensiune.
Pentru alocarea tablourilor cu mai multe dimensiuni se folosesc multipleindirectări, alocarea de memorie fiind făcută în mai multe etape.
Test de autoevaluare
1. Se da secvenŃa:.......
int *p; p=new int(7);............
Ce se întâmplă la compilare?
a. variabilei p i se atribuie valoarea 7; b. adresa memorată de p este 7;c. se aloca memorie pentru un întreg si aceasta se initializeaza cu 7d. lui p i se atribuie adresa unei zone de memorie constituita din 7 locaŃii
consecutive de întreg (7*2)octeti
2. Se da secvenŃa:.........int *p;
p=new int[7];.........
Ce se întâmplă la compilare?
a. se alocă zona de memorie pentru 7 întregi consecutivi (7*4)octeti b. secvenŃa generează un mesaj de eroarec. lui p i se atribuie valoarea 7;
d. se aloca 7 octeti de memorie pentru p.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 213/267
213
3. Ce efect are ultima linie din secvenŃa de program:........int *p;
p=new int(10);delete p;
..........
a. dealoca zona de memorie indicata de pointerul p; b. şterge conŃinutul lui p;c. lui p i se atribuie valoarea 10d. dealoca 10 octeti de memorie începând cu adresa
conŃinuta in p
4. Ce greşeala exista in aceasta secvenŃa de program?.........int *p,*q; //1
p=new int(7); //2q=p; //3delete q; //4*p=17; //5...........
a. foloseşte o zona de memorie care a fost deja dealocată (//5) b. este necesara instrucŃiunea "delete p"c. linia //3 din secvenŃa este greşitad. secvenŃa este corecta
5. Unde este greşeala in aceasta secvenŃa de program?.........int x=7; //1int *y=&x; //2delete y; //3..........
a. in linia 1 b. in linia 2c. in linia 3
d. secvenŃa este corecta la compilare
6. Ce greşeli apar in următoarea secvenŃa de program?int x=7; //1int *y; //2delete y; //3*y=7; //4.........
a. in linia 1 b. in linia 2
c. in linia 3d. in linia 4
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 214/267
214
7. Se da secvenŃa:.......int *p;&p=new int(7);............
Ce se întâmpla la compilare?a. variabilei p i se atribuie valoarea 7;
b. adresa memorata de p este 7;c. lui p i se atribuie adresa zonei de memorie alocate mai susd. lui p i se atribuie adresa unei zone de memorie constituita din 7 locaŃii
consecutive de întreg (7*2)octeti
8. Se da secvenŃa:.......int **p;
p=new int[2][3];............
Ce se întâmpla la compilare?a. se alocă o matrice cu 2 linii, 3 coloane;
b. eroare de sintaxă;c. lui p i se atribuie adresa zonei de memorie alocate mai sus ;d. lui p i se atribuie adresa unei zone de memorie constituita din 7 locaŃii
consecutive de întreg (7*2*3) octeti.
9. Se da secvenŃa:.......int **p;int tab [2][3] = { 1, 2, 3};
p = tab ;............delete p ;
Ce se întâmpla la compilare?a. lui p i se atribuie adresa zonei de memorie la care este alocat tab ; b. eroare de sintaxă produsă de atribuire (p este pointer de int, iar tab este
pointer de 3 int);c. eroare de sintaxă produsă de faptul că o matrice nu se poate declara cuiniŃializare ;
d. eroare de sintaxă produsă de numărul prea mic al valorilor deiniŃializare;
e. eroare la execuŃie produsă de folosirea operatorului delete fără a seface anterior alocare de memorie.
10. Se da secvenŃa:
int n, m;
int ** mat;int i, j;
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 215/267
215
.......mat=new int*[n];for(i=0 ; i<n ; i++)
mat[i]=new int[m];Ce se întâmplă la compilare?
a. eroare de sintaxă pentru că nu se pot aloca tablouri de pointeri; b. se alocă memorie pentru o matrice cu n linii şi m coloane;c. eroare de sintaxă pentru că nu se pot face alocări de memorie în
secvenŃe repetitive.
Întrebări. ExerciŃii. Probleme.
1. Se citesc de la tastatură elementele unui tablou unidimensional. Să se înlocuiască toatevalorile negative cu valoarea 0. Se afişează elementele tabloului. Tabloul este alocatdinamic cu o dimensiune citită de la tastatură.
2. Se citesc de la tastatură elementele a două tablouri unidimensionale de aceeaşidimensiune. Se calculează elementele unui al treilea tablou ca sumă a elementelor deacelaşi index ale primelor două şi se afişează. Dimensiunea este citită de la tastatură, iar tablourile sunt alocate dinamic.
3. Se citesc de la tastatură două şiruri de caractere. Se determină un al treilea şir princoncatenarea primelor două şi se afişează. Pentru referirea elementelor se vor folosioperaŃii cu pointeri.
4. Se alocă o matrice pătratica a cărei dimensiune este citită de la tastatură. Se citesc de latastatură valori pentru elementele matricei. Să se afişeze diagonala principală şi ceasecundară.
5. Sa se întocmeasca un program în care se alocă dinamic 3 matrice cu dimensiuni citite dela tastatură. Pentru două dintre acestea se citesc valorile elementelor de la tastatură. Secalculează a treia matrice ca sumă a primelor două şi se afişează.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 216/267
216
Unitatea de învăŃare U.12. FUNCłII ÎN C/C++
Cuprins
Introducere .................................................................................................................. 216
Obiectivele unităŃii de învăŃare ................................................................................... 217
U12.1. DefiniŃii de funcŃii ........................................................................................... 217
U12.2. DeclaraŃii de funcŃii. Prototipuri. .................................................................... 218
U12.3. Transferul parametrilor ................................................................................... 218
U12.3.1. Transferul prin valoare. Conversii de tip. ......................................... 218
U12.3.2. Transferul prin adresă ....................................................................... 219U12.3.3. Transferul prin variabile referinŃă ..................................................... 220
U12.4. Rezultatul unei funcŃii. InstrucŃiunea return. .................................................. 222
U12.5. FuncŃii recursive .............................................................................................. 222
U12.6. Pointeri de funcŃii ............................................................................................ 223
Exemple ...................................................................................................................... 224
Rezumat ...................................................................................................................... 228
Test de autoevaluare ................................................................................................... 229
Întrebări, exerciŃii şi probleme .................................................................................... 232
Introducere
În limbajul C++ (similar cu limbajul C standard) programul este o colecŃie
de module distincte numite funcŃii, structura generală a programului fiind:
<directive preprocesor><declaraŃii globale>funcŃii
Un program C++ conŃine obligatoriu o funcŃie numită main() şi aceasta este
apelată la lansarea în execuŃie a programului.
Programul sursă poate fi partiŃionat în mai multe fişiere grupate într-un
proiect (se utilizează meniul Project din mediul de programare utilizat). Fiecare
fişier conŃine declaraŃii globale şi un set de funcŃii, dar numai unul conŃine funcŃia
main().
În C++, ca şi în C, se utilizează declaraŃii (prototipuri) şi definiŃii de
funcŃii.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 217/267
217
De regulă, se declară prototipurile de funcŃii în zona declaraŃiilor globale,
urmând ca apoi să se facă definiŃiile funcŃiilor. DefiniŃiile se pot regăsi în diferite
fişiere sursă.
Apelul unei funcŃii produce lansarea în execuŃie a funcŃiei respective şi se
poate face doar dacă, cel puŃin prototipul funcŃiei a fost deja stabilit.
O funcŃie reprezintă un bloc de instrucŃiuni care este desemnat printr-un
nume, care poate prelua date de intrare prin parametrii şi poate returna un rezultat.
Obiectivele unităŃii de învăŃare
După parcurgerea acestei unităŃi de învăŃare trebuie să ştii:
Sintaxa de declarare şi definire a funcŃiilor;
PosibilităŃi de transfer al datelor între funcŃii prin parametri (transfer prinvaloare, prin adresă, prin referinŃă);
Rezultatul unei funcŃii. InstrucŃiunea return şi posibilităŃi de transfer al datelor
prin cele trei modalităŃi (transfer prin valoare, prin adresă, prin referinŃă);
Definirea funcŃiilor recursive;
Declararea şi folosirea pointerilor de funcŃii.
Durata medie de parcurgere a celei de a douăsprezecea unităŃi de învăŃare
este de 2 ore.
U12.1. DefiniŃii de funcŃii
Sintaxa definiŃiei unei funcŃii este:
tip_rez nume_funcŃie (<lista_parametri>){
<declaraŃii locale>secvenŃă de instrucŃiuni
}
unde:
- tip_rez - este un tip oarecare de dată şi reprezintă tipul rezultatului returnat de
funcŃie. Dacă nu este specificat, implicit tipul rezultatului returnat este int.
Pentru funcŃiile care nu returnează rezultat trebuie să se specifice tipul
void.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 218/267
218
- nume_functie - este un identificator.
- lista_parametri - reprezintă enumerarea declaraŃiilor parametrilor sub forma:
tip_parametru nume_parametru, <tip_parametru nume_parametru>
Tipul parametrului poate fi orice tip valid de date.
Nu este admisă definirea unei funcŃii în blocul altei funcŃii şi nu sunt permise salturi
cu instrucŃiunea goto în afara funcŃiei.
Apelul funcŃiei constă din numele funcŃiei urmat de lista de constante, variabile sau
expresii asociate parametrilor încadrată între paranteze ().
Atât la definirea, cât şi la apelul funcŃiilor, parantezele () urmează întotdeauna numele
funcŃiilor, chiar dacă acestea nu au parametri.
Se foloseşte denumirea de parametri formali pentru identificatorii din lista de
argumente din definiŃia funcŃiei şi parametri efectivi (constantele, variabilele, expresiile) din
lista unui apel al funcŃiei.
Parametrii formali reprezintă variabile locale care au domeniu funcŃia şi timpul de
viaŃă corespunde duratei de execuŃie a funcŃiei, deci valorile lor se memorează în stivă sau în
registrele procesorului.
U12.2. DeclaraŃii de funcŃii. Prototipuri.
Apelul unei funcŃii nu se poate face înainte de definiŃia ei. Sunt situaŃii în care nu este
posibil acest lucru (în cazul funcŃiilor care se apelează unele pe altele, sau al funcŃiilor definite
în alte fişiere sursă).
Pentru a oferi compilatorului posibilitatea de a verifica corectitudinea apelului unei
funcŃii (numărul şi tipurile parametrilor, tipul rezultatului, eventualele conversii care apar), se
pot folosi declaraŃii fără definire, numite prototipuri. Sintaxa generală a unui prototip este:
<tip> nume_functie (<lista_parametri>);
Lipsa lista_parametri este interpretată în C++ ca funcŃie fără parametri, deci cuvântul
void nu este necesar, spre deosebire de C standard care nu consideră funcŃia fără parametri, ci
cu orice listă de parametri şi, ca urmare, nu verifică parametrii efectivi la apelare.
În declaraŃia funcŃiei este suficient ca în lista_parametri să se specifice tipurile
parametrilor, fără identificatorii lor. Dacă însă se specifică identificatorii, aceştia trebuie să fie
identici cu cei folosiŃi în antetul definiŃiei funcŃiei.
Prototipul funcŃiei trebuie să fie plasat înainte de orice apel al funcŃiei.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 219/267
219
U12.3. Transferul parametrilor
U12.3.1. Transferul prin valoare. Conversii de tip.
La apelul unei funcŃii, valoarea parametrilor efectivi este încărcată în zona de memorie
corespunzătoare parametrilor formali. Acest procedeu se numeşte transfer prin valoare. Dacă parametrul efectiv este o variabilă, ea nu este afectată de nici o operaŃie asupra parametrului
formal, ceea ce poate constitui o protecŃie utilă.
Transferul de valoare este însoŃit de eventuale conversii de tip realizate de compilator,
implicite sau explicite dacă se foloseşte operatorul cast. Conversia se realizează de la tipul
parametrului efectiv către tipul parametrului formal.
Se foloseşte ca exemplu definirea şi apelul unei funcŃii care preia două variabile şi
realizează inversarea valorilor acestora între ele.
#include <stdio.h>
void schimba(int , int ); // lista de parametri este formată din variabile int
void main(){ int i, j;
float p, q;scanf(”%d%d”, &i, &j);schimba(i, j); // apelul funcŃiei include ca parametri efectivi
// variabilele i, j de tip int, deci nu este necesară// conversia lor; pe parcursul execuŃiei funcŃiei// schimba() se alocă variabilele locale a, respectiv// b, care sunt iniŃializate cu valorile i, respectiv j.// Inversarea valorilor se produce asupra// variabilelor locale a şi b, variabilele i şi j ne fiind// afectate
printf(”\ni=%d, j=%d”, i, j);scanf(“%f%f”, &p, &q);schimba(p, q); // apelul funcŃiei include ca parametri efectivi variabile
// de tip float, deci va avea loc o conversie degradantă,// implicită, float->int, care însă nu afectează variabilele
// p şi q, ci conversia se face la iniŃializarea variabilelor a// şi b; la finalul execuŃiei funcŃiei se constată că p şi q// rămân nemodificate
printf(”\ni=%f, j=%f”, p, q);}
void schimba(int a, int b){
int temp ; // inversarea valorilor a două variabile se face printemp=a; // atribuiri succesive, folosind o variabilă auxiliară, tempa= b;
b=temp;}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 220/267
220
U12.3.2. Transferul prin adresă
Pentru ca o funcŃie să poată modifica valoarea unei variabile folosită ca parametru
efectiv, trebuie folosit un parametru formal de tip pointer, iar la apelul funcŃiei să se
folosească ca parametru efectiv adresa variabilei.
Se foloseşte pentru exemplificare tot definirea şi apelul unei funcŃii care preia două
variabile şi realizează inversarea valorilor acestora, dar parametrii funcŃiei vor fi pointeri.
#include <stdio.h>
void schimba(int *, int *); // lista de parametri este formată din pointeri la int
void main(){
int i, j;scanf(”%d%d”, &i, &j);schimba(&i, &j); // la apelul funcŃiei, parametrii efectivi sunt adrese de
// variabile printf(”\ni=%d, j=%d”, i, j);
}
void schimba(int *a, int *b){
int temp ;temp=*a;
*a=*b;*b=temp;}
Parametri tablou constituie o excepŃie de la transferul parametrilor prin valoare,
deoarece funcŃia primeşte ca parametru adresa tabloului. Acest lucru este motivat de faptul că,
în general, tablourile conŃin o cantitate mare de date al căror transfer prin valoare ar avea ca
efect o scădere a vitezei de execuŃie şi creştere a memoriei necesare prin copierea valorilor
într-o variabilă locală. De altfel, numele tabloului este echivalent cu adresa sa. În prototip şi
antetul funcŃiei, parametrul tablou se specifică în lista de parametri sub forma:
tip nume_tablou[ ]
sautip *nume_tablou
U12.3.3. Transferul prin variabile referinŃă
Folosirea parametrilor formali variabile referinŃă este similară folosirii parametrilor
formali pointeri, asigurând posibilitatea de a modifica valorile parametrilor efectivi.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 221/267
221
Utilizarea referinŃelor prezintă avantajul că procesul de transfer prin referinŃă este
efectuat de compilator în mod transparent, scrierea funcŃiei şi apelul ei fiind simplificate.
Dacă tipul parametrului efectiv nu coincide cu cel al parametrului formal referinŃă,
compilatorul efectuează o conversie, ca în cazul transferului prin valoare. Pentru realizarea
conversiei se creează un obiect temporar de dimensiunea tipului referinŃă, în care se înscrie
valoarea convertită a parametrului efectiv, parametrul formal referinŃă fiind asociat obiectului
temporar. Se pierd astfel avantajele folosirii referinŃelor ca parametri formali.
#include <stdio.h>
void schimba(int &, int &); // lista de parametri este formată din referinŃe de// variabile int
void main()
{ int i, j;float p, q;scanf(”%d%d”, &i, &j);schimba(i, j); // apelul funcŃiei include ca parametri efectivi
// variabilele i, j de tip int, deci nu este necesară// conversia lor; pe parcursul execuŃiei funcŃiei// schimba() ele sunt redenumite, a, respectiv b,// inversarea valorilor având efect asupra// variabilelor din apel, i şi j
printf(”\ni=%d, j=%d”, i, j);scanf(“%f%f”, &p, &q);
schimba(p, q); // apelul funcŃiei include ca parametri efectivi variabile// de tip float, deci va avea loc o conversie degradantă,// implicită, float->int, care are ca urmare crearea de// variabile temporare; referinŃele care se creează sunt// pentru aceste variabile temporare, şi nu pentru p şi q;// inversarea valorilor are efect asupra variabilelor // temporare, astfel că, la ieşirea din funcŃie, se va// constata faptul că valorile variabilelor p şi q au rămas// nemodificate
printf(”\ni=%f, j=%f”, p, q);}
void schimba(int &a, int &b){
int temp ;temp=a;a= b;
b=temp;}
Este utilă folosirea parametrilor formali referinŃă şi în situaŃia în care parametrul aredimensiune mare şi crearea în stivă a unei copii a valorii are ca efect reducerea vitezei de
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 222/267
222
execuŃie şi creşterea semnificativă a stivei. În această situaŃie, dacă nu se doreşte modificarea
parametrului efectiv, acesta poate fi protejat prin folosirea modificatorului const la declararea
parametrului formal referinŃă.
U12.4. Rezultatul unei funcŃii. InstrucŃiunea return.
InstrucŃiunea return determină încheierea execuŃiei unei funcŃii şi revenirea în funcŃia
apelantă. Ea a fost prezentată în Unitatea de învăŃare nr. 8.
Valoarea expresiei reprezintă rezultatul întors de funcŃie, deci trebuie să fie compatibil
cu tipul indicat în prototip şi definiŃie.
Dacă tipul funcŃiei este void, instrucŃiunea return este necesară doar dacă se doreşte
revenirea din funcŃie înainte de execuŃia întregii secvenŃe de instrucŃiuni care alcătuieşte
funcŃia.Transferul rezultatului se poate face utilizând toate cele trei metode: prin valoare,
pointer sau referinŃă.
În cazul transferului prin pointer sau referinŃă, obiectul a cărui adresă se întoarce nu
trebuie să fie un obiect automatic, deoarece acesta dispare odată cu terminarea execuŃiei
funcŃiei. În cazul returnării prin referinŃă, o asemenea situaŃie e semnalată de compilator ca
eroare, în schimb, în cazul pointerilor nu este semnalată eroarea. Adresa de memorie returnată
va corespunde unei zone de memorie care nu mai este alocată şi pot apărea efecte neaşteptate.
U12.5. FuncŃii recursive
O funcŃie este numită funcŃie recursivă dacă ea se autoapelează, fie direct (în definiŃia
ei se face apel la ea însăşi), fie indirect (prin apelul altor funcŃii). Limbajele C/C++ dispun de
mecanisme speciale care permit suspendarea execuŃiei unei funcŃii, salvarea datelor şi
reactivarea execuŃiei la momentul potrivit. Pentru fiecare apel al funcŃiei, parametrii şi
variabilele automatice se memorează pe stivă, având valori distincte. Variabilele statice ocupă
tot timpul aceeaşi zonă de memorie (figurează într-un singur exemplar) şi îşi păstreazăvaloarea de la un apel la altul. Orice apel al unei funcŃii conduce la o revenire în funcŃia
respectivă, în punctul următor instrucŃiunii de apel. La revenirea dintr-o funcŃie, stiva este
curăŃată (stiva revine la starea dinaintea apelului).
Un exemplu de funcŃie recursivă este funcŃia de calcul a factorialului (n!), definită
astfel:
fact(n)=1, dacă n=0;
fact(n)=n*fact(n-1), dacă n>0;
Este prezentat în continuare programul care implementează această funcŃie.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 223/267
223
#include <stdio.h>#include <conio.h>#include <stdlib.h>
double fact(int n)
{if (n<0) // valorile negative sunt invalide{ printf("\nParametru negativ !");
exit(2);}
if (n==0)return 1;
elsereturn n*fact(n-1);
}
void main(){
int nr;double f;
printf("\nIntrodu un numar: ");scanf("%d",&nr);f=fact(nr);
printf("\n %d ! = %.0lf",nr,f);getch();
}
Se observă că în corpul funcŃiei fact se apelează însăşi funcŃia fact.
Spre exemplu, dacă se doreşte calcularea valorii 4!, se apelează funcŃia: fact(4). În
interiorul său se calculează expresia 4*fact(3). Apelul funcŃiei fact(3) va calcula la rândul său
3*fact(2), fact(2) calculează 2*fact(1) şi în fine, fact(1) calculează 1*fact(0). Valoarea 0 a
parametrului funcŃiei are ca efect întreruperea recursivităŃii.
O funcŃie recursivă poate fi realizată şi iterativ. Modul de implementare trebuie ales în
funcŃie de problemă. Deşi implementarea recursivă a unui algoritm permite o descriere clară
şi compactă, recursivitatea nu conduce la economie de memorie şi nici la execuŃia mai rapidă
a programelor. În general, se recomandă utilizarea funcŃiilor recursive în anumite tehnici de
programare, cum ar fi unele metode de căutare (backtracking).
U12.6. Pointeri de funcŃii
Limbajul C++, ca şi limbajul C, permite operarea cu variabile pointer care conŃin
adresa de început a codului executabil al unei funcŃii. Aceste variabile permit:
transferul ca parametru al adresei funcŃiei asociate; apelul funcŃiei prin intermediul pointerului.
Fig. 12.1. Exemplificarea apeluluifuncŃiilor recursive
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 224/267
224
DeclaraŃia cu sintaxa:
tip_r(*p_fct)(<lista_tip_param>);
declară p_fct ca pointer cu tipul funcŃie cu rezultatul tip_r şi parametri lista_tip_param.
ObservaŃii
În C standard, lista tipurilor parametrilor poate lipsi şi nu se fac verificări ale
parametrilor, în timp ce în C++ lipsa listei parametrilor indică o funcŃie fără
parametri.
# include <stdio.h>
int fct(int, float); // prototip de funcŃie
void main(){
int (*p_f)(int, float) // p_f, pointer de funcŃieint i = 5, j;float r = 3.5;
p_f = fct; // se atribuie adresa funcŃiei fct pointerului p_f j = p_f(i, r); // se apelează funcŃia fct prin pointerul p_f
printf(“\nj = %d”, j);}
int fct(int a, float b){
printf(“\na = %d”, a); printf(“\nb = %f”, b);return ( a + (int)b );
}
Exemple
/***************************************************************************
Exemplul 12.1. Se scrie un program în care se compară două şiruri de caractere (prin funcŃia
test()) folosind două criterii diferite de comparare exprimate prin funcŃiile comp1() şi
respectiv comp2(). Criteriul de comparare este precizat prin apelul uneia din funcŃiile de
comparare, apel făcut prin intermediul unei variabile pointer de funcŃie.***************************************************************************/
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 225/267
225
#include<stdio.h>#include<conio.h>void test(char*, char *, int(*)(char*, char*)); // funcŃia test() are un parametru
// de tip pointer de funcŃie
int comp1(char *, char *);int comp2(char *, char *);
void main(){
char s1[80], s2[80];int (*p)(char*, char*); // se declară pointerul p de funcŃii cu
// prototipul : int functie (char *, char *) p=comp1; // variabilei pointer p i se atribuie ca
// valoare adresa funcŃiei comp1() puts("Introduceti primul sir");gets(s1);
puts("Introduceti al doilea sir");gets(s2);test(s1, s2, p); // compară şirurile folosind funcŃia comp1()getch();
p=comp2; // variabilei pointer p i se atribuie ca// valoare adresa funcŃiei comp2()
test(s1, s2, p); // compară şirurile folosind funcŃia comp2()getch();
}
void test(char*a, char*b, int(*comp)(char*, char*)){
if(!(comp)(a, b)) printf("\ns1 egal cu s2");
else printf("\ns1 diferit de s2");
}
int comp(char *s1, char *s2) // funcŃia compară primele caractere ale{
return(s1[0]-s2[0]); // şirurilor }
int comp1(char *s1, char *s2) // funcŃia compară lungimile şirurilor {
int i=0, j=0;while( s1[i] ) i++;while( s2[j] ) j++;return ( i - j );
}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 226/267
226
/***************************************************************************
Exemplul 12.2. Sã se întocmeascã un program în care se definesc următoarele funcŃii:
- o functie de citire a elementelor unui tablou de întregi;
- o functie de afisare a elementelor unui tablou de întregi;
- o functie care returneaza maximul dintre elementele unui tablou de întregi;
- o functie de ordonare a elementelor unui tablou de întregi.
In functia main se declara un tablou de întregi si se exemplifica folosirea funcŃiilor
definite.
Tablourile au dimensiunea stabilită cu ajutorul unei constante definită cu directiva
#define.
***************************************************************************/
#include<stdio.h>#include<conio.h>
#define N 5 // constanta folosita pentru a stabili dimensiunea tablourilor
void citire(int t[]);void afisare(int t[]);int maxim(int t[]);void ordonare(int t[]);
void main()
{ int tab[N];citire(tab); printf("\nSe afiseaza valorile elementelor de tablou");afisare(tab);
printf("\nValoarea maxima este: %d", maxim(tab));ordonare(tab);
printf("\nSe afiseaza valorile elementelor de tablou");afisare(tab);getch();
}
void citire(int t[]){ int i;
for (i=0;i<N;i++){ printf("\nelementul [%d]=", i+1);
scanf("%d",&t[i]);}
}void afisare(int t[]){ int i;
for (i=0;i<N;i++) printf("\nelementul [%d]= %d", i+1, t[i]);
}int maxim(int t[])
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 227/267
227
{int i, max=t[0];for (i=1;i<N;i++)if(max<t[i])
max=t[i];
return max;}
void ordonare(int t[]) // se foloseşte algoritmul "bubble sort"{
int i, k, aux;do{
k=0;for(i=0;i<N-1;i++)
if(t[i]>t[i+1])
{aux=t[i];t[i]=t[i+1];t[i+1]=aux;k=1;
}}while(k!=0);
}
Rezumat
În limbajele C/C++ programul este o colecŃie de module distincte numite
funcŃii.
Un program C++ conŃine obligatoriu o funcŃie numită main() şi aceasta este
apelată la lansarea în execuŃie a programului.
În C/C++ se utilizează declaraŃii (prototipuri) şi definiŃii de funcŃii.
Nu este admisă definirea unei funcŃii în blocul altei funcŃii şi nu sunt permisesalturi cu instrucŃiunea goto în afara funcŃiei.
Apelul funcŃiei constă din numele funcŃiei urmat, între paranteze (), de lista
parametrilor efectivi (constante, variabile sau expresii) asociaŃi parametrilor
formali.
Parametrii formali reprezintă variabile locale care au domeniu funcŃia şi timpul
de viaŃă corespunde duratei de execuŃie a funcŃiei.
Transferul datelor prin parametri sau ca valoare returnată din funcŃie se poate
face prin valoare, adresă sau referinŃă. Transferul de valori este însoŃit de eventuale conversii de tip realizate de
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 228/267
228
compilator, implicite sau explicite dacă se foloseşte operatorul cast.
Folosirea parametrilor formali pointeri şi referinŃă se folosesc în situaŃia în care
parametrul are dimensiune mare şi crearea în stivă a unei copii a valorii are ca
efect reducerea vitezei de execuŃie şi creşterea semnificativă a stivei sau dacă se
doreşte modificarea prin funcŃie a unor variabile care au ca domeniu funcŃia
apelantă.
La returnarea prin pointer sau referinŃă, trebuie avut în vedere ca obiectul a
cărui adresă se întoarce să nu fie un obiect automatic, deoarece acesta dispare
odată cu terminarea execuŃiei funcŃiei.
Limbajele C/C++ permit utilizarea funcŃiilor recursive (funcŃii care se
autoapelează).
Limbajele C/C++ permit operarea cu variabile pointer de funcŃii (conŃin adresa
de început a codului executabil al unei funcŃii). Aceste variabile permit transferulca parametru al adresei funcŃiei asociate şi apelul funcŃiei prin intermediul
pointerului.
Test de autoevaluare
1. Linia de program C:float cub(float a);
a. reprezintă antetul unei funcŃii b. poate fi înlocuita cu:
float cub(float);c. generează eroare de sintaxad. reprezintă prototipul unei funcŃiie. nici o propoziŃie din cele de mai sus nu este adevărata
2. Functia care are prototipul:f(int a, float x);
a. are 2 parametrii: un întreg si un real b. întoarce un rezultat întregc. nu întoarce nici un rezultatd. prototipul de mai sus va genera o eroare de sintaxa
3. Consideram ca avem functia:int f (int number, int n){ int count, result;for(count=1 , result=1; count<=n ; count++)
result*=number;return result;}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 229/267
229
va returna, in urma apelului f(3, 2), valoarea:a. 1
b. 3c. 9d. 6
4. Programul:#include <stdio.h>#include <conio.h>void f(char*s){ if (!s[0])
return;f(s+1);
putch(*s);}void main()
{ f("abcde"); }a. va produce o eroare de sintaxa
b. va produce afisarea: edcbac. va produce afisarea: ad. defineşte o funcŃie recursivăe. nu va produce nici o afişare
5. Programul:#include <stdio.h>int f(char*s){ int i;
for(i=0 ; s[i] ; i++);return i;
}void main(){ printf(“\n%d”, f(“abcd”)); }
a. va produce o eroare de sintaxă b. afişează culoarea 4c. afisarea sirul: abcdd. afisarea unui rezultat 0
6.
Programul:#include<stdio.h>int f(unsigned char);void main(){ printf("%#x\n", f(0x33));}int f(unsigned char c){ char mask=255;
return (mask&&c);}
va produce:a. o eroare de sintaxa
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 230/267
230
b. afisarea 0xff c. afisarea 0x1d. afisarea 0x33e. nici una din situaŃiile de mai sus
7. Programul:#include<stdio.h>int f(unsigned char);void main(){ printf("%#x\n", f(0x33));}int f(unsigned char c){ char mask=255;
return (mask||c);}
va produce:
a. o eroare de sintaxa b. afisarea 0x1c. afisarea 0xff d. afisarea 0x33e. afisarea 0x00
8. Se considera functia in limbaj C:int functie(char *sir1, char *sir2){ for( ; *sir1==*sir2 ; sir1++, sir2++)
if(!(*sir1)) return 1;return 0;
}Ce realizează functia?
a. compara cele doua şiruri (sir1 si sir2) si returneaza 1 in caz de b. copiaza sir2 in sir1c. copiaza sir1 in sir2d. nimic deoarece conŃine erori
identitate
9. Se considera functia in limbaj C:int functie(char sir1[],char sir2[])
{ int i;for(i=0 ; sir2[i] ; i++)sir1[i] = sir2[i];
sir1[++i] = '\0';return i;
}Ce realizează functia?
a. nimic deoarece conŃine erori b. copiaza sir1 in sir2c. copiaza sir2 in sir1d. returneaza numarul de caractere conŃinute in sir2, inclusiv 0 final
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 231/267
231
10. Se considera functia in limbaj C:void functie(char* sir1, char* sir2){
while(*sir1++ = *sir2++);}
Ce realizează functia?a. nimic deoarece instrucŃiunea while este greşita b. copiaza sir1 in sir2c. copiaza sir2 in sir1d. compara şirurile sir1 si sir2
Întrebări. ExerciŃii. Probleme.
1. Sa se scrie un program in care se defineste o functie care preia ca parametru un întreg.Functia returneaza 1 daca numarul este prim, sau 0, daca numarul nu este prim.
int prim(unsigned);
In functia main() se citesc doua valori pentru a şi b care reprezintă capetele unui interval[a , b]. Să se afişeze toate valorile prime din intervalul dat.
2. Sã se întocmeascã un program în care se definesc următoarele funcŃii:a. O funcŃie care copiază conŃinutul unui şir de caractere în alt şir;
b. O funcŃie care compară două şiruri de caractere;c. O funcŃie care concatenează două şiruri.
În funcŃia main() se exemplifică folosirea acestor funcŃii.
Notă: Nu se folosesc funcŃiile din fişierul string.h !
3. Sa se rescrie programul din exemplul 12.2., funcŃiile fiind definite pentru tablouri alocatedinamic, dimensiunea acestora fiind citită de la tastatură la execuŃia programului.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 232/267
232
Unitatea de învăŃare U.13. TIPURI DE DATE DEFINITE DEUTILIZATOR
Cuprins
Introducere .................................................................................................................. 233
Obiectivele unităŃii de învăŃare ................................................................................... 234
U13.1. Enumerarea .................................................................................................... 234
U13.2. Structuri de date .............................................................................................. 235
U13.3. Câmpuri de biŃi ................................................................................................ 242
U13.4. Uniuni .............................................................................................................. 240Exemple ...................................................................................................................... 244
Rezumat ...................................................................................................................... 248
Test de autoevaluare ................................................................................................... 249
Întrebări, exerciŃii şi probleme .................................................................................... 252
Introducere
Reprezentarea informaŃia prelucrată de un program, reprezentată doar folosind tipurile predefinite şi cele derivate, poate fi destul de dificilă atunci când
datele sunt complexe şi trebuie structurate după diferite criterii. Programatorul
poate să-şi definească propriile tipuri de date care să răspundă cât mai eficient
cerinŃelor aplicaŃiei.
Limbajele C/C++, oferă următoarele posibilităŃi de definire de noi tipuri de
date:
declaraŃia typedef – permite redenumirea tipurilor de date; prin
aceasta creşte lizibilitatea programului; enumerarea – permite denumirea unui tip de date asociat cu tipul int
simultan cu definirea unei liste de constante;
structura – defineşte colecŃii de date de diferite tipuri referite printr-un
singur nume;
câmpuri de biŃi – reprezintă membri ai unei structuri care nu sunt
alocaŃi la nivel de octet, ci alocaŃi la nivel de bit;
uniunea – defineşte colecŃii de date de tipuri diferite care folosesc în
comun o zonă de memorie.
Limbajul C++ oferă în plus faŃă de C posibilitatea definirii de clase, acestea
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 233/267
233
fiind tipuri de date care respectă principiile programării orientate pe obiecte.
Obiectivele unităŃii de învăŃare
După parcurgerea acestei unităŃi de învăŃare trebuie să ştii: Declararea de tipuri de date prin enumerare şi utilizarea constantelor astfel
definite;
Declararea structurilor de date şi manevrarea obiectelor de acest tip;
Utilizarea câmpurilor de biŃi;
Declararea uniunilor şi manevrarea obiectelor de acest tip.
Durata medie de parcurgere a celei de a treisprezecea unităŃi de învăŃare estede 2 ore.
U13.1. Enumerarea
Tipul enumerare constă dintr-un ansamblu de constante întregi, fiecare asociată unui
identificator. Sintaxa declaraŃiei este:
enum <id_tip_enum> {id_elem<=const>,…} <lista_id_var>;unde: - id_tip_enum = nume tip enumerare ;
- id_elem = nume element;
- const = constantă de iniŃializare a elementului.
id_tip_enum reprezintă un nume de tip de date, putându-se folosi similar cu orice tip
de date predefinit, putându-se declara variabile, pointeri, tablouri, etc. din acel tip.
Dacă declaraŃia nu specifică constante pentru id_elem, valorile implice sunt 0 pentru
primul element, iar pentru celelalte valoarea elementului precedent incrementat cu o unitate.Identificatorii elementelor trebuie să fie unici în domeniul lor (diferiŃi de numele
oricărei variabile, funcŃie sau tip declarat cu typedef).
enum boolean {false, true}; // valoarea identificatorului false este 0, iar a lui// true este 1
sau
typedef enum {false, true} boolean; // declaraŃia este echivalentă declaraŃiei
// anterioare
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 234/267
234
De exemplu, se poate scrie secvenŃa:
# include <stdio.h>
enum boolean {false, true}; // valoarea identificatorului false este 0, iar a lui
// true este 1void main(){
boolean op1=false, op2;op2=true;
printf(“\n op1=%d\nop2=%d”, op1, op2);}
Tipul enumerare facilitează operarea cu variabile care pot lua un număr mic de valori
întregi, asociindu-se nume sugestive pentru fiecare valoare. Programul devine mai clar şi mai
uşor de urmărit.
U13.2. Structuri de date
Structura este o colecŃie de date referite cu un nume comun. O declaraŃie de structură
precizează identificatorii şi tipurile elementelor componente şi constituie o definiŃie a unui
nou tip de date.
Sintaxa declaraŃiei unui tip structură este:
struct id_tip_struct
{tip_elem1 id_elem1;tip_elem2 id_elem2;…tip_elemN id_elemN;
} lista_id_var_struct;
unde: - struct = cuvânt cheie pentru declararea tipurilor structură;
- id_tip_struct = numele tipului structură declarat;- tip_elemK = tipul elementului K, unde K=1…N;
- id_elemK = numele elementului K;
- lista_id_var_struct = lista cu numele variabilelor de tipul declarat, id_ti_struct.
Pot să lipsească, fie numele structurii, fie lista variabilelor declarate, dar nu amândouă.
De regulă se specifică numele tipului structură definit, aceasta permiŃând declaraŃii ulterioare
de obiecte din acest tip.
Elementele structurii se numesc generic membrii (câmpurile) structurii. Pentru fiecare
membru se precizează tipul datei şi numele. Tipurile membrilor pot fi oarecare, mai puŃin
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 235/267
235
tipul structură care se defineşte, dar pot fi de tip pointer la structura respectivă.
De exemplu, se poate defini următorul tip de date:
struct ex_stru
{ int m1;char m2;float m3;
};
O variabilă de tip ex_stru se declară :
ex_stru var1;
Variabila var1 se alocă în memorie ca în fig.13.1.
Byte m1 m2 m3999 1000 1001 1002 1003 1004 1005 1006
... ... Adrese memorie
Adresa variabilei (&var1)
var1
999Byte1007
Fig.13.1. Alocarea în memorie unei variabile de tip ex_stru
Membrii unei structuri pot fi de orice tip, deci pot fi la rândul lor de tip structură, spre
exemplu:
struct data // se declară tipul de date data, ca structură cu 3 membri// de tip unsigned int
{ unsigned int zi;unsigned int luna;
unsigned int an;};
struct persoana // se declară tipul de date persoana ca structură cu 2{ char nume[15]; // membri şir de caractere şi un membru de tip data
char prenume[15];data data_n;
} pers1, pers2 ; // odată cu declaraŃia tipului de date persoana, se// declară două obiecte din acest tip de date
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 236/267
236
... Adrese memorie ‘A’
nume[0]
nume
‘N’ ‘D’ ‘R’ ‘I’‘E’ ‘S’
prenume[0]
prenume
‘T’ ‘A’ ‘N’ ‘\0’‘\0’
data_n
zi luna an10 10 2000
stud1
Fig.13.2. Alocarea în memorie a unei variabile de tip persoana
O variabilă de tip persoana se alocă în memorie ca în fig.13.2.
Se poate declara un tip structură folosind cuvântul cheie typedef, sintaxa fiind:
typedef struct {
tip_elem1 id_elem1;tip_elem2 id_elem2;…tip_elemN id_elemN;
} id_tip_struct;
unde semnificaŃia denumirilor este identică cu cea anterioară.
Se reia exemplul anterior, utilizând typedef pentru declaraŃia structurilor:
typedef struct{unsigned int zi;unsigned int luna;unsigned int an;
} data;
typedef struct{char nume[15];char prenume[15];
data data_n;} persoana;
În cazul folosirii declaraŃiei cu typedef nu se pot face simultan şi declaraŃii de variabile
de tipul structurii. Acestea vor putea fi folosite ulterior.
DeclaraŃia unei variabile de tip structură se poate face cu iniŃializare prin enumerarea
valorilor membrilor în ordinea în care apar în declaraŃie.
persoana pers= {“Ionescu”, ”Adrian”, 10, 10, 1975}; // declararea unui obiect persoana
// cu iniŃializare
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 237/267
237
Dacă declaraŃia nu se face cu iniŃializare, membrii variabilelor iau valoare 0 dacă
declaraŃiile sunt globale sau statice, sau valori reziduale dacă declaraŃiile sunt locale.
Referirea unui membru al unei variabile de tip structură se face folosind operatorul de
selecŃie (.) (punct), sub forma:
nume_variabilă . nume_câmp
De exemplu,
printf(”\nNumele: %s”, pers.nume); printf(”\nPrenume: %s”, pers.prenume); printf(”\nData nasterii: %d.%d.%d”, pers.data_n.zi, pers.data_n.luna, pers.data_n.an);
Se pot declara pointeri la structuri care pot prelua adresa oricărei variabile de tipul
structurii respective.
persoana * p_pers; // se declară un obiect pointer la persoana p_pers = &pers; // atribuire de valoare pointerului
Alocarea dinamică de memorie se poate face şi pentru obiecte de tip structură,
folosind atât funcŃiile specifice limbajului C, cât şi operatorii specifici din C++.
p_pers = (persoana*)malloc(sizeof(persoana)); // alocarea unui element de tip persoana
sau:
p_pers = (persoana*)malloc(dim*sizeof(persoana)); // alocarea unui tablou cu dim// elemente de tip persoana
Eliberarea de memorie se face folosindu-se funcŃia free.
free(p_pers);
Alocarea de memorie folosind operatorii specifice se face astfel:
p_pers = new persoana[dim]; // alocarea unui tablou cu dim// elemente de tip persoana
….delete [ ] p_pers; // dealocarea memoriei
Referirea unui membru al unei structuri indicate de un pointer se face folosind sintaxa:
(* p_pers).nume;
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 238/267
238
sau folosind operatorul de selecŃie indirectă (->) (săgeată).
p_pers->nume;
Exemple de folosire a câmpurilor unei structuri:
puts("\nIntroduceti numele: ");scanf("%s", &p_pers->nume);
puts("\nIntroduceti prenumele: ")scanf("%s", &p_pers->prenume);
puts("\nIntroduceti data nasterii: ");scanf("%d.%d.%d", &p_pers->data_n.zi, &p_pers->data_n.luna, &p_pers->data_n.an);
Operatorul de atribuire admite ca operanzi variabile structură de acelaşi tip, efectuând
toate atribuirile membru cu membru.
persoana p1={"Popescu", "George", 5, 12, 1982}, p2; // p1 se declară cu// iniŃializare, p2 fără iniŃializare
p2=p1; // prin atribuire, p2 preia, membru// cu membru datele din p1
printf("\nNumele:%s", p2.nume); printf("\nPrenume:%s", p2.prenume); printf("\nData nasterii: %d.%d.%d", p2.data_n.zi, p2.data_n.luna, p2.data_n.an);
Pot fi definite funcŃii care să realizeze transfer de informaŃie prin variabile de tip
structură. Transferul unui parametru de tip structură se poate face atât prin valoare, cât şi prin
adresă sau variabile referinŃă. Parametrii formali şi cei efectivi trebuie să fie de acelaşi tip.
Se consideră spre exemplu o structură definită pentru a reprezenta numere complexe
prin valorile pentru partea reală şi cea imaginară:
struct complex { int re, im;} ;
Pentru acest tip de date se defini funcŃii care transferă obiecte în diferite moduri. Spre
exemplu se poate defini o funcŃie care afişează informaŃia conŃinută într-o astfel de dată:
void afisare(complex c) // funcŃie cu parametru de tip complex – se{ // face transfer prin valoare
printf("\n\t%d + i * %d\n", c.re, c.im);}
Definirea unei funcŃii care citeşte de la tastatură valori pentru o variabilă complex se
poate defini:
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 239/267
239
complex citire( ) // funcŃie care returnează o dată de tip complex-{
complex c; printf("\nre=");scanf("%d", &c.re);
printf("\nim=");scanf("%d", &c.im);return c;
}
sau:
void citire(complex * c) // funcŃie cu parametru pointer de complex-{ // transfer prin adresă
printf("\nre=");
scanf("%d", &c->re); printf("\nim=");scanf("%d", &c->im);
}
U13.3. Câmpuri de biŃi
Câmpul de biŃi este un membru al unei structuri sau uniuni care are alocat un grup de
biŃi în interiorul unui cuvânt de memorie.
DeclaraŃia unei structuri cu membrii câmpuri de biŃi se face sub forma:
struct id_tip_struct{
tip_elem1 id_elem1 : lungime;tip_elem2 id_elem2 : lungime;…tip_elemN id_elemN : lungime;
} lista_id_var_struct;
unde lungime reprezintă numărul de biŃi utilizaŃi pentru reprezentarea în memorie a câmpului
respectiv.
RestricŃiile care se impun la declararea câmpurilor de biŃi sunt:
tipul poate fi int signed sau unsigned;
lungimea este o constantă întreagă cu valoarea în domeniul 0-15;
nu se poate evalua adresa câmpului, deci nu se poate folosi operatorul & pentru
acel câmp, deci nu se pot folosi pointeri pentru aceste câmpuri;
nu se pot folosi tablouri de câmpuri de biŃi.
De exemplu, se consideră declaraŃia:
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 240/267
240
struct ex_bit{
unsigned m1 : 1;unsigned m2 : 4;unsigned m3 : 1;
unsigned m4 : 10;};
Dacă se declară o variabilă:
ex_bit variabila_mea;
ea, va fi alocată în memorie ca în fig. 13.3.
Byte Byte Byte Byte Byte Byte Byte Byte999 1000 1001 1002 1003 1004 1005 1006
... ... Adrese memorie
variabila_mea
12345678910111213141516
m4 m3 m2 m1
Fig.13.3. Alocarea în memorie a unei variabile de tip ex_bit
Aşa cum se ştie, unitatea de memorie cea mai mică direct adresabilă este octetul.
Folosirea câmpurilor de biŃi permite accesul la nivel de bit, ceea ce reprezintă o facilitate
oferită de C/C++.
Un alt avantaj oferit de folosirea câmpurilor de biŃi este economia de memorie care se
poate face. Dacă unele date iau valori în domenii de valori restrânse, reprezentarea lor se
poate face pe un număr de biŃi care permite reprezentarea acelor valori.Dacă se folosesc n biŃi, se pot reprezenta 2n valori.
De exemplu, dacă se doreşte folosirea datelor calendaristice, valoarea zilei este
cuprinsă în intervalul 1...31, deci sunt necesari 5 biŃi (25 = 32)., valoarea lunii se poate
reprezenta pe 4 biŃi, iar pentru an am putea folosi 12 biŃi. O astfel de reprezentare va folosi 3
sau 4 octeŃi, depinde de compilatorul folosit, deci mai puŃin decât dacă declaraŃiile ar fi făcute
fără folosirea câmpurilor de biŃi. Este posibil ca o parte din biŃi să nu fie folosiŃi. Acest lucru
nu generează erori.
Referirea membrilor se face ca pentru orice structură, folosind operatorii de selecŃiedirectă sau indirectă (punct sau săgeată).
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 241/267
241
O problemă apare, de exemplu, la citirea de valori pentru astfel de date, pentru că,
pentru aceşti membri nu se poate folosi operatorul adresă (&).
#include <stdio.h>
struct DATA{
unsigned int zi :5; // se declară membrul zi cu reprezentare pe 5 biŃiunsigned int luna :4; // se declară membrul luna cu reprezentare pe 4 biŃiunsigned int an :12; // se declară membrul an cu reprezentare pe 12 biŃi
};
void main(){
DATA data_n; // se declară un obiect de tip DATE
unsigned int aux1, aux2, aux3;
puts(”Introduceti data :”)scanf(”%2d.%2d.%4d”, &aux1, &aux2, &aux3); // este necesară utilizarea unor
// variabile auxiliare pentru citirea// valorilor, deoarece pentru// câmpurile de biŃi nu se poate// face referire la adresă
data_n.zi=aux1;data_n.luna=aux2;data_n.an=aux3;....
}
Dacă se doreşte determinarea dimensiunii în octeŃi a memoriei folosită pentru
reprezentarea acestor date, se poate folosi operatorul sizeof().
printf(”data_n ocupa %d octeti”, sizeof(data_n));
U13.4. Uniuni
Uniunea permite utilizarea în comun a unei zone de memorie de către mai multe
obiecte de tipuri diferite. Sintaxa de declarare a unei uniuni este similară declaraŃiei unei
structuri:union id_tip_uniune{
tip_elem1 id_elem1;tip_elem2 id_elem2;…
tip_elemN id_elemN;} lista_id_var_uniune;
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 242/267
242
sautypedef union{
tip_elem1 id_elem1;tip_elem2 id_elem2;
…tip_elemN id_elemN;
} id_tip_uniune;
SpaŃiul alocat în memorie corespunde tipului de dimensiune maximă, membrii uniunii
utilizând în comun zona de memorie.
Se consideră declaraŃia:
union exemplu
{char c;int i;float f;
};
O variabilă de tipul exemplu declarată, var1, se reprezintă în memorie ca în fig.13.4.
Reprezentarea se face pe 4 octeŃi, adică numărul de octeŃi necesar câmpului cu reprezentare în
domeniul cel mai larg. Câmpul cel mai mare este câmpul f.
exemplu var1;
i
c
f
999 1000 1001 1002 1003 1004 1005 1006... ... Adrese memorie
Adresa variabil &var1ă ( )
var1
999 1007
Fig.13.4. Reprezentarea în memorie a unei uniuni
La un moment se foloseşte un membru al uniunii. Modificarea unui membru va
produce modificări şi asupra celorlalŃi.
Se consideră următoarea aplicaŃie:
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 243/267
243
#include <stdio.h>
struct octet{
unsigned int b0:1; // se declară o structură care ocupă un octet de memorie,unsigned int b1:1; // cu acces separat, prin membrii săi, la fiecare bit în parteunsigned int b2:1; /unsigned int b3:1;unsigned int b4:1;unsigned int b5:1;unsigned int b6:1;unsigned int b7:1;
};
union intreg{
char val; // se declară o uniune ce ocupă un octet de memorie care poateoctet bit; // fi accesat ca şi char prin membrul val, sau ca octet prin
}; // membrul bit
void main (){
intreg i;i.val=22;
// se afişează fiecare bit al uniunii separat folosindu-se câmpul i.bit: printf("\n0x%x se reprezinta in binar: %d%d%d%d%d%d%d%d", i.val, i.bit.b7,i.bit.b6, i.bit.b5, i.bit.b4, i.bit.b3, i.bit.b2, i.bit.b1, i.bit.b0);
}
Programul afişează:
0x16 se reprezinta in binar 00010110
Programul realizează afişarea în format binar a unei valori reprezentată pe un octet, detip char.
ObservaŃii
Numărul de octeŃi folosit în aceste aplicaŃii depinde de compilatorul folosit. De
exemplu tipul int se reprezintă fie pe 2 octeŃi, fie 4.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 244/267
244
Exemple
/***************************************************************************
Exemplu1 13.1. Se scrie un program în care se declară o structură pentru reprezentarea
punctelor în plan prin coordonatele sale. Se exemplifică folosirea variabilelor de tip structura,
tablouri si a pointerilor de structuri.
***************************************************************************/
#include <stdio.h>#include <conio.h>
#include <math.h>#define N 4
struct punct { int x, y;}; // structură pentru reprezentarea punctelor în plan prin// coordonatele sale
void main(){ punct p1, p2; // se declară variabile de tip punct punct pct[N]; // se declară un tablou cu elemente de tip punct
punct *pp; // se declară un pointer la tipul punct
int i;double dist;
printf("Introduceti coordonate pentru p1:"); printf("\np1.x=");scanf("%d", &p1.x);
printf("p1.y=");scanf("%d", &p1.y);
printf("Introduceti coordonate pentru p2:"); printf("\np2.x=");scanf("%d", &p2.x);
printf("p2.y=");scanf("%d", &p2.y);
// se calculeaza distanŃa dintre două puncte
dist=sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y)); printf("\nDistanta dintre p1 si p2 este: %.2f\n", dist);getch();
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 245/267
245
printf("Introduceti coordonate pentru cele 10 puncte:\n");for(i=0 ; i<N ; i++){ printf("\npct[%d]:", i); printf("\nx=");
scanf("%d", &pct[i].x); printf("y=");scanf("%d", &pct[i].y);
}
printf("Coordonatele sunt:\n");for(i=0 ; i<N ; i++)
printf("punctul %d - <%d , %d> \n", i, pct[i].x, pct[i].y);
// se face referire la elementele tabloului cu elemente de tip punct in mod indirect, prin// pointerul pp
pp=pct; printf("Coordonatele sunt:\n");for(i=0;i<N;i++)
printf("punctul %d - <%d , %d>\n", i, (pp+i)->x, (pp+i)->y);
getch();}
/***************************************************************************
Exemplu1 13.2. Se scrie un program în care se declară o structură pentru reprezentareanumerelor complexe. Se definesc următoarele funcŃii: o funcŃie care citeşte de la tastatură
valori pentru o dată de tip complex, o funcŃie care afişează o dată de tip complex, o funcŃie
care calculează şi returnează suma a două numere complexe. Valoarea returnată de funcŃie
este tot de tip complex.
***************************************************************************/
#include <stdio.h>
struct complex { int re, im;} ; // declaraŃia tipului de dată complex
void afisare(complex c) // funcŃie cu parametru de tip complex – se{ // face transfer prin valoare
printf("\n\t%d + i * %d\n", c.re, c.im);}
void citire(complex * c) // funcŃie cu parametru pointer de complex-{ // transfer prin adresă
printf("\nre=");
scanf("%d", &c->re); printf("\nim=");scanf("%d", &c->im);
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 246/267
246
}
complex suma(complex & a, complex & b) // funcŃie care preia prin referinŃă date de{ // tip complex şi returnează o dată de tip
complex c; // complex
c.re=a.re+b.re;c.im=a.im+b.im;return c;
}
void main(){
complex c1, c2, c3; // declaraŃie de variabile complex
printf("\nSe citesc valori pentru c1:");citire(&c1); // funcŃia preia adresa unei variabile de
// tip complex printf("\nSe citesc valori pentru c2:");citire(&c2);
printf("\nNumerele complexe sunt:"); // funcŃia de afişare preia ca parametriafisare(c1); // variabile de tip complex, transferul seafisare(c2); // face prin valoare
c3=suma(c1, c2); // funcŃia preia parametrii prin// referinŃă şi întoarce o valoare// care e atribuită unei variabile
printf("\nSuma numerelor complexe este:");afisare(c3);
}
/***************************************************************************
Exemplu1 13.3. Se scrie un program prin care se citeşte o valoare întreagă de la tastatură. Se
afişează în binar valoarea citită. Se vor folosi câmpuri de biŃi şi uniuni. (Se consideră tipul int
cu reprezentare pe 4 octeŃi).
***************************************************************************/
#include <stdio.h>
struct dword { unsigned b0:1; // structura permite accesul la fiecare bitunsigned b1:1; // care intră în alcătuirea unei reprezentăriunsigned b2:1; // pe 4 octeŃi (32 biŃi).unsigned b3:1;unsigned b4:1;unsigned b5:1;unsigned b6:1;
unsigned b7:1;unsigned b8:1;
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 247/267
247
unsigned b9:1;unsigned b10:1;unsigned b11:1;unsigned b12:1;unsigned b13:1;
unsigned b14:1;unsigned b15:1;unsigned b16:1;unsigned b17:1;unsigned b18:1;unsigned b19:1;unsigned b20:1;unsigned b21:1;unsigned b22:1;unsigned b23:1;unsigned b24:1;
unsigned b25:1;unsigned b26:1;unsigned b27:1;unsigned b28:1;unsigned b29:1;unsigned b30:1;unsigned b31:1;
};
union intreg { int a; // prin cei doi membrii ai uniunii, aceeaşi zonă dedword d; // memorie poate fi interpretată fie ca int, fie la
// nivel de biŃi prin membrul dword};
void print_dword( dword b) // afişarea binară a obiectului{ printf("%d%d%d%d%d%d%d%d %d%d%d%d%d%d%d%d
%d%d%d%d%d%d%d%d %d%d%d%d%d%d%d%d", b.b31, b.b30, b.b29, b.b28, b.b27, b.b26, b.b25, b.b24, b.b23, b.b22, b.b21, b.b20, b.b19, b.b18, b.b17, b.b16, b.b15, b.b14, b.b13, b.b12, b.b11, b.b10, b.b9, b.b8,
b.b7, b.b6, b.b5, b.b4, b.b3, b.b2, b.b1, b.b0);}
void main(){
intreg var1;
printf("Introdu un intreg = ");scanf("%d", &var1.a);
printf("\n %d se reprezinta in binar:", var1.d); print_dword(var1.d);
}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 248/267
248
Rezumat
Programatorul poate să-şi definească propriile tipuri de date care să răspundă
cât mai eficient cerinŃelor aplicaŃiei. Se pot defini noi tipuri de date prin redenumire folosind cuvântul cheie typedef,
definirea unui tip de date însoŃit de o listă de constante folosind cuvântul cheie
enum, definirea unei colecŃii de date de diferite tipuri prin cuvintele cheie struct
sau union.
Tipul enumerare constă dintr-un ansamblu de constante întregi, fiecare asociată
unui identificator.
Structura este o colecŃie de date referite cu un nume comun. O declaraŃie de
structură precizează identificatorii şi tipurile elementelor componente şi
constituie o definiŃie a unui nou tip de date.
Pentru elementele structurii, numite membrii sau câmpuri, se precizează tipul
datei şi numele. Tipurile membrilor pot fi oarecare, mai puŃin tipul structură care
se defineşte, dar pot fi de tip pointer la structura respectivă.
Membrii unei structuri pot fi alocaŃi la nivel de bit, folosind câmpuri de biŃi.
Pentru aceştia nu se poate evalua adresa câmpului, deci nu se poate folosi
operatorul & şi nu se pot folosi pointeri pentru aceste câmpuri.
Uniunea defineşte colecŃii de date de tipuri diferite care folosesc în comun o
zonă de memorie.
Pentru referirea membrilor structurilor şi uniunilor se folosesc operatorii de
selecŃie (.) (punct) în referirea directă sau operatorul de selecŃie indirectă (->)
(săgeată) în referirea prin pointeri.
Test de autoevaluare
1. Care din afirmaŃiile de mai jos sunt adevărate:
a. membrii unei structuri pot fi de orice tip b. membrii unei structuri se declara ca orice variabila specificandu-se
numele si tipul câmpuluic. membrii unei structuri pot fi de orice tip, chiar si de tip structura,
dar nu de tipul curent declarat
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 249/267
249
2. Se da secvenŃa următoare:void main (void){ struct pers { char nume[20];
pers adr;long tel;
float nr_matricol; }; pers x;x.nume[10]="Popescu";
printf("%s", x.nume[10]);}
care afiseaza:a. Popescu
b. eroare in declararea structuriic. eroare, deoarece sirul a fost initializat greşit
3. Care din afirmaŃiile de mai jos sunt corecte:
a. o dată de tip strutura nu poate fi referita atât ca right_value cat si caleft_value
b. operaŃiile care pot fi făcute cu date de tip structură sunt copierea siatribuirea
c. date de tip structură nu pot fi comparate folosind operatori relaŃionali
4. Fie secvenŃa:struct ex{
char *sir;int i; };
struct ex *pt;++pt->i;
Aceasta secvenŃa are ca efect:a. incrementarea pointerului pt
b. incrementarea câmpului i al structuriic. incrementarea pointerului inaintea accesării, urmata de incrementarea
lui i
5. Ce afiseaza secvenŃa de program următoare:void main (void){ struct complex {
float re;float im;};complex z1,z2,*pz;z2.re = 1.53;z2.im = 2.31;z1=z2;
pz=&z1; printf("%f\t%f",z1.re,z1.im);}
a. eroare, pentru ca unei date de tip structură nu i se poate atribui o altădată de acelaşi tip.
b. 1.530000 2.310000c. eroare in declararea structurii
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 250/267
250
6. Este corecta referirea membrilor structuriistruct ex{
int i;char str[20];double d;};
struct ex s, *sp=&s;s.i = 3;sp.d = 1.23;
a. da, deoarece i si d sunt membrii structurii b. nu, deoarece referirea membrilor structurii se face obligatoriu prin
pointerul la structurac. nu, deoarece referirea câmpului d este incorecta
7. Fie secvenŃa:struct complex {
float re;
float im;};struct complex x,y,z;
Aceasta declaraŃie rezerva spaŃiu de memorie de:a. 8 octeti
b. 24 octetic. 3 octeti
8. Ce va afisa secvenŃa de program următoare:void main(void){ struct complex{
float re;float im;};
struct complex tab[10]={{1,2},{1,4},{1,5}};float a,b;a=tab[0].re;
b=tab[0].im; printf("%f\t%f", a, b);}
a. eroare, datorita declararii incorecte a tabloului b. 1 2c. 111 245
9. Ce efect produce secventa următoare:typedef struct {
char nume[10];char adr[20];long tel;}pers;
pers student;....student.nume[0]='A';
a. eroare, nu se poate pune un caracter intr-o variabila de tip structura b. adresa câmpului nume este 'A'
c. prima litera a câmpului nume este 'A'
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 251/267
251
10. Se considera secvenŃa:void main(void){ struct candidat{
char nume[80];float nota1,nota2;};
candidat *px; px=(candidat*)malloc(sizeof(candidat));.....}
Ce efect produce aceasta secvenŃa:a. initializeaza structura candidat cu valoarea px;
b. eliberează zona de memorie rezervata la declararea structuriic. alocarea efectiva a memoriei, iar px va conŃine adresa de memorie
rezervata
11. Se considera secvenŃa:struct adr{ char nume[30], strada[20];
int nr,bl,ap;long cod;
}adresa, lista[100];main(){ lista[10]=adresa;...... }
Ce efect produce aceasta secvenŃa:a. copiaza toate valorile din variabila adresa in elementul de index 10 al
tabloului de adrese lista[]; b. aloca aceeaşi zona de memorie atât pentru structura adresa cat si
pentru structura lista;c. initializeaza structura adresa cu elementul 10 din structura lista
12. Care din următoarele afirmaŃii sunt adevărate?a. structura este o colecŃie de date, neapărat de acelaşi fel, grupate
împreuna sub un singur nume in scopul unei utilizări convenabile b. structura este o colecŃie de date de tipuri diferite, grupate împreuna
sub un singur nume in scopul unei utilizări convenabilec. structurile sunt tipuri de date derivated. structurile sunt tipuri de date fundamentale
13. Se considera declaratia:typedef struct{ char nume[20];
char adresa[50];int virsta;
} persoana; persoana student;
Care din afirmaŃiile de mai jos sunt adevărate?a. student este o variabila de tip persoana, pentru care se rezerva
memorie (74 de octeti) b. persoana este o variabila de tip structura, pentru care se rezerva
memorie (74 de octeti)
c. persoana este un nou tip de date, pentru care nu se rezerva memoried. declaratia este greşita
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 252/267
252
14. Care din afirmaŃiile de mai jos sunt adevărate?a. o structura poate fi transmisa ca argument unei funcŃii
b. in limbajul C, nu se pot folosi pointeri la structuric. un pointer la o structura poate fi transmis ca argument unei functiid. câmpurile unei structuri nu pot fi transmise ca argumente unei functii
Întrebări. ExerciŃii. Probleme.
1. Să se rescrie exemplul nr. 13.1 în care se defineşte o funcŃie pentru citirea de la tastaturăa unei date de tip punct, una pentru afişare şi o a treia care calculează distanŃa dintre
două puncte preluate ca parametri. Apelurile lor se vor folosi în funcŃia main.
2. Să se scrie un program în care se defineşte o structură pentru reprezentarea unui triunghi prin lungimile laturilor sale. Se defineşte o funcŃie pentru citirea de la tastatură a uneidate de tip triunghi, una pentru afişare şi o a treia care calculează aria triunghiului.Apelurile lor se vor folosi în funcŃia main.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 253/267
253
Unitatea de învăŃare U.14. EXEMPLE
Cuprins
Introducere .................................................................................................................. 253
Obiectivele unităŃii de învăŃare ................................................................................... 253
Exemple ...................................................................................................................... 254
IntroducereÎn primele 13 unităŃi de învăŃare au fost prezentate noŃiuni de bază
referitoare la utilizarea unor limbaje de programare. NoŃiunile prezentate au vizat
tipuri de date utilizate în reprezentarea datelor, care pot fi tipuri predefinite, ca de
exemplu char, int, float, double, tipuri derivate, cum sunt pointerii, referinŃele şi
tablourile, sau cele definite de programator folosind structuri sau uniuni. De
asemenea, au fost prezentaŃi operatorii definiŃi în C/C++ şi instrucŃiunile
disponibile. Un aspect important care trebuie avut în vedere în construirea unui
program este modularizarea acestuia prin utilizarea funcŃiilor.În formarea unui programator este importantă formarea unui stil de
programare, aplicarea unor tehnici de programare, aspecte care însă nu au
constituit subiectul acestui curs decât în măsura în care au fost necesare scrierii
exemplelor prezentate. Pentru fixarea noŃiunilor, în prezenta unitate de învăŃare vor
fi prezentate câteva exemple care încearcă să sublinieze o dată în plus modul de
utilizare a noŃiunilor analizate până la acest moment.
Obiectivele unităŃii de învăŃare
Prin parcurgerea acestei unităŃi de învăŃare se exemplifică utilizarea tuturor
elementelor de bază ale limbajelor C/C++ prezentate în acest curs, astfel încât
studentul să ştie, la final, modul de transpunere a unor probleme din diverse
domenii într-un program.
Durata medie de parcurgere a celei de a paisprezecea unităŃi de învăŃare este
de 2 ore.
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 254/267
254
Exemple
/***************************************************************************
Exemplul 14.1. Să se întocmească un program în care se defineşte funcŃia de calcul aradicalului de ordin 2. Se va folosi calculul termenilor seriei Newton:
nr X =0 , )(2/11
1−
−+=
n
nn x
nr x x
Limita seriei astfel definită este nr , calculul termenilor se va finaliza în
momentul în care diferenŃa a doi termeni alăturaŃi se încadrează în precizia propusă ( ε<−
−1nn xx ). De la tastatură se vor citi numărul pentru care se
calculează radicalul şi precizia de calcul.
ObservaŃie: Nu se va folosi funcŃia sqrt() definită în fişierul header math.h
***************************************************************************/
#include<conio.h>#include<stdio.h>
double sqrt(double, double); // preia ca parametru numărul pentru care se calculează radicalul// şi precizia de calcul; returnează valoarea radicalului.
double abs(double); // returnează valoarea absolută a parametrului
void main(){ double nr, eps, rad;
// se citeşte numărul pentru care se calculează radicaluldo{ puts("\nIntrodu numarul (valoare pozitiva):");
scanf("%lf", &nr);}while(nr<0); // valoarea citită trebuie să fie pozitivă
// se citeşte precizia de calculdo{ puts("\nIntrodu precizia de calcul (valoare cuprinsa in intervalul (0,0.1)):");
scanf("%lf", &eps);}while ((eps<=0)||(eps>0.01)) ); // valoarea citită trebuie să fie pozitivă
// se calculează radicalul, folosind funcŃia definitărad=sqrt(nr,eps);
printf("\nValoarea radicalului ptrentru n=%lf este: %lf", nr, rad);getch();
}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 255/267
255
// definiŃia funcŃiei de calcul al radicaluluidouble sqrt(double n,double e){ double r, x;
r=n;do
{ x=r;r=1./2 * (x + n/x); printf("\nval.intermediara:%.10lf",r); // se afişează valorile termenilor calculaŃi
}while (abs(x-r)>e);return r;
}
// funcŃie care returnează valoarea absolută a unei valori preluată ca parametrudouble abs(double a){ if (a>0)
return a;return -a;
}
/***************************************************************************
Exemplul 14.2. Să se scrie un program in care se afiseaza tabla înmulŃirii de la 1 la 10 cu
afisare in formatul:
***************************************************************************/
#include <stdio.h>#include <conio.h>
void main(void){
int i, j;
printf (" | "); //afisarea unor spatii goalefor(i=1; i<=10 ; i++) // se afiseaza deinmultitul printf("%5d", i);
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 256/267
256
printf("\n--------------------------------------------------------");for(i=1 ; i<=10 ; i++){ printf("\n%3d | ", i); // se afiseaza inmultitorul
for( j =1 ; j<=10 ; j++) // se afiseaza valorile produselor i*j printf("%5d", i*j);
} printf("\n");getch();
}
/***************************************************************************
Exemplul 14.3. Să se rescrie exemplul 7.1. în care se rezolvă ecuaŃia de gradul II:
0cx bxa 2=+⋅+⋅
CoeficienŃii a, b şi c se citesc de la tastatură. Se va folosi schema logică din
figura alăturată.
***************************************************************************/
#include <stdio.h>#include <conio.h>
#include <math.h>
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 257/267
257
void main(){
float a, b, c, delta, x1, x2;
printf("coeficientul lui x^2:");
scanf("%f", &a); printf("coeficientul lui x:");scanf("%f", &b);
printf("termenul liber:");scanf("%f", &c);if (a==0)
if (b==0)if (c==0)
printf("Ecuatie nedeterminata !\n");else
printf("Ecuatie imposibila !\n");
else{
printf("Ecuatie de grad I"); printf("\nSolutia este: x = %.2f !\n", -c/b);
}else{
delta= b*b - 4*a*c;if ( delta<0){
printf("radacini complexe\n"); printf("x1= %.2f + i* %.2f !\n", -b/(2*a), sqrt(-delta)/(2*a)); printf("x2= %.2f - i* %.2f !\n", -b/(2*a), sqrt(-delta)/(2*a));
}else
if ( delta==0 ){
x1 = x2 = -b/(2*a); printf("Radacini reale si egale:\n"); printf("x1=x2=%.2f", x1 );
}
else{ printf("Radacini reale si distincte:");x1 = (-b+sqrt(delta))/(2*a);x2 = (-b-sqrt(delta))/(2*a);
printf("\nx1=%.2f\n", x1 ); printf("\nx2=%.2f\n", x2 );
}}getch();}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 258/267
258
/***************************************************************************Exemplul 14.4. Sa se scrie un program in care se definesc următoarele funcŃii:
- o functie de afişare a divizorilor unui întreg, întregul fiind preluat ca
parametru;
- o funcŃie care returneazã c.m.m.d.c. a doi întregi preluaŃi ca parametri;- o funcŃie care returneazã c.m.m.m.c. a doi întregi preluaŃi ca parametri.
În funcŃia main() se citesc doi întregi de la tastaturã, a si b. Se afiseaza un
meniu prin care se permite alegerea intre următoarele opŃiuni:
- afisarea divizorilor lui a
- afisarea divizorilor lui b
- afisarea c.m.m.d.c. pentru a si b
- afisarea c.m.m.m.c. pentru a si b
- ieşirea din program***************************************************************************/
#include<stdio.h>#include <conio.h>
void af_div(int); // functie de afisare a divizorilor unui număr int cmmdc (int, int); // calcul cmmdc a doi întregiint cmmmc(int, int); // calculul cmmmc a doi întregivoid meniu(void); // functie de afisare a meniului
void main(){
int nr1, nr2, optiune;
do{
printf("nr1 = ");scanf("%d", &nr1);
}while (nr1<=1); // se verifica daca valoarea citita este >1
do{
printf("nr2 = ");scanf("%d", &nr2);
}while (nr2<=2); // se verifica daca valoarea citita este >1
// secvenŃa de afişare a meniului se va executa in mod repetat, până la alegerea opŃiunii// desemnată prin valoarea 5do
{meniu(); // apelul functiei de afisare a meniului
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 259/267
259
printf("\n\nIntrodu optiunea: ");scanf("%d", &optiune);
switch(optiune){case 1: printf("\nDivizorii numarului %d sunt: ", nr1);
af_div(nr1);getch(); break;
case 2: printf("\nDivizorii numarului %d sunt: ", nr2);af_div(nr2);getch();
break;case 3: printf("\nCMMDC = %d ", cmmdc(nr1, nr2) );
getch(); break;
case 4: printf("\nCMMMC = %d ", cmmmc(nr1, nr2) );
getch(); break;
case 5: printf("\nSfarsit de program !\n");getch();
break;default: printf("\nOptiunea dumneavoastra este gresita !");
getch();}
}while(optiune != 5);
}
void af_div(int nr) // se afişează toŃi divizorii începând cu valoarea 2{
int i;for(i=2; i<=nr ; i++)if (!(nr%i)) printf("%d ", i);
}
int cmmdc(int n1, int n2)
{// calcul cmmdc se face folosind algoritmul lui// Euclid descris în figura alăturatăwhile(n1!=n2)
{if (n1>n2)
n1=n1-n2;else
n2=n2-n1;}
return n1;
}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 260/267
260
int cmmmc(int n1,int n2){
return n1*n2/cmmdc_1(n1,n2);}
void meniu(void){ printf("\n\n--------------------------- MENIU ------------------------------\n\n"); printf("\n1. Afisarea divizorilor primului intreg introdus."); printf("\n2. Afisarea divizorilor celui de al doilea intreg introdus."); printf("\n3. Afisarea cmmdc pentru cei doi intregi introdusi(varianta 1)."); printf("\n4. Afisarea cmmmc pentru cei doi intregi."); printf("\n5. Iesire din program.");
}
/***************************************************************************
Exemplul 14.5. Forma generala a unui polinom este:
011n
1nn
n axa...xaxa +⋅++⋅+⋅−
− Sa se întocmeasca un program pentru reprezentarea polinoamelor prin gard si
valorile coeficienŃilor. CoeficienŃii se vor memora în tablouri unidimensionale.
Se citesc de la tastatura datele pentru două polinoame (grad si coeficient)
Se afişează cele două polinoame.
Se determină un al treilea polinom ca sumă a primelor două şi se afişează.***************************************************************************/
#include <stdio.h>int citire_pol(float *coef) // functia citeste de la tastatura gradul, memorat in
// variabila grad si coeficienŃii memoraŃi in tabloul coef // si returneaza valoarea gradului polinomului
{ int grad;float aux; // se foloseşte ca variabilă intermediară la citirea coeficienŃilor
// de tip float ai polinomuluido{ printf("\nGradul polinomului= ");
scanf("%d", &grad);}while(grad<0 || grad >= 19); // se verifică valoarea gradului; dimensiunea tablourilor
// de coeficienŃi este 20, deci gradul trebuie să fie <=19for(int i=0 ; i<=grad ; i++){ printf("Coeficientul monomului de grad %d = ", i);
scanf("%f", &aux);coef[i] = aux;
}
return grad;}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 261/267
261
void afisare_pol(float coef[], int grad){
int i;for(i=grad ; i>0 ; i--) // se face afişarea în ordine descrescătoare a gradelor
// monoamelor
{ if(coef[i]!=0) printf("%.2f*X^%d ", coef[i], i);
if(coef[i-1]>0) printf("+");
}if(coef[0]!=0) // monomul de grad 0 se afişează distinct
printf("%.2f\n", coef[0]);}
int suma_pol(float*coef1, int gr1, float*coef2, int gr2, float*coef)
//functia returneaza valoarea gradului polinomului suma{ int gr3;
int i;if(gr1>gr2) // polinoamele însumate pot fi de grade diferite{
gr3=gr1;for(i=0;i<=gr1;i++)
coef3[i]=coef1[i];for(i=0;i<=gr2;i++)
coef3[i]=coef3[i]+coef2[i];}else{
gr3=gr2;for(i=0;i<=gr2;i++)
coef3[i]=coef2[i];for(i=0;i<=gr1;i++)
coef3[i]=coef3[i]+coef1[i];}return gr3; // se returnează gradul polinomului rezultat
}
void main(){
float p1[20], p2[20], p3[20]; // tablourile pentru memorarea coeficientilor // a trei polinoame
int gr1, gr2, gr3; // variabile pentru memorarea gradelor a// 3 polinoame (<=19)
printf("Introduceti date pentru primul polinom:\n");gr1 = citire_pol(p1);
printf("\nPolinomul este:\n");
afisare_pol(p1, gr1); printf("\nIntroduceti date pentru al doilea polinom:\n");
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 262/267
262
gr2 = citire_pol(p2); printf("\nPolinomul este:\n");afisare_pol(p2, gr2);gr3 = suma_pol(p1, gr1, p2, gr2, p3);
printf("\nPolinomul suma este:\n");
afisare_pol(p3, gr3);}
ObservaŃii
FuncŃia de determinare a cmmdc poate fi scrisă folosind şi alŃi algoritmi. Sunt
prezentate în continuare două versiuni:
a. Se parcurg, în ordine crescătoare toate valorile cuprinse în intervalul [2,
min(n1, n2)], verificându-se dacă reprezintă divizor comun pentru n1 şi n2.
Variabila div va păstra valoarea maximă dintre divizorii comuni ai celor douănumere.
int cmmdc (int n1, int n2){
int min, div, i;min = n1<n2 ? n1 : n2; // minimul dintre valorile n1 si n2for(i=2; i<=min ; i++){
if(!(n1%i)&&!(n2%i))
div=i;}return div;
}
b. Se parcurg, în ordine descrescătoare valorile cuprinse în intervalul [ min(n1,
n2), 2], verificându-se dacă reprezintă divizor comun pentru n1 şi n2. Prima
valoare determinată ca divizor comun pentru n1 şi n2 va reprezenta cel mai
mare divizor comun al celor două.
int cmmdc (int n1, int n2){
int min, i;min = n1<n2 ? n1 : n2; // minimul dintre valorile n1 si n2for(i=min; i>=2 ; i--){
if(!(n1%i)&&!(n2%i)) break;
}return i;
}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 263/267
263
/***************************************************************************
Exemplul 14.6. Să se întocmească un program în care se definesc structurile:struct data
{ int zi, luna, an;};
struct student{ char nume[15], prenume[20];
data data_n;int gr;int note[8];float media;
};
Folosind aceste structuri să se memoreze datele unei grupe de studenŃi.
Datele vor fi citite de la tastatură, vor fi memorate într-un tablou de tip
student şi vor fi afişate.***************************************************************************/
#include <stdio.h>#include <conio.h>
#define N 50
struct data{ int zi, luna, an;};
struct student{ char nume[15], prenume[20];data data_n;int gr;int note[8];float media;};
void citire(student & s); // prototipul funcŃiei de citire a datelor unui studentvoid afisare(student & s); // prototipul funcŃiei de afişare a datelor unui student
void main(){ student grupa[N];
int nr_stud, k;
// se citeşte numărul studenŃilor <=50do{ printf("\nIntroduceti numarul studentilor:");
scanf("%d", &nr_stud);} while (nr_stud<1 || nr_stud>50);
// se citesc datele studenŃilor printf("Introduceti datele studentilor:\n");
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 264/267
264
for(k=0 ; k<nr_stud ; k++){ printf("\nIntroduceti datele studentului %d:",k+1);
citire(grupa[k]); // apelul funcŃiei de citire}
// se afişează datele studenŃilor printf("\nDatele citite sunt:\n");for(k=0;k<nr_stud;k++){ afisare(grupa[k]); // apelul funcŃiei de afişare
getch();}
getch();}
void citire(student & s) // definiŃia funcŃiei de citire a datelor unui student
{int i;
printf("\nnumele:");scanf("%14s", s.nume);
printf("prenumele:");scanf("%19s", s.prenume);
printf("data nasterii:");scanf("%d%*c%d%*c%d", &s.data_n.zi, &s.data_n.luna, &s.data_n.an);
printf("grupa:");scanf("%d", &s.gr);
printf("Notele:\n");s.media=0;for(i=0; i<8; i++){ printf("nota[%d]=",i+1);
scanf("%d", &s.note[i]);s.media += s.note[i];
}s.media /=8;
}
void afisare(student & s) // definiŃia funcŃiei de afişare a datelor unui student
{ printf("\n----------------------------------------------------"); printf("\nNumele: %s %s", s.nume, s.prenume); printf("\nGrupa: %d", s.gr); printf("\nData nasterii: %d.%d.%d", s.data_n.zi, s.data_n.luna, s.data_n.an); printf("\nNotele: ");for(int i=0 ; i<8 ; i++)
printf("%d ", s.note[i]); printf("\nMedia: %.2f", s.media);
printf("\n----------------------------------------------------\n");}
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 265/267
265
Rezolvarea testelor de autoevaluare
Unitatea de învăŃare U3
1. c d
2. d
3. a d
4. a e
5. a b d
6. a c
7. a c d
8. b c d
Unitatea de învăŃare U4
1. a b e2. b c d
3. b c e
4. a5. a d
6. a c
7. a d8. c
9. b d
10. b c11. a b
12. c d
Unitatea de învăŃare U5
1. b c
2. a
3. d
4. a
5. a
6. d
7. c
8. d
9. c
10. b
11. b
12. d
Unitatea de învăŃare U6
1. a b c
2. a b d e
3. e
4. a c d
5. a c d
6. b
7. –
8. e
9. a
10. b d
11. b
12. d
13. b
14. a
15. a
Unitatea de învăŃare U7
1. a
2. a
3. a c 4. a c d 5. -
Unitatea de învăŃare U8
1. b
2. c
3. a
4. e
5. d
6. c
7. e
Unitatea de învăŃare U9
1. b c d
2. a3. a b
4. b
5. c6. c
7. b d
8. b
9. a
10. b
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 266/267
266
Unitatea de învăŃare U10
1. a d
2. a b c
3. b
4. c
5. b c e
6. a b c
7. a c
8. a
9. d
10. b
11. c
12. c
Unitatea de învăŃare U11
1. c
2. a
3. a
4. a
5. c
6. c d
7. –
8. b
9. b e
10. b
Unitatea de învăŃare U12
1. a b d
2. a b3. c
4. b
5. b6. c
7. b
8. a
9. c
10. c
Unitatea de învăŃare U13
1. b c
2. c
3. b c
4. b
5. b
6. c
7. b
8. b
9. c
10. c
11. a
12.
13. b c
14. a c
15. a c
5/14/2018 Program Area Calculatoarelor Si Limbaje de Program Are - slidepdf.com
http://slidepdf.com/reader/full/program-area-calculatoarelor-si-limbaje-de-program-are 267/267
Bibliografie.
[1] Jamsa, K., Klander, L., Totul despre C şi C++, Editura Teora, 2000
[2] Eckel, B., Thinking in C++ 2nd edition, version TICA12, Prentice Hall, 2000,http://www.BruceEckel.com/ThinkingInCPP2e.html
[3] Knuth, D.E., Tratat de programarea calculatoarelor, vol.3: Algoritmiseminumerici, Editura Tehnică, Bucureşti, 1985.
[4] Popa, M., Popa, M., Elemente de algoritmi şi limbaje de programare, EdituraUniversităŃii din Bucureşti, 2005.
[5] Schildt, H.: C++ Manual complet, Editura Teora, Bucureşti, 2000
[6] Schildt, H., C++ - manual complet, Editura Teora, Bucureşti, 2001
[7] Ungureanu, A, Ungureanu, D., s.a., Informatica la îndemâna oricui, EdituraUniversităŃii NaŃionale de Apărare “Carol I”, Bucureşti, 2006.
[8] Ungureanu, D., Programare obiectuală folosind C++, Editura UniversităŃiiTransilvania, Braşov, 2009
[9] Ungureanu, D., Programare procedurală folosind C/C++, Editura UniversităŃiiTransilvania, Braşov, 2008
[10] Ungureanu, D., ş.a.: Programarea calculatoarelor – îndrumar C++,Universitatea Transilvania din Braşov 2001.
[11] Negrescu, L.: Limbaje de programare C/C++ pentru începători, Vol. I, II, Ed.MicroInformatica Cluj-Napoca2000.
[12] http://www.cprogramming.com/tutorial.html
[13] http://www.intap.net/~drw/cpp/index.htm
[14] http://www.icce.rug.nl/documents/cplusplus
[15] http://www.uow.edu.au/~nabg/ABC/ABC.html
[16] *** Borland C++ Version 3.1, Programming Guide, Borland International,1992
[17] *** Borland C++ Version 3.1, Library Reference, Borland International, 1992
[18] *** Borland C++ Version 3.1, User’s Guide, Borland International, 1992
[19] *** C Programming and C++ Programming, http://www.cprogramming.com