UNIVERSITATEA DUNREA DE JOS GALAI FACULTATEA DE ECONOMIE I ADMINISTRAREA AFACERILOR

Adrian Lupac

PROGRAMAREA CALCULATOARELOR

ISBN 978-606-8216-24-9

Editura EUROPLUS Galai, 2010

CUPRINS1. Noiuni de baz n programarea calculatoarelor........................................................................... 4Stabilirea corectitudinii i eficienei soluionrii problemei de rezolvat ....................................................................5 Algoritmul ..................................................................................................................................................................6 Descrierea algoritmilor ...............................................................................................................................................7 Programul .................................................................................................................................................................10

2. Introducere n limbajul C noiuni de baz ................................................................................ 12Tipuri de date de baz...............................................................................................................................................14

Constante i variabile n limbajul C ..........................................................................................................17Preluarea datelor de la tastatur................................................................................................................................20

3. Operatori aritmetici ....................................................................................................................... 21Operatori de incrementare i decrementare ..............................................................................................................21 Operatori relaionali i operatorii logici ...................................................................................................................23 Conversii n C...........................................................................................................................................................23 Operatorul cast .........................................................................................................................................................25

4. Instruciuni de control ale programului....................................................................................... 26Instruciunea vid i instruciunea expresie .............................................................................................26 Instruciunea if ............................................................................................................................................27 Instruciunea switch....................................................................................................................................31

5. Instruciuni repetitive .................................................................................................................... 33Instruciunea for .........................................................................................................................................33

6. Instruciuni repetitive .................................................................................................................... 37Instruciunea while .....................................................................................................................................37 Instruciunea do-while................................................................................................................................39 Instruciunea break i instruciunea continue..........................................................................................39

7. Funcii de intrare/ieire standard ................................................................................................. 41Funciile getch() i getche()......................................................................................................................................41 Funcia printf() .........................................................................................................................................................41 Funcia scanf() ..........................................................................................................................................................45

8. Funcii n C.................................................................................................................................... 47Definirea unei funcii................................................................................................................................................47 Prototipul funciilor ..................................................................................................................................................48 Apelul funciilor .......................................................................................................................................................49 Variabile locale i variabile globale .........................................................................................................................50

9. Structuri n limbajul C .................................................................................................................. 57 10. Preprocesare. Directive preprocesor........................................................................................... 60Directiva preprocesor #define....................................................................................................................60

11. Fiiere n C .................................................................................................................................. 63STREAM-ul.................................................................................................................................................63 Bazele fiierelor ...........................................................................................................................................64

2

Funciile feof() i ferror()............................................................................................................................69

12. Funcii text de nivel nalt ............................................................................................................ 72Citirea i scrierea datelor binare ...............................................................................................................74 Accesul random...........................................................................................................................................77

3

1. Noiuni de baz n programarea calculatoarelorProgramarea este o component a informaticii care are ca principal obiectiv realizarea de programe care s constituie soluiile oferite cu ajutorul calculatorului unor probleme date. Programatorii sunt acele persoane apte s implementeze ntr-un limbaj de programare algoritmul propus ca soluie la respectiva problem, ce se preteaz a fi rezolvat cu ajutorul unui sistem de calcul. Dup nivelul de implicare n efortul de rezolvare a problemelor specialitii n programare pot fi mprii n mai multe categorii: analiti, analiti-programatori, ingineri-programatori, programatori amatori, etc. Cu toii au ns n comun faptul c fiecare trebuie s cunoasc sintaxa i semantica unui limbal de programare i s fie capabil, nu doar s citeasc, ci chiar s scrie codul surs, adic programul propriu-zis. Din acest punct de vedere cunotinele de programare sunt considerate ABC-ul informaticii i sunt indispensabile oricrui profesionist n domeniu i nu numai. Pentru a putea fi rezolvat cu ajutorul unui sistem de calcul, fiecare problem va trebui s treac prin trei etape obligatorii: analiza problemei, proiectarea algoritmului de soluionare i implementarea algoritmului ntr-un program pe calculator. n ultima etap, sub acelai nume, au fost incluse n plus dou subetape cunoscute sub numele de testarea i ntreinerea programului. Aceste subetape nu lipsesc din ciclul de via a oricrui produs-program. Dac etapa implementrii algoritmului ntr-un program executabil este o etap exclusiv practic, realizat n faa calculatorului, celelalte dou etape au un pronunat caracter teoretic. n consecin, primele dou etape sunt caracterizate de un anumit grad de abstractizare. Din punct de vedere practic ns, i n ultim instan, criteriul decisiv ce confer succesul rezolvrii problemei este dat de calitatea implementrii propriu-zise. Mai exact, succesul soluionrii este dat de performanele programului: utilitate, vitez de execuie, fiabilitate, posibiliti de dezvoltare ulterioare, lizibilitate, etc. Cu toate acestea este imatur i neprofesional strategia programatorilor nceptori care, neglijnd primele dou etape, sar direct la a treia, evitnd etapa de analiz i componenta abstract a efortului de soluionare. Ei se justific cu toii prin expresii puerile de genul: Eu nu vreau s mai pierd vremea cu teoria, am s fac programul cum tiu eu. Ct vreme nu va face altcineva altul mai bun dect al meu, nu am de ce s-mi mai bat capul!.

4

