In C# dienen arrays als containers voor het opslaan van elementen van hetzelfde gegevenstype. Bij het maken van een array zijn er meerdere benaderingen om deze met elementen te initialiseren. Dit artikel gaat dieper in op de verschillende methoden voor het initialiseren van arrays in C# en biedt een uitgebreide verkenning van elke benadering.
Methoden om arrays in C# te initialiseren
Arrays zijn een essentiële gegevensstructuur in computerprogrammering waarmee u een verzameling elementen van hetzelfde gegevenstype in aangrenzende geheugenlocaties kunt opslaan en manipuleren. Hier zijn enkele manieren om arrays in C# te initialiseren:
1: Arrays initialiseren met behulp van de Array Initializer-syntaxis
De eenvoudigste manier om een array te initialiseren is door gebruik te maken van de array-initialisatiesyntaxis, aangezien hierbij de array-elementen tussen accolades worden geplaatst, gescheiden door komma's, bijvoorbeeld:
int [ ] nummers = { 1 , 2 , 3 , 4 , 5 } ;
In deze code wordt een integer-array met de naam 'numbers' gemaakt en geïnitialiseerd met de waarden 1 tot en met 5. Op dezelfde manier kunt u dezelfde syntaxis gebruiken om een multidimensionale array te initialiseren.
int [ , ] mijnMultiDimensionalArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Hier is een voorbeeldcode die de initialisatiesyntaxis gebruikt om een 1D- en 2D-array in C# te initialiseren:
systeem gebruiken;
klassenarray
{
statische leegte Main ( snaar [ ] argumenten )
{
// Een 1D-array initialiseren met behulp van de initialisatiesyntaxis
int [ ] matrix1D = { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'Waarden in array1D:' ) ;
voor ( int ik = 0 ; i < array1D.Lengte; ik++ ) {
Console.WriteLine ( matrix1D [ i ] ) ;
}
// Een 2D-array initialiseren met behulp van de initialisatiesyntaxis
int [ , ] matrix2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'Waarden in array2D:' ) ;
voor ( int ik = 0 ; i < array2D.GetLength ( 0 ) ; ik++ ) {
voor ( int j = 0 ; J < array2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , ik, j, array2D [ ik, j ] ) ;
}
}
}
}
In deze code gebruiken we de initialisatiesyntaxis om een 1-dimensionale integer-array genaamd array1D te initialiseren met de waarden 1, 2, 3, 4 en 5.
We gebruiken ook de initializer-syntaxis om een 2-dimensionale integer-array met de naam array2D te initialiseren met de waarden {1, 2}, {3, 4} en {5, 6}.
We gebruiken dan extra for-lussen om door elk element van elke array te itereren en de waarde ervan naar de console af te drukken.
2: Arrays initialiseren met het nieuwe trefwoord
Een aanvullende methode voor het initialiseren van een array is het gebruik van de extensie nieuw trefwoord. Dit omvat het specificeren van de grootte van de array tussen vierkante haken, gevolgd door het nieuwe trefwoord en vervolgens het gegevenstype van de array-elementen. Bijvoorbeeld:
int [ ] getallen = nieuwe int [ 5 ] ;
Deze code maakt een integer-array met de naam numbers met een grootte van 5 en initialiseert alle elementen naar hun standaardwaarde, die 0 is voor integer-arrays.
Dit is de syntaxis voor het initialiseren van een multidimensionale array met behulp van het nieuwe trefwoord in C#:
< type > [ , ] < arrayNaam > = nieuw < type > [ < lengte1 > , < lengte2 > , ... ] { { < beginwaarden > } } ;
In deze syntaxis is
Hier is een voorbeeld van hoe u deze syntaxis kunt gebruiken om een 2-dimensionale integer-array te initialiseren:
int [ , ] myArray = nieuwe int [ 3 , 2 ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
In dit voorbeeld initialiseren we een 2d integer-array met de naam myArray met 3 rijen en 2 kolommen met het nieuwe trefwoord. We geven ook beginwaarden voor elk element van de array met behulp van de syntaxis van dubbele accolades. De waarden zijn {1, 2}, {3, 4} en {5, 6}, overeenkomend met de elementen in elke rij.
Hier is een voorbeeld van hoe u het nieuwe trefwoord kunt gebruiken om zowel een 1-dimensionale als een 2-dimensionale array in C# te initialiseren, samen met code om de waarden in elke array af te drukken:
systeem gebruiken;klassenarray
{
statische leegte Main ( snaar [ ] argumenten )
{
// Initialisatie van een 1 -dimensionale reeks
int [ ] myArray1D = nieuwe int [ ] { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'Waarden in myArray1D:' ) ;
voor ( int ik = 0 ; i < myArray1D.Lengte; ik++ )
{
Console.WriteLine ( mijnArray1D [ i ] ) ;
}
// Initialisatie van een 2 -dimensionale reeks
int [ , ] myArray2D = nieuwe int [ , ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'Waarden in myArray2D:' ) ;
voor ( int ik = 0 ; i < myArray2D.GetLength ( 0 ) ; ik++ )
{
voor ( int j = 0 ; J < myArray2D.GetLength ( 1 ) ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , ik, j, mijnArray2D [ ik, j ] ) ;
}
}
}
}
In deze code gebruiken we het nieuwe sleutelwoord om een eendimensionale integer-array genaamd te initialiseren mijnArray1D met de waarden 1, 2, 3, 4 en 5, en een 2-dimensionale array met gehele getallen genaamd mijnArray2D met de waarden {1, 2}, {3, 4} en {5, 6}.
We gebruiken dan for-lussen om door elk element van elke array te itereren en de waarde ervan naar de console af te drukken. Merk op dat we voor de 2-dimensionale array gebruiken GetLengte() om het aantal rijen en kolommen te bepalen, en het gebruik van geneste for-lussen om elk element te doorlopen.
3: Arrays initialiseren met behulp van lussen
Arrays kunnen ook worden geïnitialiseerd met behulp van lussen. Een benadering is het gebruik van een for-lus, waarmee u door de array kunt itereren en waarden aan elk element kunt toewijzen.
int [ ] getallen = nieuwe int [ 5 ] ;voor ( int ik = 0 ; i < nummers.Lengte; ik++ )
{
nummers [ i ] = ik + 1 ;
}
Deze code maakt een integer-array met de naam numbers met een grootte van 5 en kent aan elk element een waarde toe die gelijk is aan de index plus 1. Hier is een voorbeeld van hoe een 2-dimensionale integer-array in C# geïnitialiseerd kan worden met loops:
voor ( int ik = 0 ; i < 3 ; ik++ )
{
voor ( int j = 0 ; J < 2 ; j++ )
{
mijnArray [ ik, j ] = ik + j;
}
}
In dit voorbeeld gebruiken we geneste for-lussen om door elk element van een 2-dimensionale integer-array genaamd mijnArray , die 3 rijen en 2 kolommen heeft. Voor elk element stellen we de waarde in op de som van de rij- en kolomindexen met behulp van de uitdrukking i + j.
Hier is een voorbeeld van het gebruik van lussen om zowel een 1-dimensionale als een 2-dimensionale array in C# te initialiseren, samen met code om de waarden in elke array af te drukken:
systeem gebruiken;klassenarray
{
statische leegte Main ( snaar [ ] argumenten )
{
// Initialisatie van een 1 -dimensionale array met behulp van een lus
int [ ] myArray1D = nieuwe int [ 5 ] ;
voor ( int ik = 0 ; i < myArray1D.Lengte; ik++ )
{
mijnArray1D [ i ] = ik + 1 ;
}
Console.WriteLine ( 'Waarden in myArray1D:' ) ;
voor ( int ik = 0 ; i < myArray1D.Lengte; ik++ )
{
Console.WriteLine ( mijnArray1D [ i ] ) ;
}
// Initialisatie van een 2 -dimensionale array met geneste lussen
int [ , ] myArray2D = nieuwe int [ 3 , 2 ] ;
voor ( int ik = 0 ; i < 3 ; ik++ )
{
voor ( int j = 0 ; J < 2 ; j++ )
{
mijnArray2D [ ik, j ] = ik + j;
}
}
Console.WriteLine ( 'Waarden in myArray2D:' ) ;
voor ( int ik = 0 ; i < 3 ; ik++ )
{
voor ( int j = 0 ; J < 2 ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , ik, j, mijnArray2D [ ik, j ] ) ;
}
}
}
}
In deze code gebruiken we een for-lus om een 1-dimensionale integer-array genaamd myArray1D te initialiseren met de waarden 1, 2, 3, 4 en 5. We gebruiken ook geneste for-lussen om een 2-dimensionale integer-array genaamd myArray2D met de waarden {0, 1}, {1, 2} en {2, 3} met de uitdrukking i + j.
Gebruik vervolgens extra for-lussen om elk element van elke array te doorlopen en de waarde ervan naar de console af te drukken.
4: Arrays initialiseren met behulp van Array.Copy()
Een alternatieve benadering voor het initialiseren van een array is het gebruik van de functie Array.Copy(). Dit omvat het maken van een bronarray met de gewenste elementen en deze vervolgens kopiëren naar een doelarray. Bijvoorbeeld:
int [ ] bron = { 1 , 2 , 3 , 4 , 5 } ;int [ ] doel = nieuwe int [ bron.Lengte ] ;
Array.Kopieer ( bron , doel, bron. Lengte ) ;
Deze code maakt een integer-array met de naam source met de waarden 1 tot en met 5, maakt een nieuwe integer-array met de naam target met dezelfde grootte als source en kopieert vervolgens de elementen van source naar target.
Sta me toe een voorbeeld te geven dat het gebruik van Array.Copy demonstreert om een tweedimensionale integer-array in C# te initialiseren:
int [ , ] bronarray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;int [ , ] destinationArray = nieuwe int [ 3 , 2 ] ;
Array.Kopieer ( sourceArray, destinationArray, sourceArray.Length ) ;
In dit voorbeeld hebben we een 2-dimensionale integer-array genaamd bronarray met 3 rijen en 2 kolommen. Wij gebruiken Array.Copy() om de inhoud van sourceArray te kopiëren naar een nieuwe 2-dimensionale array met gehele getallen, genaamd destinationArray, die ook 3 rijen en 2 kolommen heeft.
De Array.Copy() methode duurt drie argumenten : de bronarray , de bestemmingsmatrix , en de lengte van de te kopiëren gegevens. In dit geval kopiëren we de volledige inhoud van bronarray naar binnen bestemmingArray , dus we passeren sourceArray.Length als derde argument.
Merk op dat u kunt gebruiken Array.Copy() om arrays met een willekeurig aantal dimensies te initialiseren, zolang de bron- en doelarrays hetzelfde aantal dimensies en dezelfde grootte in elke dimensie hebben.
Houd daar ook rekening mee Array.Copy() voert een ondiepe kopie uit van de bronarray, wat betekent dat als de bronarray referentietypen bevat, de referenties worden gekopieerd, maar de objecten zelf niet worden gedupliceerd.
Hier is de volledige code die gebruikt Array.Copy() functie om de array in C# te initialiseren:
systeem gebruiken;klassenarray
{
statische leegte Main ( snaar [ ] argumenten )
{
// Initialisatie van een 1 -dimensionale array met behulp van Array.Copy
int [ ] bronArray1D = { 1 , 2 , 3 , 4 , 5 } ;
int [ ] destinationArray1D = nieuwe int [ 5 ] ;
Array.Kopieer ( sourceArray1D, destinationArray1D, sourceArray1D.Length ) ;
Console.WriteLine ( 'Waarden in destinationArray1D:' ) ;
voor ( int ik = 0 ; i < destinationArray1D.Length; ik++ ) {
Console.WriteLine ( bestemmingArray1D [ i ] ) ;
}
// Initialisatie van een 2 -dimensionale array met behulp van Array.Copy
int [ , ] bronArray2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
int [ , ] destinationArray2D = nieuwe int [ 3 , 2 ] ;
Array.Kopieer ( sourceArray2D, destinationArray2D, sourceArray2D.Length ) ;
Console.WriteLine ( 'Waarden in destinationArray2D:' ) ;
voor ( int ik = 0 ; i < destinationArray2D.GetLength ( 0 ) ; ik++ ) {
voor ( int j = 0 ; J < destinationArray2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, bestemmingArray2D [ ik, j ] ) ;
}
}
}
}
In deze code gebruiken we Array.Copy() om een 1-dimensionale array met gehele getallen genaamd destinationArray1D te initialiseren met de waarden 1, 2, 3, 4 en 5 uit een bronarray genaamd sourceArray1D.
We gebruiken ook Array.Copy() om een 2-dimensionale array met gehele getallen genaamd destinationArray2D te initialiseren met de waarden {1, 2}, {3, 4} en {5, 6} uit een bronarray genaamd sourceArray2D.
We gebruiken dan extra for-lussen om door elk element van elke array te itereren en de waarde ervan naar de console af te drukken.
Conclusie
In dit artikel hebben we verschillende manieren onderzocht om arrays in C# te initialiseren. We hebben de syntaxis van de array-initialisatie behandeld, waarbij we het nieuwe sleutelwoord gebruikten, arrays initialiseerden met behulp van lussen en de methode Array.Copy() gebruikten. Afhankelijk van de specifieke use-case heeft elk van deze methoden zijn eigen voor- en nadelen. Door uzelf vertrouwd te maken met deze verschillende benaderingen, kunt u de meest geschikte benadering voor uw specifieke vereisten selecteren.