1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Review] [Kuiz 0]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi Ross, Tommy MacWilliam, Lucas Freitas, Joseph Ong] [Universiti Harvard]

3
00:00:05,000 --> 00:00:08,000
>> [Ini adalah CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Hei, semua.

5
00:00:10,000 --> 00:00:15,000
Selamat datang ke sesi kajian untuk Kuiz 0, yang sedang berlaku hari Rabu ini.

6
00:00:15,000 --> 00:00:19,000
Apa yang kita akan lakukan malam, saya dengan 3 TFS lain,

7
00:00:19,000 --> 00:00:24,000
dan bersama-sama kita akan pergi melalui kajian apa yang kami lakukan dalam kursus setakat ini.

8
00:00:24,000 --> 00:00:27,000
Ia tidak akan menjadi 100% menyeluruh, tetapi ia harus memberi anda idea yang lebih baik

9
00:00:27,000 --> 00:00:31,000
apa yang anda sudah mempunyai dan apa yang anda masih perlu belajar sebelum Rabu.

10
00:00:31,000 --> 00:00:34,000
Dan berasa bebas untuk mengangkat tangan anda dengan soalan-soalan seperti yang kita pergi bersama-sama,

11
00:00:34,000 --> 00:00:38,000
tetapi perlu diingat bahawa kita juga akan mempunyai sedikit masa di akhir-

12
00:00:38,000 --> 00:00:41,000
jika kita dapat melalui dengan beberapa minit untuk ganti-untuk melakukan soalan umum,

13
00:00:41,000 --> 00:00:47,000
supaya menyimpan bahawa dalam fikiran, dan sebagainya kita akan bermula pada awal dengan 0 Minggu.

14
00:00:47,000 --> 00:00:50,000
>> [Kuiz 0 Kajian!] [Bahagian 0] [Lexi Ross] Tetapi sebelum kita lakukan yang membolehkan bercakap tentang

15
00:00:50,000 --> 00:00:53,000
logistik kuiz.

16
00:00:53,000 --> 00:00:55,000
>> [Logistics] [Kuiz berlaku pada hari Rabu 10/10 sebagai ganti kuliah]

17
00:00:55,000 --> 00:00:57,000
>> [(Lihat http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf untuk mendapatkan butiran)] Ia adalah pada Wednesday, October 10th.

18
00:00:57,000 --> 00:01:00,000
>> Itulah hari Rabu ini, dan jika anda pergi ke URL ini di sini,

19
00:01:00,000 --> 00:01:03,000
yang juga boleh diakses dari pautan ke CS50.net-ada 's-

20
00:01:03,000 --> 00:01:06,000
anda boleh melihat maklumat tentang di mana untuk pergi berdasarkan

21
00:01:06,000 --> 00:01:10,000
nama akhir anda atau gabungan sekolah serta

22
00:01:10,000 --> 00:01:14,000
ia menceritakan tentang apa kuiz akan meliputi dan jenis soalan yang anda akan mendapat.

23
00:01:14,000 --> 00:01:19,000
Perlu diingat bahawa anda juga akan mempunyai peluang untuk mengkaji semula untuk kuiz dalam seksyen,

24
00:01:19,000 --> 00:01:21,000
jadi TFS anda perlu pergi ke atas beberapa masalah amalan,

25
00:01:21,000 --> 00:01:29,000
dan itulah satu lagi peluang yang baik untuk melihat di mana anda masih perlu belajar untuk kuiz.

26
00:01:29,000 --> 00:01:32,000
Mari kita mulakan pada awal dengan Bytes 'n' Bit.

27
00:01:32,000 --> 00:01:35,000
Ingat sedikit adalah hanya 0 atau 1,

28
00:01:35,000 --> 00:01:38,000
dan satu bait adalah koleksi 8 bit-bit.

29
00:01:38,000 --> 00:01:42,000
Mari kita lihat di koleksi ini bit yang betul di sini.

30
00:01:42,000 --> 00:01:44,000
Kita harus dapat mengetahui berapa banyak bit yang terdapat.

31
00:01:44,000 --> 00:01:48,000
Jika kita mengira terdapat hanya 8 daripada mereka, lapan 0 atau 1 unit.

32
00:01:48,000 --> 00:01:51,000
Dan sejak ada 8 bit, itulah 1 bait,

33
00:01:51,000 --> 00:01:53,000
dan mari kita menukar kepada perenambelasan.

34
00:01:53,000 --> 00:01:58,000
Perenambelasan adalah asas 16, dan ia adalah agak mudah untuk menukar

35
00:01:58,000 --> 00:02:01,000
nombor perduaan, yang adalah apa yang, untuk beberapa dalam perenambelasan.

36
00:02:01,000 --> 00:02:04,000
Apa yang kita lakukan ialah kita melihat kumpulan 4,

37
00:02:04,000 --> 00:02:07,000
dan kita menukar mereka untuk digit perenambelasan yang sesuai.

38
00:02:07,000 --> 00:02:11,000
Kita mulakan dengan kumpulan paling kanan 4, jadi 0011.

39
00:02:11,000 --> 00:02:16,000
Itu akan menjadi satu 1 dan satu 2, jadi bersama-sama yang membuat 3.

40
00:02:16,000 --> 00:02:19,000
Dan kemudian mari kita melihat blok lain 4.

41
00:02:19,000 --> 00:02:24,000
1101. Itu akan menjadi satu 1, satu 4, dan satu 8.

42
00:02:24,000 --> 00:02:28,000
Bersama yang akan menjadi 13, yang menjadikan D.

43
00:02:28,000 --> 00:02:32,000
Dan kita akan ingat bahawa dalam perenambelasan kita tidak hanya pergi 0 hingga 9.

44
00:02:32,000 --> 00:02:36,000
Kami pergi 0 melalui F, jadi selepas 9, 10 bersamaan kepada A,

45
00:02:36,000 --> 00:02:40,000
11 kepada B, dan sebagainya di mana F adalah 15.

46
00:02:40,000 --> 00:02:44,000
Berikut 13 ialah D,

47
00:02:44,000 --> 00:02:49,000
jadi untuk menukar ia kepada perpuluhan semua yang kita lakukan adalah kita sebenarnya

48
00:02:49,000 --> 00:02:52,000
merawat setiap kedudukan sebagai kuasa 2.

49
00:02:52,000 --> 00:02:58,000
Itulah satu 1, satu 2, sifar 4s, sifar 8s, satu 16, dan sebagainya,

50
00:02:58,000 --> 00:03:03,000
dan ia sedikit sukar untuk mengira dalam kepala anda, tetapi jika kita pergi ke slaid seterusnya

51
00:03:03,000 --> 00:03:05,000
kita boleh lihat jawapan itu.

52
00:03:05,000 --> 00:03:09,000
>> Pada dasarnya kita akan merentasi dari kanan kembali ke kiri,

53
00:03:09,000 --> 00:03:14,000
dan kita mendarabkan setiap angka dengan kuasa yang sama 2.

54
00:03:14,000 --> 00:03:19,000
Dan ingat, perenambelasan kita menandakan nombor-nombor ini dengan 0x pada permulaan

55
00:03:19,000 --> 00:03:23,000
supaya kita tidak mengelirukan ia dengan nombor perpuluhan.

56
00:03:23,000 --> 00:03:29,000
Berterusan ke atas, ini adalah Jadual ASCII,

57
00:03:29,000 --> 00:03:35,000
dan apa yang kita gunakan ASCII bagi adalah untuk memetakan dari watak-watak kepada nilai-nilai berangka.

58
00:03:35,000 --> 00:03:39,000
Ingat dalam pset kriptografi kita membuat penggunaan meluas Jadual ASCII

59
00:03:39,000 --> 00:03:43,000
dalam usaha untuk menggunakan pelbagai kaedah kriptografi,

60
00:03:43,000 --> 00:03:47,000
Caesar dan cipher Vigenère, untuk menukar huruf yang berbeza

61
00:03:47,000 --> 00:03:52,000
dalam rentetan mengikut kunci yang diberikan oleh pengguna.

62
00:03:52,000 --> 00:03:56,000
Mari kita melihat sedikit matematik ASCII.

63
00:03:56,000 --> 00:04:02,000
Melihat 'P' + 1, dalam bentuk watak yang akan menjadi Q,

64
00:04:02,000 --> 00:04:07,000
dan ingat bahawa ''5 ≠ 5.

65
00:04:07,000 --> 00:04:10,000
Dan bagaimana sebenarnya kita akan menukar antara 2 bentuk mereka?

66
00:04:10,000 --> 00:04:13,000
Ia sebenarnya tidak terlalu keras.

67
00:04:13,000 --> 00:04:16,000
Dalam usaha untuk mendapatkan 5 kita tolak '0 '

68
00:04:16,000 --> 00:04:20,000
kerana terdapat 5 tempat antara '0 'dan '5'.

69
00:04:20,000 --> 00:04:23,000
Dalam usaha untuk pergi cara lain kita hanya menambah 0,,

70
00:04:23,000 --> 00:04:25,000
jadi ia adalah jenis seperti aritmetik tetap.

71
00:04:25,000 --> 00:04:29,000
Hanya ingat bahawa apabila sesuatu mempunyai petikan sekelilingnya ia adalah watak

72
00:04:29,000 --> 00:04:37,000
dan dengan itu sepadan dengan nilai dalam jadual ASCII.

73
00:04:37,000 --> 00:04:40,000
Melangkah ke topik sains komputer yang lebih umum.

74
00:04:40,000 --> 00:04:43,000
Kami belajar apa algoritma dan bagaimana kita menggunakan pengaturcaraan

75
00:04:43,000 --> 00:04:45,000
untuk melaksanakan algoritma.

76
00:04:45,000 --> 00:04:48,000
Beberapa contoh algoritma adalah sesuatu yang benar-benar mudah seperti

77
00:04:48,000 --> 00:04:51,000
memeriksa sama ada nombor adalah genap atau ganjil.

78
00:04:51,000 --> 00:04:54,000
Untuk itu ingat kita MOD nombor dengan 2 dan memeriksa jika hasilnya adalah 0.

79
00:04:54,000 --> 00:04:57,000
Jika ya, ia adalah lebih. Jika tidak, ia adalah ganjil.

80
00:04:57,000 --> 00:04:59,000
Dan itulah satu contoh algoritma yang benar-benar asas.

81
00:04:59,000 --> 00:05:02,000
>> Sedikit lebih terlibat adalah carian binari,

82
00:05:02,000 --> 00:05:05,000
yang kita akan pergi lebih lewat dalam sesi kajian.

83
00:05:05,000 --> 00:05:09,000
Dan pengaturcaraan adalah istilah yang kita gunakan untuk mengambil algoritma

84
00:05:09,000 --> 00:05:15,000
dan menukar kod komputer boleh membaca.

85
00:05:15,000 --> 00:05:20,000
2 contoh pengaturcaraan Scratch,

86
00:05:20,000 --> 00:05:22,000
yang adalah apa yang kita lakukan di titik 0 Minggu.

87
00:05:22,000 --> 00:05:25,000
Walaupun kita tidak sebenarnya menaip kod, ia adalah satu cara melaksanakan

88
00:05:25,000 --> 00:05:29,000
ini algoritma, yang mencetak nombor 1-10,

89
00:05:29,000 --> 00:05:32,000
dan di sini kita melakukan perkara yang sama dalam bahasa pengaturcaraan C.

90
00:05:32,000 --> 00:05:41,000
Ini adalah fungsi setara, hanya ditulis dalam bahasa yang berbeza atau sintaks.

91
00:05:41,000 --> 00:05:44,000
Kami kemudian belajar tentang ungkapan boolean,

92
00:05:44,000 --> 00:05:48,000
dan boolean adalah nilai yang sama ada benar atau palsu,

93
00:05:48,000 --> 00:05:51,000
dan ungkapan di sini sering kali boolean

94
00:05:51,000 --> 00:05:55,000
pergi di dalam keadaan, jadi jika (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
baik, kita sudah ditetapkan x = 5, jadi keadaan yang akan menilai kepada true.

96
00:06:00,000 --> 00:06:03,000
Dan jika ia benar, apa-apa kod di bawah keadaan

97
00:06:03,000 --> 00:06:08,000
akan dinilai oleh komputer, jadi rentetan yang akan dicetak

98
00:06:08,000 --> 00:06:12,000
output standard, dan istilah keadaan

99
00:06:12,000 --> 00:06:16,000
merujuk kepada apa yang ada di dalam kurungan kenyataan jika.

100
00:06:16,000 --> 00:06:20,000
Ingat semua operator.

101
00:06:20,000 --> 00:06:26,000
Ingat && dan | | apabila kita sedang berusaha untuk menggabungkan 2 atau lebih keadaan,

102
00:06:26,000 --> 00:06:30,000
== Tidak = untuk memeriksa sama ada 2 perkara adalah sama.

103
00:06:30,000 --> 00:06:36,000
Ingatlah bahawa = adalah untuk tugasan sedangkan == operator boolean.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ dan kemudian 2 akhir adalah jelas dengan sendirinya.

105
00:06:41,000 --> 00:06:45,000
Satu kajian umum logik boolean di sini.

106
00:06:45,000 --> 00:06:48,000
Dan ungkapan boolean juga penting dalam gelung,

107
00:06:48,000 --> 00:06:50,000
yang kita akan pergi lebih sekarang.

108
00:06:50,000 --> 00:06:56,000
Kami belajar tentang 3 jenis gelung setakat pada CS50,, manakala, dan lakukan semasa.

109
00:06:56,000 --> 00:06:59,000
Dan ia adalah penting untuk mengetahui bahawa manakala bagi kebanyakan tujuan

110
00:06:59,000 --> 00:07:02,000
kita sebenarnya boleh menggunakan apa-apa jenis gelung umumnya

111
00:07:02,000 --> 00:07:06,000
terdapat jenis tertentu tujuan atau corak biasa

112
00:07:06,000 --> 00:07:09,000
dalam pengaturcaraan yang khusus memanggil satu ini gelung

113
00:07:09,000 --> 00:07:13,000
yang menjadikan ia paling berkesan atau elegan untuk kod dengan cara itu.

114
00:07:13,000 --> 00:07:18,000
Mari kita pergi ke setiap apa-gelung cenderung untuk digunakan bagi paling sering.

115
00:07:18,000 --> 00:07:21,000
>> Dalam gelung untuk kita umumnya sudah tahu berapa kali kita mahu melelar.

116
00:07:21,000 --> 00:07:24,000
Itulah apa yang kita masukkan ke dalam keadaan.

117
00:07:24,000 --> 00:07:28,000
Kerana, i = 0, i <10, sebagai contoh.

118
00:07:28,000 --> 00:07:31,000
Kita sudah tahu bahawa kita mahu melakukan sesuatu yang 10 kali.

119
00:07:31,000 --> 00:07:34,000
Sekarang, bagi gelung sementara, umumnya kita tidak semestinya

120
00:07:34,000 --> 00:07:36,000
tahu berapa kali kita mahu gelung untuk menjalankan.

121
00:07:36,000 --> 00:07:39,000
Tetapi kita tahu beberapa jenis keadaan yang kita mahu ia

122
00:07:39,000 --> 00:07:41,000
sentiasa menjadi benar atau sentiasa menjadi palsu.

123
00:07:41,000 --> 00:07:44,000
Sebagai contoh, semasa ditetapkan.

124
00:07:44,000 --> 00:07:46,000
Mari kita mengatakan bahawa adalah satu pemboleh ubah boolean.

125
00:07:46,000 --> 00:07:48,000
Walaupun yang benar kita mahu kod untuk menilai,

126
00:07:48,000 --> 00:07:52,000
jadi sedikit lebih extensible, sedikit lebih umum daripada gelung,

127
00:07:52,000 --> 00:07:55,000
tetapi apa-apa untuk gelung juga boleh ditukar kepada gelung sementara.

128
00:07:55,000 --> 00:08:00,000
Akhirnya, lakukan manakala gelung, yang mungkin menjadi trickiest untuk memahami merta,

129
00:08:00,000 --> 00:08:04,000
sering digunakan apabila kita mahu menilai kod yang pertama

130
00:08:04,000 --> 00:08:06,000
sebelum kali pertama kita memeriksa keadaan.

131
00:08:06,000 --> 00:08:09,000
Satu kes biasa digunakan untuk buat gelung while

132
00:08:09,000 --> 00:08:12,000
apabila anda mahu untuk mendapatkan input pengguna, dan anda tahu anda mahu untuk meminta pengguna

133
00:08:12,000 --> 00:08:15,000
untuk input sekurang-kurangnya sekali, tetapi jika mereka tidak memberi anda input yang baik segera

134
00:08:15,000 --> 00:08:18,000
anda mahu menyimpan meminta mereka sehingga mereka memberi anda input yang baik.

135
00:08:18,000 --> 00:08:21,000
Itulah penggunaan yang paling biasa melakukan gelung while,

136
00:08:21,000 --> 00:08:23,000
dan mari kita melihat struktur sebenar ini gelung.

137
00:08:23,000 --> 00:08:27,000
Mereka biasanya sentiasa cenderung untuk mengikuti pola-pola ini.

138
00:08:27,000 --> 00:08:30,000
>> Pada gelung untuk bahagian anda mempunyai 3 komponen:

139
00:08:30,000 --> 00:08:35,000
pengawalan, biasanya sesuatu seperti int i = 0 mana i ialah kaunter,

140
00:08:35,000 --> 00:08:40,000
keadaan, di mana kita mahu mengatakan menjalankan ini untuk gelung sebagai selagi keadaan ini masih memegang,

141
00:08:40,000 --> 00:08:44,000
seperti i <10, dan kemudian akhirnya, update, yang adalah bagaimana kita kenaikan

142
00:08:44,000 --> 00:08:47,000
pembolehubah kaunter di setiap titik di dalam gelung.

143
00:08:47,000 --> 00:08:50,000
Satu perkara biasa untuk melihat di sana hanya i + +,

144
00:08:50,000 --> 00:08:52,000
yang bermaksud kenaikan i sebanyak 1 setiap masa.

145
00:08:52,000 --> 00:08:55,000
Anda juga boleh melakukan sesuatu seperti i + = 2,

146
00:08:55,000 --> 00:08:58,000
yang bermaksud tambahkan 2 kepada i setiap kali anda pergi melalui gelung.

147
00:08:58,000 --> 00:09:03,000
Dan kemudian melakukan ini hanya merujuk kepada mana-mana kod yang sebenarnya berjalan sebagai sebahagian daripada gelung.

148
00:09:03,000 --> 00:09:09,000
Dan untuk gelung sementara, masa ini kita sebenarnya mempunyai pengawalan luar gelung,

149
00:09:09,000 --> 00:09:12,000
demikian bagi contoh, katakan kita sedang berusaha untuk melakukan jenis yang sama gelung kerana saya hanya diterangkan.

150
00:09:12,000 --> 00:09:16,000
Kita akan mengatakan int i = 0 sebelum gelung bermula.

151
00:09:16,000 --> 00:09:20,000
Kemudian kita boleh mengatakan manakala i <10 melakukan ini,

152
00:09:20,000 --> 00:09:22,000
jadi blok sama kod seperti sebelum ini,

153
00:09:22,000 --> 00:09:26,000
dan masa ini bahagian mengemaskini kod, contohnya, i + +,

154
00:09:26,000 --> 00:09:29,000
sebenarnya berlaku di dalam gelung.

155
00:09:29,000 --> 00:09:33,000
Dan akhirnya, untuk lakukan semasa, ia adalah serupa dengan gelung sementara,

156
00:09:33,000 --> 00:09:36,000
tetapi kita perlu ingat bahawa kod akan menilai sekali

157
00:09:36,000 --> 00:09:40,000
sebelum keadaan diperiksa, jadi ia masuk akal yang lebih banyak

158
00:09:40,000 --> 00:09:44,000
jika anda melihat di perintah atas ke bawah.

159
00:09:44,000 --> 00:09:49,000
Dalam, lakukan manakala gelung kod menilai sebelum anda melihat keadaan sementara

160
00:09:49,000 --> 00:09:55,000
manakala gelung sementara, ia cek pertama.

161
00:09:55,000 --> 00:09:59,000
Penyata dan pembolehubah.

162
00:09:59,000 --> 00:10:04,000
Apabila kita hendak mewujudkan satu pembolehubah baru kita mahu untuk memulakan ia.

163
00:10:04,000 --> 00:10:07,000
>> Sebagai contoh, bar int initializes bar berubah-ubah,

164
00:10:07,000 --> 00:10:10,000
tetapi ia tidak memberikan nilai, jadi apakah nilai bar sekarang?

165
00:10:10,000 --> 00:10:12,000
Kita tidak tahu.

166
00:10:12,000 --> 00:10:14,000
Ia boleh menjadi beberapa nilai sampah yang sebelum ini disimpan di dalam memori di sana,

167
00:10:14,000 --> 00:10:16,000
dan kita tidak mahu menggunakan pembolehubah yang

168
00:10:16,000 --> 00:10:19,000
sehingga kita benar-benar memberi nilai,

169
00:10:19,000 --> 00:10:21,000
jadi kita mengisytiharkan ia di sini.

170
00:10:21,000 --> 00:10:24,000
Kemudian kami memulakan ia menjadi 42 bawah.

171
00:10:24,000 --> 00:10:28,000
Kini, sudah tentu, kita tahu ini boleh dilakukan dalam satu baris, int bar = 42.

172
00:10:28,000 --> 00:10:30,000
Tetapi hanya untuk membersihkan pelbagai langkah-langkah yang sedang berlaku,

173
00:10:30,000 --> 00:10:34,000
pengisytiharan dan pengawalan yang berlaku secara berasingan di sini.

174
00:10:34,000 --> 00:10:38,000
Ia berlaku pada satu langkah, dan satu depan, int Baz = bar + 1,

175
00:10:38,000 --> 00:10:44,000
kenyataan ini di bawah, bahawa Baz kenaikan, jadi pada akhir blok kod ini

176
00:10:44,000 --> 00:10:48,000
jika kita adalah untuk mencetak nilai Baz ia akan menjadi 44

177
00:10:48,000 --> 00:10:52,000
kerana kita mengaku dan memulakan ia menjadi 1> bar,

178
00:10:52,000 --> 00:10:58,000
dan kemudian kita kenaikan sekali lagi dengan + +.

179
00:10:58,000 --> 00:11:02,000
Kami pergi ke sebentar cantik ini, tetapi ia adalah baik untuk mempunyai umum

180
00:11:02,000 --> 00:11:04,000
memahami apa benang dan acara.

181
00:11:04,000 --> 00:11:06,000
Kami melakukan ini terutamanya dalam Gores,

182
00:11:06,000 --> 00:11:09,000
supaya anda boleh berfikir benang sebagai urutan pelbagai kod

183
00:11:09,000 --> 00:11:11,000
berjalan pada masa yang sama.

184
00:11:11,000 --> 00:11:14,000
Dalam kenyataannya, ia mungkin tidak berjalan pada masa yang sama,

185
00:11:14,000 --> 00:11:17,000
tetapi jenis abstrak kita boleh berfikir ia dengan cara itu.

186
00:11:17,000 --> 00:11:20,000
>> Di Awal, sebagai contoh, kita mempunyai sprites berganda.

187
00:11:20,000 --> 00:11:22,000
Ia boleh melaksanakan kod yang berbeza pada masa yang sama.

188
00:11:22,000 --> 00:11:26,000
Satu boleh berjalan manakala yang lain mengatakan sesuatu

189
00:11:26,000 --> 00:11:29,000
dalam bahagian yang berbeza skrin.

190
00:11:29,000 --> 00:11:34,000
Peristiwa adalah satu lagi cara yang memisahkan logik

191
00:11:34,000 --> 00:11:37,000
antara unsur-unsur yang berlainan kod anda,

192
00:11:37,000 --> 00:11:40,000
dan dalam Gores kita mampu untuk mensimulasikan peristiwa menggunakan Penyiaran,

193
00:11:40,000 --> 00:11:43,000
dan itulah sebenarnya Apabila Saya Menerima, tidak Apabila saya Dengar,

194
00:11:43,000 --> 00:11:47,000
tetapi pada dasarnya ia adalah satu cara untuk menghantar maklumat

195
00:11:47,000 --> 00:11:49,000
dari satu bidadari yang lain.

196
00:11:49,000 --> 00:11:52,000
Sebagai contoh, anda mungkin mahu untuk menghantar permainan lebih,

197
00:11:52,000 --> 00:11:56,000
dan apabila bidadari lain menerima permainan lebih,

198
00:11:56,000 --> 00:11:58,000
ia bertindak balas dengan cara yang tertentu.

199
00:11:58,000 --> 00:12:03,000
Ia adalah satu model yang penting untuk memahami untuk pengaturcaraan.

200
00:12:03,000 --> 00:12:07,000
Hanya untuk pergi ke Minggu asas 0, apa yang kita telah pergi setakat ini,

201
00:12:07,000 --> 00:12:10,000
mari kita melihat program ini mudah C.

202
00:12:10,000 --> 00:12:14,000
Teks ini mungkin sedikit kecil dari sini, tetapi saya akan pergi ke ia benar-benar cepat.

203
00:12:14,000 --> 00:12:20,000
Kami termasuk 2 fail header di atas, cs50.h dan stdio.h.

204
00:12:20,000 --> 00:12:23,000
Kami kemudian menentukan had berterusan dipanggil untuk menjadi 100.

205
00:12:23,000 --> 00:12:26,000
Kami kemudian melaksanakan fungsi utama kami.

206
00:12:26,000 --> 00:12:29,000
Oleh kerana kita tidak menggunakan hujah baris arahan di sini, kita perlu meletakkan sah

207
00:12:29,000 --> 00:12:32,000
sebagai hujah untuk utama.

208
00:12:32,000 --> 00:12:38,000
Kita lihat int utama di atas. Itulah jenis pulangan, maka kembali 0 di bawah.

209
00:12:38,000 --> 00:12:41,000
Dan kita menggunakan CS50 perpustakaan fungsi mendapatkan int

210
00:12:41,000 --> 00:12:45,000
untuk meminta pengguna untuk input, dan kita menyimpannya dalam x ini berubah-ubah,

211
00:12:45,000 --> 00:12:51,000
jadi kita mengisytiharkan x di atas, dan kami memulakan dengan x = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> Kami kemudian memeriksa untuk melihat jika pengguna memberikan kita input yang baik.

213
00:12:53,000 --> 00:12:59,000
Jika ia HAD ≥ kita mahu untuk kembali kod ralat 1 dan mencetak mesej ralat.

214
00:12:59,000 --> 00:13:02,000
Dan akhirnya, jika pengguna telah memberikan kita input yang baik

215
00:13:02,000 --> 00:13:08,000
kita akan persegi nombor dan mencetak hasil itu.

216
00:13:08,000 --> 00:13:11,000
Hanya untuk memastikan bahawa orang-orang rumah melanda semua

217
00:13:11,000 --> 00:13:17,000
anda boleh melihat label bahagian yang berlainan kod di sini.

218
00:13:17,000 --> 00:13:19,000
Saya sebutkan berterusan, fail header.

219
00:13:19,000 --> 00:13:21,000
Oh, int x. Pastikan untuk ingat bahawa pembolehubah tempatan.

220
00:13:21,000 --> 00:13:24,000
Itu berbeza dari pembolehubah global, yang kita akan bercakap tentang

221
00:13:24,000 --> 00:13:27,000
sedikit kemudian dalam sesi kajian,

222
00:13:27,000 --> 00:13:30,000
dan kita memanggil fungsi perpustakaan printf,

223
00:13:30,000 --> 00:13:34,000
jadi jika kita tidak dimasukkan fail header stdio.h

224
00:13:34,000 --> 00:13:37,000
kita tidak akan mampu untuk memanggil printf.

225
00:13:37,000 --> 00:13:42,000
Dan saya percaya anak panah yang mendapat terputus sini menunjuk ke% d,

226
00:13:42,000 --> 00:13:45,000
yang merupakan rentetan format dalam printf.

227
00:13:45,000 --> 00:13:52,000
Ia mengatakan mencetak pembolehubah ini sebagai nombor,% d.

228
00:13:52,000 --> 00:13:58,000
Dan bahawa ia adalah untuk 0 Minggu.

229
00:13:58,000 --> 00:14:06,000
Sekarang Lucas akan terus.

230
00:14:06,000 --> 00:14:08,000
Hey, guys. Nama saya ialah Lucas.

231
00:14:08,000 --> 00:14:10,000
Saya seorang mahasiswa tingkat kedua di rumah terbaik di kampus, Mather,

232
00:14:10,000 --> 00:14:14,000
dan saya akan bercakap sedikit tentang Minggu 1 dan 2.1.

233
00:14:14,000 --> 00:14:16,000
[Minggu 1 dan 2.1!] [Lucas Freitas]

234
00:14:16,000 --> 00:14:19,000
Sebagai Lexi telah berkata, apabila kita mula menterjemahkan kod anda dari Gores kepada C

235
00:14:19,000 --> 00:14:23,000
salah satu perkara yang kita perhatikan adalah bahawa anda tidak boleh hanya

236
00:14:23,000 --> 00:14:26,000
menulis kod anda dan jalankan ia menggunakan bendera hijau lagi.

237
00:14:26,000 --> 00:14:30,000
Sebenarnya, anda perlu menggunakan beberapa langkah-langkah untuk membuat aturcara C anda

238
00:14:30,000 --> 00:14:33,000
menjadi fail boleh laku.

239
00:14:33,000 --> 00:14:36,000
Pada asasnya apa yang anda lakukan apabila anda sedang menulis program adalah bahawa

240
00:14:36,000 --> 00:14:40,000
anda menterjemahkan idea anda ke dalam bahasa yang pengkompil boleh memahami,

241
00:14:40,000 --> 00:14:44,000
jadi apabila anda menulis program dalam C

242
00:14:44,000 --> 00:14:47,000
apa yang anda lakukan sebenarnya menulis sesuatu yang pengkompil anda akan memahami,

243
00:14:47,000 --> 00:14:50,000
dan kemudian pengkompil akan menterjemahkan kod yang

244
00:14:50,000 --> 00:14:53,000
ke dalam sesuatu yang komputer anda akan memahami.

245
00:14:53,000 --> 00:14:55,000
>> Dan perkara, komputer anda sebenarnya sangat bodoh.

246
00:14:55,000 --> 00:14:57,000
Komputer anda hanya boleh memahami 0 dan 1s,

247
00:14:57,000 --> 00:15:01,000
begitu sebenarnya dalam komputer pertama orang biasanya diprogramkan

248
00:15:01,000 --> 00:15:04,000
menggunakan 0 dan 1s, tetapi tidak lagi, terima Allah.

249
00:15:04,000 --> 00:15:07,000
Kita tidak perlu menghafal urutan 0 dan 1s

250
00:15:07,000 --> 00:15:10,000
untuk bagi gelung atau untuk gelung sementara dan sebagainya.

251
00:15:10,000 --> 00:15:13,000
Itulah sebabnya kita mempunyai pengkompil.

252
00:15:13,000 --> 00:15:17,000
Apa pengkompil tidak adalah ia pada asasnya menterjemahkan kod C,

253
00:15:17,000 --> 00:15:21,000
dalam kes ini, kepada bahasa yang komputer anda akan faham,

254
00:15:21,000 --> 00:15:25,000
yang merupakan kod objek, dan pengkompil yang kita gunakan

255
00:15:25,000 --> 00:15:30,000
dipanggil dilafaz, jadi ini adalah sebenarnya simbol untuk dilafaz.

256
00:15:30,000 --> 00:15:33,000
Apabila anda mempunyai program anda, anda perlu melakukan 2 perkara.

257
00:15:33,000 --> 00:15:37,000
Pertama, anda perlu untuk menyusun program anda, dan kemudian anda pergi untuk menjalankan program anda.

258
00:15:37,000 --> 00:15:41,000
Untuk menyusun program anda, anda mempunyai banyak pilihan untuk berbuat demikian.

259
00:15:41,000 --> 00:15:44,000
Yang pertama adalah untuk melakukan program.c dilafaz

260
00:15:44,000 --> 00:15:47,000
di mana program adalah nama program anda.

261
00:15:47,000 --> 00:15:51,000
Dalam kes ini, anda boleh melihat mereka hanya berkata "Hei, menyusun program saya."

262
00:15:51,000 --> 00:15:56,000
Anda tidak mengatakan "Saya mahu ini nama untuk program saya" atau apa-apa.

263
00:15:56,000 --> 00:15:58,000
>> Pilihan kedua memberi nama untuk program anda.

264
00:15:58,000 --> 00:16:02,000
Anda boleh mengatakan dilafaz-o dan kemudian nama yang anda mahu

265
00:16:02,000 --> 00:16:06,000
fail boleh laku yang akan dinamakan dan kemudian program.c.

266
00:16:06,000 --> 00:16:11,000
Dan anda juga boleh lakukan membuat program, dan melihat bagaimana dalam 2 kes pertama

267
00:16:11,000 --> 00:16:15,000
Saya meletakkan c, dan dalam salah satu ketiga saya hanya mempunyai program?

268
00:16:15,000 --> 00:16:18,000
Ya, anda sebenarnya tidak perlu meletakkan c apabila anda menggunakan membuat.

269
00:16:18,000 --> 00:16:22,000
Jika tidak, pengkompil sebenarnya akan menjerit pada anda.

270
00:16:22,000 --> 00:16:24,000
Dan juga, saya tidak tahu jika anda semua ingat,

271
00:16:24,000 --> 00:16:29,000
tetapi banyak kali kita juga digunakan lcs50 atau lm.

272
00:16:29,000 --> 00:16:31,000
Yang dipanggil menghubungkan.

273
00:16:31,000 --> 00:16:35,000
Ia hanya memberitahu pengkompil bahawa anda akan menggunakan perpustakaan mereka di sana,

274
00:16:35,000 --> 00:16:39,000
jadi jika anda mahu menggunakan cs50.h anda sebenarnya perlu menaip

275
00:16:39,000 --> 00:16:43,000
program.c dilafaz-lcs50.

276
00:16:43,000 --> 00:16:45,000
Jika anda tidak berbuat demikian, pengkompil tidak akan tahu

277
00:16:45,000 --> 00:16:50,000
bahawa anda menggunakan fungsi-fungsi dalam cs50.h.

278
00:16:50,000 --> 00:16:52,000
Dan apabila anda mahu untuk menjalankan program anda, anda mempunyai 2 pilihan.

279
00:16:52,000 --> 00:16:57,000
Jika anda lakukan program.c dilafaz anda tidak memberi nama untuk program anda.

280
00:16:57,000 --> 00:17:01,000
Anda perlu untuk menjalankan ia menggunakan / a.out.

281
00:17:01,000 --> 00:17:06,000
A.out adalah nama standard yang dilafaz memberikan program anda jika anda tidak memberikan nama.

282
00:17:06,000 --> 00:17:11,000
Jika tidak, anda akan lakukan. / Program jika anda memberikan nama untuk program anda,

283
00:17:11,000 --> 00:17:15,000
dan juga jika anda tidak membuat program nama program akan mendapat

284
00:17:15,000 --> 00:17:23,000
sudah akan diprogramkan nama yang sama seperti fail c.

285
00:17:23,000 --> 00:17:26,000
Kemudian kita bercakap tentang jenis data dan data.

286
00:17:26,000 --> 00:17:31,000
>> Pada asasnya jenis data adalah perkara yang sama seperti kotak kecil yang mereka gunakan

287
00:17:31,000 --> 00:17:35,000
untuk menyimpan nilai, jadi jenis data adalah sebenarnya seperti Pokémons.

288
00:17:35,000 --> 00:17:39,000
Mereka datang dalam pelbagai saiz dan jenis.

289
00:17:39,000 --> 00:17:43,000
Saya tidak tahu jika analogi yang masuk akal.

290
00:17:43,000 --> 00:17:46,000
Saiz data sebenarnya bergantung pada seni bina mesin.

291
00:17:46,000 --> 00:17:49,000
Semua data saiz yang saya akan menunjukkan di sini

292
00:17:49,000 --> 00:17:53,000
sebenarnya untuk mesin 32-bit, yang merupakan kes perkakas kami,

293
00:17:53,000 --> 00:17:56,000
tetapi jika anda sebenarnya pengekodan Mac anda atau dalam Windows juga

294
00:17:56,000 --> 00:17:59,000
mungkin anda akan mempunyai mesin 64-bit,

295
00:17:59,000 --> 00:18:03,000
jadi ingat bahawa saiz data yang saya akan menunjukkan di sini

296
00:18:03,000 --> 00:18:06,000
adalah untuk mesin 32-bit.

297
00:18:06,000 --> 00:18:08,000
Yang pertama yang kita lihat adalah int,

298
00:18:08,000 --> 00:18:10,000
yang agak mudah.

299
00:18:10,000 --> 00:18:13,000
Anda menggunakan int untuk menyimpan integer.

300
00:18:13,000 --> 00:18:16,000
Kami juga melihat watak, char.

301
00:18:16,000 --> 00:18:20,000
Jika anda mahu menggunakan surat atau simbol sedikit anda mungkin akan menggunakan char.

302
00:18:20,000 --> 00:18:26,000
Char A mempunyai 1 bait, yang bermaksud 8 bit, seperti Lexi berkata.

303
00:18:26,000 --> 00:18:31,000
Pada asasnya kita mempunyai Jadual ASCII yang mempunyai 256

304
00:18:31,000 --> 00:18:34,000
kemungkinan kombinasi 0 dan 1s,

305
00:18:34,000 --> 00:18:37,000
dan kemudian apabila anda menaip satu char ia akan menterjemahkan

306
00:18:37,000 --> 00:18:44,000
watak bahawa input anda nombor yang anda ada dalam jadual ASCII, seperti Lexi berkata.

307
00:18:44,000 --> 00:18:48,000
Kami juga mempunyai apungan, yang kita gunakan untuk menyimpan nombor perpuluhan.

308
00:18:48,000 --> 00:18:53,000
Jika anda ingin memilih 3,14, sebagai contoh, anda akan menggunakan apungan

309
00:18:53,000 --> 00:18:55,000
atau dua yang mempunyai lebih tepat.

310
00:18:55,000 --> 00:18:57,000
Apungan A mempunyai 4 bait.

311
00:18:57,000 --> 00:19:01,000
Double A mempunyai 8 bait, jadi perbezaan hanya ialah ketepatan.

312
00:19:01,000 --> 00:19:04,000
Kami juga mempunyai panjang yang digunakan untuk integer,

313
00:19:04,000 --> 00:19:09,000
dan anda boleh melihat untuk mesin 32-bit int dan lama mempunyai saiz yang sama,

314
00:19:09,000 --> 00:19:13,000
jadi ia tidak benar-benar masuk akal untuk menggunakan lama dalam mesin 32-bit.

315
00:19:13,000 --> 00:19:17,000
>> Tetapi jika anda menggunakan mesin Mac dan 64-bit, sebenarnya yang lama mempunyai saiz 8,

316
00:19:17,000 --> 00:19:19,000
jadi ia benar-benar bergantung kepada seni bina.

317
00:19:19,000 --> 00:19:22,000
Bagi mesin 32-bit ia tidak masuk akal untuk menggunakan panjang benar-benar.

318
00:19:22,000 --> 00:19:25,000
Dan kemudian yang lama, di sisi lain, mempunyai 8 bait,

319
00:19:25,000 --> 00:19:30,000
jadi ia adalah sangat baik jika anda mahu mempunyai integer lagi.

320
00:19:30,000 --> 00:19:34,000
Dan akhirnya, kita mempunyai tali, yang sebenarnya * char,

321
00:19:34,000 --> 00:19:37,000
yang merupakan penunjuk kepada char.

322
00:19:37,000 --> 00:19:40,000
Ia amat mudah untuk berfikir bahawa saiz tali akan menjadi seperti

323
00:19:40,000 --> 00:19:42,000
bilangan aksara yang anda telah ada,

324
00:19:42,000 --> 00:19:45,000
tetapi sebenarnya * char sendiri

325
00:19:45,000 --> 00:19:49,000
mempunyai saiz penunjuk kepada char, yang adalah 4 bait.

326
00:19:49,000 --> 00:19:52,000
Saiz * char 4 bait.

327
00:19:52,000 --> 00:19:56,000
Ia tidak kira jika anda mempunyai satu perkataan kecil atau surat atau apa-apa.

328
00:19:56,000 --> 00:19:58,000
Ia akan menjadi 4 bait.

329
00:19:58,000 --> 00:20:01,000
Kami juga belajar sedikit tentang pemutus,

330
00:20:01,000 --> 00:20:04,000
jadi seperti yang anda boleh lihat, jika anda mempunyai, sebagai contoh, satu program yang mengatakan

331
00:20:04,000 --> 00:20:08,000
int x = 3 dan kemudian printf ("% d", x / 2)

332
00:20:08,000 --> 00:20:12,000
adakah anda semua tahu apa yang ia akan mencetak pada skrin?

333
00:20:12,000 --> 00:20:14,000
>> Seseorang? >> [Pelajar] 2.

334
00:20:14,000 --> 00:20:16,000
1. >> 1, yeah.

335
00:20:16,000 --> 00:20:20,000
Apabila anda melakukan 3/2 ia akan mendapat 1,5,

336
00:20:20,000 --> 00:20:24,000
tetapi kerana kita sedang menggunakan integer ia akan mengabaikan bahagian perpuluhan,

337
00:20:24,000 --> 00:20:26,000
dan anda akan mempunyai 1.

338
00:20:26,000 --> 00:20:29,000
Jika anda tidak mahu itu berlaku apa yang anda boleh lakukan, sebagai contoh,

339
00:20:29,000 --> 00:20:33,000
adalah mengisytiharkan apungan y = x.

340
00:20:33,000 --> 00:20:40,000
Maka x yang digunakan untuk menjadi 3 kini akan menjadi 3,000 dalam y.

341
00:20:40,000 --> 00:20:44,000
Dan kemudian anda boleh mencetak y / 2.

342
00:20:44,000 --> 00:20:50,000
Sebenarnya, saya harus mempunyai 2 a. di sana.

343
00:20:50,000 --> 00:20:55,000
Ia akan melakukan 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
dan anda akan dapat 1.5.

345
00:20:58,000 --> 00:21:06,000
Dan kita mempunyai f 0,2 ini hanya untuk meminta 2 unit perpuluhan dalam bahagian perpuluhan.

346
00:21:06,000 --> 00:21:12,000
Jika anda mempunyai 0,3 f ia akan sebenarnya mempunyai 1,500.

347
00:21:12,000 --> 00:21:16,000
Jika ia adalah 2 ia akan menjadi 1,50.

348
00:21:16,000 --> 00:21:18,000
Kami juga mempunyai kes ini di sini.

349
00:21:18,000 --> 00:21:22,000
Jika anda melakukan apungan x = 3.14 dan kemudian anda x printf

350
00:21:22,000 --> 00:21:24,000
anda pergi untuk mendapatkan 3,14.

351
00:21:24,000 --> 00:21:29,000
Dan jika anda lakukan x = int x,

352
00:21:29,000 --> 00:21:34,000
yang bermaksud merawat x sebagai int dan anda mencetak x kini

353
00:21:34,000 --> 00:21:36,000
anda akan mempunyai 3,00.

354
00:21:36,000 --> 00:21:38,000
Adakah yang masuk akal?

355
00:21:38,000 --> 00:21:41,000
Kerana anda first merawat x sebagai integer, maka anda mengabaikan bahagian perpuluhan,

356
00:21:41,000 --> 00:21:45,000
dan kemudian anda mencetak x.

357
00:21:45,000 --> 00:21:47,000
Dan akhirnya, anda juga boleh melakukan ini,

358
00:21:47,000 --> 00:21:52,000
int x = 65, dan kemudian anda mengisytiharkan char c = x,

359
00:21:52,000 --> 00:21:56,000
dan kemudian jika anda mencetak c anda sebenarnya akan mendapat

360
00:21:56,000 --> 00:21:59,000
A, jadi pada dasarnya apa yang anda lakukan di sini

361
00:21:59,000 --> 00:22:02,000
menterjemahkan integer ke dalam watak,

362
00:22:02,000 --> 00:22:05,000
seperti Jadual ASCII tidak.

363
00:22:05,000 --> 00:22:08,000
Kami juga bercakap tentang pengendali matematik.

364
00:22:08,000 --> 00:22:14,000
Kebanyakan mereka adalah agak mudah, jadi +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
dan juga kita bercakap tentang arena, yang merupakan baki bahagian 2 nombor.

366
00:22:20,000 --> 00:22:23,000
Jika anda mempunyai 10% 3, sebagai contoh,

367
00:22:23,000 --> 00:22:27,000
ia bermakna membahagikan 10 dengan 3, dan apa yang selebihnya?

368
00:22:27,000 --> 00:22:30,000
Ia akan menjadi 1, jadi ia sebenarnya amat berguna untuk banyak program.

369
00:22:30,000 --> 00:22:38,000
Untuk Vigenère dan Caesar Saya agak pasti bahawa semua kalian yang digunakan arena.

370
00:22:38,000 --> 00:22:43,000
Mengenai operator matematik, berhati-hati apabila menggabungkan * dan /.

371
00:22:43,000 --> 00:22:48,000
>> Sebagai contoh, jika anda melakukan (3/2) * 2 apa yang anda akan mendapat?

372
00:22:48,000 --> 00:22:50,000
[Pelajar] 2.

373
00:22:50,000 --> 00:22:54,000
Ya, 2, kerana 3/2 akan ialah 1.5,

374
00:22:54,000 --> 00:22:57,000
tetapi kerana anda sedang melakukan operasi antara 2 integer

375
00:22:57,000 --> 00:22:59,000
anda sebenarnya hanya akan untuk mempertimbangkan 1,

376
00:22:59,000 --> 00:23:03,000
dan kemudian 1 * 2 akan menjadi 2, jadi sangat, sangat berhati-hati

377
00:23:03,000 --> 00:23:07,000
apabila melakukan aritmetik dengan integer kerana

378
00:23:07,000 --> 00:23:12,000
anda mungkin akan mendapat bahawa 2 = 3, dalam kes itu.

379
00:23:12,000 --> 00:23:14,000
Dan juga menjadi sangat berhati-hati tentang keutamaan.

380
00:23:14,000 --> 00:23:21,000
Anda biasanya perlu menggunakan kurungan untuk memastikan bahawa anda tahu apa yang anda lakukan.

381
00:23:21,000 --> 00:23:27,000
Beberapa pintasan berguna, sudah tentu, seseorang itu i + + atau i + = 1

382
00:23:27,000 --> 00:23:30,000
atau menggunakan + =.

383
00:23:30,000 --> 00:23:34,000
Itu adalah perkara yang sama seperti melakukan i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Anda juga boleh melakukan i - atau i - = 1,

385
00:23:39,000 --> 00:23:42,000
yang merupakan perkara yang sama seperti i = i -1,

386
00:23:42,000 --> 00:23:46,000
sesuatu yang anda lelaki menggunakan banyak dalam gelung, sekurang-kurangnya.

387
00:23:46,000 --> 00:23:52,000
Juga, untuk *, jika anda menggunakan * = dan jika anda lakukan, sebagai contoh,

388
00:23:52,000 --> 00:23:57,000
i * = 2 adalah perkara yang sama sebagai berkata i = i * 2,

389
00:23:57,000 --> 00:23:59,000
dan perkara yang sama untuk bahagian.

390
00:23:59,000 --> 00:24:08,000
Jika anda lakukan i / = 2 ia adalah perkara yang sama seperti i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Sekarang tentang fungsi.

392
00:24:10,000 --> 00:24:13,000
Kalian tahu bahawa fungsi adalah satu strategi yang sangat baik untuk menyelamatkan kod

393
00:24:13,000 --> 00:24:16,000
semasa anda pengaturcaraan, jadi jika anda mahu untuk melaksanakan tugas yang sama.

394
00:24:16,000 --> 00:24:20,000
dalam kod sekali lagi dan sekali lagi, mungkin anda mahu menggunakan fungsi

395
00:24:20,000 --> 00:24:25,000
hanya jadi anda tidak perlu copy dan paste kod berulang-ulang kali.

396
00:24:25,000 --> 00:24:28,000
Sebenarnya, utama adalah fungsi, dan apabila saya menunjukkan kepada anda format fungsi

397
00:24:28,000 --> 00:24:32,000
anda akan melihat bahawa itu adalah cukup jelas.

398
00:24:32,000 --> 00:24:35,000
Kami juga menggunakan fungsi dari beberapa perpustakaan,

399
00:24:35,000 --> 00:24:39,000
sebagai contoh, printf, GetIn, yang adalah dari perpustakaan CS50,

400
00:24:39,000 --> 00:24:43,000
dan fungsi lain seperti toupper.

401
00:24:43,000 --> 00:24:46,000
Semua fungsi-fungsi sebenarnya dilaksanakan di perpustakaan lain,

402
00:24:46,000 --> 00:24:49,000
dan apabila anda meletakkan fail-fail menambat di awal program anda

403
00:24:49,000 --> 00:24:53,000
anda mengatakan anda boleh sila berikan saya kod untuk fungsi-fungsi

404
00:24:53,000 --> 00:24:57,000
jadi saya tidak perlu untuk melaksanakan mereka dengan diri sendiri?

405
00:24:57,000 --> 00:25:00,000
Dan anda juga boleh menulis fungsi-fungsi anda sendiri, jadi apabila anda mulakan program

406
00:25:00,000 --> 00:25:04,000
anda sedar bahawa perpustakaan tidak mempunyai segala fungsi yang anda perlukan.

407
00:25:04,000 --> 00:25:10,000
Untuk pset terakhir, sebagai contoh, kita menulis menarik, perebutan, dan lookup,

408
00:25:10,000 --> 00:25:13,000
dan ia adalah amat penting untuk dapat untuk menulis fungsi

409
00:25:13,000 --> 00:25:17,000
kerana mereka adalah berguna, dan kita menggunakannya sepanjang masa dalam pengaturcaraan,

410
00:25:17,000 --> 00:25:19,000
dan ia menjimatkan banyak kod.

411
00:25:19,000 --> 00:25:21,000
Format fungsi adalah salah satu ini.

412
00:25:21,000 --> 00:25:24,000
Kami mempunyai jenis pulangan pada mulanya. Apakah jenis pulangan?

413
00:25:24,000 --> 00:25:27,000
Ia hanya apabila fungsi anda akan kembali.

414
00:25:27,000 --> 00:25:29,000
Jika anda mempunyai fungsi, sebagai contoh, faktorial,

415
00:25:29,000 --> 00:25:31,000
yang akan mengira faktorial integer,

416
00:25:31,000 --> 00:25:34,000
mungkin ia akan kembali integer juga.

417
00:25:34,000 --> 00:25:37,000
Kemudian jenis pulangan akan menjadi int.

418
00:25:37,000 --> 00:25:41,000
Printf sebenarnya mempunyai kekosongan jenis pulangan

419
00:25:41,000 --> 00:25:43,000
kerana anda tidak kembali apa-apa.

420
00:25:43,000 --> 00:25:45,000
Anda hanya mencetak perkara untuk skrin

421
00:25:45,000 --> 00:25:48,000
dan berhenti fungsi selepas itu.

422
00:25:48,000 --> 00:25:51,000
Kemudian anda mempunyai nama fungsi yang anda boleh memilih.

423
00:25:51,000 --> 00:25:55,000
Anda perlu sedikit munasabah, seperti tidak memilih nama seperti xyz

424
00:25:55,000 --> 00:25:58,000
atau seperti x2f.

425
00:25:58,000 --> 00:26:02,000
Cuba untuk membuat nama yang masuk akal.

426
00:26:02,000 --> 00:26:04,000
>> Sebagai contoh, jika ia faktorial, katakan faktorial.

427
00:26:04,000 --> 00:26:08,000
Jika ia merupakan satu fungsi yang akan melukis sesuatu, namakan ia menarik.

428
00:26:08,000 --> 00:26:11,000
Dan kemudian kita mempunyai parameter, yang juga dipanggil hujah,

429
00:26:11,000 --> 00:26:14,000
yang adalah seperti sumber yang berfungsi anda perlu

430
00:26:14,000 --> 00:26:17,000
dari kod anda untuk melaksanakan tugasnya.

431
00:26:17,000 --> 00:26:20,000
Jika anda ingin mengira faktorial nombor

432
00:26:20,000 --> 00:26:23,000
mungkin anda perlukan untuk memiliki nombor untuk mengira faktorial.

433
00:26:23,000 --> 00:26:27,000
Salah satu hujah bahawa anda akan mempunyai bilangan itu sendiri.

434
00:26:27,000 --> 00:26:31,000
Dan kemudian ia akan melakukan sesuatu dan kembali nilai pada akhir

435
00:26:31,000 --> 00:26:35,000
melainkan jika ia adalah fungsi yang tidak sah.

436
00:26:35,000 --> 00:26:37,000
Mari kita lihat satu contoh.

437
00:26:37,000 --> 00:26:40,000
Jika saya mahu menulis fungsi yang jumlah wang semua nombor dalam pelbagai integer,

438
00:26:40,000 --> 00:26:43,000
pertama sekali, jenis pulangan akan menjadi int

439
00:26:43,000 --> 00:26:46,000
kerana saya mempunyai pelbagai integer.

440
00:26:46,000 --> 00:26:51,000
Dan kemudian saya akan mempunyai nama yang berfungsi seperti sumArray,

441
00:26:51,000 --> 00:26:54,000
dan kemudian ia akan mengambil pelbagai itu sendiri, untuk nums int,

442
00:26:54,000 --> 00:26:58,000
dan kemudian panjang array jadi saya tahu berapa banyak nombor saya untuk meringkaskannya.

443
00:26:58,000 --> 00:27:02,000
Kemudian saya perlu untuk memulakan sejumlah pembolehubah yang dipanggil, sebagai contoh, kepada 0,

444
00:27:02,000 --> 00:27:08,000
dan setiap kali saya melihat satu elemen dalam array saya perlu menambah kepada jumlah, jadi saya lakukan untuk gelung.

445
00:27:08,000 --> 00:27:15,000
Sama seperti Lexi berkata, anda lakukan int i = 0, i <panjang dan i + +.

446
00:27:15,000 --> 00:27:20,000
Dan bagi setiap elemen dalam array saya lakukan jumlah + = nums [i],

447
00:27:20,000 --> 00:27:24,000
dan kemudian saya kembali jumlah, jadi ia adalah sangat mudah, dan ia menjimatkan banyak kod

448
00:27:24,000 --> 00:27:28,000
jika anda menggunakan fungsi ini banyak kali.

449
00:27:28,000 --> 00:27:32,000
Kemudian kami mengambil melihat pada keadaan.

450
00:27:32,000 --> 00:27:38,000
Kami mempunyai jika, lain, dan lain jika.

451
00:27:38,000 --> 00:27:42,000
Mari kita lihat apakah perbezaan di antara mereka.

452
00:27:42,000 --> 00:27:45,000
Ambil melihat ini 2 kod. Apakah perbezaan antara mereka?

453
00:27:45,000 --> 00:27:49,000
Yang pertama telah pada dasarnya kod mahu anda untuk memberitahu

454
00:27:49,000 --> 00:27:51,000
jika nombor adalah +, -, atau 0.

455
00:27:51,000 --> 00:27:55,000
Yang pertama mengatakan jika ia> 0, maka ia adalah positif.

456
00:27:55,000 --> 00:28:00,000
Jika ia = kepada 0, maka ia adalah 0, dan jika ia adalah <0, maka ia adalah negatif.

457
00:28:00,000 --> 00:28:04,000
>> Dan satu lagi melakukan jika, else if, lain.

458
00:28:04,000 --> 00:28:07,000
Perbezaan antara kedua-dua adalah bahawa satu ini sebenarnya akan

459
00:28:07,000 --> 00:28:13,000
memeriksa jika> 0 <0 atau = 0 tiga kali,

460
00:28:13,000 --> 00:28:17,000
jadi jika anda mempunyai nombor 2, sebagai contoh, ia akan datang ke sini dan mengatakan

461
00:28:17,000 --> 00:28:21,000
jika (x> 0), dan ia akan berkata ya, jadi saya hendak mencetak positif.

462
00:28:21,000 --> 00:28:25,000
Tetapi walaupun saya tahu bahawa ia adalah> 0 dan ia tidak akan menjadi 0 atau <0

463
00:28:25,000 --> 00:28:29,000
Saya masih akan lakukan ialah 0, ia <0,

464
00:28:29,000 --> 00:28:33,000
jadi saya sebenarnya berlaku di dalam IFS bahawa saya tidak perlu

465
00:28:33,000 --> 00:28:38,000
kerana saya sudah tahu bahawa ia tidak akan memenuhi mana-mana syarat-syarat ini.

466
00:28:38,000 --> 00:28:41,000
Saya boleh menggunakan jika, else if, else.

467
00:28:41,000 --> 00:28:45,000
Ia pada dasarnya mengatakan jika x = 0 saya hendak mencetak positif.

468
00:28:45,000 --> 00:28:48,000
Jika tidak, saya akan juga menguji ini.

469
00:28:48,000 --> 00:28:51,000
Jika ia adalah 2 tidak saya akan melakukan ini.

470
00:28:51,000 --> 00:28:54,000
Pada asasnya jika saya terpaksa x = 2 anda akan mengatakan

471
00:28:54,000 --> 00:28:57,000
jika (x> 0), ya, jadi mencetak ini.

472
00:28:57,000 --> 00:29:00,000
Sekarang saya tahu bahawa ia adalah> 0 dan bahawa ia berpuas pertama jika

473
00:29:00,000 --> 00:29:02,000
Saya tidak akan menjalankan kod ini.

474
00:29:02,000 --> 00:29:09,000
Kod berjalan lebih cepat, sebenarnya, 3 kali lebih cepat jika anda menggunakan ini.

475
00:29:09,000 --> 00:29:11,000
Kami juga belajar tentang dan atau.

476
00:29:11,000 --> 00:29:15,000
Saya tidak akan pergi melalui ini kerana Lexi sudah bercakap tentang mereka.

477
00:29:15,000 --> 00:29:17,000
Ia hanya && dan | pengendali |.

478
00:29:17,000 --> 00:29:21,000
>> Satu-satunya perkara yang saya akan katakan adalah berhati-hati apabila anda mempunyai 3 keadaan.

479
00:29:21,000 --> 00:29:24,000
Gunakan kurungan kerana ia adalah sangat mengelirukan apabila anda mempunyai keadaan

480
00:29:24,000 --> 00:29:27,000
dan satu lagi atau satu lagi.

481
00:29:27,000 --> 00:29:30,000
Gunakan kurungan hanya untuk memastikan bahawa keadaan anda masuk akal

482
00:29:30,000 --> 00:29:34,000
kerana dalam kes itu, sebagai contoh, anda boleh membayangkan bahawa

483
00:29:34,000 --> 00:29:38,000
ia boleh menjadi syarat pertama dan satu atau yang lain

484
00:29:38,000 --> 00:29:41,000
atau 2 syarat yang digabungkan dalam dan

485
00:29:41,000 --> 00:29:45,000
atau satu pertiga, jadi berhati-hati.

486
00:29:45,000 --> 00:29:48,000
Dan akhirnya, kita bercakap tentang suis.

487
00:29:48,000 --> 00:29:53,000
Suis adalah sangat berguna apabila anda mempunyai pembolehubah.

488
00:29:53,000 --> 00:29:55,000
Mari kita mengatakan bahawa anda mempunyai pembolehubah seperti n

489
00:29:55,000 --> 00:29:59,000
yang boleh menjadi 0, 1, atau 2, dan bagi setiap kes-kes

490
00:29:59,000 --> 00:30:01,000
anda akan melaksanakan tugas.

491
00:30:01,000 --> 00:30:04,000
Anda boleh mengatakan menukar pembolehubah, dan ia menunjukkan bahawa

492
00:30:04,000 --> 00:30:08,000
nilai itu adalah seperti nilai1 saya akan berbuat demikian,

493
00:30:08,000 --> 00:30:12,000
dan kemudian saya memecahkan, yang bermakna saya tidak akan kelihatan di mana-mana kes-kes lain

494
00:30:12,000 --> 00:30:15,000
kerana kita sudah berpuas hati kes itu

495
00:30:15,000 --> 00:30:20,000
dan kemudian nilai2 dan sebagainya, dan saya juga boleh mempunyai suis lalai.

496
00:30:20,000 --> 00:30:24,000
Ini bermakna jika ia tidak memenuhi mana-mana kes-kes yang saya telah

497
00:30:24,000 --> 00:30:29,000
bahawa saya akan melakukan sesuatu yang lain, tetapi itulah pilihan.

498
00:30:29,000 --> 00:30:36,000
Itu semua bagi saya. Sekarang mari kita Tommy.

499
00:30:36,000 --> 00:30:41,000
Baiklah, ini akan menjadi Minggu 3-ish.

500
00:30:41,000 --> 00:30:45,000
Ini adalah beberapa topik yang kita akan meliputi, kripto, skop, tatasusunan, dan sebagainya.

501
00:30:45,000 --> 00:30:49,000
Hanya satu perkataan yang cepat pada kripto. Kami tidak akan tukul rumah ini.

502
00:30:49,000 --> 00:30:52,000
>> Kami melakukan ini dalam pset 2, tetapi untuk kuiz pastikan anda tahu perbezaan

503
00:30:52,000 --> 00:30:54,000
antara cipher Caesar dan cipher Vigenère,

504
00:30:54,000 --> 00:30:57,000
bagaimana kedua-dua kerja sifer mereka dan apa yang ia seperti untuk menyulitkan

505
00:30:57,000 --> 00:30:59,000
dan teks menyahsulit menggunakan mereka 2 sifer.

506
00:30:59,000 --> 00:31:03,000
Ingat, cipher Caesar hanya berputar watak masing-masing dengan jumlah yang sama,

507
00:31:03,000 --> 00:31:06,000
memastikan anda arena oleh bilangan huruf dalam abjad.

508
00:31:06,000 --> 00:31:09,000
Dan cipher Vigenère, di sisi lain, berputar setiap aksara

509
00:31:09,000 --> 00:31:12,000
dengan jumlah yang berbeza, jadi bukannya mengatakan

510
00:31:12,000 --> 00:31:15,000
setiap diputar watak oleh 3 Vigenère akan memutarkan setiap aksara

511
00:31:15,000 --> 00:31:17,000
oleh jumlah yang berbeza bergantung pada kata kunci tertentu

512
00:31:17,000 --> 00:31:20,000
di mana setiap huruf dalam kata kunci mewakili beberapa jumlah yang berbeza

513
00:31:20,000 --> 00:31:26,000
untuk memutar teks yang jelas oleh.

514
00:31:26,000 --> 00:31:28,000
Mari kita bercakap pertama mengenai skop pembolehubah.

515
00:31:28,000 --> 00:31:30,000
Terdapat 2 jenis pembolehubah.

516
00:31:30,000 --> 00:31:33,000
Kami mempunyai pembolehubah tempatan, dan ini akan ditakrifkan

517
00:31:33,000 --> 00:31:36,000
luar utama atau di luar mana-mana fungsi atau blok,

518
00:31:36,000 --> 00:31:39,000
dan ini akan boleh diakses di mana-mana dalam program anda.

519
00:31:39,000 --> 00:31:41,000
Jika anda mempunyai fungsi dan dalam fungsi itu adalah gelung sementara

520
00:31:41,000 --> 00:31:44,000
pembolehubah global yang besar boleh diakses di mana-mana.

521
00:31:44,000 --> 00:31:48,000
Satu pembolehubah tempatan, di sisi lain, adalah scoped ke tempat di mana ia ditakrifkan.

522
00:31:48,000 --> 00:31:53,000
>> Jika anda mempunyai fungsi di sini, sebagai contoh, kita mempunyai ini fungsi g,

523
00:31:53,000 --> 00:31:56,000
dan di dalam g terdapat pembolehubah yang di sini dipanggil y,

524
00:31:56,000 --> 00:31:58,000
dan ini bermakna bahawa ini adalah satu pemboleh ubah tempatan.

525
00:31:58,000 --> 00:32:00,000
Walaupun pembolehubah ini dipanggil y

526
00:32:00,000 --> 00:32:03,000
dan berubah-ubah ini dipanggil y 2 fungsi

527
00:32:03,000 --> 00:32:06,000
tidak mempunyai idea apa pembolehubah tempatan antara satu sama lain.

528
00:32:06,000 --> 00:32:10,000
Sebaliknya, di sini kita katakan int x = 5,

529
00:32:10,000 --> 00:32:12,000
dan ini adalah di luar skop fungsi mana-mana.

530
00:32:12,000 --> 00:32:16,000
Ia adalah di luar skop utama, jadi ini adalah satu pemboleh ubah global.

531
00:32:16,000 --> 00:32:20,000
Ini bermakna bahawa dalam 2 fungsi ini apabila saya mengatakan x - atau x + +

532
00:32:20,000 --> 00:32:26,000
Saya mengakses x sama di mana ini y dan y ini adalah pembolehubah yang berbeza.

533
00:32:26,000 --> 00:32:30,000
Itulah perbezaan antara pemboleh ubah global dan pembolehubah tempatan.

534
00:32:30,000 --> 00:32:33,000
Setakat reka bentuk berkenaan, kadang-kadang ia mungkin idea yang lebih baik

535
00:32:33,000 --> 00:32:37,000
untuk memastikan pembolehubah tempatan apabila anda mungkin boleh

536
00:32:37,000 --> 00:32:39,000
sejak mempunyai sekumpulan pembolehubah global boleh mendapatkan benar-benar mengelirukan.

537
00:32:39,000 --> 00:32:42,000
Jika anda mempunyai sekumpulan fungsi semua mengubah perkara yang sama

538
00:32:42,000 --> 00:32:45,000
anda mungkin lupa bagaimana jika fungsi ini sengaja mengubah global ini,

539
00:32:45,000 --> 00:32:47,000
dan fungsi ini lain tidak tahu tentang hal itu,

540
00:32:47,000 --> 00:32:50,000
dan ia tidak mendapatkan cukup mengelirukan kerana anda mendapatkan kod yang lebih.

541
00:32:50,000 --> 00:32:53,000
Mengekalkan pembolehubah tempatan apabila anda mungkin boleh

542
00:32:53,000 --> 00:32:56,000
adalah reka bentuk sahaja baik.

543
00:32:56,000 --> 00:33:00,000
Tatasusunan, ingat, hanya senarai unsur-unsur jenis yang sama.

544
00:33:00,000 --> 00:33:04,000
Dalam CI tidak boleh mempunyai senarai seperti 1, 2.0, hello.

545
00:33:04,000 --> 00:33:06,000
Kita tidak boleh berbuat demikian.

546
00:33:06,000 --> 00:33:11,000
>> Apabila kita mengisytiharkan array dalam C semua unsur-unsur perlu untuk menjadi jenis yang sama.

547
00:33:11,000 --> 00:33:14,000
Di sini saya mempunyai pelbagai daripada 3 integer.

548
00:33:14,000 --> 00:33:18,000
Di sini saya mempunyai panjang array, tetapi jika saya hanya mengisytiharkan ia dalam sintaks ini

549
00:33:18,000 --> 00:33:21,000
mana saya nyatakan apa yang semua unsur-unsur Saya tidak teknikal memerlukan 3 ini.

550
00:33:21,000 --> 00:33:25,000
Pengkompil adalah cukup bijak untuk memikirkan bagaimana besar array perlu.

551
00:33:25,000 --> 00:33:28,000
Sekarang apabila saya ingin mendapatkan atau menetapkan nilai array

552
00:33:28,000 --> 00:33:30,000
ini adalah sintaks untuk berbuat demikian.

553
00:33:30,000 --> 00:33:33,000
Ini sebenarnya akan mengubah elemen kedua array kerana, ingat,

554
00:33:33,000 --> 00:33:36,000
penomboran bermula pada 0, bukan pada 1.

555
00:33:36,000 --> 00:33:42,000
Jika saya mahu untuk membaca nilai yang saya boleh mengatakan sesuatu seperti int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Atau jika saya ingin menetapkan nilai itu, seperti yang saya lakukan di sini,

557
00:33:44,000 --> 00:33:47,000
Boleh saya katakan pelbagai [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Itu masa mengakses elemen oleh indeks mereka

559
00:33:50,000 --> 00:33:52,000
atau kedudukan mereka atau di mana mereka berada dalam array,

560
00:33:52,000 --> 00:33:57,000
dan penyenaraian yang bermula pada 0.

561
00:33:57,000 --> 00:34:00,000
Kita juga boleh mempunyai tatasusunan array,

562
00:34:00,000 --> 00:34:03,000
dan ini dipanggil pelbagai multi-dimensi.

563
00:34:03,000 --> 00:34:05,000
Apabila kita mempunyai pelbagai pelbagai dimensi

564
00:34:05,000 --> 00:34:07,000
yang bermakna kita boleh mempunyai sesuatu seperti baris dan lajur,

565
00:34:07,000 --> 00:34:11,000
dan ini adalah hanya satu cara menggambarkan ini atau memikirkan ia.

566
00:34:11,000 --> 00:34:14,000
Apabila saya mempunyai pelbagai multi-dimensi yang bermakna saya akan mula memerlukan

567
00:34:14,000 --> 00:34:17,000
lebih daripada 1 indeks kerana jika saya mempunyai grid

568
00:34:17,000 --> 00:34:19,000
hanya mengatakan apa berturut-turut anda berada dalam tidak memberi kita nombor satu.

569
00:34:19,000 --> 00:34:22,000
Itu benar-benar hanya akan memberikan kita senarai nombor.

570
00:34:22,000 --> 00:34:25,000
Katakan saya mempunyai array ini di sini.

571
00:34:25,000 --> 00:34:30,000
Saya mempunyai pelbagai dipanggil grid, dan saya mengatakan baris 2 itu dan 3 lajur,

572
00:34:30,000 --> 00:34:32,000
dan jadi ini adalah salah satu cara menggambarkan ia.

573
00:34:32,000 --> 00:34:37,000
Apabila saya katakan saya mahu untuk mendapatkan elemen pada [1] [2]

574
00:34:37,000 --> 00:34:41,000
yang bererti bahawa oleh kerana ini adalah baris pertama dan kemudian lajur

575
00:34:41,000 --> 00:34:44,000
Saya akan melompat untuk berdayung 1 sejak saya berkata 1.

576
00:34:44,000 --> 00:34:49,000
>> Kemudian saya akan datang ke sini untuk lajur 2, dan saya akan mendapatkan nilai 6.

577
00:34:49,000 --> 00:34:51,000
Masuk akal?

578
00:34:51,000 --> 00:34:55,000
Tatasusunan Multi-dimensi, ingat, teknikal hanya pelbagai tatasusunan.

579
00:34:55,000 --> 00:34:57,000
Kita boleh mempunyai tatasusunan tatasusunan array.

580
00:34:57,000 --> 00:35:00,000
Kita boleh terus pergi, tetapi benar-benar salah satu cara untuk berfikir tentang

581
00:35:00,000 --> 00:35:03,000
bagaimana ini sedang dibentangkan dan apa yang berlaku adalah untuk menggambarkan

582
00:35:03,000 --> 00:35:09,000
dalam grid seperti ini.

583
00:35:09,000 --> 00:35:12,000
Apabila kita meninggal tatasusunan kepada fungsi, mereka akan berkelakuan

584
00:35:12,000 --> 00:35:16,000
sedikit berbeza daripada apabila kita meninggal pembolehubah tetap untuk fungsi

585
00:35:16,000 --> 00:35:18,000
seperti melepaskan int atau apungan.

586
00:35:18,000 --> 00:35:21,000
Apabila kita lulus dalam jenis int atau char atau mana-mana data lain

587
00:35:21,000 --> 00:35:24,000
kita hanya mengambil melihat jika fungsi mengubah

588
00:35:24,000 --> 00:35:28,000
nilai pembolehubah bahawa bahawa perubahan tidak akan membiakkan

589
00:35:28,000 --> 00:35:32,000
kepada fungsi memanggil.

590
00:35:32,000 --> 00:35:35,000
Dengan pelbagai, di sisi lain, yang akan berlaku.

591
00:35:35,000 --> 00:35:39,000
Jika saya lulus dalam pelbagai untuk beberapa fungsi dan fungsi yang mengubah beberapa elemen,

592
00:35:39,000 --> 00:35:43,000
apabila saya datang kembali ke fungsi yang dipanggil

593
00:35:43,000 --> 00:35:47,000
pelbagai saya kini akan menjadi berbeza, dan perbendaharaan kata untuk itu

594
00:35:47,000 --> 00:35:50,000
tatasusunan adalah diluluskan oleh rujukan, seperti yang kita akan lihat nanti.

595
00:35:50,000 --> 00:35:53,000
Ini adalah berkaitan dengan bagaimana kerja petunjuk, di mana ini jenis data asas,

596
00:35:53,000 --> 00:35:55,000
Sebaliknya, yang diluluskan oleh nilai.

597
00:35:55,000 --> 00:35:59,000
>> Kita boleh berfikir bahawa seperti membuat salinan pembolehubah beberapa dan kemudian lulus dalam salinan.

598
00:35:59,000 --> 00:36:01,000
Ia tidak kira apa yang kita lakukan dengan pembolehubah yang.

599
00:36:01,000 --> 00:36:06,000
Fungsi panggilan tidak akan sedar bahawa ia telah berubah.

600
00:36:06,000 --> 00:36:10,000
Tatasusunan adalah hanya sedikit berbeza dalam hal itu.

601
00:36:10,000 --> 00:36:13,000
Sebagai contoh, kerana kita hanya melihat, utama ialah hanya fungsi

602
00:36:13,000 --> 00:36:15,000
yang boleh mengambil dalam 2 hujah.

603
00:36:15,000 --> 00:36:20,000
Hujah pertama untuk fungsi utama adalah argc, atau bilangan hujah,

604
00:36:20,000 --> 00:36:23,000
dan hujah kedua dipanggil argv,

605
00:36:23,000 --> 00:36:27,000
dan mereka adalah nilai sebenar mereka hujah.

606
00:36:27,000 --> 00:36:30,000
Katakan saya mempunyai satu program yang dipanggil this.c,

607
00:36:30,000 --> 00:36:34,000
dan saya katakan membuat ini, dan saya akan menjalankannya pada baris arahan.

608
00:36:34,000 --> 00:36:38,000
Sekarang untuk lulus dalam beberapa hujah untuk program saya dipanggil ini,

609
00:36:38,000 --> 00:36:42,000
Saya boleh mengatakan sesuatu seperti. / Ini adalah cs 50.

610
00:36:42,000 --> 00:36:45,000
Ini adalah apa yang kita bayangkan Daud untuk melakukan setiap hari di terminal.

611
00:36:45,000 --> 00:36:48,000
Tetapi kini fungsi utama dalam program itu

612
00:36:48,000 --> 00:36:52,000
mempunyai nilai-nilai ini, jadi argc ialah 4.

613
00:36:52,000 --> 00:36:56,000
Ia mungkin sedikit mengelirukan kerana benar-benar kita hanya lulus dalam cs 50.

614
00:36:56,000 --> 00:36:58,000
Itu hanya 3.

615
00:36:58,000 --> 00:37:02,000
Tetapi ingat bahawa elemen pertama argv atau hujah pertama

616
00:37:02,000 --> 00:37:05,000
adalah nama fungsi itu sendiri.

617
00:37:05,000 --> 00:37:07,190
Jadi ini bermakna bahawa kita mempunyai 4 perkara di sini,

618
00:37:07,190 --> 00:37:10,530
dan elemen pertama akan menjadi. / ini.

619
00:37:10,530 --> 00:37:12,970
Dan ini akan diwakili sebagai rentetan.

620
00:37:12,970 --> 00:37:18,590
Kemudian unsur-unsur yang selebihnya adalah apa yang kita ditaip dalam selepas nama program.

621
00:37:18,590 --> 00:37:22,720
Jadi hanya sebagai diketepikan, kerana kita mungkin melihat di pset 2,

622
00:37:22,720 --> 00:37:28,780
ingat bahawa rentetan 50 ≠ 50 integer.

623
00:37:28,780 --> 00:37:32,520
Jadi kita tidak boleh mengatakan sesuatu seperti, 'int x = argv 3.'

624
00:37:32,520 --> 00:37:36,470
>> Itu hanya tidak akan masuk akal, kerana ini adalah rentetan, dan ini adalah integer.

625
00:37:36,470 --> 00:37:38,510
Jadi jika anda mahu untuk menukar antara 2, ingat, kita akan

626
00:37:38,510 --> 00:37:40,810
mempunyai fungsi ini sihir dipanggil atoi.

627
00:37:40,810 --> 00:37:46,270
Itu mengambil rentetan dan mengembalikan integer yang diwakili di dalam rentetan itu.

628
00:37:46,270 --> 00:37:48,360
Jadi itulah kesilapan mudah untuk membuat kuiz,

629
00:37:48,360 --> 00:37:51,590
hanya memikirkan bahawa ini secara automatik akan menjadi jenis yang betul.

630
00:37:51,590 --> 00:37:53,860
Tetapi hanya tahu bahawa ini akan sentiasa menjadi rentetan

631
00:37:53,860 --> 00:38:00,920
walaupun rentetan hanya mengandungi integer atau watak atau apungan.

632
00:38:00,920 --> 00:38:03,380
Jadi sekarang mari kita bercakap tentang masa berjalan.

633
00:38:03,380 --> 00:38:06,700
Apabila kita mempunyai semua algoritma ini yang melakukan semua perkara-perkara ini gila,

634
00:38:06,700 --> 00:38:11,580
ia menjadi benar-benar berguna untuk bertanya soalan, "Berapa lama mereka mengambil?"

635
00:38:11,580 --> 00:38:15,500
Kami mewakili bahawa dengan sesuatu yang dipanggil notasi asimptot.

636
00:38:15,500 --> 00:38:18,430
Jadi ini bermakna - baik, mari kita mengatakan bahawa kita memberikan algoritma kami

637
00:38:18,430 --> 00:38:20,840
beberapa input yang benar-benar, benar-benar, benar-benar besar.

638
00:38:20,840 --> 00:38:23,840
Kami mahu bertanya soalan, "Berapa lama ia akan mengambil?

639
00:38:23,840 --> 00:38:26,370
Berapa banyak langkah-langkah yang ia akan mengambil algoritma kami untuk menjalankan

640
00:38:26,370 --> 00:38:29,980
sebagai fungsi saiz input? "

641
00:38:29,980 --> 00:38:33,080
Jadi Cara pertama kita boleh menggambarkan masa berjalan dengan besar O.

642
00:38:33,080 --> 00:38:35,380
Dan ini adalah masa terburuk berjalan kami.

643
00:38:35,380 --> 00:38:38,590
Jadi, jika kita mahu untuk menyelesaikan array, dan kita memberi algoritma kami array

644
00:38:38,590 --> 00:38:41,000
itulah dalam turutan menurun apabila ia perlu berada dalam usaha menaik,

645
00:38:41,000 --> 00:38:43,130
yang akan menjadi kes terburuk.

646
00:38:43,130 --> 00:38:49,800
Ini adalah atas kami terikat dalam panjang maksimum masa algoritma kami akan mengambil.

647
00:38:49,800 --> 00:38:54,740
Sebaliknya, ini Ω akan untuk menggambarkan kes terbaik masa berjalan.

648
00:38:54,740 --> 00:38:58,210
Jadi, jika kita memberi pelbagai yang sudah disusun algoritma sorting,

649
00:38:58,210 --> 00:39:00,940
berapa lama ia akan mengambil masa untuk mengatasinya?

650
00:39:00,940 --> 00:39:06,610
Dan ini, maka, menerangkan lebih rendah terikat pada menjalankan masa.

651
00:39:06,610 --> 00:39:10,980
Jadi di sini adalah hanya beberapa perkataan yang menggambarkan beberapa kali berjalan biasa.

652
00:39:10,980 --> 00:39:13,120
Ini adalah dalam tertib menaik.

653
00:39:13,120 --> 00:39:16,060
Masa terpantas berjalan kita ada dipanggil malar.

654
00:39:16,060 --> 00:39:19,800
>> Ini bermakna tidak kira berapa banyak elemen yang kita berikan algoritma kami,

655
00:39:19,800 --> 00:39:22,280
tidak kira berapa besar pelbagai kami, sorting

656
00:39:22,280 --> 00:39:26,510
atau melakukan apa sahaja yang kita lakukan kepada array akan sentiasa mengambil jumlah masa yang sama.

657
00:39:26,510 --> 00:39:30,270
Jadi, kita boleh menyatakan bahawa hanya dengan 1, yang adalah pemalar.

658
00:39:30,270 --> 00:39:32,410
Kami juga melihat pada masa jangka logaritma.

659
00:39:32,410 --> 00:39:34,800
Jadi sesuatu seperti carian binari adalah logaritma,

660
00:39:34,800 --> 00:39:37,140
di mana kita mengurangkan masalah pada separuh masa setiap

661
00:39:37,140 --> 00:39:40,970
dan kemudian perkara yang hanya mendapat yang lebih tinggi dari sana.

662
00:39:40,970 --> 00:39:43,580
Dan jika anda pernah menulis O mana-mana algoritma faktorial,

663
00:39:43,580 --> 00:39:47,850
anda mungkin tidak perlu menganggap ini sebagai kerja hari anda.

664
00:39:47,850 --> 00:39:53,910
Apabila kita bandingkan menjalankan kali ia adalah penting untuk ingat perkara-perkara ini.

665
00:39:53,910 --> 00:39:57,760
Jadi jika saya mempunyai algoritma yang O (n), dan orang lain

666
00:39:57,760 --> 00:40:03,590
telah algoritma O (2n) ini adalah sebenarnya berasimptot bersamaan.

667
00:40:03,590 --> 00:40:06,590
Jadi, jika kita dapat n untuk menjadi nombor besar seperti eleventy bilion:

668
00:40:06,590 --> 00:40:13,090
jadi apabila kita membandingkan eleventy bilion kepada sesuatu seperti eleventy bilion + 3,

669
00:40:13,090 --> 00:40:17,640
tiba-tiba 3 yang tidak benar-benar membuat perbezaan yang besar lagi.

670
00:40:17,640 --> 00:40:20,980
Itulah sebabnya kita akan mula mempertimbangkan perkara-perkara ini untuk menjadi setaraf.

671
00:40:20,980 --> 00:40:24,220
Jadi perkara seperti ini pemalar di sini, terdapat 2 x ini, atau menambah 3,

672
00:40:24,220 --> 00:40:27,180
ini adalah hanya pemalar, dan ini akan jatuh.

673
00:40:27,180 --> 00:40:32,480
Jadi itulah sebabnya semua 3 daripada masa-masa yang dikendalikan adalah sama seperti mengatakan mereka berada O (n).

674
00:40:32,480 --> 00:40:37,490
Begitu juga, jika kita mempunyai 2 jangka masa yang lain, katakan O (n ³ + 2n ²), kita boleh menambah

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, dan kemudian kita mempunyai satu masa yang lain jangka yang hanya O (n ³).

676
00:40:42,070 --> 00:40:46,290
sekali lagi, ini adalah perkara yang sama kerana ini - ini tidak sama.

677
00:40:46,290 --> 00:40:49,840
Ini adalah perkara yang sama, maaf. Jadi ini adalah sama kerana

678
00:40:49,840 --> 00:40:53,090
³ n ini akan menguasai ² 2n.

679
00:40:53,090 --> 00:40:59,130
>> Apa yang tidak perkara yang sama jika kita telah menjalankan kali seperti O (n ³) dan O (n ²)

680
00:40:59,130 --> 00:41:02,820
kerana ³ n ini adalah lebih besar daripada ² n ini.

681
00:41:02,820 --> 00:41:05,470
Jadi jika kita mempunyai atlet, tiba-tiba ini bermula kira,

682
00:41:05,470 --> 00:41:08,280
tetapi apabila kita hanya berurusan dengan faktor-faktor seperti kita di sini,

683
00:41:08,280 --> 00:41:12,810
maka ia tidak akan perkara kerana mereka hanya akan terkeluar.

684
00:41:12,810 --> 00:41:16,760
Mari kita lihat di beberapa algoritma yang telah kita lihat setakat

685
00:41:16,760 --> 00:41:19,260
dan bercakap tentang masa larian mereka.

686
00:41:19,260 --> 00:41:23,850
Cara pertama mencari bilangan dalam senarai, yang kita lihat, carian linear.

687
00:41:23,850 --> 00:41:26,950
Dan pelaksanaan carian linear adalah super mudah.

688
00:41:26,950 --> 00:41:30,490
Kami hanya mempunyai senarai, dan kita akan melihat setiap elemen tunggal dalam senarai

689
00:41:30,490 --> 00:41:34,260
sehingga kita dapati nombor kita sedang mencari.

690
00:41:34,260 --> 00:41:38,370
Supaya bermakna bahawa dalam kes terburuk, O (n).

691
00:41:38,370 --> 00:41:40,860
Dan kes terburuk di sini boleh menjadi jika elemen

692
00:41:40,860 --> 00:41:45,710
elemen terakhir, kemudian menggunakan carian linear kita perlu melihat setiap elemen tunggal

693
00:41:45,710 --> 00:41:50,180
sehingga kita sampai ke satu yang terakhir untuk mengetahui bahawa ia adalah sebenarnya dalam senarai.

694
00:41:50,180 --> 00:41:52,910
Kita tidak boleh hanya memberikan separuh dan mengatakan, "Ia mungkin tidak ada."

695
00:41:52,910 --> 00:41:55,980
Dengan carian linear, kita perlu melihat perkara keseluruhan.

696
00:41:55,980 --> 00:41:59,090
Masa berjalan kes terbaik, di sisi lain, adalah malar

697
00:41:59,090 --> 00:42:04,200
kerana dalam kes terbaik elemen yang kita sedang mencari hanya yang pertama dalam senarai.

698
00:42:04,200 --> 00:42:08,930
Jadi ia akan membawa kita sebenarnya langkah 1, tidak kira berapa besar senarai

699
00:42:08,930 --> 00:42:12,140
jika kita sedang mencari elemen pertama setiap masa.

700
00:42:12,140 --> 00:42:15,390
>> Jadi apabila anda mencari, ingat, ia tidak memerlukan bahawa senarai kami perlu diselesaikan.

701
00:42:15,390 --> 00:42:19,430
Kerana kita hanya akan melihat lebih setiap elemen tunggal, dan ia tidak benar-benar perkara

702
00:42:19,430 --> 00:42:23,560
apakah perintah mereka adalah elemen masuk

703
00:42:23,560 --> 00:42:28,110
Sebuah algoritma carian yang lebih bijak adalah sesuatu seperti carian binari.

704
00:42:28,110 --> 00:42:31,500
Ingat, pelaksanaan carian binari adalah apabila anda hendak

705
00:42:31,500 --> 00:42:34,320
terus mencari di tengah-tengah senarai.

706
00:42:34,320 --> 00:42:38,000
Dan kerana kita sedang mencari di tengah-tengah, kita memerlukan senarai diisih

707
00:42:38,000 --> 00:42:40,580
atau lain kita tidak tahu mana tengah-tengah, dan kita perlu untuk melihat lebih

708
00:42:40,580 --> 00:42:44,480
senarai keseluruhan untuk mencari ia, dan kemudian pada ketika itu kita hanya membuang masa.

709
00:42:44,480 --> 00:42:48,480
Jadi jika kita mempunyai senarai yang disusun dan kita dapati tengah-tengah, kita akan membandingkan tengah

710
00:42:48,480 --> 00:42:51,590
kepada elemen kita sedang mencari.

711
00:42:51,590 --> 00:42:54,640
Jika ia terlalu tinggi, maka kita boleh melupakan separuh yang betul

712
00:42:54,640 --> 00:42:57,810
kerana kita tahu bahawa jika unsur kami sudah terlalu tinggi

713
00:42:57,810 --> 00:43:01,080
dan segala-galanya hak unsur ini adalah lebih tinggi,

714
00:43:01,080 --> 00:43:02,760
maka kita tidak perlu melihat ada lagi.

715
00:43:02,760 --> 00:43:05,430
Jika di sisi lain, jika elemen kami adalah terlalu rendah,

716
00:43:05,430 --> 00:43:08,700
kita tahu segala-galanya ke kiri elemen itu adalah juga terlalu rendah,

717
00:43:08,700 --> 00:43:11,390
jadi ia tidak benar-benar masuk akal untuk melihat di sana, sama ada.

718
00:43:11,390 --> 00:43:15,760
Dengan cara ini, dengan setiap langkah dan setiap kali kita melihat titik tengah senarai,

719
00:43:15,760 --> 00:43:19,060
kita pergi untuk mengurangkan masalah kami pada separuh kerana tiba-tiba kita tahu

720
00:43:19,060 --> 00:43:23,040
keseluruhan sekumpulan nombor yang tidak boleh menjadi salah satu yang kita cari.

721
00:43:23,040 --> 00:43:26,950
>> Dalam pseudokod ini akan melihat sesuatu seperti ini,

722
00:43:26,950 --> 00:43:30,990
dan kerana kita sedang memotong senarai pada separuh masa setiap satu,

723
00:43:30,990 --> 00:43:34,920
melompat kes terburuk masa jangka kami daripada linear kepada logaritma.

724
00:43:34,920 --> 00:43:39,260
Jadi tiba-tiba kita mempunyai log dalam langkah-langkah untuk mencari satu elemen dalam senarai.

725
00:43:39,260 --> 00:43:42,460
Masa berjalan kes terbaik, walaupun, masih berterusan

726
00:43:42,460 --> 00:43:45,180
kerana sekarang, mari kita hanya mengatakan bahawa elemen yang kita cari adalah

727
00:43:45,180 --> 00:43:48,380
sentiasa pertengahan tepat senarai asal.

728
00:43:48,380 --> 00:43:52,080
Jadi, kita boleh mengembangkan senarai kami sebagai besar seperti yang kita mahu, tetapi jika elemen yang kita cari adalah di tengah-tengah,

729
00:43:52,080 --> 00:43:54,910
maka ia hanya akan membawa kita langkah 1.

730
00:43:54,910 --> 00:44:00,920
Jadi itulah sebabnya kita O (log n) dan Ω (1) atau berterusan.

731
00:44:00,920 --> 00:44:04,510
Mari kita sebenarnya menjalankan carian binari dalam senarai ini.

732
00:44:04,510 --> 00:44:08,020
Jadi mari kita mengatakan bahawa kita sedang mencari elemen 164.

733
00:44:08,020 --> 00:44:11,650
Perkara pertama yang kita akan lakukan adalah mencari titik tengah senarai ini.

734
00:44:11,650 --> 00:44:15,060
Ia hanya kebetulan bahawa titik tengah akan jatuh di antara 2 nombor,

735
00:44:15,060 --> 00:44:18,960
jadi mari kita hanya sewenang-wenangnya berkata, setiap kali titik tengah jatuh antara 2 nombor,

736
00:44:18,960 --> 00:44:21,150
mari kita hanya pusingan.

737
00:44:21,150 --> 00:44:24,330
Kita hanya perlu pastikan yang kita lakukan ini setiap langkah perjalanan.

738
00:44:24,330 --> 00:44:29,040
Jadi kami pergi ke pusingan sehingga, dan kita akan mengatakan bahawa 161 adalah pertengahan senarai kami.

739
00:44:29,040 --> 00:44:34,640
Jadi 161 <164, dan setiap elemen ke kiri daripada 161

740
00:44:34,640 --> 00:44:39,120
juga <164, jadi kita tahu bahawa ia tidak akan membantu kita pada semua

741
00:44:39,120 --> 00:44:42,690
untuk mula mencari di sini kerana unsur kita cari tidak boleh berada di sana.

742
00:44:42,690 --> 00:44:47,060
Jadi apa yang kita boleh lakukan ialah kita hanya boleh melupakan separuh bahawa keseluruhan kiri senarai,

743
00:44:47,060 --> 00:44:51,700
dan kini hanya mempertimbangkan dari kanan seterusnya 161.

744
00:44:51,700 --> 00:44:54,050
>> Jadi sekali lagi, ini adalah titik tengah, mari kita hanya pusingan.

745
00:44:54,050 --> 00:44:56,260
Sekarang 175 adalah terlalu besar.

746
00:44:56,260 --> 00:44:59,180
Jadi kita tahu ia tidak akan membantu kita mencari di sini atau di sini,

747
00:44:59,180 --> 00:45:06,610
jadi kita hanya boleh membuang yang jauh, dan akhirnya kita akan mencecah 164.

748
00:45:06,610 --> 00:45:10,560
Sebarang pertanyaan pada carian binari?

749
00:45:10,560 --> 00:45:14,180
Mari kita beralih daripada mencari melalui senarai yang sudah disusun

750
00:45:14,180 --> 00:45:17,660
untuk benar-benar mengambil senarai nombor dalam mana-mana perintah

751
00:45:17,660 --> 00:45:20,960
dan membuat senarai itu dalam tertib menaik.

752
00:45:20,960 --> 00:45:24,060
Algoritma pertama kita melihat dipanggil isih gelembung.

753
00:45:24,060 --> 00:45:27,300
Dan ini akan menjadi mudah algoritma yang kita lihat.

754
00:45:27,300 --> 00:45:32,970
Isih gelembung mengatakan bahawa apabila mana-mana 2 elemen di dalam senarai adalah keluar dari tempat,

755
00:45:32,970 --> 00:45:36,500
bermakna terdapat beberapa yang lebih tinggi ke kiri bilangan yang lebih rendah,

756
00:45:36,500 --> 00:45:40,190
maka kita pergi untuk menukar mereka, kerana itu bermakna bahawa senarai ini akan menjadi

757
00:45:40,190 --> 00:45:42,860
"Lebih disusun" berbanding sebelum ia.

758
00:45:42,860 --> 00:45:45,180
Dan kami hanya akan meneruskan proses ini sekali lagi dan lagi dan lagi

759
00:45:45,180 --> 00:45:52,100
sehingga akhirnya jenis unsur gelembung ke lokasi yang betul mereka dan kami mempunyai senarai yang disusun.

760
00:45:52,100 --> 00:45:57,230
>> Jangka masa ini akan menjadi O (n ²). Mengapa?

761
00:45:57,230 --> 00:46:00,370
Nah, kerana dalam kes terburuk, kita akan mengambil setiap elemen, dan

762
00:46:00,370 --> 00:46:04,570
kita akan berakhir membandingkan kepada setiap elemen lain dalam senarai.

763
00:46:04,570 --> 00:46:08,030
Tetapi dalam kes yang terbaik, kita mempunyai senarai yang sudah disusun, gelembung apapun

764
00:46:08,030 --> 00:46:12,230
hanya akan pergi melalui sekali, katakan "Nope, saya tidak membuat apa-apa pertukaran, jadi saya lakukan."

765
00:46:12,230 --> 00:46:17,410
Jadi kita mempunyai masa terbaik kes berjalan Ω (n).

766
00:46:17,410 --> 00:46:20,680
Mari kita menjalankan apapun gelembung pada senarai.

767
00:46:20,680 --> 00:46:23,560
Atau pertama, mari kita hanya melihat pseudokod beberapa benar-benar cepat.

768
00:46:23,560 --> 00:46:28,160
Kami mahu mengatakan bahawa kita mahu menjejaki, dalam setiap lelaran gelung,

769
00:46:28,160 --> 00:46:32,190
menjejaki sama ada atau tidak kita mengubah sebarang unsur-unsur.

770
00:46:32,190 --> 00:46:37,610
Jadi sebab bagi yang demikian, kita akan berhenti apabila kita telah tidak bertukar mana-mana elemen.

771
00:46:37,610 --> 00:46:41,980
Jadi pada permulaan gelung kita kita tidak bertukar apa-apa, jadi kita akan mengatakan itu palsu.

772
00:46:41,980 --> 00:46:47,170
Sekarang, kita akan pergi melalui senarai dan bandingkan unsur i elemen i + 1

773
00:46:47,170 --> 00:46:50,310
dan jika ia adalah kes bahawa terdapat beberapa yang lebih besar ke kiri bilangan yang lebih kecil,

774
00:46:50,310 --> 00:46:52,310
maka kita hanya akan menukar mereka.

775
00:46:52,310 --> 00:46:54,490
>> Dan kemudian kita akan ingat bahawa kita bertukar unsur.

776
00:46:54,490 --> 00:46:58,900
Ini bermakna bahawa kita perlu pergi melalui senarai sekurang-kurangnya 1 lagi masa

777
00:46:58,900 --> 00:47:02,160
kerana keadaan di mana kita berhenti apabila senarai keseluruhan sudah disusun,

778
00:47:02,160 --> 00:47:04,890
bermakna kita telah tidak membuat apa-apa pertukaran.

779
00:47:04,890 --> 00:47:09,960
Jadi itulah sebabnya keadaan kita turun di sini adalah 'manakala beberapa elemen telah bertukar.'

780
00:47:09,960 --> 00:47:13,720
Jadi sekarang mari kita hanya melihat ini berjalan pada senarai.

781
00:47:13,720 --> 00:47:16,640
Saya mempunyai senarai 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Isih gelembung akan bermula sepanjang jalan di sebelah kiri, dan ia akan membandingkan

783
00:47:19,850 --> 00:47:24,700
unsur-unsur i, jadi 0 hingga i + 1, yang adalah elemen 1.

784
00:47:24,700 --> 00:47:29,020
Ia akan berkata, baik 5> 0, tetapi sekarang 5 adalah ke kiri,

785
00:47:29,020 --> 00:47:32,500
jadi saya perlu untuk menukar 5 dan 0.

786
00:47:32,500 --> 00:47:35,470
Apabila saya menukar mereka, tiba-tiba saya mendapatkan senarai ini yang berbeza.

787
00:47:35,470 --> 00:47:38,260
Sekarang 5> 1, jadi kita pergi untuk menukar mereka.

788
00:47:38,260 --> 00:47:42,160
5 tidak> 6, jadi kita tidak perlu untuk berbuat apa-apa di sini.

789
00:47:42,160 --> 00:47:46,690
Tetapi 6> 4, jadi kita perlu untuk menukar.

790
00:47:46,690 --> 00:47:49,740
Sekali lagi, kita perlu untuk menjalankan melalui senarai keseluruhan akhirnya menemui

791
00:47:49,740 --> 00:47:52,330
bahawa ini adalah daripada perintah; kita menukar mereka,

792
00:47:52,330 --> 00:47:57,120
dan pada ketika ini kita perlu untuk menjalankan melalui senarai masa 1 more

793
00:47:57,120 --> 00:48:05,390
untuk memastikan bahawa segala-galanya dalam perintahnya, dan pada apapun gelembung titik ini telah selesai.

794
00:48:05,390 --> 00:48:10,720
Sebuah algoritma yang berbeza untuk mengambil beberapa elemen dan menyusun mereka adalah jenis pemilihan.

795
00:48:10,720 --> 00:48:15,740
Idea di sebalik apapun pemilihan adalah bahawa kita akan membina sebahagian disusun senarai

796
00:48:15,740 --> 00:48:18,150
1 elemen pada satu-satu masa.

797
00:48:18,150 --> 00:48:23,170
>> Dan cara kita pergi untuk berbuat demikian adalah dengan membina segmen kiri senarai.

798
00:48:23,170 --> 00:48:27,510
Dan pada dasarnya, setiap pada setiap langkah, kita akan mengambil elemen terkecil kita telah meninggalkan

799
00:48:27,510 --> 00:48:32,310
yang belum diselesaikan lagi, dan kita akan bergerak ke dalam segmen yang disusun.

800
00:48:32,310 --> 00:48:35,850
Ini bermakna kita perlu sentiasa mencari elemen Unsorted minimum

801
00:48:35,850 --> 00:48:40,720
dan kemudian mengambil elemen minimum dan swap dengan apa jua

802
00:48:40,720 --> 00:48:45,090
kiri paling elemen yang tidak disusun.

803
00:48:45,090 --> 00:48:50,890
Masa berjalan ini akan menjadi O (n ²) kerana dalam kes terburuk

804
00:48:50,890 --> 00:48:55,070
kita perlu untuk membandingkan setiap elemen tunggal untuk setiap elemen lain.

805
00:48:55,070 --> 00:48:59,250
Kerana kita mengatakan bahawa jika kita mula di separuh kiri senarai, kita perlu

806
00:48:59,250 --> 00:49:02,970
untuk pergi melalui keseluruhan segmen yang betul untuk mencari elemen terkecil.

807
00:49:02,970 --> 00:49:05,430
Dan kemudian, sekali lagi, kita perlu untuk pergi ke segmen yang betul keseluruhan dan

808
00:49:05,430 --> 00:49:08,210
terus pergi ke bahawa lebih dan lebih dan lebih lagi.

809
00:49:08,210 --> 00:49:11,350
Itu akan menjadi ² n. Kami akan perlu untuk di dalam gelung yang lain untuk gelung

810
00:49:11,350 --> 00:49:13,350
yang mencadangkan ² n.

811
00:49:13,350 --> 00:49:16,530
Dalam pemikiran kes terbaik, mari kita mengatakan bahawa kita memberikan ia satu senarai yang sudah disusun;

812
00:49:16,530 --> 00:49:19,270
kita sebenarnya tidak melakukan apa-apa lebih baik daripada ² n.

813
00:49:19,270 --> 00:49:21,730
Kerana apapun pemilihan tidak mempunyai cara untuk mengetahui bahawa

814
00:49:21,730 --> 00:49:25,540
elemen minimum hanya satu saya berlaku untuk melihat.

815
00:49:25,540 --> 00:49:28,970
Ia masih perlu untuk memastikan bahawa ini sebenarnya adalah minimum.

816
00:49:28,970 --> 00:49:31,670
>> Dan satu-satunya cara untuk memastikan bahawa ia adalah minimum, menggunakan algoritma ini,

817
00:49:31,670 --> 00:49:34,640
adalah untuk melihat pada setiap elemen tunggal lagi.

818
00:49:34,640 --> 00:49:38,420
Jadi benar-benar, jika anda memberikan ia - jika anda memberikan apapun pemilihan senarai sudah disusun,

819
00:49:38,420 --> 00:49:42,720
ia tidak akan melakukan apa-apa yang lebih baik daripada memberikan senarai yang tidak diselesaikan lagi.

820
00:49:42,720 --> 00:49:46,320
By the way, jika ia berlaku untuk kes bahawa sesuatu adalah O (sesuatu)

821
00:49:46,320 --> 00:49:50,640
dan omega sesuatu, kita hanya boleh mengatakan lebih ringkas bahawa ia adalah θ sesuatu.

822
00:49:50,640 --> 00:49:52,760
Jadi, jika anda melihat yang tampil di mana-mana, bahawa apa yang hanya bermakna.

823
00:49:52,760 --> 00:49:57,580
>> Jika sesuatu theta n ², ia adalah kedua-dua O besar (n ²) dan Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Jadi kes terbaik dan kes terburuk, ia tidak membuat perbezaan,

825
00:49:59,790 --> 00:50:04,400
algoritma akan melakukan perkara yang sama setiap kali.

826
00:50:04,400 --> 00:50:06,610
Jadi ini adalah apa pseudokod untuk menyelesaikan pemilihan boleh kelihatan seperti.

827
00:50:06,610 --> 00:50:10,630
Kami pada dasarnya akan mengatakan bahawa saya mahu untuk melelar senarai

828
00:50:10,630 --> 00:50:15,180
dari kiri ke kanan, dan pada setiap lelaran gelung, saya akan bergerak

829
00:50:15,180 --> 00:50:19,780
elemen minimum ke bahagian ini disusun senarai.

830
00:50:19,780 --> 00:50:23,260
Dan apabila saya memindahkan sesuatu di sana, saya tidak perlu untuk melihat bahawa elemen lagi.

831
00:50:23,260 --> 00:50:28,600
Kerana, ia disusun sebaik sahaja saya menukar elemen dalam segmen kiri senarai

832
00:50:28,600 --> 00:50:32,600
kerana kita sedang melakukan segala-galanya dalam tertib menaik dengan menggunakan minimum.

833
00:50:32,600 --> 00:50:38,740
Jadi kita berkata, okay, kita berada pada kedudukan i, dan kita perlu melihat semua elemen

834
00:50:38,740 --> 00:50:42,260
kepada hak i untuk mencari minimum.

835
00:50:42,260 --> 00:50:46,150
Jadi itu bermakna kita mahu melihat dari i + 1 akhir senarai.

836
00:50:46,150 --> 00:50:51,610
Dan kini, jika elemen bahawa kita sedang melihat adalah kurang daripada minimum kami setakat ini,

837
00:50:51,610 --> 00:50:54,190
yang, ingat, kita bermula dari minimum untuk hanya menjadi

838
00:50:54,190 --> 00:50:57,020
apa jua unsur yang kita berada pada masa ini, saya akan menganggap itulah minimum.

839
00:50:57,020 --> 00:51:00,270
Jika saya dapati elemen yang lebih kecil daripada itu, maka saya akan katakan, okay,

840
00:51:00,270 --> 00:51:02,700
baik, saya telah mendapati minimum baru.

841
00:51:02,700 --> 00:51:06,080
Saya akan ingat di mana minimum yang.

842
00:51:06,080 --> 00:51:09,560
>> Jadi sekarang, apabila saya telah pergi melalui segmen yang Unsorted kanan,

843
00:51:09,560 --> 00:51:16,690
Yang boleh saya katakan saya akan menukar elemen minimum dengan unsur yang berada dalam kedudukan i.

844
00:51:16,690 --> 00:51:21,100
Itu akan untuk membina senarai saya, bahagian saya disusun senarai dari kiri ke kanan,

845
00:51:21,100 --> 00:51:25,190
dan kita tidak pernah perlu untuk melihat unsur lagi apabila ia adalah di bahagian itu.

846
00:51:25,190 --> 00:51:27,930
Apabila kita telah bertukar.

847
00:51:27,930 --> 00:51:30,260
Jadi mari kita menjalankan apapun pemilihan dalam senarai ini.

848
00:51:30,260 --> 00:51:38,220
Elemen biru di sini akan menjadi i, dan elemen merah akan menjadi elemen minimum.

849
00:51:38,220 --> 00:51:41,570
Jadi saya bermula sepanjang jalan di sebelah kiri senarai, jadi pada 5.

850
00:51:41,570 --> 00:51:44,610
Sekarang kita perlu mencari elemen Unsorted minimum.

851
00:51:44,610 --> 00:51:49,480
Jadi kita katakan 0 <5, jadi 0 adalah minimum baru saya.

852
00:51:49,480 --> 00:51:53,820
>> Tetapi saya tidak boleh berhenti di situ, kerana walaupun kita boleh mengiktiraf bahawa 0 adalah yang terkecil,

853
00:51:53,820 --> 00:51:59,390
kita perlu untuk menjalankan melalui setiap elemen lain senarai untuk pastikan.

854
00:51:59,390 --> 00:52:01,760
Jadi 1 adalah lebih besar, 6 adalah lebih besar, 4 adalah lebih besar.

855
00:52:01,760 --> 00:52:05,850
Ini bermakna bahawa selepas melihat semua elemen-elemen ini, saya telah berazam 0 adalah yang paling kecil.

856
00:52:05,850 --> 00:52:09,800
Jadi saya akan menukar 5 dan 0.

857
00:52:09,800 --> 00:52:15,480
Apabila saya menukar itu, saya akan mendapatkan senarai baru, dan saya tahu bahawa saya tidak perlu untuk melihat bahawa 0 lagi

858
00:52:15,480 --> 00:52:19,380
kerana sekali saya telah bertukar ia, saya telah disusun dan kami sudah selesai.

859
00:52:19,380 --> 00:52:22,730
Kini ia hanya kebetulan bahawa elemen biru sekali lagi 5,

860
00:52:22,730 --> 00:52:26,030
dan kita perlu melihat pada 1, 6 dan 4 untuk menentukan bahawa 1

861
00:52:26,030 --> 00:52:31,520
adalah elemen minimum terkecil, jadi kami akan menukar 1 dan 5.

862
00:52:31,520 --> 00:52:36,890
Sekali lagi, kita perlu melihat - bandingkan 5 dengan 6 dan 4,

863
00:52:36,890 --> 00:52:39,830
dan kami akan menukar 4 dan 5, dan akhirnya, bandingkan

864
00:52:39,830 --> 00:52:45,740
mereka 2 nombor dan swap mereka sehingga kita mendapat senarai kami disusun.

865
00:52:45,740 --> 00:52:49,730
Sebarang pertanyaan mengenai apapun pemilihan?

866
00:52:49,730 --> 00:52:56,420
Okay. Mari kita beralih ke topik terakhir di sini, dan yang rekursi.

867
00:52:56,420 --> 00:52:59,810
>> Rekursi, ingat, perkara ini benar-benar meta mana fungsi

868
00:52:59,810 --> 00:53:02,740
berkali-kali panggilan itu sendiri.

869
00:53:02,740 --> 00:53:05,620
Jadi, pada satu ketika, manakala fuction kami berkali-kali memanggil sendiri,

870
00:53:05,620 --> 00:53:10,100
perlu ada beberapa titik di mana kita berhenti memanggil diri.

871
00:53:10,100 --> 00:53:13,670
Kerana jika kita tidak berbuat demikian, maka kita hanya akan terus melakukan ini selama-lamanya,

872
00:53:13,670 --> 00:53:16,660
dan program kami hanya tidak akan menamatkan.

873
00:53:16,660 --> 00:53:19,200
Kami menyeru ini keadaan kes asas.

874
00:53:19,200 --> 00:53:22,570
Dan kes asas mengatakan, bukannya memanggil fungsi lagi,

875
00:53:22,570 --> 00:53:25,330
Saya hanya akan kembali beberapa nilai.

876
00:53:25,330 --> 00:53:28,080
Jadi apabila kita telah kembali nilai, kami telah menghentikan memanggil diri,

877
00:53:28,080 --> 00:53:32,550
dan selebihnya panggilan kami telah dibuat setakat ini juga boleh kembali.

878
00:53:32,550 --> 00:53:36,050
Bertentangan dengan kes asas adalah kes rekursi.

879
00:53:36,050 --> 00:53:39,050
Dan ini adalah apabila kita hendak membuat panggilan lain untuk fungsi bahawa kita kini masuk

880
00:53:39,050 --> 00:53:44,690
Dan kita mungkin, walaupun tidak selalu, mahu menggunakan hujah-hujah yang berbeza.

881
00:53:44,690 --> 00:53:48,940
>> Jadi, jika kita mempunyai satu fungsi yang dipanggil f, dan f hanya dipanggil mengambil 1 hujah,

882
00:53:48,940 --> 00:53:52,010
dan kita hanya menyimpan memanggil f (1), f (1), f (1), dan ia hanya kebetulan bahawa

883
00:53:52,010 --> 00:53:56,510
hujah 1 jatuh ke dalam kes rekursi, kita masih tidak akan berhenti.

884
00:53:56,510 --> 00:54:01,620
Malah jika kita mempunyai kes asas, kita perlu memastikan bahawa akhirnya kita akan melanda bahawa kes asas.

885
00:54:01,620 --> 00:54:04,250
Kami tidak hanya menyimpan tinggal dalam kes ini rekursi.

886
00:54:04,250 --> 00:54:09,870
Secara umumnya, apabila kita panggil diri kita, kita mungkin akan mempunyai hujah yang berbeza setiap kali.

887
00:54:09,870 --> 00:54:12,700
Berikut adalah fungsi rekursi yang benar-benar mudah.

888
00:54:12,700 --> 00:54:15,090
Jadi, ini akan mengira faktoran nombor.

889
00:54:15,090 --> 00:54:17,790
Sehingga top sini kita mempunyai kes asas kami.

890
00:54:17,790 --> 00:54:22,330
Dalam kes bahawa n ≤ 1, kita tidak akan memanggil faktorial lagi.

891
00:54:22,330 --> 00:54:26,490
Kita akan berhenti, kita hanya akan kembali beberapa nilai.

892
00:54:26,490 --> 00:54:30,170
Jika ini tidak benar, maka kita pergi untuk memukul kes rekursi kami.

893
00:54:30,170 --> 00:54:33,550
Notis di sini bahawa kita tidak hanya memanggil faktorial (n), kerana itu tidak akan sangat membantu.

894
00:54:33,550 --> 00:54:36,810
Kami akan memanggil faktorial sesuatu yang lain.

895
00:54:36,810 --> 00:54:40,850
>> Dan supaya anda boleh lihat, akhirnya jika kita lulus sesuatu faktorial (5) atau,

896
00:54:40,850 --> 00:54:45,900
kita akan memanggil faktorial (4) dan sebagainya, dan akhirnya kita akan melanda kes ini asas.

897
00:54:45,900 --> 00:54:51,730
Jadi ini kelihatan baik. Mari kita lihat apa yang berlaku apabila kita sebenarnya menjalankan ini.

898
00:54:51,730 --> 00:54:57,840
Ini adalah timbunan, dan mari kita mengatakan bahawa utama akan memanggil fungsi ini dengan hujah (4).

899
00:54:57,840 --> 00:55:02,200
Jadi sekali faktorial melihat dan = 4, faktoran akan memanggil dirinya.

900
00:55:02,200 --> 00:55:05,010
Sekarang, tiba-tiba, kita mempunyai faktorial (3).

901
00:55:05,010 --> 00:55:10,780
Jadi fungsi-fungsi ini akan terus berkembang sehingga akhirnya kita melanda kes asas kami.

902
00:55:10,780 --> 00:55:17,830
Pada ketika ini, nilai pulangan ini adalah pulangan (nx nilai pulangan ini),

903
00:55:17,830 --> 00:55:21,290
nilai pulangan ini adalah nx nilai pulangan ini.

904
00:55:21,290 --> 00:55:23,290
Akhirnya kita perlu untuk memukul beberapa nombor.

905
00:55:23,290 --> 00:55:26,560
Di atas sini, kita katakan pulangan 1.

906
00:55:26,560 --> 00:55:30,650
Ini bermakna bahawa apabila kita kembali nombor yang, kita boleh pop ini off timbunan.

907
00:55:30,650 --> 00:55:36,570
Jadi ini faktorial (1) dilakukan.

908
00:55:36,570 --> 00:55:41,190
Apabila 1 pulangan, ini faktorial (1) pulangan, ini kembali kepada 1.

909
00:55:41,190 --> 00:55:46,910
Nilai pulangan ini, ingat, adalah nx nilai pulangan ini.

910
00:55:46,910 --> 00:55:50,720
Jadi, tiba-tiba, lelaki ini tahu bahawa saya mahu kembali 2.

911
00:55:50,720 --> 00:55:55,910
>> Jadi ingat, memulangkan nilai ini adalah hanya nx nilai kembali di sini.

912
00:55:55,910 --> 00:56:01,160
Jadi sekarang kita boleh mengatakan 3 x 2, dan akhirnya, di sini kita boleh mengatakan

913
00:56:01,160 --> 00:56:04,010
ini hanya akan menjadi 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
Dan sekali ini pulangan, kita akan mendapat ke dalam integer tunggal utama.

915
00:56:09,570 --> 00:56:15,460
Sebarang pertanyaan pada rekursi?

916
00:56:15,460 --> 00:56:17,090
Semua hak. Jadi ada lebih banyak masa untuk soalan di hujung,

917
00:56:17,090 --> 00:56:23,360
tetapi kini Yusuf akan meliputi topik yang selebihnya.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] Baiklah. Jadi sekarang bahawa kita telah bercakap tentang recursions,

919
00:56:25,590 --> 00:56:27,840
mari kita bercakap sedikit tentang apa bergabung apapun adalah.

920
00:56:27,840 --> 00:56:31,740
Gabung apapun pada asasnya cara lain menyusun senarai nombor.

921
00:56:31,740 --> 00:56:36,430
Dan bagaimana ia berfungsi, dengan jenis merge anda mempunyai senarai, dan apa yang kita lakukan adalah

922
00:56:36,430 --> 00:56:39,120
kita katakan, mari kita berpecah ini kepada 2 bahagian.

923
00:56:39,120 --> 00:56:42,750
Kami pertama akan menjalankan bergabung apapun sekali lagi di separuh kiri,

924
00:56:42,750 --> 00:56:45,040
maka kami akan menjalankan menggabungkan jenis di separuh kanan,

925
00:56:45,040 --> 00:56:50,240
dan yang memberikan kami sekarang 2 bahagian yang disusun, dan kini kami akan untuk menggabungkan mereka dua bersama-sama.

926
00:56:50,240 --> 00:56:55,010
Ia agak sukar untuk melihat tanpa contoh, jadi kita akan pergi melalui usul dan lihat apa yang berlaku.

927
00:56:55,010 --> 00:56:59,590
Jadi anda mula dengan senarai ini, kita berpecah kepada 2 bahagian.

928
00:56:59,590 --> 00:57:02,300
Kami menjalankan bergabung jenis di separuh kiri pertama.

929
00:57:02,300 --> 00:57:06,660
Jadi itulah separuh kiri, dan kini kita berjalan mereka melalui senarai ini sekali lagi

930
00:57:06,660 --> 00:57:09,800
yang mendapat berlalu ke dalam apapun merge, dan kemudian kita melihat, sekali lagi,

931
00:57:09,800 --> 00:57:13,270
di sebelah kiri senarai ini dan kami menjalankan menggabungkan jenis di atasnya.

932
00:57:13,270 --> 00:57:15,880
Sekarang, kita akan mendapat ke senarai 2 nombor,

933
00:57:15,880 --> 00:57:19,010
dan kini separuh kiri hanya 1 elemen panjang, dan kita tidak boleh

934
00:57:19,010 --> 00:57:23,380
berpecah senarai itu hanya 1 elemen ke dalam separuh, jadi kita hanya mengatakan, apabila kita mempunyai 50,

935
00:57:23,380 --> 00:57:26,400
yang hanya 1 elemen, ia sudah disusun.

936
00:57:26,400 --> 00:57:29,860
>> Apabila kita sedang dilakukan dengan itu, kita dapat melihat bahawa kita boleh

937
00:57:29,860 --> 00:57:32,230
bergerak ke separuh kanan senarai ini,

938
00:57:32,230 --> 00:57:36,480
dan 3 juga disusun, dan jadi sekarang bahawa kedua-dua bahagian senarai ini disusun

939
00:57:36,480 --> 00:57:39,080
kita boleh menyertai nombor-nombor ini kembali bersama-sama.

940
00:57:39,080 --> 00:57:45,320
Jadi kita melihat pada 50 dan 3; 3 adalah lebih kecil daripada 50, jadi ia pergi pertama dan kemudian 50 datang masuk

941
00:57:45,320 --> 00:57:49,340
Sekarang, yang dilakukan, kita kembali kepada senarai itu dan apapun ia adalah separuh betul.

942
00:57:49,340 --> 00:57:52,440
42 adalah nombor itu sendiri, jadi ia sudah disusun.

943
00:57:52,440 --> 00:57:57,850
Jadi sekarang kita bandingkan ini 2 dan 3 adalah lebih kecil daripada 42, jadi yang mendapat dimasukkan ke dalam mulanya,

944
00:57:57,850 --> 00:58:02,340
kini 42 mendapat dimasukkan ke dalam, dan 50 mendapat meletakkan masuk

945
00:58:02,340 --> 00:58:07,220
Sekarang, itu diselesaikan, kita pergi sepanjang jalan kembali ke atas, 1337 dan 15.

946
00:58:07,220 --> 00:58:14,560
Nah, sekarang kita melihat separuh kiri senarai ini, 1337 adalah dengan sendirinya jadi ia disusun dan sama dengan 15.

947
00:58:14,560 --> 00:58:19,020
Jadi sekarang kita menggabungkan kedua-2 nombor untuk menyelesaikan bahawa senarai asal, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
jadi ia pergi pertama, maka 1337 pergi masuk

949
00:58:23,060 --> 00:58:26,640
Dan sekarang kita disusun kedua-dua bahagian senarai asal top up.

950
00:58:26,640 --> 00:58:30,440
Dan semua yang perlu kita lakukan adalah menggabungkan kedua.

951
00:58:30,440 --> 00:58:36,890
Kami melihat 2 nombor pertama senarai ini, 3 <15, jadi ia pergi ke dalam pelbagai jenis yang pertama.

952
00:58:36,890 --> 00:58:44,460
15 <42, jadi ia pergi masuk Sekarang, 42 <1337, yang pergi masuk

953
00:58:44,460 --> 00:58:51,010
50 <1337, jadi ia pergi masuk Dan melihat bahawa kita hanya mengambil 2 nombor dari senarai ini.

954
00:58:51,010 --> 00:58:53,640
Jadi kita tidak hanya seli antara 2 senarai.

955
00:58:53,640 --> 00:58:56,050
Kami hanya mencari pada mulanya, dan kita sedang mengambil elemen

956
00:58:56,050 --> 00:59:00,270
yang lebih kecil dan kemudian meletakkan ia ke dalam pelbagai kami.

957
00:59:00,270 --> 00:59:04,080
Sekarang kita telah digabungkan semua bahagian dan kami sudah selesai.

958
00:59:04,080 --> 00:59:07,780
>> Sebarang pertanyaan tentang bergabung apapun? Ya?

959
00:59:07,780 --> 00:59:14,190
[Pelajar] Jika ia berpecah kepada kumpulan-kumpulan yang berbeza, mengapa tidak mereka hanya berpecah sekali

960
00:59:14,190 --> 00:59:19,970
dan anda mempunyai 3 dan 2 dalam satu kumpulan? [Rehat yang tidak bijaksana yang soalan]

961
00:59:19,970 --> 00:59:24,940
Sebab - jadi persoalannya ialah, mengapa tidak boleh kita hanya bergabung mereka pada langkah yang pertama selepas kita mempunyai mereka?

962
00:59:24,940 --> 00:59:29,530
Sebab kita boleh lakukan ini, bermula pada elemen-elemen yang paling kiri kedua-dua pihak,

963
00:59:29,530 --> 00:59:33,040
dan kemudian mengambil satu yang lebih kecil dan memasukkannya ke dalam, adalah bahawa kita tahu bahawa ini

964
00:59:33,040 --> 00:59:35,290
senarai individu dalam pesanan disusun.

965
00:59:35,290 --> 00:59:37,290
Jadi jika saya melihat elemen-elemen yang paling kiri kedua-dua bahagian,

966
00:59:37,290 --> 00:59:40,490
Saya tahu mereka akan menjadi elemen terkecil senarai.

967
00:59:40,490 --> 00:59:43,930
Jadi saya boleh meletakkan mereka ke tempat elemen terkecil senarai ini besar.

968
00:59:43,930 --> 00:59:47,810
Sebaliknya, jika saya melihat mereka 2 senarai di peringkat kedua di sana,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 dan 15, mereka tidak diselesaikan.

970
00:59:51,640 --> 00:59:55,770
Jadi jika saya melihat 50 dan 1337, saya akan meletakkan 50 ke dalam senarai saya pertama.

971
00:59:55,770 --> 01:00:00,130
Tetapi itu tidak benar-benar masuk akal, kerana 3 adalah elemen terkecil daripada semua orang.

972
01:00:00,130 --> 01:00:04,390
Jadi sebab sahaja yang boleh kita lakukan langkah ini menggabungkan adalah kerana senarai kami sudah disusun.

973
01:00:04,390 --> 01:00:07,010
Itulah sebabnya kita perlu untuk mendapatkan sepanjang jalan ke bawah

974
01:00:07,010 --> 01:00:09,800
kerana apabila kita mempunyai hanya satu nombor, anda tahu bahawa nombor tunggal

975
01:00:09,800 --> 01:00:14,120
dalam dan dengan sendirinya sudah senarai yang disusun.

976
01:00:14,120 --> 01:00:19,360
>> Apa-apa soalan? Tidak?

977
01:00:19,360 --> 01:00:24,260
Kerumitan? Nah, anda boleh melihat bahawa pada setiap langkah ada nombor akhir,

978
01:00:24,260 --> 01:00:27,590
dan kita boleh membahagikan senarai dalam log separuh n kali,

979
01:00:27,590 --> 01:00:31,700
yang mana kita akan mendapat ini log n x n kerumitan.

980
01:00:31,700 --> 01:00:34,940
Dan anda akan melihat kes yang terbaik untuk menyelesaikan merge n log n, dan ia hanya kebetulan

981
01:00:34,940 --> 01:00:39,340
bahawa kes terburuk, atau Ω di sana, juga n log n.

982
01:00:39,340 --> 01:00:42,480
Sesuatu yang perlu diingat.

983
01:00:42,480 --> 01:00:45,750
Bergerak ke atas, mari kita pergi ke beberapa fail super asas I / O.

984
01:00:45,750 --> 01:00:48,830
Jika anda melihat Kacau, anda akan melihat kita mempunyai beberapa jenis sistem

985
01:00:48,830 --> 01:00:51,270
di mana anda boleh menulis ke fail log jika anda membaca melalui kod.

986
01:00:51,270 --> 01:00:53,730
Mari kita lihat bagaimana anda boleh berbuat demikian.

987
01:00:53,730 --> 01:00:57,450
Nah, kita mempunyai fprintf, yang anda boleh berfikir sebagai hanya printf,

988
01:00:57,450 --> 01:01:01,720
tetapi hanya mencetak ke fail sebaliknya, dan seterusnya f pada permulaan.

989
01:01:01,720 --> 01:01:07,570
Ini jenis kod di sini, apa yang ia adalah, seperti yang anda mungkin telah dilihat dalam Kacau,

990
01:01:07,570 --> 01:01:12,310
ia pergi melalui percetakan 2-dimensi pelbagai anda keluar baris demi baris apa nombor.

991
01:01:12,310 --> 01:01:17,850
Dalam kes ini, printf mencetak keluar ke terminal anda atau apa yang kita panggil output standard seksyen.

992
01:01:17,850 --> 01:01:22,170
>> Dan kini, dalam kes ini, semua yang perlu kita lakukan adalah menggantikan printf dengan fprintf,

993
01:01:22,170 --> 01:01:26,770
beritahu apa fail yang anda mahu untuk mencetak, dan dalam kes ini ia hanya mencetak ia keluar untuk fail yang

994
01:01:26,770 --> 01:01:32,230
bukannya mencetak ia keluar ke terminal anda.

995
01:01:32,230 --> 01:01:36,500
Nah, maka menimbulkan persoalan: Di manakah kita mendapatkan fail jenis ini dari, betul-betul?

996
01:01:36,500 --> 01:01:39,840
Kami diluluskan log masuk untuk fuction ini fprintf tetapi kita tidak tahu dari mana ia datang.

997
01:01:39,840 --> 01:01:43,980
Nah, awal dalam kod, apa yang kita terpaksa ini sebahagian kod di sini,

998
01:01:43,980 --> 01:01:48,340
yang pada dasarnya mengatakan bahawa fail terbuka panggilan log.txt.

999
01:01:48,340 --> 01:01:53,220
Apa yang kita lakukan selepas itu adalah kita perlu memastikan bahawa fail sebenarnya membuka berjaya.

1000
01:01:53,220 --> 01:01:57,070
Jadi, ia mungkin gagal atas sebab-sebab yang pelbagai, anda tidak mempunyai ruang yang cukup di dalam komputer anda, sebagai contoh.

1001
01:01:57,070 --> 01:01:59,790
Jadi ia sentiasa penting sebelum anda melakukan apa-apa operasi dengan fail

1002
01:01:59,790 --> 01:02:03,300
bahawa kita memeriksa sama ada fail tersebut telah dibuka dengan jayanya.

1003
01:02:03,300 --> 01:02:09,330
Jadi apa yang, itulah hujah untuk fopen, baik, kita boleh membuka fail dalam banyak cara.

1004
01:02:09,330 --> 01:02:13,510
Apa yang kita boleh lakukan ialah, kita boleh lulus ia w, yang bermaksud mengatasi fail jika ia keluar sudah,

1005
01:02:13,510 --> 01:02:18,070
Kita boleh lulus, yang mereka melampirkan pada akhir fail dan bukannya mengatasi ia,

1006
01:02:18,070 --> 01:02:22,730
atau kita boleh menentukan r, yang bermaksud, mari kita membuka fail sebagai baca sahaja.

1007
01:02:22,730 --> 01:02:24,890
Jadi, jika program ini cuba untuk membuat apa-apa perubahan kepada fail,

1008
01:02:24,890 --> 01:02:30,140
menjerit pada mereka dan jangan biarkan mereka melakukannya.

1009
01:02:30,140 --> 01:02:33,320
Akhirnya, apabila kita sedang dilakukan dengan fail, selesai melakukan operasi di atasnya,

1010
01:02:33,320 --> 01:02:35,860
kita perlu pastikan kita menutup fail.

1011
01:02:35,860 --> 01:02:38,830
Dan demikian pada akhir program anda, anda akan lulus mereka lagi

1012
01:02:38,830 --> 01:02:42,120
fail ini bahawa anda dibuka, dan hanya menutup.

1013
01:02:42,120 --> 01:02:44,650
Jadi ini adalah sesuatu yang penting yang anda perlu pastikan anda melakukan.

1014
01:02:44,650 --> 01:02:47,180
Jadi ingat anda boleh membuka fail, maka anda boleh menulis ke fail,

1015
01:02:47,180 --> 01:02:51,270
melakukan operasi dalam fail, tetapi kemudian anda perlu untuk menutup fail di akhir.

1016
01:02:51,270 --> 01:02:53,270
>> Sebarang soalan pada fail asas I / O? Ya?

1017
01:02:53,270 --> 01:02:58,050
[Pelajar soalan, difahami]

1018
01:02:58,050 --> 01:03:02,480
Hak di sini. Persoalannya, di manakah fail ini log.txt muncul?

1019
01:03:02,480 --> 01:03:07,890
Nah, jika anda hanya memberi log.txt, ia mewujudkan dalam direktori yang sama sebagai executable.

1020
01:03:07,890 --> 01:03:10,500
Jadi jika you're - >> [Pelajar soalan, difahami]

1021
01:03:10,500 --> 01:03:18,830
Ya. Dalam folder yang sama, atau dalam direktori yang sama, seperti yang anda memanggilnya.

1022
01:03:18,830 --> 01:03:21,400
Sekarang ingatan, timbunan, dan timbunan.

1023
01:03:21,400 --> 01:03:23,400
Jadi bagaimana memori dibentangkan dalam komputer?

1024
01:03:23,400 --> 01:03:26,270
Nah, anda boleh bayangkan memori sebagai jenis blok ini di sini.

1025
01:03:26,270 --> 01:03:30,260
Dan dalam ingatan kita mempunyai apa yang dipanggil timbunan yang terperangkap di sana, dan timbunan yang di bawah sana.

1026
01:03:30,260 --> 01:03:34,480
Dan timbunan tumbuh ke bawah dan timbunan tumbuh ke atas.

1027
01:03:34,480 --> 01:03:38,620
Jadi sebagai Tommy menyebut - oh, baik, dan kita mempunyai ini 4 segmen lain yang saya akan sampai ke dalam kedua -

1028
01:03:38,620 --> 01:03:42,890
Sebagai Tommy berkata sebelum ini, anda tahu bagaimana fungsi beliau memanggil diri mereka dan memanggil antara satu sama lain?

1029
01:03:42,890 --> 01:03:44,930
Mereka membina ini jenis bingkai tindanan.

1030
01:03:44,930 --> 01:03:47,360
Nah, jika panggilan utama foo, foo mendapat diletakkan pada timbunan.

1031
01:03:47,360 --> 01:03:52,430
Foo panggilan bar, bar mendapatkan kita meletakkan pada timbunan, dan yang mendapat dimasukkan pada timbunan selepas.

1032
01:03:52,430 --> 01:03:57,040
Dan kerana mereka kembali, mereka masing-masing mendapat diambil kira timbunan.

1033
01:03:57,040 --> 01:04:00,140
Apa yang setiap lokasi ini dan ingatan memegang?

1034
01:04:00,140 --> 01:04:03,110
Nah, atas, yang merupakan segmen teks, mengandungi program itu sendiri.

1035
01:04:03,110 --> 01:04:06,390
Jadi kod mesin, yang ada, sebaik sahaja anda menyusun program anda.

1036
01:04:06,390 --> 01:04:08,520
Seterusnya, apa-apa dimulakan pembolehubah global.

1037
01:04:08,520 --> 01:04:12,660
>> Jadi anda mempunyai pembolehubah global dalam program anda, dan anda mengatakan seperti, a 5 =,

1038
01:04:12,660 --> 01:04:15,260
yang mendapat dimasukkan ke dalam segmen itu, dan betul-betul di bawah itu,

1039
01:04:15,260 --> 01:04:18,990
anda mempunyai apa-apa data yang tidak diisytiharkan global, yang hanya int,

1040
01:04:18,990 --> 01:04:20,990
tetapi anda tidak mengatakan ia adalah sama dengan apa-apa.

1041
01:04:20,990 --> 01:04:23,870
Sedarlah ini adalah pembolehubah global, jadi mereka berada di luar utama.

1042
01:04:23,870 --> 01:04:28,560
Jadi ini bermakna sebarang pembolehubah global yang diisytiharkan tetapi tidak dimulakan.

1043
01:04:28,560 --> 01:04:32,310
Jadi apa dalam timbunan? Memori diperuntukkan menggunakan malloc, yang kita akan sampai ke dalam sedikit.

1044
01:04:32,310 --> 01:04:35,990
Dan akhirnya, dengan timbunan anda mempunyai sebarang pembolehubah tempatan

1045
01:04:35,990 --> 01:04:39,950
dan apa-apa fungsi yang anda mungkin memanggil mana-mana parameter mereka.

1046
01:04:39,950 --> 01:04:43,720
Perkara yang lepas, anda tidak benar-benar perlu tahu apa pembolehubah persekitaran lakukan,

1047
01:04:43,720 --> 01:04:46,700
tetapi apabila anda menjalankan program, adalah sesuatu yang berkaitan, seperti

1048
01:04:46,700 --> 01:04:49,550
ini adalah username orang yang berlari program.

1049
01:04:49,550 --> 01:04:51,550
Dan yang akan menjadi jenis di bawah.

1050
01:04:51,550 --> 01:04:54,540
Dari segi alamat ingatan, yang adalah nilai perenambelasan,

1051
01:04:54,540 --> 01:04:58,170
nilai pada permulaan atas pada 0, dan mereka pergi sepanjang jalan ke bawah.

1052
01:04:58,170 --> 01:05:00,440
Dalam kes ini, jika anda pada sistem 32-bit,

1053
01:05:00,440 --> 01:05:05,390
alamat di bawah akan menjadi 0x, diikuti oleh af, kerana itulah 32 bit,

1054
01:05:05,390 --> 01:05:10,890
yang merupakan 8 bait, dan dalam kes ini 8 bytes sepadan dengan 8 digit perenambelasan.

1055
01:05:10,890 --> 01:05:20,110
Jadi turun di sini anda akan mempunyai, seperti, 0xffffff, dan di sana anda akan mempunyai 0.

1056
01:05:20,110 --> 01:05:23,660
Jadi apa yang adalah petunjuk? Sebahagian daripada anda mungkin tidak telah dilindungi ini dalam seksyen sebelum ini.

1057
01:05:23,660 --> 01:05:26,660
tetapi kita tidak pergi ke kuliah, jadi penunjuk adalah hanya jenis data

1058
01:05:26,660 --> 01:05:34,030
mana kedai, bukannya sejenis nilai seperti 50, ia menyimpan alamat beberapa lokasi dalam ingatan.

1059
01:05:34,030 --> 01:05:36,020
Seperti memori yang [tidak bijaksana yang].

1060
01:05:36,020 --> 01:05:41,120
Jadi dalam kes ini, apa yang telah kita adalah, kita mempunyai satu penuding kepada integer atau * int,

1061
01:05:41,120 --> 01:05:46,210
dan ia mengandungi alamat perenambelasan 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Jadi apa yang kita ada sekarang, ini mata penunjuk di beberapa lokasi dalam ingatan,

1063
01:05:50,880 --> 01:05:56,020
dan itulah hanya, nilai 50 adalah di lokasi memori ini.

1064
01:05:56,020 --> 01:06:01,810
Pada sesetengah sistem 32-bit, ke atas semua sistem 32-bit, petunjuk mengambil bit 32 atau 4 bait.

1065
01:06:01,810 --> 01:06:06,020
Tetapi, sebagai contoh, pada sistem 64-bit, petunjuk adalah 64-bit.

1066
01:06:06,020 --> 01:06:08,040
Jadi itulah sesuatu yang anda akan mahu ingat.

1067
01:06:08,040 --> 01:06:12,310
Jadi pada sistem akhir-bit, penunjuk adalah bit akhir panjang.

1068
01:06:12,310 --> 01:06:17,320
Penunjuk adalah jenis sukar untuk dihadam tanpa perkara-perkara tambahan,

1069
01:06:17,320 --> 01:06:20,300
jadi mari kita pergi melalui contoh peruntukan memori dinamik.

1070
01:06:20,300 --> 01:06:25,130
Apa memori peruntukan dinamik tidak untuk anda, atau apa yang kita panggil malloc

1071
01:06:25,130 --> 01:06:29,280
ia membolehkan anda memperuntukkan beberapa jenis data di luar set.

1072
01:06:29,280 --> 01:06:31,830
Jadi data ini adalah jenis lebih kekal bagi tempoh program.

1073
01:06:31,830 --> 01:06:36,430
Kerana seperti yang anda tahu, jika anda mengisytiharkan x di dalam fungsi, dan bahawa pulangan fungsi,

1074
01:06:36,430 --> 01:06:40,910
anda tidak lagi mempunyai akses kepada data yang telah disimpan dalam x.

1075
01:06:40,910 --> 01:06:44,420
Apa petunjuk marilah kita lakukan adalah mereka marilah kita menyimpan ingatan atau nilai-nilai kedai

1076
01:06:44,420 --> 01:06:46,840
dalam segmen yang berbeza ingatan, iaitu timbunan itu.

1077
01:06:46,840 --> 01:06:49,340
Sekarang apabila kita kembali fungsi, selagi kita mempunyai penunjuk

1078
01:06:49,340 --> 01:06:54,960
ke lokasi tersebut dalam ingatan, maka apa yang boleh kita lakukan ialah kita hanya boleh melihat nilai di sana.

1079
01:06:54,960 --> 01:06:58,020
Mari kita melihat contoh: Ini adalah susun atur ingatan kita lagi.

1080
01:06:58,020 --> 01:07:00,050
Dan kita mempunyai fungsi ini, utama.

1081
01:07:00,050 --> 01:07:06,870
Apa yang ia adalah - okay, begitu mudah, betul - int x = 5, itu hanya pembolehubah pada timbunan utama.

1082
01:07:06,870 --> 01:07:12,450
>> Sebaliknya, sekarang kita mengisytiharkan satu penunjuk yang memanggil giveMeThreeInts fungsi.

1083
01:07:12,450 --> 01:07:16,800
Dan jadi sekarang kita pergi ke fungsi ini dan kita mewujudkan bingkai tindanan baru untuk itu.

1084
01:07:16,800 --> 01:07:20,440
Walau bagaimanapun, dalam bingkai tindanan ini, kita mengisytiharkan int * menggoda,

1085
01:07:20,440 --> 01:07:23,210
yang dalam mallocs 3 integer untuk kita.

1086
01:07:23,210 --> 01:07:25,880
Jadi saiz int akan memberi kita berapa banyak bait int ini adalah,

1087
01:07:25,880 --> 01:07:29,620
dan malloc memberikan kita bahawa bait banyak ruang pada timbunan itu.

1088
01:07:29,620 --> 01:07:32,890
Jadi dalam kes ini, kita telah mencipta ruang yang cukup untuk 3 integer,

1089
01:07:32,890 --> 01:07:36,830
dan timbunan itu adalah cara di sana, itulah sebabnya saya telah ditarik ia lebih tinggi.

1090
01:07:36,830 --> 01:07:42,900
Apabila kita sedang dilakukan, kita kembali di sini, anda hanya perlu 3 ints dikembalikan,

1091
01:07:42,900 --> 01:07:47,000
dan ia kembali alamat, dalam kes ini lebih di mana memori yang.

1092
01:07:47,000 --> 01:07:51,250
Dan kita menetapkan pointer = suis, dan di sana kita mempunyai hanya satu lagi penunjuk.

1093
01:07:51,250 --> 01:07:54,550
Tetapi apa yang bahawa pulangan fungsi disusun di sini dan hilang.

1094
01:07:54,550 --> 01:07:59,250
Jadi sementara hilang, tetapi kita masih mengekalkan alamat di mana

1095
01:07:59,250 --> 01:08:01,850
mereka 3 integer dalam sesalur.

1096
01:08:01,850 --> 01:08:06,180
Jadi dalam set ini, petunjuk scoped tempatan untuk bingkai disusun,

1097
01:08:06,180 --> 01:08:09,860
tetapi memori yang mereka rujuk adalah dalam timbunan.

1098
01:08:09,860 --> 01:08:12,190
>> Adakah yang masuk akal?

1099
01:08:12,190 --> 01:08:14,960
[Pelajar] Bolehkah anda mengulangi bahawa? >> [Yusuf] Ya.

1100
01:08:14,960 --> 01:08:20,270
Jadi jika saya kembali hanya sedikit, anda lihat bahawa menggoda diperuntukkan

1101
01:08:20,270 --> 01:08:23,500
beberapa memori pada timbunan sehingga sana.

1102
01:08:23,500 --> 01:08:28,680
Jadi, apabila fungsi ini, giveMeThreeInts pulangan, ini timbunan sini akan hilang.

1103
01:08:28,680 --> 01:08:35,819
Dan dengan mana-mana pembolehubah, dalam kes ini, ini penunjuk yang telah diperuntukkan dalam bingkai disusun.

1104
01:08:35,819 --> 01:08:39,649
Yang akan hilang, tetapi sejak kami kembali menggoda

1105
01:08:39,649 --> 01:08:46,330
dan kita menetapkan penunjuk = menggoda, penunjuk yang kini akan menunjukkan memori yang sama lokasi sebagai menggoda adalah.

1106
01:08:46,330 --> 01:08:50,370
Jadi sekarang, walaupun kita kehilangan sementara, bahawa penunjuk tempatan,

1107
01:08:50,370 --> 01:08:59,109
kita masih mengekalkan alamat ingatan apa yang ia menunjuk ke dalam penunjuk yang berubah-ubah.

1108
01:08:59,109 --> 01:09:03,740
Soalan? Yang boleh jenis topik mengelirukan jika anda tidak pergi ke atasnya dalam seksyen.

1109
01:09:03,740 --> 01:09:09,240
Kita boleh, TF anda pasti akan pergi lebih dan sudah tentu kita boleh menjawab soalan-soalan

1110
01:09:09,240 --> 01:09:11,500
pada akhir sesi kajian ini.

1111
01:09:11,500 --> 01:09:14,220
Tetapi ini adalah jenis topik yang kompleks, dan saya mempunyai lebih banyak contoh yang akan muncul

1112
01:09:14,220 --> 01:09:18,790
yang akan membantu menjelaskan apa petunjuk sebenarnya.

1113
01:09:18,790 --> 01:09:22,500
>> Dalam kes ini, petunjuk adalah bersamaan dengan array,

1114
01:09:22,500 --> 01:09:25,229
jadi saya hanya boleh menggunakan penunjuk ini sebagai perkara yang sama seperti pelbagai int.

1115
01:09:25,229 --> 01:09:29,840
Jadi saya mengindeks ke 0, dan menukar integer yang pertama untuk 1,

1116
01:09:29,840 --> 01:09:39,689
menukar integer kedua kepada 2, dan integer 3 hingga 3.

1117
01:09:39,689 --> 01:09:44,210
Jadi lanjut mengenai petunjuk. Nah, ingat Binky.

1118
01:09:44,210 --> 01:09:48,319
Dalam kes ini kita telah diperuntukkan penunjuk, atau kita mengisytiharkan penunjuk,

1119
01:09:48,319 --> 01:09:52,760
tetapi pada mulanya, apabila saya hanya mengisytiharkan penunjuk, ia bukan menunjuk ke mana-mana sahaja dalam ingatan.

1120
01:09:52,760 --> 01:09:54,930
Ia hanya nilai sampah di dalamnya.

1121
01:09:54,930 --> 01:09:56,470
Jadi saya tidak tahu di mana penunjuk ini menunjuk ke.

1122
01:09:56,470 --> 01:10:01,630
Ia mempunyai alamat yang hanya dipenuhi dengan 0 dan 1 di mana ia pada mulanya diisytiharkan.

1123
01:10:01,630 --> 01:10:04,810
Saya tidak boleh berbuat apa-apa dengan ini sehingga saya memanggil malloc di atasnya

1124
01:10:04,810 --> 01:10:08,390
dan kemudian ia memberikan saya sedikit ruang pada timbunan di mana saya boleh meletakkan nilai-nilai di dalam.

1125
01:10:08,390 --> 01:10:11,980
Kemudian lagi, saya tidak tahu apa yang di dalam memori ini.

1126
01:10:11,980 --> 01:10:16,780
Jadi perkara pertama yang saya perlu lakukan adalah memeriksa sama ada sistem mempunyai memori yang cukup

1127
01:10:16,780 --> 01:10:20,850
untuk memberikan saya kembali 1 integer di tempat pertama, itulah sebabnya saya lakukan ini memeriksa.

1128
01:10:20,850 --> 01:10:25,020
Jika penunjuk adalah batal, yang bermakna bahawa ia tidak mempunyai ruang yang cukup atau beberapa kesilapan lain berlaku,

1129
01:10:25,020 --> 01:10:26,320
jadi saya harus keluar daripada program saya.

1130
01:10:26,320 --> 01:10:29,400
 Tetapi jika ia tidak berjaya, kini saya boleh menggunakan penunjuk bahawa

1131
01:10:29,400 --> 01:10:35,020
dan apa penunjuk * tidak adalah ia mengikuti mana alamat

1132
01:10:35,020 --> 01:10:38,480
di mana nilai itu, dan ia menyatakan ia sama dengan 1.

1133
01:10:38,480 --> 01:10:41,850
Jadi di sini, kita sedang memeriksa jika memori yang wujud.

1134
01:10:41,850 --> 01:10:45,380
>> Sebaik sahaja anda tahu ia wujud, anda boleh meletakkan ke dalamnya

1135
01:10:45,380 --> 01:10:50,460
apakah nilai yang anda mahu dimasukkan ke dalam ia, dalam kes ini 1.

1136
01:10:50,460 --> 01:10:53,060
Apabila kita sedang dilakukan dengan itu, anda perlu untuk membebaskan bahawa penunjuk

1137
01:10:53,060 --> 01:10:57,160
kerana kita perlu kembali kepada sistem bahawa memori yang anda meminta di tempat pertama.

1138
01:10:57,160 --> 01:10:59,690
Kerana komputer tidak tahu apabila kita hendak dilakukan dengan ia.

1139
01:10:59,690 --> 01:11:02,510
Dalam kes ini kita jelas memberitahu ia, okay, kita dilakukan dengan memori itu.

1140
01:11:02,510 --> 01:11:10,780
Jika beberapa proses lain perlu, beberapa program lain yang memerlukannya, berasa bebas untuk pergi ke hadapan dan mengambil ia.

1141
01:11:10,780 --> 01:11:15,110
Apa yang kita juga boleh lakukan ialah kita hanya boleh mendapatkan alamat pembolehubah tempatan di set.

1142
01:11:15,110 --> 01:11:19,080
X Begitu int dalam bingkai disusun daripada utama.

1143
01:11:19,080 --> 01:11:23,060
Dan apabila kita menggunakan #: glib ini, ini dan pengendali, apa yang ia adalah

1144
01:11:23,060 --> 01:11:27,310
ia mengambil masa x, dan x ialah hanya beberapa data dalam memori, tetapi ia mempunyai alamat.

1145
01:11:27,310 --> 01:11:33,790
Ia terletak di suatu tempat. Jadi dengan memanggil & x, apakah ini tidak adalah ia memberikan kita alamat x.

1146
01:11:33,790 --> 01:11:38,430
Dengan cara ini, kita sedang membuat titik penunjuk di mana x adalah dalam ingatan.

1147
01:11:38,430 --> 01:11:41,710
Sekarang kita hanya melakukan sesuatu seperti * x, kita akan mendapat 5 kembali.

1148
01:11:41,710 --> 01:11:43,820
Bintang itu dipanggil dereferencing ia.

1149
01:11:43,820 --> 01:11:46,640
Anda mengikuti alamat dan anda mendapat nilai yang disimpan di sana.

1150
01:11:51,000 --> 01:11:53,310
>> Apa-apa soalan? Ya?

1151
01:11:53,310 --> 01:11:56,500
[Pelajar] Jika anda tidak melakukan perkara yang bermata 3-, adakah ia masih menyusun?

1152
01:11:56,500 --> 01:11:59,490
Ya. Jika anda tidak melakukan perkara 3-penunjuk, ia masih akan menyusun,

1153
01:11:59,490 --> 01:12:02,720
tetapi saya akan menunjukkan kepada anda apa yang berlaku dalam kedua, dan tanpa berbuat demikian,

1154
01:12:02,720 --> 01:12:04,860
itulah apa yang kita panggil kebocoran memori. Anda tidak memberikan sistem

1155
01:12:04,860 --> 01:12:07,850
menyokong memori, jadi selepas manakala program akan berkumpul

1156
01:12:07,850 --> 01:12:10,940
memori yang ia tidak menggunakan, dan apa-apa lagi boleh menggunakannya.

1157
01:12:10,940 --> 01:12:15,750
Jika anda pernah melihat Firefox 1.5 juta kilobytes pada komputer anda,

1158
01:12:15,750 --> 01:12:17,840
dalam pengurus tugas, itulah apa yang berlaku.

1159
01:12:17,840 --> 01:12:20,760
Anda mempunyai kebocoran memori dalam program ini bahawa mereka tidak mengendalikan.

1160
01:12:23,080 --> 01:12:26,240
Jadi bagaimana penunjuk aritmetik kerja?

1161
01:12:26,240 --> 01:12:29,480
Nah, aritmetik penunjuk adalah jenis pengindeksan seperti ke dalam array.

1162
01:12:29,480 --> 01:12:36,370
Dalam kes ini, saya mempunyai penunjuk, dan apa yang saya lakukan ialah saya membuat titik penunjuk kepada elemen pertama

1163
01:12:36,370 --> 01:12:42,100
array ini 3 integer bahawa saya telah diperuntukkan.

1164
01:12:42,100 --> 01:12:46,670
Jadi sekarang apa yang saya lakukan, penunjuk bintang hanya menukar elemen pertama dalam senarai.

1165
01:12:46,670 --> 01:12:49,140
Bintang pointer +1 mata di sini.

1166
01:12:49,140 --> 01:12:53,140
Jadi penunjuk adalah di sini, penunjuk +1 adalah di sini, penunjuk 2 adalah di sini.

1167
01:12:53,140 --> 01:12:56,610
>> Jadi hanya menambah 1 adalah perkara yang sama seperti bergerak di sepanjang array ini.

1168
01:12:56,610 --> 01:12:59,880
Apa yang kita lakukan ialah, apabila kita melakukan penunjuk 1 anda mendapat alamat di sini,

1169
01:12:59,880 --> 01:13:04,180
dan dalam usaha untuk mendapatkan nilai di sini, anda meletakkan bintang dari seluruh ungkapan

1170
01:13:04,180 --> 01:13:05,990
untuk dereference.

1171
01:13:05,990 --> 01:13:09,940
Jadi, dalam kes ini, saya menetapkan lokasi pertama dalam pelbagai ini kepada 1,

1172
01:13:09,940 --> 01:13:13,970
lokasi kedua kepada 2, dan lokasi ketiga hingga 3.

1173
01:13:13,970 --> 01:13:18,180
Kemudian apa yang saya lakukan di sini adalah saya mencetak penunjuk kami 1,

1174
01:13:18,180 --> 01:13:19,970
yang hanya memberikan saya 2.

1175
01:13:19,970 --> 01:13:23,650
Sekarang saya incrementing penunjuk, jadi penunjuk sama pointer 1,

1176
01:13:23,650 --> 01:13:26,780
yang bergerak ke hadapan.

1177
01:13:26,780 --> 01:13:30,810
Dan jadi sekarang jika saya hendak mencetak keluar 1 penunjuk, penunjuk +1 adalah kini 3,

1178
01:13:30,810 --> 01:13:33,990
yang dalam kes ini mencetak keluar 3.

1179
01:13:33,990 --> 01:13:36,560
Dan untuk sesuatu yang percuma, penunjuk bahawa saya memberikan

1180
01:13:36,560 --> 01:13:40,540
mesti menunjuk pada permulaan array yang saya pulang dari malloc.

1181
01:13:40,540 --> 01:13:43,430
Jadi, dalam kes ini, jika saya adalah untuk memanggil 3 di sini, ini tidak akan menjadi betul,

1182
01:13:43,430 --> 01:13:45,070
kerana ia adalah di tengah-tengah array.

1183
01:13:45,070 --> 01:13:48,820
Saya perlu tolak untuk sampai ke lokasi asal

1184
01:13:48,820 --> 01:13:50,420
tempat pertama awal sebelum saya boleh membebaskan.

1185
01:13:56,300 --> 01:13:58,450
Jadi, di sini adalah satu contoh yang lebih terlibat.

1186
01:13:58,450 --> 01:14:03,360
Dalam kes ini, kita memperuntukkan 7 watak-watak dalam pelbagai watak.

1187
01:14:03,360 --> 01:14:06,480
>> Dan dalam kes ini apa yang kita lakukan ialah kita menggelung lebih 6 pertama mereka,

1188
01:14:06,480 --> 01:14:09,900
dan kita menetapkan mereka ke Z.

1189
01:14:09,900 --> 01:14:13,350
Jadi, bagi int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Jadi, penunjuk + i hanya akan memberikan kita, dalam hal ini,

1191
01:14:16,220 --> 01:14:20,860
penunjuk, penunjuk +1, penunjuk 2, penunjuk +3, dan sebagainya dan sebagainya di dalam gelung.

1192
01:14:20,860 --> 01:14:24,040
Apa yang ia akan lakukan ialah ia mendapat alamat itu, dereferences untuk mendapatkan nilai,

1193
01:14:24,040 --> 01:14:27,440
dan perubahan yang nilai kepada seorang Z.

1194
01:14:27,440 --> 01:14:30,350
Kemudian pada akhir ingat ini adalah rentetan, kan?

1195
01:14:30,350 --> 01:14:33,560
Semua rentetan mempunyai berakhir dengan watak nol menamatkan.

1196
01:14:33,560 --> 01:14:38,620
Jadi, apa yang saya lakukan adalah dalam pointer 6 saya meletakkan watak null masuk

1197
01:14:38,620 --> 01:14:43,980
Dan kini apa yang saya pada dasarnya lakukan di sini sedang melaksanakan printf untuk rentetan, kan?

1198
01:14:43,980 --> 01:14:46,190
>> Jadi, bilakah printf sekarang apabila ia sampai ke penghujung rentetan?

1199
01:14:46,190 --> 01:14:48,230
Apabila ia mencecah watak nol menamatkan.

1200
01:14:48,230 --> 01:14:52,030
Jadi, dalam kes ini, asal mata penunjuk saya ke permulaan array ini.

1201
01:14:52,030 --> 01:14:56,410
Saya hendak mencetak aksara pertama keluar. Saya bergerak lebih daripada satu.

1202
01:14:56,410 --> 01:14:58,420
Saya mencetak watak yang keluar. Saya memindahkan ia lebih.

1203
01:14:58,420 --> 01:15:02,180
Dan saya terus melakukan ini sehingga saya mencapai akhir.

1204
01:15:02,180 --> 01:15:07,750
Dan kini penunjuk akhir * akan dereference ini dan mendapatkan watak nol menamatkan kembali.

1205
01:15:07,750 --> 01:15:11,780
Dan begitu gelung sementara saya berjalan hanya apabila nilai yang tidak adalah watak nol menamatkan.

1206
01:15:11,780 --> 01:15:13,770
Jadi, sekarang saya keluar daripada gelung ini.

1207
01:15:18,780 --> 01:15:21,180
Dan jadi jika saya tolakkan 6 daripada penunjuk ini,

1208
01:15:21,180 --> 01:15:22,860
Saya kembali semua cara untuk permulaan.

1209
01:15:22,860 --> 01:15:27,880
Ingat, saya lakukan ini kerana saya perlu pergi ke permulaan dalam usaha untuk membebaskan.

1210
01:15:27,880 --> 01:15:30,270
>> Jadi, saya tahu yang banyak. Adakah terdapat apa-apa soalan?

1211
01:15:30,270 --> 01:15:31,870
Tolong, ya?

1212
01:15:31,870 --> 01:15:36,610
[Pelajar tidak bijaksana yang soalan]

1213
01:15:36,610 --> 01:15:38,190
Anda boleh mengatakan bahawa lebih kuat? Maaf.

1214
01:15:38,190 --> 01:15:44,140
[Pelajar] Pada slaid terakhir sejurus sebelum anda membebaskan penunjuk,

1215
01:15:44,140 --> 01:15:47,300
di mana anda sebenarnya mengubah nilai penunjuk?

1216
01:15:47,300 --> 01:15:50,370
[Yusuf] Jadi, di sini. >> [Pelajar] Oh, okay.

1217
01:15:50,370 --> 01:15:51,890
[Yusuf] Jadi, saya mempunyai penunjuk tolak tolak, hak,

1218
01:15:51,890 --> 01:15:54,140
yang bergerak perkara siapa yang menyangka, dan kemudian saya membebaskannya,

1219
01:15:54,140 --> 01:15:57,000
kerana penunjuk ini mempunyai untuk menunjukkan permulaan array.

1220
01:15:57,000 --> 01:16:00,420
[Pelajar] Tetapi itu tidak akan diperlukan telah anda berhenti selepas garis itu.

1221
01:16:00,420 --> 01:16:03,130
[Joseph] Jadi, jika saya telah berhenti selepas ini, ini akan dianggap kebocoran memori,

1222
01:16:03,130 --> 01:16:04,810
kerana saya tidak menjalankan percuma.

1223
01:16:04,810 --> 01:16:11,290
[Pelajar] I [] yang tidak bijaksana yang selepas tiga baris pertama di mana anda mempunyai penunjuk 1 [difahami].

1224
01:16:11,290 --> 01:16:13,140
[Yusuf] Uh-huh. Jadi, apa soalan di sana?

1225
01:16:13,140 --> 01:16:14,780
Maaf. Tidak, tidak. Pergi, pergi, sila.

1226
01:16:14,780 --> 01:16:16,870
[Pelajar] Jadi, anda tidak mengubah nilai petunjuk.

1227
01:16:16,870 --> 01:16:19,130
Anda tidak akan mempunyai untuk melakukan penunjuk tolak tolak.

1228
01:16:19,130 --> 01:16:19,730
[Yusuf] Ya, betul-betul.

1229
01:16:19,730 --> 01:16:21,890
Jadi, apabila saya melakukan +1 penunjuk dan pointer 2,

1230
01:16:21,890 --> 01:16:24,410
Saya tidak melakukan penunjuk sama pointer 1.

1231
01:16:24,410 --> 01:16:27,260
Jadi, penunjuk hanya tetap menunjuk pada permulaan array.

1232
01:16:27,260 --> 01:16:31,460
Ia hanya apabila saya melakukan ditambah ditambah bahawa ia menetapkan nilai kembali di dalam penunjuk,

1233
01:16:31,460 --> 01:16:33,550
bahawa ia sebenarnya bergerak ini bersama-sama.

1234
01:16:36,860 --> 01:16:37,780
Semua hak.

1235
01:16:40,550 --> 01:16:42,030
Lebih banyak soalan?

1236
01:16:44,680 --> 01:16:47,790
>> Sekali lagi, jika ini adalah jenis hangat, ini akan dibincangkan dalam sesi.

1237
01:16:47,790 --> 01:16:50,710
Tanya rakan-rakan mengajar anda tentang ia, dan kita boleh menjawab soalan-soalan di akhir.

1238
01:16:53,510 --> 01:16:56,600
Dan biasanya kita tidak suka untuk melakukan perkara ini tolak.

1239
01:16:56,600 --> 01:16:59,760
Ini memerlukan saya mengesan berapa banyak saya telah diimbangi dalam array.

1240
01:16:59,760 --> 01:17:04,520
Jadi, secara umum, ini adalah hanya untuk menjelaskan bagaimana kerja-kerja aritmetik penunjuk.

1241
01:17:04,520 --> 01:17:07,970
Tetapi apa yang kita biasanya suka lakukan ialah kita suka untuk membuat salinan penunjuk,

1242
01:17:07,970 --> 01:17:11,640
dan kemudian kita akan menggunakan salinan itu apabila kita sedang bergerak dalam string.

1243
01:17:11,640 --> 01:17:14,660
Jadi, dalam kes ini anda menggunakan salinan untuk mencetak rentetan keseluruhan,

1244
01:17:14,660 --> 01:17:19,040
tetapi kita tidak perlu untuk melakukan seperti penunjuk tolak 6 atau menjejaki berapa banyak kita bergerak dalam hal ini,

1245
01:17:19,040 --> 01:17:22,700
hanya kerana kita tahu bahawa titik asal kita masih menunjukkan permulaan senarai

1246
01:17:22,700 --> 01:17:25,340
dan semua yang kita diubah adalah salinan ini.

1247
01:17:25,340 --> 01:17:28,250
Jadi, secara umum, mengubah salinan penunjuk asal anda.

1248
01:17:28,250 --> 01:17:32,350
Jangan cuba untuk menyelesaikan seperti - Don 't mengubah salinan asal.

1249
01:17:32,350 --> 01:17:35,290
Cuba untuk mengubah hanya salinan asal anda.

1250
01:17:41,540 --> 01:17:44,870
Jadi, anda notis apabila kita lulus rentetan ke printf

1251
01:17:44,870 --> 01:17:48,990
anda tidak perlu untuk meletakkan bintang di hadapan seperti yang kita lakukan dengan semua dereferences lain, kan?

1252
01:17:48,990 --> 01:17:54,180
Jadi, jika anda mencetak% keseluruhan rentetan s menjangka adalah alamat,

1253
01:17:54,180 --> 01:17:57,610
dan dalam kes ini penunjuk atau dalam kes ini seperti pelbagai watak.

1254
01:17:57,610 --> 01:18:00,330
>> Watak, char * s, dan array adalah perkara yang sama.

1255
01:18:00,330 --> 01:18:03,690
Pointer adalah untuk watak-watak, dan barisan watak adalah perkara yang sama.

1256
01:18:03,690 --> 01:18:05,720
Dan sebagainya, semua yang perlu kita lakukan adalah lulus dalam penunjuk.

1257
01:18:05,720 --> 01:18:08,150
Kami tidak mempunyai untuk lulus dalam * seperti penunjuk atau apa-apa seperti itu.

1258
01:18:13,110 --> 01:18:14,930
Jadi, tatasusunan dan petunjuk adalah perkara yang sama.

1259
01:18:14,930 --> 01:18:19,160
Apabila anda melakukan sesuatu seperti x [y] di sini untuk pelbagai,

1260
01:18:19,160 --> 01:18:21,960
apa yang ia lakukan di bawah hud ia berkata, okay, ia adalah pelbagai watak,

1261
01:18:21,960 --> 01:18:23,690
jadi ia adalah penunjuk.

1262
01:18:23,690 --> 01:18:26,510
Dan sebagainya x adalah perkara yang sama,

1263
01:18:26,510 --> 01:18:28,650
dan sebagainya apa yang ia adalah ia menambah y x,

1264
01:18:28,650 --> 01:18:31,820
yang merupakan perkara yang sama seperti bergerak ke hadapan dalam ingatan yang banyak.

1265
01:18:31,820 --> 01:18:34,930
Dan sekarang x + y memberikan kita beberapa jenis alamat,

1266
01:18:34,930 --> 01:18:37,570
dan kita dereference alamat atau ikut anak panah

1267
01:18:37,570 --> 01:18:41,640
mana bahawa lokasi dalam ingatan dan kita mendapat nilai daripada lokasi tersebut dalam ingatan.

1268
01:18:41,640 --> 01:18:43,720
Jadi, jadi kedua-dua adalah perkara yang sama.

1269
01:18:43,720 --> 01:18:45,840
Ia hanya gula sintaktik.

1270
01:18:45,840 --> 01:18:48,090
Mereka melakukan perkara yang sama. Mereka hanya syntactics yang berbeza antara satu sama lain.

1271
01:18:51,500 --> 01:18:57,590
>> Jadi, apa yang boleh pergi salah dengan petunjuk? Seperti, banyak. Okay. Jadi, perkara-perkara buruk.

1272
01:18:57,590 --> 01:19:02,410
Beberapa perkara-perkara buruk yang boleh anda lakukan tidak memeriksa jika panggilan malloc anda kembali batal, betul-betul?

1273
01:19:02,410 --> 01:19:06,560
Dalam kes ini, saya meminta sistem untuk memberikan saya - apakah nombor itu?

1274
01:19:06,560 --> 01:19:11,200
Seperti 2 bilion kali 4, kerana saiz integer adalah 4 bait.

1275
01:19:11,200 --> 01:19:13,810
Saya meminta untuk seperti 8000000000 bait.

1276
01:19:13,810 --> 01:19:17,270
Sudah tentu komputer saya tidak akan dapat memberikan saya yang kembali memori banyak.

1277
01:19:17,270 --> 01:19:20,960
Dan kita tidak memeriksa jika ini adalah batal, jadi apabila kita cuba untuk dereference di sana -

1278
01:19:20,960 --> 01:19:24,270
mengikuti anak panah ke mana ia akan - kita tidak mempunyai memori yang.

1279
01:19:24,270 --> 01:19:27,150
Ini adalah apa yang kita panggil dereferencing penunjuk nol.

1280
01:19:27,150 --> 01:19:29,710
Dan ini pada dasarnya menyebabkan anda segfault.

1281
01:19:29,710 --> 01:19:31,790
Ini adalah salah satu cara anda boleh segfault.

1282
01:19:34,090 --> 01:19:38,090
Lain-lain perkara-perkara buruk yang boleh anda lakukan - oh baik.

1283
01:19:38,090 --> 01:19:40,650
Itu dereferencing penunjuk nol. Okay.

1284
01:19:40,650 --> 01:19:45,160
Lain-lain perkara yang buruk - baik, untuk menetapkan bahawa anda hanya meletakkan cek di sana

1285
01:19:45,160 --> 01:19:46,980
yang memeriksa sama ada penunjuk adalah batal

1286
01:19:46,980 --> 01:19:51,000
dan keluar daripada program ini jika ia berlaku bahawa malloc mengembalikan penunjuk nol.

1287
01:19:55,110 --> 01:19:59,850
Itulah komik xkcd. Orang faham sekarang. Susun.

1288
01:20:06,120 --> 01:20:09,350
>> Jadi, ingatan. Dan saya pergi lebih ini.

1289
01:20:09,350 --> 01:20:12,000
Kami memanggil malloc dalam gelung, tetapi setiap kali kita memanggil malloc

1290
01:20:12,000 --> 01:20:14,370
kita kehilangan mengesan di mana penunjuk ini menunjuk ke,

1291
01:20:14,370 --> 01:20:15,750
kerana kita sedang clobbering ia.

1292
01:20:15,750 --> 01:20:18,410
Jadi, panggilan awal untuk malloc memberi saya ingatan di sini.

1293
01:20:18,410 --> 01:20:19,990
Penunjuk penunjuk saya ini.

1294
01:20:19,990 --> 01:20:23,020
Sekarang, saya tidak membebaskan, jadi sekarang saya panggil malloc lagi.

1295
01:20:23,020 --> 01:20:26,070
Kini ia menunjuk ke sini. Sekarang ingatan saya menunjuk ke sini.

1296
01:20:26,070 --> 01:20:27,640
Menunjuk ke sini. Menunjuk ke sini.

1297
01:20:27,640 --> 01:20:31,820
Tetapi saya telah hilang mengesan alamat semua memori di sini bahawa saya memperuntukkan.

1298
01:20:31,820 --> 01:20:35,100
Dan sebagainya sekarang saya tidak mempunyai apa-apa rujukan kepada mereka lagi.

1299
01:20:35,100 --> 01:20:37,230
Jadi, saya tidak boleh membebaskan mereka di luar gelung ini.

1300
01:20:37,230 --> 01:20:39,390
Dan sebagainya untuk menetapkan sesuatu seperti ini,

1301
01:20:39,390 --> 01:20:42,250
jika anda lupa untuk memori percuma dan anda mendapatkan ini kebocoran memori,

1302
01:20:42,250 --> 01:20:45,810
Anda perlu untuk membebaskan memori di dalam gelung ini sebaik sahaja anda selesai dengan ia.

1303
01:20:45,810 --> 01:20:51,400
Nah, ini adalah apa yang berlaku. Saya tahu banyak anda benci ini.

1304
01:20:51,400 --> 01:20:55,270
Tetapi sekarang - Yay! Anda akan mendapat seperti 44.000 kilobytes.

1305
01:20:55,270 --> 01:20:57,110
Jadi, anda bebas pada akhir gelung,

1306
01:20:57,110 --> 01:20:59,770
dan perkara yang berlaku hanya membebaskan memori setiap masa.

1307
01:20:59,770 --> 01:21:03,620
Pada asasnya, program anda tidak mempunyai kebocoran memori lagi.

1308
01:21:03,620 --> 01:21:08,150
>> Dan kini sesuatu yang lain yang boleh anda lakukan adalah membebaskan beberapa memori yang anda telah diminta untuk dua kali.

1309
01:21:08,150 --> 01:21:11,060
Dalam kes ini, anda malloc sesuatu, anda menukar nilainya.

1310
01:21:11,060 --> 01:21:13,140
Anda bebas sekali kerana anda berkata anda telah dilakukan dengan ia.

1311
01:21:13,140 --> 01:21:14,940
Tetapi kemudian kita dibebaskan sekali lagi.

1312
01:21:14,940 --> 01:21:16,730
Ini adalah sesuatu yang cukup buruk.

1313
01:21:16,730 --> 01:21:18,820
Ia tidak akan pada mulanya segfault,

1314
01:21:18,820 --> 01:21:23,350
tetapi selepas itu apa ini tidak berganda membebaskan ini merosakkan struktur timbunan anda,

1315
01:21:23,350 --> 01:21:27,200
dan anda akan belajar sedikit lebih lanjut mengenai ini jika anda memilih untuk mengambil kelas seperti CS61.

1316
01:21:27,200 --> 01:21:30,000
Tetapi pada dasarnya selepas manakala komputer anda akan terkeliru

1317
01:21:30,000 --> 01:21:33,010
tentang apa lokasi ingatan di mana dan di mana ia disimpan -

1318
01:21:33,010 --> 01:21:34,800
di mana data disimpan dalam ingatan.

1319
01:21:34,800 --> 01:21:38,080
Dan supaya membebaskan penunjuk dua kali adalah satu perkara yang buruk yang anda tidak mahu lakukan.

1320
01:21:38,080 --> 01:21:41,600
>> Perkara-perkara lain yang boleh pergi salah tidak menggunakan sizeof.

1321
01:21:41,600 --> 01:21:44,460
Jadi, dalam kes ini anda malloc 8 bait,

1322
01:21:44,460 --> 01:21:46,700
dan itulah perkara yang sama sebagai dua integer, betul-betul?

1323
01:21:46,700 --> 01:21:49,580
Jadi, itulah selamat, tetapi ia?

1324
01:21:49,580 --> 01:21:52,160
Nah, sebagai Lucas bercakap tentang seni bina yang berbeza,

1325
01:21:52,160 --> 01:21:54,220
integer panjang yang berbeza.

1326
01:21:54,220 --> 01:21:57,970
Jadi, pada perkakas yang anda gunakan, integer adalah kira-kira 4 bait,

1327
01:21:57,970 --> 01:22:02,370
tetapi pada sistem lain mereka mungkin 8 bait atau mereka mungkin 16 bait.

1328
01:22:02,370 --> 01:22:05,680
Jadi, jika saya hanya menggunakan nombor ini di sini,

1329
01:22:05,680 --> 01:22:07,310
program ini mungkin bekerja pada perkakas,

1330
01:22:07,310 --> 01:22:10,360
tetapi ia tidak akan memperuntukkan memori yang cukup pada sistem lain.

1331
01:22:10,360 --> 01:22:14,020
Dalam kes ini, ini adalah apa pengendali sizeof digunakan untuk.

1332
01:22:14,020 --> 01:22:16,880
Apabila kita panggil sizeof (int), apa ini tidak

1333
01:22:16,880 --> 01:22:21,910
 ia memberikan kita saiz integer pada sistem bahawa program ini berjalan.

1334
01:22:21,910 --> 01:22:25,490
Jadi, dalam kes ini, sizeof (int) akan kembali 4 pada sesuatu seperti perkakas,

1335
01:22:25,490 --> 01:22:29,980
dan sekarang ini kehendak 4 * 2, iaitu 8,

1336
01:22:29,980 --> 01:22:32,330
yang hanya jumlah ruang yang perlu bagi dua integer.

1337
01:22:32,330 --> 01:22:36,710
Pada sistem yang berbeza, jika int adalah seperti 16 bait atau 8 bait,

1338
01:22:36,710 --> 01:22:39,380
ia hanya akan kembali bait yang cukup untuk menyimpan sejumlah itu.

1339
01:22:41,830 --> 01:22:45,310
>> Dan akhirnya, structs.

1340
01:22:45,310 --> 01:22:48,340
Jadi, jika anda mahu untuk menyimpan papan Sudoku dalam ingatan, bagaimana kita mungkin melakukan ini?

1341
01:22:48,340 --> 01:22:51,570
Anda mungkin berfikir seperti pembolehubah untuk perkara yang pertama,

1342
01:22:51,570 --> 01:22:53,820
pembolehubah bagi perkara yang kedua, ubah bagi perkara ketiga,

1343
01:22:53,820 --> 01:22:56,420
pembolehubah untuk perkara keempat - buruk, betul?

1344
01:22:56,420 --> 01:23:00,750
Jadi, salah satu penambahbaikan anda boleh membuat di atas ini adalah untuk membuat pelbagai 9 x 9.

1345
01:23:00,750 --> 01:23:04,480
Itu baik, tetapi bagaimana jika anda mahu untuk mengaitkan perkara-perkara lain dengan lembaga Sudoku

1346
01:23:04,480 --> 01:23:06,490
seperti apa kesukaran lembaga,

1347
01:23:06,490 --> 01:23:11,740
atau, sebagai contoh, apa yang skor anda, atau berapa banyak masa ia diambil anda untuk menyelesaikan lembaga ini?

1348
01:23:11,740 --> 01:23:14,970
Nah, apa yang anda boleh lakukan ialah anda boleh membuat struct.

1349
01:23:14,970 --> 01:23:18,910
Apa yang saya pada dasarnya mengatakan saya menentukan struktur ini di sini,

1350
01:23:18,910 --> 01:23:23,230
dan saya menentukan suatu lembaga Sudoku yang terdiri daripada lembaga yang 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> Dan apa yang ia mempunyai ia mempunyai petunjuk untuk nama peringkat.

1352
01:23:26,650 --> 01:23:30,730
Ia juga mempunyai x dan y, yang koordinat di mana saya sekarang.

1353
01:23:30,730 --> 01:23:35,980
Ia juga telah menghabiskan masa [difahami], dan ia mempunyai jumlah langkah-langkah yang saya telah dimasukkan setakat.

1354
01:23:35,980 --> 01:23:40,010
Dan sebagainya dalam kes ini, saya boleh mengumpulkan sekumpulan keseluruhan data ke hanya satu struktur

1355
01:23:40,010 --> 01:23:42,790
bukannya mempunyai ia seperti terbang di sekitar seperti pembolehubah yang berbeza

1356
01:23:42,790 --> 01:23:44,540
bahawa saya tidak boleh benar-benar menjejaki.

1357
01:23:44,540 --> 01:23:49,720
Dan ini membolehkan kita mempunyai hanya sintaks bagus untuk jenis rujukan perkara yang berbeza di dalam struct ini.

1358
01:23:49,720 --> 01:23:53,430
Saya hanya boleh melakukan board.board, dan saya mendapat lembaga Sudoku kembali.

1359
01:23:53,430 --> 01:23:56,320
Board.level, saya mendapat bagaimana sukar ia adalah.

1360
01:23:56,320 --> 01:24:00,540
Board.x dan board.y memberi saya koordinat di mana saya mungkin dalam lembaga.

1361
01:24:00,540 --> 01:24:04,730
Dan jadi saya mengakses apa yang kita panggil bidang dalam struct.

1362
01:24:04,730 --> 01:24:08,840
Ini mentakrifkan sudokuBoard, yang merupakan jenis yang saya ada.

1363
01:24:08,840 --> 01:24:14,800
Dan sekarang kita berada di sini. Saya mempunyai pembolehubah yang dipanggil "lembaga" sudokuBoard jenis.

1364
01:24:14,800 --> 01:24:18,820
Dan jadi sekarang saya boleh mengakses semua bidang yang membentuk struktur ini di sini.

1365
01:24:20,830 --> 01:24:22,450
>> Sebarang pertanyaan tentang structs? Ya?

1366
01:24:22,450 --> 01:24:25,890
[Pelajar] Untuk int x, y, anda mengisytiharkan kedua-duanya dalam satu baris? >> [Yusuf] Uh-huh.

1367
01:24:25,890 --> 01:24:27,400
[Pelajar] Jadi, boleh anda hanya berbuat demikian dengan mereka semua?

1368
01:24:27,400 --> 01:24:31,200
Seperti di x, y koma kali bahawa jumlah?

1369
01:24:31,200 --> 01:24:34,460
[Yusuf] Ya, anda pasti dapat berbuat demikian, tetapi sebab saya meletakkan x dan y pada baris yang sama -

1370
01:24:34,460 --> 01:24:36,330
dan persoalannya ialah mengapa kita hanya boleh melakukan ini pada baris yang sama?

1371
01:24:36,330 --> 01:24:38,600
Mengapa tidak kita hanya meletakkan semua ini pada baris yang sama adalah

1372
01:24:38,600 --> 01:24:42,090
x dan y adalah berkaitan antara satu sama lain,

1373
01:24:42,090 --> 01:24:44,780
dan ini hanya stylistically lebih tepat, dalam erti kata,

1374
01:24:44,780 --> 01:24:46,600
kerana ia kumpulan dua perkara pada baris yang sama

1375
01:24:46,600 --> 01:24:49,340
yang jenis seperti berkaitan dengan perkara yang sama.

1376
01:24:49,340 --> 01:24:51,440
Dan saya hanya berpecah ini selain. Ia hanya satu perkara yang gaya.

1377
01:24:51,440 --> 01:24:53,720
Ia berfungsi membuat tiada perbezaan jua.

1378
01:24:58,150 --> 01:24:59,270
Mana-mana soalan-soalan lain pada structs?

1379
01:25:03,030 --> 01:25:06,620
Anda boleh menentukan Pokédex dengan struct.

1380
01:25:06,620 --> 01:25:11,720
Satu Pokémon mempunyai nombor dan ia mempunyai surat, pemilik, jenis.

1381
01:25:11,720 --> 01:25:16,990
Dan kemudian jika anda mempunyai pelbagai Pokémon, anda boleh membuat sehingga Pokédex, betul-betul?

1382
01:25:16,990 --> 01:25:20,810
Okay, sejuk. Jadi, soalan pada structs. Mereka adalah berkaitan dengan structs.

1383
01:25:20,810 --> 01:25:25,270
>> Akhirnya, GDB. Apakah GDB membiarkan anda lakukan? Ia membolehkan anda debug program anda.

1384
01:25:25,270 --> 01:25:27,650
Dan jika anda telah tidak digunakan GDB, saya akan disyorkan menonton pendek

1385
01:25:27,650 --> 01:25:31,250
dan hanya akan atas apa yang GDB adalah, bagaimana anda bekerja dengan, bagaimana anda mungkin menggunakan,

1386
01:25:31,250 --> 01:25:32,900
dan menguji program.

1387
01:25:32,900 --> 01:25:37,400
Dan jadi apa GDB membolehkan anda lakukan adalah ia membolehkan menjedakan [difahami] program anda

1388
01:25:37,400 --> 01:25:38,920
dan garis praktikal.

1389
01:25:38,920 --> 01:25:42,600
Sebagai contoh, saya mahu pelaksanaan jeda pada seperti baris 3 program saya,

1390
01:25:42,600 --> 01:25:46,010
dan semasa saya di baris 3 saya boleh mencetak keluar semua nilai-nilai yang terdapat.

1391
01:25:46,010 --> 01:25:49,710
Dan supaya apa yang kita panggil seperti berhenti dalam satu barisan

1392
01:25:49,710 --> 01:25:52,350
kita panggil ini meletakkan titik putus di garis yang

1393
01:25:52,350 --> 01:25:55,920
dan kemudian kita boleh mencetak pembolehubah di negeri program pada masa itu.

1394
01:25:55,920 --> 01:25:58,990
>> Kita boleh kemudian dari sana melangkah melalui program garis-oleh-line.

1395
01:25:58,990 --> 01:26:03,200
Dan kemudian kita boleh melihat negeri timbunan pada masa itu.

1396
01:26:03,200 --> 01:26:08,600
Dan sebagainya untuk menggunakan GDB, apa yang kita lakukan adalah kita panggil dilafaz pada fail C,

1397
01:26:08,600 --> 01:26:11,290
tetapi kita perlu untuk lulus ia bendera ggdb-.

1398
01:26:11,290 --> 01:26:15,850
Dan apabila kita sudah selesai dengan itu kita hanya menjalankan Pra-Pemasangan pada fail output yang terhasil.

1399
01:26:15,850 --> 01:26:18,810
Dan supaya anda mendapat beberapa jisim seperti teks seperti ini,

1400
01:26:18,810 --> 01:26:21,990
tetapi benar-benar semua yang anda perlu lakukan adalah menaip arahan pada permulaan.

1401
01:26:21,990 --> 01:26:24,250
Cuti utama meletakkan titik putus di utama.

1402
01:26:24,250 --> 01:26:28,470
Senarai 400 menyenaraikan baris kod sekitar 400 baris.

1403
01:26:28,470 --> 01:26:31,410
Dan sebagainya dalam kes ini anda hanya boleh melihat sekeliling dan berkata, oh,

1404
01:26:31,410 --> 01:26:34,360
Saya mahu untuk menetapkan titik putus di garisan 397, yang adalah baris ini,

1405
01:26:34,360 --> 01:26:37,170
dan kemudian program anda berjalan ke dalam langkah itu dan ia akan pecah.

1406
01:26:37,170 --> 01:26:41,120
Ia akan berhenti seketika di sana, dan anda boleh mencetak, sebagai contoh, nilai rendah atau tinggi.

1407
01:26:41,120 --> 01:26:46,410
Dan sebagainya terdapat sekumpulan arahan yang anda perlu tahu,

1408
01:26:46,410 --> 01:26:48,660
dan tayangan gambar ini akan naik di laman web,

1409
01:26:48,660 --> 01:26:54,000
jadi jika anda hanya mahu untuk rujukan ini atau ingin meletakkan mereka pada kepingan anda menipu, berasa bebas.

1410
01:26:54,000 --> 01:27:00,650
>> Sejuk. Itu adalah Kuiz Kajian 0, dan kita akan melekat di sekeliling jika anda mempunyai sebarang soalan.

1411
01:27:00,650 --> 01:27:03,850
Semua hak.

1412
01:27:03,850 --> 01:27:09,030
>>  [Tepukan]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]