Pointeri

Un pointer este o variabila destinata stocarii adresei de inceput a unui obiect din
memorie.
Adresa este un numar intreg pozitiv, iar obiectul poate fi o constanta, o variabila, un
tablou, sau o structura de date mai complexa.
Tipuri de pointeri
- pointeri de date: stocheaza adresa unei variabile sau constante din memorie;
- pointeri de functii: stocheaza adresa codului executabil din functii;
- pointeri generici/void: stocheaza adresa unui obiect oarecare;
Declaratii
- pointeri de date: tip *nume_pointer;
- pointeri generici: void *nume_pointer;
Exemple
int *p;
float var, *p;
int *tab[10];
void *pg;
Operatori specifici pointerilor
- operatorul "&" (adresare/referentiere); se foloseste pentru aflarea adresei unui obiect;
combinatie: &nume_obiect;
ex.: int a, *p=&a; // spunem ca p este un pointer la variabila a;
- operatorul "*" (indirectare/dereferentiere); se foloseste pentru vizualizarea sau
modificarea continutului aflat la adresa dintr-un pointer;
combinatie: *nume_pointer;
ex.: 1) cout << *p;
2) int a=4, *p=&a;
*p=5;

Un pointer, inainte de a fi utilizat, trebuie definit cu o adresa(valoare valida) sau cu

valoarea 0/NULL (valoare nevalida).
Initializarea unui pointer
Un pointer poate fi initializat la declarare sau dupa declarare, dupa urmatorul

exemplu:
int a, *p=&a;
//sau
int a,*p;
p=&a;
Utilizarea operatorului (cast)
- (tip)nume_pointer => se foloseste pentru a converti adresa continuta in pointer in tip;
- (tip*)nume_pointer => se foloseste pentru a converti tipul pointerul/variabilei la noul tip;
- *(tip*)nume_pointer => se foloseste (in cazul pointerilor void) pentru a modifica
valoarea continuta la adresa pe care o pointeaza;
In limbajul C/C++ se permite ca orice tip de pointer sa pointeze oriunde in memorie,
tipul pointerului determinand modul in care va fi tratat obiectul pointat atunci cand este
prelucrat prin intermediul pointerului.
Exemplu:
1)
int a;
double *p=&a;
*p=4.5 //voi scrie 8 octeti => rezultatul va fi eronat!

2)
double a;
int *p=&a;
*p=8; // voi scrie 4 octeti => rezultatul va fi eronat!
Cand un pointer de un tip pointeaza un obiect de un alt tip si cand se efectueaza
operatii de editare/vizualizare a continutului, pot aparea erori.De aceea, un pointer de un
tip nu va fi folosit sa pointeze o data de alt tip.
Acest mod de pointare este posibil in CodeBlocks fara conversii explicite, insa in
Visual Studio este necesar ca variabila din stanga sa se converteasca la tipul var. din
dreapta:
int a=8, *p1=&a;
float *p2=(float *)&a;
Pointerii generici nu sunt asociati unui anumit tip de date.Dimensiunea zonei de

memorie adresate si interpretarea datelor din acea zona nu sunt definite.

De aceea, in lucrul cu pointeri void se va folosi operatorul de conversie explicita in felul
urmator:
- (tip)pointer_generic // cand este nevoie doar de adresa din pointer;
Ex.: cout << (int)p;
- *(tip*)pointer_generic
pointer;
Ex.: cout << *(int*)p;

// pentru vizualizarea/editarea continutului de la adresa din

OBS: operatorul *(char*)nume_pointer se foloseste pentru accesarea pe octet la zonele

de memorie;
Ex.: int a=9, *p=&a;
cout << int(*(char*)p); //output: first byte of a, which contains the nb. 9;
Operatii cu pointeri
Asupra pointerilor se pot efectua urmatoarele operatii: atribuire, comparare, adunare,
scadere, incrementare si decrementare.
Atribuirea
Fie pointerii A si B.Atunci, A=B constituie o operatie de atribuire corecta daca:
1) A este void iar B este de orice tip;
2) B si A au tipuri diferite, dar la atribuire se foloseste operatorul (cast) in felul urmator:
A = (tipul_A*)B;
3) A si B sunt de acelasi tip;
Compararea
Operatia de comparare se realizeaza folosind operatorii relationali.
Fie pointerii A si B.Operatia de comparare: A g B, unde g este un op. rel., este valida
atunci cand:
1) A si B sunt de acelasi tip;
2) A si B au tipuri diferite, insa la comparare, comparatorul se converteste la tipul
decomparatului, dupa urmatorul exemplu: if(A<(tip_A*)B);
OBS: pointerii se pot compara cu NULL(sau 0) in felul urmator:
p == NULL <=> !p;
p !=0 <=> p;
Adunare, scadere, incrementare, decrementare

Se pot aduna sau scadea doar numere intregi.

Fie codul:
tip *p;
p+n;
p+n presupune adunarea la adresa continuta in pointer a valorii n inmultita cu sizeof(tip);
Acelasi principiu se aplica si in cazul incrementarii, numai ca n = 1;
Rezultatul este corect doar atunci cand pointerul adreseaza un tablou, iar prin operatia
aritmetica se realizeaza o deplasare in interiorul limitelor tabloului.
OBS: operatia de incrementare se poate realiza asupra:
- pointerului insusi: p++;
caz part.: *p++ (obtine continutul si apoi incrementeaza adresa);
- obiectului pe care il pointeaza: (*p)++;
Scaderea pointerilor
Fie operatia A-B.A-B este o operatie valida daca A si B sunt pointeri de acelsi tip sau
daca A si B sunt pointeri diferiti insa unul din ei se converteste la tipul celuilalt.
OBS: nu este permisa adunare pointerilor;