1
00:00:07,360 --> 00:00:09,360
[Powered by Google Translate] Mari kita bercakap tentang tatasusunan.

2
00:00:09,360 --> 00:00:12,780
Jadi mengapa kita pernah mahu untuk menggunakan tatasusunan?

3
00:00:12,780 --> 00:00:17,210
Nah mari kita katakan anda mempunyai satu program yang perlu untuk menyimpan 5 ID pelajar.

4
00:00:17,210 --> 00:00:21,270
Ia mungkin kelihatan munasabah untuk mempunyai 5 pembolehubah yang berasingan.

5
00:00:21,270 --> 00:00:24,240
Atas sebab-sebab yang kita akan melihat dalam sedikit, kita akan mula mengira dari 0.

6
00:00:24,240 --> 00:00:30,700
Pembolehubah kita akan mempunyai akan menjadi id0 int, ID1 int, dan sebagainya.

7
00:00:30,700 --> 00:00:34,870
Mana-mana logik kita mahu untuk melaksanakan pada ID pelajar akan perlu disalin dan ditampal

8
00:00:34,870 --> 00:00:36,870
bagi setiap ID pelajar.

9
00:00:36,870 --> 00:00:39,710
Jika kita mahu untuk memeriksa pelajar yang berada di CS50,

10
00:00:39,710 --> 00:00:43,910
kita mula-mula akan perlu untuk memeriksa jika id0 mewakili pelajar dalam kursus ini.

11
00:00:43,910 --> 00:00:48,070
Kemudian untuk melakukan perkara yang sama untuk pelajar seterusnya, kita akan perlu untuk copy dan paste kod untuk id0

12
00:00:48,070 --> 00:00:54,430
dan menggantikan semua kejadian id0 dengan ID1 dan sebagainya untuk id2, 3, dan 4.

13
00:00:54,430 --> 00:00:57,560
>> Sebaik sahaja anda mendengar bahawa kita perlu salin dan tampal,

14
00:00:57,560 --> 00:01:00,440
anda perlu mula berfikir bahawa terdapat satu penyelesaian yang lebih baik.

15
00:01:00,440 --> 00:01:05,360
Sekarang apa jika anda sedar anda tidak perlu 5 ID pelajar tetapi 7?

16
00:01:05,360 --> 00:01:09,570
Anda perlu untuk kembali ke dalam kod sumber anda dan menambah dalam id5, id6,

17
00:01:09,570 --> 00:01:14,260
dan copy dan paste logik untuk memeriksa jika ID tergolong dalam kelas ini 2 ID baru.

18
00:01:14,260 --> 00:01:19,600
Tiada apa yang menghubungkan semua ini ID bersama-sama, dan sebagainya tidak ada cara meminta-minta

19
00:01:19,600 --> 00:01:22,040
program untuk melakukan ini untuk ID 0 melalui 6.

20
00:01:22,040 --> 00:01:26,120
Nah sekarang anda sedar anda mempunyai 100 ID pelajar.

21
00:01:26,120 --> 00:01:30,770
Ia mula kelihatan kurang daripada yang ideal perlu untuk berasingan mengisytiharkan setiap ID ini,

22
00:01:30,770 --> 00:01:33,760
dan copy dan paste mana-mana logik bagi mereka ID baru.

23
00:01:33,760 --> 00:01:38,380
Tetapi mungkin kita ditentukan, dan kita melakukannya untuk semua 100 pelajar.

24
00:01:38,380 --> 00:01:42,240
Tetapi bagaimana jika anda tidak tahu bagaimana ramai pelajar yang ada sebenarnya?

25
00:01:42,240 --> 00:01:47,320
Terdapat hanya beberapa pelajar n dan program anda mempunyai bertanya kepada pengguna apa yang n.

26
00:01:47,320 --> 00:01:50,250
Oh. Ini tidak akan bekerja sangat baik.

27
00:01:50,250 --> 00:01:53,820
Program anda hanya berfungsi untuk beberapa beberapa berterusan pelajar.

