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 Universiteit]

3
00:00:04,220 --> 00:00:07,260
[Hierdie is CS50. CS50.TV]

4
00:00:07,260 --> 00:00:11,510
Die CS50 biblioteek is 'n nuttige hulpmiddel wat ons op die toestel geïnstalleer

5
00:00:11,510 --> 00:00:15,870
te maak dit makliker vir jou programme te kan skryf wat vinnige gebruikers vir insette.

6
00:00:15,870 --> 00:00:21,670
In hierdie video, sal ons trek die gordyn terug en kyk na wat presies is in die CS50 biblioteek.

7
00:00:21,670 --> 00:00:25,520
>> In die video op die C-biblioteke, ons praat oor hoe jy # headers lêers

8
00:00:25,520 --> 00:00:27,570
van die biblioteek in jou bronkode,

9
00:00:27,570 --> 00:00:31,150
en dan het jy 'n skakel met 'n binêre biblioteek lêer tydens die koppeling fase

10
00:00:31,150 --> 00:00:33,140
van die samestelling.

11
00:00:33,140 --> 00:00:36,440
Met die kopteksbeelde lêers spesifiseer die koppelvlak van die biblioteek.

12
00:00:36,440 --> 00:00:41,280
Dit beteken dat hulle detail van al die hulpbronne wat die biblioteek beskikbaar vir jou om te gebruik,

13
00:00:41,280 --> 00:00:45,250
soos funksie verklarings, konstantes, en data tipes.

14
00:00:45,250 --> 00:00:48,890
Die binêre biblioteek lêer bevat die implementering van die biblioteek,

15
00:00:48,890 --> 00:00:54,580
wat is saamgestel uit die biblioteek se header lêers en die biblioteek se c bron kode lêers.

16
00:00:54,580 --> 00:00:59,820
>> Die binêre biblioteek lêer is nie baie interessant om te kyk want dit is goed, in binêre.

17
00:00:59,820 --> 00:01:03,300
So, kom ons neem 'n blik op die kopteksbeelde lêers vir die biblioteek plaas.

18
00:01:03,300 --> 00:01:07,710
In hierdie geval, daar is net een header lêer genaamd cs50.h.

19
00:01:07,710 --> 00:01:11,040
Ons het dit in die gebruiker geïnstalleer, sluit directory

20
00:01:11,040 --> 00:01:15,150
saam met die ander stelsel biblioteke header lêers.

21
00:01:15,150 --> 00:01:21,530
>> Een van die eerste dinge wat jy sal sien, is dat cs50.h # sluit header lêers van ander biblioteke

22
00:01:21,530 --> 00:01:25,670
float, limiete, standaard Bool, en standaard lib.

23
00:01:25,670 --> 00:01:28,800
Weereens, na aanleiding van die beginsel van nie die wiel weer uitvind,

24
00:01:28,800 --> 00:01:33,490
ons het die CS0 biblioteek met behulp van gereedskap wat ander vir ons gebou.

25
00:01:33,490 --> 00:01:38,690
>> Die volgende ding wat jy sien in die biblioteek is dat ons 'n nuwe soort sogenaamde "string definieer."

26
00:01:38,690 --> 00:01:42,330
Hierdie reël skep eintlik maar net 'n alias vir die tipe char *

27
00:01:42,330 --> 00:01:46,000
sodat dit mettertyd nie kant die nuwe string tipe met eienskappe

28
00:01:46,000 --> 00:01:49,650
algemeen geassosieer met die string voorwerpe in ander tale,

29
00:01:49,650 --> 00:01:50,850
soos lengte.

30
00:01:50,850 --> 00:01:55,180
Die rede waarom ons dit gedoen het, is om nuwe programmeerders te beskerm teen die gruwelike besonderhede

31
00:01:55,180 --> 00:01:57,580
wysers totdat hulle klaar is.

32
00:01:57,580 --> 00:02:00,130
>> Die volgende deel van die header-lêer is die verklaring van die funksies

33
00:02:00,130 --> 00:02:04,410
dat die CS50 biblioteek verskaf saam met die dokumentasie.

34
00:02:04,410 --> 00:02:06,940
Let op die vlak van detail in die kommentaar hier.

35
00:02:06,940 --> 00:02:10,560
Dit is super belangrik sodat mense weet hoe om hierdie funksies te gebruik.

