Curs C

i

Cristian IOSIFESCU

Programarea calculatoarelor i

limbaje de programare

iii

Cuprins

1. NOIUNI INTRODUCTIVE ..................................................................................... 1 1.1 Abordarea problemelor .............................................................................................................. 1 1.2 Algoritmi....................................................................................................................................... 1

1.2.1 Proprietile fundamentale ale algoritmilor ............................................................................ 1 1.2.2 Reprezentarea algoritmilor .................................................................................................... 2

1.3 Algoritmul programatorului ....................................................................................................... 4 1.3.1 Definirea i analiza problemei................................................................................................ 4 1.3.2 Proiectarea algoritmului ......................................................................................................... 4 1.3.3 Implementarea (codificarea) algoritmului .............................................................................. 5 1.3.4 Testarea i depanarea programului....................................................................................... 5 1.3.5 Elaborarea documentaiei...................................................................................................... 8 1.3.6 Exploatarea i ntreinerea..................................................................................................... 8

1.4 Abstractizare i rafinare ............................................................................................................. 8 1.5 Limbajul C/C++ ............................................................................................................................ 9

1.5.1 Originile limbajului C .............................................................................................................. 9 1.6 Structura unui program C sau C++ ......................................................................................... 11

1.6.1 Preprocesorul....................................................................................................................... 12 1.6.2 Funcia main ........................................................................................................................ 13

1.7 Harta zonelor de memorie ale unui program C ...................................................................... 13 1.8 Primele programe...................................................................................................................... 14

2. DATE, OPERATORI I EXPRESII ....................................................................... 16 2.1 Vocabularul................................................................................................................................ 16 2.2 Unitile lexicale ale limbajului C............................................................................................. 16

2.2.1 Identificatori.......................................................................................................................... 16 2.2.2 Cuvinte cheie ....................................................................................................................... 17 2.2.3 Operaii de intrare/ieire ...................................................................................................... 17

2.3 Date n limbajul C ...................................................................................................................... 18 2.3.1 Numele unei date................................................................................................................. 18 2.3.2 Tipuri de date ....................................................................................................................... 19 2.3.3 Variabile ............................................................................................................................... 21 2.3.4 Modificatori de acces ........................................................................................................... 25 2.3.5 Clase de memorare ............................................................................................................. 26 2.3.6 Iniializarea variabilelor n declaraii..................................................................................... 28 2.3.7 Constante............................................................................................................................. 28

2.4 Operatori i expresii.................................................................................................................. 31 2.4.1 Operatori .............................................................................................................................. 32 2.4.2 Expresii ................................................................................................................................ 38 2.4.3 Conversii de tip .................................................................................................................... 40

3. STRUCTURI DE CONTROL ................................................................................ 42 3.1 Adevrat i fals n C .................................................................................................................. 42 3.2 Structura secvenial ................................................................................................................ 42

3.2.1 Instruciunea vid................................................................................................................. 42 3.2.2 Instruciunea expresie.......................................................................................................... 43 3.2.3 Instruciunea compus (instruciunea bloc)......................................................................... 43

3.3 Structura de decizie (alternativ, de selecie) ........................................................................ 43 3.3.1 Instruciunea if ................................................................................................................... 43 3.3.2 Structura de selecie cu ramuri multiple - instruciunea switch ........................................ 46

3.4 Structuri ciclice (repetitive)...................................................................................................... 47 3.4.1 Implementarea structurilor ciclice cu test iniial ................................................................... 47 3.4.2 Implementarea structurilor ciclice cu test final..................................................................... 50 3.4.3 Exerciii ................................................................................................................................ 50

3.5 Instruciuni de salt .................................................................................................................... 53 3.5.1 Instruciunea return .......................................................................................................... 53 3.5.2 Instruciunea goto............................................................................................................... 54 3.5.3 Instruciunea break ............................................................................................................ 55 3.5.4 Instruciunea continue ...................................................................................................... 55

3.6 Instruciuni expresie ................................................................................................................. 57

iv

3.7 Instruciuni bloc ........................................................................................................................ 57 4. TABLOURI ........................................................................................................... 58

4.1 Tablouri unidimensionale......................................................................................................... 58 4.1.1 Iniializarea tablourilor unidimensionale............................................................................... 59

4.2 iruri ........................................................................................................................................... 60 4.2.1 Iniializarea irurilor.............................................................................................................. 60

4.3 Tablouri bidimensionale ........................................................................................................... 61 4.3.1 Iniializarea tablourilor bidimensionale................................................................................. 62

4.4 Tablouri multidimensionale ..................................................................................................... 63 4.4.1 Iniializarea de tablouri nedimensionate .............................................................................. 63

4.5 Exemple...................................................................................................................................... 64 5. POINTERI............................................................................................................. 67

5.1 Variabile pointer ........................................................................................................................ 67 5.1.1 Declararea variabilelor pointer............................................................................................. 67 5.1.2 Operatorii pentru pointeri ..................................................................................................... 67 5.1.3 Pointeri generici ................................................................................................................... 69

5.2 Operaii cu pointeri ................................................................................................................... 69 5.2.1 Adunarea sau scderea....................................................................................................... 69 5.2.2 Compararea valorilor variabilelor pointer............................................................................. 70

5.3 Pointeri i tablouri..................................................................................................................... 70 5.3.1 Pointeri i iruri de caractere ............................................................................................... 71 5.3.2 Pointeri i tablouri multidimensionale .................................................................................. 73

5.4 Tablouri de pointeri................................................................................................................... 74 5.5 Pointeri la pointeri..................................................................................................................... 75 5.6 Modificatorul const n declararea pointerilor........................................................................ 76

6. FUNCII................................................................................................................ 77 6.1 Structura unei funcii ................................................................................................................ 77 6.2 Apelul i prototipul funciilor ................................................................................................... 78 6.3 Regulile de competen ale unei funcii ................................................................................. 79 6.4 Transferul parametrilor unei funcii ........................................................................................ 79

6.4.1 Transferul parametrilor prin valoare .................................................................................... 79 6.4.2 Transferul parametrilor prin pointeri .................................................................................... 81 6.4.3 Transferul parametrilor prin referin ................................................................................... 82

6.5 Apelul funciilor folosind tablouri............................................................................................ 83 6.5.1 Funcii care returneaz pointeri ........................................................................................... 86

6.6 Funcii de tip void .................................................................................................................... 87 6.7 Funcii cu parametri implicii ................................................................................................... 87 6.8 Funcii cu numr variabil de parametri ................................................................................... 88 6.9 Transferul parametrilor ctre funcia main............................................................................. 88 6.10 Ce returneaz funcia main()? ............................................................................................. 89 6.11 Funcii recursive...................................................................................................................... 90 6.12 Pointeri ctre funcii................................................................................................................ 92 6.13 Probleme de implementare .................................................................................................... 94

6.13.1 Parametri i funcii de uz general ...................................................................................... 94 6.13.2 Eficien ............................................................................................................................. 94 6.13.3 Biblioteci i fiiere .............................................................................................................. 95

7. TIPURI DE DATE DEFINITE DE UTILIZATOR.................................................... 97 7.1 Structuri ..................................................................................................................................... 97

7.1.1 Transmiterea structurilor n funcii ....................................................................................... 99 7.1.2 Pointeri ctre structuri ........................................................................................................ 100

7.2 Cmpuri de bii ........................................................................................................................ 102 7.3 Uniuni ....................................................................................................................................... 103 7.4 Enumerri................................................................................................................................. 104 7.5 Declaraii de tip........................................................................................................................ 108

8. PREPROCESORUL ........................................................................................... 109 8.1 Preprocesorul C ...................................................................................................................... 109 8.2 Directiva #define...................................................................................................................... 109

8.2.1 Definirea de macrocomenzi tip funcie .............................................................................. 110

v

8.3 Directiva #error ..................................................................................................................... 111 8.4 Directiva #include ................................................................................................................. 111 8.5 Directive de compilare condiional...................................................................................... 112

8.5.1 Directivele #if, #else, #endif, #elif ................................................................... 112 8.5.2 Directivele #ifdef i #ifndef ........................................................................................ 114 8.5.3 Directiva #undef ............................................................................................................... 115 8.5.4 Utilizarea operatorului defined........................................................................................ 115

8.6 Directiva #line ....................................................................................................................... 115 8.7 Directiva #pragma ................................................................................................................... 116 8.8 Operatorii de preprocesare # i ## ....................................................................................... 116 8.9 Nume predefinite de macrocomenzi ..................................................................................... 116 8.10 Comentariile........................................................................................................................... 117

9. BIBLIOTECA STANDARD................................................................................. 118 9.1 Funcii de intrare/ieire: ..................................................................................... 118

9.1.1 Operaii I/O pentru consol................................................................................................ 119 9.1.2 Operaii cu fiiere............................................................................................................... 123

9.2 Funcii pentru caractere i iruri de caractere..................................................................... 133 9.2.1 Funcii de testare i conversie a caracterelor: .............................................. 133 9.2.2 Funcii pentru iruri de caractere: ............................................................... 134

9.3 Funcii matematice: .............................................................................................. 135 9.3.1 Funcii aritmetice................................................................................................................ 135 9.3.2 Funcii trigonometrice directe i inverse ............................................................................ 135 9.3.3 Funcii exponeniale i logaritmice..................................................................................... 136

