Dalam C#, tatasusunan berfungsi sebagai bekas untuk menyimpan elemen jenis data yang sama. Apabila mencipta tatasusunan, terdapat pelbagai pendekatan untuk memulakannya dengan elemen. Artikel ini menyelidiki kaedah yang berbeza untuk memulakan tatasusunan dalam C#, menyediakan penerokaan menyeluruh bagi setiap pendekatan.
Kaedah Untuk Memulakan Tatasusunan dalam C#
Tatasusunan ialah struktur data penting dalam pengaturcaraan komputer yang membolehkan anda menyimpan dan memanipulasi koleksi elemen jenis data yang sama di lokasi memori bersebelahan. Berikut ialah beberapa cara untuk memulakan tatasusunan dalam C#:
1: Memulakan Tatasusunan Menggunakan Sintaks Pemula Tatasusunan
Pendekatan yang paling mudah untuk memulakan tatasusunan adalah dengan menggunakan sintaks pemula tatasusunan kerana ini melibatkan melampirkan elemen tatasusunan dalam pendakap, dipisahkan dengan koma, sebagai contoh:
int [ ] nombor = { 1 , 2 , 3 , 4 , 5 } ;
Dalam kod ini, tatasusunan integer bernama 'nombor' dicipta dan dimulakan dengan nilai 1 hingga 5. Begitu juga, anda boleh menggunakan sintaks yang sama untuk memulakan tatasusunan berbilang dimensi.
int [ , ] myMultiDimensionalArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Berikut ialah contoh kod yang menggunakan sintaks pemula untuk memulakan tatasusunan 1D dan 2D dalam C#:
menggunakan Sistem;
tatasusunan kelas
{
lompang statik Utama ( tali [ ] args )
{
// Memulakan tatasusunan 1D menggunakan sintaks pemula
int [ ] tatasusunan1D = { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'Nilai dalam array1D:' ) ;
untuk ( int i = 0 ; i < array1D.Length; i++ ) {
Console.WriteLine ( tatasusunan1D [ i ] ) ;
}
// Memulakan tatasusunan 2D menggunakan sintaks pemula
int [ , ] tatasusunan2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'Nilai dalam array2D:' ) ;
untuk ( int i = 0 ; i < array2D.GetLength ( 0 ) ; i++ ) {
untuk ( int j = 0 ; j < array2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, tatasusunan2D [ i, j ] ) ;
}
}
}
}
Dalam kod ini, kami menggunakan sintaks pemula untuk memulakan tatasusunan integer 1 dimensi yang dipanggil array1D dengan nilai 1, 2, 3, 4 dan 5.
Kami juga menggunakan sintaks pemula untuk memulakan tatasusunan integer 2 dimensi yang dipanggil array2D dengan nilai {1, 2}, {3, 4} dan {5, 6}.
Kami kemudian menggunakan tambahan untuk gelung untuk melelaran melalui setiap elemen setiap tatasusunan dan mencetak nilainya ke konsol.
2: Memulakan Tatasusunan Menggunakan Kata Kunci baharu
Kaedah tambahan untuk memulakan tatasusunan melibatkan penggunaan baru kata kunci. Ini melibatkan penetapan saiz tatasusunan dalam kurungan segi empat sama, diikuti dengan kata kunci baharu, dan kemudian jenis data unsur tatasusunan. Sebagai contoh:
int [ ] nombor = int baharu [ 5 ] ;
Kod ini mencipta tatasusunan integer bernama nombor dengan saiz 5 dan memulakan semua elemen kepada nilai lalainya, iaitu 0 untuk tatasusunan integer.
Berikut ialah sintaks untuk memulakan tatasusunan berbilang dimensi menggunakan kata kunci baharu dalam C#:
< taip > [ , ] < arrayName > = baru < taip > [ < panjang1 > , < panjang2 > , ... ] { { < nilai awal > } } ;
Dalam sintaks ini,
Berikut ialah contoh cara menggunakan sintaks ini untuk memulakan tatasusunan integer 2 dimensi:
int [ , ] myArray = int baharu [ 3 , 2 ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Dalam contoh ini, kami memulakan tatasusunan integer 2d yang dipanggil myArray dengan 3 baris dan 2 lajur menggunakan kata kunci baharu. Kami juga menyediakan nilai awal untuk setiap elemen tatasusunan menggunakan sintaks pendakap kerinting berganda. Nilainya ialah {1, 2}, {3, 4} dan {5, 6}, sepadan dengan elemen dalam setiap baris.
Berikut ialah contoh cara menggunakan kata kunci baharu untuk memulakan tatasusunan 1 dimensi dan 2 dimensi dalam C#, bersama-sama dengan kod untuk mencetak nilai dalam setiap tatasusunan:
menggunakan Sistem;tatasusunan kelas
{
lompang statik Utama ( tali [ ] args )
{
// Memulakan a 1 tatasusunan -dimensi
int [ ] myArray1D = int baharu [ ] { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( 'Nilai dalam myArray1D:' ) ;
untuk ( int i = 0 ; i < myArray1D.Length; i++ )
{
Console.WriteLine ( myArray1D [ i ] ) ;
}
// Memulakan a 2 tatasusunan -dimensi
int [ , ] myArray2D = int baharu [ , ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( 'Nilai dalam myArray2D:' ) ;
untuk ( int i = 0 ; i < myArray2D.GetLength ( 0 ) ; i++ )
{
untuk ( int j = 0 ; j < myArray2D.GetLength ( 1 ) ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ i, j ] ) ;
}
}
}
}
Dalam kod ini, kami menggunakan kata kunci baharu untuk memulakan tatasusunan integer satu dimensi yang dipanggil myArray1D dengan nilai 1, 2, 3, 4, dan 5, dan tatasusunan integer 2 dimensi dipanggil myArray2D dengan nilai {1, 2}, {3, 4} dan {5, 6}.
Kami kemudiannya menggunakan untuk gelung untuk lelaran melalui setiap elemen setiap tatasusunan dan mencetak nilainya ke konsol. Ambil perhatian bahawa untuk tatasusunan 2 dimensi, kami menggunakan GetLength() untuk menentukan bilangan baris dan lajur, dan menggunakan gelung bersarang untuk berulang melalui setiap elemen.
3: Memulakan Tatasusunan Menggunakan Gelung
Tatasusunan juga boleh dimulakan menggunakan gelung. Satu pendekatan adalah dengan menggunakan gelung for, yang membolehkan anda mengulangi tatasusunan dan memberikan nilai kepada setiap elemen.
int [ ] nombor = int baharu [ 5 ] ;untuk ( int i = 0 ; i < nombor.Panjang; i++ )
{
nombor [ i ] = i + 1 ;
}
Kod ini mencipta tatasusunan integer bernama nombor dengan saiz 5 dan memberikan setiap elemen nilai yang sama dengan indeksnya tambah 1. Berikut ialah contoh cara untuk memulakan tatasusunan integer 2 dimensi dalam C# menggunakan gelung:
untuk ( int i = 0 ; i < 3 ; i++ )
{
untuk ( int j = 0 ; j < 2 ; j++ )
{
myArray [ i, j ] = i + j;
}
}
Dalam contoh ini, kami menggunakan gelung bersarang untuk melelaran melalui setiap elemen tatasusunan integer 2 dimensi yang dipanggil myArray , yang mempunyai 3 baris dan 2 lajur. Untuk setiap elemen, kami menetapkan nilainya kepada jumlah indeks baris dan lajurnya menggunakan ungkapan i + j.
Berikut ialah contoh cara menggunakan gelung untuk memulakan tatasusunan 1-dimensi dan 2-dimensi dalam C#, bersama-sama dengan kod untuk mencetak nilai dalam setiap tatasusunan:
menggunakan Sistem;tatasusunan kelas
{
lompang statik Utama ( tali [ ] args )
{
// Memulakan a 1 tatasusunan -dimensi menggunakan gelung
int [ ] myArray1D = int baharu [ 5 ] ;
untuk ( int i = 0 ; i < myArray1D.Length; i++ )
{
myArray1D [ i ] = i + 1 ;
}
Console.WriteLine ( 'Nilai dalam myArray1D:' ) ;
untuk ( int i = 0 ; i < myArray1D.Length; i++ )
{
Console.WriteLine ( myArray1D [ i ] ) ;
}
// Memulakan a 2 tatasusunan -dimensi menggunakan gelung bersarang
int [ , ] myArray2D = int baharu [ 3 , 2 ] ;
untuk ( int i = 0 ; i < 3 ; i++ )
{
untuk ( int j = 0 ; j < 2 ; j++ )
{
myArray2D [ i, j ] = i + j;
}
}
Console.WriteLine ( 'Nilai dalam myArray2D:' ) ;
untuk ( int i = 0 ; i < 3 ; i++ )
{
untuk ( int j = 0 ; j < 2 ; j++ )
{
Console.WriteLine ( '({0}, {1}): {2}' , i, j, myArray2D [ i, j ] ) ;
}
}
}
}
Dalam kod ini, kami menggunakan gelung for untuk memulakan tatasusunan integer 1 dimensi yang dipanggil myArray1D dengan nilai 1, 2, 3, 4 dan 5. Kami juga menggunakan gelung bersarang untuk memulakan tatasusunan integer 2 dimensi yang dipanggil myArray2D dengan nilai {0, 1}, {1, 2} dan {2, 3} menggunakan ungkapan i + j.
Kemudian gunakan tambahan untuk gelung untuk melelaran melalui setiap elemen setiap tatasusunan dan mencetak nilainya ke konsol.
4: Memulakan Tatasusunan Menggunakan Array.Copy()
Pendekatan alternatif untuk memulakan tatasusunan melibatkan penggunaan fungsi Array.Copy(). Ini melibatkan mencipta tatasusunan sumber dengan elemen yang dikehendaki dan kemudian menyalinnya ke tatasusunan sasaran. Sebagai contoh:
int [ ] sumber = { 1 , 2 , 3 , 4 , 5 } ;int [ ] sasaran = int baharu [ sumber.Panjang ] ;
Susunan.Salin ( sumber , sasaran, sumber. Panjang ) ;
Kod ini mencipta tatasusunan integer bernama sumber dengan nilai 1 hingga 5, mencipta tatasusunan integer baharu bernama sasaran dengan saiz yang sama seperti sumber, dan kemudian menyalin elemen dari sumber ke sasaran.
Benarkan saya membentangkan contoh yang menunjukkan penggunaan Array.Copy untuk memulakan tatasusunan integer dua dimensi dalam C#:
int [ , ] sourceArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;int [ , ] destinationArray = new int [ 3 , 2 ] ;
Susunan.Salin ( sourceArray, destinationArray, sourceArray.Length ) ;
Dalam contoh ini, kita mempunyai tatasusunan integer 2 dimensi dipanggil sourceArray dengan 3 baris dan 2 lajur. Kami sedang menggunakan Array.Copy() untuk menyalin kandungan sourceArray ke dalam tatasusunan integer 2 dimensi baharu yang dipanggil destinationArray, yang juga mempunyai 3 baris dan 2 lajur.
The Array.Copy() kaedah mengambil tiga hujah : yang tatasusunan sumber , yang susunan destinasi , dan juga panjang daripada data yang akan disalin. Dalam kes ini, kami menyalin keseluruhan kandungan sourceArray ke dalam destinationArray , jadi kami lulus sourceArray.Length sebagai hujah ketiga.
Perhatikan bahawa anda boleh menggunakan Array.Copy() untuk memulakan tatasusunan dengan sebarang bilangan dimensi, asalkan tatasusunan sumber dan destinasi mempunyai bilangan dimensi yang sama dan saiz yang sama dalam setiap dimensi.
Juga, perlu diingat bahawa Array.Copy() melakukan salinan cetek tatasusunan sumber, yang bermaksud bahawa jika tatasusunan sumber mengandungi jenis rujukan, rujukan akan disalin tetapi objek itu sendiri tidak akan diduplikasi.
Berikut adalah kod lengkap yang digunakan Array.Copy() fungsi untuk memulakan tatasusunan dalam C#:
menggunakan Sistem;tatasusunan kelas
{
lompang statik Utama ( tali [ ] args )
{
// Memulakan a 1 tatasusunan -dimensi menggunakan Array.Copy
int [ ] sourceArray1D = { 1 , 2 , 3 , 4 , 5 } ;
int [ ] destinationArray1D = int baharu [ 5 ] ;
Susunan.Salin ( sourceArray1D, destinationArray1D, sourceArray1D.Length ) ;
Console.WriteLine ( 'Nilai dalam destinationArray1D:' ) ;
untuk ( int i = 0 ; i < destinationArray1D.Length; i++ ) {
Console.WriteLine ( destinationArray1D [ i ] ) ;
}
// Memulakan a 2 tatasusunan -dimensi menggunakan Array.Copy
int [ , ] sourceArray2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
int [ , ] destinationArray2D = int baharu [ 3 , 2 ] ;
Susunan.Salin ( sourceArray2D, destinationArray2D, sourceArray2D.Length ) ;
Console.WriteLine ( 'Nilai dalam destinationArray2D:' ) ;
untuk ( int i = 0 ; i < destinationArray2D.GetLength ( 0 ) ; i++ ) {
untuk ( int j = 0 ; j < destinationArray2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( '({0}, {1}): {2}' , i, j, destinationArray2D [ i, j ] ) ;
}
}
}
}
Dalam kod ini, kami menggunakan Array.Copy() untuk memulakan tatasusunan integer 1 dimensi yang dipanggil destinationArray1D dengan nilai 1, 2, 3, 4 dan 5 daripada tatasusunan sumber yang dipanggil sourceArray1D.
Kami juga menggunakan Array.Copy() untuk memulakan tatasusunan integer 2 dimensi yang dipanggil destinationArray2D dengan nilai {1, 2}, {3, 4} dan {5, 6} daripada tatasusunan sumber yang dipanggil sourceArray2D.
Kami kemudiannya menggunakan tambahan untuk gelung untuk lelaran melalui setiap elemen setiap tatasusunan dan mencetak nilainya ke konsol.
Kesimpulan
Dalam artikel ini, kami meneroka cara yang berbeza untuk memulakan tatasusunan dalam C#. Kami merangkumi sintaks pemula tatasusunan, menggunakan kata kunci baharu, memulakan tatasusunan menggunakan gelung dan menggunakan kaedah Array.Copy(). Bergantung pada kes penggunaan tertentu, setiap kaedah ini mempunyai set kelebihan dan kekurangannya sendiri. Membiasakan diri dengan pendekatan yang pelbagai ini akan membolehkan anda memilih pendekatan yang paling sesuai untuk keperluan khusus anda.