1
00:00:00,000 --> 00:00:02,490
[Powered by Google Translate] [CS50 Perpustakaan]

2
00:00:02,490 --> 00:00:04,220
[Nate Hardison] [Universiti Harvard]

3
00:00:04,220 --> 00:00:07,260
[Ini adalah CS50. CS50.TV]

4
00:00:07,260 --> 00:00:11,510
Perpustakaan CS50 adalah alat yang berguna yang kita telah dipasang pada perkakas

5
00:00:11,510 --> 00:00:15,870
untuk membuat ia lebih mudah bagi anda untuk menulis program yang pengguna segera untuk input.

6
00:00:15,870 --> 00:00:21,670
Dalam video ini, kita akan tarik balik tirai dan melihat apa yang sebenarnya adalah di perpustakaan CS50.

7
00:00:21,670 --> 00:00:25,520
>> Dalam video di perpustakaan C, kita bercakap tentang bagaimana anda # include pengepala fail

8
00:00:25,520 --> 00:00:27,570
perpustakaan dalam kod sumber anda,

9
00:00:27,570 --> 00:00:31,150
dan kemudian anda dihubungkan dengan fail perpustakaan binari semasa fasa yang menghubungkan

10
00:00:31,150 --> 00:00:33,140
proses penyusunan.

11
00:00:33,140 --> 00:00:36,440
Fail-fail header menentukan antara muka perpustakaan.

12
00:00:36,440 --> 00:00:41,280
Iaitu, mereka terperinci semua sumber bahawa perpustakaan mempunyai tersedia untuk anda gunakan,

13
00:00:41,280 --> 00:00:45,250
seperti pengisytiharan fungsi, pemalar, dan jenis data.

14
00:00:45,250 --> 00:00:48,890
Fail perpustakaan binari mengandungi pelaksanaan perpustakaan,

15
00:00:48,890 --> 00:00:54,580
yang disusun dari fail header perpustakaan dan perpustakaan. c kod fail sumber.

16
00:00:54,580 --> 00:00:59,820
>> Fail perpustakaan binari tidak sangat menarik untuk melihat kerana ia adalah, baik, dalam perduaan.

17
00:00:59,820 --> 00:01:03,300
Jadi, mari kita lihat pada fail header untuk perpustakaan dan bukannya.

18
00:01:03,300 --> 00:01:07,710
Dalam kes ini, hanya terdapat satu fail header dipanggil cs50.h.

19
00:01:07,710 --> 00:01:11,040
Kami telah dipasang dalam pengguna termasuk direktori

20
00:01:11,040 --> 00:01:15,150
bersama-sama dengan fail header perpustakaan sistem lain '.

21
00:01:15,150 --> 00:01:21,530
>> Salah satu perkara pertama yang anda akan notis adalah bahawa cs50.h # termasuk fail header dari perpustakaan lain -

22
00:01:21,530 --> 00:01:25,670
apungan, had, standard bool, dan lib standard.

23
00:01:25,670 --> 00:01:28,800
Sekali lagi, berikutan prinsip tidak Reinventing roda,

24
00:01:28,800 --> 00:01:33,490
kami telah membina perpustakaan CS0 menggunakan alat yang lain yang disediakan untuk kita.

25
00:01:33,490 --> 00:01:38,690
>> Perkara seterusnya yang anda akan melihat di perpustakaan adalah bahawa kita menentukan jenis baru yang dipanggil "tali."

26
00:01:38,690 --> 00:01:42,330
Keturunan ini benar-benar hanya mewujudkan alias untuk jenis * char,

27
00:01:42,330 --> 00:01:46,000
supaya ia tidak ajaib pengajaran jenis rentetan baru dengan sifat-sifat

28
00:01:46,000 --> 00:01:49,650
sering dikaitkan dengan objek rentetan dalam bahasa-bahasa lain,

29
00:01:49,650 --> 00:01:50,850
seperti panjang.

30
00:01:50,850 --> 00:01:55,180
Sebab kita telah melakukan ini adalah untuk melindungi pengaturcara baru dari butiran ngeri