9.4 Funcii utilitare: ................................................................................................. 136 9.5 Operaii cu directoare ............................................................................................................. 137 9.6 Funcii pentru dat i or: .................................................................................... 137 9.7 Valori limit dependente de implementare: i .......................... 139 9.8 Moduri de alocare a memoriei ............................................................................................... 140

9.8.1 Alocarea memoriei n mod dinamic ................................................................................... 140

10. GESTIUNEA ECRANULUI N MOD TEXT....................................................... 143 10.1 Setarea ecranului n mod text .............................................................................................. 144 10.2 Definirea unei ferestre .......................................................................................................... 144 10.3 tergerea unei ferestre ......................................................................................................... 144 10.4 Gestiunea cursorului ............................................................................................................ 145 10.5 Determinarea parametrilor ecranului .................................................................................. 145 10.6 Modurile video alb/negru...................................................................................................... 146 10.7 Setarea culorilor .................................................................................................................... 146 10.8 Gestiunea textelor................................................................................................................. 147

11. GESTIUNEA ECRANULUI N MOD GRAFIC .................................................. 154 11.1 Setarea modului grafic ......................................................................................................... 154 11.2 Gestiunea culorilor................................................................................................................ 157 11.3 Starea ecranului .................................................................................................................... 159 11.4 Gestiunea textelor................................................................................................................. 160 11.5 Gestiunea imaginilor............................................................................................................. 163 11.6 Tratarea erorilor..................................................................................................................... 169 11.7 Desenare i colorare............................................................................................................. 172

12. SORTARE I CUTARE ................................................................................. 182 12.1 Sortarea.................................................................................................................................. 182

12.1.1 Clase de algoritmi de sortare........................................................................................... 182 12.1.2 Aprecierea algoritmilor de sortare ................................................................................... 182 12.1.3 Sortare prin metoda bulelor ............................................................................................. 183 12.1.4 Sortarea prin selecie....................................................................................................... 184 12.1.5 Sortarea prin inserare ...................................................................................................... 185 12.1.6 Algoritmi de sortare superiori........................................................................................... 185 12.1.7 Sortarea prin metoda Shell .............................................................................................. 186 12.1.8 Sortarea prin metoda rapid (QuickSort)......................................................................... 187

12.2 Cutarea ................................................................................................................................. 191 12.2.1 Metode de cutare........................................................................................................... 191

vi

13. LISTE, COZI, STIVE I ARBORI ..................................................................... 193 13.1 Liste ........................................................................................................................................ 193

13.1.1 Liste simplu nlnuite ...................................................................................................... 194 13.1.2 Liste dublu nlnuite........................................................................................................ 198

13.2 Cozi ......................................................................................................................................... 201 13.2.1 Cozi circulare ................................................................................................................... 204

13.3 Stive ........................................................................................................................................ 205 13.4 Arbori binari........................................................................................................................... 207 Manuale electronice ...................................................................................................................... 213

vii

Lista exemplelor

Exemplul 1.1 Aria unui dreptunghi......................................................................................3 Exemplul 1.2 Se citesc 2 valori reale. S se afieze valoarea maximului dintre cele 2 numere.................................................................................................................................3 Exemplul 1.3 Algoritm maxim perechi numere. ..................................................................3 Exemplul 2.1: Constante caracter.....................................................................................30 Exemplul 2.2: iruri de caractere......................................................................................31 Exemplul 3.1 Instruciunea if ..........................................................................................45 Exemplul 3.2 Instruciunea if - calculul valorii unei funcii...............................................45 Exemplul 3.3 Calculator de buzunar - construcia if-else ...........................................46 Exemplul 3.4 Calculator de buzunar - instruciunea switch............................................47 Exemplul 3.5 Cicluri ..........................................................................................................50 Exemplul 3.6 Suma i produsul primelor n numere naturale ............................................51 Exemplul 3.7 Maximul unui ir de numere naturale ..........................................................52 Exemplul 3.8 Conversia unui numr din baza 10 ntr-o alt baz de numeraie...............52 Exemplul 3.9 Calculul unei serii ........................................................................................53 Exemplul 3.10 Citire caractere..........................................................................................57 Exemplul 4.1 Citirea i afiarea elementelor unei matrici .................................................62 Exemplul 4.2 Interschimbarea elementelor unui vector ....................................................64 Exemplul 4.3 Citirea i afiarea elementelor unei matrici .................................................64 Exemplul 4.4 Operaii cu matrici .......................................................................................65 Exemplul 5.1.....................................................................................................................68 Exemplul 5.2.....................................................................................................................68 Exemplul 5.3.....................................................................................................................69 Exemplul 5.4 Legtura dintre pointeri i vectori ................................................................71 Exemplul 5.5 Legtura dintre pointeri i irurile de caractere ...........................................72 Exemplul 5.6 Pointeri - vector...........................................................................................72 Exemplul 5.7 S se testeze programul urmtor, urmrind cu atenie rezultatele obinute............................................................................................................................................74 Exemplul 6.1 Domeniul de vizibilitate a unei variabile ......................................................78 Exemplul 6.2: Apelul unei funcii .......................................................................................78 Exemplul 6.3: Parametri formali i parametri efectivi. .......................................................80 Exemplul 6.4: Expresii ca parametri efectivi .....................................................................80 Exemplul 6.5: Valoare returnat prin referin ..................................................................83 Exemplul 6.6: Modificatorul de acces const n lista declaraiilor parametrilor formali ai unei funcii..........................................................................................................................83 Exemplul 6.7: Tablouri ca parametri - elementul minim dintr-un vector ............................84 Exemplul 6.8: Funcii care returneaz pointeri..................................................................86 Exemplul 6.9: Funcii care returneaz pointeri..................................................................86 Exemplul 6.10: Program Salut nume ................................................................................89 Exemplul 6.11: S se implementeze un program care afieaz argumentele transmise ctre funcia main..............................................................................................................89 Exemplul 6.12: S se implementeze recursiv funcia care calculeaz n!, unde n este introdus de la tastatur: .....................................................................................................90 Exemplul 6.13: irul lui Fibonacci .....................................................................................91 Exemplul 6.14 Calculul derivatei unei funcii ntr-un punct................................................92 Exemplul 6.15 Pointeri ctre funcii ..................................................................................93 Exemplul 7.1 Structuri - elevi ..........................................................................................104

viii

Exemplul 9.1: S se scrie un program care creeaz un fiier text n care se vor scrie caracterele introduse de la tastatur (citite din fiierul standard de intrare), pn la ntlnirea caracterului ^Z = Ctrl+Z....................................................................................126 Exemplul 9.2: S se scrie un program care citete un fiier text, caracter cu caracter, i afieaz coninutul acestuia.............................................................................................126 Exemplul 9.3...................................................................................................................127 Exemplul 9.4 S se scrie un program care creeaz un fiier text n care se vor scrie irurile de caractere introduse de la tastatur. .................................................................128 Exemplul 9.5 S se scrie un program care citete un fiier text, linie cu linie, i afieaz coninutul acestuia ...........................................................................................................128 Exemplul 9.6 S se scrie un program care creeaz un fiier binar n care se vor introduce numere reale, nenule. ......................................................................................................129 Exemplul 9.7 S se scrie un program ce citete dintr-un fiier binar numere reale, nenule..........................................................................................................................................130 Exemplul 10.1 S se scrie o funcie care afieaz parametrii ecranului. ........................146 Exemplul 10.2 S se scrie un program care seteaz pe rnd modurile text, definite cu ajutorul constantelor simbolice: BW40, C40, BW80, C80 i C4350 i afieaz parametrii ecranului pentru fiecare din modurile respective..............................................................147 Exemplul 10.3 S se scrie un program care afieaz texte n modurile video intens i video normal. ...................................................................................................................148 Exemplul 10.4 S se scrie un program care afieaz toate combinaiile de culori posibile pentru fond i caractere. Se consider c se dispune de un adaptor color EGA/VGA. ...148 Exemplul 10.6 S se scrie o funcie care afieaz o fereastr limitat de un chenar i pe fondul creia se afieaz un ntreg. Cursorul devine invizibil la afiarea ferestrei. Funcia are prototipul:...................................................................................................................149 Exemplul 10.7 S se scrie un program care afieaz ferestre pe ecran n mod aleator. Ferestrele sunt de dimensiune fix, dar au poziii aleatoare pe ecran. De asemenea, ele pot avea chenar format dintr-o linie simpl sau dubl sau s nu aib chenar. Culorile de fond i de afiare a caracterelor sunt aleatoare. Ferestrele se numeroteaz i numrul ferestrei se afieaz n fereastr. Prima fereastr afiat se numeroteaz cu 1. ............151 Exemplul 11.1 S se scrie un program care seteaz modul grafic n dou feluri: ..........156 Exemplul 11.2 S se scrie un program care afieaz codurile culorilor pentru paleta implicit............................................................................................................................158 Exemplul 11.3 S se scrie un program care afieaz urmtoarele informaii: ................159 Exemplul 11.4 S se scrie un program care afieaz texte folosind toate cele 5 fonturi, caracterele avnd pe rnd dimensiunile 1, 2, 3 i 4. n cazul fonturilor diferite de DEFAULT_FONT, se vor afia texte ale cror caractere se vor afla n rapoartele: 4/3 n lime i 2/1 n nlime. ...................................................................................................162 Exemplul 11.5 S se scrie un program care afieaz texte cadrate n toate variantele definite de funcia settextjustify..............................................................................163 Exemplul 11.6 S se scrie un program care realizeaz urmtoarele:.............................166 Exemplul 11.7 S se scrie un program care realizeaz urmtoarele:.............................167 Exemplul 11.8 S se scrie un program care realizeaz urmtoarele:.............................168 Exemplul 11.9 S se scrie un program care afieaz parametri implicii ai modului grafic setat prin apelul funciei initgraph: ..............................................................................170 Exemplul 11.10 S se scrie un program care traseaz linii orizontale folosind cele 4 stiluri standard i ambele grosimi. .............................................................................................176 Exemplul 11.11 S se scrie un program care traseaz urmtoarele figuri: ....................176 Exemplul 11.12 S se scrie un program care coloreaz figurile geometrice trasate n programul precedent........................................................................................................177

