În matematică, array-urile unidimensionale sunt cunoscute ca vectori. Unii dintre voi poate vă aminti încă (siiiiigur! 🙂) faptul că 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 șah, î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
2
3
4
5
6
7
8
9
10
11
12
13
14
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
int[,] arrayBiDimensional;
Console.ReadLine();
}
}
}
|
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
2
3
4
5
6
7
8
9
10
11
12
13
14
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
int[,,] arrayTriDimensional;
Console.ReadLine();
}
}
}
|
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.
Declarăm array-urile multidimensionale astfel:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
int[,] intMatrice;
float[,] floatMatrice;
string[,,] strCub;
Console.ReadLine();
}
}
}
|
și le putem inițializa astfel:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
int[,] intMatrice = new int[3, 4];
float[,] floatMatrice = new float[8, 2];
string[,,] strCub = new string[5, 5, 5];
Console.ReadLine();
}
}
}
|
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
7
8
9
10
11
12
13
14
15
16
17
18
19
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
int[,] matrice =
{
{ 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)
Console.ReadLine();
}
}
}
|
Ș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 declarația de mai sus. 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 rând
matrice[1, 0], matrice[1, 1], matrice[1, 2], matrice[1, 3] // al doilea rând
|
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
9
10
11
12
13
14
15
16
17
18
19
20
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
int[,] matrice =
{
{ 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
};
matrice.GetLength(0);
matrice.GetLength(1);
Console.ReadLine();
}
}
}
|
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
17
18
19
20
21
22
23
24
25
26
27
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
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();
}
Console.ReadLine();
}
}
}
|
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:
