LUCRAREA NR. 6 POINTERI

Transcription

1 LUCRAREA NR. 6 POINTERI Un pointer este o variabilă care păstrează adresa unui obiect de tip corespunzător. Forma generală pentru declararea unei variabile pointer este: tip * nume_variabila; unde tip poate fi oricare din tipurile de bază admise în C, iar nume_variabila este numele variabilei pointer. Tipul de bază al pointerului defineşte tipul variabilelor spre care indică pointerul Operatori pointer Există doi operatori pointer speciali * şi &: Operatorul & este un operator unar care oferă (returnează) adresa unei variabile (adresa operandului său). Operatorul * este complementarul lui &. Este un operator unar care returnează valoarea variabilei plasată la adresa care urmează după acest operator. int *count_addr, count, val; count = 100; /* int count are valoarea 100 */ count_addr = &count; /*count_addr indica spre count. */ val = count_addr; /* val preia valoarea de la adresa count_addr. */ printf ("%d", val); /*Se va tipari numarul 100 */ } Importanţa tipului de bază Considerăm declaraţia: val = *count_addr; Se pune întrebarea: care va fi numărul de bytes ce va fi transferat variabilei val de la adresa indicată prin *count_addr. Sau, mai general, de unde ştie compilatorul câţi bytes să transfere în cazul oricărei asignări care utilizează pointeri. Răspunsul la aceste întrebări este acela că, tipul de bază al pointerului determină tipul datei spre care indică pointerul. /* Acest program nu lucreaza corect */ float x = 10.12, y; short int *p; /* pointer la intreg */ p = &x; /* p preia adresa lui x */ y = *p; /* y preia valoarea de la adresa p */ printf ("x = %f y = %f",x,y); } Acest program nu va atribui valoarea lui x lui y, deoarece în program se declară p ca fiind pointer la întreg scurt şi compilatorul va transfera în y numai 2 bytes (corespunzători reprezentării unui întreg scurt) şi nu 4 bytes, corespunzători unui număr real în virgulă mobilă Expresii în care intervin pointeri În general, expresiile în care intervin pointeri respectă aceleaşi reguli ca orice alte expresii din limbajul C. Atribuirea pointerilor Ca orice variabilă, un pointer poate fi folosit în membrul drept al unei instrucţiuni de asignare (atribuire), pentru atribuirea valorii unui pointer unui alt pointer. 1

2 int x; int *p1,*p2; /* pointeri la intregi */ p1 = &x; /* p1 indica spre x */ p2 = p1 /* p2 indica tot spre x */ printf ("p1 = %p p2 = %p", p1, p2); } /* Se afiseaza valoarea hexa a adresei lui x, nu valoarea lui x */ Se observă că în funcţia printf() tipărirea se face cu formatul %p care specifică faptul că variabilele din listă vor fi afişate ca adrese pointer. Operaţii aritmetice efectuate asupra pointerilor o Utilizarea operatorilor de incrementare şi decrementare Fie secvenţa: int *p1; /* pointer la intreg */ p1++; De fiecare dată când se incrementează p1, acesta va indica spre următorul întreg. Astfel, dacă p1 = 2000, după efectuarea instrucţiunii p1++, acesta va fi p1 = 2004 (va indica spre următorul întreg). După fiecare incrementare a unui pointer, acesta va indica spre următorul element al tipului său de bază. După fiecare decrementare a unui pointer, acesta va indica spre elementul anterior. Valoarea pointerilor va fi crescută sau micşorată în concordanţă cu lungimea tipului datelor spre care aceştia indică, aşa cum se poate vedea în exemplul următor: Cum valoarea indirectată de un pointer este o l-valoare, ea poate fi asignată şi incrementată ca orice altă variabilă. O l-valoare (left value) este un operand care poate fi plasat în stânga unei operaţii de atribuire. Verificaţi utilizarea pointerilor din programul următor: void main(void) { short *pi, *pj, t; long *pl; double *pd; short i, j; i=1; j=2; t=3; printf("i= %d, j= %d\n", i, j); pi=&i; pj=&j; printf("pi= %p, pj= %p\n", pi, pj); *pj /= *pi+1; printf("*pi= %d *pj= %d\n", *pi, *pj); *pj /= *pi+2; printf("*pi= %d *pj= %d\n", *pi, *pj); printf("++pj= %p, ++*pj= %d\n",++pj,++*pj); } o Utilizarea operatorilor de adunare şi de scădere La sau dintr-un pointer, se pot aduna sau scădea valori de tip întreg. Rezultatul este un pointer de acelaşi tip cu cel iniţial, indicând spre un alt element din tablou. De exemplu, p1 = p1 + 9; face ca p1 să indice spre al 9-lea element având tipul lui p1, considerând că elementul curent este indicat de p1. Evident că valoarea pointerului se va modifica corespunzător lungimii tipului datei indicată prin pointer. int *p1; /* Pointer la intreg */ p1 = p1 + 9; Dacă valoarea p1 = 3000, atunci p1 + 9 va avea valoarea: (valoarea lui p1)+9*sizeof(int)=3000+9*4=3036 Aceleaşi considerente sunt valabile în cazul în care un întreg este scăzut dintr-un pointer. Dacă doi pointeri de acelaşi tip sunt scăzuţi, rezultatul este un număr întreg cu semn care reprezintă deplasamentul dintre cei doi pointeri (pointerii la obiecte vecine diferă cu 1). În cazul tablourilor, dacă pointerul rezultat indică în afara tabloului, rezultatul este nedefinit. Dacă p indică spre ultimul membru dintr-un tablou, atunci (p+1) are valoare nedeterminată. Observaţii : Nu se pot aduna sau scădea valori de tip float sau double la/sau dintr-un pointer. 2

