Storan data.
Andaikan anda telah membangunkan permainan komputer yang dipanggil "User Hostile" di mana pemain bersaing dengan berbelit-belit dan tidak mesra antara muka komputer. Kini anda perlu menulis program yang menjejaki jualan bulanan permainan ini dalam tempoh lima tahun. Atau katakan anda perlu menginventori Kad Dagangan Hero Penggodam.
Tidak lama lagi anda akan membuat kesimpulan bahawa anda memerlukan lebih daripada jenis data asas yang mudah untuk menyimpan dan memproses maklumat.
Susunatur. Pengenalan.
Untuk memudahkan kerja dengan jumlah data yang besar, sekumpulan sel diberikan nama. Kumpulan sel sedemikian dipanggil tatasusunan.
Array – ia adalah sekumpulan sel memori daripada jenis yang sama, terletak bersebelahan dan mempunyai nama yang sama. Setiap sel dalam kumpulan mempunyai nombor unik.
Terdapat tiga perkara yang anda perlu pelajari apabila bekerja dengan tatasusunan:
x memperuntukkan memori saiz yang diperlukan untuk tatasusunan;
x tulis data ke sel yang dikehendaki;
x baca data daripada sel.
Buat tatasusunan.
Apabila mencipta tatasusunan, ruang diperuntukkan dalam memori (sebilangan sel).
1) Tatasusunan boleh dibuat dengan hanya menghitung elemen:
int[] nums = < kod>baharu int[] { 1, 2, 3, 5 };
int bermakna semua objek dalam tatasusunan adalah integer. Sebagai ganti int boleh terdapat sebarang jenis data lain. Sebagai contoh,
rentetan[] nama = ["Vasya", "Peter", "Fedya"];
2) Kami tidak boleh menentukan nilai tatasusunan dengan segera, tetapi hanya mencipta tatasusunan panjang yang kami perlukan.
int[] nums = new int[4];
3) Tatasusunan sentiasa "tahu" saiz anda. Saiz tatasusunan a boleh didapati seperti ini:
a.Length;
Selalunya saiz tatasusunan disimpan dalam pembolehubah yang berasingan supaya atur cara boleh ditukar dengan mudah untuk berfungsi dengan saiz tatasusunan yang berbeza. Contoh:
int N = 10; // simpan saiz tatasusunan dalam pembolehubah N
int[] nums = new int[4]; // buat tatasusunan saiz N
Console.Write(nums.Length); // memaparkan saiz tatasusunan
Saiz tatasusunan boleh ditetapkan daripada papan kekunci.
|
Merujuk kepada elemen tatasusunan.
Kebanyakan kegunaan tatasusunan datang daripada fakta bahawa elemennya boleh diakses secara individu.
Cara untuk melakukannya ialah dengan menggunakan indeks untuk menomborkan elemen.
Indeks ialah nilai yang menunjuk kepada elemen tatasusunan tertentu.
Ingat: Penomboran tatasusunan C# bermula pada sifar.< br />
Contoh mengakses tatasusunan A:
int x = (A[3] + 5) * A[1] / / baca nilai A[3] dan A[1]
A[0] = x + 6 // tulis nilai baharu kepada A[0]
Mari kita analisis atur cara untuk bekerja dengan elemen tatasusunan.
int i = 1;
int[] A = new int[5]; //buat tatasusunan 5 elemen
A[0] = 23; // kepada setiap 5 elemen tatasusunan (indeks dari 0 hingga 4)
A[1] = 12; // tulis nilai tertentu
A[2] = 7;
A[3] = 43;
A[4] = 51;
A[2] = A[i] + 2*A[i-1] + A[2*i]; // tukar nilai elemen dengan indeks 2 kepada hasil ungkapan
// kerana i=1, kemudian menggantikan nilai pembolehubah i ke dalam ungkapan yang kita dapat
// ungkapan seterusnya A[2] = A[1] + 2*A[0] + A[2];
Console.Write((A[2] + A[4]));
Hasil daripada melaksanakan atur cara ini, nilai jumlah elemen tatasusunan dengan indeks 2 dan dengan indeks 4 akan muncul pada skrin, bersamaan dengan 116. Seperti yang anda lihat daripada contoh, kami boleh mengakses mana-mana elemen tatasusunan. Dan juga mengira nombor elemen yang diperlukan menggunakan pelbagai formula (contohnya, seperti dalam program A[i-1] atau A[2*i], dalam kes ini, indeks elemen akan dikira dan bergantung pada nilai i).
Mari analisa contoh atur cara.
int N = 5;
int[] A = int baharu[N];
int x = 1;
A[x + 4] = A[x] + A[2 * (x + 1)]; // selepas menggantikan x ke dalam ungkapan dan pengiraan
// dapatkan baris seterusnya A[5] = A[1] + A[4]
// A[5] tiada unsur sedemikian wujud
// ralat - tatasusunan di luar sempadan
Tatasusunan diisytiharkan dengan 5 elemen, yang bermaksud elemen akan diberi nombor dari 0 hingga 4. Kami melihat, bahawa atur cara dalam baris ke-6 merujuk kepada elemen yang tidak wujud: A[5].
Ternyata program itu telah melampaui batas tatasusunan.
Larian tatasusunan ialah akses kepada elemen pada indeks yang tidak wujud dalam tatasusunan.
Dalam kes sedemikian, program biasanya ranap dengan ralat masa jalan.
|
Apabila bekerja dengan tatasusunan, anda biasanya perlu bekerja dengan semua elemen tatasusunan sekaligus.
Lelaran ke atas elemen: kami melihat semua elemen tatasusunan dan, jika perlu, lakukan beberapa operasi dengan setiap elemen.
Untuk ini, gelung dengan pembolehubah paling kerap digunakan, yang berubah daripada 0 kepada N-1, dengan N ialah nombor unsur tatasusunan.
Di bawah N kami akan mempertimbangkan saiz semasa tatasusunan, iaitu,
N = A.Length;
...
untuk (int i = 0; i < N; i++)
{
// di sini kita bekerja dengan A[i]
}
Dalam gelung yang ditentukan, pembolehubah i akan mengambil nilai 0, 1, 2, ..., N-1. Oleh itu, pada setiap langkah gelung, kami mengakses elemen khusus tatasusunan dengan nombor i.
Iaitu, sudah cukup untuk menerangkan perkara yang perlu dilakukan dengan satu elemen tatasusunan A[i] dan meletakkan tindakan ini di dalam gelung sedemikian.
Mari tulis atur cara yang mengisi tatasusunan dengan N nombor semula jadi yang pertama, iaitu, pada penghujung atur cara, elemen tatasusunan harus menjadi sama
A[0] = 1
A[1] = 2
A[2] = 3
...
A[N - 1] = N
Mudah untuk melihat corak: nilai elemen tatasusunan mestilah lebih besar sebanyak 1 daripada indeks unsur.
Gelung akan kelihatan seperti ini
untuk (int i = 0; i < N; i++) { A[ i] = i + 1; }
|
Cara tambahan untuk bekerja dengan elemen tatasusunan
Kecuali untuk untuk , anda juga boleh menggunakan foreach - ia melelang ke atas semua elemen tatasusunan, tanpa menggunakan indeks. Kadangkala ia boleh menjadi mudah, sebagai contoh, untuk memaparkan tatasusunan pada skrin.
foreach(int i dalam A)
{
Console.Write(i + " ");
}
Dan ini adalah cara anda boleh membaca tatasusunan, elemen yang ditulis pada satu baris dan dipisahkan oleh ruang, dari papan kekunci.
menggunakan System.Linq; // anda perlu menulis arahan ini untuk menggunakan fungsi yang berkaitan dengan bekerja dengan tatasusunan
...
teks rentetan = Console.ReadLine();
int[] tatasusunan = teks.Split(' ').Pilih(int.Parse).ToArray();
// Split() membelah rentetan menjadi objek berasingan (dalam kes ini, pembahagian ruang)
// Select(int.Parse) menukarkan setiap objek (rentetan) kepada int
// ToArray() menulis semua objek yang diterima ke array
|