Stabilirea corectitudinii i eficienei soluionrii problemei de rezolvat Este adevrat c etapa care vizeaz implementarea unei probleme este fundamental, dar primele dou etape au o importan capital. Ele sunt singurele ce pot oferi rspunsuri corecte la urmtoarele ntrebri dificile: Exist certitudinea c soluia gsit este i cea corect? Exist certitudinea c problema este rezolvat complet? Ct de eficient este soluia gsit? Ct de aproape este soluia aleas de cea optim? S menionm n plus c literatura de specialitate conine un numr impresionant de probleme capcan pentru nceptori, i nu numai pentru ei. Ele provin majoritatea din realitatea imediat dar pentru fiecare dintre ele nu se cunosc soluii eficiente. De exemplu, este dovedit teoretic c problema, aparent banal pentru un calculator, a proiectrii Orarului optim ntr-o instituie de nvmnt (facultate sau liceu) este o problem intratabil la ora actual (toate programele care s-au realizat pn acum nu ofer dect soluii aproximative fr a putea spune ct de aproape sau de departe este soluia optim de orar). Ci dintre programatorii nceptori n-ar fi surprini s afle c problema att de simpl (ca enun), a crei soluionare tocmai au abandonat-o, este de fapt o problem dovedit teoretic ca fiind intratabil sau chiar insolvabil algoritmic? Partea proast a lucrurilor este c problemele netratabile pot fi cu uurin confundate cu unele uoare la o privire rapid i lipsit de experien. Etapa de analiz este singura care permite dovedirea cu argumente riguroase a corectitudinii soluiei, iar etapa de proiectare este singura care poate oferi argumente precise n favoarea eficienei soluiei propuse. n general problemele concrete din informatic au n forma lor iniial sau n enun o caracteristic pragmatic, fiind foarte ancorate n realitatea imediat. Totui ele conin n formularea lor iniial un grad mare de eterogenitate, diversitate i lips de rigoare. Fiecare dintre aceste defecte este un obstacol major pentru demonstrarea corectitudinii soluiei. Rolul esenial al etapei de analiz este acela de a transfera problema ntr-un plan abstract, adic de a o modela. Acest univers paralel abstract este dotat cu mai mult rigoare i disciplin intern, avnd legi precise, i poate oferi instrumentele logice i formale necesare pentru demonstrarea riguroas a corectitudinii soluiei problemei. Planul abstract n care sunt transportate toate problemele de informatic este planul sau universul obiectelor matematice iar corespondentul problemei n acest plan va fi modelul matematic abstract asociat problemei. Demonstrarea corectitudinii proprietilor ce leag obiectele universului matematic a fost i este sarcina matematicienilor. Celui ce analizeaz problema din punct de vedere informatic i revine sarcina (nu tocmai uoar) de a dovedi printr-o demonstraie 5

constructiv c exist o coresponden precis ntre prile componente ale problemei reale, dezasamblat n timpul analizei, i prile componente ale modelului abstract asociat. Odat descoperit, formulat precis i dovedit, aceast perfect oglindire a problemei reale n planul obiectelor matematice ofer certitudinea c toate proprietile i legturile ce exist ntre subansamblele modelului abstract se vor regsii precis (prin reflectare) ntre prile interne ale problemei reale, i invers. Atunci, soluiei abstracte descoperite cu ajutorul modelului matematic abstract i va corespunde o soluie real concretizat printr-un algoritm ce poate fi implementat ntrun program executabil. Ideea central a etapei a doua proiectarea unui algoritm de soluionare eficient poate fi formulat astfel: din studiul proprietilor i limitelor modelului matematic abstract asociat problemei se deduc limitele inferioare ale complexitii minimale (efortului minimal obligatoriu) inerente oricrui algoritm ce va soluiona problema n cauz. Complexitatea intern a modelului abstract i complexitatea soluiei abstracte se va reflecta imediat asupra complexitii reale a algoritmului, adic asupra eficienei de soluionare a problemei. Acest fapt permite prognosticarea nc din aceast faz faza de proiectare a algoritmului de soluionare a eficienei practice, msurabil ca durat de execuie, a programului. Algoritmul Se tie c la baza oricrui program st un algoritm (care, uneori, este numit metod de rezolvare). Noiunea de algoritm este o noiune fundamental n informatic i nelegerea ei, alturi de nelegerea modului de funcionare a unui calculator, permite nelegerea noiunii de program executabil. Vom oferi n continuare o definiie unanim acceptat pentru noiunea de algoritm:Definiie. Prin algoritm se nelege o mulime finit de operaii (instruciuni) elementare care executate ntr-o ordine bine stabilit (determinat), pornind de la un set de date de intrare dintr-un domeniu de valori posibile (valide), produce n timp finit un set de date de ieire (rezultate).

Cele trei caracteristici eseniale ale unui algoritm sunt: Determinismul dat de faptul c ordinea de execuie a instruciunilor algoritmului este bine precizat (strict determinat). Acest fapt d una din calitile de baz a calculatorului: el va face ntotdeauna ceea ce i s-a cerut (prin program) s fac, el nu va avea iniiative sau opiuni proprii, el nu-i permite s greeasc nici mcar odat, el nu se va plictisi ci va duce programul la acelai sfrit indiferent de cte ori i se va cere s repete acest lucru. Nu aceeai situaie se ntmpl cu fiinele umane (Errare humanum est). Oamenii pot avea n situaii 6

