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

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

3
00:00:04,220 --> 00:00:07,260
[Ito ay CS50. CS50.TV]

4
00:00:07,260 --> 00:00:11,510
Ang CS50 library ay isang kapaki-pakinabang na tool na aming na-install sa appliance

5
00:00:11,510 --> 00:00:15,870
upang gawing mas madali para sa iyo upang sumulat ng mga programa na prompt mga gumagamit para sa input.

6
00:00:15,870 --> 00:00:21,670
Sa video na ito, makikita namin hilahin ang kurtina at tingnan kung ano ang eksaktong ay sa CS50 library.

7
00:00:21,670 --> 00:00:25,520
>> Sa video sa mga aklatan sa C, makipag-usap namin tungkol sa kung paano mo # include file header

8
00:00:25,520 --> 00:00:27,570
ng library sa iyong source code,

9
00:00:27,570 --> 00:00:31,150
at pagkatapos ay i-link mo sa isang binary file ng library sa panahon ng phase ang pag-link

10
00:00:31,150 --> 00:00:33,140
ng compilation proseso.

11
00:00:33,140 --> 00:00:36,440
Ang mga file header tukuyin ang interface ng library.

12
00:00:36,440 --> 00:00:41,280
Iyon ay, sila detalye ng lahat ng mga mapagkukunan na library ay magagamit para sa iyo upang gamitin ang,

13
00:00:41,280 --> 00:00:45,250
tulad ng mga function na pagdeklara, constants, at mga uri ng data.

14
00:00:45,250 --> 00:00:48,890
Ang binary file ng library ay naglalaman ang pagpapatupad ng library,

15
00:00:48,890 --> 00:00:54,580
na inipon mula sa mga file ng header sa library at ang library. c source code file.

16
00:00:54,580 --> 00:00:59,820
>> Ang binary file ng library ay hindi lubhang kawili-wili upang tingnan dahil, well, sa binary.

17
00:00:59,820 --> 00:01:03,300
Kaya, sabihin tingnan ang mga file ng header para sa library sa halip.

18
00:01:03,300 --> 00:01:07,710
Sa kasong ito, mayroon lamang isang header ng file na tinatawag na cs50.h.

19
00:01:07,710 --> 00:01:11,040
Namin na-install ang mga ito sa gumagamit ang direktoryo

20
00:01:11,040 --> 00:01:15,150
kasama ang sa iba pang mga sistema ng aklatan 'file ng header.

21
00:01:15,150 --> 00:01:21,530
>> Isa ng ang unang bagay na mapapansin mo ay cs50.h # ang mga file ng header mula sa iba pang mga aklatan -

22
00:01:21,530 --> 00:01:25,670
Float, mga limitasyon, karaniwang bool, at karaniwang Lib.

23
00:01:25,670 --> 00:01:28,800
Muli, ng pagsunod sa mga prinsipyo ng hindi reinventing ang wheel,

24
00:01:28,800 --> 00:01:33,490
na binuo namin ang CS0 library na gamit ang mga tool na ang ibang para sa amin.

25
00:01:33,490 --> 00:01:38,690
>> Ang susunod na bagay na makikita mo sa library na namin tukuyin ang isang bagong uri ng tinatawag na "string."

26
00:01:38,690 --> 00:01:42,330
Linyang ito ay talagang lamang lumilikha ng isang alias para sa magpasinda * uri,

27
00:01:42,330 --> 00:01:46,000
kaya hindi ito ay magically humitik ang bagong uri ng string na may mga katangian

28
00:01:46,000 --> 00:01:49,650
karaniwang nauugnay sa mga bagay ng string sa iba pang mga wika,

29
00:01:49,650 --> 00:01:50,850
tulad ng haba.

30
00:01:50,850 --> 00:01:55,180
Ang dahilan kung bakit namin nagawa mo na ito sa kalasag ang mga bagong programmer mula sa madugo detalye

31
00:01:55,180 --> 00:01:57,580
ng mga payo hanggang sila ay handa.

32
00:01:57,580 --> 00:02:00,130
>> Ang susunod na bahagi ng file ng header ay ang deklarasyon ng function