36
00:02:10,560 --> 00:02:19,150
Ons verklaar, op sy beurt, funksioneer die gebruiker en terugkeer karakters, dubbels, dryf, ints aan te spoor,

37
00:02:19,150 --> 00:02:24,160
lank verlang, en snare, met behulp van ons eie string tipe.

38
00:02:24,160 --> 00:02:26,260
Na aanleiding van die beginsel van inligting wegkruip,

39
00:02:26,260 --> 00:02:31,640
ons het ons definisie in 'n aparte c implementering lêer - cs50.c -

40
00:02:31,640 --> 00:02:35,110
geleë in die gebruiker bron gids.

41
00:02:35,110 --> 00:02:38,040
Ons het voorsien dat die lêer sodat jy kan 'n blik op dit,

42
00:02:38,040 --> 00:02:41,490
leer uit dit, en heropstel dit op verskillende masjiene as jy wil,

43
00:02:41,490 --> 00:02:45,510
selfs al het ons dink dit is beter om te werk op die toestel vir hierdie klas.

44
00:02:45,510 --> 00:02:47,580
In elk geval, laat ons neem 'n blik op dit nou.

45
00:02:49,020 --> 00:02:54,620
>> Die funksies getChar, GetDouble, GetFloat, getint, en GetLongLong

46
00:02:54,620 --> 00:02:58,160
is almal gebou op die top van die GetString funksie.

47
00:02:58,160 --> 00:03:01,510
Dit blyk dat hulle in wese almal volg dieselfde patroon.

48
00:03:01,510 --> 00:03:04,870
Hulle maak gebruik van 'n while lus om die gebruiker vir 'n lyn van die toevoer te vinnig.

49
00:03:04,870 --> 00:03:08,430
Hulle terugkeer 'n spesiale waarde indien die gebruiker 'n leë lyn insette.

50
00:03:08,430 --> 00:03:11,750
Hulle probeer om die gebruiker se insette te ontleed as die toepaslike tipe,

51
00:03:11,750 --> 00:03:15,010
word dit 'n char, 'n dubbel, 'n float, ens.

52
00:03:15,010 --> 00:03:18,710
En dan sal hulle die resultaat terug indien die inset is suksesvol ontleed

53
00:03:18,710 --> 00:03:21,330
of hulle reprompt die gebruiker.

54
00:03:21,330 --> 00:03:24,230
>> Op 'n hoë vlak, is daar niks regtig lastig hier.

55
00:03:24,230 --> 00:03:28,760
Jy kan insgelyks gestruktureerde kode geskryf het jouself in die verlede.

56
00:03:28,760 --> 00:03:34,720
Miskien is die mees kriptiese-looking deel is die sscanf oproep wat die gebruiker se insette ontleed.

57
00:03:34,720 --> 00:03:38,160
Sscanf is deel van die inset-formaat omskakeling familie.

58
00:03:38,160 --> 00:03:42,300
Dit leef in standaard io.h, en sy werk is 'n C-string te ontleed,

59
00:03:42,300 --> 00:03:46,520
volgens 'n spesifieke formaat, die stoor van die parse uitslae in veranderlike

60
00:03:46,520 --> 00:03:48,720
wat deur die oproeper.

61
00:03:48,720 --> 00:03:53,570
Sedert die invoer formaat omskakeling funksies is baie nuttig, wyd gebruik word funksies

62
00:03:53,570 --> 00:03:56,160
wat nie super intuïtief op die eerste,

63
00:03:56,160 --> 00:03:58,300
ons gaan oor hoe sscanf werk.

64
00:03:58,300 --> 00:04:03,330
>> Die eerste argument te sscanf is 'n char * - 'n wyser na 'n karakter.

65
00:04:03,330 --> 00:04:05,150
Vir die funksie om behoorlik te werk,

66
00:04:05,150 --> 00:04:08,340
dat die karakter moet die eerste teken van 'n C-string,

67
00:04:08,340 --> 00:04:12,270
beëindig met die null \ 0 karakter.

68
00:04:12,270 --> 00:04:15,120
Dit is die string te ontleed

69
00:04:15,120 --> 00:04:18,269
Die tweede argument te sscanf is 'n formaat string,

70
00:04:18,269 --> 00:04:20,839
tipies as 'n string konstante geslaag,

71
00:04:20,839 --> 00:04:24,040
en jy mag gesien het 'n string soos hierdie voor wanneer die gebruik van printf.