determinate un comportament non-deterministic (surprinztor). Acesta este motivul pentru care numeroi utilizatori de calculatoare (de exemplu contabilii), datorit fenomenului de personificare a calculatorului (confundarea aciunilor i dialogului simulat de programul ce ruleaz pe calculator cu reaciile unei personaliti vii), nu recunosc perfectul determinism ce st la baza executrii oricrui program pe calculator. Universalitatea dat de faptul c, privind algoritmul ca pe o metod automat (mecanic) de rezolvare, aceast metod are un caracter general-universal. Algoritmul nu ofer o soluie punctual, pentru un singur set de date de intrare, ci ofer soluie pentru o mulime foarte larg (de cele mai multe ori infinit) de date de intrare valide. Aceasta este trstura de baz care explic deosebita utilitate a calculatoarelor i datorit acestei trsturi suntem siguri c investiia financiar fcut prin cumprarea unui calculator i a produsului software necesar va putea fi cu siguran amortizat. Cheltuiala se face o singur dat n timp ce programul pe calculator va putea fi executat rapid i economicos de un numr orict de mare de ori, pe date diferite! De exemplu, algoritmul de rezolvare nvat la liceu a ecuaiilor de gradul doi: ax2+bx+c=0, se aplic cu succes pentru o mulime infinit de date de intrare: (a,b,c)\{0}xx. Finitudinea pentru fiecare intrare valid orice algoritm trebuie s conduc n timp finit (dup un numr finit de pai) la un rezultat. Aceast caracteristic este analog proprietii de convergen a unor metode din matematic: trebuie s avem garania, dinainte de a aplica metoda (algoritmul), c metoda se termin cu succes (ea converge ctre soluie). S observm i diferena: n timp ce metoda matematic este corect chiar dac ea converge ctre soluie doar la infinit (!), un algoritm trebuie s ntoarc rezultatul dup un numr finit de pai. S observm de asemenea c, acolo unde matematica nu ofer dovada, algoritmul nu va fi capabil s o ofere nici el. De exemplu, nu este greu de scris un algoritm care s verifice corectitudinea afirmaiei Conjecturii lui Goldbach: Orice numr par se scrie ca sum de dou numere prime, dar, dei programul rezultat poate fi lsat s ruleze pn la valori extrem de mari, fr s apar nici un contra-exemplu, totui conjectura nu poate fi astfel infirmat (dar nici afirmat!). Descrierea algoritmilor Dou dintre metodele clasice de descriere a algoritmilor sunt Schemele logice i PseudoCodul. Ambele metode de descriere conin doar patru operaii (instruciuni) elementare care au fiecare un corespondent att schem logic ct i n pseudo-cod. 7

n cele ce urmeaz vom descrie doar varianta oferit de pseudo-cod deoarece folosirea schemelor logice s-a redus drastic n ultimii ani. Schemele logice mai pot fi ntlnite sub numele de diagrame de proces n anumite cri de specialitate inginereti. Avantajul descrierii algoritmilor prin scheme logice este dat de libertatea total de nlnuire a operaiilor (practic, sgeata care descrie ordinea de execuie, pleac de la o operaie i poate fi trasat nspre orice alt operaie). Este demonstrat matematic riguros c descrierea prin pseudo-cod, dei pare mult mai restrictiv (operaiile nu pot fi nlnuite oricum, ci trebuie executate n ordinea citirii: de sus n jos i de la stnga la dreapta), este totui perfect echivalent. Deci, este dovedit c plusul de ordine, rigoare i simplitate pe care l ofer descrierea prin pseudo-cod nu ngrdete prin nimic libertatea programrii. Totui, programele scrise n limbajele de asamblare, care sunt mult mai compacte i au dimensiunile mult reduse, nu ar putea fi descrise altfel dect prin scheme logice. 1. Atribuirea var:=expresie; 2. Intrare/Ieire Citete var1, var2, var3, ; Scrie var1, var2, var3, ; sau Scrie expresia1, expresia2, expresia3,; 3. Condiionala Dac atunci instruciune1 [altfel instruciune2]; 4. Ciclurile Exist (din motive de uurin a descrierii algoritmilor) trei tipuri de instruciuni de ciclare. Ele sunt echivalente ntre ele, oricare variant de descriere putnd fi folosit n locul celorlalte dou, cu modificri sau adugiri minimale: repet instruciune1, instruciune2, pn cnd ; ct timp execut instruciune; pentru var_contor:=val_iniial pn la val_final execut instruciune; n cazul ciclurilor, grupul instruciunilor ce se repet se numete corpul ciclului iar condiia logic care permite sau nu reluarea execuiei ciclului este denumit condiia de ciclare. Observm c ciclul de tipul Repet are condiia de repetare la sfrit ceea ce are ca i consecin faptul c, corpul ciclului se execut cel puin odat, n mod obligatoriu, nainte de verificarea condiiei logice. Nu acelai lucru se ntmpl n cazul ciclului de tipul ct timp, cnd este posibil ca instruciunea compus din corpul ciclului s nu poat fi executat nici mcar odat. n plus, s mai observm c

8

ciclul de tipul Pentru pn la conine (n mod ascuns) o instruciune de incrementare a variabilei contor. Limbajele de programare care sunt relativ apropiate de limbajele naturale sunt denumite limbaje de nivel nalt (high-level), de exemplu limbajul Pascal, spre deosebire de limbajele de programare mai apropiate de codurile numerice ale instruciunilor microprocesorului. Acestea din urm se numesc limbaje de nivel sczut (low-level), de exemplu limbajul de asamblare. Limbajul de programare C are un statut mai special el putnd fi privit, datorit structurii sale, ca fcnd parte din ambele categorii. Peste tot unde n pseudo-cod apare cuvntul instruciune el poate fi nlocuit cu oricare din cele patru instruciuni elementare. Aceast substituire poart numele de imbricare. Prin instruciune se va nelege atunci, fie o singur instruciune simpl (una din cele patru), fie o instruciune compus. Instruciunea compus este format dintr-un grup de instruciuni delimitate i grupate n mod precis (ntre acolade { } n C). Spre deosebire de pseudo-cod care permite doar structurile noi formate prin imbricarea repetat a celor patru instruciuni n modul precizat, schemele logice permit structurarea n orice succesiune a celor patru instruciuni elementare, ordinea lor de execuie fiind dat de sensul sgeilor. Repetm c dei, aparent, pseudo-codul limiteaz libertatea de descriere doar la structurile prezentate, o teorem fundamental pentru programare afirm c puterea de descriere a pseudolimbajului este aceeai cu cea a schemelor logice. Forma de programare care se bazeaz doar pe cele patru structuri se numete programare structurat (spre deosebire de programarea nestructurat bazat pe descrierea prin scheme logice). Teorema de echivalen a puterii de descriere prin pseudo-cod cu puterea de descriere prin schem logic afirm c programarea structurat (aparent limitat de cele patru structuri) este echivalent cu programarea nestructurat (liber de structuri impuse). Evident, prin ordinea, lizibilitatea i fiabilitatea oferit de cele patru structuri elementare (i asta fr a ngrdi libertatea de exprimare) programarea structurat este net avantajoas. n fapt, limbajele de programare nestructurat (Fortran, Basic) au fost de mult scoase din uz, ele (limbajele de asamblare) sunt necesare a fi folosite n continuare doar n programarea de sistem i n programarea industrial (n automatizri).