31
00:01:55,180 --> 00:01:57,580
petunjuk sehingga mereka sudah bersedia.

32
00:01:57,580 --> 00:02:00,130
>> Bahagian seterusnya fail header adalah pengisytiharan fungsi

33
00:02:00,130 --> 00:02:04,410
bahawa perpustakaan CS50 menyediakan bersama-sama dengan dokumentasi.

34
00:02:04,410 --> 00:02:06,940
Notis tahap terperinci dalam komen-komen di sini.

35
00:02:06,940 --> 00:02:10,560
Ini adalah sangat penting supaya orang tahu bagaimana untuk menggunakan fungsi ini.

36
00:02:10,560 --> 00:02:19,150
Kami mengaku, pada gilirannya, berfungsi untuk segera turun dan aksara pulangan, beregu, pelampung, ints,

37
00:02:19,150 --> 00:02:24,160
panjang Roh meronta-ronta, dan tali, menggunakan jenis tali kita sendiri.

38
00:02:24,160 --> 00:02:26,260
Berikutan prinsip menyembunyikan maklumat,

39
00:02:26,260 --> 00:02:31,640
kami telah meletakkan definisi kami dalam fail berasingan pelaksanaan c - cs50.c -

40
00:02:31,640 --> 00:02:35,110
terletak dalam direktori sumber pengguna.

41
00:02:35,110 --> 00:02:38,040
Kami telah menyediakan fail tersebut supaya anda boleh mengambil melihat pada ia,

42
00:02:38,040 --> 00:02:41,490
belajar daripadanya, dan susun semula pada mesin yang berbeza jika anda mahu,

43
00:02:41,490 --> 00:02:45,510
walaupun kita fikir ia adalah lebih baik untuk bekerja pada perkakas untuk kelas ini.

44
00:02:45,510 --> 00:02:47,580
Bagaimanapun, mari kita melihat pada ia sekarang.

45
00:02:49,020 --> 00:02:54,620
>> Fungsi GetChar, GetDouble, GetFloat, GetInt, dan GetLongLong

46
00:02:54,620 --> 00:02:58,160
semua dibina di atas fungsi GetString.

47
00:02:58,160 --> 00:03:01,510
Ia ternyata bahawa mereka semua mengikuti dasarnya corak yang sama.

48
00:03:01,510 --> 00:03:04,870
Mereka menggunakan gelung sementara untuk segera turun satu baris input.

49
00:03:04,870 --> 00:03:08,430
Mereka kembali nilai istimewa jika pengguna input satu baris kosong.

50
00:03:08,430 --> 00:03:11,750
Mereka cuba untuk menghuraikan input pengguna sebagai jenis yang sesuai,

51
00:03:11,750 --> 00:03:15,010
char, dua, apungan, dan lain-lain

52
00:03:15,010 --> 00:03:18,710
Dan kemudian mereka sama ada memulangkan hasilnya jika input telah berjaya dipecah

53
00:03:18,710 --> 00:03:21,330
atau mereka reprompt pengguna.

54
00:03:21,330 --> 00:03:24,230
>> Pada tahap yang tinggi, tidak ada yang benar-benar sukar di sini.

55
00:03:24,230 --> 00:03:28,760
Anda mungkin telah ditulis kod sama berstruktur diri anda pada masa lalu.

56
00:03:28,760 --> 00:03:34,720
Mungkin bahagian yang paling samar-cari adalah panggilan sscanf yang mem-parsing input pengguna.

57
00:03:34,720 --> 00:03:38,160
Sscanf adalah sebahagian daripada keluarga input penukaran format.

58
00:03:38,160 --> 00:03:42,300
Ia tinggal di io.h standard, dan tugasnya adalah untuk menghuraikan rentetan C,

59
00:03:42,300 --> 00:03:46,520
mengikut format tertentu, menyimpan keputusan menghuraikan dalam pembolehubah

60
00:03:46,520 --> 00:03:48,720
disediakan oleh pemanggil.

