======== Capitolul 6 ======== ===================== Tipuri fundamentale de date ===================== --------------------------Declaratii si expresii --------------------------Variabilele si constantele sunt obiecte cu care

se lucreaza intr-un program. In C, toate variabilele trebuie declarate inainte de a fi folosite. Declaratiile au doua scopuri: 1. spun compilatorului cat spatiu de memorie trebuie rezervat pentru memorarea acelor variabile; 2. permit compilatorului sa instruiasca masina pentru a face operatiile specifice corect. De e emplu, in e presia a ! b, operatorul ! este aplicat pentru doua variabile. "asina e ecuta in mod diferit adunarea pentru variabile de tip #int# si pentru variabile de tip #float#. $ineinteles, pentru programator aceste conventii sunt transparente %se mai spune ca #!# este operator de supraincarcare&. ' presiile sunt combinatii %cu inteles& de constante, variabile si apeluri de functii. "a(oritatea e presiilor %cum ar fi, de e emplu, variabilele& au si valoare si tip. In multe situatii, valoarea returnata depinde in principal de tipul e presiei. -----------------------------------Tipuri fundamentale de date -----------------------------------)vem urmatoarele tipuri fundamentale de date %scriere intreaga - lunga&: c*ar signed s*ort int unsigned s*ort int float signed c*ar signed int unsigned int double unsigned c*ar signed long int unsigned long int long double

+oate acestea sunt cuvinte rezervate, deci nu se pot folosi ca nume de variabile. )lte tipuri de date, cum ar fi vectorii si pointerii, sunt derivate din tipurile fundamentale. De obicei, cuvantul rezervat #signed# nu se mai scrie. De e emplu, #signed int# este ec*ivalent cu #int#. De asemenea, cuvintele #s*ort int#, #long int# si #unsigned int# pot fi prescurtate, de obicei, ca #s*ort#, #long# si #unsigned#. Cu aceste conventii, tabelul de mai sus se mai poate scrie: c*ar s*ort unsigned s*ort float signed c*ar int unsigned double unsigned c*ar long unsigned long long double

+ipurile fundamentale se pot grupa dupa functionalitate: 1. tipurile integrale sunt cele care sunt folosite pentru reprezentarea valorilor intregi; 2. tipurile reale sunt cele care sunt folosite pentru reprezentarea valorilor reale; ,. tipurile aritmetice sunt tipuri integrale sau reale. )cestea sunt: +ipuri integrale: c*ar s*ort unsigned s*ort +ipuri reale: float signed c*ar int unsigned double unsigned c*ar long unsigned long long double

-----------------------------Caractere si tipul "char" -----------------------------In C, variabilele de orice tip integral pot fi folosite pentru reprezentarea caracterelor. In particular, variabilele de tip #c*ar# si #int# se folosesc pentru acest scop. )m vazut in capitolul precedent ca atunci cand dorim sa comparam o variabila cu '-., atunci trebuie sa declaram acea variabila de tip #int#, si nu de tip #c*ar#. Constante cum ar fi /a/, /!/ pe care le gandim ca fiind caractere sunt de tip #int#, si nu de tip #c*ar#. 0etineti ca nu e ista constante de tip #c*ar# 111

0eamintim ca toate caracterele sunt tratate ca #intregi mici#, si reciproc, intregii mici sunt tratati ca niste caractere. In particular, orice e presie integrala poate fi afi2ata in format 3ntreg sau caracter. ----------' emplu: 4resupunem ca avem o #bucata# de cod C: ----------c*ar c 5 /a/; 67 /a/ are codul )8CII 9: 76 int i 5 ;<; 67 ;< este codul )8CII pentru /)/ 76 printf%#=c#, c ! 1&; 67 este afisat b 76 printf%#=d#, c ! 2&; 67 este afisat 99 76 printf%#=c#, i ! ,&; 67 este afisat D 76 In C, fiecare caracter este memorat pe un octet de memorie. 4e aproape toate masinile, un octet este compus din > biti. .ie declaratia c*ar c 5 /a/; 4utem gandi ca #c# este memorat pe un octet astfel --------------------------------?@?1?1?@?@?@?@?1? --------------------------------: ; < A , 2 1 @ .iecare celula reprezinta un bit si fiecare bit este numerotat %incepand cu cel mai putin semnificativ&. $itii care formeaza un octet sunt fie #on#, fie #off#, aceste stari fiind reprezentate prin 1 si @ respectiv. )cesta ne conduce sa gandim fiecare octet din memorie ca un sir de > cifre binare %se mai numesc siruri de biti&. )stfel variabila #c# poate fi gandita ca sirul de biti @11@@@@1 "ai general, fiecare cuvant masina poate fi gandit ca un sir de cifre binare grupate in octeti. Bn sir de cifre binare poate fi deci gandit ca un numar binar %adica in baza 2&. .ara a intra in detalii matematice %teorema bazei de numeratie& vom face doar un e emplu: ----------' emplu: ----------Valoarea lui #c# este numarul @11@@@@1 %in baza 2& 1 2C; ! 1 2C< ! @ 2CA ! @ 2C, ! @ 2C2 ! @ 2C1 ! 1 2C@