9

Programul Prin program se nelege un ir de instruciuni-main care sunt rezultatul compilrii algoritmului proiectat spre rezolvarea problemei dorite ce a fost descris ntr-un limbaj de programare (ca i cod surs). Etapele realizrii unui program sunt: editarea codului surs, etap ce se realizeaz cu ajutorul unui program editor de texte rezultatul fiind un fiier C, cu extensia .c (.cpp); compilarea, etapa de traducere din limbajul de programare C n limbajul intern al microprocesorului, i este realizat cu ajutorul programului compilator C i are ca rezultat un fiier obiect, cu extensia .obj (n limbajul C) sau .exe (n limbajul Pascal); link-editarea, etap la care se adaug modului obiect rezultat la compilare diferite module coninnd subprograme i rutine de bibliotec, rezultnd un fiier executabil (aceast etap este comasat n Turbo Pascal sau Borland Pascal cu etapa de compilare), cu extensia .exe execuia (Run), etapa de lansare n execuie propriu-zis a programului obinut, lansare realizat de interpretorul de comenzi al sistemului de operare (command.com pentru sistemele DOS+Windows) Observm c aceste etape sunt complet independente n timp unele de altele i necesit pentru limbajul C utilizarea a patru programe ajuttoare: editor de texte, compilator C, link-editor i interpretorul de comenzi al sistemului de operare. n cazul mediilor de programare integrate (Borland) comandarea acestor patru programe ajuttoare precum i depanarea erorilor de execuie este mult facilitat. OBSERVAIE: Link-editarea reprezint asamblarea unor module precompilate pentru a rezulta un fiier executabil. De exemplu, dac avem mai multe module de program (s zicem diverse funcii) le putem compila pe fiecare n mod separat i n felul acesta putem observa i erorile mai uor iar la sfrit le linkeditm i va rezulta programul. Fiierele precompilate (pe care le vom link-edita) au avantajul c se pot folosi la diferite proiecte pstrnd de exemplu o oarecare paternitate asupra lor, va fi foarte dificil ca cineva s obin codul surs i s-l poat modifica fr s depun un efort considerabil. Deci va putea utiliza funciile dar e destul de dificil s modifici sau s copiezi ntr-un program personal doar cteva din aceste funcii. E mai uoar i depanarea programului pe module. De asemenea, merit subliniat faptul c n timp ce fiierul text C, ce conine codul surs, poate fi transportat pe orice main (calculator) indiferent de micro-procesorul acesteia urmnd a fi compilat la faa locului, n cazul fiierului obiect acesta nu mai poate fi folosit dect pe maina 10

(calculatorul) pentru care a fost creat (datorit instruciunilor specifice micro-procesorului din care este compus). Deci, pe calculatoare diferite (avnd micro-procesoare diferite) vom avea nevoie de compilatoare C diferite. n plus, s remarcm faptul c fiierele obiect rezultate n urma compilrii pot fi link-editate mpreun, chiar dac provin din limbaje de programare diferite. Astfel, un program rezultat (un fiier .exe sau .com) poate fi compus din module obiect care provin din surse diferite (fiiere Pascal, C, asamblare, etc.).

11

2. Introducere n limbajul C noiuni de bazToate elementele care compun un limbaj de programare, aa cum este i limbajul C nu sunt de sine stttoare, ci n conjuncie unul cu cellalt. Din acest motiv este important s fie nelese aspectele fundamentale ale limbajului, nainte ca ele s fie detaliate. Toate aplicaiile realizate prin intermediul limbajului C au anumite trsturi comune. Programele conin cel puin o funcie, fiecare incluznd una sau mai multe instruciuni. O funcie poate fi definit ca fiind o subrutin care poate fi apelat de diferite pri ale unei aplicaii. O instruciune se refer la o aciune care trebuie s fie executat de un program. Toate instruciunile scrise ntr-un program trebuie s aparin unei funcii i se termin obligatoriu cu caracterul ;. Cea mai simpl form a unei funcii este urmtoarea:nume_funcie() { instruciuni; }