72
00:04:24,040 --> 00:04:28,650
'N%-teken in die formaat string dui op 'n omskakeling specific.

73
00:04:28,650 --> 00:04:30,850
Die karakter wat onmiddellik volg op 'n persentasie teken,

74
00:04:30,850 --> 00:04:35,430
dui op die C-tipe wat ons wil sscanf te omskep.

75
00:04:35,430 --> 00:04:40,090
In getint, sien jy dat daar is 'n% d en% c.

76
00:04:40,090 --> 00:04:48,690
Dit beteken dat sscanf sal probeer om 'n desimale int -% d - en 'n char -% c.

77
00:04:48,690 --> 00:04:51,510
Vir elke omskakeling specificatie in die formaat string,

78
00:04:51,510 --> 00:04:56,620
sscanf verwag dat 'n ooreenstemmende argument later in sy argument lys.

79
00:04:56,620 --> 00:05:00,850
Daardie argument moet verwys na 'n toepaslik getikte plek

80
00:05:00,850 --> 00:05:04,000
wat die gevolg van die omskakeling te stoor.

81
00:05:04,000 --> 00:05:08,910
>> Die tipiese manier om dit te doen is om 'n veranderlike te skep op die stapel voor die sscanf oproep

82
00:05:08,910 --> 00:05:11,440
vir elke item wat jy wil om uit die string te parse

83
00:05:11,440 --> 00:05:15,520
en gebruik dan die adres operateur - die ampersand - wysers te slaag

84
00:05:15,520 --> 00:05:19,100
aan daardie veranderlikes aan die sscanf oproep.

85
00:05:19,100 --> 00:05:22,720
Kan jy sien dat in getint ons presies dit doen.

86
00:05:22,720 --> 00:05:28,240
Reg voor die sscanf oproep, verklaar ons 'n int n en 'n char oproep c op die stapel,

87
00:05:28,240 --> 00:05:32,340
en ons verwysings na hulle slaag in die sscanf oproep.

88
00:05:32,340 --> 00:05:35,800
Om hierdie veranderlikes op die stapel word verkies bo die gebruik van spasie

89
00:05:35,800 --> 00:05:39,350
op die hoop met malloc, omdat jy die oorhoofse van die malloc oproep te vermy,

90
00:05:39,350 --> 00:05:43,060
en jy hoef nie te bekommer oor die lek van geheue.

91
00:05:43,060 --> 00:05:47,280
Karakters word nie voorafgegaan deur 'n persentasie teken gevra nie bekering.

92
00:05:47,280 --> 00:05:50,380
Eerder hulle voeg net na die formaat spesifikasie.

93
00:05:50,380 --> 00:05:56,500
>> Byvoorbeeld, as die formaat string in getint was 'n% d in plaas daarvan,

94
00:05:56,500 --> 00:05:59,800
sscanf sal kyk vir die letter A, gevolg deur 'n int,

95
00:05:59,800 --> 00:06:04,360
en terwyl dit poog om die int te omskep, sou dit nie doen nie enigiets anders met die a.

96
00:06:04,360 --> 00:06:07,440
Die enigste uitsondering op hierdie spasie.

97
00:06:07,440 --> 00:06:11,030
Wit spasie karakters in die formaat string ooreenstem met enige bedrag van spasie -

98
00:06:11,030 --> 00:06:12,890
selfs glad nie.

99
00:06:12,890 --> 00:06:18,100
So, wat is die rede waarom die kommentaar noem moontlik met die leiding en / of eindig met spasies.

100
00:06:18,100 --> 00:06:22,910
So, op hierdie punt is dit lyk soos ons sscanf oproep probeer om die gebruiker se inset string te ontleed

101
00:06:22,910 --> 00:06:25,380
deur te kyk vir moontlike Witruimte,

102
00:06:25,380 --> 00:06:29,300
gevolg deur 'n int wat sal omgeskakel word en gestoor in die int veranderlike n

103
00:06:29,300 --> 00:06:33,090
gevolg deur 'n bedrag van spasie, en gevolg deur 'n karakter

104
00:06:33,090 --> 00:06:35,810
gestoor in die char veranderlike c.

105
00:06:35,810 --> 00:06:37,790
>> Wat oor die terugkeer waarde?

106
00:06:37,790 --> 00:06:41,560
Sscanf sal die inset lyn parse van begin tot einde,

107
00:06:41,560 --> 00:06:44,860
stop wanneer dit die einde bereik of wanneer 'n karakter in die inset

