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

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

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 orang.

5
00:00:10,000 --> 00:00:15,000
Selamat datang di sesi review untuk Kuis 0, yang berlangsung Rabu ini.

6
00:00:15,000 --> 00:00:19,000
Apa yang kita akan lakukan malam ini, aku dengan 3 TF lainnya,

7
00:00:19,000 --> 00:00:24,000
dan bersama-sama kita akan pergi melalui review dari apa yang kita lakukan dalam kursus tersebut sejauh ini.

8
00:00:24,000 --> 00:00:27,000
Ini tidak akan menjadi 100% yang komprehensif, tetapi harus memberikan Anda ide yang lebih baik

9
00:00:27,000 --> 00:00:31,000
dari apa yang sudah Anda miliki ke bawah dan apa yang masih perlu untuk belajar sebelum hari Rabu.

10
00:00:31,000 --> 00:00:34,000
Dan jangan ragu untuk mengangkat tangan Anda dengan pertanyaan-pertanyaan seperti yang kita akan bersama,

11
00:00:34,000 --> 00:00:38,000
namun perlu diingat bahwa kita juga akan memiliki sedikit waktu di akhir-

12
00:00:38,000 --> 00:00:41,000
jika kita melewati dengan beberapa menit untuk cadangan-untuk melakukan pertanyaan umum,

13
00:00:41,000 --> 00:00:47,000
jadi ingatlah bahwa dalam pikiran, dan dengan demikian kita akan mulai pada awal dengan Minggu 0.

14
00:00:47,000 --> 00:00:50,000
>> [Kuis 0 Review!] [Bagian 0] [Lexi Ross] Tapi sebelum kita melakukan itu mari kita bicara tentang

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

16
00:00:53,000 --> 00:00:55,000
>> [Logistik] [Kuis berlangsung pada Rabu 10/10 sebagai pengganti kuliah]

17
00:00:55,000 --> 00:00:57,000
>> [(Lihat http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf untuk rincian)] Hal ini pada hari Rabu, tanggal 10 Oktober.

18
00:00:57,000 --> 00:01:00,000
>> Itu Rabu ini, dan jika Anda pergi ke URL ini di sini,

19
00:01:00,000 --> 00:01:03,000
yang juga dapat diakses dari CS50.net-ada link ke sana-

20
00:01:03,000 --> 00:01:06,000
Anda dapat melihat informasi tentang ke mana harus pergi berdasarkan

21
00:01:06,000 --> 00:01:10,000
Anda nama belakang atau afiliasi sekolah serta

22
00:01:10,000 --> 00:01:14,000
ia memberitahu tentang apa kuis akan menutupi dan jenis pertanyaan yang Anda akan mendapatkan.

23
00:01:14,000 --> 00:01:19,000
Perlu diingat bahwa Anda juga akan memiliki kesempatan untuk meninjau untuk kuis dalam bagian,

24
00:01:19,000 --> 00:01:21,000
sehingga TF Anda harus pergi lebih dari beberapa masalah praktek,

25
00:01:21,000 --> 00:01:29,000
dan itu kesempatan lain yang baik untuk melihat di mana Anda masih perlu belajar untuk kuis.

26
00:01:29,000 --> 00:01:32,000
Mari kita mulai dari awal dengan Bytes 'n' Bits.

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

28
00:01:35,000 --> 00:01:38,000
dan byte adalah kumpulan dari 8 bit dari mereka.

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

30
00:01:42,000 --> 00:01:44,000
Kita harus bisa mengetahui berapa banyak bit ada.

31
00:01:44,000 --> 00:01:48,000
Dimana kita menghitung ada hanya 8 dari mereka, delapan 0 atau 1 unit.

32
00:01:48,000 --> 00:01:51,000
Dan karena ada 8 bit, itu 1 byte,

33
00:01:51,000 --> 00:01:53,000
dan mari kita mengubahnya menjadi heksadesimal.

34
00:01:53,000 --> 00:01:58,000
Heksadesimal adalah basis 16, dan itu cukup mudah untuk mengkonversi

35
00:01:58,000 --> 00:02:01,000
nomor dalam biner, yang adalah apa itu, ke nomor di heksadesimal.

36
00:02:01,000 --> 00:02:04,000
Semua yang kita lakukan adalah kita melihat kelompok 4,

37
00:02:04,000 --> 00:02:07,000
dan kita mengkonversikannya ke digit heksadesimal yang sesuai.

38
00:02:07,000 --> 00:02:11,000
Kita mulai dengan kelompok paling kanan dari 4, jadi 0011.

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

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

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

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

43
00:02:28,000 --> 00:02:32,000
Dan kita akan ingat bahwa dalam heksadesimal kita tidak hanya pergi 0 sampai 9.

44
00:02:32,000 --> 00:02:36,000
Kami pergi 0 sampai F, jadi setelah 9, 10 berkorespondensi dengan A,

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

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

47
00:02:44,000 --> 00:02:49,000
sehingga untuk mengubahnya menjadi desimal semua yang kita lakukan adalah kita benar-benar

48
00:02:49,000 --> 00:02:52,000
memperlakukan setiap posisi sebagai kekuatan dari 2.

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

50
00:02:58,000 --> 00:03:03,000
dan itu agak sulit untuk menghitung di kepala Anda, tetapi jika kita pergi ke slide berikutnya

51
00:03:03,000 --> 00:03:05,000
kita dapat melihat jawabannya.

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

53
00:03:09,000 --> 00:03:14,000
dan kita mengalikan setiap digit oleh kekuatan yang sesuai 2.

54
00:03:14,000 --> 00:03:19,000
Dan ingat, untuk heksadesimal kami menunjukkan angka-angka dengan 0x di awal

55
00:03:19,000 --> 00:03:23,000
jadi kita tidak bingung dengan angka desimal.

56
00:03:23,000 --> 00:03:29,000
Melanjutkan, ini adalah Tabel ASCII,

57
00:03:29,000 --> 00:03:35,000
dan apa yang kita gunakan ASCII untuk adalah untuk memetakan dari karakter nilai-nilai numerik.

58
00:03:35,000 --> 00:03:39,000
Ingat dalam pset kriptografi kami membuat ekstensif menggunakan Tabel ASCII

59
00:03:39,000 --> 00:03:43,000
untuk menggunakan berbagai metode kriptografi,

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

61
00:03:47,000 --> 00:03:52,000
dalam string sesuai dengan kunci yang diberikan oleh pengguna.

62
00:03:52,000 --> 00:03:56,000
Mari kita lihat sedikit matematika ASCII.

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

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

65
00:04:07,000 --> 00:04:10,000
Dan bagaimana tepatnya kita akan mengkonversi antara 2 bentuk?

66
00:04:10,000 --> 00:04:13,000
Ini tidak benar-benar terlalu keras.

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

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

69
00:04:20,000 --> 00:04:23,000
Dalam rangka untuk pergi ke arah lain kita hanya tambahkan 0 tersebut,

70
00:04:23,000 --> 00:04:25,000
jadi semacam aritmatika biasa.

71
00:04:25,000 --> 00:04:29,000
Hanya ingat bahwa ketika sesuatu memiliki tanda kutip itu karakter

72
00:04:29,000 --> 00:04:37,000
dan dengan demikian sesuai dengan nilai dalam tabel ASCII.

73
00:04:37,000 --> 00:04:40,000
Pindah ke lebih topik ilmu komputer umum.

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

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

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

77
00:04:48,000 --> 00:04:51,000
memeriksa apakah suatu bilangan genap atau ganjil.

78
00:04:51,000 --> 00:04:54,000
Untuk itu ingat kita mod nomor dengan 2 dan periksa apakah hasilnya adalah 0.

79
00:04:54,000 --> 00:04:57,000
Jika demikian, itu bahkan. Jika tidak, itu aneh.

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

81
00:04:59,000 --> 00:05:02,000
>> Sedikit yang lebih terlibat adalah pencarian biner,

82
00:05:02,000 --> 00:05:05,000
yang kita akan pergi ke nanti dalam sesi review.

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

84
00:05:09,000 --> 00:05:15,000
dan mengubahnya menjadi kode komputer dapat membaca.

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

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

87
00:05:22,000 --> 00:05:25,000
Meskipun kita tidak benar-benar mengetikkan kode itu adalah cara menerapkan

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

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

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

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

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

93
00:05:48,000 --> 00:05:51,000
dan di sini seringkali boolean ekspresi

