C# valodā masīvi kalpo kā konteineri viena un tā paša datu tipa elementu glabāšanai. Veidojot masīvu, ir vairākas pieejas, kā to inicializēt ar elementiem. Šajā rakstā ir aplūkotas dažādas masīvu inicializācijas metodes C#, sniedzot visaptverošu katras pieejas izpēti.
Masīvu inicializācijas metodes C#
Masīvi ir būtiska datu struktūra datorprogrammēšanā, kas ļauj glabāt un apstrādāt viena un tā paša datu tipa elementu kolekciju blakus esošās atmiņas vietās. Šeit ir daži veidi, kā inicializēt masīvus C#:
1: Masīvu inicializācija, izmantojot masīva inicializatora sintaksi
Visvienkāršākā pieeja masīva inicializācijai ir izmantot masīva inicializatora sintaksi, jo tas ietver masīva elementu iekļaušanu iekavās, atdalot tos ar komatiem, piemēram:
starpt [ ] cipari = { 1 , 2 , 3 , 4 , 5 } ;
Šajā kodā tiek izveidots veselu skaitļu masīvs ar nosaukumu “numbers” un inicializēts ar vērtībām no 1 līdz 5. Tāpat varat izmantot to pašu sintaksi, lai inicializētu daudzdimensiju masīvu.
starpt [ , ] myMultiDimensionalArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Šeit ir koda piemērs, kas izmanto inicializatora sintaksi, lai inicializētu 1D un 2D masīvu C#:
izmantojot sistēmu;
klases masīvs
{
statiskā tukšums Galvenā ( virkne [ ] args )
{
// 1D masīva inicializācija, izmantojot inicializētāja sintaksi
starpt [ ] masīvs1D = { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'Vērtības masīvā1D:' ) ;
priekš ( int i = 0 ; i < masīvs1D.Garums; i++ ) {
Console.WriteLine ( masīvs1D [ i ] ) ;
}
// 2D masīva inicializācija, izmantojot inicializētāja sintaksi
starpt [ , ] masīvs2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'Vērtības masīvā2D:' ) ;
priekš ( int i = 0 ; i < masīvs2D.GetLength ( 0 ) ; i++ ) {
priekš ( int j = 0 ; j < masīvs2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, masīvs2D [ es, j ] ) ;
}
}
}
}
Šajā kodā mēs izmantojam inicializatora sintaksi, lai inicializētu 1 dimensijas veselu skaitļu masīvu, ko sauc par masīvu1D ar vērtībām 1, 2, 3, 4 un 5.
Mēs arī izmantojam inicializatora sintaksi, lai inicializētu 2 dimensiju veselu skaitļu masīvu, ko sauc par masīvu2D ar vērtībām {1, 2}, {3, 4} un {5, 6}.
Pēc tam mēs izmantojam papildu cilpas, lai atkārtotu katru katra masīva elementu un izdrukātu tā vērtību konsolē.
2. Masīvu inicializācija, izmantojot jauno atslēgvārdu
Papildu metode masīva inicializācijai ietver izmantošanu jauns atslēgvārds. Tas ietver masīva lieluma norādīšanu kvadrātiekavās, kam seko jaunais atslēgvārds un pēc tam masīva elementu datu tips. Piemēram:
starpt [ ] skaitļi = jauns int [ 5 ] ;
Šis kods izveido veselu skaitļu masīvu ar skaitļiem, kuru izmērs ir 5, un inicializē visus elementus uz to noklusējuma vērtību, kas ir 0 veselu skaitļu masīviem.
Lūk, sintakse daudzdimensiju masīva inicializācijai, izmantojot jauno atslēgvārdu C#:
< veids > [ , ] < masīvaNosaukums > = jauns < veids > [ < garums1 > , < garums2 > ,... ] { { < sākotnējās vērtības > } } ;
Šajā sintaksē
Tālāk ir sniegts piemērs, kā izmantot šo sintaksi, lai inicializētu 2-dimensiju veselu skaitļu masīvu:
starpt [ , ] myArray = jauns int [ 3 , 2 ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Šajā piemērā mēs inicializējam 2d veselu skaitļu masīvu ar nosaukumu myArray ar 3 rindām un 2 kolonnām, izmantojot jauno atslēgvārdu. Mēs nodrošinām arī sākotnējās vērtības katram masīva elementam, izmantojot dubultās cirtaini iekavas sintaksi. Vērtības ir {1, 2}, {3, 4} un {5, 6}, kas atbilst elementiem katrā rindā.
Šeit ir piemērs, kā izmantot jauno atslēgvārdu, lai inicializētu gan 1-dimensiju, gan 2-dimensiju masīvu C#, kā arī kodu, lai izdrukātu katra masīva vērtības:
izmantojot sistēmu;klases masīvs
{
statiskā tukšums Galvenā ( virkne [ ] args )
{
// Inicializēšana a 1 -dimensiju masīvs
starpt [ ] myArray1D = jauns int [ ] { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'Vērtības in myArray1D:' ) ;
priekš ( int i = 0 ; i < myArray1D.Length; i++ )
{
Console.WriteLine ( myArray1D [ i ] ) ;
}
// Inicializēšana a 2 -dimensiju masīvs
starpt [ , ] myArray2D = jauns int [ , ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'Vērtības in myArray2D:' ) ;
priekš ( int i = 0 ; i < myArray2D.GetLength ( 0 ) ; i++ )
{
priekš ( int j = 0 ; j < myArray2D.GetLength ( 1 ) ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ es, j ] ) ;
}
}
}
}
Šajā kodā mēs izmantojam jauno atslēgvārdu, lai inicializētu viendimensijas veselu skaitļu masīvu, ko sauc myArray1D ar vērtībām 1, 2, 3, 4 un 5 un 2-dimensiju veselu skaitļu masīvu, ko sauc myArray2D ar vērtībām {1, 2}, {3, 4} un {5, 6}.
Pēc tam mēs izmantojam cilpas, lai atkārtotu katru katra masīva elementu un izdrukātu tā vērtību konsolē. Ņemiet vērā, ka 2-dimensiju masīvam mēs izmantojam GetLength() lai noteiktu rindu un kolonnu skaitu un izmantotu ligzdotas cilpas, lai atkārtotu katru elementu.
3: Masīvu inicializācija, izmantojot cilpas
Masīvus var inicializēt arī, izmantojot cilpas. Viena pieeja ir izmantot for cilpu, kas ļauj atkārtot masīvu un piešķirt vērtības katram elementam.
starpt [ ] skaitļi = jauns int [ 5 ] ;priekš ( int i = 0 ; i < skaitļi.Garums; i++ )
{
cipariem [ i ] = i + 1 ;
}
Šis kods izveido veselu skaitļu masīvu ar skaitļiem, kuru izmērs ir 5, un katram elementam piešķir vērtību, kas vienāda ar tā indeksu plus 1. Tālāk ir sniegts piemērs, kā inicializēt 2 dimensiju veselu skaitļu masīvu C#, izmantojot cilpas:
priekš ( int i = 0 ; i < 3 ; i++ )
{
priekš ( int j = 0 ; j < 2 ; j++ )
{
myArray [ es, j ] = i + j;
}
}
Šajā piemērā mēs izmantojam ligzdotas cilpas, lai atkārtotu katru 2-dimensiju veselu skaitļu masīva elementu myArray , kurā ir 3 rindas un 2 kolonnas. Katram elementam mēs iestatām tā vērtību uz tā rindu un kolonnu indeksu summu, izmantojot izteiksmi i + j.
Šeit ir piemērs, kā izmantot cilpas, lai inicializētu gan 1-dimensiju, gan 2-dimensiju masīvu C#, kā arī kodu, lai izdrukātu vērtības katrā masīvā:
izmantojot sistēmu;klases masīvs
{
statiskā tukšums Galvenā ( virkne [ ] args )
{
// Inicializēšana a 1 -dimensiju masīvs, izmantojot cilpu
starpt [ ] myArray1D = jauns int [ 5 ] ;
priekš ( int i = 0 ; i < myArray1D.Length; i++ )
{
myArray1D [ i ] = i + 1 ;
}
Console.WriteLine ( 'Vērtības in myArray1D:' ) ;
priekš ( int i = 0 ; i < myArray1D.Length; i++ )
{
Console.WriteLine ( myArray1D [ i ] ) ;
}
// Inicializēšana a 2 -dimensiju masīvs, izmantojot ligzdotas cilpas
starpt [ , ] myArray2D = jauns int [ 3 , 2 ] ;
priekš ( int i = 0 ; i < 3 ; i++ )
{
priekš ( int j = 0 ; j < 2 ; j++ )
{
myArray2D [ es, j ] = i + j;
}
}
Console.WriteLine ( 'Vērtības in myArray2D:' ) ;
priekš ( int i = 0 ; i < 3 ; i++ )
{
priekš ( int j = 0 ; j < 2 ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ es, j ] ) ;
}
}
}
}
Šajā kodā mēs izmantojam for cilpu, lai inicializētu 1 dimensiju veselu skaitļu masīvu, ko sauc par myArray1D ar vērtībām 1, 2, 3, 4 un 5. Mēs arī izmantojam ligzdotas cilpas, lai inicializētu 2 dimensiju veselu skaitļu masīvu, ko sauc par myArray2D ar vērtībām {0, 1}, {1, 2} un {2, 3}, izmantojot izteiksmi i + j.
Pēc tam izmantojiet papildu cilpas, lai atkārtotu katru katra masīva elementu un izdrukātu tā vērtību konsolē.
4: masīvu inicializācija, izmantojot Array.Copy()
Alternatīva pieeja masīva inicializācijai ietver funkcijas Array.Copy() izmantošanu. Tas ietver avota masīva izveidi ar vēlamajiem elementiem un pēc tam to kopēšanu mērķa masīvā. Piemēram:
starpt [ ] avots = { 1 , 2 , 3 , 4 , 5 } ;starpt [ ] mērķis = jauns int [ avots.Garums ] ;
Masīvs.Kopēt ( avots , mērķis, avots.Garums ) ;
Šis kods izveido veselu skaitļu masīvu ar nosaukumu avots ar vērtībām no 1 līdz 5, izveido jaunu veselu skaitļu masīvu ar nosaukumu Mērķis ar tādu pašu lielumu kā avots, un pēc tam kopē elementus no avota uz mērķi.
Ļaujiet man sniegt piemēru, kas parāda Array.Copy izmantošanu, lai inicializētu divdimensiju veselu skaitļu masīvu C#:
starpt [ , ] sourceArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;starpt [ , ] targetArray = jauns int [ 3 , 2 ] ;
Masīvs.Kopēt ( sourceArray, destinationArray, sourceArray.Length ) ;
Šajā piemērā mums ir 2-dimensiju veselu skaitļu masīvs avotsArray ar 3 rindām un 2 kolonnām. Mēs lietojam Masīvs.Kopēt() lai kopētu sourceArray saturu jaunā 2-dimensiju veselu skaitļu masīvā ar nosaukumu destinationArray, kurā ir arī 3 rindas un 2 kolonnas.
The Masīvs.Kopēt() metode aizņem trīs argumenti : avotu masīvs , galamērķa masīvs , un garums no kopējamajiem datiem. Šajā gadījumā mēs kopējot visu saturu avotsArray iekšā galamērķisArray , tāpēc ejam garām avotsArray.Length kā trešais arguments.
Ņemiet vērā, ka varat izmantot Masīvs.Kopēt() lai inicializētu masīvus ar jebkādu izmēru skaitu, ja avota un mērķa masīviem ir vienāds dimensiju skaits un vienāds izmērs katrā dimensijā.
Tāpat paturiet prātā, ka Masīvs.Kopēt() veic seklu avota masīva kopiju, kas nozīmē, ka, ja avota masīvs satur atsauces tipus, atsauces tiks kopētas, bet paši objekti netiks dublēti.
Šeit ir pilns izmantotais kods Masīvs.Kopēt() funkcija, lai inicializētu masīvu C#:
izmantojot sistēmu;klases masīvs
{
statiskā tukšums Galvenā ( virkne [ ] args )
{
// Inicializēšana a 1 -dimensiju masīvs, izmantojot Array.Copy
starpt [ ] avotsArray1D = { 1 , 2 , 3 , 4 , 5 } ;
starpt [ ] targetArray1D = jauns int [ 5 ] ;
Masīvs.Kopēt ( avotsArray1D, galamērķisArray1D, avotsArray1D.Length ) ;
Console.WriteLine ( 'Vērtības galamērķīArray1D:' ) ;
priekš ( int i = 0 ; i < galamērķisArray1D.Length; i++ ) {
Console.WriteLine ( galamērķisArray1D [ i ] ) ;
}
// Inicializēšana a 2 -dimensiju masīvs, izmantojot Array.Copy
starpt [ , ] avotsArray2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
starpt [ , ] targetArray2D = jauns int [ 3 , 2 ] ;
Masīvs.Kopēt ( avotsArray2D, galamērķisArray2D, avotsArray2D.Length ) ;
Console.WriteLine ( 'Vērtības galamērķīArray2D:' ) ;
priekš ( int i = 0 ; i < galamērķisArray2D.GetLength ( 0 ) ; i++ ) {
priekš ( int j = 0 ; j < galamērķisArray2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, galamērķisArray2D [ es, j ] ) ;
}
}
}
}
Šajā kodā mēs izmantojam Masīvs.Kopēt() lai inicializētu viendimensiju veselu skaitļu masīvu, ko sauc par destinationArray1D ar vērtībām 1, 2, 3, 4 un 5 no avota masīva, ko sauc par sourceArray1D.
Mēs arī lietojam Masīvs.Kopēt() lai inicializētu divdimensiju veselu skaitļu masīvu, ko sauc par targetArray2D ar vērtībām {1, 2}, {3, 4} un {5, 6} no avota masīva, ko sauc par sourceArray2D.
Pēc tam mēs izmantojam papildu cilpas, lai atkārtotu katru katra masīva elementu un izdrukātu tā vērtību konsolē.
Secinājums
Šajā rakstā mēs izpētījām dažādus veidus, kā inicializēt masīvus C#. Mēs aptvērām masīva inicializatora sintaksi, izmantojot jauno atslēgvārdu, inicializējot masīvus, izmantojot cilpas, un izmantojot metodi Array.Copy(). Atkarībā no konkrētā lietošanas gadījuma katrai no šīm metodēm ir savas priekšrocības un trūkumi. Iepazīstoties ar šīm dažādajām pieejām, varēsiet izvēlēties savām konkrētajām prasībām vispiemērotāko.