Differences
This shows you the differences between two versions of the page.
|
programare-ca:laboratoare:lab07 [2012/11/09 18:42] laura.vasilescu [Exerciţii de Laborator] |
— (current) | ||
|---|---|---|---|
| Line 1: | Line 1: | ||
| - | ===== Pointeri. Abordarea lucrului cu tablouri folosind pointeri. ===== | ||
| - | **Responsabil:** [[laura.vasilescu@cti.pub.ro|Laura Vasilescu]] | ||
| - | |||
| - | |||
| - | ===== Obiective ===== | ||
| - | |||
| - | În urma parcurgerii acestui laborator, studentul va fi capabil: | ||
| - | * să înţeleagă noţiunea de pointer şi modurile în care se poate opera cu memoria în limbajul C | ||
| - | * să cunoască modul în care pointerii sunt folosiţi în a returna sau modifica parametri în cadrul unei funcţii | ||
| - | * să înţeleagă noţiunea de pointer la o funcţie şi să-l folosească în situaţiile în care acesta este necesar; | ||
| - | * să folosească funcţiile de alocare şi de eliberare a memoriei | ||
| - | |||
| - | {{ http://imgs.xkcd.com/comics/pointers.png}} | ||
| - | |||
| - | ===== Noţiunea de pointer ===== | ||
| - | |||
| - | Un **pointer** este o variabilă care reţine o adresă de memorie. | ||
| - | |||
| - | În C, un pointer poate reprezenta: | ||
| - | - adresa unor date de un anumit tip | ||
| - | * tip elementar, structură, şir de caractere etc. | ||
| - | * operațiile cu pointeri sunt determinate de dimensiunea tipului de date | ||
| - | - adresa unei funcții | ||
| - | * adresa la care punctul curent de execuţie va sări, în cazul în care acea funcţie este apelată | ||
| - | - adresa unei adrese de memorie | ||
| - | * acest tip de pointer poate fi redus la prima situaţie | ||
| - | - adresa unei zone cu conţinut necunoscut (pointer către void) | ||
| - | |||
| - | <note tip> | ||
| - | Dimensiunea unui pointer depinde de arhitectura și sistemul de operare pe care a fost compilat programul. Dimensiunea unui pointer se determină cu **''sizeof(void *)''** și nu este în mod necesar egală cu dimensiunea unui tip de date întreg. | ||
| - | |||
| - | În cadrul laboratorului și al temelor de casă se vor utiliza mașini și pointeri pe 32 de biți. | ||
| - | </note> | ||
| - | |||
| - | ===== Operatori ===== | ||
| - | |||
| - | ==== Operatorul de referențiere ==== | ||
| - | |||
| - | **''&''** - apare în fața variabilei asupra căreia acționează | ||
| - | |||
| - | Este aplicat unei variabile de un anumit tip de date și are funcția de a obține adresa de memorie a variabilei respective. | ||
| - | |||
| - | ==== Operatorul de dereferențiere ==== | ||
| - | |||
| - | **''*''** - apare în fața variabilei asupra căreia acționează | ||
| - | |||
| - | Este aplicat unei variabile de tip pointer și are funcția de a obține valoarea stocată la adresa respectivă. | ||
| - | |||
| - | <note warning> | ||
| - | Declararea unui pointer nu înseamnă alocarea unei zone de memorie în care pot fi stocate date. Un pointer este tot un tip de date, a cărui valoare este un număr ce reprezintă o adresă de memorie. | ||
| - | </note> | ||
| - | |||
| - | Pentru ca dereferențierea să aibă loc cu succes, pointer-ul trebuie să indice o adresă de memorie validă, la care programul are acces. Această adresă poate fi adresa unei variabile declarate în prealabil sau adresa unui bloc de memorie alocat dinamic (după cum vom vedea mai departe). | ||
| - | |||
| - | Este indicată inițializarea pointerilor cu constanta ''NULL'', compatibilă cu orice tip de pointer, care indica, prin convenție, un pointer neinițializat. | ||
| - | |||
| - | ==== Particularități ==== | ||
| - | <code c> | ||
| - | int *a; /* Pointer */ | ||
| - | int b = 5; /* Variabila */ | ||
| - | char *c; /* Pointer catre un caracter (sau sir de caractere) */ | ||
| - | void *buff = NULL; /* Pointer catre void, initializat la NULL */ | ||
| - | |||
| - | /* Asignare NEVALIDA; a este un pointer neinitializat */ | ||
| - | *a = 1; | ||
| - | |||
| - | /* a ia adresa variabilei b */ | ||
| - | a = &b; | ||
| - | |||
| - | /* Continutul memoriei de la adresa a (care a fost initializata mai sus) | ||
| - | ia valoarea 5 . Acest lucru este echivalent cu "b = 5;" | ||
| - | */ | ||
| - | *a = 5; | ||
| - | </code> | ||
| - | |||
| - | În cazul declaraţiilor de pointeri, operatorul ''*''este asociat numelui variabilei, şi nu numelui tipului, astfel că, pentru o declaraţie de mai multe variabile, operatorul ''*'' trebuie să apară pentru fiecare variabilă în parte şi este recomandat ca şi formatarea codului să indice această asociere. De exemplu: | ||
| - | <code c> | ||
| - | /* sir1 e pointer, sir2 si sir3 sunt caractere */ | ||
| - | char *sir1, sir2, sir3; | ||
| - | |||
| - | /* a, b si c sunt pointeri */ | ||
| - | int *a, *b, *c; | ||
| - | |||
| - | /* Doar a este pointer; formatarea codului este nerecomandata */ | ||
| - | char* a, b; | ||
| - | </code> | ||
| - | |||
| - | Operatorul ''*'' poate fi folosit şi în specificarea numelui unui tip (de exemplu în cazul unui ''cast''), şi în acest caz el apare după numele tipului. De exemplu: | ||
| - | <code c> | ||
| - | void *var = NULL; | ||
| - | int *num = (int *)var; // Operatie valida, dar riscanta | ||
| - | </code> | ||
| - | |||
| - | <note warning> | ||
| - | Un pointer către ''void'' nu poate fi folosit direct în operaţii cu pointeri, ci trebuie convertit mai întâi la un pointer către un tip de date. | ||
| - | </note> | ||
| - | De exemplu: | ||
| - | <code c> | ||
| - | void *mem; | ||
| - | //[...] | ||
| - | *mem = 10; // Operatie ILEGALA | ||
| - | ((int *)mem) = 10; // Operatie legala, dar riscanta | ||
| - | </code> | ||
| - | ===== Tipuri de pointeri ===== | ||
| - | |||
| - | ==== Pointeri la date ==== | ||
| - | |||
| - | == Stocarea datelor la o anumită adresă; Citirea datelor de la o anumită adresă == | ||
| - | <code c> | ||
| - | *p = y; // Ia valoarea y si pune-o la adresa indicata de p | ||
| - | x = *p; // Ia valoarea de la adresa indicata de p si pune-o in variabila x | ||
| - | *s1++ = *s2++; | ||
| - | </code> | ||
| - | |||
| - | == Atribuirea unei adrese unui pointer == | ||
| - | <code c> | ||
| - | p1 = p2; | ||
| - | p = NULL; | ||
| - | p = malloc(n); // Veti studia malloc() intr-un laborator ulterior | ||
| - | </code> | ||
| - | |||
| - | == Interpretarea diferită a datelor din memorie == | ||
| - | <code c> | ||
| - | int n; | ||
| - | short s1, s2; | ||
| - | s1 = *((short*)&n); // Extrage primul cuvant din intregul n | ||
| - | s2 = *((short*)&n + 1); // Extrage cel de-al doilea cuvant din intregul n | ||
| - | </code> | ||
| - | |||
| - | == Aritmetică cu pointeri == | ||
| - | Adunarea sau scăderea unui întreg la un pointer, incrementarea sau decrementarea unui pointer. Aceste operaţii lucrează în multipli de dimensiunea tipului de date la care pointerii se referă, pentru a permite accesul la memorie ca într-un vector (a se vedea laboratorul de [[:programare-ca:laboratoare:lab05|tablouri]]). De exemplu: | ||
| - | <code c> | ||
| - | int *num; | ||
| - | |||
| - | /* Aduna la adresa initiala dimensiunea tipului de date referit | ||
| - | de pointer (pe sizeof(int)), dand acces la urmatorul intreg | ||
| - | care ar fi stocat daca zona aceea de memorie ar fi organizata | ||
| - | sub forma unui vector | ||
| - | */ | ||
| - | num++; | ||
| - | |||
| - | /* Incrementeaza adresa cu 5 * sizeof(int) */ | ||
| - | num = num + 5; | ||
| - | </code> | ||
| - | ==== Pointeri la tablouri ==== | ||
| - | |||
| - | După cum a fost prezentat în [[programare-ca:laboratoare:lab05|laboratorul de vectori]], o variabilă vector conţine adresa de început a vectorului (adresa primei componente a vectorului), şi de aceea este echivalentă cu un pointer la tipul elementelor din vector. Această echivalenţă este exploatată, de obicei, în argumentele de tip vector şi în lucrul cu vectori alocaţi dinamic. De exemplu, pentru declararea unei funcţii care primeşte un vector de întregi şi dimensiunea lui, avem două posibilităţi: | ||
| - | <code c> | ||
| - | void printVec(int a[], int n); | ||
| - | </code> | ||
| - | sau | ||
| - | <code c> | ||
| - | void printVec(int *a, int n); | ||
| - | </code> | ||
| - | |||
| - | În interiorul funcţiei ne putem referi la elementele vectorului ''a'' fie prin indici, fie prin indirectare, indiferent de felul cum a fost declarat parametrul vector ''a'': | ||
| - | <code c> | ||
| - | void printVec (int a[], int n) | ||
| - | { | ||
| - | int i; | ||
| - | for (i = 0; i < n; i++) | ||
| - | printf("%6d", a[i]); // Indexare | ||
| - | } | ||
| - | </code> | ||
| - | sau | ||
| - | <code c> | ||
| - | void printVec (int *a, int n) | ||
| - | { | ||
| - | int i; | ||
| - | for (i = 0; i < n; i++) | ||
| - | printf("%6d", *a++); // Indirectare | ||
| - | } | ||
| - | </code> | ||
| - | |||
| - | Astfel, există următoarele echivalenţe de notaţii pentru un vector ''a'': | ||
| - | <code c> | ||
| - | a[0] <==> *a | ||
| - | a[1] <==> *(a + 1) | ||
| - | a[k] <==> *(a + k) | ||
| - | &a[0] <==> a | ||
| - | &a[1] <==> a + 1 | ||
| - | &a[k] <==> a + k | ||
| - | </code> | ||
| - | |||
| - | Diferenţa dintre o variabilă pointer şi un nume de vector este aceea că un nume de vector este un pointer constant (adresa sa este alocată de către compilatorul C şi nu mai poate fi modificată la execuţie), deci nu poate apărea în stânga unei atribuiri, în timp ce o variabilă pointer are un conţinut modificabil prin atribuire sau prin operaţii aritmetice. De exemplu: | ||
| - | <code c> | ||
| - | int a[100], *p; | ||
| - | p = a; ++p; //corect | ||
| - | a = p; ++a; //EROARE | ||
| - | </code> | ||
| - | De asemenea, o variabilă de tip vector conţine şi informaţii legate de lungimea vectorului şi dimensiunea totală ocupată în memorie, în timp ce un pointer doar descrie o poziţie în memorie (e o valoarea punctuală). Operatorul ''sizeof(v)'' pentru un vector ''v[N]'' de tipul ''T'' va fi ''N * sizeof(T)'', în timp ce ''sizeof(v)'' pentru o variabila ''v'' de tipul ''T *'' va fi ''sizeof(T *)'', adică dimensiunea unui pointer. | ||
| - | |||
| - | Ca o ultimă notă, este importat de remarcat că o funcţie poate avea ca rezultat un pointer, dar nu poate avea ca rezultat un vector. | ||
| - | |||
| - | ==== Pointeri în funcţii ==== | ||
| - | |||
| - | În cadrul funcţiilor, pointerii pot fi folosiţi, printre altele, pentru: | ||
| - | * Transmiterea de rezultate prin argumente | ||
| - | * Transmiterea unei adrese prin rezultatul funcţiei | ||
| - | * Utilizarea unor funcţii cu nume diferite (date prin adresele acestora) | ||
| - | |||
| - | O funcţie care trebuie să modifice mai multe valori primite prin argumente sau care trebuie să transmită mai multe rezultate calculate în cadrul funcţiei trebuie să folosească argumente de tip pointer. | ||
| - | |||
| - | De exemplu, o funcţie care primeşte ca parametru un număr, pe care il modifica: | ||
| - | <code c> | ||
| - | // Functie care incrementeaza un intreg n modulo m | ||
| - | int incmod (int *n, int m) { | ||
| - | return ++(*n) % m; | ||
| - | } | ||
| - | |||
| - | // Utilizarea functiei | ||
| - | int main() { | ||
| - | int n = 10; | ||
| - | int m = 15; | ||
| - | | ||
| - | incmod(&n, m); | ||
| - | // Afisam noua valoare a lui n | ||
| - | printf("n: %d", n); | ||
| - | | ||
| - | return 0; | ||
| - | } | ||
| - | </code> | ||
| - | |||
| - | O funcţie care trebuie să modifice două sau mai multe argumente, le va specifica pe acestea individual, prin câte un pointer, sau într-un mod unificat, printr-un vector, ca în exemplul următor: | ||
| - | <code c> | ||
| - | void inctime (int *h, int *m, int *s); | ||
| - | // sau | ||
| - | void inctime (int t[3]); // t[0]=h, t[1]=m, t[2]=s | ||
| - | </code> | ||
| - | |||
| - | O funcţie poate avea ca rezultat un pointer, dar acest pointer nu trebuie să conţină adresa unei variabile locale. De obicei, rezultatul pointer este egal cu unul din argumente, eventual modificat în funcţie. De exemplu: | ||
| - | <code c> | ||
| - | // Incrementare pointer p | ||
| - | char *incptr(char *p) { | ||
| - | return ++p; | ||
| - | } | ||
| - | </code> | ||
| - | |||
| - | O variabila locală are o existenţă temporară, garantată numai pe durata execuţiei funcţiei în care este definită (cu excepţia variabilelor locale statice), şi de aceea adresa unei astfel de variabile nu trebuie transmisă în afara funcţiei, pentru a fi folosită ulterior. De exemplu, următoarea secvenţă de cod este ''greşită'': | ||
| - | <code c> | ||
| - | // Vector cu cifrele unui nr intreg | ||
| - | int * cifre (int n) { | ||
| - | int k, c[5]; // Vector local | ||
| - | |||
| - | for (k = 4; k >= 0; k--) { | ||
| - | c[k] = n % 10; | ||
| - | n = n / 10; | ||
| - | } | ||
| - | |||
| - | return c; // Aici este eroarea ! | ||
| - | } | ||
| - | </code> | ||
| - | |||
| - | Astfel, o funcţie care trebuie să transmită ca rezultat un vector poate fi scrisă corect în două feluri: | ||
| - | * Primeşte ca argument adresa vectorului (definit şi alocat în altă funcţie) şi depune rezultatele la adresa primită (soluţia recomandată!); | ||
| - | * Alocă dinamic memoria pentru vector (folosind ''malloc''), iar această alocare se menţine şi la ieşirea din funcţie. | ||
| - | |||
| - | ==== Pointeri la funcţii ==== | ||
| - | |||
| - | Anumite aplicaţii numerice necesită scrierea unei funcţii care să poată apela o funcţie cu nume necunoscut, dar cu prototip şi efect cunoscut. | ||
| - | |||
| - | De exemplu, o funcţie care să calculeze integrala definită a oricărei funcţii cu un singur argument sau care să determine o radăcină reala a oricărei ecuaţii (neliniare). | ||
| - | |||
| - | Aici vom lua ca exemplu o funcţie ''listf'' care poate afişa (lista) valorile unei alte funcţii cu un singur argument, într-un interval dat şi cu un pas dat. Exemple de utilizare a funcţiei <tt>listf</tt> pentru afişarea valorilor unor funcţii de bibliotecă: | ||
| - | <code c> | ||
| - | int main(void) { | ||
| - | listf(sin, 0.0, 2.0 * M_PI, M_PI / 10.0); | ||
| - | listf(exp, 1.0, 20.0, 1.0); | ||
| - | | ||
| - | return 0; | ||
| - | } | ||
| - | </code> | ||
| - | |||
| - | Problemele apar la definirea unei astfel de funcţii, care primeşte ca argument numele (adresa) unei funcţii. Prin convenţie, în limbajul C, numele unei funcţii neînsoţit de o listă de argumente şi de parantezele ''()'' specifice unui apel este interpretat ca un pointer către funcţia respectivă (fără a se folosi operatorul de adresare ''&''). Deci ''sin'' este adresa funcţiei sin(x) în apelul funcţiei ''listf''. Declararea unui argument formal (sau a unei variabile) de tip pointer la o funcţie are forma următoare: | ||
| - | <code c> | ||
| - | tip (*pf) (lista_arg_formale) | ||
| - | </code> | ||
| - | unde: | ||
| - | * ''pf'' este numele argumentului (variabilei) pointer la funcţie | ||
| - | * ''tip'' este tipul rezultatului funcţiei | ||
| - | |||
| - | Parantezele sunt importante, deoarece absenţa lor modifică interpretarea declaraţiei. De exemplu, putem avea: | ||
| - | <code c> | ||
| - | tip * f(lista_arg_formale) // functie cu rezultat pointer, si NU pointer | ||
| - | </code> | ||
| - | |||
| - | În concluzie, definirea funcţiei ''listf'' este: | ||
| - | <code c> | ||
| - | void listf (double (*fp)(double), double min, double max, double pas) { | ||
| - | double x,y; | ||
| - | |||
| - | for (x = min; x <= max; x = x + pas) { | ||
| - | y=(*fp)(x); // apel functie de la adresa din "fp" | ||
| - | printf("\n%20.10lf %20.10lf", x, y); | ||
| - | } | ||
| - | } | ||
| - | </code> | ||
| - | |||
| - | O eroare de programare care trece de compilare şi se manifestă la execuţie este apelarea unei funcţii fără paranteze; compilatorul nu apelează funcţia şi consideră că programatorul vrea să folosească adresa funcţiei. De exemplu: | ||
| - | <code c> | ||
| - | if (kbhit) | ||
| - | break; // echivalent cu if(1) break; | ||
| - | |||
| - | if (kbhit()) | ||
| - | break; // iesire din ciclu la apasarea unei taste | ||
| - | </code> | ||
| - | |||
| - | ===== Expresii complexe cu pointeri ===== | ||
| - | |||
| - | Deşi sunt întâlnite mai rar în practică, limbajul C permite declararea unor tipuri de date complexe, precum: | ||
| - | |||
| - | <code c> | ||
| - | char *(*(*x)())[10]; | ||
| - | </code> | ||
| - | |||
| - | În interpretarea acestor expresii, operatorii ''()'' şi ''[]'' au precedenţa în faţa ''*'' şi modul de interpretare al acestor expresii este pornind ''din interior spre exterior''. Astfel expresia dată ca exemplu mai sus este (numerele de sub expresie reprezintă ordinea de interpretare): | ||
| - | - o variabila ''x'' | ||
| - | - care este un pointer la o funcţie | ||
| - | - fără nici un parametru | ||
| - | - şi care întoarce un pointer | ||
| - | - la un vector de 10 elemente | ||
| - | - de tip pointer | ||
| - | - către tipul ''char'' | ||
| - | |||
| - | Folosind acest procedeu, se pot rezolva şi alte situaţii aparent extrem de complexe: | ||
| - | <code c> | ||
| - | unsigned int *(* const *name[5][10] ) ( void ); | ||
| - | </code> | ||
| - | care semnifică o matrice de 5x10 de pointeri către pointeri constanţi la o funcţie, care nu ia nici un parametru, şi care întoarce un pointer către tipul ''unsigned int''. | ||
| - | |||
| - | ===== Exerciţii de Laborator ===== | ||
| - | |||
| - | - **[3p]** În reprezentarea unui număr întreg pe mai mulţi octeţi (de exemplu un short sau un int), se pune problema ordinii în care apar octeţii în memorie. Astfel, există două moduri de reprezentare: | ||
| - | * Big-endian (în care primul octet din memorie este cel mai semnificativ) | ||
| - | * Little-endian (în care primul octet din memorie este cel mai puţin semnificativ)\\ **Se cere** să se scrie un program care să determine endianess-ul calculatorului pe care este compilat şi rulat, şi să afişeze un mesaj corespunzător pe ecran. | ||
| - | - În limbajul C, şirurile de caractere sunt reprezentate în memorie ca o succesiune de valori de tip char terminate printr-un caracter special NULL ('\0'). Șirurile de caractere sunt pasate ca parametri printr-un pointer la primul caracter din şir, şi sunt prelucrate până când se întâlneşte caracterul nul, indiferent care este lungimea reală a zonei alocate. Astfel, un anumit vector de caractere de lungime N poate stoca şiruri de caractere de lungime între 0 şi N-1 (pentru că nu considerăm şi caracterul nul ca făcând parte din conţinutul şirului). | ||
| - | * **[1p]** Să se scrie o funcţie care calculează lungimea unui şir de caractere dat ca parametru<code>int str_length(char *s);</code> | ||
| - | * **[1p]** Să se scrie o funcţie pentru ştergerea (eliminarea) a n caractere dintr-o poziţie dată a unui şir ce returnează adresa șirului de caractere modificat<code>char * strdel(char *s, int pos, int n);</code> | ||
| - | * **[1p]** Să se scrie o funcţie pentru inserarea unui şir ''s2'' într-o poziţie dată ''pos'' dintr-un şir ''s1''. Se va presupune că există suficient loc în vectorul lui ''s1'' pentru a face loc şirului ''s2''. Funcţia returnează adresa şirului ''s1''.<code>char * strins(char *s1, int pos, char *s2)</code> | ||
| - | - * **[1p]** Scrieţi o funcţie care stabileşte dacă un şir dat (format din caractere alfanumerice) este egal cu o mască, ce poate conţine caractere alfanumerice şi caracterul special '?'. Se consideră că acest caracter înlocuieşte orice alt caracter alfanumeric. De exemplu, "abcde" este echivalent cu "?bc?e".<code>int eq_mask(char *sir, char *masca);</code> | ||