94
00:05:51,000 --> 00:05:55,000
masuk ke dalam kondisi, jadi jika (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
well, kita sudah diatur x = 5, sehingga kondisi yang akan mengevaluasi benar.

96
00:06:00,000 --> 00:06:03,000
Dan jika itu benar, apa pun kode di bawah kondisi

97
00:06:03,000 --> 00:06:08,000
akan dievaluasi oleh komputer, sehingga string yang akan dicetak

98
00:06:08,000 --> 00:06:12,000
ke output standar, dan kondisi jangka

99
00:06:12,000 --> 00:06:16,000
mengacu pada apa pun yang di dalam kurung dari pernyataan jika.

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

101
00:06:20,000 --> 00:06:26,000
Ingat && itu dan | | ketika kita sedang mencoba untuk menggabungkan 2 atau lebih kondisi,

102
00:06:26,000 --> 00:06:30,000
== Tidak = 2 untuk memeriksa apakah hal yang sama.

103
00:06:30,000 --> 00:06:36,000
Ingat bahwa = adalah untuk tugas sementara == adalah operator boolean.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ 2 dan kemudian akhir yang cukup jelas.

105
00:06:41,000 --> 00:06:45,000
Sebuah tinjauan umum logika boolean sini.

106
00:06:45,000 --> 00:06:48,000
Dan ekspresi boolean juga penting dalam loop,

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

108
00:06:50,000 --> 00:06:56,000
Kami belajar tentang 3 jenis loop sejauh CS50, untuk, sementara, dan dilakukan sementara.

109
00:06:56,000 --> 00:06:59,000
Dan itu penting untuk mengetahui bahwa sementara untuk sebagian besar tujuan

110
00:06:59,000 --> 00:07:02,000
kita benar-benar dapat menggunakan semua jenis lingkaran pada umumnya

111
00:07:02,000 --> 00:07:06,000
ada beberapa jenis tujuan atau pola umum

112
00:07:06,000 --> 00:07:09,000
dalam pemrograman yang secara khusus meminta salah satu loop

113
00:07:09,000 --> 00:07:13,000
yang membuatnya paling efisien atau elegan untuk kode dengan cara itu.

114
00:07:13,000 --> 00:07:18,000
Mari kita atas apa masing-masing loop cenderung digunakan untuk paling sering.

115
00:07:18,000 --> 00:07:21,000
>> Dalam untuk loop kita umumnya sudah tahu berapa kali kita ingin iterate.

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

117
00:07:24,000 --> 00:07:28,000
Sebab, i = 0, i <10, misalnya.

118
00:07:28,000 --> 00:07:31,000
Kita sudah tahu bahwa kami ingin melakukan sesuatu 10 kali.

119
00:07:31,000 --> 00:07:34,000
Sekarang, untuk loop sementara, umumnya kita tidak selalu

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

121
00:07:36,000 --> 00:07:39,000
Tapi kita tahu semacam kondisi yang kita inginkan

122
00:07:39,000 --> 00:07:41,000
selalu benar atau selalu salah.

123
00:07:41,000 --> 00:07:44,000
Sebagai contoh, ketika diatur.

124
00:07:44,000 --> 00:07:46,000
Mari kita mengatakan bahwa adalah variabel boolean.

125
00:07:46,000 --> 00:07:48,000
Sementara itu benar kita ingin kode untuk mengevaluasi,

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

127
00:07:52,000 --> 00:07:55,000
tetapi setiap untuk loop juga dapat dikonversi ke loop sementara.

128
00:07:55,000 --> 00:08:00,000
Akhirnya, lakukan sementara loop, yang mungkin paling sulit untuk memahami segera,

129
00:08:00,000 --> 00:08:04,000
sering digunakan ketika kita ingin mengevaluasi kode pertama

130
00:08:04,000 --> 00:08:06,000
sebelum kalinya kami memeriksa kondisi.

131
00:08:06,000 --> 00:08:09,000
Contoh penggunaan umum untuk lakukan sementara loop

132
00:08:09,000 --> 00:08:12,000
adalah ketika Anda ingin mendapatkan input pengguna, dan Anda tahu bahwa Anda ingin meminta pengguna

133
00:08:12,000 --> 00:08:15,000
untuk input setidaknya sekali, tetapi jika mereka tidak memberikan masukan yang baik langsung

134
00:08:15,000 --> 00:08:18,000
Anda ingin terus meminta mereka sampai mereka memberikan masukan yang baik.

135
00:08:18,000 --> 00:08:21,000
Itulah penggunaan yang paling umum dari do while loop,

136
00:08:21,000 --> 00:08:23,000
dan mari kita lihat struktur yang sebenarnya dari loop ini.

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

138
00:08:27,000 --> 00:08:30,000
>> Pada pengulangan untuk di dalam Anda memiliki 3 komponen:

139
00:08:30,000 --> 00:08:35,000
inisialisasi, biasanya sesuatu seperti int i = 0 di mana i adalah meja,

140
00:08:35,000 --> 00:08:40,000
kondisi, di mana kita ingin mengatakan menjalankan ini untuk loop selama kondisi ini masih memegang,

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

142
00:08:44,000 --> 00:08:47,000
variabel counter pada setiap titik dalam lingkaran.

143
00:08:47,000 --> 00:08:50,000
Suatu hal yang umum untuk melihat hanya ada i + +,

144
00:08:50,000 --> 00:08:52,000
yang berarti kenaikan i oleh 1 setiap waktu.

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

146
00:08:55,000 --> 00:08:58,000
yang berarti menambah 2 sampai i setiap kali Anda pergi melalui loop.

147
00:08:58,000 --> 00:09:03,000
Dan kemudian melakukan hal ini hanya mengacu pada kode yang benar-benar berjalan sebagai bagian dari loop.

148
00:09:03,000 --> 00:09:09,000
Dan untuk beberapa saat loop, kali ini kita benar-benar memiliki inisialisasi luar loop,

149
00:09:09,000 --> 00:09:12,000
jadi misalnya, katakanlah kita sedang berusaha untuk melakukan jenis yang sama dari lingkaran seperti yang saya baru saja dijelaskan.

150
00:09:12,000 --> 00:09:16,000
Kami akan mengatakan int i = 0 sebelum loop dimulai.

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

152
00:09:20,000 --> 00:09:22,000
sehingga blok yang sama kode seperti sebelumnya,

153
00:09:22,000 --> 00:09:26,000
dan kali ini bagian dari pembaruan kode, misalnya, i + +,

154
00:09:26,000 --> 00:09:29,000
benar-benar berjalan dalam lingkaran.

155
00:09:29,000 --> 00:09:33,000
Dan akhirnya, untuk melakukan sementara, itu mirip dengan loop sementara,

156
00:09:33,000 --> 00:09:36,000
tapi kita harus ingat bahwa kode akan mengevaluasi sekali

157
00:09:36,000 --> 00:09:40,000
sebelum kondisi tersebut akan diperiksa, sehingga masuk akal lebih banyak

158
00:09:40,000 --> 00:09:44,000
jika Anda melihat itu dalam urutan atas ke bawah.

159
00:09:44,000 --> 00:09:49,000
Dalam lakukan sementara loop kode mengevaluasi sebelum Anda bahkan melihat kondisi sementara,

160
00:09:49,000 --> 00:09:55,000
sedangkan while loop, ia akan mengecek terlebih dahulu.

161
00:09:55,000 --> 00:09:59,000
Laporan dan variabel.

162
00:09:59,000 --> 00:10:04,000
Ketika kita ingin membuat variabel baru pertama kita ingin menginisialisasi itu.

163
00:10:04,000 --> 00:10:07,000
>> Misalnya, bar int menginisialisasi variabel bar,

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

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

166
00:10:12,000 --> 00:10:14,000
Bisa jadi beberapa nilai sampah yang sebelumnya disimpan dalam memori sana,

167
00:10:14,000 --> 00:10:16,000
dan kami tidak ingin menggunakan variabel yang

168
00:10:16,000 --> 00:10:19,000
sampai kita benar-benar memberikan nilai,

169
00:10:19,000 --> 00:10:21,000
jadi kita mendeklarasikan sini.

170
00:10:21,000 --> 00:10:24,000
Kemudian kita menginisialisasi itu menjadi 42 di bawah ini.

171
00:10:24,000 --> 00:10:28,000
Sekarang, tentu saja, kita tahu ini dapat dilakukan pada satu baris, int bar = 42.

172
00:10:28,000 --> 00:10:30,000
Tapi hanya untuk menghapus beberapa langkah yang terjadi,

173
00:10:30,000 --> 00:10:34,000
deklarasi dan inisialisasi yang terjadi secara terpisah di sini.

174
00:10:34,000 --> 00:10:38,000
Hal ini terjadi pada satu langkah, dan yang berikutnya, int baz = bar + 1,

175
00:10:38,000 --> 00:10:44,000
pernyataan ini di bawah ini, bahwa baz bertahap, sehingga pada akhir blok kode ini

176
00:10:44,000 --> 00:10:48,000
jika kita mencetak nilai baz akan 44

177
00:10:48,000 --> 00:10:52,000
karena kita mendeklarasikan dan menginisialisasi menjadi 1 bar>,

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

179
00:10:58,000 --> 00:11:02,000
Kami pergi sebentar ini cantik, tapi itu baik untuk memiliki seorang jenderal

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

181
00:11:04,000 --> 00:11:06,000
Kami terutama melakukan ini di Scratch,

182
00:11:06,000 --> 00:11:09,000
sehingga Anda bisa memikirkan benang sebagai urutan beberapa kode

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

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

185
00:11:14,000 --> 00:11:17,000
tapi semacam abstrak dapat kita pikirkan dengan cara itu.

186
00:11:17,000 --> 00:11:20,000
>> Dalam Scratch, misalnya, kami memiliki beberapa sprite.

187
00:11:20,000 --> 00:11:22,000
Ini bisa mengeksekusi kode yang berbeda pada waktu yang sama.

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

189
00:11:26,000 --> 00:11:29,000
di bagian yang berbeda dari layar.

190
00:11:29,000 --> 00:11:34,000
Acara lain adalah cara memisahkan logika

191
00:11:34,000 --> 00:11:37,000
antara unsur-unsur yang berbeda dari kode Anda,

192
00:11:37,000 --> 00:11:40,000
dan dalam Scratch kami mampu mensimulasikan peristiwa menggunakan Broadcast,

193
00:11:40,000 --> 00:11:43,000
dan itu benar-benar Ketika saya Menerima, tidak Ketika Aku Mendengar,

194
00:11:43,000 --> 00:11:47,000
tapi pada dasarnya itu adalah cara untuk mengirimkan informasi

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

196
00:11:49,000 --> 00:11:52,000
Sebagai contoh, Anda mungkin ingin mengirimkan permainan berakhir,

197
00:11:52,000 --> 00:11:56,000
dan ketika sprite lain menerima permainan di atas,

198
00:11:56,000 --> 00:11:58,000
akan meresponnya dengan cara tertentu.

199
00:11:58,000 --> 00:12:03,000
Ini adalah model penting untuk memahami untuk pemrograman.

200
00:12:03,000 --> 00:12:07,000
Hanya untuk pergi atas dasar Minggu 0, apa yang kita telah melebihi sejauh ini,

201
00:12:07,000 --> 00:12:10,000
mari kita lihat program C sederhana.

202
00:12:10,000 --> 00:12:14,000
Teks mungkin sedikit kecil dari sini, tapi aku akan pergi ke itu benar-benar cepat.

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

204
00:12:20,000 --> 00:12:23,000
Kami kemudian mendefinisikan batas yang disebut konstan menjadi 100.

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

206
00:12:26,000 --> 00:12:29,000
Karena kita tidak menggunakan argumen baris perintah di sini kita perlu menempatkan batal

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

208
00:12:32,000 --> 00:12:38,000
Kita melihat di atas int main. Itulah jenis kembali, maka kembali 0 di bagian bawah.

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

210
00:12:41,000 --> 00:12:45,000
untuk meminta pengguna untuk masukan, dan kami menyimpannya dalam variabel x,

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

212
00:12:51,000 --> 00:12:53,000
>> Kami kemudian memeriksa untuk melihat apakah pengguna memberi kami masukan yang baik.

213
00:12:53,000 --> 00:12:59,000
Jika itu LIMIT ≥ kami ingin mengembalikan kode kesalahan 1 dan mencetak pesan kesalahan.

214
00:12:59,000 --> 00:13:02,000
Dan akhirnya, masukan jika pengguna telah memberi kita baik

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

216
00:13:08,000 --> 00:13:11,000
Hanya untuk memastikan bahwa mereka semua pulang hit

217
00:13:11,000 --> 00:13:17,000
Anda dapat melihat label dari bagian yang berbeda dari kode di sini.

218
00:13:17,000 --> 00:13:19,000
Saya sebutkan konstan, file header.

219
00:13:19,000 --> 00:13:21,000
Oh, int x. Pastikan untuk mengingat itu adalah variabel lokal.

220
00:13:21,000 --> 00:13:24,000
Yang kontras dari sebuah variabel global, yang akan kita bicarakan

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

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

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

224
00:13:34,000 --> 00:13:37,000
kita tidak akan bisa menelepon printf.

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

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

227
00:13:45,000 --> 00:13:52,000
Dikatakan mencetak variabel ini sebagai d nomor,%.

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

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

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

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

232
00:14:10,000 --> 00:14:14,000
dan aku akan berbicara 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
Seperti Lexi mengatakan, ketika kita mulai menerjemahkan kode Anda dari Gores ke C

235
00:14:19,000 --> 00:14:23,000
salah satu hal yang kita perhatikan adalah bahwa Anda tidak bisa hanya

236
00:14:23,000 --> 00:14:26,000
menulis kode Anda dan menjalankannya menggunakan bendera hijau lagi.

237
00:14:26,000 --> 00:14:30,000
Sebenarnya, Anda harus menggunakan beberapa langkah untuk membuat Anda program C

238
00:14:30,000 --> 00:14:33,000
menjadi file eksekusi.

239
00:14:33,000 --> 00:14:36,000
Pada dasarnya apa yang Anda lakukan ketika Anda sedang menulis sebuah program adalah bahwa

240
00:14:36,000 --> 00:14:40,000
Anda menerjemahkan ide Anda ke dalam bahasa yang kompilator dapat mengerti,

241
00:14:40,000 --> 00:14:44,000
jadi ketika Anda sedang menulis sebuah program dalam C

242
00:14:44,000 --> 00:14:47,000
apa yang Anda lakukan adalah benar-benar menulis sesuatu yang kompiler Anda akan mengerti,

243
00:14:47,000 --> 00:14:50,000
dan kemudian compiler akan menerjemahkan kode yang

244
00:14:50,000 --> 00:14:53,000
menjadi sesuatu yang komputer Anda akan mengerti.

245
00:14:53,000 --> 00:14:55,000
>> Dan hal ini, komputer Anda sebenarnya sangat bodoh.

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

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

248
00:15:01,000 --> 00:15:04,000
menggunakan 0s dan 1s, tapi sekarang tidak lagi, terima kasih Tuhan.

249
00:15:04,000 --> 00:15:07,000
Kami tidak harus menghafal urutan 0s dan 1s untuk

250
00:15:07,000 --> 00:15:10,000
untuk untuk loop atau while loop dan sebagainya.

251
00:15:10,000 --> 00:15:13,000
Itulah mengapa kita memiliki sebuah kompiler.

252
00:15:13,000 --> 00:15:17,000
Apa compiler yang dilakukan adalah pada dasarnya menerjemahkan kode C,

253
00:15:17,000 --> 00:15:21,000
dalam kasus kami, dengan bahasa bahwa komputer Anda akan mengerti,

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

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

256
00:15:30,000 --> 00:15:33,000
Bila Anda memiliki program Anda, Anda harus melakukan 2 hal.

257
00:15:33,000 --> 00:15:37,000
Pertama, Anda harus mengkompilasi program Anda, dan kemudian Anda akan menjalankan program Anda.

258
00:15:37,000 --> 00:15:41,000
Untuk mengkompilasi program Anda, Anda memiliki banyak pilihan untuk melakukannya.

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

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 hal ini Anda dapat melihat mereka hanya mengatakan "Hei, mengkompilasi program saya."

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

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

264
00:15:58,000 --> 00:16:02,000
Anda dapat mengatakan dentang-o dan kemudian nama yang Anda inginkan

265
00:16:02,000 --> 00:16:06,000
file executable yang akan dinamakan sebagai dan kemudian program.c.

266
00:16:06,000 --> 00:16:11,000
Dan Anda juga dapat melakukan membuat program, dan melihat bagaimana dalam 2 kasus pertama

267
00:16:11,000 --> 00:16:15,000
Aku menaruh c,. Dan yang ketiga saya hanya memiliki program?

268
00:16:15,000 --> 00:16:18,000
Ya, Anda benar-benar tidak perlu menempatkan c ketika Anda menggunakan make..

269
00:16:18,000 --> 00:16:22,000
Jika compiler sebenarnya akan berteriak pada Anda.

270
00:16:22,000 --> 00:16:24,000
Dan juga, saya tidak tahu apakah kalian ingat,

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

272
00:16:29,000 --> 00:16:31,000
Itu disebut menghubungkan.

273
00:16:31,000 --> 00:16:35,000
Itu hanya memberitahu compiler bahwa Anda akan menggunakan orang-orang perpustakaan di sana,

274
00:16:35,000 --> 00:16:39,000
jadi jika Anda ingin menggunakan cs50.h Anda benar-benar harus mengetikkan

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

276
00:16:43,000 --> 00:16:45,000
Jika Anda tidak melakukan itu, compiler tidak akan tahu

277
00:16:45,000 --> 00:16:50,000
bahwa Anda menggunakan fungsi-fungsi di cs50.h.

278
00:16:50,000 --> 00:16:52,000
Dan ketika Anda ingin menjalankan program Anda, Anda memiliki 2 pilihan.

279
00:16:52,000 --> 00:16:57,000
Jika Anda melakukan program.c dentang Anda tidak memberikan nama untuk program anda.

280
00:16:57,000 --> 00:17:01,000
Anda harus menjalankannya dengan menggunakan / a.out..

281
00:17:01,000 --> 00:17:06,000
A.out adalah nama standar yang dentang memberikan program Anda jika Anda tidak memberikan nama.

282
00:17:06,000 --> 00:17:11,000
Jika tidak, Anda akan melakukan / program. Jika Anda memberi nama untuk program anda,

283
00:17:11,000 --> 00:17:15,000
dan juga jika Anda memang membuat nama program yang program akan mendapatkan

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

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

286
00:17:26,000 --> 00:17:31,000
>> Pada dasarnya tipe data adalah hal yang sama seperti kotak-kotak kecil yang mereka gunakan

287
00:17:31,000 --> 00:17:35,000
untuk menyimpan nilai-nilai, sehingga tipe data sebenarnya seperti Pokemons.

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

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

290
00:17:43,000 --> 00:17:46,000
Ukuran data sebenarnya tergantung pada arsitektur mesin.

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

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

293
00:17:53,000 --> 00:17:56,000
tetapi jika Anda benar-benar coding Anda Mac atau Windows juga

294
00:17:56,000 --> 00:17:59,000
Mungkin Anda akan memiliki mesin 64-bit,

295
00:17:59,000 --> 00:18:03,000
jadi ingat bahwa ukuran data bahwa aku 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 sebuah int,

298
00:18:08,000 --> 00:18:10,000
yang cukup sederhana.

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 karakter, char.

301
00:18:16,000 --> 00:18:20,000
Jika Anda ingin menggunakan huruf atau simbol kecil Anda mungkin akan menggunakan char.

302
00:18:20,000 --> 00:18:26,000
Char A memiliki 1 byte, yang berarti 8 bit, seperti kata Lexi.

303
00:18:26,000 --> 00:18:31,000
Pada dasarnya kita memiliki Tabel ASCII yang memiliki 256

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

305
00:18:34,000 --> 00:18:37,000
dan kemudian ketika Anda mengetik sebuah char itu akan menerjemahkan

306
00:18:37,000 --> 00:18:44,000
karakter yang Anda masukan nomor yang Anda miliki dalam tabel ASCII, seperti kata Lexi.

307
00:18:44,000 --> 00:18:48,000
Kami juga memiliki float, yang kita gunakan untuk menyimpan angka desimal.

308
00:18:48,000 --> 00:18:53,000
Jika Anda ingin memilih 3,14, misalnya, Anda akan menggunakan pelampung

309
00:18:53,000 --> 00:18:55,000
atau ganda yang memiliki lebih presisi.

310
00:18:55,000 --> 00:18:57,000
Sebuah float memiliki 4 byte.

311
00:18:57,000 --> 00:19:01,000
Ganda A memiliki 8 byte, sehingga satu-satunya perbedaan adalah presisi.

312
00:19:01,000 --> 00:19:04,000
Kami juga memiliki panjang yang digunakan untuk bilangan bulat,

313
00:19:04,000 --> 00:19:09,000
dan Anda bisa melihat mesin 32-bit int dan panjang memiliki ukuran yang sama,

314
00:19:09,000 --> 00:19:13,000
sehingga tidak benar-benar masuk akal untuk menggunakan panjang di mesin 32-bit.

315
00:19:13,000 --> 00:19:17,000
>> Tapi jika Anda menggunakan mesin Mac dan 64-bit, sebenarnya memiliki ukuran panjang 8,

316
00:19:17,000 --> 00:19:19,000
sehingga benar-benar tergantung pada arsitektur.

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

318
00:19:22,000 --> 00:19:25,000
Dan kemudian lama, di sisi lain, memiliki 8 byte,

319
00:19:25,000 --> 00:19:30,000
sehingga sangat baik jika Anda ingin memiliki sebuah integer lagi.

320
00:19:30,000 --> 00:19:34,000
Dan akhirnya, kita memiliki string, yang sebenarnya adalah sebuah char *,

321
00:19:34,000 --> 00:19:37,000
yang merupakan pointer ke char.

322
00:19:37,000 --> 00:19:40,000
Ini sangat mudah untuk berpikir bahwa ukuran string akan menjadi seperti

323
00:19:40,000 --> 00:19:42,000
jumlah karakter yang telah ada,

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

325
00:19:45,000 --> 00:19:49,000
memiliki ukuran pointer ke char, yaitu 4 byte.

326
00:19:49,000 --> 00:19:52,000
Ukuran char * adalah 4 byte.

327
00:19:52,000 --> 00:19:56,000
Tidak masalah jika Anda memiliki sebuah kata kecil atau surat atau apa pun.

328
00:19:56,000 --> 00:19:58,000
Ini akan menjadi 4 byte.

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

330
00:20:01,000 --> 00:20:04,000
sehingga Anda dapat melihat, jika Anda memiliki, misalnya, sebuah 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
apakah kalian tahu apa itu akan mencetak pada layar?

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

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

335
00:20:16,000 --> 00:20:20,000
Ketika Anda melakukan 3/2 itu akan mendapatkan 1,5,

336
00:20:20,000 --> 00:20:24,000
tapi karena kita menggunakan integer itu akan mengabaikan bagian desimal,

337
00:20:24,000 --> 00:20:26,000
dan Anda akan memiliki 1.

338
00:20:26,000 --> 00:20:29,000
Jika Anda tidak ingin hal itu terjadi apa yang dapat Anda lakukan, misalnya,

339
00:20:29,000 --> 00:20:33,000
adalah mendeklarasikan pelampung y = x.

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

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

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

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

344
00:20:55,000 --> 00:20:58,000
dan Anda akan mendapatkan 1,5.

345
00:20:58,000 --> 00:21:06,000
Dan kita memiliki f .2 hanya untuk meminta 2 unit desimal di bagian desimal.

346
00:21:06,000 --> 00:21:12,000
Jika Anda memiliki .3 f itu akan telah benar-benar 1.500.

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

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

349
00:21:18,000 --> 00:21:22,000
Jika Anda melakukan float x = 3,14 x dan kemudian Anda printf

350
00:21:22,000 --> 00:21:24,000
Anda akan mendapatkan 3,14.

351
00:21:24,000 --> 00:21:29,000
Dan jika Anda melakukan x = int x,

352
00:21:29,000 --> 00:21:34,000
yang berarti memperlakukan x sebagai int dan Anda mencetak x sekarang

353
00:21:34,000 --> 00:21:36,000
Anda akan memiliki 3,00.

354
00:21:36,000 --> 00:21:38,000
Apakah itu masuk akal?

355
00:21:38,000 --> 00:21:41,000
Karena Anda pertama memperlakukan x sebagai integer, sehingga Anda mengabaikan bagian desimal,

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 dapat melakukan hal ini,

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

359
00:21:52,000 --> 00:21:56,000
dan kemudian jika Anda mencetak c Anda benar-benar akan mendapatkan

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
adalah menerjemahkan bilangan bulat ke dalam karakter,

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

363
00:22:05,000 --> 00:22:08,000
Kami juga berbicara tentang operator matematika.

364
00:22:08,000 --> 00:22:14,000
Kebanyakan dari mereka adalah cukup sederhana, sehingga +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
dan juga kita berbicara tentang mod, yang merupakan sisa dari sebuah divisi dari 2 angka.

366
00:22:20,000 --> 00:22:23,000
Jika Anda memiliki 10% 3, misalnya,

367
00:22:23,000 --> 00:22:27,000
itu berarti membagi 10 dengan 3, dan apa sisanya?

368
00:22:27,000 --> 00:22:30,000
Ini akan menjadi 1, sehingga benar-benar sangat berguna bagi banyak program.

369
00:22:30,000 --> 00:22:38,000
Untuk Vigenère dan Caesar Aku cukup yakin bahwa semua dari kalian menggunakan mod.

370
00:22:38,000 --> 00:22:43,000
Tentang operator matematika, sangat berhati-hati ketika menggabungkan * dan /.

371
00:22:43,000 --> 00:22:48,000
>> Misalnya, jika Anda melakukan (3/2) * 2 apa yang Anda akan mendapatkan?

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

373
00:22:50,000 --> 00:22:54,000
Ya, 2, karena 3/2 akan menjadi 1,5,

374
00:22:54,000 --> 00:22:57,000
tapi karena Anda melakukan operasi antara 2 bilangan bulat

375
00:22:57,000 --> 00:22:59,000
Anda benar-benar hanya akan 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
ketika melakukan aritmatika dengan bilangan bulat karena

378
00:23:07,000 --> 00:23:12,000
Anda mungkin mendapatkan 2 = 3, dalam kasus itu.

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

380
00:23:14,000 --> 00:23:21,000
Anda biasanya harus menggunakan tanda kurung untuk memastikan bahwa Anda tahu apa yang Anda lakukan.

381
00:23:21,000 --> 00:23:27,000
Beberapa cara pintas yang berguna, tentu saja, satu adalah 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 hal yang sama seperti melakukan i = i + 1.

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

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

386
00:23:42,000 --> 00:23:46,000
sesuatu yang kalian gunakan banyak dalam untuk loop, setidaknya.

387
00:23:46,000 --> 00:23:52,000
Juga, untuk *, jika Anda menggunakan * = dan jika Anda melakukannya, misalnya,

388
00:23:52,000 --> 00:23:57,000
i * = 2 adalah hal yang sama dengan mengatakan i = i * 2,

389
00:23:57,000 --> 00:23:59,000
dan hal yang sama untuk divisi.

390
00:23:59,000 --> 00:24:08,000
Jika Anda melakukannya i / = 2 itu adalah hal 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 mengetahui bahwa fungsi strategi yang sangat baik untuk menyimpan kode

393
00:24:13,000 --> 00:24:16,000
saat Anda sedang pemrograman, jadi jika Anda ingin melakukan tugas yang sama

394
00:24:16,000 --> 00:24:20,000
dalam kode lagi dan lagi, mungkin Anda ingin menggunakan fungsi

395
00:24:20,000 --> 00:24:25,000
hanya sehingga Anda tidak perlu copy dan paste kode berulang-ulang.

396
00:24:25,000 --> 00:24:28,000
Sebenarnya, fungsi utama adalah, dan ketika saya menunjukkan format dari suatu fungsi

397
00:24:28,000 --> 00:24:32,000
Anda akan melihat bahwa 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
Misalnya, printf, GetIn, yaitu 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 yang benar-benar diterapkan di perpustakaan lain,

402
00:24:46,000 --> 00:24:49,000
dan ketika Anda meletakkan file-file tether di awal program Anda

403
00:24:49,000 --> 00:24:53,000
Anda katakan bisa tolong beri saya kode untuk fungsi-fungsi

404
00:24:53,000 --> 00:24:57,000
jadi saya tidak perlu menerapkannya sendiri?

405
00:24:57,000 --> 00:25:00,000
Dan Anda juga dapat menulis fungsi sendiri, jadi ketika Anda memulai pemrograman

406
00:25:00,000 --> 00:25:04,000
Anda menyadari bahwa perpustakaan tidak memiliki semua fungsi yang Anda butuhkan.

407
00:25:04,000 --> 00:25:10,000
Untuk pset lalu, misalnya, kita menulis menggambar, berebut, dan lookup,

408
00:25:10,000 --> 00:25:13,000
dan itu sangat, sangat penting untuk dapat menulis fungsi

409
00:25:13,000 --> 00:25:17,000
karena mereka berguna, dan kami menggunakannya sepanjang waktu dalam pemrograman,

410
00:25:17,000 --> 00:25:19,000
dan menghemat banyak kode.

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

412
00:25:21,000 --> 00:25:24,000
Kami memiliki tipe kembali di awal. Apa jenis kembali?

413
00:25:24,000 --> 00:25:27,000
Hanya saja ketika fungsi Anda akan kembali.

414
00:25:27,000 --> 00:25:29,000
Jika Anda memiliki fungsi, misalnya, faktorial,

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

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

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

418
00:25:37,000 --> 00:25:41,000
Printf sebenarnya memiliki tipe void kembali

419
00:25:41,000 --> 00:25:43,000
karena Anda tidak kembali apa-apa.

420
00:25:43,000 --> 00:25:45,000
Kau hanya mencetak hal-hal ke layar

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

422
00:25:48,000 --> 00:25:51,000
Kemudian Anda memiliki nama fungsi yang dapat Anda pilih.

423
00:25:51,000 --> 00:25:55,000
Anda harus sedikit akal, 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
Cobalah untuk membuat nama yang masuk akal.

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

427
00:26:04,000 --> 00:26:08,000
Jika itu adalah fungsi yang akan menggambar sesuatu, nama itu menarik.

428
00:26:08,000 --> 00:26:11,000
Dan kemudian kita memiliki parameter, yang juga disebut argumen,

429
00:26:11,000 --> 00:26:14,000
yang seperti sumber daya yang fungsi Anda membutuhkan

430
00:26:14,000 --> 00:26:17,000
dari kode Anda untuk melakukan tugasnya.

431
00:26:17,000 --> 00:26:20,000
Jika Anda ingin menghitung faktorial dari angka

432
00:26:20,000 --> 00:26:23,000
Mungkin Anda harus memiliki nomor untuk menghitung faktorial.

433
00:26:23,000 --> 00:26:27,000
Salah satu argumen yang Anda akan miliki adalah nomor sendiri.

434
00:26:27,000 --> 00:26:31,000
Dan kemudian itu akan melakukan sesuatu dan mengembalikan nilai di akhir

435
00:26:31,000 --> 00:26:35,000
kecuali jika fungsi void.

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

437
00:26:37,000 --> 00:26:40,000
Jika saya ingin menulis fungsi yang merangkum semua angka dalam sebuah array bilangan bulat,

438
00:26:40,000 --> 00:26:43,000
pertama-tama, jenis kembali akan menjadi int

439
00:26:43,000 --> 00:26:46,000
karena saya memiliki sebuah array bilangan bulat.

440
00:26:46,000 --> 00:26:51,000
Dan kemudian aku akan memiliki nama fungsi seperti sumArray,

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

442
00:26:54,000 --> 00:26:58,000
dan kemudian panjang dari array jadi saya tahu berapa banyak angka yang saya harus jumlah.

443
00:26:58,000 --> 00:27:02,000
Lalu aku harus menginisialisasi sejumlah variabel yang disebut, misalnya, untuk 0,

444
00:27:02,000 --> 00:27:08,000
dan setiap kali aku melihat sebuah elemen dalam array saya harus menambahkannya ke sum, jadi saya lakukan untuk loop.

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

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

447
00:27:20,000 --> 00:27:24,000
dan kemudian saya kembali jumlahnya, sehingga sangat sederhana, dan menghemat banyak kode

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 kondisi.

450
00:27:32,000 --> 00:27:38,000
Kami memiliki if, else, dan lain jika.

451
00:27:38,000 --> 00:27:42,000
Mari kita lihat apa perbedaan antara mereka.

452
00:27:42,000 --> 00:27:45,000
Lihatlah ini 2 kode. Apa perbedaan antara mereka?

453
00:27:45,000 --> 00:27:49,000
Yang pertama telah-dasarnya kode ingin kau mengatakan

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

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

456
00:27:55,000 --> 00:28:00,000
Jika itu = ke 0 maka itu 0, dan jika <0 maka hasilnya negatif.

457
00:28:00,000 --> 00:28:04,000
>> Dan yang lain lakukan if, else if, else.

458
00:28:04,000 --> 00:28:07,000
Perbedaan antara keduanya adalah bahwa yang satu ini benar-benar akan

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

460
00:28:13,000 --> 00:28:17,000
jadi jika Anda memiliki nomor 2, misalnya, itu akan datang ke sini dan mengatakan

461
00:28:17,000 --> 00:28:21,000
if (x> 0), dan itu akan mengatakan ya, jadi saya mencetak positif.

462
00:28:21,000 --> 00:28:25,000
Tapi meskipun aku tahu bahwa itu> 0 dan itu tidak akan menjadi 0 atau <0

463
00:28:25,000 --> 00:28:29,000
Aku masih akan lakukan itu 0, apakah <0,

464
00:28:29,000 --> 00:28:33,000
jadi aku benar-benar akan dalam ifs bahwa saya tidak perlu

465
00:28:33,000 --> 00:28:38,000
karena saya sudah tahu bahwa itu tidak akan memenuhi salah satu kondisi.

466
00:28:38,000 --> 00:28:41,000
Saya bisa menggunakan if, else if, else pernyataan.

467
00:28:41,000 --> 00:28:45,000
Pada dasarnya mengatakan jika x = 0 Saya mencetak positif.

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

469
00:28:48,000 --> 00:28:51,000
Jika itu 2 tidak aku akan melakukan hal ini.

470
00:28:51,000 --> 00:28:54,000
Pada dasarnya jika saya memiliki x = 2 Anda akan mengatakan

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

472
00:28:57,000 --> 00:29:00,000
Sekarang saya tahu bahwa itu> 0 dan itu puas pertama jika

473
00:29:00,000 --> 00:29:02,000
Aku bahkan tidak akan menjalankan kode ini.

474
00:29:02,000 --> 00:29:09,000
Kode 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 dan atau.

476
00:29:11,000 --> 00:29:15,000
Aku tidak akan pergi melalui ini karena Lexi sudah berbicara tentang mereka.

477
00:29:15,000 --> 00:29:17,000
Ini hanya && dan operator | |.

478
00:29:17,000 --> 00:29:21,000
>> Satu-satunya hal saya akan katakan adalah berhati-hati ketika Anda memiliki 3 kondisi.

479
00:29:21,000 --> 00:29:24,000
Gunakan tanda kurung karena itu sangat membingungkan ketika Anda memiliki kondisi

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 tanda kurung hanya untuk memastikan bahwa kondisi Anda masuk akal

482
00:29:30,000 --> 00:29:34,000
karena dalam kasus itu, misalnya, Anda dapat membayangkan bahwa

483
00:29:34,000 --> 00:29:38,000
bisa jadi kondisi pertama dan satu atau yang lain

484
00:29:38,000 --> 00:29:41,000
atau 2 kondisi gabungan dalam dan

485
00:29:41,000 --> 00:29:45,000
atau yang ketiga, jadi berhati-hatilah.

486
00:29:45,000 --> 00:29:48,000
Dan akhirnya, kami berbicara tentang switch.

487
00:29:48,000 --> 00:29:53,000
Switch adalah sangat berguna ketika Anda memiliki variabel.

488
00:29:53,000 --> 00:29:55,000
Mari kita mengatakan bahwa Anda memiliki variabel seperti n

489
00:29:55,000 --> 00:29:59,000
yang bisa 0, 1, atau 2, dan untuk masing-masing kasus

490
00:29:59,000 --> 00:30:01,000
Anda akan melakukan tugas.

491
00:30:01,000 --> 00:30:04,000
Anda dapat mengatakan beralih variabel, dan itu menunjukkan bahwa

492
00:30:04,000 --> 00:30:08,000
Nilai kemudian seperti nilai1 Aku akan melakukan hal ini,

493
00:30:08,000 --> 00:30:12,000
dan kemudian saya putuskan, yang berarti aku tidak akan melihat salah satu kasus lain

494
00:30:12,000 --> 00:30:15,000
karena kita sudah puas kasus

495
00:30:15,000 --> 00:30:20,000
dan kemudian nilai2 dan sebagainya, dan saya juga dapat memiliki tombol default.

496
00:30:20,000 --> 00:30:24,000
Itu berarti jika tidak memenuhi salah satu kasus yang saya punya

497
00:30:24,000 --> 00:30:29,000
bahwa aku akan melakukan sesuatu yang lain, tapi itu opsional.

498
00:30:29,000 --> 00:30:36,000
Itu semua untuk 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 kami akan meliputi, kripto, ruang lingkup, array, dan sebagainya.

501
00:30:45,000 --> 00:30:49,000
Hanya kata cepat pada kripto. Kami tidak akan palu rumah ini.

502
00:30:49,000 --> 00:30:52,000
>> Kami melakukan ini di pset 2, tapi untuk kuis pastikan Anda tahu bedanya

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 dari mereka yang bekerja cipher dan bagaimana rasanya untuk mengenkripsi

505
00:30:57,000 --> 00:30:59,000
dan mendekripsi teks yang menggunakan 2 cipher.

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

507
00:31:03,000 --> 00:31:06,000
pastikan Anda mod dengan jumlah huruf dalam alfabet.

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

509
00:31:09,000 --> 00:31:12,000
dengan jumlah yang berbeda, jadi daripada mengatakan

510
00:31:12,000 --> 00:31:15,000
diputar setiap karakter dengan 3 Vigenère akan berputar setiap karakter

511
00:31:15,000 --> 00:31:17,000
dengan jumlah yang berbeda tergantung pada kata kunci tertentu

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

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

514
00:31:26,000 --> 00:31:28,000
Mari kita pertama berbicara tentang ruang lingkup variabel.

515
00:31:28,000 --> 00:31:30,000
Ada 2 jenis variabel.

516
00:31:30,000 --> 00:31:33,000
Kami memiliki variabel lokal, dan ini akan didefinisikan

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

518
00:31:36,000 --> 00:31:39,000
dan ini akan dapat diakses di mana saja dalam program Anda.

519
00:31:39,000 --> 00:31:41,000
Jika Anda memiliki fungsi dan fungsi yang merupakan loop sementara

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

521
00:31:44,000 --> 00:31:48,000
Sebuah variabel lokal, di sisi lain, adalah scoped ke tempat di mana ia didefinisikan.

522
00:31:48,000 --> 00:31:53,000
>> Jika Anda memiliki fungsi di sini, misalnya, kita memiliki fungsi g,

523
00:31:53,000 --> 00:31:56,000
dan dalam g ada variabel di sini disebut y,

524
00:31:56,000 --> 00:31:58,000
dan itu berarti bahwa ini adalah variabel lokal.

525
00:31:58,000 --> 00:32:00,000
Meskipun variabel ini disebut y

526
00:32:00,000 --> 00:32:03,000
dan variabel ini disebut y ini 2 fungsi

527
00:32:03,000 --> 00:32:06,000
tidak tahu apa variabel lokal masing-masing berada.

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

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

530
00:32:12,000 --> 00:32:16,000
Ini adalah di luar lingkup utama, jadi ini adalah variabel global.

531
00:32:16,000 --> 00:32:20,000
Itu berarti bahwa di dalam dari 2 fungsi ketika saya mengatakan x - atau x + +

532
00:32:20,000 --> 00:32:26,000
Saya mengakses x sama dimana ini y dan y ini adalah variabel yang berbeda.

533
00:32:26,000 --> 00:32:30,000
Itulah perbedaan antara variabel global dan variabel lokal.

534
00:32:30,000 --> 00:32:33,000
Sejauh desain yang bersangkutan, kadang-kadang itu mungkin ide yang lebih baik

535
00:32:33,000 --> 00:32:37,000
untuk menjaga variabel lokal setiap kali Anda mungkin bisa

536
00:32:37,000 --> 00:32:39,000
karena memiliki banyak variabel global bisa benar-benar membingungkan.

537
00:32:39,000 --> 00:32:42,000
Jika Anda memiliki banyak fungsi semua memodifikasi hal yang sama

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

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

540
00:32:47,000 --> 00:32:50,000
dan itu tidak bisa cukup membingungkan karena Anda mendapatkan lebih banyak kode.

541
00:32:50,000 --> 00:32:53,000
Menjaga variabel lokal setiap kali Anda mungkin bisa

542
00:32:53,000 --> 00:32:56,000
adalah desain hanya baik.

543
00:32:56,000 --> 00:33:00,000
Array, ingat, hanya daftar elemen dari jenis yang sama.

544
00:33:00,000 --> 00:33:04,000
Di dalam CI tidak bisa memiliki daftar seperti 1, 2,0, halo.

545
00:33:04,000 --> 00:33:06,000
Kami hanya tidak bisa melakukan itu.

546
00:33:06,000 --> 00:33:11,000
>> Ketika kita mendeklarasikan array di C semua elemen harus dari jenis yang sama.

547
00:33:11,000 --> 00:33:14,000
Di sini saya memiliki sebuah array dari 3 bilangan bulat.

548
00:33:14,000 --> 00:33:18,000
Di sini saya memiliki panjang array, tetapi jika aku hanya menyatakan dalam sintaks ini

549
00:33:18,000 --> 00:33:21,000
di mana saya menentukan apa semua elemen yang saya tidak perlu secara teknis 3 ini.

550
00:33:21,000 --> 00:33:25,000
Compiler cukup pintar untuk mengetahui seberapa besar array harus.

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

552
00:33:28,000 --> 00:33:30,000
ini adalah sintaks untuk melakukan itu.

553
00:33:30,000 --> 00:33:33,000
Ini benar-benar akan mengubah elemen kedua dari array karena, ingat,

554
00:33:33,000 --> 00:33:36,000
penomoran dimulai dari 0, bukan pada 1.

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

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

557
00:33:44,000 --> 00:33:47,000
Saya dapat mengatakan array [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Waktu itu mengakses elemen dengan indeks mereka

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

560
00:33:52,000 --> 00:33:57,000
dan daftar yang dimulai pada 0.

561
00:33:57,000 --> 00:34:00,000
Kami juga dapat memiliki array dari array,

562
00:34:00,000 --> 00:34:03,000
dan ini disebut array multi-dimensi.

563
00:34:03,000 --> 00:34:05,000
Ketika kita memiliki array multi-dimensi

564
00:34:05,000 --> 00:34:07,000
itu berarti kita dapat memiliki sesuatu seperti baris dan kolom,

565
00:34:07,000 --> 00:34:11,000
dan ini adalah salah satu cara untuk memvisualisasikan ini atau berpikir tentang hal itu.

566
00:34:11,000 --> 00:34:14,000
Ketika saya memiliki array multi-dimensi yang berarti aku akan mulai membutuhkan

567
00:34:14,000 --> 00:34:17,000
lebih dari 1 indeks karena jika saya memiliki grid

568
00:34:17,000 --> 00:34:19,000
hanya mengatakan apa baris anda berada di tidak memberi kami nomor.

569
00:34:19,000 --> 00:34:22,000
Itu benar-benar hanya akan memberi kita daftar nomor.

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

571
00:34:25,000 --> 00:34:30,000
Aku punya sebuah array disebut grid, dan saya katakan itu 2 baris dan 3 kolom,

572
00:34:30,000 --> 00:34:32,000
dan jadi ini adalah salah satu cara untuk memvisualisasikan itu.

573
00:34:32,000 --> 00:34:37,000
Ketika saya mengatakan saya ingin mendapatkan elemen pada [1] [2]

574
00:34:37,000 --> 00:34:41,000
yang berarti bahwa karena ini adalah baris pertama dan kemudian kolom

575
00:34:41,000 --> 00:34:44,000
Aku akan melompat ke baris 1 karena aku berkata 1.

576
00:34:44,000 --> 00:34:49,000
>> Lalu aku akan datang ke sini ke kolom 2, dan aku akan mendapatkan nilai 6.

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

578
00:34:51,000 --> 00:34:55,000
Multi-dimensi array, ingat, secara teknis hanya sebuah array dari array.

579
00:34:55,000 --> 00:34:57,000
Kita dapat memiliki array dari array dari array.

580
00:34:57,000 --> 00:35:00,000
Kita bisa terus, tapi benar-benar salah satu cara untuk berpikir tentang

581
00:35:00,000 --> 00:35:03,000
bagaimana ini sedang ditata dan apa yang terjadi adalah untuk memvisualisasikan

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

583
00:35:09,000 --> 00:35:12,000
Ketika kami melewati array ke fungsi, mereka akan berperilaku

584
00:35:12,000 --> 00:35:16,000
sedikit berbeda dari ketika kami melewati variabel reguler untuk fungsi

585
00:35:16,000 --> 00:35:18,000
seperti lewat sebuah int atau float.

586
00:35:18,000 --> 00:35:21,000
Ketika kita lulus dalam tipe int atau char atau salah satu data lain

587
00:35:21,000 --> 00:35:24,000
kami hanya mengambil melihat apakah fungsi memodifikasi

588
00:35:24,000 --> 00:35:28,000
nilai variabel bahwa perubahan tidak akan menyebarkan up

589
00:35:28,000 --> 00:35:32,000
untuk fungsi panggilan.

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

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

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

593
00:35:43,000 --> 00:35:47,000
array saya sekarang akan berbeda, dan kosa kata untuk itu

594
00:35:47,000 --> 00:35:50,000
array adalah tersebut diteruskan oleh referensi, seperti yang akan kita lihat nanti.

595
00:35:50,000 --> 00:35:53,000
Hal ini terkait dengan bagaimana kerja pointer, di mana jenis data dasar,

596
00:35:53,000 --> 00:35:55,000
di sisi lain, yang disahkan oleh nilai.

597
00:35:55,000 --> 00:35:59,000
>> Kita bisa memikirkan bahwa sebagai membuat salinan beberapa variabel dan kemudian melewati di copy.

598
00:35:59,000 --> 00:36:01,000
Tidak peduli apa yang kita lakukan dengan variabel itu.

599
00:36:01,000 --> 00:36:06,000
Pemanggilan fungsi tidak akan menyadari bahwa itu berubah.

600
00:36:06,000 --> 00:36:10,000
Array hanya sedikit berbeda dalam hal itu.

601
00:36:10,000 --> 00:36:13,000
Misalnya, seperti yang kita hanya melihat, utamanya hanyalah fungsi

602
00:36:13,000 --> 00:36:15,000
yang dapat mengambil dalam 2 argumen.

603
00:36:15,000 --> 00:36:20,000
Argumen pertama yang fungsi utamanya adalah argc, atau jumlah argumen,

604
00:36:20,000 --> 00:36:23,000
dan argumen kedua disebut argv,

605
00:36:23,000 --> 00:36:27,000
dan mereka adalah nilai yang sebenarnya dari argumen-argumen.

606
00:36:27,000 --> 00:36:30,000
Katakanlah saya memiliki program yang disebut this.c,

607
00:36:30,000 --> 00:36:34,000
dan saya katakan membuat ini, dan aku akan menjalankan ini pada baris perintah.

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

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

610
00:36:42,000 --> 00:36:45,000
Ini adalah apa yang kita bayangkan David harus dilakukan setiap hari di terminal.

611
00:36:45,000 --> 00:36:48,000
Tapi sekarang di dalam fungsi utama dari program yang

612
00:36:48,000 --> 00:36:52,000
memiliki nilai-nilai, sehingga argc adalah 4.

613
00:36:52,000 --> 00:36:56,000
Ini mungkin sedikit membingungkan karena benar-benar kami hanya lewat di cs adalah 50.

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

615
00:36:58,000 --> 00:37:02,000
Tapi ingat bahwa elemen pertama dari argv atau argumen pertama

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

617
00:37:05,000 --> 00:37:07,190
Jadi itu berarti bahwa kita memiliki 4 hal 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 string.

620
00:37:12,970 --> 00:37:18,590
Kemudian elemen yang tersisa adalah apa yang kita mengetik setelah nama program.

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

622
00:37:22,720 --> 00:37:28,780
ingat bahwa string adalah 50 ≠ 50 integer.

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

624
00:37:32,520 --> 00:37:36,470
>> Itu hanya tidak akan masuk akal, karena ini adalah string, dan ini adalah bilangan bulat.

625
00:37:36,470 --> 00:37:38,510
Jadi jika Anda ingin mengkonversi antara 2 ini, ingat, kita akan

626
00:37:38,510 --> 00:37:40,810
memiliki fungsi sihir yang disebut atoi.

627
00:37:40,810 --> 00:37:46,270
Yang mengambil string dan mengembalikan integer diwakili dalam string tersebut.

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

629
00:37:48,360 --> 00:37:51,590
hanya berpikir bahwa ini otomatis akan menjadi jenis yang tepat.

630
00:37:51,590 --> 00:37:53,860
Tapi hanya tahu bahwa ini akan selalu string

631
00:37:53,860 --> 00:38:00,920
bahkan jika string hanya berisi integer atau karakter atau pelampung.

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

633
00:38:03,380 --> 00:38:06,700
Ketika kita memiliki semua algoritma ini yang melakukan semua hal-hal gila,

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

635
00:38:11,580 --> 00:38:15,500
Kami menyatakan bahwa dengan sesuatu yang disebut notasi asimtotik.

636
00:38:15,500 --> 00:38:18,430
Jadi ini berarti bahwa - baik, katakanlah kita memberikan algoritma

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

638
00:38:20,840 --> 00:38:23,840
Kami ingin bertanya, "Berapa lama itu akan berlangsung?

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

640
00:38:26,370 --> 00:38:29,980
sebagai fungsi dari ukuran masukan? "

641
00:38:29,980 --> 00:38:33,080
Jadi cara pertama kita dapat menggambarkan waktu dijalankan adalah dengan big O.

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

643
00:38:35,380 --> 00:38:38,590
Jadi jika kita ingin mengurutkan array, dan kami memberikan algoritma kami array

644
00:38:38,590 --> 00:38:41,000
yang ada di urutan ketika harus dalam urutan menaik,

645
00:38:41,000 --> 00:38:43,130
itu akan menjadi kasus terburuk.

646
00:38:43,130 --> 00:38:49,800
Ini adalah atas kami terikat dalam jangka waktu maksimal algoritma kami akan mengambil.

647
00:38:49,800 --> 00:38:54,740
Di sisi lain, ini Ω akan menjelaskan kasus terbaik waktu berjalan.

648
00:38:54,740 --> 00:38:58,210
Jadi, jika kita memberikan sebuah array yang sudah diurutkan dengan algoritma sorting,

649
00:38:58,210 --> 00:39:00,940
berapa lama waktu yang dibutuhkan untuk semacam itu?

650
00:39:00,940 --> 00:39:06,610
Dan ini, maka, menggambarkan batas bawah pada waktu berjalan.

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

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

653
00:39:13,120 --> 00:39:16,060
Waktu tercepat berjalan kita miliki disebut konstan.

654
00:39:16,060 --> 00:39:19,800
>> Itu berarti tidak peduli berapa banyak elemen yang kita berikan algoritma kami,

655
00:39:19,800 --> 00:39:22,280
tidak peduli seberapa besar array kita adalah, menyortir itu

656
00:39:22,280 --> 00:39:26,510
atau melakukan apa pun yang kita lakukan untuk array akan selalu mengambil jumlah waktu yang sama.

657
00:39:26,510 --> 00:39:30,270
Jadi kita bisa menyatakan bahwa hanya dengan 1, yang merupakan konstanta.

658
00:39:30,270 --> 00:39:32,410
Kami juga melihat pada waktu berjalan logaritmik.

659
00:39:32,410 --> 00:39:34,800
Jadi sesuatu seperti pencarian biner adalah logaritmik,

660
00:39:34,800 --> 00:39:37,140
di mana kita memotong masalah dalam setengah setiap kali

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

662
00:39:40,970 --> 00:39:43,580
Dan jika Anda pernah menulis sebuah O dari setiap algoritma faktorial,

663
00:39:43,580 --> 00:39:47,850
Anda mungkin tidak harus mempertimbangkan ini sebagai pekerjaan anda.

664
00:39:47,850 --> 00:39:53,910
Ketika kita bandingkan kali menjalankannya penting untuk diingat hal-hal ini.

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

666
00:39:57,760 --> 00:40:03,590
memiliki algoritma O (2n) ini sebenarnya asimtotik setara.

667
00:40:03,590 --> 00:40:06,590
Jadi jika kita membayangkan n menjadi jumlah yang besar seperti sebelas miliar:

668
00:40:06,590 --> 00:40:13,090
jadi ketika kita membandingkan sebelas miliar untuk sesuatu seperti sebelas miliar + 3,

669
00:40:13,090 --> 00:40:17,640
tiba-tiba +3 itu tidak benar-benar membuat perbedaan besar lagi.

670
00:40:17,640 --> 00:40:20,980
Itulah sebabnya kita akan mulai mempertimbangkan hal-hal untuk menjadi setara.

671
00:40:20,980 --> 00:40:24,220
So hal-hal seperti ini konstanta sini, ada 2 x ini, atau menambahkan 3,

672
00:40:24,220 --> 00:40:27,180
ini hanya konstanta, dan ini akan turun naik.

673
00:40:27,180 --> 00:40:32,480
Jadi itulah mengapa semua 3 ini kali run adalah sama dengan mengatakan mereka O (n).

674
00:40:32,480 --> 00:40:37,490
Demikian pula, jika kita memiliki 2 kali run lain, katakanlah O (n + 2n ² ³), kita dapat menambahkan

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, dan kemudian kita memiliki waktu berjalan itu hanya O (n ³).

676
00:40:42,070 --> 00:40:46,290
lagi, ini adalah hal yang sama karena ini - ini adalah tidak sama.

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

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

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

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

681
00:41:02,820 --> 00:41:05,470
Jadi jika kita memiliki eksponen, tiba-tiba ini mulai peduli,

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

683
00:41:08,280 --> 00:41:12,810
maka itu tidak akan menjadi masalah karena mereka hanya akan drop out.

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

685
00:41:16,760 --> 00:41:19,260
dan berbicara tentang waktu berjalan mereka.

686
00:41:19,260 --> 00:41:23,850
Cara pertama mencari nomor dalam daftar, yang kita lihat, adalah pencarian linear.

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

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

689
00:41:30,490 --> 00:41:34,260
sampai kita menemukan nomor yang kita cari.

690
00:41:34,260 --> 00:41:38,370
Jadi itu berarti bahwa dalam kasus terburuk, ini O (n).

691
00:41:38,370 --> 00:41:40,860
Dan kasus terburuk di sini bisa jika elemen adalah

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

693
00:41:45,710 --> 00:41:50,180
hingga sampai yang terakhir untuk mengetahui bahwa itu sebenarnya dalam daftar.

694
00:41:50,180 --> 00:41:52,910
Kita tidak bisa hanya menyerah di tengah jalan dan berkata, "Ini mungkin tidak ada."

695
00:41:52,910 --> 00:41:55,980
Dengan pencarian linear kita harus melihat semuanya.

696
00:41:55,980 --> 00:41:59,090
Waktu berjalan kasus terbaik, di sisi lain, adalah konstan

697
00:41:59,090 --> 00:42:04,200
karena dalam kasus terbaik elemen yang kita cari adalah hanya yang pertama dalam daftar.

698
00:42:04,200 --> 00:42:08,930
Jadi itu akan membawa kita tepat 1 langkah, tidak peduli seberapa besar daftar ini

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

700
00:42:12,140 --> 00:42:15,390
>> Jadi, ketika Anda mencari, ingat, itu tidak mengharuskan daftar kami akan diurutkan.

701
00:42:15,390 --> 00:42:19,430
Karena kita hanya akan melihat lebih setiap elemen tunggal, dan itu tidak terlalu penting

702
00:42:19,430 --> 00:42:23,560
rangka apa unsur-unsur yang masuk

703
00:42:23,560 --> 00:42:28,110
Sebuah algoritma pencarian yang lebih cerdas adalah sesuatu seperti pencarian biner.

704
00:42:28,110 --> 00:42:31,500
Ingat, pelaksanaan pencarian biner adalah ketika Anda akan

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

706
00:42:34,320 --> 00:42:38,000
Dan karena kita sedang melihat tengah, kami mengharuskan daftar diurutkan

707
00:42:38,000 --> 00:42:40,580
atau kita tidak tahu di mana tengah adalah, dan kita harus melihat lebih

708
00:42:40,580 --> 00:42:44,480
seluruh daftar untuk menemukan itu, dan kemudian pada saat itu kami hanya membuang-buang waktu.

709
00:42:44,480 --> 00:42:48,480
Jadi jika kita memiliki daftar diurutkan dan kami menemukan tengah, kita akan membandingkan tengah

710
00:42:48,480 --> 00:42:51,590
ke elemen yang kita cari.

711
00:42:51,590 --> 00:42:54,640
Jika terlalu tinggi, maka kita bisa melupakan kanan setengah

712
00:42:54,640 --> 00:42:57,810
karena kita tahu bahwa jika elemen kita sudah terlalu tinggi

713
00:42:57,810 --> 00:43:01,080
dan segala sesuatu di sebelah kanan elemen ini bahkan 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
Dimana di sisi lain, jika elemen kami terlalu rendah,

716
00:43:05,430 --> 00:43:08,700
kita tahu semuanya ke kiri elemen yang juga terlalu rendah,

717
00:43:08,700 --> 00:43:11,390
sehingga tidak benar-benar masuk akal untuk melihat di sana, baik.

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

719
00:43:15,760 --> 00:43:19,060
kita akan memotong masalah kita di setengah karena tiba-tiba kita tahu

720
00:43:19,060 --> 00:43:23,040
sejumlah angka yang tidak bisa menjadi orang yang kita cari.

721
00:43:23,040 --> 00:43:26,950
>> Dalam pseudocode ini akan terlihat seperti ini,

722
00:43:26,950 --> 00:43:30,990
dan karena kita sedang memotong daftar di setengah setiap saat,

723
00:43:30,990 --> 00:43:34,920
kami terburuk melompat run time dari linier logaritmik.

724
00:43:34,920 --> 00:43:39,260
Begitu tiba-tiba kita memiliki log-in langkah-langkah untuk menemukan elemen dalam daftar.

725
00:43:39,260 --> 00:43:42,460
Waktu berjalan kasus terbaik, meskipun, masih konstan

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

727
00:43:45,180 --> 00:43:48,380
selalu tengah tepat dari daftar asli.

728
00:43:48,380 --> 00:43:52,080
Jadi kita dapat tumbuh daftar kami sebesar seperti yang kita inginkan, tapi jika elemen yang kita cari adalah di tengah,

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

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

731
00:44:00,920 --> 00:44:04,510
Mari kita benar-benar menjalankan pencarian biner pada daftar ini.

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

733
00:44:08,020 --> 00:44:11,650
Hal pertama yang akan kita lakukan adalah menemukan titik tengah dari daftar ini.

734
00:44:11,650 --> 00:44:15,060
Kebetulan bahwa titik tengah akan jatuh antara 2 angka,

735
00:44:15,060 --> 00:44:18,960
jadi mari kita katakan sewenang-wenang, setiap kali titik tengah jatuh antara 2 angka,

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

737
00:44:21,150 --> 00:44:24,330
Kami hanya perlu memastikan bahwa kita melakukan hal ini setiap langkah dari jalan.

738
00:44:24,330 --> 00:44:29,040
Jadi kita akan mengumpulkan, dan kita akan mengatakan bahwa 161 adalah tengah daftar kami.

739
00:44:29,040 --> 00:44:34,640
Jadi 161 <164, dan setiap elemen di sebelah kiri dari 161

740
00:44:34,640 --> 00:44:39,120
juga <164, jadi kita tahu bahwa itu tidak akan membantu kami sama sekali

741
00:44:39,120 --> 00:44:42,690
untuk mulai mencari ke sini karena elemen yang kita cari tidak bisa berada di sana.

742
00:44:42,690 --> 00:44:47,060
Jadi apa yang bisa kita lakukan adalah kita hanya bisa melupakan bahwa kiri setengah seluruh daftar,

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

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

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

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

747
00:44:59,180 --> 00:45:06,610
jadi kami hanya bisa membuang itu pergi, dan akhirnya kita akan memukul 164.

748
00:45:06,610 --> 00:45:10,560
Setiap pertanyaan pada pencarian biner?

749
00:45:10,560 --> 00:45:14,180
Mari kita beralih dari mencari melalui daftar yang sudah diurutkan

750
00:45:14,180 --> 00:45:17,660
untuk benar-benar mengambil daftar nomor dalam urutan apapun

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

752
00:45:20,960 --> 00:45:24,060
Algoritma pertama kita melihat disebut bubble sort.

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

754
00:45:27,300 --> 00:45:32,970
Bubble sort mengatakan bahwa bila ada 2 unsur dalam daftar adalah keluar dari tempat,

755
00:45:32,970 --> 00:45:36,500
berarti ada jumlah yang lebih tinggi di sebelah kiri angka yang lebih rendah,

756
00:45:36,500 --> 00:45:40,190
maka kita akan swap mereka, karena itu berarti bahwa daftar akan

757
00:45:40,190 --> 00:45:42,860
"Lebih diurutkan" daripada sebelumnya.

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

759
00:45:45,180 --> 00:45:52,100
sampai akhirnya jenis unsur gelembung ke lokasi yang benar dan kami memiliki daftar diurutkan.

760
00:45:52,100 --> 00:45:57,230
>> Waktu run ini akan menjadi O (n ²). Kenapa?

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

762
00:46:00,370 --> 00:46:04,570
kita akan berakhir membandingkannya dengan setiap elemen lain dalam daftar.

763
00:46:04,570 --> 00:46:08,030
Tapi dalam kasus terbaik, kami memiliki daftar yang sudah diurutkan, gelembung semacam ini

764
00:46:08,030 --> 00:46:12,230
hanya akan pergi melalui sekali, katakan "Tidak. Aku tidak melakukan swap, jadi saya sudah selesai."

765
00:46:12,230 --> 00:46:17,410
Jadi kami memiliki waktu terbaik-kasus menjalankan Ω (n).

766
00:46:17,410 --> 00:46:20,680
Mari kita jalankan bubble sort pada daftar.

767
00:46:20,680 --> 00:46:23,560
Atau pertama, mari kita lihat pseudocode beberapa benar-benar cepat.

768
00:46:23,560 --> 00:46:28,160
Kami ingin mengatakan kita ingin melacak, dalam setiap iterasi dari loop,

769
00:46:28,160 --> 00:46:32,190
melacak apakah atau tidak kita mengubah setiap elemen.

770
00:46:32,190 --> 00:46:37,610
Jadi alasan untuk itu adalah, kita akan berhenti ketika kita tidak bertukar setiap elemen.

771
00:46:37,610 --> 00:46:41,980
Jadi pada awal loop kita belum bertukar apa-apa, jadi kita akan mengatakan bahwa itu palsu.

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

773
00:46:47,170 --> 00:46:50,310
dan jika itu adalah kasus bahwa ada sejumlah besar di sebelah kiri sejumlah kecil,

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

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

776
00:46:54,490 --> 00:46:58,900
Itu berarti bahwa kita harus pergi melalui daftar setidaknya 1 lebih banyak waktu

777
00:46:58,900 --> 00:47:02,160
karena kondisi di mana kami berhenti adalah ketika seluruh daftar sudah diurutkan,

778
00:47:02,160 --> 00:47:04,890
artinya kita tidak membuat swap.

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

780
00:47:09,960 --> 00:47:13,720
Jadi sekarang mari kita lihat ini berjalan pada daftar.

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

782
00:47:16,640 --> 00:47:19,850
Bubble sort akan mulai sepanjang jalan di sebelah kiri, dan itu akan membandingkan

783
00:47:19,850 --> 00:47:24,700
elemen i, jadi 0 sampai i + 1, yang merupakan elemen 1.

784
00:47:24,700 --> 00:47:29,020
Ini akan mengatakan, baik 5> 0, tapi 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
Ketika saya swap mereka, tiba-tiba saya mendapatkan daftar yang berbeda.

787
00:47:35,470 --> 00:47:38,260
Sekarang 5> 1, sehingga kita akan swap mereka.

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

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

790
00:47:46,690 --> 00:47:49,740
Sekali lagi, kita perlu untuk menjalankan melalui seluruh daftar untuk akhirnya menemukan

791
00:47:49,740 --> 00:47:52,330
bahwa ini adalah rusak, kita swap mereka,

792
00:47:52,330 --> 00:47:57,120
dan pada saat ini kita perlu menjalankan melalui daftar waktu 1 lebih

793
00:47:57,120 --> 00:48:05,390
untuk memastikan bahwa semuanya dalam rangka, dan saat ini semacam titik gelembung telah selesai.

794
00:48:05,390 --> 00:48:10,720
Sebuah algoritma yang berbeda untuk mengambil beberapa elemen dan menyortir mereka adalah semacam seleksi.

795
00:48:10,720 --> 00:48:15,740
Ide di balik semacam seleksi adalah bahwa kita akan membangun sebagian diurutkan dari daftar

796
00:48:15,740 --> 00:48:18,150
1 elemen pada suatu waktu.

797
00:48:18,150 --> 00:48:23,170
>> Dan cara kita akan melakukan itu adalah dengan membangun segmen kiri dari daftar.

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

799
00:48:27,510 --> 00:48:32,310
yang belum diurutkan belum, dan kita akan memindahkannya ke dalam segmen diurutkan.

800
00:48:32,310 --> 00:48:35,850
Itu berarti kita perlu untuk terus menemukan elemen minimum unsorted

801
00:48:35,850 --> 00:48:40,720
dan kemudian mengambil elemen minimum dan swap dengan apapun

802
00:48:40,720 --> 00:48:45,090
kiri-sebagian elemen yang tidak diurutkan.

803
00:48:45,090 --> 00:48:50,890
Waktu berjalan ini akan menjadi O (n ²) karena dalam kasus terburuk

804
00:48:50,890 --> 00:48:55,070
kita perlu membandingkan setiap elemen tunggal untuk setiap elemen lain.

805
00:48:55,070 --> 00:48:59,250
Karena kita katakan bahwa jika kita mulai dari kiri setengah dari daftar, kita perlu

806
00:48:59,250 --> 00:49:02,970
untuk pergi melalui segmen seluruh hak untuk menemukan elemen terkecil.

807
00:49:02,970 --> 00:49:05,430
Dan kemudian, sekali lagi, kita harus pergi ke segmen seluruh hak dan

808
00:49:05,430 --> 00:49:08,210
terus selama itu berulang-ulang.

809
00:49:08,210 --> 00:49:11,350
Itu akan menjadi n ². Kita akan membutuhkan untuk di dalam lingkaran lain untuk loop

810
00:49:11,350 --> 00:49:13,350
yang menunjukkan ² n.

811
00:49:13,350 --> 00:49:16,530
Dalam pemikiran kasus terbaik, katakanlah kita memberikan sebuah daftar yang sudah disortir;

812
00:49:16,530 --> 00:49:19,270
kita benar-benar tidak melakukan lebih baik daripada ² n.

813
00:49:19,270 --> 00:49:21,730
Karena semacam seleksi tidak memiliki cara untuk mengetahui bahwa

814
00:49:21,730 --> 00:49:25,540
elemen minimum adalah hanya yang saya kebetulan melihat.

815
00:49:25,540 --> 00:49:28,970
Ini masih perlu untuk memastikan bahwa ini sebenarnya minimum.

816
00:49:28,970 --> 00:49:31,670
>> Dan satu-satunya cara untuk memastikan bahwa itu minimum, menggunakan algoritma ini,

817
00:49:31,670 --> 00:49:34,640
adalah dengan melihat setiap elemen tunggal lagi.

818
00:49:34,640 --> 00:49:38,420
Jadi benar-benar, jika Anda memberikan itu - jika Anda memberikan semacam seleksi daftar yang sudah diurutkan,

819
00:49:38,420 --> 00:49:42,720
itu tidak akan melakukan lebih baik daripada memberikan sebuah daftar yang tidak diurutkan belum.

820
00:49:42,720 --> 00:49:46,320
By the way, jika hal itu terjadi menjadi kasus bahwa ada sesuatu yang O (sesuatu)

821
00:49:46,320 --> 00:49:50,640
dan omega dari sesuatu, kita hanya bisa mengatakan lebih ringkas bahwa itu θ sesuatu.

822
00:49:50,640 --> 00:49:52,760
Jadi jika Anda melihat yang muncul di mana saja, itulah yang hanya berarti.

823
00:49:52,760 --> 00:49:57,580
>> Jika ada sesuatu yang theta dari n ², keduanya O besar (n ²) dan Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Sehingga kasus terbaik dan kasus terburuk, itu tidak membuat perbedaan,

825
00:49:59,790 --> 00:50:04,400
algoritma akan melakukan hal yang sama setiap waktu.

826
00:50:04,400 --> 00:50:06,610
Jadi ini adalah apa pseudocode untuk semacam seleksi bisa terlihat seperti.

827
00:50:06,610 --> 00:50:10,630
Kita pada dasarnya akan mengatakan bahwa saya ingin iterate atas daftar

828
00:50:10,630 --> 00:50:15,180
dari kiri ke kanan, dan pada setiap iterasi dari loop, aku akan pindah

829
00:50:15,180 --> 00:50:19,780
elemen minimum dalam bagian ini diurutkan dari daftar.

830
00:50:19,780 --> 00:50:23,260
Dan setelah saya memindahkan sesuatu di sana, saya tidak pernah perlu melihat unsur itu lagi.

831
00:50:23,260 --> 00:50:28,600
Karena begitu saya swap elemen ke segmen kiri dari daftar, itu diurutkan

832
00:50:28,600 --> 00:50:32,600
karena kita melakukan segala sesuatu dalam urutan dengan menggunakan minimum.

833
00:50:32,600 --> 00:50:38,740
Jadi kami berkata, oke, kita berada di posisi saya, dan kita perlu melihat semua elemen

834
00:50:38,740 --> 00:50:42,260
di sebelah kanan saya untuk menemukan minimum.

835
00:50:42,260 --> 00:50:46,150
Jadi itu berarti kita ingin melihat dari i + 1 ke akhir daftar.

836
00:50:46,150 --> 00:50:51,610
Dan sekarang, jika elemen yang kita sedang melihat kurang dari minimum kami sejauh ini,

837
00:50:51,610 --> 00:50:54,190
yang, ingat, kita mulai off minimal untuk hanya menjadi

838
00:50:54,190 --> 00:50:57,020
apapun elemen kita saat ini di, saya akan menganggap itu minimum.

839
00:50:57,020 --> 00:51:00,270
Jika saya menemukan sebuah elemen yang lebih kecil dari itu, maka aku akan mengatakan, oke,

840
00:51:00,270 --> 00:51:02,700
baik, saya telah menemukan minimal baru.

841
00:51:02,700 --> 00:51:06,080
Aku akan mengingat di mana minimum itu.

842
00:51:06,080 --> 00:51:09,560
>> Jadi sekarang, setelah aku sudah melalui segmen unsorted yang tepat,

843
00:51:09,560 --> 00:51:16,690
Saya dapat mengatakan aku akan menukar elemen minimum dengan elemen yang ada di posisi saya.

844
00:51:16,690 --> 00:51:21,100
Itu akan membangun daftar saya, saya bagian dari daftar diurutkan dari kiri ke kanan,

845
00:51:21,100 --> 00:51:25,190
dan kita tidak merasa perlu untuk melihat elemen lagi setelah itu di bagian itu.

846
00:51:25,190 --> 00:51:27,930
Setelah kami bertukar.

847
00:51:27,930 --> 00:51:30,260
Jadi mari kita jalankan semacam pilihan pada daftar ini.

848
00:51:30,260 --> 00:51:38,220
Elemen biru di sini akan menjadi i, dan unsur warna merah akan menjadi elemen minimal.

849
00:51:38,220 --> 00:51:41,570
Jadi saya mulai sepanjang jalan di sebelah kiri dari daftar, sehingga pada 5.

850
00:51:41,570 --> 00:51:44,610
Sekarang kita perlu menemukan elemen unsorted minimum.

851
00:51:44,610 --> 00:51:49,480
Jadi kita katakan 0 <5, sehingga 0 adalah minimum baru saya.

852
00:51:49,480 --> 00:51:53,820
>> Tapi aku tidak bisa berhenti di situ, karena meskipun kita dapat mengenali bahwa 0 adalah yang terkecil,

853
00:51:53,820 --> 00:51:59,390
kita perlu berjalan melalui setiap elemen lain dari daftar untuk memastikan.

854
00:51:59,390 --> 00:52:01,760
Jadi 1 lebih besar, lebih besar 6, 4 lebih besar.

855
00:52:01,760 --> 00:52:05,850
Itu berarti bahwa setelah melihat semua elemen, saya sudah bertekad 0 adalah yang terkecil.

856
00:52:05,850 --> 00:52:09,800
Jadi aku akan menukar 5 dan 0.

857
00:52:09,800 --> 00:52:15,480
Setelah saya swap itu, aku akan mendapatkan daftar baru, dan saya tahu bahwa saya tidak perlu melihat bahwa 0 lagi

858
00:52:15,480 --> 00:52:19,380
karena sekali saya sudah bertukar, saya sudah diurutkan dan kami sudah selesai.

859
00:52:19,380 --> 00:52:22,730
Sekarang kebetulan bahwa elemen biru lagi 5,

860
00:52:22,730 --> 00:52:26,030
dan kita perlu melihat 1, 6 dan 4 untuk menentukan bahwa 1

861
00:52:26,030 --> 00:52:31,520
adalah elemen minimum terkecil, jadi kita akan swap 1 dan 5.

862
00:52:31,520 --> 00:52:36,890
Sekali lagi, kita perlu melihat - membandingkan 5 ke 6 dan 4,

863
00:52:36,890 --> 00:52:39,830
dan kita akan menukar 4 dan 5, dan akhirnya, bandingkan

864
00:52:39,830 --> 00:52:45,740
mereka 2 angka dan swap mereka sampai kita mendapatkan daftar kami diurutkan.

865
00:52:45,740 --> 00:52:49,730
Setiap pertanyaan tentang selection sort?

866
00:52:49,730 --> 00:52:56,420
Oke. Mari kita pindah ke topik terakhir di sini, dan itu adalah rekursi.

867
00:52:56,420 --> 00:52:59,810
>> Rekursi, ingat, ini hal meta-benar di mana fungsi

868
00:52:59,810 --> 00:53:02,740
berulang kali menyebut dirinya.

869
00:53:02,740 --> 00:53:05,620
Jadi di beberapa titik, sementara fungsinya kita berulang kali menyebut dirinya,

870
00:53:05,620 --> 00:53:10,100
perlu ada beberapa titik di mana kita berhenti memanggil diri kita sendiri.

871
00:53:10,100 --> 00:53:13,670
Karena jika kita tidak melakukan itu, maka kita hanya akan terus melakukan hal ini selamanya,

872
00:53:13,670 --> 00:53:16,660
dan program kami hanya tidak akan mengakhiri.

873
00:53:16,660 --> 00:53:19,200
Kami menyebutnya kondisi ini kasus dasar.

874
00:53:19,200 --> 00:53:22,570
Dan kasus dasar mengatakan, daripada memanggil fungsi lagi,

875
00:53:22,570 --> 00:53:25,330
Aku hanya akan kembali beberapa nilai.

876
00:53:25,330 --> 00:53:28,080
Jadi setelah kami telah kembali nilai, kami telah berhenti memanggil diri kita sendiri,

877
00:53:28,080 --> 00:53:32,550
dan sisanya dari panggilan yang kita buat sejauh ini juga dapat kembali.

878
00:53:32,550 --> 00:53:36,050
Kebalikan dari kasus dasar adalah kasus rekursif.

879
00:53:36,050 --> 00:53:39,050
Dan ini adalah ketika kita ingin membuat panggilan lain untuk fungsi yang kita saat ini masuk

880
00:53:39,050 --> 00:53:44,690
Dan kita mungkin, meskipun tidak selalu, ingin menggunakan argumen yang berbeda.

881
00:53:44,690 --> 00:53:48,940
>> Jadi jika kita memiliki fungsi yang disebut f, dan f hanya disebut mengambil 1 argumen,

882
00:53:48,940 --> 00:53:52,010
dan kami hanya terus menelepon f (1), f (1), f (1), dan itu hanya terjadi bahwa

883
00:53:52,010 --> 00:53:56,510
argumen 1 jatuh ke dalam kasus rekursif, kita masih tidak akan pernah berhenti.

884
00:53:56,510 --> 00:54:01,620
Bahkan jika kita memiliki kasus dasar, kita perlu memastikan bahwa pada akhirnya kita akan memukul kasus dasar.

885
00:54:01,620 --> 00:54:04,250
Kami tidak terus tinggal dalam hal ini rekursif.

886
00:54:04,250 --> 00:54:09,870
Umumnya, ketika kita menyebut diri kita, kita mungkin akan memiliki argumen yang berbeda setiap kali.

887
00:54:09,870 --> 00:54:12,700
Berikut ini adalah fungsi rekursif benar-benar sederhana.

888
00:54:12,700 --> 00:54:15,090
Jadi ini akan menghitung faktorial dari angka.

889
00:54:15,090 --> 00:54:17,790
Up atas sini kita memiliki kasus dasar kami.

890
00:54:17,790 --> 00:54:22,330
Dalam hal bahwa n ≤ 1, kita tidak akan memanggil faktorial lagi.

891
00:54:22,330 --> 00:54:26,490
Kita akan berhenti, kami hanya akan mengembalikan nilai tertentu.

892
00:54:26,490 --> 00:54:30,170
Jika hal ini tidak benar, maka kita akan memukul kasus rekursif kami.

893
00:54:30,170 --> 00:54:33,550
Perhatikan di sini bahwa kita tidak hanya memanggil faktorial (n), karena itu tidak akan sangat membantu.

894
00:54:33,550 --> 00:54:36,810
Kita akan memanggil faktorial sesuatu yang lain.

895
00:54:36,810 --> 00:54:40,850
>> Dan sehingga Anda dapat melihat, pada akhirnya jika kita melewati sesuatu faktorial (5) atau,

896
00:54:40,850 --> 00:54:45,900
kita akan memanggil faktorial (4) dan seterusnya, dan akhirnya kita akan memukul ini kasus dasar.

897
00:54:45,900 --> 00:54:51,730
Jadi ini terlihat baik. Mari kita lihat apa yang terjadi ketika kita benar-benar menjalankan ini.

898
00:54:51,730 --> 00:54:57,840
Ini adalah stack, dan mari kita mengatakan bahwa utama akan memanggil fungsi ini dengan argumen (4).

899
00:54:57,840 --> 00:55:02,200
Jadi sekali faktorial melihat dan = 4, faktorial akan memanggil dirinya sendiri.

900
00:55:02,200 --> 00:55:05,010
Sekarang, tiba-tiba, kami memiliki faktorial (3).

901
00:55:05,010 --> 00:55:10,780
Jadi fungsi-fungsi ini akan terus tumbuh sampai akhirnya kita memukul kasus dasar kami.

902
00:55:10,780 --> 00:55:17,830
Pada titik ini, nilai pengembalian ini adalah kembali (nx nilai kembali dari ini),

903
00:55:17,830 --> 00:55:21,290
nilai pengembalian ini adalah nx nilai pengembalian ini.

904
00:55:21,290 --> 00:55:23,290
Akhirnya kita perlu untuk memukul beberapa nomor.

905
00:55:23,290 --> 00:55:26,560
Di atas sini, kita katakan kembali 1.

906
00:55:26,560 --> 00:55:30,650
Itu berarti bahwa sekali kita kembali jumlah tersebut, kita dapat pop ini dari tumpukan.

907
00:55:30,650 --> 00:55:36,570
Jadi ini faktorial (1) dilakukan.

908
00:55:36,570 --> 00:55:41,190
Ketika kembali 1, ini (1) faktorial kembali, ini kembali ke 1.

909
00:55:41,190 --> 00:55:46,910
Nilai kembali dari ini, ingat, adalah nx nilai pengembalian ini.

910
00:55:46,910 --> 00:55:50,720
Begitu tiba-tiba, orang ini tahu bahwa saya ingin kembali 2.

911
00:55:50,720 --> 00:55:55,910
>> Jadi ingat, mengembalikan nilai ini hanya nx nilai kembali di sini.

912
00:55:55,910 --> 00:56:01,160
Jadi sekarang kita dapat mengatakan 3 x 2, dan akhirnya, di sini kita dapat 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 kembali, kami turun ke dalam bilangan bulat tunggal utama.

915
00:56:09,570 --> 00:56:15,460
Setiap pertanyaan tentang rekursi?

916
00:56:15,460 --> 00:56:17,090
Baiklah. Jadi ada lebih banyak waktu untuk pertanyaan-pertanyaan di akhir,

917
00:56:17,090 --> 00:56:23,360
tapi sekarang Yusuf akan mencakup topik yang tersisa.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] Baiklah. Jadi sekarang kita bicarakan recursions,

919
00:56:25,590 --> 00:56:27,840
mari kita bicara sedikit tentang apa menggabungkan semacam ini.

920
00:56:27,840 --> 00:56:31,740
Merge sort pada dasarnya cara lain untuk menyortir daftar nomor.

921
00:56:31,740 --> 00:56:36,430
Dan cara kerjanya adalah, dengan gabungan semacam Anda memiliki daftar, dan apa yang kita lakukan adalah

922
00:56:36,430 --> 00:56:39,120
kita katakan, mari kita membagi ini menjadi 2 bagian.

923
00:56:39,120 --> 00:56:42,750
Pertama-tama kita akan menjalankan menggabungkan semacam lagi di kiri setengah,

924
00:56:42,750 --> 00:56:45,040
maka kita akan jalankan menggabungkan semacam di kanan setengah,

925
00:56:45,040 --> 00:56:50,240
dan yang memberi kita sekarang 2 bagian yang diurutkan, dan sekarang kita akan menggabungkan mereka bersama-sama bagian.

926
00:56:50,240 --> 00:56:55,010
Ini agak sulit untuk melihat tanpa contoh, jadi kita akan pergi melalui gerakan dan melihat apa yang terjadi.

927
00:56:55,010 --> 00:56:59,590
Jadi Anda mulai dengan daftar ini, kami membagi menjadi 2 bagian.

928
00:56:59,590 --> 00:57:02,300
Kami menjalankan menggabungkan semacam di kiri setengah pertama.

929
00:57:02,300 --> 00:57:06,660
Jadi itulah kiri setengah, dan sekarang kita menjalankan mereka melalui daftar ini lagi

930
00:57:06,660 --> 00:57:09,800
yang akan dilewatkan ke semacam gabungan, dan kemudian kita melihat, sekali lagi,

931
00:57:09,800 --> 00:57:13,270
di sisi kiri dari daftar ini dan kami jalankan menggabungkan semacam di atasnya.

932
00:57:13,270 --> 00:57:15,880
Sekarang, kita turun ke daftar nomor 2,

933
00:57:15,880 --> 00:57:19,010
dan sekarang kiri setengah hanya 1 elemen yang panjang, dan kita tidak bisa

934
00:57:19,010 --> 00:57:23,380
membagi daftar yang hanya 1 elemen menjadi setengah, jadi kami hanya mengatakan, setelah kami memiliki 50,

935
00:57:23,380 --> 00:57:26,400
yang hanya 1 elemen, itu sudah diurutkan.

936
00:57:26,400 --> 00:57:29,860
>> Setelah kami selesai dengan itu, kita dapat melihat bahwa kita bisa

937
00:57:29,860 --> 00:57:32,230
pindah ke kanan setengah dari daftar ini,

938
00:57:32,230 --> 00:57:36,480
dan 3 juga diurutkan, dan jadi sekarang bahwa kedua bagian dari daftar ini diurutkan

939
00:57:36,480 --> 00:57:39,080
kita bisa bergabung dengan angka-angka ini kembali bersama-sama.

940
00:57:39,080 --> 00:57:45,320
Jadi kita melihat 50 dan 3, 3 lebih kecil dari 50, sehingga masuk terlebih dulu dan kemudian 50 masuk

941
00:57:45,320 --> 00:57:49,340
Sekarang, itu dilakukan, kita kembali ke daftar itu dan semacam itu setengah benar.

942
00:57:49,340 --> 00:57:52,440
42 adalah nomor itu sendiri, jadi sudah diurutkan.

943
00:57:52,440 --> 00:57:57,850
Jadi sekarang kita membandingkan 2 dan 3 lebih kecil dari 42, sehingga akan dimasukkan ke dalam pertama,

944
00:57:57,850 --> 00:58:02,340
sekarang 42 akan dimasukkan ke dalam, dan 50 akan meletakkan masuk

945
00:58:02,340 --> 00:58:07,220
Sekarang, itu diurutkan, kita pergi semua jalan kembali ke atas, 1.337 dan 15.

946
00:58:07,220 --> 00:58:14,560
Nah, sekarang kita melihat kiri setengah dari daftar ini, 1.337 adalah dengan sendirinya sehingga yang diurutkan dan sama dengan 15.

947
00:58:14,560 --> 00:58:19,020
Jadi sekarang kita menggabungkan 2 angka untuk menyortir daftar itu asli, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
sehingga masuk terlebih dulu, kemudian berjalan masuk 1.337

949
00:58:23,060 --> 00:58:26,640
Dan sekarang kita diurutkan kedua bagian dari daftar asli di bagian atas.

950
00:58:26,640 --> 00:58:30,440
Dan semua yang harus kita lakukan adalah menggabungkan.

951
00:58:30,440 --> 00:58:36,890
Kami melihat 2 angka pertama dari daftar ini, 3 <15, sehingga masuk ke array semacam pertama.

952
00:58:36,890 --> 00:58:44,460
15 <42, sehingga berjalan masuk Sekarang, 42 <1337, yang berlangsung masuk

953
00:58:44,460 --> 00:58:51,010
50 <1337, begitu seterusnya masuk Dan perhatikan bahwa kami hanya mengambil 2 nomor dari daftar ini.

954
00:58:51,010 --> 00:58:53,640
Jadi kita tidak hanya bergantian antara 2 daftar.

955
00:58:53,640 --> 00:58:56,050
Kita hanya melihat awal, dan kami mengambil elemen

956
00:58:56,050 --> 00:59:00,270
yang lebih kecil dan kemudian memasukkannya ke dalam array kita.

957
00:59:00,270 --> 00:59:04,080
Sekarang kita sudah digabung semua bagian dan kami sudah selesai.

958
00:59:04,080 --> 00:59:07,780
>> Setiap pertanyaan tentang merge sort? Ya?

959
00:59:07,780 --> 00:59:14,190
[Mahasiswa] Jika membelah diri menjadi kelompok-kelompok yang berbeda, mengapa mereka tidak hanya membagi sekali

960
00:59:14,190 --> 00:59:19,970
dan Anda memiliki 3 dan 2 dalam kelompok? [Sisa dimengerti pertanyaan]

961
00:59:19,970 --> 00:59:24,940
Alasan - jadi pertanyaannya adalah, mengapa kita tidak bisa hanya menggabungkan mereka pada langkah pertama setelah kita memilikinya?

962
00:59:24,940 --> 00:59:29,530
Alasan kami bisa melakukan hal ini, mulai dari yang paling kiri elemen dari kedua belah pihak,

963
00:59:29,530 --> 00:59:33,040
dan kemudian mengambil yang lebih kecil dan memasukkannya ke dalam, adalah bahwa kita tahu bahwa

964
00:59:33,040 --> 00:59:35,290
daftar individu dalam perintah diurutkan.

965
00:59:35,290 --> 00:59:37,290
Jadi jika saya sedang melihat kiri-paling elemen kedua bagian,

966
00:59:37,290 --> 00:59:40,490
Saya tahu mereka akan menjadi unsur terkecil dari daftar tersebut.

967
00:59:40,490 --> 00:59:43,930
Jadi saya bisa menempatkan mereka ke tempat elemen terkecil dari daftar ini besar.

968
00:59:43,930 --> 00:59:47,810
Di sisi lain, jika saya melihat orang-orang 2 daftar di tingkat kedua di sana,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1.337 dan 15, mereka tidak diurutkan.

970
00:59:51,640 --> 00:59:55,770
Jadi jika saya melihat 50 dan 1337, aku akan dimasukkan ke dalam daftar 50 saya pertama.

971
00:59:55,770 --> 01:00:00,130
Tapi itu tidak benar-benar masuk akal, karena 3 adalah elemen terkecil dari semua orang.

972
01:00:00,130 --> 01:00:04,390
Jadi satu-satunya alasan yang bisa kita lakukan langkah ini adalah karena menggabungkan daftar kami sudah diurutkan.

973
01:00:04,390 --> 01:00:07,010
Itulah sebabnya kita harus turun sampai ke bawah

974
01:00:07,010 --> 01:00:09,800
karena ketika kita hanya memiliki satu nomor, Anda tahu bahwa satu nomor

975
01:00:09,800 --> 01:00:14,120
dalam dan dari dirinya sendiri sudah daftar diurutkan.

976
01:00:14,120 --> 01:00:19,360
>> Ada pertanyaan? Tidak ada?

977
01:00:19,360 --> 01:00:24,260
Kompleksitas? Nah, Anda bisa melihat bahwa di setiap langkah ada nomor akhir,

978
01:00:24,260 --> 01:00:27,590
dan kita dapat membagi daftar dalam log setengah n kali,

979
01:00:27,590 --> 01:00:31,700
yang mana kita mendapatkan ini log n x n kompleksitas.

980
01:00:31,700 --> 01:00:34,940
Dan Anda akan melihat kasus terbaik untuk gabungan semacam adalah n log n, dan kebetulan

981
01:00:34,940 --> 01:00:39,340
bahwa kasus 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 pada, mari kita pergi ke beberapa file dasar super I / O.

984
01:00:45,750 --> 01:00:48,830
Jika Anda melihat Scramble, Anda akan melihat kami memiliki semacam sistem

985
01:00:48,830 --> 01:00:51,270
di mana Anda bisa menulis ke file log jika Anda membaca kode.

986
01:00:51,270 --> 01:00:53,730
Mari kita lihat bagaimana Anda bisa melakukan itu.

987
01:00:53,730 --> 01:00:57,450
Nah, kita memiliki fprintf, yang dapat Anda pikirkan hanya sebagai printf,

988
01:00:57,450 --> 01:01:01,720
tapi hanya mencetak ke file bukan, dan karenanya f di awal.

989
01:01:01,720 --> 01:01:07,570
Ini semacam kode di sini, apa yang dilakukannya adalah, karena Anda mungkin telah melihat di Scramble,

990
01:01:07,570 --> 01:01:12,310
ia pergi melalui 2-dimensi pencetakan array Anda keluar baris demi baris apa jumlahnya.

991
01:01:12,310 --> 01:01:17,850
Dalam kasus ini, printf mencetak ke terminal Anda atau apa yang kita sebut output standar bagian.

992
01:01:17,850 --> 01:01:22,170
>> Dan sekarang, dalam hal ini, yang harus kita lakukan adalah mengganti printf dengan fprintf,

993
01:01:22,170 --> 01:01:26,770
ceritakan apa file yang ingin Anda cetak, dan dalam hal ini hanya mencetaknya ke file yang

994
01:01:26,770 --> 01:01:32,230
bukannya mencetak keluar ke terminal Anda.

995
01:01:32,230 --> 01:01:36,500
Nah, maka itu menimbulkan pertanyaan: mana kita mendapatkan semacam file dari, kan?

996
01:01:36,500 --> 01:01:39,840
Kami melewati masuk ke ini fuction fprintf tapi kami tidak tahu dari mana asalnya.

997
01:01:39,840 --> 01:01:43,980
Nah, di awal kode, apa yang kita miliki adalah serangkaian kode ini di sini,

998
01:01:43,980 --> 01:01:48,340
yang pada dasarnya mengatakan bahwa terbuka file log.txt panggilan.

999
01:01:48,340 --> 01:01:53,220
Apa yang kita lakukan setelah itu adalah kita harus memastikan bahwa file tersebut benar-benar dibuka berhasil.

1000
01:01:53,220 --> 01:01:57,070
Jadi mungkin gagal karena beberapa alasan, Anda tidak memiliki cukup ruang pada komputer Anda, misalnya.

1001
01:01:57,070 --> 01:01:59,790
Jadi selalu penting sebelum Anda melakukan operasi dengan file

1002
01:01:59,790 --> 01:02:03,300
bahwa kita memeriksa apakah file yang dibuka dengan sukses.

1003
01:02:03,300 --> 01:02:09,330
Jadi apa bahwa, itu argumen fopen, juga, kita dapat membuka file dalam banyak cara.

1004
01:02:09,330 --> 01:02:13,510
Apa yang dapat kita lakukan adalah, kita bisa lulus w, yang berarti menimpa file jika sudah keluar,

1005
01:02:13,510 --> 01:02:18,070
Kami dapat melewati suatu, yang mereka tambahkan ke akhir file bukan utama itu,

1006
01:02:18,070 --> 01:02:22,730
atau kita dapat menentukan r, yang berarti, mari kita buka file sebagai read-only.

1007
01:02:22,730 --> 01:02:24,890
Jadi jika program mencoba untuk membuat perubahan pada file tersebut,

1008
01:02:24,890 --> 01:02:30,140
berteriak pada mereka dan jangan biarkan mereka melakukannya.

1009
01:02:30,140 --> 01:02:33,320
Akhirnya, setelah kami selesai dengan file tersebut, selesai melakukan operasi di atasnya,

1010
01:02:33,320 --> 01:02:35,860
kita perlu memastikan bahwa kita menutup file.

1011
01:02:35,860 --> 01:02:38,830
Dan sehingga pada akhir program Anda, Anda akan melewati mereka lagi

1012
01:02:38,830 --> 01:02:42,120
file ini yang dibuka, dan hanya menutupnya.

1013
01:02:42,120 --> 01:02:44,650
Jadi ini adalah sesuatu yang penting bahwa Anda harus memastikan Anda lakukan.

1014
01:02:44,650 --> 01:02:47,180
Jadi ingat Anda dapat membuka file, maka Anda dapat menulis ke file tersebut,

1015
01:02:47,180 --> 01:02:51,270
melakukan operasi dalam file, tapi kemudian Anda harus menutup file di akhir.

1016
01:02:51,270 --> 01:02:53,270
>> Setiap pertanyaan pada file dasar I / O? Ya?

1017
01:02:53,270 --> 01:02:58,050
[Pertanyaan Mahasiswa, dipahami]

1018
01:02:58,050 --> 01:03:02,480
Di sini. Pertanyaannya adalah, dari mana file ini log.txt muncul?

1019
01:03:02,480 --> 01:03:07,890
Nah, jika Anda hanya memberikan log.txt, itu menciptakan dalam direktori yang sama dengan eksekusi.

1020
01:03:07,890 --> 01:03:10,500
Jadi jika kau - >> [pertanyaan Mahasiswa, dipahami]

1021
01:03:10,500 --> 01:03:18,830
Ya. Dalam folder yang sama, atau dalam direktori yang sama, seperti yang Anda menyebutnya.

1022
01:03:18,830 --> 01:03:21,400
Sekarang memori, tumpukan, dan tumpukan.

1023
01:03:21,400 --> 01:03:23,400
Jadi bagaimana memori diletakkan di komputer?

1024
01:03:23,400 --> 01:03:26,270
Nah, Anda bisa membayangkan memori sebagai semacam ini blok di sini.

1025
01:03:26,270 --> 01:03:30,260
Dan dalam memori kita memiliki apa yang disebut tumpukan terjebak di sana, dan tumpukan yang ada di bawah sana.

1026
01:03:30,260 --> 01:03:34,480
Dan tumpukan tumbuh ke bawah dan tumpukan tumbuh ke atas.

1027
01:03:34,480 --> 01:03:38,620
Sehingga Tommy disebutkan - oh, baik, dan kita memiliki 4 segmen lain yang saya akan mendapatkan dalam satu detik -

1028
01:03:38,620 --> 01:03:42,890
Seperti Tommy mengatakan sebelumnya, Anda tahu bagaimana fungsi nya menyebut diri mereka dan memanggil satu sama lain?

1029
01:03:42,890 --> 01:03:44,930
Mereka membangun semacam ini stack frame.

1030
01:03:44,930 --> 01:03:47,360
Nah, jika panggilan utama foo, foo akan dimasukkan pada stack.

1031
01:03:47,360 --> 01:03:52,430
Foo panggilan bar, bar ini bisa diletakkan di stack, dan yang akan diletakkan di tumpukan setelah.

1032
01:03:52,430 --> 01:03:57,040
Dan saat mereka kembali, mereka masing-masing bisa diambil dari tumpukan.

1033
01:03:57,040 --> 01:04:00,140
Apa masing-masing lokasi dan memori terus?

1034
01:04:00,140 --> 01:04:03,110
Nah, bagian atas, yang merupakan segmen teks, berisi program itu sendiri.

1035
01:04:03,110 --> 01:04:06,390
Jadi kode mesin, yang ada di sana, setelah Anda mengkompilasi program Anda.

1036
01:04:06,390 --> 01:04:08,520
Selanjutnya, setiap diinisialisasi variabel global.

1037
01:04:08,520 --> 01:04:12,660
>> Jadi Anda memiliki variabel global dalam program Anda, dan Anda berkata seperti, a = 5,

1038
01:04:12,660 --> 01:04:15,260
yang akan dimasukkan ke dalam segmen itu, dan tepat di bawah itu,

1039
01:04:15,260 --> 01:04:18,990
Anda memiliki data global uninitialized, yang hanya int a,

1040
01:04:18,990 --> 01:04:20,990
tapi Anda tidak mengatakan itu sama dengan apa pun.

1041
01:04:20,990 --> 01:04:23,870
Sadarilah ini adalah variabel global, sehingga mereka berada di luar dari utama.

1042
01:04:23,870 --> 01:04:28,560
Jadi ini berarti setiap variabel global yang dideklarasikan tetapi tidak diinisialisasi.

1043
01:04:28,560 --> 01:04:32,310
Jadi apa yang ada di tumpukan? Memori yang dialokasikan dengan menggunakan malloc, yang akan kita sampai ke dalam sedikit.

1044
01:04:32,310 --> 01:04:35,990
Dan akhirnya, dengan tumpukan Anda memiliki variabel lokal

1045
01:04:35,990 --> 01:04:39,950
dan setiap fungsi yang Anda sebut dalam salah satu parameter mereka.

1046
01:04:39,950 --> 01:04:43,720
Hal terakhir, Anda tidak benar-benar harus tahu apa variabel lingkungan lakukan,

1047
01:04:43,720 --> 01:04:46,700
tapi setiap kali Anda menjalankan program, ada sesuatu yang terkait, seperti

1048
01:04:46,700 --> 01:04:49,550
ini adalah nama pengguna dari orang yang menjalankan program tersebut.

1049
01:04:49,550 --> 01:04:51,550
Dan itu akan menjadi semacam di bagian bawah.

1050
01:04:51,550 --> 01:04:54,540
Dalam hal alamat memori, yaitu nilai-nilai heksadesimal,

1051
01:04:54,540 --> 01:04:58,170
nilai-nilai pada awal atas pada 0, dan mereka pergi semua jalan ke bawah.

1052
01:04:58,170 --> 01:05:00,440
Dalam hal ini, jika Anda berada di sistem 32-bit,

1053
01:05:00,440 --> 01:05:05,390
alamat di bagian bawah akan menjadi 0x, diikuti oleh af, karena itulah 32 bit,

1054
01:05:05,390 --> 01:05:10,890
yang merupakan 8 byte, dan dalam hal ini 8 byte sesuai dengan 8 digit heksadesimal.

1055
01:05:10,890 --> 01:05:20,110
Jadi di sini Anda akan memiliki, seperti, 0xffffff, dan di sana Anda akan memiliki 0.

1056
01:05:20,110 --> 01:05:23,660
Jadi apa pointer? Beberapa dari Anda mungkin telah membahas hal ini dalam bagian sebelumnya.

1057
01:05:23,660 --> 01:05:26,660
tapi kami pergi lebih dari itu dalam kuliah, sehingga pointer hanyalah sebuah tipe data

1058
01:05:26,660 --> 01:05:34,030
yang toko, bukan semacam nilai seperti 50, menyimpan alamat dari beberapa lokasi di memori.

1059
01:05:34,030 --> 01:05:36,020
Seperti memori yang [dipahami].

1060
01:05:36,020 --> 01:05:41,120
Jadi dalam hal ini, apa yang telah kita adalah, kita memiliki pointer ke integer atau int *,

1061
01:05:41,120 --> 01:05:46,210
dan berisi alamat heksadesimal dari 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Jadi apa yang kita miliki adalah, sekarang, poin pointer ini di beberapa lokasi di memori,

1063
01:05:50,880 --> 01:05:56,020
dan itu hanya, nilai 50 adalah di lokasi memori.

1064
01:05:56,020 --> 01:06:01,810
Pada beberapa sistem 32-bit, pada semua sistem 32-bit, pointer mengambil bit 32 atau 4 byte.

1065
01:06:01,810 --> 01:06:06,020
Tapi, misalnya, pada sistem 64-bit, pointer adalah 64 bit.

1066
01:06:06,020 --> 01:06:08,040
Jadi itu adalah sesuatu yang Anda akan ingin diingat.

1067
01:06:08,040 --> 01:06:12,310
Jadi pada sistem akhir-bit, pointer adalah bit akhir panjang.

1068
01:06:12,310 --> 01:06:17,320
Pointer adalah semacam sulit untuk mencerna tanpa hal-hal ekstra,

1069
01:06:17,320 --> 01:06:20,300
jadi mari kita pergi melalui contoh alokasi memori dinamis.

1070
01:06:20,300 --> 01:06:25,130
Apa alokasi memori dinamis lakukan untuk Anda, atau apa yang kita sebut malloc,

1071
01:06:25,130 --> 01:06:29,280
itu memungkinkan Anda mengalokasikan semacam data di luar himpunan.

1072
01:06:29,280 --> 01:06:31,830
Jadi data ini adalah semacam lebih permanen untuk durasi program.

1073
01:06:31,830 --> 01:06:36,430
Karena seperti yang Anda tahu, jika Anda mendeklarasikan x dalam fungsi, dan yang mengembalikan fungsi,

1074
01:06:36,430 --> 01:06:40,910
Anda tidak lagi memiliki akses ke data yang tersimpan dalam x.

1075
01:06:40,910 --> 01:06:44,420
Apa pointer mari kita lakukan adalah mereka Mari kita menyimpan nilai-nilai memori atau toko

1076
01:06:44,420 --> 01:06:46,840
dalam segmen yang berbeda dari memori, yaitu heap.

1077
01:06:46,840 --> 01:06:49,340
Sekarang setelah kami kembali keluar dari fungsi, asalkan kita memiliki pointer

1078
01:06:49,340 --> 01:06:54,960
ke lokasi di memori, maka apa yang dapat kita lakukan adalah kita hanya dapat melihat nilai-nilai di sana.

1079
01:06:54,960 --> 01:06:58,020
Mari kita lihat contoh: Ini adalah tata letak memori kami lagi.

1080
01:06:58,020 --> 01:07:00,050
Dan kami memiliki fungsi ini, utama.

1081
01:07:00,050 --> 01:07:06,870
Apa yang dilakukannya adalah - oke, begitu sederhana, benar -? Int x = 5, itu hanya sebuah variabel pada stack di main.

1082
01:07:06,870 --> 01:07:12,450
>> Di sisi lain, sekarang kita mendeklarasikan pointer yang memanggil giveMeThreeInts fungsi.

1083
01:07:12,450 --> 01:07:16,800
Dan jadi sekarang kita masuk ke fungsi ini dan kami membuat stack frame baru untuk itu.

1084
01:07:16,800 --> 01:07:20,440
Namun, dalam stack frame, kita mendeklarasikan int * temp,

1085
01:07:20,440 --> 01:07:23,210
yang pada mallocs 3 bilangan bulat bagi kita.

1086
01:07:23,210 --> 01:07:25,880
Jadi ukuran int akan memberi kita berapa banyak byte int ini,

1087
01:07:25,880 --> 01:07:29,620
dan malloc memberi kita bahwa banyak byte ruang di heap.

1088
01:07:29,620 --> 01:07:32,890
Jadi dalam hal ini, kami telah menciptakan ruang yang cukup untuk 3 bilangan bulat,

1089
01:07:32,890 --> 01:07:36,830
dan tumpukan adalah cara di atas sana, itulah sebabnya saya sudah ditarik itu lebih tinggi.

1090
01:07:36,830 --> 01:07:42,900
Setelah kita selesai, kita kembali ke sini, Anda hanya perlu 3 ints kembali,

1091
01:07:42,900 --> 01:07:47,000
dan ia mengembalikan alamat, dalam hal ini lebih di mana memori yang.

1092
01:07:47,000 --> 01:07:51,250
Dan kami menetapkan pointer = switch, dan di sana kami hanya memiliki pointer lain.

1093
01:07:51,250 --> 01:07:54,550
Tapi apa yang mengembalikan fungsi ditumpuk di sini dan menghilang.

1094
01:07:54,550 --> 01:07:59,250
Jadi suhu menghilang, tapi kami masih mempertahankan alamat di mana

1095
01:07:59,250 --> 01:08:01,850
3 bilangan bulat mereka berada di dalam induk.

1096
01:08:01,850 --> 01:08:06,180
Jadi dalam set ini, pointer scoped lokal untuk frame ditumpuk,

1097
01:08:06,180 --> 01:08:09,860
tapi memori yang mereka lihat adalah di heap.

1098
01:08:09,860 --> 01:08:12,190
>> Apakah itu masuk akal?

1099
01:08:12,190 --> 01:08:14,960
[Siswa] Bisakah Anda mengulanginya? >> [Yusuf] Ya.

1100
01:08:14,960 --> 01:08:20,270
Jadi jika saya kembali hanya sedikit, Anda melihat bahwa suhu dialokasikan

1101
01:08:20,270 --> 01:08:23,500
beberapa memori di heap sana.

1102
01:08:23,500 --> 01:08:28,680
Jadi, ketika fungsi ini, giveMeThreeInts kembali, ini tumpukan sini akan menghilang.

1103
01:08:28,680 --> 01:08:35,819
Dan dengan itu salah satu variabel, dalam hal ini, ini pointer yang dialokasikan dalam bingkai ditumpuk.

1104
01:08:35,819 --> 01:08:39,649
Itu akan menghilang, tapi karena kami kembali suhu

1105
01:08:39,649 --> 01:08:46,330
dan kami mengatur pointer = temp, pointer yang sekarang akan menunjukkan memori yang sama dari lokasi sebagai temp.

1106
01:08:46,330 --> 01:08:50,370
Jadi sekarang, meskipun kita kehilangan temp, itu pointer lokal,

1107
01:08:50,370 --> 01:08:59,109
kita masih mempertahankan alamat memori dari apa itu menunjuk ke dalam variabel pointer itu.

1108
01:08:59,109 --> 01:09:03,740
Pertanyaan? Itu bisa menjadi semacam topik membingungkan jika Anda tidak pergi lebih dari itu dalam bagian.

1109
01:09:03,740 --> 01:09:09,240
Kita bisa, TF Anda pasti akan pergi di atasnya dan tentu saja kita dapat menjawab pertanyaan

1110
01:09:09,240 --> 01:09:11,500
pada akhir sesi review untuk ini.

1111
01:09:11,500 --> 01:09:14,220
Tapi ini adalah semacam topik yang kompleks, dan saya memiliki lebih banyak contoh yang akan muncul

1112
01:09:14,220 --> 01:09:18,790
yang akan membantu menjelaskan apa pointer sebenarnya.

1113
01:09:18,790 --> 01:09:22,500
>> Dalam hal ini, pointer setara dengan array,

1114
01:09:22,500 --> 01:09:25,229
jadi saya hanya bisa menggunakan pointer ini sebagai hal yang sama sebagai array int.

1115
01:09:25,229 --> 01:09:29,840
Jadi aku pengindeksan ke 0, dan mengubah integer pertama 1,

1116
01:09:29,840 --> 01:09:39,689
mengubah integer kedua 2, dan 3 untuk bilangan bulat 3.

1117
01:09:39,689 --> 01:09:44,210
Jadi lebih pada pointer. Nah, mengingat Binky.

1118
01:09:44,210 --> 01:09:48,319
Dalam hal ini kami telah dialokasikan pointer, atau kita menyatakan pointer,

1119
01:09:48,319 --> 01:09:52,760
tapi awalnya, ketika saya hanya menyatakan pointer, itu tidak menunjuk ke mana saja di memori.

1120
01:09:52,760 --> 01:09:54,930
Ini nilai sampah hanya di dalamnya.

1121
01:09:54,930 --> 01:09:56,470
Jadi saya tidak tahu di mana pointer ini menunjuk ke.

1122
01:09:56,470 --> 01:10:01,630
Ini memiliki alamat yang hanya diisi dengan 0 dan 1 yang mana itu awalnya diumumkan.

1123
01:10:01,630 --> 01:10:04,810
Saya tidak bisa melakukan apa-apa dengan ini sampai saya sebut malloc di atasnya

1124
01:10:04,810 --> 01:10:08,390
dan kemudian memberi saya sedikit ruang di tumpukan mana saya dapat menempatkan nilai-nilai di dalamnya.

1125
01:10:08,390 --> 01:10:11,980
Kemudian lagi, saya tidak tahu apa yang ada di dalam memori ini.

1126
01:10:11,980 --> 01:10:16,780
Jadi hal pertama yang saya lakukan adalah memeriksa apakah sistem tersebut memiliki cukup memori

1127
01:10:16,780 --> 01:10:20,850
untuk memberikan kembali 1 integer di tempat pertama, itulah sebabnya aku melakukan ini cek.

1128
01:10:20,850 --> 01:10:25,020
Jika pointer adalah null, yang berarti bahwa ia tidak memiliki cukup ruang atau beberapa error lain terjadi,

1129
01:10:25,020 --> 01:10:26,320
jadi saya harus keluar dari program saya.

1130
01:10:26,320 --> 01:10:29,400
 Tapi jika hal itu berhasil, sekarang saya dapat menggunakan pointer yang

1131
01:10:29,400 --> 01:10:35,020
dan apa pointer * dilakukannya itu berikut di mana alamat adalah

1132
01:10:35,020 --> 01:10:38,480
ke mana nilai yang, dan set itu sama dengan 1.

1133
01:10:38,480 --> 01:10:41,850
Jadi di sini, kita memeriksa apakah memori yang ada.

1134
01:10:41,850 --> 01:10:45,380
>> Setelah Anda tahu itu ada, Anda dapat dimasukkan ke dalamnya

1135
01:10:45,380 --> 01:10:50,460
apa nilai yang Anda inginkan untuk dimasukkan ke dalamnya, dalam hal ini 1.

1136
01:10:50,460 --> 01:10:53,060
Setelah kita sudah selesai dengan hal itu, Anda perlu membebaskan bahwa pointer

1137
01:10:53,060 --> 01:10:57,160
karena kita harus kembali ke sistem yang memori yang Anda minta di tempat pertama.

1138
01:10:57,160 --> 01:10:59,690
Karena komputer tidak tahu kapan kita sudah selesai dengan itu.

1139
01:10:59,690 --> 01:11:02,510
Dalam kasus ini kita secara eksplisit mengatakan, oke, kita sudah selesai dengan memori itu.

1140
01:11:02,510 --> 01:11:10,780
Jika beberapa proses lain membutuhkannya, beberapa program lain membutuhkannya, merasa bebas untuk pergi ke depan dan mengambilnya.

1141
01:11:10,780 --> 01:11:15,110
Apa yang kita juga bisa lakukan adalah kita hanya bisa mendapatkan alamat dari variabel lokal di set.

1142
01:11:15,110 --> 01:11:19,080
Jadi x int adalah dalam bingkai ditumpuk utama.

1143
01:11:19,080 --> 01:11:23,060
Dan ketika kita menggunakan ampersand ini, ini dan operator, apa yang dilakukannya adalah

1144
01:11:23,060 --> 01:11:27,310
dibutuhkan x, dan x adalah hanya beberapa data dalam memori, tetapi memiliki alamat.

1145
01:11:27,310 --> 01:11:33,790
Itu terletak di suatu tempat. Jadi dengan menelepon & x, apa ini tidak akan memberikan kami alamat dari x.

1146
01:11:33,790 --> 01:11:38,430
Dengan melakukan hal ini, kami membuat titik pointer ke mana x adalah dalam memori.

1147
01:11:38,430 --> 01:11:41,710
Sekarang kita hanya sesuatu seperti * x, kita akan mendapatkan 5 kembali.

1148
01:11:41,710 --> 01:11:43,820
Bintang ini disebut dereferencing itu.

1149
01:11:43,820 --> 01:11:46,640
Anda mengikuti alamat dan Anda mendapatkan nilai itu disimpan di sana.

1150
01:11:51,000 --> 01:11:53,310
>> Ada pertanyaan? Ya?

1151
01:11:53,310 --> 01:11:56,500
[Siswa] Jika Anda tidak melakukan hal-3 runcing, apakah itu masih mengkompilasi?

1152
01:11:56,500 --> 01:11:59,490
Ya. Jika Anda tidak melakukan hal-3 pointer, itu masih akan mengkompilasi,

1153
01:11:59,490 --> 01:12:02,720
tapi aku akan menunjukkan kepada Anda apa yang terjadi dalam hitungan detik, dan tanpa melakukan itu,

1154
01:12:02,720 --> 01:12:04,860
itulah yang kita sebut kebocoran memori. Kau tidak memberikan sistem

1155
01:12:04,860 --> 01:12:07,850
kembali memori, sehingga setelah beberapa saat program ini akan menumpuk

1156
01:12:07,850 --> 01:12:10,940
memori bahwa itu tidak menggunakan, dan tidak ada lagi yang bisa menggunakannya.

1157
01:12:10,940 --> 01:12:15,750
Jika Anda pernah melihat Firefox dengan 1,5 juta kilobyte pada komputer Anda,

1158
01:12:15,750 --> 01:12:17,840
di task manager, itulah apa yang terjadi.

1159
01:12:17,840 --> 01:12:20,760
Anda memiliki kebocoran memori dalam program yang mereka tidak menangani.

1160
01:12:23,080 --> 01:12:26,240
Jadi bagaimana pointer bekerja aritmatika?

1161
01:12:26,240 --> 01:12:29,480
Nah, aritmatika pointer adalah semacam pengindeksan sejenisnya ke array.

1162
01:12:29,480 --> 01:12:36,370
Dalam hal ini, saya memiliki pointer, dan apa yang saya lakukan adalah saya membuat titik pointer ke elemen pertama

1163
01:12:36,370 --> 01:12:42,100
dari array 3 bilangan bulat bahwa saya telah dialokasikan.

1164
01:12:42,100 --> 01:12:46,670
Jadi sekarang apa yang saya lakukan, pointer bintang hanya mengubah elemen pertama dalam daftar.

1165
01:12:46,670 --> 01:12:49,140
Bintang pointer +1 poin di sini.

1166
01:12:49,140 --> 01:12:53,140
Jadi pointer adalah di sini, pointer +1 ada di sini, pointer +2 ada di sini.

1167
01:12:53,140 --> 01:12:56,610
>> Jadi hanya menambahkan 1 adalah hal yang sama seperti bergerak sepanjang array ini.

1168
01:12:56,610 --> 01:12:59,880
Apa yang kita lakukan adalah, ketika kita melakukan pointer +1 Anda mendapatkan alamat di sini,

1169
01:12:59,880 --> 01:13:04,180
dan dalam rangka untuk mendapatkan nilai di sini, Anda menempatkan sebuah bintang dalam dari seluruh ekspresi

1170
01:13:04,180 --> 01:13:05,990
untuk dereference itu.

1171
01:13:05,990 --> 01:13:09,940
Jadi, dalam hal ini, saya menetapkan lokasi pertama dalam array ini untuk 1,

1172
01:13:09,940 --> 01:13:13,970
kedua lokasi ke 2, dan lokasi ketiga 3.

1173
01:13:13,970 --> 01:13:18,180
Lalu apa yang saya lakukan di sini adalah aku mencetak pointer kami +1,

1174
01:13:18,180 --> 01:13:19,970
yang hanya memberi saya 2.

1175
01:13:19,970 --> 01:13:23,650
Sekarang aku incrementing pointer, sehingga pointer sama dengan pointer +1,

1176
01:13:23,650 --> 01:13:26,780
yang bergerak ke depan.

1177
01:13:26,780 --> 01:13:30,810
Dan jadi sekarang jika saya mencetak pointer +1, pointer +1 sekarang 3,

1178
01:13:30,810 --> 01:13:33,990
yang dalam hal ini mencetak keluar 3.

1179
01:13:33,990 --> 01:13:36,560
Dan untuk sesuatu yang gratis, pointer yang saya berikan

1180
01:13:36,560 --> 01:13:40,540
harus menunjuk pada awal dari array yang aku pulang dari malloc.

1181
01:13:40,540 --> 01:13:43,430
Jadi, dalam hal ini, jika saya menelepon 3 di sini, ini tidak akan benar,

1182
01:13:43,430 --> 01:13:45,070
karena itu di tengah-tengah array.

1183
01:13:45,070 --> 01:13:48,820
Saya harus mengurangi untuk sampai ke lokasi asli

1184
01:13:48,820 --> 01:13:50,420
tempat pertama awal sebelum saya bisa membebaskannya.

1185
01:13:56,300 --> 01:13:58,450
Jadi, inilah contoh yang lebih terlibat.

1186
01:13:58,450 --> 01:14:03,360
Dalam kasus ini, kita mengalokasikan 7 karakter dalam array karakter.

1187
01:14:03,360 --> 01:14:06,480
>> Dan dalam hal ini apa yang kita lakukan adalah kita perulangan selama 6 pertama mereka,

1188
01:14:06,480 --> 01:14:09,900
dan kami sedang menyiapkan mereka untuk Z.

1189
01:14:09,900 --> 01:14:13,350
Jadi, untuk int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Jadi, pointer + saya hanya akan memberi kita, dalam hal ini,

1191
01:14:16,220 --> 01:14:20,860
pointer, pointer +1, +2 pointer, pointer +3, dan seterusnya dan sebagainya dalam lingkaran.

1192
01:14:20,860 --> 01:14:24,040
Apa yang akan lakukan adalah mendapat alamat itu, dereferences untuk mendapatkan nilai,

1193
01:14:24,040 --> 01:14:27,440
dan perubahan yang nilai ke Z.

1194
01:14:27,440 --> 01:14:30,350
Kemudian pada akhirnya ingat ini adalah string, kan?

1195
01:14:30,350 --> 01:14:33,560
Semua string harus berakhir dengan karakter terminating null.

1196
01:14:33,560 --> 01:14:38,620
Jadi, apa yang saya lakukan adalah di pointer 6 Aku meletakkan karakter null terminator masuk

1197
01:14:38,620 --> 01:14:43,980
Dan sekarang apa yang saya lakukan di sini pada dasarnya adalah menerapkan printf untuk string, kan?

1198
01:14:43,980 --> 01:14:46,190
>> Jadi, kapan printf sekarang ketika itu mencapai akhir dari string?

1199
01:14:46,190 --> 01:14:48,230
Ketika hits karakter terminating null.

1200
01:14:48,230 --> 01:14:52,030
Jadi, dalam hal ini, poin pointer asli saya ke awal array ini.

1201
01:14:52,030 --> 01:14:56,410
Saya mencetak karakter pertama keluar. Aku bergerak lebih dari satu.

1202
01:14:56,410 --> 01:14:58,420
Saya mencetak karakter yang keluar. Saya memindahkannya di atas.

1203
01:14:58,420 --> 01:15:02,180
Dan saya terus melakukan hal ini sampai aku mencapai akhir.

1204
01:15:02,180 --> 01:15:07,750
Dan sekarang pointer * akhir akan dereference ini dan mendapatkan karakter terminating nol kembali.

1205
01:15:07,750 --> 01:15:11,780
Dan jadi loop sementara saya berjalan hanya jika nilai yang tidak mengakhiri karakter null.

1206
01:15:11,780 --> 01:15:13,770
Jadi, sekarang aku keluar dari lingkaran ini.

1207
01:15:18,780 --> 01:15:21,180
Dan jadi jika saya kurangi 6 dari pointer ini,

1208
01:15:21,180 --> 01:15:22,860
Saya kembali semua jalan ke awal.

1209
01:15:22,860 --> 01:15:27,880
Ingat, aku melakukan ini karena saya harus pergi ke awal untuk membebaskan itu.

1210
01:15:27,880 --> 01:15:30,270
>> Jadi, saya tahu itu banyak. Apakah ada pertanyaan?

1211
01:15:30,270 --> 01:15:31,870
Tolong, ya?

1212
01:15:31,870 --> 01:15:36,610
[Mahasiswa dapat dipahami pertanyaan]

1213
01:15:36,610 --> 01:15:38,190
Dapatkah Anda mengatakan bahwa keras? Maaf.

1214
01:15:38,190 --> 01:15:44,140
[Mahasiswa] Pada slide terakhir tepat sebelum Anda membebaskan pointer,

1215
01:15:44,140 --> 01:15:47,300
mana yang Anda benar-benar mengubah nilai pointer?

1216
01:15:47,300 --> 01:15:50,370
[Yusuf] Jadi, di sini. >> [Siswa] Oh, oke.

1217
01:15:50,370 --> 01:15:51,890
[Yusuf] Jadi, saya memiliki pointer dikurangi minus, tepat,

1218
01:15:51,890 --> 01:15:54,140
yang bergerak hal kembali satu, dan kemudian aku membebaskan itu,

1219
01:15:54,140 --> 01:15:57,000
karena pointer ini harus menunjuk ke awal array.

1220
01:15:57,000 --> 01:16:00,420
[Mahasiswa] Tapi itu tidak akan diperlukan telah Anda berhenti setelah baris itu.

1221
01:16:00,420 --> 01:16:03,130
[Yusuf] Jadi, jika saya telah berhenti setelah ini, ini akan dianggap sebagai kebocoran memori,

1222
01:16:03,130 --> 01:16:04,810
karena saya tidak menjalankan gratis.

1223
01:16:04,810 --> 01:16:11,290
[Mahasiswa] I [dipahami] setelah tiga baris pertama di mana Anda memiliki pointer +1 [dipahami].

1224
01:16:11,290 --> 01:16:13,140
[Joseph] Uh-huh. Jadi, apa ada pertanyaan?

1225
01:16:13,140 --> 01:16:14,780
Maaf. Tidak, tidak. Pergi, pergi, silakan.

1226
01:16:14,780 --> 01:16:16,870
[Mahasiswa] Jadi, Anda tidak mengubah nilai pointer.

1227
01:16:16,870 --> 01:16:19,130
Anda tidak akan harus melakukan pointer dikurangi minus.

1228
01:16:19,130 --> 01:16:19,730
[Yusuf] Ya, tepatnya.

1229
01:16:19,730 --> 01:16:21,890
Jadi, ketika saya melakukan pointer dan pointer +1 +2,

1230
01:16:21,890 --> 01:16:24,410
Aku tidak melakukan pointer sama dengan pointer +1.

1231
01:16:24,410 --> 01:16:27,260
Jadi, pointer hanya tetap menunjuk pada awal array.

1232
01:16:27,260 --> 01:16:31,460
Hanya ketika saya lakukan plus plus yang menetapkan nilai kembali ke dalam pointer,

1233
01:16:31,460 --> 01:16:33,550
bahwa itu benar-benar bergerak ini bersama.

1234
01:16:36,860 --> 01:16:37,780
Baiklah.

1235
01:16:40,550 --> 01:16:42,030
Lebih banyak pertanyaan?

1236
01:16:44,680 --> 01:16:47,790
>> Sekali lagi, jika ini adalah semacam luar biasa, hal ini akan dibahas dalam sesi.

1237
01:16:47,790 --> 01:16:50,710
Tanyakan rekan mengajar Anda tentang hal itu, dan kita dapat menjawab pertanyaan-pertanyaan di akhir.

1238
01:16:53,510 --> 01:16:56,600
Dan biasanya kita tidak ingin melakukan hal ini dikurangi.

1239
01:16:56,600 --> 01:16:59,760
Hal ini harus mengharuskan saya melacak betapa aku offset dalam array.

1240
01:16:59,760 --> 01:17:04,520
Jadi, secara umum, ini hanya untuk menjelaskan bagaimana karya pointer aritmatika.

1241
01:17:04,520 --> 01:17:07,970
Tapi apa yang biasanya kita ingin lakukan adalah kita ingin membuat salinan pointer,

1242
01:17:07,970 --> 01:17:11,640
dan kemudian kita akan menggunakan salinan bahwa ketika kita sedang bergerak di dalam string.

1243
01:17:11,640 --> 01:17:14,660
Jadi, dalam hal ini Anda menggunakan salin untuk mencetak seluruh string,

1244
01:17:14,660 --> 01:17:19,040
tapi kita tidak harus melakukan seperti pointer minus 6 atau melacak berapa banyak kita pindah dalam hal ini,

1245
01:17:19,040 --> 01:17:22,700
hanya karena kita tahu bahwa titik awal kita masih menunjuk ke awal daftar

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 pointer asli Anda.

1248
01:17:28,250 --> 01:17:32,350
Jangan mencoba untuk semacam seperti - jangan mengubah salinan asli.

1249
01:17:32,350 --> 01:17:35,290
Mencoba untuk mengubah salinan hanya asli Anda.

1250
01:17:41,540 --> 01:17:44,870
Jadi, Anda perhatikan ketika kami melewati string menjadi printf

1251
01:17:44,870 --> 01:17:48,990
Anda tidak harus meletakkan bintang di depannya seperti yang kami lakukan dengan semua dereferences lain, kan?

1252
01:17:48,990 --> 01:17:54,180
Jadi, jika Anda mencetak s seluruh string% mengharapkan adalah alamat,

1253
01:17:54,180 --> 01:17:57,610
dan dalam hal ini pointer atau dalam hal ini seperti sebuah array karakter.

1254
01:17:57,610 --> 01:18:00,330
>> Karakter, char * s, dan array adalah hal yang sama.

1255
01:18:00,330 --> 01:18:03,690
Pointer adalah karakter, dan karakter array adalah hal yang sama.

1256
01:18:03,690 --> 01:18:05,720
Dan sebagainya, yang harus kita lakukan adalah lulus dalam pointer.

1257
01:18:05,720 --> 01:18:08,150
Kami tidak harus melewati di seperti pointer * atau sesuatu seperti itu.

1258
01:18:13,110 --> 01:18:14,930
Jadi, array dan pointer adalah hal yang sama.

1259
01:18:14,930 --> 01:18:19,160
Ketika Anda melakukan sesuatu seperti x [y] di sini untuk array,

1260
01:18:19,160 --> 01:18:21,960
apa yang dilakukannya di bawah tenda adalah itu mengatakan, oke, itu adalah array karakter,

1261
01:18:21,960 --> 01:18:23,690
jadi pointer.

1262
01:18:23,690 --> 01:18:26,510
Dan sehingga x adalah hal yang sama,

1263
01:18:26,510 --> 01:18:28,650
dan jadi apa yang dilakukannya itu menambahkan y untuk x,

1264
01:18:28,650 --> 01:18:31,820
yang merupakan hal yang sama seperti bergerak maju dalam memori yang banyak.

1265
01:18:31,820 --> 01:18:34,930
Dan sekarang x + y memberi kita semacam alamat,

1266
01:18:34,930 --> 01:18:37,570
dan kami dereference alamat atau mengikuti panah

1267
01:18:37,570 --> 01:18:41,640
ke tempat yang lokasi di memori dan kami mendapatkan nilai keluar dari lokasi di memori.

1268
01:18:41,640 --> 01:18:43,720
Jadi, sehingga kedua adalah hal yang persis sama.

1269
01:18:43,720 --> 01:18:45,840
Ini hanya sintaksis gula.

1270
01:18:45,840 --> 01:18:48,090
Mereka melakukan hal yang sama. Mereka hanya Syntactics yang berbeda satu sama lain.

1271
01:18:51,500 --> 01:18:57,590
>> Jadi, apa yang bisa salah dengan pointer? Seperti, banyak. Oke. Jadi, hal-hal buruk.

1272
01:18:57,590 --> 01:19:02,410
Beberapa hal-hal buruk yang dapat Anda lakukan tidak memeriksa apakah panggilan malloc Anda mengembalikan null, kan?

1273
01:19:02,410 --> 01:19:06,560
Dalam kasus ini, saya minta sistem untuk memberikan - berapa nomor itu?

1274
01:19:06,560 --> 01:19:11,200
Seperti 2 miliar kali 4, karena ukuran integer adalah 4 byte.

1275
01:19:11,200 --> 01:19:13,810
Saya minta itu untuk seperti 8 miliar byte.

1276
01:19:13,810 --> 01:19:17,270
Tentu saja komputer saya tidak akan bisa memberikan itu kembali banyak memori.

1277
01:19:17,270 --> 01:19:20,960
Dan kami tidak memeriksa apakah ini adalah nol, sehingga ketika kita mencoba untuk dereference itu di sana -

1278
01:19:20,960 --> 01:19:24,270
ikuti panah ke mana itu akan - kita tidak memiliki memori itu.

1279
01:19:24,270 --> 01:19:27,150
Ini adalah apa yang kita sebut dereferencing pointer null.

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 bisa segfault.

1282
01:19:34,090 --> 01:19:38,090
Hal-hal buruk lainnya yang dapat Anda lakukan - oh baik.

1283
01:19:38,090 --> 01:19:40,650
Itu dereferencing pointer null. Oke.

1284
01:19:40,650 --> 01:19:45,160
Hal-hal buruk lainnya - baik, untuk memperbaiki bahwa Anda hanya menempatkan cek di sana

1285
01:19:45,160 --> 01:19:46,980
yang memeriksa apakah pointer adalah null

1286
01:19:46,980 --> 01:19:51,000
dan keluar dari program jika terjadi malloc yang mengembalikan pointer null.

1287
01:19:55,110 --> 01:19:59,850
Itulah komik xkcd. Orang mengerti sekarang. Semacam.

1288
01:20:06,120 --> 01:20:09,350
>> Jadi, memori. Dan aku pergi selama ini.

1289
01:20:09,350 --> 01:20:12,000
Kami memanggil malloc dalam satu lingkaran, tapi setiap kali kita sebut malloc

1290
01:20:12,000 --> 01:20:14,370
kita kehilangan jejak di mana pointer ini menunjuk ke,

1291
01:20:14,370 --> 01:20:15,750
karena kita clobbering itu.

1292
01:20:15,750 --> 01:20:18,410
Jadi, panggilan awal untuk malloc memberi saya memori di sini.

1293
01:20:18,410 --> 01:20:19,990
Saya pointer pointer ini.

1294
01:20:19,990 --> 01:20:23,020
Sekarang, saya tidak membebaskannya, jadi sekarang saya sebut malloc lagi.

1295
01:20:23,020 --> 01:20:26,070
Sekarang ini menunjuk ke sini. Sekarang memori saya menunjuk di 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
Tapi aku sudah kehilangan jejak alamat dari semua memori di sini bahwa saya dialokasikan.

1298
01:20:31,820 --> 01:20:35,100
Dan jadi sekarang saya tidak punya referensi untuk mereka lagi.

1299
01:20:35,100 --> 01:20:37,230
Jadi, saya tidak bisa membebaskan mereka di luar lingkaran ini.

1300
01:20:37,230 --> 01:20:39,390
Dan sebagainya dalam rangka untuk memperbaiki sesuatu seperti ini,

1301
01:20:39,390 --> 01:20:42,250
jika Anda lupa untuk membebaskan memori dan Anda mendapatkan kebocoran memori,

1302
01:20:42,250 --> 01:20:45,810
Anda harus membebaskan memori dalam lingkaran ini setelah Anda selesai dengan itu.

1303
01:20:45,810 --> 01:20:51,400
Nah, inilah yang terjadi. Saya tahu banyak dari Anda benci ini.

1304
01:20:51,400 --> 01:20:55,270
Tapi sekarang - yay! Anda mendapatkan seperti 44.000 kilobyte.

1305
01:20:55,270 --> 01:20:57,110
Jadi, Anda bebas itu pada akhir loop,

1306
01:20:57,110 --> 01:20:59,770
dan itu akan hanya membebaskan memori setiap waktu.

1307
01:20:59,770 --> 01:21:03,620
Pada dasarnya, program anda tidak memiliki kebocoran memori lagi.

1308
01:21:03,620 --> 01:21:08,150
>> Dan sekarang hal lain yang dapat Anda lakukan adalah membebaskan beberapa memori yang telah Anda minta dua kali.

1309
01:21:08,150 --> 01:21:11,060
Dalam hal ini, sesuatu malloc, Anda mengubah nilainya.

1310
01:21:11,060 --> 01:21:13,140
Anda bebas sekali karena Anda mengatakan Anda selesai dengan itu.

1311
01:21:13,140 --> 01:21:14,940
Tapi kemudian kami dibebaskan lagi.

1312
01:21:14,940 --> 01:21:16,730
Ini adalah sesuatu yang sangat buruk.

1313
01:21:16,730 --> 01:21:18,820
Ini tidak akan awalnya segfault,

1314
01:21:18,820 --> 01:21:23,350
tapi setelah beberapa saat apa yang tidak membebaskan ganda ini merusak struktur tumpukan Anda,

1315
01:21:23,350 --> 01:21:27,200
dan Anda akan belajar sedikit lebih banyak tentang hal ini jika Anda memilih untuk mengambil kelas seperti CS61.

1316
01:21:27,200 --> 01:21:30,000
Tapi pada dasarnya setelah beberapa saat komputer Anda akan bingung

1317
01:21:30,000 --> 01:21:33,010
tentang apa lokasi memori yang mana dan di mana itu disimpan -

1318
01:21:33,010 --> 01:21:34,800
dimana data disimpan dalam memori.

1319
01:21:34,800 --> 01:21:38,080
Dan sehingga membebaskan pointer dua kali adalah hal yang buruk yang Anda tidak ingin lakukan.

1320
01:21:38,080 --> 01:21:41,600
>> Hal-hal lain yang bisa salah tidak menggunakan sizeof.

1321
01:21:41,600 --> 01:21:44,460
Jadi, dalam hal ini Anda malloc 8 byte,

1322
01:21:44,460 --> 01:21:46,700
dan itulah hal yang sama seperti dua bilangan bulat, kan?

1323
01:21:46,700 --> 01:21:49,580
Jadi, itu benar-benar aman, tetapi apakah itu?

1324
01:21:49,580 --> 01:21:52,160
Yah, seperti Lucas berbicara tentang pada arsitektur yang berbeda,

1325
01:21:52,160 --> 01:21:54,220
bilangan bulat dengan panjang yang berbeda.

1326
01:21:54,220 --> 01:21:57,970
Jadi, pada alat yang Anda gunakan, bilangan bulat sekitar 4 byte,

1327
01:21:57,970 --> 01:22:02,370
tapi pada beberapa sistem lain mereka mungkin 8 byte atau mereka mungkin 16 byte.

1328
01:22:02,370 --> 01:22:05,680
Jadi, jika saya hanya menggunakan nomor ini di sini,

1329
01:22:05,680 --> 01:22:07,310
program ini bisa bekerja pada alat,

1330
01:22:07,310 --> 01:22:10,360
tapi itu tidak akan mengalokasikan cukup memori pada beberapa sistem lain.

1331
01:22:10,360 --> 01:22:14,020
Dalam kasus ini, ini adalah apa operator sizeof digunakan untuk.

1332
01:22:14,020 --> 01:22:16,880
Ketika kita sebut sizeof (int), apa yang dilakukan adalah

1333
01:22:16,880 --> 01:22:21,910
 memberikan kita ukuran integer pada sistem bahwa program ini berjalan.

1334
01:22:21,910 --> 01:22:25,490
Jadi, dalam hal ini, sizeof (int) akan kembali 4 pada sesuatu seperti alat,

1335
01:22:25,490 --> 01:22:29,980
dan sekarang ini kehendak 4 * 2, yaitu 8,

1336
01:22:29,980 --> 01:22:32,330
yang hanya jumlah ruang yang diperlukan untuk dua bilangan bulat.

1337
01:22:32,330 --> 01:22:36,710
Pada sistem yang berbeda, jika int seperti 16 byte atau 8 byte,

1338
01:22:36,710 --> 01:22:39,380
itu hanya akan kembali byte cukup untuk menyimpan jumlah tersebut.

1339
01:22:41,830 --> 01:22:45,310
>> Dan akhirnya, structs.

1340
01:22:45,310 --> 01:22:48,340
Jadi, jika Anda ingin menyimpan papan sudoku dalam memori, bagaimana mungkin kita melakukan ini?

1341
01:22:48,340 --> 01:22:51,570
Anda mungkin berpikir seperti variabel untuk hal pertama,

1342
01:22:51,570 --> 01:22:53,820
variabel untuk hal kedua, variabel untuk hal yang ketiga,

1343
01:22:53,820 --> 01:22:56,420
variabel untuk hal yang keempat - yang buruk, kan?

1344
01:22:56,420 --> 01:23:00,750
Jadi, salah satu perbaikan Anda dapat membuat di atas ini adalah untuk membuat 9 x 9 array.

1345
01:23:00,750 --> 01:23:04,480
Itu baik-baik saja, tetapi bagaimana jika Anda ingin mengaitkan hal-hal lain dengan papan sudoku

1346
01:23:04,480 --> 01:23:06,490
seperti apa kesulitan papan adalah,

1347
01:23:06,490 --> 01:23:11,740
atau, misalnya, berapa skor Anda, atau berapa banyak waktu itu diambil Anda untuk memecahkan forum ini?

1348
01:23:11,740 --> 01:23:14,970
Nah, apa yang dapat Anda lakukan adalah Anda dapat membuat sebuah struct.

1349
01:23:14,970 --> 01:23:18,910
Apa yang saya katakan adalah pada dasarnya aku mendefinisikan struktur ini di sini,

1350
01:23:18,910 --> 01:23:23,230
dan aku mendefinisikan papan sudoku yang terdiri dari papan yang 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> Dan apa yang telah ia memiliki pointer ke nama tingkat.

1352
01:23:26,650 --> 01:23:30,730
Ia juga memiliki x dan y, yang merupakan koordinat keberadaan saya sekarang.

1353
01:23:30,730 --> 01:23:35,980
Ini juga memiliki waktu yang dihabiskan [dimengerti], dan memiliki jumlah total bergerak saya sudah diinput sejauh ini.

1354
01:23:35,980 --> 01:23:40,010
Dan sehingga dalam kasus ini, saya dapat mengelompokkan sejumlah besar data ke dalam satu struktur

1355
01:23:40,010 --> 01:23:42,790
daripada harus seperti terbang di sekitar seperti variabel yang berbeda

1356
01:23:42,790 --> 01:23:44,540
bahwa saya tidak bisa benar-benar melacak.

1357
01:23:44,540 --> 01:23:49,720
Dan ini memungkinkan kita hanya memiliki sintaks bagus untuk semacam referensi hal yang berbeda dalam struct ini.

1358
01:23:49,720 --> 01:23:53,430
Saya hanya bisa melakukan board.board, dan saya mendapatkan papan sudoku kembali.

1359
01:23:53,430 --> 01:23:56,320
Board.level, saya mendapatkan betapa sulitnya itu.

1360
01:23:56,320 --> 01:24:00,540
Board.x dan board.y memberikan koordinat di mana aku bisa berada di papan.

1361
01:24:00,540 --> 01:24:04,730
Dan jadi aku mengakses apa yang kita sebut bidang dalam struct.

1362
01:24:04,730 --> 01:24:08,840
Ini mendefinisikan sudokuBoard, yang merupakan jenis yang saya miliki.

1363
01:24:08,840 --> 01:24:14,800
Dan sekarang kita di sini. Saya memiliki sebuah variabel yang disebut "papan" dari sudokuBoard jenis.

1364
01:24:14,800 --> 01:24:18,820
Dan jadi sekarang saya dapat mengakses semua bidang yang membentuk struktur ini di sini.

1365
01:24:20,830 --> 01:24:22,450
>> Setiap pertanyaan tentang struct? Ya?

1366
01:24:22,450 --> 01:24:25,890
[Mahasiswa] Untuk int x, y, Anda menyatakan baik pada satu baris? >> [Joseph] Uh-huh.

1367
01:24:25,890 --> 01:24:27,400
[Mahasiswa] Jadi, bisa Anda hanya melakukan itu dengan mereka semua?

1368
01:24:27,400 --> 01:24:31,200
Seperti di x, y kali koma yang total?

1369
01:24:31,200 --> 01:24:34,460
[Yusuf] Ya, Anda pasti bisa melakukan itu, tetapi alasan saya menempatkan x dan y pada baris yang sama -

1370
01:24:34,460 --> 01:24:36,330
dan pertanyaannya adalah mengapa kita hanya melakukan ini pada baris yang sama?

1371
01:24:36,330 --> 01:24:38,600
Mengapa kita tidak hanya menempatkan semua pada baris yang sama adalah

1372
01:24:38,600 --> 01:24:42,090
x dan y yang terkait satu sama lain,

1373
01:24:42,090 --> 01:24:44,780
dan ini hanya Gaya lebih benar, dalam arti,

1374
01:24:44,780 --> 01:24:46,600
karena itu pengelompokan dua hal pada baris yang sama

1375
01:24:46,600 --> 01:24:49,340
semacam seperti dari berhubungan dengan hal yang sama.

1376
01:24:49,340 --> 01:24:51,440
Dan saya hanya membagi ini terpisah. Ini hanya hal gaya.

1377
01:24:51,440 --> 01:24:53,720
Ini fungsional ada bedanya sama sekali.

1378
01:24:58,150 --> 01:24:59,270
Ada pertanyaan lain pada structs?

1379
01:25:03,030 --> 01:25:06,620
Anda dapat mendefinisikan Pokédex dengan struct.

1380
01:25:06,620 --> 01:25:11,720
Sebuah Pokémon memiliki nomor dan memiliki surat, pemilik, tipe.

1381
01:25:11,720 --> 01:25:16,990
Dan kemudian jika Anda memiliki sebuah array Pokémon, Anda dapat membuat Pokédex, kan?

1382
01:25:16,990 --> 01:25:20,810
Oke, dingin. Jadi, pertanyaan tentang struct. Mereka adalah terkait dengan struct.

1383
01:25:20,810 --> 01:25:25,270
>> Akhirnya, GDB. Apa GDB membiarkan Anda lakukan? Ini memungkinkan Anda men-debug program Anda.

1384
01:25:25,270 --> 01:25:27,650
Dan jika Anda belum pernah menggunakan GDB, saya akan merekomendasikan menonton singkat

1385
01:25:27,650 --> 01:25:31,250
dan hanya akan atas apa GDB adalah, bagaimana Anda bekerja dengan itu, bagaimana Anda dapat menggunakannya,

1386
01:25:31,250 --> 01:25:32,900
dan mengujinya pada sebuah program.

1387
01:25:32,900 --> 01:25:37,400
Dan jadi apa GDB memungkinkan Anda lakukan adalah itu memungkinkan jeda [dimengerti] up program Anda

1388
01:25:37,400 --> 01:25:38,920
dan garis praktis.

1389
01:25:38,920 --> 01:25:42,600
Sebagai contoh, saya ingin eksekusi jeda di seperti baris 3 dari program saya,

1390
01:25:42,600 --> 01:25:46,010
dan sementara aku di baris 3 saya bisa mencetak semua nilai-nilai yang ada.

1391
01:25:46,010 --> 01:25:49,710
Dan jadi apa yang kita sebut seperti berhenti di baris

1392
01:25:49,710 --> 01:25:52,350
yang kita sebut ini menempatkan breakpoint pada baris yang

1393
01:25:52,350 --> 01:25:55,920
dan kemudian kita bisa mencetak variabel pada keadaan program pada waktu itu.

1394
01:25:55,920 --> 01:25:58,990
>> Kita kemudian dapat dari sana langkah melalui program baris demi baris.

1395
01:25:58,990 --> 01:26:03,200
Dan kemudian kita dapat melihat keadaan stack pada saat itu.

1396
01:26:03,200 --> 01:26:08,600
Dan agar dapat menggunakan GDB, apa yang kita lakukan adalah kita sebut dentang pada file C,

1397
01:26:08,600 --> 01:26:11,290
tapi kita harus lulus bendera ggdb-.

1398
01:26:11,290 --> 01:26:15,850
Dan setelah kami selesai dengan itu kita hanya menjalankan gdb pada file output yang dihasilkan.

1399
01:26:15,850 --> 01:26:18,810
Dan sehingga Anda mendapatkan beberapa massa seperti teks seperti ini,

1400
01:26:18,810 --> 01:26:21,990
tapi benar-benar harus Anda lakukan adalah mengetikkan perintah di awal.

1401
01:26:21,990 --> 01:26:24,250
Istirahat utama menempatkan breakpoint di utama.

1402
01:26:24,250 --> 01:26:28,470
Daftar 400 daftar baris kode sekitar baris 400.

1403
01:26:28,470 --> 01:26:31,410
Dan sehingga dalam hal ini Anda hanya dapat melihat-lihat dan berkata, oh,

1404
01:26:31,410 --> 01:26:34,360
Saya ingin mengatur breakpoint pada baris 397, yang merupakan baris ini,

1405
01:26:34,360 --> 01:26:37,170
dan kemudian program anda berjalan ke langkah itu dan itu akan pecah.

1406
01:26:37,170 --> 01:26:41,120
Ini akan berhenti di sana, dan Anda dapat mencetak, misalnya, nilai rendah atau tinggi.

1407
01:26:41,120 --> 01:26:46,410
Dan jadi ada sekelompok perintah yang perlu Anda ketahui,

1408
01:26:46,410 --> 01:26:48,660
dan slideshow ini akan naik pada website,

1409
01:26:48,660 --> 01:26:54,000
jadi jika Anda hanya ingin referensi ini atau seperti menempatkan mereka pada lembar Anda curang, merasa bebas.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. Itu Kuis Ulasan 0, dan kami akan tetap sekitar jika Anda memiliki pertanyaan.

1411
01:27:00,650 --> 01:27:03,850
Baiklah.

1412
01:27:03,850 --> 01:27:09,030
>>  [Tepuk tangan]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]