În C#, matricele servesc ca containere pentru stocarea elementelor de același tip de date. Când creați o matrice, există mai multe abordări pentru a o inițializa cu elemente. Acest articol analizează diferitele metode de inițializare a matricelor în C#, oferind o explorare cuprinzătoare a fiecărei abordări.
Metode de inițializare a matricelor în C#
Matricele sunt o structură de date esențială în programarea computerelor, care vă permite să stocați și să manipulați o colecție de elemente de același tip de date în locații de memorie adiacente. Iată câteva modalități de a inițializa matrice în C#:
1: Inițializarea tablourilor folosind sintaxa Array Initializer
Cea mai simplă abordare de a inițializa o matrice este utilizarea sintaxei de inițializare a matricei, deoarece aceasta implică includerea elementelor matricei între acolade, separate prin virgule, de exemplu:
int [ ] numere = { 1 , 2 , 3 , 4 , 5 } ;
În acest cod, este creată și inițializată o matrice întregă numită „numerele” cu valorile de la 1 la 5. În mod similar, puteți folosi aceeași sintaxă pentru a inițializa o matrice multidimensională.
int [ , ] myMultiDimensionalArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Iată un exemplu de cod care utilizează sintaxa inițializatorului pentru a inițializa o matrice 1D și 2D în C#:
folosind System;
matrice de clasă
{
gol static Principal ( şir [ ] argumente )
{
// Inițializarea unui tablou 1D utilizând sintaxa inițializatorului
int [ ] matrice1D = { 1 , 2 , 3 , 4 , 5 } ;
Consolă.WriteLine ( „Valori în array1D:” ) ;
pentru ( int i = 0 ; i < array1D.Lungime; i++ ) {
Consolă.WriteLine ( matrice1D [ i ] ) ;
}
// Inițializarea unei matrice 2D utilizând sintaxa inițializatorului
int [ , ] array2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Consolă.WriteLine ( „Valori în array2D:” ) ;
pentru ( int i = 0 ; i < array2D.GetLength ( 0 ) ; i++ ) {
pentru ( int j = 0 ; j < array2D.GetLength ( 1 ) ; j++ ) {
Consolă.WriteLine ( „({0}, {1}): {2}” , i, j, array2D [ eu, j ] ) ;
}
}
}
}
În acest cod, folosim sintaxa de inițializare pentru a inițializa un tablou întreg unidimensional numit array1D cu valorile 1, 2, 3, 4 și 5.
De asemenea, folosim sintaxa de inițializare pentru a inițializa o matrice întregă bidimensională numită array2D cu valorile {1, 2}, {3, 4} și {5, 6}.
Apoi folosim bucle suplimentare pentru a itera fiecare element al fiecărei matrice și a imprima valoarea acestuia pe consolă.
2: Inițializarea matricelor folosind noul cuvânt cheie
O metodă suplimentară de inițializare a unei matrice implică utilizarea nou cuvânt cheie. Aceasta implică specificarea dimensiunii matricei între paranteze drepte, urmată de noul cuvânt cheie și apoi de tipul de date al elementelor matricei. De exemplu:
int [ ] numere = new int [ 5 ] ;
Acest cod creează o matrice cu numere întregi denumite numere cu dimensiunea 5 și inițializează toate elementele la valoarea lor implicită, care este 0 pentru matricele întregi.
Iată sintaxa pentru inițializarea unei matrice multidimensionale folosind noul cuvânt cheie în C#:
< tip > [ , ] < arrayName > = nou < tip > [ < lungime1 > , < lungimea 2 > ,... ] { { < initialValues > } } ;
În această sintaxă,
Iată un exemplu despre cum să utilizați această sintaxă pentru a inițializa o matrice întregă bidimensională:
int [ , ] myArray = new int [ 3 , 2 ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
În acest exemplu, inițializam o matrice de numere întregi 2d numită myArray cu 3 rânduri și 2 coloane folosind noul cuvânt cheie. De asemenea, oferim valori inițiale pentru fiecare element al matricei folosind sintaxa duble acolade. Valorile sunt {1, 2}, {3, 4} și {5, 6}, corespunzătoare elementelor din fiecare rând.
Iată un exemplu despre cum să utilizați noul cuvânt cheie pentru a inițializa atât o matrice unidimensională, cât și una bidimensională în C#, împreună cu codul pentru a tipări valorile din fiecare matrice:
folosind System;matrice de clasă
{
gol static Principal ( şir [ ] argumente )
{
// Inițializarea a 1 -matrice dimensională
int [ ] myArray1D = nou int [ ] { 1 , 2 , 3 , 4 , 5 } ;
Consolă.WriteLine ( „Valori în myArray1D:” ) ;
pentru ( int i = 0 ; i < myArray1D.Length; i++ )
{
Consolă.WriteLine ( myArray1D [ i ] ) ;
}
// Inițializarea a 2 -matrice dimensională
int [ , ] myArray2D = nou int [ , ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Consolă.WriteLine ( „Valori în myArray2D:” ) ;
pentru ( int i = 0 ; i < myArray2D.GetLength ( 0 ) ; i++ )
{
pentru ( int j = 0 ; j < myArray2D.GetLength ( 1 ) ; j++ )
{
Consolă.WriteLine ( „({0}, {1}): {2}” , i, j, myArray2D [ eu, j ] ) ;
}
}
}
}
În acest cod, folosim noul cuvânt cheie pentru a inițializa o matrice de numere întregi unidimensionale numită myArray1D cu valorile 1, 2, 3, 4 și 5 și o matrice întregă bidimensională numită myArray2D cu valorile {1, 2}, {3, 4} și {5, 6}.
Folosim apoi buclele for pentru a itera fiecare element al fiecărei matrice și a imprima valoarea acestuia pe consolă. Rețineți că pentru matricea bidimensională, folosim GetLength() pentru a determina numărul de rânduri și coloane și folosind bucle imbricate for pentru a itera prin fiecare element.
3: Inițializarea tablourilor folosind bucle
Arrayurile pot fi, de asemenea, inițializate folosind bucle. O abordare este să folosiți o buclă for, care vă permite să iterați prin matrice și să atribuiți valori fiecărui element.
int [ ] numere = new int [ 5 ] ;pentru ( int i = 0 ; i < numere.Lungime; i++ )
{
numere [ i ] = i + 1 ;
}
Acest cod creează o matrice de numere întregi denumite numere cu dimensiunea de 5 și atribuie fiecărui element o valoare egală cu indexul său plus 1. Iată un exemplu despre cum să inițializați o matrice de numere întregi bidimensionale în C# folosind bucle:
pentru ( int i = 0 ; i < 3 ; i++ )
{
pentru ( int j = 0 ; j < 2 ; j++ )
{
myArray [ eu, j ] = i + j;
}
}
În acest exemplu, folosim bucle imbricate for pentru a itera prin fiecare element al unui tablou întreg bidimensional numit myArray , care are 3 rânduri și 2 coloane. Pentru fiecare element, îi setăm valoarea la suma indicilor de rând și coloane folosind expresia i + j.
Iată un exemplu de utilizare a buclelor pentru a inițializa atât o matrice unidimensională, cât și una bidimensională în C#, împreună cu codul pentru a tipări valorile din fiecare matrice:
folosind System;matrice de clasă
{
gol static Principal ( şir [ ] argumente )
{
// Inițializarea a 1 -matrice dimensională folosind o buclă
int [ ] myArray1D = nou int [ 5 ] ;
pentru ( int i = 0 ; i < myArray1D.Length; i++ )
{
myArray1D [ i ] = i + 1 ;
}
Consolă.WriteLine ( „Valori în myArray1D:” ) ;
pentru ( int i = 0 ; i < myArray1D.Length; i++ )
{
Consolă.WriteLine ( myArray1D [ i ] ) ;
}
// Inițializarea a 2 -matrice dimensională folosind bucle imbricate
int [ , ] myArray2D = nou int [ 3 , 2 ] ;
pentru ( int i = 0 ; i < 3 ; i++ )
{
pentru ( int j = 0 ; j < 2 ; j++ )
{
myArray2D [ eu, j ] = i + j;
}
}
Consolă.WriteLine ( „Valori în myArray2D:” ) ;
pentru ( int i = 0 ; i < 3 ; i++ )
{
pentru ( int j = 0 ; j < 2 ; j++ )
{
Consolă.WriteLine ( „({0}, {1}): {2}” , i, j, myArray2D [ eu, j ] ) ;
}
}
}
}
În acest cod, folosim o buclă for pentru a inițializa o matrice întregă bidimensională numită myArray1D cu valorile 1, 2, 3, 4 și 5. De asemenea, folosim bucle imbricate for pentru a inițializa o matrice întregă bidimensională numită myArray2D cu valorile {0, 1}, {1, 2} și {2, 3} folosind expresia i + j.
Apoi folosiți bucle suplimentare pentru a itera fiecare element al fiecărei matrice și a imprima valoarea acestuia pe consolă.
4: Inițializarea matricelor folosind Array.Copy()
O abordare alternativă pentru inițializarea unui tablou implică utilizarea funcției Array.Copy(). Aceasta implică crearea unei matrice sursă cu elementele dorite și apoi copiarea lor într-o matrice țintă. De exemplu:
int [ ] sursă = { 1 , 2 , 3 , 4 , 5 } ;int [ ] target = new int [ sursa.Lungimea ] ;
Array.Copy ( sursă , tinta, sursa.Lungimea ) ;
Acest cod creează o matrice de întregi numită sursă cu valorile de la 1 la 5, creează o nouă matrice de întregi numită țintă cu aceeași dimensiune ca sursă și apoi copiază elementele de la sursă la țintă.
Permiteți-mi să vă prezint un exemplu care demonstrează utilizarea Array.Copy pentru a inițializa o matrice întregă bidimensională în C#:
int [ , ] sourceArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;int [ , ] destinationArray = nou int [ 3 , 2 ] ;
Array.Copy ( sourceArray, destinationArray, sourceArray.Length ) ;
În acest exemplu, avem un tablou întreg bidimensional numit sourceArray cu 3 rânduri și 2 coloane. Noi folosim Array.Copy() pentru a copia conținutul sourceArray într-o nouă matrice de numere întregi bidimensionale numită destinationArray, care are, de asemenea, 3 rânduri și 2 coloane.
The Array.Copy() metoda ia trei argumente : cel matrice sursă , cel matrice de destinație , si lungime a datelor de copiat. În acest caz, copiem întregul conținut al sourceArray în destinationArray , așa că trecem sourceArray.Length ca al treilea argument.
Rețineți că puteți utiliza Array.Copy() pentru a inițializa matrice cu orice număr de dimensiuni, atâta timp cât matricele sursă și destinație au același număr de dimensiuni și aceeași dimensiune în fiecare dimensiune.
De asemenea, rețineți că Array.Copy() realizează o copie superficială a matricei sursă, ceea ce înseamnă că dacă tabloul sursă conține tipuri de referință, referințele vor fi copiate, dar obiectele în sine nu vor fi duplicate.
Iată codul complet pe care îl folosește Array.Copy() funcția de inițializare a matricei în C#:
folosind System;matrice de clasă
{
gol static Principal ( şir [ ] argumente )
{
// Inițializarea a 1 -matrice dimensională folosind Array.Copy
int [ ] sursăArray1D = { 1 , 2 , 3 , 4 , 5 } ;
int [ ] destinationArray1D = nou int [ 5 ] ;
Array.Copy ( sourceArray1D, destinationArray1D, sourceArray1D.Length ) ;
Consolă.WriteLine ( „Valori în destinationArray1D:” ) ;
pentru ( int i = 0 ; i < destinationArray1D.Length; i++ ) {
Consolă.WriteLine ( destinationArray1D [ i ] ) ;
}
// Inițializarea a 2 -matrice dimensională folosind Array.Copy
int [ , ] sourceArray2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
int [ , ] destinationArray2D = nou int [ 3 , 2 ] ;
Array.Copy ( sourceArray2D, destinationArray2D, sourceArray2D.Length ) ;
Consolă.WriteLine ( „Valori în destinationArray2D:” ) ;
pentru ( int i = 0 ; i < destinationArray2D.GetLength ( 0 ) ; i++ ) {
pentru ( int j = 0 ; j < destinationArray2D.GetLength ( 1 ) ; j++ ) {
Consolă.WriteLine ( „({0}, {1}): {2}” , i, j, destinationArray2D [ eu, j ] ) ;
}
}
}
}
În acest cod, folosim Array.Copy() pentru a inițializa un tablou întreg unidimensional numit destinationArray1D cu valorile 1, 2, 3, 4 și 5 dintr-o matrice sursă numită sourceArray1D.
De asemenea, folosim Array.Copy() pentru a inițializa un tablou întreg bidimensional numit destinationArray2D cu valorile {1, 2}, {3, 4} și {5, 6} dintr-o matrice sursă numită sourceArray2D.
Apoi folosim bucle suplimentare pentru a itera fiecare element al fiecărei matrice și a imprima valoarea acestuia pe consolă.
Concluzie
În acest articol, am explorat diferite moduri de inițializare a matricelor în C#. Am acoperit sintaxa de inițializare a matricei, folosind noul cuvânt cheie, inițialând matrice folosind bucle și folosind metoda Array.Copy(). În funcție de cazul specific de utilizare, fiecare dintre aceste metode are propriul său set de avantaje și dezavantaje. Familiarizarea cu aceste abordări diverse vă va permite să selectați cea mai potrivită pentru cerințele dumneavoastră particulare.