33
00:02:00,130 --> 00:02:04,410
na ang CS50 library nagbibigay kasama ang dokumentasyon.

34
00:02:04,410 --> 00:02:06,940
Pansinin ang antas ng detalye sa ang mga komento dito.

35
00:02:06,940 --> 00:02:10,560
Ito ay sobrang mahalaga upang ang mga taong kilala kung paano gamitin ang mga function.

36
00:02:10,560 --> 00:02:19,150
Idedeklara namin, sa pagliko, function upang i-prompt ng gumagamit at return char, Doubles, kamay, ints,

37
00:02:19,150 --> 00:02:24,160
mahaba na longs, at mga string, gamit ang ating sariling uri ng string.

38
00:02:24,160 --> 00:02:26,260
Ng pagsunod sa mga prinsipyo ng impormasyon nagtatago,

39
00:02:26,260 --> 00:02:31,640
ilagay namin ang aming kahulugan sa isang hiwalay na file na c pagpapatupad - cs50.c--

40
00:02:31,640 --> 00:02:35,110
na matatagpuan sa direktoryo ng pinagmulan ng user.

41
00:02:35,110 --> 00:02:38,040
Nagbigay kami ng mga file na sa gayon maaari mong tingnan ito,

42
00:02:38,040 --> 00:02:41,490
matuto mula sa ito, at mag-recompile ito sa ibang machine kung nais mo,

43
00:02:41,490 --> 00:02:45,510
kahit na sa tingin namin ito ay mas mahusay na upang gumana sa appliance para sa uri.

44
00:02:45,510 --> 00:02:47,580
Pa Rin, sabihin tingnan ito ngayon.

45
00:02:49,020 --> 00:02:54,620
>> Ang mga function ng GetChar, GetDouble, GetFloat, GetInt, at GetLongLong

46
00:02:54,620 --> 00:02:58,160
ay itinayo sa tuktok ng GetString function na.

47
00:02:58,160 --> 00:03:01,510
Ito lumiliko out na lahat ng mga ito ay sundin ang mahalagang parehong pattern.

48
00:03:01,510 --> 00:03:04,870
Gamitin ito ay may habang loop upang i-prompt ang user para sa isang linya ng input.

49
00:03:04,870 --> 00:03:08,430
Ibalik ang mga ito ng espesyal na halaga kung ang user input ang isang walang laman na linya.

50
00:03:08,430 --> 00:03:11,750
Tinangka nilang upang i-parse ang input ng user bilang ang naaangkop na uri,

51
00:03:11,750 --> 00:03:15,010
maging ito ng isang pansamantalang trabaho, may double, isang Float, atbp.

52
00:03:15,010 --> 00:03:18,710
At pagkatapos ay ibalik ang resulta kung input ay matagumpay na na-parse

53
00:03:18,710 --> 00:03:21,330
o reprompt sila ang gumagamit.

54
00:03:21,330 --> 00:03:24,230
>> Sa isang mataas na antas, wala talagang nakakalito dito.

55
00:03:24,230 --> 00:03:28,760
Maaari mong nakasulat na katulad nakabalangkas na code ang iyong sarili sa nakaraan.

56
00:03:28,760 --> 00:03:34,720
Marahil ang pinaka mukhang misteriyoso-bahagi ang sscanf tawag na Pina-parse ang input ng user.

57
00:03:34,720 --> 00:03:38,160
Sscanf ay bahagi ng conversion sa format ng input pamilya.

58
00:03:38,160 --> 00:03:42,300
Nakatira sa karaniwang io.h, at ang trabaho nito ay upang i-parse ng C string,

59
00:03:42,300 --> 00:03:46,520
ayon sa isang partikular na format, itinatago ang mga resulta ng parse sa variable

60
00:03:46,520 --> 00:03:48,720
ibinigay ng tumatawag.

61
00:03:48,720 --> 00:03:53,570
Dahil ang format ng input function ng conversion ay masyadong kapaki-pakinabang, malawakang ginagamit function