unde nume_funcie reprezint numele unei funcii, iar instruciuni reprezint secvena de instruciuni (una sau mai multe) care aparine funciei declarate. n ceea ce privete numele funciei (i nu numai) trebuie spus c limbajul C este de tip CASE-SENSITIVE, ceea ce presupune ca programatorul s aib n vedere faptul c, compilatorul C face deosebire ntre litere mari i litere mici. Orice program n limbajul C conine cel puin o funcie: funcia main(). Execuia fiecrui program ncepe cu funcia main(), ceea ce nseamn c dac programatorul omite scrierea acestei funcii, compilatorul va fi n imposibilitatea compilrii programului editat. Astfel, atunci cnd se execut un program, primele instruciuni executate sunt cele care fac parte din funcia main. Dac programul conine mai multe funcii, numele acestora va fi definit de utilizator. Toate programele scrise n limbajul C sunt memorate ntr-un fiier sau mai multe, acestea avnd extensia .c. Un fiier care conine un program scris n C sau care conine numai o parte a acestuia se numete fiier surs. Prin compilarea fiierului surs rezult un fiier obiect, care are extensia .obj. Fiierele surs care intr n compunerea unui program pot fi compilate mpreun sau separat. n urma unei compilri rezult un fiier obiect; fiierele obiect aferente aplicaiei pot fi reunite ntr-un program executabil prin link-editare. n urma link-editrii rezult un fiier executabil, cu extensia .exe. 12

Un nume este o succesiune de litere i eventual cifre, primul caracter fiind liter. Pot fi utilizate litere mici i litere mari precum i caracterul subliniere (_). Exist un numr de cuvinte mprumutate din limba englez care au o semnificaie predefinit. Utilizatorul nu poate da o alt utilizare acestora i de aceea se mai numesc cuvinte cheie. Acestea se scriu mereu cu litere mici i reprezint nume cu destinaii speciale (for, if, while, break, exit, etc.). Atomi lexicali Ca i alte limbaje, C are un alfabet i reguli pentru scrierea programelor corecte folosind semne de punctuaie. Aceste reguli formeaz sintaxa limbajului C. Compilatorul C are rolul de a testa dac un program editat este corect. Dac sunt erori, atunci va afia o list de mesaje de eroare i se va opri. Iniial, compilatorul mparte mulimea caracterelor (programul surs) n atomi lexicali, care reprezint vocabularul de baz al limbajului. n ANSI C (ANSI = American National Standards Institute) sunt ase tipuri de atomi lexicali (care se mai numesc i elemente lexicale sau uniti lexicale): cuvinte rezervate; identificatori; constante; iruri constante; operatori; semne de punctuaie. Caractere i atomi lexicali Un program C este o secven de caractere; caracterele permise n programele C sunt: literele mici i literele mari ale alfabetului: a b ... z, A, B, , Z cifre : 0 1 ... 9 alte caractere: * / = ( ) { } [ ] < > ' " ! @ # $ % & _ | ^ ~ \ . , ; : ? spaii: blank, newline i tab Identificatori Un identificator este un atom lexical compus dintr-o secven de litere, cifre sau caracterul underscore ("_") cu restricia c primul caracter este o liter sau underscore. n multe implementri C, se face distincie ntre litere mici i mari. n general, se obinuiete ca identificatorii s fie scrii cu nume sugestive care s uureze citirea i documentarea programului.

13

Exemple: 1. k, _id, contor, un_identificator sunt identificatori; 2. gresit#unu, 100_gresit_doi, -plus nu sunt identificatori. Comentarii n C Comentariile sunt iruri de caractere cuprinse ntre /* i */. Comentariile nu reprezint atomi lexicali. Practic, compilatorul va traduce comentariile ntr-un singur caracter spatiu, de aceea comentariile nu fac parte din codul executabil. Avantajele folosirii comentariilor: uurarea documentrii ulterioare; scopul documentrii este explicarea clar a folosirii programelor; un comentariu poate conine informaii care argumenteaz demonstraia corectitudinii unui algoritm; comentariile sunt foarte bine venite a fi scrise odat cu textul programului. Tipuri de date de baz Mulimea tipurilor de date predefinite constituie o caracteristic important i un argument n alegerea unui limbaj sau altul pentru rezolvarea unei probleme. n limbajul C exist o serie de tipuri simple de date predefinite (tabelul 2.1), a cror lungime poate s difere de la un calculator la altul i de la o implementare la alta. Pentru fiecare tip predefinit din limbajul C exist cuvinte rezervate, care reprezint modificatori de tip: unsigned, signed, long i short pentru tipul int; signed i unsigned pentru tipul char; long pentru tipul double. Cuvintele rezervate dintre parantezele ptrate sunt opionale i diferitele combinaii definesc acelai tip de dat. Tipurile de date specifice limbajului C sunt prezentate n tabelul 2.1. De asemenea, o component important a unui program C o reprezint biblioteca funciilor C (a funciilor executate de un program) care pot realiza: operaii de intrare/ieire, operaii matematice, operaii cu iruri, etc. Printre cele mai des folosite funcii din C se numr funcia printf, care este principala funcie de ieire aferent limbajului C, i este redat sub urmtoarea form:printf(sir de caractere);

14

Pentru exemplul prezentat, pe ecran se va afia irul de caractere inclus ntre ghilimele.Tabelul 2.1 Principalele tipuri de date n limbajul C Tip int short int long int Nr.octei 4 2 8 Interval de valori [-2147483648 2147483647] (-231 231-1) [-32768 32767] (-215 215-1) (-231 231-1) / (-215 215-1) Semnificaie conine numere ntregi cu semn, reprezentate binar pe 4 octei conine numere ntregi cu semn, reprezentate binar pe 2octei conine numere ntregi cu semn, reprezentate binar pe 8 octei se folosete pentru a crea ntregi fr semn. Diferena dintre ntreg cu semn i fr semn const n modul n care compilatorul interpreteaz bitul de semn. Dac bitul de semn este 0, numrul este pozitiv, i dac bitul de semn este 1, numrul este negativ. De cele mai multe ori, numerele negative se reprezint n complement fa de doi. Dac un ntreg este declarat cu unsigned, cnd bitul de semn este 1, numrul devine 231-1 sunt caractere, adic simboluri tipografice elementare: litere, cifre, semne de punctuaie, simboluri matematice, etc; caracter fr semn38

