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

2
00:00:02,490 --> 00:00:04,220
[Nate Hardison] [Hārvarda]

3
00:00:04,220 --> 00:00:07,260
[Tas ir CS50. CS50.TV]

4
00:00:07,260 --> 00:00:11,510
The CS50 bibliotēka ir noderīgs instruments, kas mums ir uzstādītas uz ierīces

5
00:00:11,510 --> 00:00:15,870
lai būtu vieglāk, lai jūs varētu rakstīt programmas, kas liks lietotājiem par ieejas.

6
00:00:15,870 --> 00:00:21,670
Šajā video, mēs pull atpakaļ aizkaru un apskatīt ko tieši atrodas CS50 bibliotēkā.

7
00:00:21,670 --> 00:00:25,520
>> Šajā video par C bibliotēku, mēs runājam par to, kā jūs # ietvert galvenes faili

8
00:00:25,520 --> 00:00:27,570
no bibliotēkas jūsu avota kodu,

9
00:00:27,570 --> 00:00:31,150
un tad jūs saistīt ar bināro bibliotēkas failu laikā savieno posmā

10
00:00:31,150 --> 00:00:33,140
apkopošanas process.

11
00:00:33,140 --> 00:00:36,440
Header failus norādīt interfeisu bibliotēku.

12
00:00:36,440 --> 00:00:41,280
Tas ir, tie dati visus resursus, kas bibliotēkā ir pieejami, lai jūs varētu izmantot,

13
00:00:41,280 --> 00:00:45,250
piemēram funkciju deklarācijām, konstanšu, un datu tipi.

14
00:00:45,250 --> 00:00:48,890
Binārā bibliotēkas fails satur īstenošanu bibliotēkas,

15
00:00:48,890 --> 00:00:54,580
kurā tiek apkopota no bibliotēkas header failiem un bibliotēkas. c pirmkods failus.

16
00:00:54,580 --> 00:00:59,820
>> Binārā bibliotēkas fails nav ļoti interesanti aplūkot, jo tas ir, labi, jo bināro.

17
00:00:59,820 --> 00:01:03,300
Tātad, pieņemsim apskatīt header failus bibliotēkā vietā.

18
00:01:03,300 --> 00:01:07,710
Šajā gadījumā, tur ir tikai viens header failu sauc cs50.h.

19
00:01:07,710 --> 00:01:11,040
Mēs esam uzstādītas tā, lai lietotājs ietver direktoriju

20
00:01:11,040 --> 00:01:15,150
Kopā ar citiem sistēmu bibliotēku header failus.

21
00:01:15,150 --> 00:01:21,530
>> Viena no pirmajām lietām, jūs ievērosiet, ka cs50.h # ietver header failus no citām bibliotēkām -

22
00:01:21,530 --> 00:01:25,670
peldēt, ierobežojumi, standarta bool un standarta lib.

23
00:01:25,670 --> 00:01:28,800
Atkal pēc principa ne izgudrot riteni,

24
00:01:28,800 --> 00:01:33,490
mēs esam izveidojuši CS0 bibliotēkā, izmantojot rīkus, kas cita paredzētos mums.

25
00:01:33,490 --> 00:01:38,690
>> Nākamā lieta, jūs redzēt bibliotēkā ir, ka mēs definējam jauna veida sauc par "virkne."

26
00:01:38,690 --> 00:01:42,330
Šī līnija tiešām tikai rada alias par char * tipa,

27
00:01:42,330 --> 00:01:46,000
lai tas nav maģiski piesūcināt jauno stīgu tipu ar atribūtiem

28
00:01:46,000 --> 00:01:49,650
parasti tiek saistīts ar stīgu objektiem citās valodās,

29
00:01:49,650 --> 00:01:50,850
piemēram, garumu.

30
00:01:50,850 --> 00:01:55,180
Iemesls, kāpēc mēs esam darījuši, ir, lai pasargātu jaunos programmētājus no asiņains detaļas