62
00:03:53,570 --> 00:03:56,160
na hindi sobrang intuitive sa una,

63
00:03:56,160 --> 00:03:58,300
kami sa kung paano sscanf gumagana.

64
00:03:58,300 --> 00:04:03,330
>> Ang unang argumento sa sscanf ay isang pansamantalang trabaho * - isang pointer sa isang character.

65
00:04:03,330 --> 00:04:05,150
Para sa function upang gumana nang maayos,

66
00:04:05,150 --> 00:04:08,340
character na dapat ay ang unang character ng isang string ng C,

67
00:04:08,340 --> 00:04:12,270
winakasan na may null \ 0 karakter.

68
00:04:12,270 --> 00:04:15,120
Ito ay ang string upang i-parse

69
00:04:15,120 --> 00:04:18,269
Ang pangalawang argumento sa sscanf ay isang format string,

70
00:04:18,269 --> 00:04:20,839
karaniwang naipasa in bilang isang string ng pare-pareho,

71
00:04:20,839 --> 00:04:24,040
at maaaring nakakita ka ng isang string tulad nito bago kapag gumagamit ng printf.

72
00:04:24,040 --> 00:04:28,650
Isang porsiyento mag-sign in ang string ng format ay nagpapahiwatig isang conversion specifier.

73
00:04:28,650 --> 00:04:30,850
Agad ang character na ang pagsunod sa isang porsiyento sign,

74
00:04:30,850 --> 00:04:35,430
nagpapahiwatig C uri na gusto naming sscanf i-convert.

75
00:04:35,430 --> 00:04:40,090
Sa Sa GetInt, makita na may% d at% c.

76
00:04:40,090 --> 00:04:48,690
Nangangahulugan ito na sscanf ay subukang ng decimal int -% d - at isang pansamantalang trabaho -% c.

77
00:04:48,690 --> 00:04:51,510
Para sa bawat conversion specifier sa string ng format,

78
00:04:51,510 --> 00:04:56,620
sscanf inaasahan ang isang naaayong argumento sa ibang pagkakataon sa listahan ng argumento.

79
00:04:56,620 --> 00:05:00,850
Argument na dapat ituro sa isang naaangkop na-type na lokasyon

80
00:05:00,850 --> 00:05:04,000
kung saan-imbak ang resulta ng conversion.

81
00:05:04,000 --> 00:05:08,910
>> Ang tipikal na paraan ng paggawa nito ay upang lumikha ng isang variable sa stack bago ang sscanf tawag

82
00:05:08,910 --> 00:05:11,440
para sa bawat item na gusto mong i-parse mula sa string

83
00:05:11,440 --> 00:05:15,520
at pagkatapos ay gamitin ang address ng operator - ang ampersand - upang pumasa sa mga payo

84
00:05:15,520 --> 00:05:19,100
sa mga variable sa tawag sscanf.

85
00:05:19,100 --> 00:05:22,720
Maaari mong makita na sa GetInt gawin namin ang eksaktong ito.

86
00:05:22,720 --> 00:05:28,240
Bago mismo ang tawag ng sscanf, aming ipinapahayag ng isang int tinatawag n at magpasinda c tawag sa stack,

87
00:05:28,240 --> 00:05:32,340
at pumasa kami ng mga payo sa kanila sa tawag ng sscanf.

88
00:05:32,340 --> 00:05:35,800
Paglalagay ng mga variable na ito sa stack ay ginustong sa paglipas ng paggamit ng espasyo inilalaan

89
00:05:35,800 --> 00:05:39,350
sa magbunton sa malloc, dahil mong maiwasan ang overhead ng tawag ng malloc,

90
00:05:39,350 --> 00:05:43,060
at hindi mo na kailangang mag-alala tungkol sa tagas memory.

91
00:05:43,060 --> 00:05:47,280
Character hindi prefix sa pamamagitan ng pag-sign ng porsiyento hindi prompt ng conversion.

92
00:05:47,280 --> 00:05:50,380
Sa halip lang nila idagdag sa detalye ng format.

