A C#-ban a tömbök konténerként szolgálnak az azonos adattípusú elemek tárolására. Egy tömb létrehozásakor többféle módon is inicializálható elemekkel. Ez a cikk a tömbök C# nyelven történő inicializálásának különböző módszereivel foglalkozik, és átfogó feltárást nyújt az egyes megközelítésekhez.
A tömbök inicializálásának módszerei C#-ban
A tömbök a számítógépes programozás alapvető adatstruktúrái, amelyek lehetővé teszik azonos adattípusú elemek gyűjteményének tárolását és kezelését egymás melletti memóriahelyeken. Íme néhány módszer a tömbök inicializálására C#-ban:
1: Tömbök inicializálása a tömb inicializáló szintaxisával
A tömb inicializálásának legegyszerűbb módja a tömb inicializáló szintaxisának használata, mivel ez azt jelenti, hogy a tömb elemeit kapcsos zárójelek közé kell tenni, vesszővel elválasztva, például:
int [ ] számok = { 1 , 2 , 3 , 4 , 5 } ;
Ebben a kódban egy „számok” nevű egész szám tömb jön létre és inicializálódik 1 és 5 közötti értékekkel. Hasonlóképpen, ugyanazt a szintaxist használhatja többdimenziós tömb inicializálására.
int [ , ] myMultiDimensionalArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Íme egy példakód, amely az inicializáló szintaxist használja egy 1D és 2D tömb inicializálására C# nyelven:
Rendszer használata;
osztály tömb
{
statikus üres Fő ( húr [ ] args )
{
// 1D tömb inicializálása az inicializáló szintaxis használatával
int [ ] tömb1D = { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'Értékek a tömbben 1D:' ) ;
számára ( int i = 0 ; én < tömb1D.Length; i++ ) {
Console.WriteLine ( tömb1D [ én ] ) ;
}
// 2D tömb inicializálása az inicializáló szintaxis használatával
int [ , ] tömb2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'Értékek a tömb2D-ben:' ) ;
számára ( int i = 0 ; én < array2D.GetLength ( 0 ) ; i++ ) {
számára ( int j = 0 ; j < array2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, tömb2D [ i, j ] ) ;
}
}
}
}
Ebben a kódban az inicializáló szintaxist használjuk a tömb1D nevű, 1, 2, 3, 4 és 5 értékekkel rendelkező egydimenziós egész tömb inicializálására.
Az inicializáló szintaxist használjuk egy kétdimenziós egész szám tömb inicializálására is, az úgynevezett array2D értékekkel: {1, 2}, {3, 4} és {5, 6}.
Ezután további for ciklusokat használunk az egyes tömbök egyes elemeinek iterálására, és kinyomtatjuk az értéküket a konzolra.
2: Tömbök inicializálása az új kulcsszó használatával
Egy további módszer egy tömb inicializálására magában foglalja a új kulcsszó. Ez magában foglalja a tömb méretének megadását szögletes zárójelben, majd az új kulcsszót, majd a tömbelemek adattípusát. Például:
int [ ] számok = új int [ 5 ] ;
Ez a kód létrehoz egy 5-ös méretű számok nevű egész szám tömböt, és az összes elemet az alapértelmezett értékükre inicializálja, ami az egész tömbök esetében 0.
Íme a szintaxis a többdimenziós tömb inicializálásához az új kulcsszó használatával a C#-ban:
< típus > [ , ] < arrayName > = új < típus > [ < hossz1 > , < hossz2 > ,... ] { { < kezdeti értékek > } } ;
Ebben a szintaxisban a
Íme egy példa arra, hogyan kell ezt a szintaxist használni kétdimenziós egész tömb inicializálására:
int [ , ] myArray = új int [ 3 , 2 ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Ebben a példában egy myArray nevű 2d egész tömböt inicializálunk 3 sorral és 2 oszloppal az új kulcsszó használatával. A dupla kapcsos kapcsos kapcsos zárójelek szintaxisának használatával a tömb minden eleméhez is megadunk kezdeti értékeket. Az értékek a következők: {1, 2}, {3, 4} és {5, 6}, amelyek az egyes sorok elemeinek felelnek meg.
Íme egy példa arra, hogyan használhatjuk az új kulcsszót egy és kétdimenziós tömb inicializálására C# nyelven, valamint egy kódot az egyes tömbök értékeinek kinyomtatására:
Rendszer használata;osztály tömb
{
statikus üres Fő ( húr [ ] args )
{
// Inicializálás a 1 -dimenziós tömb
int [ ] myArray1D = új int [ ] { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'Értékek a myArray1D-ben:' ) ;
számára ( int i = 0 ; én < myArray1D.Length; i++ )
{
Console.WriteLine ( myArray1D [ én ] ) ;
}
// Inicializálás a 2 -dimenziós tömb
int [ , ] myArray2D = új int [ , ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'Értékek a myArray2D-ben:' ) ;
számára ( int i = 0 ; én < myArray2D.GetLength ( 0 ) ; i++ )
{
számára ( int j = 0 ; j < myArray2D.GetLength ( 1 ) ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ i, j ] ) ;
}
}
}
}
Ebben a kódban az új kulcsszót használjuk egy elnevezésű egydimenziós egész tömb inicializálására myArray1D 1, 2, 3, 4 és 5 értékkel, valamint egy kétdimenziós egész tömb ún. myArray2D {1, 2}, {3, 4} és {5, 6} értékekkel.
Ezután for ciklusokat használunk az egyes tömbök egyes elemeinek iterálására, és kinyomtatjuk az értéküket a konzolra. Ne feledje, hogy a 2-dimenziós tömbhöz ezt használjuk GetLength() a sorok és oszlopok számának meghatározásához, és a beágyazott for ciklusok használatával az egyes elemeken keresztüli iterációhoz.
3: Tömbök inicializálása hurkok használatával
A tömbök ciklusok segítségével is inicializálhatók. Az egyik megközelítés a for ciklus alkalmazása, amely lehetővé teszi a tömbben való iterációt és értékek hozzárendelését az egyes elemekhez.
int [ ] számok = új int [ 5 ] ;számára ( int i = 0 ; én < számok.Hosszú; i++ )
{
számok [ én ] = i + 1 ;
}
Ez a kód létrehoz egy 5-ös méretű egész számokat tartalmazó tömböt, és minden elemhez hozzárendel egy értéket, amely megegyezik az indexével, plusz 1-gyel. Íme egy példa arra, hogyan inicializálhat kétdimenziós egész tömböt C# nyelven ciklusok segítségével:
számára ( int i = 0 ; én < 3 ; i++ )
{
számára ( int j = 0 ; j < 2 ; j++ )
{
myArray [ i, j ] = i + j;
}
}
Ebben a példában a beágyazott ciklusokat használjuk az úgynevezett kétdimenziós egész tömb egyes elemei közötti iterációhoz. myArray , amelynek 3 sora és 2 oszlopa van. Minden elemnél beállítjuk az értékét a sor és oszlop indexeinek összegére az i + j kifejezéssel.
Íme egy példa arra, hogyan lehet ciklusokat használni egy 1-dimenziós és kétdimenziós tömb inicializálására C#-ban, valamint kódot az egyes tömbök értékeinek kinyomtatására:
Rendszer használata;osztály tömb
{
statikus üres Fő ( húr [ ] args )
{
// Inicializálás a 1 -dimenziós tömb hurkot használva
int [ ] myArray1D = új int [ 5 ] ;
számára ( int i = 0 ; én < myArray1D.Length; i++ )
{
myArray1D [ én ] = i + 1 ;
}
Console.WriteLine ( 'Értékek a myArray1D-ben:' ) ;
számára ( int i = 0 ; én < myArray1D.Length; i++ )
{
Console.WriteLine ( myArray1D [ én ] ) ;
}
// Inicializálás a 2 -dimenziós tömb beágyazott hurkokat használva
int [ , ] myArray2D = új int [ 3 , 2 ] ;
számára ( int i = 0 ; én < 3 ; i++ )
{
számára ( int j = 0 ; j < 2 ; j++ )
{
myArray2D [ i, j ] = i + j;
}
}
Console.WriteLine ( 'Értékek a myArray2D-ben:' ) ;
számára ( int i = 0 ; én < 3 ; i++ )
{
számára ( int j = 0 ; j < 2 ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ i, j ] ) ;
}
}
}
}
Ebben a kódban egy for ciklust használunk a myArray1D nevű egydimenziós egész tömb inicializálására 1, 2, 3, 4 és 5 értékkel. A beágyazott ciklusokat egy kétdimenziós egész tömb inicializálására is használjuk. myArray2D a {0, 1}, {1, 2} és {2, 3} értékekkel az i + j kifejezés használatával.
Ezután további for ciklusokat használva ismételje meg az egyes tömb minden elemét, és kinyomtassa az értékét a konzolra.
4: Tömbök inicializálása az Array.Copy() segítségével
A tömb inicializálásának alternatív módja az Array.Copy() függvény használata. Ez magában foglalja egy forrástömb létrehozását a kívánt elemekkel, majd másolja azokat egy céltömbbe. Például:
int [ ] forrás = { 1 , 2 , 3 , 4 , 5 } ;int [ ] cél = új int [ forrás.Hosszú ] ;
Array.Copy ( forrás , cél, forrás.Length ) ;
Ez a kód létrehoz egy forrás nevű egész szám tömböt 1-től 5-ig terjedő értékekkel, létrehoz egy új, cél nevű egész tömböt, amelynek mérete megegyezik a forráséval, majd átmásolja az elemeket a forrásból a célba.
Hadd mutassak be egy példát, amely bemutatja az Array.Copy használatát egy kétdimenziós egész tömb inicializálására C# nyelven:
int [ , ] sourceArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;int [ , ] targetArray = new int [ 3 , 2 ] ;
Array.Copy ( sourceArray, destinationArray, sourceArray.Length ) ;
Ebben a példában van egy kétdimenziós egész tömbünk sourceArray 3 sorral és 2 oszloppal. használunk Array.Copy() hogy a sourceArray tartalmát átmásoljuk egy új, 2 dimenziós egész szám tömbbe, melynek neve destinationArray, amely szintén 3 sorból és 2 oszlopból áll.
A Array.Copy() módszert vesz igénybe három érv : a forrástömb , a cél tömb , és a hossz a másolandó adatokról. Ebben az esetben a teljes tartalmat másoljuk sourceArray -ba destinationArray , tehát átmegyünk sourceArray.Length mint a harmadik érv.
Vegye figyelembe, hogy használhatja Array.Copy() tetszőleges számú dimenziójú tömbök inicializálása, feltéve, hogy a forrás- és céltömbök minden dimenzióban ugyanannyi dimenzióval és mérettel rendelkeznek.
Azt is tartsd szem előtt Array.Copy() elvégzi a forrástömb sekély másolását, ami azt jelenti, hogy ha a forrástömb hivatkozástípusokat tartalmaz, akkor a hivatkozások másolásra kerülnek, de maguk az objektumok nem duplikálódnak.
Itt van a teljes kód, amelyet használ Array.Copy() függvény a tömb inicializálásához C#-ban:
Rendszer használata;osztály tömb
{
statikus üres Fő ( húr [ ] args )
{
// Inicializálás a 1 -dimenziós tömb az Array.Copy használatával
int [ ] sourceArray1D = { 1 , 2 , 3 , 4 , 5 } ;
int [ ] célArray1D = új int [ 5 ] ;
Array.Copy ( forrásTömb1D, célTömb1D, forrásTömb1D.Length ) ;
Console.WriteLine ( 'Értékek a destinationArray1D-ben:' ) ;
számára ( int i = 0 ; én < célTömb1D.Length; i++ ) {
Console.WriteLine ( célTömb1D [ én ] ) ;
}
// Inicializálás a 2 -dimenziós tömb az Array.Copy használatával
int [ , ] sourceArray2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
int [ , ] targetArray2D = new int [ 3 , 2 ] ;
Array.Copy ( sourceArray2D, destinationArray2D, sourceArray2D.Length ) ;
Console.WriteLine ( 'Értékek a destinationArray2D-ben:' ) ;
számára ( int i = 0 ; én < destinationArray2D.GetLength ( 0 ) ; i++ ) {
számára ( int j = 0 ; j < destinationArray2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, célTömb2D [ i, j ] ) ;
}
}
}
}
Ebben a kódban használjuk Array.Copy() a destinationArray1D nevű egydimenziós egész tömb inicializálása 1, 2, 3, 4 és 5 értékkel a sourceArray1D nevű forrástömbből.
Mi is használunk Array.Copy() a destinationArray2D nevű kétdimenziós egész tömb inicializálása {1, 2}, {3, 4} és {5, 6} értékekkel a sourceArray2D nevű forrástömbből.
Ezután további for ciklusokat használunk az egyes tömbök egyes elemeinek iterálására, és kinyomtatjuk az értéküket a konzolra.
Következtetés
Ebben a cikkben a tömbök C# nyelven történő inicializálásának különböző módjait vizsgáltuk. A tömb inicializáló szintaxisával foglalkoztunk, az új kulcsszó használatával, a tömbök inicializálásával ciklusokkal és az Array.Copy() metódussal. A konkrét felhasználási esettől függően ezeknek a módszereknek mindegyikének megvannak a maga előnyei és hátrányai. Ha megismeri ezeket a változatos megközelítéseket, akkor kiválaszthatja az Ön igényeinek leginkább megfelelőt.