ix

Exemplul 11.13 S se scrie un program care afieaz 15 dreptunghiuri colorate, pe trei rnduri, folosind toate cele 15 culori ale paletei diferite de culoarea de fond. Sub fiecare dreptunghi se listeaz indicele culorii dreptunghiului, n tabloul care definete paleta curent de culori. Dup afiarea celor 15 dreptunghiuri se poate regla monitorul aa nct fiecare dreptunghi s fie vizibil. ........................................................................................178 Exemplul 11.14 S se scrie un program care afieaz dreptunghiuri utiliznd toate haurile standard. ............................................................................................................179 Exemplul 11.15 S se scrie un program care traseaz un cerc folosind ecuaiile parametrice ale cercului:..................................................................................................179 Exemplul 11.16 S se scrie un program care deplaseaz o imagine pe ecran. .............180 Exemplul 12.1 Program de sortare cu utilizarea diverselor metode prezentate ...............188 Exemplul 13.1 Program simplu de planificare a ntlnirilor .............................................202 Exemplul 13.2 Calculator postfix pentru expresii ntregi .................................................206 Exemplul 13.3 Creare i afiare arbore ..........................................................................208

Noiuni introductive

1

1. Noiuni introductive

1.1 Abordarea problemelor

Programarea reprezint tiina i arta rezolvrii problemelor [1]. Pentru a fi un bun programator trebuie s fii un bun rezolvitor al problemelor, iar pentru aceasta trebuie s tii s "ataci" problemele ntr-un mod metodic, de la prima definire i evaluare a problemei pn la soluia final, testare i documentaie. La nceput, cnd te vei confrunta cu o problem de programare, vei fi tentat s te aezi la calculator i s ncepi s o codifici pe msur ce i vine o idee de rezolvare a sa. Oricum, este bine s reziti acestei tentaii. O astfel de abordare poate merge pentru probleme simple, dar nu va merge pentru problemele complexe gsite n practic. n acest capitol vei nva o metod sistematic care v va face s devenii un bun rezolvitor de probleme i prin urmare un bun programator. Numim aceast metod algoritmul programatorului. Mai precis, vei studia paii cerui de rezolvarea oricrei probleme de programare utiliznd metoda structurat top/down. Vei fi introdui n conceptul abstractizrii care permite ca problemele s fie vzute n termeni generali. Plecnd de la o soluie abstract iniial, vei defini mai n detaliu pas cu pas soluia, pn cnd aceasta atinge un nivel care poate fi codificat direct ntr-un program pentru calculator. Pe msur ce acumulai experien vei vedea c "secretul" unei programri de succes este o bun planificare prin intermediul analizei abstracte i a unei dezvoltri incrementale, fapt ce va conduce la proiectarea de programe structurate ntr-o manier top/down. O astfel de modalitate de proiectare a programelor este sprijinit foarte bine de limbajele structurate ca C.

1.2 Algoritmi

Algoritmul este un set ordonat de pai executabili, descrii fr echivoc, care definesc un proces finit.

Algoritmii nu sunt folosii exclusiv n programare [2]. Orice set de instruciuni, ca acelea pe care le putei gsi ntr-o partitur muzical, ntr-o reet culinar sau n ghidul de asamblare a unui dispozitiv, poate fi considerat un algoritm. Pentru ca o main de calcul s poat rezolva o anumit problem, programatorul trebuie mai nti s stabileasc un algoritm care s conduc la efectuarea la sarcinii respective.

1.2.1 Proprietile fundamentale ale algoritmilor Caracterul finit: orice algoritm bine proiectat se termin ntr-un numr finit de pai; Caracterul unic i universal: orice algoritm trebuie s rezolve toate problemele dintr-o

clas de probleme; Caracterul discret: fiecare aciune se execut la un moment dat de timp; Caracterul determinist: ordinea aciunilor n execuie este determinat n mod unic de

rezultatele obinute la fiecare moment de timp. Realizabilitatea: orice algoritm trebuie s poat fi codificat ntr-un limbaj de

programare; Nerespectarea acestor caracteristici generale conduce la obinerea de algoritmi neperformani, posibil infinii sau nerealizabili.

Capitolul 1

1.2.2 Reprezentarea algoritmilor Reprezentarea (descrierea) unui algoritm nu se poate face n absena unui limbaj comun celor care vor s l neleag. De aceea s-a stabilit o mulime bine definit de primitive (blocuri elementare care stau la baza reprezentrii algoritmilor). Fiecare primitiv se caracterizeaz prin sintax i semantic. Sintaxa se refer la reprezentarea simbolic a primitivei; semantica se refer la semnificaia primitivei. Exemplu de primitiv: aer-din punct de vedere sintactic este un cuvnt format din trei simboluri (litere); din punct de vedere semantic este o substan gazoas care nconjoar globul pmntesc. Algoritmii se reprezint prin:

scheme logice; pseudocod.

1.2.2.1 Reprezentarea algoritmilor prin scheme logice Primitivele utilizate n schemele logice sunt simboluri grafice, cu funciuni (reprezentnd procese de calcul) bine precizate. Aceste simboluri sunt unite prin sgei (arce) orientate care indic ordinea de execuie a proceselor de calcul.

Simboluri de nceput i sfrit. Simbolul START desemneaz nceputul unui program sau al unui subprogram. Simbolul STOP desemneaz sfritul unui program sau al unui subprogram. Prezena lor este obligatorie.

2

Simbolul paralelogram: semnific procese (operaii) de intrare/ieire (citirea sau scrierea-afiarea)

Simbolul dreptunghi: semnific o atribuire (modificarea valorii unei date).

CITETE a,b AFIEAZ a,b

a6 Condiie A

START STOP

F

Simbolul romb este utilizat pentru decizii. Se testeaz dac condiia din blocul de decizie este adevrat (A) sau fals (F).

Cu ajutorul acestor simboluri grafice se poate reprezenta orice algoritm. Repetarea unei secvene se realizeaz prin combinarea simbolurilor de decizie i de atribuire.

1.2.2.2 Reprezentarea algoritmilor prin pseudocod Pseudocodul este inspirat din limbajele de programare, nefiind ns att de formalizat ca acestea. Pseudocodul reprezint o punte de legtur ntre limbajul natural i limbajele de programare. Nu exist un standard pentru regulile lexicale. Limbajul pseudocod permite comunicarea ntre oameni, i nu comunicarea om-main (precum limbajele de programare). Pseudocodul utilizeaz cuvinte cheie (scrise cu majuscule subliniate) cu urmtoarele semnificaii: Sfrit algoritm: SFRITnceput algoritm: NCEPUTCitire (introducere) date: CITETE lista Scriere (afiare) date: SCRIE lista Atribuire: Structura de decizie (alternativ): DAC condiie ATUNCI aciune1 ALTFEL aciune2

Noiuni introductive

3

Structuri repetitive cu test iniial: CT TIMP condiie REPET aciune sau: PENTRU contor = val_ini LA val_fin [PAS] REPET aciune; Structuri repetitive cu test final: REPET aciune CT TIMP condiie sau: REPET aciune PN CND condiie Pe lng cuvintele cheie, n reprezentarea algoritmilor n pseudocod pot apare i propoziii nestandard a cror detaliere va fi realizat ulterior. n cazul n care se realizeaz un algoritm modularizat, pot apare cuvintele cheie: SUBALGORITM nume (lista_intrri) CHEAM nume (lista_valori_efective_de_intrare) Exemple: Se vor prezenta n continuare algoritmii de rezolvare pentru cteva probleme simple.

Exemplul 1.1 Aria unui dreptunghi Se citesc 2 valori numerice reale, care reprezint dimensiunile (lungimea i limea unui dreptunghi). S se calculeze i s se afieze aria dreptunghiului.

ALGORITM arie_dreptunghi NCEPUT CITETE L,l aria = b ATUNCI AFIEAZ a ALTFEL AFIEAZ b SFRIT algoritm

ALGORITM max_2_nr_v2 NCEPUT CITETE a, b DAC a >= b ATUNCI max

Capitolul 1

4

(Structura cu test iniial v2) NCEPUT a5 (orice valoare diferit de 0) CT TIMP (a0 sau b0) REPET NCEPUT CITETE a, b DAC (a>=b) ATUNCI AFIEAZ a ALTFEL AFIEAZ b SFRIT ciclu SFRIT algoritm

(Structura cu test final) NCEPUT REPET NCEPUT CITETE a,b DAC (a>=b) ATUNCI AFIEAZ a ALTFEL AFIEAZ b SFRIT ciclu CT TIMP (a0 sau b0) SFRIT algoritm

1.3 Algoritmul programatorului