93
00:05:50,380 --> 00:05:56,500
>> Halimbawa, kung ang string ng format sa GetInt ay% d sa halip,

94
00:05:56,500 --> 00:05:59,800
ay tumingin ng sscanf para sa titik na sinusundan ng isang int,

95
00:05:59,800 --> 00:06:04,360
at habang ito ay subukang i-convert ang int, hindi ito ay gawin ang anumang bagay na may isang.

96
00:06:04,360 --> 00:06:07,440
Ang tanging mga pagbubukod na ito ay whitespace.

97
00:06:07,440 --> 00:06:11,030
Puting espasyo character sa string ng format na tumugma sa anumang mga halaga ng whitespace -

98
00:06:11,030 --> 00:06:12,890
kahit wala sa lahat.

99
00:06:12,890 --> 00:06:18,100
Kaya, na ang dahilan kung bakit ang komento ang pagbanggit posibleng sa mga nangungunang at / o sumusunod whitespace.

100
00:06:18,100 --> 00:06:22,910
Kaya, sa puntong ito mukhang aming sscanf tawag ay subukang i-parse ang input string ang user

101
00:06:22,910 --> 00:06:25,380
sa pamamagitan ng check para sa posibleng nangungunang whitespace,

102
00:06:25,380 --> 00:06:29,300
sinundan sa pamamagitan ng isang int na mako-convert at naka-imbak sa int variable n

103
00:06:29,300 --> 00:06:33,090
sinusundan ng ilang halaga ng whitespace, at sinusundan ng isang character

104
00:06:33,090 --> 00:06:35,810
naka-imbak sa magpasinda variable c.

105
00:06:35,810 --> 00:06:37,790
>> Paano ang tungkol sa mga halaga ng return?

106
00:06:37,790 --> 00:06:41,560
Sscanf ay parse ang linya ng input mula simula hanggang matapos,

107
00:06:41,560 --> 00:06:44,860
pagtigil kapag umabot sa dulo o kapag isang character sa input

108
00:06:44,860 --> 00:06:49,320
ay hindi tumutugma sa isang format ng character o kapag hindi ito gumawa ng conversion.

109
00:06:49,320 --> 00:06:52,690
Ito ang return halaga ay ginagamit sa solong kapag ito tumigil.

110
00:06:52,690 --> 00:06:55,670
Kung huminto ito, dahil naabot na ninyo ang dulo ng input string

111
00:06:55,670 --> 00:07:00,630
bago gumawa ng anumang mga conversion at bago bagsak upang tumugma sa bahagi ng string ng format,

112
00:07:00,630 --> 00:07:04,840
pagkatapos ay ang mga espesyal na pare-pareho ang EOF ay ibinalik.

113
00:07:04,840 --> 00:07:08,200
Kung hindi man, nagbabalik ang bilang ng mga matagumpay na conversion,

114
00:07:08,200 --> 00:07:14,380
na maaaring 0, 1, o 2, dahil tatanungin namin ang para sa dalawang mga conversion.

115
00:07:14,380 --> 00:07:19,000
Sa aming kaso, nais naming tiyakin na ang gumagamit na nai-type sa isang int at lamang sa isang int.

116
00:07:19,000 --> 00:07:23,370
>> Kaya, gusto naming sscanf upang bumalik 1. Makita kung bakit?

117
00:07:23,370 --> 00:07:26,850
Kung sscanf ibinalik 0, pagkatapos ay walang mga conversion ay ginawa,

118
00:07:26,850 --> 00:07:31,690
kaya ang user-type ng isang bagay maliban sa isang int sa simula ng input.

119
00:07:31,690 --> 00:07:37,100
Kung nagbabalik ng sscanf 2, ang user ay maayos type ito sa sa simula ng input,

120
00:07:37,100 --> 00:07:41,390
ngunit pagkatapos nila na nai-type sa ilang di-whitespace character na pagkatapos

121
00:07:41,390 --> 00:07:44,940
simula ng% c conversion nagtagumpay.

122
00:07:44,940 --> 00:07:49,570
Wow, na medyo isang napakahabang paliwanag para sa isang function na tawag.

