48627669.

doc

CUPRINS
CUPRINS................................................................................................................................................i Cap 1 INTRODUCERE ÎN LIMBAJUL C...........................................................................................4 1.1 Scurt istoric..................................................................................................................................4 1.2 Forma unui program C..............................................................................................................8 1.3 Compilarea unui program C......................................................................................................9 Cap 2 Tipuri, operatori, expresii.........................................................................................................10 2.1. Tipuri simple.............................................................................................................................11 2.2. Literali ......................................................................................................................................11 2.3. Declararea unei variabile şi a unei constante........................................................................12 2.4. Operatori...................................................................................................................................14 2.4.1. Operatori aritmetici.............................................................................................................14 2.4.2. Operatorii relaţionali (de comparaţie).................................................................................15 2.4.3. Operatori logici...................................................................................................................15 2.4.4. Operatori la nivel de bit......................................................................................................15 2.4.5. Operatorul de asignare........................................................................................................16 2.4.6. Operatorul condiţional........................................................................................................17 2.4.7. Operatorul virgulă...............................................................................................................17 2.4.8. Precedenţa operatorilor.......................................................................................................17 Cap 3 FUNCTII...................................................................................................................................19 3.1. Definirea unei funcţii...............................................................................................................19 3.2. Returnarea unui apel...............................................................................................................20 3.3. Funcţii cu un număr variabil de parametri..........................................................................20 3.4. Sfârşitul execuţiei unui program............................................................................................20 3.5. Apelul şi transmiterea parametrilor......................................................................................21 3.6. Funcţia principală main..........................................................................................................22 Cap 4 FUNCŢII DE INTRARE IEŞIRE............................................................................................24 4.1.Fluxuri şi fişiere.........................................................................................................................24 Semnificaţia......................................................................................................................................26 4.2. Funcţii de intrare/ieşire pentru caractere..............................................................................27 4.3. Scrierea cu format....................................................................................................................27 4.5. Citirea cu format......................................................................................................................31 Cap 5 INSTRUCŢIUNI DE CONTROL.............................................................................................34 5.1. Instrucţiunea if.........................................................................................................................35 5.3. Instrucţiunea while...................................................................................................................37 5.4. Instruc]iunea do ... while.........................................................................................................38 5.5. Instrucţiunea for.......................................................................................................................39
i

Gheorghe GRIGORAŞ

5.6. Instrucţiunea break..................................................................................................................40 5.7. Instrucţiunea continue.............................................................................................................41 5.8. Instrucţiunea go to...................................................................................................................41 5.9. Exerciţii.....................................................................................................................................42 Calculul factorialului. ...................................................................................................................42 2. Conversie...................................................................................................................................42 3. Numărarea biţilor 1 într-un număr............................................................................................42 4. Prezentare de date......................................................................................................................42 5.10. Soluţii la exerciţii...................................................................................................................42 1. Calculul factorialului.................................................................................................................43 2. Conversie...................................................................................................................................43 3. Numărarea biţilor 1 într-un număr............................................................................................44 4. Prezentare de date......................................................................................................................45 Cap 6 TABLOURI ŞI POINTERI.......................................................................................................46 6.1. Pointeri......................................................................................................................................46 6.2. Tablouri cu o dimensiune........................................................................................................47 6.2.1. Referenţierea unui element al tabloului..............................................................................47 6.2.2. Iniţializarea unui tablou......................................................................................................48 6.3. Relaţia între pointeri şi tablouri.............................................................................................49 6.4. Operaţii aritmetice cu pointeri...............................................................................................50 6.5. Şiruri de caractere....................................................................................................................50 6.6. Tablouri cu mai multe dimensiuni.........................................................................................51 6.7. Tablouri de pointeri.................................................................................................................52 6.8. Pointeri şi alocarea memoriei..................................................................................................53 6.9. Operatorul “sizeof”..................................................................................................................54 6.10. Pointeri către funcţii..............................................................................................................55 6.11. Exerciţii...................................................................................................................................56 6.12. Soluţii.......................................................................................................................................57 Cap 7 CONSTRUIREA DE NOI TIPURI..........................................................................................59 7.1. Redenumirea unui tip..............................................................................................................59 7.2. Tipul structură........................................................................................................................60 7.3. Accesul şi iniţializarea câmpurilor unei structuri.................................................................61 7.4. Structuri autoreferenţiate.......................................................................................................62 7.5. Tipul enumerare.......................................................................................................................63 7.6. Uniuni.......................................................................................................................................64 7.7. Exerciţii.....................................................................................................................................65 7.8. Soluţii.........................................................................................................................................66 Cap 8 GESTIUNEA MEMORIEI.......................................................................................................70 8.1. Precizarea unui mecanism de memorare...............................................................................71 8.2. Gestiunea automată a memoriei.............................................................................................71
ii

48627669.doc

8.3. Gestionarea “register” a memoriei.........................................................................................72 8.4. Gestionarea statică a memoriei...............................................................................................72 8.5. Variabile globale.......................................................................................................................72 8.6. Declararea variabilelor externe..............................................................................................73 8.7. Gestiunea dinamică a memoriei..............................................................................................73 8.8. Exerciţii.....................................................................................................................................74 8.9. Soluţii.........................................................................................................................................74 Cap 9 CONVERSIA DE TIP...............................................................................................................77 9.1. Mecanisme de conversie..........................................................................................................77 9.1.1 Conversia la asignare...........................................................................................................78 9.1.2 Evaluarea expresiilor aritmetice...........................................................................................79 .....................................................................................................................................................79 9.1.3. Evaluarea expresiilor logice................................................................................................79 9.1.4 Conversii explicite................................................................................................................80 9.1.5 Conversie de pointeri. Pointerul universal...........................................................................80 Cap 10 PREPROCESORUL................................................................................................................82 10.1 Directive preprocesor..............................................................................................................82 10.1.1 Constante simbolice. Directiva #define.............................................................................83 10.1.2 Includerea fişierelor...........................................................................................................83 10.1.3 Compilare condiţionată......................................................................................................84 10.1.4 Directiva #error..................................................................................................................85 10.2 Macroinstruţiuni.....................................................................................................................85 10.2.1 Macroinstrucţiuni predefinite.............................................................................................85 10.2.2 Macroinstrucţiuni tip funcţie..............................................................................................86 Cap 11 EXERCIŢII..............................................................................................................................87 BIBLIOGRAFIE..................................................................................................................................89 ANEXA.................................................................................................................................................90 Biblioteca standard C......................................................................................................................90 Codul ASCII....................................................................................................................................93

iii

un limbaj bazat pe BCPL care a fost proiectat de asemenea de către Ken Thompson în 1970. este oficial din “Combined” dar neoficial se consideră a fi iniţiala pronumelui lui Cristopher Strachey. care la început s-a numit NB dar numele său a fost stabilit C. operanzii flotanţi din expresii trebuiau precedaţi de punct. restul operanzilor erau consideraţi întregi. Problemele create în jurul limbajelor BCPL şi B au dus la dezvoltarea unui nou limbaj. Numele “C”. cel care a condus echipa ce a proiectat CPL-ul. BCPL a fost proiectat de Martin Richards în 1967 şi face parte din categoria “low-level languages”. Proiectarea limbajului B a fost influienţată de limitele maşinii pe care a fost implementat: un PDP-7 cu capacitatea 4K ( cuvinte de 18 biţi).3 Scurt istoric Forma unui program C Compilarea unui program C 1. la Bell Laboratories în USA. CPL a fost dezvoltat la Universităţile Cambridge şi London în anii 1960-1963. Limbajele BCPL şi B sunt limbaje de nivel scăzut faţă de limbajul Pascal şi nici unul din ele nu este tipizat: toate datele sunt considerate cuvinte maşină încât. sau “systems programming languages”. În mare parte ( construcţiile for şi . Limbajul a fost proiectat şi implementat de către Dennis Ritchie la Bell Laboratories în 1972. Primul limbaj de nivel înalt implementat sub acest sistem de operare a fost limbajul B.2 1.1 Scurt istoric Strămoşii limbajului C sunt limbajele de programare CPL. bazat pe B. B şi Algol 68. În una din implementările BCPL-ului.Cap 1 INTRODUCERE ÎN LIMBAJUL C 1. În anii ’60. BCPL.1 1. considerat la început a proveni de la Cambridge. Ken Thomson a început proiectarea sistemului de operare Unix. exemple simple de programe duc la complicaţii nebănuite. sintaxa este total diferită. Asemănarea cu BCPL a fost mai degrabă semantică.

Odată cu creştere popularităţii calculatoarelor personale. De exemplu.48627669. unele din acestea au adăugate o serie de facilităţi sau extensii proprii care nu împiedică compilarea unui program standard. în prezent . Un fapt cu totul inedit a fost acela că.doc switch. este lipsa totală a verificării tipului (type checking). adică a elementelor de bază în funcţionarea unui calculator. Are de asemenea o mulţime bogată de operatori care-i dau un înalt grad de expresivitate. Se înţelege că au existat şi neconcordanţe în multitudinea de “dialecte” ale limbajului. o variabilă de un tip scalar oarecare poate apare în aceeaşi expresie 5 .1. Ada) cu gradul de control şi flexibilitatea oferite de către limbajul de asamblare. Genealogia limbajului C este prezentată în Figura 1. tratarea pointerilor etc.versiunea 5 şi multă vreme a constituit un standard (neoficial de altfel) al limbajului şKeR 78ţ. Unul din motivele pentru care limbajul C este în acelaşi timp agreat de mare parte din programatori şi dezagreat de altă mare parte din programatori. a octeţilor şi a adreselor de memorie. au apărut numeroase alte implementări ale limbajului C şi astfel a crescut şi popularitatea acestuia. C permite manevrarea biţilor. Limbajul C are structuri de control adecvate precum şi facilităţi de structurare a datelor care îl fac să fie folosit într-o diversitate de domenii. programele scrise în C au un grad mare de portabilitate: uşurinţa de a adapta programele scrise pentru o anumită categorie de calculatoare sau sisteme de operare la alte calculatoare sau sisteme de operare. Algol. mare parte din implementările C -ului s-au dovedit de un mare grad de compatibilitate: un program scris pentru una din variante putea fi compilat cu succes folosind o altă variantă. Din acest motiv varianta clasică a limbajului C a fost asociată sistemului de operare Unix .1. Standardul ANSI ( American National Standard Institute) a fost redactat abia în decembrie 1989 şi a fost pus la dispoziţia celor interesaţi la începutul lui 1990. De altfel. Fortran. toate compilatoarele C sunt compatibile cu standardul ANSI C. Firma Borland a folosit acest standard în faza de proiect şi a realizat implementările Turbo C care se bucură de un succes remarcabil. •FORTRAN I (1957) •FORTRAN II (1958) •ALGOL 60 (1960) •ALGOL 68 (1968) •CPL (1963) •BCPL (1967) •B (1970) •C (1972) •C++ (1984) Figura 1. Pentru eliminarea acestora în 1983 a fost creată o comisie care să stabilească un standard al acestui limbaj. Modula. În ciuda acestui fapt . Limbajul C este privit ca un limbaj de nivel mediu întrucât combină cele mai reuşite elemente ale limbajelor de nivel înalt ( Pas-cal.) limbajul a fost influienţat şi de Algol 68. Ritchie a lucrat pe un calculator DEC PDP-11 sub sistemul de operare Unix.

limbajul a căpătat o mare popularitate în lumea academică şi nu numai. Cei care agrează limbajul C îi apreciază flexibilitatea sa. Bjarne Stroustrup a realizat în Octombrie 1979 un preprocesor. Mesa. chiar dacă era clădit pe C. proiect ce trebuia să realizeze distribuirea nucleului UNIX într-o reţea de computere conectate LAN. • C este un limbaj eficient: semantica sa este “low level” ceea ce înseamnă că pot fi folosite cu eficienţă resursele hardware pentru programele C. un membru al echipei lui Stroustrup. C++arm reprezintă “The Annotated C++ Reference Manual” iar C++std este standardul ANSI C++. numit Cpre. Compilatoarele oferite împreună cu sistemul Unix sunt relativ ieftine (uneori chiar gratuite) şi pot fi folosite pe o diversitate de maşini. ++ can. Clu) pentru acest proiect sunt expuse chiar de creatorul noului limbaj: • C este un limbaj flexibil: se poate folosi în orice domeniu şi permite utilizarea oricăror tehnici de programare. In C++. • C este un limbaj portabil: chiar dacă un program C nu este automat portabil de la o maşină la alta.Gheorghe GRIGORAŞ cu o variabilă de un alt tip scalar. •Fortran(1956) •Algol 60(1960) •CPL(1963) 6 . acesta oglindeşte conceptele fundamentale ale unui computer tradiţional. • C este un limbaj disponibil: un limbaj pentru care se poate găsi cu uşurinţă un compilator. depending on context. Pentru realizarea acestui proiect. Cele mai mari influienţe asupra noului limbaj le-au avut: Simula care a dat clasele. Datele care apar în paranteză se referă la prima implementare disponibilă pentru limbajul respectiv(după [STR 94]). este prezentată genealogia limbajului C++ iar figura 1. cei care nu-l agrează îl consideră un limbaj lipsit de siguranţă. este că datorită faptului că face parte din sistemul de operare Unix. În martie 1980 preprocesorul îmbunătăţit era implementat pe 16 sisteme iar limbajul acceptat de acesta a fost numit “C cu Clase”. indiferent de ce calculator dispunem. Ada. După numele “ C cu clase” limbajul a fost “botezat” C84. era vorba totuşi de un nou limbaj. Algol 68 care a dat supraîncărcarea operatorilor. numită C++. tough it is always pronounced “plus plus”. Originea acestui limbaj şSTR 94ţ trebuie căutată în proiectul care a început în Aprilie 1979 la “Computing Research Center of Bell Laboratories” în Murray Hill. USA. prezintă etapele importante din proiectarea limbajului. a apărut în 1984. Smalltalk.>> În figura 1. had a nice interpretation.3. Asta pentru scurt timp însă deoarece comitetul ANSI pentru standardizarea C-ului a atras atenţia că se poate crea o confuzie cu această denumire.Iată ce spune Stroustrup despre această alegere: <<I picked C++ because it wos short. and wasn’t of the form “adjective C”.2. şi a fost folosit pentru prima dată în Decembrie 1983. Motivele pentru care a fost ales limbajul C (în faţa altor limbaje ale vremii: Modula-2. care a adăugat la limbajul C conceptul de clasă folosit pentru prima dată de limbajul Simula ( dezvoltat în anii 1962-1967 de norvegienii Kristen Nyagaard şi Ole-Johan Dahl). be read as “next”. referinţele şi abilitatea de a declara variabile oriunde în cadrul unui bloc şi BCPL de unde a fost luată forma de prezentare a comentariilor cu //. Ceea ce este sigur. Numele C++ a fost sugerat de Rick Mascitti. New Jersey. acest lucru este posibil în general fără un efort deosebit. “succesor” or “increment” . Aşa cum vom vedea pe parcursul prezentării limbajului. O nouă versiune a limbajului C.

doc •BCPL(1967) •Simula 67(1969) •C •Algol 68(1977) •C cu Clase (1980) •Ada (1983) •ANSI C (1986) •C++ (1984) •ML(1976) •Clu(1978) •C++arm(1990) •C++std (1995) Figura 1. 1979 1980 1982 1983 1984 1985 1986 1987 1988 1990 1991 1992 1994 Mai Octombrie Aprilie Ianuarie August Decembrie Ianuarie Februarie Octombrie Septembrie Noiembrie Decembrie Ianuarie Iunie Martie Mai Mai Iunie Februarie Martie Mai August Începutul proiectului “C cu clase” Prima implementare a lui C cu clase Primul raport intern la Bell Labs asupra lui C cu clase Primul articol extern asupra lui C cu clase Prima implementare a limbajului C++ Limbajul a fost “botezat” C++ Primul manual C++ Prima lansare externă C++ Manualul The C++ Programming Language Prima conferinţă OOPSLA (centrată pe Smalltalk) Prima conferinţă USENIX C++ Prima lansare GNU C++ Prima implementare Oregon Software C++ Prima implementare Zortech C++ Prima reuniune tehnică ANSI X3J16 pentru C++ Prima implementare Borland C++ C++arm: The Annotated C++ Reference Manual Prima reuniune ISO WG21 Prima lansare DEC C++ Prima lansare Microsoft C++ Prima lansare IBM C++ A fost înregistrat Raportul Comitetului ANSI/ISO 7 .2.48627669.

char raspuns.a = b. In caz contrar. primul limbaj de programare studiat (cel puţin până acum) a fost altul decât limbajul C. } Să trecem în revistă structura programului prezentat.h> int cmmdc (int x. do { printf (" Introduceti 2 valori intregi pozitive -->"). cel care se apucă de învăţat limbajul C. b este valoarea cautata. . } printf (" Cmmdc al celor doua numere este: %d\n".se calculeaza restul impartirii intregi a lui a prin b. &b). Aceasta pentru că în programa de liceu. x = y. se începe cu un limbaj diferit de C iar în învăţământul superior.b)). scanf ("%c". la facultăţile care au în planul de învăţământ informatică şi chiar la cele de profil. return x. scanf ("%d%d". return 0. */ # include <stdio. Trebuie reţinut faptul că orice program C conţine definiţia unei funcţii cu numele main care ţine locul programului 8 . Urmează o linie ce începe cu #.cmmdc (a. 1. Aceste comentarii sunt incluse între "parantezele" “/*” şi “*/”. int y){ int rest. if (b>a) { int c = a. do { rest = x%y.h. b capata valoarea restului si procedeul se repeta. Vom începe prezentarea printr-un exemplu. mai ştie cel puţin un limbaj de programare (Pascal în cele mai multe cazuri).b = c. Pe această linie este o directivă care este gestionată de precompilator (preprocesor) şi permite includerea definiţiilor funcţiilor intrare/ieşire furnizate de sistem şi care se găsesc în fişierul stdio.2 Forma unui program C În general.b. } while (raspuns!=’n’). Programul 1 /* Calculul celui mai mare divizor comun (cmmdc) a doua numere intregi pozitive a si b.daca acest rest este nul. la disciplina de informatică. Primele linii din program constituie comentarii. &raspuns). Programul pe care l-am prezentat este constituit din două funcţii: main şi cmmdc.Gheorghe GRIGORAŞ Figura 1.3. &a. a capata valoarea lui b. Metoda care se aplica pentru a determina cmmdc este urmatoarea: . printf (" Continuati ? d)a n)u -->"). } int main (){ int a. y = rest. } while (rest!=0).

Unele compilatoare au programul propriu de legare. atunci trebuie folosit un editor pentru crearea fişierului sursă C. Corpul unei funcţii este delimitat de acolade: ‘{’ ţine locul lui begin (dinalte limbaje) iar ‘}’ al lui end. Compilarea programului. Celelalte două zone reprezintă aşa zisa stivă a programului şi zona de manevră. În corpul funcţiei main în Programul 1 avem apeluri la alte funcţii: printf. Procesul de legare (linking) este acela în care programul de legare(linker) combină codul scris de programator cu codul obiect al funcţiilor utilizate şi care se găseşte în bibliteca standard. în esenţă.b)) este un apel la o operaţie de scriere (pe ecranul monitorului) a textului: cuprins între " şi " în afară de %dăn care reprezintă formatul cu care se va tipări valoarea returnată de apelul la funcţia cmmdc (a. Acesta este un apel la o operaţie de citire a unor date pe care le introducem de la tastatură. Stiva este folosită în timpul execuţiei programului în scopurile: • memorează adresele de revenire ale apelurilor la funcţii. Deşi au fost concepute şi interpretoare de C şi acestea sunt disponibile pentru diferite medii.). 2.h. Construcţia "do {. singura funcţie care trebuie să fie prezentă în orice program se numeşte main( ). Aceste funcţii vor fi prezentate mai târziu într-un capitol special.. Prin urmare. care îndeplinesc funcţii distincte (figura 1. Majoritatea compilatoarelor C asigură medii de programare care includ facilităţi pentru realizarea tuturor etapelor precizate mai sus. )" care apare şi în funcţia main şi în funcţia cmmdc este una din structurile iterative de care dispune limbajul C: grupul de instrucţiuni cuprins între acoladele de după do se execută atâta timp cât condiţia scrisă după while este îndeplinită (de precizat că acel grup de instrucţiuni se execută măcar odată). 9 . altele folosesc programul de legare al sistemului de operare.b): va fi scris un număr întreg (%d) după care se trece la linie nouă (caracterul ăn).doc principal: punctul de intrare în execuţia unui program C este funcţia main. Într-un program C corect conceput.. o schemă a ceea ce face programul. Parametrul "%d%d" specifică formatul de citire a două numere întregi (d de la digit) iar parametrii &a. compilatoarele ce există pe piaţă conţin cu siguranţă şi alte funcţii. cmmdc. Crearea programului. Definiţiile acestor funcţii se află în fişierul sistemului stdio. Standardul ANSI C precizează setul minimal de funcţii care va fi inclus în biblioteca standard. operaţiile de intrare/ieşire se realizează prin apel la funcţiile unei biblioteci standard furnizate de sistem. C a fost gândit de la bun început ca fiind destinat compilării.4. În exemplul de aici avem: printf cu un parametru aflat între ghilimele: acest text va fi tipărit pe ecran scanf cu trei parametri: "%d%d". iar &b adresa variabilei b.Urmează o zonă de memorie în care sunt stocate variabilele globale. Atenţie însă: compilatoarele acceptă ca fişiere de intrare (programe sursă) numai fişiere text standard. scanf. 3. Toate programele în C constau dintr-una sau mai multe funcţii. &b corespund adreselor (faptul că & apare în faţă) unde vor fi memorate cele două valori întregi: &a adresa variabilei a. Crearea unui format executabil al unui program C parcurge următoarele trei etape: 1. Dacă se foloseşte un compilator care nu are integrat un editor (cum sunt cele din sistemul de operare UNIX). funcţia main( ) conţine.3 Compilarea unui program C Se ştie că există două metode generale de transformare a unui program sursă într-un program executabil: compilarea şi interpretarea. schemă compusă din apeluri ale altor funcţii aflate în biblioteca standard a limbajului C sau definite de programator. 1. dacă se crează un fişier sursă cu editorul Word su Windows. Legarea programului cu funcţiile necesare existente în bibliotecă. Prima regiune este aceea care stochează codul programului. acesta trebuie salvat ca fişier text pentru a putea fi utilizat de un compilator. În limbajul C nu există instrucţiuni de intrare/ieşire. printf ("Cmmdc al celor doua numere este: %dăn" cmmdc (a. Structurile de control ale limbajului C se vor prezenta într-un capitol special. &a şi %b. Aceasta este prima funcţie apelată la începutul executării programului. Limbajul C a fost optimizat special în vederea compilării.} while ( . Un program C compilat creează şi foloseşte patru zone de memorie disjuncte.48627669.

2. STIVA ZONA DE MANEVRĂ VARIABILE GLOBALE CODUL PROGRAMULUI Figura 1.4. operatori.4. De aceea C++ acceptă limbajul C: orice program C va putea fi compilat de un compilator C++. care a fost concepută pentru programarea orientată pe obiecte.3. în încheierea acestei scurte introduceri . Să mai precizăm . un programator care nu ştie C nu va putea programa în C++. programarea în limbajul C va dăinui multă vreme de acum încolo. Aşa cum vom vedea în partea a doua a acestei cărţi. că în general. le foloseşte pentru stocarea unor articole de genul listelor înlănţuite şi arborilor. sunt compilatoare C++. Zona de manevră (heap) este o regiune de memorie liberă pe care programul . Cap 2 Tipuri.După unii autori.1. 2. C++ este o versiune extinsă a limbajului C. memorează starea curentă a unităşii centrale de prelucrare. expresii 2. 2.Gheorghe GRIGORAŞ • • • memorează argumentele funcţiilor. memorează variabilele locale. compilatoarele existente pe piaţă. aşa cum dăinuie de când a fost creat limbajul şi. prin intermediul funcţiilor de alocare dinamică ale limbajului C. 2. 10 Tipuri simple Literali Declararea unei variabile Operatori .

. Limbajul C oferă de asemenea un mecanism de conversie a tipului care va fi prezentat mai târziu în lucrare. 4294967295 2.iar double pentru numere reale în dublă precizie – aproximativ 15 cifre semnificative. Tabela 2.48627669. Tipuri întregi unsigned Tipul unsigned char unsigned short unsigned (int) unsigned long (int) Dimensiunea 8 biţi 16 biţi 16 biţi 32 biţi Domeniul 0 . Diferenîa dintre acestea constă în dimensiunea zonei de memorie ocupată de o variabilă de acest tip şi implicit de mărimea domeniului de valori.32767 long -2147483648. nume de constante (literali). Aceste tipuri sunt utilizate pentru reprezentarea numerelor întregi. Specificarea signed tip este echi-valentă cu tip iar unsigned tip are semnificaţia din Tabela 2. Acest lucru este sintetizat în Tabela 1. 65535 0 .127 short .2. Tipurile de bază ale limbajului C pot fi grupate în trei mulţimi: • Tipuri întregi: char. Pentru tipurile întregi se pot folosi specificările signed şi unsigned. short. 2..doc O expresie în limbajul C – ca în orice limbaj de programare – este o secvenţă de operatori şi operanzi care descrie algoritmul de calcul al unei valori. Tipurile întregi Tipul Dimensiunea memoriei ocupate 8 biţi 16 biţi 16 biţi 32 biţi Domeniul char . Aceşti operanzi. 255 0 .. • Tipul vid: void. Este un tip folosit pentru reprezentări de dimensiune nulă. Ele se disting prin precizia de reprezentare: float – numere reale în simplă precizie –aproximativ 6 cifre semnificative ..32767 int . Tabela 1. (long int) 2147483647 • Tipuri reale: float.. Literali 11 . 65535 0 . au un anume tip iar în funcţie de aceste tipuri se vor aplica algoritmi specifici pentru determinarea valorii expresiei.128.. double Aceste tipuri sunt folosite pentru a reprezenta numere reale. Operanzii într-o expresie sunt nume de variabile. fiecare dintre ei.32768. int şi long.32768. Tipuri simple Tipurile simple (sau tipurile de bază) ale limbajului C definesc dimensiunea zonei de memorie ocupată de valoarea unei variabile precum şi modul în care va fi interpretat conţinutul acestei zone. apeluri la funcţii....1.

2.următoarele caractere sunt caractere alfanumerice (litere sau cifre) sau ‘_’.2E^3. A24E 39u.425 -15. 0 O12. ele reprezintă valori care nu pot fi modificate pe parcursul execuţiei unui program. ‘\ddd’ . ‘\’’ . Tabela 3.retur de car.Nu trebuie să coincidă cu vreun cuvânt cheie (vezi Tabela 4) Tabela 4. Constante literale Constante Exemple întregi 123. ‘\\’ .retur de linie.backspace. ‘\r’ . Declararea unei variabile şi a unei constante Toate variabilele unui program trebuiesc declarate înainte de a fi utilizate. ^423.3. -12.caracterul ‘’’ ‘\”’ . ‘\t’ . 10e-12 caracter ‘a’.tabulare verticală. ‘\xhh’ . -457. O3724 ox7F.interlinie (linie nouă). 57F3u întregi 12L. o42l long 423uL.caracterul \ (backslash). 42153l.caracter de cod octal ddd.primul caracter este literă sau ‘_’ (underscore). .caracterul ”. 25AfuL flotant 3.caracterul NULL. ‘A’. . ‘\u’ . în limbajul C se folosesc diferite reguli sintactice pentru reprezentarea constantelor. o245u. Tabela 3 sintetizează unele din aceste reguli. ‘\o’ .03. Un identificator în limbajul C este un şir de caractere care trebuie să îndeplinească condiţiile: .14159.Gheorghe GRIGORAŞ Literalii (sau constantele literale) sunt valori constante. Variabilele sunt obiectele de bază ale limbajului şi au un nume care este un identificator. Acestea sunt: ‘\n’ . ‘\b’ . ‘^’ şir “şir de caractere” Explicaţii Notaţia zecimală Notaţia octală (prefix O) Notaţie hexazecimală (prefix ox sau OX) Constante fără semn Reprezentare pe 32 biţi Constante fără semn pe 32 biţi Reprezentare fără exponent Reprezentare cu exponent Există şi caractere speciale (de control) care sunt compuse din caracterul “\” şi din alt caracter. Cuvintele cheie ale limbajelor C şi C^^ asm auto break case catch char class const continue default 12 delete do double else enum extern float for friend goto handle if inline int long new operator overload private protected public register return short signed sizeof static struct switch template this throw try typedef union unsigned virtual void volatile while .caracter de cod hexazecimal hh. . ‘\f’ . OX3.tabulare.

pi = 3.e-4. având durata de viaţă pe parcursul execuţiei funcţiei. const double e = 2. alocarea se face în registrele unităţii centrale şi nu în memoria RAM. Variabilele din clasa automatic sunt definite în interiorul funcţiilor fiind locale funcţiei în care au fost definite. Dacă se definesc în interiorul unei funcţii trebuie să aibă neapărat în faţă cuvântul rezervat static (se mai spune că sunt în clasa static internal). O constantă se declară prin: const tip nume= valoare. despărţite prin virgule. dacă e posibil. const char mesaj[ ] = "Eroare". Tabelul 5 sintetizează clasele de alocare. const float pi = 3. Exemple: int i. k. Această clasă este implicită.71828182845905. float eps = 1. tip nume = valoare. Mai multe variabile de acelaşi tip pot fi declarate în aceeaşi instrucţiune. Clasele principale de alocare sunt automatic şi static. j. Register Static internal External Static external External (în funcţie) . Variabilele definite în exteriorul tuturor funcţiilor fără vreun specificator de clasă sunt în clasa extern şi au alocate adrese fixe. într-o declaraţie se specifică clasa de alocare (implicit sau explicit). Tot în interiorul unei funcţii variabilele mai pot fi definite şi în clasa register care este asemănătoare cu cea automatic cu deosebirea că.14159. char n1='\n'. permanentă). Variabilele din clasele auto şi register nu îşi păstrează valoarea de la un apel la altul al funcţiei în care sunt definite.48627669. în afară de tipul variabilei şi eventual o valoare iniţială pentru aceasta.doc O variabilă se declară prin una din următoarele instrucţiuni: tip nume. Tabelul 5. explicit se poate specifica prin cuvântul cheie aut: aut int x. Variabilele din clasa static diferă de cele din clasa auto sau register prin aceea că sunt memorate în locaţii fixe de memorie (au o adresă fixă.14159. Clase de alocare CLASA CARACTERISTICI Adre Păstrează Vizibilitate să valoarea fixă în interiorul funcţiei NU NU în interiorul funcţiei în toate modulele în modulul în care-i definită în toate modulele aplicaţiei DA DA DA DA DA DA DA Durata de viaţă Pe durata funcţiei Pe durata aplicaţiei Pe durata aplicaţiei Pe durata aplicaţiei 13 Auto. Variabilele se declară la începutul funcţiilor (variabile locale) sau în exteriorul tuturor funcţiilor (variabile globale).

m. asociativitatea este de la dreapta la stânga. Operatorii ++ şi -. ++x.0 25. operatori binari cu notaţie infixată adică: operand operator operand. x++. • postfixaţi: variabila este incrementată (decrementată) după evaluarea expresiei în care se află iar asociativitatea este de la stânga la dreapta. operatorul ternar condiţional operand 1 ? operand 2 : operand 3.4. (x + y) * z.plus şi minus unari. ++ autoincrementarea. operatori unari cu notaţie prefixată sau postfixată: -x. y--. evaluarea se face în mod natural.Gheorghe GRIGORAŞ Static în toate modulele DA External aplicaţiei (în funcţie) În capitolul al optulea sunt tratate mai în amănunt problemele legate de gestiunea memoriei. ca şi perechea: x+y*z . acolo unde nu este specificat altfel. Aceştia pot fi unari sau binari iar în privinţa asociativităţii. Dacă tipul operanzilor este acelaşi într-o expresie.0 20./* l = 12 apoi i = 11 */ 14 . k. • • • • 2. Operatorii ce pot apare într-un program C sunt de patru feluri: operatori primari de parantetizare. Exemplu: x+y x % y. Negaţia are semnificaţia obişnuită: schimbă semnul valorii expresiei în faţa căreia se află. Operatori aritmetici Operatorii aritmetici sunt aceea care se aplică operanzilor numerici. float beta = 25. Spre exemplu. j. constante sau apeluri la funcţii (despre care se va vorbi mai târziu). -autodecrementarea.1.se face în ordinea indicată mai jos: alpha + sqrt (25) alpha + 5.45 Dacă operanzii au tipuri diferite . aceştia delimitează subexpresii şi pot schimba asociativitatea operatorilor. dacă se declară: float alpha = 20. • Operatorii unari: +. Exemple: Fie declaraţia int i = 10.45.4. se aplică conversii implicite de tip: unul din operanzi se converteşte la tipul celuilalt iar tipul rezultatului va fi tipul comun. atunci evaluarea expresiei: alpha + sqrt (beta). De pildă expresiile x * y +z şi x * (y + z) vor fi evaluate diferit pentru aceleaşi valori ale variabilelor.. l. Evaluarea expresiilor se face înlocuind operanzii prin valorile sale şi efectuînd operaţiile conform cu specificaţiile acestora.incrementează (decrementează) cu 1 valoarea unei variabile şi pot fi : • prefixaţi: variabila este incrementată (decrementată) înainte de evaluarea expresiei în care se află iar asociativitatea este de la dreapta la stânga. atunci: j = i ++ /* j = 10 apoi i = 10 */ k = ++i/* i = 12 apoi k = 12 */ l = i-. Fiecare dintre aceştia au un tip declarat. Operatori Operatorii se folosesc la constituirea de expresii pornind de la constante şi variabile. aceasta este de la stânga la dreapta. 2. Am văzut că operanzii pot fi variabile.45 + 5.

2. • !op1 are valoarea fals dacă op1 este adevărat şi are valoarea adevărat dacă op1 este fals. .conjuncţia logică (şi) Expresia: • op1&&op2 are valoarea adevărat (1) dacă cei doi operanzi sunt evaluaţi la adevărat. int. ^) este cea naturală (aminitm că 1 reprezintă valoarea logică “adevărat” iar 0 valoarea “fals”). în secvenţa anterioară.prezentate în Anexa – care sunt operatori cu scriere prefixată: .deplasare la stânga. asin. x. Operatori logici Operatorii logici sunt operatori binari care se aplică unor operanzi ce au valori adevărat (1) sau fals (0) şi ei corespund operaţiilor logice uzuale: ! .disjuncţie logică la nivel de bit.4.4.conjuncţie logică la nivel de bit. Exemplele următoare sunt edificatoare. tan. atan. >> .negare la nivel de bit (operator unar).funcţiile trigonometrice uzuale: sin.funcţia de ridicare la putere pow. cos. Semnificaţia primilor trei operatori binari (&. ^ . y a = (x! = y). 15 . logaritmică etc.  .48627669.2. dacă x va fi egal cu y atunci a va căpăta valoarea 0 iar în caz contrar a va căpăta valoarea 1. short. iar dacă unul din ei are valoarea fals (0) atunci expresia are valoarea zero. long) şi servesc la poziţionarea sau interpretarea valorilor întregi ca o secvenţă de valori binare.negaţia logică cu asociativitate de la dreapta la stânga  . Aceşti operatori sunt: & . Operatorii relaţionali (de comparaţie) Operatorii relaţionali sunt operatori binari şi permit compararea valorilor a doi operanzi (expresii) iar rezultatul evaluării este zero (dacă rezultatul este fals) sau 1 (dacă rezultatul este adevărat). .4.funcţiile exponenţială. Operatori la nivel de bit Limbajul C dispune de şase operatori pentru tratarea informaţiei la nivel de bit. • op1 op2 are valoarea zero (fals) dacă i numai dacă op1 şi op2 au ambii valoareea zero (fals).3.doc m = --i /* i = 10 apoi m = 10 */ • Operatorii binari sunt următorii + adunare * înmulţire scădere / împărţire % modulo La aceşti operatori se adaugă funcţiile din biblioteca matematică . |. acos. Aceştia sunt operatori binari iar sintaxa lor în C este: < (mai mic) <= (mai mic sau egal) > (mai mare) >= (mai mare sau egal) == (egal) != (diferit) Cum rezultatul unei comparări este un număr întreg este posibilă asignarea acestuia unei variabile întregi: int a.sau exclusiv la nivel de bit.disjuncţia logică (sau) && .4. ~ . 2.deplasare la dreapta. Aceştia se pot aplica doar operanzilor de tip întreg (char. 2. << .

Această asignare este echivalentă cu : e1 = (e1) op (e2).4. Pe lângă acest tip de asignare. Operatorul de asignare Operatorul de asignare. are ca efect evaluarea expresiei din dreapta semnului = şi atribuirea acestei valori variabilei ce se află în stânga acestui semn. |=. prin aceasta cele patru variabile i... k. %= • Operatori logici la nivel de bit: &=. 16 . Astfel variabilă = expresie. este o expresie ce are ca valoare. este o construcţie validă în C. -=. ~ op1 = 10011011 Operatorii binari de decalare ( << şi >>) servesc la decalarea cu un anumit număr de biţi (dat de cel de-al doilea operand) la stânga sau la dreapta în cadrul primului operand.5. Acest lucru permite “atribuirea în lanţ”precizând că asociativitatea operatorului de asignare este de la dreapta la stânga: var1 = var2 = . unde e1 şi e2 sunt expresii. variabila = expresie. în particular se poate obţine (rapid!) înmulţirea cu 2op2 (op1 << op2) sau cu 2-op2 (op1 >> op2). /=. = varn = expresie. prin care cele n variabile capătă valoarea expresiei din partea dreaptă. Se obţin asignări compuse cu: • Operatori aritmetici: +=. limbajul C permite compunerea asignării (#) cu un operator binar (op) obţinându-se operatori de asignare compusă: e1 op = e2. y = x << 2.4) z = 0000 0000 0000 0011(= 13/4) 2. ^= • Operatori de decalare: <<=. valoarea expresiei din dreapta semnului # . exprimat prin =. x = 0000 0000 0000 1101 (= 13) y = 0000 0000 0011 0100 (= 13. permite ca aceştia să formeze expresii care au atribuite valori. *=. z = x >> 2. >>= Faptul că atribuirea este privită ca un operator binar. l capătă valoarea 1. Spre exemplu i = j = k = l = 1.Gheorghe GRIGORAŞ op1 =01100100 op2 =10111010 op1 & op2 = 00100000 op1 | op2 = 11111110 op1 ^ op2 = 11011110 De asemenea negaţia (~) acţionează la nivelul fiecărui bit schimbând 1 =n 0 şi 0 =n 1. j. Exemple: x = 13.

expresia este egală cu op2 iar dacă op1 are valoarea fals. este o expresie echivalentă cu construcţia: if (a > b) max = a. j--) 2. O asemenea construcţie apare frecvent în instrucţiuni for pentru realizarea mai multor acţiuni: for(i = 0. j++) for(i = 0. . 2.op3 sunt operanzi. Forma generală a sa este: op1 ? op2 : op3. unde op1. i++. Expresiile sunt evaluate de la stânga la dreapta iar valoarea întregii expresii este valoarea (şi tipul. operatorul condiţional şi cel de atribuire li se aplică asociativitatea la dreapta pe când tuturor celorlalţi li se aplică asociativitatea la stânga.j = 0. se înţelege) expresiei ultime ce apare în acest şir. Dacă op1 are valoarea adevărat.4.doc 2. Operatorul virgulă Forma generală a unei expresii ce utilizează acest operator este: expresie1.. [] () sizeof -> . Tabelul nr.4. ~ ! +. .7.6.6. expresia este egală cu op3. Operatorul condiţional se notează cu ?: şi are asociativitatea de la dreapta la stânga. i < j. * Funcţia (semnificaţia) Acces explicit la o variabilă globală (unar) Acces explicit la o clasă (binar) Selectarea unui membru Indexarea unui tablou Apel la o funcţie Lungimea în biţi Incrementare. Am văzut că operatorii primari de parantetizare pot schimba asociativitatea operatorilor. decrementare Negare pe biţi Negare logică Plus. i++. Exemplu: max = (a > b) ? a : b. operatorilor unari. Operator :: :: →. 6.8. Operatorul condiţional Acesta este singurul operator ternar al limbajului C..j = n-1. Pentru limbajul C. Precedenţa operatorilor Asociativitatea şi precedenţa operatorilor indică ordinea în care se evaluează subexpresiile într-o expresie.expresie2. . i < 100.4. else max = b.op2. minus unari Acces la o variabilă Descrierea 17 .48627669. Precedenţa operatorilor limbajului C este dată în tabelul nr.

^=.delete ->* . |= .<=. << <.* *. %= +=. <<=.*=./=. >>= &=.>> . . inegalitate Conjuncţie pe bit Sau exclusiv pe bit Sau (disjunctiv) pe bit Conjuncţie logică Disjuncţie logică Afectare condiţională Operatori de asignare compusă Operatorul virgulă 18 . -=.Gheorghe GRIGORAŞ & () new. % +. >. >= ==. /. != & ^ | && || ?: =. Adresa unei variabile Conversie de tip (cast) Operatori de gestiune a memoriei Selectarea unui membru Operatori multiplicativi Operatori aritmetici Operatori de decalare Operatori relaţionali Egalitate.

Definirea unei funcţii Returnarea unui apel Funcţii cu un număr variabil de parametri Sfârşitul execuţiei unui program Apelul şi transmiterea parametrilor Funcţia principală main În limbajul C .modificări ulterioare ale acestuia.spre deosebire de Pascal sau alte limbaje . instructiuni. o funcţie trebuie declarată înainte de a fi apelată. getc. 3. funcţii ce se găsesc în bibliotecile sistemului.relativ uşor . 3.6.5. Dacă această specificare lipseşte. respectiv tipul valorii returnate de un apel la această funcţie.1.descompunerea unei secvenţe lungi de procesare a informaţiei într-o mulţime de secvenţe “mici” de transformări de bază ale informaţiei. tipul implicit al funcţiei este int.Cap 3 FUNCTII 3.2. utilizarea unei funcţii permite: . Limbajul C permite de asemenea utilizarea unor funcţii predefinite (printf. Definirea unei funcţii Definiţia unei funcţii are următoarea sintaxă: tip nume (lista parametri) { declaratii (de variabile). 3. .nu există noţiunile distincte de procedură şi de funcţie. Numele unei funcţii este un identificator şi acesta trebuie să respecte aceleaşi reguli ca cele referitoare la numele unei variabile. tip este unul din cuvintele rezervate care defineşte tipul funcţiei. 3. Aceste elemente de nivel înalt oferă o claritate în plus programului global şi permite . Să precizăm că nu se poate defini o funcţie în interiorul altei funcţii. 3.). În C există doar funcţii care returnează o valoare.3. Apelurile la aceste funcţii sunt gestionate în faza de editare a legăturilor.1. Signatura unei .furnizarea către alţi programatori a unor elemente de bază de nivel înalt.4. detaliile acestor elemente rămân “ascunse” pentru utilizator. Aşa cum o variabilă trebuie declarată înainte de a fi utilizată într-o expresie. În general. 3. Declararea unei funcţii constă în a da signatura funcţiei. } În această definiţie. etc. Este posibilă definirea de funcţii care să retuneze valoarea vidă: în acest caz tipul valorii returnate este void. Mulţimea funcţiilor unui program poate fi partiţionată în mai multe fişiere care pot fi compilate separat. Funcţiile care returnează în programul apelant valoarea vidă se declară de tip void.

implicit: în definiţia funcţiei. linia de început conţine tipul său şi argumentele sale (număr şi tip). 3. Un exemplu la îndemână îl oferă funcţiile sistemului: printf. O funcţie f returnează o valoare în corpul funcţiei din care s-a făcut apel la f. 3.2. Funcţii cu un număr variabil de parametri Există funcţii care pot avea un număr nedeterminat de parametri. Există două moduri de a declara o funcţie: ./*Un apel cu 2 argumente */ printf ("a\%d.explicit: printr-o instrucţiune ce descrie signatura sa în cazul în care se face apel la o funcţie descrisă într-un fişier separat sau în cazul în care apelul la funcţia respectivă precede declaraţia funcţiei în acelaşi fişier. int strlen (const char* s).x). printf("x\%f\n". O funcţie care returnează valoarea vidă (funcţie de tip void) poate conţine instrucţiunea "return" fără argument sau poate omite această instrucţiune. Valoarea expresiei "expresie" va fi returnată şi poate fi utilizată în programul apelant. prin instrucţiunea return (plasată în corpul lui f). void schimbare (int . Iată câteva instrucţiuni de declarare a unei funcţii: long int cod (const char *.4.Gheorghe GRIGORAŞ funcţii defineşte atât tipul său (tipul valorii returnabile) cât şi numărul şi tipul argumentelor sale. int). scanf. 3.. Funcţia "exit" este o funcţie sistem care termină execuţia unui program. int funct ( ).b). Acesta este singurul exemplu de apel la o funcţie care nu returnează nimic: sistemul opreşte execuţia programului şi raportează valoarea transmisă la apel. Această valoare poate fi utilă atunci când programul este executat în interiorul 20 . . În ultima linie avem un exemplu de funcţie fără parametri (numărul parametrilor este zero).: printf ("Un apel cu un singur argument \n").a. int). Sfârşitul execuţiei unui program exit (valoare). etc. /*3 argumente */. Definirea unor astfel de funcţii se face printr-o sintaxă de forma: int printf (char *.b\%d\n".. ). . Returnarea unui apel Sintaxa instrucţiunii de returnare a valorii unei funcţii este: return expresie. care în C++ se numeşte "elipsă". Tipul acestei expresii trebuie să fie acelaşi cu tipul funcţiei. char* decod (long int).3.

int* y){ int temp = *x. 3.doc unei linii de comandă a interpretorului de comenzi. a.5. n++. Un exemplu clasic al consecinţei acestui mod de transfer al parametrilor este ilustrat mai jos: void schimba1(int x. Asta înseamnă că parametrul actual (de la apel) şi parametrul formal corespunzător (declarat în antetul funcţiei) sunt două variabile distincte.48627669. valoarea implicită a codului returnat la sfârşitul execuţiei unui program este 0. Funcţia schimba2 care simulează transmiterea parametrilor prin referinţă este: void schimba2(int* x . Apelul şi transmiterea parametrilor Apelul unei funcţii se face prin: nume (listă _ parametri_actuali). b =%d". b = 2. Ordinea evaluării parametrilor este în general de la stânga la dreapta dar acest lucru nu este garantat de orice compilator. pentru schimbarea conţinutului unor variabile 21 . x = y.b). În absenţa unei instrucţiuni exit. int y){ int temp = x. Prin convenţie. printf ("%d %d \n". Pentru înlăturarea acestui efect este posibilă simularea unui mod de transmitere prin referinţă. De pildă. Singura diferenţă este că valoarea transmisă prin parametrii actuali &a. *x = *y.. &b). } iar apelul în funcţia main se face prin: schimba2 (&a . printf ("a = %d. Modificările efectuate asupra parametrilor formali nu au decât un efect local care nu este vizibil în afara funcţiei.&b este adresa lui a respectiv b şi prin funcţia schimba2 se modifică valorile referenţiate. Aşadar. *y = temp. secvenţa: int n = 10. } main ( ){ int a = 1. Să precizăm că în C nu există decât un singur mod de transmitere a parametrilor şi anume transmiterea prin valoare. punând drept parametri actuali valorile adreselor variabilelor ce trebuiesc modificate. Să facem precizarea că şi în cazul funcţiei schimba2 transmiterea parametrilor se face prin valoare: am simulat aici transferul prin referinţă ce ar fi trebuit să se facă în cazul funcţiei schimba1. Asta înseamnă că o funcţie nu poate modifica parametrii actuali. tipăreşte (cu unele compilatoare) 10 10 şi nu 10 11. încât trebuiesc luate măsurile corespunzătoare. n). } Apelul funcţiei schimba1 în funcţia main nu are efectul scontat: prin apelul la printf se tipăresc valorile 1 şi 2 pentru a respectiv b. valoarea nulă (0) semnifică faptul că programul se termină normal iar o valoare nenulă (1 sau -1) semnifică faptul că s-a produs o eroare. dacă funcţia este declarată fără tip şi prin folosirea numelui funcţiei urmat de lista de parametri actuali într-o expresie (în care este permis tipul ei) atunci când funcţia este declarată cu tip . schimba1(a. b). În C adresa unei variabile poate fi specificată într-o variabilă de tip "pointer" (de care vom vorbi mai târziu). y â temp.

argc: numărul argumentelor din linia de comandă (inclusiv numele programului).. } } Dacă acest program are numele prg2 atunci linia de comandă: prg2 22 . . Valoarea întreagă returnată de funcţia main este valoarea transmisă mediului la sfârşitul execuţiei programului (vezi funcţia exit). 1. char* argv[ ] ){ if (argc<2) printf ("Nu exista argumente in aceasta executie ! \n"). else { printf ("Argumentele executiei sunt: \n"). este permisă utilizarea funcţiei main fără parametri: int main( ) este o declaraţie validă pentru funcţia main. parametrul corespunzător trebuie să fie de tip pointer. i++) printf ("%s". Argumentele de tip pointer vor fi utilizate de asemenea pentru transmiterea ca parametru a unei variabile de tip structură (vezi Cap. Aceasta defineşte punctul de intrare în execuţia programului. p2..7) precum şi pentru limitarea numărului de valori ce trebuiesc puse în stiva de apel a execuţiei unui program. pn Atunci argc va avea valoarea n^1 iar argv va fi un tablou ce conţine pointeri astfel: 0 1 : . 3. în particular. argv [i] ). Funcţia principală main int main(int argc. “nume . .program” “p1” “pn” 0 n Iată un exemplu de utilizare a acestor argumente : Programul 2 main (int argc. În cazul în care programatorul nu doreşte să utilizeze argumentele (parametrii) transmise la execuţie. for (i â 1. i < argc. În capitolul 6 vom discuta mai pe larg modul de transmitere al parametrilor de tip tablou ca argumente ale unei funcţii.6. Parametrii funcţiei main permit recuperarea argumentelor transmise din momentul execuţiei programului. linia de comandă conţine numele programului urmat de o listă de parametri: nume-program p1.eroare)..argv: un tablou de pointeri către fiecare din argumentele liniei de comandă.Gheorghe GRIGORAŞ printr-o funcţie. } Funcţia main este singura funcţie absolut necesară într-un program C.succes. Parametrii disponibili la apelul funcţiei main sunt: . În general. la lansarea unui program. arg[0] conţine numele programului executabil.char* argv [ ]) { instructiuni. Utilizarea instrucţiunii return precizează condiţia de terminare ( 0 .

48627669.doc produce scrierea mesajului: Nu exista argumente in aceasta executie ! iar linia de comandă: prg2 Iata niste argumente ! produce scrierea mesajului: Iata niste argumente 23 .

4 4.Fluxuri şi fişiere Sistemul de fişiere al limbajului C este conceput pentru a lucra cu o mare varietate de dispozitive. Acesta din urmă este opţional pe ultima linie şi este determinat de modul de implementare.. inclusiv cu terminale. # include <stdio. pot avea loc transferuri de informaţii între fişier şi programul curent în execuţie.! Cap 4 FUNCŢII DE INTRARE IEŞIRE 4. Datorită posibilelor conversii s-ar putea ca numărul de caractere scrise/citite să difere de numărul de caractere existente pe dispozitivul extern. stare. Pointerul de fişier identifică un anumit fişier şi este folosit de către fluxul asociat pentru a conduce operaţia de intrare/ieşire. încât aceeaşi funcţie care scrie date pe un fişier de pe disc poate fi folosită pentru a scrie date pe o altă categorie de dispozitive: consola. Un pointer de fişier este un pointer către informaţia care defineşte diverse caracteristici ale unui fişier(nume. Deşi fiecare dintre acestea este foarte diferit de celelalte. Unificarea sistemului de intrare/ieşire în C se face prin “pointerii” de fişier. imprimanta. o imprimantă sau “o zonă” (fişier) pe disc. • Fluxul binar este o secvenţă de octeţi cu corespondenţă biunivocă faţă de octeţii existenţi pe dispozitivul extern: numărul de octeţi scrişi/citiţi este acelaşi cu numărul acestora de pe dispozitivul extern. Pentru a putea utiliza într-un program funcţiile standard de intrare/ieşire trebuie scrisă la începutul acestui program o directivă "include" care are ca argument numele fişierului antet ce conţine definiţiile acestor funcţii: stdio. unităţi de disc sau de bandă etc. Standardul ANSI C permite organizarea unui flux text în linii care se încheie cu un caracter linie nouă(“ăn”).2 4.1 4. Aşadar dispozitivul fizic pe care se scriu datele se numeşte fişier iar abstractizarea acestuia se numeşte flux (sau stream). Un flux se poate asocia unui fişier executând o operaţie de deschidere: odată deschis.1.h> Orice program C începe execuţia prin deschiderea unităţilor de intrare/ieşire standard: stdin : unitatea standard de intrare stdout : unitatea standard de ie[ire stderr : unitatea de eroare stdprn : unitatea standard de ie[ire (imprimant\) prn . sistemul de fişiere le transformă pe fiecare într-un dispozitiv logic numit flux. poziţie curentă etc).h . Fluxurile sunt independente de dispozitivele iniţiale .3 4.5 Fluxuri şi fişiere Accesul la fişiere. Există două tipuri de fluxuri: • Fluxul text este o scvenţă de caractere. Un fişier în limbajul C poate fi un terminal. Tipul FILE Funcţii de intrare /ieşire pentru caractere Scrierea cu format Citirea cu format 4.

în lipsa altor indicaţii.const char* mod) 25 . Aceste fişiere (stdin. Accesul la fişiere. Declararea unei variabile de tip "pointer la fişier" se face folosind tipul FILE definit în fişierul antet stdio. Acest dispozitiv este gestionat de sistem pentru a asigura intrările şi ieşirile efectuate în program. Bibliotecile standard C oferă o serie de funcţii pentru operaţii de intrare/ieşire orientate pe fişiere. tastaturii calculatorului (intrare) şi ecranului (ieşire şi eroare).h şi are forma: FILE* pointer_la_fi[ier unde pointer_la_fişier este un identificator (numele pointerului).doc Aceste unităţi standard sunt asociate. FILE* fopen(const char* fi[ier. Tipul FILE Conceptul de bază pentru intrări/ieşiri standard este cel de pointer la fişier.48627669. Sistemul de fişiere ANSI C este compus din mai multe funcţii legate una de alta. Deschiderea unui fişier se face prin funcţia fopen care returnează ca rezultat un pointer la un descriptor de fişier. stdout) pot fi orientate şi către alte dispozitive sau fişiere. Dispozitivele standard de intrare (tastatura) şi de ieşire (ecranul) sunt văzute tot ca fişiere cu pointerii stdin şi stdout. Cele mai frecvent folosite dintre acestea sunt date în Tabelul 5 şi vor fi prezentate în continuare.1. Tabelul 5 NUME fopen( ) fclose( ) putc( ) fputc( ) puts( ) fputs( ) getc( ) fgetc( ) gets( ) fgets( ) fseek( ) printf( ) fprintf( ) scanf( ) fscanf( ) feof( ) ferror( ) rewind( ) remove( ) fflush( ) OPERA}IE Deschide un fişier Închide un fişier Scrie un caracter într-un fişier Analog lui putc() Scrie un şir pe ecran Scrie un şir pe fişier Citeşte un caracter dintr-un fişier Analog lui getc( ) Citeşte un şir de la tastatură Citeşte un şir din fişier Caută un anumit octet într-un fişier Scrie la ieşirea standard Analogul pentru fişiere al funcţiei printf( ) Citeşte din intrarea standard Analogul pentru fişiere al funcţiei scanf( ) Returnează “adevărat” dacă se atinge sfărşitul fişierului Returnează “adevărat” dacă survine o eroare Iniţializează indicatorul de poziţie al fişierului la început Şterge un fişier Goleşte conţinutul unui fişier 4.

Prin închidere se eliberează descriptorul de fişier. Valoarea returnată este un pointer la un descriptor de fişier valid. Dacă deschiderea nu s-a efectuat corect valoarea returnată este NULL(pointer la informaţia nulă) . se actualizează fişierul pe disc şi încetează conexiunea logică între pointer şi fişier."w+". Dacă funcţia fopen returnează o valoare nenulă. FILE* pointer_la_fi[ier cod = fclose (pointer_la_fi[ier) Fişierele pot fi reasignate prin program folosind funcţia freopen: FILE* freopen (const char* nume_fisier. fişier este un şir de caractere (identificator) ce desemnează numele extern al fişierului iar mod este un şir de caractere ce descrie modul de deschidere al fişierului. stdout) == NULL) { 26 .h> main ( ){ printf ("Mesaj scris pe monitor \n"). deschide fişierul cu numele “nume_fişier” în modul de acces "mod". if (freopen ("CON". aceasta indică faptul că deschiderea s-a efectuat corect. if(freopen("iesire.dat". const char* mod. Închiderea unui fişier se face prin apelul la funcţia fclose: int fclose (FILE* pointer_la_fi[ier) Funcţia returnează EOF în caz de eroare şi 0 în caz normal. } printf ("Mesaj scris in fisierul iesire.Gheorghe GRIGORAŞ Aici. FILE* pf). exit (1). Apelul la fclose se poate face prin: int cod. "Eroare la reasignare \n"). Programul 3 # include <stdio. "wt". valoare ce va fi utilizată în apelul la funcţiile de intrare/ieşire. Modurile posibile de deschidere (deci şirurile de caractere ce constituie parametrul lui fopen) sunt date în Tabelul 6. Apelul la această funcţie închide fişierul cu pointerul "pf". deschiderea unui fişier existent în modurile "w" sau "w+" produce pierderea conţinutului său de până atunci.dat \n"). Programul următor ilustrează acest fapt. mod "r" "w" "a" "r+" "w+" "a+" Semnificaţia Citire Creare (schimbare) pentru scriere Adăugare la sfârşitul fişierului (existent) Actualizare (citire/scriere) Schimbare pentru actualizare Actualizare cu scriere la sfârşitul fişierului (existent) Facem precizarea că. fclose (stdout). Aceasta permite redirecţiona-rea dispozitivelor periferice prin program. Tabelul 6. Acest lucru poate fi folosit pentru tratarea erorilor la deschiderea fişierului. atribuind pointerul "pf" la acest fişier.stdout)==NULL) { fprintf (stderr.

a scrierii apelului la fgetc şi fputc în cazul în care intrarea respectiv ieşirea este cea standard : stdin respectiv stdout.48627669. cod = fgetc(c. Limbajul C dispune şi de posibilitatea: ştergerii de fişiere prin funcţia remove: int remove(const char* nume_fi[ier). iar putchar (c). stdout la CON\n"). Scrierea cu format 27 .doc } • • } printf ("Mesaj scris din nou pe monitor \n"). Funcţii de intrare/ieşire pentru caractere int fgetc(FILE* flux). simplificată. este echivalentă cu: fput (c. Există de asemenea două funcţii getchar şi putchar care permit exprimarea în C.2. const char* nume_vechi ). Spre exemplu: c = getchar ( ). "eroare la reasignarea lui exit (1). Funcţia fputc scrie un caracter la sfârşitul fişierului pointat prin pointer_la_fişier.3. c = fgetc(pointer_la_fişier). 4. FILE* pointer_la_fişier. redenumirii unui fişier: int rename (const char* nume_nou. char c. este echivalentă cu: c = fgetc (stdin). int fputc(char c. char c. pointer_la_fişier). Funcţia fgetc returnează valoarea întreagă a caracterului următor din fişierul pointat cu pointer_la_fişier sau constanta EOF în caz de eroare sau sfârşit de fişier. fprintf (stderr. În caz de eroare este returnată valoarea EOF. • creării unui fişier temporar: FILE*tmpfile (void). int cod. FILE* flux).. stdout). FILE* pointer_la_fişier. 4.

întreg în notaţie zecimală fără semn real în notaţie zecimală sub forma [-]mmm. int fprintf(FILE* flux.ddddddE ± xx. p sau X u f e sau E TIP ARGUMEN T int int int int float sau double float sau double CONVERSIA întreg în notaţie zecimală cu semn. # : desemnează un format alternativ.const char* şir_format. 28 .: rezultatul conversiei se va cadra la dreapta. Formatele ce se folosesc în C sunt date în Tabelul 7. int printf(const char* şir_format. Formatul "şir-format" este un şir de caractere ce conţine fie caractere ordinare fie directive de conversie pentru transformarea valorii unei variabile într-un şir de caractere Caracterele ordinare sunt transmise la ieşire aşa cum apar ele pe când directivele de conversie indică formatul de ieşire pentru argumentele transmise în apelul funcţiei. CARACTE R d sau i o x. real în notaţie zecimală sub forma: [-]m. F. …).Gheorghe GRIGORAŞ Funcţiile de scriere cu format permit afişarea sub forma unui şir de caractere a diverselor valori. pentru x sau p se folosesc literele a. caracterele se vor cadra la stânga (implicit) sau la dreapta (pentru -). • eventual un număr pentru a indica dimensiunea minimală a câmpului în care se va afişa. Pentru formatele flotante ( e. întreg în notaţie hexa fără semn.dddddd sau numărul de d este dat de argumente de precizie (implicit acesta este 6). B. E. iar pentru X literele A. dacă acesta este hexazecimal se va adăuga ox sau OX înaintea numărului. Numărul de d este dat de argumente de precizie (implicit este 6). C. d. D. Se pot utiliza şi dimensiuni variabile: se utilizează '*' în loc de numărul ce indică dimensiunea iar variabila respectivă se pune în lista de argumente. • • Tabelul 7. b. c. Dacă formatul este octal se va adăuga un o înaintea numărului. e. într-un fişier sau într-un şir de caractere. Această secvenţă conţine. eventual caracterul l care precizează că numărul ce urmează a fi afişat este un "întreg lung" (long integer). Indicatorii disponibili în C sunt: . f.dddddde ± xx sau [-]m. g. în ordine: • eventual unul sau mai mulţi indicatori ce modifică semnificaţia conversiei. G) rezultatul se va afişa cu un punct zecimal. Acestea pot fi transmise la ieşirea standard. int sprintf(char* s. Funcţia printf se utilizează pentru afişarea la ieşirea standard. iar sprintf pentru scrierea într-un şir de caractere. la g sau G se vor afişa şi zerourile nesemnificative de după punctul zecimal.const char* şir_format. în plus . E. Formatele de conversie utilizate de printf.…). întreg în notaţie octală fără semn. fprintf pentru scrierea într-un fişier. Dacă dimensiunea rezultată prin conversie este mai mică. f.cu excepţia cazului când primul caracter nu este semn. O directivă se specifică prin caracterul % urmat de o secvenţă de caractere ce identifică formatul.…). caracterul ce indică formatul conversiei. + : la formatul de ieşire va fi ataşat semnul + sau .

double d = 123. ui). printf(" ul = %d\n".doc g sau G c s p n % float sau double int char* void* int* afişare în acelaşi stil cu e dacă exponentul este -4 sau superior preciziei. printf(" Forma zecimala:\n"). afişarea unui şir de caractere până la întâlnirea caracterului '@0' (sfârşit de şir) sau până când numărul de caractere este egal cu numărul de precizie. printf(" ui = %o\n". unsigned long int ul = 987654321UL. 29 . l).45. long int l = 123456789L. afişarea unui singur caracter după conversie în unsigned char. In urma execuţiei se va afişa: Forma zecimala: i = 123 l = 123456789 ui = 45678 ul = 987654321 Forma octala: ui = 131156 ul = 7267464261 printf("Scrierea hexazecimala:\n"). ul). unsigned int ui = 45678U. i).ul). Permite afişarea caracterului ‘ % ‘ Exemple Următoarele programe ilustrează folosirea formatelor de afişare la apelul funcţiei printf rezultatele sunt ilustrate la sfârşitul fiecărui program. în stil f în caz contrar. nu există nici conversie nici afişare în acest caz: este vorba de referinţe la un pointer la un întreg în care se va stoca numărul de caractere afişate până în prezent. printf(" Forma octala:\n"). printf(" ui = %u\n". printf(" i = %lo\n\n". printf(" ul = %lu\n\n". afişează argumentul în notaţia pointer. Programul 4 # include <stdio. printf(" l = %ld\n".h> int main ( ) { int i = 123. ui). printf(" i = %d\n".i).48627669.

4d|\n". 123). 123). 123).-123). Iată ce se va afişa: |0123| |+0123| |0X007B| | 123| |123 | 30 . printf("\n").-123. printf("Afisarea semnului:\n"). printf("|%+6. printf("\n").-123. 123. printf("|%o| |%#o|\n". 123).4d|\n". printf(" ul = %lX\n\n". 123).4o|\n". ui). printf("|%+.123. printf("|%+5d| |%+-5d|\n". 123). 123). printf("|%5d| |%-5d|\n". printf("|%x| |%#x|\n". 123).Gheorghe GRIGORAŞ printf(" ui = %X\n". În urma execuţiei se va afişa: Scrierea hexazecimala: ui = B26E ul = 3ADE68B1 Afisarea semnului: |-123| |-123| |-123| | 123| |+123| |123| Afisare in octal si hexazecimal: |76| |0x7b| |7B| |0X7B| |173| |0173| /*Specificarea lungimii campului si a **numarului de cifre*/ printf("|%. 123.4X|\n". ul). printf("Afisare in octal si hexazecimal:\n"). printf("|% d| |%+d| |%d|\n". printf("|%+6. 123). 123). 123. printf("|% d| |%+d| |%d|\n". 123). printf("|%. printf("|%+6. 123). printf("|%#5d| |%#-5d|\n". 123.4X|\n". 123).4d|\n". 123.123. printf("|%X| |%#X|\n". printf("\n"). 123. printf("\n").

0E|\n" 3.3E|\n" 3. de la un fişier respectiv dintr-un şir de caractere sunt: int scanf (const char* şir_format.48627669.14157e123).100000| |3.14157).14157). 31 .1E+10| |-1. printf("|%.11G|\t|%. const char* şir_format. Citirea cu format Funcţiile de citire cu format permit interpretarea unui şir de caractere ca o secvenţă de valori în concordanţă cu un format dat. printf("|%#.…).1e5.00001). 3. 3.| |3. Aceste funcţii.14157e123).141570| |3.14157).14157). printf("|%E|\t|%G|\n". Rezultatul interpretării este încărcat la adresele ce se dau ca argumente la apelul funcţiilor de citire.14157e123).100000E+10| |3.1E+07| |3100000| |3.1e6.0001| |1E-05| |310000| |3.doc | +123| |+123 | | 0X7B| |0X7B | | +0123| | 0173| |0X007B| /* Afisarea numerelor in virgula flotanta*/ printf("|%f|\n" 3. 3.3f|\n" 3.1e10. -0. …). printf("|%E|\n" 3. printf("|%f|\t|%G|\n". printf("|%. printf("|%.110). 3.14157e123).1 E+11| 4.…).142E+123| |3E+123| |3.1e7). return0. 0.0f|\n" 3. printf("|%#. printf("|%.5. printf("|%f|\t|%G|\n".1| |3.0f|\n" 3. printf("|%G|\t|%G|\n".1e11). printf("|%E|\n" 3. printf("|%.11G|\n". 3. } Iată ce se va afişa de această dată: |3. int sscanf (char* s. corespunzătoare citirii de la intrarea standard.142| |3| |3.0E|\n" 3.1.14157e123).141570E+123| |1. 3. 3. int fscanf (FILE* flux.E+123| |3. 3.1). const char* şir_format.0001.

] FORMAT DE INTRARE întreg în notaţie zecimală. Directivele pentru specificarea unui format sunt utilizate pentru precizarea conversiei următorului câmp citit. real în notaţie virgulă flotantă. citeşte caracterele din intrare atât timp cât acestea aparţin mulţi-mii indicate în [ ]. întreg în notaţie octală. Nu se face nici o operaţie de citire. întreg în notaţie octală(primul caracter 'o') sau hexa (primul caracter 'Ox' sau 'OX'). şir de caractere: se citeşte până la întâlnirea unui spaţiu sau până la atingerea numărului de caractere indicat. Adaugă la argument caracterul '@0' (sfârşit de şir). g p n [. întreg în notaţie hexa. Pentru citirea următorului caracter diferit de spaţiu se foloseşte %ls. punând caracterul '*' în directivă (de ex. rezultatul citirii este memorat în variabila corespunzătoare din lista argumentelor funcţiei. caracter.caractere ordinare (în afară de %) care trebuie să corespundă următorului caracter citit.caractere de spaţiere sau tabulare care vor fi ignorate. %*s): în acest caz câmpul este citit dar nu-i memorat.. de obicei sunt ignorate. Se poate face o omisiune de afectare. care încep cu '%'. Formatele de conversie pentru scanf CARACTER d i o u x c s e. În general. Programul 5 32 . Câmpul ce urmează a fi convertit (ce este citit) se întinde până la primul spaţiu sau numărul de caractere din acest câmp este specificat în format.] % char* Programul următor ilustrează utilizarea formatelor de intrare. TIPUL ARGUMENTULUI int* int* int* unsigned int* int* char* char* float* double* void* int* char* [∧. scrie în argument numărul de caractere citite până acum. f.. valoarea unei adrese. Tabelul 8. . .. Caracterele pentru specificarea unui format de citire sunt date în Tabelul 8. citindu-se şi spaţiile care.directive de specificare a formatului.Gheorghe GRIGORAŞ Formatul (şir_format) este un şir de caractere care poate conţine: . permite indicarea caracterului literal '%'. Dacă este indicat un număr q (%qC) atunci sunt citite cel mult q caractere. întreg fără semn în notaţie zecimală. Implicit se citeşte un singur caracter. citeşte caracterele din intrare atât cât acestea nu sunt în mulţimea indicată în [ ] după care adaugă '@0'..

printf("Introduceti un text: "). c3.s5. scanf("%d%d%d". scanf("%4s %4s %4s". s1.s1. scanf("%4c%4c%4c". printf("Ati introdus:%d\t%d\t%d\n".s6)return 0. scanf("%c%c%c".s3). &c1.c3). &i1. } Rezultatul unei execuţii a acestui program este: Introduceti trei numere intregi: 5454 -9988 0 A-ti introdus numerele: 5454 -9988 0 Introduceti trei numere intregi: 5454998 390 A-ti introdus numerele: 5454 998 390 Introduceti un text: Iata un exemplu! s1=|Iata| s2=|un| s3=|exemplu!| Introduceti un text: Iata un exemplu! s1=|Iata| s2=|un| s3=|exem| c1=|p| c2=|l| c3=|u| Introduceti un text: Iata un exemplu!: s4=|! Ia| s5=|ta u| s6=|n ex| 33 .s3[10].s2.s2[10]. &i2.i1. printf("Introduceti trei numere intregi: "). &i2.s4. printf("s1=|%s|\ts2=|%s|\ts3=|%s|\n". s2. printf("Introduceti trei numere intregi: "). printf("Introduceti un text: "). s5[5]. i3.i2. charc1.s3).s6).i3). scanf("%s%s%s.48627669. c2. s1. printf("s4=|%4s|\ts5=|%4s|\ts6=|%4s|\n". printf("s1=|%s|\ts2=|%s|\ts3=|%s|\n".s5. scanf("%4d%3d%4d". s3"). printf("c1= |%c|\tc2=|%c|\tc3=|%c|\n"c1. char s4[5].&c2. &i3). s3).s2. s2.doc #include <stdio.&c3).h> int main(){ int i1. s6[5].i3).i2. printf("Introduceti un text: "). s4.s1. printf("Ati introdus:%d\t%d\t%d\n". &i3). i2. &i1. s4[4] =s5[4] =s6[4] ="\0".c2.i1. chars1[10].

5. Un bloc este un [ir de instruc]iuni `ncadrat `n acolade: { [i } (care joac\ rolul de begin . ~n capitolul 2 am v\zut cum se construiesc expresiile `n C.' este o instruc]iune `n C.8.6. Un bloc este echivalent cu o instruc]iune. 5. • instruc]iuni de control.3.. end din alte limbaje). O expresie urmat\ de caracterul '. Instruc]iunile if Instruc]iunea switch Instruc]iunea while Instruc]iunea do.. j ++.7.2. • expresii. Urm\toarele construc]ii sunt instruc]iuni C de tip expresii: i = 1. 5.9. 5. . cod = printf ("%d\n". 5.10.4.1. ++ k. Iat\ un bloc `n C: { i = 1. 5. 5.while Instruc]iunea for Instruc]iunea break Instruc]iunea continue Instruc]iunea go to Exerci]ii Solu]ii la exerci]ii Limbajul C ofer\ urm\toarele tipuri de instruc]iuni: • declara]ii..Cap 5 INSTRUCŢIUNI DE CONTROL 5. ~n general o instruc]iune se termin\ prin '. 5. • blocuri de instruc]iuni.5. alpha).'. 5. • defini]ii de func]ii..

tip identificator = valoare.doc } j = 2. Instrucţiunea if if (expresie) if ( expresie ) instruc]iune1 instruc]iune1 else instruc]iune2 Ca [i `n alte limbaje de programare aceast\ instruc]iune permite alegerea `ntre dou\ alternative. Expresia se pune obligatoriu `ntre paranteze iar partea "else instruc]iune2. x). s [i] = t [j]. if ((c = getchar ( ) ) ! = EOF) putchar (c). else if (x==y) printf("numerele sunt egale\n"). b += 1. Instruc]iunile de declarare a variabilelor (declara]iile) sunt de forma(vezi [i paragraful 2.48627669.1. else printf("al doilea numar este mai mare\n"). short. Vom trece `n revist\ `n continuare instruc]iunile de control ale limbajului C. int sau long). 35 . real (float sau double) sau tip pointer. else printf("%d este cel mai mare\n". if (x>y) printf("%d este cel mai mare\n". s [i] = t [j]. j --. else y = y-x." este facultativ\. 5. Semantica acestei instruc]iuni este uzual\: dac\ valoarea expresiei "expresie" este nenul\ (ceea ce `nseamn\ "true") atunci se execut\ instruc]iune1 iar dac\ aceast\ valoare este nul\ ("false") se execut\ instruc]iune2 (dac\ aceasta exist\). i ++. y). if (x>y) printf("primul numar este cel mai mare\n"). if ( a < b ) { a += 2. Exemple: if (x>y) x = x-y. }.3) : tip identificator. Tipul expresiei de dup\ cuv=ntul rezervat if poate fi `ntreg (char.

caracter sau enumerare. se execut\ instruc]iunile desemnate de ramura "default". break. care poate fi de tip `ntreg. Exemplu: switch (getchar ( ) ) { case 'a': printf ("s-a citit litera a\n"). dac\ aceasta exist\. Instruc]iunea switch switch(expresie){ case const1: instruc]iune1 case const2: instruc]iune2 … case constn: instruc]iunen default: instruc]iune } Instruc]iunea switch este o structur\ de control cu alegeri multiple ce `nlocuie[te o succesiune de alternative de tip if.2. else printf (“ b nu este egal cu doi\n”). 36 .Gheorghe GRIGORAŞ else a -=b. case 'b': printf ("s-a citit litera b\n"). cons2. dac\ expresia nu are nici una din valorile indicate prin cons1. 5.. break.. Aceasta permite execu]ia unei anumite ramuri `n func]ie de valoarea expresiei "expresie" din parantez\. Dac\ expresia are valoarea const1 atunci se execut\ instruc]iune1 [i toate cele ce urmeaz\ dup\ aceasta p=n\ la `nt=lnirea unei instruc]iuni "break".. . deci exemplul este interpretat astfel: if ( a == 1 ) if ( b == 2 ) printf (“ b este egal cu doi\n”). dac\ valoarea sa este const2 atunci se execut\ instruc]iune2 [i urm\toarele p=n\ la "break" etc. else printf (“ b nu este egal cu doi\n”). Aten]ie! ~n acest ultim exemplu este o eroare de sintax\: alternativa else nu poate fi asociat\ cu if pentru c\ `naintea sa ( dup\ } ) apare caracterul ‘. C\rui if `i este ata[at else? Limbajul C rezolv\ problema aceasta prin ata[area lui else celui mai apropiat if.’ care reprezint\ instruc]iunea vid\! Apare [i problema ambiguit\]ii (a[a zisa problem\ “dangling else”): if ( a == 1 ) if ( b == 2 ) printf (“ b este egal cu doi\n”). Cazul default este facultativ.

este evaluat\ [i dac\ aceasta nu este nul\. y. se execut\ "instruc]iune" (care poate fi. while ((c = getchar( )) != EOF){ putchar (c). un bloc). naltele. b sau c\n"). break. } Programul urm\tor ilustreaz\ utilizarea instruc]iunii while [i a instruc]iunii switch. pe fiecare ramur\ s-a folosit instruc]iunea break. ce trebuie pus\ `ntre paranteze. } ~n acest exemplu. n++ } int x. else y = y-x. Exemplu: int c. `n cazul `n care exist\ pe una din ramuri alte instruc]iuni de control. n = 0. binen]eles. default: printf ("s-a citit altceva decat a. Instrucţiunea while while(expresie) instruc]iune Expresia "expresie".3. while (x!=y) { if (x>y) x = x-y. 5. Dup\ execu]ia acestei instruc]iuni se face din nou evaluarea expresiei indicate `n while [i se repet\ execu]ia p=n\ c=nd evaluarea expresiei returneaz\ o valoare nul\. Acest program analizeaz\ un text [i num\r\ vocalele.h> int main (void){ int nvocale. nspatii. break.48627669. break poate lipsi (vezi exemplul de la insrtuc]iunea for). Se `n]elege c\. spa]iile goale [i restul caracterelor din acesta. nvocale = naltele = nspatii = 0. char c. printf ("Introduceti un text\n -->"). while ((c = getchar( )) != '\n') { switch (c) { case 'a': case 'A': 37 .doc case 'c': printf ("s-a citit litera c\n"). Programul 6 # include <stdio.

Gheorghe GRIGORAŞ case case case case } } } printf("In text sunt %d vocale. while do instruc]iune while(expresie). n++..while (adic\ "instruc]iune") se execut\ la intrarea `n aceast\ bucl\ dup\ care se testeaz\ condi]ia "expresie": dac\ aceasta are valoare nenul\ se execut\ din nou "instruc]iune" etc. %d spatii si %d alte caractere. n-1). n-1). printf ("Linia contine %d caractere \n". return 0. c. do { c = getchar ( ). 38 .nvocale. "instruc]iune" se execut\ m\car o dat\ pe c=nd `n cazul while. c = getchar ( ) while (c!= '\n') { c = getchar ( ).while. Spre deosebire de instruc]iunea while. break. n++ }.nspatii. break.. case ' ': case '\t': nspatii++. } while (c!= '\n'). 'e': case 'E': 'i': case 'I': 'o': case 'O': 'u': case 'U': nvocale++. c. A[adar `n cazul do. default: naltele++. "instruc]iune" nu se execut\.4. dac\ "expresie" este evaluat\ prima dat\ la zero.\n".. Rezultatul unei execu]ii: Introduceti un text: --> Iata un text pentru test ! In text sunt 8 vocale.. printf ("Linia contine %d caractere\n". int n = 1. Instruc]iunea do . Execu]ia se termin\ atunci c=nd "expresie" are valoarea nul\... 5. Exemplu: int n = 0.5 spatii si 13 alte caractere.naltele). "corpul" instruc]iunii do.

• se execut\ (o singur\ dat\) expr1 [i se intr\ `n bucl\ (execu]ia de n ≥ 0 a instruc]iunii "instruc]iune"). . expr2 . 2. 5. while (expr2){ instruc]iune expr3. i++) putchar (c).doc Se constat\ u[or c\ cele dou\ secven]e de program sunt echivalente. c = getchar ( ). Exemplu: for (i = 0. expr3) instruc]iune Aceasta este o bucl\ infinit\. i++) if (c == '\n') break.5. S\ observ\m c\ ini]ializarea lui i s-a f\cut `n afara instruc]iunii for ! • Suprimarea expresiei de control: for( expr . } Instruc]iunea poate fi folosit\ [i prin suprimarea uneia dintre expr1. for( . 39 . expr3) instruc]iune Semantica acestei instruc]iuni poate fi descris\ `n dou\ moduri: 1. Instruc]iunea este echivalent\ cu secven]a: expr1. .(c = getchar( )) != '\0'.) din care lipse[te prima instruc]iune (expr1. i). for(. printf("numarul de caractere:%d\n". • instruc]iunea expr3 se execut\ la fiecare sf=r[it de bucl\.) Exemplu: i = 0.48627669. expr2 sau expr3 sau prin suprimarea corpului ("instruc]iune"): • Suprimarea ini]ializ\rii. Singura modalitate de a ie[i din aceasta este utilizarea instruc]iunii break. • expresia expr2 se evalueaz\ [i se testeaz\ la fiecare `nceput de bucl\: dac\ este adev\rat\ atunci se execut\ "instruc]iune" altfel bucla se termin\. Instrucţiunea for for (expr1. expr2. expr3) instruc]iune Aceasta este echivalent\ cu secven]a dat\ mai sus (2.

5. expr2 .Gheorghe GRIGORAŞ • Suprimarea expresiei finale: for( expr1 . if (sum>=50) { printf ("50\n"). expr2 . break. do) sau dintr-o instruc]iune cu alegeri multiple (switch). ) instruc]iune Exemplu: i=0 for (. ) instruc]iune Exemplu: for (i = 0. while ( ( c = getchar( )) != EOF) { sum++. 40 .3): 1. Instrucţiunea break Instruc]iunea break permite ie[irea dintr-o bucl\ (for. (c = getchar( )) != '\0'.){ putchar (c) i++ } printf ("numarul de caractere: %d\n". { putchar (c) i++ } printf ("numarul de caractere: %d\n". expr2 . i).6. (c = getchar( )) != '\0'. • Suprimarea corpului buclei: for( expr1 . Exemplu: for (i = 0. • Suprimarea ini]ializ\rii [i a expresiei finale: for( . expr3 ) . i). Iat\ c=teva exemple de utilizare a acestei instruc]iuni (vezi [i programul de la sf=r[itul paragrafului 5. i++). while. getchar( )!= '\n'.

numar <= 100. . 2. p=n\ la sf=r[itul buclei `n care se afl\. Instrucţiunea go to Instruc]iunea go to provoac\ saltul necondi]ionat la o etichet\.5) break. suma). printf("Tablourile nu au elemente comune\ n"). Iat\ un exemplu: int numar. sum <= 25. while ( ( c = getchar( ))!= EOF) { sum++. } ~n acest caz instruc]iunea break permite ie[irea din bucla for. i++) for (j=0. i < n. ~n acest prim exemplu. 41 .7. ea provoac\ trecerea la urm\toarea itera]ie. j < m. `n cuprinsul acelea[i func]ii.doc } } printf ("Iesire din bucla while\n"). j++) if (a [i] == b [j] ) go to gasit. suma++ = numar. go to eticheta . numar++) { if (numar % 5 == 0) continue. for (j = sum. 5. suma = 0. j++) { j* = 1. instruc]iunea break permite ie[irea din bucla while dup\ citirea a 50 de caractere [i nu la `nt=lnirea caracterului EOF. ~n exemplul urm\tor se ilustreaz\ folosirea instruc]iunii go to [i modul cum ea poate fi evitat\: for (i = 0. } printf ("Total: %d". } print ("Suma este:%d\n". Este recomandat s\ se evite folosirea instruc]iunii go to (a[a cer principiile program\rii structurate) dar uneori este util\.5.8. Se observ\ c\ prin continue se evit\ ad\ugarea la suma a numerelor multiple 5. de 5. for (numar = 1. . sum). Instrucţiunea continue Instruc]iunea continue ignor\ toate instruc]iunile ce urmeaz\ dup\ ea. Etichetele sunt nume ce se pun `n fa]a instruc]iunilor ]int\ urmate de ":". if ( j >= 75.48627669.

. 4.a[i]). gasit: printf (" a[%d]=b[%d]=%d\n". i++) for (j = 0. . Ultima linie va con]ine suma sumelor. Exerciţii jgjj Calculul factorialului. ad\ug=nd la sf=r[itul liniei suma lor. 5.calculul factorialului acestui num\r (iterativ). Se va utiliza o itera]ie pentru citirea caracter cu caracter a num\rului. verific\ validitatea sa [i efectueaz\ conversia `n zecimal.10. itera]ia se opre[te dac\ se cite[te un caracter ce nu este cifr\ hexazecimal\ [i. se va face apel la o func]ie ce num\r\ bi]ii 1.j. j++) gasit = (a [i] == b [j]).a [i]). 3.Gheorghe GRIGORAŞ . j < m &&! gasit.citirea unui num\r natural (dat de utilizator). pe m\sur\ ce se citesc cifrele hexazecimale se face conversia `n zecimal. Numerele n [i l se definesc ca valori constante.j. ~n bucla de citire. Scrie]i un program care s\ realizeze urm\toarele: . Scrie]i dou\ variante ale programului: a) programul con]ine doar func]ia principal\ main ( ) b) func]ia principal\ main face apel la o func]ie de conversie a unui caracter reprezent=nd o cifr\ hexazecimal\ `n valoarea sa zecimal\: int conversie (char x). Conversie Scrie]i un program care cite[te un num\r hexazecimal (ca o succesiune de caractere). aliniat\ la sf=r[it de linie. 5.i. 2. else printf ("Tablourile nu au elemente comune \n"). Prezentare de date Scrie]i un program care cite[te n valori `ntregi [i le afi[eaz\ c=te l pe fiecare linie. if (gasit) printf (" a[%d]= b[%d]= %d\n".i. int gasit = 0. i < n && ! gasit. for (i = 0.9. Soluţii la exerciţii 42 .afi[area rezultaului. Numărarea biţilor 1 într-un număr Scrie]i un program care cite[te 10 numere `ntregi [i pentru fiecare din acestea calculeaz\ num\rul bi]ilor ce au valoarea 1.

i < = n. else numar = numar*16 + (c .'0'). Prima solu]ie face conversie `n func]ia main ( ) iar a doua solu]ie folose[te o func]ie de conversie. Conversie Vom construi o bucl\ while care se execut\ at=ta timp c=t ultimul caracter citit este o cifr\ hexazecimal\: 0-9 sau a-f sau A-F.'a' + 10). fact). Dac\ este o astfel de cifr\. a) /*Citirea unui numar hexa si conversia sa in zecimal*/ # include <stdio. return 0. } 2. printf (" %d ! = %d\". /* Calculul lui n! */ # include <stdio. printf ("Introduceti un numar natural ->"). for (i = 2. &n).doc 1. } printf("Conversia zecimala :%d\n". n. numar). } 43 . while (( c>= '0') && (c<='9')| | (c>= 'a') && (c<='f')| | (c>= 'A') && (c<='F') { if ((c>= '0') && (c<='9')) numar = numar*16 + (c . c = getchar ( ). Programul va trebui completat cu un test pentru a controla valoarea citit\ [i cu un test pentru a verifica dac\ rezultatul calculului nu dep\[e[te capacitatea de reprezentare a unui num\r `ntreg.h> int main (void) { int n. i++) fact * = i. i. else if ((c>= 'a') && (c<='f')) numar = numar*16 + (c . printf (" Introduceti un numar hexa ->").'A' + 10). scanf ("%d". fact. return 0. c = getchar ( ) . se converte[te `n valoare `ntreag\. Calculul factorialului Iat\ o solu]ia incomplet\ a problemei. p\str=nd valoarea cumulat\ a num\rului zecimal ob]inut.h> int main (void){ int numar = 0. fact = 1. char c.48627669.

} int numarbit(int x){ int n = 0.h> int conversie (char x){ return (x>= '0') && ( x<= '9') ? x . Numărarea biţilor 1 într-un număr Determinarea bi]ilor 1 se face prin decalaj succesiv [i testarea bitului. } return 0. } 44 intreg */ . printf ("Numarul bitilor 1 este: %d\n". i < 10. return 0. c = getchar ( ) . printf (" Introduceti un numar hexa ->"). for (i = 0.'0': ((x>='a')&&(x<='f')?x-'a':x-'A')+10. x >>=1. i++) { printf ("Introduceti o valoare intreaga: "). while (x!=0) { if (x & 01) n++. int main (void) { int i. } int main (void){ int numar = 0. } printf ("Conversia zecimala: %d\n". /* Numararea bitilor 1 din reprezentarea binara a unui numar # include <stdio. numar). while (( c>= '0') && (c<='9')| | (c>= 'a') && (c<='f ')| | (c>= 'A') && (c<='F') { numar = numar*16 + conversie (c). int val.Gheorghe GRIGORAŞ b) /*Citirea unui numar hexa si conversia sa in zecimal*/ # include <stdio. } return n.h> int numarbit(int). scanf ("%d". numarbit(val)). char c. } 3. c = getchar ( ) . &val).

/* suma sumelor par]iale */ nt. } 45 . sumap = 0. nl = 0. suma).doc ~n func]ia numarbit. for (nt = 0. printf ("%6d"./*numarul intregilor pe linie */ suma=0. sumap).Ultima linie contine suma sumelor */ # include <stdio. /*numarul total de intregi */ printf ("Introduceti%d numere intregi". ++nl. &val). Prin instruc]iunea x >>=1 se decaleaz\ bi]ii lui x cu o pozi]ie la dreapta. if (nl == l ) { printf (" %6d\n". suma += sumap. nt++) { scanf ("%d". for (i = nl. se poate a[adar utiliza x ca variabil\ de lucru. i++) printf (" "). int main (void){ int val. return 0 . i < l. 4. val). suma p+= val. nt < n.48627669.h> const n = 10. suma += sumap. printf ("%6d\n". i++) printf (" "). const l = 3. /*suma din linia curenta*/ nl=0. sumap). la st=nga se adaug\ un zero. n). for (i = 0. Prezentare de date /* Se citesc n intregi si se afiseaza cate l pe **linie impreuna cu suma acestora la sfarsit de **linie. /*ultima valoare intreaga citita */ sumap=0. } } if (nl! = 0) { /*ultima linie este incompleta: se **completeaza cu spatii*/ int i. i < l. } /* alinierea sumei totale pe ultima linie */ int i. printf ("%d\n". transmiterea parametrului se face prin valoare.

6. pi = &i. De exemplu. char *pc. se specific\ faptul c\ pi este un pointer la o variabil\ de tip `ntreg iar pc un pointer la o variabil\ de tip "char".9.12.11. permite ob]inerea adresei acesteia: int i. 6. 6.7. 6.2.8. aplicat unei variabile. 6.3.Cap 6 TABLOURI ŞI POINTERI 6. Pointeri Tablouri cu o dimensiune Rela]ia `ntre pointeri [i tablouri Opera]ii aritmetice cu pointeri {iruri de caractere Tablouri cu mai multe dimensiuni Tablouri de pointeri Pointeri [i alocarea memoriei Operatorul sizeof Pointeri c\tre func]ii Exerci]ii Solu]ii 6. prin declara]iile: int *pi. Pointerii au tip : aceasta `nseamn\ c\ un pointer nu poate fi folosit dec=t pentru a con]ine adrese de variabile de un singur tip. Operatorul unar "&" numit operator de referen]iere sau adresare. 6.5.4.1. Pointeri tip *identificator.10. 6. 6. Un pointer este o variabil\ ce con]ine adresa unei alte variabile.1. .6. 6. 6. 6.

numit\ expresie indice . vector[1]. Utilizarea operatorului "*" este destul de delicat\. } Apelul corespunz\tor este: int x = 1. A[adar. numele tabloului (nume) .) nu are nici un efect asupra variabilelor x. b = temp. Declara]ia int vector[10]. permite derefen]ierea unui pointer. Varianta corect\ este: void schimbare_corecta (int *p.doc Operatorul unar "*". ~n declara]ia de mai sus.y (actuale) pentru c\ func]ia lucreaz\ cu variabilele ei locale a [i b. schimbare_corecta (&x. o declara]ie de tablou cu o dimensiune con]ine tipul tabloului (tip). `n limbajul C transferul implicit al parametrilor este prin valoare. indirectare. x = *pi ⇔ x = i. y = 2. dimensiune. este: void schimbare (int a. Tablouri cu o dimensiune tip nume[dimensiune].care este un identificator . cele 10 elemente ale tabloului vector sunt: vector[0]. fiecare din acestea put=nd fi accesibil\. furniz=nd valoarea variabilei pointate de acesta: int x. Dac\ se dore[te modificarea unui parametru formal.48627669. Dimensiunea este o constant\ `ntreag\ [i specific\ num\rul elementelor tabloului. 6.2.…. Exemplul clasic pentru acest procedeu este acela al func]iei de interschimbare a dou\ variabile. dereferen]iere. int *q){ int temp. trebuie transmis\ func]iei adresa variabilei iar `n corpul func]iei s\ se foloseasc\ operatorul de dereferen]iere. 6. } Un apel al acestei func]ii (prin schimbare (x. define[te un tablou cu numele "vector" care are 10 elemente de acela[i tip.precum [i dimensiunea sa. y).2. Utilizarea unui pointer care este ini]ializat gre[it este o eroare des `nt=lnit\ `n programare [i din p\cate consecin]ele sunt imprevizibile. chiar periculoas\ am spune: acesta permite citirea sau scrierea `n orice zon\ de memorie. O aplica]ie important\ privind utilizarea pointerilor este transferul prin referin]\ al parametrilor unei func]ii. a = b. Primul element al tabloului este cel de indice 0 iar ultimul este cel de indice dimensiune -1.1. &y). incorect\ (semantic) `n limbaj C. *q = temp. int b) { int temp = a. vector[9] 47 .care trebuie s\ aib\ valoarea `ntre 0 [i dimensiune . Forma "clasic\" a func]iei. A[a cum s-a precizat la capitolul "Func]ii". *p = *q. temp = *p. `ntreg.1. Un tablou este o colec]ie de elemente(date) de acela[i tip. int vector[10]. Referenţierea unui element al tabloului Elementele unui tablou pot fi accesate prin numele tabloului urmat de o expresie `ntre paranteze p\trate .

2. 1}. 3. tab[1] = tab[2] = 'b'. 0}. Dupa aceste transformari structura sa va fi: 'a' 'b' 'c' 'd' 'e' Dac\ lista de valori ini]iale (dat\ dup\ declara]ie) cuprinde mai pu]ine elemente dec=t dimensiunea declarat\ a tabloului. aceasta se determin\ de c\tre compilator: float x[ ] = {2.. tab[marime/2] = 'c'.2 3 4 0 48 . separate prin virgule. tip nume[dim] = { valoare_1. 4. atunci celelalte valori se ini]ializeaz\ cu zero. tab[3] = tab[4] = 'd'. int a[4] = {1. # define marime 5. valoare_2.1] = 'e'. Spre exemplu int a[10] = {5. }. char tab[marime]. 2. 2 0 5. '\o'}.. 'a' 'b' 'b' 'd' 'd' Tabloul va avea structura: tab[marime . 5.2. 3. care se `nchid `ntre acolade. 2. 3. 2. 6. Adresa primului element (cel de indice 0) este [i adresa tabloului iar celelalte elemente se raporteaz\ la acesta.Gheorghe GRIGORAŞ La declararea unui tablou se aloc\ o zon\ de memorie contigu\ care s\ stocheze toate elementele tabloului. Exemple: 1. 0. are ca efect crearea tabloului: 5 2 3 1 0 0 0 0 0 0 ~n cazul unui tablou care se ini]ializeaz\. char s[4] = {'a'.2. poate fi omis\ dimensiunea. 'c'. 'b'. . Iniţializarea unui tablou Ini]ializarea unui tablou se face prin semnul "#" dup\ declara]ia acestuia urmat de o list\ de valori ini]iale. 4}. tab[0] = 'a'.

3. ini]ializarea se poate face [i cu [iruri de caractere incluse `ntre ghilimele. numele unui tablou poate fi utilizat ca pointer (constant) la adresa de `nceput a tabloului. 'b'. este echivalent\ cu: char s[ ] = {'a'. i++) *(pa+i) = 100. for ( i = 0. '\0'}. `n general "*(pa+i)" este totuna cu tab[i]. i++) *(pa++) = 100. float x [20]. pa = &tab[0]. 'd'. acest caracter noteaz\ sf=r[itul [irului( vezi paragraful 6. Relaţia între pointeri şi tablouri S\ consider\m urm\toarea secven]\: int tab[10]. `n sensul c\ ele reprezint\ adresa aceleia[i zone de memorie. int *pa. } Este de remarcat faptul c\ nu se face nici o verificare a limitelor unui tablou atunci c=nd se acceseaz\ un element al s\u. b[3]. De aceea. i < 10. c[3]. for (i=0. 'b'. 6. 'e'. iar declara]ia: char s[ ] = "abcdef" . ~n limbajul C. sunt echivalente. declara]ia: char s[6] = "abcdef" .48627669. 'd'. Ini]ializarea unui tablou se poate face [i prin citirea succesiv\ a tuturor elementelor sale: int i. for ( i = 0. Urm\toarele secven]e for sunt echivalente: for ( i = 0. pa = &tab[0]. Nota]ia "*pa" este echivalent\ cu nota]ia tab[0] iar nota]ia "*(pa+1)" este echivalent\ cu nota]ia tab[1]. ultimul element al tabloului este caracterul ‘\0’. Ultima instruc]iune asigneaz\ variabilei pointer pa adresa primului element al tabloului tab.doc ~n cazul tablourilor de caractere. A[adar.5). i++) tab[i] = 100. i < 20. pa = &tab[0]. este perfect valid\ asignarea 49 . 'e'. De notat c\ `n cazul sirurilor de caractere ce se memoreaz\ `ntr-un tablou. Spre exemplu dac\ se declar\ int a[3]. c[-2]. 'f'. &x[i]). 'f'}. i++) { scanf (" %f". 'c'. b[1]. cu declara]iile de mai sus. i < 10. [i alocarea se face astfel: a[0 a[1] a[2] b[0] b[1] b[2] c[0] c[1] c[2 ] ] atunci expresiile a[4]. este echivalent\ cu: char s[6] = {'a'. 'c'. i < 10.

Prin conven]ie. i < 10.5.3 ptr1 . Nota]ia pointer ptr = tablou ptr1 = ptr + 5 ptr + i ptr + 4 ptr . dup\ incrementare. '\o'}. care este echivalent\ cu "pa=&tab[0]. echivalen]a `ntre elementele unui tablou [i numele s\u se exprim\ prin: tablou[i] *(tablou + i) &tablou[i] tablou + i 6. Iat\ [i alte exemple: `n partea st=ng\ se descrie o expresie `n care apar pointeri iar `n dreapta expresia echivalent\ `n termenii tabloului. Pentru a reprezenta un [ir de caractere. --) [i sc\derea a doi pointeri de acela[i tip.". Şiruri de caractere ~n limbajul C. A[adar se poate scrie [i: for ( i = 0. pf++. incrementarea/decrementarea (^^.'t'. Operaţii aritmetice cu pointeri Opera]iile aritmetice permise asupra pointerilor sunt adunarea/ sc\derea unei constante. Citirea respectiv tip\rirea acestui [ir se face prin instruc]iunile: 50 . sau tab ++. i++. float *pf = ftablou. char mesaj[ ] = "salut!". ~n rezumat. pa++) *pa = 100. char mesaj[7] = "salut!". Trebuie precizat `ns\ c\ unitatea care intr\ `n discu]ie nu este octetul ci adresa obiectului pointat.'u'.'l'. pf pointeaz\ la cel de-al doilea element al tabloului ftablou.'!'. ultimul caracter dintr-un astfel de lan] este caracterul NULL (' @0').Gheorghe GRIGORAŞ pa = tab. pa = tab. Tabloul de caractere (pe care-l numim mesaj): 's' 'a' 'l' 'u' 't' '!' ' @o' poate fi declarat prin una din urm\toarele trei instruc]iuni: char mesaj[7] = {'s'. nu exist\ un tip de baz\ pentru [iruri (lan]uri) de caractere.'a'.ptr ptr ++ Nota]ia tablou i=0 i=i+5 tablou [i] tablou [4] tablou [-3] j-i i ++ 6. Nu sunt valide (e lesne de dedus) expresiile: tab = pa.4. se utilizeaz\ tablourile de caractere. ~n acest exemplu. S\ urm\rim urm\torul exemplu: float ftablou[10].

.*dim_n elemente de acela[i tip (declarat) stocate `ntr-o zon\ contigu\ de memorie. Exist\ o bibliotec\ de func]ii standard pentru manipularea [irurilor de caractere care se prezint\ `n anex\. `n concordan]\ cu modul de stocare a elementelor tabloului `n memorie. Pentru a accesa un element dintr-un tablou exist\ mai multe moduri de notare. mesaj).. mesaj). 6.. .doc scanf("%s". dim_n trebuie s\ fie constante. ~n aceast\ declara]ie. O alt\ viziune (acceptat\ de C) a acestui tablou este aceea a unui tablou cu o singur\ dimensiune `n care fiecare element este la r=ndul s\u un tablou cu o dimensiune: t t[0] t[1] t[2] t [0][0] t [1][0] t [2][0] t [0][1] t [0][2] t [0][3] t [1][1] t [1][2] t [1][3] t [2][1] t [2][2] t [2][3] Elementul t[1] reprezint\ un tablou cu o dimensiune iar elementul ha[urat este referen]iat prin *(t[1]+3).6. mesaj[0]). datorit\ numerot\rii indicilor de la 0)...[dim_n]. ~n sf=r[it a treia viziune a tabloului este aceea a unei succesiuni de elemente dispuse `ntr-o zon\ contigu\: t [0][0] t [0][1] t [0][2] t [0][3] 51 .48627669. dim_1. scanf("%s".. Iat\ de exemplu o declara]ie a unui tablou cu dou\ dimensiuni de valori 3 respectiv 4 (a[adar o matrice cu 3 linii [i 4 coloane). Un tablou declarat `n acest mod se compune din dim_1*dim_2*. dim_2. printf("%s".. &mesaj[0]). O prim\ viziune a reprezent\rii acestuia `n memorie este cea natural\ a unei matrice: t [0][0] t [0][1] t [0][2] t [0][3] t [1][0] t [1][1] t [1][2] t [1][3] t [2][0] t [2][1] t [2][2] t [2][3] Elementeul ha[urat din acest tablou se referen]iaz\ prin t[1][2] (este elementul de pe linia 2 [i coloana 3 din matrice. Tablouri cu mai multe dimensiuni Declararea unui tablou cu N dimensiuni se face prin: tip nume[dim_1][dim_2]. int t[3][4]. printf("%s".

{9. t [1][0] cu 5 iar t [1][1] cu 6. zi[0] 'l' ' u ' ' n ' 52 zi[1] 'm ' 'a' 'r' zi[2] ' m ' 'i' 'e' zi[3] 'j' ' o ' 'i' zi[4] 'v ' 'i' ' n ' zi[5] 's' 'a ' ' m ' zi[6] 'd ' 'u ' ' m ' . char *zi[7] = {"luni". 2. 3. "joi". restul elementelor sunt ini]ializate cu zero. 12}. t[3][4]: • ini]ializarea prin enumerarea tuturor elementelor tabloului ( `n ordinea liniilor dac\-i vorba de matrice): int t[3][4] = {1. }. 11. "vineri". 5. pot intra `n componen]a unui tablou. 4}. 10. 8. S\ exemplific\m aceste moduri cu referiri la acela[i tablou pe care l-am reprezentat mai sus. 6}}. 3. 6. 9.Gheorghe GRIGORAŞ t [1][0] t [1][1] t [1][2] t [1][3] t [2][0] t [2][1] t [2][2] t [2][3] Elementul ha[urat (acela[i ca [i `n cazurile anterioare) se referen]iaz\ prin: *( *t + 6) sau prin nota]ia echivalent\: *( &( t[0][0] + 6)) S\ not\m c\ `n acest caz t este de tip pointer de pointer de `ntregi (dubl\ adresare indirect\). separat: int t[3][4] ={{1. 6. 11. Iat\ cum se declar\ un tablou de pointeri cu 7 componente ce se ini]ializeaz\ cu adresele [irurilor constante ce reprezint\ numele zilelor dintr-o s\pt\m=n\. Un tablou unidimensional de pointeri corespunde la un tablou (cu dou\ dimensiuni) de elemente de tipul pointat. "miercuri". 12} }. [i ini]ializarea unui tablou se poate face `n moduri diferite (sintactic vorbind). 8}. O problem\ important\ relativ la tablourile cu mai multe dimensiuni este cea a ini]ializ\rii acestora. "duminica").{5. Astfel t [0][0] va fi ini]ializat cu 1. A[a cum referen]ierea unui element al tabloului poate fi f\cut\ `n mai multe moduri. 6. • ini]ializarea numai a unor elemente din tablou: int t[3][4] = {{1}.7. "sambata". 7. 2. 10. • ini]ializarea fiec\rei dimensiuni de tablou.{5. 4. "marti". Tablouri de pointeri Pointerii fiind variabile. 7.

i++) if (strcmp (tabp [i]. sortat = 0. while (! sortat) { sortat = 1. for (i = 0. tabp [i] = tabp [i+1]. } } } Apelul pentru sortarea alfabetic\ a zilelor s\pt\m=nii este sortare(zi. 7). S\ mai d\m un exemplu de func]ie care sorteaz\ lexicografic (alfabetic) [irurile pointate de tabp: void sortare (char* tabp[ ]. ~n corpul func]iei sortare s-a folosit un apel la func]ia strcmp care compar\ 2 [iruri de caractere s1 [i s2. } Apelul acestei func]ii pentru scrierea zilelor s\pt\m=nii este: scrie (zi. rezultatul este negativ dac\ s1 < s2. O func]ie care s\ afi[eze toate [irurile de caractere (pointate de tabp) la un singur apel ar putea ar\ta astfel: void scrie(char *tabp [ ].8. i < n. cu numele tabp.48627669.h> 53 .doc 'i' 't' 'i' 'r' 'c' 'u' 'r' 'i' ' e ' 'r ' 'i' 'b ' 'a ' 't' 'a ' 'i' 'n ' 'i' 'c ' 'a ' S\ consider\m un tablou de pointeri de tip char. tabp [i+1]) > 0) { temp =tabp [i]. # include <stdlib. sortat = 0. char *temp. tabp[i] ). Acest spa]iu este posibil de accesat cu ajutorul variabilelor de tip pointer. int n) { int i. pozitiv dac\ s1 > s2 [i zero dac\ s1 # s2. 6. Pointeri şi alocarea memoriei Printre func]iile de alocare a memoriei (vezi Anexa ). i++) if (tabp [i] != NULL) printf ( "%s\n". 7). tabp [i+1] = temp. i < n-1. "maloc" [i "free" joac\ un rol important pentru c\ ele permit alocarea / dealocarea `n mod dinamic a spa]iului din memorie. int n){ int i. for (i = 0.

sizeof(tip). element *ptr. atunci c=nd este parametrul unei func]ii.. Operatorul “sizeof” ofer\ dimensiunea `n octe]i a tipului expresiei considerate(tipului respectiv). /*declaratia este echivalenta cu void f(double*)*/ int main( ){ 54 . /*presupunem ca tipul element este definit undeva */ -------tampon = malloc(512). void free(void *ptr). Pointerul returnat este de tip "void" ce corespunde unui pointer la o variabil\ de tip oarecare. . Func]ia malloc are ca argument num\rul de octe]i dori]i a fi aloca]i [i `ntoarce ca rezultat un pointer c\tre zona de memorie liber\ alocat\ de sistem. De pild\. Pentru a ob]ine num\rul elementelor tabloului t se utilizeaz\ expresia “sizeof t” sau “sizeof t[0]”. Operatorul “sizeof” sizeof expresie. Dac\ nu mai este memorie disponibil\ (nu se poate face alocarea) func]ia malloc returneaz\ valoarea NULL. /*s-a alocat o zona de 32 de "elemente"*/ if ((tampon == NULL | | ptr == NULL)) { printf ("Alocare imposibila ! \n"). /* s-a alocat o memorie tampon de 512 caractere*/ ptr = malloc(32*sizeof(element)). 6. Iat\ un exemplu: char *tampon. dup\ utilizarea memoriei tampon [i ptr (`n exemplul de mai sus) se scrie (`n program) free (tampon). Func]ia "free" permite dealocarea spa]iului de memorie alocat `n prealabil de malloc. void f(double[ ]). Acest lucru se ilustreaz\ `n exemplul urm\tor: double tab [100]. free (((char*)ptr). Alocarea dinamic\ a memoriei este deosebit de util\ at=ta timp c=t programatorul folose[te structuri de date pentru care nu [tie dimensiunea la scrierea programului. operatorul sizeof ofer\ dimensiunea `n octe]i a memoriei ocupat\ de `ntreg tabloul. S\ not\m `n acela[i timp c\. prin urmare operatorul sizeof nu ofer\ dimensiunea memoriei ocupat\ de tablou ci dimensiunea tipului pointer. se poate utiliza operatorul "sizeof" (vezi sec]iunea urm\toare).9.. . un tablou este considerat ca [i un pointer. Pentru specificarea m\rimii unui tip particular... Dac\ se aplic\ unui tablou. ~n cursul execu]iei programul poate aloca memorie `n limitele impuse de sistem.Gheorghe GRIGORAŞ void *malloc (size_t dim).

const char*). "Constantin Vasile". ofer\ num\rul de octe]i utiliza]i pentru a memora un `ntreg “long” (este incorect a scrie sizeof long).. de a defini o variabil\ de tip pointer c\tre o func]ie. nume: este identificatorul pointerului la func]ie.h> # include <string. size_t n. cel\lalt de tipul const char*. De aceast\ dat\ parantezele sunt obligatorii. De exemplu declara]ia: char *(*p)(char*.h> enum {n_max = 10}.doc int i = sizeof tab.48627669. const void* val2)) Func]ia qsort este o func]ie de sortare general\ care permite sortarea unui tablou de elemente de tip oarecare(baza) prin specificarea unei func]ii de comparare. "Ion Gheorghe". Un exemplu de utilizare a tipului pointer la o func]ie este func]ia de comparare “cmp” ce apare ca argument la func]ia de sortare “qsort” (vezi anexa ): void qsort(const void* baza. Este posibil.10. tip: este tipul returnat de func]ia pointat\. /* i este initializat cu sizeof(double)*/ } Pentru a ob]ine dimensiunea memoriei ocupat\ de un tip anume se folose[te: sizeof(tip). unul de tip char*. pe de alt\ parte. size_n t. Declara]ia unui pointer la o func]ie este de forma: tip(*nume) (lista_arg). . /* tab_int este tabloul ce contine lungimile liniilor **ce trebuie sortat */ char* tab_nume[n_max] = { "Ionescu Ion". Apelul sizeof(long).h> # include <stdlib. lista_arg : este lista argumentelor func]iei pointate. Iat\ un program ce utilizeaz\ func]ia qsort : # include <stdio. 6. Este important a se pune “*nume” `n parantez\ deoarece declara]ia “tip *nume (lista_parametri)” precizeaaz\ c\ nume este o func]ie de tip “tip*”. } void f(double t[ ]){ int i = sizeof t. /* i este initializat cu 100 * sizeof(double)*/ f(tab). precizeaz\ c\ p este un pointer la o func]ie de tip char* (pointer la tipul char).. int(*cmp)(const void* val1. 55 . int tab_int[n_max]. Pointeri către funcţii O func]ie are un nume care este identificator dar acesta nu constituie o variabil\ `n C. are doi parametri.

tab_nume[i]). i++) printf("%2d: %s\n". printf("Nume ordonate lexicografic: \n"). [irurile de caractere sunt memorate `n tablouri `n care ultimul element este un delimitator de sf=r[it de [ir: caracterul NULL(‘\0’). const void* p2) { return(strcmp(*(char**)p1. for(i = 0.11. n_max.i. qsort(tab_int. printf("Lista initiala de nume : \n").comp_nume). i++) tab_int[i] = strlen(tab_nume[i]).sizeof(char*). Dac\ are loc rela]ia s1 < s2. const void* n2) { return(*(int*)n1. "Vasiliu Catalina". Exerciţii 1. printf("Lungimile numelor sortate:\n"). } int comp_nume (const void* p1. for(i = 0. for (i = 0. `n C.i. "Vasile Radu". S\ se scrie programe C care s\ implementeze func]iile: a) int strlen(const char*s) : func]ie ce returneaz\ dimensiunea [irului s. c) char* strcat(char* dest.*(int*)n2). A[a cum s-a mai precizat.const char* sursa) : func]ie ce copie [irul sursa `n [irul dest [i returneaz\ dest. for(i = 0. i++) printf("%2d: %s\n". "Vasilescu Maria". i < n_max . b) char* strcpy(char* dest. "Vasilescu Cristi" }.i. qsort(tab_nume. "Constantinescu Ioana". i < n_max.n_max. 56 . const char* s2) : func]ie ce compar\ [irurile s1 [i s2 conform ordinii lexicografice.const char* sursa): func]ie ce concateneaz\ [irul sursa la sf=r[itul [irului dest [i returneaz\ valoarea lui dest. i < n_max. dac\ s1 = s2 se returneaz\ 0 [i dac\ s1 > s2 se returneaz\ o valoare pozitiv\.tab_nume[i]). se returneaz\ o valoare negativ\. i++) printf("%2d: %d\n". i < n_max. "Constantiniu Calin". } 6.tab_int[i]). return 0. sizeof(int).*(char**)p2)). d) int strcmp(const char* s1. comp_int). /* tab_nume este tabloul ce trebuie ordonat **lexicografic */ /* se definesc functiile de comparatie */ int comp_int (const void* n1. } int main(void) { int i.Gheorghe GRIGORAŞ "Constantin Mircea". ~n anex\ sunt date func]iile din biblioteca standard care se aplic\ [irurilor de caractere.

int strcmp(const char *s1. const char *sursa). # include <stdlib. const char *sursa){ int i = 0. char *sfarsit = "exemplu ! ". return dest.i . } char *strcat(char *dest. } char *strcmp(const char *s1. Dac\ evaluarea acestui parametru este valoarea fals (0) atunci assert returneaz\ un mesaj de eroare. int strlen(const char *s){ int i = 0.h> int strlen(const char *s) char* strcopy(char *dest. i++ } dest[i] = '\0'. char* strcat(char *dest. int main(){ char *inceput = "Iat\". } char *strcpy(char* dest. while(sursa[i] != '\0') { dest[i] = sursa[i].doc 6. const char *sursa). 57 . const char *s2){ int i = 0. const char *sursa){ while(*dest != '\0') dest++. while(*scr != '\0') *dest++ = *src++. *dest = '\0'.48627669.s2[i]. char *mesaj. Soluţii 1.h> # include <assert. return -. char *mijloc = "un mic". const char *s2). Implementarea func]iilor de la a) la d) se poate face folosind nota]ia tablou sau aritmetica pointerilor. return s1[i] . } Iat\ [i un program care testeaz\ aceste func]ii. Se folose[te func]ia assert (anexa ) care are ca parametru o expresie logic\ ce descrie o proprietate ce trebuie verificat\. return dest. while(s[i++] != '\0') .12. while((s1[i] == s2[i] && (s1[i] != '\0')) i++.

"Iat un micut exemplu!") < 0).inceput) > 0). 58 . assert(strcmp(mesaj. assert(strcmp(mesaj. mesaj = malloc(lung + 1).Gheorghe GRIGORAŞ } int lungime.mijloc). lungime = strlen(inceput)+ strlen(mijloc) +strlen(sfarsit). sfarsit). assert(lungime==strlen("Iata un mic exemplu ! ")). "Iata un mic exemplu !")== 0). strcat(strcat(strcopy(mesaj.inceput). return 0. assert(strcmp(mesaj.

~n anumite programe este util s\ regrup\m diferite variabile pentru a exprima o anume rela]ie ce le caracterizeaz\. typedef char Mesaj[49].7 7. .2 7. Sintaxa ei este: typedef tip nume_nou. Instruc]iunea permite redenumirea at=t a tipurilor de baz\ (deja existente) c=t [i a tipurilor construite.5 7.3 structuri 7.Cap 7 CONSTRUIREA DE NOI TIPURI 7.1. ~n acest capitol vom vedea c\ `n C putem construi “structuri” sau “uniuni” care permit regruparea elementelor de tipuri diferite `n scopul de a defini un nou tip. 7.8 Redenumirea unui tip Tipul structur\ Accesul [i ini]ializarea c=mpurilor unei Structuri autoreferen]iate Tipul enumerare Uniuni Exerci]ii Solu]ii ~n capitolul al doilea au fost introduse tipurile de baz\ ale limbajului C. De asemenea exist\ posibilitatea de a renumi (redenumi) un anume tip. Redenumirea unui tip Instruc]iunea typedef permite redenumirea unui tip. Iat\ c=teva exemple: typedef long Mare.4 7. Aici “tip” este tipul ce se dore[te a fi redenumit iar nume_nou este numele ce se d\ acestuia.6 7.1 7. De pild\ un tablou permite a regrupa o mul]ime de elemente de acela[i tip.

el este totu[i util pentru a identifica structura definit\. Fiecare linie din partea “declara]ii” define[te un c=mp al structurii. } struct Student ionescu. typedef struct{ short ziua. short luna. char prenume[20] Data data_nasterii.Gheorghe GRIGORAŞ typedef char Luna[10]. }. struct Data data_nasterii.2. ~n instruc]iunea de mai sus “nume” este facultativ. struct Persoana colegul. Mare a. short anul. 7. struct Data{ short ziua. Luna ianuarie = "ianuarie". Tipul structură Instruc]iunea pentru definirea structurilor este: struct nume{ declara]ii }. popescu. char prenume[20]. short luna. Mesaj salut="!Bine a-ti venit la cursul<Limbajul C>". int varsta. char *prenume. struct Student{ char *nume. O variabil\ de tipul “ struct nume” poate fi definit\ `n aceea[i instruc]iune `n care este definit\ structura sau separat Iat\ c=teva exemple: struct Persoana{ char nume[20]. Structura este o colec]ie de una sau mai multe variabile (numite membri) grupate sub un singur nume.b. int an. typedef struct { char nume[20]. char *grupa. } Data. short anul. } amicul. 60 .

Aici. O form\ echivalent\ este urm\toarea: (*necunoscut).varsta este de tip int. Persoana ionescu. 0}.nume este de tip char*.3. urmat\ de numele c=mpului. S\ consider\m acum declara]ia: typedef struct{ char nume[40] . char prenume[40].48627669.de pild\. Dou\ structuri de acela[i fel pot s\ apar\ `ntr-o expresie de atribuire. dan. dan. int varsta. Iat\. urm\rind exemplele din paragraful precedent. popescu. O atribuire de structuri este o copiere bit cu bit a elementelor corespunz\toare. Prin aceasta.varsta = (*necunoscut). necunoscut ->varsta = 41. *necunoscut. variabilele “ionescu” [i “dan” sunt definite ca fiind de tip Persoana . `nc=t o astfel de expresie are sens doar dac\ structurile sunt de acela[i tip. Elementul desemnat `n acest mod este echivalent cu o variabil\ de acela[i tip cu c=mpul definit `n structur\. Persoana necunoscut = { " " . amicul. Exemplu: necunoscut = &ionescu. 42 }. } Persoana. Are sens asfel: necunoscut = ionescu . 61 . ionescu. Ini]ializarea unei variabile de tip structur\ se poate face `n maniera `n care se ini]ializeaz\ un tablou: se descrie cu ajutorul unei liste de valori ini]iale c=mpurile structurii: Persoana ionescu = { "Ionescu". care este un tip structur\.nume = necunoscut->nume. dan. Accesul şi iniţializarea câmpurilor unei structuri Accesul la c=mpurile unei variabile de tip structur\ se face utiliz=nd numele unei variabilei urmat\ de punct (“.doc } Persoana. c=mpurile din variabila “ionescu” sunt copiate `n c=mpurile corespunz\toare din variabila “necunoscut”. Persoana ionescu.data_nasterii. prin typedef li se atribuie un nume. Accesul la c=mpurile unei astfel de variabile(pointer la o structur\) se face ad\ug=nd dup\ numele varibilei pointer o “s\geat\” (“->”) .ziua este de tip short. avem: ionescu. S\ observ\m c\ structurile se pot defini f\r\ nume.varsta = 41.nume. iar necunoscut este o variabil\ de tip pointer la structura Persoana . "Vasile" .”) [i de numele c=mpului selec]ionat. " " . 7.

fiecare nod este compus dintr-o informa]ie (valoarea nodului) [i doi pointeri. printf("Al doilea arbore este: \n"). Din acest motiv structura are un nume: Arbore. Programul Arbori binari. struct Arbore* drept. a1=adauga(1. void afisare (Arbore* a). a2=adauga(10. } Arbore.. unul la subarborele st=ng altul la cel drept. liste. adauga(20. Arbore* a2. printf("\n"). afisare(a2). printf("\n"). struct Arbore *stang. adauga(3.4. arbori etc. adauga(2. printf("Primul arbore este: \n"). NULL)). `ntr-un arbore binar. struct Arbore *drept. De pild\. Structuri autoreferenţiate Utilizarea structurilor permite construirea de structuri de date evoluate ca: fi[iere. struct Arbore* stang. Arbore* s.. Arbore* d){ 62 . NULL). Arbore* adauga(valoare v. NULL). afisare(a1).h> typedef int valoare. S\ observ\m c\ structura Arbore se autoreferen]iaz\: printre c=mpurile structurii arbore sunt dou\ care sunt de acela]i tip struct Arbore. # include <stdio. /* s-a definit tipul "valoare" pentru **informatia din nodurile arborelui*/ typedef struct Arbore{ valoare val. return 0. NULL. typedef struct Arbore{ valoare val. NULL. Iat\ cum poate fi definit\ o astfel de structur\: typedef struct { . Arbore* d).. NULL)). Programul urm\tor ilustreaz\ utilizarea unei structuri autoreferen]iate: se construiesc doi arbori binari folosind func]ia “adauga” [i se afi[eaz\ un arbore `n nota]ia infix (func]ia “afisare”). } Arbore* adauga(valoare v. adauga(4. int main( ){ Arbore* a1. } Arbore. a1. Arbore* s.Gheorghe GRIGORAŞ 7.h> # include <stlib. NULL. } valoare.

48627669.doc

} void afisare (Arbore* a){ if (a! = NULL) { printf ("(%d", a->val , " "); afisare (a->stang); printf (" "); afisare (a->drept); printf (")"); } else printf ("nil"); } Execu]ia programului are ca rezultat afi[area urm\toarelor informa]ii: Primul arbore este: (1 (2 (3 nil nil) nil) (4 nil nil)) Al doilea arbore este: (10(1 (2 (3 nil nil) nil) (4 nil nil)) (20 nil nil))

Arbore* c; c=malloc (sizeof (Arbore)); c->val = v; c->stang = s; c->drept = d; return c;

7.5. Tipul enumerare
Definirea unui tip enumerare se face prin instruc]iunea: enum nume { Un tip enumerare permite ca, lista_de_identificatori}; `ntr-o maniera elegant\,s\ definim un tip care nu poate lua valori dec=t `ntr-o mul]ime precizat\ de valori constante. Primul identificator constant din lista de identificatori cap\t\ valoarea 0, al doilea valoarea 1, etc. cu excep]ia cazului `n care programatorul ofer\ valori ini]iale acestor identificatori. Exemple: enum Bool {da, nu}; Aici da are valoarea 0 iar nu are valoarea 1. enum Bool {da=1, nu=0}; enum Bool {nu, da} ~n ambele situa]ii, nu are valoarea 0 iar da are valoarea 1. enum Luna {ian=1, feb, mar, april, mai, iunie, iulie, august, sept, oct, nov, dec}; Aici, pentru c\ lui ian i s-a dat valoarea ini]ial\ 1, celelalte luni vor avea respectiv valorile 2, 3, ..., 12. Similar cu definirea variabilelor de tip structura se definesc variabilele de tip enumerare: enum Bool raspuns; enum Bool spune=da; Evident se poate redenumi [i tipul enumerare: Typedef enum {da, nu} Bool Bool raspuns=nu;

63

Gheorghe GRIGORAŞ

7.6. Uniuni
Uniunile sunt structuri care pot con]ine (la momente de timp diferite), obiecte de tipuri diferite. De fapt, este vorba despre zone de memorie care, la un moment dat con]in un anume tip de variabil\ iar la alt moment acest tip se poate schimba. Sintaxa este similar\ cu cea care define[te o structur\: union nume { declara]ii };

Lista de declara]ii, spre deosebire de cea de la structur\, care definea c=mpurile acesteia, define[te o list\ de alegeri posibile. Uniunea trebuie privit\ ca o structur\ `n care membrii ocup\ aceea[i zon\ de memorie; dimensiunea memoriei alocat\ pentru o variabil\ de tip uniune este dimensiunea celui mai mare membru al uniunii. S\ not\m c\, la un moment dat doar un membru al uniunii poate ocupa memoria. ~n exemplul urm\tor se specific\ faptul c\ un punct `n plan poate fi definit fie prin coordonatele sale carteziene fie prin cele polare. Typedef union { struct { long abscisa; long ordonata; } cart; struct { float ro; float teta; } pol; } Coordonate; float pi=3.1415926; Coordonate p1, p2; ... printf("%d%d\n",p1.cart.abscisa,p1.cart.ordonata); printf("%f%f\n",p2.pol.ro,p2.pol.teta); O variabil\ de tip Coordonate, cum sunt de pild\ p1 [i p2, poate con]ine fie valori `ntregi reprezent=nd coordonatele carteziene fie valori flotante reprezent\nd coordonatele polare. Desigur c\ `n acest caz se presupune c\ prin program se afl\ c\ p1 este de tip cart iar p2 este de tip pol. Declara]iile precedente pot fi modificate astfel (pentru a memora `n variabil\ `ns\[i tipul de reprezentare ales) : typedef enum {cart=1,pol=2,nec=0} TipCoord; typedef union { TipCoord tip; struct { TipCoord tip; long abscisa; long ordonata; } cart;
64

48627669.doc

struct { TidCoord tip; float ro; float teta; } pol; } Coordonate; C=mpul “tip” este prezent `n toate alternativele uniunii [i el poate fi consultat prin referin]a p1.tip sau p1.cart.tip sau p1.pol.tip. Se mai poate elimina [i aceast\ redondan]\ prin urm\toarea declara]ie: typedef struct { TipCoord tip; union { struct { long abscisa; long ordonata; } cart; struct { float ro; float teta; } pol; } val; } Coordonate; Dezavantajul este c\ numirea coordonatelor se face printr-o “cascad\” mai mare : p1.val.cart.abscisa p1.val.cart.ordonata , dac\ p1.tip=1 p2.val.pol.ro p2.val.pol.teta , dac\ p2.tip=2