Algoritmul programatorului este o reet, pentru dumneavoastr ca programatori, pe care este bine s o utilizai n dezvoltarea programelor. El const n: Definirea i analiza problemei (nelegerea problemei i specificarea cerinelor

acesteia). Se stabilete CE trebuie s fac aplicaia, i nu CUM. Se stabilesc datele de intrare (identificarea mediului iniial) i se stabilesc obiectivele (identificarea mediului final, a rezultatelor);

Proiectarea (conceperea unei metode de rezolvare a problemei printr-o metod algoritmic);

Implementarea (codificarea algoritmului ales ntr-un limbaj de programare); Testarea (verificarea corectitudinii programului) i depanarea aplicaiei obinute; Elaborarea documentaiei programului. Exploatarea i ntreinerea.

1.3.1 Definirea i analiza problemei Putei afirma c acest pas este un pas esenial n rezolvarea oricrei probleme. Totui, este pasul care se trece cu vederea cel mai des, mai ales n programarea calculatoarelor. Lipsa unei burse definiii a problemei conduce de cele mai multe ori la soluii greoaie, nclcite n special n cazul unor aplicaii mai complexe. Care sunt elementele care trebuie considerate ca parte a acestei etape n scrierea programului?. Trebuie avute n vedere datele de ieire (prin tipul lor: date numerice, caracter sau i una i alta, modul de prezentare - afiare sub form de text sau grafic) - care reprezint rezultatul programului, datele de intrare (prin tip, mod de introducere: de la tastatur sau cu ajutorul unui sistem automat de recunoatere) i tipul de prelucrare care se efectueaz asupra acestora. Toate aceste aspecte trebuie avute n vedere atunci cnd se urmrete definirea unei probleme de programare. Pe scurt se poate spune c definirea problemei presupune considerarea cerinelor de intrare, ieire i de procesare. ntotdeauna aplicaia va dicta modul n care trebuie efectuat definirea problemei.

1.3.2 Proiectarea algoritmului Aceast etap a algoritmului programatorului este probabil cea mai important. Imaginai-v c ai ncerca s construii o cas fr a avea un set de schie corespunztor. Rezultatul ar putea fi catastrofal! Acelai lucru se poate ntmpla i dac ncercai s scriei un program fr un plan bun. Atunci cnd se dezvolt un produs soft, gsirea unei soluii presupune utilizarea unui set de algoritmi. n aceasta etap, care cade exclusiv n sarcina programatorului, paii soluiei sunt descrii cu ajutorul unei scheme logice sau prin pseudocod.

Noiuni introductive

5

1.3.3 Implementarea (codificarea) algoritmului Codificarea programului trebuie s fie una dintre cele mai simple sarcini din ntregul proces de programare, dac definirea problemei i gsirea unui algoritm au fost efectuate n mod corespunztor. Limbajul de programare pe care l vei folosi va fi determinat de natura problemei, de limbajele la care avea acces i de caracteristicile sistemului dumneavoastr. Codificarea const n scrierea efectiv a programului surs ntr-un limbaj formal de programare prin transcrierea pailor algoritmului n codul limbajului de programare. Programele surs sunt fiiere text care conin instruciuni (cu sintactica i semantica proprii limbajului utilizat). Programul (fiierul) surs este creat cu ajutorul unui editor de texte i va fi salvat pe disc (programele surs C primesc, de obicei, extensia .c, iar cele C++, extensia .cpp). Pentru a putea fi executat, programul surs trebuie ulterior compilat i linkeditat. Am dori s reamintim c procesul de scriere a programelor este ntr-adevr un proces mecanic i trebuie s ocupe locul al doilea ca importan dup gsirea algoritmului ce ofer o soluie problemei studiate. n viitor calculatoarele i vor genera propriul cod plecnd de la algoritmii construii n mod corespunztor. Cercetarea tiinific din domeniul inteligentei artificiale a condus la realizarea unor pachete de programe care sunt capabile s "genereze programe''. Ceea ce trebuie s reinei, este c n viitor, calculatoarele vor fi probabil capabile s-i genereze propriul cod, dar cu toate acestea va fi nevoie de creativitatea fiinei umane pentru gsirea i dezvoltarea unui algoritm.

1.3.4 Testarea i depanarea programului Vei afla n curnd, c doar n ocazii rare un program funcioneaz corect, fr erori, imediat dup codificare. Desigur, o bun definire a problemei i un algoritm corect elimin multe erori din program. Totui, de cele mai multe ori exist erori care rmn nedetectate, indiferent ct de bine sunt efectuai paii precedeni ai algoritmului programatorului. Eliminarea unor astfel de erori poate s se dovedeasc o sarcin mare consumatoare a timpului programatorului. Nu exist o procedur magic pentru depanarea programelor, dar o metod sistematic poate s fac procesul mai uor. Paii de baz n depanare sunt:

stabilirea faptului c programul are o eroare; localizarea i determinarea tipului i cauzei erorii; eliminarea erorii.

Primul lucru pe care trebuie s-l facei, este s v dai seama dac programul dumneavoastr are sau nu vreo eroare. Uneori acest lucru este foarte evident atunci cnd, spre exemplu, calculatorul se blocheaz. Alteori programul funcioneaz corect pn cnd unul dintre utilizatori introduce informaii pe care nu le-ai luat n considerare. Cele mai subtile erori apar atunci cnd programul pare s genereze rezultate corecte, dar Ia o privire mai atent se constat contrariul. Urmtorul pas n procesul de depanare este localizarea i determinarea cauzei erorii. Izolarea poziiei n care se produce eroarea este uneori cea mai dificil problem a depanrii. Acesta este momentul n care trebuie s facei apel la un instrument foarte util, i anume depanatorul (debugger-ul). Eliminarea erorii este ultimul pas al procesului de depanare. Cunoaterea erorii, cunotinele dumneavoastr legate de limbajul C, aceast carte, depanatorul integrat i manualele TURBO C-ului toate sunt instrumente preioase n eliminarea acesteia. Atunci cnd scriei programe n C exist patru lucruri pe care le putei face pentru a testa i depana programul dumneavoastr:

verificarea preliminar, compilarea/linkeditarea programului, rularea programului i

Capitolul 1

utilizarea depanatorului. 1.3.4.1 Verificarea preliminar Aceasta verificare este similar cu a face corectura mici scrisori sau a unui manuscris. Ideea este s urmrii mental programul pentru a vedea dac logica acestuia este corect. Trebuie s considerai diferite date de intrare i s notai rezultatele generate n urma execuiei programului. n particular ncercai s determinai cum se va comporta programul dac introducei date pe care n mod normal nu le-ai introduce. De exemplu, s presupunem c programul cere ca utilizatorul s introduc o valoare a crei rdcin ptrat trebuie gsit. Desigur utilizatorul NU ar trebui s introduc o valoare negativ, deoarece rdcina ptrat a unei valori negative este un numr imaginar. Totui, cum va funciona programul dac utilizatorul va face acest lucru?. O alt valoare care ntotdeauna trebuie considerat ca mrime de intrare este valoarea zero, n special cnd este utilizat n operaii aritmetice cum ar fi mprirea. Cnd vei scrie primele dumneavoastr programe vei fi tentat s srii peste aceast faz a verificrii preliminate, deoarece de abia ateptai s executai programul pe care l-ai scris. Totui, pe msura ce ctigai experien, v vei da seama repede ct de mult timp economisii urmnd aceast procedur.

1.3.4.2 Compilarea/linkeditarea programului

1.3.4.2.1 Compilarea Procesul de compilare este realizat cu ajutorul compilatorului, care translateaz codul surs n cod obiect (cod main), pentru ca programul s poat fi neles de calculator. n cazul limbajului C, n prima faz a compilrii este invocat preprocesorul. Acesta recunoate i analizeaz mai nti o serie de instruciuni speciale, numite directive procesor. Verific apoi codul surs pentru a constata dac acesta respect sintaxa i semantica limbajului. Dac exist erori, acestea sunt semnalate utilizatorului. Utilizatorul trebuie s corecteze erorile (modificnd programul surs). Abia apoi codul surs este translatat n cod de asamblare, iar n final, n cod main, binar, propriu calculatorului. Acest cod binar este numit cod obiect i de obicei este memorat ntr-un alt fiier, numit fiier obiect. Fiierul obiect va avea, de obicei, acelai nume cu fiierul surs i extensia .obj.

1.3.4.2.2 Linkeditarea Dup ce programul surs a fost translatat n program obiect, el este va fi supus operaiei de linkeditare. Scopul fazei de linkeditare este acela de a obine o form final a programului, n vederea execuiei acestuia. Linkeditorul leag modulele obiect, rezolv referinele ctre funciile externe i rutinele din biblioteci i produce cod executabil,

memorat ntr-un alt fiier, numit fiier executabil (acelai nume, extensia .exe)

Cod executabil *.exe Linkeditor

Cod obiect *.obj

(Preprocesor) Compilator

Cod surs *.c

Figura 1.1 Etapele necesare obinerii fiierului executabil n mod obinuit, la compilare pot apare diferite tipuri de erori cum ar fi: erorile de sintax, pe care le-ai fcut n scrierea programului, i care reprezint o violare a regulilor limbajului de programare (cum ar fi de exemplu utilizarea caracterului "." n locul caracterului ";"). n fiierul surs pot exista de asemenea i erori de tip. O eroare de tip apare atunci cnd

6

Noiuni introductive

7

ncercai s utilizai tipuri diferite, de exemplu tipul caracter n locul unei date de tip numeric.