61
00:03:48,720 --> 00:03:53,570
Sejak fungsi input penukaran format yang sangat berguna, digunakan secara meluas fungsi

62
00:03:53,570 --> 00:03:56,160
yang tidak intuitif super pada mulanya,

63
00:03:56,160 --> 00:03:58,300
kami akan pergi lebih bagaimana sscanf berfungsi.

64
00:03:58,300 --> 00:04:03,330
>> Hujah pertama ke sscanf adalah * char - penunjuk kepada watak.

65
00:04:03,330 --> 00:04:05,150
Bagi fungsi untuk berfungsi dengan betul,

66
00:04:05,150 --> 00:04:08,340
watak yang harus menjadi watak pertama rentetan C,

67
00:04:08,340 --> 00:04:12,270
ditamatkan dengan nol \ watak 0.

68
00:04:12,270 --> 00:04:15,120
Ini adalah rentetan untuk menghuraikan

69
00:04:15,120 --> 00:04:18,269
Hujah kedua ke sscanf adalah rentetan format,

70
00:04:18,269 --> 00:04:20,839
biasanya diluluskan sebagai pemalar rentetan,

71
00:04:20,839 --> 00:04:24,040
dan anda mungkin telah melihat rentetan seperti sebelum ini apabila menggunakan printf.

72
00:04:24,040 --> 00:04:28,650
Satu tanda peratus dalam rentetan format menunjukkan specifier penukaran.

73
00:04:28,650 --> 00:04:30,850
Watak sejurus selepas tanda peratus,

74
00:04:30,850 --> 00:04:35,430
menunjukkan jenis C yang kita mahu sscanf untuk menukar.

75
00:04:35,430 --> 00:04:40,090
Di GetInt itu, anda lihat bahawa terdapat% d dan c%.

76
00:04:40,090 --> 00:04:48,690
Ini bermakna bahawa sscanf akan cuba untuk perpuluhan int - d% - dan char - c%.

77
00:04:48,690 --> 00:04:51,510
Untuk specifier penukaran setiap satu dalam rentetan format,

78
00:04:51,510 --> 00:04:56,620
sscanf menjangka hujah yang sepadan kemudian dalam senarai hujah.

79
00:04:56,620 --> 00:05:00,850
Hujah bahawa mesti menunjukkan lokasi yang sesuai ditaip

80
00:05:00,850 --> 00:05:04,000
di mana untuk menyimpan hasil penukaran.

81
00:05:04,000 --> 00:05:08,910
>> Cara biasa untuk melakukan ini adalah untuk mewujudkan pemboleh ubah pada timbunan sebelum panggilan sscanf

82
00:05:08,910 --> 00:05:11,440
bagi setiap item yang anda mahu untuk menghuraikan daripada rentetan

83
00:05:11,440 --> 00:05:15,520
dan kemudian gunakan pengendali alamat - #: glib - untuk lulus petunjuk

84
00:05:15,520 --> 00:05:19,100
kepada pembolehubah panggilan sscanf.

85
00:05:19,100 --> 00:05:22,720
Anda boleh melihat bahawa dalam GetInt kita lakukan betul-betul ini.

86
00:05:22,720 --> 00:05:28,240
Hak sebelum panggilan sscanf, kita mengisytiharkan int dipanggil n dan c panggilan char pada timbunan,

87
00:05:28,240 --> 00:05:32,340
dan kita lulus petunjuk untuk mereka ke panggilan sscanf.

88
00:05:32,340 --> 00:05:35,800
Meletakkan pembolehubah pada timbunan digemari berbanding menggunakan ruang yang diperuntukkan

89
00:05:35,800 --> 00:05:39,350
pada timbunan dengan malloc, kerana anda mengelakkan overhed panggilan malloc,

90
00:05:39,350 --> 00:05:43,060
dan anda tidak perlu bimbang tentang bocor memori.

91
00:05:43,060 --> 00:05:47,280
Aksara tidak awalan tanda peratus tidak meminta penukaran.