care inseamna ;A ! ,2 ! 1 5 9: in notatia zecimala %in baza 1@&. )D8I C pune la dispozitie trei tipuri referitoare la caractere: c*ar signed c*ar unsigned c*ar

De obicei, tipul #c*ar# este ec*ivalent cu #signed c*ar# sau #unsigned c*ar#, depinzand de compilator. .iecare din aceste trei tipuri se memoreaza pe un octet %deci poate #tine# 2<; valori distincte&. 4entru #signed c*ar#, valorile sunt intre -12> si 12:, iar pentru #unsigned c*ar# intre @ si 2<<. ----------------------Tipul de date "int" ----------------------+ipul de date #int# este cel mai folosit tip din limba(ul C. )cest tip, impreuna cu alte tipuri integrale %cum ar fi: #c*ar#, #s*ort# si #long#& este desemnat pentru lucrul cu valori intregi reprezentabile pe o masina. In matematica, numerele naturale sunt @, 1, 2, ,, ..., care impreuna cu cele negative %corespunzatoare& formeaza numerele intregi. 4e o masina, se pot reprezenta %folosind un tip integral& numai o submultime finita a acestor numere. De obicei, un cuvant se memoreaza pe un cuvant masina. )numite calculatoare folosesc cuvante de 2 octeti %51; biti&, altele A octeti %5,2 biti&. ----------' emple:

----------1. "asini ce folosesc cuvinte memorate pe 2 octeti: 4C 2. "asini ce folosesc cuvinte memorate pe A octeti: )pollo, EeFlett-4acGard, De t, 8ilicon Hrap*ics, 8un, etc. 4resupunem ca lucram pe un calculator care lucreaza pe A octeti. )ceasta implica ca un cuvant are ,2 biti, deci poate #tine# 2CI,2J valori distincte. Kumatate sunt folosite pentru reprezentarea numerelor negative si cealalta (umatate pentru pozitive: - 2CI,1J, -2CI,1J!1,..., -2, -1, @, 1, 2, ..., 2CI,1J-1 Daca lucram pe un calculator unde memorarea unui cuvant se face pe 2 octeti, atunci putem memora 2CI1;J valori distincte. Valoarea cea mai mare, a tipului #int# este data de constanta ")LID+. 'vident cea mai mica valoare va fi -")LID+-1. Daca se incearca, de e emplu, adunarea a doua numere %si se depaseste aceasta valoare&, atunci se va primi un mesa( #integer overfloF#. ------------------------------------------------------------Tipurile integrale "short", "long" si "unsigned" ------------------------------------------------------------De obicei, tipul #s*ort# se memoreaza pe doi octeti si tipul #long# pe patru octeti. )stfel, pe masinile in care cuvintele au patru octeti, lungimea tipului #int# este aceeasi cu lungimea tipului #long#, iar pe masinile in care cuvintele au doi octeti, lungimea tipului #int# este egala cu lungimea tipului #s*ort#. Constantele predefinite ")L8E-0+ si ")LM-DH %in unele implementari M-DHN")L& caracterizeaza lungimea acestor tipuri. De obicei, ")L8E-0+52CI1<J si ")LM-DH52CI,1J. )stfel, daca #s# este o variabila de tip #s*ort#, atunci - ")L8E-0+ O5 s O5 ")L8E-0+-1 Daca #l# este o variabila de tip #long#, atunci - ")LM-DH O5 s O5 ")LM-DH-1 In ceea ce priveste tipul #unsigned#, acesta este memorat pe acelasi numar de octeti ca si tipul #int#. Daca #u# este o variabila de tip #unsigned#, atunci @ O5 u O5 27")LID+-1 --------------Tipuri reale --------------)D8I C contine trei tipuri reale: #float#, #double# si #long double#. Variabilele de acest tip vor putea tine valori reale, cum ar fi: @.@@1 2.@ ,.1A1<9

)ceasta notatie se numeste notatie zecimala, deoarece contine punctul zecimal. "ai e ista si notatia e ponentiala. De e emplu, 1.2,A<;:e< corespunde cu 1.2,A<;: 1@C<512,A<;.:

4e ma(oritatea masinilor, tipul #float# se memoreaza pe A octeti, iar tipul #double# pe > octeti. )sta inseamna ca o variabila de tipul #float# poate avea ; zecimale, iar o variabila de tipul #double# poate avea 1< zecimale. )stfel, o variabila de tipul #float# are forma @,dN1 dN2 dN, dNA dN< dN; unde -,> O5 n O5 ,>. )semanator, o variabila de tipul #double# are forma @,dN1 dN2 ... dNI1<J unde -,@> O5 n O5 ,@>. )stfel, instructiunea 5 12,.A<12,A<12,A<12,A<; 67 2@ cifre semnificative 76 va implica atribuirea lui a valorii 1@C, %1< cifre semnificative& 1@CInJ 1@CInJ

@.12,A<12,A<12,A<

In )D8I C, pentru varibilele de tip #long double# se aloca mai multa memorie. Insa sunt compilatoare care trateaza acest e act tip e act ca si #double#. --------------------------Operatorul "sizeof()" --------------------------C pune la dispozitie operatorul #sizeof%&# pentru determinarea numarului de octeti necesari memorarii unui obiect. )cesta are aceeasi prioritate si asociativitate ca si ceilalti operatori unari. - e presie de forma sizeof%obiect& returneaza un intreg car reprezinta numarul de octeti necesari pentru memorarea obiectului in memorie. Bn obiect poate fi un tip, cum ar fi #int# sau #float#, sau poate fi o e presie, cum ar fi a ! b, sau poate fi un sir sau o structura. ----------' emplu: Calculul numarului de octeti pentru cateva tipuri ----------Pinclude Ostdio.*Q main%& I printf%#Mungimea catorva tipuri fundamentale.RnRn#&; printf%# c*ar:=,d octeti Rn#, sizeof%c*ar&&; printf%# s*ort:=,d octeti Rn#, sizeof%s*ort&&; printf%# int:=,d octeti Rn#, sizeof%int&&; printf%# long:=,d octeti Rn#, sizeof%long&&; printf%# unsigned:=,d octeti Rn#, sizeof%unsigned&&; printf%# float:=,d octeti Rn#, sizeof%float&&; printf%# double:=,d octeti Rn#, sizeof%double&&; printf%#long double:=,d octeti Rn#, sizeof%long double&&; J Din moment ce limba(ul C este fle ibil in ceea ce priveste necesarul de memorie pentru tipurile fundamentale, situatiile pot sa difere de la o masina la alta. +otusi, aceasta garanteaza ca: sizeof%c*ar& 5 1 sizeof%s*ort& O5 sizeof%int& O5 sizeof%long& sizeof%signed& O5 sizeof%unsigned& O5 sizeof%int& sizeof%float& O5 sizeof%double& O5 sizeof%long double& #sizeof%&# nu este o functie %c*iar daca contine paranteze atunci cand ne referim la tipuri&, ci este un operator. De e emplu: sizeof%a ! b ! :.:& este ec*ivalent cu sizeof a ! b ! :.: ------------------------unctii matematice ------------------------Du e ista functii matematice implicite %in compilatorul C&, ci acestea sunt descrise in biblioteci. De e emplu, functiile sSrt%& poF%& e p%& log%& sin%& cos%& tan%& sunt definite in biblioteca Omat*.*Q. +oate aceste functii, cu e ceptia lui #poFer%&# au un argument de tip #double# si returneaza o valoare de tip #double#. .unctia #poFer%&# are doua argumente de tip #double# si returneaza o valoare de tip #double#. --------------------------------------Con!ersii implicite si explicite --------------------------------------- e presie aritmetica, cum ar fi # ! T#, are si valoare si tip. De e emplu, daca # # si #T# au tipul #int#, atunci e presia # ! T# are tipul #int#. Dar, daca # # si #T# au ambele tipul #s*ort#, atunci # ! T# este de tip #int#, si nu #s*ort#. )ceasta se intampla deoarece in orice e presie, #s*ort# se converteste la #int#. ------------------------Con!ersia la intreg -----------------------Bn #c*ar# sau #s*ort#, ori #signed# sau #unsigned#, ori un tip enumerare %vom reveni& poate fi folosit in orice e presie unde poate fi folosit #int# sau #unsigned int#. Daca toate valorile tipului original pot fi reprezentate de un #int#, atunci valoarea acesteia se va converti la #int#; altfel se va converti la #unsigned int#. )ceasta se numeste #conversie la intreg#. -----------