O eroare de sintax este orice nclcare a regulilor limbajului de programare, iar o eroare de tip apare atunci cnd se utilizeaz un tip de dat n locul altuia.

n timpul compilrii, compilatorul va genera mesaje de eroare i de avertisment i va poziiona cursorul pe ecranul monitorului n poziia din program, n care a fost detectat eroarea. Dac nu nelegei un anumit mesaj de eroare, apsai doar tasta F1 pentru a primi explicaii suplimentare legate de acea eroare. Programul nu poate fi compilat mai departe de punctul n care a fost detectat eroarea pn cnd aceasta nu este corectat. Odat ce eroarea a fost corectat programul trebuie compilat din nou. Dac alte erori sunt depistate ele trebuie corectate, programul recompilat i aa mai departe pn cnd ntregul program este compilat cu succes. Dup ce compilatorul nu mai semnaleaz erori, trebuie editate legturile cu alte rutine care sunt necesare pentru execuia programului. Erorile n faza de editare a legturilor (linkeditare) apar atunci cnd aceste rutine nu pot fi accesate sau nu sunt gsite n directorul indicat.

O eroare la editarea legturilor apare atunci cnd una dintre rutinele accesate nu poate fi localizat de compilator.

1.3.4.3 Rularea programului Odat compilat i editarea legturilor efectuat, trebuie s executai sau s rulai programul. Totui, doar pentru c programul a fost compilat i legturile editate cu succes nu nseamn c va funciona corect n toate condiiile posibile. Erorile obinuite care pot s apar n acest stadiu sunt erori logice i erori de execuie. Aceste tipuri de erori sunt cel mai greu de depistat. O eroare logic apare arunci cnd, de exemplu, o bucl i spune calculatorului s repete o operaie, dar nu i spune cnd s se opreasc. Acest tip de bucl se numete bucl infinit. O astfel de eroare nu va genera un mesaj de eroare, deoarece calculatorul face ceea ce i se spune. O eroare de execuie apare cnd programul ncearc s efectueze o operaie ilegal, n contradicie cu regulile matematice sau ale compilatorului folosit. Dou erori de execuie comune sunt mprirea cu zero i extragerea rdcinii ptrate dintr-o valoare negativ. O eroare obinuit dar de aceast dat impus de compilator, este ncercarea de utilizare a unui numr ntreg mai mare dect posibilitile de reprezentare ale calculatorului. Cele mai multe compilatoare C limiteaz domeniul numerelor ntregi la intervalul [-32768, 32767]. n cazul n care un ntreg depete aceste limite rezultatele nu pot fi anticipate. Uneori, cnd apare o eroare de execuie programul poate fi abandonat automat cu afiarea unui mesaj de eroare corespunztor. Alteori programul pare s funcioneze corect dei datele obinute sunt greite. n aceste situaii s-ar putea s fie necesar consultarea manualelor compilatorului pentru determinarea cu exactitate a naturii erorii. Oricum eroarea trebuie depistat i eliminat naintea unei alte ncercri de executare a programului.

O eroare logic apare atunci cnd compilatorul face ceea ce i se spune, dar nu este ceea ce doreai de fapt. O eroare de execuie apare atunci cnd programul ncearc s efectueze o operaie care nu este n conformitate cu regulile matematice sau cele particulare ale compilatorului folosit

Capitolul 1

8

Un alt tip de erori, din pcate foarte des ntlnite n programele inginereti, se refer la unitile de msur ale mrimilor fizice. Calculele efectuate de ctre programe se efectueaz exclusiv cu numere/valori i nicidecum cu mrimi fizice. De exemplu, dac n calcule considerm viteza unui corp v=5, calculatorul nu va ti dac aceast valoare reprezint m/s sau km/h. Coerena sistemului de uniti de msur pentru mrimile fizice folosite n calcule revine n exclusivitate programatorului, i este bine ca toate mrimile fizice s fie exprimate de la nceput n uniti ale SI: m, kg, s.

1.3.4.4 Utilizarea depanatorului Unul dintre cele mai importante instrumente de programare pe care le avei la dispoziie este depanatorul (debugger). El v permite s examinai ndeaproape modul n care funcioneaz programul dumneavoastr. Mediul C include un depanator integrat care permite execuia pas cu pas a programelor i n acelai timp vizualizarea rezultatelor curente.

1.3.5 Elaborarea documentaiei Unul din ultimii pai al algoritmului programatorului, este foarte adesea trecut cu vederea, dar este un pas toarte important n special cnd programele urmeaz s fie vndute unor utilizatori. Efortul necesar elaborrii documentaiei poate fi uurat dac etapele precedente ale algoritmului programatorului au fost efectuate n mod corespunztor. n aceste condiii documentaia poate fi simpla nregistrare a rezultatelor obinute n etapele anterioare. O bun documentaie trebuie s includ cel puin urmtoarele:

o descriere narativ a definirii problemei care va include tipul de intrare, ieire i prelucrare implicate de program;

algoritmul; un listing al programului comentat. Comentarea unui program este o parte

important din cadrul ntregului proces de elaborare a documentaiei. Fiecare program trebuie s includ comentarii la nceputul acestuia prin care s se precizeze ceea ce face, algoritmii speciali pe care i utilizeaz i un scurt rezumat al definirii problemei. n plus, trebuie incluse numele programatorului, data la care a fost scris programul, sau data ultimei modificri;

exemple de date de intrare i de ieire; rezultatele testrii i depanrii; instruciuni de utilizare.

Documentaia trebuie s fie bine structurat i ntr-o form agreabil. Trebuie s fie uor de neles de dumneavoastr, dar i de ctre oricare alt persoan care ar dori s utilizeze sau s modifice programul n viitor. O ultima remarc: elaborarea documentaiei trebuie s fie un proces n continu desfurare. Ori de cte ori modificai programul trebuie s avei grij ca documentaia s fie actualizat n mod corespunztor.

1.3.6 Exploatarea i ntreinerea Const n activitatea de personalizare (logo-uri, antete, capuri de tabele, etc.) sau modificare a aplicaiei, la cererea beneficiarului sau n urma unor deficiene constatate pe parcursul utilizrii aplicaiei.

1.4 Abstractizare i rafinare

n acest moment, trebuie s introducem un concept foarte important n programare, i anume abstractizarea. Acest concept ne permite s vedem problema n termeni generali, fr s ne de preocupm detalii i n consecin, ofer posibilitatea generalizrii n rezolvarea problemelor.

Noiuni introductive

9

Abstractizarea permite generalizarea n rezolvarea problemelor prin abordarea acestora n termeni generali, fr s in seama de detaliile soluiei

Cnd ncepei s scriei un nou program, pentru nceput trebuie s avei n minte imaginea de ansamblu a problemei. Odat ce ai fcut acest lucru, mai trziu, putei rafina n mod gradat soluia oferind mai multe detalii, pn cnd ajungei la ceea ce v dorii. Procesul de adugare treptat de noi detalii unei soluii generale a unei probleme se numete rafinare incremental.

Rafinarea incremental este procesul de adugare treptat a detaliilor n generarea unei soluii pn n momentul n care ea poate fi codificat cu uurin.

Conceptele de abstractizare i rafinare incremental v permit s controlai problema n spiritul metodei divide ei impera i s o rezolvai ntr-o manier top-down. Aceast strategie s-a dovedit de succes pentru toate tipurile de probleme, n special n programare. n programare generm o soluie sau un algoritm, i n mod gradat l rafinm producnd algoritmi mai detaliai, pn cnd ajungem la un nivel care poate fi codificat cu uurin ntr-un limbaj de programare.

1.5 Limbajul C/C++

1.5.1 Originile limbajului C C a fost inventat i implementat pentru prima oar de ctre Dennis Ritchie pe un sistem DEC PDP-11 care folosea sistemul de operare UNIX [3]. C este rezultatul unui proces de dezvoltare care a nceput cu un limbaj denumit BCPL. BCPL a fost pus la punct de ctre Martin Richards i a stat la baza unui program denumit B, inventat de ctre Ken Thompson. B a dus la dezvoltarea limbajului C, n anii 70. Timp de mult vreme, standardul de facto pentru limbajul C a fost versiunea furnizat mpreun cu varianta 5 a sistemului de operare UNIX. Aceasta a fost descris pentru prima oar n volumul [4]. Odat cu creterea popularitii calculatoarelor personale, au fost create o mulime de implementri ale limbajului C. Printr-o coinciden de domeniul miraculosului, mare parte dintre acestea s-au dovedit de un mare grad de compatibilitate. (Aceasta nseamn c un program scris pentru una din aceste variante putea fi compilat cu succes folosind o alt variant.) Cu toate acestea, din cauza inexistenei unui standard, au existat i neconcordane. Pentru a rezolva aceasta problem, n vara lui 1983 a fost creat o comisie care s stabileasc un standard ANSI (American National Standards Institute) care s defineasc definitiv limbajul C. Standardul ANSI C a fost adoptat, n cele din urm, n decembrie 1989, iar primele copii ale acestuia au devenit accesibile publicului la nceputul lui 1990. n prezent, toate principalele compilatoare de C sunt compatibile cu standardul ANSI C. Acest standard mai conine i informaii privind caracteristicile vechii versiuni de C ncorporat n UNIX. Cu alte cuvinte, indiferent de compilatorul de C folosit sau de mediul n care este folosit acesta, cartea de fa ofer un material cu aplicabilitate imediat. C este adesea denumit limbaj de nivel mediu (middle-level language). Aceasta nu nseamn c C ar fi mai puin puternic, mai dificil de folosit sau mai puin extins dect un limbaj de nivel nalt cum ar fi BASIC sau Pascal, i nici nu implic faptul c C ar fi tot att de dificil ca limbajul de asamblare (i problemele asociate acestuia). C este conceput ca limbaj de nivel mediu ntruct combin cele mai reuite elemente ale limbajelor de nivel