92
00:05:47,280 --> 00:05:50,380
Sebaliknya mereka hanya menambah spesifikasi format.

93
00:05:50,380 --> 00:05:56,500
>> Sebagai contoh, jika rentetan format di GetInt% d sebaliknya,

94
00:05:56,500 --> 00:05:59,800
sscanf akan mencari surat yang diikuti oleh int,

95
00:05:59,800 --> 00:06:04,360
dan manakala ia akan cuba untuk menukar int, ia tidak akan berbuat apa-apa lagi dengan.

96
00:06:04,360 --> 00:06:07,440
Satunya pengecualian kepada ini adalah ruang kosong.

97
00:06:07,440 --> 00:06:11,030
Aksara ruang putih dalam rentetan format sepadan dengan mana-mana jumlah ruang kosong -

98
00:06:11,030 --> 00:06:12,890
walaupun tiada pada semua.

99
00:06:12,890 --> 00:06:18,100
Jadi, itulah mengapa komen menyebut mungkin dengan membawa dan / atau ketinggalan ruang kosong.

100
00:06:18,100 --> 00:06:22,910
Jadi, pada ketika ini ia kelihatan seperti panggilan sscanf kami akan cuba untuk menghuraikan rentetan input pengguna

101
00:06:22,910 --> 00:06:25,380
dengan memeriksa mungkin ruangputih putih terkemuka,

102
00:06:25,380 --> 00:06:29,300
diikuti oleh int yang akan ditukar dan disimpan dalam pembolehubah int n

103
00:06:29,300 --> 00:06:33,090
diikuti oleh beberapa jumlah ruang kosong, dan diikuti oleh watak

104
00:06:33,090 --> 00:06:35,810
disimpan dalam c ubah char.

105
00:06:35,810 --> 00:06:37,790
>> Bagaimana tentang nilai pulangan?

106
00:06:37,790 --> 00:06:41,560
Sscanf akan menghuraikan baris input dari awal hingga akhir,

107
00:06:41,560 --> 00:06:44,860
berhenti apabila ia sampai akhir atau apabila watak dalam input

108
00:06:44,860 --> 00:06:49,320
tidak sepadan dengan watak format atau apabila ia tidak boleh membuat penukaran.

109
00:06:49,320 --> 00:06:52,690
Nilai pulangan Ia digunakan untuk satu apabila ia berhenti.

110
00:06:52,690 --> 00:06:55,670
Jika ia berhenti, kerana ia sampai ke penghujung tali input

111
00:06:55,670 --> 00:07:00,630
sebelum membuat apa-apa penukaran dan sebelum gagal untuk memadankan sebahagian rentetan format,

112
00:07:00,630 --> 00:07:04,840
maka EOF berterusan khas dikembalikan.

113
00:07:04,840 --> 00:07:08,200
Jika tidak, ia akan mengembalikan bilangan penukaran yang berjaya,

114
00:07:08,200 --> 00:07:14,380
yang boleh menjadi 0, 1, atau 2, kerana kami telah diminta untuk dua penukaran.

115
00:07:14,380 --> 00:07:19,000
Dalam kes kami, kami ingin memastikan bahawa pengguna ditaip dalam int dan hanya int.

116
00:07:19,000 --> 00:07:23,370
>> Jadi, kita mahu sscanf untuk kembali 1. Lihat mengapa?

117
00:07:23,370 --> 00:07:26,850
Jika sscanf kembali 0, maka tiada penukaran telah dibuat,

118
00:07:26,850 --> 00:07:31,690
jadi pengguna menaip sesuatu yang lain daripada int pada permulaan input.

119
00:07:31,690 --> 00:07:37,100
Jika sscanf kembali 2, maka pengguna tidak betul taip dalam pada permulaan input,

120
00:07:37,100 --> 00:07:41,390
tetapi mereka kemudian ditaip dalam watak beberapa bukan ruang putih selepas itu

121
00:07:41,390 --> 00:07:44,940
sejak% c penukaran berjaya.

