Tutorial C++: Pointeri, Memorie Dinamică, Referinţe

Ce este un pointer?

Un pointer este o variabilă care memorează o adresă de memorie.
Un pointer se declară în felul următor:

tip * nume;

Aici tip* reprezintă tipul de dată al variabilei (obiectului) pe care pointerul îl referă.
Un pointer este un pointer deoarece el memorează o adresă şi ocupă acelaşi spaţiu de memorie cu un pointer de alt tip*.
Totuşi, asta nu înseamnă că puteţi memora adresa unui double într-un pointer int* sau să interschimbaţi adrese între pointeri de tipuri diferite.
Pe lângă memorarea adreselor, pointerii mai pot accesa şi conţinutul de la respectivele adrese. Decodificarea conţinutului se face pe baza tipului pointerului tip*.
Spaţiul de memorie pe care îl ocupă un pointer depinde de compilator şi sistemul de operare.
Exemplu de pointeri:

int * p1; // Refera un int
char * p2; // Refera un char

Aveţi grijă să iniţializaţi un pointer înainte de a-l folosi, altfel puteţi accesa zone de memorie pentru care programul vostru nu are acces, iar acest lucru poate cauza erori în program.
Puteţi iniţializa un pointer fie cu o adresă de memorie, fie cu pointerul NULL nullptr.
Acest keyword a fost introdus în noul standard C++11 şi diferă de NULL prin faptul că nu este un întreg, pur şi simplu reprezintă un pointer NULL.
NULL în C/C++ este definit ca #define NULL 0 - practic NULL este constanta zero.
Dacă compilatorul vă permite, folosiţi nullptr în loc de NULL.
Adresa unei variabile se obţine cu operatorul de referenţiere (&) (sau operatorul adresă).

ptr = &var;

Conţinutul unei adrese de memorie (stocată într-un pointer) se obţine cu operatorul de dereferenţiere (*) (sau operatorul de indirectare).

*ptr

Nu confundaţi acest operator cu steluţa (*) din declararea unui pointer! Ea face parte din tipul pointerului.
Iată un exemplu mai concret:

#include <iostream>
using namespace std;

int main()
{
    int * p1; double * p2;
    int d1 = 45; double d2 = 3.14;
    p1 = &d1;  // p1 refera variabila d1
    p2 = &d2;  // p2 refera variabila d2
    // Afisez adresele de memorie stocate in cei doi pointeri
    cout << p1 << ' ' << p2 << '\n';
    // Afisez continutul stocat la adresele de memorie
    // din cei doi pointeri
    cout << *p1 << ' ' << *p2 << '\n';
    cout << sizeof(p1) << ' ' << sizeof(p2);
    return 0;
}

Output:

0x22fef4 0x22fee8
45 3.14
4 4

Prin convenţie numerele hexazecimale sunt reprezentate cu prefixul 0x.
Operatorul sizeof(ob), unde ob reprezintă un tip (int, char, float, etc.) sau un obiect (variabilă), returnează mărimea, în bytes, a argumentului.
După cum vedeţi, pointerii ocupă 4 bytes de memorie (în sistemele de 32-biţi).

Puteţi scădea doi pointeri ca să obţineţi numărul de elemente de tipul respectiv ce încap între ei.

#include <iostream>
using namespace std;

int main()
{
    double * p1, * p2;
    double d1 = 1.1, d2 = 2.2;
    p1 = &d1; p2 = &d2;
    cout << p1 << ' ' << p2 << '\n';
    cout << p1 - p2;
    return 0;
}

Output:

0x22fef0 0x22fee8
1

Diferenţa dintre 0x22fef0 şi 0x22fee8 este 0x8, adică 8, iar 8 bytes este spaţiul de memorie pe care îl ocupă 1 double, deci rezultatul afişat este 1.
Puteţi scădea numai pointeri ce referă acelaşi tip de dată.
Dacă p1 ar fi fost int*, codul de mai sus nu ar fi compilat.

Alocarea dinamică

Când declaraţi un vector trebuie să precizaţi numărul de elemente ce-l vor alcătui.
Asta înseamnă că stabiliţi spaţiu de memorie ocupat de vector înainte de a ştii exact numărul de elemente ce va fi memorat în vectorul respectiv.
Vectorii statici pot fi ineficienţi din punct de vedere al memoriei ocupate atunci când nu se ştie exact câte elemente va memora vectorul.
De aceea C++ ne pune la dispoziţie operatorii new şi delete cu care putem aloca / dealoca memorie dinamic în timpul execuţiei programului.
Cu new se alocă (rezervă) memorie. Operatorul returnează adresa de memorie a spaţiului alocat.

tip* var = new tip;

Sau putem aloca un bloc de memorie (vector dinamic):

tip* var = new tip[nr_elem];