108
00:06:44,860 --> 00:06:49,320
kom nie ooreen met 'n formaat karakter of wanneer dit nie 'n sukses nie.

109
00:06:49,320 --> 00:06:52,690
Dit se terugkeer waarde word gebruik om uitsonder wanneer dit opgehou.

110
00:06:52,690 --> 00:06:55,670
As dit gestop het, omdat dit die einde van die inset string bereik

111
00:06:55,670 --> 00:07:00,630
voordat hy enige doelskoppe en voor nie deel van die formaat string aan te pas,

112
00:07:00,630 --> 00:07:04,840
dan die spesiale konstante EOF teruggestuur word.

113
00:07:04,840 --> 00:07:08,200
Andersins, dit gee die aantal suksesvolle conversies,

114
00:07:08,200 --> 00:07:14,380
wat kan wees 0, 1 of 2, aangesien ons het gevra vir twee doelskoppe.

115
00:07:14,380 --> 00:07:19,000
In ons geval, ons wil om seker te maak dat die gebruiker in 'n int en slegs 'n int getik.

116
00:07:19,000 --> 00:07:23,370
>> So, ons wil sscanf 1 om terug te keer. Sien waarom?

117
00:07:23,370 --> 00:07:26,850
As sscanf teruggekeer 0, dan is geen bekerings gemaak is,

118
00:07:26,850 --> 00:07:31,690
sodat die gebruiker ingetik iets anders as 'n int aan die begin van die insette.

119
00:07:31,690 --> 00:07:37,100
As sscanf terugkeer 2, dan is die gebruiker het behoorlik tik dit in aan die begin van die insette,

120
00:07:37,100 --> 00:07:41,390
maar hulle dan in sommige nie-spasie karakter getik daarna

121
00:07:41,390 --> 00:07:44,940
sedert die% c sukses daarin geslaag.

122
00:07:44,940 --> 00:07:49,570
Sjoe, dit is nogal 'n lang verduideliking vir een funksie oproep.

123
00:07:49,570 --> 00:07:53,460
In elk geval, as jy meer inligting wil hê op sscanf en sy broers en susters,

124
00:07:53,460 --> 00:07:57,130
check die man bladsye, Google, of albei.

125
00:07:57,130 --> 00:07:58,780
Daar is baie van die formaat string opsies,

126
00:07:58,780 --> 00:08:03,830
en dit kan red jy 'n baie van die handewerker wanneer ek probeer om stringe te ontleed in C.

127
00:08:03,830 --> 00:08:07,180
>> Die finale funksie in die biblioteek om na te kyk, is GetString.

128
00:08:07,180 --> 00:08:10,310
Dit blyk dat GetString is 'n moeilike funksie behoorlik te skryf,

129
00:08:10,310 --> 00:08:14,290
selfs al is dit lyk asof so 'n eenvoudige, gemeenskaplike taak.

130
00:08:14,290 --> 00:08:16,170
Hoekom is dit die geval?

131
00:08:16,170 --> 00:08:21,380
Wel, laat ons dink oor hoe ons hier gaan om die lyn op te slaan dat die gebruiker tipes.

132
00:08:21,380 --> 00:08:23,880
Aangesien 'n string is 'n volgorde van die karakters,

133
00:08:23,880 --> 00:08:26,430
ons dalk wil om dit te stoor in 'n skikking op die stapel,

134
00:08:26,430 --> 00:08:31,250
maar ons sou nodig het om te weet hoe lank die skikking gaan wees wanneer ons dit verklaar.

135
00:08:31,250 --> 00:08:34,030
Net so, as ons wil om dit te sit op die wal,

136
00:08:34,030 --> 00:08:38,090
ons nodig het om te slaag malloc die aantal grepe wat ons wil reserwe,

137
00:08:38,090 --> 00:08:39,730
maar dit is onmoontlik.

138
00:08:39,730 --> 00:08:42,760
Ons het geen idee hoeveel karakters sal die gebruiker tik

139
00:08:42,760 --> 00:08:46,590
voor die aangesig van die gebruiker tik hulle eintlik nie.

140
00:08:46,590 --> 00:08:50,720
>> 'N naïef oplossing vir hierdie probleem is om net te behou 'n groot stuk van die ruimte, sê,

141
00:08:50,720 --> 00:08:54,540
'n blok van 1000 karakters vir die gebruiker se insette,