' emplu: ----------c*ar c 5 /)/; printf%#=cRn#, c&; Variabila #c# apare ca argument al functiei #printf%&#. Cu toate acestea, deoarece are loc conversia la intreg, tipul e presiei #c# este #int#, si nu #c*ar#. -------------------------------------Con!ersiile aritmetice uzuale -------------------------------------Conversiile aritmetice pot apare cand sunt evaluati operanzii unui operator binar. -----------' emplu: -----------4resupunem ca #i# este #int# si #f# este un #float#. In e presia #i ! f#, operandul #i# se converteste la #float# si deci e presia #i ! f# va intoarce tipul #float#. )ceste reguli se numesc #conversii aritmetice uzuale#. Iata urmatorul #algoritm#: daca un operand este de tip #long double# atunci si celalalt operand va fi convertit la tipul #long double# altfel daca un operand este de tip #double# atunci si celalalt operand va fi convertit la tipul #double# altfel daca un operand este de tip #float# atunci si celalalt operand va fi convertit la tipul #float# altfel 677777 au loc conversiile la intreg 777776 daca un operand este de tip #unsigned long# atunci si celalalt operand va fi convertit la tipul #unsigned long# altfel daca un operand are tipul #long# si celalalt #unsigned# atunci - daca un #long# poate reprezenta toate valorile #unsigned# atunci operandul de tip #unsigned# se va converti la #long# - daca un #long# nu poate reprezenta toate valorile #unsigned# atunci ambii operanzi se vor converti la #unsigned long# altfel daca un operand are tipul #long# atunci celalalt operand se converteste la #long# altfel daca un operator are tipul #unsigned# atunci celalalt operand va fi convertit la #unsigned# altfel ambii operanzi vor avea tipul #int# ----------' emplu: 4resupunem ca avem declaratiile: ----------c*ar c; s*ort s; int i; unsigned u; unsigned long ul; float f; double d; long double ld; )tunci avem urmatoarele valori pentru tipurile e presiilor de mai (os: -------------------------------------------------------------------? ' presie +ip ? ' presie +ip ? -------------------------------------------------------------------? c-s6i int u 7 : - i unsigned ? ? u 7 2.@ - i double f 7 : - i float ?

? c!, int : 7 s 7 ul unsigned long ? ? c ! <.@ double ld ! c long double ? ? d!s double u - ul unsigned long ? ? 27i6l long u-l dependent de sistem ? ------------------------------------------------------------------------------------------Con!ersii explicite -----------------------Daca #i# este de tip #int#, atunci %double& i va converti valoarea lui #i# astfel incat e presia sa aiba tipul #double#. Variabila #i# ramane nesc*imbata. Conversiile se pot aplica si e presiilor. ----------' emple: -----------

%long& %/)/ ! 1.@& 5 %float& %%int& T ! 1& %double& % 5 ::&

-peratorul de conversie de tip %cast& este un operator unar care are aceeasi prioritate si asociativitate %de la dreapta la stanga& ca alti operatori unari. -----------' emplu: -----------' presia %float& i ! ,

este ec*ivalenta cu %%float& i& ! ,

pentru ca operatorul #cast# are prioritate mai mare decat #!#. --------------------------------------"rori de programare frec!ente --------------------------------------4resupunem ca suntem pe o masina care lucreaza folosind cuvinte memorate pe doi octeti. Consideram urmatorul e emplu: ----------' emplu: ----------int a 5 1, b 5 1::;, c 5 ,2@@@; printf%#=dRn#, a ! b ! c&; 67 eroare: va fi afisat -,1:<9 76 Bn mod de a repara aceasta greseala este inlocuirea instructiunii #printf%&# cu: printf%#=dRn#, %long& a ! b ! c&; 67 va fi afisat ,,::: 76 ---------------------------------------------"xercitii propuse spre implementare ---------------------------------------------1. 4resupunem ca depunem o suma %depozit la termen& intr-o banca care ofera o dobanda de ,> = %de e emplu& pe an. 8a se calculeze suma finala dupa un anumit numar de ani %se va tine cont de #dobanda la dobanda#&. 2. 8crieti o functie C utilizator care sa simuleze functia #poFer%m, n&# pentru m intreg si n natural. Cate inmultiri are functia U ,. 8a se verifice care din urmatoarele numere este mai mare: piCe sau eCIpiJ unde #pi#5,.1A1<92;<,<>9:9,2A si #e#52.:1>2>1>2>A<9@A<2A. A. 8a se scrie un program C care apro imeaza #pi# si #e# cu un anumit numar de zecimale. Idei: 4entru calculul lui #e#, puteti folosi convergenta sirului 1!Rsum 16n1 -Q e 4entru calculul lui #pi#, puteti folosi convergenta sirului Rsum 16GC2 -Q piC26;