Nu există succes garantat când alocaţi memorie dinamic.
Operatorul new alocă memorie din zona liberă (heap).
Este posibil ca această zonă din memorie să fie ocupată de alte aplicaţii sau starea sistemului să nu permită o astfel de alocare.
În această situaţie new lansează o excepţie. Puteţi folosi (nothrow) astfel încât new să returneze pointerul NULL în caz de eşec.

tip* var = new (nothrow) tip;

Memoria alocată cu new - numai aceasta - poate fi dealocată (eliberată) cu delete.

delete var;
delete[] var; // pentru vectori

După ce aţi folosit delete pe un pointer, acesta nu mai indică către o adresă validă (respectiva adresă nu mai este rezervată pentru programul vostru), de aceea este bine să-i atribuiţi valoarea nullptr (sau NULL).
ATENŢIE: delete nu distruge variabila pointer! El eliberează spaţiul de memorie indicat de pointer prin adresa pe care o memorează.

Nu uitaţi să dealocaţi spaţiul de memorie atunci când nu mai aveţi nevoie de el!
Dacă nu dealocaţi memoria, aceasta rămâne rezervată, degeaba, pentru aplicaţia voastră, când alte aplicaţii ar putea avea nevoie de ea sau chiar programul vostru, care alocă fără să elibereze, poate rămâne fără spaţiu de lucru. Fenomenul se numeşte memory leak.
Un exemplu de alocare dinamică:

#include <iostream>
using namespace std;

int main()
{
    int* x = new int;
    *x = 98;
    cout << *x << ' ' << x;
    delete x;
    return 0;
}

Output:

98 0x7c0f70

Un vector static este practic un pointer constant. El referă numai blocul de memorie care îi este atribuit de compilator.
Numele vectorului este un pointer către primul element din vector. Exemplu:

#include <iostream>
using namespace std;

int main()
{
    int v[] = {1, 2, 3, 4, 5};
    cout << *v; // Se va afisa 1
    return 0;
}

Puteţi accesa elementele unui vector, static sau dinamic, în două moduri:

v[i]; // SAU
*(v+i);
// unde i este un intreg

Atunci când adunaţi sau scădeţi un intreg dintr-un pointer, deplasaţi pointerul peste i blocuri de memorie de tipul referit de pointer.
De exemplu, dacă un pointer (int* ptr;) referă / indică adresa 0x22feec, atunci ptr+1 va referi adresa 0x22fef0.
0x22feec + 4 = 0x22fef0 (4 este mărimea în bytes a tipului int). Vezi imaginea de mai sus.
Aşadar, putem folosi operatorii ++ şi -- pentru a parcurge un vector:

#include <iostream>
using namespace std;

int main()
{
    int v[] = {1, 2, 3, 4, 5};
    for (int i = 0; i < 5; i++)
        cout << *(v+i) << ' '; // v[i]
    return 0;
}

Din acest motiv vectorii se transmit prin referinţă.
Deoarece ei sunt nişte pointeri constanţi a căror adresă (stocată în ei) este transmisă (prin valoare) parametrului funcţiei, care este un vector.
Acel vector accesează, şi eventual modifică, conţinutul de la adresa de memorie primită.
Un exemplu cu vectori dinamici. Programul cere utilizatorului să introducă o listă de numere, iar acesta calculează şi afişează suma lor:

#include <iostream>
using namespace std;

int main()
{
    int n, suma = 0;
    cout << "Cate numere vrei sa adun? "; cin >> n;
    int * nr = new int[n];
    cout << "Scrie numerele despartite prin spatiu: ";
    for (int i = 0; i < n; i++)
        cin >> nr[i];
    // Suma
    for (int i = 0; i < n; i++)
        suma += nr[i];
    cout << "Suma lor este: " << suma;
    delete[] nr;
    return 0;
}

Pointerii constanţi sunt de două feluri:
- Pointeri care nu pot modifica datele referite (date constante), dar care pot fi modificaţi (le puteţi atribui o altă adresă);

const tip* ptr;

- Pointeri care pot modifica datele referite (date neconstante), dar care nu pot fi modificaţi (nu le puteţi atribui o altă adresă);

tip* const ptr;

- Pointeri care nu pot modifica datele referite şi nu pot fi modificaţi.

const tip* const ptr;

Exemplu:

#include <iostream>
using namespace std;

int main()
{
    const int sz = 10;
    int money = 3000;

    const int* pSz = &money;
    int* const pMoney = &money;
    const int* const ptr = &sz;

    pSz = &sz; // OK!
// *pSz = 11;  // Eroare! Nu pot modifica variabila referita
    *pMoney = 4000;   // OK!
//  pMoney = &sz;  // Eroare! Pointer constant
//  ptr = &money;  // Eroare!
//  *ptr = 13;     // Eroare
    pSz = &money;

    // Eroare! Chiar daca money nu este const
    // Pointerul n-o poate modifica
//  *pSz = 5000;

    // Iar daca se incearca modificarea unei variabile const
    // Cu un pointer neconstant, din nou eroare
    // const int* este DIFERIT de int*
    // &sz returneaza o adresa (pointer) de tip const int*
//  int* pt = &sz;
//  *pt = 17;

    return 0;
}