28
00:01:53,820 --> 00:01:57,520
>> Menyelesaikan semua masalah-masalah ini adalah keindahan tatasusunan.

29
00:01:57,520 --> 00:01:59,930
Jadi apa yang adalah array?

30
00:01:59,930 --> 00:02:04,480
Dalam beberapa bahasa pengaturcaraan pelbagai jenis mungkin dapat melakukan sedikit lebih,

31
00:02:04,480 --> 00:02:09,960
tetapi di sini kita akan memberi tumpuan kepada pelbagai struktur data asas seperti yang anda akan melihat di C.

32
00:02:09,960 --> 00:02:14,030
Pelbagai adalah hanya satu blok besar memori. Itu sahaja.

33
00:02:14,030 --> 00:02:17,770
Apabila kita mengatakan kita mempunyai pelbagai sebanyak 10 integer, yang hanya bermakna kita mempunyai beberapa blok

34
00:02:17,770 --> 00:02:20,740
memori yang cukup besar untuk memegang 10 integer berasingan.

35
00:02:29,930 --> 00:02:33,410
Mengandaikan bahawa integer adalah 4 bait, ini bermakna bahawa pelbagai sebanyak 10 integer

36
00:02:33,410 --> 00:02:37,180
adalah blok berterusan 40 bait dalam ingatan.

37
00:02:42,660 --> 00:02:46,280
Malah apabila anda menggunakan tatasusunan multidimensi, yang kita tidak akan pergi ke sini,

38
00:02:46,280 --> 00:02:49,200
ia masih hanya satu blok besar memori.

39
00:02:49,200 --> 00:02:51,840
Notasi multidimensi hanyalah kemudahan.

40
00:02:51,840 --> 00:02:55,640
Jika anda mempunyai 3 oleh 3 pelbagai multidimensi integer,

41
00:02:55,640 --> 00:03:00,650
maka program anda akan benar-benar hanya merawat ini sebagai blok besar daripada 36 bait.

42
00:03:00,650 --> 00:03:05,460
Jumlah integer adalah 3 kali 3, dan integer setiap mengambil masa sehingga 4 bait.

43
00:03:05,460 --> 00:03:07,750
>> Mari kita lihat pada contoh asas.

44
00:03:07,750 --> 00:03:10,660
Kita boleh lihat di sini 2 cara yang berbeza tatasusunan mengisytiharkan.

45
00:03:15,660 --> 00:03:18,580
Kami akan mempunyai mengulas 1 daripada mereka keluar untuk program untuk menyusun

46
00:03:18,580 --> 00:03:20,900
kerana kita mengisytiharkan x dua kali.

47
00:03:20,900 --> 00:03:25,140
Kami akan mengambil kelihatan di beberapa perbezaan antara kedua-2 jenis perisytiharan dalam sedikit.

48
00:03:25,140 --> 00:03:28,560
Kedua-dua garisan ini mengisytiharkan pelbagai N saiz,

49
00:03:28,560 --> 00:03:30,740
di mana kita telah # mentakrifkan N sebagai 10.

50
00:03:30,740 --> 00:03:34,460
Kita boleh hanya sebagai mudah telah meminta pengguna untuk integer positif

51
00:03:34,460 --> 00:03:37,250
dan digunakan bahawa integer sebagai beberapa elemen dalam array kami.

52
00:03:37,250 --> 00:03:41,960
Seperti contoh ID pelajar kami sebelum ini, ini adalah semacam mengisytiharkan 10 yang berasingan

53
00:03:41,960 --> 00:03:49,000
pembolehubah khayalan; x0, x1, x2, dan sebagainya sehingga ke xn-1.

54
00:03:57,270 --> 00:04:00,840
Mengabaikan garis mana kita mengisytiharkan array, notis kurungan persegi utuh

55
00:04:00,840 --> 00:04:02,090
di dalam untuk gelung.

56
00:04:02,090 --> 00:04:09,660
Apabila kita menulis sesuatu seperti x [3], yang saya hanya akan membaca sebagai x kurungan 3,

