[Powered by Google Translate] Mari kita bercakap tentang tatasusunan.
Jadi mengapa kita pernah mahu untuk menggunakan tatasusunan?
Nah mari kita katakan anda mempunyai satu program yang perlu untuk menyimpan 5 ID pelajar.
Ia mungkin kelihatan munasabah untuk mempunyai 5 pembolehubah yang berasingan.
Atas sebab-sebab yang kita akan melihat dalam sedikit, kita akan mula mengira dari 0.
Pembolehubah kita akan mempunyai akan menjadi id0 int, ID1 int, dan sebagainya.
Mana-mana logik kita mahu untuk melaksanakan pada ID pelajar akan perlu disalin dan ditampal
bagi setiap ID pelajar.
Jika kita mahu untuk memeriksa pelajar yang berada di CS50,
kita mula-mula akan perlu untuk memeriksa jika id0 mewakili pelajar dalam kursus ini.
Kemudian untuk melakukan perkara yang sama untuk pelajar seterusnya, kita akan perlu untuk copy dan paste kod untuk id0
dan menggantikan semua kejadian id0 dengan ID1 dan sebagainya untuk id2, 3, dan 4.
>> Sebaik sahaja anda mendengar bahawa kita perlu salin dan tampal,
anda perlu mula berfikir bahawa terdapat satu penyelesaian yang lebih baik.
Sekarang apa jika anda sedar anda tidak perlu 5 ID pelajar tetapi 7?
Anda perlu untuk kembali ke dalam kod sumber anda dan menambah dalam id5, id6,
dan copy dan paste logik untuk memeriksa jika ID tergolong dalam kelas ini 2 ID baru.
Tiada apa yang menghubungkan semua ini ID bersama-sama, dan sebagainya tidak ada cara meminta-minta
program untuk melakukan ini untuk ID 0 melalui 6.
Nah sekarang anda sedar anda mempunyai 100 ID pelajar.
Ia mula kelihatan kurang daripada yang ideal perlu untuk berasingan mengisytiharkan setiap ID ini,
dan copy dan paste mana-mana logik bagi mereka ID baru.
Tetapi mungkin kita ditentukan, dan kita melakukannya untuk semua 100 pelajar.
Tetapi bagaimana jika anda tidak tahu bagaimana ramai pelajar yang ada sebenarnya?
Terdapat hanya beberapa pelajar n dan program anda mempunyai bertanya kepada pengguna apa yang n.
Oh. Ini tidak akan bekerja sangat baik.
Program anda hanya berfungsi untuk beberapa beberapa berterusan pelajar.
>> Menyelesaikan semua masalah-masalah ini adalah keindahan tatasusunan.
Jadi apa yang adalah array?
Dalam beberapa bahasa pengaturcaraan pelbagai jenis mungkin dapat melakukan sedikit lebih,
tetapi di sini kita akan memberi tumpuan kepada pelbagai struktur data asas seperti yang anda akan melihat di C.
Pelbagai adalah hanya satu blok besar memori. Itu sahaja.
Apabila kita mengatakan kita mempunyai pelbagai sebanyak 10 integer, yang hanya bermakna kita mempunyai beberapa blok
memori yang cukup besar untuk memegang 10 integer berasingan.
Mengandaikan bahawa integer adalah 4 bait, ini bermakna bahawa pelbagai sebanyak 10 integer
adalah blok berterusan 40 bait dalam ingatan.
Malah apabila anda menggunakan tatasusunan multidimensi, yang kita tidak akan pergi ke sini,
ia masih hanya satu blok besar memori.
Notasi multidimensi hanyalah kemudahan.
Jika anda mempunyai 3 oleh 3 pelbagai multidimensi integer,
maka program anda akan benar-benar hanya merawat ini sebagai blok besar daripada 36 bait.
Jumlah integer adalah 3 kali 3, dan integer setiap mengambil masa sehingga 4 bait.
>> Mari kita lihat pada contoh asas.
Kita boleh lihat di sini 2 cara yang berbeza tatasusunan mengisytiharkan.
Kami akan mempunyai mengulas 1 daripada mereka keluar untuk program untuk menyusun
kerana kita mengisytiharkan x dua kali.
Kami akan mengambil kelihatan di beberapa perbezaan antara kedua-2 jenis perisytiharan dalam sedikit.
Kedua-dua garisan ini mengisytiharkan pelbagai N saiz,
di mana kita telah # mentakrifkan N sebagai 10.
Kita boleh hanya sebagai mudah telah meminta pengguna untuk integer positif
dan digunakan bahawa integer sebagai beberapa elemen dalam array kami.
Seperti contoh ID pelajar kami sebelum ini, ini adalah semacam mengisytiharkan 10 yang berasingan
pembolehubah khayalan; x0, x1, x2, dan sebagainya sehingga ke xn-1.
Mengabaikan garis mana kita mengisytiharkan array, notis kurungan persegi utuh
di dalam untuk gelung.
Apabila kita menulis sesuatu seperti x [3], yang saya hanya akan membaca sebagai x kurungan 3,
anda boleh berfikir ia suka meminta x3 khayalan.
Notis daripada dengan pelbagai saiz N, ini bermakna bahawa nombor di dalam kurungan,
yang kita akan memanggil indeks, boleh menjadi apa-apa dari 0 hingga N-1,
yang merupakan sejumlah N indeks.
>> Untuk berfikir tentang bagaimana ini sebenarnya berfungsi
ingat bahawa array adalah blok memori yang besar.
Mengandaikan bahawa integer adalah 4 bait, x array keseluruhan adalah blok 40 bait memori.
Jadi x0 merujuk kepada 4 bait yang sangat pertama blok.
X [1] merujuk kepada 4 bait akan datang dan sebagainya.
Ini bermakna bahawa permulaan x adalah semua program yang pernah perlu untuk menjejaki.
Jika anda mahu menggunakan x [400], maka program ini tahu bahawa ini adalah bersamaan
kepada hanya 1,600 bait selepas permulaan x.
Dari mana asalnya kita akan mendapat 1,600 bait dari? Ia hanya 400 kali 4 bait setiap integer.
>> Sebelum bergerak ke atas, ia amat penting untuk menyedari bahawa dalam C
tidak ada penguatkuasaan indeks yang kita gunakan dalam array.
Blok besar kami adalah hanya 10 integer panjang, tetapi tiada apa yang akan menjerit pada kita jika kita menulis x [20]
ataupun x [-5].
Indeks tidak perlu untuk menjadi nombor.
Ia boleh menjadi apa-apa ungkapan yang sewenang-wenangnya.
Dalam program ini kita menggunakan i pembolehubah daripada gelung untuk indeks ke dalam array.
Ini adalah corak yang sangat biasa, menggelung dari i = 0 untuk panjang array,
dan kemudian menggunakan i sebagai indeks untuk array.
Dengan cara ini anda berkesan gelung seluruh array,
dan sama ada anda boleh menetapkan ke tempat masing-masing dalam pelbagai atau menggunakannya untuk pengiraan tertentu.
>> Dalam pertama bagi gelung, i bermula pada 0,
dan sebagainya ia akan memberikan tempat 0 dalam array, nilai 0 times 2.
Kemudian i kenaikan, dan kami sediakan tempat pertama dalam pelbagai nilai 1 kali 2.
Kemudian i kenaikan lagi dan sebagainya naik sehingga kami sediakan untuk meletakkan N-1 dalam array
nilai N-1 kali 2.
Jadi kita telah mencipta pelbagai dengan 10 nombor pertama walaupun.
Mungkin evens akan menjadi nama yang sedikit lebih baik bagi pembolehubah daripada x,
tetapi yang akan diberikan sesuatu.
Kedua untuk gelung kemudian hanya mencetak nilai-nilai yang kita telah disimpan di dalam array.
>> Mari kita cuba menjalankan program dengan kedua-dua jenis pengisytiharan pelbagai
dan lihat pada output program.
Setakat yang kita boleh lihat, program itu berkelakuan dengan cara yang sama bagi kedua-dua jenis perisytiharan.
Mari kita juga mengambil melihat apa yang berlaku jika kita menukar gelung pertama tidak berhenti di N
tetapi sebaliknya berkata 10,000.
Cara luar akhir array.
Oops. Mungkin anda telah melihat sebelum ini.
Satu kesalahan segmentasi bermakna program anda telah terhempas.
Anda mula melihat ini apabila anda menyentuh kawasan ingatan anda tidak perlu menyentuh.
Di sini kita menyentuh 10,000 tempat luar permulaan x,
yang jelas adalah tempat dalam ingatan kita tidak harus menyentuh.
Jadi kebanyakan kita mungkin akan tidak sengaja meletakkan 10.000 bukannya N,
tetapi apa yang jika kita melakukan sesuatu yang lebih halus seperti mengatakan hapus kurang daripada atau sama dengan N
dalam keadaan gelung untuk berbanding dengan kurang daripada N.
Ingatlah bahawa array hanya mempunyai indeks dari 0 hingga N-1,
yang bermaksud bahawa indeks N adalah di luar akhir array.
Program ini tidak mungkin kemalangan dalam kes ini, tetapi ia masih ralat.
Malah, kesilapan ini adalah begitu umum bahawa ia mempunyai nama sendiri,
luar oleh 1 kesilapan.
>> Itulah untuk asas.
Jadi, apakah perbezaan utama antara 2 jenis pengisytiharan pelbagai?
Satu perbezaan adalah di mana blok memori yang besar pergi.
Dalam deklarasi pertama, yang saya akan memanggil jenis kurungan pelbagai,
walaupun ini adalah tidak bermaksud nama konvensional,
ia akan pergi pada timbunan.
Manakala di tempat kedua, yang saya akan memanggil jenis penunjuk pelbagai, ia akan pergi pada timbunan.
Ini bermakna bahawa apabila pulangan fungsi, array kurungan secara automatik akan deallocated,
sedangkan sebagai anda explicitily mesti memanggil bebas pada pelbagai penunjuk
atau lain anda mempunyai kebocoran memori.
Selain itu, pelbagai pendakap tidak sebenarnya adalah pembolehubah.
Ini adalah penting. Ia hanya simbol.
Anda boleh berfikir ia sebagai pemalar bahawa pengkompil memilih untuk anda.
Ini bermakna bahawa kita tidak boleh melakukan sesuatu seperti x + + dengan jenis kurungan,
walaupun ini adalah betul-betul sah dengan jenis penunjuk.
>> Jenis penunjuk adalah pembolehubah.
Untuk jenis penunjuk, kita mempunyai 2 blok memori yang berasingan.
X ubah sendiri disimpan dalam timbunan dan hanya penunjuk tunggal,
tetapi blok memori yang besar disimpan pada timbunan.
X ubah pada timbunan hanya menyimpan alamat
blok besar memori pada timbunan.
Salah satu implikasi ini adalah dengan saiz pengendali.
Jika anda bertanya saiz array kurungan, ia akan memberikan anda saiz blok besar memori,
sesuatu seperti 40 bytes,
tetapi jika anda bertanya untuk saiz jenis penunjuk pelbagai,
ia akan memberikan anda saiz x ubah sendiri, yang pada perkakas mungkin hanya 4 bait.
Menggunakan pelbagai jenis penunjuk, ia adalah mustahil untuk terus meminta
saiz blok besar memori.
Ini bukan biasanya banyak sekatan kerana kita sangat jarang mahu saiz
blok besar memori, dan biasanya kita boleh mengira jika kita perlu.
>> Akhirnya, pelbagai kurungan berlaku untuk menyediakan kami dengan jalan pintas untuk Memulakan array.
Mari kita lihat bagaimana kita boleh menulis pertama 10 integer walaupun menggunakan initilization jalan pintas.
Dengan pelbagai penunjuk, tidak ada satu cara untuk melakukan jalan pintas seperti ini.
Ini hanya pengenalan kepada apa yang anda boleh lakukan dengan tatasusunan.
Mereka muncul dalam hampir setiap program yang anda tulis.
Semoga anda kini boleh melihat cara yang lebih baik daripada melakukan contoh pelajar ID
dari permulaan video.
>> Nama saya adalah Rob Bowden, dan ini adalah CS50.