Pointerii pot fi parametri ai unei funcţii.
Studiaţi cu atenţie exemplele următoare.

#include <iostream>
using namespace std;

void vreauPointer(int* p)
{
    cout << "In functie *p = " << *p << '\n';
    *p = 90;  // Modific continutul de la adresa memorata in p
    cout << "Dupa modificare *p = " << *p << '\n';
    int x = 12;
    // Modificarea pointerului este vizibila doar aici
    // Deoarece variabila pointer nu este
    // transmisa prin referinta
    p = &x;
    cout << "In functie p refera " << p << '\n';
}

int main()
{
    int q = 70;
    int* ptr = &q;
    cout << "In main q = " << q << '\n';
    cout << "In main *ptr = " << *ptr << '\n';
    cout << "In main ptr refera " << ptr << '\n';
    vreauPointer(ptr);
    cout << "Dupa apel q = " << q << '\n';
    cout << "Dupa apel *ptr = " << *ptr << '\n';
    cout << "Dupa apel ptr refera " << ptr << '\n';
    return 0;
}

Output:

In main q = 70
In main *ptr = 70
In main ptr refera 0x22fef8
In funtie *p = 70
In functie p refera 0x22fef8
Dupa modificare *p = 90
Dupa modificare p refera 0x22fe6c
Dupa apel q = 90
Dupa apel *ptr = 90
Dupa apel ptr refera 0x22fef8

Pointerii pot fi transmişi prin referinţă.

#include <iostream>
using namespace std;

void vreauPointer(int* &p)  // Referinta!
{
    cout << "In functie *p = " << *p << '\n';
    *p = 90;  // Modific continutul de la adresa memorata in p
    cout << "In functie p refera " << p << '\n';
    cout << "Dupa modificare *p = " << *p << '\n';
    int x = 12;  // Aceasta variabila va fi distrusa la sfarsitul functiei
    // Modificarea pointerului este vizibila in afara
    // Deoarece variabila pointer este
    // transmisa prin referinta
    p = &x;
    cout << "Dupa modificare p refera " << p << '\n';
}

int main()
{
    int q = 70;
    int* ptr = &q;
    cout << "In main q = " << q << '\n';
    cout << "In main *ptr = " << *ptr << '\n';
    cout << "In main ptr refera " << ptr << '\n';
    vreauPointer(ptr);
    cout << "Dupa apel q = " << q << '\n';
    cout << "Dupa apel *ptr = " << *ptr << '\n';
    cout << "Dupa apel ptr refera " << ptr << '\n';
    return 0;
}

Output:

In main q = 70
In main *ptr = 70
In main ptr refera 0x22fefc
In funtie *p = 70
In functie p refera 0x22fefc
Dupa modificare *p = 90
Dupa modificare p refera 0x22fe6c
Dupa apel q = 90
Dupa apel *ptr = 4683872
Dupa apel ptr refera 0x22fe6c

Observaţi că *ptr referă o valoare ciudată. Acest lucru se întâmplă deoarece ptr memorează adresa variabilei x din funcţia vreauPointer().
Când o funcţie îşi termină execuţia toate variabilele declarate în acea funcţie (+parametrii) sunt distruse (memoria ocupată de ele este eliberată).
La respectiva adresă rămâne numai gunoi (junk), un şir de 1 şi 0 care nu are niciun sens pentru programul vostru, dar acesta îşi face datoria şi afişează interpretarea int, în acest caz, a biţilor.
Acelaşi lucru se întâmplă şi când folosiţi un pointer neiniţializat sau o variabilă neiniţializată.

Referinţe

O referinţă este un alias pentru o variabilă.
Dacă variabila reprezintă o anumită zonă de memorie, şi referinţa va reprezenta aceeaşi zonă de memorie.
Referinţele se declară cu (&).

#include <iostream>
using namespace std;

int main()
{
    int x = 6;
    int& q = x;  // q refera acelasi spatiu de memorie ca si x
    q += 5;      // Referintele se folosesc normal ca si variabilele
    cout << x;   // se va afisa 11
    return 0;
}

Referinţele trebuie iniţializate!
Nu puteţi iniţializa o referinţă cu o constantă! Trebuie să fie un obiect / variabilă.
Puteţi avea referinţe constante care referă variabile constante.

#include <iostream>
using namespace std;

int main()
{
    const int p = 5;
    const int& x = p;
    cout << x; // 5
    return 0;
}

De îndată ce a fost iniţializată, referinţa nu mai poate fi schimbată. Nu mai aveţi cum.
Referinţa se comportă ca o altă variabilă.