Lucrre r. Limbjul C cu plicții î liz umerică Elemete geerle le limbjului C ELEMENTE GENERALE ALE LIMBAJULUI C. Scopul lucrării Lucrre re c scop prezetre elemetelor de bză le limbjului C.. Noţiui teoretice. Structur progrmelor Orice ctivitte de progrmre îcepe cu editre progrmului, î coformitte cu regulile sitctice şi semtice ferete limbjului. Se elboreză stfel şumitul progrm sursă", cre se păstreză îtr-u fişier (fişier sursă) su mi multe. Aceste fişiere u etesi.c petru limbjul C şi.cpp petru limbjul C++. Petru pute fi eecutt, progrmul trebuie să prcurgă o serie de etpe: - etp de compilre cre presupue rezolvre directivelor către preprocesor şi trspuere progrmului sursă î progrm obiect" (pri compilre uui fişier sursă se obţie u fişier obiect cu etesi.obj): - etp de li-editre cre presupue legre progrmului obiect obţiut cu bibliotecile de sistem; rezultă u progrm eecutbil (î urm li-editării se obţie u fişier eecutbil cu etesi.ee) - etp de lsre î eecuţie. U progrm sursă este compus di u su mi multe fucţii ditre cre u sigură trebuie umită mi(). Eemplul următor coţie o sigură fucţie, fucţi mi(). Către cestă fucţie priciplă sistemul de operre trsferă cotrolul l lsre î eecuţie progrmului. E. #iclude<stdio.h> mi() pritf ("Progrm i limbjul C!"); Dcă sut prcurse î mod corect etpele de compilre şi li-editre le progrmului, l lsre lui î eecuţie v pre mesjul: Progrm i limbjul C! Acoldele îcdreză o costrucţie (istrucţiue compusă su bloc) lcătuită di declrţii şi istrucţiui ş cum este czul corpului uei fucţii.. Vribile. Tipuri de vribile. Declrre Limbjul C permite utilizre de vribile (ume simbolice) petru memorre dtelor, clculelor su rezulttelor. Î cdrul progrmelor C este obligtorie declrre vribilelor, cre costă î precizre tipului vribilei. Î urm declrţiei, vribil determiă compiltorul să-i loce u spţiu corespuzător de memorie. Î limbjul C eistă cici tipuri de vribile: - crcter: chr, - îtreg: it, - rel î virgul mobilă î simplă precizie: flot, - rel î virgul mobilă î dublă precizie: double şi - tip de vribilă eprecizt su ieistet: void Primele 4 tipuri ritmetice de bză pot fi etise cu jutorul uor declrţii suplimetre, cum r fi: - siged (cu sem) - usiged (fără sem) - log (lug) - short (scurt). U eemplu de set de tipuri de vribile obţiut cu jutorul cestor declrţii este prezett î Tb.. Eemple de declrţii de vribile: it i, j, ; double vl, set; usiged it m; Progrmul următor utilizeză declrţii multiple de vribile: E. #iclude<stdio.h> mi() it r; chr ev; flot timp; r=5; ev = 'S'; timp =.30; pritf("eveimetul %c re umărul %d ", ev, r); pritf("si vut loc l %f", timp); Î urm eecuţiei cestui progrm se v fiş: Eveimetul S re umărul 5 şi vut loc l.300000
Limbjul C cu plicții î liz umerică Elemete geerle le limbjului C Tb. Tipuri de vribile î limbjul C Tip Spţiul Domeiul de vlori (biţi) chr 8-8 7 usiged chr 8 0 55 siged chr 8-8 7 it 6-3768 3767 usiged it 6 0 65535 siged it 6-3768 3767 short it 6-3768 3767 usiged short it 6 0 65535 siged short it 6-3768 3767 log it 3 -.47.483.648.47.483.647 siged log it 3 -.47.483.648.47.483.67 usiged log it 3 0 4.94.967.95 flot 3 0-37 0 37 (6 digiti precizie) double 64 0-308 0 308 (0 digiti precizie) log double 80 0-493 0 493 (5 digiti precizie).3 Fucţi pritf( ) Fucţi pritf() permite fişre tetului flt ître ghilimele precum şi vlori le diferitelor vribile di progrm, utilizâd umite otţii deumite specifictori de formt cre relizeză coversi dtelor îtr-o formă decvtă petru fişre. Prototipul fucţiei pritf() se găseşte î fişierul tet stdio.h şi de cee este evoie de declrţi preprocesor: #iclude<stdio.h> l îceputul fiecărui progrm cre foloseşte cestă fucţie. Formtele specifice utilizte de fucţi pritf() sut: %c petru fişre uui sigur crcter; %s petru fişre uui şir de crctere; %d petru fişre uui umăr îtreg (î bz zece) cu sem; %i petru fişre uui umăr îtreg (î bz zece) cu sem ; %u petru fişre uui umăr îtreg (î bz zece) fără sem; %f petru fişre uui umăr rel (otţie zecimlă); %e petru fişre uui umăr rel (otţie epoeţilă); %g petru fişre uui umăr rel (ce mi scurtă reprezetre ditre %f si %e); % petru fişre uui umăr hezeciml îtreg fără sem; %o petru fişre uui umăr octl îtreg fără sem %p petru fişre uui poiter ( uei drese); Î plus se pot folosi următorele prefie: l cu d, i, u,, o permite fişre uei dte de tip log l cu f, e, g permite fişre uei dte de tip double h cu d, i, u,, o permite fişre uei dte de tip short L cu f, e, g permite fişre uei dte de tip log double. Eemple: %ld - permite fişre uei dte de tip log it %hu - permite fişre uei dte de tip short usiged it Î eemplul fişre vlorii rele s- relizt cu şse zecimle şi u cu două coform operţiei de tribuire iiţile cestei vribile. Petru fişre corectă, formtul de scriere %f trebuie îsoţit de o otţie suplimetră cre specifică dimesiue câmpului de fişre dtelor şi precizi de fişre cestor. Acestă otţie suplimetră se itroduce ître simbolul % şi simbolul f şi re form geerlă %-m.f cu m şi umere îtregi vâd următorele semificţii: semul -, î czul î cre este folosit, relizeză liiere l stâg iformţiei fişte î cdrul câmpului de fişre; î lips cestui, implicit liiere se fce l drept. m precizeză dimesiue câmpului de fişre (umărul de coloe). reprezită umărul de digiţi di prte zecimlă (precizi de fişre umărului) Astfel, î eemplul, dcă î locul specificţiei de formt %f m fi trecut %5.f, l cosolă r fi părut mesjul: Eveimetul S re umărul 5 şi vut loc l.30
Limbjul C cu plicții î liz umerică Elemete geerle le limbjului C E. 3 #iclude<stdio.h> mi() flot vlore; vlore = 0.330; pritf ("%8.f%8.f\,.5,45.7); pritf ("% -8.f % -8.f\.",.5,45.7); pritf ("%f\",vlore); pritf ("%5.f\", vlore); pritf (" %0f\", vlore) ; pritf ("%0f\, vlore); Î urm eecutării progrmului di e.3, v rezult:. 5 4 5. 7. 5 4 5. 7 0. 3 3 0 0. 3 0. 3 0 0 0 0. 3 3 0 0. 3 3 0 Se observă că prezeţ uui zero îite umărului cre specifică dimesiue câmpului de scriere determiă l fişre umplere cu zero spţiilor gole..4. Secveţe de evitre (escpe) Î eemplul 3, crcterul "\" isert î şirul de crctere di pelul fucţiei pritf() determit fişre pe o liie ouă (crrige retur-liefeed). Acest crcter este u eemplu de secveţă escpe, umită ş deorece simbolul (\) bcslsh este cosidert crcter escpe, cre determiă o btere de l iterpretre ormlă şirului. Aceste secveţe escpe sut: \ beep lrmă-sooră; \b bcspce spţiu îpoi; \f formfeed liie ouă, dr pe colo următore celei curete; \ ewlie determiă trecere l liie ouă, pe prim coloă; \r crrige retur determiă reveire l îceputul liiei; \t tb determiă sltul cursorului di 8 i 8 coloe; \\ bcslsh ; \' postrof simplu; \" ghilimele; \0 ull ; \ddd vlore crcter î otţie octlă (fiecre d reprezită u digit); \dd vlore crcter î otţie hezecimlă;.5. Fucţi scf() O ltă fucţie des utiliztă limbjului C este fucţi de itroducere dtelor scf(). Î mod similr 3 cu pritf(), pelul fucţiei scf() implică utilizre uui şir de crctere de cotrol urmte de o listă de rgumete. Dr, î timp ce pritf() utilizeză ume de vribile, costte şi epresii, scf() utilizeză poiteri l vribile. Eemplul 4 este o vrită progrmului di eemplul î cre, î plus, se utilizeză fucţi scf(). E. 4 #iclude<stdio.h> mi() it r; chr ev; flot timp; pritf ("Itroduceţi poziti, eveimetul, timp:"); scf ("%c %d %f", &ev, &r, &timp); pritf ("Eveimetul %c re umărul %d ", ev, r); pritf (" şi vut loc l %5.f", timp); Eecuţi progrmului pote fi: Itroduceţi poziti, eveimetul şi timpul: A 6.30 Eveimetul A re umărul 6 şi vut loc l.30 Vlorile vribilelor ev, r şi timp u fost itroduse de l tsttură. Petru seprre lor fost utilizt spţiu (bl). Pute fi folosit retur su tb; orice lt seprtor (liie, virgul) u relizeză cestă seprre. 3. Problemă rezolvtă 3. Să se scrie u progrm cre permite flre codului umeric l uei tste î zeciml, he si octl. #iclude<stdio.h> #iclude<coio.h> void mi(void) chr crcter; clrscr(); pritf("acest progrm fisez codul uei tste i zeciml, he si octl.\"); pritf("apsti o tst:"); scf("%c",&crcter); pritf("codul tstei \ %c\ este %d (i deciml), % (i he), %o (i octl)\", crcter, crcter, crcter, crcter); getch(); 4. Chestiui de studit 4. Studiere oţiuilor teoretice şi eemplelor prezette. 4. Studiere problemelor rezolvte şi idetificre elemetelor de limbj şi lgoritmilor utilizţi.
Limbjul C cu plicții î liz umerică Poiteri î limbjul C Lucrre r. 3 POINTERI ÎN LIMBAJUL C. Scopul lucrării Lucrre re c scop prezetre utilizării vribilelor poiter î limbjul C.. Noţiui teoretice. Declrre vribilelor poiter Vribilele poiter (idictor) reprezită drese le uor zoe de memorie. Poiterii sut utilizţi petru fce referire l dte cuoscute, pri dresele lor. Putere şi fleibilitte î utilizre poiterilor, specifică limbjului C, reprezită u vtj fţă de celellte limbje (de e. Pscl). Eistă ctegorii de poiteri: poiteri de dte (obiecte) cre coţi drese le uor vribile su costte di memorie; poiteri de fucţii cre coţi dres codului eecutbil l uei fucţii. Î plus, eistă şi poiteri de tip void (o trei ctegorie), cre pot coţie dres uui obiect orecre. Declrre uui poiter de dte se fce cu sit: tip *vr_ptr; Prezeţ crcterului * defieşte vribil vr_ptr c fiid de tip poiter, î timp ce tip este tipul obiectelor căror dresă o v coţie (umit şi tipul de bză l vribilei poiter vr_ptr). Petru poiterii de tip void se foloseşte declrţi: void * v_ptr; Eemplul următor coţie u set de declrţii de vribile poiter: E.: it *iptr; flot *fptr, vl; void *v_dr; it * tbptr [0]; flot ** dptr; Î cestă secveţă de progrm, vribil iptr este u poiter de obiecte it, ir vribil fptr u poiter de obiecte flot. Tot ici, tbptr este u tblou de 0 poiteri de tip it, ir dptr v pute coţie dres uui poiter de obiecte flot (se relizeză o dublă idirectre, poiter l poiter). Deorece, l compilre su î timpul eecuţiei progrmului u se fc verificări le vlidităţii vlorilor poiterilor, orice vribilă poiter trebuie iiţiliztă cu o vlore vlidă, 0 su dres uui obiect su uei fucţii, îite de fi utiliztă. Iiţilizre cu vlore 0 uei vribile poiter idică fptul c cest u coţie dres uui obiect su uei fucţii. Uzul, î ceste czuri, se foloseşte petru tribuire idetifictorul NULL(=0), cre este declrt î fişierele tet (stdio.h, stdlib.h etc.). Utilizre vribilelor poiter implică folosire doi opertori uri: opertorul & ce permite flre dresei uei vribile orecre şi opertorul * cre permite ccesul l vribil drestă de u poiter. Astfel, î czul uei vribile vr de tipul tip, epresi: &vr se citeşte: dres vribilei vr ir rezulttul este u poiter de obiecte tip şi re vlore dresei obiectului vr. Î czul uei vribile poiter de obiecte tip, umită ptr, epresi: *ptr se citeşte: l dres ptr ir rezulttul este de tipul tip şi reprezită obiectul drest de vribil poiter ptr. Epresi *ptr pote fi utiliztă tât petru flre vlorii obiectului, dr şi î cdrul uei operţii de tribuire.
Limbjul C cu plicții î liz umerică Poiteri î limbjul C Utilizre cestor opertori este prezettă î eemplul următor, î cre, petru fişre dreselor î hezeciml se foloseşte fucţi pritf() împreuă cu specifictorul de formt %p: E.: #iclude <stdio.h> void mi(void) it vr=5, *ptr; pritf( \ Vribil vr se flă l dres:%p, &vr); pritf( \ şi re vlore vr=%d,vr); ptr=&vr; pritf( \ Vribil ptr re vlore:%p, ptr); pritf( \ şi coţie dres obiectului: %d,*ptr); *ptr=0; pritf( \Acum, vribil vr re vlore %d\,vr); Î urm eecuţiei progrmului se fişeză: Vribil vr se flă l dres: A56 şi re vlore vr=5 Vribil ptr re vlore: A56 şi coţie dres obiectului: 5 Acum, vribil vr re vlore 0 Î urm operţiei de tribuire ptr=&vr, vribil poiter ptr prei dres vribilei vr, stfel îcât cele două obiecte *iptr şi vr devi idetice, reprezetâd u îtreg cu vlore 5 de l dres A56. Î ceste codiţii, epresi *ptr pote fi folosită î locul vribilei vr, cu efecte idetice. De cee, tribuire *ptr=0 re c efect modificre vlorii vribilei vr di 5 î 0.. Operţii rimetice cu poiteri Operţiile ritmetice ce se pot efectu cu poiteri sut: comprre, dure şi scădere. Aceste operţii sut supuse uor reguli şi restricţii specifice. Î czul î cre tipurile socite operzilor poiter u sut idetice, pot pre erori, cre u sut îtotdeu semlte de compiltor. Î cest ses, se recomdă coversi de tip eplicită cu opertorul cst, de form (tip*). Opertorii relţioli permit comprre vlorilor doi poiteri:.. it *ptr,*ptr; if(ptr<ptr) pritf( ptr=%p <ptr=%p,ptr,ptr); Î multe situţii este ecesră comprre uui poiter cu 0, petru verific dcă dreseză su u u obiect:.. if(ptr==null) /* ptr este u poiter ul*/ else /* ptr este u poiter eul*/.. su, sub form: if(!ptr) /* ptr este u poiter ul*/ else /* ptr este u poiter eul*/ Pot fi efectute operţii de dure su de scădere ître u poiter de obiecte şi u îtreg. Deorece u poiter este o vlore cre idică o umită locţie di memorie, dcă dăugăm umărul cestei vlori, poiterul v idic următore locţie di memorie. Deci, î cdrul cestor operţii itervie şi tipul vribilei. Regul după cre se efectueză ceste operţii este următore: î czul uei vribile poiter ptr: tip *ptr; operţiile ritmetice: ptr+ şi ptr- corespud dăugării/scăderii l dres ptr vlorii *sizeof(tip). De eemplu:.. it *ip; /* sizeof(it)= */ flot *fp; /* sizeof(flot)=4 */ double *dp, *dp; /* sizeof(double)=8 */. dp=dp+5; /* dp<-- dres_dp+5*8 */ fp=fp-; /* fp<-- dres_fp-*4 */ ip++; /* ip<-- dres_ip+* */ dp--; /* dp<-- dres_dp-*8 */ Î celşi cotet, se pote efectu scădere doi poiteri de obiecte de celşi tip, vâd c rezultt o vlore îtregă ce reprezită rportul ditre difereţ celor două drese şi dimesiue tipului de bză, c î eemplul: it i; flot *fp,*fp; /*sizeof(flot)=4*/ i=fp-fp; /*i=(dres_fp-dres_fp)/sizeof(flot)*/
Limbjul C cu plicții î liz umerică Poiteri î limbjul C Avâd î vedere importţ tipului poiterilor î cdrul operţiilor de dure şi scădere, operzii u pot fi poiteri de fucţii su poiteri void..3 Vribile dimice Petru tipurile de dte l cre se cuoşte dimesiue zoei de memorie ecesră, cest este fită î urm declrţiei, îite lsării î eecuţie progrmului. Î czul structurilor de dte căror dimesiue u este cuoscută su se modifică î timpul eecuţiei progrmului, este ecesră o locre pri progrm memoriei, î timpul eecuţiei. Memori loctă este folosită, ir tuci câd u mi este utilă, se elibereză tot î timpul eecuţiei progrmului. Vribilele crete stfel se umesc dimice. Prototipurile fucţiilor utilizte petru locre şi eliberre memoriei î timpul eecuţiei progrmului se flă î fişierele lloc.h şi stdlib.h. O fucţie des utiliztă petru locre dimică memoriei este mlloc() şi re prototipul: void*mlloc(usiged r_octeţi); Pri prmetrul fucţiei mlloc() se precizeză dimesiue î octeţi zoei de memorie solicitte. Dcă operţi de locre reuşeşte, fucţi îtorce u poiter cre coţie dres primului octet l zoei de memorie locte. Î cz cotrr (spţiul dispoibil este isuficiet) poiterul rezultt este NULL (=0). Petru o buă portbilitte progrmelor, este recomdbil, î pelul fucţiei mlloc(), să se utilizeze opertorii cst (petru coversie de tip l tribuire) şi sizeof (petru precizre dimesiuii zoei solicitte). De eemplu, dcă se doreşte locre uei zoe de memorie petru 0 vlori de tipul flot, se pote proced stfel:. flot *fp; fp=(flot*)mlloc(0*sizeof(flot));. Eliberre memoriei (rezultte î urm uei locări dimice) se fce tuci câd vribil dimică u mi este utilă, ir spţiul loct pote fi refolosit. Î cest cz se pote folosi fucţi free() cre re prototipul: void free(void*ptr); Prmetrul fucţiei free() este u poiter ce coţie dres zoei cre trebuie elibertă şi cre obligtoriu este rezulttul uui pel l uei fucţii de locre dimică (de tip mlloc()). Astfel, zo loctă terior pote fi elibertă pri pelul:. free(fp);. Zo de memorie loctă stfel este echivletă cu u tblou. Elemetele cestui pot fi referite idet. De eemplu fp[5] este obiectul flot de l dres fp+5. 3. Problemă rezolvtă 3. Acest progrm eemplifică regulile specifice operţiilor ritmetice cu poiteri. #iclude <stdio.h> void mi(void) it =5,b=0, *iptr, *iptr,i; flot m=7.3, *fptr; iptr=&;iptr=&b; fptr=&m; pritf("\ fptr=%u, *fptr=%.f, &fptr=%u", fptr, *fptr, &fptr); fptr++;pritf("\ Icremetre fptr:"); pritf("\ fptr=%u, *fptr=%.f, &fptr=%u", fptr, *fptr, &fptr); pritf("\ iptr=%u, *iptr=%d, iptr=%u, *iptr=%d", iptr, *iptr, iptr,*iptr); i=iptr-iptr; pritf("\ Diferet poiterilor iptr si iptr este=%d",i); iptr=iptr+8; pritf("\ iptr=%u, *iptr=%d, iptr=%u, *iptr=%d", iptr, *iptr,iptr,*iptr); 4. Chestiui de studit 4. Studiere şi îsuşire oţiuilor teoretice şi eemplelor prezette. 4. Idetificre elemetelor de limbj şi lgoritmilor utilizţi. 3
Limbjul C cu plicții î liz umerică Tblouri şi poiteri î limbjul C Lucrre r. 4 TABLOURI ŞI POINTERI ÎN LIMBAJUL C. Scopul lucrării Lucrre re c scop prezetre legăturii ditre tblouri şi poiteri î limbjul C. Noţiui teoretice. Tblouri şi şiruri de crctere U tblou este o structură omogeă, formtă ditr-u umăr fiit de elemete de celşi tip deumit tipul de bză l tbloului. Sit de bză î declrre uui tblou este: tip ume_tblou[r_elem]=vl_iitil.; De eemplu: it tb[5]=5,4,3,,; defieşte u tblou de 5 vlori de tip it şi relizeză iiţilizre cestui cu vlorile di iteriorul coldelor. Petru idetificre uui elemet l uui tblou se foloseşte umele tbloului şi ideul (poziţi elemetului î tblou). Vlorile pe cre le pote lu ideul plecă de l 0, ultimul elemet vâd ideul r_elem-: Astfel, î eemplul precedet, tb[0] este primul elemet l tbloului şi re vlore 5. Limbjul C u re u tip de dte specil petru şiruri de crctere, dr permite folosire tblourilor uidimesiole de tip crcter (chr). Sit de declrre este: chr ume_sir [r_elem]; Petru mrc sfârşitul uui şir cu elemete, după ultimul crcter, compiltorul rezervă + locţii de memorie, pe ultim poziţie dăugâd u octet cu vlore 0 (crcterul \0 ). Astfel, cest termitor \0 permite testre sfârşitului şirului. Î bibliotec limbjului C eistă u set de fucţii dedicte operţiilor cu şiruri. Astfel, î fişierul stdio.h sut declrte: - fucţi gets(sir_dest) cre citeşte crctere itroduse de l tsttur şi le trsferă î şirul sir_dest şi - fucţi puts(sir) cre fişeză şirul şir pe ecr, ir, î fişierul strig.h, se găsesc câtev fucţii ce relizeză operţii uzule cu şiruri, cum r fi: - fucţi strcpy(sir_dest,sir_surs) cre copiză şirul sir_surs î şirul sir_dest, - fucţi strct(sir, sir) cre dugă şirul sir l sfârşitul şirului sir (coctere) şi - fucţi strle(sir) cre retureză umărul de elemete l şirului sir. - fucţi strcmp(sir,sir) cre compră succesiv crcterele celor şiruri. Dcă şirurile sut idetice retureză vlore 0, ir dcă diferă, o vlore eulă. Utilizre cestor fucţii este prezettă î eemplul următor, cre testeză itroducere prolei corecte et : #iclude <stdio.h> #iclude <strig.h> #iclude<process.h> void mi(void) chr sir[0], prol[0]; strcpy(prol, et ); puts( Itroduceti prol: ); gets(sir); if (strcmp(sir, prol)) puts( Icorect ); eit(); /*iesire di progrm */ else puts( Corect! ); /* si se pote eecut i cotiure progrmul */
Limbjul C cu plicții î liz umerică Tblouri şi poiteri î limbjul C Î czul tblourilor uidimesiole, se pote omite dimesiue l declrţie. Î cestă situţie, dimesiue zoei de memorie locte este fită de compiltor pe bz listei de costte utilizte l iiţilizre. Î czul tblourilor mri, u mi este ecesră umărre elemetelor, c î declrţi: chr sir[]= Nu mi este evoie de dimesiue sirului ;. Tblouri şi poiteri Numele uui tblou fără ide este echivlet cu u poiter costt de tipul elemetelor tbloului, vâd c vlore dres primului elemet di tblou. Totuşi, î timp ce uei vribile de tip poiter i se tribuie vlori l eecuţie, u este posibil şi petru umele uui tblou, cre v ve mereu c vlore dres primului elemet. De cee se spue că umele uui tblou este u poiter costt. De eemplu, după declrţiile:.. flot ftb[0],*fptr; it i;. se pote fce tribuire: fptr=ftb; î urm cărei vribil poiter fptr v ve dres primului elemet l tbloului ftb. Eistă de semee următorele echivleţe:. &ftb[0] <= => ftb. &ftb[] <= => ftb+ 3. &ftb[i] <= => ftb+i 4. ftb[0] <= => *ftb 5. ftb[4] <= => *(ftb+4) 6. fptr+i <= => fptr[i] Pe bz cestor eglităţi se pote clcul epresi: (&ftb[i]-ftb)= = ftb+i- ftb==i Chir dcă coţie dres primului elemet, umele tbloului (fără ide) referă îtregul tblou, stfel că î eemplul ostru sizeof(ftb) v ve vlore 40 (0 elemete de 4 octeţi fiecre). Î czul tblourilor multidimesiole, deorece reprezită tblouri cu elemete tblouri, umele uui stfel de tblou (fără ide) este u poiter de tblouri. Î eemplul:.. flot fmt [0][0]; flot *fp; fp=mt;.. tribuire fp=mt; este icorectă, deorece mt este poiter de tblouri flot cu 0 elemete şi u u poiter flot. Astfel, mt referă prim liie mtricii idetifictă pri mt[0], ir mt[0] referă primul elemet l mtricii mt[0][0]. Pot fi scrise echivleţele:. &mt[0] <= => mt. &mt[0][0] <= => mt[0] 3. mt[0][0] <= => *mt[0] <= => **mt 4. *(mt+i) <= => mt[i] <= =>&mt[i][0] 5. *(*(mt+)+5)<==>*(mt[]+5)<==>mt[][5] Î geerl este vlbilă echivleţ: mt[i][j] <= =>*(*(mt+i)+j) 3. Probleme rezolvte 3. Acest progrm îcrcă tbloul t cu umerele.0 şi poi copiză coţiutul lui t î tbloul t: PROGRAMUL 3. #iclude <stdio.h> mi ( ) it t [0],t[0]; it i; for (i=;i<;i++) t[i-] = i; for (i=0;i<0;i++) t[i] =t[i]; for (i=0;i<0;i++) pritf( %d,t[i] ); 3. Acest progrm clculeză urm uei mtrice pătrte (sum elemetelor de pe digol priciplă) utilizâd vribile poiter petru dresre elemetelor mtricei. Aceste vribile poiter sut iiţilizt (petru fiecre liie) cu dres de îceput liiei respective.
Limbjul C cu plicții î liz umerică Tblouri şi poiteri î limbjul C PROGRAMUL 3. #iclude <stdio.h> #iclude <coio.h> mi ( ) it mt[0][0]; it s=0, *ptr,,i,j; pritf("dti dimesiue mtricei ptrte:"); scf("%d",&); for(i=0;i<;i++) for(j=0;j<;j++) pritf("mt[%d][%d]=",i+,j+); scf("%d",&mt[i][j]); for(i=0;i<;i++) ptr=mt[i]; s=s+*(ptr+i); pritf("sum=%d\",s); 3.3 Acest progrm umără spţiile ditr-u şir itrodus de l tsttur de către utiliztor. Este testt fiecre crcter, ir dcă cest u este spţiu, istrucţiue cotiue forţeză relure ciclului for. Î czul î cre este găsit u spţiu, vlore vribilei spţiu este icremettă. Prcurgere şirului se relizeză pri icremetre vribilei str de tip poiter l u şir de crctere PROGRAMUL 3.3 #iclude <stdio.h> void mi (void) chr sir[80], *str; it sptiu; pritf("itroduceti u sir: "); gets(sir); str = sir; for (sptiu=0; *str; str++) if (*str!= ' ') cotiue; sptiu++; pritf("sirul cotie %d sptii \",sptiu); 4. Chestiui de studit 4. Studiere oţiuilor teoretice şi eemplelor prezette. 4. Studiere problemelor rezolvte şi idetificre elemetelor de limbj şi lgoritmilor utilizţi. 3
Limbjul C cu plicții î liz umerică Fucţii i limbjul C Lucrre r. 5 FUNCŢII ÎN LIMBAJUL C. Scopul lucrării Lucrre re c scop prezetre fucţiilor î limbjul C.. Noţiui teoretice Î geerl, u progrm C este lcătuit di u su mi multe fucţii. Îtotdeu eistă cel puţi o fucţie, fucţi mi() cre este peltă l lsre î eecuţie progrmului. Sit geerlă defiirii uei fucţii este : tip_fct ume_fct(listă_declrţii_prmetrii) <list_declrţii_locle> listă_istrucţiui tip_fct este tipul rezulttului returt de fucţie. Dcă o fucţie u îtorce u rezultt, tipul folosit este void. Î eemplul următor fucţi m primeşte doi prmetrii de tip flot şi fişeză vlore mimă şi medi cestor. Deorece fucţi u îtorce iciu rezultt, tipul său este void: E.:. void m(flot,flot ) flot mim; /* declrtie loclă */ if(>) mim=; else mim=; pritf ( Mim=%f;Medie=%f\,mim,(+)/); =7.5; mi() flot r; m(r,4.53); /*pel l fuctiei fm*/ Formtul geerl l pelului uei fucţii este: ume_fct (prm, prm ) Numim prmetrii formli idetifictorii di list_declrţii_prmetrii di defiiţi fucţiei şi prmetrii efectivi cele vribile, costte su epresii di list uui pel l fucţiei. Se observă c prmetrii formli reprezită vribilele locle le fucţiei. Timpul lor de viţă corespude durtei de eecuţie fucţiei. Trsmitere prmetrilor (î urm uui pel l fucţiei) se relizeză pri îcărcre vlorii prmetrilor efectivi î zo de memorie prmetrilor formli. Acest procedeu se umeşte trsfer pri vlore. Î czul î cre prmetrul efectiv este o vribilă, operţiile efectute î cdrul fucţiei supr prmetrului forml u o fecteză. Î E., tribuire =7.5 di filul fucţiei u modifică vlore vribilei r di pelul m(r,4.53);. Dcă se doreşte modificre vlorii uei vribile idicte c prmetru efectiv îtr-o fucţie, trebuie c prmetrul forml să fie de tip poiter. L pelre, trebuie să i se ofere eplicit dres uei vribile. Acest procedeu se umeşte trsfer pri referiţă. Î czul trsferului pri referiţă, modificre reliztă de fucţie supr prmetrilor efectivi este vlbilă tât î iteriorul cât şi î eteriorul fucţiei. Atuci câd se doreşte c fucţi să retureze u rezultt se foloseşte istrucţiue retur cu sit: retur (epresie) Vlore epresiei este rezulttul îtors de fucţie, ir prtezele sut opţiole.
Limbjul C cu plicții î liz umerică Fucţii i limbjul C 3. Probleme rezolvte 3. Următorul progrm creeză şi implemeteză o fucţie cre cută u crcter îtr-u şir şi retureză tote poziţiile pe cre cest este găsit. Poziţiile returte sut grupte îtr-u tblou, deorece rezulttul fucţiei este de tip poiter l îtreg. #iclude<strig.h> #iclude<stdio.h> #iclude<coio.h> #iclude<lloc.h> /*<mlloc.h> ptr Visul C*/ it *fid(chr*sir,chr crcter) it*,*b; chr*sir; sir=sir; =(it*)mlloc(strle(sir)); b=; while(*sir!='\0') if(*sir==crcter) *=(sir-sir); ++; sir++; *=-; retur(b); void mi(void) clrscr(); chr *s="cest este sirul cre v fi lizt"; chr cr=''; it *poziti,i; poziti=fid(s,cr); i=0; while (poziti[i]!=-) pritf(" %d ", poziti[i++]+); 3. Următorul progrm clculeză sum elemetelor uui vector utilizâd o fucţie vâd pritre prmetrii formli şi o vribilă poiter. #iclude<stdio.h> double fsum(double *ptr, it ) it i; double sum=0; for(i=0;i<;i++) sum=sum+*(ptr+i); retur sum; mi() double tb[0],elem,sum; it i,r; pritf("dti umrul de elemete l vectorului:"); scf("%d",&r); for (i=0; i<r;i++) pritf("numr(%d)=",i+); scf("%lf", &elem); tb[i]=elem; sum=fsum(tb,r); pritf("sum elemetelor vectorului este: %5.lf", sum); 4. Probleme propuse 4.. Să se implemeteze o fucţie cre cută u crcter îtr-u şir şi retureză de câte ori s- găsit crcterul. 4. Să se implemeteze o fucţie cre clculeză sum elemetelor de pe digol priciplă uei mtrice pătrte, utilizâd vribile poiter petru dresre elemetelor mtricei. 5. Chestiui de studit 5. Studiere oţiuilor teoretice şi eemplelor prezette. 5. Studiere problemelor rezolvte şi idetificre elemetelor de limbj şi lgoritmilor utilizţi. 5.3 Rezolvre problemelor propuse
Limbjul C cu plicții î liz umerică Structuri Lucrre r.6 STRUCTURI. Scopul lucrării Lucrre re c scop prezetre utilizării tipurilor de dte de tip structură î limbjul C.. Noţiui teoretice Limbjul C permite utiliztorului să defiescă oi tipuri de dte petru ve o reprezetre mi covebilă iformţiei. Eistă posibilitte grupării uor elemete, petru reprezet dte complee, cel mi des sub form uor structuri. Structur este o colecţie de vribile ce pot fi de tipuri diferite, grupte împreuă sub u sigur ume şi memortă îtr-o zoă cotiuă de memorie. Sit geerlă de declrre uei structuri este: struct ume_structur tip elem; tip elem; tip elem; list_vr_struct; î cre: struct = cuvât cheie socit structurilor; ume_structur = umele dt de utiliztor structurii; tipi = tipul elemetului elemi ; list_vr_struct = list vribilelor de tip structură ume_structur defiită terior. Elemetele compoete le uei structuri se umesc membrii su câmpuri. De eemplu u puct idetifict pri coordotele sle şi y pote fi reprezett pri itermediul uei structuri cu două câmpuri şi y de tip flot: struct puct flot ; flot y; m,; ir m şi sut două vribile de tip structură puct. Referire l u membru l uei structuri se fce cu jutorul opertorului puct. plst ître umele structurii şi umele membrului, m. fiid bscis puctului m. Iiţilizre uei vribile de tip structură se pote fce: - pri iiţilizre fiecărui membru l structurii su, - globl, pri eumerre, ître colde, vlorilor iiţile le membrilor, î ordie î cre pr î declrţie. Petru vribilele structură puct di eemplul precedet se pot fce iiţilizările: m.=0.5; m.y=m.+7; =.3, 34.5; Pot fi defiite şi structuri îcuibte. De eemplu, u dreptughi pote fi defiit pri două pucte le uei digole: struct dreptughi struct puct pt; struct puct pt; ; struct dreptughi d; d.pt.y=9.7; Î ultim tribuire, ordot puctului pt l dreptughiului d primeşte vlore 9.7. De semee, pot fi declrte tblouri cu elemete structuri: struct puct sirpucte[0]; Petru cest şir de pucte, secveţ: sirpucte[].=0; tribuie bscisei celui de-l treile puct vlore 0. Pot fi efectute operţii de tribuire ître vribile de tip structură de celşi tip, cre echivleză cu tribuiri membru cu membru. Pot fi defiite şi vribile poiter de tip structură: struct puct *pct; pct=&sirpucte[5]; Petru ccesul l u elemet l uei structuri idicte de u poiter se utilizeză opertorul de selecţie idirectă: -> (săget): pct->y=.3;
Limbjul C cu plicții î liz umerică Structuri 3. Probleme rezolvte 3. Se cosideră o grupă de mim 0 de studeţi idetificţi pri umele lor. Petru fiecre studet se cuosc otele l cele ptru emee di sesiue. Să se fişeze toţi studeţii bursieri ( căror medie este mi mre su eglă cu 8.5). #iclude<stdio.h> struct studet chr ume[5]; it ot; it ot; it ot3; it ot4; stud[0]; it i,; flot medie; void mi (void) pritf(" Dti umrul de studeti: "); scf("%d",&); for(i=0;i<;i++) pritf(" NUME="); scf("%s",stud[i].ume); pritf(" NOTA="); scf("%d",&stud[i].ot); pritf(" NOTA="); scf("%d",&stud[i].ot); pritf(" NOTA3="); scf("%d",&stud[i].ot3); pritf(" NOTA4="); scf("%d",&stud[i].ot4); i=0; while(i<) medie=(flot)(stud[i].ot+stud[i].ot+ stud[i].ot3+ stud[i].ot4)/4; if(medie>=8.5) puts(stud[i].ume); pritf("%5.f\",medie); i++; 3.. Progrmul următor utilizeză tipul structură socit cărţilor ditr-o bibliotecă şi fce o selecţie după ul priţiei. #iclude<stdio.h> #iclude<coio.h> struct crte chr titlu[0]; chr utor[0]; it ; flot pret; ; void mi(void) struct crte bib[50]; it i,=0; clrscr(); pritf("\ Dti umrul de crti:"); scf("%d",&); for(i=0;i<;i++) pritf(" Titlu="); scf("%s",bib[i].titlu); pritf(" Autor="); scf("%s",bib[i].utor); pritf(" Aul pritiei="); scf("%d",&bib[i].); pritf(" Pret="); scf("%f",&bib[i].pret); pritf("crti editte îite de revolutie:\"); i=0; while(i<) if(bib[i].<=989) puts(bib[i].titlu); puts(bib[i].utor); pritf("\"); i++;
Limbjul C cu plicții î liz umerică Structuri 4. Probleme propuse 4. Petru o grupă de studeţi se cuosc umele studeţilor şi 5 ote obţiute l sfârşitul semestrului. Se cere să se fişeze studeţii cre u u ici o restţă. 4.. Să se folosescă structuri de tip puct, petru determi dc trei pucte A,B,C (dte pri coordotele lor) pot form u triughi şi de ce tip (orecre, isoscel, echilterl). 5. Chestiui de studit 5. Studiere oţiuilor teoretice şi eemplelor prezette. 5. Studiere problemelor rezolvte şi idetificre elemetelor de limbj şi lgoritmilor utilizţi. 5.3 Rezolvre problemelor propuse. 4.3 Folosid tipul comple c o structură cu două câmpuri (prte relă şi prte imgiră), să se simuleze operţiile supr umerelor complee: dure, scădere, îmulţire, împărţire, modul, prte relă şi prte imgiră. 3
Limbjul C cu plicții î liz umerică Liste Lucrre r. 7 LISTE. Scopul lucrării Lucrre re c scop prezetre listelor î limbjul C, puâd ccetul pe reprezetre cestor cu jutorul structurilor de dte dimice.. Noţiui teoretice Î umite situţii este ecesră orgizre iformţiilor sub form uor liste. De eemplu list persoelor ditr-o istituţie, produselor ditr-u mgzi etc.. List este deci compusă di elemete de celşi tip, ir iformţi coţiută î fiecre elemet l listei este de multe ori compleă. List re u umăr vribil de elemete şi deci u crcter dimic. Astfel, l îceputul eecuţiei progrmului, list este golă urmâd c cest să fie complettă şi să i se ducă poi modificări, tot pri progrm. Limbjul C permite implemetre listelor cu jutorul vribilelor dimice de tip structură. Utilizre tblourilor petru reprezetre uor liste este posibilă, dr u este eficietă, deorece listele u u crcter dimic spre deosebire de tblouri. De cee, prctic uzulă este de ordo elemetele uei liste folosid vribile poiter cre itră î compoeţ elemetelor. Utilizre cestor vribile poiter dă u crcter recursiv elemetelor listei. Listele implemette stfel se umesc îlăţuite. Elemetele uei stfel de liste portă deumire uzulă de oduri. Dcă ître oduri eistă o sigură relţie de legătură list se umeşte simplu îlăţuită, ir dcă eistă două relţii de legătură list se umeşte dublu îlăţuită. Cele mi uzule operţii cre se pot efectu supr uei liste îlăţuite sut: crere listei, ccesul l u od, dăugre, ştergere su modificre uui elemet şi ştergere listei... Liste simplu îlăţuite Ître odurile uei liste simplu îlăţuite eistă o sigură relţie de legătură, de obicei de idicre succesorului uui elemet. Acestă legătură se implemeteză cu jutorul uui poiter ce memoreză dres odului următor di listă. De eemplu petru o listă de persoe simplu îlăţuită, l cre se cuosc umele, preumele şi vârst, odul re următore formă: struct od chr ume[5]; chr preume[5]; it vrst; struct od *urm;; Î cestă structură, câmpul urm v coţie dres următorului od di listă. El este u poiter l o vribilă de tip structură idetică cu ce di cre fce prte. Petru ultimul od di listă, vribil urm v ve vlore NULL, deorece u mi urmeză u lt od. De semee, spre primul od l listei u poiteză ici u lt od. Cuoştere primului şi ultimului elemet l listei este importţă, deorece permite ccesul l orice elemet pri prcurgere listei (îcepâd cu primul) şi fciliteză operţiile de dăugre de elemete oi l sfârşitul listei. Atuci câd trebuie dăugt u elemet î listă se prcurg etpele:. se locă dimic spţiu petru respectivul elemet,. se creeză elemetul pri îscriere iformţiilor corespuzătore şi 3. se legă î listă. Câd u elemet trebuie scos di listă, se rup şi se refc legăturile, ir spţiul ocupt de cest se elibereză...liste dublu îlăţuite Ître odurile uei liste dublu îlăţuite vor eist două relţii de legătură, cu elemetul terior şi cu elemetul următor. Î cest cz, vor eist doi poiteri de legătură ce memoreză dres odului terior şi respectiv celui următor di listă. Implemetre eemplului precedet se v fce, î czul utilizării listelor dublu îlăţuite, sub form: struct od chr ume[5]; chr preume[5]; it vrst; struct od *t; struct od *urm; ; Adăugre uui elemet îtr-o listă dublu îlăţuită v ecesit celeşi etpe c î czul listelor simplu îlăţuite. Fucţi cre relizeză dăugre uui elemet îtr-o listă dublu îlăţuită, l cărui od re structur de mi sus, v ve următore formă:
Limbjul C cu plicții î liz umerică Liste void dug(chr *Nume,chr *Preume,it Vrst) struct od *p; p=(struct od *)mlloc(sizeof(struct od)); if(p==null) pritf("memorie isuficietă.\"); retur; strcpy(p->ume,nume); strcpy(p->preume,preume); p->vrst=vrst; p->urm=null; ultim->urm=p; p->t=ultim; ultim=p; 3. Problemă rezolvtă Să se creeze o listă simplu îlăţuită persoelor ditr-o istituţie î cre să se memoreze umele, preumele şi vârst fiecărui. Să se fişeze persoele căror vârstă este mi mică de 40 de i. Persoele cre u vârst de pesiore (65 de i) vor fi elimite di listă. Se v fiş poi list persoelor rămse. #iclude <stdio.h> #iclude <strig.h> #iclude <lloc.h> #iclude <coio.h> struct od chr ume[5]; chr preume[5]; it vrst; struct od *urm;; struct od *prim,*ultim; void dug(chr *Nume,chr *Preume,it Vrst) struct od *p; p=(struct od *)mlloc(sizeof(struct od)); if(p==null) pritf("memorie isuficietă.\"); retur; strcpy(p->ume,nume); strcpy(p->preume,preume); p->vrst=vrst; p->urm=null; if(prim==null) prim=ultim=p; else ultim->urm=p; ultim=p; void sterge(struct od *p) struct od *q; if(!p) retur; if(prim==p) prim=p->urm; if(prim==null) ultim=null; else for(q=prim;q->urm!=p&&q->urm!=null;q=q->urm) if(q->urm==null) pritf("elemetul u prţie listei.\"); retur; q->urm=p->urm; if(p==ultim) ultim=q; free(p); void mi(void) chr Nume[5],Preume[5]; it Vrst; it i,; struct od *p,*q; pritf("numărul de persoe:");scf("%d",&); prim=ultim=null; for(i=0;i<;i++) pritf("nume:");gets(nume); pritf("preume:");gets(preume); pritf("vrst:");scf("%d",&vrst); dug(nume,preume,vrst); pritf("list persoelor sub 40 de i :\"); for(p=prim;p!=null;p=p->urm) if(p->vrst <= 40) pritf("%5s%5s - %d\", p->ume,p->preume,p->vrst); p=prim; while(p!=null) if(p->vrst > 65) q=p->urm; sterge(p); p=q; else p=p->urm; pritf("list persoelor rmse:\"); for(p=prim;p!=null;p=p->urm) pritf("%5s%5s - %d\",p->ume,p-> preume, p->vrst);
Limbjul C cu plicții î liz umerică Liste 4. Probleme propuse 4. Să se implemeteze list di problem rezolvtă 3 cu jutorul listelor dublu îlăţuite. 4. Să se creeze o listă studeţilor prezeţi l u eme de dmitere î cre să se memoreze umele, preumele şi medi de dmitere. Să se fişeze studeţii cre primesc bursă (cu medi peste 9.50). Studeţii cu medi de dmitere sub 5.00 sut cosiderţi respişi şi vor fi elimiţi di listă. Se v fiş poi list studeţilor dmişi. 5. Chestiui de studit 5. Studiere oţiuilor teoretice şi eemplelor prezette. 5. Studiere problemelor rezolvte şi idetificre elemetelor de limbj şi lgoritmilor utilizţi. 5.3 Rezolvre problemelor propuse 3
Limbjul C cu plicții î liz umerică - Fişiere i limbjul C Lucrre r.8 FIŞIERE IN LIMBAJUL C. Scopul lucrării Lucrre re c scop prezetre utilizării fişierelor î limbjul C.. Noţiui teoretice U fişier reprezită o colecţie ordotă de îregistrări. Mjoritte operţiilor de itrre ieşire se bzeză pe mipulre fişierelor. Dtele itroduse de l tsttură formeză u fişier de itrre, î timp ce dtele fişte pe disply su listte l imprimtă formeză u fişier de ieşire. Eistă două tipuri de fişiere: tet şi bire. Î timp ce fişierele tet coţi crctere ASCII î gm 0-7 (iformţie citibilă), fişierele bire coţi îşiruiri de crctere, eiteligibile petru utiliztor. De eemplu, fişierele sursă sut fişiere tet, î timp ce fişierele eecutbile sut fişiere bire. Prelucrre uui fişier presupue o serie de operţii precedte de deschidere fişierului şi filizte cu îchidere cestui. Î urm deschiderii uui fişier se geereză u poiter l o structură de tip FILE predeclrtă î stdio.h. Sit de declrre uui poiter l FILE este: FILE*fptr; fptr fiid umele vribilei poiter cu cre se lucreză î cotiure. Deschidere uui fişier se relizeză cu fucţi fope() cu sit geerlă: FILE *fope(cost chr*ume_fisier, cost chr *mod); î cre: ume_fisier este umele fişierului cre se v deschide su cre; mod este modul î cre este deschis fişierul: r deschide fişierul petru citire; w deschide u fişier petru scriere; deschide su creeză u fişier petru scriere l sfârşitul fişierului (dăugre); r+ deschide u fişier petru ctulizre (citire + scriere); w+ deschide u fişier petru ctulizre, coţiutul terior se elimiă; + deschide u fişier petru ctulizre l sfârşit. Fişierele pot fi deschise î mod bir su tet, după cum este specifict î rgumetul mod l fucţiei fope pri dăugre literei t petru tet su b petru bir. Dcă operţi de deschidere re succes, fucţi retureză u poiter l FILE (poiter cre v fi folosit î cotiure î operţiile supr fişierului), ir dcă eşueză, fope îtorce vlore NULL. Î eemplul următor: FILE *fptr, *fptr; fptr=fope( fist.tt, r+t ); fptr=fope( fisb.bi, wb ); sut deschise două fişiere: primul de tip tet petru operţii de ctulizre şi cel de-l doile de tip bir petru scriere. Îchidere uui fişier se relizeză cu fucţi fclose() vâd sit geerlă: it fclose(file* fptr_fisier); cre v îchide fişierul specifict de fptr_fisier. Fucţi fclose() retureză vlore 0 î cz de îchidere cu succes fişierului şi EOF dcă părut o erore. Îchidere fişierelor di eemplul precedet se v fce cu secveţ: fclose(fptr); fclose(fptr); Scriere de dte î fişier se relizeză cu jutorul fucţiei fpritf(): it fpritf(file *fptr, cost chr *formt, rg, rg,,rg) cre scrie î fişierul poitt de fptr dtele specificte de rg rg, î formtul specifict pri şirul de crctere formt. Î eemplul: FILE *fpt; it i=5; chr c= B ; flot f=.7543; fpt=fope( fis.dt, w ); fpritf(fpt, %d,%c,%f,i,c,f); pri utilizre fucţiei fpritf(), se scriu î fişierul fis.dt, descris de fpt, u îtreg, u crcter şi o vribilă de tip flot. Citire de dte ditr-u fişier se relizeză cu jutorul fucţiei fscf(): it fscf(file *fptr, cost chr *formt, rg, rg,,rg) cre citeşte di fişierul idict de fptr dte sub cotrolul formtului specifict î formt şi le tribuie vribilelor pri dresele specificte î rg, rg, rg, cre, de cestă dtă, sut poiteri.
Limbjul C cu plicții î liz umerică - Fişiere i limbjul C 3. Problemă rezolvtă Să se creeze u fişier tet ce coţie iformţii despre produsele ditr-u mgzi. Să se scrie poi o fucţie de dăugre, poi u de căutre î fişier după ume şi modificre umărului de bucăţi. Î fil să se listeze coţiutul fişierului modifict. #iclude<stdio.h> #iclude<strig.h> #iclude<coio.h> #iclude<process.h> #defie f "produse.tt" typedef struct chr ume[0]; it r; flot pret; prod; FILE *fp; void crere () if((fp=fope(f,"w"))==null) pritf("erore de crere\"); eit(); fclose(fp); void listre () prod s; clrscr(); if((fp=fope(f,"r"))==null) pritf("erore de deschidere \"); eit(); do fred(&s,sizeof(prod),,fp); if(feof(fp)) bre; pritf("\%s",s.ume); pritf("\%d",s.r); pritf("\%5.f",s.pret); while (!feof(fp)); fclose(fp); void dugre () chr c; prod s; clrscr(); if((fp=fope(f,""))==null) pritf("erore de deschidere\"); eit(); c='d'; while(c=='d') pritf("\ Nume:"); scf("%s",s.ume); pritf("\numrul de bucti:"); scf("%d",&(s.r)); pritf("\pret: "); scf("%f",&(s.pret)); fwrite(&s,sizeof(prod),,fp); pritf("\\ Mi doriţi dăugre? (d/): "); c=getch(); fclose(fp); void modificre() prod s; log it poz; it gsit=0; chr [0]; it rou; pritf("\ Dti umele dup cre se cut: "); scf("%s",); pritf("\ Dti ou ctitte: "); scf("%d",&rou); if((fp=fope(f,"r+"))==null) pritf("erore de deschidere\"); eit(); while((!gsit)&&(!feof(fp))) poz=ftell(fp); fred(&s,sizeof(prod),,fp); if(!strcmp(,s.ume)) gsit++; if(!gsit) pritf("\nu s- gsit iregistrre "); getch(); else fsee(fp,poz,seek_set); fred(&s,sizeof(prod),,fp); s.r=rou; fsee(fp,poz,seek_set); fwrite(&s,sizeof(prod),,fp); fclose(fp); void mi() crere(); dugre(); listre(); modificre(); listre();
Limbjul C cu plicții î liz umerică - Fişiere i limbjul C 4. Probleme propuse 4.. Să se creeze şi să se listeze u fişier bir cu studeţi, î cre să se memoreze umele şi două ote. Dtele se citesc ditr-u fişier tet cret terior. 4.. Să se scrie o procedură de crere uui fişier tet ce coţie ume de studeţi şi o lt de ctulizre pri dăugre cestui fişier. Î fil se v scrie o procedură de listre coţiutului fişierului. 5. Chestiui de studit 5. Studiere oţiuilor teoretice şi eemplelor prezette. 5. Studiere problemei rezolvte şi idetificre elemetelor de limbj şi lgoritmilor utilizţi. 5.3 Rezolvre problemelor propuse 3
Limbjul C cu plicții î liz umerică Rezolvre ecuţiilor Lucrre r. 9 REZOLVAREA ECUAŢIILOR. Scopul lucrării Lucrre re c scop prezetre uei metode umerice de rezolvre ecuţiilor lgebrice şi trscedete cu jutorul limbjului C++.. Noţiui teoretice Eistă mi multe metode umerice utilizte petru clculul rădăciilor rele le uei ecuţii lgebrice: metod bisecţiei, metod poziţiei flse, metod proimţiilor succesive, metod lui Newto, metod lui Birstow, etc.. Aceste sut metode de clcul cre presupu utilizre uor lgoritmi umerici ce permit găsire rădăciilor. Îite de clculul propriu-zis l rădăciilor (pri procedee itertive), trebuie reliztă o seprre rădăciilor ce costă î găsire celor itervle cre coţi cel mult o rădăciă. Metod bisecţiei Acestă metodă mi este umită metod îjumătăţirii itervlului su metod biprtiţiei. Metod permite găsire uei rădăcii (cu o umită erore ε) ecuţiei: f()=0 î itervlul [,b], ude f : [,b] >R şi f este cotiuă pe [,b]. Se presupue că s- relizt î prelbil o seprre rădăciilor, stfel îcât pe itervlul [,b] eistă cel mult o rădăciă ξ. Algoritmul îcepe pri lizre următorelor ptru situţii:. f()=0 şi deci ξ=;. f(b)=0 şi deci ξ=b; 3. f() f(b)<0 şi tuci ξ prţie itervlului (,b) 4. f() f(b)>0 şi tuci u eistă o rădăciă î itervlului [,b]. Vritele, şi 4 presupu îcheiere procesului de găsire rădăciii. Algoritmul cotiuă, î vrit 3, cu îjumătăţire itervlului [,b] şi determire vlorii 0 =(+b)/. Se verifică dcă 0 este soluţie ecuţiei, pri evlure f( 0 ) < ε. Î cz cotrr, se lege semiitervlul [,b ] l cpetele cărui fucţi re seme opuse (f( ) f(b ) 0) şi se repetă pşii de mi sus. Se obţi itervle de tip [ i, b i ] c fiid jumătte di itervlul [ i-, b i- ] pri metod geerlă: i- =( i- +b i- )/; i = i-, b i = i- dcă f( i- ) f( i- )<0 i = i-, b i =b i- dcă f( i- ) f( i- )>0 Se obţi stfel două şiruri covergete: - şirul l etremităţilor stâgi le itervlelor, cre este mooto crescător ( < < < ) - şirul b l etremităţilor drepte le itervlelor, cre este mooto descrescător (b > b > > b ) Se observă şi că b - =(b-)/. Aşdr, şi b vor coverge mbele către soluţi ξ, deorece eistă o vlore petru cre b - < ε, ude ε este erore impusă petru clculul soluţiei ecuţiei dte. Se pote proim soluţi ecuţiei cu vlore mijlocului itervlului [, b ]. Î cotiure, pe bz lgoritmului prezett, se vor prezet două fucţii î limbjul C++, corespuzătore rezolvării ecuţiilor lgebrice şi respectiv trscedete. Eemplul it bisectiepol (double s, double d, it grd, double coef[], double err, double *rd) double m ; if(poly(s,grd,coef)*poly(d,grd,coef)>0) retur 0; if( poly (s,grd,coef) == 0 ) *rd=s; retur ; if(poly(d,grd,coef)==0) *rd=d; retur ; m=0.5*(s+d);
Limbjul C cu plicții î liz umerică Rezolvre ecuţiilor while((fbs(d-s)>err) &&(poly(m,grd,coef)!=0)) m=0.5*(d+s); if(poly(s,grd,coef)*poly(m,grd,coef)<0) d=m; else s=m; *rd=m; retur ; Î cest eemplu s şi d reprezită limitele stâg şi respectiv drept le itervlelor de lucru, ir m mijlocul cestor. Este utiliztă fucţi mtemtică poly() di mth.h, cre permite flre vlorii uui poliom îtr-u puct (primul prmetru l fucţiei) cuoscâdu-se grdul poliomului (l doile prmetru) şi vectorul coeficieţilor cestui (l treile prmetru). Fucţi îtorce vlore 0 î czul î cre u este găsită o rădăciă î itervlul specifict şi vlore î cz de succes, vlore soluţiei fiid trsfertă î vribil *rd. Eemplul. it bisectiefct(double(*f)(double),double s, double d, double err, double *rd) double m; if(f(s)*f(d)>0) retur 0; if(f(s)==0) *rd=s; retur ; if(f(d)==0) *rd=d; retur ; m=0.5*(s+d); while( (fbs(d-s)>err)&&(f(m)!=0) ) m=0.5*(s+d); if( f(s)*f(m)<0) d=m; else s=m; *rd=m; retur ; Implemetre cestei fucţii s- relizt î mod semăător cu fucţi di eemplul. Primul prmetru l cestei fucţii este u poiter ce coţie dres fucţiei mtemtice petru cre se cută soluţiile. 3. Probleme rezolvte 3. Să se fle dcă ecuţi: 3-9 +3-5=0 re o rădăciă î itervlul (-4.5,6), şi să se fle vlore cestei (î czul î cre eistă) cu o erore de 0.00000. #iclude<mth.h> #iclude<iostrem.h> it bisectiepol (double s, double d, it grd, double coef[], double err, double *rd) double m ; if(poly(s,grd,coef)*poly(d,grd,coef)>0) retur 0; if( poly (s,grd,coef) == 0 ) *rd=s; retur ; if(poly(d,grd,coef)==0) *rd=d; retur ; m=0.5*(s+d); while((fbs(d-s)>err) &&(poly(m,grd,coef)!=0)) m=0.5*(d+s); if(poly(s,grd,coef)*poly(m,grd,coef)<0) d=m; else s=m; *rd=m; retur ; void mi(void) double *rd; double f[]=-5,3,-9,; if (bisectiepol(4.5,6,3,f,0.00000,rd)==) cout<<"fucti re o rdci i itervlul (4.5,6) egl cu:"; cout<<*rd; else cout<<"fucti u re rdci i itervlul specifict";
Limbjul C cu plicții î liz umerică Rezolvre ecuţiilor 3.. Să să fle soluţi ecuţiei trscedete e 0 î itervlul (0.,), plicâd metod bisecţiei cu o erore de clcul de 0.000000000 #iclude<mth.h> #iclude<iostrem.h> double fct(double ) double vl_fct; vl_fct=-ep(-); retur (vl_fct); it bisectiefct(double(*f)(double),double s, double d, double err, double *rd) double m; if(f(s)*f(d)>0) retur 0; if(f(s)==0) *rd=s; retur ; if(f(d)==0) *rd=d; retur ; m=0.5*(s+d); while( (fbs(d-s)>err)&&(f(m)!=0) ) m=0.5*(s+d); if( f(s)*f(m)<0) d=m; else s=m; *rd=m; retur ; void mi(void) double s=0.,d=.0,err=0.0000000,*sol; bisectiefct(fct,s,d,err,sol); cout<<"soluti ecutiei f()=0 pe itervlul: ("<<s<<","<<d<<") este: "<<*sol; 4. Probleme propuse 4. Să se fle dcă ecuţi 3 6 +8=0 re o rădăciă î itervlul (,3), ir î cz firmtiv să se găsescă cestă soluţie. 4. Să se găsescă o rădăciă ecuţiei si() 0.5 0 î itervlul (,) cu o precizie de 0.00000. 5. Chestiui de studit 5. Studiere oţiuilor teoretice şi eemplelor prezette. 5. Studiere problemelor rezolvte şi idetificre elemetelor de limbj şi lgoritmilor utilizţi. 5.3 Rezolvre problemelor propuse 3
Limbjul C cu plicții î liz umerică Iterpolre fucţiilor Lucrre r. 0 INTERPOLAREA FUNCŢIILOR. Scopul lucrării Lucrre re c scop prezetre uei metode umerice de proimre fucţiilor tbelte şi implemetării cestei î limbjul C++.. Noţiui teoretice Iterpolre reprezită o metodă umerică de proimre fucţiilor dte sub formă tbelră. Avâd u set discret de dte [ i,y i ] (i=0,,,) (obţiut î urm uor eperimete, măsurători etc.), metod presupue găsire uei fucţii f() cotiuă cre să verifice y i =f( i ) (i=0,,,). Fucţi f() se umeşte fucţie de iterpolre, ir puctele i oduri le reţelei de iterpolre. Uzul, fucţi de iterpolre re o formă simplă petru permite cu uşuriţă flre vlorilor î orice puct l domeiului de defiiţie şi petru pute fi uşor prelucrtă (derivtă, itegrtă etc.). De cee, iterpolre este utiliztă şi î cdrul metodelor umerice de derivre, itegrre etc.. Clculul fucţiei f() petru vlori le lui cuprise ître odurile reţelei de iterpolre se umeşte iterpolre, ir dcă se flă î fr reţelei, etrpolre.. Iterpolre poliomilă Ce mi utiliztă fucţie de iterpolre este fucţi poliomilă. Iterpolre poliomilă presupue găsire uui poliom P() cre să verifice: P( i )=y i, i=0,,, () Dcă poliomul P() re epresi: P () 0 () codiţiile di relţi () sut echivlete cu: 0 0 0 0 0 0 y y y 0 (3) Deorece determitul cestui sistem (de tip Vdermode): D ( (4) i, j 0 j i j i) este diferit de zero (odurile i sut disticte), sistemul v ve o soluţie uică petru coeficieţii 0,.. şi deci petru poliomul de iterpolre. Se obţie ş umitul poliomul de iterpolre l lui Lgrge, cre re form: j P ( ) yi (5) i 0 j 0, j i Deci, cu jutorul cestui poliom, se pote clcul vlore fucţiei î orice puct ecuoscut cupris ître 0 si. Implemetre poliomului de iterpolre Lgrge se pote fce cu fucţi C++: double lgrge(it, flot [], flot y[],flot poit) it i,j; flot sum=0, prod; for(i=0; i<; i++) prod = ; for(j=0;j<;j++) if (j!=i) prod*=(poit-[j])/([i]-[j]); sum+=y[i]*prod; retur sum; Î czul î cre reţeu de iterpolre re dor două pucte, iterpolre devie liiră: f () y y y (6) Ultim eglitte di relţi (6) reprezită chir ecuţi uei drepte cre trece pri puctele (,y ) şi (,y ). i j
Limbjul C cu plicții î liz umerică Iterpolre fucţiilor 3. Problemă rezolvtă Î urm uor măsurători s-u obţiut următorele dte memorte î vribilele şi y: 0 0. 0. 0.3 0.4 0.5 0.6 0.7 0.8 0.9 y 7 4 7 0 5 6 8 9 30 Se cere să se determie pucte ître odurile reţelei de iterpolre ( de eemplu petru: =0.35 ; =0.64 ; =0.89) #iclude<iostrem.h> double lgrge(it, flot [], flot y[],flot poit) it i,j; flot sum=0, prod; for(i=0; i<; i++) prod = ; for(j=0;j<;j++) if (j!=i) prod*=(poit-[j])/([i]-[j]); sum+=y[i]*prod; retur sum; 4. Problemă propusă Plecâd de l dtele problemei rezolvte 3, să se scrie u progrm cre relizeză iterpolre, îsă petru u umăr mi mic de oduri le reţelei de iterpolre. De eemplu, petru 7 oduri lese î mod diferit: uiform distribuit, mi multe î prim prte su mi multe î dou prte. Să se compre rezulttele obţiute petru flre vlorilor fucţiei î puctele =0.35, =0.64 şi =0.89. Să se cometeze rezulttele obţiute. 5. Chestiui de studit 5. Studiere oţiuilor teoretice şi eemplelor prezette. 5. Studiere problemelor rezolvte şi idetificre elemetelor de limbj şi lgoritmilor utilizţi. 5.3 Rezolvre problemei propuse. void mi(void) it =0; flot vl; flot []=0,0.,0.,0.3,0.4,0.5,0.6,0.7,0.8,0.9; flot y[]=7,4,7,0,,5,6,8,9,30; flot p=0.64; vl=lgrge(,,y,p); cout<<"vlore fuctiei de iterpolre i puctul ="<<p<<" este: "<<vl;