7.7. Exerciţii
1. Scrie]i un program pentru consultarea unei agende telefonice la nivelul personalului unei societ\]i. Pentru aceasta va trebui s\ se realizeze urm\toarele: 1.1 crearea agendei telefonice sub forma unui fi[ier text. Acest fi[ier va con]ine o mul]ime de linii, fiecare av=nd c=te dou\ c=mpuri: un [ir de caractere ce `nseamn\ identitatea abonatului [i un num\r care corespunde num\rului s\u de telefon. Iat\ un exemplu: andrei 1427 anca 2130 ana 2131 barbu2140 bogdan 1430 … … [tefan 2143 victor 2114 zeno 1442 1.2 crearea programului care realizeaz\ urm\toarele:
65

} persoana. Soluţii 1. while ((compar>0) && (i<n)) { compar=strcmp(cineva.h> # define dim_agenda 100 # define lung_nume 20 typedef char sir[lung_nume] typedef struct { sir nume. S\ se scrie un program care s\ realizeze: a) alc\tuirea unei liste de adrese care folose[te un tablou de structur\ pentru stocarea informa]iilor legate de adrese (nume. /* s-a definit o structura de tip persoana*/ persoana agenda[dim_agenda].Gheorghe GRIGORAŞ a) ini]ializarea unui tablou de elemente structurate prin citirea fi[ierului ce reprezint\ agenda telefonic\.8. b) consultarea agendei: la furnizarea unui nume programul ofer\ num\rul de telefon corespunz\tor (dac\ acesta exist\). b) completarea tabloului de structuri cu noi adrese. codul po[tal). De exemplu:  anca tel.: 2130  anuta persoan\ necunoscut\  [tefan tel.: 2143  quit 2. ora[. i++. while ((compar!=0) && (a<=b)) { 66 . c) afi[area pe ecran a listei de adrese. int i=0. 7.nume). strada. Vom construi dou\ func]ii pentru c\utarea `n agenda telefonic\: caut\_secv pentru c\utarea secven]ial\ [i caut\_dih pentru c\utarea dihotomic\(binar\). /* s-a definit agenda ca un tablou de persoane */ int n=0.h> # include <string. int a=0. int tel. int i. } return (compar==0)? i-1:-1. /* numarul persoanelor din agenda */ /* urmeaza functia de cautare secventiala */ int cauta_secv(char cineva[ ]) { int compar=1. int b=n-1. } /* urmeaza functia de cautare dihotomica */ int cauta_dih(char cineva[ ]){ int compar=1. # include <stdio. agenda[i].

/* initializarea agendei telefonice */ fisier=fopen("telefon. &(agenda[n]."%s%d". else printf("tel. } 2./* se cauta in a doua parte */ /* Program pentru listarea unor adrese folosind un **tablou de structuri*/ 67 . if (!fin) { i=cauta_secv(cineva). i=(a+b)/2. printf("Consultare agenda telefonica\n"). gaseste_liber -exploreaz\ tabloul de structuri `n c\utarea unui element nefolosit. scanf("%s".48627669. introducere -ad\ugarea unui nou nume `n urm\toarea structur\ liber\. n++. */ if (i==-1) printf("tel. } return (compar==0)? i:-1. while (!fin) { printf(">")./* se cauta in prima parte */ else if (compar>0) a=i+1.tel)). compar=strcmp(cineva.%s:%d\n"."r"). & cineva).nume). printf("\t Dati prenumele celui cautat \n").doc } int main(void){ FILE* fisier.txt". select_meniu -afi[area op]iunilor.agenda[i]. afiseaz\ -afi[area listei de adrese.%s:necunoscut!\n".cineva). /* sau i=cauta_dih(cineva). } } return 0. Programul con]ine func]iile: init_lista -ini]ializarea listei. int i. printf("\t sau "quit" pentru sfarsit \n").cineva. if (compar<0) b=i-1. sir cineva. fin=0.tel).&(agenda[n]. "quit")==0). fin=(strcmp(cineva.agenda[i]. } while (!feof(fisier)). sterge -[tergerea unei adrese. do { fscanf(fisier.nume).

c=atoi(s). } void introducere(void){ int liber.nume[0]= °\0°. liber=gaseste_liber(). int select_meniu(void). introducere(void). Afisati fisierul \n"). printf("1. printf("2. printf("4.t<MAX. break. Iesire din program \n").Gheorghe GRIGORAŞ # include <stdio.) { optiune=select_meniu(). char oras[20]. Stergeti un nume \n").h> # define MAX 100 struct adresa { char nume[30]. break. } int select_meniu(void){ char s[80].h> # include <stdlib. init_lista(). gets(s). Introduceti un nume \n"). void init_lista(void). case 2: sterge(). for(t=0. char strada[40]. unsigned long int cod_postal. unsigned long int numar. 68 . return c.. do { printf("\n Introduceti optiunea dvs. afiseaza(void). } adresa_info[MAX]. printf("3. for(. case 4: exit(0). void main(void){ char optiune.++t)adresa_info[t]. gaseste_liber(void). case 3: afiseaza(). } while (c<0 || c>4).: "). switch(optiune) { case 1: introducere(). } } } void init_lista(void){ register int t. void sterge(void). int c. char s[80]. break.

adresa_info[t].adresa_info[t].10).++t).10).adresa_info[t]. printf("Introduceti nr.cod_postal= strtoul(s. printf("Introduceti numarul: "). gets(s). } if (liber==-1) { printf("\n Lista este completa. gets(s).nume). adresa_info[liber].nume).adresa_info[t]. inregistrarii: ").cod_postal).doc } gaseste_liber(void){ register int t.nume[0]&&t<MAX. } void afiseaza(void){ register int t. for (t=0. t<MAX. °\0°. printf("Introduceti numele orasului: "). /* Nu mai este loc in lista*/ return t.oras).strada). printf("Introduceti numele strazii: "). adresa_info[liber]. gets(s). } } printf("\n\n"). gets(adresa_info[liber]. °\0°. } void sterge(void){ register int liber. gets(adresa_info[liber].numar=strtoul(s. ").strada). } printf("Introduceti numele: ").adresa_info[t]. 69 . ++t) { if (adresa_info[t].48627669. adresa_info[t]. gets(adresa_info[liber].oras). liber=atoi(s).numar). for(t=0. printf("Introduceti codul postal: "). printf("%lu\n". char s[80]. if (liber>=0 & liber<MAX) adresa_info[liber]. printf("%s\n". return. if (t==MAX) return -1.nume[0]) { printf("%s\n".nume[0]= °\0°. printf("%lu\n". printf("%s\n".

6 Declararea variabilelor externe 8. Memorarea poate fi: • static\. • dinamic\. `n segmentul datelor programului. .2 Gestiunea automat\ a memoriei 8. `n stiva de execu]ie. Acest mecanism se refer\ la gestionarea memoriei `n cursul execu]iei programului. ~n acela[i timp `ns\.9 Solu]ii Limbajul C ofer\ programatorului posibilitatea de a preciza mecanismul pe care-l dore[te pentru memorarea unei variabile. ~n general programatorul nu trebuie s\ se g=ndeasc\ explicit la un mecanism anume de memorare. • `ntr-un registru al calculatorului.3 Gestionarea “register” a memoriei 8. nu este lipsit de interes ca programatorul s\ cunoasc\ particularit\]ile fiec\rui tip de mecanism de memorare [i de asemenea s\ cunoasc\ modul `n care compilatorul va administra variabilele pe care le declar\ `n program. Compilatorul asociaz\ `n mod automat unei variabile un tip de memorare care corespunde locului unde s-a f\cut declararea. • automat\.4 Gestionarea static\ a memoriei 8.8 Exerci]ii 8.5 Variabile globale 8.7 Gestiunea dinamic\ a memoriei 8.1 Precizarea unui mecanism de memorare 8.Cap 8 GESTIUNEA MEMORIEI 8. `n memoria disponibil\.

identificator – este numele variabilei. posed\ un anume tip [i este administrat\ de un anume mecanism de memorare. tip unde: mem –este unul din cuvintele cheie: auto. valoarea ini]ial\.interpretarea con]inutului variabilei atunci c=nd ea este supus\ unor instruc]iuni. . Gestiunea automată a memoriei Variabilele cu gestiune automat\ corespund variabilelor alocate `n stivele de execu]ie. o variabil\ este identificat\ printr-un nume (identificator).48627669. A[adar. o variabil\ definit\ `ntr-un bloc va fi o variabil\ cu gestiune automat\. Precizarea unui mecanism de memorare Programatorul are posibilitatea s\ precizeze un mecanism de memorare prin instruc]iunea: mem identificator. register. 8. Categoria de memorare (mem) c\reia-i apar]ine variabila va determina: . Tipul variabilei va determina: .2. `ncep=nd cu locul de declarare.el este implicit */ /* x are o valoare nedefinita pe cand p este un **pointer care are ca valoare adresa lui x */ 71 . auto float *p = &x.dimensiunea zonei de memorie alocat\ pentru a reprezenta variabila. extern. . Vom trece `n revist\ aceste mecanisme de memorare. . static. Exemple: auto float x. dac\ nu este dat\ explicit. tip – este cuv=ntul cheie ce define[te tipul variabilei. Ini]ializarea unei variabile “auto” se va efectua la fiecare intrare `n bloc.ini]ializarea variabilei: con]inutul implicit (dac\ exist\ unul) al variabilei la crearea sa. char mesaj[ ] = "Mesaj initial". va fi nedefinit\. tip [i trebuie s\ fie totdeauna `n interiorul unui bloc. `n lipsa acestuia. Declararea se face prin: auto identificator .durata de via]\ a variabilei: perioada de timp `n care variabila este accesibil\. S\ mai not\m c\ limbajul C standard (ISO) permite ini]ializarea tablourilor [i structurilor `n cazul gestiunii automate a memoriei. Cuv=ntul cheie “auto” nu este obligatoriu.vizibilitatea variabilei: identificarea p\r]ii din program capabil\ s\ foloseasc\ acea variabil\.1. Durata de via]\ [i vizibilitatea unei variabile “auto” vor fi limitate la interiorul blocului `n care este definit\.doc 8. /*cuvantul auto a fost omis.

`nainte de execu]ia func]iei main. cerin]a aceasta este satisf\cut\ `n mod real doar dac\ este posibil\. Cum num\rul de regi[tri este limitat [i depinde de tipul de ma[in\ pe care ruleaz\ programul. Implicit sunt ini]ializate cu 0 la `nc\rcarea programului. Variabilele statice sunt alocate `n segmentul de date al programului. nedefinit\. Este u[or de `n]eles c\. Utilizarea acestei clase de memorare trebuie v\zut\ ca o directiv\ de optimizare dat\ compilatorului. Gestionarea “register” a memoriei . p=n\ la sf=r[itul fi[ierului surs\. pointeri. [i 72 . Ea este definit\ `ncep=nd cu declara]ia sa. prin urmare nu se poate defini o variabil\ global\ `n corpul unei func]ii. acesta ]ine cont de ea at=ta timp c=t exist\ regi[tri disponibili `n ma[in\.4. . Variabile globale O variabil\ global\ este o variabil\ static\ care poate fi referen]iat\ `n orice loc al programului. ansamblul c=mpurilor va fi ini]ializat cu zero. Gestionarea statică a memoriei static tip identificator . O astfel de variabil\ se declar\ prin: tip identificator . Exemple de utilizare a unor astfel de variabile sunt `n solu]ia exerci]iului 2 din capitolul precedent. Vizibilitatea unei astfel de variabile statice depinde de locul `n care a fost declarat\: . se folose[te cuv=ntul cheie “extern”. Ea este efectiv\ doar pentru variabilele care pot fi codificate pe un cuv=nt-ma[in\: caractere. 8.`n exteriorul unui bloc: va fi vizibil\ `ncep=nd cu definirea sa p=n\ la sf=r[itul fi[ierului. `ntregi.evitarea transmiterii unor argumente la func]ii apelate. 8. durata lor de via]\ este timpul de execu]ie al programului `nsu[i. este imposibil a se ob]ine adresa unei astfel de variabile. ~n acela[i timp ele permit: .`n interiorul unui bloc: va fi vizibil\ doar `n blocul acela (la fel ca variabilele auto). register tip identificator Cuv=ntul cheie “register” permite programatorului s\ indice faptul c\ variabila ce se define[te se memoreaz\ `n unul din regi[trii calculatorului. oferindu-le posibilitatea s\ accead\ la aceste argumente. Pentru a defini o variabil\ global\ `n alt fi[ier. ~n cazul tablourilor sau structurilor. Valoarea ini]ial\ a unei variabile registru este. utilizarea unei variabile globale vine `n contradic]ie cu principiile program\rii modulare.5. `n exteriorul oric\rui bloc.3. Declara]ia “register” trebuie s\ fie plasat\ `n interiorul unui bloc. declarate `n alte fi[iere. ~n plus.Gheorghe GRIGORAŞ 8. implicit.

Fi[ier 2 extern int x...}. } ~n cazul declar\rii func]iilor ce se definesc `n alt modul (fi[ier). . Ea este referen]iat\ folosind o variabil\ pointer (vezi cap.y.. 8. Gestiunea dinamică a memoriei Gestiunea dinamic\ a memoriei permite crearea de noi variabile pe parcursul execu]iei programului.7. extern char c. . Declara]ia: extern void functie(char). funct1(void) { x=. Declararea variabilelor externe O variabil\ extern\ poate fi declarat\ `n orice punct al programului prin: extern identificator .x=..y.doc - av=nd `n fi[ierul local specificarea extern. S\ not\m c\ o variabil\ alocat\ dinamic nu are un nume explicit. Durata de via]\ a unei variabile alocat\ dinamic este explicit\: -variabila este creat\ `n urma execu]iei opera]iei de alocare a memoriei (func]ia “malloc” `n C [i operatorul “new” `n C++). } .6.. 8.}. adic\ tipul rezultatului [i al parametrilor de apel. fie implicit cu valori 0. Aten]ie `ns\ c\ o variabil\ global\ poate fi modificat\ indirect pe perioada apelului la o func]ie.. char c. main(void){ ... 6) care con]ine adresa sa. Fi[ier 2 extern int x. extern char c. fun1(void){... tip Aceast\ declara]ie permite declararea local\ a unei variabile definit\ `n alt fi[ier(cu acela[i nume). Cuv=ntul rezervat extern indic\ compilatorului faptul c\ tipurile [i numele variabilelor care urmeaz\ au fost declarate `n alt\ parte [i nu mai aloc\ din nou spa]iu de memorie pentru acestea.. fun2(void){.. Exemple: Fi[ier 1 int x. 73 . y.y=... ~n cazul func]iilor important este s\ se descrie signatura sa. este echivalent\ cu: void functie (char).. ini]ializarea structurilor [i tablourilor fie `n mod explicit indic=nd valori ini]iale. Aceast\ gestiune se efectueaz\ `n memoria disponibil\ care se nume[te “gr\mad\” (heap). Aceast\ facilitate este legat\ de faptul c\ limbajul C permite compilarea [i legarea separat\ a diferitelor module de program: prin declararea unei variabile extern se comunic\ tuturor fi[ierelor variabilele globale necesare programului. De aceea.48627669. cuv=ntul extern este facultativ.. -variabila dispare `n urma execu]iei opera]iei de restituire a memoriei (func]ia “free” `n C [i operatorul “delete” `n C++).

