1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Hét 4]

2
00:00:03,000 --> 00:00:05,000
[David J. Malan] [Harvard Egyetem]

3
00:00:05,000 --> 00:00:08,000
[Ez a CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> Rendben, itt CS50, és ez a kezdete 4. héten,

5
00:00:12,000 --> 00:00:16,000
és ez az egyik a leglassabb lehetséges rendező algoritmus.

6
00:00:16,000 --> 00:00:19,000
Melyik volt az, hogy mi csak néztem oda?

7
00:00:19,000 --> 00:00:24,000
Ez volt buborék rendezés érdekében nagy O (n ^ 2) + összeget,

8
00:00:24,000 --> 00:00:28,000
és valóban nem mi vagyunk az egyetlenek, akik ebben a világban, hogy úgy tűnik, hogy tudni

9
00:00:28,000 --> 00:00:30,000
mi buborék rendezés, illetve a működési idő.

10
00:00:30,000 --> 00:00:33,000
Valóban, ez egy interjú Eric Schmidt a Google

11
00:00:33,000 --> 00:00:45,000
és a korábbi szenátor Barack Obama néhány évvel ezelőtt.

12
00:00:45,000 --> 00:00:48,000
>> Nos, szenátor, te itt a Google-nál,

13
00:00:48,000 --> 00:00:54,000
és azt szeretném tudni, hogy az elnökség, mint egy állásinterjú.

14
00:00:54,000 --> 00:00:58,000
Nos, nehéz munkát találni, mint elnök, és megy keresztül a borzongás most.

15
00:00:58,000 --> 00:01:00,000
Ez is nehéz munkát találni a Google-nál.

16
00:01:00,000 --> 00:01:05,000
Van kérdése, és kéri, hogy jelöltek kérdéseket,

17
00:01:05,000 --> 00:01:10,000
és ez az egyik a Larry Schwimmer.

18
00:01:10,000 --> 00:01:14,000
Azt hiszitek, viccelek? Ez itt van.

19
00:01:14,000 --> 00:01:18,000
Mi a leghatékonyabb módja annak, hogy rendezni egy millió 32-bites egész?

20
00:01:18,000 --> 00:01:21,000
[Nevetés]

21
00:01:21,000 --> 00:01:24,000
Well-

22
00:01:24,000 --> 00:01:26,000
Sajnálom. >> Nem, nem, nem, nem.

23
00:01:26,000 --> 00:01:34,000
Azt hiszem, a buborék rendezés lenne a rossz út.

24
00:01:34,000 --> 00:01:39,000
>> Gyerünk, ki mondta ezt neki?

25
00:01:39,000 --> 00:01:43,000
Múlt héten emlékeztetni vettünk egy kis szünetet a kódot, legalább egy nap,

26
00:01:43,000 --> 00:01:46,000
és elkezdtem összpontosítva valamilyen magasabb szinten ötletek és problémamegoldás általában

27
00:01:46,000 --> 00:01:49,000
keretében a keresés és válogatás,

28
00:01:49,000 --> 00:01:53,000
és azt be valamit, amit mi nem pofon ez a név a múlt héten,

29
00:01:53,000 --> 00:01:56,000
de aszimptotikus jelölések, a Big O, a Big Omega,

30
00:01:56,000 --> 00:02:00,000
és néha a nagy Theta jelölés, és ezek csupán módokon

31
00:02:00,000 --> 00:02:02,000
hogy leírja a futási ideje algoritmusok,

32
00:02:02,000 --> 00:02:05,000
mennyi időt vesz igénybe egy algoritmus futtatásához.

33
00:02:05,000 --> 00:02:08,000
>> És akkor emlékszem, hogy beszélt a futási idő szempontjából a méret

34
00:02:08,000 --> 00:02:11,000
a bemeneti, amit általában véve n, függetlenül a probléma lehet,

35
00:02:11,000 --> 00:02:13,000
ahol n az emberek száma a szobában,

36
00:02:13,000 --> 00:02:17,000
az oldalak számát a telefonkönyvben, és elkezdtük írni a dolgokat

37
00:02:17,000 --> 00:02:21,000
mint O (n ^ 2) vagy O (n) vagy O (n log n),

38
00:02:21,000 --> 00:02:24,000
és még ha a matek nem igazán dolgoznak ki, így tökéletesen

39
00:02:24,000 --> 00:02:28,000
és ez n ² - n / 2, vagy valami ilyesmi

40
00:02:28,000 --> 00:02:31,000
mi lenne inkább csak dobja néhány alacsonyabb rendű feltételeket,

41
00:02:31,000 --> 00:02:34,000
és a motiváció is van, hogy valóban szeretnénk

42
00:02:34,000 --> 00:02:37,000
fajta objektív módon értékelésére

43
00:02:37,000 --> 00:02:39,000
teljesítménye programok vagy teljesítményének algoritmusok

44
00:02:39,000 --> 00:02:42,000
, hogy a végén a nap semmi köze, például,

45
00:02:42,000 --> 00:02:45,000
A sebesség a számítógép ma.

46
00:02:45,000 --> 00:02:47,000
>> Például, ha a végre buborék rendezés,

47
00:02:47,000 --> 00:02:50,000
vagy végre egyesítése rendezés vagy kiválasztás sort a mai számítógép,

48
00:02:50,000 --> 00:02:53,000
A 2 GHz-es számítógépet, és futtatja azt,

49
00:02:53,000 --> 00:02:56,000
és némi másodpercek száma, a következő évben van egy 3 GHz

50
00:02:56,000 --> 00:02:59,000
vagy a 4 GHz-es számítógépet, és lehet, hogy majd azt állítják, hogy "Wow, én algoritmus

51
00:02:59,000 --> 00:03:03,000
most kétszer olyan gyors, "amikor a valóságban ez nyilvánvalóan nem ez a helyzet.

52
00:03:03,000 --> 00:03:06,000
Ez csak a hardver ütött gyorsabb, de a számítógép

53
00:03:06,000 --> 00:03:10,000
nem, és ezért szeretné, hogy dobja el a dolgokat, mint a

54
00:03:10,000 --> 00:03:13,000
többszörösei 2 vagy többszöröse 3, amikor a leíró

55
00:03:13,000 --> 00:03:17,000
, hogy milyen gyorsan vagy milyen lassú az algoritmus, és tényleg csak összpontosítani

56
00:03:17,000 --> 00:03:20,000
n vagy néhány tényező annak

57
00:03:20,000 --> 00:03:24,000
Egyes annak erejét, mint abban az esetben, a fajta a múlt héten.

58
00:03:24,000 --> 00:03:27,000
És emlékeztetni arra, hogy segítségével a merge sort

59
00:03:27,000 --> 00:03:31,000
tudtuk, hogy ezt sokkal jobb, mint buborék rendezés és kiválasztás sort

60
00:03:31,000 --> 00:03:33,000
és még beillesztés sort.

61
00:03:33,000 --> 00:03:36,000
>> Kaptunk le n log n, és újra,

62
00:03:36,000 --> 00:03:39,000
Emlékeztetek arra, hogy log n általában az valamit, hogy nő

63
00:03:39,000 --> 00:03:43,000
lassabban akkor n, így n log n eddig jó volt

64
00:03:43,000 --> 00:03:45,000
mivel az kevésbé mint n ².

65
00:03:45,000 --> 00:03:47,000
De elérése n log n a merge sort

66
00:03:47,000 --> 00:03:51,000
mi volt az az alap, csírája egy ötlet, hogy mi volt, hogy felerősítse a

67
00:03:51,000 --> 00:03:54,000
hogy mi is megmutatta, vissza a 0. héten?

68
00:03:54,000 --> 00:03:58,000
Hogyan kezeljük a rendezési probléma ügyesen a merge sort?

69
00:03:58,000 --> 00:04:04,000
Mi volt a legfontosabb betekintést, talán?

70
00:04:04,000 --> 00:04:07,000
Bárki, aki egyáltalán.

71
00:04:07,000 --> 00:04:09,000
Oké, egy lépést hátra.

72
00:04:09,000 --> 00:04:11,000
Ismertesse merge sort a saját szavaival.

73
00:04:11,000 --> 00:04:15,000
Hogyan működik?

74
00:04:15,000 --> 00:04:17,000
Oké, evezni vissza 0. héten.

75
00:04:17,000 --> 00:04:19,000
Oké, igen.

76
00:04:19,000 --> 00:04:22,000
[Hallhatatlan-diák]

77
00:04:22,000 --> 00:04:26,000
Oké, jó, szóval megosztotta a tömb számokat 2 db.

78
00:04:26,000 --> 00:04:29,000
Mi sorrendje minden egyes ilyen darab, aztán egyesült őket,

79
00:04:29,000 --> 00:04:33,000
és láttuk ezt az ötletet, mielőtt figyelembe a probléma, hogy ez a nagy

80
00:04:33,000 --> 00:04:36,000
és darabolás fel egy probléma, hogy ez a nagy, vagy a nagy.

81
00:04:36,000 --> 00:04:38,000
>> Hívja a telefonkönyv példa.

82
00:04:38,000 --> 00:04:42,000
Emlékezzünk az ön-számlálás algoritmust héttel ezelőtt,

83
00:04:42,000 --> 00:04:45,000
így merge sort foglalta össze ezt a pszeudokód ide.

84
00:04:45,000 --> 00:04:48,000
Amikor adott n elemű, első volt józanság megtekintéséhez.

85
00:04:48,000 --> 00:04:51,000
Ha n <2, akkor nem csinál semmit

86
00:04:51,000 --> 00:04:55,000
mert ha n <2, akkor n értéke 0 vagy 1 nyilvánvalóan,

87
00:04:55,000 --> 00:04:57,000
és így, ha ez 0 vagy 1 semmi rendezni.

88
00:04:57,000 --> 00:04:59,000
Te kész.

89
00:04:59,000 --> 00:05:01,000
A lista már triviálisan rendezve.

90
00:05:01,000 --> 00:05:04,000
De egyébként ha van 2 vagy több elem megy előre, és az őket elválasztó

91
00:05:04,000 --> 00:05:06,000
a 2 fél, balra és jobbra.

92
00:05:06,000 --> 00:05:09,000
Rendezése minden említett fél, majd egyesíteni a rendezett felét.

93
00:05:09,000 --> 00:05:13,000
De a probléma az, hogy első látásra ez az érzés vagyunk punting.

94
00:05:13,000 --> 00:05:17,000
Ez körkörös meghatározás, hogy ha én kértem, hogy rendezni ezeket n elemek

95
00:05:17,000 --> 00:05:22,000
, és azt mondod: "Oké, rendben, akkor rendezni e n / 2 és az n / 2 elem"

96
00:05:22,000 --> 00:05:27,000
akkor a következő kérdés az lesz, hogy "Rendben, hogyan rendezheti a n / 2 elem?"

97
00:05:27,000 --> 00:05:30,000
>> Hanem azért, mert a szerkezete ennek a programnak,

98
00:05:30,000 --> 00:05:33,000
mert ez az alapeset, hogy úgy mondjam,

99
00:05:33,000 --> 00:05:39,000
Ebben a speciális esetben, hogy azt mondja, ha n <néhány fix érték, mint a 2 menettérti azonnal.

100
00:05:39,000 --> 00:05:42,000
Ne válaszoljon az ugyanezen kör választ.

101
00:05:42,000 --> 00:05:46,000
Ez a folyamat, ez a ciklikusság-utóbb véget ér.

102
00:05:46,000 --> 00:05:50,000
Ha azt kérdezni: "Növekvő ezeket n elemeket", és azt mondod: "Rendben, rendezze ezeket n / 2"

103
00:05:50,000 --> 00:05:53,000
akkor azt mondja: "Rendben, sort ezek n / 4, n / 8, n/16"

104
00:05:53,000 --> 00:05:56,000
végül akkor osszuk el egy elég nagy szám

105
00:05:56,000 --> 00:05:59,000
hogy neked csak 1 elemet balra, ekkor tud mondani,

106
00:05:59,000 --> 00:06:02,000
"Íme, itt van egy rendezett egyetlen elem."

107
00:06:02,000 --> 00:06:06,000
Aztán a ragyogás ezen algoritmus ide, hogy abból származnak

108
00:06:06,000 --> 00:06:09,000
hogy ha egyszer már az összes ilyen egyedileg válogatott listákat,

109
00:06:09,000 --> 00:06:12,000
amelyek mind az 1-es méret, ami úgy tűnik, hogy használhatatlan,

110
00:06:12,000 --> 00:06:15,000
ha egyszer elkezd összevonással és összevonással

111
00:06:15,000 --> 00:06:19,000
Ön kiépítése végül Rob tette a videót a véglegesen rendezett listát.

112
00:06:19,000 --> 00:06:22,000
>> De ez a gondolat messze túlmutat válogatás.

113
00:06:22,000 --> 00:06:26,000
Van ez a gondolat beágyazott e program néven ismert rekurzió,

114
00:06:26,000 --> 00:06:29,000
az ötletet, mely szerint van egy program,

115
00:06:29,000 --> 00:06:32,000
és megoldani néhány problémát hívod magad,

116
00:06:32,000 --> 00:06:36,000
vagy tegye keretében programozási nyelvek Ön egy funkciót,

117
00:06:36,000 --> 00:06:39,000
és annak érdekében, hogy megoldja a problémát, akkor a függvény nevezed magad

118
00:06:39,000 --> 00:06:42,000
újra és újra és újra, de a funkció

119
00:06:42,000 --> 00:06:44,000
nem hívod magad végtelen sok alkalommal.

120
00:06:44,000 --> 00:06:47,000
Végül meg kell mélypontot, hogy úgy mondjam,

121
00:06:47,000 --> 00:06:49,000
és néhány kemény kódolt alap feltétele, hogy azt mondja,

122
00:06:49,000 --> 00:06:53,000
ezen a ponton megáll hívás magad úgy, hogy az egész folyamat

123
00:06:53,000 --> 00:06:56,000
végül valóban megáll.

124
00:06:56,000 --> 00:06:58,000
Mit jelent ez valójában, hogy recurse?

125
00:06:58,000 --> 00:07:01,000
>> Lássuk, ha tehetünk egy egyszerű, triviális példát, mondjuk,

126
00:07:01,000 --> 00:07:03,000
3 ember velem ide a színpadra, ha valaki kényelmes.

127
00:07:03,000 --> 00:07:06,000
1, gyere fel, 2 és 3.

128
00:07:06,000 --> 00:07:09,000
Ha 3 jössz ide.

129
00:07:09,000 --> 00:07:12,000
Ha azt szeretnénk, hogy álljon közvetlenül ide egy sorban, tegyük fel, hogy a probléma kéznél

130
00:07:12,000 --> 00:07:15,000
nagyon triviálisan számolja az embereknek a száma, akik itt vannak.

131
00:07:15,000 --> 00:07:18,000
De őszintén szólva, fáradt vagyok mindezen számolás példákat.

132
00:07:18,000 --> 00:07:21,000
Ez el fog tartani egy ideig, 1, 2, és pont, pont, pont.

133
00:07:21,000 --> 00:07:23,000
Ez fog tartani örökre.

134
00:07:23,000 --> 00:07:25,000
Inkább csak punt ezt a problémát teljesen a segítségével, hogy mi a neve?

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

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

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

138
00:07:31,000 --> 00:07:34,000
Most Én már feltette a kérdést valaki

139
00:07:34,000 --> 00:07:37,000
hány ember fel ebben a szakaszban, és fogalmam sincs.

140
00:07:37,000 --> 00:07:40,000
Ez egy nagyon hosszú lista, és így ahelyett, hogy fogom csinálni ezt a trükköt.

141
00:07:40,000 --> 00:07:43,000
Meg fogom kérni a személy mellett, hogy tegyek a munka nagy részét,

142
00:07:43,000 --> 00:07:46,000
és ha ő kész csinál a munka nagy részét

143
00:07:46,000 --> 00:07:49,000
Fogok csinálni a legkevesebb munka lehetséges, és csak adjunk hozzá 1

144
00:07:49,000 --> 00:07:51,000
hogy bármilyen rá válasz, hogy itt vagyunk.

145
00:07:51,000 --> 00:07:54,000
Már kérték, hány ember van a színpadon.

146
00:07:54,000 --> 00:07:57,000
Hány ember van a színpadon, a bal oldalon van?

147
00:07:57,000 --> 00:08:00,000
A bal rám? >> Oké, de nem csalnak.

148
00:08:00,000 --> 00:08:04,000
Ez jó, ez igaz, de ha azt akarjuk, hogy továbbra is ezt a logikát

149
00:08:04,000 --> 00:08:08,000
tegyük fel, hogy hasonlóan szeretné punt ezt a problémát, hogy a bal oldalán van,

150
00:08:08,000 --> 00:08:11,000
így ahelyett answer közvetlenül megy előre, és add meg a pénzükért.

151
00:08:11,000 --> 00:08:14,000
Ó, milyen sokan balra engem?

152
00:08:14,000 --> 00:08:16,000
Hányan vannak a bal oldalon?

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

154
00:08:18,000 --> 00:08:27,000
[Nevetés]

155
00:08:27,000 --> 00:08:30,000
Oké, tehát 0, akkor mi most Willy tett

156
00:08:30,000 --> 00:08:33,000
van már vissza a válasz ebben az irányban mondván 0.

157
00:08:33,000 --> 00:08:36,000
Most mit tegyünk? >> 1.

158
00:08:36,000 --> 00:08:39,000
Oké, te vagy az 1, tehát azt mondod: "Rendben van, megyek hozzá 1

159
00:08:39,000 --> 00:08:41,000
hogy bármilyen Willy gróf ", így 1 + 0.

160
00:08:41,000 --> 00:08:43,000
Te most 1, így a választ a jobb most,

161
00:08:43,000 --> 00:08:45,000
1. >> És az enyém lenne a 2.

162
00:08:45,000 --> 00:08:48,000
Jó, így szedi az előző választ 1,

163
00:08:48,000 --> 00:08:51,000
hozzáadták a minimális mennyiségű munkát akarsz csinálni, ami +1.

164
00:08:51,000 --> 00:08:55,000
Most van 2, és akkor majd adja meg, amely érték?

165
00:08:55,000 --> 00:08:57,000
3, Úgy értem, sajnálom, 2.

166
00:08:57,000 --> 00:08:59,000
Jó.

167
00:08:59,000 --> 00:09:02,000
>> Nos, mi volt 0-balra.

168
00:09:02,000 --> 00:09:05,000
Aztán volt 1, majd adunk hozzá 2,

169
00:09:05,000 --> 00:09:07,000
és most átadta nekem a 2-es szám,

170
00:09:07,000 --> 00:09:10,000
és ezért mondom, oké, +1, 3.

171
00:09:10,000 --> 00:09:13,000
Van ugyanis 3 ember mellett állva rám ezen a színpadon,

172
00:09:13,000 --> 00:09:16,000
így volna nyilvánvalóan tette ezt nagyon lineárisan,

173
00:09:16,000 --> 00:09:19,000
nagyon is nyilvánvaló módon, de mit igazán csinálni?

174
00:09:19,000 --> 00:09:21,000
Mi volt a probléma méretű, 3 kezdetben.

175
00:09:21,000 --> 00:09:24,000
Ezután tört le egy probléma a 2-es méret,

176
00:09:24,000 --> 00:09:27,000
akkor a probléma az 1-es méret, és majd végül az alapeset

177
00:09:27,000 --> 00:09:29,000
valóban, oh, nincs ott senki,

178
00:09:29,000 --> 00:09:33,000
ekkor Willy visszatért hatékonyan a kódolt választ egy pár alkalommal,

179
00:09:33,000 --> 00:09:36,000
, a második pedig ezután buborékoltatunk fel, buborékoltatunk fel, buborékoltattunk fel,

180
00:09:36,000 --> 00:09:39,000
és azután hozzáadásával ebben az egy további 1

181
00:09:39,000 --> 00:09:41,000
most már végre ezt alapgondolata rekurzió.

182
00:09:41,000 --> 00:09:44,000
>> Most, ebben az esetben nem igazán egy probléma megoldásához

183
00:09:44,000 --> 00:09:46,000
bármely hatékonyabban, akkor láttunk eddig.

184
00:09:46,000 --> 00:09:48,000
De gondolj az algoritmusok tettünk a színpadon eddig.

185
00:09:48,000 --> 00:09:51,000
Mi volt 8 darab papír a táblára,

186
00:09:51,000 --> 00:09:55,000
a videó, amikor Sean kereste a 7-es, és mit mondott valójában csinálni?

187
00:09:55,000 --> 00:09:58,000
Nos, ő nem tett semmilyen oszd meg és uralkodj.

188
00:09:58,000 --> 00:10:01,000
Ő nem tett semmilyen rekurzió.

189
00:10:01,000 --> 00:10:03,000
Inkább ő csak tette a lineáris algoritmus.

190
00:10:03,000 --> 00:10:07,000
De amikor bevezette azt az elképzelést, rendezett számok színpadon élő múlt héten

191
00:10:07,000 --> 00:10:09,000
akkor mi volt ennek az ösztönnek az lesz a középső,

192
00:10:09,000 --> 00:10:13,000
ekkor volt egy kisebb lista mérete 4 vagy másik lista 4-es méretű,

193
00:10:13,000 --> 00:10:17,000
és akkor volt, pontosan ugyanaz a probléma, ezért ismételt, többszöri, ismételt.

194
00:10:17,000 --> 00:10:19,000
Más szóval, mi recursed.

195
00:10:19,000 --> 00:10:24,000
Köszönjük, hogy a 3 önkéntesek itt bizonyításának rekurzió velünk.

196
00:10:24,000 --> 00:10:28,000
>> Lássuk, ha nem tudjuk, hogy ez most egy kicsit konkrétabb,

197
00:10:28,000 --> 00:10:30,000
egy probléma megoldására, hogy ismét tudtunk csinálni elég könnyen,

198
00:10:30,000 --> 00:10:34,000
de mi fogjuk használni, mint egy lépcsőfok, hogy végrehajtja ezt az alapvető elképzelést.

199
00:10:34,000 --> 00:10:37,000
Ha azt akarom, hogy kiszámolja az összegzése egy csomó számok,

200
00:10:37,000 --> 00:10:39,000
például, ha át a 3-as szám,

201
00:10:39,000 --> 00:10:42,000
Azt akarom, hogy ön a szigma értéke 3,

202
00:10:42,000 --> 00:10:46,000
így az összege 3 + 2 + 1 + 0.

203
00:10:46,000 --> 00:10:48,000
Azt akarom, hogy menj vissza a választ 6,

204
00:10:48,000 --> 00:10:51,000
úgyhogy végrehajtásához sigma funkciót, ez a funkció összegzés

205
00:10:51,000 --> 00:10:54,000
arra, hogy ismét vesz bemenet, majd visszaadja az összegzési

206
00:10:54,000 --> 00:10:57,000
E szám egészen 0-ra.

207
00:10:57,000 --> 00:10:59,000
Megtehetjük ezt elég egyszerű, ugye?

208
00:10:59,000 --> 00:11:01,000
Mi is ezt valamilyen looping szerkezet,

209
00:11:01,000 --> 00:11:04,000
hadd menjen előre, és kap ez elkezdődött.

210
00:11:04,000 --> 00:11:07,000
>> Beleértve stdio.h.

211
00:11:07,000 --> 00:11:09,000
Hadd magam fő dolgozni itt.

212
00:11:09,000 --> 00:11:12,000
Nézzük Mentés sigma.c.

213
00:11:12,000 --> 00:11:14,000
Aztán megyek itt, és én fogom állapítsa int n,

214
00:11:14,000 --> 00:11:18,000
és fogok csinálni a következő, amíg a felhasználó nem működik együtt.

215
00:11:18,000 --> 00:11:22,000
Amíg a felhasználó nem adott nekem egy pozitív szám

216
00:11:22,000 --> 00:11:26,000
hadd menjen előre, és kéri őket, n = getInt,

217
00:11:26,000 --> 00:11:28,000
és hadd adjon nekik néhány utasítást, hogy mit kell csinálni,

218
00:11:28,000 --> 00:11:33,000
így printf ("Pozitív egész kérem").

219
00:11:33,000 --> 00:11:39,000
Csak valami viszonylag egyszerű, mint ez, hogy mire elérjük a 14 vezetéken

220
00:11:39,000 --> 00:11:42,000
most már van egy pozitív egész feltehetően n.

221
00:11:42,000 --> 00:11:44,000
>> Most valamit csinálni vele.

222
00:11:44,000 --> 00:11:50,000
Hadd menjek előre, és kiszámítja az összegzése, ezért int összeg = sigma (n).

223
00:11:50,000 --> 00:11:54,000
Sigma csak összegzése, úgyhogy én csak írni azt a szakértő módon.

224
00:11:54,000 --> 00:11:56,000
Majd csak hívni szigma ott.

225
00:11:56,000 --> 00:11:58,000
Ez az összeg, és most megyek, hogy nyomtassa ki az eredményt,

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

227
00:12:08,000 --> 00:12:11,000
És aztán vissza 0 a jó intézkedés.

228
00:12:11,000 --> 00:12:15,000
Már mindent megtett, hogy ez a program előírja, kivéve az érdekes rész,

229
00:12:15,000 --> 00:12:18,000
amely a ténylegesen alkalmazni a szigma funkciót.

230
00:12:18,000 --> 00:12:22,000
>> Hadd menjek le ide, hogy az aljára, és hadd állapítsa funkció sigma.

231
00:12:22,000 --> 00:12:26,000
Úgy van, hogy olyan változó, hogy ez a típusú egész szám,

232
00:12:26,000 --> 00:12:30,000
és milyen adattípus akarok visszatérni feltehetően a Sigma?

233
00:12:30,000 --> 00:12:34,000
Int, mert azt akarom, hogy megfeleljen az elvárásaimnak on line 15.

234
00:12:34,000 --> 00:12:37,000
Az itt hadd menjen előre, és végrehajtják ezt

235
00:12:37,000 --> 00:12:41,000
Egy nagyon egyszerű módon.

236
00:12:41,000 --> 00:12:45,000
>> Menjünk előre, és azt mondják, int összeg = 0,

237
00:12:45,000 --> 00:12:47,000
és most megyek egy kicsit a hurok itt

238
00:12:47,000 --> 00:12:50,000
hogy fog mondani valamit, mint ez,

239
00:12:50,000 --> 00:13:01,000
for (int i = 0; I <= szám; i + +) összeg + = i.

240
00:13:01,000 --> 00:13:05,000
Aztán megyek vissza az összeget.

241
00:13:05,000 --> 00:13:07,000
Tudtam volna végre ezt a tetszőleges számú módon.

242
00:13:07,000 --> 00:13:09,000
Én is használtam egy darabig hurok.

243
00:13:09,000 --> 00:13:11,000
Tudtam volna kihagyja a változó összeg, ha tényleg akartam,

244
00:13:11,000 --> 00:13:15,000
de a rövid, már csak egy függvény, hogy ha nem hülye nyilatkozik összeg 0.

245
00:13:15,000 --> 00:13:18,000
Ezután megismétli 0-tól akár a száma,

246
00:13:18,000 --> 00:13:23,000
és minden iteráció hozzáteszi, hogy a jelenlegi értéket összeg, majd visszatér összeget.

247
00:13:23,000 --> 00:13:25,000
>> Nos, van egy kis optimalizálás itt.

248
00:13:25,000 --> 00:13:29,000
Ez valószínűleg egy elvesztegetett lépés, de hát legyen. Ez rendben van most.

249
00:13:29,000 --> 00:13:32,000
Vagyunk, legalább, hogy alapos és megy 0 egészen akár.

250
00:13:32,000 --> 00:13:34,000
Nem nagyon kemény és nagyon egyszerű,

251
00:13:34,000 --> 00:13:37,000
de kiderül, hogy a szigma funkcióval van az ugyanezt a lehetőséget

252
00:13:37,000 --> 00:13:39,000
mint mi itt a színpadon.

253
00:13:39,000 --> 00:13:42,000
A színpadon már csak számolni, hogy hány ember volt mellettem,

254
00:13:42,000 --> 00:13:47,000
hanem ha azt akartuk, hogy számolja meg a 3 + 2 + 1

255
00:13:47,000 --> 00:13:51,000
le 0-ra tudtunk hasonlóan punt egy függvény

256
00:13:51,000 --> 00:13:55,000
hogy én inkább írni, hogy a rekurzív.

257
00:13:55,000 --> 00:13:57,000
Itt csináljuk gyors józanság ellenőrizze és győződjön meg róla, én nem hülye.

258
00:13:57,000 --> 00:14:00,000
>> Tudom, hogy van legalább egy dolog ez a program, hogy én csináltam rosszul.

259
00:14:00,000 --> 00:14:04,000
Amikor hit lép fogok kapni bármilyen kiabál rám?

260
00:14:04,000 --> 00:14:06,000
Mit fogok, hogy kiabált szó?

261
00:14:06,000 --> 00:14:11,000
Ja, elfelejtettem a prototípus, úgyhogy függvény segítségével úgynevezett szigma on line 15,

262
00:14:11,000 --> 00:14:16,000
de ez nem nyilvánított ig a 22, úgyhogy a legjobb proaktív menni ide

263
00:14:16,000 --> 00:14:22,000
és állapítsa meg a prototípus, és azt mondom int sigma (int szám), és ennyi.

264
00:14:22,000 --> 00:14:24,000
Ez végre az alján.

265
00:14:24,000 --> 00:14:27,000
>> Vagy egy másik módja, hogy oldja meg ezt,

266
00:14:27,000 --> 00:14:30,000
Tudtam mozgatni a funkció ott, ami nem rossz,

267
00:14:30,000 --> 00:14:32,000
de legalább, ha a programok kezdenek hosszú, őszintén szólva,

268
00:14:32,000 --> 00:14:35,000
Azt hiszem, van néhány érték, amely mindig a legfontosabb a csúcson

269
00:14:35,000 --> 00:14:38,000
úgy, hogy az olvasó tudja nyitni a fájlt, majd azonnal látni

270
00:14:38,000 --> 00:14:40,000
mit csinál a program anélkül, hogy keressük rajta

271
00:14:40,000 --> 00:14:42,000
keres, hogy a fő funkciója.

272
00:14:42,000 --> 00:14:49,000
Menjünk le a terminál ablak van, próbálja sigma tenni szigma,

273
00:14:49,000 --> 00:14:51,000
és elcsesztem itt is.

274
00:14:51,000 --> 00:14:55,000
Implicit nyilatkozatot funkció getInt jelenti elfelejtettem csinálni mi mást?

275
00:14:55,000 --> 00:14:57,000
[Hallhatatlan-diák]

276
00:14:57,000 --> 00:15:00,000
Jó, így nyilvánvalóan a gyakori hiba, úgyhogy tegyük ezt itt,

277
00:15:00,000 --> 00:15:04,000
cs50.h, és most menjünk vissza a terminál ablakot.

278
00:15:04,000 --> 00:15:08,000
>> Majd törölje a képernyőt, és én, hogy futtassa újra sigma.

279
00:15:08,000 --> 00:15:11,000
Úgy tűnik, hogy összeállítani. Hadd futni sigma.

280
00:15:11,000 --> 00:15:15,000
Majd írja be a 3-as szám, és nem kap 6, tehát nem a szigorú ellenőrzést,

281
00:15:15,000 --> 00:15:18,000
de legalább úgy tűnik, hogy működik az első pillantásra, de most hadd rip szét,

282
00:15:18,000 --> 00:15:21,000
és hagyja, hogy a valóban kihasználhatják azt az elképzelést, rekurzió, újra,

283
00:15:21,000 --> 00:15:24,000
Egy nagyon egyszerű kontextus úgyhogy néhány hét múlva

284
00:15:24,000 --> 00:15:27,000
amikor elkezdjük felfedezni galambász adatszerkezetek, mint a tömbök

285
00:15:27,000 --> 00:15:30,000
van egy másik eszköz az eszköztár, amellyel

286
00:15:30,000 --> 00:15:33,000
manipulálják ezeket adatstruktúrák mint látni fogjuk.

287
00:15:33,000 --> 00:15:36,000
Ez az iteratív megközelítés, a loop-alapú megközelítés.

288
00:15:36,000 --> 00:15:39,000
>> Hadd ehelyett most ezt.

289
00:15:39,000 --> 00:15:44,000
Hadd inkább azt mondják, hogy az összegzése a szám

290
00:15:44,000 --> 00:15:48,000
le 0-ra valóban ugyanaz, mint a

291
00:15:48,000 --> 00:15:53,000
száma + sigma (száma - 1).

292
00:15:53,000 --> 00:15:57,000
Más szóval, ahogy a színpadon I punted az egyes emberek mellém,

293
00:15:57,000 --> 00:16:00,000
és viszont punting tartott, amíg végül el mélypontját a Willy,

294
00:16:00,000 --> 00:16:03,000
aki vissza a kódolt választ, mint a 0-ra.

295
00:16:03,000 --> 00:16:07,000
Itt most mi hasonlóan punting a szigma

296
00:16:07,000 --> 00:16:10,000
ugyanazt a funkciót, mint eredetileg nevezett, de a legfontosabb betekintést itt

297
00:16:10,000 --> 00:16:12,000
az, hogy mi nem hív szigma azonosan.

298
00:16:12,000 --> 00:16:14,000
Mi nem halad n.

299
00:16:14,000 --> 00:16:17,000
Mi jól halad száma - 1,

300
00:16:17,000 --> 00:16:20,000
így egy valamivel kisebb probléma, valamivel kisebb probléma.

301
00:16:20,000 --> 00:16:23,000
>> Sajnos, ez nem egészen megoldás még, és mielőtt rögzítjük

302
00:16:23,000 --> 00:16:26,000
milyen lehet ugrott ki, mint nyilvánvaló, néhányan

303
00:16:26,000 --> 00:16:28,000
hadd menjen előre, és futtassa újra tenni.

304
00:16:28,000 --> 00:16:30,000
Úgy tűnik, hogy rendben összeállításához.

305
00:16:30,000 --> 00:16:32,000
Hadd futtasd Sigma, 6.

306
00:16:32,000 --> 00:16:37,000
Hoppá, hadd futtassa újra Sigma, 6.

307
00:16:37,000 --> 00:16:42,000
Már láttam ilyet, de véletlenül utoljára is.

308
00:16:42,000 --> 00:16:48,000
Miért kaptam ezt a rejtélyes szegmentálási hiba? Igen.

309
00:16:48,000 --> 00:16:50,000
[Hallhatatlan-diák]

310
00:16:50,000 --> 00:16:53,000
Nincs az alapeset, pontosabban, mi valószínűleg történt?

311
00:16:53,000 --> 00:16:58,000
Ez a tünet milyen viselkedés?

312
00:16:58,000 --> 00:17:00,000
Mondja, hogy egy kicsit hangosabban.

313
00:17:00,000 --> 00:17:02,000
[Hallhatatlan-diák]

314
00:17:02,000 --> 00:17:05,000
Ez egy végtelen ciklus hatékonyan, és a probléma a végtelen hurkok

315
00:17:05,000 --> 00:17:08,000
amikor az együtt jár a rekurziót ebben az esetben, egy függvény nevezte magát,

316
00:17:08,000 --> 00:17:10,000
mi történik, minden alkalommal, amikor hívja a funkciót?

317
00:17:10,000 --> 00:17:13,000
Nos, gondolom, vissza hogyan lefektetett a memória a számítógép.

318
00:17:13,000 --> 00:17:16,000
Azt mondta, hogy itt van ez a darab a memória az úgynevezett stack, ami az alján,

319
00:17:16,000 --> 00:17:19,000
és minden alkalommal, amikor hív egy függvényt egy kicsit több memóriát kap valósult

320
00:17:19,000 --> 00:17:24,000
Ezen az úgynevezett stack tartalmazó függvény helyi változók vagy paraméterek

321
00:17:24,000 --> 00:17:27,000
így ha sigma felhívja sigma felhívja szigma felhívja szigma

322
00:17:27,000 --> 00:17:29,000
 felhívja sigma amennyiben nem ez a történet vége?

323
00:17:29,000 --> 00:17:31,000
>> Nos, ez végül túllépése a teljes összeget

324
00:17:31,000 --> 00:17:33,000
memóriát, hogy van elérhető a számítógéphez.

325
00:17:33,000 --> 00:17:37,000
Te túllépés a szegmens, amit kéne maradnia,

326
00:17:37,000 --> 00:17:40,000
és megkapod ezt a szegmentációs hiba, core dump,

327
00:17:40,000 --> 00:17:43,000
és milyen core dump jelenti, hogy most van egy nevű fájlt core

328
00:17:43,000 --> 00:17:46,000
amely egy fájl, amely nullákkal és egyesekkel

329
00:17:46,000 --> 00:17:49,000
hogy valóban a jövőben lesz diagnosztikailag hasznos.

330
00:17:49,000 --> 00:17:52,000
Ha ez nem egyértelmű, hogy hol a hiba a

331
00:17:52,000 --> 00:17:54,000
akkor valóban egy kicsit a kriminalisztika, hogy úgy mondjam,

332
00:17:54,000 --> 00:17:58,000
ezen a core dump fájlt, ami ismét csak egy csomó nullákkal és egyesekkel

333
00:17:58,000 --> 00:18:02,000
jelenti, hogy lényegében az állam a program a memóriában

334
00:18:02,000 --> 00:18:05,000
a pillanatban, amikor összeomlott így.

335
00:18:05,000 --> 00:18:11,000
>> A javítás az, hogy nem tudunk vakon vissza szigma,

336
00:18:11,000 --> 00:18:14,000
a száma + szigma egy valamivel kisebb probléma.

337
00:18:14,000 --> 00:18:16,000
Szükségünk van valamilyen alap esetben is,

338
00:18:16,000 --> 00:18:19,000
és mi legyen a bázis esetében valószínűleg?

339
00:18:19,000 --> 00:18:22,000
[Hallhatatlan-diák]

340
00:18:22,000 --> 00:18:25,000
Rendben, amíg a szám pozitív kellene tulajdonképpen vissza ezt,

341
00:18:25,000 --> 00:18:29,000
vagy másképpen fogalmazva, ha a szám, mondjuk, <= 0-ra

342
00:18:29,000 --> 00:18:32,000
Tudod mit, én megyek előre és vissza 0,

343
00:18:32,000 --> 00:18:36,000
ugyanúgy, mint Willy volt, és mást, megyek, hogy menjen előre

344
00:18:36,000 --> 00:18:41,000
és vissza ezt, így ez nem olyan sokkal rövidebb

345
00:18:41,000 --> 00:18:44,000
mint az iteratív változata, amit felvert fel először egy for ciklus,

346
00:18:44,000 --> 00:18:48,000
azonban észre, hogy itt van ez a fajta elegancia hozzá.

347
00:18:48,000 --> 00:18:51,000
Ahelyett, hogy az adatszolgáltató egyes szám és előadó mindezt matematikai

348
00:18:51,000 --> 00:18:54,000
és hozzá a dolgokat a helyi változók

349
00:18:54,000 --> 00:18:57,000
ön helyett azt mondja: "Jól van, ha ez egy szuper könnyű probléma,

350
00:18:57,000 --> 00:19:01,000
mint a szám <0, hadd azonnal vissza 0-ra. "

351
00:19:01,000 --> 00:19:03,000
>> Nem fogunk zavarni támogató negatív számokat,

352
00:19:03,000 --> 00:19:05,000
így fogok keményen kódot a 0 értéket.

353
00:19:05,000 --> 00:19:08,000
De egyébként, hogy végrehajtsák ezt a gondolatot az összegező

354
00:19:08,000 --> 00:19:11,000
Mindezen számok együttesen lehet hatékonyan, hogy egy kis falatot

355
00:19:11,000 --> 00:19:14,000
ki a probléma, ugyanúgy, mint tettük itt a színpadon,

356
00:19:14,000 --> 00:19:18,000
akkor punt a többi probléma a következő személyt,

357
00:19:18,000 --> 00:19:20,000
de ebben az esetben a következő személy magad.

358
00:19:20,000 --> 00:19:22,000
Ez egy azonos nevű funkciót.

359
00:19:22,000 --> 00:19:25,000
Csak add meg, hogy egy kisebb és kisebb és kisebb problémát minden egyes alkalommal,

360
00:19:25,000 --> 00:19:28,000
és bár mi nem igazán hivatalossá dolgokat ide a kódot

361
00:19:28,000 --> 00:19:33,000
ez pontosan mi is folyik a 0. héten, a telefonkönyvben.

362
00:19:33,000 --> 00:19:36,000
Pontosan ez az, hogy mi történik az elmúlt hét Sean

363
00:19:36,000 --> 00:19:39,000
és a mi bemutatók keres számok.

364
00:19:39,000 --> 00:19:42,000
Ez vesz egy problémát, és elosztjuk meg újra és újra.

365
00:19:42,000 --> 00:19:44,000
>> Más szóval, van egy módja már fordításának

366
00:19:44,000 --> 00:19:47,000
ez a valós konstrukciót, ez a magasabb szintű konstrukció

367
00:19:47,000 --> 00:19:51,000
Az oszd meg és uralkodj, és csinál valamit újra és újra

368
00:19:51,000 --> 00:19:56,000
kódot, így ez az, amit látni fogjuk, újra az idő múlásával.

369
00:19:56,000 --> 00:20:00,000
Most, mint egy félre, ha új rekurzió akkor legalább megérteni,

370
00:20:00,000 --> 00:20:02,000
hogy ez miért vicces.

371
00:20:02,000 --> 00:20:05,000
Fogok menni google.com,

372
00:20:05,000 --> 00:20:17,000
és megyek keresni néhány tippet és trükköt rekurzió írja.

373
00:20:17,000 --> 00:20:21,000
Mondd meg az a személy, Ön mellett, ha nem nevetnek most.

374
00:20:21,000 --> 00:20:23,000
Gondolt rekurzió?

375
00:20:23,000 --> 00:20:25,000
Did you mean-ah, ott vagyunk.

376
00:20:25,000 --> 00:20:28,000
Oké, most, hogy ez a többi mindenkinek.

377
00:20:28,000 --> 00:20:30,000
Egy kis húsvéti tojás beágyazott valahol ott a Google.

378
00:20:30,000 --> 00:20:33,000
Mint félre, egyet a linkeket tesszük a pályán honlapján

379
00:20:33,000 --> 00:20:36,000
mára csak ez a rács a különböző válogatás algoritmusok,

380
00:20:36,000 --> 00:20:39,000
amelyek közül néhány néztük múlt héten, de mi a jó ebben megjelenítés

381
00:20:39,000 --> 00:20:43,000
ahogy próbálja tekerje elméd köré különböző dolgokat kapcsolódó algoritmusok

382
00:20:43,000 --> 00:20:46,000
tudom, hogy nagyon könnyen nekiláthatnak különböző típusú bemenet.

383
00:20:46,000 --> 00:20:50,000
A bemenetek minden megfordult, a bemenetek többnyire rendezve, a bemenetek véletlen és így tovább.

384
00:20:50,000 --> 00:20:53,000
Ahogy próbálja újra, megkülönbözteti ezeket a dolgokat a fejedben

385
00:20:53,000 --> 00:20:57,000
észre, hogy ezt az URL a kurzus honlapján a Lectures oldalon

386
00:20:57,000 --> 00:21:00,000
segíthet miatt át néhány ilyen.

387
00:21:00,000 --> 00:21:05,000
>> Ma végre kap, hogy megoldja ezt a problémát egy kicsit vissza,

388
00:21:05,000 --> 00:21:08,000
ami az volt, hogy ez a csere a funkció nem működött,

389
00:21:08,000 --> 00:21:12,000
és mi volt az alapvető probléma ezzel a funkcióval swap,

390
00:21:12,000 --> 00:21:15,000
a cél az volt, ismét cseréljenek értéket itt és itt

391
00:21:15,000 --> 00:21:17,000
oly módon, hogy ez történik?

392
00:21:17,000 --> 00:21:20,000
Ez valójában nem működik. Miért?

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

394
00:21:22,000 --> 00:21:28,000
[Hallhatatlan-diák]

395
00:21:28,000 --> 00:21:31,000
Pontosan, a magyarázat erre a bugginess

396
00:21:31,000 --> 00:21:34,000
Egyszerűen azért, mert ha hívja funkciók C

397
00:21:34,000 --> 00:21:38,000
és ezeket a funkciókat vesz érvek, mint a és b itt,

398
00:21:38,000 --> 00:21:42,000
Ön halad példányban bármilyen érték, amit nyújt, hogy ezt a funkciót.

399
00:21:42,000 --> 00:21:46,000
Ön nem biztosítja az eredeti értékek maguk

400
00:21:46,000 --> 00:21:49,000
így látta ezt keretében buggyc,

401
00:21:49,000 --> 00:21:52,000
buggy3.c, ami úgy nézett egy kicsit valami ilyesmi.

402
00:21:52,000 --> 00:21:57,000
>> Emlékezzünk arra, hogy mi volt az x és y inicializálódik az 1. és 2., illetve.

403
00:21:57,000 --> 00:21:59,000
Ezután kinyomtatható mik voltak azok.

404
00:21:59,000 --> 00:22:03,000
Aztán azt állította, hogy én swapping őket hívja swap x, y.

405
00:22:03,000 --> 00:22:06,000
De a probléma az volt, hogy a csere működött,

406
00:22:06,000 --> 00:22:10,000
de csak a hatálya alá a swap funkció is.

407
00:22:10,000 --> 00:22:13,000
Amint elérjük a 40 vezetéken ezeket cserélték értékek

408
00:22:13,000 --> 00:22:16,000
dobtak el, és így semmi

409
00:22:16,000 --> 00:22:21,000
Az eredeti funkció fő ténylegesen változott,

410
00:22:21,000 --> 00:22:26,000
így ha úgy gondolja, majd vissza, hogy ez mit néz szempontjából emlékezetünk

411
00:22:26,000 --> 00:22:29,000
ha ez a bal oldali a fórumon jelentése-

412
00:22:29,000 --> 00:22:33,000
és én minden tőlem telhetőt, hogy mindenki lássa, ha a bal oldalán a fórumon

413
00:22:33,000 --> 00:22:37,000
jelentése, mondjuk, a RAM és a verem fog növekedni fel ilyen módon,

414
00:22:37,000 --> 00:22:43,000
és hívjuk a függvényt, mint a fő-, és fontosabb a 2 helyi változók, x és y,

415
00:22:43,000 --> 00:22:48,000
menjünk le ezeket, mint x itt, és menjünk le ezeket y itt,

416
00:22:48,000 --> 00:22:55,000
és tegyük az értékek 1 és 2, így ez itt a fő,

417
00:22:55,000 --> 00:22:58,000
és amikor fő felhívja a swap függvény az operációs rendszer

418
00:22:58,000 --> 00:23:02,000
meghozta a swap függvény saját rend a memória a verem,

419
00:23:02,000 --> 00:23:04,000
saját keret a verem, hogy úgy mondjam.

420
00:23:04,000 --> 00:23:08,000
Azt is lefoglal 32 bit ezen ints.

421
00:23:08,000 --> 00:23:11,000
Ez történik hívni őket és b, de ez teljesen önkényes.

422
00:23:11,000 --> 00:23:13,000
Lehetett nevezték őket, amit akar, de mi történik, ha a fő

423
00:23:13,000 --> 00:23:19,000
felhívja swap tart ez 1, tesz egy példányt ott tesz egy példányt ott.

424
00:23:19,000 --> 00:23:23,000
>> Jelenleg 1 más helyi változó csere, bár az úgynevezett mi? >> Tmp.

425
00:23:23,000 --> 00:23:27,000
Tmp, úgyhogy hadd adjak magamnak még egy 32 bit itt,

426
00:23:27,000 --> 00:23:29,000
és mit tegyek ez a funkció?

427
00:23:29,000 --> 00:23:34,000
Azt mondtam, int tmp kap, így van 1, ezért tettem ezt, amikor utoljára játszottunk ezt a példát.

428
00:23:34,000 --> 00:23:39,000
Aztán lesz b, tehát b értéke 2, így most ez lesz 2,

429
00:23:39,000 --> 00:23:42,000
és most b kap temp, így a temp 1,

430
00:23:42,000 --> 00:23:44,000
így most b válik ez.

431
00:23:44,000 --> 00:23:46,000
Ez nagyszerű. Ez működött.

432
00:23:46,000 --> 00:23:49,000
De aztán, amint a függvény

433
00:23:49,000 --> 00:23:52,000
csere memóriájában ténylegesen eltűnik oly módon, hogy újra fel lehet használni

434
00:23:52,000 --> 00:23:58,000
valamilyen más funkciót a jövőben, és a fő nyilvánvalóan teljesen változatlan.

435
00:23:58,000 --> 00:24:00,000
Szükségünk van egy módja annak, alapvetően ezen probléma megoldásához,

436
00:24:00,000 --> 00:24:03,000
és ma mi végre van egy ezt a módszert, amellyel

437
00:24:03,000 --> 00:24:06,000
tudjuk be egy úgynevezett mutató.

438
00:24:06,000 --> 00:24:09,000
Kiderül, hogy meg tudjuk oldani ezt a problémát

439
00:24:09,000 --> 00:24:12,000
nem vezetjük példány x és y

440
00:24:12,000 --> 00:24:18,000
hanem átadásával, amit, mit gondol, hogy a swap funkció?

441
00:24:18,000 --> 00:24:20,000
Ja, és mi van a cím?

442
00:24:20,000 --> 00:24:22,000
Mi nem igazán beszéltünk címeket sok részlet,

443
00:24:22,000 --> 00:24:25,000
de ha ez a tábla mutatja a számítógép memóriájában

444
00:24:25,000 --> 00:24:28,000
tudtuk biztosan kezdeni a számozást byte az én RAM

445
00:24:28,000 --> 00:24:31,000
és azt mondják, ez a bájt # 1, ez a bájt # 2, # 3 bájt,

446
00:24:31,000 --> 00:24:35,000
# 4 bájt, bájt # ... 2000000000 ha van 2 GB RAM,

447
00:24:35,000 --> 00:24:38,000
így minden bizonnyal jönni néhány önkényes számozási rendszer

448
00:24:38,000 --> 00:24:41,000
minden egyes bájt a számítógép memóriájában.

449
00:24:41,000 --> 00:24:43,000
>> Mi van, ha ehelyett, amikor hívásváltás

450
00:24:43,000 --> 00:24:47,000
ahelyett igazolványt példányban x és y

451
00:24:47,000 --> 00:24:51,000
miért nem inkább át a címét x itt,

452
00:24:51,000 --> 00:24:55,000
címe y itt lényegében a postacím

453
00:24:55,000 --> 00:24:59,000
Az x és y, mert akkor csere, ha ő tájékoztatta

454
00:24:59,000 --> 00:25:01,000
A cím a memóriában az x és y,

455
00:25:01,000 --> 00:25:04,000
akkor csere, ha képzett neki egy kicsit,

456
00:25:04,000 --> 00:25:07,000
tudott potenciálisan vezetni arra a címre, hogy úgy mondjam,

457
00:25:07,000 --> 00:25:11,000
x, és módosítsa a számot ott, majd a meghajtó a címét y,

458
00:25:11,000 --> 00:25:16,000
számának módosításához ott, miközben valójában nem kapok másolatát ezeket az értékeket magát,

459
00:25:16,000 --> 00:25:19,000
így még akkor is beszéltünk erről, hogy a fő memóriájába

460
00:25:19,000 --> 00:25:23,000
és ez az, hogy a swap-memóriája az erős és a veszélyes rész a C

461
00:25:23,000 --> 00:25:28,000
, hogy minden funkció megérinteni memóriát bárhol a számítógép,

462
00:25:28,000 --> 00:25:32,000
és ez az erős, hogy meg tudod csinálni nagyon divatos dolgokat számítógépes programok C.

463
00:25:32,000 --> 00:25:36,000
Ez veszélyes, mert akkor is csavarja ki nagyon könnyen.

464
00:25:36,000 --> 00:25:39,000
Sőt, az egyik az a leggyakoribb módja a programok manapság kiaknázandó

465
00:25:39,000 --> 00:25:42,000
még mindig a programozó nem felismerni

466
00:25:42,000 --> 00:25:45,000
hogy ő, amely lehetővé teszi az adat

467
00:25:45,000 --> 00:25:49,000
írandó olyan helyen a memória nem erre tervezték.

468
00:25:49,000 --> 00:25:51,000
>> Például ő nyilatkozik egy sor 10-es méret

469
00:25:51,000 --> 00:25:56,000
de aztán véletlenül megpróbál tenni 11 byte-ba, hogy a tömb memória,

470
00:25:56,000 --> 00:25:59,000
és elkezdi megható részei memória már nem érvényesek.

471
00:25:59,000 --> 00:26:02,000
Csak kontextuális ezt néhány talán tudja, hogy

472
00:26:02,000 --> 00:26:06,000
szoftver gyakran kér sorozatszámot vagy regisztrációs kulcs,

473
00:26:06,000 --> 00:26:08,000
Photoshop és a Word és programok, mint ez.

474
00:26:08,000 --> 00:26:12,000
Léteznek repedések, mivel néhány tudjátok, online hol lehet futtatni egy kis program,

475
00:26:12,000 --> 00:26:14,000
és íme, nincs több kérelem egy sorszám.

476
00:26:14,000 --> 00:26:16,000
Milyen az, hogy működik?

477
00:26:16,000 --> 00:26:21,000
Sok esetben ezek a dolgok egyszerűen csak megtalálni a számítógépek

478
00:26:21,000 --> 00:26:24,000
text szegmensek a számítógép aktuális nullákkal és egyesekkel

479
00:26:24,000 --> 00:26:28,000
hol van ez a funkció, ha a sorozatszám kérik,

480
00:26:28,000 --> 00:26:31,000
és felülírja ezt a helyet, vagy miközben a program fut

481
00:26:31,000 --> 00:26:33,000
tudod kitalálni, hol a kulcs ténylegesen tárolt

482
00:26:33,000 --> 00:26:37,000
segítségével egy úgynevezett debugger, és akkor kiváló szoftver módon.

483
00:26:37,000 --> 00:26:40,000
Ez nem azt jelenti, hogy ez a célunk a következő pár napban,

484
00:26:40,000 --> 00:26:42,000
de nagyon valós következményei.

485
00:26:42,000 --> 00:26:45,000
Ez az egyetlen történik vonja lopás szoftver,

486
00:26:45,000 --> 00:26:47,000
de ott is kompromisszum a teljes gép.

487
00:26:47,000 --> 00:26:50,000
>> Valójában, amikor weboldalak ezekben a napokban kizsákmányolás

488
00:26:50,000 --> 00:26:53,000
és a sérült és az adatok szivárgott és jelszavakat lopott

489
00:26:53,000 --> 00:26:58,000
ez nagyon gyakran kapcsolódik a rossz gazdálkodás egyik memóriájában,

490
00:26:58,000 --> 00:27:01,000
vagy, abban az esetben az adatbázisok, elmulasztása előre

491
00:27:01,000 --> 00:27:03,000
kontradiktórius bemenet, így több az, hogy az elkövetkezendő hetek során,

492
00:27:03,000 --> 00:27:07,000
de most csak egy settenkedik sajtóbemutató a fajta kár, hogy meg tudod csinálni

493
00:27:07,000 --> 00:27:11,000
azzal, hogy nem egészen megértése hogyan működnek a dolgok a motorháztető alatt.

494
00:27:11,000 --> 00:27:14,000
Menjünk megértéséről szól, hogy miért ez hibás

495
00:27:14,000 --> 00:27:17,000
-vel egy olyan eszköz, amely egyre inkább hasznos

496
00:27:17,000 --> 00:27:19,000
mint a mi programok kap bonyolultabb.

497
00:27:19,000 --> 00:27:21,000
Eddig, ha már volt egy hiba a programban

498
00:27:21,000 --> 00:27:23,000
hogy elment az erről hibakeresés ez?

499
00:27:23,000 --> 00:27:25,000
Mit a technikák voltak eddig, hogy tanítják a TF

500
00:27:25,000 --> 00:27:27,000
vagy csak autodidakta?

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

502
00:27:29,000 --> 00:27:31,000
Printf, így a printf valószínűleg már a barátod, ha meg akarja nézni

503
00:27:31,000 --> 00:27:33,000
mi folyik belül a program

504
00:27:33,000 --> 00:27:36,000
Ön az imént printf ide, printf itt printf itt.

505
00:27:36,000 --> 00:27:38,000
Akkor fuss ez, és kapsz egy csomó dolog a képernyőn

506
00:27:38,000 --> 00:27:43,000
hogy tudod használni, hogy aztán levezetni, ami valójában rosszul a programban.

507
00:27:43,000 --> 00:27:45,000
>> Printf hajlamos arra, hogy egy nagyon erős dolog,

508
00:27:45,000 --> 00:27:47,000
de ez egy nagyon manuális folyamat.

509
00:27:47,000 --> 00:27:49,000
Van, hogy egy printf itt, egy printf itt,

510
00:27:49,000 --> 00:27:51,000
és ha tedd belsejében egy hurkot akkor lehet, hogy 100 sor

511
00:27:51,000 --> 00:27:53,000
kibocsátás, amit majd meg kell rostálni keresztül.

512
00:27:53,000 --> 00:27:58,000
Ez nem egy nagyon felhasználóbarát vagy interaktív mechanizmus hibakereső programok

513
00:27:58,000 --> 00:28:00,000
de szerencsére létezik alternatíva.

514
00:28:00,000 --> 00:28:03,000
Van egy program, például az úgynevezett GDB, a GNU Debugger,

515
00:28:03,000 --> 00:28:06,000
ami egy kicsit misztikus, hogyan használja azt.

516
00:28:06,000 --> 00:28:08,000
Ez egy kicsit bonyolult, de őszintén szólva,

517
00:28:08,000 --> 00:28:11,000
ez az egyik olyan dolog, ahol ha tesz ezen a héten és a jövő

518
00:28:11,000 --> 00:28:14,000
az extra órát, hogy megértsék ilyesmit GDB

519
00:28:14,000 --> 00:28:18,000
meg fog menteni valószínűleg tíz óra a hosszú távon,

520
00:28:18,000 --> 00:28:21,000
így van, hogy hadd adjak egy teaser, hogyan működik ez a dolog.

521
00:28:21,000 --> 00:28:23,000
>> Én vagyok az én terminál ablakban.

522
00:28:23,000 --> 00:28:26,000
Hadd menjek előre, és fordítani ezt a programot, buggy3.

523
00:28:26,000 --> 00:28:28,000
Ez már naprakész.

524
00:28:28,000 --> 00:28:31,000
Hadd futtatni, mint tettük egy kicsit vissza, és valóban, ez eltörött.

525
00:28:31,000 --> 00:28:34,000
De miért van ez? Lehet, hogy elszúrtam a swap funkciót.

526
00:28:34,000 --> 00:28:37,000
Talán ez az a és b. Én nem egészen mozgó őket körül helyesen.

527
00:28:37,000 --> 00:28:39,000
Hadd menjek előre, és ezt.

528
00:28:39,000 --> 00:28:43,000
Ahelyett, hogy csak fuss buggy3 hadd helyett futtatni ezt a programot GDB,

529
00:28:43,000 --> 00:28:48,000
és azt fogom mondani, hogy fuss buggy3,

530
00:28:48,000 --> 00:28:52,000
és megyek fel egy parancssori argumentum,-tui,

531
00:28:52,000 --> 00:28:55,000
és mi, hogy ezt a jövőben a problémákat, hogy emlékeztesse spec.

532
00:28:55,000 --> 00:28:57,000
És most ez a fekete-fehér felület bukkant fel, hogy újra,

533
00:28:57,000 --> 00:28:59,000
egy kicsit nyomasztó az első, mert ez az egész

534
00:28:59,000 --> 00:29:02,000
jótállási információk itt lent, de legalább van valami ismerős.

535
00:29:02,000 --> 00:29:04,000
Az ablak tetején az én tényleges kódot,

536
00:29:04,000 --> 00:29:08,000
és ha felfelé itt hadd lapozzunk a legtetején a fájl,

537
00:29:08,000 --> 00:29:11,000
és valóban, van buggy3.c és azt tapasztaljuk, alján ezen ablak

538
00:29:11,000 --> 00:29:13,000
Van ez a GDB gyors.

539
00:29:13,000 --> 00:29:16,000
>> Ez nem ugyanaz, mint a normális John Harvard gyors.

540
00:29:16,000 --> 00:29:19,000
Ez egy figyelmeztetés fog engedje meg, hogy ellenőrizzék GDB.

541
00:29:19,000 --> 00:29:21,000
GDB egy debugger.

542
00:29:21,000 --> 00:29:24,000
A hibakereső olyan program, amely lehetővé teszi, hogy séta

543
00:29:24,000 --> 00:29:27,000
végrehajtása a program soronként sorra,

544
00:29:27,000 --> 00:29:30,000
az út mentén, hogy bármit szeretnénk a programot,

545
00:29:30,000 --> 00:29:33,000
még hívásfunkciók, vagy keres, ami még fontosabb,

546
00:29:33,000 --> 00:29:35,000
különböző változó értékeit.

547
00:29:35,000 --> 00:29:37,000
Menjünk előre, és ezt.

548
00:29:37,000 --> 00:29:40,000
Én megyek előre, és írja be a GDB fut a parancssorba,

549
00:29:40,000 --> 00:29:43,000
így észre a bal alsó sarokban a képernyő, amit beírt fut,

550
00:29:43,000 --> 00:29:45,000
és én már nyomd meg az Entert, és mit, hogy tegyek?

551
00:29:45,000 --> 00:29:50,000
Szó futott a program, de valójában nem sokat látni tovább itt

552
00:29:50,000 --> 00:29:55,000
mert valójában nem azt mondta a debugger

553
00:29:55,000 --> 00:29:57,000
szünet egy adott pillanatban.

554
00:29:57,000 --> 00:29:59,000
Csak írja távon futtatja a programot.

555
00:29:59,000 --> 00:30:01,000
Igazából nem látok semmit. Nem tudok manipulálni.

556
00:30:01,000 --> 00:30:03,000
>> Ehelyett hadd tegye ezt.

557
00:30:03,000 --> 00:30:08,000
Ezen GDB parancsot hadd helyett írja törés, az enter billentyűt.

558
00:30:08,000 --> 00:30:10,000
Ez nem az, amit akartam beírni.

559
00:30:10,000 --> 00:30:13,000
Nézzük inkább írja szünet fő.

560
00:30:13,000 --> 00:30:15,000
Más szóval, azt akarom állítani egy úgynevezett töréspont,

561
00:30:15,000 --> 00:30:18,000
amely találóan elnevezett, mert eltörik vagy szünet

562
00:30:18,000 --> 00:30:21,000
végrehajtása a program, hogy az adott helyen.

563
00:30:21,000 --> 00:30:23,000
Fő a neve az én funkció.

564
00:30:23,000 --> 00:30:25,000
Figyeljük meg, hogy GDB elég okos.

565
00:30:25,000 --> 00:30:28,000
Ebből rájött, hogy fő történik kezdeni nagyjából 18 vezetéken

566
00:30:28,000 --> 00:30:32,000
A buggy3.c, majd észre, itt a bal felső sarokban

567
00:30:32,000 --> 00:30:34,000
b + közvetlen közelében 18 vezetéken.

568
00:30:34,000 --> 00:30:38,000
Ez eszembe juttatta, hogy meghatározta a töréspontot sorban 18.

569
00:30:38,000 --> 00:30:42,000
Ez az, amikor azt írja run, megyek futni a programot

570
00:30:42,000 --> 00:30:45,000
addig, amíg eléri, hogy a töréspont,

571
00:30:45,000 --> 00:30:48,000
így a program leáll nekem sorban 18.

572
00:30:48,000 --> 00:30:50,000
Itt vagyunk, fuss.

573
00:30:50,000 --> 00:30:53,000
Semmi sem úgy tűnik, hogy történt, de a felhívás a bal alsó sarokban

574
00:30:53,000 --> 00:30:58,000
kezdő program, buggy3, töréspont 1-fő at buggy3.c 18 vezetéken.

575
00:30:58,000 --> 00:31:00,000
Mit tehetek most?

576
00:31:00,000 --> 00:31:03,000
>> Figyeljük meg tudok kezdeni gépelni dolgokat, mint a nyomtatás,

577
00:31:03,000 --> 00:31:08,000
Nem printf, print x, és most, hogy furcsa.

578
00:31:08,000 --> 00:31:11,000
A $ 1 csak a kíváncsiság, mint látni fogjuk

579
00:31:11,000 --> 00:31:14,000
minden alkalommal, amikor nyomtat valamit, kapsz egy új $ értéket.

580
00:31:14,000 --> 00:31:18,000
Ez így utalja vissza az előző értékeket csak abban az esetben,

581
00:31:18,000 --> 00:31:21,000
de most mi print azt mondja nekem, hogy az x értéke ezen a ponton a történet

582
00:31:21,000 --> 00:31:26,000
látszólag 134514032.

583
00:31:26,000 --> 00:31:29,000
Mi az? Honnan, hogy még ide?

584
00:31:29,000 --> 00:31:31,000
[Hallhatatlan-diák]

585
00:31:31,000 --> 00:31:34,000
Valóban, ez az, amit hívom a szemét érték, és mi már nem beszéltünk még,

586
00:31:34,000 --> 00:31:37,000
de az ok, hogy Ön változók inicializálása

587
00:31:37,000 --> 00:31:40,000
nyilvánvalóan úgy, hogy van néhány érték, amely azt szeretné, hogy van.

588
00:31:40,000 --> 00:31:44,000
De a fogás felidézni, hogy akkor nyilvánítja változókat

589
00:31:44,000 --> 00:31:46,000
mint én egy perccel ezelőtt az én szigma példa

590
00:31:46,000 --> 00:31:48,000
anélkül, hogy azokat egy értéket.

591
00:31:48,000 --> 00:31:50,000
Emlékezzünk, mit tettem ide a szigma.

592
00:31:50,000 --> 00:31:52,000
Kijelentettem n, de mi értéke adtam meg?

593
00:31:52,000 --> 00:31:56,000
Nincs, mert tudtam, hogy a következő néhány sorban

594
00:31:56,000 --> 00:31:59,000
GetInt is gondoskodik a probléma üzembe értékű belsejében n.

595
00:31:59,000 --> 00:32:02,000
>> De ezen a ponton a történet line 11

596
00:32:02,000 --> 00:32:05,000
és a 12-es vonal és a vonal 13 és 14. sor

597
00:32:05,000 --> 00:32:08,000
szerte a több vonalon mi az értéke az n?

598
00:32:08,000 --> 00:32:10,000
A C-ben, csak nem tudom.

599
00:32:10,000 --> 00:32:14,000
Ez általában valamilyen szemét érték, néhány teljesen véletlen számot

600
00:32:14,000 --> 00:32:17,000
ami megmaradt lényegében néhány korábbi funkció

601
00:32:17,000 --> 00:32:21,000
miután futni, így a program fut

602
00:32:21,000 --> 00:32:24,000
Emlékeztetek arra, hogy a funkció lesz a funkció, funkció, funkció.

603
00:32:24,000 --> 00:32:27,000
Mindezen keretek kap fektetni a memóriában, majd ezeket a funkciókat visszatérés,

604
00:32:27,000 --> 00:32:31,000
és mint azt javasoltam a radír a memória végül újra.

605
00:32:31,000 --> 00:32:37,000
Nos, ez csak azért történik, hogy ez a változó x ebben a programban

606
00:32:37,000 --> 00:32:41,000
Úgy tűnik, hogy néhány olyan értéket, mint a szemetet, 134514032

607
00:32:41,000 --> 00:32:44,000
néhány korábbi funkcióját, és nem az egyik, hogy én írtam.

608
00:32:44,000 --> 00:32:47,000
Ez lehet valami, ami ténylegesen az operációs rendszer,

609
00:32:47,000 --> 00:32:49,000
Néhány funkció a motorháztető alatt.

610
00:32:49,000 --> 00:32:52,000
>> Oké, rendben, de hadd most tovább a következő sorra.

611
00:32:52,000 --> 00:32:55,000
Ha azt írja be a "next" én GDB azonnali és én nyomd meg az Entert,

612
00:32:55,000 --> 00:32:58,000
észre, hogy a kiemelése mozog lefelé a vonal 19,

613
00:32:58,000 --> 00:33:01,000
de a logikus következménye, hogy a 18. sor

614
00:33:01,000 --> 00:33:06,000
már befejezte a végrehajtó, így ha újra írja be a "print x"

615
00:33:06,000 --> 00:33:10,000
Azt kell most lásd 1, sőt, tudom.

616
00:33:10,000 --> 00:33:14,000
Ismét a $ cucc egy módja GDB emlékeztetve,

617
00:33:14,000 --> 00:33:17,000
mi a története nyomatok, amit tettél.

618
00:33:17,000 --> 00:33:21,000
Most hadd menjen előre, és nyomtassa ki y, és valóban, y néhány őrült érték is,

619
00:33:21,000 --> 00:33:24,000
de nem nagy ügy, mert a 19 vagyunk arról, hogy rendelje hozzá

620
00:33:24,000 --> 00:33:27,000
a 2 értéket, ezért hadd írja be a "next" újra.

621
00:33:27,000 --> 00:33:29,000
És most mi vagyunk a printf sorban.

622
00:33:29,000 --> 00:33:31,000
Hadd csináljam print x.

623
00:33:31,000 --> 00:33:34,000
Hadd csináljam print y. Őszintén szólva, én egy kicsit fáradt nyomtatási ezt.

624
00:33:34,000 --> 00:33:38,000
Hadd helyett írja "kijelző x" és "y kijelző,"

625
00:33:38,000 --> 00:33:41,000
és most minden alkalommal, amikor írja be a parancsot a jövőben

626
00:33:41,000 --> 00:33:45,000
Én is emlékeztetik mi x és y, mi x és y, mi x és y.

627
00:33:45,000 --> 00:33:48,000
>> Én is, mint félretéve, írja be a "info helyiek."

628
00:33:48,000 --> 00:33:50,000
Info egy speciális parancs.

629
00:33:50,000 --> 00:33:52,000
A helyiek azt jelenti, hogy megmutatja nekem a lokális változók.

630
00:33:52,000 --> 00:33:55,000
Csak abban az esetben elfelejtem, vagy ez egy őrült, bonyolult függvény

631
00:33:55,000 --> 00:33:57,000
hogy én vagy valaki más írta info helyiek fogja mondani, hogy

632
00:33:57,000 --> 00:34:00,000
melyek az összes helyi változót ezen belül a helyi funkció

633
00:34:00,000 --> 00:34:03,000
hogy esetleg érdekel, ha azt szeretné, hogy piszkálni körül.

634
00:34:03,000 --> 00:34:07,000
Most printf körülbelül végrehajtani, úgyhogy hadd menjen előre, és csak a típus "next".

635
00:34:07,000 --> 00:34:10,000
Mert mi vagyunk ebben a környezetben mi valójában nem látta azt

636
00:34:10,000 --> 00:34:14,000
végre itt lent, de észre ez egy kicsit szétroncsolt itt.

637
00:34:14,000 --> 00:34:17,000
De észre, ez felülbírálja a képernyőn van,

638
00:34:17,000 --> 00:34:21,000
így ez nem egy tökéletes program itt, de ez rendben van, mert én mindig piszkálni körül

639
00:34:21,000 --> 00:34:23,000
használatával print, ha akarok.

640
00:34:23,000 --> 00:34:26,000
>> Hadd írja next újra, és most itt az érdekes rész.

641
00:34:26,000 --> 00:34:29,000
Ezen a ponton a történet y értéke 2, és x értéke 1,

642
00:34:29,000 --> 00:34:32,000
ahogy azt itt, és újra,

643
00:34:32,000 --> 00:34:35,000
az oka ez automatikusan megjeleníti most, mert használt a parancs

644
00:34:35,000 --> 00:34:40,000
kijelző x és y kijelző, így a pillanatban írja next

645
00:34:40,000 --> 00:34:43,000
elméletben x és y váljon cserélték.

646
00:34:43,000 --> 00:34:45,000
Most már tudjuk, hogy ez nem lesz a helyzet,

647
00:34:45,000 --> 00:34:49,000
de majd meglátjuk, egy pillanat, hogyan tudunk merülni mélyebbre, hogy kitaláljuk, hogy miért igaz.

648
00:34:49,000 --> 00:34:54,000
Tovább gombra, és sajnos még mindig y 2 és x még mindig 1, és tudom erősíteni annyira.

649
00:34:54,000 --> 00:34:56,000
Print x, print y.

650
00:34:56,000 --> 00:34:59,000
Valóban, nincs csere is történt, úgyhogy kezdjük ezt újra.

651
00:34:59,000 --> 00:35:01,000
Nyilvánvaló, csere van törve.

652
00:35:01,000 --> 00:35:04,000
Nézzük inkább írja be a "run" újra.

653
00:35:04,000 --> 00:35:07,000
Hadd mondjam el, igen, szeretnék újraindítani a kezdetektől, az enter billentyűt.

654
00:35:07,000 --> 00:35:09,000
>> Most én vagyok vissza sorban 18.

655
00:35:09,000 --> 00:35:11,000
Most észre x és y értékek szemét megint.

656
00:35:11,000 --> 00:35:15,000
Következő, next, next, next.

657
00:35:15,000 --> 00:35:17,000
Ha unatkozni Én is csak írja n a következő.

658
00:35:17,000 --> 00:35:21,000
Tudod rövidítéséhez azt a lehető legrövidebb karaktersorozat.

659
00:35:21,000 --> 00:35:23,000
Swap most elromlott.

660
00:35:23,000 --> 00:35:25,000
Nézzük merülés, így ahelyett, hogy gépelés következő,

661
00:35:25,000 --> 00:35:30,000
Most megyek, hogy írja lépést, így az én megerősítéséről belül ez a funkció

662
00:35:30,000 --> 00:35:33,000
annak érdekében, hogy tudok járni rajta, úgyhogy hit lépést, majd adja meg.

663
00:35:33,000 --> 00:35:37,000
Figyeljük meg, hogy a kiemelése ugrik lejjebb az én programban sor 36.

664
00:35:37,000 --> 00:35:39,000
Most mi vagyunk a lokális változók?

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

666
00:35:41,000 --> 00:35:43,000
Semmi, csak még, mert mi már nem jutott, hogy ezt a vonalat,

667
00:35:43,000 --> 00:35:47,000
úgyhogy menjünk előre, és mondja ki a "next".

668
00:35:47,000 --> 00:35:50,000
Most úgy tűnik, hogy tmp, print tmp.

669
00:35:50,000 --> 00:35:52,000
Garbage érték, ugye? Azt hiszem, igen.

670
00:35:52,000 --> 00:35:55,000
Mit szólnál nyomtatása, print b, 1 és 2?

671
00:35:55,000 --> 00:35:58,000
Abban a pillanatban, amint írja next újra

672
00:35:58,000 --> 00:36:02,000
tmp fog tartani az értéke 1, remélhetőleg,

673
00:36:02,000 --> 00:36:05,000
mert tmp fog kell rendelni az értékét.

674
00:36:05,000 --> 00:36:08,000
>> Most nem nyomtat, print b,

675
00:36:08,000 --> 00:36:11,000
de most nyomtatni tmp, és ez valóban 1.

676
00:36:11,000 --> 00:36:14,000
Hadd csinálni. Hadd csinálni.

677
00:36:14,000 --> 00:36:16,000
Már kész a swap funkciót.

678
00:36:16,000 --> 00:36:19,000
Én még mindig a benne lévő sorban 40, úgyhogy hadd nyomtatni,

679
00:36:19,000 --> 00:36:22,000
print b, és nem érdekel, hogy mit tmp van.

680
00:36:22,000 --> 00:36:27,000
Úgy néz ki, csere helyes, amikor a csere a és b.

681
00:36:27,000 --> 00:36:31,000
De ha most írja a következő, én ugorj vissza a vonal 25,

682
00:36:31,000 --> 00:36:34,000
és persze, ha az I. típusú x és y print

683
00:36:34,000 --> 00:36:38,000
ők még mindig változatlan, tehát még nem rögzítették a problémát.

684
00:36:38,000 --> 00:36:41,000
De diagnosztikai Most talán ennek GDB programmal

685
00:36:41,000 --> 00:36:44,000
most már legalább ütött egy lépéssel közelebb a megértés

686
00:36:44,000 --> 00:36:47,000
mi baj, anélkül, hogy szemét a kódot azáltal, hogy a printf itt,

687
00:36:47,000 --> 00:36:50,000
printf itt printf ide, majd fut újra és újra

688
00:36:50,000 --> 00:36:52,000
hogy kitaláljam, mi baj.

689
00:36:52,000 --> 00:36:55,000
>> Én megyek előre, és lépjen ki ebből a teljesen kilép.

690
00:36:55,000 --> 00:36:57,000
Ez lesz majd mondani, hogy "kilép?" Igen.

691
00:36:57,000 --> 00:37:00,000
Most már itt vagyok én normális parancssorba, és én végezzük GDB.

692
00:37:00,000 --> 00:37:03,000
Mint félre, akkor nem kell használni ezt a tui-zászló.

693
00:37:03,000 --> 00:37:07,000
Sőt, ha nem adjuk meg azt kapsz lényegében az alsó felében a képernyőn.

694
00:37:07,000 --> 00:37:11,000
Ha majd írja szünet fő és futtassa

695
00:37:11,000 --> 00:37:15,000
Még mindig fut a program, de mit fog tenni több szövegesen

696
00:37:15,000 --> 00:37:18,000
csak mutasd meg nekem az aktuális sor egyesével.

697
00:37:18,000 --> 00:37:21,000
The-tui, szöveges felhasználói felület,

698
00:37:21,000 --> 00:37:25,000
csak azt mutatja, hogy több, a program egyszerre, ami talán egy kicsit fogalmilag könnyebb.

699
00:37:25,000 --> 00:37:27,000
De valóban, én is csak csináld next, next, next,

700
00:37:27,000 --> 00:37:30,000
és meg fogom látni, egy sort egy időben, és ha szeretné, hogy mi folyik itt

701
00:37:30,000 --> 00:37:35,000
Én típusú listát és látni egy csomó szomszédos vonalak.

702
00:37:35,000 --> 00:37:39,000
>> Van egy videó, hogy már kérte, hogy figyelje a probléma készletek 3

703
00:37:39,000 --> 00:37:43,000
amely Nate kiterjed néhány bonyolult GDB,

704
00:37:43,000 --> 00:37:46,000
és ez az egyik olyan dolog, őszintén szólva, ahol néhány nem triviális százalékos Ön

705
00:37:46,000 --> 00:37:49,000
soha nem fog megérinteni GDB, és hogy lesz egy rossz dolog

706
00:37:49,000 --> 00:37:53,000
mert szó lesz a végén több időt töltenek majd ebben a félévben

707
00:37:53,000 --> 00:37:56,000
kergeti bugs akkor lenne, ha életbe, hogy fél óra / óra

708
00:37:56,000 --> 00:38:00,000
ezen a héten és a jövő tanulás kap kényelmes GDB.

709
00:38:00,000 --> 00:38:02,000
Printf volt a barátja.

710
00:38:02,000 --> 00:38:05,000
GDB kell most a barátod.

711
00:38:05,000 --> 00:38:08,000
>> Bármilyen kérdésre GDB?

712
00:38:08,000 --> 00:38:12,000
És itt egy rövid lista néhány a legerősebb és hasznos parancsokat.

713
00:38:12,000 --> 00:38:15,000
Aha. >> Tud nyomtatni egy string?

714
00:38:15,000 --> 00:38:17,000
Tud nyomtatni egy string? Abszolút.

715
00:38:17,000 --> 00:38:19,000
Nem kell, hogy csak egész számok.

716
00:38:19,000 --> 00:38:22,000
Ha egy változó s string csak típus print s.

717
00:38:22,000 --> 00:38:24,000
Ez megmutatja, hogy mi karakterlánc változó.

718
00:38:24,000 --> 00:38:26,000
[Hallhatatlan-diák]

719
00:38:26,000 --> 00:38:28,000
Ez megadja a cím és a szöveg is.

720
00:38:28,000 --> 00:38:32,000
Ez megmutatja, mindkettő.

721
00:38:32,000 --> 00:38:34,000
És egy utolsó dolog, csak azért, mert ezek jó tudni is.

722
00:38:34,000 --> 00:38:37,000
Visszakövetés és a keret, hadd merüljön ebbe még egyszer utoljára,

723
00:38:37,000 --> 00:38:39,000
pontosan ugyanazt program GDB.

724
00:38:39,000 --> 00:38:44,000
Hadd menjek előre, és futtassa a szöveges felhasználói felület változata,

725
00:38:44,000 --> 00:38:46,000
szünet fő.

726
00:38:46,000 --> 00:38:49,000
Hadd menjek előre, és futtassa újra. Itt vagyok.

727
00:38:49,000 --> 00:38:55,000
Most hadd menjek next, next, next, next, next, step, írja.

728
00:38:55,000 --> 00:39:00,000
>> És most tegyük fel, én vagyok most csere szándékosan, de olyan vagyok, mint: "A fenébe, mi volt az x értéke?"

729
00:39:00,000 --> 00:39:02,000
Nem tudom x többé.

730
00:39:02,000 --> 00:39:05,000
Nem tudom y, mert ők nem hatályát.

731
00:39:05,000 --> 00:39:07,000
Ők nem a kontextusban, de nem probléma.

732
00:39:07,000 --> 00:39:09,000
Én beírhatja backtrace.

733
00:39:09,000 --> 00:39:13,000
Ez azt mutatja meg az összes funkciót, hogy végre ezen a ponton az időben.

734
00:39:13,000 --> 00:39:16,000
Figyelje meg, hogy az egyik az alsó, a fő, vonalak fel a fő

735
00:39:16,000 --> 00:39:18,000
hogy az alján a kép itt.

736
00:39:18,000 --> 00:39:22,000
Az a tény, hogy a swap fölött vonalba swap fölötti a memóriában van,

737
00:39:22,000 --> 00:39:26,000
és ha akarom, hogy újra a fő ideiglenesen tudom mondani, hogy "keretet".

738
00:39:26,000 --> 00:39:30,000
Mi a száma? Main frame # 1.

739
00:39:30,000 --> 00:39:32,000
Én megyek előre, és mondja ki a "keret 1".

740
00:39:32,000 --> 00:39:36,000
>> Most itt vagyok a fő, és én is nyomtathat x, és tudok nyomtatni y,

741
00:39:36,000 --> 00:39:40,000
de nem tudok nyomtatni, vagy b.

742
00:39:40,000 --> 00:39:43,000
De ha azt mondom: "Oké, várj egy percet. Hol volt a csere?"

743
00:39:43,000 --> 00:39:46,000
Hadd menjek előre, és azt mondják: "frame 0".

744
00:39:46,000 --> 00:39:48,000
Most itt vagyok, ahol szeretnék lenni, és mint félre,

745
00:39:48,000 --> 00:39:52,000
van más parancs is, mint ha tényleg kezd unatkozni gépelés next, next, next, next,

746
00:39:52,000 --> 00:39:56,000
Ön általában mondani a dolgokat, mint a "következő 10", és hogy át lehet lépni a következő 10 vonalak.

747
00:39:56,000 --> 00:39:59,000
Azt is írja: "továbbra is", ha tényleg kap elege lépett át rajta.

748
00:39:59,000 --> 00:40:05,000
Tovább fog futni a program, megszakítás nélkül, amíg eléri egy töréspont,

749
00:40:05,000 --> 00:40:07,000
akár a hurok vagy lejjebb a programban.

750
00:40:07,000 --> 00:40:11,000
>> Ebben az esetben továbbra is a végén, és a program kilépett rendesen.

751
00:40:11,000 --> 00:40:13,000
Ez egy divatos módon alsóbbrendű folyamat.

752
00:40:13,000 --> 00:40:16,000
Csak a program kilépett rendesen.

753
00:40:16,000 --> 00:40:24,000
Bővebben az, hogy a videó és a hibakeresés üléseken, hogy jöjjön.

754
00:40:24,000 --> 00:40:26,000
Ez volt egy csomó.

755
00:40:26,000 --> 00:40:35,000
Nézzük mi 5-perces szünet van, és mi vissza a struktúrákat és fájlokat.

756
00:40:35,000 --> 00:40:38,000
>> Ha már lebukott e heti Pset már

757
00:40:38,000 --> 00:40:41,000
tudni fogja, hogy mi használja a forgalmazási kódot,

758
00:40:41,000 --> 00:40:45,000
a forráskódot, hogy mi az, hogy Ön, mint egy kiindulási pont, néhány új technikákat.

759
00:40:45,000 --> 00:40:50,000
Különösen azt be ezt az új kulcsszót hívott struct, a szerkezet,

760
00:40:50,000 --> 00:40:53,000
annak érdekében, hogy mi is létrehozhatunk egyéni változók fajta.

761
00:40:53,000 --> 00:40:57,000
Mi is bevezette a fogalmat fájl I / O, a fájl bemenet és kimenet,

762
00:40:57,000 --> 00:41:00,000
és ez az, hogy ki tudjuk menteni az állam

763
00:41:00,000 --> 00:41:03,000
a Scramble fórumon, hogy egy fájlt a lemezen

764
00:41:03,000 --> 00:41:06,000
úgy, hogy a tanítás ösztöndíjasok és megértem

765
00:41:06,000 --> 00:41:09,000
mi folyik belül a program anélkül, hogy kézzel játszani

766
00:41:09,000 --> 00:41:11,000
tucatnyi játékok Scramble.

767
00:41:11,000 --> 00:41:13,000
Meg tudjuk csinálni ezt jobban automatedly.

768
00:41:13,000 --> 00:41:18,000
>> Ez az elképzelés egy struct old meglehetősen impozáns probléma.

769
00:41:18,000 --> 00:41:21,000
Tegyük fel, hogy szeretnénk végrehajtani néhány program

770
00:41:21,000 --> 00:41:25,000
hogy valahogy nyomon követi információk diákok,

771
00:41:25,000 --> 00:41:28,000
és a diákok lehetnek, például egy azonosító, egy nevet

772
00:41:28,000 --> 00:41:31,000
és egy házat egy olyan helyen, mint a Harvard, így ezek a 3 információkat

773
00:41:31,000 --> 00:41:34,000
akarjuk tartani körül, hadd menjen előre, és kezdjük el beírni a kis program van,

774
00:41:34,000 --> 00:41:38,000
között stdio.h.

775
00:41:38,000 --> 00:41:42,000
Hadd tegyek közé cs50.h.

776
00:41:42,000 --> 00:41:44,000
És akkor kezdődik a fő funkciója.

777
00:41:44,000 --> 00:41:46,000
Én nem zavarja semmilyen parancssori argumentumok,

778
00:41:46,000 --> 00:41:49,000
és itt szeretnék egy diák, így fogom mondani

779
00:41:49,000 --> 00:41:54,000
a hallgató neve, így fogom mondani, hogy "string name".

780
00:41:54,000 --> 00:41:59,000
Akkor fogok mondani, egy diák is van azonosítója, ezért int id,

781
00:41:59,000 --> 00:42:03,000
és a hallgató egy házat, úgyhogy én is akartam mondani "string ház."

782
00:42:03,000 --> 00:42:06,000
Akkor megrendelni ezeket egy kicsit tisztábban, mint ez.

783
00:42:06,000 --> 00:42:11,000
Oké, most már 3 változókat, amelyek képviseletére a tanuló, így a "diák".

784
00:42:11,000 --> 00:42:15,000
>> És most szeretném feltölteni ezeket az értékeket, ezért hadd menjen előre, és mond valamit, mint a

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

786
00:42:18,000 --> 00:42:21,000
Név fog kapni David.

787
00:42:21,000 --> 00:42:24,000
Tegyük fel, hogy házat fog kapni Mather,

788
00:42:24,000 --> 00:42:31,000
majd fogok csinálni valamit önkényesen hasonló printf ("% s,

789
00:42:31,000 --> 00:42:37,000
amelynek ID% d, él% s.

790
00:42:37,000 --> 00:42:41,000
És most, mit szeretnék, hogy csatlakoztassa itt, egyik a másik után?

791
00:42:41,000 --> 00:42:47,000
Név, id, house, return 0.

792
00:42:47,000 --> 00:42:50,000
Oké, ha elszúrtam valahol itt

793
00:42:50,000 --> 00:42:54,000
Azt hiszem, van egy nagyon jó program, amely tárolja az egyik diák.

794
00:42:54,000 --> 00:42:57,000
Persze, ez nem is olyan érdekes. Mit tegyek, ha akarom, hogy 2 diák?

795
00:42:57,000 --> 00:42:59,000
Ez nem nagy ügy. Tudom támogatni 2 fő részére.

796
00:42:59,000 --> 00:43:03,000
Hadd menjek előre, és jelölje ki ezt, és menj le ide,

797
00:43:03,000 --> 00:43:09,000
és azt mondhatja, hogy "id = 456" valaki, mint Rob, aki él Kirkland.

798
00:43:09,000 --> 00:43:12,000
>> Oké, várj, de én nem nevezném ezeket ugyanaz a dolog,

799
00:43:12,000 --> 00:43:15,000
, és úgy néz ki, megyek kell másolni ezt,

800
00:43:15,000 --> 00:43:19,000
ezért hadd mondjam, hogy ezek lesznek Dávid változók,

801
00:43:19,000 --> 00:43:23,000
és hadd kap néhány másolatot ezekről a Rob.

802
00:43:23,000 --> 00:43:27,000
Hívjuk ezeket Rob de ez nem fog menni most

803
00:43:27,000 --> 00:43:33,000
mert már-várj, változtassuk meg engem ID1, NAME1 és house1.

804
00:43:33,000 --> 00:43:35,000
Rob lesz 2, 2.

805
00:43:35,000 --> 00:43:42,000
Van ezen változtatni itt, itt, itt, itt, itt, itt.

806
00:43:42,000 --> 00:43:45,000
Várj, mi van Tommy? Csináljuk ezt újra.

807
00:43:45,000 --> 00:43:49,000
Nyilvánvaló, hogy ha még mindig úgy gondolja, hogy ez egy jó módja ennek, ez nem,

808
00:43:49,000 --> 00:43:52,000
így copy / paste rossz.

809
00:43:52,000 --> 00:43:55,000
De megoldotta ezt egy héttel ezelőtt.

810
00:43:55,000 --> 00:43:59,000
>> Mi volt a megoldás, ha azt akartuk, hogy a több példányban azonos adatokat típus?

811
00:43:59,000 --> 00:44:01,000
[Diákok] A tömb.

812
00:44:01,000 --> 00:44:03,000
Egy tömb, hadd próbálja megtisztítani ezt.

813
00:44:03,000 --> 00:44:07,000
Engedjék meg, hogy néhány helyet magamnak a tetején, és hadd helyette ezt itt.

814
00:44:07,000 --> 00:44:12,000
Hívjuk ezeket az embereket, és helyette fogok mondani, "int ids,"

815
00:44:12,000 --> 00:44:14,000
és én fogom támogatni 3 of us most.

816
00:44:14,000 --> 00:44:18,000
Fogok mondani "string nevek", és én támogatni 3 of us,

817
00:44:18,000 --> 00:44:22,000
majd fogok mondani "string házak", és megyek, hogy támogassák 3 minket.

818
00:44:22,000 --> 00:44:26,000
Most itt van, nem David szerzés saját lokális változók

819
00:44:26,000 --> 00:44:28,000
tudunk megszabadulni e.

820
00:44:28,000 --> 00:44:30,000
Ez jó érzés, hogy mi Tisztítás fel.

821
00:44:30,000 --> 00:44:35,000
Én majd mondja Dávid lesz a [0] és nevek [0]

822
00:44:35,000 --> 00:44:38,000
és házak [0].

823
00:44:38,000 --> 00:44:41,000
Aztán Rob tudunk hasonlóan menteni ezt.

824
00:44:41,000 --> 00:44:46,000
Nézzük, hogy ezt ide, így fog önkényesen lesz ids [1].

825
00:44:46,000 --> 00:44:50,000
Ő lesz a nevek [1],

826
00:44:50,000 --> 00:44:53,000
majd végül házak [1].

827
00:44:53,000 --> 00:44:57,000
>> Még egy kicsit unalmas, és most már, hogy kitaláljuk,

828
00:44:57,000 --> 00:45:03,000
így mondjuk: "names [0], id [0], házak [0]

829
00:45:03,000 --> 00:45:06,000
és menjünk pluralize ezt.

830
00:45:06,000 --> 00:45:09,000
IDS, ids, ids.

831
00:45:09,000 --> 00:45:12,000
És ismét, én csinálom, úgyhogy megint, én már folyamodik copy / paste újra

832
00:45:12,000 --> 00:45:14,000
így esély van egy másik megoldás van.

833
00:45:14,000 --> 00:45:18,000
Én valószínűleg tisztítani ezt fel tovább a hurok, vagy valami ilyesmi,

834
00:45:18,000 --> 00:45:21,000
így rövid, ez egy kicsit jobb, de még mindig úgy érzi, mint

835
00:45:21,000 --> 00:45:24,000
Én igénybe a copy / paste, de ez, azt állítják,

836
00:45:24,000 --> 00:45:27,000
nem igazán alapvetően jó megoldás, mert

837
00:45:27,000 --> 00:45:29,000
mi lenne, ha valamikor úgy döntünk, tudod mit?

838
00:45:29,000 --> 00:45:32,000
Tényleg kellett volna tárolni e-mail címét David és Rob

839
00:45:32,000 --> 00:45:34,000
és mindenki más ebben a programban.

840
00:45:34,000 --> 00:45:36,000
Azt is meg kell tárolni a telefonszámokat.

841
00:45:36,000 --> 00:45:39,000
Azt is meg kellene tárolni segélyhívó telefonszámokat.

842
00:45:39,000 --> 00:45:41,000
Mindannyian ezeket a darabokat az adatokat szeretnénk tárolni,

843
00:45:41,000 --> 00:45:43,000
igen, hogyan megy körülbelül csinálás ez?

844
00:45:43,000 --> 00:45:46,000
>> Ön kijelenti másik tömböt a tetején, és akkor kézzel hozzá

845
00:45:46,000 --> 00:45:49,000
E-mail cím [0], e-mail címe [1]

846
00:45:49,000 --> 00:45:51,000
David és Rob és így tovább.

847
00:45:51,000 --> 00:45:56,000
De tényleg csak egy feltételezés alapjául ez a design

848
00:45:56,000 --> 00:45:59,000
, hogy én vagyok a megtiszteltetés rendszer tudni, hogy

849
00:45:59,000 --> 00:46:03,000
[I] az egyes több tömböt

850
00:46:03,000 --> 00:46:06,000
csak azért történik, hogy utalja az ugyanaz a személy,

851
00:46:06,000 --> 00:46:10,000
így [0] ids a szám 123,

852
00:46:10,000 --> 00:46:13,000
és én fogom feltételezni, hogy a nevek [0]

853
00:46:13,000 --> 00:46:16,000
ugyanaz a személy nevét és házak [0]

854
00:46:16,000 --> 00:46:21,000
ugyanaz a személy házába, és így tovább az összes különböző tömbök, amit létre.

855
00:46:21,000 --> 00:46:24,000
De észre, hogy nincs alapvető kapcsolat

856
00:46:24,000 --> 00:46:27,000
közül 3 db információt, id, név és a ház,

857
00:46:27,000 --> 00:46:32,000
annak ellenére, hogy a gazdálkodó egység próbálunk modell ez a program nem tömbök.

858
00:46:32,000 --> 00:46:35,000
Tömbök csak ezt programozási módja ennek.

859
00:46:35,000 --> 00:46:38,000
Amit igazán akar, hogy a modellt a program egy személy

860
00:46:38,000 --> 00:46:41,000
mint Dávid, az a személy, mint Rob belsejében, amely

861
00:46:41,000 --> 00:46:46,000
vagy kapszulázó a neve és azonosítója, valamint egy házat.

862
00:46:46,000 --> 00:46:49,000
>> Lehet valahogy kifejezni ezt az ötletet a tokozás

863
00:46:49,000 --> 00:46:52,000
amelyben egy személy van egy azonosítója, egy nevet és egy házat

864
00:46:52,000 --> 00:46:55,000
és nem folyamodnak ahhoz, hogy valóban ez a hack, amellyel már csak

865
00:46:55,000 --> 00:46:58,000
bízom benne, hogy valami konzol

866
00:46:58,000 --> 00:47:02,000
utal az azonos emberi szervezet minden, ezeket a különálló tömbök?

867
00:47:02,000 --> 00:47:04,000
Tudjuk ténylegesen ezt.

868
00:47:04,000 --> 00:47:08,000
Hadd menjek a fenti fő most, hadd hozzon létre saját adattípust

869
00:47:08,000 --> 00:47:10,000
az igazán először.

870
00:47:10,000 --> 00:47:14,000
Úgy használta ezt a technikát Scramble,

871
00:47:14,000 --> 00:47:17,000
de itt én megyek előre, és hozzon létre egy adattípus,

872
00:47:17,000 --> 00:47:19,000
és tudod mit, én fogom hívni diák vagy személy,

873
00:47:19,000 --> 00:47:23,000
és én fogom használni typedef az határozza meg a típusát.

874
00:47:23,000 --> 00:47:25,000
Fogom mondani, hogy ez a struktúra,

875
00:47:25,000 --> 00:47:29,000
és akkor ez a szerkezet lesz típusú diák, akkor mondjuk,

876
00:47:29,000 --> 00:47:31,000
annak ellenére, hogy egy kicsit én kelt most nekem.

877
00:47:31,000 --> 00:47:33,000
Azt mondjuk "int id".

878
00:47:33,000 --> 00:47:35,000
Majd mondják, hogy "string name".

879
00:47:35,000 --> 00:47:37,000
Akkor mondjuk "string ház"

880
00:47:37,000 --> 00:47:40,000
így most a végére e néhány sornyi kódot

881
00:47:40,000 --> 00:47:45,000
Imént tanított csenget, hogy létezik

882
00:47:45,000 --> 00:47:49,000
Egy adattípus mellett ints mellett vonósok mellett páros mellett lebeg.

883
00:47:49,000 --> 00:47:54,000
>> Mivel e pillanatban line 11 van, most egy új adattípus nevű diák,

884
00:47:54,000 --> 00:47:58,000
és most kijelentem diák változót bárhol akarok,

885
00:47:58,000 --> 00:48:01,000
hadd Görgessen ide az emberek.

886
00:48:01,000 --> 00:48:05,000
Most már tudom hogy eltűnjön ez, és mehetek vissza David ide,

887
00:48:05,000 --> 00:48:10,000
és az I. Dávid valójában mondani, hogy David,

888
00:48:10,000 --> 00:48:13,000
akkor szó szerint megnevezni a változó után magam,

889
00:48:13,000 --> 00:48:16,000
lesz típusú diák.

890
00:48:16,000 --> 00:48:18,000
Ez tűnhet egy kicsit furcsa, de ez még nem minden, hogy a különböző

891
00:48:18,000 --> 00:48:22,000
a kijelentésen valami, mint egy int vagy egy string vagy egy úszó.

892
00:48:22,000 --> 00:48:24,000
Ez csak azért történik, hogy hívják diák most,

893
00:48:24,000 --> 00:48:28,000
és ha azt akarjuk, hogy valami belül ezt a szerkezetet

894
00:48:28,000 --> 00:48:31,000
Most kell használni egy új darab szintaxis, de ez elég egyértelmű,

895
00:48:31,000 --> 00:48:39,000
david.id = 123, david.name = "David" a tőke-D,

896
00:48:39,000 --> 00:48:42,000
és david.house = "Mather,"

897
00:48:42,000 --> 00:48:46,000
és most hogy eltűnjön ez a cucc itt.

898
00:48:46,000 --> 00:48:51,000
Figyeljük meg mi már most átalakítottuk a programot tényleg sokkal jobb megoldás

899
00:48:51,000 --> 00:48:54,000
az, hogy most a programunk tükrözi a valós világban.

900
00:48:54,000 --> 00:48:57,000
>> Van egy valós világ fogalma egy személy vagy egy diák.

901
00:48:57,000 --> 00:49:02,000
Itt van már a C változat egy személy vagy pontosabban a hallgató.

902
00:49:02,000 --> 00:49:05,000
Belül az adott személy ezek fontos jellemzőit,

903
00:49:05,000 --> 00:49:10,000
ID, név és a ház, így a Rob lényegében válik ugyanaz itt lent,

904
00:49:10,000 --> 00:49:14,000
így diák rob, és most rob.id = 456,

905
00:49:14,000 --> 00:49:17,000
rob.name = "Rob".

906
00:49:17,000 --> 00:49:20,000
Az a tény, hogy a változó neve Rob egyfajta értelmetlen.

907
00:49:20,000 --> 00:49:22,000
Mi volna neveztük x vagy y vagy z.

908
00:49:22,000 --> 00:49:25,000
Csak nevezték el Rob hogy szemantikailag következetes,

909
00:49:25,000 --> 00:49:28,000
de valójában a név belsejében e területen is,

910
00:49:28,000 --> 00:49:30,000
így most van ez.

911
00:49:30,000 --> 00:49:33,000
Ez szintén nem érzi, mint a legjobb design, hogy már nehezen kódolt David.

912
00:49:33,000 --> 00:49:35,000
Már kemény kódolt Rob.

913
00:49:35,000 --> 00:49:39,000
És én még mindig kénytelen néhány példányt be minden alkalommal szeretnék új változókat.

914
00:49:39,000 --> 00:49:43,000
Sőt, azt kell, hogy minden látszólag e változók egy nevet,

915
00:49:43,000 --> 00:49:46,000
bár én sokkal inkább írni ezeket a változókat

916
00:49:46,000 --> 00:49:48,000
 Több általánosságban a diákok.

917
00:49:48,000 --> 00:49:52,000
>> Most már tudjuk egyesíteni az ötlet, hogy már jól működik nálunk

918
00:49:52,000 --> 00:49:56,000
és helyette azt mondja: "Tudod mit, adj egy változó nevezett hallgatók,

919
00:49:56,000 --> 00:50:01,000
és mondjuk meg, hogy legyen méretű, 3 ", így most tudom ezt tovább finomítani,

920
00:50:01,000 --> 00:50:04,000
megszabadulni a kézi bejelentett David,

921
00:50:04,000 --> 00:50:08,000
és én inkább mondani valamit, mint a diákok [0] itt.

922
00:50:08,000 --> 00:50:11,000
Tudok majd mondani, diákok [0] itt,

923
00:50:11,000 --> 00:50:14,000
diákok [0] itt, és így tovább, és én is menni körül

924
00:50:14,000 --> 00:50:16,000
és tisztítsa meg, hogy a fel Rob.

925
00:50:16,000 --> 00:50:19,000
Azt is megy a most talán hozzá egy hurok

926
00:50:19,000 --> 00:50:23,000
és használata, valamint getString getInt hogy ténylegesen kap ezeknek az értékeknek a felhasználó elől.

927
00:50:23,000 --> 00:50:27,000
Tudtam járni hozzá egy állandó, mert ez általában rossz gyakorlat

928
00:50:27,000 --> 00:50:29,000
kemény-kód bizonyos tetszőleges számú, mint 3 itt

929
00:50:29,000 --> 00:50:33,000
és aztán csak ne feledjük, hogy meg kell tenni legfeljebb 3 diák is.

930
00:50:33,000 --> 00:50:36,000
Ez valószínűleg jobb, hogy # define tetején az én fájl

931
00:50:36,000 --> 00:50:40,000
és a tényező, hogy ki, így valóban, hadd menjen előre, és általánosítani ezt.

932
00:50:40,000 --> 00:50:43,000
>> Hadd nyit egy példát, hogy ez napjaink

933
00:50:43,000 --> 00:50:46,000
példák előre, structs1.

934
00:50:46,000 --> 00:50:49,000
Ez egy komplett program, amely a # define ide

935
00:50:49,000 --> 00:50:51,000
és azt mondja, megyünk, hogy a 3 diák alapértelmezés szerint.

936
00:50:51,000 --> 00:50:54,000
Itt vagyok nyilvánító osztály értékű diákok,

937
00:50:54,000 --> 00:50:57,000
így egy osztályteremben a diákok, és most egy hurok

938
00:50:57,000 --> 00:51:00,000
csak azért, hogy a kódot egy kicsit elegáns, népességnövekedés az osztály

939
00:51:00,000 --> 00:51:05,000
a felhasználó bemenet, így navigálhat i = 0-tól akár a diákok, amely 3.

940
00:51:05,000 --> 00:51:07,000
Aztán megkérdezi a felhasználót ez a verzió

941
00:51:07,000 --> 00:51:10,000
 mi a hallgató azonosítóját, és kapok rá getInt.

942
00:51:10,000 --> 00:51:13,000
Mi a hallgató nevét, majd kapok azt getString.

943
00:51:13,000 --> 00:51:15,000
Mi a tanuló háza? Értem azt getString.

944
00:51:15,000 --> 00:51:19,000
És akkor az alján van csak úgy döntött, hogy módosítani

945
00:51:19,000 --> 00:51:22,000
mennyire vagyok nyomtatás ezeket, és hogy ténylegesen használni a hurok,

946
00:51:22,000 --> 00:51:24,000
és aki vagyok nyomtatás?

947
00:51:24,000 --> 00:51:27,000
Az kommentezni vagyok nyomtatás valaki Mather,

948
00:51:27,000 --> 00:51:30,000
és ez annyira Rob és Tommy, és így tovább, valójában Tommy a Mather.

949
00:51:30,000 --> 00:51:34,000
Tommy és David lenne kinyomtatni a jelen ügyben, de hogy van ez működik?

950
00:51:34,000 --> 00:51:40,000
Nem láttuk ezt a funkciót, de hogy a találgatás, hogy mi ez.

951
00:51:40,000 --> 00:51:42,000
Összehasonlítja a szálakat.

952
00:51:42,000 --> 00:51:45,000
>> Ez egy kicsit, nem nyilvánvaló, hogy hogyan viszonyul húrok, mert kiderült, hogy

953
00:51:45,000 --> 00:51:49,000
ha visszatér 0 azt jelenti, hogy a húrok egyenlő.

954
00:51:49,000 --> 00:51:53,000
Ha visszatér a -1 azt jelenti, hogy jön egy betűrendben a másik előtt,

955
00:51:53,000 --> 00:51:57,000
és ha visszatér 1 azt jelenti, hogy a többi szó a betűrendben

956
00:51:57,000 --> 00:52:00,000
még mielőtt a másik, és nézd online, vagy a férfi oldal

957
00:52:00,000 --> 00:52:04,000
pontosan lássák, milyen módon, amely de ez most csinál ez mondja

958
00:52:04,000 --> 00:52:09,000
ha a [i]. house egyenlő: "Mather"

959
00:52:09,000 --> 00:52:13,000
akkor megy előre, és nyomtassa ki így és így van Mather.

960
00:52:13,000 --> 00:52:16,000
De itt van valami, amit még nem látott, és mi jön vissza erre.

961
00:52:16,000 --> 00:52:21,000
Nem emlékszem, hogy valaha ezt minden az én programokat.

962
00:52:21,000 --> 00:52:24,000
Free nyilvánvalóan utal memória, memória felszabadítása,

963
00:52:24,000 --> 00:52:31,000
de mit memória én látszólag felszabadítja e hurok alján ez a program?

964
00:52:31,000 --> 00:52:34,000
Úgy néz ki, én vagyok szabadítva a személy nevét

965
00:52:34,000 --> 00:52:37,000
és az a személy házába, de miért van ez?

966
00:52:37,000 --> 00:52:41,000
>> Kiderült, hogy ezek a hetek, amit használ getString

967
00:52:41,000 --> 00:52:45,000
voltunk ilyen bemutatta egy bug-ba valamennyien a programokat.

968
00:52:45,000 --> 00:52:51,000
GetString by design Memóriát azért, hogy visszatérjen egy string,

969
00:52:51,000 --> 00:52:55,000
mint Dávid, vagy Rob, és akkor majd csinálsz, amit akarsz

970
00:52:55,000 --> 00:52:59,000
azzal a húr a programot, mert mi már fenn a memória az Ön számára.

971
00:52:59,000 --> 00:53:02,000
A probléma az egész idő alatt minden alkalommal, amikor szükséges getString

972
00:53:02,000 --> 00:53:05,000
mi, a szerzői getString, már kérte az operációs rendszer

973
00:53:05,000 --> 00:53:07,000
hogy nekünk egy kis RAM ezt a fonalat.

974
00:53:07,000 --> 00:53:09,000
Adj egy kis RAM ez a következő string.

975
00:53:09,000 --> 00:53:11,000
Adj nekünk néhány RAM ez a következő string.

976
00:53:11,000 --> 00:53:13,000
Amit a programozó, soha nem csinál

977
00:53:13,000 --> 00:53:15,000
ad nekünk, hogy memória vissza,

978
00:53:15,000 --> 00:53:17,000
így e több hétig az összes program, amit írt

979
00:53:17,000 --> 00:53:20,000
volt az úgynevezett memória ugrást, amelyben tartják a

980
00:53:20,000 --> 00:53:24,000
egyre több és több memóriát minden alkalommal, amikor hívás getString, és ez rendben van.

981
00:53:24,000 --> 00:53:27,000
Tudatosan ezt, hogy az első hetekben, mert ez nem olyan érdekes

982
00:53:27,000 --> 00:53:29,000
hogy nem kell aggódnia, ha a string jön.

983
00:53:29,000 --> 00:53:34,000
Minden, amit szeretnénk, az a szó, Rob, hogy jöjjön vissza, amikor a felhasználó a be!

984
00:53:34,000 --> 00:53:38,000
>> De előrelépés most el kell kezdeni, hogy a kifinomultabb erről.

985
00:53:38,000 --> 00:53:42,000
Minden alkalommal, amikor a memóriát, jobb, végül adja vissza.

986
00:53:42,000 --> 00:53:45,000
Ellenkező esetben a valós világban a Mac vagy PC lehet, hogy alkalmanként tapasztalt

987
00:53:45,000 --> 00:53:50,000
tünetek, ha a számítógép szűnnek meg végül

988
00:53:50,000 --> 00:53:54,000
vagy a hülye pörgő strandlabda éppen elfoglaló a számítógép

989
00:53:54,000 --> 00:53:56,000
teljes figyelmet, és nem tudsz csinálni a dolgokat.

990
00:53:56,000 --> 00:54:00,000
Ez azzal magyarázható, hogy tetszőleges számú hibát, de azok között az esetleges hibákat

991
00:54:00,000 --> 00:54:03,000
vannak dolgok, nevezzük memóriavesztés, amellyel valaki, aki azt írta, hogy a szoftver

992
00:54:03,000 --> 00:54:07,000
Ön használ nem emlékszem, hogy szabad memória

993
00:54:07,000 --> 00:54:10,000
, hogy ő kérte a operációs rendszer,

994
00:54:10,000 --> 00:54:14,000
nem használó getString, mert ez egy CS50 dolog, de a hasonló funkciókat

995
00:54:14,000 --> 00:54:16,000
hogy kérje az operációs rendszer a memória.

996
00:54:16,000 --> 00:54:19,000
Ha Ön vagy ők csavart, és valójában soha nem tér vissza, hogy a memória

997
00:54:19,000 --> 00:54:24,000
a tünete, ami lehet, hogy egy program lelassítja és lassítja, és lassítja

998
00:54:24,000 --> 00:54:26,000
ha emlékszel, hogy hívja ingyenes.

999
00:54:26,000 --> 00:54:28,000
>> Majd gyere vissza, mikor és miért neveznétek ingyen,

1000
00:54:28,000 --> 00:54:32,000
de menjünk előre csak a jó intézkedés, és próbálja meg futtatni az adott programot.

1001
00:54:32,000 --> 00:54:35,000
Ezt nevezték structs1 írja.

1002
00:54:35,000 --> 00:54:40,000
Hadd menjek előre, és fuss 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, és látjuk, Dávid a Mather, Tommy a Mather.

1005
00:54:50,000 --> 00:54:53,000
Ez csak egy kis józanság ellenőrzése, hogy a program működik.

1006
00:54:53,000 --> 00:54:56,000
Nos, sajnos, ez a program egy kicsit frusztráló, hogy

1007
00:54:56,000 --> 00:55:00,000
Én minden munkát, nem adtam a 9 különböző vonósok, nyomd meg az Entert,

1008
00:55:00,000 --> 00:55:04,000
azt mondták, aki a Mather, de természetesen tudtam, ki volt Mather már, mert nem adtam meg.

1009
00:55:04,000 --> 00:55:07,000
Ez legalább jó, ha ez a program több, mint egy adatbázis

1010
00:55:07,000 --> 00:55:10,000
és ez tényleg emlékszik, amit már beírt

1011
00:55:10,000 --> 00:55:12,000
így soha többé nem kell ilyen input hallgatói nyilvántartások.

1012
00:55:12,000 --> 00:55:15,000
Lehet, hogy olyan, mint egy registrarial rendszer.

1013
00:55:15,000 --> 00:55:21,000
>> Meg tudjuk csinálni ezt a technikát nevezik fájl I / O, a fájl bemenet és kimenet,

1014
00:55:21,000 --> 00:55:24,000
igen általános megfogalmazásban azt bármikor el szeretnénk olvasni fájlokat írni vagy fájlok

1015
00:55:24,000 --> 00:55:26,000
meg tudod csinálni ezt egy bizonyos funkciók.

1016
00:55:26,000 --> 00:55:29,000
Hadd menjek előre, és nyissa meg ezt a példát structs2.c,

1017
00:55:29,000 --> 00:55:33,000
, amely majdnem azonos, de lássuk, mi most csinál.

1018
00:55:33,000 --> 00:55:36,000
A tetején a fájl Kijelentem, egy osztály a hallgatók.

1019
00:55:36,000 --> 00:55:38,000
Aztán népességnövekedés az osztályt a felhasználó bemenet,

1020
00:55:38,000 --> 00:55:41,000
így azok sornyi kódot pontosan úgy, mint korábban.

1021
00:55:41,000 --> 00:55:45,000
Akkor, ha én itt vagyok görgessen nyomtatni mindenkit, aki a Mather önkényesen, mint korábban,

1022
00:55:45,000 --> 00:55:47,000
de ez egy érdekes újdonság.

1023
00:55:47,000 --> 00:55:51,000
Ezek a vonalak kódot újak, és vezessen be valamit,

1024
00:55:51,000 --> 00:55:55,000
FILE, nagybetűs, és azt * itt is.

1025
00:55:55,000 --> 00:55:58,000
Hadd mozgatni ezt ide, a * ide is.

1026
00:55:58,000 --> 00:56:00,000
>> Ez a funkció még nem látott, fopen,

1027
00:56:00,000 --> 00:56:03,000
de ez azt jelenti fájl nyitva van, úgyhogy átlássa ezeket,

1028
00:56:03,000 --> 00:56:05,000
és ez az, amit mi jön vissza a jövőben psets,

1029
00:56:05,000 --> 00:56:10,000
de ez a vonal itt lényegében megnyit egy fájlt nevű adatbázist,

1030
00:56:10,000 --> 00:56:13,000
és különösen megnyitja azt oly módon, hogy meg tudja csinálni, amit vele?

1031
00:56:13,000 --> 00:56:15,000
[Hallhatatlan-diák]

1032
00:56:15,000 --> 00:56:19,000
Igaz, így a "w" csak azt jelenti, hogy mondja az operációs rendszer

1033
00:56:19,000 --> 00:56:21,000
megnyitni ezt a fájlt oly módon, hogy tudok írni.

1034
00:56:21,000 --> 00:56:23,000
Nem akarom, hogy elolvassa. Nem akarom, hogy csak nézd meg.

1035
00:56:23,000 --> 00:56:26,000
Azt akarom, hogy változtassa meg, és adjunk hozzá cucc esetlegesen rá,

1036
00:56:26,000 --> 00:56:28,000
és a fájl fog hívni adatbázisba.

1037
00:56:28,000 --> 00:56:30,000
Ezt nevezhetnénk semmit.

1038
00:56:30,000 --> 00:56:32,000
Ez lehet database.txt. Ez lehet az. DB.

1039
00:56:32,000 --> 00:56:37,000
Ez lehet egy szó, mint a foo, de önkényesen úgy döntött, hogy a fájl nevét adatbázisban.

1040
00:56:37,000 --> 00:56:42,000
Ez egy kis józanság ellenőrzése, hogy mi jön vissza nagy részletességgel az idő múlásával,

1041
00:56:42,000 --> 00:56:47,000
ha fp, a fájl pointer, nem egyenlő NULL azt jelenti, hogy minden rendben van.

1042
00:56:47,000 --> 00:56:51,000
>> Hosszú történet rövid, funkciók, mint a fopen néha nem.

1043
00:56:51,000 --> 00:56:53,000
Lehet, hogy a fájl nem létezik. Talán elfogyott a lemezterület.

1044
00:56:53,000 --> 00:56:55,000
Lehet, hogy nincs engedélye az adott mappát,

1045
00:56:55,000 --> 00:56:58,000
így ha fopen függvény null valami rossz történt.

1046
00:56:58,000 --> 00:57:02,000
Ezzel szemben, ha fopen nem tér vissza null, minden rendben van

1047
00:57:02,000 --> 00:57:04,000
és én írjuk ezt a fájlt.

1048
00:57:04,000 --> 00:57:06,000
Itt egy új trükk.

1049
00:57:06,000 --> 00:57:08,000
Ez a for ciklus, ami iterációjával az egyes tanítványom,

1050
00:57:08,000 --> 00:57:10,000
és ez úgy néz ki, hasonló ahhoz, amit tettünk korábban,

1051
00:57:10,000 --> 00:57:15,000
de ez a funkció egy unokatestvére printf hívott fprintf a fájl printf,

1052
00:57:15,000 --> 00:57:18,000
, és vegyük észre, hogy ez különbözik csak 2 módon.

1053
00:57:18,000 --> 00:57:20,000
Egyik, hogy kezdődik f helyett p,

1054
00:57:20,000 --> 00:57:23,000
de aztán az első érv nyilvánvalóan mi?

1055
00:57:23,000 --> 00:57:25,000
[Diákok] fájl. >> Ez egy fájlt.

1056
00:57:25,000 --> 00:57:30,000
Ez a dolog az úgynevezett fp, amit majd végül kötekedik eltekintve, amit a fájl pointer van,

1057
00:57:30,000 --> 00:57:35,000
de most fp egyszerűen képviseli a fájlt, amit megnyitott,

1058
00:57:35,000 --> 00:57:41,000
így fprintf itt azt mondja, nyomtassa ki a felhasználói azonosítót a fájlt, hogy ne a képernyőt.

1059
00:57:41,000 --> 00:57:44,000
Nyomtassa ki a felhasználó nevét a fájl, nem a képernyőn,

1060
00:57:44,000 --> 00:57:47,000
a ház a fájlt, nem a képernyőn, majd ide, természetesen,

1061
00:57:47,000 --> 00:57:50,000
zárja be a fájlt, majd itt lent szabad a memóriát.

1062
00:57:50,000 --> 00:57:53,000
>> Az egyetlen különbség a 2-es verziója, és 1-es verzió

1063
00:57:53,000 --> 00:57:58,000
a bevezetése fopen és ez a fájl a *

1064
00:57:58,000 --> 00:58:01,000
és ez a fogalma fprintf, úgyhogy lássuk, mi a végeredmény.

1065
00:58:01,000 --> 00:58:03,000
Hadd menjek be a terminál ablakot.

1066
00:58:03,000 --> 00:58:06,000
Hadd futni structs2 írja.

1067
00:58:06,000 --> 00:58:09,000
Úgy tűnik, minden rendben van. Nézzük ismételni structs2.

1068
00:58:09,000 --> 00:58:15,000
123, David Mather, 456, Rob Kirkland,

1069
00:58:15,000 --> 00:58:19,000
789, Tommy Mather, az enter billentyűt.

1070
00:58:19,000 --> 00:58:23,000
Úgy viselkedett, mintha ugyanaz, de ha most nem ls

1071
00:58:23,000 --> 00:58:28,000
észre, milyen fájl van az összes kódomat, adatbázis,

1072
00:58:28,000 --> 00:58:32,000
úgyhogy nyitni, gedit adatbázis, és nézd meg ezt.

1073
00:58:32,000 --> 00:58:34,000
Ez nem a legszexisebb fájl formátumokat.

1074
00:58:34,000 --> 00:58:38,000
Ez tényleg egy adat sor soronként soronként,

1075
00:58:38,000 --> 00:58:42,000
de azok, akik az Excel vagy CSV fájlokat, vesszővel elválasztott értékek,

1076
00:58:42,000 --> 00:58:47,000
Tudtam biztosan használtam fprintf ehelyett talán ilyet

1077
00:58:47,000 --> 00:58:50,000
így én ténylegesen létrehozni az egyenértékű egy Excel fájl

1078
00:58:50,000 --> 00:58:53,000
elválasztva vesszővel dolgokat, nem csak az új vonalak.

1079
00:58:53,000 --> 00:58:56,000
>> Ebben az esetben, ha én ehelyett vessző helyett új vonalak

1080
00:58:56,000 --> 00:59:01,000
Tudtam szó megnyitni az adatbázis fájlt az Excel, ha helyette tette, hogy néz ki, mint ez.

1081
00:59:01,000 --> 00:59:03,000
Röviden, most, hogy a hatalom, hogy írjon fájlokat

1082
00:59:03,000 --> 00:59:07,000
most már kezdeni tartós adatok tartása körül lemezen

1083
00:59:07,000 --> 00:59:10,000
annak érdekében, hogy tudjuk tartani információkat körül újra és újra.

1084
00:59:10,000 --> 00:59:14,000
Értesítés egy pár más dolog, hogy most már egy kicsit ismerős.

1085
00:59:14,000 --> 00:59:16,000
A tetején C fájl van egy typedef

1086
00:59:16,000 --> 00:59:21,000
mert azt akartuk, hogy hozzon létre egy adattípus, amely egy szót,

1087
00:59:21,000 --> 00:59:25,000
így ez a típus az úgynevezett szó, és ezen belül az e struktúra

1088
00:59:25,000 --> 00:59:27,000
ez egy kicsit szakértő most.

1089
00:59:27,000 --> 00:59:30,000
Miért egy szó alkotja látszólag egy tömb?

1090
00:59:30,000 --> 00:59:33,000
Mi az a szó, csak ösztönösen?

1091
00:59:33,000 --> 00:59:35,000
>> Ez egy sor karakter.

1092
00:59:35,000 --> 00:59:37,000
Ez egy karaktersorozatot háttal hátra.

1093
00:59:37,000 --> 00:59:41,000
LETTERS minden sapkák történik, hogy azt önkényesen mondjuk a maximális hosszt

1094
00:59:41,000 --> 00:59:44,000
minden szót a szótárban, hogy mi használ Scramble.

1095
00:59:44,000 --> 00:59:46,000
Miért van a +1?

1096
00:59:46,000 --> 00:59:48,000
A null karakter.

1097
00:59:48,000 --> 00:59:51,000
Emlékezzünk, amikor megcsináltuk a Bananagrams példában szükség különleges értéket

1098
00:59:51,000 --> 00:59:55,000
végén a szó-ben annak érdekében, hogy követni

1099
00:59:55,000 --> 00:59:59,000
hol szavak ténylegesen véget ért, és a probléma meg előírás szerint

1100
00:59:59,000 --> 01:00:03,000
Itt vagyunk társítani egy adott szót a logikai érték,

1101
01:00:03,000 --> 01:00:05,000
egy zászlót, hogy úgy mondjam, igaz vagy hamis.

1102
01:00:05,000 --> 01:00:09,000
Találtál ezt a szót már, mert rájövünk,

1103
01:00:09,000 --> 01:00:13,000
valóban szükségünk van egy módja annak, emlékezés nem csak egy szó, mi van a Scramble

1104
01:00:13,000 --> 01:00:15,000
de függetlenül attól, hogy az emberi, megtaláltam

1105
01:00:15,000 --> 01:00:20,000
így ha nem talál a szó ", a" nem lehet csak írja be, írja be, az adja meg, az adja meg

1106
01:00:20,000 --> 01:00:23,000
és kap 3 pont, 3 pont, 3 pont, 3 pont.

1107
01:00:23,000 --> 01:00:26,000
Azt akarjuk, hogy képes legyen feketelistára szó beállításával bool

1108
01:00:26,000 --> 01:00:29,000
true ha már megtalálta, és így éppen ezért

1109
01:00:29,000 --> 01:00:31,000
kiöntött azt ezt a struktúrát.

1110
01:00:31,000 --> 01:00:35,000
>> Most, itt lent a tülekedés van ez a másik struct nevű szótárban.

1111
01:00:35,000 --> 01:00:39,000
Hiányában itt a szó typedef mert ebben az esetben

1112
01:00:39,000 --> 01:00:43,000
mi szükség van, hogy magukba az ötlet egy szótár,

1113
01:00:43,000 --> 01:00:46,000
és egy szótár tartalmaz egy csomó szó,

1114
01:00:46,000 --> 01:00:49,000
szerint közvetlenül ezt a tömböt, és hány ilyen szavak vannak?

1115
01:00:49,000 --> 01:00:51,000
Nos, bármi ez a változó nevű Méret mondja.

1116
01:00:51,000 --> 01:00:53,000
De csak kell egy szótár.

1117
01:00:53,000 --> 01:00:55,000
Nem kell egy adattípust nevű szótárban.

1118
01:00:55,000 --> 01:00:58,000
Csak kell egy közülük, így kiderül, a C

1119
01:00:58,000 --> 01:01:03,000
hogy ha nem mondom typedef, struct mondod, majd belül a kapcsos zárójelek

1120
01:01:03,000 --> 01:01:05,000
tegye a változókat, akkor tegye a nevet.

1121
01:01:05,000 --> 01:01:09,000
Ez nyilvánító egy változót nevű szótár

1122
01:01:09,000 --> 01:01:11,000
úgy néz ki, mint ez.

1123
01:01:11,000 --> 01:01:16,000
Ezzel szemben, ezek a sorok létrehozása újrahasználható adatszerkezet nevezett Szó

1124
01:01:16,000 --> 01:01:19,000
hozhat létre több példányt, mint hoztunk létre

1125
01:01:19,000 --> 01:01:22,000
több példányban versenyző.

1126
01:01:22,000 --> 01:01:24,000
>> Mit jelent ez végső soron lehetővé teszi számunkra, mit tegyek?

1127
01:01:24,000 --> 01:01:30,000
Hadd menjek vissza, mondjuk, egy egyszerűbb példa egyszerűbb alkalommal,

1128
01:01:30,000 --> 01:01:34,000
és hadd nyitni, mondjuk, compare1.c.

1129
01:01:34,000 --> 01:01:38,000
A probléma itt kéznél van, hogy ténylegesen héjúak vissza

1130
01:01:38,000 --> 01:01:41,000
a réteg egy string, és kezdje levette ezeket a képzési kerekek

1131
01:01:41,000 --> 01:01:44,000
mert kiderül, hogy egy string egész idő

1132
01:01:44,000 --> 01:01:47,000
olyan megígértük az 1. hét tényleg csak egy becenevet,

1133
01:01:47,000 --> 01:01:51,000
szinonimájaként a CS50 könyvtár valamit, ami úgy néz ki, egy kicsit rejtélyes,

1134
01:01:51,000 --> 01:01:53,000
char *, és láttuk ezt a csillag előtt.

1135
01:01:53,000 --> 01:01:55,000
Láttuk azt az összefüggésben fájlokat.

1136
01:01:55,000 --> 01:01:59,000
>> Nézzük most már értem, miért voltunk bujkál ezt a részletet egy ideje most.

1137
01:01:59,000 --> 01:02:02,000
Itt van egy nevű fájlt compare1.c,

1138
01:02:02,000 --> 01:02:07,000
és ez nyilvánvalóan felkéri a felhasználót a 2 szalagot, s és t,

1139
01:02:07,000 --> 01:02:11,000
és akkor megpróbálja összehasonlítani a húrok egyenlőség sorban 26,

1140
01:02:11,000 --> 01:02:14,000
és ha ők egyenlő azt mondja: "Te gépelt ugyanaz a dolog"

1141
01:02:14,000 --> 01:02:17,000
és ha ők nem egyenlő azt mondja: "Te gépelt különböző dolog."

1142
01:02:17,000 --> 01:02:19,000
Hadd menjek előre, és futtassa ezt a programot.

1143
01:02:19,000 --> 01:02:23,000
Hadd menjek az én forrás könyvtárába, hogy a compare1. Az összeállított rendben.

1144
01:02:23,000 --> 01:02:25,000
Hadd futni compare1.

1145
01:02:25,000 --> 01:02:27,000
Én nagyítás, az enter billentyűt.

1146
01:02:27,000 --> 01:02:29,000
Mondj valamit. HELLO.

1147
01:02:29,000 --> 01:02:32,000
Azt mondom valami újra. HELLO.

1148
01:02:32,000 --> 01:02:34,000
Én biztosan nem írja különböző dolog.

1149
01:02:34,000 --> 01:02:37,000
>> Hadd próbáljam meg újra. BYE BYE.

1150
01:02:37,000 --> 01:02:40,000
Határozottan nem a különböző, így mi folyik itt?

1151
01:02:40,000 --> 01:02:44,000
Nos, mi is valójában az összehasonlított sorban 26?

1152
01:02:44,000 --> 01:02:46,000
[Hallhatatlan-diák]

1153
01:02:46,000 --> 01:02:49,000
Igen, így kiderül, hogy egy string, adattípus, egyfajta fehér hazugság.

1154
01:02:49,000 --> 01:02:53,000
Egy karakterlánc egy char *, de mi egy char *?

1155
01:02:53,000 --> 01:02:56,000
A char *, mint mondják, egy mutató,

1156
01:02:56,000 --> 01:03:00,000
és a mutató ténylegesen a címet,

1157
01:03:00,000 --> 01:03:05,000
összeg memóriabeli helyét, és ha történetesen beírt a szót, mint HELLO,

1158
01:03:05,000 --> 01:03:08,000
visszahívja a korábbi viták húrok

1159
01:03:08,000 --> 01:03:16,000
ez olyan, mint a szó HELLO.

1160
01:03:16,000 --> 01:03:19,000
Ne feledje, hogy a szó, mint a HELLO leírható

1161
01:03:19,000 --> 01:03:22,000
mint egy sor karakter, mint ez

1162
01:03:22,000 --> 01:03:25,000
, majd egy különleges karakter a végén hívott a null karakter,

1163
01:03:25,000 --> 01:03:27,000
mint a \ jelöli.

1164
01:03:27,000 --> 01:03:29,000
Milyen valójában egy string?

1165
01:03:29,000 --> 01:03:32,000
Vegyük észre, hogy ez a többszörös darabokat memória,

1166
01:03:32,000 --> 01:03:36,000
és valóban, a vége csak ismertté, miután megnézi az egész szöveg

1167
01:03:36,000 --> 01:03:38,000
keresi a különleges null karaktert.

1168
01:03:38,000 --> 01:03:41,000
De ha ez egy darab memória a számítógép memóriájából,

1169
01:03:41,000 --> 01:03:44,000
mondjuk önkényesen azt mondják, hogy ez a szöveg csak most szerencsés,

1170
01:03:44,000 --> 01:03:47,000
És van elhelyezni a legelején a számítógép RAM.

1171
01:03:47,000 --> 01:03:54,000
Ez bájt 0, 1, 2, 3, 4, 5, 6 ...

1172
01:03:54,000 --> 01:04:02,000
>> Amikor azt mondom, valami ilyesmit getString és én húr s = getString

1173
01:04:02,000 --> 01:04:04,000
mi valóban a vissza?

1174
01:04:04,000 --> 01:04:08,000
Ezen az elmúlt néhány hét, mi valóban a tárolt s

1175
01:04:08,000 --> 01:04:13,000
Nem ez a karakterlánc önmagában, de ebben az esetben mi is tárolják,

1176
01:04:13,000 --> 01:04:18,000
a 0, mert mi getString valójában nem csinál

1177
01:04:18,000 --> 01:04:20,000
A nem fizikailag vissza string.

1178
01:04:20,000 --> 01:04:22,000
Ez még csak nem is igazán konceptuális értelemben.

1179
01:04:22,000 --> 01:04:24,000
Mit csinál visszatérés egy szám.

1180
01:04:24,000 --> 01:04:28,000
Ez a szám a címe HELLO a memóriában,

1181
01:04:28,000 --> 01:04:32,000
és string s aztán, ha húzza vissza ezt a réteget, húr nem igazán létezik.

1182
01:04:32,000 --> 01:04:35,000
Ez csak egy egyszerűsítés CS50 könyvtárban.

1183
01:04:35,000 --> 01:04:38,000
>> Ez valóban egy úgynevezett char *.

1184
01:04:38,000 --> 01:04:41,000
Char van értelme, mert mi az a szó, mint a HELLO!

1185
01:04:41,000 --> 01:04:44,000
Nos, ez egy sor karakter, egy sor karakter.

1186
01:04:44,000 --> 01:04:47,000
Char *: a címét egy karaktert,

1187
01:04:47,000 --> 01:04:50,000
tehát mit is jelent, hogy visszatérjen egy string?

1188
01:04:50,000 --> 01:04:53,000
Egy szép, egyszerű módot visszatérés egy string

1189
01:04:53,000 --> 01:04:57,000
inkább, mint megpróbálja kitalálni, hogyan térjen vissza 5 vagy 6 különböző bytes

1190
01:04:57,000 --> 01:05:01,000
hadd vissza a címet, amely byte?

1191
01:05:01,000 --> 01:05:03,000
Az első.

1192
01:05:03,000 --> 01:05:06,000
Más szóval, hadd adjak a címét egy karaktert a memóriában.

1193
01:05:06,000 --> 01:05:10,000
Ez az, amit char * képviseli a címe egyetlen karaktert a memóriában.

1194
01:05:10,000 --> 01:05:12,000
Hívja a változó s.

1195
01:05:12,000 --> 01:05:15,000
Tárolja s az adott címet, amit én mondtam önkényesen 0,

1196
01:05:15,000 --> 01:05:19,000
csak azért, hogy a dolgok egyszerű, de a valóságban ez általában egy nagyobb számot.

1197
01:05:19,000 --> 01:05:21,000
>> Várj egy percet.

1198
01:05:21,000 --> 01:05:23,000
Ha csak ad nekem a címét az első karakter, hogyan tudom, mi a címe

1199
01:05:23,000 --> 01:05:25,000
A második karakter, a harmadik, a negyedik és az ötödik?

1200
01:05:25,000 --> 01:05:27,000
[Hallhatatlan-diák]

1201
01:05:27,000 --> 01:05:31,000
Csak tudja, hol a vége a húr útján ez a praktikus trükköt,

1202
01:05:31,000 --> 01:05:35,000
így ha használja valami ilyesmit printf, milyen printf szó szerint veszi az érvet,

1203
01:05:35,000 --> 01:05:39,000
emlékeztetni arra, hogy használja ezt a% s placeholder, majd adja át a

1204
01:05:39,000 --> 01:05:41,000
változó, ami tárolja a string.

1205
01:05:41,000 --> 01:05:47,000
Amit igazán halad a címe az első karakter, amely string.

1206
01:05:47,000 --> 01:05:50,000
Printf akkor használ a hurok vagy a while ciklus, amikor megkapta ezt a címet,

1207
01:05:50,000 --> 01:05:53,000
Például, 0, hadd tegye ezt most,

1208
01:05:53,000 --> 01:06:02,000
printf ("% s \ n", s);

1209
01:06:02,000 --> 01:06:07,000
Amikor hívom printf ("% s \ n", s), amit én igazán nyújt printf

1210
01:06:07,000 --> 01:06:13,000
a cím első karaktere s, ami ebben az esetben tetszőleges H.

1211
01:06:13,000 --> 01:06:16,000
>> Hogyan printf tudja, pontosan mi jelenik meg a képernyőn?

1212
01:06:16,000 --> 01:06:19,000
Az a személy, aki végre printf végre egy while vagy for ciklus

1213
01:06:19,000 --> 01:06:23,000
azt mondja ez karakter megegyezik a speciális null karakter?

1214
01:06:23,000 --> 01:06:25,000
Ha nem, akkor nyomtassa ki. Mit szólsz ehhez?

1215
01:06:25,000 --> 01:06:28,000
Ha nem nyomtassa ki, nyomtassa ki, nyomtassa ki, nyomtassa ki.

1216
01:06:28,000 --> 01:06:32,000
Oh, ez egy különleges. Állítsa le a nyomtatást, és térjen vissza a felhasználónak.

1217
01:06:32,000 --> 01:06:35,000
És ez szó szerint minden, ami történt a motorháztető alatt,

1218
01:06:35,000 --> 01:06:38,000
és ez sokat megemészteni az első nap egy osztály,

1219
01:06:38,000 --> 01:06:43,000
de most ez tényleg az építőköve minden megértés

1220
01:06:43,000 --> 01:06:46,000
ez folyik belül a számítógép memóriájában,

1221
01:06:46,000 --> 01:06:49,000
és végül mi kötekedik ezt leszámítva egy kis segítség

1222
01:06:49,000 --> 01:06:51,000
az egyik barátunk a Stanford.

1223
01:06:51,000 --> 01:06:56,000
>> Professor Nick Parlante Stanford tette ezt a csodálatos képsor

1224
01:06:56,000 --> 01:06:58,000
mindenféle nyelven bevezetett

1225
01:06:58,000 --> 01:07:00,000
ez a kis Claymation karaktert Muci.

1226
01:07:00,000 --> 01:07:03,000
A hang fogsz hallani néhány 2. settenkedik sajtóbemutató

1227
01:07:03,000 --> 01:07:05,000
az, hogy a Stanford professzora, és kapsz

1228
01:07:05,000 --> 01:07:07,000
csak 5 vagy 6 másodperc e most,

1229
01:07:07,000 --> 01:07:09,000
de ez a megjegyzés, amely fogunk kötni ma

1230
01:07:09,000 --> 01:07:11,000
és kezdődik szerdán.

1231
01:07:11,000 --> 01:07:15,000
Adok Pointer Fun Muci, az előnézet.

1232
01:07:15,000 --> 01:07:18,000
[♪ ♪ Music] [Professor Parlante] Hey, Muci.

1233
01:07:18,000 --> 01:07:21,000
Kelj fel. Itt az ideje a mutató fun.

1234
01:07:21,000 --> 01:07:24,000
[Muci] Mi ez? Tudjon meg többet a mutatók?

1235
01:07:24,000 --> 01:07:26,000
Oh, nagyszerű!

1236
01:07:26,000 --> 01:07:29,000
>> Fogjuk látni szerdán.

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]