31
00:01:55,180 --> 00:01:57,580
gada norādes, līdz tie gatavi.

32
00:01:57,580 --> 00:02:00,130
>> Nākamā daļa no header failu, ir deklarācija par funkcijām

33
00:02:00,130 --> 00:02:04,410
ka CS50 bibliotēka nodrošina kopā ar dokumentāciju.

34
00:02:04,410 --> 00:02:06,940
Paziņojums precizitātes līmeni komentārus šeit.

35
00:02:06,940 --> 00:02:10,560
Tas ir super svarīgi, lai cilvēki zina, kā izmantot šīs funkcijas.

36
00:02:10,560 --> 00:02:19,150
Mēs paziņojam, savukārt, darbojas, lai nekavējoties lietotājam un atgriešanās chars, dubultlikmes, pludiņiem, Ints,

37
00:02:19,150 --> 00:02:24,160
garš ilgojas, un stīgas, izmantojot mūsu pašu stīgu veidu.

38
00:02:24,160 --> 00:02:26,260
Pēc principa informācijas slēpšanās,

39
00:02:26,260 --> 00:02:31,640
Mēs esam mūsu definīciju atsevišķā c ieviešanas failu -. cs50.c--

40
00:02:31,640 --> 00:02:35,110
kas atrodas lietotāja avota direktorijā.

41
00:02:35,110 --> 00:02:38,040
Mēs esam ja šo failu, lai jūs varētu to apskatīt to,

42
00:02:38,040 --> 00:02:41,490
mācīties no tā, un recompile to uz dažādām mašīnām, ja vēlaties,

43
00:02:41,490 --> 00:02:45,510
pat ja mēs domāju, ka labāk strādāt uz ierīces šīs klases.

44
00:02:45,510 --> 00:02:47,580
Anyway, pieņemsim to apskatīt to tagad.

45
00:02:49,020 --> 00:02:54,620
>> Funkcijas getchar, GetDouble, GetFloat, GetInt, un GetLongLong

46
00:02:54,620 --> 00:02:58,160
visas ir būvētas uz augšu GetString funkcijas.

47
00:02:58,160 --> 00:03:01,510
Izrādās, ka viņi visi seko būtībā to pašu modeli.

48
00:03:01,510 --> 00:03:04,870
Viņi izmanto, kamēr cilpa, lai nekavējoties lietotājam par vienu līniju ievadi.

49
00:03:04,870 --> 00:03:08,430
Viņi atgriezīsies īpašu vērtību, ja lietotājs izejvielas tukšu līniju.

50
00:03:08,430 --> 00:03:11,750
Viņi mēģinās parsēt lietotāja ievadi kā piemērotu veidu,

51
00:03:11,750 --> 00:03:15,010
vai tas būtu palija, dubultā, peldēt, uc

52
00:03:15,010 --> 00:03:18,710
Un tad viņi vai nu atgriezties rezultātu, ja ieeja ir veiksmīgi parsēt

53
00:03:18,710 --> 00:03:21,330
vai tie reprompt lietotājam.

54
00:03:21,330 --> 00:03:24,230
>> Augstā līmenī, nekas patiešām grūts šeit.

55
00:03:24,230 --> 00:03:28,760
Jums varētu būt rakstīts tamlīdzīgos kodu sevi pagātnē.

56
00:03:28,760 --> 00:03:34,720
Iespējams, visvairāk noslēpumains izskata daļa ir sscanf zvans, kas parses lietotāja ievadi.

57
00:03:34,720 --> 00:03:38,160
Sscanf ir daļa no ieejas formāta konversijas ģimeni.

58
00:03:38,160 --> 00:03:42,300
Tā dzīvo standarta io.h, un tās uzdevums ir parsēt C virkni,

59
00:03:42,300 --> 00:03:46,520
saskaņā ar īpašu formātu, uzglabāšanu parsēt rezultātus mainīgs

60
00:03:46,520 --> 00:03:48,720
sniedz zvanītāja.