unsigned int

4

[0 2147483647] (0-231 1)

[signed] char unsigned char float

1 1 4

[-128 127] (-27 27-1) [0 255] (28-1) [3,4*10-38

3,4*10 ]

double long double

8 12

[1,7*10-308 1,7*10308] [3,4*10-4932 1,1*104932]

zecimal n virgul flotant simpl precizie conin numere reprezentate n virgul flotant (pot avea partea fracionar) zecimal n virgul flotant dubl precizie conin numere reprezentate n virgul flotant (pot avea partea fracionar) Reprezentare flotant n dubl precizie

O alt component important care caracterizeaz majoritatea programelor C sunt fiierele header. Toate informaiile aferente funciilor din biblioteca standard se afl n fiiere care sunt transmise mpreun cu compilatorul, aceste fiiere recunoscndu-se prin intermediul extensiei: .h. Informaiile din aceste fiiere sunt folosite de compilator pentru lucrul cu funciile din bibliotec. Toate fiierele necesare se adaug prin intermediul directivei preprocesor #include, care are rolul de a determina compilatorul s citeasc un alt fiier i s-l includ n program. Un fiier cu text surs poate fi inclus cu ajutorul construciei #include. Aceast construcie are formatul: 15

#include specificator_fiier sau

#include

unde specificator_fiier (care depinde de sistemul de operare) definete un fiier cu text surs pstrat pe disc. n faza de preprocesare, textul fiierului respectiv se substituie construciei #include. Astfel, textul fiierului respectiv ia parte la compilare mpreun cu textul n care a fost inclus. n cazul sistemului de operare DOS, specificatorul de fiier trebuie s fie un nume de fiier mpreun cu extensia lui (.C pentru compilatorul C, .H pentru fiiere de tip header fiiere cu prototipuri, etc.). De asemenea, n afar de numele i extensia fiierului, specificatorul de fiier poate conine i o cale dac este necesar, pentru localizarea fiierului. Diferena dintre cele dou formate const n modul de cutare al fiierului de inclus: formatul cu paranteze unghiulare se folosete la includerea fiierelor standard, cum sunt cele care conin prototipuri pentru funcii din bibliotec; n cazul n care se folosete formatul cu ghilimele, fiierul este cutat n directorul curent sau conform cii dac aceasta este prezent. Un fiier standard care se include frecvent este stdio.h; acesta conine prototipurile pentru o serie de funcii ce realizeaz operaii de intrare/ieire. Construciile #include se scriu de obicei la nceputul fiierelor surs, pentru ca textele inserate s fie valabile n tot fiierul surs care se compileaz. Pentru a putea folosi ntr-un program funcia printf(), este necesar includerea directivei #include deoarece, aa cum spuneam anterior, aceast directiv conine informaii cu privire la aceast funcie de ieire. Directivele incluse n program nu se finalizeaz cu caracterul ;, deoarece nu reprezint un cuvnt cheie al programului, ci o instruciune ctre compilatorul C. Cel mai simplu program scris n limbajul C este urmtorul: Exemplu:#include main() { printf("Primul program in limbajul C !!!"); getch(); }

care va afia pe suprafaa ecranului mesajul: Primul program in limbajul C !!!. Observaie: getch() este o funcie de ieire fr ecou (caracterul tiprit nu este afiat pe ecran) asupra creia se va reveni n cursul aferent funciilor de intrare/ieire; este folosit de mediul DevC++ pentru a pstra pe ecran (pn la apsarea unei taste) rezultatul programului compilat.

16

Practic, n acest program banal sunt incluse toate aspectele comune i obligatorii aferente unui program scris n C. Prima linie permite includerea n program a fiierului stdio.h. pentru a fi citit de compilator. nceputul funciei principale este desemnat de a doua linie, main(). Corpul tuturor funciilor n C (deci, i a funciei main) este inclus ntre dou paranteze acolad; tot ce este scris n interiorul acestor paranteze acolade constituie corpul funciei. n cazul programului prezentat anterior, corpul funciei main() este format dintr-o singur instruciune, care apeleaz funcia printf() din biblioteca standard pentru a permite afiarea pe ecran a irului dorit. Atunci cnd corpul unei funcii este format din mai multe instruciuni, parcurgerea acestora se va face secvenial. Constante i variabile n limbajul C O constant n limbajul C are un tip i o valoarea. Att tipul ct i valoarea sunt determinate de caracterele care intr n compunerea constantei. Valoarea unei constante nu poate fi schimbat n timpul execuiei programului n care a fost utilizat. Exist mai multe tipuri de constante: ntregi sunt constante care pot fi scrise n sistemul de numeraie n baza 8, 10 sau 16. O constant zecimal ntreag este un ir de cifre zecimale care are prima cifr diferit de zero. Constantele octale reprezint succesiuni de cifre octale (0-7) precedate de un zero nesemnificativ. O constant hexazecimal este o succesiune de cifre hexazecimale precedate de 0x sau 0X. Ex: 15150 care se reprezint binar prin: 00000000 00000000 00111011 00101110 flotante reprezint un numr raional i se compune din: o parte ntreag care poate fi i vid este o constant zecimal; o parte fracionar care poate fi i vid se compune din caracterul punct dup care urmeaz o succesiune de cifre zecimale; un exponent care poate fi i vid ncepe cu litera e sau E, dup care urmeaz un semn opional (plus sau minus) i un ir de cifre zecimale. Exponentul definete un factor care exprim o putere a lui 10. Ex:

100. 100 100.48 100,48 .48 0,48 12e5 12*105 .5E-5 0,5*10-5 15.255e2 15,255*102 17

1500.123e-3 1500,123*10-3

caracter o constant caracter are ca valoare codul ASCII al caracterului pe care-l reprezint i are tipul int. O constant caracter corespunztoare unui caracter imprimabil se reprezint prin caracterul respectiv inclus ntre caractere apostrof: A valoarea 65 a valoarea 97 * valoarea 42

ntr-un program utilizm alturi de date constante i date variabile care i schimb valorile n timpul execuiei programului. Dac la o dat constant ne putem referi folosind caracterele din compunerea ei, la o variabil trebuie s ne referim altfel. Cel mai simplu mod este acela de a denumi data respectiv. Numele datei ne permite accesul la valoarea ei, precum i schimbarea valorii dac este nevoie. n cazul n care o dat nu are legturi cu alte dat (spre exemplu, de ordine) se spune c ea este o dat izolat. Numele unei date izolate se spune c reprezint o variabil simpl. Unei date izolate i corespunde un tip. n cursul execuiei programului se pot schimba valorile unei date variabile dar nu i tipul ei. Corespondena dintre numele unei date variabile i tipul acesteia se definete printr-o declaraie. O variabil reprezint o locaie de memorie creia i s-a atribuit un nume i care conine diferite valori. Orice variabil n C trebuie mai nti declarat si apoi va fi folosit n program. Cnd se declar o variabil, se folosete urmtoarea form:tip nume_variabil,

unde tip este tipul de dat dorit pentru variabila declarat, iar nume_variabil este numele variabilei (Ex: int varsta, n care se declar variabila varsta ca fiind de tip ntreg). Dac exist ntr-un program mai multe variabile de acelai tip, atunci ele pot fi declarate pentru acelai tip, separndu-le prin virgul (exemplu: int a,b,c;). Pentru a atribui o valoare unei variabile se folosete urmtoarea form general:nume_variabil=valoare,

unde nume_variabil este numele variabilei (dac nu este nsoit de un tip, se consider c a fost declarat anterior), iar valoare reprezint valoarea atribuit variabilei nume_variabil (ex: i=10, n care s-a atribuit variabilei i (considerat a fi de tip int) valoare 10). O variabil care este declarat i se poate atribui o valoare iniial iniializarea variabilei. Iniializarea variabilei are urmtoarea form:tip_dat nume_variabil = valoare;

18

Ex: int variabila=10; Observaie: Atunci cnd se iniializeaz o variabil, este obligatoriu ca dup semnul egal s avem o constant n cazul n care n loc de constant avem o alt variabil (care nu a fost iniializat), compilatorul va genera o eroare la compilarea programului. De asemenea, trebuie spus c atunci cnd se declar variabile, o parte dintre acestea pot primi valori iniiale n timp ce altele nu (ex: int i=1,j=1,a). n exemplele de program prezentate anterior, s-a folosit funcia printf() prin intermediul creia s-au afiat pe ecran caracterele scrise ntre ghilimele. ns pe ecran pot fi afiate prin intermediul funciei printf() i alte valori, cum ar fi cele aferente variabilelor declarate. n aceast situaie, funcia printf() conine mai multe argumente. Spre exemplu, dac dorim s afim valoarea variabilei i declarat anterior, se va folosi un specificator de format (toi specificatorii de format trebuie s nceap cu caracterul %). Caracterele vor fi afiate pe ecran n aceeai ordine n care ele sunt ntlnite n ir. Rolul specificatorului de format este acela de a informa funcia printf() c o alt categorie de date va fi afiat. Spre exemplu, dac se folosete calificatorul de format %d, atunci se va tipri pe ecran un ntreg n format zecimal. n acest caz, funcia va arata astfel:printf("Valoarea variabilei i este %d",i);

n care valoare care trebuie afiat se afl pe al doilea argument, dup virgul (n cazul nostru, este i) i va fi afiat pe ecran acolo unde este ntlnit specificatorul de format. Funcia de mai sus va produce ca rezultat: Valoarea variabilei i este 10. Atunci cnd dorim s afim un caracter, specificatorul de format este %c, iar pentru tipurile float i double se folosete specificatorul %f. Exemplu:main() { int i=1; char c=A; float f=15.15; double d=156.675; printf(Valoarea variabilei intregi i este %d\n,i); printf(Valoarea variabilei caracter c este %c\n,c); printf(Valoarea variabilei float f este %f\n,f); printf(Valoarea variabilei double d este %f\n,d); }

n exemplu anterior, au fost declarate i afiate valoriri ale variabilelor aferente celor patru tipuri de date prezentate.

19

Preluarea datelor de la tastatur Pentru preluarea datelor de la tastatur, se folosete funcia scanf(), din biblioteca C standard. Pentru citirea de valori de la tastatur, se folosete urmtoarea form general:scanf(%spec_format,&variabila);

unde variabila este numele variabilei care va prelua valoarea introdusa de la tastatura. n funcia scanf(), primul argument este un ir care determin cum va fi tratat al doilea argument. Astfel, specificatorul de format %spec_format arat c al doilea argument (variabila) va primi valoarea introdus de la tastatur. De fiecare dat cnd se folosete funcia scanf(), deci cnd se preiau date de la tastatur, este obligatoriu ca variabila care preia valoarea s fie precedat de caracterul &. Practic, caracterul & permite funciei scanf() s plaseze o valoare n unul din argumentele sale. Atunci cnd se preiau caractere de la tastatur, funcia scanf() ateapt apsarea tastei ENTER i apoi convertete irul n format binar. Exemplu: Se creeaz urmtorul program:#include main() { int i; printf(introduceti valoarea lui i:); scanf(%d,&i); printf(valoarea lui i este: %d,i); }