123
00:07:49,570 --> 00:07:53,460
Pa rin, kung nais mo ng karagdagang impormasyon sa sscanf at ang kapatid,

124
00:07:53,460 --> 00:07:57,130
tingnan ang mga pahina ng tao, Google, o pareho.

125
00:07:57,130 --> 00:07:58,780
Mayroong maraming ng mga pagpipilian sa format string,

126
00:07:58,780 --> 00:08:03,830
at ang mga ito ay maaaring i-save ka ng maraming trabahong pangkamay kapag sinusubukang upang i-parse ang mga string sa C.

127
00:08:03,830 --> 00:08:07,180
>> Ang huling function sa library upang tumingin sa GetString.

128
00:08:07,180 --> 00:08:10,310
Ito lumiliko out na ang GetString ay isang mahirap imaneho function na magsulat ng maayos,

129
00:08:10,310 --> 00:08:14,290
kahit na ito tila tulad ng isang simple, karaniwang gawain.

130
00:08:14,290 --> 00:08:16,170
Bakit ito ang kaso?

131
00:08:16,170 --> 00:08:21,380
Well, sabihin isipin ang tungkol sa kung paano namin upang iimbak ang linya na gumagamit ang mga uri.

132
00:08:21,380 --> 00:08:23,880
Dahil string ay isang pagkakasunud-sunod ng mga karakter,

133
00:08:23,880 --> 00:08:26,430
maaari naming gusto upang mag-imbak ang mga ito sa isang array sa stack,

134
00:08:26,430 --> 00:08:31,250
ngunit kailangan naming malaman kung gaano katagal array ay pagpunta sa kapag ipinapahayag namin ito.

135
00:08:31,250 --> 00:08:34,030
Gayundin, kung gusto naming ilagay ang mga ito sa magbunton,

136
00:08:34,030 --> 00:08:38,090
kailangan namin upang pumasa sa malloc ang bilang ng mga byte gusto naming reserve,

137
00:08:38,090 --> 00:08:39,730
ngunit ito ay imposible.

138
00:08:39,730 --> 00:08:42,760
Wala kaming ideya kung gaano karaming karakter ang user ay type sa

139
00:08:42,760 --> 00:08:46,590
bago ang user na aktwal na ay ilagay ang mga ito.

140
00:08:46,590 --> 00:08:50,720
>> Isang musmos na solusyon sa problemang ito ay upang lamang magreserba ng malaking tipak ng puwang, sabihin nating,

141
00:08:50,720 --> 00:08:54,540
isang bloke ng 1000 karakter para sa input ng user,

142
00:08:54,540 --> 00:08:57,980
ipagpalagay na ang gumagamit ay hindi kailanman ay type sa isang string na mahaba.

143
00:08:57,980 --> 00:09:00,810
Ito ay isang masamang ideya para sa dalawang mga kadahilanan.

144
00:09:00,810 --> 00:09:05,280
Una, ipagpalagay na ang mga gumagamit karaniwang hindi type sa mga string na mahaba,

145
00:09:05,280 --> 00:09:07,610
maaari mong i-aaksaya ng maraming memorya.

146
00:09:07,610 --> 00:09:10,530
Sa mga modernong machine, ito ay maaaring hindi isang isyu kung gagawin mo ito

147
00:09:10,530 --> 00:09:13,890
sa isa o dalawang mga nakahiwalay na mga pangyayari,

148
00:09:13,890 --> 00:09:17,630
ngunit kung ikaw ay pagkuha ng input ng user sa isang loop at pag-imbak para sa hinaharap na paggamit,

149
00:09:17,630 --> 00:09:20,870
maaari mong mabilis sipsipin up ng isang tonelada ng memorya.

150
00:09:20,870 --> 00:09:24,450
Bukod pa rito, kung ang programa ay sumusulat para sa isang mas maliit na computer na -

151
00:09:24,450 --> 00:09:28,100
aparato tulad ng isang smartphone o ibang bagay na may limitadong memorya -

152
00:09:28,100 --> 00:09:32,060
solusyong ito ay magdulot ng mga problema ng maraming mas mabilis.

