Curs C++ | Sectiunea 24 – Siruri de pointeri

💡 Nu ne opreste nimic in a avea pointeri ca elemente ale ale unui sir. Sa presupunem ca avem nevoie de un sir dinamic, bidimensional. Nu putem prezice cate linii si cate coloane, stim doar ca numarul de coloane este stocat in variabila cols si numarul de linii in rows.

❗ Pentru a avea sirul complet configurabil si usor de accesat, trebuie sa facem urmatoarele lucruri:

• stocam pointerul ce indica la inceputul fiecarei linii separat, putand astfel sa ajungem la fiecare linie ca la orice vector; vom stoca acesti pointeri intr-un sir, numit sir de linii
• fiecare element din sirul de linii va fi un pointer catre o linie separata
• avem nevoie de un pointer suplimentar pentru a indica la sirul de linii – il putem numi ptrarr

int *ptrarr

❓ Ce tip de variabila este ptrarr? In primul rand, rezultatul dereferenierii nu este un int ci este un pointer ce indica la un int. Putem spune deci, ca ptrarr este pointer ce indica la un pointer ce indica la un int.

Pointer la pointer 💫

Odata ce am declarat pointerul, putem aloca memorie pentru sirul de linii.

ptrarr = new int * [rows]

📝 Trebuie sa mentionam cateva aspecte. In primul rand, pointerul returnat de operatorul new este de tip int** (pentru ca este un pointer ce indica la un pointer ce indica la un int) si este asignat lui ptrarr. In al doilea rand, elementele sirului de linii vor fi pointeri ce indica la linii, fiind de tipul int*.

In final, putem aloca memorie pentru fiecare linie iar cel mai simplu mod in care putem sa o facem este folosind o bucla for.

for (int r = 0; r < rows; r++)
  ptrarr[r] = new int[columns];

Folosirea acestui sir este foarte simpla, similara cu ce am facut la matrice. Daca vrem spre exemplu sa asignam valoarea 10 elementului aflat pe linia r si coloana c, scriem astfel:

ptrarr[r][c] = 10;

• expresia ptrarr[r] este interpretata ca *(ptrarr + r), ceea ce se traduce ca dereferentiind elementul ce indica la linia dorita
• pointerul este dereferentiat inca o data, intreaga expresie aratand ca mai jos, accesand astfel valoara dorita de tip int

*(*(ptrarr + r) + c)

Matrice triunghiulara

💡 Avantajul unui astfel de sir este, spre deosebire de unul normal, ca fiecare linie poate avea lungimi diferite. Acest lucru poate fi util pentru un algoritm unde nu este nevoie de tot sirul, ci doar de o bucata. In special, ne putem referi la matricea triunghiulara.

🔺 Triunghiularitatea este obinuta prin faptul ca dimensiunea memoriei alocata depinde de numarul liniei iar modul in care acea valoarea este asignata elementului, refleca locatia in sir.

❗ Tineti cont de faptul ca ordinea eliberarii memoriei este inversa fata de cea a alocarii!

#include <iostream>

int main() {
  int rows = 5, cols = 5;
  int ** arr;
  // alocam memorie si initializam sirul
  arr = new int * [rows]; //alocam memorie pentru sirul de linii
  for (int r = 0; r < rows; r++) {
    arr[r] = new int[r + 1]; //alocam memorie pentru fiecare linie
    for (int c = 0; c <= r; c++) { ///asignam valori
      arr[r][c] = (r + 1) * 10 + c + 1;
    }
  }
  // afisam valorile parcurgand matricea
  for (int r = 0; r < rows; r++) {
    for (int c = 0; c <= r; c++) {
      std::cout << arr[r][c] << " ";
    }
    std::cout << std::endl;
  }
  // eliberam memoria
  for (int r = 0; r < rows; r++) {
    delete[] arr[r]; //eliberam memoria pentru fiecare linie
  }
  delete[] arr; //eliberam memoria pentru sirul de linii
  return 0;
}

Programul va produce rezulatul de mai jos. Puteti sa va jucati putin cu acest tip de matrice, puteti incerca sa inversati triunghiul ori sa ii schimbati orientarea 🙂 .

11 
21 22 
31 32 33 
41 42 43 44 
51 52 53 54 55 

Aici se termina si aceasta sectiune. Toate diagramele au fost realizata folosind PlantUML. Pentru intrebari suplimentare puteti folosi informatiile de aici.

➡ Sectiunea anterioara:Curs C++ | Sectiunea 23 – Alocare de memorie

➡ Sectiunea urmatoare:Curs C++ | Sectiunea 25 – Conversii