S\ se construiasc\ un program. char top_stiva(void).h. Modulele vor fi: -stiva. Soluţii 1. pop. care con]ine modulul principal. void pop(void). b) scoate [irurile din stiv\ [i le afi[eaz\ (evident `n ordinea invers\ stivuirii). 8. void push(const sir ch).} 74 . Avem aici de-a face cu o variabil\ alocat\ dinamic care este referen]iat\ cu ajutorul pointerului ptr prin *ptr. -stiva. Defini]i un modul pentru gestionarea unei stive de [iruri de caractere.c : modul de gestionare a stivei de **caractere */ # define dim 100. int stiva_vida(void).8. format din trei module. care con]ine implementarea func]iilor.} void pop(){--index. Utiliza]i func]iile de manipulare a [irurilor de caractere (Anexa ) pentru definirea func]iilor acestui modul.c. void pop(sir ch). /* stiva. -prog. void push(char c){stiva[index++]=c.} int stiva_vida(){return(index==0).h : header ce contine declaratiile **functiilor din modulul stiva. int stiva_plina(void). int stiva_vida(void). stiva_vid\.c */ void push(char).} char top_stiva(){return(stiva[index-1]). stiva_plin\.c. Exerciţii 1. 2. De exemplu: Persoana *ptr.Gheorghe GRIGORAŞ vizibilitatea unei variabile alocat\ dinamic este legat\ de tipul de gestiune al pointerilor care referen]iaz\ indirect acea variabil\.h” care are con]inutul: # define dimensiune_sir 80 # define dimensiune_stiva 10 typedef char sir[dimensiune_sir]. care con]ine declara]iile func]iilor din modulul stiva. citirea se va face p=n\ la `nt=lnirea sf=r[itului de fi[ier sau p=n\ la umplerea stivei. /* stiva. int stiva_plina(void).9. static int index=0. Pornind de la acest modul scrie]i un program test care realizeaz\: a) citirea unui [ir de [iruri de caractere care se vor “`mpinge” `n stiv\ (se vor stivui). care s\ implementeze func]iile uzuale aplicate unei stive de caractere: push. 8. Caracteristicile modulului sunt definite `n fi[ierul header “stiva.c. static char stiva[dim]. top. ptr=malloc(sizeof(Persoana)).

&element)!=EOF){ push(element). */ # include <stdio. */ assert(!stiva_plina()). printf("<%c\n". void push(const sir ch).doc int stiva_plina(){return(index==dim).48627669.c ** Gestionarea unei stive de siruri de caractere.h> # include <stdio. } printf("\n"). strcpy(stiva[index]. void push(const sir c){ /* Se copie c in stiva dupa care se incrementeaza **index. printf("Incarcati stiva: \n>"). void pop(sir ch).c" # include <stdlib. int stiva_vida(void).h" # include "stiva. } return 0.h> # include "stiva. while(!stiva_plina()&&scanf("%c".h> int main() { char element.h*/ # define dimensiune_sir 80 # define dimensiune_stiva 10 typedef char sir[dimensiune_sir].c).} /* prog. printf(">"). int stiva_plina(void). while (!stiva_vida()) { element=top_stiva(). /* indicile top-ului stivei */ static sir stiva[dimensiune_stiva]. 75 . */ static int index=0.element). /*modul.c : modulul principal */ # include "stiva. printf("Iata continutul stivei: \n").h> # include <string. Inainte de aceasta se apeleaza functia **assert care impune o conditie pentru a continua **executia: stiva sa nu fie plina.h" /* ** variabile cu clasa de memorare *static*. /*stiva. index++.h> # include <assert. pop(). **nevizibile in alte fisiere. } 2.

c : programul de test ce consta din doua **iteratii: prima pentru citirea din fisierul de **intrare si stivuirea informatiei. printf(">"). while(!stiva_plina()&&scanf("%s".x). 76 . a doua pentru **afisarea rezultatului destivuirii. } return 0. } int stiva_vida(void){ return(index==0).} int stiva_plina(void){ return(index==dimensiune_stiva). printf("Se incarca stiva: \n>"). printf("Iata continutul stivei: \n"). } printf("\n"). while (!stiva_goala()) { pop(x). --index.x)!=EOF) { push(x). */ # include <stdio. printf("<%s\n". strcpy(c.Gheorghe GRIGORAŞ } } void pop(sir c){ /* se decrementeaza index apoi se copie top-ul **stivei in c */ assert(!stiva_vida()).stiva[index]). } /* test.h> # include "stiva.h" int main(void){ sir x.

ca o consecin]\ se pierde valoarea frac]ionar\ a variabilei reale. int i=2.4. Conversii de pointeri. Conversii explicite 9. Evaluarea expresiilor aritmetice 9. Mecanisme de conversie Se disting patru cazuri `n care `ntr-un program C se aplică un mecanism de conversie: 1. ~n al doilea caz se poate converti o valoare real\ la o valoare `ntreag\.. .1.. Conversia de tip `n limbajul C ofer\ un mecanism simplu pentru evaluarea expresiilor aritmetice [i pentru transmiterea parametrilor. f=i.. if (pi>2) pi=pi/i. se poate interpreta con]inutul unei variabile de tip caracter ca fiind o valoare `ntreag\ [i drept urmare posibilitatea utiliz\rii acesteia `ntr-o expresie aritmetic\. . Evaluarea expresiilor logice 9.1 Mecanisme de conversie 9.. ~n primul caz de pild\.Cap 9 CONVERSIA DE TIP 9. 9.1. asignarea cu tipuri diferite ale variabilelor termeni ai asignării: float f. 2.1. Conversia la asignare 9.. evaluarea unei expresii aritmetice sau logice în care componentele expresiei au tipuri diferite: float pi=3.14.1.1. Pointerul universal.1. int i=10. Trebuie s\ facem distinc]ia `ntre dou\ maniere de conversie: aceea care are drept scop schimbarea interpret\rii con]inutului unei variabile [i conversia care are drept consecin]\ modificarea con]inutului unei variabile.5.3.2.1.

(b) reprezentarea tipului “destinatar” este mai mare ca dimensiune dec=t cea a tipului “surs\”: long=int/short/char int=short/char short=char ~n acest caz nu exist\ pierdere de informa]ie: bi]ii sursei sunt completa]i cu zero (p\str=ndu-se eventualul bit semn).Gheorghe GRIGORAŞ 3. /* f1=2. 3. lucrurile se petrec dup\ cum urmeaz\: 1. bitul semn `n schimb nu se mai “transfer\”: unsigned long=int/short/char unsigned=short/char unsigned short=char 2. compilatorul este cel care gireaz\ aceste conversii. asign\ri `n care intervin dou\ tipuri `ntregi: (a) reprezentarea tipului “surs\” este mai mare ca dimensiune dec=t reprezentarea tipului “destinatar”: char=short/int/long short=int/long int=long ~n acest caz bi]ii de rang superior din valoarea din partea dreapt\ a asign\rii sunt suprima]i `nc=t exist\. Dac\ destinatarul este un tip far\ semn. asignarea unei valori reale `n dubl\ precizie la o variabil\ real\ `n simpl\ precizie: float=double ~n acest caz exist\ o pierdere a preciziei reprezent\rii valorii reale. Conversiile `ntre tipurile de baz\ ale limbajului sunt considerate permise iar tratamentul la care sunt supuse datele de c\tre compilator este bine stabilit de regulile limbajului. Poate ap\rea [i aici eroarea “Floating point exception” dac\ partea exponent este prea mare pentru o variabil\ real\ `n simpl\ precizie. 9. mecanismul este acela[i. apare o eroare (Floating point exception). asignarea unei valori reale la o valoare `ntreag\: char/short/int/long=float/double ~n acest caz sunt suprimate cifrele de la partea zecimal\: este conversie prin trunchiere [i nu prin rotunjire. Dac\ valoarea p\r]ii `ntregi a sursei este prea mare pentru a fi reprezentat\ `ntr-un `ntreg. /*caracterul ‘z’ este convertit la un intreg */ ~n cazul `n care se utilizeaz\ operatori de conversie.’z’). c=nd apar dou\ tipuri diferite.8 */ float f2=14/5.0 */ apelul unei funcţii: printf(“%d\n”. Vom detalia `n continuare aceste mecanisme.1. 78 . /* f2=2. utilizarea operatorilor de conversie: float f1=(float)14/5. o pierdere de informa]ie. poten]ial. Alte conversii `n care intervin tipuri definite de programator sunt considerate ilicite [i sunt respinse de compilator.1 Conversia la asignare ~n conversia la asignare.

`n caz contrar prin “true”. • asignarea valorilor 0-1: dac\ evaluarea expresiilor este “false” (true).1. /* b capata valoarea 0 */ i=10 while (i--) { . De aceea evaluarea unei expresii logice se face prin: • evaluarea operanzilor: dac\ valoarea aritmetic\ este 0 atunci aceasta se interpreteaz\ prin “false”.doc 9. . etc..1. f\r\ semn..se alege tipul de evaluare: `ntreg. } 79 ..2 Evaluarea expresiilor aritmetice tipurile `ntregi mai mici dec=t int sunt convertite la int.3. real. lucrurile se petrec astfel: - Dac\ un operand este: double unsigned long long unsigned Exemple: i (int) int int + Cel\lalt operand se converte[te la: double unsigned long long unsigned + c (char) int int + b) (float) double double Rezultatul este: double unsigned long long unsigned Faza 1: Faza 2: Rezultatul: i (int) Faza 1 Faza 2 Rezulta t Faza 1 Faza 2 Rezulta t int (a (long) long double int double double double double double 9.48627669. valoarea asignat\ acesteia este 0 (1). Exemple: x=50.tipul float este convertit la double. ~n rezumat. Faza II: .. b=(x>0) && (x<31). Evaluarea expresiilor logice Rezultatul evalu\rii unei expresii logice va fi 0 (reprezent=nd “false”) sau 1 (reprezent=nd “true”).

*/ .5 Conversie de pointeri. S\ consider\m de pild\ urm\toarea secven]\: char *alocare(int dim). . o valoare de tip void* este implicit convertit\ la o valoare pointer de un tip oarecare.Gheorghe GRIGORAŞ ~nainte de prima evaluare a expresiei “i.1. */ f=a/(float)b.-“.25... double r. Exemple: int a=21.. .25. float f. i se decrementeaz\. Aceast\ incompatibilitate se poate evita `n dou\ moduri. Ace[ti operatori de conversie permit programatorului s\ specifice o conversie care nu se face implicit de c\tre compilator.schimbarea tipului valorii returnate de o func]ie. i are valoarea 10 deci expresia cap\t\ valoarea “true”. int *ptr. b=4. Compilatorul for]eaz\ conversia [i afi[eaz\ un mesaj de avertisment (“warning”) `ntotdeauna c=nd `ntrun program apare o astfel de conversie. int* ptr1 80 . O prim\ solu]ie const\ `n a utiliza o conversie explicit\: . Pentru exemplul precedent se procedeaz\ astfel: void* alocare(int dim). Reciproc.. ptr=(int*) alocare(100). O a doua solu]ie const\ `n a utiliza tipul pointer universal void*.0. Operanzii ce apar `n aceast\ expresie r\m=n neschimba]i. /* f=5. dup\ care. 9. /* f5. .. */ f=(float)a/b. /* f=5..4 Conversii explicite Conversiile explicite se exprim\ prin: (tip) expresie sau tip ( expresie ) At=ta timp c=t conversia este permis\. a=(int)ceil(r). ~n cea de-a treia linie a secven]ei de mai sus apare o asignare `ntre pointeri incompatibili. Ace[tia pot fi utiliza]i: . f=a/b.pentru for]area conversiilor `n expresii... etc. rezultatul expresiei este convertit la tipul indicat. r=sqrt(double(a)). ptr = alocare(100).. /*functia ceil returneaza o valoare de tip intreg*/ 9.1. O variabil\ pointer de tip void* poate primi ca valoare pointer la un tip oarecare. Pointerul universal Conversia `ntre pointeri la tipuri diferite nu este implicit\.pentru transmiterea valorilor cu tipurile cerute ca parametri `n func]ii.

48627669.doc double* ptr2 ptr1=alocare(10). Tipul pointer universal void* este folosit frecvent `n func]iile disponibile din bibliotecile limbajului C (Anexa) `n scopul de a realiza conversii implicite `ntre pointeri de tipuri diferite. ptr2=alocare(20). Asign\rile pentru ptr1. 81 . ptr2 sunt corecte: tabloul de pointeri alocare este de tip void* `nc=t ace[ti pointeri pot fi asigna]i la pointeri de orice tip.

1. Programatorul asociaz\ o secven]\ de instruc]iuni unui identificator.2. ea face parte integrant\ din procesul de compilare: apelul compilatorului pentru un program execut\ mai `nt=i `nc\rcarea preprocesorului.1 Macroinstruc]iuni predefinite 10. O directiv\ este de forma: # instruc]iune argumente Principalele instruc]iuni pentru preprocesor sunt: . 10.2 Macroinstruc]iuni tip func]ie ~n codul surs\ al unui program C se pot include instruc]iuni destinate compilatorului. Rezultatul activit\]ii preprocesorului este un fi[ier surs\ `n care sunt tratate toate directivele de precompilare [i care este transmis compilatorului.3 Compilare condi]ionat\ 10.2 Macroinstruc]iuni 10. acestea sunt directive c\tre preprocesor. ~n acela[i timp `ns\. Precompilarea este o faz\ de prelucrare independent\ de compilarea propriu-zis\.1. • compil\ri condi]ionate conform unor parametri (valori) transmise `n comanda de compilare.2.4 Directiva #error 10. acestea se numesc directive pentru preprocesor.1 Constante simbolice.Cap 10 PREPROCESORUL 10. • definirea unor constante simbolice.1 Directive preprocesor Preprocesorul trateaz\ doar liniile ce `ncep prin caracterul “#”.1.1.1 Directive preprocesor 10.2 Includerea fi[ierelor 10. • definirea macroinstruc]iunilor. La apari]ia acestui identificator `n program. Directiva #define 10. preprocesorul substituie secven]a corespunz\toare de instruc]iuni `n locul acestui identificator. Preprocesorul realizeaz\ o faz\ de precompilare care are ca obiect: • includerea unor fi[iere (specificate) `n program.

.1. # define UNU . prin [irul de caractere asociat. Constanta simbolic\ se define[te cu directiva “define”: # define identificator [ir_de_caractere Exemple: # define NULL 0L # define TRUE 1 # define FALSE 0 # define EOF (-1) Utilizarea constantelor simbolice are diverse scopuri. # undefine UNU ..1. Exemplu: # define EOF (-1) ..48627669. • a defini existen]a unei constante simbolice: # define ident • a suprima defini]ia [i existen]a unei constante simbolice: # undef ident Vizibilitatea constantelor simbolice `ncepe cu definirea lor (directiva #define) [i ]ine p=n\ la sf=r[itul fi[ierului.1 Constante simbolice.. `n textul surs\.2 Includerea fişierelor Directiva #include cere compilatorului s\ ia `n considerare [i un alt fi[ier surs\ `n afar\ de cel `n care se afl\ directiva.. Forma acestei directive este: # include <nume_fisier> /* se caut\ fi[ierul `ncep=nd cu directoarele standard */ 83 . Directiva #define O constant\ simbolic\ asociaz\ unui identificator un [ir de caractere. 10...doc define if elif line ifndef else include error undef endif ifdif pragma De notat c\ un r=nd `n fi[ierul surs\ C nu poate con]ine mai mult de o directiv\.. 10. Preprocesorul `nlocuie[te fiecare apari]ie a identificatorului. Acest mecanism permite: • a asigna unui identificator un [ir de caractere.. cu excep]ia cazului c=nd `n acesta apare o directiv\ #undefine pentru identificatorul corespunz\tor.

.Gheorghe GRIGORAŞ sau # include ″nume_fisier″ /* se caut\ fi[ierul `n directorul curent sau cel indicat prin cale */ Includerea fi[ierelor poate fi utilizat\ pentru: • a insera fi[iere surs\ din biblioteci C care pot con]ine module de aplica]ii sau defini]ii de func]ii.h care con]ine declararea acestor func]ii: # include <math. /* se calculeaza puterea a n-a a lui π */ ~n fi[ierul math. Directiva “else” ofer\ o alternativ\ `n cazul `n care “if” e[ueaz\.. (double)n). 10... # elif expresien codn.3 Compilare condiţionată Directivele de compilare condi]ionat\ permit compilarea selectiv\ a unor por]iuni din programul surs\. val=pow(M_PI. 2. # elif expresie2 cod2. ea poate determina un lan] de if-else-if: # if expresie cod. Aceste directive sunt: # # # # # # if expr_constanta else endif elif expr_constanta ifdef identificator ifndef identificator Directiva “if“ prin “expr_constant\” care urmeaz\ dup\ ea permite includerea por]iunii de cod `ntre “if” [i “endif” `n procesul de compilare. 3. • a insera fi[iere “header” (care au extensia ‘. defini]ii de tipuri..h> . declara]ii de func]ii incluse `ntr-o bibliotec\. # elif expresie1 cod1. doar dac\ expresia este evaluat\ la “true” (`n caz contrar aceast\ por]iune de cod este ignorat\ de compilator).h’).1. este asem\n\toare instruc]iunii if-else din limbajul C.. Aceste fi[iere con]in: 1. constante simbolice [i macroinstruc]iuni standard. Exemplu Pentru a folosi func]iile din biblioteca matematic\ se include fi[ierul math. Directiva “elif” are sensul de “else if”. # endif 84 .h se afl\ defini]ia constantei M_PI [i a func]iei pow( )..

_DATE_. _FILE_. # line num\r “nume_fi[ier”. Are forma: # error mesaj La `nt=lnirea directivei este `ntrerupt\ compilarea [i se afi[eaz\ “mesaj”-ul ce este scris `n linia directivei. Acestea sunt: _LINE_.2. zi. Macroinstruc]iunea _STDC_ con]ine constanta 1 scris\ `n baza 10. Ambele directive pot folosi o alternativ\ de forma #else dar nu [i #elif. 85 . compilarea condi]ionat\ este folosit\ pentru: • scrierea de programe portabile: constantele simbolice ce se testeaz\ pot reprezenta tipul [i caracteristicile ma[inilor utilizate pentru o anume por]iune de cod. Identificatorul _LINE_ con]ine num\rul liniei de cod la compilare iar _FILE_ este un [ir care con]ine numele fi[ierului surs\ compilat.2 Macroinstruţiuni Prin acest mecanism programatorul asociaz\ o secven]\ de instruc]iuni unui identificator.1 Macroinstrucţiuni predefinite Limbajul standard ANSI C define[te cinci nume de macroinstruc]iuni predefinite. 10.doc Directivele “ifdef” (if defined) [i “ifndef” (if not defined) sunt utilizate pentru compilarea condi]ionat\ de definirea anterioar\ a lui “identificator” `ntr-o directiv\ de tipul #define. iar “nume_fi[ier” este un identificator valid de fi[ier care devine noua valoare a lui _FILE_.48627669. ~n concluzie. `ncorporate `n compilator. acesta devine noua valoare a lui _LINE_ `n punctul `n care se `nt=lne[te directiva. • traseul de execu]ie al programelor `n faza de test. an sunt compuse din c=te dou\ cifre ce reprezint\ `n ansamblu data conversiei fi[ierului surs\ `n cod obiect. Aceasta semnific\ faptul c\ implementarea este conform standardului ANSI C.4 Directiva #error Directiva #error cere compilatorului s\ sisteze compilarea. Dac\ _STDC_ nu-i definit\ sau con]ine altceva dec=t 1. 10. Se utilizeaz\ la depanarea programelor. implementarea nu este `n variant\ standard. _TIME_. # line “nume_fi[ier”. 10. Aici “num\r” este orice `ntreg pozitiv. Macroinstruc]iunea _DATE_ con]ine un [ir de forma “lun\/zi/an” `n care lun\. Con]inutul acestor doi identificatori poate fi modificat prin directiva #line: # line num\r. Ora la care a fost executat\ aceast\ conversie este con]inut\ `n _TIME_ sub forma [irului ora/minute/secunde. • optimizarea unor coduri utiliz=nd avantajele specifice fiec\rei ma[ini. _STDC_.1.

Gheorghe GRIGORAŞ

10.2.2 Macroinstrucţiuni tip funcţie
Aceste macroinstruc]iuni utilizator se definesc cu directiva #define: # define nume_macro secven]\_caractere Aici, “nume_macro” poate fi un identificator ce reprezint\ numele macroinstruc]iunii. Acesta, utilizat `ntr-un text surs\, va fi `nlocuit cu “secven]\_caractere” care poate `nsemna o secven]\ de instruc]iuni C (vezi [i 10.1.1). Dar “nume_macro” poate fi [i numele unei func]ii urmat\ de parametri: prin aceasta se define[te o macroinstruc]iune de tip func]ie care poate fi ‘apelat\’ `n orice punct al programului `n care a fost definit\.
Exemplu:

# define <stdio.h> # define ABS(a) (a)<0?-(a):(a) void main(void){ printf(″Valoarea absoluta a lui -1 si 1: %d%d″,ABS(-1),ABS(1)); } Folosirea func]iilor definite ca macroinstruc]iuni are, pe de o parte, un avantaj major: m\rirea vitezei de execu]ie a codului fiindc\ nu mai apare nici o `nc\rcare suplimentar\ legat\ de apelarea func]iei. Pe de alt\ parte `ns\, dac\ dimensiunea macroinstruc]iunii tip func]ie este mare, acest supliment de vitez\ este “anihilat” de cre[terea dimensiunii programului, datorit\ codului care apare de mai multe ori.

86

Cap 11 EXERCIŢII
1. S\ se a. b. c. scrie un program numit maxmin.c care s\ execute : citirea unui intreg pozitiv n; citirea a n numere reale; determinarea valorilor maxim [i minim dintre cele n numere citite;

2. S\ se scrie un program numit sumedia.c care s\ citeasc\ niste numere reale [i, pentru fiecare s\ scrie un r=nd `ntr-un tabel ce are forma: Nr.crt. Num\r Min Max Suma Media … … …. …. …. ….
unde Min(Max) `nseamn\ cel mai mic(mare) dintre numerele citite p=n\ `n acel moment, Suma [i Media fiind suma (media) numerelor citite p=n\ `n acel moment

3. S\ se scrie un program care s\ numere literele mici, literele mari , cifrele [i celelalte caractere(la un loc) dintr-un text(fi[ier). 4. S\ se scrie func]ii recursive pentru calculul factorialului unui num\r dat n, a puterilor 1,2 …, k a unui num\r n, a sumei numerelor naturale m [i n. S\ se foloseasc\ aceste func[ii `ntr-un program principal. 5. S\ se scrie o func]ie “ int este_prim(int n) ” care s\z returneze 1 dac\ num\rul n este prim [i zero `n caz contrar. S\ se scrie o func]ie “ fibonacci ( int n) “ care s\ returneze al n-ulea termen al [irului lui Fibonacci. S\ se foloseasc\ cele dou\ func]ii pentru a verifica dac\ al n-ulea termen din [irul lui Fibonacci este num\r prim ( n = 1, …, 12). 6. Folosind func]ia “este_prim( … )” de la exerci]iul precedent, scrie]i un program ce s\ verifice conjectura lui Goldbach pentru toate numerele pare dintr-un interval dat [a,b] : Orice num\r par n mai mare ca 2 este suma a dou\ numere prime. De exemplu: 700 = 17 + 683 , 702 = 11 + 691, 704 = 3 + 701, etc. 7. Urm\toarea func]ie calculeaz\, recursiv, cel mai mare divizor comun a dou\ numere `ntregi pozitive p [i q: int cmmdc_r(int p, int q) { int r; if (( r = p % q ) == 0 ) return q; else return cmmdc_r(q, r); } Scrie]i un program pentru testarea acestei func]ii precum [i pentru calculul celui mai mare divizor comun a n numere date. Scrie]i apoi [i testa]i varianta iterativ\ a func]iei, cu numele : int cmmdc_i (int p, int q) 8. Descrie]i [i implementa]i trei algoritmi de sortare.

Gheorghe GRIGORAŞ

9. Construi]i o func]ie “ int numar_cuvinte(const char *s) “ care s\ returneze numarul cuvintelor din [irul s ( cuvintele sunt desp\r]ite prin spa]iu/spa]ii). S\ se testeze aceast\ func]ie pentru un [ir anume(fi[ier). 10. S\ se scrie [i apoi s\ se testeze func]ii pentru adunarea a doi vectori [i pentru adunarea a dou\ matrice. 11. S\ se scrie un program `n care s\ se foloseasc\ func]ia sistemului : void qsort(void *array, size_t n_els,size_t el_size, int compare(const void *, const void *)) pentru a sorta o list\ de numere reale `n ordinea cresc\toare relativ la p\r]ile frac]ionare a acestor numere. De exemplu lista: 2.43, 45.01, 23.90, 123.04, 0.98 este sortat\ astfel: 45.01, 123.04, 2.43, 23.90, 0.98 12. S\ se scrie func]iile care implementeaz\ o stiv\ `n C(push, pop, top, etc). S\ se foloseasc\ acestea pentru a verific\ dac\ un [ir de caractere format numai din literele a, b, c este palindrom cu centrul ‘c’: [irurile: aabacabaa , bababbcbbabab, c, aca, bbcbb sunt palindroame pe c=nd [irurile: aabbcbb. ccab, aaaaaaaacaaaabb, acb, aaaa nu sunt palindroame. 13.Fie a un tablou bidimensional (m x n). Un punct sa al acestui tablou este un element a[i0,j0]cu proprietatea: a[i0,j0] = min{a[i0,j] : 0<=j<=n-1} = max{a[i,j0] : 0<=i<=m-1} Scrieti un program care determina punctele sa (daca exista) ale unui tablou bidimensional. 14. Se da o matrice patratica. Sa se ordoneze crescator fiecare linie a matricii, apoi sa se rearanjeze liniile astfel incat suma elementelor de pe diagonala sa fie minima. 15. Scrieti un program care, avand la intrare doua siruri de caractere, determina cel mai lung subsir comun si pozitiile la care acesta incepe in fiecare dintre cele doua siruri. 16. Proiectati structuri de date pentru reprezentarea unui punct, a unui triunghi, dreptunghi, cerc. Scrieti proceduri de citire si scriere a unui punct, triunghi etc. Scrieti o procedura care determina, pentru un triunghi dat, numarul punctelor de coordonate intregi aflate in interiorul sau. Scrieti o procedura similara pentru cerc. 17. Proiectati o structura de date pentru reprezentarea datei calendaristice si scrieti subprograme care:

88

Teora 1998 2. vol I. 1992. Editura Teora. 6. Sa se proiecteze o structura de date pentru reprezentarea multimilor finite de numere complexe si sa se scrie proceduri care realizeaza operatii cu multimi de numere complexe reprezentate astfel. Aplica]ii `n C [i C++. Grigora[. 1999. Bucure[ti 1998 89 . Bucure[ti.III. E. BIBLIOGRAFIE 1. Gh. Editura Didactic\. 5. Limbajul C standard.. Editura “Spiru Haret”.Limbajele C si C++ in Aplicatii 3. Cristea. • • calculeaza data calendaristica care urmeaza unei anumite date.Limbajul C Volumul II . Bucuresti.Kalisz. [i al]ii. B.P\nsiu. Liviu Negrescu Limbajele C si C++ pentru incepatori. Gh.Giumale.doc • verifica daca valoarea unei variabile din structura este o data valida. manual pentru licee de informatic\. 4.48627669. calculeaza data calendaristica care precede o anumita data. 18.. Musc\. Programarea calculatoarelor:Fundamente. Herbert Schildt C .V. A.Limbajul C++ Volumul III . Informatic\ aplicat\.C. Editura Teora. Ed. 1998. Cluj-Napoca Volumul I . P\tru].XI. Ia[i. cls.Manual Complet.

/* c c c c c c c c c c c este este este este este este este este este este este alfanumeric? */ alfabetic? */ car. este tip\rit un mesaj(diagnostic) [i se iese din program. . /* isxdigit(int c).h> con]ine macro-ul assert() • void assert (int expr).h > <locale. de control? */ cifra? */ car. <limits./* isalpha(int c). /* islower(int c).h > <float. Fi[ierul <errno.h > <errno. /* isgraph(int c). /* isprint(int c). /* isspace(int c).h> <stdlib.h > <math. /* isdigit(int c).h> <string. /* iscntrl(int c). /* ispunct(int c).h> con]ine macrouri folosite pentru raportarea erorilor.h > 1.ANEXA Biblioteca standard C FI{IERE HEADER <assert.h > <setjmp.h > <stdio. h> <stddef. punctuatie? */ spatiu? */ litera mare? */ cifra hexa? */ Mai con]ine: int tolower (int c) [i int toupper ( int c) funcii ce permit transformarea literelor din mari ]n mici sau invers. h> <stdarg. h> <ctype. Fi[ierul <ctype. /* isupper(int c).h> Fi[ierul <assert. 2. 3. Dac\ expr este zero. h> <signal. grafic? */ litera mica? */ tiparibil? */ car.h> <time.h> con]ine macrouri (func]ii) pentru testarea caracterelor: • • • • • • • • • • • int int int int int int int int int int int isalnum(int c).

double sqrt ( double x). DBL_MIN. FILENAME_MAX. double acos ( double x). /*tipul diferen]\ de pointeri */ unsigned size_t. double log10 ( double x). stdout. Fi[ierul <stddef. atan2 ( double y. Fi[ierul <setjmp> con]ine declara]ii [i prototipuri ce permite programatorului s\ utilizeze salturi nelocale. Fi[ierul <math. double atan ( double x). /* Seteaz\ indicatorul la `nceputul fi[ierului */ 91 . 5. func]ii) ce permit setarea unor propriet\]i “locale”: forma punctului zecimal. EOF. • int fclose (FILE *fp). 9. FOPEN_MAX.h> con]ine construc]ii ce permit programatorului s\ m=nuiasc\ condi]ii sau semnale excep]ionale. Fi[ierul <locale. Sunt definite aici constantele BUFSIZ. long offset. TMP_MAX. stderr [i pentru structura FILE. FLT_MAX. Fi[ierul <limits. 6. Fi[ierul <stdio. double log ( double x). • • • • • • • • • • • 8.h> con]ine defini]iile unor constante ce caracterizeaz\ `ntregii: CHAR_BIT. INT_MAX etc.h> con]ine o redefinire (typedef) de tip [i trei m macrouri ce permit scrierea de func]ii cu un num\r variabil de argument ( ca [i printf ). tan ( double x). cosh ( double x). /* Pozi]ioneaz\ indicatorul pentru urm\toarea opera]ie `n fi[ier la “place” + “offset” */ • long ftell (FILE *fp). double double double double double double double double double double double cos ( double x).h> con]ine prototipuri pentru func]iile matematice: 4. 10.h> con]ine macrourile. /* Returneaz\ valoarea indicatorului de pozi]ie a fi[ierului pointat de fp*/ • void rewind (FILE *fp). NULL.doc Fi[irerul <float.h> con]ine construc]ii (structuri. • FILE *tmpfile (void).h> con]ine defini]ii de tip [i macrouri ce se folosesc `n alte defini]ii: • • • • typedef typedef typedef #define char wchar_t. int place). double y). • int fflush (FILE *fp). double exp ( double x). pow ( double x.48627669. sin ( double x). De asemenea sunt defini]i pointerii stdin. sinh ( double x). DBL_EPSILON etc. Fi[ierul < signal. tanh ( double x). CHAR_MAX. Fi[ierul <stdarg.h> con]ine defini]iile unor constante pentru limitele unor valori flotante: DBL_MAX. informa]ii monetare etc. double y). fmod ( double x. 11. fabs ( double x). double flor ( double x). 7. 12. defini]iile de tip [i prototipurile func]iilor utilizate de programator pentru a accesa fi[iere. Func]ii pentru accesul la fi[iere: • FILE *fopen (const char *filename. double x). • int fseek (FILE *fp. double asin ( double x). ceil ( double x). const char *mode). /*tipul ob]inut din sizeof() */ NULL. /* tipul wide character*/ int ptrdiff_t.

int denom). • int rand(void). void *from. /* comparare a cel mult n caractere din [irurile s1 [i s2*/ • char *strncpy(char *s1. • void srand(unsigned seed). /* Seteaz\ indicatorul la valoarea pos */ • int rename (const char *from. Iat\ unele dintre ele: • void *calloc(size_t n. Fi[ierul <string. sortare. • long labs(long i). size_t el_size. /*concatenare*/ • char *strchr(const char *s. size_t n). size_t n_els. const char *s2) /* copie s2 `n s1 */ • size_strlen(const char *s). const void *)). int c). size_t n). int c. size_t size). • int abs(int i). • void exit(int status). • long atol(const char *s). const fpos_t *pos).etc. size_t n) /* copie cel mult n caractere din s2 `n s1 */ 92 . /*cauta c `n [irul s*/ • int strcmp(const char *s1.h> con]ine prototipurile func]iilor de uz general : alocarea dinamic\ a memoriei. const void *)). size_t n). int compare(const void *. int base). De asemnea fi[ierul mai con]ine prototipurile func]iilor de intrare/ie[ire (vezi cap. Fi[ierul <stdlib. /*lungimea [irului s */ • char *strncat(char *s1. size_t n). char **end_ptr. /* comparare [iruri*/ • char *strcpy(char *s1. const char *s2. size_t n_els. • void abort(void). • double atof(const char *s). const char *s2.4). • void *memcpy(void *to. const char *s2). • ldiv_t ldiv(long numer.Gheorghe GRIGORAŞ • int fsetpos (FILE *fp. /*concatenarea a cel mult n caractere din s1 la s2*/ • int strncmp(const char *s1. • div_t div(int numer. • void *malloc(size_t size). size_t n). comunicarea cu sistemul. size_t n). size_t el_size. const char *s2). int compare(const void *.h> con]ine prototipuri de func]ii pentru manipularea blocurilor de memorie sau a [irurilor: • void memcmp(const void *p. const void *a_ptr. • void free(void *ptr). • long strtol(const char *s. • void *realloc(void *ptr. • char *strcat(char *s1. • void *memset(void *p. const char *s2. long denumer). size_t el_size). conversie de stringuri. 13. • double strtod(const char *s). • void *bsearch(const void *key_ptr. const char *to). 14. c\utare binar\. const void *q. • int atoi(const char *s). • void qsort(void *a_ptr. generare de numere aleatoare. • void *memmove(void *to. void *from.

• typedef long time_t. int tm_yday.. int tm_year.59 */ /*ore 0. const char *s2).11 */ /*anul de la 1900 */ /* zilele de la 0 la 6 */ /*zilele din an 0. Se folose[te structura tm care este definit\ astfel: struct tm { int tm_sec. de secunde trecute de la 1 Inuarie 1970 */ • char *asctime(const struct tm *tp). /*converte[te timpul inregistrat [i pointat de tp `ntr-un string ce reprezint\ data*/ • char *ctime (const time_t *t_ptr). /*returneaz\ nr. /* caut\ tokenuri `n s1 folosind caracterele din s2 ca separatori */ 15. are ca efect scrierea datei calenderistice. int tm_mon.data*/ • struct tm *localtime(const time_t *t_ptr). const char *s2). int tm_mday. /* caut\ `n s1 prima apari]ie a lui s2 */ • char *strtok(char *s1. Fi[ierul <time.48627669. int tm_isdst. acum = time(NULL).31 */ /*luna anului 0. int tm_min. orei ]i cele privind ceasul intern al calculatorului. Codul ASCII American Standard Code for Information Interchange 0 1 2 3 4 5 6 7 8 9 93 . int tm_wday.60*/ /*minutr 0.. }. int tm_hour..... asctime(localtime(acum))).23 */ /*ziua lunii 1. printf("%s\n%s ". /*secunde 0.. ?8 converte[te timpul pointat de t_ptr la string . /*returneaz\ num\rul de tacturi CPU utilizate de program p=n\ aici*/ • time_t time(time_t *tp).h> con]ine prototipuri ale func]iilor pentru ob]inerea datei.doc • char *strstr(const char *s1. De exemplu: … time_t acum. ctime(&acum).365 */ /* Indicator de timp */ Func]ii: • typedef long clock_t. • clock_t clock(void). .

z sunt contigue. be l bs cr es c ~n]elesul audible bell backspase retur car escape unor abrevieri ht tab orizontal nl nul vt linie nou\ null tab vertical ~n sistemele UNIX. 94 . ~n tabela urm\toare se da “semantica” unora din caracterele de pe liniile 0-2. 6 @ J T ^ h r | enq si em # 7 A K U _ i s } ack dle sub $ .Z [i a .Gheorghe GRIGORAŞ 0 1 2 3 4 5 6 7 8 9 10 11 12 nul nl dc4 rs ( 2 < F P Z d n x soh vt nak us ) 3 = G Q [ e o y stx np syn sp * 4 > H R \ f p z etx cr etb ! + 5 ? I S ] g q { eot so can “ . comanda man ascii produce afi[area tabelei codurilor ASCII pe ecran. E O Y c m w Observa]ii: • Caracterul G este `n linia 7 [i coloana 1 deci are codul ASCII 71. • Codurile caracterelor 0-9. • Diferen]a `ntre codurile literelor mari [i cele mici corespunz\toare este 32. • Caracterele cu codurile 0-31 [i 127 nu sunt tip\ribile. A . 8 B L V ‘ j t ~ bel dc1 esc % / 9 C M W a k u del bs dc2 fs & 0 : D N X b l v ht dc3 gs ’ 1 . • Caracterul cu codul 32 este spa]iu (gol) [i se tip\re[te ca [i un spa]iu gol.

Sign up to vote on this title
UsefulNot useful