61
00:03:48,720 --> 00:03:53,570
Tā kā ievades formāts konversijas funkcijas ir ļoti noderīgas, plaši lietotās funkcijas

62
00:03:53,570 --> 00:03:56,160
ka nav super intuitīvu sākumā,

63
00:03:56,160 --> 00:03:58,300
mēs iet pār to, kā sscanf darbi.

64
00:03:58,300 --> 00:04:03,330
>> Pirmais arguments, lai sscanf ir char * - rādītājs, lai raksturu.

65
00:04:03,330 --> 00:04:05,150
Lai funkcija darbotos pareizi,

66
00:04:05,150 --> 00:04:08,340
ka raksturs būtu pirmais raksturs ir C virknes,

67
00:04:08,340 --> 00:04:12,270
izbeigt ar nulles \ 0 raksturu.

68
00:04:12,270 --> 00:04:15,120
Tas ir virkne parsēt

69
00:04:15,120 --> 00:04:18,269
Otrs arguments, lai sscanf ir formāta virkne,

70
00:04:18,269 --> 00:04:20,839
parasti pieņemts kā string konstantes,

71
00:04:20,839 --> 00:04:24,040
un jūs varētu būt redzējis virkni līdzīgu pirms lietojot printf.

72
00:04:24,040 --> 00:04:28,650
Procenti zīme formāta virknes norāda konversijas noteicēju.

73
00:04:28,650 --> 00:04:30,850
Raksturs uzreiz pēc procentu zīmi,

74
00:04:30,850 --> 00:04:35,430
norāda C tipa ka mēs vēlamies sscanf konvertēt uz.

75
00:04:35,430 --> 00:04:40,090
Jo GetInt, jūs redzēsiet, ka tur ir% d un% c.

76
00:04:40,090 --> 00:04:48,690
Tas nozīmē, ka sscanf mēģinās decimālskaitlis int - Par% D - un char - THE% c.

77
00:04:48,690 --> 00:04:51,510
Par katru pārveides apzīmētājs uz formāta virknes,

78
00:04:51,510 --> 00:04:56,620
sscanf sagaida atbilstošs arguments vēlāk tās argumentu sarakstā.

79
00:04:56,620 --> 00:05:00,850
Šis arguments ir jānorāda uz attiecīgi drukātā vietā

80
00:05:00,850 --> 00:05:04,000
, kuros uzglabāt rezultātu pārveidošanu.

81
00:05:04,000 --> 00:05:08,910
>> Tipisks veids, kā to panākt, ir izveidot mainīgo uz skursteņa pirms sscanf zvana

82
00:05:08,910 --> 00:05:11,440
par katru posteni, ka jūs vēlaties, lai parsēt no virknes

83
00:05:11,440 --> 00:05:15,520
un pēc tam izmantot adrešu operators - zīme & - nodot norādes

84
00:05:15,520 --> 00:05:19,100
tiem mainīgie sscanf zvanu.

85
00:05:19,100 --> 00:05:22,720
Jūs varat redzēt, ka GetInt mēs darīt tieši to.

86
00:05:22,720 --> 00:05:28,240
Tiesības pirms sscanf zvana, mēs paziņojam int sauc n un char zvanu C uz steku,

87
00:05:28,240 --> 00:05:32,340
un mums iet norādes uz tām uz sscanf zvanu.

88
00:05:32,340 --> 00:05:35,800
Liekot šiem mainīgajiem uz skursteņa ir priekšroka pār izmantojot piešķirto telpu

89
00:05:35,800 --> 00:05:39,350
uz kaudzes ar malloc, jo jūs izvairītos pieskaitāmās malloc zvanu,

90
00:05:39,350 --> 00:05:43,060
un jums nav jāuztraucas par noplūdi atmiņu.

91
00:05:43,060 --> 00:05:47,280
Rakstzīmes nav prefiksu procentu zīmi nevaicāt konversiju.