122
00:07:44,940 --> 00:07:49,570
Wow, itu penjelasan yang agak panjang untuk satu fungsi panggilan.

123
00:07:49,570 --> 00:07:53,460
Bagaimanapun, jika anda mahu maklumat lanjut pada sscanf dan adik-beradik,

124
00:07:53,460 --> 00:07:57,130
menyemak muka surat manusia, Google, atau kedua-duanya.

125
00:07:57,130 --> 00:07:58,780
Terdapat banyak pilihan rentetan format,

126
00:07:58,780 --> 00:08:03,830
dan ini boleh menjimatkan banyak buruh manual apabila cuba untuk menghuraikan rentetan di C.

127
00:08:03,830 --> 00:08:07,180
>> Fungsi akhir di perpustakaan untuk melihat adalah GetString.

128
00:08:07,180 --> 00:08:10,310
Ia ternyata bahawa GetString adalah fungsi yang sukar untuk menulis dengan betul,

129
00:08:10,310 --> 00:08:14,290
walaupun ia seolah-olah seperti satu tugas yang mudah, biasa.

130
00:08:14,290 --> 00:08:16,170
Mengapa kes ini?

131
00:08:16,170 --> 00:08:21,380
Nah, mari kita berfikir tentang bagaimana kita akan menyimpan baris yang pengguna jenis masuk

132
00:08:21,380 --> 00:08:23,880
Sejak rentetan adalah satu urutan aksara,

133
00:08:23,880 --> 00:08:26,430
kita mungkin mahu untuk menyimpan ia dalam pelbagai pada timbunan,

134
00:08:26,430 --> 00:08:31,250
tetapi kita perlu tahu berapa lama array akan menjadi apabila kita mengisytiharkan ia.

135
00:08:31,250 --> 00:08:34,030
Begitu juga, jika kita mahu meletakkan ia pada timbunan,

136
00:08:34,030 --> 00:08:38,090
kita perlu lulus malloc bilangan bait yang kita mahu untuk menempah,

137
00:08:38,090 --> 00:08:39,730
tetapi ini adalah mustahil.

138
00:08:39,730 --> 00:08:42,760
Kami tidak mempunyai idea berapa banyak aksara pengguna akan menaip

139
00:08:42,760 --> 00:08:46,590
sebelum pengguna sebenarnya tidak menaip mereka.

140
00:08:46,590 --> 00:08:50,720
>> Naif Satu penyelesaian kepada masalah ini adalah untuk hanya menempah sebahagian besar ruang, berkata,

141
00:08:50,720 --> 00:08:54,540
blok 1000 aksara bagi input pengguna,

142
00:08:54,540 --> 00:08:57,980
menganggap bahawa pengguna tidak akan menaip dalam rentetan yang lama.

143
00:08:57,980 --> 00:09:00,810
Ini adalah idea yang buruk kerana dua sebab.

144
00:09:00,810 --> 00:09:05,280
Pertama, andaian yang pengguna biasanya tidak menaip dalam rentetan yang panjang,

145
00:09:05,280 --> 00:09:07,610
anda boleh membazirkan banyak memori.

146
00:09:07,610 --> 00:09:10,530
Pada mesin moden, ini mungkin tidak menjadi isu jika anda melakukan ini

147
00:09:10,530 --> 00:09:13,890
dalam satu atau dua keadaan terpencil,

148
00:09:13,890 --> 00:09:17,630
tetapi jika anda mengambil input pengguna dalam gelung dan menyimpan untuk kegunaan kemudian,

149
00:09:17,630 --> 00:09:20,870
anda dengan cepat boleh menghisap sehingga satu tan ingatan.

150
00:09:20,870 --> 00:09:24,450
Selain itu, jika program yang anda menulis adalah untuk komputer yang lebih kecil -

151
00:09:24,450 --> 00:09:28,100
peranti seperti telefon pintar atau sesuatu yang lain dengan memori yang terhad -

152
00:09:28,100 --> 00:09:32,060
penyelesaian ini akan menyebabkan masalah yang banyak lebih cepat.