153
00:09:32,060 --> 00:09:36,450
Ang ikalawang, mas malubhang dahilan upang hindi gawin ito na umalis iyong programa mahina

154
00:09:36,450 --> 00:09:39,710
sa kung ano ang tinatawag na isang buffer overflow atake.

155
00:09:39,710 --> 00:09:45,840
Sa programming, ang buffer ng memorya na ginagamit upang pansamantalang mag-imbak ng data ng input o output,

156
00:09:45,840 --> 00:09:48,980
na sa kasong ito ay aming 1000 magpasinda block.

157
00:09:48,980 --> 00:09:53,370
Isang buffer overflow nangyayari kapag ang data ay nakasulat nakaraan dulo ng bloke.

158
00:09:53,370 --> 00:09:57,790
>> Halimbawa, kung ang isang gumagamit ay aktwal na ginagawa uri sa higit sa 1000 na karakter.

159
00:09:57,790 --> 00:10:01,570
Maaari mong naranasan ito aksidenteng kapag mga programa na may array.

160
00:10:01,570 --> 00:10:05,620
Kung mayroon kang isang hanay ng mga 10 ints, walang hinto mula sa sinusubukang basahin o sumulat

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

162
00:10:07,810 --> 00:10:10,000
Walang mga tagatala babala o error.

163
00:10:10,000 --> 00:10:13,250
Ang programa blunders tuwid magpatuloy at access ang memorya

164
00:10:13,250 --> 00:10:18,150
kung saan sa tingin nito ay ang ika-15 int, at maaari itong patungan ng iyong iba pang mga variable.

165
00:10:18,150 --> 00:10:22,040
Sa pinakamasama kaso, maaari mong patungan ang ilan ng mga panloob na iyong programa

166
00:10:22,040 --> 00:10:26,820
mekanismo ng kontrol, na nagiging sanhi ng iyong programa sa aktwal na isakatuparan ang iba't ibang mga tagubilin

167
00:10:26,820 --> 00:10:28,340
kaysa sa nilayon mo.

168
00:10:28,340 --> 00:10:31,360
>> Ngayon, ito ay hindi karaniwang gawin ito aksidenteng,

169
00:10:31,360 --> 00:10:35,150
ngunit ito ay medyo karaniwang diskarte na ang mga masamang guys gamitin upang masira ang mga programa

170
00:10:35,150 --> 00:10:39,080
at ilagay ang nakakahamak na code sa ibang mga tao computer.

171
00:10:39,080 --> 00:10:42,910
Samakatuwid, hindi lamang namin maaaring gamitin ang aming musmos na solusyon.

172
00:10:42,910 --> 00:10:45,590
Kailangan namin ng isang paraan upang maiwasan ang aming mga programa mula sa pagiging mahina

173
00:10:45,590 --> 00:10:47,880
sa isang atake ng buffer overflow.

174
00:10:47,880 --> 00:10:51,430
Upang gawin ito, kailangan namin upang matiyak na ang aming buffer palaguin bilang nabasa na namin

175
00:10:51,430 --> 00:10:53,850
karagdagang input mula sa user.

176
00:10:53,850 --> 00:10:57,440
Ang solusyon? Ginagamit namin ang isang magbunton inilalaan buffer.

177
00:10:57,440 --> 00:10:59,950
Dahil maaari naming palitan ang laki nito gamit ang resize function na ang realloc,

178
00:10:59,950 --> 00:11:04,580
at panatilihin namin track ng dalawang numero - index ng susunod na walang laman na slot sa buffer

179
00:11:04,580 --> 00:11:08,390
at ang haba o kapasidad ng buffer.

180
00:11:08,390 --> 00:11:13,210
Basahin namin sa mga karakter mula sa gumagamit ng isa sa bawat pagkakataon gamit ang fgetc function na.

181
00:11:13,210 --> 00:11:19,360
Ang argument ang fgetc function na tumatagal - stdin - ay isang reference sa karaniwang input string,

182
00:11:19,360 --> 00:11:23,810
na isang preconnected channel input na ginagamit upang ilipat ang input ng user