92
00:05:47,280 --> 00:05:50,380
Drīzāk viņi vienkārši pievienot formāta specifikāciju.

93
00:05:50,380 --> 00:05:56,500
>> Piemēram, ja formāta virknes GetInt bija% d vietā,

94
00:05:56,500 --> 00:05:59,800
sscanf varētu meklēt burtu A, kam seko int,

95
00:05:59,800 --> 00:06:04,360
un kamēr tas varētu mēģināt pārveidot int, tas nav jādara kaut kas cits ar a.

96
00:06:04,360 --> 00:06:07,440
Vienīgais izņēmums ir atstarpes.

97
00:06:07,440 --> 00:06:11,030
Balta telpa rakstzīmes formāta virknes atbilstu jebkuru summu tukšumiem -

98
00:06:11,030 --> 00:06:12,890
pat nav vispār.

99
00:06:12,890 --> 00:06:18,100
Tātad, tāpēc komentārs piemin iespējams ar vadošajiem un / vai tukšumus.

100
00:06:18,100 --> 00:06:22,910
Tātad, šajā brīdī tas izskatās mūsu sscanf aicinājumu mēģinās parsēt lietotāja ieejas virknes

101
00:06:22,910 --> 00:06:25,380
, pārbaudot iespējamo vadošo atstarpi,

102
00:06:25,380 --> 00:06:29,300
seko int kas tiks konvertēta un uzglabā int mainīgo n

103
00:06:29,300 --> 00:06:33,090
seko kādu summu atstarpes, un seko rakstura

104
00:06:33,090 --> 00:06:35,810
uzglabā char mainīgā c.

105
00:06:35,810 --> 00:06:37,790
>> Kas par atgriešanās vērtību?

106
00:06:37,790 --> 00:06:41,560
Sscanf parsēt ieejas līniju no sākuma līdz beigām,

107
00:06:41,560 --> 00:06:44,860
apstāšanās, kad tā sasniedz beigām vai ja rakstzīmi ievades

108
00:06:44,860 --> 00:06:49,320
nesakrīt formāta raksturs vai ja tas nevar veikt konversiju.

109
00:06:49,320 --> 00:06:52,690
Tas ir atgriešanās vērtība tiek izmantota, lai izdalīt, kad tas apstājās.

110
00:06:52,690 --> 00:06:55,670
Ja tas apstājās, jo tas sasnieguši ieejas virknes

111
00:06:55,670 --> 00:07:00,630
Pirms jebkādu konvertēšanu un pirms nespēj saskaņot daļu no formāta virknes,

112
00:07:00,630 --> 00:07:04,840
tad īpaša pastāvīga EOF tiek atgriezta.

113
00:07:04,840 --> 00:07:08,200
Pretējā gadījumā tas atgriež vairākas veiksmīgas konvertēšanu,

114
00:07:08,200 --> 00:07:14,380
kas varētu būt 0, 1, 2 vai, jo mēs esam lūdza divus reklāmguvumiem.

115
00:07:14,380 --> 00:07:19,000
Mūsu gadījumā, mēs vēlamies pārliecināties, ka lietotājs ievadījis int un tikai Int.

116
00:07:19,000 --> 00:07:23,370
>> Tātad, mēs vēlamies sscanf atgriezties 1. Redzēt, kāpēc?

117
00:07:23,370 --> 00:07:26,850
Ja sscanf atgriezās 0, tad nav pārrēķināšana tika veikta,

118
00:07:26,850 --> 00:07:31,690
lai lietotājs drukāti kaut ko citu nekā int sākumā ieejas.

119
00:07:31,690 --> 00:07:37,100
Ja sscanf atgriež 2, tad lietotājs nebija pareizi ierakstiet to sākumā ieejas,

120
00:07:37,100 --> 00:07:41,390
bet pēc tam viņi drukāti dažās bez atstarpēm raksturs vēlāk

121
00:07:41,390 --> 00:07:44,940
kopš% c konversija izdevās.

122
00:07:44,940 --> 00:07:49,570
Wow, tas ir diezgan garš skaidrojums par vienu funkciju zvanu.

123
00:07:49,570 --> 00:07:53,460
Anyway, ja jūs vēlaties vairāk informācijas par sscanf un tās vecvecākus,

124
00:07:53,460 --> 00:07:57,130
izbraukšana cilvēks lapas, google, vai abus.

125
00:07:57,130 --> 00:07:58,780
Ir daudz formāta stīgu opcijas,

126
00:07:58,780 --> 00:08:03,830
un tie var ietaupīt daudz roku darba, mēģinot apstrādāt virknes C.

127
00:08:03,830 --> 00:08:07,180
>> Galīgo funkcija bibliotēkā apskatīt ir GetString.

128
00:08:07,180 --> 00:08:10,310
Izrādās, ka GetString ir grūts uzdevums rakstīt pareizi,

129
00:08:10,310 --> 00:08:14,290
pat ja tas šķiet tik vienkāršs, kopīgu uzdevumu.

130
00:08:14,290 --> 00:08:16,170
Kāpēc tas notiek?

131
00:08:16,170 --> 00:08:21,380
Nu, pieņemsim domāt par to, kā mēs spēsim saglabāt līniju, ka lietotājs iekšā

132
00:08:21,380 --> 00:08:23,880
Tā virkne ir secība chars,

133
00:08:23,880 --> 00:08:26,430
mēs varētu vēlēties, lai saglabātu to masīvā uz skursteņa,

134
00:08:26,430 --> 00:08:31,250
bet mums būtu nepieciešams zināt, cik ilgi masīvs būs, kad mēs par to ziņo.

135
00:08:31,250 --> 00:08:34,030
Tāpat, ja mēs gribam, lai tā uz kaudzes,

136
00:08:34,030 --> 00:08:38,090
Mums nepieciešams nodot lai malloc baitu skaitu mēs vēlamies, lai rezervē,

137
00:08:38,090 --> 00:08:39,730
bet tas ir neiespējami.

138
00:08:39,730 --> 00:08:42,760
Mums nav ne jausmas, cik daudz simb lietotājs tips

139
00:08:42,760 --> 00:08:46,590
pirms lietotājs faktiski nav rakstīt tos.

140
00:08:46,590 --> 00:08:50,720
>> Naivs risinājums šai problēmai ir tikai rezervēt lielu rieciens vietas, teiksim,

141
00:08:50,720 --> 00:08:54,540
bloks 1000 chars uz lietotāja ievadītajiem datiem,

142
00:08:54,540 --> 00:08:57,980
pieņemot, ka lietotājs nekad ierakstiet virkni, kas ilgi.

143
00:08:57,980 --> 00:09:00,810
Tas ir slikta ideja divu iemeslu dēļ.

144
00:09:00,810 --> 00:09:05,280
Pirmkārt, pieņemot, ka lietotāji parasti nav rakstīt stīgas, ka ilgi,

145
00:09:05,280 --> 00:09:07,610
jūs varētu atkritumu daudz atmiņas.

146
00:09:07,610 --> 00:09:10,530
Uz mūsdienu mašīnām, tas varētu būt jautājums, ja jūs šo

147
00:09:10,530 --> 00:09:13,890
vienā vai divos atsevišķos gadījumos,

148
00:09:13,890 --> 00:09:17,630
bet, ja jūs lietojat lietotāja ievadi ar cilpu un uzglabāšanai vēlākai izmantošanai,

149
00:09:17,630 --> 00:09:20,870
Jūs varat ātri uzsūkt ton atmiņas.

150
00:09:20,870 --> 00:09:24,450
Turklāt, ja programma jūs esat rakstiski ir mazāku datoru -

151
00:09:24,450 --> 00:09:28,100
ierīci, piemēram, viedtālrunis vai kaut kas cits ar ierobežotu atmiņu -

152
00:09:28,100 --> 00:09:32,060
šis risinājums radīs problēmas daudz ātrāk.

153
00:09:32,060 --> 00:09:36,450
Otrā, daudz nopietnu iemeslu to darīt, ir, ka tas atstāj savu programmu neaizsargāti

154
00:09:36,450 --> 00:09:39,710
, ko sauc bufera pārpildes uzbrukumu.

155
00:09:39,710 --> 00:09:45,840
Programmēšanā, buferis ir atmiņas izmanto uz laiku uzglabāt ievades vai izvades datus,

156
00:09:45,840 --> 00:09:48,980
kas šajā gadījumā ir mūsu 1000-char bloks.

157
00:09:48,980 --> 00:09:53,370
Bufera pārpildes notiek tad, kad dati ir rakstīts pagātnes beigām bloku.

158
00:09:53,370 --> 00:09:57,790
>> Piemēram, ja lietotājs tiešām veidu vairāk nekā 1000 simboli.

159
00:09:57,790 --> 00:10:01,570
Jums varētu būt pieredzējuši šo nejauši plānojot ar masīviem.

160
00:10:01,570 --> 00:10:05,620
Ja jums ir masīvs 10 Ints, nekas jūs no mēģinot lasīt un rakstīt

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

162
00:10:07,810 --> 00:10:10,000
Nav kompilators brīdinājumi vai kļūdas.

163
00:10:10,000 --> 00:10:13,250
Programmā tikai Blunders taisni un piekļūst atmiņas

164
00:10:13,250 --> 00:10:18,150
ja tā domā 15 int būs, un tas var pārrakstīt savu citi mainīgie.

165
00:10:18,150 --> 00:10:22,040
Sliktākajā gadījumā, jūs varat pārrakstīt dažas no jūsu programmas iekšējās

166
00:10:22,040 --> 00:10:26,820
kontroles mehānismi, kas izraisa jūsu programmu, lai reāli izpildīt dažādas instrukcijas

167
00:10:26,820 --> 00:10:28,340
nekā paredzēts.

168
00:10:28,340 --> 00:10:31,360
>> Tagad, tas nav bieži to darīt nejauši,

169
00:10:31,360 --> 00:10:35,150
bet tas ir diezgan izplatīta metode, kas slikti puiši izmanto, lai izjauktu programmas

170
00:10:35,150 --> 00:10:39,080
un nodot ļaunprātīgu kodu uz citu cilvēku datoriem.

171
00:10:39,080 --> 00:10:42,910
Tāpēc, mēs varam ne tikai izmantot savu naivo risinājumu.

172
00:10:42,910 --> 00:10:45,590
Mums ir nepieciešams veids, lai novērstu mūsu programmas no neaizsargāti

173
00:10:45,590 --> 00:10:47,880
uz bufera pārpildes uzbrukumu.

174
00:10:47,880 --> 00:10:51,430
Lai to izdarītu, mums ir nepieciešams, lai pārliecinātos, ka mūsu bufera var augt kā mēs lasām

175
00:10:51,430 --> 00:10:53,850
vairāk ieeja no lietotāja.

176
00:10:53,850 --> 00:10:57,440
Risinājums? Mēs izmantojam kaudze piešķirti buferi.

177
00:10:57,440 --> 00:10:59,950
Tā kā mēs varam mainīt to, izmantojot mainītu realloc funkciju,

178
00:10:59,950 --> 00:11:04,580
un mēs sekot divu skaitļu - indeksu nākamā slotā buferī

179
00:11:04,580 --> 00:11:08,390
un garums vai bufera kapacitāte.

180
00:11:08,390 --> 00:11:13,210
Mēs lasīt chars no lietotāja pa vienam, izmantojot fgetc funkciju.

181
00:11:13,210 --> 00:11:19,360
The argumentu fgetc funkcija tiek - stdin - ir atsauce uz standarta ieejas virkni,

182
00:11:19,360 --> 00:11:23,810
kas ir preconnected ieejas kanālu, kas tiek izmantots, lai pārsūtītu lietotāja ievadi