3 Nu se pot efectua operaţii de înmulţire şi împărţire cu pointeri. Scăderea a doi pointeri este exemplificată în programul: void main(){ int i=4, j; float x[] = {1,2,3,4,5,6,7,8,9}, *px; j = &x[i]-&x[i-2]; px = &x[4]+i; printf("%d %f %p %p\n",j,*px,&x[4],px); } o Compararea pointerilor Doi pointeri de acelaşi tip se pot compara printr-o expresie relaţională, astfel: dacă p şi q sunt doi pointeri, atunci instrucţiunile: if (p < q) printf ( p indica spre o adresa mai mica decit q \n ); sunt corecte. Compararea pointerilor se utilizează când doi sau mai mulţi pointeri indică spre acelaşi obiect comun. Un exemplu interesant de utilizare a pointerilor constă în examinarea conţinutului locaţiilor de memorie ale calculatorului. /*Programul afiseaza continutul locatiilor de memorie dela o adresa specificata*/ # include <stdlib.h> dump (start); unsigned long int start; /* start = adresa de inceput */ printf ( Introduceti adresa de start: ); scanf ( %lu, &start); dump (start); } /* Se apeleaza functia dump () */ dump (start) /* Se defineste functia dump() */ unsigned long int start; { char far *p; int t; p = (char far *) start; /*Conversie la un pointer*/ for (t = 0; ; t++, p++) { if (!(t%16)) printf ("/n"); printf ("%2X ", *p); /*Afiseaza in hexazecimal continutul locatiei de memorie adresata cu *p*/ if (kbhit()) return;} } /* Stop cand se apasa orice tasta */ o Utilizarea pointerilor ca parametri formali ai funcţiilor În exemplele de până acum, s-au folosit funcţii C care atunci când erau apelate, parametrii acestor funcţii erau (întotdeauna) actualizaţi prin pasarea valorii fiecărui argument. Acest fapt ne îndreptăţeşte să numim C-ul ca un limbaj de apel prin valoare. Există totuşi o excepţie de la această regulă atunci când argumentul este un tablou. Această excepţie este explicată, pe scurt, prin faptul că valoarea unui nume al unui tablou (vector, matrice etc.) neindexate este adresa primului său element. Folosind variabile pointer se pot pasa adrese pentru orice tip de date. Spre exemplu, funcţia scanf() acceptă un parametru de tip pointer (adresă): scanf( %f,&x); Ceea ce este important de evidenţiat este cum anume se poate scrie o funcţie care să accepte ca parametri formali sau ca argumente pointeri?. Funcţia care recepţionează o adresă ca argument va trebui să declare acest parametru ca o variabilă pointer. De exemplu, funcţia swap() care va interschimba valorile a doi întregi poate fi declarată astfel: void swap(); /*Prototipul functiei swap()*/ void main(void) { int i,j; i=1; j=2; printf("i= %d j= %d\n", i, j); swap(&i,&j); /* Apelul functiei */ printf("i= %d j= %d\n", i, j); } void swap(int *pi, int *pj) { int t; t = *pi; *pi = *pj; *pj = t; } 3

4 6.2. Pointeri şi tablouri Între pointeri şi tablouri există o strânsă legătură în limbajul C. Există însă o mare deosebire între tablouri şi pointeri pe care trebuie să o avem mereu în vedere. Un tablou constă întotdeauna dintr-o mare cantitate de memorie, îndeajuns de mare pentru a reţine toţi octeţii corepunzători tuturor elementelor tabloului. Astfel, tabloul q declarat ca short q[100]; rezervă 2x100 octeţi de memorie iar int q[100] rezervă 4x100 octeţi de memorie. În C numele unui tablou fără indici este adresa de start a tabloului. De fapt, numele tabloului este un pointer la tablou. Ca o concluzie, un pointer declarat sau numele unui tablou fără indici reprezintă adrese, pe când numele unui tablou cu indici se referă la valorile stocate în acea poziţie în tablou. Pentru a avea acces la elementul unui tablou, în limbajul C, se folosesc 2 metode : 1. utilizarea indicilor tabloului; 2. utilizarea pointerilor. Deoarece a doua metodă este mai rapidă, în programarea în C, de regulă, se utilizează această metodă. Pentru a vedea modul de utilizare a celor două metode, considerăm un program care tipăreşte cu litere mici un şir de caractere introdus de la tastatură cu litere mari: Versiunea cu indici char sir[80]; int i; printf ("Introduceti un sir de caractere scrise cu litere mari: \n"); gets (sir); printf ("Acesta este sirul in litere mici: \n"); for(i=0;sir[i];i++) printf("%c", tolower(str[i]));} Versiunea cu pointeri char sir[80], *p; printf ("Introduceti un sir de caractere scrise cu litere mari: \n"); gets (sir); printf (" Acesta este sirul in litere mici: \ n"); p = sir; /* p preia adresa de inceput a sirului */ while (*p) printf (" %c ", tolower(*p++)); } Pointerii sunt rapizi şi uşor de utilizat când se doreşte referirea elementelor unui tablou în ordine strict crescătoare sau strict descrescătoare. Dacă însă se doreşte referirea aleatoare a elementelor unui tablou, atunci indexarea tabloului este cel mai simplu şi sigur de utilizat Indexarea pointerilor În C, dacă p este un pointer, iar i este întreg, p[i] este identic cu *(p+i). Dacă avem declaraţiile: short q[100]; short *pq atunci sunt permise şi posibile următoarele declaraţii: Varianta cu tablou pq=&q[0] pq=q q[n] Varianta cu pointeri pq=&q[0] pq=q pq[n] *(pq+n) 4 Descriere Pointerul pq indică adresa primului element al tabloului q pq[n] înseamnă acelaşi lucru cu *(pq+n) În C, dacă se pune un index unui pointer, ca în pq[n], atunci se consideră această utilizare echivalentă cu *(pq+n). Cu alte cuvinte, orice referire la pq[n] înseamnă acelaşi lucru cu valoarea de la adresa (pq+n). Programul următor realizează tipărirea pe ecran a numerelor cuprinse între 1 şi 10. #include <stdio.h> int v[10]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; int *p, i; p = v; /* p indica spre v */ for (i=0;i<10;i++) printf ("%d", p[i]);}

