În matematică, array-urile unidimensionale sunt cunoscute ca vectori. Unii dintre voi poate vă aminti încă (siiiiigur! 🙂 ) ca array-urile multidimensionale sunt numite matrici. În programare, numim array-uri multidimensionale orice array cu mai mult de o dimensiune.
De exemplu, cum am putea reprezenta structura unei table de sah, în cod? Ea are două dimensiuni: una formată din numere (pornind de la 1, terminând cu 8) și una din literele (de la A la H), și identificăm o celulă prin combinarea celor două, ca într-un sistem de coordonate: H3, B6, etc.
Modul în care realizăm acest lucru este prin declararea unui array bidimensional, astfel:
|
1 |
int [,] arrayBiDimensional; |
Dacă doriți să reprezentați un sistem tridimensional, cum ar fi coordonatele unui punct 3D (axele X, Y și Z), puteți declara un array tridimensional:
|
1 |
int [,,] arrayTriDimensional; |
si asa mai departe. Cu toate acestea, array-urile bidimensionale sunt rar utilizate, iar cele cu mai mult de două dimensiuni chiar și mai rar. Cu toate acestea, în teorie, ați putea declara un număr infinit de dimensiuni.
Declaram array-urile multidimensionale astfel:
|
1 2 3 |
int[,] intMatrice; float[,] floatMatrice; string[,,] strCub; |
și le putem inițializa astfel:
|
1 2 3 |
int[,] intMatrice = new int[3, 4]; float[,] floatMatrice = new float[8, 2]; string[,,] stringCub = new string[5, 5, 5]; |
Deoarece array-urile multidimensionale sunt greu de înțeles ca și concept când le vizualizăm așa, le puteți imagina mai bine vizualizându-le prin următoarea imagine:
Imaginea de mai sus reprezintă reprezentarea vizuală a matricei noastre intMatrice, populată cu unele elemente aleatoare. După cum se poate vedea din inițializarea noastră, am declarat intMatrice cu două dimensiuni, una de 3 elemente, una de 4. Imaginea ilustrează exact același lucru, ținând cont de faptul că array-urile multidimensionale, la fel ca array-urile obișnuite, au indecșii pornind de la 0, nu 1.
În cele din urmă, acesta este modul în care vom inițializa array-ul noastru multidimensional cu unele valori:
|
1 2 3 4 5 6 |
int[,] matrix = { {1, 2, 3, 4}, // valori rand 0, cu 4 coloane {5, 6, 7, 8}, // valori rand 1, cu 4 coloane }; // Marimea matricei este 2 x 4 (2 randuri, 4 coloane) |
Și da, este un pic complicat. Dar nu fiți triști, chiar și programatorii cu experiență au probleme în conceptualizarea array-urilor cu mai mult de trei dimensiuni 😀
Cu toate acestea, accesarea sau setarea valorilor anumitor locații ale array-urilor multidimensionale este un pic mai simplă. Considerați următoarea declarație:
|
1 2 3 4 5 |
int[,] _matrice = { {1, 2, 3, 4}, {5, 6, 7, 8}, }; |
Array-ul _matrice are un total de 8 elemente, 2 rânduri cu 4 coloane fiecare. Deci, elementele sale pot fi accesate astfel:
|
1 2 |
_matrice[0, 0] _matrice[0, 1] _matrice[0, 2] _matrice[0, 3] //primul rand _matrice[1, 0] _matrice[1, 1] _matrice[1, 2] _matrice[1, 3] //al doilea rand |
După o inspecție rapidă a exemplului meu, vă puteți da seama probabil că array-urile bidimensionale pot fi accesate prin
|
1 |
_matrice[rand, coloana] |
și similar, orice număr de dimensiuni pot fi accesate cu
|
1 |
nDimensionalArray[index1, …, indexN] |
Un alt concept de care ar trebui să fiți conștienți este lungimea array-urilor multidimensionale. Desigur, nu putem accesa proprietatea Length direct, cum am făcut în cazul array-urilor unidimensionale, deoarece nu este posibil. Acest lucru se datorează faptului că fiecare dimensiune are propria sa lungime, care poate fi preluată în acest fel:
|
1 2 3 4 5 6 7 8 |
int[,] _matrice = { {1, 2, 3, 4}, {5, 6, 7, 8}, }; _matrice.GetLength(0); _matrice.GetLength(1); |
La o prima vedere, ați putea crede că _matrice.GetLength(0) va returna lungimea primului rând, în timp ce _matrice.GetLength(1), valorile celui de-al doilea, iar aceasta ar fi o capcană perfidă! De fapt, _matrice.GetLength(0) returnează lungimea primei noastre dimensiuni – rândurile – care, în cazul nostru este 2, în timp ce _matrice.GetLength(1) returnează lungimea celei de a doua dimensiuni – coloanele – care este 4!
Pentru a încheia această lecție, acesta este modul de afișare a elementelor unei matrice la consolă:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
// Declara si initializeeaza o matrice de marime 2 x 4 int[,] _matrice = { {1, 2, 3, 4}, // valori rand 0 {5, 6, 7, 8}, // valori rand 1 }; //afiseaza matricea la consola for (int rand = 0; rand < _matrice.GetLength(0); rand++) { for (int coloana = 0; coloana < _matrice.GetLength(1); coloana++) { Console.Write(_matrice[rand, coloana]); } Console.WriteLine(); } |
Mai întâi declarăm și inițializăm o matrice. Matricea este bidimensională, de aceea folosim o buclă For ce va itera rândurile și o buclă For imbricată, care va itera coloanele pentru fiecare rând. La fiecare iterație vom afișa elementul curent folosind metoda adecvată pentru a accesa acest element utilizând doi indici (rânduri și coloane). În cele din urmă, când vom executa această bucată de cod, vom obține următorul rezultat:
Conceptele explicate în această lecție sunt prezentate și vizual, ca parte a următorului videoclip:
