1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Nädal 4]

2
00:00:03,000 --> 00:00:05,000
[David J. Malan] [Harvardi Ülikool]

3
00:00:05,000 --> 00:00:08,000
[See on CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> Olgu, see on CS50, ja see on algus 4. nädalal

5
00:00:12,000 --> 00:00:16,000
ja see on üks aeglaseim võimalik sorteerimise algoritme.

6
00:00:16,000 --> 00:00:19,000
Kumb oli see, et me lihtsalt vaatasin seal?

7
00:00:19,000 --> 00:00:24,000
See oli mull sorteerida, et suur O (n ^ 2) + summa,

8
00:00:24,000 --> 00:00:28,000
ja tõepoolest me ei ole ainsad selles maailmas tundub, et tean

9
00:00:28,000 --> 00:00:30,000
mida mull sorteerida on või tema töötamise aja.

10
00:00:30,000 --> 00:00:33,000
Tõepoolest, see oli intervjuu Eric Schmidt Google

11
00:00:33,000 --> 00:00:45,000
ja endine senaator Barack Obama paar aastat tagasi.

12
00:00:45,000 --> 00:00:48,000
>> Nüüd, senaator, et sa siin oled Google,

13
00:00:48,000 --> 00:00:54,000
ja mulle meeldib mõelda eesistujariigi nagu tööintervjuu.

14
00:00:54,000 --> 00:00:58,000
Nüüd, see on raske tööd saada presidendiks, ja sa lähed läbi külmavärinad nüüd.

15
00:00:58,000 --> 00:01:00,000
Samuti on raske saada tööd Google.

16
00:01:00,000 --> 00:01:05,000
Meil on küsimusi, ja me palume meie kandidaatide küsimused,

17
00:01:05,000 --> 00:01:10,000
ja see üks on Larry Schwimmer.

18
00:01:10,000 --> 00:01:14,000
Te arvate, et ma teen nalja? See on siinsamas.

19
00:01:14,000 --> 00:01:18,000
Mis on kõige tõhusam viis sorteerida miljonit 32-bitise täisarvu?

20
00:01:18,000 --> 00:01:21,000
[Naer]

21
00:01:21,000 --> 00:01:24,000
Hästi-

22
00:01:24,000 --> 00:01:26,000
Mul on kahju. >> Ei, ei, ei, ei.

23
00:01:26,000 --> 00:01:34,000
Ma arvan, et mull sorteerida oleks vale tee.

24
00:01:34,000 --> 00:01:39,000
>> Tule, kes rääkis talle seda?

25
00:01:39,000 --> 00:01:43,000
Eelmisel nädalal meenutada võtsime pausi kood, vähemalt kord päevas,

26
00:01:43,000 --> 00:01:46,000
ja hakkas keskendudes mõnele kõrgemale tasemele ideede ja probleemide lahendamine üldisemalt

27
00:01:46,000 --> 00:01:49,000
kontekstis otsimine ja sorteerimine,

28
00:01:49,000 --> 00:01:53,000
ja tutvustasime midagi, mida me ei laksu selle nime eelmisel nädalal,

29
00:01:53,000 --> 00:01:56,000
kuid asümptootilisest märge, Big O, Big Omega,

30
00:01:56,000 --> 00:02:00,000
ja mõnikord Big Theta märke, ja need olid lihtsalt võimalusi

31
00:02:00,000 --> 00:02:02,000
kirjeldada sõiduaega algoritme,

32
00:02:02,000 --> 00:02:05,000
kui palju aega kulub algoritm joosta.

33
00:02:05,000 --> 00:02:08,000
>> Ja ehk mäletate, et sa rääkisid sõiduaega poolest suurus

34
00:02:08,000 --> 00:02:11,000
sissetulevate, mida me tavaliselt kutsume n olenemata võib probleem olla,

35
00:02:11,000 --> 00:02:13,000
kus n on inimeste arv toas,

36
00:02:13,000 --> 00:02:17,000
lehekülgede arv telefoniraamatust ja hakkasime kirjutama asju teha

37
00:02:17,000 --> 00:02:21,000
nagu O (n ^ 2) või O (n) ehk O (n log n),

38
00:02:21,000 --> 00:02:24,000
ja isegi kui matemaatikat ei ole päris välja töötada nii perfektselt

39
00:02:24,000 --> 00:02:28,000
ja see oli n ² - n / 2 või midagi sellist

40
00:02:28,000 --> 00:02:31,000
me oleks selle asemel lihtsalt ära visata mõned väiksemad mõttes

41
00:02:31,000 --> 00:02:34,000
ja motivatsioon on, et me tõesti tahame

42
00:02:34,000 --> 00:02:37,000
omamoodi objektiivselt hinnata

43
00:02:37,000 --> 00:02:39,000
tulemuslikkust programmide või täitmise algoritmid

44
00:02:39,000 --> 00:02:42,000
et lõpus päeval ei ole midagi, näiteks

45
00:02:42,000 --> 00:02:45,000
koos kiirust oma arvuti täna.

46
00:02:45,000 --> 00:02:47,000
>> Näiteks, kui sa ellu mull sorteerida,

47
00:02:47,000 --> 00:02:50,000
või sa ellu ühendada sorteerida või valik omamoodi tänapäeva arvuti,

48
00:02:50,000 --> 00:02:53,000
2 GHz arvuti, ja sa jooksed ta,

49
00:02:53,000 --> 00:02:56,000
ja see võtab mitu sekundit, järgmisel aastal seal 3 GHz

50
00:02:56,000 --> 00:02:59,000
või 4 GHz arvuti, ja sa võiks siis väita, et "Wow, minu algoritm

51
00:02:59,000 --> 00:03:03,000
Nüüd on kaks korda kiirem, "kui tegelikult see on ilmselt nii ei ole.

52
00:03:03,000 --> 00:03:06,000
See on lihtsalt riistvara on saanud kiiremini, kuid arvuti

53
00:03:06,000 --> 00:03:10,000
ei ole, ja nii me tõesti tahame visata asjad

54
00:03:10,000 --> 00:03:13,000
2-kordselt või 3-kordselt, kui tegemist on kirjeldava

55
00:03:13,000 --> 00:03:17,000
kui kiiresti või kuidas aeglane algoritm on ja tõesti keskenduda ainult

56
00:03:17,000 --> 00:03:20,000
n või mõni tegur selle

57
00:03:20,000 --> 00:03:24,000
mõned väge kui puhul kehvasti eelmisel nädalal.

58
00:03:24,000 --> 00:03:27,000
Ja meelde tuletada, et abiga ühendamise sorteeri

59
00:03:27,000 --> 00:03:31,000
suutsime teha nii palju parem kui mull sorteerida ning valik omamoodi

60
00:03:31,000 --> 00:03:33,000
ja isegi sisestamise omamoodi.

61
00:03:33,000 --> 00:03:36,000
>> Meil alla n log n, ja jälle,

62
00:03:36,000 --> 00:03:39,000
tuletada meelde, et log n üldiselt viitab millelegi, mis kasvab

63
00:03:39,000 --> 00:03:43,000
aeglasemalt siis n, nii et n log n siiani oli hea

64
00:03:43,000 --> 00:03:45,000
sest see oli väiksem kui n ².

65
00:03:45,000 --> 00:03:47,000
Kuid selleks, et n log n koos ühendamise sorteeri

66
00:03:47,000 --> 00:03:51,000
Mis oli põhiline alge mõte, et meil oli võimendada

67
00:03:51,000 --> 00:03:54,000
et meil on ka võimendatud tagasi nädal 0?

68
00:03:54,000 --> 00:03:58,000
Kuidas me lahendada sorteerimine probleem nutikalt koos ühendamise sorteerida?

69
00:03:58,000 --> 00:04:04,000
Mis oli Võtmeküsimuseks, ehk?

70
00:04:04,000 --> 00:04:07,000
Igaüks üldse.

71
00:04:07,000 --> 00:04:09,000
Okei, astuda samm tagasi.

72
00:04:09,000 --> 00:04:11,000
Kirjelda liita omamoodi oma sõnadega.

73
00:04:11,000 --> 00:04:15,000
Kuidas see toimib?

74
00:04:15,000 --> 00:04:17,000
Hästi, me reale tagasi nädal 0.

75
00:04:17,000 --> 00:04:19,000
Okei, jah.

76
00:04:19,000 --> 00:04:22,000
[Kuuldamatu-õpilane]

77
00:04:22,000 --> 00:04:26,000
Okei, hea, et me jagatud array numbrid 2 tk.

78
00:04:26,000 --> 00:04:29,000
Me järjestatud kõik need tükid ja siis liitis need,

79
00:04:29,000 --> 00:04:33,000
ja me oleme näinud seda mõtet enne võtmise probleem, et see on suur

80
00:04:33,000 --> 00:04:36,000
ja tükeldamist it up probleem, et see on suur või see suur.

81
00:04:36,000 --> 00:04:38,000
>> Meenuta telefoniraamatust näiteks.

82
00:04:38,000 --> 00:04:42,000
Meenuta ise loendamise algoritmi alates nädalat tagasi

83
00:04:42,000 --> 00:04:45,000
nii liita omamoodi tegi kokkuvõtte selle pseudokoodi siin.

84
00:04:45,000 --> 00:04:48,000
Kui olete antud n elementi, esimene oli meelerahu vaadata.

85
00:04:48,000 --> 00:04:51,000
Kui n <2, siis ei tee üldse midagi

86
00:04:51,000 --> 00:04:55,000
sest kui n <2, siis n on ilmselt 0 või 1,

87
00:04:55,000 --> 00:04:57,000
ja nii kui see on 0 või 1, ei midagi sorteerida.

88
00:04:57,000 --> 00:04:59,000
Sa oled teinud.

89
00:04:59,000 --> 00:05:01,000
Sinu nimekirjas on juba triviaalselt sorteerida.

90
00:05:01,000 --> 00:05:04,000
Aga muidu kui sul 2 või rohkem elemente minna ja jagada neid

91
00:05:04,000 --> 00:05:06,000
jagatakse 2 poolt, vasakule ja paremale.

92
00:05:06,000 --> 00:05:09,000
Sorteeri kõik need pooleks ja seejärel ühendada järjestatud pooleks.

93
00:05:09,000 --> 00:05:13,000
Aga probleem on selles, et esmapilgul tundub see me punting.

94
00:05:13,000 --> 00:05:17,000
See on ümmarguse määratlust, et kui ma olen palunud teil sorteerida neid n elementi

95
00:05:17,000 --> 00:05:22,000
ja sa räägid mulle "Olgu, me ajame need n / 2 ja need n / 2 elementi"

96
00:05:22,000 --> 00:05:27,000
siis minu järgmine küsimus saab olema "Olgu, kuidas sa sorteerimise n / 2 elementi?"

97
00:05:27,000 --> 00:05:30,000
>> Aga struktuuri tõttu on see programm,

98
00:05:30,000 --> 00:05:33,000
sest seal on see alus juhul, kui nii võib öelda,

99
00:05:33,000 --> 00:05:39,000
see eriline juhtum, mis ütleb, et kui n on <mõned fikseeritud väärtus nagu 2 kohe tagasi.

100
00:05:39,000 --> 00:05:42,000
Ärge vastata, et sama ümmarguse vastuse.

101
00:05:42,000 --> 00:05:46,000
See protsess, see tsükli lõpuks hakkab.

102
00:05:46,000 --> 00:05:50,000
Kui ma küsin teilt "Sordi need n elementi," ja sa ütled "Fine, sorteerida need n / 2"

103
00:05:50,000 --> 00:05:53,000
siis sa ütled, "Fine, sorteerida need n / 4, n / 8, n/16"

104
00:05:53,000 --> 00:05:56,000
lõpuks saad jagage piisavalt suur arv

105
00:05:56,000 --> 00:05:59,000
et sul on vaid 1 element vasakule, misjärel võite öelda,

106
00:05:59,000 --> 00:06:02,000
"Siin, siin on järjestatud ühe osa."

107
00:06:02,000 --> 00:06:06,000
Siis sära Selle algoritmi siin on tulenevad asjaolust,

108
00:06:06,000 --> 00:06:09,000
et kui sul on kõik need eraldi sorteerida nimekirju,

109
00:06:09,000 --> 00:06:12,000
mis kõik on suurus 1, mis tundub olevat mõttetu,

110
00:06:12,000 --> 00:06:15,000
kui hakkate neid ühendamata ja neid ühendamata

111
00:06:15,000 --> 00:06:19,000
teil luua lõpuks nagu Rob tegi video lõpuks järjestatud nimekirja.

112
00:06:19,000 --> 00:06:22,000
>> Aga see idee ulatub palju kaugemale sorteerimine.

113
00:06:22,000 --> 00:06:26,000
On see mõte peidetud selle programmi tuntakse rekursioon,

114
00:06:26,000 --> 00:06:29,000
Idee, mille olete programmi

115
00:06:29,000 --> 00:06:32,000
ja lahendada mõned probleemid helistate ise,

116
00:06:32,000 --> 00:06:36,000
või panna kontekstis programmeerimiskeeled olete funktsiooni,

117
00:06:36,000 --> 00:06:39,000
ja selleks, et lahendada probleem, siis funktsioon kõne ise

118
00:06:39,000 --> 00:06:42,000
uuesti ja uuesti ja uuesti, kuid sa funktsiooni

119
00:06:42,000 --> 00:06:44,000
ei sea ennast lõpmata palju kordi.

120
00:06:44,000 --> 00:06:47,000
Lõpuks sa pead alt välja, kui nii võib öelda,

121
00:06:47,000 --> 00:06:49,000
ja mõned püsiprogrammeeritud baasi tingimus, mis ütleb,

122
00:06:49,000 --> 00:06:53,000
siinkohal lõpetada helistab ise, nii et kogu protsess

123
00:06:53,000 --> 00:06:56,000
lõpuks tõepoolest lõpetama.

124
00:06:56,000 --> 00:06:58,000
Mida see tegelikult tähendab, et recurse?

125
00:06:58,000 --> 00:07:01,000
>> Vaatame, kas me saame teha lihtne, triviaalne näiteks, ütleme,

126
00:07:01,000 --> 00:07:03,000
3 inimest koos minuga siin laval, kui keegi on mugav.

127
00:07:03,000 --> 00:07:06,000
1, tulge, 2 ja 3.

128
00:07:06,000 --> 00:07:09,000
Kui teile 3 soovi tulla siia.

129
00:07:09,000 --> 00:07:12,000
Kui soovid kandideerida kõrval mind siin rida, arvan, et probleem käepärast

130
00:07:12,000 --> 00:07:15,000
on väga triviaalselt loendada inimesi, kes on siin.

131
00:07:15,000 --> 00:07:18,000
Aga ausalt öeldes, ma olen väsinud kõigist neist lugedes näiteid.

132
00:07:18,000 --> 00:07:21,000
See läheb aega, 1, 2, ja dot, dot, dot.

133
00:07:21,000 --> 00:07:23,000
See saab võtta igaveseks.

134
00:07:23,000 --> 00:07:25,000
Ma pigem lihtsalt punt seda probleemi üldse abiga-mis su nimi on?

135
00:07:25,000 --> 00:07:27,000
Sara. >> Sara, eks.

136
00:07:27,000 --> 00:07:29,000
Kelly. >> Kelly ja?

137
00:07:29,000 --> 00:07:31,000
>> Willy. >> Willy, Sara, Kelly, ja Willy.

138
00:07:31,000 --> 00:07:34,000
Just nüüd on mul palutud seda küsimust keegi

139
00:07:34,000 --> 00:07:37,000
kui palju inimesi on üles antud etapis ja ma ei tea.

140
00:07:37,000 --> 00:07:40,000
See on tõesti pikk nimekiri, ja et selle asemel ma lähen tegema seda trikki.

141
00:07:40,000 --> 00:07:43,000
Ma küsin inimene minu kõrval teha suurema osa tööst,

142
00:07:43,000 --> 00:07:46,000
ja kui ta on teinud teed suurema osa tööst

143
00:07:46,000 --> 00:07:49,000
Ma lähen tegema vähemalt töömahtu võimalik ja lihtsalt lisage 1

144
00:07:49,000 --> 00:07:51,000
mis iganes tema vastus on, et siin me läheme.

145
00:07:51,000 --> 00:07:54,000
Mul paluti kuidas paljud inimesed on laval.

146
00:07:54,000 --> 00:07:57,000
Kui paljud inimesed on laval vasakul oled?

147
00:07:57,000 --> 00:08:00,000
Vasakul mind? >> Okei, aga ära peta.

148
00:08:00,000 --> 00:08:04,000
See on hea, see on õige, kuid kui me tahame jätkata seda loogikat

149
00:08:04,000 --> 00:08:08,000
Oletame, et sa samamoodi tahavad punt see probleem vasakule sa,

150
00:08:08,000 --> 00:08:11,000
Nii et pigem vastus otse minna ja lihtsalt vastutusest kõrvale hiilima.

151
00:08:11,000 --> 00:08:14,000
Oh, kui palju inimesi on vasakul profiili?

152
00:08:14,000 --> 00:08:16,000
Mitu inimest on vasakule?

153
00:08:16,000 --> 00:08:18,000
1.

154
00:08:18,000 --> 00:08:27,000
[Naer]

155
00:08:27,000 --> 00:08:30,000
Okei, nii et 0, mis siis nüüd Willy teinud

156
00:08:30,000 --> 00:08:33,000
on sul tagasi oma vastus selles suunas öeldes 0.

157
00:08:33,000 --> 00:08:36,000
Nüüd, mida peaksite tegema? >> 1.

158
00:08:36,000 --> 00:08:39,000
Okei, nii et sa oled 1, seega sa ütled "Olgu, ma lähen lisada 1

159
00:08:39,000 --> 00:08:41,000
mis iganes Willy arv oli, "nii 1 + 0.

160
00:08:41,000 --> 00:08:43,000
Sa oled nüüd 1 nii oma vastus õige on nüüd-

161
00:08:43,000 --> 00:08:45,000
1. >> Ja minu oleks 2.

162
00:08:45,000 --> 00:08:48,000
Hea, et te võtate eelmises vastuses: 1,

163
00:08:48,000 --> 00:08:51,000
lisades minimaalselt tööd sa teha tahad, mis on +1.

164
00:08:51,000 --> 00:08:55,000
Sul on nüüd 2 ja siis pead andma mulle mis väärtus?

165
00:08:55,000 --> 00:08:57,000
3 Ma mõtlen, vabandust, 2.

166
00:08:57,000 --> 00:08:59,000
Hea.

167
00:08:59,000 --> 00:09:02,000
>> Noh, meil oli 0 kuni vasakule.

168
00:09:02,000 --> 00:09:05,000
Siis oli meil 1 ja seejärel lisame 2

169
00:09:05,000 --> 00:09:07,000
ja nüüd sa üleandmise mulle number 2,

170
00:09:07,000 --> 00:09:10,000
ja nii ma räägin, okei, 1, 3.

171
00:09:10,000 --> 00:09:13,000
Seal on tõesti 3 inimest alalise kõrval mind selles etapis

172
00:09:13,000 --> 00:09:16,000
nii me oleks võinud ilmselt seda teinud väga lineaarselt,

173
00:09:16,000 --> 00:09:19,000
vägagi selge mood, aga mida me siis tegelikult teeme?

174
00:09:19,000 --> 00:09:21,000
Võtsime probleemi suurus 3 esialgu.

175
00:09:21,000 --> 00:09:24,000
Siis murdis ta jaguneb probleemi suurus 2,

176
00:09:24,000 --> 00:09:27,000
siis probleemi suurus 1, ja siis lõpuks tugipunkti

177
00:09:27,000 --> 00:09:29,000
oli tõesti, oh, seal on keegi seal,

178
00:09:29,000 --> 00:09:33,000
kus punkt Willy tagasi tõhusalt kodeeritud vastus paar korda,

179
00:09:33,000 --> 00:09:36,000
ja teine ​​oli siis mullidena üles, mullidena üles, mullidena üles

180
00:09:36,000 --> 00:09:39,000
ja siis lisades selle ühe lisanduva 1

181
00:09:39,000 --> 00:09:41,000
oleme rakendanud seda põhiidee rekursioon.

182
00:09:41,000 --> 00:09:44,000
>> Nüüd, sel juhul ei ole ta tegelikult lahendada probleemi

183
00:09:44,000 --> 00:09:46,000
enam tõhusalt siis oleme näinud siiani.

184
00:09:46,000 --> 00:09:48,000
Aga mõtle algoritme oleme teinud laval siiani.

185
00:09:48,000 --> 00:09:51,000
Meil oli 8 tükki raamat kriiditahvel,

186
00:09:51,000 --> 00:09:55,000
video kui Sean otsisin number 7, ja mida ta tegelikult teha?

187
00:09:55,000 --> 00:09:58,000
Noh, ta ei teinud mingeid jaga ja valitse.

188
00:09:58,000 --> 00:10:01,000
Ta ei teinud mingeid rekursioon.

189
00:10:01,000 --> 00:10:03,000
Pigem ta lihtsalt tegi seda lineaarne algoritm.

190
00:10:03,000 --> 00:10:07,000
Aga kui me tutvustas ideed järjestatud numbrite laval elama eelmisel nädalal

191
00:10:07,000 --> 00:10:09,000
siis meil oli see instinkt läheb keskel,

192
00:10:09,000 --> 00:10:13,000
kus punkt oli meil väiksem nimekirja suurus 4 või teise nimekirja size 4,

193
00:10:13,000 --> 00:10:17,000
ja siis meil oli täpselt sama probleem, nii et me korrata, korrata, korrata.

194
00:10:17,000 --> 00:10:19,000
Teisisõnu, me rekursiivselt.

195
00:10:19,000 --> 00:10:24,000
Tänan teid väga, et meie 3 vabatahtlikele siin näitamaks, rekursioon koos meiega.

196
00:10:24,000 --> 00:10:28,000
>> Vaatame, kas me ei saa teha seda nüüd natuke konkreetsem,

197
00:10:28,000 --> 00:10:30,000
lahendada probleem, et jälle me võiks teha päris kergesti,

198
00:10:30,000 --> 00:10:34,000
kuid me kasutame seda nagu hüppelaud rakendatakse seda põhimõtet.

199
00:10:34,000 --> 00:10:37,000
Kui ma tahan arvutada liitmise hunnik numbreid,

200
00:10:37,000 --> 00:10:39,000
Näiteks, kui te kaotate arv 3,

201
00:10:39,000 --> 00:10:42,000
Ma tahan teile anda väärtus sigma 3,

202
00:10:42,000 --> 00:10:46,000
nii summa 3 + 2 + 1 + 0.

203
00:10:46,000 --> 00:10:48,000
Ma tahan saada tagasi vastus 6

204
00:10:48,000 --> 00:10:51,000
nii me rakendada seda sigma funktsioon, see liitmise funktsioon

205
00:10:51,000 --> 00:10:54,000
veel kord, et küsimus võetakse sisend ja tagastab liitmise

206
00:10:54,000 --> 00:10:57,000
et number kogu tee alla 0-ga.

207
00:10:57,000 --> 00:10:59,000
Me võiksime seda teha üsna lihtsalt, eks?

208
00:10:59,000 --> 00:11:01,000
Me võiksime seda teha mingi silmuspõletamise struktuur,

209
00:11:01,000 --> 00:11:04,000
seega lubage mul minna ja saada see algas.

210
00:11:04,000 --> 00:11:07,000
>> Kaasa stdio.h.

211
00:11:07,000 --> 00:11:09,000
Las ma saan ise võtta peamised tööd siin.

212
00:11:09,000 --> 00:11:12,000
Lähme päästa seda sigma.c.

213
00:11:12,000 --> 00:11:14,000
Siis ma lähen siia, ja ma lähen kuulutada int n,

214
00:11:14,000 --> 00:11:18,000
ja ma teen järgmised samas kui kasutaja ei tee koostööd.

215
00:11:18,000 --> 00:11:22,000
Kuigi kasutaja ei ole andnud mulle positiivne arv

216
00:11:22,000 --> 00:11:26,000
lubage mul minna ja kallutada neid n = GetInt,

217
00:11:26,000 --> 00:11:28,000
ja lubage mul anda neile mõned juhised, mida teha,

218
00:11:28,000 --> 00:11:33,000
nii printf ("positiivne täisarv palun").

219
00:11:33,000 --> 00:11:39,000
Lihtsalt midagi suhteliselt lihtne, nagu seda nii, et selleks ajaks oleme tabanud rida 14

220
00:11:39,000 --> 00:11:42,000
nüüd on meil positiivne täisarv arvatavasti n.

221
00:11:42,000 --> 00:11:44,000
>> Nüüd teeme midagi koos sellega.

222
00:11:44,000 --> 00:11:50,000
Lubage mul minna ja arvutama liitmise, nii int summa = sigma (n).

223
00:11:50,000 --> 00:11:54,000
Sigma on lihtsalt liitmise, nii et ma lihtsalt kirjutan seda Kasvataja viis.

224
00:11:54,000 --> 00:11:56,000
Me lihtsalt nimetame seda sigma seal.

225
00:11:56,000 --> 00:11:58,000
See on summa, ja nüüd ma lähen välja printida tulemus,

226
00:11:58,000 --> 00:12:08,000
printf ("summa on% d \ n", summa).

227
00:12:08,000 --> 00:12:11,000
Ja siis ma return 0 hea meede.

228
00:12:11,000 --> 00:12:15,000
Me oleme teinud kõik, et see programm vajab välja huvitav osa,

229
00:12:15,000 --> 00:12:18,000
mis on tegelikult rakendada sigma funktsioon.

230
00:12:18,000 --> 00:12:22,000
>> Lubage mul minna siia alla ja andke mulle kuulutada funktsioon sigma.

231
00:12:22,000 --> 00:12:26,000
See ju võtta muutuja, mis on tüüpi täisarv,

232
00:12:26,000 --> 00:12:30,000
ja milliseid andmeid tüüp ma tahan tagasi arvatavasti Sigma?

233
00:12:30,000 --> 00:12:34,000
Keskmine, sest ma tahan, et see vastaks mu ootustele real 15.

234
00:12:34,000 --> 00:12:37,000
Siin lubage mul minna ja rakendada seda

235
00:12:37,000 --> 00:12:41,000
aastal üsna lihtne viis.

236
00:12:41,000 --> 00:12:45,000
>> Lähme edasi ja öelda int summa = 0,

237
00:12:45,000 --> 00:12:47,000
ja nüüd ma lähen on vähe loop siin

238
00:12:47,000 --> 00:12:50,000
et ei ütle midagi sellist,

239
00:12:50,000 --> 00:13:01,000
jaoks (int i = 0; ma <= arv; i + +) summa + = i.

240
00:13:01,000 --> 00:13:05,000
Ja siis ma lähen tagasi summa.

241
00:13:05,000 --> 00:13:07,000
Ma oleks võinud rakendada seda igal mitmel viisil.

242
00:13:07,000 --> 00:13:09,000
Ma oleks võinud kasutada samas silmus.

243
00:13:09,000 --> 00:13:11,000
Ma oleks võinud vahele kasutades summa muutuja kui ma tõesti tahtsin,

244
00:13:11,000 --> 00:13:15,000
aga lühidalt öeldes, me lihtsalt peame funktsioon, et kui ma ei tobu deklareerib summa on 0..

245
00:13:15,000 --> 00:13:18,000
Siis ta kordab 0 püsti arvu kaudu,

246
00:13:18,000 --> 00:13:23,000
ja iga iteratsiooni ta lisab, et praeguse väärtuse summa ja tagastab summa.

247
00:13:23,000 --> 00:13:25,000
>> Nüüd, seal on kerge optimeerimine siin.

248
00:13:25,000 --> 00:13:29,000
See on ilmselt raisatud samm, kuid olgu nii. See on hea nüüd.

249
00:13:29,000 --> 00:13:32,000
Oleme vähemalt on põhjalik ja läheb 0 koik teed üles.

250
00:13:32,000 --> 00:13:34,000
Mitte väga raske ja üsna otsekohene,

251
00:13:34,000 --> 00:13:37,000
aga tuleb välja, et koos sigma funktsioon on meil samad võimalused

252
00:13:37,000 --> 00:13:39,000
nagu me tegime siin laval.

253
00:13:39,000 --> 00:13:42,000
Laval me lihtsalt arvestada, kui palju inimesi oli minu kõrval,

254
00:13:42,000 --> 00:13:47,000
vaid siis, kui me tahtsime loendada 3 + 2 + 1

255
00:13:47,000 --> 00:13:51,000
mööda kuni 0 võiksime sarnaselt punt funktsioon

256
00:13:51,000 --> 00:13:55,000
et ma selle asemel kirjeldada nagu oleks rekursiivne.

257
00:13:55,000 --> 00:13:57,000
Siin teeme kiire meelerahu vaadata ja veenduda, ma ei tobu.

258
00:13:57,000 --> 00:14:00,000
>> Ma tean, et vähemalt üks asi selles programmis, et ma tegin valesti.

259
00:14:00,000 --> 00:14:04,000
Kui ma Enter ma hakka mingeid karjud mu peale?

260
00:14:04,000 --> 00:14:06,000
Mida ma nüüd peale karjutakse umbes?

261
00:14:06,000 --> 00:14:11,000
Jah, ma unustasin prototüüp, et ma kasutan funktsiooni nimetatakse sigma real 15,

262
00:14:11,000 --> 00:14:16,000
kuid see ei ole deklareeritud kuni liin 22, nii et ma parim ennetavalt tõusevad siin

263
00:14:16,000 --> 00:14:22,000
ja kuulutada prototüüp, ja ma ütlen int sigma (int arv), ja ongi kõik.

264
00:14:22,000 --> 00:14:24,000
See on rakendatud allosas.

265
00:14:24,000 --> 00:14:27,000
>> Või teine ​​viis, kuidas ma saaks seda lahendada,

266
00:14:27,000 --> 00:14:30,000
Ma võiks liikuda funktsioon seal üleval, mis ei ole halb,

267
00:14:30,000 --> 00:14:32,000
kuid vähemalt kui teie programmid hakkama saada kaua, ausalt öeldes

268
00:14:32,000 --> 00:14:35,000
Ma arvan, et seal on mõned väärtus alati võttes peamine tipus

269
00:14:35,000 --> 00:14:38,000
nii et sa lugeja saab faili avada ja siis kohe näha

270
00:14:38,000 --> 00:14:40,000
mida programm teeb, ilma et otsida seda

271
00:14:40,000 --> 00:14:42,000
otsin, et peamine ülesanne.

272
00:14:42,000 --> 00:14:49,000
Lähme alla minu terminaliakent siin, proovige sigma teha sigma,

273
00:14:49,000 --> 00:14:51,000
ja ma silmamunad ka siin.

274
00:14:51,000 --> 00:14:55,000
Kaudsed deklaratsiooni funktsioon GetInt tähendab, et ma olen unustanud teha, mida veel?

275
00:14:55,000 --> 00:14:57,000
[Kuuldamatu-õpilane]

276
00:14:57,000 --> 00:15:00,000
Hea, et ilmselt levinud viga, et paneme selle siia üles,

277
00:15:00,000 --> 00:15:04,000
cs50.h, ja nüüd lähme tagasi oma terminali aknas.

278
00:15:04,000 --> 00:15:08,000
>> Ma Ekraani tühjendamiseks ja ma uuesti, teha sigma.

279
00:15:08,000 --> 00:15:11,000
Tundub, et on koostatud. Lubage mul nüüd jooksma sigma.

280
00:15:11,000 --> 00:15:15,000
Ma kirjuta number 3, ja ma ei saa 6, nii ei range kontroll,

281
00:15:15,000 --> 00:15:18,000
kuid vähemalt see näib toimivat esmapilgul, kuid nüüd lähme rippida ta peale,

282
00:15:18,000 --> 00:15:21,000
ja olgem tegelikult võimendada idee rekursioon taas

283
00:15:21,000 --> 00:15:24,000
väga lihtne kontekstis nii, et mõne nädala pärast

284
00:15:24,000 --> 00:15:27,000
kui me alustada uurimist Kasvataja andmestruktuurid kui massiivid

285
00:15:27,000 --> 00:15:30,000
meil on veel üks hend, mille abil

286
00:15:30,000 --> 00:15:33,000
manipuleerida neid andmestruktuure nagu me näeme.

287
00:15:33,000 --> 00:15:36,000
See on iteratiivne lähenemine, silmus lähenemine.

288
00:15:36,000 --> 00:15:39,000
>> Lubage mul selle asemel nüüd seda teha.

289
00:15:39,000 --> 00:15:44,000
Lubage mul selle asemel öelda, et liitmise arv

290
00:15:44,000 --> 00:15:48,000
kohta allapoole 0 on tõesti sama, mis

291
00:15:48,000 --> 00:15:53,000
number + sigma (arv - 1).

292
00:15:53,000 --> 00:15:57,000
Teisisõnu, nagu laval ma punted igale inimesed minu kõrval,

293
00:15:57,000 --> 00:16:00,000
ja need omakorda hoida punting kuni me lõpuks madalaima tasemeni Willy,

294
00:16:00,000 --> 00:16:03,000
kes tuli tagasi kodeeritud vastus nagu 0.

295
00:16:03,000 --> 00:16:07,000
Siin nüüd oleme sarnaselt punting et sigma

296
00:16:07,000 --> 00:16:10,000
sama funktsioon oli algselt nimega, kuid Võtmeküsimuseks siin

297
00:16:10,000 --> 00:16:12,000
on see, et me ei sea sigma identselt.

298
00:16:12,000 --> 00:16:14,000
Me ei läbides n.

299
00:16:14,000 --> 00:16:17,000
Me selgelt läbivad arv - 1

300
00:16:17,000 --> 00:16:20,000
nii veidi väiksem probleem, veidi väiksem probleem.

301
00:16:20,000 --> 00:16:23,000
>> Kahjuks see ei ole päris lahendus veel, ja enne kui me määrata

302
00:16:23,000 --> 00:16:26,000
mida võiks välja hüpates nii ilmne on mõned teist

303
00:16:26,000 --> 00:16:28,000
lubage mul minna ja uuesti teha.

304
00:16:28,000 --> 00:16:30,000
Tundub, et koostada midagi.

305
00:16:30,000 --> 00:16:32,000
Lubage mul uuesti, sigma koos 6.

306
00:16:32,000 --> 00:16:37,000
Oih, lubage mul uuesti, sigma koos 6.

307
00:16:37,000 --> 00:16:42,000
Me oleme näinud seda enne, kuid kogemata eelmine kord ka.

308
00:16:42,000 --> 00:16:48,000
Miks ma selle segasena killustatust süü? Jah.

309
00:16:48,000 --> 00:16:50,000
[Kuuldamatu-õpilane]

310
00:16:50,000 --> 00:16:53,000
Pole mingit alust juhul, täpsemalt, mida ilmselt juhtus?

311
00:16:53,000 --> 00:16:58,000
See on sümptom, mida käitumist?

312
00:16:58,000 --> 00:17:00,000
Ütle seda veidi valjemini.

313
00:17:00,000 --> 00:17:02,000
[Kuuldamatu-õpilane]

314
00:17:02,000 --> 00:17:05,000
See on lõputu silmuse tõhusalt, ja probleem lõpmatu ring

315
00:17:05,000 --> 00:17:08,000
kui need hõlmavad rekursioon sel juhul funktsiooni kutsutakse ise,

316
00:17:08,000 --> 00:17:10,000
juhtub iga kord, kui helistate funktsiooni?

317
00:17:10,000 --> 00:17:13,000
Noh, arvan, et tagasi kuidas me sätestatud mälu arvutis.

318
00:17:13,000 --> 00:17:16,000
Me ütlesime, et seal on see patakas mälu nimetatakse korstnat, mis on allosas,

319
00:17:16,000 --> 00:17:19,000
ja iga kord, kui helistate funktsiooni natuke rohkem mälu saab panna

320
00:17:19,000 --> 00:17:24,000
Selle nn korstna sisaldab seda funktsiooni kohalik muutujate või parameetrite,

321
00:17:24,000 --> 00:17:27,000
nii et kui sigma kutsub sigma kõned sigma kutsub sigma

322
00:17:27,000 --> 00:17:29,000
 kutsub sigma Kuhu see lugu lõpeb?

323
00:17:29,000 --> 00:17:31,000
>> Noh, see lõpuks ülekulu kogusumma

324
00:17:31,000 --> 00:17:33,000
mälu, et teil on olemas arvuti.

325
00:17:33,000 --> 00:17:37,000
Sa ületatud segmendi et sa peaksid jääma,

326
00:17:37,000 --> 00:17:40,000
ja sa saad seda killustatust süü, tuum dumpinguhinnaga,

327
00:17:40,000 --> 00:17:43,000
ja mida tuum dumpinguhinnaga tähendab, et mul on nüüd fail nimega tuum

328
00:17:43,000 --> 00:17:46,000
mis on fail, mis sisaldab nulle ja ühtesid

329
00:17:46,000 --> 00:17:49,000
et tegelikult tulevikus olema diagnostiliselt kasulik.

330
00:17:49,000 --> 00:17:52,000
Kui see ei ole selge, kust teie viga on

331
00:17:52,000 --> 00:17:54,000
tegelikult võite teha natuke kohtuekspertiis, kui nii võib öelda,

332
00:17:54,000 --> 00:17:58,000
Selle tuum dump faili, mis jällegi on lihtsalt terve hunnik nulle ja ühtesid

333
00:17:58,000 --> 00:18:02,000
et sisuliselt esindab riiki oma programmi mälu

334
00:18:02,000 --> 00:18:05,000
Praegu ta kukkus niimoodi.

335
00:18:05,000 --> 00:18:11,000
>> Fix on selles, et me ei saa lihtsalt pimesi naasta sigma,

336
00:18:11,000 --> 00:18:14,000
number + sigma on veidi väiksem probleem.

337
00:18:14,000 --> 00:18:16,000
Meil peab olema mingi alus juhul,

338
00:18:16,000 --> 00:18:19,000
ja mida peaks tugipunkti arvatavasti?

339
00:18:19,000 --> 00:18:22,000
[Kuuldamatu-õpilane]

340
00:18:22,000 --> 00:18:25,000
Okei, nii kaua, kui arv on positiivne peaksime tegelikult naasma seda,

341
00:18:25,000 --> 00:18:29,000
Või teisiti öeldes, kui number on, ütleme, <= 0

342
00:18:29,000 --> 00:18:32,000
tead mis, ma lähen edasi ja tagastab 0,

343
00:18:32,000 --> 00:18:36,000
palju nagu Willy tegi, ja teine, et ma lähen edasi minna

344
00:18:36,000 --> 00:18:41,000
ja tagastab selle, et see ei ole nii palju lühem

345
00:18:41,000 --> 00:18:44,000
kui iteratiivne versioon, et me Õhutas esimene kasutades jaoks silmus,

346
00:18:44,000 --> 00:18:48,000
aga märgata, et seal on selline elegants ta.

347
00:18:48,000 --> 00:18:51,000
Asemel, et tagastada mõned number ja täites kõik see matemaatika

348
00:18:51,000 --> 00:18:54,000
ja lisades asju kohalike muutujate

349
00:18:54,000 --> 00:18:57,000
sa selle asemel öelda "Okei, kui see on super lihtne probleem,

350
00:18:57,000 --> 00:19:01,000
nagu number on <0, andke mulle kohe tagasi 0 ".

351
00:19:01,000 --> 00:19:03,000
>> Me ei kavatse viitsinud toetamine negatiivsed arvud,

352
00:19:03,000 --> 00:19:05,000
nii et ma lähen kõvasti koodi väärtus 0.

353
00:19:05,000 --> 00:19:08,000
Aga muidu, selle idee elluviimiseks summeerides

354
00:19:08,000 --> 00:19:11,000
kõik need numbrid kokku saate tõhusalt võtta väike amps

355
00:19:11,000 --> 00:19:14,000
välja probleemi, palju nagu meie tegime laval,

356
00:19:14,000 --> 00:19:18,000
siis punt ülejäänud probleem järgmisele isikule,

357
00:19:18,000 --> 00:19:20,000
kuid sel juhul järgmine inimene on ise.

358
00:19:20,000 --> 00:19:22,000
See on identselt nimega funktsioon.

359
00:19:22,000 --> 00:19:25,000
Lihtsalt andke seda väiksemaks ja väiksemaks ja väiksemaks probleem iga kord,

360
00:19:25,000 --> 00:19:28,000
ja kuigi me ei ole päris vormistatakse asju kood siia

361
00:19:28,000 --> 00:19:33,000
see on täpselt, mis juhtus aastal nädal 0 ja telefoni raamat.

362
00:19:33,000 --> 00:19:36,000
See on täpselt, mis juhtus möödunud nädalal koos Sean

363
00:19:36,000 --> 00:19:39,000
ja meie meeleavaldusi otsides numbrid.

364
00:19:39,000 --> 00:19:42,000
See võtab probleem ja jagades seda uuesti ja uuesti.

365
00:19:42,000 --> 00:19:44,000
>> Teisisõnu, seal on juba praegu tõlkimise

366
00:19:44,000 --> 00:19:47,000
see reaalses maailmas ehitada, seda kõrgem konstrukti

367
00:19:47,000 --> 00:19:51,000
jaga ja valitse ja midagi ikka ja jälle

368
00:19:51,000 --> 00:19:56,000
kodeeritud, nii et see on midagi, mida me näeme jälle ajas.

369
00:19:56,000 --> 00:20:00,000
Nüüd, kui kõrvale, kui sa oled uus rekursioon siis peaks vähemalt aru nüüd

370
00:20:00,000 --> 00:20:02,000
miks see on naljakas.

371
00:20:02,000 --> 00:20:05,000
Ma lähen minema google.com,

372
00:20:05,000 --> 00:20:17,000
ja ma lähen otsima mõned näpunäiteid, rekursioon, siseneda.

373
00:20:17,000 --> 00:20:21,000
Ütle inimene sinu kõrval, kui nad ei naera just nüüd.

374
00:20:21,000 --> 00:20:23,000
Kas mõtlesite rekursioon?

375
00:20:23,000 --> 00:20:25,000
Kas mõtlesite-ah, seal läheme.

376
00:20:25,000 --> 00:20:28,000
Okei, nüüd, et ülejäänud kõigile.

377
00:20:28,000 --> 00:20:30,000
Vähe lihavõttemuna varjatud kusagil Google.

378
00:20:30,000 --> 00:20:33,000
Nagu kõrvale, üks lingid paneme rajal veebilehte

379
00:20:33,000 --> 00:20:36,000
täna on lihtsalt see ruudustik sorteerimise algoritme,

380
00:20:36,000 --> 00:20:39,000
millest mõned me vaatasime eelmisel nädalal, kuid mis on tore selle visualiseerimine

381
00:20:39,000 --> 00:20:43,000
nagu te üritate wrap meelt umbes erinevaid asju seotud algoritme

382
00:20:43,000 --> 00:20:46,000
tean, et saab väga lihtsalt nüüd alustada erinevaid sisendeid.

383
00:20:46,000 --> 00:20:50,000
Sisendite kõik vastupidiseks, sisendite enamasti järjestatud, sisendite juhuslik ja nii edasi.

384
00:20:50,000 --> 00:20:53,000
Nagu te üritate jällegi eristada neid asju meelt

385
00:20:53,000 --> 00:20:57,000
aru, et see link on muidugi koduleheküljel Loengud lehele

386
00:20:57,000 --> 00:21:00,000
võib aidata teil põhjust läbi mõned neist.

387
00:21:00,000 --> 00:21:05,000
>> Täna me lõpuks ometi seda probleemi lahendada alates aega tagasi,

388
00:21:05,000 --> 00:21:08,000
mis oli, et see swap funktsiooni lihtsalt ei tööta,

389
00:21:08,000 --> 00:21:12,000
ja milline oli põhiprobleem see funktsioon swap,

390
00:21:12,000 --> 00:21:15,000
mille eesmärgiks oli jällegi vahetada raha siin ja siin

391
00:21:15,000 --> 00:21:17,000
nii, et see juhtub?

392
00:21:17,000 --> 00:21:20,000
See tegelikult ei tööta. Miks?

393
00:21:20,000 --> 00:21:22,000
Jah.

394
00:21:22,000 --> 00:21:28,000
[Kuuldamatu-õpilane]

395
00:21:28,000 --> 00:21:31,000
Täpselt, seletus bugginess

396
00:21:31,000 --> 00:21:34,000
lihtsalt oli, sest kui sa kasutad funktsioone C

397
00:21:34,000 --> 00:21:38,000
ja need funktsioonid võtta argumendid, nagu a ja b siin,

398
00:21:38,000 --> 00:21:42,000
läbite koopiates iganes väärtus pakute sellele funktsioonile.

399
00:21:42,000 --> 00:21:46,000
Sa ei paku Algsete ise,

400
00:21:46,000 --> 00:21:49,000
nii et me nägime seda seoses buggyc,

401
00:21:49,000 --> 00:21:52,000
buggy3.c, mis tundus natuke midagi sellist.

402
00:21:52,000 --> 00:21:57,000
>> Tuletame meelde, et meil oli x ja y algväärtusega 1 ja 2 nimetatud isikud.

403
00:21:57,000 --> 00:21:59,000
Me siis prinditakse välja, mida nad olid.

404
00:21:59,000 --> 00:22:03,000
Siis väitis, et olin nende vahetamisest, kutsudes swap x, y.

405
00:22:03,000 --> 00:22:06,000
Aga probleem oli, et vahetada töötanud,

406
00:22:06,000 --> 00:22:10,000
kuid ainult reguleerimisalasse swap funktsiooni.

407
00:22:10,000 --> 00:22:13,000
Niipea kui me tabanud rida 40 need vahetasid väärtused

408
00:22:13,000 --> 00:22:16,000
visati ära ja nii midagi

409
00:22:16,000 --> 00:22:21,000
esialgse funktsiooni main tegelikult üldse muutunud,

410
00:22:21,000 --> 00:22:26,000
nii et kui te arvate tollal, mida see välja näeb nii meie mälu

411
00:22:26,000 --> 00:22:29,000
kui see vasakus servas juhatuse esindab-

412
00:22:29,000 --> 00:22:33,000
ja ma teen oma parima kõigile näha seda, kui vasakul küljel juhatuse

413
00:22:33,000 --> 00:22:37,000
esindab, ütleme, oma RAM ja korstna läheb kasvavad üles nii,

414
00:22:37,000 --> 00:22:43,000
ja me nimetame funktsiooni nagu põhiline ja peamine on 2 kohalikud muutujad x ja y,

415
00:22:43,000 --> 00:22:48,000
olgem kirjeldab neid kui x siin ja olgem kirjeldada kui y siin,

416
00:22:48,000 --> 00:22:55,000
ja paneme väärtuste 1 ja 2, nii et see siin on peamine,

417
00:22:55,000 --> 00:22:58,000
ja kui peamine nõuab swap funktsiooni operatsioonisüsteemi

418
00:22:58,000 --> 00:23:02,000
annab swap funktsiooni oma loog mälu korstnat

419
00:23:02,000 --> 00:23:04,000
oma raami korstnat, kui nii võib öelda.

420
00:23:04,000 --> 00:23:08,000
Samuti eraldab 32 bitti nende täisarvudega.

421
00:23:08,000 --> 00:23:11,000
See juhtub, et helistada neile ja b, kuid see on täiesti meelevaldne.

422
00:23:11,000 --> 00:23:13,000
Ta oleks võinud kutsus nad iganes ta soovib, kuid mis juhtub, kui peamine

423
00:23:13,000 --> 00:23:19,000
kutsub swap on ta võtab selle 1 seab koopia olemas, seab koopia olemas.

424
00:23:19,000 --> 00:23:23,000
>> Seal on 1 teiste kohalike muutuja swap, kuigi ehk mida? >> Tmp.

425
00:23:23,000 --> 00:23:27,000
Tmp, nii et las ma annan endale teise 32 bitti siin,

426
00:23:27,000 --> 00:23:29,000
ja mis ma teha seda funktsiooni?

427
00:23:29,000 --> 00:23:34,000
Ma ütlesin int tmp saab, nii on 1, nii et ma tegin seda, kui me viimati mängis selles näites.

428
00:23:34,000 --> 00:23:39,000
Siis saab b, seega b on 2, nii et nüüd see muutub 2

429
00:23:39,000 --> 00:23:42,000
ja nüüd b saab temp, nii temp on 1,

430
00:23:42,000 --> 00:23:44,000
nii nüüd b muutub see.

431
00:23:44,000 --> 00:23:46,000
See on tore. See toimis.

432
00:23:46,000 --> 00:23:49,000
Aga siis niipea, kui funktsioon tagastab

433
00:23:49,000 --> 00:23:52,000
swap mälu sisuliselt kaob, nii et seda saab taaskasutada

434
00:23:52,000 --> 00:23:58,000
mõne muu funktsiooni tulevikus, ja peamine on loomulikult täiesti muutumatuna.

435
00:23:58,000 --> 00:24:00,000
Vajame viis põhimõtteliselt selle probleemi lahendamiseks,

436
00:24:00,000 --> 00:24:03,000
ja täna me lõpuks ometi võimalus seda kusjuures

437
00:24:03,000 --> 00:24:06,000
saame tutvustada midagi, mida nimetatakse pointer.

438
00:24:06,000 --> 00:24:09,000
Tuleb välja, et me saame selle probleemi lahendada

439
00:24:09,000 --> 00:24:12,000
ei sooritades koopiates x ja y

440
00:24:12,000 --> 00:24:18,000
kuid selle asemel, läbides, mida, sa arvad, et swap funktsiooni?

441
00:24:18,000 --> 00:24:20,000
Jah, mis aadress?

442
00:24:20,000 --> 00:24:22,000
Me ei ole tegelikult rääkinud aadressid palju detaile,

443
00:24:22,000 --> 00:24:25,000
aga kui see tahvel kujutab minu arvuti mälu

444
00:24:25,000 --> 00:24:28,000
me võiks kindlasti alustada nummerdamist baiti minu RAM

445
00:24:28,000 --> 00:24:31,000
ja öelda, see on bait # 1, see on bait # 2, bait # 3,

446
00:24:31,000 --> 00:24:35,000
bait # 4, bait # ... 2000000000 kui mul on 2 GB RAM,

447
00:24:35,000 --> 00:24:38,000
nii et me võiks kindlasti tulla mõned suvalise numeratsiooniplaani

448
00:24:38,000 --> 00:24:41,000
kõikidele üksikutele baiti minu arvuti mällu.

449
00:24:41,000 --> 00:24:43,000
>> Mis siis, kui selle asemel, kui ma nimetan vahetusleping

450
00:24:43,000 --> 00:24:47,000
mitte passi koopiad x ja y

451
00:24:47,000 --> 00:24:51,000
miks ma ei asemel viiakse aadress x siin,

452
00:24:51,000 --> 00:24:55,000
aadress y siin sisuliselt postiaadress

453
00:24:55,000 --> 00:24:59,000
x ja y, sest siis vahetada, kui ta on teavitanud

454
00:24:59,000 --> 00:25:01,000
Euroopa aadress mälestuseks x ja y,

455
00:25:01,000 --> 00:25:04,000
siis vahetada, kui me teda koolitanud natuke,

456
00:25:04,000 --> 00:25:07,000
ta võiks juhtida sellele aadressile, nii et rääkida,

457
00:25:07,000 --> 00:25:11,000
x ja arvu muuta seal, siis sõita aadress y,

458
00:25:11,000 --> 00:25:16,000
Numbri muutmiseks seal, isegi kui tegelikult ei saada nende koopiaid väärtused ise,

459
00:25:16,000 --> 00:25:19,000
Nii et kuigi me rääkisime sellest nagu oleks peamine mällu

460
00:25:19,000 --> 00:25:23,000
ja seda kui swap mälu võimas ja ohtlik osa C

461
00:25:23,000 --> 00:25:28,000
on see, et mingit ülesannet võib puudutada mälu kusagil arvutis

462
00:25:28,000 --> 00:25:32,000
ja see on võimas, mida saate teha väga uhke asju Arvutiprogrammide C.

463
00:25:32,000 --> 00:25:36,000
See on ohtlik, sest nii võib ka kägardama väga lihtsalt.

464
00:25:36,000 --> 00:25:39,000
Tegelikult üks levinumaid viise programmide nendel päevadel ära kasutada

465
00:25:39,000 --> 00:25:42,000
ikka on programmeerija ei mõista

466
00:25:42,000 --> 00:25:45,000
et ta võimaldab andmete

467
00:25:45,000 --> 00:25:49,000
tuleb kirjutada asukohta mälus, mis ei olnud ette nähtud.

468
00:25:49,000 --> 00:25:51,000
>> Näiteks ta deklareerib massiivi suurus 10

469
00:25:51,000 --> 00:25:56,000
aga siis kogemata üritab panna 11 baiti sellesse hulga mälu

470
00:25:56,000 --> 00:25:59,000
ja hakkate liigutav osad mälu, mis enam ei kehti.

471
00:25:59,000 --> 00:26:02,000
Lihtsalt konteksti, on mõned võiksite teada, et

472
00:26:02,000 --> 00:26:06,000
tarkvara sageli küsib seerianumbrid või registreerimine võtmed,

473
00:26:06,000 --> 00:26:08,000
Photoshop ja Word ja programmid niimoodi.

474
00:26:08,000 --> 00:26:12,000
On olemas praod, nagu mõned teist teavad, online, kus saab joosta väike programm,

475
00:26:12,000 --> 00:26:14,000
ja voila, enam taotlust seerianumber.

476
00:26:14,000 --> 00:26:16,000
Kuidas see töötab?

477
00:26:16,000 --> 00:26:21,000
Paljudel juhtudel on need asjad lihtsalt järeldus arvutid

478
00:26:21,000 --> 00:26:24,000
teksti segmentide arvuti tegelik nulle ja ühtesid

479
00:26:24,000 --> 00:26:28,000
Kus on see funktsioon juhul, kui seerianumber on taotletud,

480
00:26:28,000 --> 00:26:31,000
ja te kirjutate, et ruumi või kui programm töötab

481
00:26:31,000 --> 00:26:33,000
saate aru saada, kus võti on tegelikult ladustatav

482
00:26:33,000 --> 00:26:37,000
kasutades midagi, mida nimetatakse siluri ja saate crack tarkvara nii.

483
00:26:37,000 --> 00:26:40,000
See ei tähenda, et see on meie eesmärk järgmise paari päeva jooksul,

484
00:26:40,000 --> 00:26:42,000
kuid see on väga reaalse tagajärgi.

485
00:26:42,000 --> 00:26:45,000
Et üks juhtub, et kaasata varguse tarkvara,

486
00:26:45,000 --> 00:26:47,000
kuid seal on ka kompromiss kogu masinad.

487
00:26:47,000 --> 00:26:50,000
>> Tegelikult, kui veebilehed nendel päevadel on ära

488
00:26:50,000 --> 00:26:53,000
ja ohustatud ning andmed on lekkinud ja paroolid varastatakse

489
00:26:53,000 --> 00:26:58,000
see väga sageli seotud halva juhtimise ühe mällu

490
00:26:58,000 --> 00:27:01,000
või, kui tegemist on andmebaasid, suutmatus ennetada

491
00:27:01,000 --> 00:27:03,000
võistleva sisend, nii rohkem, et lähinädalatel,

492
00:27:03,000 --> 00:27:07,000
kuid nüüd lihtsalt vargsi eelvaade omamoodi kahju, mida saate teha

493
00:27:07,000 --> 00:27:11,000
mitte päris mõista, kuidas asjad töötavad all kapuuts.

494
00:27:11,000 --> 00:27:14,000
Lähme umbes aru, miks see on katki

495
00:27:14,000 --> 00:27:17,000
tööriista, mis muutub üha kasulik

496
00:27:17,000 --> 00:27:19,000
nagu meie programmide saada keerulisem.

497
00:27:19,000 --> 00:27:21,000
Nii kaugele, kui olete olnud viga teie programm

498
00:27:21,000 --> 00:27:23,000
kuidas olete läinud umbes silumiseks?

499
00:27:23,000 --> 00:27:25,000
Mis on teie tehnikat olnud siiani, kas õpetanud oma TF

500
00:27:25,000 --> 00:27:27,000
või lihtsalt iseõppinud?

501
00:27:27,000 --> 00:27:29,000
[Student] printf.

502
00:27:29,000 --> 00:27:31,000
Printf, nii printf olnud ilmselt su sõber, et kui soovite näha

503
00:27:31,000 --> 00:27:33,000
mis toimub sees oma programmi

504
00:27:33,000 --> 00:27:36,000
sa lihtsalt panna printf siin printf siin printf siin.

505
00:27:36,000 --> 00:27:38,000
Siis sa jooksed ta, ja sa saad terve hunniku asju ekraanil

506
00:27:38,000 --> 00:27:43,000
, mida saab kasutada, et siis järeldan, mis tegelikult valesti oma programmi.

507
00:27:43,000 --> 00:27:45,000
>> Printf kipub olema väga võimas asi,

508
00:27:45,000 --> 00:27:47,000
aga see on väga käsitsi protsessi.

509
00:27:47,000 --> 00:27:49,000
Sul on panna printf siin printf siin,

510
00:27:49,000 --> 00:27:51,000
ja kui paned ta sees silmus võid saada 100 rida

511
00:27:51,000 --> 00:27:53,000
toodangut, siis pead sõeluma kaudu.

512
00:27:53,000 --> 00:27:58,000
See ei ole väga kasutajasõbralik või interaktiivne süsteem silumiseks programme,

513
00:27:58,000 --> 00:28:00,000
kuid õnneks on olemas alternatiive.

514
00:28:00,000 --> 00:28:03,000
Seal on programm, näiteks nimega gdb GNU siluri,

515
00:28:03,000 --> 00:28:06,000
mis on veidi kauge, kuidas sa seda kasutada.

516
00:28:06,000 --> 00:28:08,000
See on natuke keeruline, kuid ausalt öeldes

517
00:28:08,000 --> 00:28:11,000
see on üks nendest asjadest kus kui paned käesoleval ja järgmisel nädalal

518
00:28:11,000 --> 00:28:14,000
pildi tund mõista midagi GDB

519
00:28:14,000 --> 00:28:18,000
see säästab ilmselt kümneid tundi pikas perspektiivis,

520
00:28:18,000 --> 00:28:21,000
Nii et, las ma annan sulle teaser, kuidas see asi toimib.

521
00:28:21,000 --> 00:28:23,000
>> Ma olen oma terminali aknas.

522
00:28:23,000 --> 00:28:26,000
Lubage mul minna ja koostada selle programmi buggy3.

523
00:28:26,000 --> 00:28:28,000
See on juba kursis.

524
00:28:28,000 --> 00:28:31,000
Lubage mul kasutada seda nagu me tegime aega tagasi, ja tõepoolest, see on katki.

525
00:28:31,000 --> 00:28:34,000
Aga miks see nii on? Võib-olla ma silmamunad swap funktsiooni.

526
00:28:34,000 --> 00:28:37,000
Ehk on see a ja b. Ma pole päris liigutades neid ümber õigesti.

527
00:28:37,000 --> 00:28:39,000
Lubage mul minna ja seda teha.

528
00:28:39,000 --> 00:28:43,000
Selle asemel, et lihtsalt jooksma buggy3 andke mulle selle asemel käivitada programm GDB,

529
00:28:43,000 --> 00:28:48,000
ja ma räägin seda käivitada buggy3,

530
00:28:48,000 --> 00:28:52,000
ja ma lähen lisada käsurea argument,-tui,

531
00:28:52,000 --> 00:28:55,000
ja me paneme selle tulevikus probleeme spec meelde.

532
00:28:55,000 --> 00:28:57,000
Ja nüüd on see must ja valge liides hüppasid üles, et jälle

533
00:28:57,000 --> 00:28:59,000
on veidi valdav esimesel, sest seal on kõik see

534
00:28:59,000 --> 00:29:02,000
teave garantiitingimuste siia alla, aga vähemalt midagigi tuttav.

535
00:29:02,000 --> 00:29:04,000
Ülemises aknas on minu tegelik kood,

536
00:29:04,000 --> 00:29:08,000
ja kui ma liikuge üles siin las ma kerin et väga peale minu faili

537
00:29:08,000 --> 00:29:11,000
ja tõepoolest, seal on buggy3.c, ja teate allosas see aken

538
00:29:11,000 --> 00:29:13,000
Mul on see GDB kiire.

539
00:29:13,000 --> 00:29:16,000
>> See ei ole sama, mis minu tavaline John Harvard kiire.

540
00:29:16,000 --> 00:29:19,000
See on kiire, et läheb lubage mul juhtida GDB.

541
00:29:19,000 --> 00:29:21,000
GDB on silur.

542
00:29:21,000 --> 00:29:24,000
Silur on programm, mis võimaldab teil kõndida läbi

543
00:29:24,000 --> 00:29:27,000
täitmine oma programmi rida-realt,

544
00:29:27,000 --> 00:29:30,000
mööda teed tee midagi soovite programmi

545
00:29:30,000 --> 00:29:33,000
isegi helistaja funktsioone või vaatavad, mis veelgi tähtsam,

546
00:29:33,000 --> 00:29:35,000
erinevatel muutuja väärtusi.

547
00:29:35,000 --> 00:29:37,000
Lähme edasi ja tee seda.

548
00:29:37,000 --> 00:29:40,000
Ma lähen edasi minna ja sisestada töötamises GDB on kiire,

549
00:29:40,000 --> 00:29:43,000
nii märkate allosas vasakul ekraani Olen trükitud joosta,

550
00:29:43,000 --> 00:29:45,000
ja ma olen Enter, ja mida see veel teha?

551
00:29:45,000 --> 00:29:50,000
Ta sõna otseses mõttes jooksin oma programmi, kuid tegelikult ma ei vaata palju minna siin

552
00:29:50,000 --> 00:29:55,000
sest ma ei ole tegelikult rääkinud siluri

553
00:29:55,000 --> 00:29:57,000
peatamiseks mingil kindlal ajahetkel.

554
00:29:57,000 --> 00:29:59,000
Lihtsalt kirjutades run käivitab programmi.

555
00:29:59,000 --> 00:30:01,000
Ma tegelikult ei näe midagi. Ma ei saa manipuleerida seda.

556
00:30:01,000 --> 00:30:03,000
>> Selle asemel lubage mul seda teha.

557
00:30:03,000 --> 00:30:08,000
Sel GDB kiire andke mulle selle asemel kirjuta pausi, siseneda.

558
00:30:08,000 --> 00:30:10,000
See pole see, mida ma mõtlesin kirjutada.

559
00:30:10,000 --> 00:30:13,000
Olgem selle asemel kirjuta pausi peamine.

560
00:30:13,000 --> 00:30:15,000
Teisisõnu, ma tahan luua midagi, mida nimetatakse murdepunkti,

561
00:30:15,000 --> 00:30:18,000
mis on tabavalt nimetatud, sest see murdub või pausi

562
00:30:18,000 --> 00:30:21,000
täitmine oma programmi selle konkreetse koha.

563
00:30:21,000 --> 00:30:23,000
Peamised on nimi minu ülesanne.

564
00:30:23,000 --> 00:30:25,000
Pange tähele, et GDB on päris tark.

565
00:30:25,000 --> 00:30:28,000
See arvasin, et peamine juhtub alustada umbes real 18

566
00:30:28,000 --> 00:30:32,000
kohta buggy3.c ning märkate, siin üleval vasakul

567
00:30:32,000 --> 00:30:34,000
b + on õige kõrval realt 18.

568
00:30:34,000 --> 00:30:38,000
See on meenutas mulle, et ma olen pannud murdepunkti real 18.

569
00:30:38,000 --> 00:30:42,000
See aeg, kui ma tüüpi perspektiivis ma saan oma programmi

570
00:30:42,000 --> 00:30:45,000
kuni see tabab, et murdepunkt,

571
00:30:45,000 --> 00:30:48,000
et programm paus minu jaoks eelarverea 18.

572
00:30:48,000 --> 00:30:50,000
Hakkab pihta, jooksed.

573
00:30:50,000 --> 00:30:53,000
Midagi on ilmselt juhtunud, kuid teate all vasakul

574
00:30:53,000 --> 00:30:58,000
alustades programmi buggy3, murdepunkti 1 põhitähelepanu buggy3.c realt 18.

575
00:30:58,000 --> 00:31:00,000
Mida ma nüüd teen?

576
00:31:00,000 --> 00:31:03,000
>> Teade Ma ei hakka kirjutama asju nagu print,

577
00:31:03,000 --> 00:31:08,000
ei printf, print x, ja nüüd, et on kummaline.

578
00:31:08,000 --> 00:31:11,000
$ 1 on lihtsalt uudishimu, nagu me näha

579
00:31:11,000 --> 00:31:14,000
iga kord, kui prindite midagi saate uue $ väärtus.

580
00:31:14,000 --> 00:31:18,000
See on nii, et saate naasta eelmised väärtused igaks juhuks,

581
00:31:18,000 --> 00:31:21,000
kuid nüüd, mida prindi räägib mulle, et x väärtus selles punktis lugu

582
00:31:21,000 --> 00:31:26,000
Ilmselt on 134514032.

583
00:31:26,000 --> 00:31:29,000
Mida? Kust see isegi tulevad?

584
00:31:29,000 --> 00:31:31,000
[Kuuldamatu-õpilane]

585
00:31:31,000 --> 00:31:34,000
Tõepoolest, see on see, mida me nimetame prügi väärtus, ja me pole sellest rääkinud veel,

586
00:31:34,000 --> 00:31:37,000
kuid põhjus, et te initsialiseerida muutujad

587
00:31:37,000 --> 00:31:40,000
On selge, et neil oleks mingi väärtus, et sa tahad neid on.

588
00:31:40,000 --> 00:31:44,000
Aga saak on meelde tuletada, et saate tuvastada muutujad

589
00:31:44,000 --> 00:31:46,000
nagu ma tegin hetk tagasi minu sigma näiteks

590
00:31:46,000 --> 00:31:48,000
ilma tegelikult neile väärtust.

591
00:31:48,000 --> 00:31:50,000
Meenuta, mida ma tegin üle siin sigma.

592
00:31:50,000 --> 00:31:52,000
Ma kuulutatud n, kuid mis väärtus ma anda?

593
00:31:52,000 --> 00:31:56,000
Puudub, sest ma teadsin, et järgmise paari rida

594
00:31:56,000 --> 00:31:59,000
GetInt oleks hoolitseda probleem panna raha sees n.

595
00:31:59,000 --> 00:32:02,000
>> Aga siinkohal lugu line 11

596
00:32:02,000 --> 00:32:05,000
ja rida 12 ja rida 13 ja rida 14

597
00:32:05,000 --> 00:32:08,000
kogu nende mitu rida, mis on n väärtus?

598
00:32:08,000 --> 00:32:10,000
C sa lihtsalt ei tea.

599
00:32:10,000 --> 00:32:14,000
See on tavaliselt mõned prügi väärtus, mõned täiesti juhuslik arv

600
00:32:14,000 --> 00:32:17,000
mis on jäänud üle sisuliselt mõnest eelmise funktsiooni

601
00:32:17,000 --> 00:32:21,000
ning läbinud, et teie programm töötab

602
00:32:21,000 --> 00:32:24,000
meelde tuletada, et funktsiooni saab funktsioon, funktsioon, funktsioon.

603
00:32:24,000 --> 00:32:27,000
Kõik need raamid saavad panna mälu ja seejärel neid funktsioone Vastutasuks

604
00:32:27,000 --> 00:32:31,000
ja nagu Tegin koos kustutuskumm oma mälu lõpuks uuesti kasutada.

605
00:32:31,000 --> 00:32:37,000
Noh, see lihtsalt nii juhtub, et see muutuja x selles programmis

606
00:32:37,000 --> 00:32:41,000
tundub, et on esitatud mõned prügi väärtus nagu 134514032

607
00:32:41,000 --> 00:32:44,000
mõnest eelmise funktsiooni, mitte üks, mille ma kirjutasin.

608
00:32:44,000 --> 00:32:47,000
See võiks olla midagi, mis on tegelikult operatsioonisüsteemi,

609
00:32:47,000 --> 00:32:49,000
mõned funktsiooni all kapuuts.

610
00:32:49,000 --> 00:32:52,000
>> Okei, see on hea, kuid olgem nüüd edasi järgmisele reale.

611
00:32:52,000 --> 00:32:55,000
Kui ma tüüpi "Next" minu GDB kiire ja ma tabanud siseneda,

612
00:32:55,000 --> 00:32:58,000
märgata, et esile liigub allapoole rida 19,

613
00:32:58,000 --> 00:33:01,000
aga loogiline jätk on see, et eelarverea 18

614
00:33:01,000 --> 00:33:06,000
on nüüd lõppenud täidesaatva, nii et kui ma uuesti tippida "print x"

615
00:33:06,000 --> 00:33:10,000
Ma peaks nüüd näha 1 ja tõepoolest, ma teen.

616
00:33:10,000 --> 00:33:14,000
Jällegi $ värk on viis GDB teile meelde

617
00:33:14,000 --> 00:33:17,000
Mis ajaloos pildid on mis sa teinud oled.

618
00:33:17,000 --> 00:33:21,000
Nüüd lubage mul minna ja välja printida y, ja tõepoolest, y on mõned hull väärtus samuti,

619
00:33:21,000 --> 00:33:24,000
aga pole hullu, sest rida 19 me parasjagu määrata selle

620
00:33:24,000 --> 00:33:27,000
väärtus 2, seega lubage mul kirjutada "Next" uuesti.

621
00:33:27,000 --> 00:33:29,000
Ja nüüd oleme printf rida.

622
00:33:29,000 --> 00:33:31,000
Las ma teen print x.

623
00:33:31,000 --> 00:33:34,000
Las ma teen print y. Ausalt, ma saan natuke väsinud trükkimiseks.

624
00:33:34,000 --> 00:33:38,000
Lubage mul selle asemel kirjuta "ekraan x" ja "ekraani y"

625
00:33:38,000 --> 00:33:41,000
ja nüüd iga kord kui ma anna käsk tulevikus

626
00:33:41,000 --> 00:33:45,000
Ma meenutada, mis on x ja y, mis on x ja y, mis on x ja y.

627
00:33:45,000 --> 00:33:48,000
>> Võin ka, kui kõrvale, kirjuta "info kohalikega."

628
00:33:48,000 --> 00:33:50,000
Info on spetsiaalne käsk.

629
00:33:50,000 --> 00:33:52,000
Kohalikud tähendab see näitab mulle lokaalsed muutujad.

630
00:33:52,000 --> 00:33:55,000
Igaks juhuks ma unustan või see on hull, keeruline funktsioon

631
00:33:55,000 --> 00:33:57,000
et mina või keegi teine ​​kirjutas infot kohalikega ütlen teile

632
00:33:57,000 --> 00:34:00,000
millised on kõik kohalikud muutujad sees kohalik funktsioon

633
00:34:00,000 --> 00:34:03,000
et sa võiksid hooli, kui sa tahad tuhnima.

634
00:34:03,000 --> 00:34:07,000
Nüüd printf on umbes täita, seega lubage mul minna ja lihtsalt tüüp "kõrval."

635
00:34:07,000 --> 00:34:10,000
Sest me oleme selles keskkonnas me tegelikult ei näe seda

636
00:34:10,000 --> 00:34:14,000
täita siin all, kuid märgata Läheb veidi moonutatud siin.

637
00:34:14,000 --> 00:34:17,000
Aga märka seda kõige tähtsam ekraan seal

638
00:34:17,000 --> 00:34:21,000
nii see ei ole täiuslik programm siin, aga pole hullu, sest ma alati tuhnima

639
00:34:21,000 --> 00:34:23,000
kasutades prindi, kui ma tahan.

640
00:34:23,000 --> 00:34:26,000
>> Las ma kirjuta järgmine kord, ja nüüd siin on huvitav osa.

641
00:34:26,000 --> 00:34:29,000
Sel hetkel lugu y on 2 ja x on 1,

642
00:34:29,000 --> 00:34:32,000
nagu siin soovitati, ja jälle,

643
00:34:32,000 --> 00:34:35,000
Põhjus, miks see automaatselt väljapanek nüüd on, sest ma kasutasin käsk

644
00:34:35,000 --> 00:34:40,000
Näita X ja ekraani y, nii praegu ma tüüpi kõrval

645
00:34:40,000 --> 00:34:43,000
teoreetiliselt x ja y peaks saama vahetada.

646
00:34:43,000 --> 00:34:45,000
Nüüd me juba teame, et ei kavatse olla,

647
00:34:45,000 --> 00:34:49,000
kuid eks me näeme ühel hetkel kuidas sukelduda sügavamale aru saada, miks see on tõsi.

648
00:34:49,000 --> 00:34:54,000
Järgmine ja kahjuks y on veel 2 ja x on ikka 1, ning võin kinnitada, nii palju.

649
00:34:54,000 --> 00:34:56,000
Prindi x-, trüki y.

650
00:34:56,000 --> 00:34:59,000
Tõepoolest, ei ole Vahetatakse on tegelikult juhtus nii, alustame selle üle.

651
00:34:59,000 --> 00:35:01,000
Ilmselgelt swap on katki.

652
00:35:01,000 --> 00:35:04,000
Olgem selle asemel kirjuta "run" uuesti.

653
00:35:04,000 --> 00:35:07,000
Lubage mul öelda jah, ma tahan seda uuesti käivitada algusest peale, enter.

654
00:35:07,000 --> 00:35:09,000
>> Nüüd ma olen tagasi üles real 18.

655
00:35:09,000 --> 00:35:11,000
Nüüd pane tähele, x ja y on prügi väärtused uuesti.

656
00:35:11,000 --> 00:35:15,000
Järgmine, järgmine, järgmine, järgmine.

657
00:35:15,000 --> 00:35:17,000
Kui ma igavleda võin ka lihtsalt kirjutada n järgmisel.

658
00:35:17,000 --> 00:35:21,000
Võite lühendada seda võimalikult lühikese märgijada.

659
00:35:21,000 --> 00:35:23,000
Vaheta nüüd katki.

660
00:35:23,000 --> 00:35:25,000
Olgem sukelduda, nii kirjutamise asemel kõrval,

661
00:35:25,000 --> 00:35:30,000
nüüd ma lähen kirjuta samm nii et ma samm sees seda funktsiooni

662
00:35:30,000 --> 00:35:33,000
nii et võin kõndida läbi see, et ma tabanud sammu ja siis enter.

663
00:35:33,000 --> 00:35:37,000
Pange tähele, et esile hüppab alla madalam minu programmi rida 36.

664
00:35:37,000 --> 00:35:39,000
Nüüd siis millised on kohalikud muutujad?

665
00:35:39,000 --> 00:35:41,000
Info kohalikega.

666
00:35:41,000 --> 00:35:43,000
Miski lihtsalt veel, sest me pole saanud seda liini,

667
00:35:43,000 --> 00:35:47,000
nii lähme edasi ja öelda "Next".

668
00:35:47,000 --> 00:35:50,000
Nüüd tundub, et on tmp, trüki tmp.

669
00:35:50,000 --> 00:35:52,000
Prügi väärtust, eks? Ma arvan küll.

670
00:35:52,000 --> 00:35:55,000
Kuidas printida, printimine b, 1 ja 2?

671
00:35:55,000 --> 00:35:58,000
Selleks hetkeks, niipea kui ma tüüpi järgmisel jälle

672
00:35:58,000 --> 00:36:02,000
tmp läheb võtma väärtus 1, loodetavasti

673
00:36:02,000 --> 00:36:05,000
sest tmp saab olema määratud väärtus.

674
00:36:05,000 --> 00:36:08,000
>> Nüüd teeme printida, trüki b,

675
00:36:08,000 --> 00:36:11,000
kuid nüüd printida tmp, ja see on tõesti 1.

676
00:36:11,000 --> 00:36:14,000
Lubage mul teha järgmisena. Lubage mul teha järgmisena.

677
00:36:14,000 --> 00:36:16,000
Olen lõpetanud swap funktsiooni.

678
00:36:16,000 --> 00:36:19,000
Ma olen ikka sees on kooskõlas 40, nii et andke mulle printida,

679
00:36:19,000 --> 00:36:22,000
prindi b, ja ma ei hooli, mida tmp on.

680
00:36:22,000 --> 00:36:27,000
Tundub, swap on õige, kui tegemist on vahetada ja b.

681
00:36:27,000 --> 00:36:31,000
Aga kui ma nüüd kirjuta järgmine, ma hüppan tagasi real 25

682
00:36:31,000 --> 00:36:34,000
ja muidugi, kui ma kirjuta x ja prindi y

683
00:36:34,000 --> 00:36:38,000
nad on ikka muutumatuks, nii et me ei ole fikseeritud probleem.

684
00:36:38,000 --> 00:36:41,000
Aga diagnostiliselt nüüd võibolla see GDB programmi

685
00:36:41,000 --> 00:36:44,000
oleme vähemalt saanud üks samm lähemale mõistmisele

686
00:36:44,000 --> 00:36:47,000
mis toimub vale ilma pesakond meie koodi pannes printf siin,

687
00:36:47,000 --> 00:36:50,000
printf siin printf siin ja siis töötab ta ikka ja jälle

688
00:36:50,000 --> 00:36:52,000
püüab välja selgitada, millised on valesti.

689
00:36:52,000 --> 00:36:55,000
>> Ma lähen edasi minna ja loobuda sellest üldse koos lõpetan.

690
00:36:55,000 --> 00:36:57,000
See saab siis öelda: "väljuda?" Jah.

691
00:36:57,000 --> 00:37:00,000
Nüüd olen ma tagasi minu tavaline kiire, ja ma olen teinud kasutades GDB.

692
00:37:00,000 --> 00:37:03,000
Nagu kõrvale, sa ei pea kasutama seda-tui lipp.

693
00:37:03,000 --> 00:37:07,000
Tegelikult, kui jätate selle saad sisuliselt põhja pool ekraani.

694
00:37:07,000 --> 00:37:11,000
Kui ma tippige pausi peamine ja seejärel käivitage

695
00:37:11,000 --> 00:37:15,000
Ma ei saa ikka saan oma programmi, kuid mida ta teeb on rohkem tekstina

696
00:37:15,000 --> 00:37:18,000
lihtsalt näita mulle mingi rida ühe korraga.

697
00:37:18,000 --> 00:37:21,000
-Tui, tekstiline kasutajaliides,

698
00:37:21,000 --> 00:37:25,000
lihtsalt näitab teile, mitu programmi korraga, mis on ilmselt natuke kontseptuaalselt lihtsamaks.

699
00:37:25,000 --> 00:37:27,000
Aga tõesti, ma ei saa lihtsalt teha järgmisena kõrval kõrval,

700
00:37:27,000 --> 00:37:30,000
ja ma lähen vaata üks rida korraga, ja kui ma tõesti tahan näha, mis toimub

701
00:37:30,000 --> 00:37:35,000
Ma ei kirjuta nimekiri ja vaata, kogu kari naaber read.

702
00:37:35,000 --> 00:37:39,000
>> Seal on video, et me oleme palunud, et sa vaatad jaoks probleem Komplektid 3

703
00:37:39,000 --> 00:37:43,000
kus Nate hõlmab mõned Hienoudet GDB,

704
00:37:43,000 --> 00:37:46,000
ja see on üks nendest asjadest, ausalt, kus mõned mitte-triviaalne protsent te

705
00:37:46,000 --> 00:37:49,000
kunagi puudutage GDB, ja see on halb asi

706
00:37:49,000 --> 00:37:53,000
sest sõna otseses mõttes siis lõpuks kulutusi rohkem aega hiljem see semester

707
00:37:53,000 --> 00:37:56,000
death ette vigu siis oleks, kui paned, et poole tunni / tunni

708
00:37:56,000 --> 00:38:00,000
käesoleval ja järgmisel nädalal õppe saada rahul GDB.

709
00:38:00,000 --> 00:38:02,000
Printf oli sinu sõber.

710
00:38:02,000 --> 00:38:05,000
GDB peaks nüüd olema sinu sõber.

711
00:38:05,000 --> 00:38:08,000
>> Iga küsimustele GDB?

712
00:38:08,000 --> 00:38:12,000
Ja siin on kiire nimekirja mõned kõige võimsam ja kasulikke käske.

713
00:38:12,000 --> 00:38:15,000
Jah. >> Kas teil on vaja printida string?

714
00:38:15,000 --> 00:38:17,000
Kas teil on vaja printida string? Absoluutselt.

715
00:38:17,000 --> 00:38:19,000
See ei pea just olema täisarvud.

716
00:38:19,000 --> 00:38:22,000
Kui muutuja s on string lihtsalt kirjuta prindi s.

717
00:38:22,000 --> 00:38:24,000
See näitab teile, mida see string muutuja.

718
00:38:24,000 --> 00:38:26,000
[Kuuldamatu-õpilane]

719
00:38:26,000 --> 00:38:28,000
See annab teile aadress ja nöör ise.

720
00:38:28,000 --> 00:38:32,000
See näitab teile mõlemale.

721
00:38:32,000 --> 00:38:34,000
Ja viimane asi, lihtsalt sellepärast, et need on hea teada ka.

722
00:38:34,000 --> 00:38:37,000
Tagasijälitus ja raam, lubage mul sukelduda sellesse viimast korda,

723
00:38:37,000 --> 00:38:39,000
sama täpne programm koos GDB.

724
00:38:39,000 --> 00:38:44,000
Lubage mul minna ja joosta tekstiline kasutajaliides versioon,

725
00:38:44,000 --> 00:38:46,000
murda peamine.

726
00:38:46,000 --> 00:38:49,000
Lubage mul minna ja uuesti avada. Siin ma olen.

727
00:38:49,000 --> 00:38:55,000
Nüüd ma lähen järgmisel kõrval kõrval, kõrval kõrval, samm, siseneda.

728
00:38:55,000 --> 00:39:00,000
>> Ja nüüd arvan, et ma olen nüüd swap tahtlikult, aga ma olen nagu "Kurat, milline oli x väärtus?"

729
00:39:00,000 --> 00:39:02,000
Ma ei saa x enam.

730
00:39:02,000 --> 00:39:05,000
Ma ei saa y sest nad ei ole oma ulatuselt.

731
00:39:05,000 --> 00:39:07,000
Nad ei ole kontekstis, kuid mingit probleemi.

732
00:39:07,000 --> 00:39:09,000
Ma ei kirjuta tagasijälitust.

733
00:39:09,000 --> 00:39:13,000
See näitab mulle kõik funktsioonid, mis on teostatud kuni ajahetkel.

734
00:39:13,000 --> 00:39:16,000
Pange tähele, et üks all, peamine, ridade järele peamine

735
00:39:16,000 --> 00:39:18,000
on põhjas meie pilti siit.

736
00:39:18,000 --> 00:39:22,000
Asjaolu, et swap on eespool see ridade järele swap on eespool see mälu siin,

737
00:39:22,000 --> 00:39:26,000
ja kui ma tahan saada tagasi peamine ajutiselt võin öelda "raamiga."

738
00:39:26,000 --> 00:39:30,000
Mis number? Peamine on raam # 1.

739
00:39:30,000 --> 00:39:32,000
Ma lähen edasi minna ja öelda "korpus 1".

740
00:39:32,000 --> 00:39:36,000
>> Nüüd ma olen tagasi peamine, ja ma võin printida x, ja võin printida y,

741
00:39:36,000 --> 00:39:40,000
aga ma ei saa trükkida või b.

742
00:39:40,000 --> 00:39:43,000
Aga ma ei saa, kui ma ütlen: "Okei, oota natuke. Kuhu jäi swap?"

743
00:39:43,000 --> 00:39:46,000
Lubage mul minna ja öelda "kaadri 0".

744
00:39:46,000 --> 00:39:48,000
Nüüd ma olen tagasi, kus ma tahan olla, ja kui kõrvale,

745
00:39:48,000 --> 00:39:52,000
seal on teised käsud liiga, nagu kui sa oled tõesti Igavuse kirjutades kõrval kõrval, kõrval kõrval,

746
00:39:52,000 --> 00:39:56,000
saate tavaliselt öelda asju nagu "Järgmise 10," ja et astub läbi järgmise 10 rida.

747
00:39:56,000 --> 00:39:59,000
Võite ka kirjutada "Jätka", kui sa tõesti kõrini astudes läbi.

748
00:39:59,000 --> 00:40:05,000
Jätka kestab teie programm katkematult kuni see tabab teine ​​murdepunkti,

749
00:40:05,000 --> 00:40:07,000
kas tsüklina või madalamal oma programmi.

750
00:40:07,000 --> 00:40:11,000
>> Sel juhul jätkasime lõpuni, ja programm lahkus tavaliselt.

751
00:40:11,000 --> 00:40:13,000
See on fancy viis, halvem protsess.

752
00:40:13,000 --> 00:40:16,000
Lihtsalt oma programmi lahkus tavaliselt.

753
00:40:16,000 --> 00:40:24,000
Rohkem, et video ja silumine istungid tulla.

754
00:40:24,000 --> 00:40:26,000
See oli palju.

755
00:40:26,000 --> 00:40:35,000
Võtame meie 5-minutilise pausi siin, ja me tagasi koos structs ja faile.

756
00:40:35,000 --> 00:40:38,000
>> Kui olete sukeldunud nädala pset juba

757
00:40:38,000 --> 00:40:41,000
tead, et me kasutame jagamise kood,

758
00:40:41,000 --> 00:40:45,000
lähtekoodi, et pakume teile lähtepunkt, mõned uued tehnoloogiad.

759
00:40:45,000 --> 00:40:50,000
Eelkõige võtsime kasutusele uue märksõna nimetatakse struct, ehitise,

760
00:40:50,000 --> 00:40:53,000
nii et me saame luua kohandatud muutujate kehvasti.

761
00:40:53,000 --> 00:40:57,000
Meil on ka kasutusele mõiste Faili I / O, faili sisend ja väljund,

762
00:40:57,000 --> 00:41:00,000
ja see on nii, et saame säästa riik

763
00:41:00,000 --> 00:41:03,000
oma rüselus pardal fail kettal

764
00:41:03,000 --> 00:41:06,000
nii et õpetamise stipendiaatide, samuti saan aru

765
00:41:06,000 --> 00:41:09,000
mis toimub sees oma programmi ilma käsitsi mängida

766
00:41:09,000 --> 00:41:11,000
kümneid mängud rüselus.

767
00:41:11,000 --> 00:41:13,000
Me saame seda teha rohkem automatedly.

768
00:41:13,000 --> 00:41:18,000
>> See idee struct lahendab üsna kaalukaid probleem.

769
00:41:18,000 --> 00:41:21,000
Oletame, et me tahame rakendada mõne programmi

770
00:41:21,000 --> 00:41:25,000
et kuidagi peab arvet teavet õpilased,

771
00:41:25,000 --> 00:41:28,000
ja õpilased võivad olla näiteks ID nimi

772
00:41:28,000 --> 00:41:31,000
ja maja kohas nagu Harvard, mistõttu need 3 tükki teave

773
00:41:31,000 --> 00:41:34,000
me tahame hoida umbes, seega lubage mul minna ja hakake väike programm siin,

774
00:41:34,000 --> 00:41:38,000
sisaldavad stdio.h.

775
00:41:38,000 --> 00:41:42,000
Las ma teen sisaldavad cs50.h.

776
00:41:42,000 --> 00:41:44,000
Ja siis hakkan oma põhifunktsiooni.

777
00:41:44,000 --> 00:41:46,000
Ma ei viitsinud mingeid käsurea argumente,

778
00:41:46,000 --> 00:41:49,000
ja siin ma tahan olla üliõpilane, nii et ma lähen öelda

779
00:41:49,000 --> 00:41:54,000
Üliõpilasel on nimi, nii et ma ütlen "string nimi."

780
00:41:54,000 --> 00:41:59,000
Siis ma lähen ütlen üliõpilane on ka ID, nii int id,

781
00:41:59,000 --> 00:42:03,000
ja õpilane on maja, nii et ma ka ei ütle "string maja."

782
00:42:03,000 --> 00:42:06,000
Siis ma, et need veidi puhtamalt niimoodi.

783
00:42:06,000 --> 00:42:11,000
Okei, nüüd mul on 3 muutujaid, mis hakkab esindama õpilane, et "õpilane".

784
00:42:11,000 --> 00:42:15,000
>> Ja nüüd ma tahan, et asustada neid väärtusi, seega lubage mul minna ja öelda midagi sellist

785
00:42:15,000 --> 00:42:18,000
"Id = 123".

786
00:42:18,000 --> 00:42:21,000
Nimi ei hakka David.

787
00:42:21,000 --> 00:42:24,000
Oletame, et maja ei hakka Mather,

788
00:42:24,000 --> 00:42:31,000
ja siis ma teen midagi omavoliliselt nagu printf ("% s,

789
00:42:31,000 --> 00:42:37,000
kelle ID on% d, elab% s.

790
00:42:37,000 --> 00:42:41,000
Ja nüüd, mida ma tahan ühendada siin, üksteise järel?

791
00:42:41,000 --> 00:42:47,000
Nime, ID, maja; return 0.

792
00:42:47,000 --> 00:42:50,000
Okei, kui ma silmamunad kuskil siin

793
00:42:50,000 --> 00:42:54,000
Ma arvan, et meil on päris hea programm, mis salvestab üks õpilane.

794
00:42:54,000 --> 00:42:57,000
Muidugi, see ei ole nii huvitav. Mida teha, kui ma tahan 2 õpilast?

795
00:42:57,000 --> 00:42:59,000
See pole suur asi. Toetan 2 inimest.

796
00:42:59,000 --> 00:43:03,000
Lubage mul minna ja rõhutada seda ja minna siin,

797
00:43:03,000 --> 00:43:09,000
ja võin öelda, "id = 456" keegi nagu Rob, kes elab Kirkland.

798
00:43:09,000 --> 00:43:12,000
>> Okei, oota, kuid ma ei saa kutsume neid sama asi,

799
00:43:12,000 --> 00:43:15,000
ja tundub, et ma lähen on kopeerida see,

800
00:43:15,000 --> 00:43:19,000
seega lubage mul öelda, et need on Taaveti muutujad,

801
00:43:19,000 --> 00:43:23,000
ja las ma saaksin koopiaid nendest Rob.

802
00:43:23,000 --> 00:43:27,000
Me kutsume neid Rob kuid see ei hakka tööle nüüd

803
00:43:27,000 --> 00:43:33,000
sest ma olen-oot, olgem muuta mind id1, NAME1 ja house1.

804
00:43:33,000 --> 00:43:35,000
Rob on 2, 2.

805
00:43:35,000 --> 00:43:42,000
Ma pean seda muuta siin, siin, siin, siin, siin, siin.

806
00:43:42,000 --> 00:43:45,000
Oota, mis Tommy? Teeme seda uuesti.

807
00:43:45,000 --> 00:43:49,000
Loomulikult, kui sa ikka arvan, et see on hea viis seda teha, see ei ole,

808
00:43:49,000 --> 00:43:52,000
nii copy / paste halb.

809
00:43:52,000 --> 00:43:55,000
Aga me lahendasime selle paar päeva tagasi.

810
00:43:55,000 --> 00:43:59,000
>> Milline oli meie lahendus, kui me tahtnud Rohkete sama andmetüüp?

811
00:43:59,000 --> 00:44:01,000
[Õpilased] massiivi.

812
00:44:01,000 --> 00:44:03,000
Massiiv, nii et lubage mul proovida puhastada see üles.

813
00:44:03,000 --> 00:44:07,000
Lubage mul teha mõned ruumi ennast üleval, ja andke mulle selle asemel tee seda siin.

814
00:44:07,000 --> 00:44:12,000
Me kutsume neid inimesi, ja selle asemel ma lähen ütlen "int sümbolid,"

815
00:44:12,000 --> 00:44:14,000
ja ma lähen toetada 3 meist nüüd.

816
00:44:14,000 --> 00:44:18,000
Ma ütlen "string nimed," ja ma toetan 3 meist,

817
00:44:18,000 --> 00:44:22,000
ja siis ma lähen ütlen "string majad," ja ma toetan 3 meist.

818
00:44:22,000 --> 00:44:26,000
Nüüd siin Taaveti asemel saada oma kohalike muutujate

819
00:44:26,000 --> 00:44:28,000
saame lahti neist.

820
00:44:28,000 --> 00:44:30,000
See on hea tunne, et me puhastamine selle üles.

821
00:44:30,000 --> 00:44:35,000
Võin siis öelda David saab olema [0] ja nimed [0]

822
00:44:35,000 --> 00:44:38,000
ja majad [0].

823
00:44:38,000 --> 00:44:41,000
Ja röövida saame samamoodi salvestada see.

824
00:44:41,000 --> 00:44:46,000
Paneme selle siia alla, nii ta läheb omavoliliselt olema IDS [1].

825
00:44:46,000 --> 00:44:50,000
Ta saab olema nimed, [1]

826
00:44:50,000 --> 00:44:53,000
ja siis lõpuks, majad [1].

827
00:44:53,000 --> 00:44:57,000
>> Ikka natuke tüütu, ja nüüd on mul sellest sotti,

828
00:44:57,000 --> 00:45:03,000
nii ütleme "nimed [0], id [0], majad [0]

829
00:45:03,000 --> 00:45:06,000
ja olgem pluralize seda.

830
00:45:06,000 --> 00:45:09,000
IDS, ID, ID-d.

831
00:45:09,000 --> 00:45:12,000
Ja jälle, ma teen seda, nii et jälle, ma juba pöörduvad copy / paste uuesti,

832
00:45:12,000 --> 00:45:14,000
nii koefitsiendid on seal on teine ​​lahendus siin.

833
00:45:14,000 --> 00:45:18,000
Võin ilmselt puhastada see üles veelgi kliendiliinile või midagi sellist,

834
00:45:18,000 --> 00:45:21,000
nii lühike, see on veidi parem, kuid siiski tundub

835
00:45:21,000 --> 00:45:24,000
Ma pöörduvad copy / paste, kuid isegi see, Väidan,

836
00:45:24,000 --> 00:45:27,000
ei ole tõesti põhimõtteliselt õige lahendus, sest

837
00:45:27,000 --> 00:45:29,000
Mida teha, kui millalgi me otsustame tead mida?

838
00:45:29,000 --> 00:45:32,000
Me tõesti oleks pidanud ladustamiseks e-posti aadresse David ja Rob

839
00:45:32,000 --> 00:45:34,000
ja kõik teised selles programmis.

840
00:45:34,000 --> 00:45:36,000
Me peaksime ka salvestada telefoninumbreid.

841
00:45:36,000 --> 00:45:39,000
Me peaksime ka salvestada hädaabi numbreid.

842
00:45:39,000 --> 00:45:41,000
Meil on kõik need tükid andmed, et me tahame säilitada,

843
00:45:41,000 --> 00:45:43,000
Niisiis, kuidas sa minna seda teed?

844
00:45:43,000 --> 00:45:46,000
>> Sa deklareerida teise massiivi tipus, ja siis käsitsi lisada

845
00:45:46,000 --> 00:45:49,000
e-posti aadress [0], e-posti aadress [1]

846
00:45:49,000 --> 00:45:51,000
David ja Rob ja nii edasi.

847
00:45:51,000 --> 00:45:56,000
Aga seal on tõesti ainult eeldusega see disain

848
00:45:56,000 --> 00:45:59,000
et ma kasutan au süsteem teada, et

849
00:45:59,000 --> 00:46:03,000
[I] Iga mitu massiivid

850
00:46:03,000 --> 00:46:06,000
just nii juhtub viitavad samale isikule,

851
00:46:06,000 --> 00:46:10,000
nii [0] IDS on number 123,

852
00:46:10,000 --> 00:46:13,000
ja ma lähen eeldada, et nimed [0]

853
00:46:13,000 --> 00:46:16,000
on sama isiku nimi ja maja [0]

854
00:46:16,000 --> 00:46:21,000
on sama isiku maja ja nii edasi kõigi erinevate massiivide et ma loon.

855
00:46:21,000 --> 00:46:24,000
Aga teate, et seal on mingit põhimõttelist seost

856
00:46:24,000 --> 00:46:27,000
nende hulgas 3 tükki teavet, id, nimi ja maja,

857
00:46:27,000 --> 00:46:32,000
kuigi üksuse me üritame mudel selles programmis ei ole massiivid.

858
00:46:32,000 --> 00:46:35,000
Massiivid on lihtsalt sellises programmilises viis seda teha.

859
00:46:35,000 --> 00:46:38,000
Mida me tõesti tahame mudel meie programm on inimene

860
00:46:38,000 --> 00:46:41,000
nagu David, inimene nagu Rob mille sees

861
00:46:41,000 --> 00:46:46,000
või kapseldamist on nimi ja ID ja maja.

862
00:46:46,000 --> 00:46:49,000
>> Kas me kuidagi väljendada seda mõtet kapseldus

863
00:46:49,000 --> 00:46:52,000
millega isik on ID, nimi ja maja

864
00:46:52,000 --> 00:46:55,000
ja mitte kasutama tõesti seda häkkida, mille me lihtsalt

865
00:46:55,000 --> 00:46:58,000
usun, et sulg midagi

866
00:46:58,000 --> 00:47:02,000
viitab samale inimeste üksus kõik need erinevad massiivid?

867
00:47:02,000 --> 00:47:04,000
Me ei saa tegelikult seda teha.

868
00:47:04,000 --> 00:47:08,000
Laske mul minna üle peamised nüüd, ja las ma luua oma andmete tüüp

869
00:47:08,000 --> 00:47:10,000
jaoks tõesti esimest korda.

870
00:47:10,000 --> 00:47:14,000
Me kasutasime seda tehnikat rüselus,

871
00:47:14,000 --> 00:47:17,000
kuid siin ma lähen edasi minna ja luua andmete tüüp,

872
00:47:17,000 --> 00:47:19,000
ja tead mida, ma lähen kutsun seda õpilane või isik,

873
00:47:19,000 --> 00:47:23,000
ja ma lähen kasutada typedef jaoks määratleda tüüp.

874
00:47:23,000 --> 00:47:25,000
Ma ütlen, et see on struktuur,

875
00:47:25,000 --> 00:47:29,000
ja siis see struktuur saab olema tüüpi õpilane, me ütleme,

876
00:47:29,000 --> 00:47:31,000
kuigi see on veidi dateeritud nüüd minu jaoks.

877
00:47:31,000 --> 00:47:33,000
Me ütleme "int id."

878
00:47:33,000 --> 00:47:35,000
Me ütleme "string nimi."

879
00:47:35,000 --> 00:47:37,000
Siis me ütleme "string maja,"

880
00:47:37,000 --> 00:47:40,000
nii et nüüd lõpuks need paar rida koodi

881
00:47:40,000 --> 00:47:45,000
Olen just õpetanud rõkkama, et on olemas

882
00:47:45,000 --> 00:47:49,000
andmetüüp peale ints lisaks stringid, lisaks kahekordistab kõrval hõljub.

883
00:47:49,000 --> 00:47:54,000
>> Nagu käesoleva ajahetkel line 11 on nüüd uus andmetüüp kutsus üliõpilasi,

884
00:47:54,000 --> 00:47:58,000
ja nüüd ma ei deklareerima õpilane muutuja kuskil ma tahan,

885
00:47:58,000 --> 00:48:01,000
las ma keri siin inimesi.

886
00:48:01,000 --> 00:48:05,000
Nüüd ma saan lahti sellest ja ma ei saa minna tagasi alla David siin,

887
00:48:05,000 --> 00:48:10,000
ja Taavet ma ei saa tegelikult öelda, et David,

888
00:48:10,000 --> 00:48:13,000
saame sõna otseses mõttes nimetada muutuja pärast ise,

889
00:48:13,000 --> 00:48:16,000
saab olema tüüpi õpilane.

890
00:48:16,000 --> 00:48:18,000
See võib tunduda natuke imelik, kuid see pole veel kõik, et erinevad

891
00:48:18,000 --> 00:48:22,000
kuulutamast midagi nii int või string või sularahaga.

892
00:48:22,000 --> 00:48:24,000
See lihtsalt nii juhtub olema kutsutud õpilane nüüd,

893
00:48:24,000 --> 00:48:28,000
ja kui ma tahan panna midagi sees selle struktuuri

894
00:48:28,000 --> 00:48:31,000
Mul on nüüd kasutada uus tükk süntaks, kuid see on üsna lihtne,

895
00:48:31,000 --> 00:48:39,000
david.id = 123, david.name = "David" kapitali D

896
00:48:39,000 --> 00:48:42,000
ja david.house = "Ema,"

897
00:48:42,000 --> 00:48:46,000
ja nüüd ma saan lahti see värk siin.

898
00:48:46,000 --> 00:48:51,000
TEADE Me oleme nüüd ümber meie programm tõesti palju parem

899
00:48:51,000 --> 00:48:54,000
aastal, et nüüd meie programmi peegeldab reaalse maailma.

900
00:48:54,000 --> 00:48:57,000
>> Seal on reaalse maailma mõiste isik või õpilane.

901
00:48:57,000 --> 00:49:02,000
Siin on meil nüüd C versiooni isik või täpsemalt üliõpilane.

902
00:49:02,000 --> 00:49:05,000
Toas on selle isiku on need olulised tunnused,

903
00:49:05,000 --> 00:49:10,000
ID nimi ja maja, nii Rob sisuliselt muutub sama asi siin,

904
00:49:10,000 --> 00:49:14,000
nii õpilane Rob, ja nüüd rob.id = 456,

905
00:49:14,000 --> 00:49:17,000
rob.name = "Rob".

906
00:49:17,000 --> 00:49:20,000
Asjaolu, et muutuja nimega Rob on omamoodi mõtte.

907
00:49:20,000 --> 00:49:22,000
Me võinuks see x või y või z.

908
00:49:22,000 --> 00:49:25,000
Me lihtsalt nimeks Rob olema semantiliselt järjekindel,

909
00:49:25,000 --> 00:49:28,000
aga tõesti nimi on sees, et välja ennast,

910
00:49:28,000 --> 00:49:30,000
nii et nüüd mul on see.

911
00:49:30,000 --> 00:49:33,000
Ka see ei tundu parima disaini, et ma olen kõva kodeeritud David.

912
00:49:33,000 --> 00:49:35,000
Olen kõva kodeeritud Rob.

913
00:49:35,000 --> 00:49:39,000
Ja mul on veel kasutama mõned kopeeri ja kleebi iga kord ma tahan uusi muutujaid.

914
00:49:39,000 --> 00:49:43,000
Lisaks pean ilmselt andma kõik need muutujad nimi,

915
00:49:43,000 --> 00:49:46,000
kuigi ma parema meelega kirjeldada nende muutujate

916
00:49:46,000 --> 00:49:48,000
 rohkem üldnimetusega õpilased.

917
00:49:48,000 --> 00:49:52,000
>> Nüüd saame ühendada ideid, mis on töötanud hästi meie jaoks

918
00:49:52,000 --> 00:49:56,000
ja selle asemel öelda: "Tead mis, anna mulle muutuja nimega õpilased,

919
00:49:56,000 --> 00:50:01,000
ja ajame asja olema suurus 3, "nii et nüüd võin täpsustada seda edasi

920
00:50:01,000 --> 00:50:04,000
vabaneda käsitsi deklareeritud David,

921
00:50:04,000 --> 00:50:08,000
ja võin selle asemel öelda midagi sellist õpilast [0] siin.

922
00:50:08,000 --> 00:50:11,000
Võin siis öelda õpilastele [0] siin,

923
00:50:11,000 --> 00:50:14,000
üliõpilased [0] siin, ja nii edasi, ja ma ei saa minna ümber

924
00:50:14,000 --> 00:50:16,000
ja puhastage see üles Rob.

925
00:50:16,000 --> 00:50:19,000
Ma võiks ka minna nüüd äkki lisades loop

926
00:50:19,000 --> 00:50:23,000
ja kasutades getString ja GetInt tegelikult saada neid väärtusi kasutaja.

927
00:50:23,000 --> 00:50:27,000
Ma võiks minna umbes lisades pidev, sest see on üldiselt halb tava

928
00:50:27,000 --> 00:50:29,000
kõva kood suvalise arvu nagu 3 siinsamas

929
00:50:29,000 --> 00:50:33,000
ja siis lihtsalt meeles pidada, et sa peaksid tegema enam kui 3 õpilast ta.

930
00:50:33,000 --> 00:50:36,000
Ilmselt oleks parem kasutada # define ülaosas minu fail

931
00:50:36,000 --> 00:50:40,000
ja tegur, mis läbi, nii et tõepoolest, andke minna ja üldistada seda.

932
00:50:40,000 --> 00:50:43,000
>> Lubage mul avada näiteks see vahel tänapäeva

933
00:50:43,000 --> 00:50:46,000
näited ette, structs1.

934
00:50:46,000 --> 00:50:49,000
See on täiuslikum programm, mis kasutab # define siin

935
00:50:49,000 --> 00:50:51,000
ja ütleb, et me lähed on 3. klassi õpilased vaikimisi.

936
00:50:51,000 --> 00:50:54,000
Siin ma olen, mis kuulutab klassi väärt õpilaste,

937
00:50:54,000 --> 00:50:57,000
nii klassiruumis õpilaste ja nüüd ma kasutan silmus

938
00:50:57,000 --> 00:51:00,000
lihtsalt teha kood veidi rohkem elegantne, asustada klass

939
00:51:00,000 --> 00:51:05,000
koos kasutaja sisend, nii itereerima alates i = 0 kuni õpilased, mis on 3.

940
00:51:05,000 --> 00:51:07,000
Ja siis ma ajendab kasutaja selles versioonis

941
00:51:07,000 --> 00:51:10,000
 Mis on õpilase ID ja ma saan seda koos GetInt.

942
00:51:10,000 --> 00:51:13,000
Mis on õpilase nimi, ja siis ma saan seda koos getString.

943
00:51:13,000 --> 00:51:15,000
Mis üliõpilane maja? Ma saan seda getString.

944
00:51:15,000 --> 00:51:19,000
Ja siis allosas siin ma lihtsalt otsustasin muuta

945
00:51:19,000 --> 00:51:22,000
kuidas ma printida need välja ja tegelikult kasutada tsüklina

946
00:51:22,000 --> 00:51:24,000
Ja kes ma olen trükkimine?

947
00:51:24,000 --> 00:51:27,000
Vastavalt kommentaar Ma trükkimine keegi Mather,

948
00:51:27,000 --> 00:51:30,000
ja ongi nii Rob ja Tommy ja nii edasi-tegelikult Tommy on Mather.

949
00:51:30,000 --> 00:51:34,000
Tommy ja David oleks trükitud sel juhul, kuid kuidas see töötab?

950
00:51:34,000 --> 00:51:40,000
Me ei ole näinud seda funktsiooni enne, kuid võtta oletada, milline see teeb.

951
00:51:40,000 --> 00:51:42,000
Võrdleb stringid.

952
00:51:42,000 --> 00:51:45,000
>> See on veidi vähem selge, kuidas ta võrdleb stringe, sest tuleb välja,

953
00:51:45,000 --> 00:51:49,000
kui ta tagastab 0, mis tähendab, stringid on võrdsed.

954
00:51:49,000 --> 00:51:53,000
Kui ta naaseb -1, mis tähendab, üks tuleb tähestikuliselt enne teisi,

955
00:51:53,000 --> 00:51:57,000
ja kui ta naaseb 1, mis tähendab muu sõna pärineb tähestikuliselt

956
00:51:57,000 --> 00:52:00,000
enne teisi, ja saate vaadata online või mees lehekülg

957
00:52:00,000 --> 00:52:04,000
täpselt näha, mis suunas on mis, aga see kõik on nüüd teeme, on see ütlus

958
00:52:04,000 --> 00:52:09,000
kui [i]. Maja on võrdne "Ema"

959
00:52:09,000 --> 00:52:13,000
siis edasi minna ja välja printida nii ja nii on Mather.

960
00:52:13,000 --> 00:52:16,000
Aga siin on midagi, mida me ei ole varem näinud, ja me tuleme selle juurde tagasi.

961
00:52:16,000 --> 00:52:21,000
Ma ei mäleta kunagi seda teha kõik minu programmid.

962
00:52:21,000 --> 00:52:24,000
Tasuta on ilmselt viidates mälu, vabastades mälu,

963
00:52:24,000 --> 00:52:31,000
aga mis mälu ma ilmselt vabastades selle silmuse allosas selle programmiga?

964
00:52:31,000 --> 00:52:34,000
Tundub, et ma olen vabastades isiku nimi

965
00:52:34,000 --> 00:52:37,000
ja inimese maja, kuid miks see nii on?

966
00:52:37,000 --> 00:52:41,000
>> Tuleb välja, kõik need nädalat, et olete kasutanud getString

967
00:52:41,000 --> 00:52:45,000
oleme omamoodi on kasutusele bug arvesse iga ühe oma programmides.

968
00:52:45,000 --> 00:52:51,000
GetString mille konstruktsioon eraldab mälu, et ta saaks tagasi teie stringi,

969
00:52:51,000 --> 00:52:55,000
nagu David või Rob, ja saate seejärel teha mida iganes sa tahad

970
00:52:55,000 --> 00:52:59,000
selle stringi oma programmi, sest me oleme reserveeritud mälu teile.

971
00:52:59,000 --> 00:53:02,000
Probleem on kõik see aeg iga kord, kui helistada getString

972
00:53:02,000 --> 00:53:05,000
me, autorid getString, on küsinud operatsioonisüsteemi

973
00:53:05,000 --> 00:53:07,000
anda meile natuke RAM selle stringi.

974
00:53:07,000 --> 00:53:09,000
Anna meile natuke RAM selle kõrval string.

975
00:53:09,000 --> 00:53:11,000
Anna meile rohkem RAM selle kõrval string.

976
00:53:11,000 --> 00:53:13,000
Mida sa, programmeerija, pole kunagi teinud

977
00:53:13,000 --> 00:53:15,000
annab meile, et mälu tagasi,

978
00:53:15,000 --> 00:53:17,000
nii need mitu nädalat kõik programmid olete kirjutanud

979
00:53:17,000 --> 00:53:20,000
on olnud see, mida nimetatakse mälu hüpe, mille nad hoiavad kasutades

980
00:53:20,000 --> 00:53:24,000
rohkem ja rohkem mälu iga kord, kui helistada getString, ja see on hea.

981
00:53:24,000 --> 00:53:27,000
Me sihilikult teha, et esimestel nädalatel, sest see ei ole nii huvitav

982
00:53:27,000 --> 00:53:29,000
et ei pea muretsema, kui string on pärit.

983
00:53:29,000 --> 00:53:34,000
Kõik soovid on sõna Rob tagasi tulla, kui kasutaja tipib see sisse

984
00:53:34,000 --> 00:53:38,000
>> Aga liigub edasi me nüüd peame hakkama saada keerukamaid sellest.

985
00:53:38,000 --> 00:53:42,000
Iga kord, kui me mälu eraldada me parem lõpuks viige see tagasi.

986
00:53:42,000 --> 00:53:45,000
Vastasel reaalses maailmas Mac või PC võib teil olla vahetevahel kogenud

987
00:53:45,000 --> 00:53:50,000
sümptomeid, kus arvuti on seiskumist lõpuks

988
00:53:50,000 --> 00:53:54,000
või loll ketramine rannas palli lihtsalt istuvad arvuti

989
00:53:54,000 --> 00:53:56,000
kogu tähelepanu ja sa ei saa midagi teha.

990
00:53:56,000 --> 00:54:00,000
See võib seletada ükskõik arvu vigu, kuid nende seas võimalik vead

991
00:54:00,000 --> 00:54:03,000
on asju nimetatakse mälu lekked, mille keegi, kes kirjutas, et tükk tarkvara

992
00:54:03,000 --> 00:54:07,000
sa kasutad ei mäleta mälu vabastamiseks

993
00:54:07,000 --> 00:54:10,000
et ta palus operatsioonisüsteemi,

994
00:54:10,000 --> 00:54:14,000
ei kasuta getString, sest see on CS50 asi, kuid kasutades samalaadsete ülesannetega

995
00:54:14,000 --> 00:54:16,000
et küsida operatsioonisüsteemi mällu.

996
00:54:16,000 --> 00:54:19,000
Kui teie või nad kägardama ja tegelikult kunagi naasta, et mälu

997
00:54:19,000 --> 00:54:24,000
sümptom, mis võib olla, et programm aeglustub ja aeglustub ja aeglustub

998
00:54:24,000 --> 00:54:26,000
kui sa mäletad, et helistada tasuta.

999
00:54:26,000 --> 00:54:28,000
>> Me tuleme tagasi, millal ja miks sa kutsuksin tasuta,

1000
00:54:28,000 --> 00:54:32,000
aga lähme edasi lihtsalt hea meede ja proovige käivitada selle konkreetse programmi.

1001
00:54:32,000 --> 00:54:35,000
Seda kutsuti structs1, siseneda.

1002
00:54:35,000 --> 00:54:40,000
Lubage mul minna ja joosta structs1, 123, David Mather,

1003
00:54:40,000 --> 00:54:47,000
456, Rob Kirkland, 789,

1004
00:54:47,000 --> 00:54:50,000
Tommy Mather, ja me näeme Davidi aastal Ema, Tommy sisse Mather.

1005
00:54:50,000 --> 00:54:53,000
See on natuke meelerahu kontrolli, et programm töötab.

1006
00:54:53,000 --> 00:54:56,000
Nüüd kahjuks see programm on natuke masendav, et

1007
00:54:56,000 --> 00:55:00,000
Ma tegin kõik, et töö, ma kirjutada 9 erinevat stringid, Enter,

1008
00:55:00,000 --> 00:55:04,000
öeldi kes oli Ema, veel muidugi ma teadsin, kes oli Ema juba sellepärast ma kirjutada seda.

1009
00:55:04,000 --> 00:55:07,000
Oleks vähemalt tore, kui see programm on rohkem nagu andmebaas

1010
00:55:07,000 --> 00:55:10,000
ja see tegelikult mäletab, mida ma olen sisestatud

1011
00:55:10,000 --> 00:55:12,000
nii et ma enam kunagi sisend need üliõpilane arvestust.

1012
00:55:12,000 --> 00:55:15,000
Võib-olla see on nagu registrarial süsteem.

1013
00:55:15,000 --> 00:55:21,000
>> Me saame seda teha kasutades seda tehnikat tuntakse Faili I / O, faili sisend ja väljund,

1014
00:55:21,000 --> 00:55:24,000
väga üldine viis öelda igal ajal soovite lugeda faile või kirjutage failid

1015
00:55:24,000 --> 00:55:26,000
seda saab teha teatud hulk funktsioone.

1016
00:55:26,000 --> 00:55:29,000
Lubage mul minna ja avada see näiteks structs2.c,

1017
00:55:29,000 --> 00:55:33,000
mis on peaaegu sama, aga vaatame, mis see nüüd teeb.

1018
00:55:33,000 --> 00:55:36,000
Ülaosas faili Kinnitan klassi õpilased.

1019
00:55:36,000 --> 00:55:38,000
Ma siis asustada klassi kasutaja sisend,

1020
00:55:38,000 --> 00:55:41,000
nii need rida koodi on täpselt nagu enne.

1021
00:55:41,000 --> 00:55:45,000
Siis kui ma keri siin ma printida kõik, kes on Mather meelevaldselt nagu enne,

1022
00:55:45,000 --> 00:55:47,000
kuid see on huvitav uus funktsioon.

1023
00:55:47,000 --> 00:55:51,000
Need rida koodi on uus, ja nad tutvustada siin midagi,

1024
00:55:51,000 --> 00:55:55,000
FAIL, kõik mütsid, ja see on * on ka siin.

1025
00:55:55,000 --> 00:55:58,000
Lubage mul seda liigutada siia, * üle ka siin.

1026
00:55:58,000 --> 00:56:00,000
>> See funktsioon ei ole me näinud, fopen,

1027
00:56:00,000 --> 00:56:03,000
kuid see tähendab fail avatud, niiet Lukaista need,

1028
00:56:03,000 --> 00:56:05,000
ja see on midagi, me tuleme tagasi tulevikus psets,

1029
00:56:05,000 --> 00:56:10,000
kuid seda joont siin sisuliselt avab faili nimega andmebaas

1030
00:56:10,000 --> 00:56:13,000
ja see konkreetselt avab ta nii, et ta saab teha, mida see?

1031
00:56:13,000 --> 00:56:15,000
[Kuuldamatu-õpilane]

1032
00:56:15,000 --> 00:56:19,000
Õige, nii "w" tähendab lihtsalt seda räägib operatsioonisüsteemi

1033
00:56:19,000 --> 00:56:21,000
seda faili avada nii, et võin kirjutada.

1034
00:56:21,000 --> 00:56:23,000
Ma ei taha seda lugeda. Ma ei taha lihtsalt seda vaadata.

1035
00:56:23,000 --> 00:56:26,000
Ma tahan seda muuta ja lisada asju potentsiaalselt sellele

1036
00:56:26,000 --> 00:56:28,000
ja fail saab nimeks andmebaasi.

1037
00:56:28,000 --> 00:56:30,000
Seda võiks nimetada midagi.

1038
00:56:30,000 --> 00:56:32,000
See võiks olla database.txt. See võiks olla. Db.

1039
00:56:32,000 --> 00:56:37,000
See võiks olla sõna nagu suva, aga ma otsustanud meelevaldselt nimi faili andmebaasi.

1040
00:56:37,000 --> 00:56:42,000
See on natuke meelerahu kontrolli, et me tuleme tagasi väga üksikasjalikult aja jooksul,

1041
00:56:42,000 --> 00:56:47,000
Kui FP jaoks faili viitaja, ei võrdu NULL, mis tähendab, et kõik on hästi.

1042
00:56:47,000 --> 00:56:51,000
>> Pikk lugu lühike, funktsioone nagu fopen mõnikord ebaõnnestuda.

1043
00:56:51,000 --> 00:56:53,000
Ehk faili ei ole olemas. Võibolla sa oled välja kettaruumi.

1044
00:56:53,000 --> 00:56:55,000
Võibolla sa ei ole luba selle kausta,

1045
00:56:55,000 --> 00:56:58,000
nii et kui fopen tagastab null midagi halba juhtunud.

1046
00:56:58,000 --> 00:57:02,000
Vastupidisel juhul, kui fopen ei tagasta null kõik on hästi

1047
00:57:02,000 --> 00:57:04,000
ja ma ei hakake sellele failile.

1048
00:57:04,000 --> 00:57:06,000
Siin on uus trikk.

1049
00:57:06,000 --> 00:57:08,000
See on loop, mis on itereerimise üle iga minu õpilased,

1050
00:57:08,000 --> 00:57:10,000
ja see tundub nii sarnane sellega, mida me oleme teinud enne,

1051
00:57:10,000 --> 00:57:15,000
kuid see funktsioon on nõbu printf nimetatakse fprintf faili jaoks printf,

1052
00:57:15,000 --> 00:57:18,000
ja märkate, et see on erinev, ainult 2 võimalust.

1053
00:57:18,000 --> 00:57:20,000
Üks, see algab f asemel p,

1054
00:57:20,000 --> 00:57:23,000
kuid siis tema esimene argument on ilmselt mida?

1055
00:57:23,000 --> 00:57:25,000
[Õpilased] Fail. >> See fail.

1056
00:57:25,000 --> 00:57:30,000
See asi nimega fp, mis me lõpuks tease peale mida faili viitaja on,

1057
00:57:30,000 --> 00:57:35,000
kuid nüüd fp lihtsalt esindab faili, et ma olen avatud,

1058
00:57:35,000 --> 00:57:41,000
nii fprintf siin ütleb trükkida selle kasutaja ID toimikule, mitte ekraanil.

1059
00:57:41,000 --> 00:57:44,000
Trüki kasutaja nimi faili nime, ei kuvatud,

1060
00:57:44,000 --> 00:57:47,000
maja toimikule, mitte ekraani ja siis siia alla ilmselgelt

1061
00:57:47,000 --> 00:57:50,000
sulgege fail ja seejärel siia alla tasuta mälu.

1062
00:57:50,000 --> 00:57:53,000
>> Ainus erinevus selles versioonis 2 ja versioon 1

1063
00:57:53,000 --> 00:57:58,000
on kasutusele fopen ja selle faili *

1064
00:57:58,000 --> 00:58:01,000
ja see mõiste fprintf, nii vaatame, mis lõpptulemus on.

1065
00:58:01,000 --> 00:58:03,000
Lubage mul minna minu terminaliakent.

1066
00:58:03,000 --> 00:58:06,000
Ma jooksen structs2, siseneda.

1067
00:58:06,000 --> 00:58:09,000
Paistab, et kõik on hästi. Teeme uuesti, structs2.

1068
00:58:09,000 --> 00:58:15,000
123, David Ema, 456, Rob Kirkland,

1069
00:58:15,000 --> 00:58:19,000
789, Tommy Ema, siseneda.

1070
00:58:19,000 --> 00:58:23,000
Paistab, et see toimis sama, aga kui ma nüüd tegema LS

1071
00:58:23,000 --> 00:58:28,000
teate, mis fail on siin kõigi minu kood, andmebaas,

1072
00:58:28,000 --> 00:58:32,000
Niisiis on see, gedit andmebaasi, ja vaata seda.

1073
00:58:32,000 --> 00:58:34,000
See ei ole seksikaim failivorminguid.

1074
00:58:34,000 --> 00:58:38,000
See on tõesti üks tükk andmete rida rea ​​rea ​​peale,

1075
00:58:38,000 --> 00:58:42,000
aga neile, kes kasutavad Excel või CSV faili, komaga eraldatud väärtused,

1076
00:58:42,000 --> 00:58:47,000
Ma oleks kindlasti võinud kasutada fprintf selle asemel võibolla midagi sellist teha

1077
00:58:47,000 --> 00:58:50,000
nii et ma oleks tegelikult võinud luua samaväärne Exceli faili

1078
00:58:50,000 --> 00:58:53,000
eraldades asjad komadega, mitte ainult uusi liine.

1079
00:58:53,000 --> 00:58:56,000
>> Sel juhul, kui ma oleksin selle asemel kasutada komadega asemel uued liinid

1080
00:58:56,000 --> 00:59:01,000
Võiksin sõnalt avada andmebaasi faili Excelis, kui ma selle asemel tegi ta näeb välja selline.

1081
00:59:01,000 --> 00:59:03,000
Ühesõnaga, nüüd, et meil on õigus kirjutada faili

1082
00:59:03,000 --> 00:59:07,000
saame nüüd hakata püsivaid andmeid, hoides seda ringi ketas

1083
00:59:07,000 --> 00:59:10,000
nii et saame hoida teavet ümber ja jälle.

1084
00:59:10,000 --> 00:59:14,000
Teade paar muud asjad, mis on nüüd natuke rohkem tuttav.

1085
00:59:14,000 --> 00:59:16,000
Ülaosas seda C fail on meil typedef

1086
00:59:16,000 --> 00:59:21,000
sest me tahtsime luua andmetüüp, mis tähistab sõna,

1087
00:59:21,000 --> 00:59:25,000
nii et see tüüp on nn sõna, ja sees selle struktuuri

1088
00:59:25,000 --> 00:59:27,000
see on natuke Kasvataja nüüd.

1089
00:59:27,000 --> 00:59:30,000
Miks on sõna, mis koosneb ilmselt massiivi?

1090
00:59:30,000 --> 00:59:33,000
Mis on sõna lihtsalt intuitiivselt?

1091
00:59:33,000 --> 00:59:35,000
>> See on array tähemärki.

1092
00:59:35,000 --> 00:59:37,000
See on märgijada tagasi tagasi tagasi.

1093
00:59:37,000 --> 00:59:41,000
Tähed kõik mütsid juhtub olema me suvaliselt öelda maksimaalne pikkus

1094
00:59:41,000 --> 00:59:44,000
mis tahes sõna sõnastikku, mida me kasutame jaoks rüselus.

1095
00:59:44,000 --> 00:59:46,000
Miks ma pean +1?

1096
00:59:46,000 --> 00:59:48,000
Null iseloomu.

1097
00:59:48,000 --> 00:59:51,000
Meenuta, kui me tegime Bananagrams Näiteks meil oli vaja erilist väärtust

1098
00:59:51,000 --> 00:59:55,000
aasta lõpus sõna, et jälgida

1099
00:59:55,000 --> 00:59:59,000
kus sõnad tegelikult lõppes, ja kui probleem komplekt spetsifikatsioon ütleb

1100
00:59:59,000 --> 01:00:03,000
siin me ühendavate antud sõna tõeväärtuse,

1101
01:00:03,000 --> 01:00:05,000
lipp, nii-öelda õige või vale.

1102
01:00:05,000 --> 01:00:09,000
Kas olete leidnud seda sõna juba, sest me mõistame

1103
01:00:09,000 --> 01:00:13,000
meil on tõesti vaja nii mäletamise mitte ainult see, mida sõna on rüselus

1104
01:00:13,000 --> 01:00:15,000
aga kas sa ei, inimese, on leidnud

1105
01:00:15,000 --> 01:00:20,000
nii et kui sa ei leia sõna "" sa ei saa lihtsalt kirjutada, andmeid sisestada, sisestada, sisestage

1106
01:00:20,000 --> 01:00:23,000
ja saada 3 punkti, 3 punkti, 3 punkti, 3 punkti.

1107
01:00:23,000 --> 01:00:26,000
Me tahame olla võimelised Musta Nimekirja et sõna seades bool

1108
01:00:26,000 --> 01:00:29,000
true, kui olete juba leitud, ja nii see on, miks me

1109
01:00:29,000 --> 01:00:31,000
kapseldatud ta selle struktuuri.

1110
01:00:31,000 --> 01:00:35,000
>> Nüüd, siin all on rüselus seal on see teine ​​struct nimetatakse sõnaraamat.

1111
01:00:35,000 --> 01:00:39,000
Puudub siin on sõna typedef sest sel juhul

1112
01:00:39,000 --> 01:00:43,000
meil oli vaja kapseldada idee sõnastik

1113
01:00:43,000 --> 01:00:46,000
ja sõnastik sisaldab terve hunnik sõnu,

1114
01:00:46,000 --> 01:00:49,000
Nagu võib järeldada seda massiivi ja kui palju need sõnad on olemas?

1115
01:00:49,000 --> 01:00:51,000
Noh, mis iganes see muutuja nimega suurus ütleb.

1116
01:00:51,000 --> 01:00:53,000
Aga meil on vaja ainult üks sõnastik.

1117
01:00:53,000 --> 01:00:55,000
Meil ei ole vaja andmete tüüp kutsus sõnaraamat.

1118
01:00:55,000 --> 01:00:58,000
Meil on vaja ainult üks neist, nii selgub C

1119
01:00:58,000 --> 01:01:03,000
et kui sa ei ütle typedef, sa ütlesid struct, siis sees looksulg

1120
01:01:03,000 --> 01:01:05,000
paned oma muutujaid, siis paned nime.

1121
01:01:05,000 --> 01:01:09,000
Seda kuulutatakse üks muutuja nimega sõnaraamat

1122
01:01:09,000 --> 01:01:11,000
mis näeb välja selline.

1123
01:01:11,000 --> 01:01:16,000
Seevastu need read on luua korduvkasutatavaid andmestruktuur nimetatakse sõna

1124
01:01:16,000 --> 01:01:19,000
et saate luua mitu koopiat, nagu me loodud

1125
01:01:19,000 --> 01:01:22,000
mitu koopiat õpilased.

1126
01:01:22,000 --> 01:01:24,000
>> Mida see lõppkokkuvõttes võimaldab meil teha?

1127
01:01:24,000 --> 01:01:30,000
Lubage mul minna tagasi, ütleme, lihtsam näide lihtsam korda

1128
01:01:30,000 --> 01:01:34,000
ja andke mulle avada, oletame, compare1.c.

1129
01:01:34,000 --> 01:01:38,000
Probleem on siin käepärast on tegelikult koor tagasi

1130
01:01:38,000 --> 01:01:41,000
kiht nööri ja alustada õhkutõusmise need abirattad

1131
01:01:41,000 --> 01:01:44,000
sest selgub, et string kogu aeg

1132
01:01:44,000 --> 01:01:47,000
on meil lubanud 1. nädalal tõesti lihtsalt hüüdnimi,

1133
01:01:47,000 --> 01:01:51,000
sünonüüm alates CS50 raamatukogu midagi, mis näeb välja veidi segasena,

1134
01:01:51,000 --> 01:01:53,000
char *, ja me oleme näinud seda täht enne.

1135
01:01:53,000 --> 01:01:55,000
Me nägime seda seoses faile.

1136
01:01:55,000 --> 01:01:59,000
>> Lähme nüüd aru, miks oleme olnud peidus see detail juba mõnda aega.

1137
01:01:59,000 --> 01:02:02,000
Siin on fail nimega compare1.c,

1138
01:02:02,000 --> 01:02:07,000
ja see ilmselt küsib kasutajalt 2 stringid, s ja t,

1139
01:02:07,000 --> 01:02:11,000
ja siis ta püüab võrrelda neid stringe võrdõiguslikkuse rida 26,

1140
01:02:11,000 --> 01:02:14,000
ja kui nad võrdsed ta ütleb: "Sa kirjutasid sama asja,"

1141
01:02:14,000 --> 01:02:17,000
ja kui nad ei ole võrdsed ta ütleb: "Sa kirjutasid erinevaid asju."

1142
01:02:17,000 --> 01:02:19,000
Lubage mul minna ja käivitada programm.

1143
01:02:19,000 --> 01:02:23,000
Lubage mul minna minu allikas kataloog, teha compare1. See koostatud okei.

1144
01:02:23,000 --> 01:02:25,000
Ma jooksen compare1.

1145
01:02:25,000 --> 01:02:27,000
Ma suumimiseks siseneda.

1146
01:02:27,000 --> 01:02:29,000
Ütle midagi. Tere.

1147
01:02:29,000 --> 01:02:32,000
Ma ütlen midagi uuesti. Tere.

1148
01:02:32,000 --> 01:02:34,000
Ma kindlasti ei kirjuta erinevaid asju.

1149
01:02:34,000 --> 01:02:37,000
>> Las ma proovin seda uuesti. Bye Bye.

1150
01:02:37,000 --> 01:02:40,000
Kindlasti ei erine, nii et mida siin toimub?

1151
01:02:40,000 --> 01:02:44,000
Noh, mis tegelikult on võrreldes vastavalt 26?

1152
01:02:44,000 --> 01:02:46,000
[Kuuldamatu-õpilane]

1153
01:02:46,000 --> 01:02:49,000
Jah, nii selgub, et string, andmete tüüp, on selline hädavale.

1154
01:02:49,000 --> 01:02:53,000
String on char *, kuid mida on char *?

1155
01:02:53,000 --> 01:02:56,000
Char *, nagu nad ütlevad, on pointer,

1156
01:02:56,000 --> 01:03:00,000
ja osuti on tõhusalt aadress,

1157
01:03:00,000 --> 01:03:05,000
summa asukohta mälus, ja kui juhtub, et on sisestatud sõna nagu HELLO,

1158
01:03:05,000 --> 01:03:08,000
meenutada mineviku arutelusid stringid

1159
01:03:08,000 --> 01:03:16,000
see on nagu sõna HELLO.

1160
01:03:16,000 --> 01:03:19,000
Pea meeles, et sõna nagu HELLO saab esindajad

1161
01:03:19,000 --> 01:03:22,000
massiivina tegelasi nagu see

1162
01:03:22,000 --> 01:03:25,000
ja siis spetsiaalse märgi lõpus kutsus null iseloomu,

1163
01:03:25,000 --> 01:03:27,000
nagu \ tähistab.

1164
01:03:27,000 --> 01:03:29,000
Mis on tegelikult string?

1165
01:03:29,000 --> 01:03:32,000
Pange tähele, et see on mitu mäluhulka,

1166
01:03:32,000 --> 01:03:36,000
ja tegelikult lõpuks on teada ainult üks kord vaatate läbi terve rea

1167
01:03:36,000 --> 01:03:38,000
otsin eriline null iseloomu.

1168
01:03:38,000 --> 01:03:41,000
Aga kui see on patakas mälu minu arvuti mälu,

1169
01:03:41,000 --> 01:03:44,000
olgem suvaliselt öelda, et see jada lihtsalt vedas,

1170
01:03:44,000 --> 01:03:47,000
ja ta sai paigutatud alguses minu arvuti RAM.

1171
01:03:47,000 --> 01:03:54,000
See on bait 0, 1, 2, 3, 4, 5, 6 ...

1172
01:03:54,000 --> 01:04:02,000
>> Kui ma ütlen midagi getString ja ma teen string s = getString

1173
01:04:02,000 --> 01:04:04,000
Mis tegelikult tagastatakse?

1174
01:04:04,000 --> 01:04:08,000
Need viimased mitu nädalat, mis tegelikult salvestatakse s

1175
01:04:08,000 --> 01:04:13,000
ei ole see string iseenesest, kuid sel juhul mis siin hoitakse on

1176
01:04:13,000 --> 01:04:18,000
arvu 0, sest mida getString tegelikult teeb

1177
01:04:18,000 --> 01:04:20,000
on see ei füüsiliselt tagasi string.

1178
01:04:20,000 --> 01:04:22,000
See isegi ei tõesti kontseptuaalses mõttes.

1179
01:04:22,000 --> 01:04:24,000
Mis see tulu on number.

1180
01:04:24,000 --> 01:04:28,000
See arv on aadress HELLO mälu,

1181
01:04:28,000 --> 01:04:32,000
ja string s siis, kui me koor tagasi see kiht, nöör ei ole tegelikult olemas.

1182
01:04:32,000 --> 01:04:35,000
See on ainult lihtsustamise CS50 raamatukogu.

1183
01:04:35,000 --> 01:04:38,000
>> See on tõesti midagi, mida nimetatakse char *.

1184
01:04:38,000 --> 01:04:41,000
Char on mõistlik, sest mis see sõna, nagu Halloo?

1185
01:04:41,000 --> 01:04:44,000
Noh, see on mitmeid sümboleid seeria tähemärki.

1186
01:04:44,000 --> 01:04:47,000
Char * tähendab, aadress iseloomu,

1187
01:04:47,000 --> 01:04:50,000
nii et mida see tähendab tagasi string?

1188
01:04:50,000 --> 01:04:53,000
Kena, lihtne viis tagastamise string

1189
01:04:53,000 --> 01:04:57,000
on mitte proovida aru saada, kuidas ma tagasi 5 või 6 erinevat baiti

1190
01:04:57,000 --> 01:05:01,000
lase mind tagasi mille aadressi bait?

1191
01:05:01,000 --> 01:05:03,000
Esimene.

1192
01:05:03,000 --> 01:05:06,000
Teisisõnu, lubage mul anda teile aadress märk mälu.

1193
01:05:06,000 --> 01:05:10,000
Seda char * tähistab, aadress ühe märgi mälu.

1194
01:05:10,000 --> 01:05:12,000
Helista et muutuja s.

1195
01:05:12,000 --> 01:05:15,000
Hoida s, et eelkõige aadress, mis ma omavoliliselt ütles on 0,

1196
01:05:15,000 --> 01:05:19,000
lihtsalt hoida asjad lihtsad, kuid tegelikkuses on see tavaliselt suurem number.

1197
01:05:19,000 --> 01:05:21,000
>> Oota üks hetk.

1198
01:05:21,000 --> 01:05:23,000
Kui sa vaid annad mulle aadressi esimene märk, kuidas ma tean, milline aadress on

1199
01:05:23,000 --> 01:05:25,000
teise iseloomu, kolmanda, neljanda ja viienda?

1200
01:05:25,000 --> 01:05:27,000
[Kuuldamatu-õpilane]

1201
01:05:27,000 --> 01:05:31,000
Sa ainult ei tea kus stringi lõpuni on teel seda mugav trikk,

1202
01:05:31,000 --> 01:05:35,000
Nii et kui te kasutate midagi printf, mida printf sõna otseses mõttes nagu tema argumendi,

1203
01:05:35,000 --> 01:05:39,000
meelde tuletada, et me kasutame seda% s kohatäide, ja siis viiakse

1204
01:05:39,000 --> 01:05:41,000
muutuja, mis on ladustamiseks string.

1205
01:05:41,000 --> 01:05:47,000
Mida sa tegelikult kulgeb on aadress esimene märk, et string.

1206
01:05:47,000 --> 01:05:50,000
Printf siis kasutab jaoks silmus või samas silmus saamisel, et aadress,

1207
01:05:50,000 --> 01:05:53,000
Näiteks, 0, seega lubage mul seda teha nüüd,

1208
01:05:53,000 --> 01:06:02,000
printf ("% s \ n", s);

1209
01:06:02,000 --> 01:06:07,000
Kui ma kutsun printf ("% s \ n", s); mida ma tõesti pakkuda printf koos

1210
01:06:07,000 --> 01:06:13,000
on aadress esimene märk on, mis selles meelevaldne juhul on H.

1211
01:06:13,000 --> 01:06:16,000
>> Kuidas printf tea, mida täpselt näidata ekraanil?

1212
01:06:16,000 --> 01:06:19,000
Isik, kes ellu printf rakendada samas loop või loop

1213
01:06:19,000 --> 01:06:23,000
mis ütleb, et ei see märk võrdne erilist null iseloomu?

1214
01:06:23,000 --> 01:06:25,000
Kui ei, siis printida. Kuidas oleks sellega?

1215
01:06:25,000 --> 01:06:28,000
Kui ei prindi see, printida, printida, printida.

1216
01:06:28,000 --> 01:06:32,000
Oh, see üks on eriline. Peatage printimine ja naasta kasutaja.

1217
01:06:32,000 --> 01:06:35,000
Ja see on sõna otseses mõttes kõik, mis on juhtunud all kapuuts,

1218
01:06:35,000 --> 01:06:38,000
ja see on palju seedida aastal esimesel päeval klassi,

1219
01:06:38,000 --> 01:06:43,000
kuid nüüd on tõesti ehituskivi mõista kõike

1220
01:06:43,000 --> 01:06:46,000
mis on kestnud juba sees meie arvuti mälu,

1221
01:06:46,000 --> 01:06:49,000
ja lõpuks me tease see peale on vähe abi

1222
01:06:49,000 --> 01:06:51,000
üks meie sõbrad Stanfordi.

1223
01:06:51,000 --> 01:06:56,000
>> Professor Nick Parlante Stanfordi teinud selle imelise video jada

1224
01:06:56,000 --> 01:06:58,000
alates igasuguseid erinevaid keeli, mis tutvustas

1225
01:06:58,000 --> 01:07:00,000
see väike claymation iseloomu Binky.

1226
01:07:00,000 --> 01:07:03,000
Hääl sa parasjagu kuulda vaid paar 2. vargsi eelvaade

1227
01:07:03,000 --> 01:07:05,000
on see, et Stanfordi professor, ja te saate

1228
01:07:05,000 --> 01:07:07,000
ainult 5 või 6 sekundit selle kohe,

1229
01:07:07,000 --> 01:07:09,000
kuid see on märkus, mis me sõlmida täna

1230
01:07:09,000 --> 01:07:11,000
ja algab kolmapäeval.

1231
01:07:11,000 --> 01:07:15,000
Ma annan sulle Pointer Fun Binky, eelvaate.

1232
01:07:15,000 --> 01:07:18,000
[♪ Music ♪] [professor Parlante] Hei, Binky.

1233
01:07:18,000 --> 01:07:21,000
Ärka üles. On aeg osuti lõbus.

1234
01:07:21,000 --> 01:07:24,000
[Binky] Mis see on? Lugege vihjeid?

1235
01:07:24,000 --> 01:07:26,000
Oi kui tore!

1236
01:07:26,000 --> 01:07:29,000
>> Me näeme teid kolmapäeval.

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]