153
00:09:32,060 --> 00:09:36,450
Kedua, sebab yang lebih serius untuk tidak melakukan ini adalah bahawa ia meninggalkan program anda terdedah

154
00:09:36,450 --> 00:09:39,710
apa yang dipanggil serangan penampan limpahan.

155
00:09:39,710 --> 00:09:45,840
Dalam pengaturcaraan, penampan adalah memori yang digunakan untuk menyimpan data input atau output sementara,

156
00:09:45,840 --> 00:09:48,980
yang dalam kes ini adalah blok 1000-char kami.

157
00:09:48,980 --> 00:09:53,370
A buffer overflow berlaku apabila data ditulis lepas akhir blok.

158
00:09:53,370 --> 00:09:57,790
>> Sebagai contoh, jika seorang pengguna sebenarnya tidak taip lebih daripada 1000 aksara.

159
00:09:57,790 --> 00:10:01,570
Anda mungkin telah mengalami ini sengaja apabila pengaturcaraan dengan tatasusunan.

160
00:10:01,570 --> 00:10:05,620
Jika anda mempunyai pelbagai sebanyak 10 ints, tiada apa yang menghalang anda daripada cuba untuk membaca atau menulis

161
00:10:05,620 --> 00:10:07,810
int 15.

162
00:10:07,810 --> 00:10:10,000
Tiada amaran pengkompil atau kesilapan.

163
00:10:10,000 --> 00:10:13,250
Program ini hanya kesilapan lurus ke hadapan dan mengakses memori

164
00:10:13,250 --> 00:10:18,150
jika difikirkannya int 15 akan menjadi, dan ini boleh menimpa pembolehubah lain anda.

165
00:10:18,150 --> 00:10:22,040
Dalam kes terburuk, anda boleh overwrite beberapa program anda dalaman

166
00:10:22,040 --> 00:10:26,820
mekanisme kawalan, menyebabkan program anda untuk benar-benar melaksanakan arahan yang berbeza

167
00:10:26,820 --> 00:10:28,340
daripada anda yang dimaksudkan.

168
00:10:28,340 --> 00:10:31,360
>> Kini, ia bukan perkara biasa untuk melakukan ini sengaja,

169
00:10:31,360 --> 00:10:35,150
tetapi ini adalah teknik yang agak biasa bahawa lelaki buruk gunakan untuk memecahkan program

170
00:10:35,150 --> 00:10:39,080
dan meletakkan kod berniat jahat pada komputer orang lain.

171
00:10:39,080 --> 00:10:42,910
Oleh itu, kita tidak boleh hanya menggunakan penyelesaian naif kami.

172
00:10:42,910 --> 00:10:45,590
Kita perlu satu cara untuk menghalang program kami daripada menjadi terdedah

173
00:10:45,590 --> 00:10:47,880
kepada serangan buffer overflow.

174
00:10:47,880 --> 00:10:51,430
Untuk melakukan ini, kita perlu memastikan bahawa penampan kami boleh berkembang seperti yang kita baca

175
00:10:51,430 --> 00:10:53,850
input lebih dari pengguna.

176
00:10:53,850 --> 00:10:57,440
Penyelesaiannya? Kami menggunakan penampan timbunan diperuntukkan.

177
00:10:57,440 --> 00:10:59,950
Sejak kita boleh mengubah saiz ia menggunakan saiz semula fungsi realloc,

178
00:10:59,950 --> 00:11:04,580
dan kami menjejaki dua nombor - indeks slot yang kosong akan datang dalam buffer

179
00:11:04,580 --> 00:11:08,390
dan panjang atau kapasiti penimbal.

180
00:11:08,390 --> 00:11:13,210
Kita membaca dalam aksara dari satu pengguna pada masa menggunakan fungsi fgetc.

181
00:11:13,210 --> 00:11:19,360
Hujah fungsi fgetc mengambil - stdin - adalah rujukan kepada rentetan input standard,