5 Utilizarea constantelor şir în locul poinetrilor la caractere este posibilă dar nu este uzuală. void main(){ char *sir = "To be or not to be", *altsir; printf("%s\n", "That don't impress me much"+5); printf("%c\n",*("12345"+3)); printf("%c\n","12345"[1]); puts("string\n"); altsir = "American pie"; printf("sir = %s\naltsir = %s\n",sir,altsir);} Pointeri şi şiruri Deoarece numele unui tablou fără indici este un pointer la primul element al tabloului, pentru implementarea unor funcţii care manipulează şiruri, se pot utiliza pointeri. Stim că funcţia strcmp(s1, s2) realizează compararea şirurilor s1 şi s2 şi întoarce 0 dacă s1 = s2, o valoare negativă, dacă s1 < s2 şi o valoare pozitivă, dacă s1 > s2. Prezentăm o variantă de scriere a funcţiei strcmp(s1,s2) char *s1, *s2; { while (*s1) if (*s1 - *s2) return *s1-*s2; /* Returneaza diferenta */ else {s1++; s2++;} return '\0';} //Se returneaza 0 in caz de egalitate Reamintim că un şir în C se termină cu caracterul NULL. De aceea, instructiunea while(*s1) rămâne adevărată până când se întâlneşte caracterul NULL, care este o valoare falsă. Dacă într-o expresie se utilizează un şir constant, calculatorul tratează constanta ca pointer la primul caracter al şirului. Programul următor afişează pe ecran mesajul " Acest program funcţionează ": char *s; s = " Acest program functioneaza "; printf (s); } Preluarea adresei unui element al unui tablou Până acum s-a văzut că un pointer poate să adreseze primul element al unui tablou. Este posibil să se adreseze orice element al unui tablou aplicând operatorul & unui tablou indexat. De exemplu, p = &x[2]; plasează adresa celui de-al 3-lea element al vectorului x în pointerul p. Un domeniu în care această practică este esenţiala constă în găsirea unui subşir într-un şir dat. Programul următor afişează ultima parte a unui şir introdus de la tastatură, din punctul în care se întâlneşte primul spaţiu: char s[80]; char *p; int i; printf (" Introduceti un sir : \n "); gets (s); /* Gaseste primul spatiu sau sfarsitul sirului */ for (i = 0; s[i] && s[i]!= ' '; i++) p = & s[i+1]; printf (p); } Dacă p indică spre un spaţiu, programul va afişa spaţiul şi apoi subşirul rămas. Dacă în şirul introdus nu este nici un spaţiu, p indică spre sfârşitul şirului şi atunci nu se va afişa nimic. De exemplu, dacă se introduce my friend, atunci printf() afişează mai întâi un spaţiu şi apoi friend Tablouri de pointeri Putem construi tablouri de pointeri în aceeaşi manieră în care se definesc alte tipuri de date. int *x[10]; // Vector de 10 pointeri la intregi 5

6 char *p[20]; // Vector de 20 pointeri la caracter Pentru atribuirea unei variabile întregi, var, celui de al treilea element al tabloului de pointeri *x[10], se va scrie: x[2] = &var; Pentru găsirea valorii lui var, se va scrie: y = *x[2]; //Valoarea lui var este atribuita lui y Atentie!. Trebuie facută distincţia între: int *v[10]; // Tablou de 10 pointeri la intregi int (*v)[10]; // Pointer la un tablou de 10 intregi Pentru aceasta trebuie ţinut cont de faptul că * este un operator prefixat, iar [] şi () sunt operatori postfixaţi. Deoarece prioritatea operatorilor postfixaţi este mai mare decât cea a operatorilor prefixaţi, atunci când se doreşte schimbarea priorităţii, trebuie folosite paranteze Pointeri la pointeri Un tablou de pointeri este ceea ce numim pointeri la pointeri. Conceptul de tablou de pointeri este simplu, deoarece indexarea tabloului conduce la clarificarea semnificaţiei lui. Un pointer la un pointer este o formă de indirectare multiplă sau un lanţ de pointeri. În cazul unui pointer la pointer, primul pointer conţine adresa celui de-al doilea pointer, care indică spre variabila ce conţine valoarea dorită: Pointer Pointer Variabilă Adresă > Adresă > Valoare Declararea indirectărilor multiple se face sub forma: Pentru a avea acces la o valoare indirectată printr-un pointer la pointer este necesară, de asemenea, utilizarea operatorului * de două ori, aşa cum se vede în exemplul următor: int x, *p, **q; x = 10; p = &x; /* p preia adresa lui x */ q = &p; /* q preia adresa lui p */ printf(" %d ", **q); } /*Se afiseaza valoarea lui x*/ Alocarea dinamică a memoriei Există două metode principale prin care un program C poate memora informaţii în memoria principală a calculatorului. Prima metodă foloseşte variabilele globale şi locale. În cazul variabilelor globale, memoria ce li se alocă este fixă pe tot timpul execuţiei programului. Pentru variabilele locale, programul alocă memorie în spaţiul stivei, în timpul execuţiei programului. Deşi variabilele locale sunt eficient de implementat, în C, de multe ori, utilizarea acestora, necesită cunoaşterea în avans a cantităţii de memorie necesare în fiecare situaţie. A doua metodă de alocare a memoriei, constă în utilizarea funcţiilor de alocare dinamică malloc() şi free(). Prin această metodă, un program alocă memorie pentru diversele informaţii în spaţiul memoriei libere numită heap, plasată între programul util şi memoria sa permanentă şi stivă. Se observă că stiva creşte în jos, iar dimensiunea acesteia depinde de program. H igh Low Stiva M emorie liberá pentru alocare (heap) V ar iabile globale (statice) Pr ogr am 6 M em oria Un program cu multe funcţii recursive va folosi mult mai intens stiva în comparaţie cu un program ce nu utilizeaza funcţii recursive, aceasta deoarece adresele de retur şi variabilele locale corespunzătoare acestor funcţii sunt salvate în stivă.