142
00:08:54,540 --> 00:08:57,980
die veronderstelling dat die gebruiker nooit sou tik in 'n string wat lank.

143
00:08:57,980 --> 00:09:00,810
Dit is 'n slegte idee om twee redes.

144
00:09:00,810 --> 00:09:05,280
Eerstens, in die veronderstelling dat gebruikers tipies tik nie in stringe dat die lang,

145
00:09:05,280 --> 00:09:07,610
jy kan mors nie 'n baie van die geheue.

146
00:09:07,610 --> 00:09:10,530
Op die moderne masjiene, kan dit nie 'n probleem wees as jy dit doen

147
00:09:10,530 --> 00:09:13,890
in een of twee geïsoleerde gevalle,

148
00:09:13,890 --> 00:09:17,630
maar as jy die gebruiker se insette in 'n lus en stoor vir latere gebruik,

149
00:09:17,630 --> 00:09:20,870
kan jy vinnig suig 'n ton van die geheue.

150
00:09:20,870 --> 00:09:24,450
Verder, as die program wat jy skryf is vir 'n kleiner rekenaar -

151
00:09:24,450 --> 00:09:28,100
'n toestel soos 'n smartphone of iets anders met 'n beperkte geheue -

152
00:09:28,100 --> 00:09:32,060
hierdie oplossing probleme sal veroorsaak dat 'n baie vinniger.

153
00:09:32,060 --> 00:09:36,450
Die tweede, meer ernstige rede om dit nie doen nie, is dat dit jou program verlaat kwesbare

154
00:09:36,450 --> 00:09:39,710
wat genoem word 'n buffer oorloop aanval.

155
00:09:39,710 --> 00:09:45,840
In programmering, 'n buffer geheue gebruik word om tydelik inset of uitset data stoor,

156
00:09:45,840 --> 00:09:48,980
wat in hierdie geval is ons 1000-char blok.

157
00:09:48,980 --> 00:09:53,370
'N buffer overflow voorkom wanneer data is verby die einde van die blok geskryf.

158
00:09:53,370 --> 00:09:57,790
>> Byvoorbeeld, as 'n gebruiker tik in meer as 1000 karakters.

159
00:09:57,790 --> 00:10:01,570
Jy dalk ervaar het dit per ongeluk wanneer programmering met skikkings.

160
00:10:01,570 --> 00:10:05,620
As jy 'n verskeidenheid van 10 ints, niks stop jy van probeer om te lees of skryf nie

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

162
00:10:07,810 --> 00:10:10,000
Daar is geen saamsteller waarskuwings of foute.

163
00:10:10,000 --> 00:10:13,250
Die program het net flaters reguit vorentoe en toegang tot die geheue

164
00:10:13,250 --> 00:10:18,150
waar dit dink die 15de int sal wees, en dit kan jou ander veranderlikes oorskryf.

165
00:10:18,150 --> 00:10:22,040
In die ergste geval, kan jy oorskryf sommige van jou program se interne

166
00:10:22,040 --> 00:10:26,820
beheermeganismes, om werklik veroorsaak dat jou program uitvoer verskillende instruksies

167
00:10:26,820 --> 00:10:28,340
as wat jy bedoel.

168
00:10:28,340 --> 00:10:31,360
>> Nou, dit is nie algemeen is dit per ongeluk doen,

169
00:10:31,360 --> 00:10:35,150
maar dit is 'n redelik algemene tegniek wat die slegte ouens gebruik om programme te breek

170
00:10:35,150 --> 00:10:39,080
en kwaadwillige kode op ander mense se rekenaars.

171
00:10:39,080 --> 00:10:42,910
Daarom kan ons nie net gebruik ons ​​naïef oplossing.

172
00:10:42,910 --> 00:10:45,590
Ons moet 'n manier om te verhoed dat ons programme van kwesbare

173
00:10:45,590 --> 00:10:47,880
aan 'n buffer oorloop aanval.

174
00:10:47,880 --> 00:10:51,430
Om dit te kan doen, moet ons seker maak dat ons buffer kan groei soos ons lees

175
00:10:51,430 --> 00:10:53,850
meer insette van die gebruiker.

176
00:10:53,850 --> 00:10:57,440
Die oplossing? Ons gebruik 'n hoop toegekende buffer.

177
00:10:57,440 --> 00:10:59,950
Aangesien ons dit kan die grootte van die gebruik van die grootte van die realloc funksie,