57
00:04:09,660 --> 00:04:13,090
anda boleh berfikir ia suka meminta x3 khayalan.

58
00:04:13,090 --> 00:04:17,519
Notis daripada dengan pelbagai saiz N, ini bermakna bahawa nombor di dalam kurungan,

59
00:04:17,519 --> 00:04:22,630
yang kita akan memanggil indeks, boleh menjadi apa-apa dari 0 hingga N-1,

60
00:04:22,630 --> 00:04:25,660
yang merupakan sejumlah N indeks.

61
00:04:25,660 --> 00:04:28,260
>> Untuk berfikir tentang bagaimana ini sebenarnya berfungsi

62
00:04:28,260 --> 00:04:31,260
ingat bahawa array adalah blok memori yang besar.

63
00:04:31,260 --> 00:04:37,460
Mengandaikan bahawa integer adalah 4 bait, x array keseluruhan adalah blok 40 bait memori.

64
00:04:37,460 --> 00:04:41,360
Jadi x0 merujuk kepada 4 bait yang sangat pertama blok.

65
00:04:45,810 --> 00:04:49,230
X [1] merujuk kepada 4 bait akan datang dan sebagainya.

66
00:04:49,230 --> 00:04:53,760
Ini bermakna bahawa permulaan x adalah semua program yang pernah perlu untuk menjejaki.

67
00:04:55,660 --> 00:04:59,840
Jika anda mahu menggunakan x [400], maka program ini tahu bahawa ini adalah bersamaan

68
00:04:59,840 --> 00:05:03,460
kepada hanya 1,600 bait selepas permulaan x.

69
00:05:03,460 --> 00:05:08,780
Dari mana asalnya kita akan mendapat 1,600 bait dari? Ia hanya 400 kali 4 bait setiap integer.

70
00:05:08,780 --> 00:05:13,170
>> Sebelum bergerak ke atas, ia amat penting untuk menyedari bahawa dalam C

71
00:05:13,170 --> 00:05:17,080
tidak ada penguatkuasaan indeks yang kita gunakan dalam array.

72
00:05:17,080 --> 00:05:23,180
Blok besar kami adalah hanya 10 integer panjang, tetapi tiada apa yang akan menjerit pada kita jika kita menulis x [20]

73
00:05:23,180 --> 00:05:26,060
ataupun x [-5].

74
00:05:26,060 --> 00:05:28,240
Indeks tidak perlu untuk menjadi nombor.

75
00:05:28,240 --> 00:05:30,630
Ia boleh menjadi apa-apa ungkapan yang sewenang-wenangnya.

76
00:05:30,630 --> 00:05:34,800
Dalam program ini kita menggunakan i pembolehubah daripada gelung untuk indeks ke dalam array.

77
00:05:34,800 --> 00:05:40,340
Ini adalah corak yang sangat biasa, menggelung dari i = 0 untuk panjang array,

78
00:05:40,340 --> 00:05:43,350
dan kemudian menggunakan i sebagai indeks untuk array.

79
00:05:43,350 --> 00:05:46,160
Dengan cara ini anda berkesan gelung seluruh array,

80
00:05:46,160 --> 00:05:50,600
dan sama ada anda boleh menetapkan ke tempat masing-masing dalam pelbagai atau menggunakannya untuk pengiraan tertentu.

81
00:05:50,600 --> 00:05:53,920
>> Dalam pertama bagi gelung, i bermula pada 0,

82
00:05:53,920 --> 00:05:58,680
dan sebagainya ia akan memberikan tempat 0 dalam array, nilai 0 times 2.

83
00:05:58,680 --> 00:06:04,370
Kemudian i kenaikan, dan kami sediakan tempat pertama dalam pelbagai nilai 1 kali 2.

84
00:06:04,370 --> 00:06:10,170
Kemudian i kenaikan lagi dan sebagainya naik sehingga kami sediakan untuk meletakkan N-1 dalam array

85
00:06:10,170 --> 00:06:13,370
nilai N-1 kali 2.