183
00:11:23,810 --> 00:11:26,270
mula sa terminal sa programa.

184
00:11:26,270 --> 00:11:29,890
>> Tuwing ang mga uri ng user sa isang bagong character, suriin namin upang makita kung ang index

185
00:11:29,890 --> 00:11:35,810
ng susunod na libreng puwang ng plus 1 ay mas mataas kaysa sa kapasidad ng buffer.

186
00:11:35,810 --> 00:11:39,690
Ang +1 ay dahil kung ang susunod na libreng index ay 5,

187
00:11:39,690 --> 00:11:44,150
ang haba ng aming buffer ay dapat na 6 salamat sa 0 pag-i-index.

188
00:11:44,150 --> 00:11:48,350
Kung kami maubusan ng espasyo sa buffer, pagkatapos ay tinatangka naming palitan ang laki nito,

189
00:11:48,350 --> 00:11:51,690
pagdodoble ito kaya na namin cut sa dami ng beses na na naming baguhin ang laki

190
00:11:51,690 --> 00:11:54,760
kung ang gumagamit ay nagta-type sa isang talagang mahabang string.

191
00:11:54,760 --> 00:11:57,950
Kung ang string na nakuha ng masyadong mahaba o kung patakbuhin namin ng magbunton memory,

192
00:11:57,950 --> 00:12:01,350
magbakante namin ang aming buffer at return null.

193
00:12:01,350 --> 00:12:04,170
>> Panghuli, maglagay namin ang magpasinda sa buffer.

194
00:12:04,170 --> 00:12:08,200
Sa sandaling ang mga hit user ay pumasok o bumalik, pagbibigay ng senyas ng isang bagong linya,

195
00:12:08,200 --> 00:12:12,050
o espesyal na magpasinda - kontrol d - na signal ng isang dulo ng input,

196
00:12:12,050 --> 00:12:16,240
ginagawa namin ng isang tseke upang makita kung ang user na aktwal na nai-type sa anumang bagay sa lahat.

197
00:12:16,240 --> 00:12:18,820
Kung hindi, bumalik namin null.

198
00:12:18,820 --> 00:12:22,280
Kung hindi man, dahil ang aming buffer ay malamang na mas malaki kaysa sa kailangan namin,

199
00:12:22,280 --> 00:12:24,830
sa pinakamalala kaso halos dalawang beses bilang malaking bilang kailangan namin

200
00:12:24,830 --> 00:12:27,830
dahil double namin ang bawat oras na baguhin ang laki namin,

201
00:12:27,830 --> 00:12:31,840
gumawa kami ng isang bagong kopya ng string na gamit lamang ang halaga ng puwang na kailangan namin.

202
00:12:31,840 --> 00:12:34,220
Idagdag namin ng dagdag na 1 sa tawag malloc,

203
00:12:34,220 --> 00:12:37,810
kaya na may puwang para sa mga espesyal na character null Terminator - ang \ 0,

204
00:12:37,810 --> 00:12:41,990
kung saan ikabit ang naming ang string sa sandaling kopyahin namin sa natitirang bahagi ng ang mga character na,

205
00:12:41,990 --> 00:12:45,060
gamit strncpy sa halip na strcpy

206
00:12:45,060 --> 00:12:48,830
upang maaari naming tukuyin eksakto kung gaano karaming karakter ang gusto naming kopyahin.

207
00:12:48,830 --> 00:12:51,690
Strcpy kinokopya hanggang ito hit sa isang \ 0.

208
00:12:51,690 --> 00:12:55,740
Pagkatapos namin magbakante aming buffer at ibalik ang kopya sa tumatawag.

209
00:12:55,740 --> 00:12:59,840
>> Sino alam sa isang simpleng-tila function na ma-kumplikado?

210
00:12:59,840 --> 00:13:02,820
Ngayon alam mo kung ano ang napupunta sa CS50 library.

211
00:13:02,820 --> 00:13:06,470
>> Ang pangalan ko ay Nate Hardison, at ito ay CS50.

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