Implementarea array-urilor

Cum declaram array-uri si cum le accesam in mod direct?

1. Implementarea unui array unidimensional si accesarea elementelor.

In limbajul C/C++, si de altfel in majoritatea limbajelor, un array se declara dupa cum urmeaza:

tip_de_data nume_variabila[dimensiune];

Ca exemplu un array de tipul int de dimensiunea 100, numit v, se va declara asa:

int v[100];

Sau un array de tipul char, de 50 de elemente, numit str:

char str[50];

Accesarea elementelor se va face pe baza index-ului. In cazul unui array de tip int de 10 elemente, il putem accesa astfel:

int v[10];

v[0] = 1;
v[1] = 2;
v[2] = 3;
// samd...
v[9] = 10;

Indexarea pornind mereu de la 0, ultimul element fiind n-1, unde n este lungimea array-ului.

Putem declara un array manual asa:

int v[3] = {1, 2, 3};

Punand in acolade fiecare element pe rand, separate de virgula.

Daca dorim accesarea fiecarui element pe rand, vom folosi un for loop, unde indexul i porneste de la 0 si merge pana la n-1. De obicei, odata cu declararea array-ului, vom declara si dimensiunea lui, pentru a putea tine evidenta lungimii lui cat timp lucram cu el.

int v[10];
int n = 10;

for (int i = 0; i < n; i++) {
    printf("%d ", v[i]);
    // scanf("%d", v[i]); <- in caz de citire
}

Cum for loop-ul porneste de la 0, primul index, si este marit cu 1 la fiecare repetitie, acest for loop va afisa pe rand toate elementele din array, prin intermediul variabilei i.

2. Implementarea unui array bidimensional si accesarea elementelor.

Un array bidimensional este practic un array, care contine alte array-uri. Deci pentru un array de 3x3 avem un array de dimensiunea 3, in care fiecare element este un alt array de dimensiune 3.

Pentru implementarea unui array bidimensional, se procedeaza aproximativ la fel. Diferenta consta in faptul ca acum trebuie sa definim doua dimensiuni: dimensiunea array-ului mare, si dimensiunea fiecarui array mic din interior. Sau altfel spus, numarul de linii, si numarul de coloane respectiv.

int v[3][3];

Asta este un array bidimensional, pe care il putem reprezenta ca o matrice 3x3, cum am vazut mai sus.

Tinand cont ca fiecare element din array este insusi un array, vom accesa elementele astfel:

v[0] este primul element din array-ul nostru bidimensional. El contine ca si element un alt array. Ca sa accesam valorile lui vol folosi acceasi notatie:

v[0][0]

Citirea si scrierea intr-un array bidimensional este la fel ca la un array unidimensional, doar ca avem nevoie de cate un for loop pentru fiecare "dimensiune" noua, astfel:

int m = 3; // numar linii
int n = 3; // numar coloane
int v[m][n] = {{1,2,3}, {4, 5, 6}, {7, 8, 9}}; // initializare manuala a array-ului bidimensional

for (int i = 0; i < m; i++) { // for loop pentru a parcurge fiecare rand
    for(int j = 0; i < n; i++) { // for loop pentru a parcurge fiecare coloana a randului
        printf("%d ", v[i][j]); // afisare fiecare element, separat cu un spatiu
    }
    printf("\n"); // inserarea unei linii noi, pentru a separa randurile intre ele
}

Codul de mai sus va afisa:

1 2 3
4 5 6
7 8 9

Explicatie:

In memorie, array-ul de mai sus arata asa:

[ [1, 2, 3], [4, 5, 6], [7, 8, 9] ]

[1, 2, 3], [4, 5, 6] si [7, 8, 9] sunt array-uri de dimensiunea 3, care sunt introduse in alt array, de dimensiune tot 3. Astfel obtinand reprezentarea de mai sus.

Pentru simplicitate vom nota [1, 2, 3] cu X , [4, 5, 6] cu Y, si [7, 8, 9] cu Z. Astfel array-ul principal arata asa:

[X, Y, Z].

Cu primul for loop vom parcurce aceste elemente, luandu-le pe rand:

for (int i = 0; i < m; i++) {
    // va lua pe rand elementele v[0], v[1], v[2] care sunt X, Y si Z.
}

Dar si X si Y si Z sunt, la randul lor, tot array-uri, deci elementele lor se pot accesa cu aceeasi sintaxa.

Avand acum acces la fiecare array, cate unul la fiecare iteratie, vom avea nevoie de un alt for loop pentru a le parcurge elementele, de asta folosim al doilea for loop:

for (int j = 0; j < n; j++) {

}

Ca sa accesam fiecare element din matrice acum putem spune:

X[j]

Dar, daca ne amintim notatia de la care am plecat, X este v[0], asa ca le vom accesa asa:

v[i][j];

Cu aceste nested for loops, adica for loop-uri unul intr-altul, vom accesa elementele in urmatoarea ordine:

v[0][0]
v[0][1]
v[0][2]

v[1][0]
v[1][1]
v[1][2]

v[2][0]
v[2][1]
v[2][2]