7 Funcţiile malloc() şi free() Aceste funcţii formează sistemul de alocare dinamică a memoriei în C şi fac parte din fisierul antet <stdlib.h>. Acestea lucrează împreună şi utilizează zona de memorie liberă plasată între codul program şi memoria sa permanentă (fixă) şi vârful stivei, în scopul stabilirii şi menţinerii unei liste a variabilelor memorate. De fiecare dată când se face o cerere de memorie, funcţia malloc() alocă o parte din memoria rămasă liberă. De fiecare dată când se face un apel de eliberare a memoriei, funcţia free() eliberează memorie sistemului. Declararea funcţiei malloc() se face sub forma: void *malloc (int numar_de_bytes); Aceasta întoarce un pointer de tip void, ceea ce înseamnă că trebuie utilizat un şablon explicit de tip atunci când pointerul returnat de malloc() se atribuie unui pointer de un alt tip. Dacă apelul lui malloc() se execută cu succes, malloc() va returna un pointer la primul byte al zonei de memorie din heap ce a fost alocată. Dacă nu este suficientă memorie pentru a satisfce cererea malloc(), apare un eşec şi malloc() returnează NULL. Pentru determinarea exactă a numărului de bytes necesari fiecărui tip de date, se poate folosi operatorul sizeof(). Prin aceasta, programele pot deveni portabile pe o varietate de sisteme. Funcţia free() returnează sistemului memoria alocată anterior cu malloc(). După eliberarea memoriei cu free(), aceasta se poate reutiliza folosind un apel malloc(). Declararea funcţiei free() se realizează sub forma: free(void *p); Funcţia free() eliberează spaţiul indicat de p şi nu face nimic dacă p este NULL. Parametrul actual p trebuie să fie un pointer la un spaţiu alocat anterior cu malloc(), calloc() sau realloc(). Următorul program va aloca memorie pentru 40 de întregi, va afişa valoarea acestora, după care eliberează zona, utilizând free(): # include <stdlib.h> void main(void) { int t, *p; p = (int *) malloc(40*sizeof(int)); if (!p) printf("out of memory \n"); //Verificati daca p este un pointer corect else { for (t=0; t<40; ++t) *(p + t) = t; for (t=0; t < 40; ++t) printf("%d", *(p + t)); free(p); } } Funcţiile calloc() şi realloc() Funcţia calloc() alocă un bloc de n zone de memorie, fiecare de dim octeţi şi setează la 0 zonele de memorie; funcţia returnează un pointer la acel bloc (adresa primului octet din bloc). Declararea funcţiei se face cu: void *calloc(unsigned int n, unsigned int dim); Funcţia realloc() primeşte un pointer la un bloc de memorie alocat în prealabil (declarat pointer de tip void) şi redimensionează zona alocată la dim octeţi (dacă este nevoie, se copiază vechiul conţinut întro altă zonă de memorie). Declararea funcţiei se face cu: void *realloc(void *ptr, unsigned int dim); Pointeri la structuri Limbajul C recunoaşte pointerii la structuri în acelaşi mod în care se recunoaşte pointerii la orice alt tip de variabilă. Declararea unui pointer la structură se face plasând operatorul * în faţa numelui unei variabile structură. De exemplu, pentru structura addr definită mai înainte, următoarea instrucţiune declară pe addr_pointer ca pointer la o dată de acest tip : struct addr *addr_pointer; O utilizare importantă a pointerilor la structură constă în realizarea apelului prin adresă într-o funcţie. Când unei funcţii i se transmite ca argument un pointer la o structură, calculatorul va salva şi va reface din stivă numai adresa structurii, conducând astfel la cresterea vitezei de executare a programului. 7