Capitolul 1

10

nalt cu gradul de control i flexibilitatea oferite de ctre limbajul de asamblare. Lista urmtoare prezint modul n care C se ncadreaz n spectrul limbajelor de calculator. Limbaje de nivel nalt: Ada, Modula-2, Pascal, COBOL, FORTRAN, BASIC Limbaje de nivel mediu: C++, C, FORTH Limbaje de nivel sczut: Macro-asamblor, Limbaj de asamblare n calitate de limbaj de nivel mediu, C permite manevrarea biilor, a octeilor i adreselor de memorie, adic a elementelor de baz n funcionarea unui calculator. n ciuda acestui fapt, codul C este de asemenea foarte portabil.

Portabilitatea semnific uurina de a adapta programele scrise pentru o anumit categorie de calculatoare sau sisteme de operare la alte calculatoare sau sisteme de operare.

De exemplu, dac un program scris pentru DOS poate fi convertit cu uurin astfel nct s poat fi rulat sub Windows, acel program este portabil. Toate limbajele de programare de nivel nalt accept conceptul de tipuri de date (data types). Un tip de date definete un set de valori pe care o variabil le poate stoca mpreun cu un set de operaii la care poate fi supus variabila respectiv. Cele mai comune tipuri de date sunt cele ntregi, de tip caracter sau reale. Dei limbajul C include cinci tipuri de date, el nu este un limbaj puternic tipizat, cum sunt Pascal i Ada. C permite aproape toate tipurile de conversii. De exemplu, datele de tip caracter i ntreg se pot substitui reciproc n cadrul unei expresii. Spre deosebire de limbajele de nivel nalt, C nu execut aproape nici o depistare a erorilor n timpul rulrii. De exemplu, limbajul nu verific dac limitele unui tablou sunt depite. Aceste verificri revin n sarcina programatorului. n aceeai ordine de idei, C nu necesit o compatibilitate strict ntre tipul unui parametru i cel al unui argument. Dup cum poate tii, un limbaj de nivel nalt pretinde ca tipul unui argument s fie (mai mult sau mai puin) identic cu tipul parametrului care va primi argumentul. Nu este cazul limbajului C. Acesta permite unui argument s fie de orice tip, dac poate fi convertit convenabil la tipul parametrului. n plus, C asigur toate conversiile automate n acest scop. C se deosebete de alte programe prin aceea c permite manevrarea direct a biilor, a octeilor, a cuvintelor i a pointerilor. Aceasta l face indicat pentru programarea la nivel de sistem, acolo unde aceste operaiuni sunt obinuite. Un alt aspect important al lui C este c dispune de numai 32 de cuvinte-cheie (din care 27 aparin standardului de facto elaborat de Kernighan i Ritchie, iar alte 5 au fost adugate de comisia de standardizare ANSI), care reprezint comenzile care alctuiesc limbajul C. Un limbaj de nivel nalt are, n mod normal, un numr de cuvinte-cheie de cteva ori mai mare. Ca termen de comparaie, gndii-v c majoritatea versiunilor de BASIC au cu mult peste 100 de cuvinte-cheie! C a fost creat, modificat i testat practic de ctre programatori "de meserie". Rezultatul final este acela c limbajul C ofer programatorului exact ceea ce i dorete acesta: restricii puine, mesaje de eroare limitate, structuri de bloc, funcii de sine stttoare i un set compact de cuvinte-cheie. Limbajul C++ (C incrementat) apare la nceputul anilor 80 i l are ca autor pe Bjarne Stroustrup. El este o variant de limbaj C mbuntit, mai riguroas i mai puternic, completat cu construciile necesare aplicrii principiilor programrii orientate pe obiecte (OOP - Object Oriented Programming). Limbajul C++ pstreaz toate elementele limbajului C, beneficiind de eficiena i flexibilitatea acestuia. Limbajul C++ este un

Noiuni introductive

11

superset al limbajului C. Incompatibilitile sunt minore, de aceea, modulele C pot fi ncorporate n proiecte C++ cu un efort minim.

1.6 Structura unui program C sau C++

Un program scris n limbajul C (sau C++) este compus din unul sau mai multe fiiere surs.

Un fiier surs este un fiier text care conine codul surs (n limbajul C) al unui program.

Fiecare fiier surs conine una sau mai multe funcii i eventual, referine ctre unul sau mai multe fiiere header (antet). Funcia principal a unui program este numit main. Execuia programului ncepe cu execuia acestei funcii, care poate apela, la rndul ei, alte funcii. Toate funciile folosite n program trebuie descrise n fiierele surs (cele scrise de ctre programator), n fiiere header (funciile pre-definite, existente n limbaj), sau n biblioteci de funcii.

Un fiier header este un fiier aflat n sistem sau creat de ctre programator, care conine declaraii i definiii de funcii i variabile.

Aciunile din fiecare funcie sunt codificate prin instruciuni. Exist mai multe tipuri de instruciuni, care vor fi discutate n capitolul urmtor.

O instruciune este orice expresie valid (de obicei, o atribuire sau un apel de funcie), urmat de simbolul ";".

Uneori, ca instruciune poate apare instruciunea nul (doar ";"), sau instruciunea compus (privit ca o succesiune de instruciuni simple, ncadrate ntre acoladele delimitatoare {}).

O expresie este o structur corect sintactic, format din operanzi i operatori.

Un program C se salveaz de obicei cu extensia C i implicit compilarea din mediul de programare Borland C se va face cu compilatorul de C. Dac programul este ns salvat cu extensia CPP, atunci compilarea se va face cu compilatorul C++. Un program C obinuit are urmtoarea structur [5] (textul dintre /* i */ reprezint comentarii): /*directive de preprocesare:*/ /*includeri de fiiere sau biblioteci*/ /*definiii de macrocomenzi*/ /*directive de compilare condiionat*/ /*definiii de tipuri de date*/ /*declaraii de variabile globale*/ /*definiii de funcii sau/i descrierea unor functii*/ main() /*antetul funciei principale main*/ { /*nceputul corpului funciei main*/ /*declaraii de variabile locale*/ /*instruciunile funciei principale */ return 0; /*valoarea returnat de funcia main*/ } /*sfritul corpului funciei main*/ /*descrierea funciilor care au definiiile mai sus*/

Capitolul 1

12

Trebuie fcut o precizare nc de la nceput: spre deosebire de alte limbaje cum ar fi Pascal-ul, compilatoarele pentru C i C++ fac distincie ntre litere mari i mici.

1.6.1 Preprocesorul Aa cum am menionat, n faza de compilare a fiierului surs este invocat nti preprocesorul. Acesta trateaz directivele speciale - numite directive preprocesor - pe care le gsete n fiierul surs. Directivele preprocesor sunt identificate prin simbolul #, care trebuie s fie primul caracter, diferit de spaiu, dintr-o linie. Directivele preprocesor sunt utilizate la includerea fiierelor header, la definirea numelor constantelor simbolice, la definirea macro-urilor, sau la realizarea altor funcii (de exemplu, compilarea condiionat.

1.6.1.1 Includeri La nceputul unui program C sau C++ se includ de obicei fiiere antet (cu extensia h), dar se pot include i fiiere cu funcii C sau C++ (cu extensia C sau CPP). Fiierele antet conin definiiile unor funcii a cror implementare se face separat n fiiere cu extensiile C, CPP, obj sau lib. Fiierele *.obj conin cod C sau C++ n forma compilat, iar fiierele *.lib conin biblioteci de funcii C i C++. Cele mai des folosite fiiere antet din C sunt stdio.h (Standard Input/Output) i conio.h (Console Input/Output), care conin definiiile funciilor standard de intrare/ieire (citiri, scrieri), respectiv definiii de funcii consol I/O din DOS (de exemplu funcia clrscr()), care cur ecranul n modul text). O includere ncepe cu semnul # (diez, sharp), urmat de cuvntul include i de numele fiierului care este inclus, care este dat ntre semnele < (mai mic) i > (mai mare), sau ntre ghilimele. Un fiier C sau C++ care se include NU trebuie s conin funcia main()!

1.6.1.2 Macrocomenzi Macrocomenzile simple constau n atribuirea de nume simbolice unor constante. Exemplu: #define TRUE 1 #define FALSE 0 #define N 100 #define PI 3.14159

Tratarea acestor directive preprocesor are ca efect atribuirea valorii ntregi 1 numelui (constantei simbolice) TRUE, i a valorii 0 numelui simbolic FALSE. Ca urmare, naintea compilrii propriu-zise, n programul surs, apariiile numelor TRUE i FALSE vor fi nlocuite cu valorile 1, respectiv 0. N i PI sunt constante obinuite, prima este tipul ntreg, iar a doua este o constant real. Macrocomanda de tip funcie reprezint o generalizare a conceptului de constant, n sensul c putem avea expresii constante, care se nlocuiesc n codul executabil n momentul compilrii. Definirea unei macrocomenzi de tip funcie ncepe cu #define. Dm un exemplu: #define suma(x,y) x+y

