C#-s toimivad massiivid konteineritena sama andmetüübi elementide salvestamiseks. Massiivi loomisel on selle elementidega lähtestamiseks mitu lähenemisviisi. Selles artiklis käsitletakse C# massiivide lähtestamise erinevaid meetodeid, pakkudes iga lähenemisviisi põhjalikku uurimist.
Massiivide initsialiseerimise meetodid C#-s
Massiivid on arvutiprogrammeerimises oluline andmestruktuur, mis võimaldab salvestada ja manipuleerida külgnevates mälukohtades sama andmetüübi elementide kogumit. Siin on mõned viisid massiivide lähtestamiseks C#-s:
1: Massiivide lähtestamine massiivi algataja süntaksi abil
Kõige lihtsam viis massiivi lähtestamiseks on kasutada massiivi initsialiseerija süntaksit, kuna see hõlmab massiivi elementide sulgemist sulgudes, eraldades need näiteks komadega:
int [ ] numbrid = { 1 , 2 , 3 , 4 , 5 } ;
Selles koodis luuakse täisarvu massiiv nimega 'numbrid' ja lähtestatakse väärtustega 1 kuni 5. Samamoodi saate kasutada sama süntaksit mitmemõõtmelise massiivi lähtestamiseks.
int [ , ] myMultiDimensionalArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Siin on näide koodist, mis kasutab 1D ja 2D massiivi lähtestamiseks C# keeles initsialiseerija süntaksit:
süsteemi kasutamine;
klassi massiiv
{
staatiline tühimik Peamine ( string [ ] args )
{
// 1D-massiivi lähtestamine initsialiseerija süntaksi abil
int [ ] massiiv1D = { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'Väärtused massiivi1D-s:' ) ;
jaoks ( int i = 0 ; i < massiiv1D.Pikkus; i++ ) {
Console.WriteLine ( massiiv1D [ i ] ) ;
}
// 2D-massiivi lähtestamine initsialiseerija süntaksi abil
int [ , ] massiiv2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'Väärtused massiivi2D-s:' ) ;
jaoks ( int i = 0 ; i < array2D.GetLength ( 0 ) ; i++ ) {
jaoks ( int j = 0 ; j < array2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, massiiv2D [ i, j ] ) ;
}
}
}
}
Selles koodis kasutame initsialiseerija süntaksit, et lähtestada 1-mõõtmeline täisarvude massiiv nimega massiiv1D väärtustega 1, 2, 3, 4 ja 5.
Samuti kasutame initsialiseerija süntaksit, et lähtestada kahemõõtmeline täisarvude massiiv nimega array2D väärtustega {1, 2}, {3, 4} ja {5, 6}.
Seejärel kasutame iga massiivi iga elemendi läbimiseks ja selle väärtuse konsooli printimiseks täiendavaid silmuseid.
2: Massiivide lähtestamine uue märksõna abil
Täiendav meetod massiivi lähtestamiseks hõlmab uus märksõna. See hõlmab massiivi suuruse määramist nurksulgudes, millele järgneb uus märksõna ja seejärel massiivi elementide andmetüüp. Näiteks:
int [ ] numbrid = uus int [ 5 ] ;
See kood loob täisarvu massiivi nimega numbrid suurusega 5 ja lähtestab kõik elemendid nende vaikeväärtusele, mis on täisarvu massiivide puhul 0.
Siin on süntaks mitmemõõtmelise massiivi lähtestamiseks, kasutades C#-s uut märksõna:
< tüüp > [ , ] < massiiviNimi > = uus < tüüp > [ < pikkus 1 > , < pikkus 2 > , ... ] { { < esialgsed väärtused > } } ;
Selles süntaksis on
Siin on näide selle süntaksi kasutamisest kahemõõtmelise täisarvu massiivi lähtestamiseks:
int [ , ] myArray = uus int [ 3 , 2 ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Selles näites initsialiseerime uue märksõna abil kahemõõtmelise täisarvu massiivi nimega myArray, millel on 3 rida ja 2 veergu. Samuti pakume massiivi iga elemendi jaoks algväärtusi, kasutades topeltkõverate sulgude süntaksit. Väärtused on {1, 2}, {3, 4} ja {5, 6}, mis vastavad iga rea elementidele.
Siin on näide selle kohta, kuidas kasutada uut märksõna nii ühe- kui ka kahemõõtmelise massiivi lähtestamiseks C#-s, koos koodiga iga massiivi väärtuste printimiseks:
süsteemi kasutamine;klassi massiiv
{
staatiline tühimik Peamine ( string [ ] args )
{
// Initsialiseerimine a 1 -mõõtmeline massiiv
int [ ] myArray1D = uus int [ ] { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'Väärtused myArray1D-s:' ) ;
jaoks ( int i = 0 ; i < myArray1D.Length; i++ )
{
Console.WriteLine ( myArray1D [ i ] ) ;
}
// Initsialiseerimine a 2 -mõõtmeline massiiv
int [ , ] myArray2D = uus int [ , ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'Väärtused myArray2D-s:' ) ;
jaoks ( int i = 0 ; i < myArray2D.GetLength ( 0 ) ; i++ )
{
jaoks ( int j = 0 ; j < myArray2D.GetLength ( 1 ) ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ i, j ] ) ;
}
}
}
}
Selles koodis kasutame uut märksõna nimelise ühemõõtmelise täisarvu massiivi initsialiseerimiseks myArray1D väärtustega 1, 2, 3, 4 ja 5 ning kahemõõtmelise täisarvu massiiviga nn. myArray2D väärtustega {1, 2}, {3, 4} ja {5, 6}.
Seejärel kasutame silmuseid iga massiivi iga elemendi läbimiseks ja selle väärtuse konsooli printimiseks. Pange tähele, et kahemõõtmelise massiivi jaoks kasutame GetLength() ridade ja veergude arvu määramiseks ning pesastatud silmuste abil iga elemendi läbimiseks.
3: Massiivide lähtestamine silmuste abil
Massiive saab lähtestada ka silmuste abil. Üks võimalus on kasutada for-silmust, mis võimaldab teil massiivi korrata ja igale elemendile väärtusi määrata.
int [ ] numbrid = uus int [ 5 ] ;jaoks ( int i = 0 ; i < numbrid.Pikkus; i++ )
{
numbrid [ i ] = i + 1 ;
}
See kood loob täisarvude massiivi nimega numbrid suurusega 5 ja määrab igale elemendile väärtuse, mis on võrdne selle indeksiga pluss 1. Siin on näide kahemõõtmelise täisarvu massiivi lähtestamiseks C#-s tsüklite abil:
jaoks ( int i = 0 ; i < 3 ; i++ )
{
jaoks ( int j = 0 ; j < 2 ; j++ )
{
myArray [ i, j ] = i + j;
}
}
Selles näites kasutame pesastatud silmuseid, et itereerida läbi kahemõõtmelise täisarvu massiivi iga elemendi, mida nimetatakse myArray , millel on 3 rida ja 2 veergu. Iga elemendi jaoks määrame selle väärtuse selle rea- ja veeruindeksite summaks, kasutades avaldist i + j.
Siin on näide selle kohta, kuidas kasutada silmuseid nii ühe- kui ka kahemõõtmelise massiivi lähtestamiseks C#-s koos koodiga iga massiivi väärtuste printimiseks:
süsteemi kasutamine;klassi massiiv
{
staatiline tühimik Peamine ( string [ ] args )
{
// Initsialiseerimine a 1 -mõõtmeline massiiv, kasutades silmust
int [ ] myArray1D = uus int [ 5 ] ;
jaoks ( int i = 0 ; i < myArray1D.Length; i++ )
{
myArray1D [ i ] = i + 1 ;
}
Console.WriteLine ( 'Väärtused myArray1D-s:' ) ;
jaoks ( int i = 0 ; i < myArray1D.Length; i++ )
{
Console.WriteLine ( myArray1D [ i ] ) ;
}
// Initsialiseerimine a 2 -mõõtmeline massiiv, mis kasutab pesastatud silmuseid
int [ , ] myArray2D = uus int [ 3 , 2 ] ;
jaoks ( int i = 0 ; i < 3 ; i++ )
{
jaoks ( int j = 0 ; j < 2 ; j++ )
{
myArray2D [ i, j ] = i + j;
}
}
Console.WriteLine ( 'Väärtused myArray2D-s:' ) ;
jaoks ( int i = 0 ; i < 3 ; i++ )
{
jaoks ( int j = 0 ; j < 2 ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ i, j ] ) ;
}
}
}
}
Selles koodis kasutame tsüklit for, et lähtestada 1-mõõtmeline täisarvude massiiv nimega myArray1D väärtustega 1, 2, 3, 4 ja 5. Samuti kasutame pesastatud silmuseid kahemõõtmelise täisarvu massiivi, mida nimetatakse myArray2D väärtustega {0, 1}, {1, 2} ja {2, 3}, kasutades avaldist i + j.
Seejärel kasutage täiendavaid silmuseid iga massiivi iga elemendi läbimiseks ja selle väärtuse konsooli printimiseks.
4: Massiivide lähtestamine, kasutades funktsiooni Array.Copy()
Alternatiivne lähenemisviis massiivi lähtestamiseks hõlmab funktsiooni Array.Copy() kasutamist. See hõlmab soovitud elementidega lähtemassiivi loomist ja seejärel nende kopeerimist sihtmassiivi. Näiteks:
int [ ] allikas = { 1 , 2 , 3 , 4 , 5 } ;int [ ] sihtmärk = uus int [ allikas.Pikkus ] ;
Array.Copy ( allikas , sihtmärk, allikas.Pikkus ) ;
See kood loob täisarvu massiivi nimega allikas väärtustega 1 kuni 5, loob uue täisarvu massiivi nimega siht, mille suurus on sama suur kui allikas, ja kopeerib seejärel elemendid allikast sihtmärki.
Lubage mul esitada näide, mis demonstreerib Array.Copy kasutamist kahemõõtmelise täisarvu massiivi lähtestamiseks C# keeles:
int [ , ] sourceArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;int [ , ] targetArray = uus int [ 3 , 2 ] ;
Array.Copy ( sourceArray, destinationArray, sourceArray.Length ) ;
Selles näites on meil kahemõõtmeline täisarvu massiiv nimega sourceArray 3 rea ja 2 veeruga. Me kasutame Array.Copy() lähtearray sisu kopeerimiseks uude 2-mõõtmelisse täisarvu massiivi nimega destinationArray, millel on samuti 3 rida ja 2 veergu.
The Array.Copy() meetod võtab kolm argumenti : allika massiiv , sihtkoha massiiv , ja pikkus kopeeritavatest andmetest. Sel juhul kopeerime kogu sisu sourceArray sisse sihtkohtArray , nii et möödume sourceArray.Length kolmanda argumendina.
Pange tähele, et saate kasutada Array.Copy() suvalise arvu mõõtmetega massiivide lähtestamiseks, kui lähte- ja sihtmassiividel on sama arv mõõtmeid ja igas mõõtmes sama suurus.
Samuti pidage meeles, et Array.Copy() teeb lähtemassiivi madala koopia, mis tähendab, et kui lähtemassiivi sisaldab viitetüüpe, siis viited kopeeritakse, kuid objekte endid ei dubleerita.
Siin on täielik kood, mida kasutatakse Array.Copy() funktsioon massiivi lähtestamiseks C#-s:
süsteemi kasutamine;klassi massiiv
{
staatiline tühimik Peamine ( string [ ] args )
{
// Initsialiseerimine a 1 -mõõtmeline massiiv kasutades Array.Copy
int [ ] sourceArray1D = { 1 , 2 , 3 , 4 , 5 } ;
int [ ] targetArray1D = uus int [ 5 ] ;
Array.Copy ( allikamassiiv1D, sihtkohtMassiiv1D, allikasArray1D.Length ) ;
Console.WriteLine ( 'Väärtused sihtkohas Array1D:' ) ;
jaoks ( int i = 0 ; i < sihtkohtArray1D.Length; i++ ) {
Console.WriteLine ( sihtkohtArray1D [ i ] ) ;
}
// Initsialiseerimine a 2 -mõõtmeline massiiv kasutades Array.Copy
int [ , ] sourceArray2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
int [ , ] targetArray2D = uus int [ 3 , 2 ] ;
Array.Copy ( allikamassiiv2D, sihtkohtArray2D, allikasArray2D.Length ) ;
Console.WriteLine ( 'Väärtused sihtkohas Array2D:' ) ;
jaoks ( int i = 0 ; i < sihtkohtArray2D.GetLength ( 0 ) ; i++ ) {
jaoks ( int j = 0 ; j < sihtkohtArray2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, sihtkohtArray2D [ i, j ] ) ;
}
}
}
}
Selles koodis kasutame Array.Copy() 1-dimensioonilise täisarvude massiivi, nimega sihtarv1D väärtustega 1, 2, 3, 4 ja 5 lähtestamiseks lähtemassiivist sourceArray1D.
Kasutame ka Array.Copy() kahemõõtmelise täisarvu massiivi, nimega destinationArray2D lähtestamiseks väärtustega {1, 2}, {3, 4} ja {5, 6} lähtemassiivist sourceArray2D.
Seejärel kasutame iga massiivi iga elemendi läbimiseks ja selle väärtuse konsooli printimiseks täiendavaid silmuseid.
Järeldus
Selles artiklis uurisime erinevaid viise massiivide lähtestamiseks C#-s. Käsitlesime massiivi initsialiseerija süntaksit, kasutades uut märksõna, massiivide lähtestamist silmuste abil ja kasutades meetodit Array.Copy(). Sõltuvalt konkreetsest kasutusjuhtumist on igal neist meetoditest oma eelised ja puudused. Nende erinevate lähenemisviisidega tutvumine võimaldab teil valida oma vajadustele kõige sobivama.