Pointeri și Alocare Dinamică C++ — Ghid Complet

Ce sunt Pointerii?

Un pointer este o variabilă care stochează adresa de memorie a altei variabile.

Copiază
1int x = 10;
2int* p = &x;   // p conține adresa lui x
3cout << x;     // Afișează: 10
4cout << &x;    // Afișează: adresa lui x (ex: 0x7fff...)
5cout << p;     // Afișează: aceeași adresă
6cout << *p;    // Afișează: 10 (valoarea de la adresa p)

Operații cu Pointeri

Declarare și Inițializare

Copiază
1int* p;          // pointer la int (neinițializat — periculos!)
2int* p = nullptr; // pointer null (recomandat)
3int* p = &x;    // pointer la variabila x
4
5double* d;      // pointer la double
6char* c;        // pointer la char

Dereferenciere și Modificare

Copiază
1int x = 5;
2int* p = &x;
3*p = 20;       // modifică x prin pointer
4cout << x;     // Afișează: 20

Pointeri la Funcții (transmitere prin referință)

Copiază
1void inmultesteCu2(int* p) {
2    *p *= 2;
3}
4
5int main() {
6    int x = 5;
7    inmultesteCu2(&x);
8    cout << x;   // Afișează: 10
9}

Alocare Dinamică: new și delete

Copiază
1// Alocare unui singur element
2int* p = new int;          // alocă memorie pentru un int
3int* q = new int(42);      // alocă și inițializează cu 42
4*p = 100;
5delete p;                  // eliberează memoria!
6
7// Alocare de array dinamic
8int n = 10;
9int* arr = new int[n];     // array dinamic de n elemente
10arr[0] = 5;
11arr[1] = 3;
12delete[] arr;              // eliberează array-ul! (se folosește delete[])

Greșeli frecvente cu alocare dinamică:

Copiază
1// ❌ Memory leak — uit să eliberez memoria
2int* p = new int(5);
3// ... (fără delete p) — MEMORY LEAK!
4
5// ❌ Double free — eliberez de două ori
6delete p;
7delete p;  // COMPORTAMENT NEDEFINIT!
8
9// ❌ Dangling pointer — folosesc pointer după delete
10delete p;
11cout << *p;  // COMPORTAMENT NEDEFINIT!
12
13// ✅ Corect
14delete p;
15p = nullptr;  // pointeaz la null după delete

Liste Înlănțuite în C++

Copiază
1struct Nod {
2    int valoare;
3    Nod* urmator;
4    Nod(int v) : valoare(v), urmator(nullptr) {}
5};
6
7class ListaInlantuita {
8    Nod* cap;
9public:
10    ListaInlantuita() : cap(nullptr) {}
11    
12    void inserareInceput(int val) {
13        Nod* nou = new Nod(val);
14        nou->urmator = cap;
15        cap = nou;
16    }
17    
18    void afisare() {
19        Nod* current = cap;
20        while (current) {
21            cout << current->valoare << " -> ";
22            current = current->urmator;
23        }
24        cout << "null\n";
25    }
26    
27    ~ListaInlantuita() {
28        while (cap) {
29            Nod* temp = cap;
30            cap = cap->urmator;
31            delete temp;
32        }
33    }
34};

Aritmetica Pointerilor

Copiază
1int arr[] = {10, 20, 30, 40, 50};
2int* p = arr;    // p pointează la arr[0]
3
4cout << *p;      // 10
5p++;             // p pointează la arr[1]
6cout << *p;      // 20
7p += 2;          // p pointează la arr[3]
8cout << *p;      // 40
9cout << *(arr + 1);  // 20 — echivalent cu arr[1]

Smart Pointers C++ (Modern C++)

Copiază
1#include <memory>
2
3// unique_ptr — proprietar unic
4unique_ptr<int> p = make_unique<int>(42);
5cout << *p;
6// auto-delete când iese din scope!
7
8// shared_ptr — proprietar multiplu
9shared_ptr<int> p1 = make_shared<int>(100);
10shared_ptr<int> p2 = p1;  // ambii dețin resursa
11// auto-delete când toți shared_ptr sunt distruși

Pointerii sunt un subiect esential la BAC informatica (mai ales la studiul listelor înlantuite) si la titularizare (structuri de date dinamice).