Un apel de forma suma(1.7, a) se va nlocui la compilare n codul executabil cu 1.7+a. nlocuirea se face n fiecare loc n care este apelat macrocomanda. De aceea, comportamentul unei macrocomenzi este mai degrab ca cel al unei constante dect ca al unei funcii, dei apelul ei seamn cu cel al unei funcii. Comportamentul macrocomenzilor poate conduce la erori de programare pentru cei care nu i stpnesc modul de funcionare. De exemplu, valoarea expresiei suma(1,2)*5 este

Noiuni introductive

11, i nu 15, deoarece, nlocuirea direct a apelului suma(1,2) la compilare cu 1+2 conduce la expresia 1+2*5, care are valoarea 11, ci nu la expresia (1+2)*5 cu valoarea 15. Frumuseea macrocomenzilor const ns n faptul c nu lucreaz cu tipuri de date prestabilite, astfel n exemplul de mai sus macrocomanda suma va putea fi folosit pentru orice tip de date, atta timp ct ntre valorile x i y se poate aplica operatorul +.

1.6.2 Funcia main n limbajele C i C++ nu exist noiunea de procedur, ci din categoria subprogramelor exist numai funcii. O funcie care are ca tip returnat void (vid) funcioneaz ca o procedur. Dac o funcie nu are parametri, dup nume i se pun paranteze rotunde, adic (). n orice program trebuie s existe o unic funcie main din interiorul creia se ncepe execuia programului. Funcia main poate avea ca tip returnat void sau int. Dac tipul returnat este int, atunci n interiorul funciei main pot aprea instruciuni de forma return val_int; care au ca efect ntreruperea execuiei programului i returnarea ctre sistemul de operare a valori ntregi val_int. Ultima instruciune din funcia main este de obicei return 0;, ceea nseamn c programul s-a terminat cu succes. Dac apare vreo eroare pe parcursul execuiei programului care nu poate fi tratat (memorie insuficient, imposibilitate de deschide a unui fiier etc.), se poate prsi programul cu o instruciune de forma return val_int;, unde val_int este o valoare ntreag nenul. Funcia main poate s nu aib nici un parametru, sau poate avea 2 parametri. Dac funcia main are doi parametri, atunci primul este de tip int, care reprezint numrul de parametrii n linie de comand cu care s-a executat programul, iar al doilea este un vector de iruri de caractere, n care sunt memorai parametrii din linia de comand a programului. Primul ir de caractere din vector (elementul de pe poziia 0) este chiar numele executabilului programului. Dac la execuia programului din interiorul mediului de programare C sunt necesari parametri n linie de comand, atunci acetia se pot completa la Arguments... din meniul Run. Aceti parametri nu vor fi cunoscui n afara mediului de programare. Execuia unui program executabil cu parametri n exteriorul mediului de programare se face ca i orice comand a sistemului de operare:

13

denumire_executabil parametri_desprii_prin_spaii

1.7 Harta zonelor de memorie ale unui program C

Un program C compilat creeaz i folosete patru zone de memorie distincte logic, care ndeplinesc funcii distincte. Prima regiune este aceea care stocheaz codul programului. A doua regiune reprezint zona de memorie n care sunt stocate variabilele globale. Celelalte zone reprezint stiva i zona de manevr. Stiva (stack) este folosit n mai multe scopuri, n timpul executrii programului: memoreaz adresele de revenire ale apelurilor la funcii, argumentele funciilor i variabilele locale. De asemenea, va memora starea curent a unitii centrale de prelucrare. Zona de manevr (heap) este o regiune de memorie liber pe care programul, prin intermediul funciilor de alocare dinamic ale limbajului C, le folosete pentru stocarea unor articole de genul listelor nlnuite i a arborilor.

Figura 1.2 Harta zonelor de memorie

Stiv (stack)

Zon de manevr (heap)

Variabile globale Codul programului

Aspectul exact al programului dvs. poate varia de la un compilator la altul i de la un mediu de programare la altul. De exemplu, majoritatea compilatoarelor de C pentru familia

Capitolul 1

de procesoare 8086 folosesc modaliti diferite de organizare a memoriei, datorit caracterului segmentat al arhitecturii memoriei a procesoarelor familiei 8086. Dei aspectul fizic exact al fiecreia dintre cele patru regiuni de memorie difer n funcie de tipul de CPU i de modul de implementare a limbajului C, Error! Reference source not found. prezint conceptual modul de apariie a programelor C n memoria calculatorului.

1.8 Primele programe

n aceast seciune sunt prezentate i explicate trei programe cu scopul de a asigura un suport de baz pentru prezentrile din capitolele urmtoare. Prin tradiie, primul program C este un mic exemplu dintr-o lucrare devenit clasic - The C programming language, de Brian W Kernigham i Dennis M Ritchie. #include //includerea antetului bibliotecii standard main() //definirea funciei main care nu are argumente { //nceputul corpului funciei main printf("Hello, world\n"); //apelul funciei printf return 0; //ntoarcerea codului de eroare 0 } //sfritul corpului funciei main

Acest program afieaz un mesaj de salut. Prima linie indic faptul c se folosesc funcii de intrare/ieire dintr-o bibliotec. Descrierea modului de utilizare (numele, tipul argumentelor, tipul valorii returnate etc.) a acestora se afl n fiierul cu numele stdio.h. A doua linie declar funcia principal main care va conine instruciunile programului. n acest caz singura instruciune este un apel al funciei printf care afieaz un mesaj la terminal. Mesajul text este dat ntre ghilimele i se termin cu un caracter special new-line ('\n'). Instruciunea return pred controlul sistemului de operare la terminarea programului i comunic acestuia codul 0 pentru terminare. Prin convenie aceast valoare semnific terminarea normal a programului - adic nu au aprut erori n prelucrarea datelor. Corpul funciei main apare ntre acolade. Al doilea program ateapt de la terminal introducerea unor numere ntregi nenule i determin suma lor. n momentul n care se introduce o valoare zero, programul afieaz suma calculat. n cadrul funciei main se declar dou variabile s i n care vor memora valori ntregi. Variabila s (care va pstra suma numerelor introduse) este iniializat cu valoarea 0. n continuare se repet o secven de dou instruciuni, prima fiind o operaie de intrare i a doua o adunare. Primul argument al funciei scanf - formatul de introducere "%d" - indic faptul c se ateapt introducerea unei valori ntregi n format zecimal de la terminal (tastatur). Al doilea argument indic unde se va depune n memorie valoarea citit; de aceea este necesar s se precizeze adresa variabilei n (cu ajutorul operatorului &). n a doua instruciune la valoarea variabilei s se adun valoarea variabilei n. Operatorul += are semnificaia "adun la".

14

#include main() { int s,n; s = 0; do{ scanf("%d",&n); s += n; } while (n!=0); printf("%d\n",s); return 0; }

#include main() { int n,i; double a[100], p; scanf("%d",&n); for(i=0; i

Noiuni introductive

Aceast secven se repet (do) ct timp (while) valoarea introdus (n) este nenul. Operatorul != are semnificaia "diferit de". n final funcia printf afieaz pe terminal valoarea variabilei s n format zecimal. Al treilea program ateapt de la terminal introducerea unei valori naturale n, dup care mai ateapt introducerea a n valori reale (dubl precizie): a0, a1, ..., an1. n continuare se parcurge aceast list i se determin produsul valorilor strict pozitive. n final programul afieaz produsul calculat. n cadrul funciei main se declar dou variabile n i i care vor memora valori ntregi. Se declar de asemenea un tablou unidimensional a care va memora 100 de valori de tip real (dubl precizie), i o variabil p care va memora produsul cerut. Variabila n pstreaz numrul de valori reale din lista a. Se citete de la terminal o valoare n. n continuare se introduc valorile reale ai (i = 0, 1, ..., n - 1). Formatul de introducere "%lf" indic faptul c se ateapt introducerea unei valori reale de la terminal, care va fi depus la locaia de memorie asociat variabilei ai. n locul construciei &a[i] se poate folosi forma echivalent a+i. Pentru a introduce toate valorile ai se efectueaz un ciclu for, n cadrul cruia variabila i (care controleaz ciclul) ia toate valorile ntre 0 (inclusiv) i n (exclusiv) cu pasul 1. Trecerea la urmtoarea valoare a variabilei i se face cu ajutorul operatorului ++. n continuare variabila p, care va memora produsul valorilor cerute, se iniializeaz cu 1. Fiecare valoare ai este verificat (instruciunea if) dac este strict pozitiv i n caz afirmativ este nmulit cu valoarea p. Operatorul *= are semnificaia "nmulete cu". Cu sperana c aceste cteva exemple au deschis apetitul cititorului pentru programare, vom trece n continuare la explicarea n detaliu a principalelor elemente ale limbajului de programare C/C++.

15

Capitolul 2

16

2. Date, operatori i expresii

2.1 Vocabularul

n scrierea programelor n limbajul C/C++ pot fi folosite doar anumite simboluri care alctuiesc alfabetul limbajului. Acesta cuprinde: Literele mari sau mici de la A la Z (a-z); Caracterul de subliniere ( _ underscore), folosit, de obicei, ca element de legtur ntre