183
00:11:23,810 --> 00:11:26,270
no termināla programmu.

184
00:11:26,270 --> 00:11:29,890
>> Ikreiz, kad lietotājs veidiem jaunu raksturu, mēs pārbaudām, ja indekss

185
00:11:29,890 --> 00:11:35,810
par nākamo brīvās slota plus 1 ir lielāks nekā spēju bufera.

186
00:11:35,810 --> 00:11:39,690
+1 Nāk, jo, ja nākamais bezmaksas indekss ir 5,

187
00:11:39,690 --> 00:11:44,150
tad mūsu bufera sistēmas garums jābūt 6 pateicoties 0 indeksācija.

188
00:11:44,150 --> 00:11:48,350
Ja mēs esam pietrūkt vietas buferī, tad mēs mēģināsim, lai mainītu to,

189
00:11:48,350 --> 00:11:51,690
dubultojot to tā, ka mēs samazināt par to, cik reizes mēs mainīt

190
00:11:51,690 --> 00:11:54,760
ja lietotājs ir rakstīt patiešām ilgu virknes.

191
00:11:54,760 --> 00:11:57,950
Ja virkne ir gotten pārāk ilgi, vai ja mēs izsīkšanai kaudze atmiņas,

192
00:11:57,950 --> 00:12:01,350
mēs atbrīvotu mūsu buferis un atgriezties null.

193
00:12:01,350 --> 00:12:04,170
>> Visbeidzot, mēs pievienot char uz bufera.

194
00:12:04,170 --> 00:12:08,200
Kad lietotājs hits ienākt vai atgriezties, signalizē par jaunu līniju,

195
00:12:08,200 --> 00:12:12,050
vai īpašu CHAR - kontrole d - kas liecina galu ievadi,

196
00:12:12,050 --> 00:12:16,240
mēs pārbaudi, lai redzētu, ja lietotājs faktiski drukāti neko.

197
00:12:16,240 --> 00:12:18,820
Ja ne, mēs atgriežamies null.

198
00:12:18,820 --> 00:12:22,280
Citādi, jo mūsu buferis ir iespējams lielāks nekā mums vajag,

199
00:12:22,280 --> 00:12:24,830
sliktākajā gadījumā tas ir gandrīz divas reizes lielāka kā mums vajag

200
00:12:24,830 --> 00:12:27,830
jo mēs divreiz katru reizi, kad mēs mainīt izmērus,

201
00:12:27,830 --> 00:12:31,840
mēs jaunu kopiju virknes, izmantojot tikai vietas daudzumu, kas mums ir nepieciešams.

202
00:12:31,840 --> 00:12:34,220
Mēs pievienot papildu 1 līdz malloc zvanu,

203
00:12:34,220 --> 00:12:37,810
tāpēc, ka tur ir vietas īpašo null terminatora raksturs - \ 0,

204
00:12:37,810 --> 00:12:41,990
kas mums pievienot uz virkni reiz mēs kopēt pārējās rakstzīmes,

205
00:12:41,990 --> 00:12:45,060
izmantojot strncpy nevis strcpy

206
00:12:45,060 --> 00:12:48,830
lai mēs varētu precīzi norādīt, cik daudz simb mēs vēlamies, lai kopētu.

207
00:12:48,830 --> 00:12:51,690
Strcpy kopē līdz tas hits \ 0.

208
00:12:51,690 --> 00:12:55,740
Tad mēs atbrīvotu mūsu buferis un eksemplāru atdod atpakaļ zvanītāju.

209
00:12:55,740 --> 00:12:59,840
>> Kurš zināja šāda vienkārša-šķietams funkciju varētu tik sarežģīti?

210
00:12:59,840 --> 00:13:02,820
Tagad jūs zināt, kas iet uz CS50 bibliotēkā.

211
00:13:02,820 --> 00:13:06,470
>> Mans vārds ir Nate Hardison, un tas ir CS50.

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