C#:ssa taulukot toimivat säilöinä saman tietotyypin elementtien tallentamiseen. Kun luot taulukon, on olemassa useita tapoja alustaa se elementeillä. Tässä artikkelissa käsitellään erilaisia menetelmiä taulukoiden alustamiseksi C#-kielellä ja tarjoaa kattavan selvityksen jokaisesta lähestymistavasta.
Menetelmät taulukoiden alustamiseen C#:ssa
Taulukot ovat olennainen tietorakenne tietokoneohjelmoinnissa, jonka avulla voit tallentaa ja käsitellä saman tietotyypin elementtien kokoelmaa vierekkäisiin muistipaikkoihin. Tässä on joitain tapoja alustaa taulukoita C#:ssa:
1: Taulukkojen alustaminen Array Initializer -syntaksin avulla
Yksinkertaisin tapa alustaa taulukko on käyttää taulukon alustussyntaksia, koska se sisältää taulukon elementtien sulkemisen aaltosulkeilla pilkuilla erotettuina, esimerkiksi:
int [ ] numerot = { 1 , 2 , 3 , 4 , 5 } ;
Tässä koodissa luodaan kokonaislukutaulukko nimeltä 'numbers' ja alustetaan arvoilla 1–5. Samalla tavalla voit käyttää samaa syntaksia alustaaksesi moniulotteisen taulukon.
int [ , ] myMultiDimensionalArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Tässä on esimerkkikoodi, joka käyttää alustussyntaksia 1D- ja 2D-taulukon alustamiseen C#:ssa:
käyttämällä järjestelmää;
luokkajoukko
{
staattinen tyhjyys Pää ( merkkijono [ ] args )
{
// 1D-taulukon alustaminen alustussyntaksin avulla
int [ ] array1D = { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'Arvot taulukossa1D:' ) ;
varten ( int i = 0 ; i < array1D.Length; i++ ) {
Console.WriteLine ( array1D [ i ] ) ;
}
// 2D-taulukon alustaminen alustussyntaksin avulla
int [ , ] array2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'Arvot array2D:ssä:' ) ;
varten ( int i = 0 ; i < array2D.GetLength ( 0 ) ; i++ ) {
varten ( int j = 0 ; j < array2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, array2D [ minä, j ] ) ;
}
}
}
}
Tässä koodissa käytämme alustussyntaksia alustaaksemme 1-ulotteisen kokonaislukutaulukon nimeltä array1D arvoilla 1, 2, 3, 4 ja 5.
Käytämme myös alustussyntaksia alustaaksemme 2-ulotteisen kokonaislukutaulukon nimeltä array2D arvoilla {1, 2}, {3, 4} ja {5, 6}.
Käytämme sitten ylimääräisiä for-silmukoita iteroidaksemme jokaisen taulukon jokaisen elementin läpi ja tulostaaksemme sen arvon konsoliin.
2: taulukoiden alustaminen uudella avainsanalla
Lisämenetelmä taulukon alustamiseksi sisältää Uusi avainsana. Tämä edellyttää taulukon koon määrittämistä hakasulkeissa, sen jälkeen uuden avainsanan ja sitten taulukon elementtien tietotyypin. Esimerkiksi:
int [ ] numerot = uusi int [ 5 ] ;
Tämä koodi luo kokonaislukutaulukon, jonka nimi on numerot ja jonka koko on 5, ja alustaa kaikki elementit oletusarvoonsa, joka on 0 kokonaislukutaulukoille.
Tässä on syntaksi moniulotteisen taulukon alustamiseksi käyttämällä uutta avainsanaa C#:ssa:
< tyyppi > [ , ] < arrayName > = uusi < tyyppi > [ < pituus 1 > , < pituus 2 > ,... ] { { < alkuperäiset arvot > } } ;
Tässä syntaksissa
Tässä on esimerkki siitä, kuinka tätä syntaksia käytetään 2-ulotteisen kokonaislukutaulukon alustamiseen:
int [ , ] myArray = uusi int [ 3 , 2 ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Tässä esimerkissä alustamme 2d-kokonaislukutaulukon nimeltä myArray, jossa on 3 riviä ja 2 saraketta, käyttämällä uutta avainsanaa. Tarjoamme myös alkuarvot jokaiselle taulukon elementille käyttämällä kaksoissulkumerkkiä. Arvot ovat {1, 2}, {3, 4} ja {5, 6}, jotka vastaavat kunkin rivin elementtejä.
Tässä on esimerkki siitä, kuinka uutta avainsanaa käytetään sekä 1- että 2-ulotteisen taulukon alustamiseen C#-kielellä, sekä koodi kunkin taulukon arvojen tulostamiseksi:
käyttämällä järjestelmää;luokkajoukko
{
staattinen tyhjyys Pää ( merkkijono [ ] args )
{
// Alustaminen a 1 -ulotteinen matriisi
int [ ] myArray1D = uusi int [ ] { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'Arvot myArray1D:ssä:' ) ;
varten ( int i = 0 ; i < myArray1D.Length; i++ )
{
Console.WriteLine ( myArray1D [ i ] ) ;
}
// Alustaminen a 2 -ulotteinen matriisi
int [ , ] myArray2D = uusi int [ , ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'Arvot myArray2D:ssä:' ) ;
varten ( int i = 0 ; i < myArray2D.GetLength ( 0 ) ; i++ )
{
varten ( int j = 0 ; j < myArray2D.GetLength ( 1 ) ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ minä, j ] ) ;
}
}
}
}
Tässä koodissa käytämme uutta avainsanaa alustamaan yksiulotteinen kokonaislukutaulukko nimeltä myArray1D arvoilla 1, 2, 3, 4 ja 5 sekä 2-ulotteinen kokonaislukutaulukko ns. myArray2D arvoilla {1, 2}, {3, 4} ja {5, 6}.
Käytämme sitten silmukoita iteroidaksemme jokaisen taulukon jokaisen elementin läpi ja tulostaaksemme sen arvon konsoliin. Huomaa, että käytämme 2-ulotteiselle taulukolle GetLength() määrittääksesi rivien ja sarakkeiden lukumäärän ja käyttämällä sisäkkäisiä silmukoita toistaaksesi jokaisen elementin läpi.
3: taulukoiden alustaminen silmukoiden avulla
Matriisit voidaan myös alustaa silmukoiden avulla. Yksi tapa on käyttää for-silmukkaa, jonka avulla voit iteroida taulukon läpi ja määrittää arvot jokaiselle elementille.
int [ ] numerot = uusi int [ 5 ] ;varten ( int i = 0 ; i < numerot.Pituus; i++ )
{
numeroita [ i ] = minä + 1 ;
}
Tämä koodi luo kokonaislukutaulukon, jonka nimi on numerot, joiden koko on 5, ja antaa jokaiselle elementille arvon, joka on yhtä suuri kuin sen indeksi plus 1. Tässä on esimerkki 2-ulotteisen kokonaislukutaulukon alustamisesta C#:ssa silmukoiden avulla:
varten ( int i = 0 ; i < 3 ; i++ )
{
varten ( int j = 0 ; j < 2 ; j++ )
{
myArray [ minä, j ] = i + j;
}
}
Tässä esimerkissä käytämme sisäkkäisiä silmukoita iteroidaksemme 2-ulotteisen kokonaislukutaulukon jokaisen elementin läpi. myArray , jossa on 3 riviä ja 2 saraketta. Jokaiselle elementille asetamme sen arvon sen rivi- ja sarakeindeksien summaksi lausekkeella i + j.
Tässä on esimerkki silmukoiden käyttämisestä 1-ulotteisen ja 2-ulotteisen taulukon alustamiseen C#-kielellä sekä koodi kunkin taulukon arvojen tulostamiseksi:
käyttämällä järjestelmää;luokkajoukko
{
staattinen tyhjyys Pää ( merkkijono [ ] args )
{
// Alustaminen a 1 -ulotteinen taulukko silmukan avulla
int [ ] myArray1D = uusi int [ 5 ] ;
varten ( int i = 0 ; i < myArray1D.Length; i++ )
{
myArray1D [ i ] = minä + 1 ;
}
Console.WriteLine ( 'Arvot myArray1D:ssä:' ) ;
varten ( int i = 0 ; i < myArray1D.Length; i++ )
{
Console.WriteLine ( myArray1D [ i ] ) ;
}
// Alustaminen a 2 -ulotteinen taulukko sisäkkäisiä silmukoita käyttäen
int [ , ] myArray2D = uusi int [ 3 , 2 ] ;
varten ( int i = 0 ; i < 3 ; i++ )
{
varten ( int j = 0 ; j < 2 ; j++ )
{
myArray2D [ minä, j ] = i + j;
}
}
Console.WriteLine ( 'Arvot myArray2D:ssä:' ) ;
varten ( int i = 0 ; i < 3 ; i++ )
{
varten ( int j = 0 ; j < 2 ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ minä, j ] ) ;
}
}
}
}
Tässä koodissa käytämme for-silmukkaa alustaaksemme 1-ulotteisen kokonaislukutaulukon nimeltä myArray1D arvoilla 1, 2, 3, 4 ja 5. Käytämme myös sisäkkäisiä silmukoita alustaaksemme kaksiulotteisen kokonaislukutaulukon nimeltä myArray2D arvoilla {0, 1}, {1, 2} ja {2, 3} lausekkeella i + j.
Käytä sitten muita for-silmukoita iteroidaksesi jokaisen taulukon jokaisen elementin läpi ja tulostaa sen arvo konsoliin.
4: Array.Copy() -taulukoiden alustaminen
Vaihtoehtoinen lähestymistapa taulukon alustamiseen on Array.Copy()-funktion käyttäminen. Tämä sisältää lähdetaulukon luomisen halutuilla elementeillä ja kopioimisen sitten kohdetaulukkoon. Esimerkiksi:
int [ ] lähde = { 1 , 2 , 3 , 4 , 5 } ;int [ ] kohde = uusi int [ lähde.Pituus ] ;
Array.Copy ( lähde , kohde, lähde.Pituus ) ;
Tämä koodi luo kokonaislukutaulukon nimeltä lähde, jonka arvot ovat 1–5, luo uuden kokonaislukutaulukon nimeltä kohde, joka on samankokoinen kuin lähde, ja kopioi sitten elementit lähteestä kohteeseen.
Sallikaa minun esittää esimerkki, joka havainnollistaa Array.Copyn käyttöä kaksiulotteisen kokonaislukutaulukon alustamiseen C#:ssa:
int [ , ] sourceArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;int [ , ] kohdeArray = uusi int [ 3 , 2 ] ;
Array.Copy ( sourceArray, destinationArray, sourceArray.Length ) ;
Tässä esimerkissä meillä on 2-ulotteinen kokonaislukutaulukko nimeltään sourceArray 3 rivillä ja 2 sarakkeella. Meillä on käytössä Array.Copy() kopioidaksesi sourceArrayn sisällön uuteen 2-ulotteiseen kokonaislukutaulukkoon nimeltä destinationArray, jossa on myös 3 riviä ja 2 saraketta.
The Array.Copy() menetelmä vie kolme argumenttia : lähdejoukko , kohdejoukko , ja pituus kopioitavista tiedoista. Tässä tapauksessa kopioimme koko sisällön sourceArray sisään kohdeArray , joten ohitamme sourceArray.Length kolmantena argumenttina.
Huomaa, että voit käyttää Array.Copy() alustaa taulukoita millä tahansa määrällä, kunhan lähde- ja kohdematriiseilla on sama määrä mittoja ja sama koko jokaisessa ulottuvuudessa.
Muista myös se Array.Copy() suorittaa matalan kopion lähdetaulukosta, mikä tarkoittaa, että jos lähdetaulukko sisältää viittaustyyppejä, viittaukset kopioidaan, mutta itse objektit eivät monistu.
Tässä on täydellinen koodi, jota käytetään Array.Copy() funktio alustaaksesi taulukon C#:ssa:
käyttämällä järjestelmää;luokkajoukko
{
staattinen tyhjyys Pää ( merkkijono [ ] args )
{
// Alustaminen a 1 -ulotteinen taulukko käyttäen Array.Copya
int [ ] lähdeArray1D = { 1 , 2 , 3 , 4 , 5 } ;
int [ ] kohdeArray1D = uusi int [ 5 ] ;
Array.Copy ( lähdeMatriisi1D, kohdeMatriisi1D, lähdeMatriisi1D.Pituus ) ;
Console.WriteLine ( 'Arvot määränpäässäArray1D:' ) ;
varten ( int i = 0 ; i < määränpääArray1D.Length; i++ ) {
Console.WriteLine ( kohdeArray1D [ i ] ) ;
}
// Alustaminen a 2 -ulotteinen taulukko käyttäen Array.Copya
int [ , ] sourceArray2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
int [ , ] targetArray2D = uusi int [ 3 , 2 ] ;
Array.Copy ( sourceArray2D, destinationArray2D, sourceArray2D.Length ) ;
Console.WriteLine ( 'Arvot määränpäässäArray2D:' ) ;
varten ( int i = 0 ; i < destinationArray2D.GetLength ( 0 ) ; i++ ) {
varten ( int j = 0 ; j < destinationArray2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, määränpääMatriisi2D [ minä, j ] ) ;
}
}
}
}
Tässä koodissa käytämme Array.Copy() alustaaksesi 1-ulotteisen kokonaislukutaulukon, jonka nimi on destinationArray1D arvoilla 1, 2, 3, 4 ja 5 lähdetaulukosta nimeltä sourceArray1D.
Meillä on myös käytössä Array.Copy() 2-ulotteisen kokonaislukutaulukon, jonka nimi on destinationArray2D, alustamiseksi arvoilla {1, 2}, {3, 4} ja {5, 6} lähdetaulukosta, jonka nimi on sourceArray2D.
Käytämme sitten ylimääräisiä for-silmukoita iteroidaksemme jokaisen taulukon jokaisen elementin läpi ja tulostaaksemme sen arvon konsoliin.
Johtopäätös
Tässä artikkelissa tutkimme erilaisia tapoja alustaa taulukoita C#:ssa. Käsittelimme taulukon alustussyntaksin käyttämällä uutta avainsanaa, alustamalla taulukoita silmukoiden avulla ja käyttämällä Array.Copy()-menetelmää. Tietystä käyttötapauksesta riippuen jokaisella näistä menetelmistä on omat etunsa ja haittansa. Näihin erilaisiin lähestymistapoihin tutustuminen auttaa sinua valitsemaan sopivimman vaihtoehdon omiin tarpeisiisi.