cuvintele compuse; Cifrele zecimale (0-9); Simboluri speciale (Blanc ! " # % & ' ( ) * + , . / : ; < = > ? [ \ ] ^ _ ~ { | }). Acestea pot fi:

o Caractere: operatori (Exemple: +, *, !=); delimitatori (Exemple: blank (spaiu), tab \t, newline \n, cu rolul de a separa cuvintele);

o Grupuri (perechi de caractere). Grupurile de caractere, numire adesea separatori, pot fi: ( ) - ncadreaz lista de argumente ale unei funcii sau sunt folosite n expresii pentru schimbarea ordinii de efectuare a operaiilor (n ultimul caz, fiind operator); { } - ncadreaz instruciunile compuse; // - Indic nceputul unui comentariu care se poate ntinde pn la sfritul liniei; /* */ - Indic nceputul i sfritul unui comentariu care poate cuprinde mai multe linii; " " - ncadreaz o constant ir (un ir de caractere); ' ' - ncadreaz o constant caracter (un caracter imprimabil sau o secven escape). [ ] - ncadreaz dimensiunile tablourilor sau indicii elementelor acestora

2.2 Unitile lexicale ale limbajului C

Unitile lexicale (cuvintele) limbajului C reprezint grupuri de caractere cu o semnificaie de sine stttoare; exist ase tipuri de uniti lexicale i anume: identificatori, cuvinte-cheie, constante, iruri, operatori i separatori.

2.2.1 Identificatori

Identificatorii reprezint numele unor date (constante sau variabile), sau ale unor funcii.

Identificatorul este format dintr-un ir de litere (mari sau mici), cifre sau caracterul de subliniere (underscore), fr spaii ntre ele, trebuie s nceap cu o liter sau cu caracterul de subliniere i s fie sugestivi. Exemple: viteza, greutate_neta, Viteza, Viteza1, GreutateNeta Identificatorii pot conine litere mici sau mari, dar limbajul C este senzitiv la majuscule i minuscule (case-sensitive). Astfel, identificatorii viteza i Viteza sunt diferii. Nu pot fi

Date, operatori i expresii

17

folosii ca identificatori cuvintele cheie. Identificatorii pot fi standard (ca de exemplu numele unor funcii predefinite: scanf, clear, etc.) sau alei de utilizator.

2.2.2 Cuvinte cheie

Cuvintele cheie sunt identificatori rezervai ai limbajului crora programatorul nu le poate da o alt utilizare.

Un cuvnt-cheie dintr-un program scris n C are o semnificaie bine determinat i nu poate fi folosit pentru alte scopuri, n sensul c nu poate fi folosit ca variabil sau ca nume de funcie. Tabelul 2.1 ofer lista celor 32 de cuvinte-cheie, care, combinate cu sintaxa formal a limbajului, formeaz limbajul de programare C. Dintre acestea, 27 au fost definite nc de la varianta original de C. Urmtoarele cinci au fost adugate de comisia de standardizare ANSI C: enum, const, signed, void i volatile.

Tabelul 2.1 Cuvintele-cheie ale limbajului C auto double int struct break else long switch case enum register typedef char extern return union const float short unsigned continue for signed void default goto sizeof volatile do if static while

Suplimentar, multe compilatoare de C au mai adugat i alte cuvinte-cheie, care contribuie la o exploatare superioar a mediului de operare al acestora. De exemplu, multe compilatoare includ cuvinte-cheie pentru administrarea structuri de memorie a familiei de procesoare 8086, pentru facilitarea programrii inter-limbaje i pentru accesarea ntreruperilor. Iat o list a celor mai des folosite cuvinte-cheie extinse:

asm _cs ds _es _ss edeel far huge interrupt near pascal

E posibil ca i compilatorul dvs. s accepte alte extensii care s permit utilizarea la maximum a mediului su specific de lucru. Toate cuvintele-cheie folosite de limbajul C se scriu obligatoriu cu litere mici. n C, majusculele sunt diferite de literele mici; de exemplu, else este un cuvnt-cheie timp ce ELSE nu este.

2.2.3 Operaii de intrare/ieire Limbajele C/C++ nu posed instruciuni de intrare/ieire, deci de citire/scriere (ca limbajul PASCAL, de exemplu). n limbajul C aceste operaii se realizeaz cu ajutorul unor funcii (de exemplu, printf i scanf - descrise detaliat n Capitolul 11.1.1), iar n limbajul C++ prin suprancrcarea operatorilor (definirea unor noi proprieti ale unor operatori existeni, fr ca proprietile anterioare s dispar), mai precis a operatorilor >> i > pentru intrare i operatorul

Capitolul 2

18

determin deschiderea unui canal de comunicaie a datelor ctre dispozitivul respectiv. Dup operator se specific informaiile care vor fi citite sau afiate. Exemple: coutvar; /* citete valoarea variabilei var de la tastatur */

Sunt posibile operaii multiple, de tipul: Exemple:cout > var2 >> var3;

n acest caz, se efectueaz succesiv, de la stnga la dreapta, scrierea, respectiv citirea valorilor variabilelor var1, var2 i var3. Operatorul >> se numete operator extractor (extrage valori din fluxul datelor de intrare, conform tipului acestora), iar operatorul >) pot fi doar nume de variabile. Operanzii operatorului insertor (a>>b>>e>>d; //citirea valorilor variabilelor a, b, e, d de tip int, int, int, double cout

Date, operatori i expresii

19

2.3.2 Tipuri de date Tipul unei date const ntr-o mulime de valori pentru care s-a adoptat un anumit mod de reprezentare n memoria calculatorului i o mulime de operatori care pot fi aplicai acestor valori. Tipul unei date determin lungimea zonei de memorie ocupat de acea dat. n general, lungimea zonei de memorare este dependent de calculatorul pe care s-a implementat compilatorul. Tabelul 2.2. prezint lungimea zonei de memorie ocupat de fiecare tip de dat pentru compilatoarele sub MS-DOS i UNIX/LINUX. Tipurile de baz sunt: void vid, care fie declar o funcie care nu returneaz nici o valoare, fie creeaz

pointeri generici char un singur octet (1 octet/byte = 8 bii), capabil s conin codul unui caracter

din setul local de caractere; int numr ntreg, reflect n mod tipic mrimea natural din calculatorul utilizat; float numr real n virgul mobil, simpl precizie; double numr real n virgul mobil, dubl precizie.

2.3.2.1 Modificarea tipurilor de baz n afar de tipul void, tipurile fundamentale de date pot fi precedate de diveri modificatori. Un modificator se utilizeaz pentru a schimba sensul tipului de baz n vederea unei adaptri mai precise la anumite situaii. lat lista modificatorilor:

signed unsigned long short Modificatorii signed, short, long i unsigned pot fi aplicai tipurilor de baz caracter i ntreg. Totui, modificatorul long poate fi aplicat i tipului de date double. Tabelul 2.2 prezint toate combinaiile de tipuri de date care ader la standardul ANSI C, precum i domeniile minimale de valori i dimensiunile aproximative n bii.

Tabelul 2.2 Tipurile de date care ader la standardul ANSI C, dimensiunile aproximative n bii i domeniile minimale de valori

Tip Dimens aprox n bii

Domeniu minimal de valori

char 8 de la -127 la 127 unsigned char 8 de la 0 la 255 signed char 8 de la -127 la 127 int 16 de la -32767 la 32767 unsigned int 16 de la 0 la 65535 signed int 16 Similar cu int short int 16 Similar cu int unsigned short int 16 de la 0 la 65535 signed short int 16 Similar cu short int long int 32 de la -2.147.483.647 la 2.147.483.647 signed long int 32 Similar cu long int unsigned long int 32 de la 0 la 4.294.967.295 float 32 6 zecimale exacte double 64 10 zecimale exacte long double 80 10 zecimale exacte

Utilizarea modificatorului signed pentru variabile de tip ntreg este permis, dar este inutil, deoarece declaraia implicit de ntreg presupune un numr cu semn (signed). Cea mai important utilizare a acestui modificator este de a modifica datele de tip char n variantele de implementare n care char este considerat implicit ca neavnd semn. Unele variante de implementare permit aplicarea lui unsigned tipurilor de date n virgul mobil (ca n unsigned double). Acest procedeu reduce ns portabilitatea codului

Capitolul 2

20

surs i n general nu este recomandat. Tipurile de date suplimentare sau extinse care nu au fost definite de ctre standardul ANSI C nu vor fi probabil recunoscute pe orice variant de implementare a programului C. S considerm, de exemplu, tipul int, folosit pentru date ntregi (pozitive sau negative). Evident c mulimea valorilor pentru acest tip va fi, de fapt, o submulime finit de numere ntregi. Dac pentru memorarea unei date de tip int se folosesc 2 octei de memorie, atunci valoarea maxim pentru aceasta va fi 12x2

16- 1, deci 215- 1 (32767), iar valoarea

minim va fi -12x216, deci -215 (-32768). ncercarea de a calcula o expresie de tip int a

crei valoare se situeaz n afara acestui domeniu va conduce la o eroare de execuie. Mulimea valorilor pentru o dat de tip unsigned int (ntreg fr semn) va fi format din numerele ntregi situate n intervalul [0, 216- 1]. Diferena ntre ntregii cu semn (signed) i cei fr semn (unsigned) rezid n modul n care este interpretat bitul de cel mai mare ordin al ntregului. Dac precizai un ntreg cu semn, compilatorul de C va genera un cod care presupune faptul c bitul de cel mai mare ordin al ntregului va fi folosit ca indicator de semn (sign flag). Dac acesta are valoarea 0, numrul este pozitiv; n caz contrar, numrul este negativ. n gene

Curs C

Documents

Transcript of Curs C