OPERATII ARITMETRICE CU POINTERI
Deoarece pointerii contin ca valoare o adresa de memorie, operatiile aritmetice permise sunt: atribuirea, adunarea cu un intreg, scaderea cu un intreg, scaderea a doi pointeri, comparatia unui pointer cu constanta simbolica NULL si compararea a doi pointeri. Atribuirea a fost tratata in paragraful 5.3.
Adunarea unui pointer cu un intreg
Rezultatul adunarii este un pointer de acelasi tip marit cu intregul de adunat inmultit cu numarul de octeti necesari pentru a memora o valoare de tipul pointerului. Astfel daca :
tip * ptr;
atunci: ptr + i modifica ptr cu i * sizeof (tip).
Deci noua valoare a lui ptr este: ptr + i* sizeof (tip).
Daca intregul i este l atunci se poate folosi operatorul ++ prefixat sau postfixat: ++ ptr sau 343c22d
ptr ++. Noul ptr va fi : ptr + sizeof (tip).
Ex. int * pi, i;
. . .
pi++; /* Aduna 2 la pi (sizeof (int) = 2) */
i = * (pi + 3); /* Aduna 2 * 3 la pi si intregul */
/* memorat la pi + 6 este atri- */
/* buit lui i */
. . .
Daca avem de-a face cu un masiv unidimensional (sir) tip a [DIM]; atunci numele sirului neurmat de indici este considerat pointer catre primul sau element, anume pointer constant ce contine intotdeauna adresa lui a [ o] .Altfel spus, valoarea lui a este & a[o]. Deci inseamna ca adunarea unui intreg la acest tip de pointer este o constructie corecta si :
a + i este identic cu & a [ i ] iar
* (a+i) este identic cu a [ i ] .
Efectul scaderii unui intreg dintr-un pointer este acela ca valoarea pointerului se micsoreaza cu intregul de scazut inmultit cu numarul de octeti necesari pentru a memora o valoare de tipul pointerului.
Daca:
tip * ptr;
atunci noua valoare a pointerului dupa: ptr - i este :
ptr - i * sizeof (tip).
Utilizand operatorul de decrementare -- ptr sau ptr - noua valoare pentru ptr va fi
ptr - sizeof (tip).
Atat operatorul de incrementare ++, cat si cel de decrementare - se pot utiliza in expresii cu pointeri impreuna cu operatorul de dereferentiere *. Pentru corectitudine trebuie tinut cont ca operatorii ++ , -- si * sunt de aceeasi prioritate si se asociaza de la dreapata la stanga, deci se vor folosi parantezele pentru a forta ca un operator sa se execute primul.
Astfel daca:
tip * ptr;
atunci:
*ptr ++ respectiv * ptr - mai intai obtine valoarea de la adresa ptr si apoi incrementeaza , respectiv
decrementeaza pointerul;
(*ptr)++ respectiv (*ptr) - obtine valoarea de la adresa ptr pe care o incrementeaza , respectiv o
decrementeaza;
*++ptr respectiv * -- ptr mai intai incrementeaza, respectiv decrementeaza pointerul si apoi obtine
valoarea de la noua adresa ptr;
++*ptr respectiv -- *ptr obtine valoarea de la adresa ptr pe care o incrementeaza , respectiv o
decrementeaza .
Expresiile cu pointeri de mai sus permit o scriere mai compacta a programului si in comparatie cu utilizarea indicilor la un tablou duc la o executie a programului intr-un timp mai scurt. Un motiv in plus pentru utilizarea acestor expresii este ca: *ptr++, *ptr --, *++ptr si *-- ptr, intrucat se refera la obiectul catre care indica adresa din ptr, sunt valori-stanga (L value) si deci pot fi utilizate la stanga operatorului de atribuire =. In acest caz operatorul = va modifica obiectul referit.
In general scaderea a doi pointeri este o operatie ilegala, cu cateva exceptii.
Astfel, daca pointerii sunt de acelasi tip , in sensul ca se refera la obiecte de acelasi tip, ei se pot scade si rezultatul scaderii este un intreg int sau long ( functie de modelul de memorie) egal cu numarul de locatii de memorie capabile sa memoreze o valoare de tipul comun al pointerilor existente intre adresa primului si adresa celui de-al doilea. Rezultatul este pozitiv daca primul pointer este o adresa aflata la dreapta adresei din cel de-al doilea pointer si negativ in caz contrar.
Fie pointerii ptr l si ptr 2:
tip * ptr l , * ptr 2;
atunci: ptr l - ptr 2 va fi egal cu (ptr l - ptr 2)/ sizeof (tip).
Alta scadere corecta este aceea cand cei doi pointeri indica spre elementele aceluiasi tablou si in aceasta situatie rezultatul este egal cu numarul de elemente dintre cei doi indici: pozitiv daca indicele l > indicele 2 si negativ in caz contrar.
Exemplu 5.5.1.
# include " stdio.h"
main ( )
;
/* se declara un sir de 8 intregi care se initializeaza */
pl = & x [ 2 ]; /* Pointerul pl se initializeaza cu adresa lui x [2] . Echivalent cu : pl = x + 2 ; */
p2 = x + 7; /*Pointerul p2 se initializeaza cu adresa de inceput a lui x plus inca 7 locatii a cate
2 octeti adica cu adresa lui x [7].
Echivalent cu : p2 = & x [ 7]; */
printf ("x = %u pl = %u p2= %u \n", x,pl,p2);
printf ("Diferente: pl - x = %u p2 - x = %u p2- p1 = %u \n",
pl - x, p2 - x, p2 - pl);
La executia programului se va afisa:
x = 65494 pl = 65498 p2= 65508
Diferente: pl - x = 2 p2 - x = 7 p2 - p1 = 5
Compararea a doi pointeri
Pentru ca operatia de comparare sa fie valida, cei doi pointeri trebuie sa indice catre doua elemente ale aceluiasi tablou si rezultatul comparatiei este egal cu rezultatul comparatiei celor doi indici.
Daca pointerul pl indica pe a [i], iar pointerul p2 indica pe a [j] atunci:
pl < p2 = 1 (adevarata) daca i < j;
= 0 (falsa) daca i > j;
pl > = p2 =l (adevarata) daca i > j;
= O (falsa) daca i < j;
pl = = p2 = l (adevarata) daca i = j;
= O (falsa) daca i j
Siruri cu index negativ sau mai mare decat dimensiunea maxima
La adunarea unui intreg la un pointer spunem ca daca a este un sir:
tip a [ DIM];
atunci:
a + i este identic cu & a [ i ], iar
*(a + i ) este identic cu a [i].
Intregul i care se aduna la pointerul constant a poate fi mai mare sau egal cu dimensiunea maxima a sirului.Compilatorul C nu face verificarea depasirii dimensiunii maxime.
De asemenea ,din pointerul a se poate scade orice intreg si compilatorul C nu verifica depasirea limitei din stanga a sirului.Intr-adevar la fel ca si la adunare cu intrgi :
a - j este identic cu & a [ -j], iar
(a-j) este identic cu a[-j].
Deci, in limbajul C utilizarea indexului negativ sau a indexului mai mare decat dimensiunea maxima este permisa asa cum se ilustreaza in urmatorul exemplu.
Exemplu 5.5.2.
# include "stdio.h"
main ( )
La executia programului se va afisa:
a[-3]= -3 a[2] = 2 a[12] = 12
zona neinitializata a[-4] = 65224
|