8 Pentru a găsi adresa unei variabile structură, se plasează operatorul & înaintea numelui variabilei structură. De exemplu, dându-se următorul fragment : struct balanta { float balance; char name[80]; } person; struct balanta *p; /* se declara un pointer la structura */ atunci: p = &person; plasează adresa lui person în pointerul p. Pentru a referi elementul balance, se va scrie: (*p).balance Deoarece operatorul punct are prioritate mai mare decât operatorul *, pentru o referire corectă a elementelor unei structuri utilizând pointerii sunt necesare paranteze. Actualmente, pentru referirea unui element al unei variabile structură dându-se un pointer la acea variabilă, există două metode: Prima metodă utilizează referirea explicită a pointerului nume-structură, iar a doua metodă, modernă, utilizează operatorul săgeată -> (minus urmat de mai mare). Pentru a vedea cum se utilizează un pointer-struct, examinăm următorul program care afişează ora, minutul şi secunda utilizând un timer software. void actualizeaza(); void afiseaza(), delay(); struct tm { /* se defineste structura tm */ int ore; int minute; int secunde;}; void main() {struct tm time; // Declara structura time de tip tm time.ore = 0;time.minute = 0;time.secunde = 0; for (;;) { actualizeaza (&time); afiseaza (&time); }} void actualizeaza(t) struct tm *t; {t->secunde ++; if (t->secunde == 60) { t->secunde = 0; t->minute ++; } if (t->minute == 60) { t->minute = 0; t->ore ++;} if (t->ore == 24) t->ore = 0; delay();} void afiseaza(t) // Se defineste functia afiseaza() struct tm *t; { printf ("%d : ", t->ore); printf ("%d : ", t->minute); printf ("%d ", t->secunde); printf ("\n");} void delay() /* Se defineşte funcţia delay() */ { long int t; for (t = 1;t< ;++t);} TEME: 1. Sa se ordoneze crescator si descrescator un vector de numere reale utilizand pointer. 2. Utilizand pointeri la siruri de caractere sa se realilzeze un program ce primeste un numar intreg intre 1 si 12 si returneaza numele lunii respective. 3. Sa se creeze un tablou de pointeri care sa memoreze adresele a 5 variabile de tip float. Sa se afiseze cele 5 variabile in ordine crescatoare, sa se afiseze adresele lor si adresa de inceput a tabloului de pointeri. 4. Utilizand pointeri, sa se realizeze suma, diferenta si produsul a doua matrici. Sa se afiseze adresa ultimului element din fiecare matrice. 5. Sa se realizeze o structura ALBUM cu urmatoarele campuri: nume,_album, nume_melodii, autor, interpret, an aparitie, pret. Campul nume melodii este un tablou de siruri de caractere. Campul interpret este tot o structura ce contine campurile: nume, prenume, varsta, albumuri vandute. Sa se creeze un tablou cu 5 elemente de tip ALBUM si utilizand pointeri sa se ordoneze tabloul dupa pretul unui album, dupa numele interpretului (alfabetic), dupa anul aparitiei si dupa pret. Sa se realizeze o functie care primeste ca parametru numele unei melodii si afiseaza numele albumului, interpretul, anul aparitiei si pretul. 8