86
00:06:13,370 --> 00:06:17,810
Jadi kita telah mencipta pelbagai dengan 10 nombor pertama walaupun.

87
00:06:17,810 --> 00:06:21,970
Mungkin evens akan menjadi nama yang sedikit lebih baik bagi pembolehubah daripada x,

88
00:06:21,970 --> 00:06:24,760
tetapi yang akan diberikan sesuatu.

89
00:06:24,760 --> 00:06:30,210
Kedua untuk gelung kemudian hanya mencetak nilai-nilai yang kita telah disimpan di dalam array.

90
00:06:30,210 --> 00:06:33,600
>> Mari kita cuba menjalankan program dengan kedua-dua jenis pengisytiharan pelbagai

91
00:06:33,600 --> 00:06:36,330
dan lihat pada output program.

92
00:06:51,450 --> 00:06:57,020
Setakat yang kita boleh lihat, program itu berkelakuan dengan cara yang sama bagi kedua-dua jenis perisytiharan.

93
00:06:57,020 --> 00:07:02,230
Mari kita juga mengambil melihat apa yang berlaku jika kita menukar gelung pertama tidak berhenti di N

94
00:07:02,230 --> 00:07:05,040
tetapi sebaliknya berkata 10,000.

95
00:07:05,040 --> 00:07:07,430
Cara luar akhir array.

96
00:07:14,700 --> 00:07:17,210
Oops. Mungkin anda telah melihat sebelum ini.

97
00:07:17,210 --> 00:07:20,440
Satu kesalahan segmentasi bermakna program anda telah terhempas.

98
00:07:20,440 --> 00:07:24,430
Anda mula melihat ini apabila anda menyentuh kawasan ingatan anda tidak perlu menyentuh.

99
00:07:24,430 --> 00:07:27,870
Di sini kita menyentuh 10,000 tempat luar permulaan x,

100
00:07:27,870 --> 00:07:31,920
yang jelas adalah tempat dalam ingatan kita tidak harus menyentuh.

101
00:07:31,920 --> 00:07:37,690
Jadi kebanyakan kita mungkin akan tidak sengaja meletakkan 10.000 bukannya N,

102
00:07:37,690 --> 00:07:42,930
tetapi apa yang jika kita melakukan sesuatu yang lebih halus seperti mengatakan hapus kurang daripada atau sama dengan N

103
00:07:42,930 --> 00:07:46,830
dalam keadaan gelung untuk berbanding dengan kurang daripada N.

104
00:07:46,830 --> 00:07:50,100
Ingatlah bahawa array hanya mempunyai indeks dari 0 hingga N-1,

105
00:07:50,100 --> 00:07:54,510
yang bermaksud bahawa indeks N adalah di luar akhir array.

106
00:07:54,510 --> 00:07:58,050
Program ini tidak mungkin kemalangan dalam kes ini, tetapi ia masih ralat.

107
00:07:58,050 --> 00:08:01,950
Malah, kesilapan ini adalah begitu umum bahawa ia mempunyai nama sendiri,

108
00:08:01,950 --> 00:08:03,970
luar oleh 1 kesilapan.

109
00:08:03,970 --> 00:08:05,970
>> Itulah untuk asas.

110
00:08:05,970 --> 00:08:09,960
Jadi, apakah perbezaan utama antara 2 jenis pengisytiharan pelbagai?

111
00:08:09,960 --> 00:08:13,960
Satu perbezaan adalah di mana blok memori yang besar pergi.

112
00:08:13,960 --> 00:08:17,660
Dalam deklarasi pertama, yang saya akan memanggil jenis kurungan pelbagai,

113
00:08:17,660 --> 00:08:20,300
walaupun ini adalah tidak bermaksud nama konvensional,

114
00:08:20,300 --> 00:08:22,480
ia akan pergi pada timbunan.

115
00:08:22,480 --> 00:08:27,450
Manakala di tempat kedua, yang saya akan memanggil jenis penunjuk pelbagai, ia akan pergi pada timbunan.

116
00:08:27,450 --> 00:08:32,480
Ini bermakna bahawa apabila pulangan fungsi, array kurungan secara automatik akan deallocated,