Dup lansarea n execuie, pe ecran apare o fereastr, n care se ateapt introducerea unui ntreg. Dup introducerea valorii dorite, se ateapt apsarea tastei ENTER, dup care pe ecran va fi afiat valoarea preluat de la tastatur. Dac se dorete preluarea unui caracter, atunci funcia va include specificatorul de format %c, iar dac se preia un numr n zecimal, se folosete specificatorul %f. Tem: S se scrie un program care s preia de la tastatur dou valori de tipul int, i s se afieze suma lor.

20

3. Operatori aritmetici n limbajul C exist cinci operatori aritmetici: + : adunare - : scdere * : nmulire / : mprire % : modulo are ca rezultat restul mpririi a dou numere ntregi. Dintre operatorii prezentai anterior, primii patru pot fi folosii cu orice tip de dat, n timp ce operatorul modulo se folosete doar cu tipul int. Operatorii apar n expresii, care nu reprezint altceva dect combinaii de operatori i operanzi. Ex. 3.1.#include main() { int nr1,nr2, total, rest; printf("Introduceti cele doua numere:\n"); printf("nr1 este: "); scanf("%d",&nr1); printf("nr2 este: "); scanf("%d",&nr2); total=nr1+nr2; rest=nr1%nr2; printf("\n\n%d + %d = %d \n\n",nr1,nr2,total); printf("n1/n2=%d\n\n",(nr1/nr2)); printf("Restul este:%d.",rest); getch(); }

n exemplu de mai sus s-au declarat patru variabile de tip ntreg; valorile aferente primelor dou sunt preluate de la tastatura, calculndu-se apoi suma lor prin intermediul expresiei:total=nr1+nr2;

Se observ c, operatorii pot fi inclusiv variabile. De asemenea, variabila rest primete ca valoare restul mpririi celor dou valori preluate. Operatori de incrementare i decrementare Majoritatea programelor realizate n C nu conin linii de genul: i=i+1, deoarece limbajul C pune la dispoziie un operator special care incrementeaz o variabil prin 1. Operatorul increment este ++ (de dou ori plus, fr spaiu). n acest fel, n loc de i=i+1 putem folosi i++. n mod similar, 21

pentru a decrementa variabila i cu unu, se folosete (de dou ori caracterul minus) (ex.: i--). Motivul pentru care se folosete aceast modalitate este acela c pentru multe compilatoare, aceti operatori sunt mult mai rapizi dect instruciunile de asignare corespunztoare. Aceast diferen apare deoarece n versiunea executabil a programului se evit ncrcarea i depozitarea unor instruciuni n limbaj main, prin substituirea cu o singur instruciune de incrementare sau decrementare. Atunci cnd operatorul de incrementare/decrementare apare n dreapta unei atribuiri, vom avea de-a face cu dou operaii: iniial se atribuie variabilei din stnga valoarea variabilei din dreapta, iar apoi se incrementeaz variabila din partea dreapt. Spre exemplu, dac avem urmtoarea asignare:a=b++

n care se presupune c iniial variabila b a fost iniializat cu 100, dac dorim s afim a vom constata c are valoarea 100 i nu 101, asta pentru c iniial a a primit valoarea lui b i apoi b a fost incrementat cu 1. Un aspect important care trebuie menionat este acela c aceti operatori pot apare att dup numele variabilei, ct i naintea acesteia, ns cu semnificaii i implicaii total diferite. Atunci cnd operatorul de incrementare/decrementare apare naintea variabilei, presupunnd c avem de realizat tot o atribuire de valoare, iniial se realizeaz incrementarea variabilei din dreapta i apoi valoarea modificat se atribui variabilei din stnga. Dac se consider c variabila b are valoarea 100, atribuirea:a=++b

va avea ca efect atribuirea valori 101 variabilei a. Ex. 3.2 Exemplu de utilizare a operatorilor de incrementare# include main() { int a=100, b=200,x,y; printf ("a++ = %d\n",a++); printf ("b-- = %d\n",b--); printf("a=%d, b=%d\n",a,b); printf ("--a = %d\n",--a); printf ("++b = %d\n",++b); printf("a=%d, b=%d\n",a,b); x=a++; y=b--; printf("x=%d, y=%d\n",x,y); printf("a=%d, b=%d\n",a,b); x=--a;

// afiseaza a=100 // afiseaza b=200 // afiseaza a=101 b=199 // afiseaza a=100 // afiseaza b=200 // afiseaza a=100 b=200 // afiseaza x=100 y=200 // afiseaza a=101 b=199

22

y=++b; printf("x=%d, y=%d\n",x,y); // afiseaza x=100 y=200 printf("a=%d, b=%d\n",a,b); // afiseaza a=100 b=200 }

Exemplul de mai sus pune n eviden toate aspectele menionate anterior. Operatori relaionali i operatorii logici Operatorii relaionali compar dou valori i returneaz true sau false. Operatorii logici conecteaz mpreun rezultatele true i false. Tabelul operatorilor logici este:Tabelul 4.1 Operatorii logici n limbajul C

a

b

a&&b false false true false

a||b

!a

XOR false true true false

false false false true true true true false

false true true true true true false false

Tabelul 3.1 Operatorii relaionali i semnificaia lor

Operator Semnificaie > >= < #include main() { int x=1, y=0; if (x>y) printf ("Adevarat !"); }

Dup executarea programului de mai sus, se evalueaz expresia ca fiind adevrat i pe ecran se va tipri Adevarat ! . Dac s-ar fi folosit operatorul de relaie