178
00:10:59,950 --> 00:11:04,580
en ons hou van twee getalle - die indeks van die volgende leë slot in die buffer

179
00:11:04,580 --> 00:11:08,390
en die lengte of die kapasiteit van die buffer.

180
00:11:08,390 --> 00:11:13,210
Ons lees in die karakters van die gebruiker een op 'n tyd deur gebruik te maak van die fgetc funksie.

181
00:11:13,210 --> 00:11:19,360
Die argument van die fgetc funksie neem - stdin - is 'n verwysing na die standaard inset string,

182
00:11:19,360 --> 00:11:23,810
wat is 'n preconnected invoer kanaal wat gebruik word om die gebruiker se insette oor te dra

183
00:11:23,810 --> 00:11:26,270
van die terminale na die program.

184
00:11:26,270 --> 00:11:29,890
>> Wanneer die gebruiker tipes in 'n nuwe karakter, gaan ons om te sien of die indeks

185
00:11:29,890 --> 00:11:35,810
van die volgende gratis slot plus 1 is groter as die kapasiteit van die buffer.

186
00:11:35,810 --> 00:11:39,690
Die 1 kom in want as die volgende indeks is 5,

187
00:11:39,690 --> 00:11:44,150
dan is ons buffer se lengte moet 6 danksy 0 kruip.

188
00:11:44,150 --> 00:11:48,350
As ons het hardloop uit van die ruimte in die buffer, dan sal ons probeer om dit te resize,

189
00:11:48,350 --> 00:11:51,690
te verdubbel sodat ons kap op die aantal kere wat ons die grootte van

190
00:11:51,690 --> 00:11:54,760
indien die gebruiker in 'n baie lang string tik.

191
00:11:54,760 --> 00:11:57,950
As die tou gekry het te lank, of as ons hardloop uit hoopgeheue,

192
00:11:57,950 --> 00:12:01,350
ons vry om ons buffer en terugkeer null.

193
00:12:01,350 --> 00:12:04,170
>> Ten slotte, ons voeg die kar aan die buffer.

194
00:12:04,170 --> 00:12:08,200
Sodra die gebruiker treffers betree of terugkeer, die sein van 'n nuwe reël,

195
00:12:08,200 --> 00:12:12,050
of die spesiale char - beheer d - wat dui op 'n einde van die insette,

196
00:12:12,050 --> 00:12:16,240
ons doen 'n tjek te sien as die gebruiker eintlik getik in enigiets.

197
00:12:16,240 --> 00:12:18,820
Indien nie, keer ons terug null.

198
00:12:18,820 --> 00:12:22,280
Andersins, omdat ons buffer is waarskynlik groter as wat ons nodig het,

199
00:12:22,280 --> 00:12:24,830
in die ergste geval dit is byna twee keer so groot as wat ons nodig het

200
00:12:24,830 --> 00:12:27,830
aangesien ons elke keer as ons die grootte verdubbel,

201
00:12:27,830 --> 00:12:31,840
maak ons ​​'n nuwe kopie van die string met behulp van die bedrag van die ruimte wat ons nodig het.

202
00:12:31,840 --> 00:12:34,220
Ons voeg 'n ekstra 1 aan die malloc oproep,

203
00:12:34,220 --> 00:12:37,810
sodat daar ruimte vir die spesiale null terminator karakter - die \ 0,

204
00:12:37,810 --> 00:12:41,990
wat ons voeg aan die tou wanneer ons in die res van die karakters kopieer,

205
00:12:41,990 --> 00:12:45,060
met behulp van strncpy in plaas van strcpy

206
00:12:45,060 --> 00:12:48,830
sodat ons kan spesifiseer presies hoeveel karakters ons wil kopieer.

207
00:12:48,830 --> 00:12:51,690
Strcpy afskrifte totdat dit tref 'n \ 0.

208
00:12:51,690 --> 00:12:55,740
Dan sal ons vry om ons buffer en die standaard van die afskrif aan die oproeper.

209
00:12:55,740 --> 00:12:59,840
>> Wie het geweet so 'n eenvoudige-oënskynlike funksie kan so ingewikkeld wees?

210
00:12:59,840 --> 00:13:02,820
Nou weet jy wat gaan in die CS50 biblioteek.

211
00:13:02,820 --> 00:13:06,470
>> My naam is Nate Hardison, en dit is CS50.

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