117
00:08:32,480 --> 00:08:36,419
sedangkan sebagai anda explicitily mesti memanggil bebas pada pelbagai penunjuk

118
00:08:36,419 --> 00:08:38,010
atau lain anda mempunyai kebocoran memori.

119
00:08:38,010 --> 00:08:42,750
Selain itu, pelbagai pendakap tidak sebenarnya adalah pembolehubah.

120
00:08:42,750 --> 00:08:45,490
Ini adalah penting. Ia hanya simbol.

121
00:08:45,490 --> 00:08:49,160
Anda boleh berfikir ia sebagai pemalar bahawa pengkompil memilih untuk anda.

122
00:08:49,160 --> 00:08:52,970
Ini bermakna bahawa kita tidak boleh melakukan sesuatu seperti x + + dengan jenis kurungan,

123
00:08:52,970 --> 00:08:56,240
walaupun ini adalah betul-betul sah dengan jenis penunjuk.

124
00:08:56,240 --> 00:08:58,270
>> Jenis penunjuk adalah pembolehubah.

125
00:08:58,270 --> 00:09:01,510
Untuk jenis penunjuk, kita mempunyai 2 blok memori yang berasingan.

126
00:09:01,510 --> 00:09:06,060
X ubah sendiri disimpan dalam timbunan dan hanya penunjuk tunggal,

127
00:09:06,060 --> 00:09:08,620
tetapi blok memori yang besar disimpan pada timbunan.

128
00:09:08,620 --> 00:09:11,010
X ubah pada timbunan hanya menyimpan alamat

129
00:09:11,010 --> 00:09:14,010
blok besar memori pada timbunan.

130
00:09:14,010 --> 00:09:17,370
Salah satu implikasi ini adalah dengan saiz pengendali.

131
00:09:17,370 --> 00:09:22,480
Jika anda bertanya saiz array kurungan, ia akan memberikan anda saiz blok besar memori,

132
00:09:22,480 --> 00:09:24,620
sesuatu seperti 40 bytes,

133
00:09:24,620 --> 00:09:26,920
tetapi jika anda bertanya untuk saiz jenis penunjuk pelbagai,

134
00:09:26,920 --> 00:09:32,740
ia akan memberikan anda saiz x ubah sendiri, yang pada perkakas mungkin hanya 4 bait.

135
00:09:32,740 --> 00:09:36,530
Menggunakan pelbagai jenis penunjuk, ia adalah mustahil untuk terus meminta

136
00:09:36,530 --> 00:09:38,530
saiz blok besar memori.

137
00:09:38,530 --> 00:09:42,530
Ini bukan biasanya banyak sekatan kerana kita sangat jarang mahu saiz

138
00:09:42,530 --> 00:09:46,980
blok besar memori, dan biasanya kita boleh mengira jika kita perlu.

139
00:09:46,980 --> 00:09:51,490
>> Akhirnya, pelbagai kurungan berlaku untuk menyediakan kami dengan jalan pintas untuk Memulakan array.

140
00:09:51,490 --> 00:09:56,130
Mari kita lihat bagaimana kita boleh menulis pertama 10 integer walaupun menggunakan initilization jalan pintas.

141
00:10:11,220 --> 00:10:14,470
Dengan pelbagai penunjuk, tidak ada satu cara untuk melakukan jalan pintas seperti ini.

142
00:10:14,470 --> 00:10:18,120
Ini hanya pengenalan kepada apa yang anda boleh lakukan dengan tatasusunan.

143
00:10:18,120 --> 00:10:20,990
Mereka muncul dalam hampir setiap program yang anda tulis.

144
00:10:20,990 --> 00:10:24,390
Semoga anda kini boleh melihat cara yang lebih baik daripada melakukan contoh pelajar ID

145
00:10:24,390 --> 00:10:26,710
dari permulaan video.

146
00:10:26,710 --> 00:10:29,960
>> Nama saya adalah Rob Bowden, dan ini adalah CS50.