182
00:11:19,360 --> 00:11:23,810
yang merupakan saluran input preconnected yang digunakan untuk memindahkan input pengguna

183
00:11:23,810 --> 00:11:26,270
dari terminal untuk program ini.

184
00:11:26,270 --> 00:11:29,890
>> Apabila pengguna jenis dalam watak baru, kita memeriksa untuk melihat jika indeks

185
00:11:29,890 --> 00:11:35,810
slot bebas akan datang ditambah 1 adalah lebih besar daripada kapasiti penampan.

186
00:11:35,810 --> 00:11:39,690
1 datang dalam kerana jika indeks percuma seterusnya adalah 5,

187
00:11:39,690 --> 00:11:44,150
maka panjang penampan kita mesti 6 terima kasih kepada 0 pengindeksan.

188
00:11:44,150 --> 00:11:48,350
Jika kita telah kehabisan ruang dalam buffer, maka kita cuba untuk mengubah saiz,

189
00:11:48,350 --> 00:11:51,690
menggandakan ia supaya kita mengurangkan bilangan kali bahawa kita mengubah saiz

190
00:11:51,690 --> 00:11:54,760
jika pengguna menaip rentetan benar-benar panjang.

191
00:11:54,760 --> 00:11:57,950
Jika tali itu telah mendapat terlalu lama atau jika kita kehabisan memori timbunan,

192
00:11:57,950 --> 00:12:01,350
kita membebaskan penampan dan batal pulangan.

193
00:12:01,350 --> 00:12:04,170
>> Akhirnya, kami melampirkan char buffer.

194
00:12:04,170 --> 00:12:08,200
Setelah hits pengguna memasuki atau kembali, isyarat baris baru,

195
00:12:08,200 --> 00:12:12,050
atau khas char - kawalan d - yang menandakan akhir input,

196
00:12:12,050 --> 00:12:16,240
kita melakukan pemeriksaan untuk melihat jika pengguna sebenarnya ditaip dalam apa-apa pada semua.

197
00:12:16,240 --> 00:12:18,820
Jika tidak, kita kembali null.

198
00:12:18,820 --> 00:12:22,280
Jika tidak, kerana penampan kita mungkin lebih besar daripada kita perlu,

199
00:12:22,280 --> 00:12:24,830
dalam kes terburuk, ia adalah hampir dua kali ganda besar seperti yang kita perlukan

200
00:12:24,830 --> 00:12:27,830
kerana kita menggandakan setiap kali kita mengubah saiz,

201
00:12:27,830 --> 00:12:31,840
kita membuat salinan baru rentetan menggunakan hanya jumlah ruang yang kita perlukan.

202
00:12:31,840 --> 00:12:34,220
Kami menambah 1 tambahan kepada panggilan malloc,

203
00:12:34,220 --> 00:12:37,810
supaya ada ruang untuk watak terminator khas null - \ 0,

204
00:12:37,810 --> 00:12:41,990
yang kita melampirkan pada tali sekali kita menyalin di seluruh watak-watak,

205
00:12:41,990 --> 00:12:45,060
menggunakan strncpy bukannya strcpy

206
00:12:45,060 --> 00:12:48,830
supaya kita dapat menentukan dengan tepat berapa banyak aksara yang kita mahu untuk menyalin.

207
00:12:48,830 --> 00:12:51,690
Strcpy salinan sehingga ia mencecah \ 0.

208
00:12:51,690 --> 00:12:55,740
Kemudian kita membebaskan penampan kami dan kembalikan salinan kepada pemanggil.

209
00:12:55,740 --> 00:12:59,840
>> Siapa tahu apa-apa fungsi yang mudah seolah-olah boleh begitu rumit?

210
00:12:59,840 --> 00:13:02,820
Sekarang anda tahu apa yang masuk ke dalam perpustakaan CS50.

211
00:13:02,820 --> 00:13:06,470
>> Nama saya adalah Nate Hardison, dan ini adalah CS50.

212
00:13:06,470 --> 00:13:08,350
[CS50.TV]