En C#, les matrius serveixen com a contenidors per emmagatzemar elements del mateix tipus de dades. Quan es crea una matriu, hi ha diversos enfocaments per inicialitzar-la amb elements. Aquest article aprofundeix en els diferents mètodes d'inicialització de matrius en C#, proporcionant una exploració completa de cada enfocament.
Mètodes per inicialitzar matrius en C#
Les matrius són una estructura de dades essencial en la programació d'ordinadors que permet emmagatzemar i manipular una col·lecció d'elements del mateix tipus de dades en ubicacions de memòria contigües. Aquí hi ha algunes maneres d'inicialitzar matrius en C#:
1: Inicialització de matrius utilitzant la sintaxi de l'inicialitzador de matrius
L'enfocament més senzill per inicialitzar una matriu és utilitzar la sintaxi de l'inicialitzador de matriu, ja que això implica incloure els elements de la matriu entre claus, separats per comes, per exemple:
int [ ] nombres = { 1 , 2 , 3 , 4 , 5 } ;
En aquest codi, es crea una matriu d'enters anomenada 'nombres' i s'inicia amb els valors de l'1 al 5. De la mateixa manera, podeu utilitzar la mateixa sintaxi per inicialitzar una matriu multidimensional.
int [ , ] myMultiDimensionalArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Aquí hi ha un exemple de codi que utilitza la sintaxi de l'inicialitzador per inicialitzar una matriu 1D i 2D en C#:
utilitzant el sistema;
matriu de classes
{
buit estàtic Principal ( corda [ ] args )
{
// Inicialització d'una matriu 1D utilitzant la sintaxi de l'inicialitzador
int [ ] matriu1D = { 1 , 2 , 3 , 4 , 5 } ;
Consola.WriteLine ( 'Valors a array1D:' ) ;
per ( int i = 0 ; i < array1D.Longitud; i++ ) {
Consola.WriteLine ( matriu 1D [ i ] ) ;
}
// Inicialització d'una matriu 2D utilitzant la sintaxi de l'inicialitzador
int [ , ] array2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Consola.WriteLine ( 'Valors a array2D:' ) ;
per ( int i = 0 ; i < array2D.GetLength ( 0 ) ; i++ ) {
per ( int j = 0 ; j < array2D.GetLength ( 1 ) ; j++ ) {
Consola.WriteLine ( '({0}, {1}): {2}' , i, j, array2D [ i, j ] ) ;
}
}
}
}
En aquest codi, estem utilitzant la sintaxi de l'inicialitzador per inicialitzar una matriu d'enters unidimensionals anomenada array1D amb els valors 1, 2, 3, 4 i 5.
També estem utilitzant la sintaxi de l'inicialitzador per inicialitzar una matriu d'enters bidimensional anomenada array2D amb els valors {1, 2}, {3, 4} i {5, 6}.
A continuació, utilitzem bucles for addicionals per iterar per cada element de cada matriu i imprimir el seu valor a la consola.
2: Inicialització de matrius amb la nova paraula clau
Un mètode addicional per inicialitzar una matriu consisteix a utilitzar el fitxer nou paraula clau. Això implica especificar la mida de la matriu entre claudàtors, seguida de la paraula clau nova i després el tipus de dades dels elements de la matriu. Per exemple:
int [ ] nombres = nou int [ 5 ] ;
Aquest codi crea una matriu d'enters anomenada nombres amb una mida de 5 i inicialitza tots els elements al seu valor predeterminat, que és 0 per a matrius d'entiers.
Aquí teniu la sintaxi per inicialitzar una matriu multidimensional mitjançant la nova paraula clau en C#:
< tipus > [ , ] < arrayName > = nou < tipus > [ < longitud 1 > , < longitud 2 > , ... ] { { < valors inicials > } } ;
En aquesta sintaxi,
Aquí teniu un exemple de com utilitzar aquesta sintaxi per inicialitzar una matriu d'enters bidimensionals:
int [ , ] myArray = nou int [ 3 , 2 ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
En aquest exemple, estem inicialitzant una matriu d'enters 2D anomenada myArray amb 3 files i 2 columnes utilitzant la paraula clau nova. També proporcionem valors inicials per a cada element de la matriu mitjançant la sintaxi de doble claus. Els valors són {1, 2}, {3, 4} i {5, 6}, corresponents als elements de cada fila.
Aquí teniu un exemple de com utilitzar la paraula clau nova per inicialitzar tant una matriu unidimensional com una bidimensional en C#, juntament amb el codi per imprimir els valors de cada matriu:
utilitzant el sistema;matriu de classes
{
buit estàtic Principal ( corda [ ] args )
{
// Inicialització a 1 - matriu dimensional
int [ ] myArray1D = nou int [ ] { 1 , 2 , 3 , 4 , 5 } ;
Consola.WriteLine ( 'Valors a myArray1D:' ) ;
per ( int i = 0 ; i < myArray1D.Length; i++ )
{
Consola.WriteLine ( myArray1D [ i ] ) ;
}
// Inicialització a 2 - matriu dimensional
int [ , ] myArray2D = nou int [ , ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Consola.WriteLine ( 'Valors a myArray2D:' ) ;
per ( int i = 0 ; i < myArray2D.GetLength ( 0 ) ; i++ )
{
per ( int j = 0 ; j < myArray2D.GetLength ( 1 ) ; j++ )
{
Consola.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ i, j ] ) ;
}
}
}
}
En aquest codi, estem utilitzant la paraula clau nova per inicialitzar una matriu enter unidimensional anomenada myArray1D amb els valors 1, 2, 3, 4 i 5, i una matriu sencer de dues dimensions anomenada myArray2D amb els valors {1, 2}, {3, 4} i {5, 6}.
A continuació, utilitzem for loops per iterar per cada element de cada matriu i imprimir el seu valor a la consola. Tingueu en compte que per a la matriu bidimensional, estem utilitzant GetLength() per determinar el nombre de files i columnes, i utilitzant bucles imbricats per a iterar per cada element.
3: Inicialització de matrius mitjançant bucles
Les matrius també es poden inicialitzar mitjançant bucles. Un enfocament és utilitzar un bucle for, que us permet iterar per la matriu i assignar valors a cada element.
int [ ] nombres = nou int [ 5 ] ;per ( int i = 0 ; i < nombres.Llargada; i++ )
{
nombres [ i ] = i + 1 ;
}
Aquest codi crea una matriu d'enters anomenada nombres amb una mida de 5 i assigna a cada element un valor igual al seu índex més 1. Aquí teniu un exemple de com inicialitzar una matriu d'enters bidimensionals en C# mitjançant bucles:
per ( int i = 0 ; i < 3 ; i++ )
{
per ( int j = 0 ; j < 2 ; j++ )
{
myArray [ i, j ] = i + j;
}
}
En aquest exemple, estem utilitzant bucles imbricats per a iterar a través de cada element d'una matriu enter bidimensional anomenada myArray , que té 3 files i 2 columnes. Per a cada element, estem establint el seu valor a la suma dels seus índexs de files i columnes mitjançant l'expressió i + j.
Aquí teniu un exemple de com utilitzar bucles per inicialitzar una matriu unidimensional i una bidimensional en C#, juntament amb codi per imprimir els valors de cada matriu:
utilitzant el sistema;matriu de classes
{
buit estàtic Principal ( corda [ ] args )
{
// Inicialització a 1 matriu dimensional utilitzant un bucle
int [ ] myArray1D = nou int [ 5 ] ;
per ( int i = 0 ; i < myArray1D.Length; i++ )
{
myArray1D [ i ] = i + 1 ;
}
Consola.WriteLine ( 'Valors a myArray1D:' ) ;
per ( int i = 0 ; i < myArray1D.Length; i++ )
{
Consola.WriteLine ( myArray1D [ i ] ) ;
}
// Inicialització a 2 - matriu dimensional utilitzant bucles imbricats
int [ , ] myArray2D = nou int [ 3 , 2 ] ;
per ( int i = 0 ; i < 3 ; i++ )
{
per ( int j = 0 ; j < 2 ; j++ )
{
myArray2D [ i, j ] = i + j;
}
}
Consola.WriteLine ( 'Valors a myArray2D:' ) ;
per ( int i = 0 ; i < 3 ; i++ )
{
per ( int j = 0 ; j < 2 ; j++ )
{
Consola.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ i, j ] ) ;
}
}
}
}
En aquest codi, estem utilitzant un bucle for per inicialitzar una matriu d'enters unidimensional anomenada myArray1D amb els valors 1, 2, 3, 4 i 5. També estem utilitzant bucles for imbricats per inicialitzar una matriu d'enters bidimensionals anomenada myArray2D amb els valors {0, 1}, {1, 2} i {2, 3} utilitzant l'expressió i + j.
A continuació, utilitzeu bucles for addicionals per iterar per cada element de cada matriu i imprimir el seu valor a la consola.
4: Inicialització de matrius amb Array.Copy()
Un enfocament alternatiu per inicialitzar una matriu implica utilitzar la funció Array.Copy(). Això implica crear una matriu d'origen amb els elements desitjats i després copiar-los a una matriu de destinació. Per exemple:
int [ ] font = { 1 , 2 , 3 , 4 , 5 } ;int [ ] target = nou int [ font.Llargada ] ;
Array.Copy ( font , objectiu, font.Longitud ) ;
Aquest codi crea una matriu d'enters anomenada font amb els valors de l'1 al 5, crea una nova matriu d'enters anomenada target amb la mateixa mida que la font i després copia els elements de la font a la destinació.
Permeteu-me presentar un exemple que demostra la utilització de Array.Copy per inicialitzar una matriu enter bidimensional en C#:
int [ , ] sourceArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;int [ , ] destinationArray = nou int [ 3 , 2 ] ;
Array.Copy ( sourceArray, destinationArray, sourceArray.Length ) ;
En aquest exemple, tenim una matriu d'enters bidimensional anomenada sourceArray amb 3 files i 2 columnes. Estem utilitzant Array.Copy() per copiar el contingut de sourceArray en una nova matriu d'enters bidimensional anomenada destinationArray, que també té 3 files i 2 columnes.
El Array.Copy() mètode pren tres arguments : el matriu d'origen , el matriu de destinació , i la llargada de les dades a copiar. En aquest cas, estem copiant tot el contingut de sourceArray a Destinació Array , així que passem sourceArray.Length com a tercer argument.
Tingueu en compte que podeu utilitzar Array.Copy() per inicialitzar matrius amb qualsevol nombre de dimensions, sempre que les matrius d'origen i de destinació tinguin el mateix nombre de dimensions i la mateixa mida a cada dimensió.
A més, tingues en compte que Array.Copy() realitza una còpia superficial de la matriu font, el que significa que si la matriu font conté tipus de referència, les referències es copiaran però els objectes en si no es duplicaran.
Aquí teniu el codi complet que utilitza Array.Copy() funció per inicialitzar la matriu en C#:
utilitzant el sistema;matriu de classes
{
buit estàtic Principal ( corda [ ] args )
{
// Inicialització a 1 matriu -dimensional utilitzant Array.Copy
int [ ] sourceArray1D = { 1 , 2 , 3 , 4 , 5 } ;
int [ ] destinationArray1D = nou int [ 5 ] ;
Array.Copy ( sourceArray1D, destinationArray1D, sourceArray1D.Longitud ) ;
Consola.WriteLine ( 'Valors a destinationArray1D:' ) ;
per ( int i = 0 ; i < destinacióArray1D.Longitud; i++ ) {
Consola.WriteLine ( DestinacióArray1D [ i ] ) ;
}
// Inicialització a 2 matriu -dimensional utilitzant Array.Copy
int [ , ] sourceArray2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
int [ , ] destinationArray2D = nou int [ 3 , 2 ] ;
Array.Copy ( sourceArray2D, destinationArray2D, sourceArray2D.Length ) ;
Consola.WriteLine ( 'Valors a destinationArray2D:' ) ;
per ( int i = 0 ; i < destinationArray2D.GetLength ( 0 ) ; i++ ) {
per ( int j = 0 ; j < destinationArray2D.GetLength ( 1 ) ; j++ ) {
Consola.WriteLine ( '({0}, {1}): {2}' , i, j, destinationArray2D [ i, j ] ) ;
}
}
}
}
En aquest codi, estem utilitzant Array.Copy() per inicialitzar una matriu d'enters unidimensional anomenada destinationArray1D amb els valors 1, 2, 3, 4 i 5 d'una matriu font anomenada sourceArray1D.
També estem utilitzant Array.Copy() per inicialitzar una matriu d'enters bidimensional anomenada destinationArray2D amb els valors {1, 2}, {3, 4} i {5, 6} d'una matriu font anomenada sourceArray2D.
A continuació, utilitzem bucles for addicionals per iterar per cada element de cada matriu i imprimir el seu valor a la consola.
Conclusió
En aquest article, hem explorat diferents maneres d'iniciar matrius en C#. Hem tractat la sintaxi de l'inicialitzador de matrius, utilitzant la paraula clau nova, inicialitzant matrius mitjançant bucles i utilitzant el mètode Array.Copy(). Depenent del cas d'ús específic, cadascun d'aquests mètodes té el seu propi conjunt d'avantatges i desavantatges. Familiaritzar-se amb aquests diversos enfocaments us permetrà seleccionar el més adequat per a les vostres necessitats particulars.