W języku C# tablice służą jako kontenery do przechowywania elementów tego samego typu danych. Podczas tworzenia tablicy istnieje wiele podejść do inicjowania jej elementami. W tym artykule omówiono różne metody inicjowania tablic w języku C#, zapewniając kompleksową eksplorację każdego podejścia.
Metody inicjowania tablic w języku C#
Tablice to podstawowa struktura danych w programowaniu komputerowym, która umożliwia przechowywanie i manipulowanie zbiorem elementów tego samego typu danych w ciągłych lokalizacjach pamięci. Oto kilka sposobów inicjowania tablic w języku C#:
1: Inicjowanie tablic za pomocą składni inicjatora tablicy
Najprostszym podejściem do zainicjowania tablicy jest użycie składni inicjatora tablicy, ponieważ obejmuje to umieszczenie elementów tablicy w nawiasach klamrowych, oddzielonych przecinkami, na przykład:
int [ ] liczby = { 1 , 2 , 3 , 4 , 5 } ;
W tym kodzie tworzona jest tablica liczb całkowitych o nazwie „liczby” i inicjowana wartościami od 1 do 5. Podobnie można użyć tej samej składni do zainicjowania tablicy wielowymiarowej.
int [ , ] moja tablica wielowymiarowa = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Oto przykładowy kod, który używa składni inicjalizatora do inicjalizacji tablicy 1D i 2D w języku C#:
przy użyciu Systemu;
tablica klas
{
statyczna pustka Główny ( strunowy [ ] argumenty )
{
// Inicjowanie tablicy 1D przy użyciu składni inicjalizatora
int [ ] tablica1D = { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( „Wartości w tablicy1D:” ) ;
Do ( int i = 0 ; I < tablica1D.Długość; i++ ) {
Console.WriteLine ( tablica1D [ I ] ) ;
}
// Inicjowanie tablicy 2D przy użyciu składni inicjatora
int [ , ] tablica2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( „Wartości w tablicy2D:” ) ;
Do ( int i = 0 ; I < array2D. GetLength ( 0 ) ; i++ ) {
Do ( int j = 0 ; J < array2D. GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, tablica2D [ ja, j ] ) ;
}
}
}
}
W tym kodzie używamy składni inicjalizatora do zainicjowania 1-wymiarowej tablicy liczb całkowitych o nazwie array1D z wartościami 1, 2, 3, 4 i 5.
Używamy również składni inicjatora do zainicjowania dwuwymiarowej tablicy liczb całkowitych o nazwie array2D z wartościami {1, 2}, {3, 4} i {5, 6}.
Następnie używamy dodatkowych pętli for, aby przejrzeć każdy element każdej tablicy i wydrukować jego wartość w konsoli.
2: Inicjowanie tablic przy użyciu nowego słowa kluczowego
Dodatkowa metoda inicjowania tablicy polega na wykorzystaniu metody nowy słowo kluczowe. Obejmuje to określenie rozmiaru tablicy w nawiasach kwadratowych, po którym następuje słowo kluczowe new, a następnie typ danych elementów tablicy. Na przykład:
int [ ] liczby = nowy int [ 5 ] ;
Ten kod tworzy tablicę liczb całkowitych o nazwie liczb o rozmiarze 5 i inicjuje wszystkie elementy do ich wartości domyślnej, czyli 0 dla tablic liczb całkowitych.
Oto składnia inicjowania tablicy wielowymiarowej przy użyciu słowa kluczowego new w języku C#:
< typ > [ , ] < nazwatablicy > = nowy < typ > [ < długość1 > , < długość2 > , ... ] { { < Wartości początkowe > } } ;
W tej składni
Oto przykład użycia tej składni do zainicjowania dwuwymiarowej tablicy liczb całkowitych:
int [ , ] mojaTablica = nowa int [ 3 , 2 ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
W tym przykładzie inicjujemy dwuwymiarową tablicę liczb całkowitych o nazwie myArray z 3 wierszami i 2 kolumnami przy użyciu słowa kluczowego new. Podajemy również wartości początkowe dla każdego elementu tablicy, używając składni podwójnych nawiasów klamrowych. Wartości to {1, 2}, {3, 4} i {5, 6}, odpowiadające elementom w każdym wierszu.
Oto przykład użycia słowa kluczowego new do zainicjowania zarówno jednowymiarowej, jak i dwuwymiarowej tablicy w języku C#, wraz z kodem do wydrukowania wartości w każdej tablicy:
przy użyciu Systemu;tablica klas
{
statyczna pustka Główny ( strunowy [ ] argumenty )
{
// Inicjowanie 1 -wymiarowa tablica
int [ ] myArray1D = nowa int [ ] { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( „Wartości w myArray1D:” ) ;
Do ( int i = 0 ; I < mojaTablica1D.Długość; i++ )
{
Console.WriteLine ( mojaTablica1D [ I ] ) ;
}
// Inicjowanie 2 -wymiarowa tablica
int [ , ] myArray2D = nowy int [ , ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( „Wartości w myArray2D:” ) ;
Do ( int i = 0 ; I < myArray2D. GetLength ( 0 ) ; i++ )
{
Do ( int j = 0 ; J < myArray2D. GetLength ( 1 ) ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , i, j, mojaTablica2D [ ja, j ] ) ;
}
}
}
}
W tym kodzie używamy słowa kluczowego new do zainicjowania jednowymiarowej tablicy liczb całkowitych o nazwie mojaTablica1D z wartościami 1, 2, 3, 4 i 5 oraz dwuwymiarową tablicą liczb całkowitych o nazwie mojaTablica2D z wartościami {1, 2}, {3, 4} i {5, 6}.
Następnie używamy pętli for do iteracji po każdym elemencie każdej tablicy i wyświetlenia jego wartości w konsoli. Zauważ, że dla tablicy dwuwymiarowej używamy PobierzDługość() do określenia liczby wierszy i kolumn oraz za pomocą zagnieżdżonych pętli for do iteracji po każdym elemencie.
3: Inicjowanie tablic za pomocą pętli
Tablice można również inicjować za pomocą pętli. Jednym ze sposobów jest zastosowanie pętli for, która umożliwia iteracyjne przeglądanie tablicy i przypisywanie wartości każdemu elementowi.
int [ ] liczby = nowy int [ 5 ] ;Do ( int i = 0 ; I < liczby.Długość; i++ )
{
liczby [ I ] = ja + 1 ;
}
Ten kod tworzy tablicę liczb całkowitych o nazwie liczb o rozmiarze 5 i przypisuje każdemu elementowi wartość równą jego indeksowi plus 1. Oto przykład, jak zainicjować dwuwymiarową tablicę liczb całkowitych w języku C# za pomocą pętli:
Do ( int i = 0 ; I < 3 ; i++ )
{
Do ( int j = 0 ; J < 2 ; j++ )
{
mojatablica [ ja, j ] = ja + j;
}
}
W tym przykładzie używamy zagnieżdżonych pętli for do iteracji po każdym elemencie dwuwymiarowej tablicy liczb całkowitych o nazwie mojatablica , który ma 3 wiersze i 2 kolumny. Dla każdego elementu ustawiamy jego wartość jako sumę jego indeksów wierszy i kolumn, używając wyrażenia i + j.
Oto przykład użycia pętli do zainicjowania zarówno jednowymiarowej, jak i dwuwymiarowej tablicy w języku C#, wraz z kodem do wydrukowania wartości w każdej tablicy:
przy użyciu Systemu;tablica klas
{
statyczna pustka Główny ( strunowy [ ] argumenty )
{
// Inicjowanie 1 -wymiarowa tablica za pomocą pętli
int [ ] myArray1D = nowa int [ 5 ] ;
Do ( int i = 0 ; I < mojaTablica1D.Długość; i++ )
{
mojaTablica1D [ I ] = ja + 1 ;
}
Console.WriteLine ( „Wartości w myArray1D:” ) ;
Do ( int i = 0 ; I < mojaTablica1D.Długość; i++ )
{
Console.WriteLine ( mojaTablica1D [ I ] ) ;
}
// Inicjowanie 2 -wymiarowa tablica wykorzystująca zagnieżdżone pętle
int [ , ] myArray2D = nowy int [ 3 , 2 ] ;
Do ( int i = 0 ; I < 3 ; i++ )
{
Do ( int j = 0 ; J < 2 ; j++ )
{
mojaTablica2D [ ja, j ] = ja + j;
}
}
Console.WriteLine ( „Wartości w myArray2D:” ) ;
Do ( int i = 0 ; I < 3 ; i++ )
{
Do ( int j = 0 ; J < 2 ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , i, j, mojaTablica2D [ ja, j ] ) ;
}
}
}
}
W tym kodzie używamy pętli for, aby zainicjować 1-wymiarową tablicę liczb całkowitych o nazwie myArray1D z wartościami 1, 2, 3, 4 i 5. Używamy również zagnieżdżonych pętli for, aby zainicjować dwuwymiarową tablicę liczb całkowitych o nazwie myArray2D z wartościami {0, 1}, {1, 2} i {2, 3} przy użyciu wyrażenia i + j.
Następnie użyj dodatkowych pętli for, aby przejść przez każdy element każdej tablicy i wydrukować jego wartość w konsoli.
4: Inicjowanie tablic za pomocą funkcji Array.Copy()
Alternatywne podejście do inicjowania tablicy obejmuje użycie funkcji Array.Copy(). Obejmuje to utworzenie tablicy źródłowej z żądanymi elementami, a następnie skopiowanie ich do tablicy docelowej. Na przykład:
int [ ] źródło = { 1 , 2 , 3 , 4 , 5 } ;int [ ] cel = nowy int [ źródło.Długość ] ;
Tablica. Kopiuj ( źródło , cel, źródło. Długość ) ;
Ten kod tworzy tablicę liczb całkowitych o nazwie source z wartościami od 1 do 5, tworzy nową tablicę liczb całkowitych o nazwie target o takim samym rozmiarze jak źródło, a następnie kopiuje elementy ze źródła do miejsca docelowego.
Pozwólcie, że przedstawię przykład demonstrujący wykorzystanie Array.Copy do zainicjowania dwuwymiarowej tablicy liczb całkowitych w C#:
int [ , ] tablica źródłowa = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;int [ , ] docelowyArray = nowy int [ 3 , 2 ] ;
Tablica. Kopiuj ( tablica źródłowa, tablica docelowa, tablicaźródłowa.Długość ) ;
W tym przykładzie mamy dwuwymiarową tablicę liczb całkowitych o nazwie tablica źródłowa z 3 wierszami i 2 kolumnami. Używamy Array.Copy() aby skopiować zawartość sourceArray do nowej dwuwymiarowej tablicy liczb całkowitych o nazwie destinationArray, która również ma 3 wiersze i 2 kolumny.
The Array.Copy() metoda trwa trzy argumenty : tablica źródłowa , tablica docelowa , i długość danych do skopiowania. W tym przypadku kopiujemy całą zawartość pliku tablica źródłowa do tablica docelowa , więc mijamy sourceArray.Length jako trzeci argument.
Pamiętaj, że możesz użyć Tablica.Kopiuj() aby zainicjować tablice z dowolną liczbą wymiarów, o ile tablice źródłowa i docelowa mają taką samą liczbę wymiarów i ten sam rozmiar w każdym wymiarze.
Pamiętaj też o tym Tablica.Kopiuj() wykonuje płytką kopię tablicy źródłowej, co oznacza, że jeśli tablica źródłowa zawiera typy referencyjne, odniesienia zostaną skopiowane, ale same obiekty nie zostaną zduplikowane.
Oto pełny kod, który używa Tablica.Kopiuj() funkcja do inicjalizacji tablicy w C#:
przy użyciu Systemu;tablica klas
{
statyczna pustka Główny ( strunowy [ ] argumenty )
{
// Inicjowanie 1 -wymiarowa tablica przy użyciu Array.Copy
int [ ] źródłoTablica1D = { 1 , 2 , 3 , 4 , 5 } ;
int [ ] docelowyArray1D = nowy int [ 5 ] ;
Tablica. Kopiuj ( sourceArray1D, targetArray1D, sourceArray1D.Length ) ;
Console.WriteLine ( „Wartości w docelowej tablicy1D:” ) ;
Do ( int i = 0 ; I < miejsce doceloweArray1D.Length; i++ ) {
Console.WriteLine ( miejsce doceloweTablica1D [ I ] ) ;
}
// Inicjowanie 2 -wymiarowa tablica przy użyciu Array.Copy
int [ , ] źródłoTablica2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
int [ , ] docelowyArray2D = nowy int [ 3 , 2 ] ;
Tablica. Kopiuj ( sourceArray2D, targetArray2D, sourceArray2D.Length ) ;
Console.WriteLine ( „Wartości w miejscu docelowymArray2D:” ) ;
Do ( int i = 0 ; I < miejsce doceloweArray2D.GetLength ( 0 ) ; i++ ) {
Do ( int j = 0 ; J < miejsce doceloweArray2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, tablica docelowa2D [ ja, j ] ) ;
}
}
}
}
W tym kodzie używamy Array.Copy() aby zainicjować 1-wymiarową tablicę liczb całkowitych o nazwie docelowyArray1D z wartościami 1, 2, 3, 4 i 5 z tablicy źródłowej o nazwie sourceArray1D.
My również korzystamy Array.Copy() zainicjować dwuwymiarową tablicę liczb całkowitych o nazwie destinationArray2D z wartościami {1, 2}, {3, 4} i {5, 6} z tablicy źródłowej o nazwie sourceArray2D.
Następnie używamy dodatkowych pętli for, aby przejrzeć każdy element każdej tablicy i wydrukować jego wartość w konsoli.
Wniosek
W tym artykule zbadaliśmy różne sposoby inicjowania tablic w języku C#. Omówiliśmy składnię inicjatora tablic, używając słowa kluczowego new, inicjując tablice za pomocą pętli i używając metody Array.Copy(). W zależności od konkretnego przypadku użycia, każda z tych metod ma swój własny zestaw zalet i wad. Zapoznanie się z tymi różnymi podejściami pozwoli Ci wybrać najbardziej odpowiednie dla Twoich konkretnych wymagań.