1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Týden 4]

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

3
00:00:05,000 --> 00:00:08,000
[To je CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> Dobře, to je CS50, a to je začátek 4. týdnu

5
00:00:12,000 --> 00:00:16,000
a to je jeden z nejpomaleji možných algoritmů třídění.

6
00:00:16,000 --> 00:00:19,000
Který z nich je to, že jsme právě shlédli tam?

7
00:00:19,000 --> 00:00:24,000
To bylo bublina řazení, aby velké O (n ^ 2) + součet,

8
00:00:24,000 --> 00:00:28,000
a opravdu nejsme jediní, kdo v tomto světě zřejmě vědí,

9
00:00:28,000 --> 00:00:30,000
co bublina sort nebo jeho hrací čas.

10
00:00:30,000 --> 00:00:33,000
Opravdu, to byl rozhovor s Ericem Schmidtem z Google

11
00:00:33,000 --> 00:00:45,000
a bývalý senátor Barack Obama jen před několika lety.

12
00:00:45,000 --> 00:00:48,000
>> Nyní, senátor, jsi tady na Google,

13
00:00:48,000 --> 00:00:54,000
a jsem rád, že předsednictví jako pohovoru.

14
00:00:54,000 --> 00:00:58,000
Nyní, je těžké dostat práci jako prezident, a ty jdeš přes nástrahami teď.

15
00:00:58,000 --> 00:01:00,000
Je také těžké získat práci na Google.

16
00:01:00,000 --> 00:01:05,000
Máme otázky, a žádáme naše kandidáty otázky,

17
00:01:05,000 --> 00:01:10,000
a tohle je od Larry Schwimmer.

18
00:01:10,000 --> 00:01:14,000
Vy myslíte, že si dělám legraci? Je to přímo tady.

19
00:01:14,000 --> 00:01:18,000
Jaká je nejúčinnější způsob, jak třídit milion 32-bit celé číslo?

20
00:01:18,000 --> 00:01:21,000
[Smích]

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

22
00:01:24,000 --> 00:01:26,000
Je mi to líto. >> Ne, ne, ne, ne.

23
00:01:26,000 --> 00:01:34,000
Myslím, že bublina druh by špatný způsob, jak jít.

24
00:01:34,000 --> 00:01:39,000
>> Pojď, který mu řekl, toto?

25
00:01:39,000 --> 00:01:43,000
Minulý týden jsme připomenout si pauzu od kódu, alespoň na jeden den,

26
00:01:43,000 --> 00:01:46,000
a začal se zaměřením na některé vyšší úrovni myšlenek a řešení problémů obecně

27
00:01:46,000 --> 00:01:49,000
v rámci vyhledávání a řazení,

28
00:01:49,000 --> 00:01:53,000
a jsme zavedli něco, co jsme neměli Slap tento název minulý týden,

29
00:01:53,000 --> 00:01:56,000
ale asymptotická notace, Big O, Big Omega,

30
00:01:56,000 --> 00:02:00,000
a někdy Big Theta zápis, a ty byly jednoduchý způsob

31
00:02:00,000 --> 00:02:02,000
popsat čas běhu algoritmů,

32
00:02:02,000 --> 00:02:05,000
jak dlouho to trvá, než algoritmus spustit.

33
00:02:05,000 --> 00:02:08,000
>> A vy si možná vzpomenou, že jsi mluvil o době chodu z hlediska velikosti

34
00:02:08,000 --> 00:02:11,000
vstupu, který jsme obvykle nazýváme n, bez ohledu na problém může být,

35
00:02:11,000 --> 00:02:13,000
, kde n je počet osob v místnosti,

36
00:02:13,000 --> 00:02:17,000
počet stránek v telefonním seznamu, a začali jsme psát věci

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

38
00:02:21,000 --> 00:02:24,000
a to i když matematika nebyla úplně fungovat tak dokonale

39
00:02:24,000 --> 00:02:28,000
a to bylo n ² - n / 2 nebo něco takového

40
00:02:28,000 --> 00:02:31,000
bychom místo toho jen zahodit některé z nižších řádů,

41
00:02:31,000 --> 00:02:34,000
a motivace je, že opravdu chceme

42
00:02:34,000 --> 00:02:37,000
druh objektivního způsobu hodnocení

43
00:02:37,000 --> 00:02:39,000
výkon programů nebo výkon algoritmů

44
00:02:39,000 --> 00:02:42,000
že na konci dne nemá nic společného, ​​například,

45
00:02:42,000 --> 00:02:45,000
s rychlosti vašeho počítače dnes.

46
00:02:45,000 --> 00:02:47,000
>> Například, pokud se rozhodnete bubliny třídění,

47
00:02:47,000 --> 00:02:50,000
nebo se rozhodnete sloučit řazení nebo výběr druhu na dnešním počítači,

48
00:02:50,000 --> 00:02:53,000
2 GHz počítač, a spustit jej,

49
00:02:53,000 --> 00:02:56,000
a to trvá určitý počet sekund, příští rok je tu 3 GHz

50
00:02:56,000 --> 00:02:59,000
nebo 4 GHz počítač, a ty by se pak tvrdit, že "Wow, můj algoritmus

51
00:02:59,000 --> 00:03:03,000
je nyní dvakrát tak rychle, "když ve skutečnosti to zjevně není tento případ.

52
00:03:03,000 --> 00:03:06,000
Je to jen hardware dostal rychleji, ale váš počítač

53
00:03:06,000 --> 00:03:10,000
není, a tak jsme opravdu chcete vyhodit věci, jako je

54
00:03:10,000 --> 00:03:13,000
násobky 2 nebo násobky 3, pokud jde o popis

55
00:03:13,000 --> 00:03:17,000
jak rychle nebo jak pomalu algoritmus je a opravdu soustředit jen

56
00:03:17,000 --> 00:03:20,000
na n nebo nějaký faktor této smlouvy,

57
00:03:20,000 --> 00:03:24,000
část výkonu jeho jako v případě druhů z minulého týdne.

58
00:03:24,000 --> 00:03:27,000
A připomínají, že s pomocí druhu korespondence

59
00:03:27,000 --> 00:03:31,000
jsme byli schopni udělat mnohem lépe, než bublina řadit a výběru seřadit

60
00:03:31,000 --> 00:03:33,000
a dokonce i vkládání sort.

61
00:03:33,000 --> 00:03:36,000
>> Máme se na n log n, a znovu,

62
00:03:36,000 --> 00:03:39,000
Připomínám, že log n obecně se odkazuje na něco, co roste

63
00:03:39,000 --> 00:03:43,000
pomaleji pak n, tak n log n dosud byla dobrá

64
00:03:43,000 --> 00:03:45,000
protože to bylo menší, než ² n.

65
00:03:45,000 --> 00:03:47,000
Ale k dosažení n log n s řadit slučovací

66
00:03:47,000 --> 00:03:51,000
co bylo základní zárodek myšlenky, že jsme museli využít

67
00:03:51,000 --> 00:03:54,000
že jsme také zadlužuje zpátky v týdnu 0?

68
00:03:54,000 --> 00:03:58,000
Jak jsme řešit problém řazení chytře s řadit slučovací?

69
00:03:58,000 --> 00:04:04,000
Jaký byl klíčový vhled, snad?

70
00:04:04,000 --> 00:04:07,000
Každý, kdo vůbec.

71
00:04:07,000 --> 00:04:09,000
Dobře, pojďme o krok zpět.

72
00:04:09,000 --> 00:04:11,000
Popište sloučit druh vlastními slovy.

73
00:04:11,000 --> 00:04:15,000
Jak to funguje?

74
00:04:15,000 --> 00:04:17,000
Dobře, budeme veslovat zpátky týdenních 0.

75
00:04:17,000 --> 00:04:19,000
Dobře, jo.

76
00:04:19,000 --> 00:04:22,000
[Neslyšitelné-student]

77
00:04:22,000 --> 00:04:26,000
Dobře, dobře, tak jsme se rozdělili pole čísel do 2 kusy.

78
00:04:26,000 --> 00:04:29,000
Jsme seřazeny každý z těchto kusů, a pak jsme sloučili je,

79
00:04:29,000 --> 00:04:33,000
a my jsme viděli tuto myšlenku před braní problém, který je takhle velký

80
00:04:33,000 --> 00:04:36,000
a sekání je, jak se na problém, který je to velké nebo to velké.

81
00:04:36,000 --> 00:04:38,000
>> Připomeňme telefonního seznamu příklad.

82
00:04:38,000 --> 00:04:42,000
Vzpomeňte si na vlastní algoritmus počítání od týdny,

83
00:04:42,000 --> 00:04:45,000
tak sloučit řadit byl shrnut v tomto pseudokódu zde.

84
00:04:45,000 --> 00:04:48,000
Když jste stejně n prvků, nejprve to byl zdravý rozum zkontrolovat.

85
00:04:48,000 --> 00:04:51,000
Pokud n <2, pak nedělají vůbec nic

86
00:04:51,000 --> 00:04:55,000
protože pokud n <2, pak n je zřejmě 0 nebo 1,

87
00:04:55,000 --> 00:04:57,000
a tak pokud je to buď 0 nebo 1 nic vyřešit.

88
00:04:57,000 --> 00:04:59,000
To je vše.

89
00:04:59,000 --> 00:05:01,000
Váš seznam je již triviálně seřazen.

90
00:05:01,000 --> 00:05:04,000
Ale jinak, pokud máte 2 nebo více prvků jít dopředu a rozdělit je

91
00:05:04,000 --> 00:05:06,000
do 2 poloviny, levou a pravou.

92
00:05:06,000 --> 00:05:09,000
Seřadit každé z těchto polovin, a pak sloučit seřazené poloviny.

93
00:05:09,000 --> 00:05:13,000
Ale problém je, že na první pohled to pocit, jako bychom to plavit.

94
00:05:13,000 --> 00:05:17,000
To je kruhová definice v tom, že pokud jsem vás požádal, abyste seřadit tyto n prvků

95
00:05:17,000 --> 00:05:22,000
a vy mi říkáte, "Dobře, fajn, budeme třídit ty n / 2 a ty n / 2 prvků,"

96
00:05:22,000 --> 00:05:27,000
pak moje další otázka bude "Fajn, jak si setřídit n / 2 prvků?"

97
00:05:27,000 --> 00:05:30,000
>> Ale protože struktury tohoto programu,

98
00:05:30,000 --> 00:05:33,000
protože tam je tento referenční případ, abych tak řekl,

99
00:05:33,000 --> 00:05:39,000
tento zvláštní případ, který říká, že pokud je n <nějakou pevnou hodnotu, jako je 2 návratu ihned.

100
00:05:39,000 --> 00:05:42,000
Neodpovídejte se stejným kruhovou odpověď.

101
00:05:42,000 --> 00:05:46,000
Tento proces, bude tento cyklová nakonec skončí.

102
00:05:46,000 --> 00:05:50,000
Když se tě zeptám "Jak tyto n prvky," a vy říkáte, "Fine, třídit tyto n / 2,"

103
00:05:50,000 --> 00:05:53,000
pak řekneš: "Dobře, trochu to n / 4, n / 8, n/16,"

104
00:05:53,000 --> 00:05:56,000
nakonec budete dělit dost velký počet

105
00:05:56,000 --> 00:05:59,000
že budete mít jen 1 prvek doleva, na kterém místě si můžete říct,

106
00:05:59,000 --> 00:06:02,000
"Tady, tady je seřazena jeden prvek."

107
00:06:02,000 --> 00:06:06,000
Pak lesk tohoto algoritmu tady je odvozena od skutečnosti

108
00:06:06,000 --> 00:06:09,000
, že jakmile budete mít všechny tyto jednotlivě tříděné seznamy,

109
00:06:09,000 --> 00:06:12,000
z nichž všechny jsou velikosti 1, což se zdá být zbytečné,

110
00:06:12,000 --> 00:06:15,000
jakmile začnete sloučení a sloučení

111
00:06:15,000 --> 00:06:19,000
si vybudovat konečně jako Rob dělal ve videu konečně jsou seřazena seznam.

112
00:06:19,000 --> 00:06:22,000
>> Ale tato myšlenka sahá daleko za hranice třídění.

113
00:06:22,000 --> 00:06:26,000
Tam je tento nápad zakotven v tomto programu známého jako rekurze,

114
00:06:26,000 --> 00:06:29,000
nápad, kterým jste program,

115
00:06:29,000 --> 00:06:32,000
a vyřešit nějaký problém si říkáš,

116
00:06:32,000 --> 00:06:36,000
nebo dát do souvislosti programovacích jazyků, které jsou funkce,

117
00:06:36,000 --> 00:06:39,000
a za účelem vyřešení problému, můžete funkce říkáš

118
00:06:39,000 --> 00:06:42,000
znovu a znovu a znovu, ale funkce

119
00:06:42,000 --> 00:06:44,000
nelze volat sami nekonečně mnohokrát.

120
00:06:44,000 --> 00:06:47,000
Nakonec budete muset dna, abych tak řekl,

121
00:06:47,000 --> 00:06:49,000
a máte nějaké pevně základní podmínku, která říká, že

122
00:06:49,000 --> 00:06:53,000
V tomto bodě přestat říkat si tak, aby celý proces

123
00:06:53,000 --> 00:06:56,000
Nakonec se ve skutečnosti zastavit.

124
00:06:56,000 --> 00:06:58,000
Co to vlastně znamená, aby recurse?

125
00:06:58,000 --> 00:07:01,000
>> Pojďme se podívat, jestli můžeme udělat jednoduchý, triviální příklad, řekněme,

126
00:07:01,000 --> 00:07:03,000
3 osoby se mnou tady na jevišti, když někdo je pohodlné.

127
00:07:03,000 --> 00:07:06,000
1, pojď nahoru, 2 a 3.

128
00:07:06,000 --> 00:07:09,000
Pokud 3 chtít přijít sem.

129
00:07:09,000 --> 00:07:12,000
Pokud chcete postavit hned vedle mě tady v řadě, předpokládám, že problém na dosah ruky

130
00:07:12,000 --> 00:07:15,000
je velmi triviální spočítat počet lidí, kteří jsou zde.

131
00:07:15,000 --> 00:07:18,000
Ale upřímně řečeno, jsem unavená ze všech těchto počítání příkladů.

132
00:07:18,000 --> 00:07:21,000
To bude nějakou dobu trvat, 1, 2, a tečka, tečka, tečka.

133
00:07:21,000 --> 00:07:23,000
Bude to trvat věčně.

134
00:07:23,000 --> 00:07:25,000
Já bych raději punt tento problém zcela pomocí-Jak se jmenujete?

135
00:07:25,000 --> 00:07:27,000
Sara. >> Sara, v pořádku.

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

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

138
00:07:31,000 --> 00:07:34,000
Právě teď jsem se ptal někdo

139
00:07:34,000 --> 00:07:37,000
kolik lidí je na této scéně, a já nemám ponětí.

140
00:07:37,000 --> 00:07:40,000
To je opravdu dlouhý seznam, a tak místo toho budu dělat tento trik.

141
00:07:40,000 --> 00:07:43,000
Jdu se zeptat na osobu vedle mě dělat většinu práce,

142
00:07:43,000 --> 00:07:46,000
a jakmile se provádí dělá většinu práce

143
00:07:46,000 --> 00:07:49,000
Budu dělat co nejmenší množství práce je možné, a stačí přidat 1

144
00:07:49,000 --> 00:07:51,000
na jakoukoli její odpověď je, tak je to tady.

145
00:07:51,000 --> 00:07:54,000
Byl jsem požádán, kolik lidí je na jevišti.

146
00:07:54,000 --> 00:07:57,000
Kolik lidí je na jevišti vlevo z vás?

147
00:07:57,000 --> 00:08:00,000
Ze mě zbylo? >> Dobře, ale nebudou podvádět.

148
00:08:00,000 --> 00:08:04,000
To je dobře, to je pravda, ale pokud chceme, aby i nadále tuto logiku

149
00:08:04,000 --> 00:08:08,000
předpokládejme, že si podobně chcete punt tento problém na levé straně vás,

150
00:08:08,000 --> 00:08:11,000
takže spíše než odpovědi přímo do toho pusťte a jen projít do minusu.

151
00:08:11,000 --> 00:08:14,000
Ach, kolik lidí je na levé straně mě?

152
00:08:14,000 --> 00:08:16,000
Jak mnoho lidí jsou umístěny na levé?

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

154
00:08:18,000 --> 00:08:27,000
[Smích]

155
00:08:27,000 --> 00:08:30,000
Dobře, tak 0, takže to, co teď Willy udělal

156
00:08:30,000 --> 00:08:33,000
je, že jste se vrátil vaši odpověď tímto směrem říká 0.

157
00:08:33,000 --> 00:08:36,000
Nyní, co byste měli dělat? >> 1.

158
00:08:36,000 --> 00:08:39,000
Dobře, takže jste 1, takže si řekl, "Dobře, budu přidávat 1

159
00:08:39,000 --> 00:08:41,000
na jakoukoli Willyho hrabě, "tak 1 + 0.

160
00:08:41,000 --> 00:08:43,000
Nyní jste 1 tak, aby vaše odpověď na pravé straně je nyní-

161
00:08:43,000 --> 00:08:45,000
1. >> A já bych být 2.

162
00:08:45,000 --> 00:08:48,000
Dobré, takže bereš předchozí odpověď 1,

163
00:08:48,000 --> 00:08:51,000
přidání minimální množství práce, kterou chcete udělat, což je +1.

164
00:08:51,000 --> 00:08:55,000
Nyní máte 2, a potom mi podat které hodnota?

165
00:08:55,000 --> 00:08:57,000
3, myslím, promiň, 2.

166
00:08:57,000 --> 00:08:59,000
Dobré.

167
00:08:59,000 --> 00:09:02,000
>> No, měli jsme 0 vlevo.

168
00:09:02,000 --> 00:09:05,000
Pak jsme měli 1, a pak přidáme 2,

169
00:09:05,000 --> 00:09:07,000
a teď jsi podal mi číslo 2,

170
00:09:07,000 --> 00:09:10,000
a tak jsem řekl, v pořádku, 1, 3.

171
00:09:10,000 --> 00:09:13,000
Tam je opravdu 3 lidé stojící vedle mě na této scéně,

172
00:09:13,000 --> 00:09:16,000
takže můžeme zřejmě udělal velmi lineárně,

173
00:09:16,000 --> 00:09:19,000
velmi v módě zřejmé, ale co jsme opravdu?

174
00:09:19,000 --> 00:09:21,000
Vzali jsme si problém velikosti 3 původně.

175
00:09:21,000 --> 00:09:24,000
Pak jsme roztřídili do problému velikosti 2,

176
00:09:24,000 --> 00:09:27,000
pak problém velikosti 1, a nakonec referenční případ

177
00:09:27,000 --> 00:09:29,000
Bylo to opravdu, oh, tam nikdo není,

178
00:09:29,000 --> 00:09:33,000
na kterém místě Willy vrátil účinně pevně odpověď několikrát,

179
00:09:33,000 --> 00:09:36,000
a druhý byl pak bublal vzhůru, bublal vzhůru, bublalo up,

180
00:09:36,000 --> 00:09:39,000
a pak přidáním do tohoto jednoho dodatečného 1

181
00:09:39,000 --> 00:09:41,000
Vytvořili jsme tuto základní myšlenku rekurze.

182
00:09:41,000 --> 00:09:44,000
>> Nyní, v tomto případě je to opravdu vyřešit problém

183
00:09:44,000 --> 00:09:46,000
jakékoli účinněji než jsme viděli doposud.

184
00:09:46,000 --> 00:09:48,000
Ale přemýšlet o algoritmech jsme udělali na jevišti tak daleko.

185
00:09:48,000 --> 00:09:51,000
Měli jsme 8 kusů papíru na tabuli,

186
00:09:51,000 --> 00:09:55,000
na videu, kdy Sean hledal číslo 7, a co udělal opravdu?

187
00:09:55,000 --> 00:09:58,000
No, on to neudělal nějaký druh rozděl a panuj.

188
00:09:58,000 --> 00:10:01,000
Neudělal jakékoliv rekurze.

189
00:10:01,000 --> 00:10:03,000
Spíše to právě udělal tento lineární algoritmus.

190
00:10:03,000 --> 00:10:07,000
Ale když jsme zavedli myšlenku seřazena čísel na jevišti žít minulý týden

191
00:10:07,000 --> 00:10:09,000
pak jsme měli tento instinkt jít do středu,

192
00:10:09,000 --> 00:10:13,000
na kterém místě jsme měli menší seznam velikosti 4 nebo jiném seznamu velikosti 4,

193
00:10:13,000 --> 00:10:17,000
a pak jsme měli přesně stejný problém, tak jsme opakovali, opakoval, opakoval.

194
00:10:17,000 --> 00:10:19,000
Jinými slovy, recursed.

195
00:10:19,000 --> 00:10:24,000
Děkuji moc se do našeho 3 dobrovolníků zde pro demonstraci rekurze s námi.

196
00:10:24,000 --> 00:10:28,000
>> Pojďme se podívat, jestli nemůžeme to teď trochu konkrétnější,

197
00:10:28,000 --> 00:10:30,000
řeší problém, který jsme opět mohli dělat docela snadno,

198
00:10:30,000 --> 00:10:34,000
ale budeme používat jako odrazový můstek k provádění tohoto základní myšlenku.

199
00:10:34,000 --> 00:10:37,000
Pokud chci spočítat součty spoustu čísel,

200
00:10:37,000 --> 00:10:39,000
například, jestliže si projít v počtu 3,

201
00:10:39,000 --> 00:10:42,000
Chci, aby vám hodnotu sigma 3,

202
00:10:42,000 --> 00:10:46,000
takže součet 3 + 2 + 1 + 0.

203
00:10:46,000 --> 00:10:48,000
Chci se dostat zpět odpověď 6,

204
00:10:48,000 --> 00:10:51,000
takže budeme provádět tuto sigma funkci, to shrnutí funkce

205
00:10:51,000 --> 00:10:54,000
že opět bere na vstupu, a potom vrátí shrnutí

206
00:10:54,000 --> 00:10:57,000
z tohoto počtu celou cestu až na 0.

207
00:10:57,000 --> 00:10:59,000
Mohli bychom to hezké jednoduše, že?

208
00:10:59,000 --> 00:11:01,000
Mohli bychom to udělat s nějakým druhem smyčky struktury,

209
00:11:01,000 --> 00:11:04,000
tak nechte mě jít dopředu a dostat to začalo.

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

211
00:11:07,000 --> 00:11:09,000
Dovolte mi, abych se sám do hlavní pracovat s tady.

212
00:11:09,000 --> 00:11:12,000
Pojďme uložit jako sigma.c.

213
00:11:12,000 --> 00:11:14,000
Pak jsem jít sem, a budu deklarovat int n,

214
00:11:14,000 --> 00:11:18,000
a já budu dělat následující, zatímco uživatel nespolupracuje.

215
00:11:18,000 --> 00:11:22,000
Zatímco uživatel mi nedala kladné číslo

216
00:11:22,000 --> 00:11:26,000
nech mě jít napřed a přiměli je pro n = GetInt,

217
00:11:26,000 --> 00:11:28,000
a dovolte mi, abych jim nějaké instrukce o tom, co dělat,

218
00:11:28,000 --> 00:11:33,000
takže printf ("Positive integer prosím").

219
00:11:33,000 --> 00:11:39,000
Jen něco relativně jednoduchého, jako to tak, že v době, kdy jsme narazili řádek 14

220
00:11:39,000 --> 00:11:42,000
nyní máme kladné číslo pravděpodobně v n.

221
00:11:42,000 --> 00:11:44,000
>> Nyní se pojďme udělat něco s tím.

222
00:11:44,000 --> 00:11:50,000
Nech mě jít dopředu a počítat součty, takže int sum = sigma (n).

223
00:11:50,000 --> 00:11:54,000
Sigma je jen shrnutí, takže jsem jen psát to v milovník způsobem.

224
00:11:54,000 --> 00:11:56,000
Budeme prostě říkat sigma tam.

225
00:11:56,000 --> 00:11:58,000
To je částka, a teď jdu vytisknout výsledek,

226
00:11:58,000 --> 00:12:08,000
printf ("Součet je% d, \ n", sum).

227
00:12:08,000 --> 00:12:11,000
A pak se vrátím 0 pro správnou míru.

228
00:12:11,000 --> 00:12:15,000
Udělali jsme všechno, co tento program vyžaduje kromě zajímavé části,

229
00:12:15,000 --> 00:12:18,000
který je skutečně realizovat sigma funkci.

230
00:12:18,000 --> 00:12:22,000
>> Nechte mě jít sem dolů až na dno, a dovolte mi, abych určil funkci sigma.

231
00:12:22,000 --> 00:12:26,000
Má to vzít proměnnou, která je typu integer,

232
00:12:26,000 --> 00:12:30,000
a jaká data typu nechci vrátit pravděpodobně z sigma?

233
00:12:30,000 --> 00:12:34,000
Int, protože chci, aby to tak, aby odpovídala mé očekávání na lince 15.

234
00:12:34,000 --> 00:12:37,000
V tu nechte mě jít dopředu a provedení tohoto

235
00:12:37,000 --> 00:12:41,000
v docela přímočaře.

236
00:12:41,000 --> 00:12:45,000
>> Pojďme dál a říct, int sum = 0,

237
00:12:45,000 --> 00:12:47,000
a teď jdu mít málo pro smyčce zde

238
00:12:47,000 --> 00:12:50,000
že se to říct něco takového,

239
00:12:50,000 --> 00:13:01,000
for (int i = 0; I <= číslo; i + +) součet + = i.

240
00:13:01,000 --> 00:13:05,000
A pak budu vracet částku.

241
00:13:05,000 --> 00:13:07,000
Jsem mohl provádět to v mnoha způsoby.

242
00:13:07,000 --> 00:13:09,000
Mohl jsem použil while.

243
00:13:09,000 --> 00:13:11,000
Mohl jsem přeskočil pomocí součtu proměnné, jestli jsem opravdu chtěl,

244
00:13:11,000 --> 00:13:15,000
ale v krátké, jen musíme funkci, že když jsem neměl flákat prohlašuje součet je 0.

245
00:13:15,000 --> 00:13:18,000
Pak se opakuje z 0 na nahoru přes čísla,

246
00:13:18,000 --> 00:13:23,000
a na každé iteraci je dodává, že aktuální hodnotu součtu a vrátí součet.

247
00:13:23,000 --> 00:13:25,000
>> Nyní je tu mírné optimalizace zde.

248
00:13:25,000 --> 00:13:29,000
To je pravděpodobně zbytečná krok, ale budiž. To je v pořádku pro tuto chvíli.

249
00:13:29,000 --> 00:13:32,000
Jsme je alespoň důkladné a bude 0 celou cestu nahoru.

250
00:13:32,000 --> 00:13:34,000
Není příliš tvrdý a velice jednoduché,

251
00:13:34,000 --> 00:13:37,000
ale ukazuje se, že s touto funkcí sigma máme stejnou možnost

252
00:13:37,000 --> 00:13:39,000
jako jsme to udělali tady na jevišti.

253
00:13:39,000 --> 00:13:42,000
Na jevišti jsme právě počítal, kolik lidí bylo vedle mě,

254
00:13:42,000 --> 00:13:47,000
ale pokud bychom chtěli spočítat 3 + 2 + 1

255
00:13:47,000 --> 00:13:51,000
na až do 0 bychom mohli podobně punt na funkci

256
00:13:51,000 --> 00:13:55,000
že budu místo toho popisovat jako rekurzivní.

257
00:13:55,000 --> 00:13:57,000
Zde pojďme se rychle zdravý rozum zkontrolovat a ujistěte se, že jsem to neudělal flákat.

258
00:13:57,000 --> 00:14:00,000
>> Vím, že je tu alespoň jedna věc v tomto programu, které jsem udělal špatně.

259
00:14:00,000 --> 00:14:04,000
Když jsem narazila zadejte budu se dostat jakýkoliv druh na mě ječet?

260
00:14:04,000 --> 00:14:06,000
Co budu se křičel na o?

261
00:14:06,000 --> 00:14:11,000
Jo, zapomněl jsem prototyp, takže jsem pomocí funkce nazývá sigma on-line 15,

262
00:14:11,000 --> 00:14:16,000
ale to není prohlášen až řádku 22, tak jsem možná aktivně jít sem

263
00:14:16,000 --> 00:14:22,000
a prohlásit prototyp, a řeknu int sigma (int number), a to je vše.

264
00:14:22,000 --> 00:14:24,000
Je prováděna na dně.

265
00:14:24,000 --> 00:14:27,000
>> Nebo jiný způsob, jak bych mohl vyřešit tento problém,

266
00:14:27,000 --> 00:14:30,000
Mohl bych funkci přesunout tam, což není špatné,

267
00:14:30,000 --> 00:14:32,000
ale aspoň, když jsou vaše programy začnou se dlouho, upřímně řečeno,

268
00:14:32,000 --> 00:14:35,000
Myslím, že je to nějaké hodnoty vždy s hlavním nahoře

269
00:14:35,000 --> 00:14:38,000
takže ve čtenáři může otevřít soubor a pak okamžitě vidět

270
00:14:38,000 --> 00:14:40,000
co program dělá, aniž by museli hledat přes něj

271
00:14:40,000 --> 00:14:42,000
hledá pro tuto hlavní funkci.

272
00:14:42,000 --> 00:14:49,000
Pojďme dolů do mého okna terminálu zde, zkuste dělat sigma sigma dělat,

273
00:14:49,000 --> 00:14:51,000
a já jsem podělal tady taky.

274
00:14:51,000 --> 00:14:55,000
Implicitní prohlášení o funkce GetInt znamená, že jsem zapomněl na to, co jiného?

275
00:14:55,000 --> 00:14:57,000
[Neslyšitelné-student]

276
00:14:57,000 --> 00:15:00,000
Dobré, tak zřejmě častý omyl, takže pojďme dát této události zde,

277
00:15:00,000 --> 00:15:04,000
cs50.h, a teď se vraťme k mému terminálovém okně.

278
00:15:04,000 --> 00:15:08,000
>> Budu vymazat obrazovku, a já znovu spusťte, aby sigma.

279
00:15:08,000 --> 00:15:11,000
Zdá se, že se sestavují. Dovolte mi, abych nyní spustit sigma.

280
00:15:11,000 --> 00:15:15,000
Budu zadejte číslo 3, a já jsem si 6, takže není přísné kontroly,

281
00:15:15,000 --> 00:15:18,000
ale alespoň se zdá, že funguje na první pohled, ale nyní pojďme to rip sebe,

282
00:15:18,000 --> 00:15:21,000
a pojďme skutečně využívají myšlenku rekurze, znovu,

283
00:15:21,000 --> 00:15:24,000
ve velmi jednoduchém kontextu tak, aby za pár týdnů

284
00:15:24,000 --> 00:15:27,000
když začneme zkoumat milovník datových struktur, než pole

285
00:15:27,000 --> 00:15:30,000
máme další nástroj v toolkitu, se kterým se

286
00:15:30,000 --> 00:15:33,000
manipulovat tyto datové struktury jak uvidíme.

287
00:15:33,000 --> 00:15:36,000
To je iterativní přístup, loop-založený přístup.

288
00:15:36,000 --> 00:15:39,000
>> Dovolte mi, abych místo toho teď udělat.

289
00:15:39,000 --> 00:15:44,000
Dovolte mi, abych místo toho řekl, že součtem počtů

290
00:15:44,000 --> 00:15:48,000
dolů k 0, je opravdu to samé jako

291
00:15:48,000 --> 00:15:53,000
Číslo + sigma (číslo - 1).

292
00:15:53,000 --> 00:15:57,000
Jinými slovy, stejně jako na stupně I punted se každý z lidí vedle mne,

293
00:15:57,000 --> 00:16:00,000
a podle pořadí držel plavit až jsme konečně svého dna na Willyho,

294
00:16:00,000 --> 00:16:03,000
kdo měl vrátit pevně odpověď jako 0.

295
00:16:03,000 --> 00:16:07,000
Tady jsme podobně plavit na sigma

296
00:16:07,000 --> 00:16:10,000
stejná funkce jako bylo původně volal, ale klíčový vhled zde

297
00:16:10,000 --> 00:16:12,000
je to, že nejsme volat sigma identicky.

298
00:16:12,000 --> 00:16:14,000
Jsme neprochází v n.

299
00:16:14,000 --> 00:16:17,000
Jsme jednoznačně prochází v řadě - 1,

300
00:16:17,000 --> 00:16:20,000
tak o něco menší problém, o něco menší problém.

301
00:16:20,000 --> 00:16:23,000
>> Bohužel, to není tak úplně řešení dosud, a než jsme se opravit

302
00:16:23,000 --> 00:16:26,000
Co by mohlo být skákat tak, jak zřejmé, na některé z vás

303
00:16:26,000 --> 00:16:28,000
nech mě jít napřed a znovu dělat.

304
00:16:28,000 --> 00:16:30,000
Zdá se, že sestavit v pořádku.

305
00:16:30,000 --> 00:16:32,000
Dovolte mi, abych znovu spustit sigma s 6.

306
00:16:32,000 --> 00:16:37,000
Jejda, dovolte mi, abych znovu spusťte sigma s 6.

307
00:16:37,000 --> 00:16:42,000
Viděli jsme to předtím, byť náhodně poslední době také.

308
00:16:42,000 --> 00:16:48,000
Proč jsem si tento tajemnou segmentation fault? Jo.

309
00:16:48,000 --> 00:16:50,000
[Neslyšitelné-student]

310
00:16:50,000 --> 00:16:53,000
Není base-case, a konkrétněji, co se asi stalo?

311
00:16:53,000 --> 00:16:58,000
To je příznakem jaké chování?

312
00:16:58,000 --> 00:17:00,000
Řekni to trochu hlasitěji.

313
00:17:00,000 --> 00:17:02,000
[Neslyšitelné-student]

314
00:17:02,000 --> 00:17:05,000
Je to nekonečná smyčka efektivně, a problém s nekonečnými smyčkami

315
00:17:05,000 --> 00:17:08,000
když zahrnují rekurzi v tomto případě, funkce volat sebe,

316
00:17:08,000 --> 00:17:10,000
co se stane pokaždé, když zavolat funkci?

317
00:17:10,000 --> 00:17:13,000
No, myslím, že zpět k tomu, jak je stanoveno v paměti v počítači.

318
00:17:13,000 --> 00:17:16,000
Řekli jsme, že je to kus paměti tzv. stack, který je na dně,

319
00:17:16,000 --> 00:17:19,000
a pokaždé, když budete volat funkce trochu více paměti dostane dal

320
00:17:19,000 --> 00:17:24,000
na tzv. zásobníku obsahujícího tuto funkci je lokální proměnné nebo parametry,

321
00:17:24,000 --> 00:17:27,000
takže pokud sigma volá sigma sigma volání volání sigma

322
00:17:27,000 --> 00:17:29,000
 vyzývá sigma, kde tento příběh skončí?

323
00:17:29,000 --> 00:17:31,000
>> No, to nakonec překročení celková částka

324
00:17:31,000 --> 00:17:33,000
paměti, že máte k dispozici k počítači.

325
00:17:33,000 --> 00:17:37,000
Můžete obsadit segment, který jste měl zůstat uvnitř,

326
00:17:37,000 --> 00:17:40,000
a stáhni segmentation fault, core dumpingové,

327
00:17:40,000 --> 00:17:43,000
a co core dumpingové znamená, že teď máte soubor s názvem core

328
00:17:43,000 --> 00:17:46,000
což je soubor obsahující nul a jedniček

329
00:17:46,000 --> 00:17:49,000
že skutečně v budoucnu bude diagnosticky užitečné.

330
00:17:49,000 --> 00:17:52,000
Pokud to není zřejmé na vás, kde se vaše chyba je

331
00:17:52,000 --> 00:17:54,000
můžete skutečně udělat trochu forenzní analýzy, abych tak řekl,

332
00:17:54,000 --> 00:17:58,000
na tento soubor core dump, která je opět jen celá parta nul a jedniček

333
00:17:58,000 --> 00:18:02,000
které v podstatě představuje stav vašeho programu do paměti

334
00:18:02,000 --> 00:18:05,000
v okamžiku, kdy se zřítil tímto způsobem.

335
00:18:05,000 --> 00:18:11,000
>> Oprava je, že nemůžeme jen tak slepě vrátit sigma,

336
00:18:11,000 --> 00:18:14,000
počet + Sigma poněkud menší problém.

337
00:18:14,000 --> 00:18:16,000
Musíme mít nějaký základní věci tady,

338
00:18:16,000 --> 00:18:19,000
a co by referenční případ, pravděpodobně?

339
00:18:19,000 --> 00:18:22,000
[Neslyšitelné-student]

340
00:18:22,000 --> 00:18:25,000
Dobře, tak dlouho, dokud je číslo kladné bychom se měli skutečně vrátí to,

341
00:18:25,000 --> 00:18:29,000
nebo jinak řečeno, pokud je číslo, řekněme, <= k 0

342
00:18:29,000 --> 00:18:32,000
Víš co, já půjdu napřed a vrátit 0,

343
00:18:32,000 --> 00:18:36,000
podobně jako Willy udělal, a jiný, budu pokračovat

344
00:18:36,000 --> 00:18:41,000
a vrátit to, takže to není, že mnohem kratší

345
00:18:41,000 --> 00:18:44,000
než iterativní verze, které jsme šlehačkou jako první pomocí smyčky for,

346
00:18:44,000 --> 00:18:48,000
ale všimněte si, že je to druh elegance k ní.

347
00:18:48,000 --> 00:18:51,000
Namísto návratu nějaké číslo a provedení všech těchto matematiku

348
00:18:51,000 --> 00:18:54,000
a přidáním věci s lokálními proměnnými

349
00:18:54,000 --> 00:18:57,000
jste místo toho řekl: "Dobře, pokud je to super jednoduchý problém,

350
00:18:57,000 --> 00:19:01,000
jako je číslo <0, dovolte mi, abych se ihned vrátit 0. "

351
00:19:01,000 --> 00:19:03,000
>> Nebudeme se obtěžovat podporu záporná čísla,

352
00:19:03,000 --> 00:19:05,000
takže budu pevný kód hodnotu 0.

353
00:19:05,000 --> 00:19:08,000
Ale jinak, realizovat tuto myšlenku sčítání

354
00:19:08,000 --> 00:19:11,000
všechny z těchto čísel dohromady můžete účinně vzít malý kousek

355
00:19:11,000 --> 00:19:14,000
z problému, stejně jako jsme to udělali tady na jevišti,

356
00:19:14,000 --> 00:19:18,000
pak pramice zbytek problému na další osoby,

357
00:19:18,000 --> 00:19:20,000
, ale v tomto případě, že další osoba sami.

358
00:19:20,000 --> 00:19:22,000
Je to stejně pojmenované funkce.

359
00:19:22,000 --> 00:19:25,000
Jen projít to menší a menší a menší problém pokaždé,

360
00:19:25,000 --> 00:19:28,000
a i když jsme se zcela formalizované věci v kódu zde

361
00:19:28,000 --> 00:19:33,000
To je přesně to, co se děje v týdnu 0 se v telefonním seznamu.

362
00:19:33,000 --> 00:19:36,000
To je přesně to, co se děje v posledních týdnech se Seanem

363
00:19:36,000 --> 00:19:39,000
a s našimi ukázkami vyhledávání čísel.

364
00:19:39,000 --> 00:19:42,000
Trvá to nějaký problém a dělení to znovu a znovu.

365
00:19:42,000 --> 00:19:44,000
>> Jinými slovy, existuje způsob, jak teď překládání

366
00:19:44,000 --> 00:19:47,000
tento reálný svět konstrukt, to vyšší úroveň konstrukt

367
00:19:47,000 --> 00:19:51,000
z rozděl a panuj a dělat něco znovu a znovu

368
00:19:51,000 --> 00:19:56,000
v kódu, takže to je něco, co budeme vidět znovu v průběhu času.

369
00:19:56,000 --> 00:20:00,000
Nyní, stejně jako stranou, pokud jste nový rekurze, měli byste alespoň chápu

370
00:20:00,000 --> 00:20:02,000
proč je to legrační.

371
00:20:02,000 --> 00:20:05,000
Chystám se jít na google.com,

372
00:20:05,000 --> 00:20:17,000
a budu hledat několik tipů a triků na rekurze, zadejte.

373
00:20:17,000 --> 00:20:21,000
Řekněte osoby vedle vás, jestli se nesměje právě teď.

374
00:20:21,000 --> 00:20:23,000
Měli jste na mysli rekurzi?

375
00:20:23,000 --> 00:20:25,000
Měli jste na mysli-ah, tam jdeme.

376
00:20:25,000 --> 00:20:28,000
Dobře, teď to zbytek každého.

377
00:20:28,000 --> 00:20:30,000
Trochu Velikonoční vajíčko vložené někde v Google.

378
00:20:30,000 --> 00:20:33,000
Jak stranou, jeden z článků my jsme dali na hřišti internetových stránkách

379
00:20:33,000 --> 00:20:36,000
pro dnešek je jen tato síť různých algoritmů třídění,

380
00:20:36,000 --> 00:20:39,000
z nichž některé jsme se podívali na minulý týden, ale to, co je hezké o této vizualizace

381
00:20:39,000 --> 00:20:43,000
jak jste se snaží zabalit svou mysl kolem různých věcí souvisejících s algoritmy

382
00:20:43,000 --> 00:20:46,000
víte, že můžete velmi snadno nyní začít s různými typy vstupů.

383
00:20:46,000 --> 00:20:50,000
Vstupy všechny zvrátit, vstupy většinou jsou seřazena, vstupy náhodné a tak dále.

384
00:20:50,000 --> 00:20:53,000
Pokud se pokusíte znovu, rozlišit tyto věci ve vaší mysli

385
00:20:53,000 --> 00:20:57,000
uvědomit, že tato URL na hřišti stránkách na přednášky stránce

386
00:20:57,000 --> 00:21:00,000
vám mohou pomoci důvodem přes některé z nich.

387
00:21:00,000 --> 00:21:05,000
>> Dnes jsme se konečně dostat k řešení tohoto problému z chvíli zpět,

388
00:21:05,000 --> 00:21:08,000
který byl, že tato odkládací funkce prostě nefunguje,

389
00:21:08,000 --> 00:21:12,000
a to, co bylo zásadní problém s touto funkcí swapu,

390
00:21:12,000 --> 00:21:15,000
cílem bylo opět vyměnit hodnotu zde a zde

391
00:21:15,000 --> 00:21:17,000
takové, že se tak stane?

392
00:21:17,000 --> 00:21:20,000
To nebylo ve skutečnosti fungovat. Proč?

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

394
00:21:22,000 --> 00:21:28,000
[Neslyšitelné-student]

395
00:21:28,000 --> 00:21:31,000
Přesně, vysvětlení pro tento bugginess

396
00:21:31,000 --> 00:21:34,000
prostě bylo proto, že když budete volat funkce v C

397
00:21:34,000 --> 00:21:38,000
a ty funkce trvat argumenty, jako a, b zde,

398
00:21:38,000 --> 00:21:42,000
jste kolemjdoucí v kopiích jakoukoli hodnotu jste poskytování této funkci.

399
00:21:42,000 --> 00:21:46,000
Nejste poskytuje původní hodnoty sami,

400
00:21:46,000 --> 00:21:49,000
takže viděl v kontextu buggyc,

401
00:21:49,000 --> 00:21:52,000
buggy3.c, který vypadal trochu něco takového.

402
00:21:52,000 --> 00:21:57,000
>> Připomeňme si, že jsme měli x a y inicializována na 1 a 2, resp.

403
00:21:57,000 --> 00:21:59,000
Pak jsme vytisknout to, co oni byli.

404
00:21:59,000 --> 00:22:03,000
Pak jsem tvrdil, že jsem byl vyměňovat je voláním swap x, y.

405
00:22:03,000 --> 00:22:06,000
Ale problém byl, že odkládání pracoval,

406
00:22:06,000 --> 00:22:10,000
ale pouze v rozsahu swapu fungovat sám.

407
00:22:10,000 --> 00:22:13,000
Jakmile jsme narazili řádek 40 těmto vyměnili hodnoty

408
00:22:13,000 --> 00:22:16,000
byly vyhozeny, a tak nic

409
00:22:16,000 --> 00:22:21,000
v původní funkce byla hlavní vlastně nezměnil,

410
00:22:21,000 --> 00:22:26,000
takže pokud si myslíte, že tehdy, co to vypadá, pokud jde o naší paměti

411
00:22:26,000 --> 00:22:29,000
v případě, že levá strana desky představuje-

412
00:22:29,000 --> 00:22:33,000
a já budu dělat moje nejlepší pro každého vidět, v případě, že levá strana tabule

413
00:22:33,000 --> 00:22:37,000
představuje, řekněme, RAM, a zásobník bude růst na up tímto způsobem,

414
00:22:37,000 --> 00:22:43,000
a zavoláme funkci jako hlavní, a hlavní má 2 lokální proměnné, x a y,

415
00:22:43,000 --> 00:22:48,000
pojďme popsat ty, které jsou x tady, a pojďme popisovat tyto jako y tady,

416
00:22:48,000 --> 00:22:55,000
a pojďme dát v hodnotách 1 a 2, tak tohle je hlavní,

417
00:22:55,000 --> 00:22:58,000
a když hlavní volá swap funkce operačního systému

418
00:22:58,000 --> 00:23:02,000
dává SWAP funkce vlastní pás paměti na zásobníku,

419
00:23:02,000 --> 00:23:04,000
vlastní rám ve frontě, abych tak řekl.

420
00:23:04,000 --> 00:23:08,000
Je také přiděluje 32 bitů pro tyto ints.

421
00:23:08,000 --> 00:23:11,000
Stává se to nazvat, a b, ale to je naprosto nahodilé.

422
00:23:11,000 --> 00:23:13,000
Mohlo by jich povolal, co chce, ale co se stane, když hlavní

423
00:23:13,000 --> 00:23:19,000
vyzývá swap je to bere tuto 1, dá kopii tam, dá kopii tam.

424
00:23:19,000 --> 00:23:23,000
>> K dispozici je 1 další lokální proměnnou v swapu, když volal, co? >> Tmp.

425
00:23:23,000 --> 00:23:27,000
Tmp, tak mi dovolte dát si dalších 32 bitů zde,

426
00:23:27,000 --> 00:23:29,000
a co jsem udělal v této funkci?

427
00:23:29,000 --> 00:23:34,000
Řekl jsem int tmp dostane, tak má 1, tak jsem to udělal, když jsme naposledy hráli v tomto příkladu.

428
00:23:34,000 --> 00:23:39,000
Pak se dostane b, takže b je 2, takže nyní to bude 2,

429
00:23:39,000 --> 00:23:42,000
a nyní b dostane teplota, takže teplota je 1,

430
00:23:42,000 --> 00:23:44,000
tak teď b stává toto.

431
00:23:44,000 --> 00:23:46,000
To je skvělé. Fungovalo to.

432
00:23:46,000 --> 00:23:49,000
Ale pak, jakmile se funkce vrátí

433
00:23:49,000 --> 00:23:52,000
swapu paměti ve skutečnosti zmizí, takže to může být znovu

434
00:23:52,000 --> 00:23:58,000
jinou funkci v budoucnu, a hlavní je samozřejmě zcela beze změny.

435
00:23:58,000 --> 00:24:00,000
Potřebujeme způsob, jak zásadně vyřešení tohoto problému,

436
00:24:00,000 --> 00:24:03,000
a dnes budeme mít konečně způsob, jak toho dosáhnout, kdy

437
00:24:03,000 --> 00:24:06,000
můžeme představit něco jako ukazatel.

438
00:24:06,000 --> 00:24:09,000
Ukazuje se, že můžeme vyřešit tento problém

439
00:24:09,000 --> 00:24:12,000
není předáním kopie x a y

440
00:24:12,000 --> 00:24:18,000
ale tím, že podstoupí v co, myslíš, na odkládací funkci?

441
00:24:18,000 --> 00:24:20,000
Jo, co o adrese?

442
00:24:20,000 --> 00:24:22,000
Jsme opravdu mluvil o adresách v hodně podrobně,

443
00:24:22,000 --> 00:24:25,000
ale pokud to tabule představuje mého paměti počítače

444
00:24:25,000 --> 00:24:28,000
bychom mohli jistě začít číslování bytů v mém RAM

445
00:24:28,000 --> 00:24:31,000
a říci to je byte # 1, to je byte # 2, byte # 3,

446
00:24:31,000 --> 00:24:35,000
byte # 4, byte # ... 2000000000 když mám 2 GB paměti RAM,

447
00:24:35,000 --> 00:24:38,000
takže jsme mohli určitě přijít s nějakým libovolným schématu číslování

448
00:24:38,000 --> 00:24:41,000
pro všechny jednotlivé byty v mé paměti počítače.

449
00:24:41,000 --> 00:24:43,000
>> Co když místo toho, když jsem hovor odkládací

450
00:24:43,000 --> 00:24:47,000
spíše než projít v kopiích x a y

451
00:24:47,000 --> 00:24:51,000
proč bych místo předat adresu x zde,

452
00:24:51,000 --> 00:24:55,000
adresa y tady, v podstatě poštovní adresa

453
00:24:55,000 --> 00:24:59,000
x a y, protože pak swap, když je informován

454
00:24:59,000 --> 00:25:01,000
na adresu v paměti X a Y,

455
00:25:01,000 --> 00:25:04,000
pak swap, pokud jsme cvičili ho trochu,

456
00:25:04,000 --> 00:25:07,000
mohl potenciálně řídit na tuto adresu, abych tak řekl,

457
00:25:07,000 --> 00:25:11,000
x, a změnit číslo tam, pak cesta na adresu y,

458
00:25:11,000 --> 00:25:16,000
změnit číslo tam, i když ne ve skutečnosti získat kopie těchto hodnot sám,

459
00:25:16,000 --> 00:25:19,000
takže i když jsme o tom mluvili jako hlavní paměti

460
00:25:19,000 --> 00:25:23,000
a toto jako bytí swapu paměti silný a nebezpečný část C

461
00:25:23,000 --> 00:25:28,000
je to, že každý funkce může dotknout paměti kdekoli v počítači,

462
00:25:28,000 --> 00:25:32,000
a to je silný v tom, že můžete dělat velmi efektní věci s počítačovými programy v C.

463
00:25:32,000 --> 00:25:36,000
To je nebezpečné, protože můžete také zkazit velmi snadno.

464
00:25:36,000 --> 00:25:39,000
Ve skutečnosti, na jeden z nejčastějších způsobů, jak programy v těchto dnech být využity

465
00:25:39,000 --> 00:25:42,000
Stále je pro programátor neuvědomuje

466
00:25:42,000 --> 00:25:45,000
že on nebo ona je umožnit datové

467
00:25:45,000 --> 00:25:49,000
být napsán v místě v paměti, že nebyl určen.

468
00:25:49,000 --> 00:25:51,000
>> Například, on nebo ona prohlašuje, pole o velikosti 10

469
00:25:51,000 --> 00:25:56,000
ale pak náhodně snaží dát 11 bajtů do této matice v paměti,

470
00:25:56,000 --> 00:25:59,000
a začnete dotýkat částí paměti, které již nejsou platné.

471
00:25:59,000 --> 00:26:02,000
Jen pro kontextové to, někteří z vás vědí, že

472
00:26:02,000 --> 00:26:06,000
software často vás vyzve k zadání sériového čísla nebo registračních klíčů,

473
00:26:06,000 --> 00:26:08,000
Photoshop a Word a programy, jako je tato.

474
00:26:08,000 --> 00:26:12,000
Existují trhliny, jak si někteří z vás vědí, on-line, kde můžete spustit malý program,

475
00:26:12,000 --> 00:26:14,000
a voila, nic víc žádost o pořadové číslo.

476
00:26:14,000 --> 00:26:16,000
Jak je to, že pracuje?

477
00:26:16,000 --> 00:26:21,000
V mnoha případech se tyto věci jednoduše najít v počítačích

478
00:26:21,000 --> 00:26:24,000
textové segmenty v počítači skutečných nul a jedniček

479
00:26:24,000 --> 00:26:28,000
kde je tato funkce, kde je požadováno sériové číslo,

480
00:26:28,000 --> 00:26:31,000
a přepsat prostor, nebo když je program spuštěn

481
00:26:31,000 --> 00:26:33,000
můžete zjistit, kde je klíč skutečně uložen

482
00:26:33,000 --> 00:26:37,000
pomocí něco jako debugger, a můžete bezva software tímto způsobem.

483
00:26:37,000 --> 00:26:40,000
To je však neznamená, že toto je naším cílem pro další dva dny,

484
00:26:40,000 --> 00:26:42,000
ale má velmi reálné následky.

485
00:26:42,000 --> 00:26:45,000
Že jeden se stane zapojit krádeže softwaru,

486
00:26:45,000 --> 00:26:47,000
ale je tu i kompromis celých strojů.

487
00:26:47,000 --> 00:26:50,000
>> Ve skutečnosti, když webové stránky v těchto dnech jsou využívány

488
00:26:50,000 --> 00:26:53,000
a ohrožena a data jsou děravý a hesla jsou ukradené

489
00:26:53,000 --> 00:26:58,000
Tento velmi často souvisí se špatným řízením něčí paměti,

490
00:26:58,000 --> 00:27:01,000
nebo, v případě databází, neschopnost předvídat

491
00:27:01,000 --> 00:27:03,000
kontradiktorní vstup, tak o tom více v příštích týdnech,

492
00:27:03,000 --> 00:27:07,000
ale teď jen plížit náhled druhu škod, které můžete udělat

493
00:27:07,000 --> 00:27:11,000
tím, že zcela pochopit, jak věci fungují pod pokličku.

494
00:27:11,000 --> 00:27:14,000
Pojďme o pochopení, proč je vadný

495
00:27:14,000 --> 00:27:17,000
s nástrojem, který bude stále více a více užitečné

496
00:27:17,000 --> 00:27:19,000
jak naše programy se složitější.

497
00:27:19,000 --> 00:27:21,000
Tak daleko, když jste měli chybu v programu

498
00:27:21,000 --> 00:27:23,000
jak jste odešla o ladění to?

499
00:27:23,000 --> 00:27:25,000
Co vaše techniky byly tak daleko, ať už učil své TF

500
00:27:25,000 --> 00:27:27,000
nebo jen samouk?

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

502
00:27:29,000 --> 00:27:31,000
Printf, takže printf byl pravděpodobně tvůj přítel v tom, že pokud chcete vidět

503
00:27:31,000 --> 00:27:33,000
co se děje uvnitř vašeho programu

504
00:27:33,000 --> 00:27:36,000
stačí dát printf tady, printf tady, printf zde.

505
00:27:36,000 --> 00:27:38,000
Pak jej spustíte, a dostanete spoustu věcí na obrazovce

506
00:27:38,000 --> 00:27:43,000
, které můžete použít, aby pak odvodit, co se vlastně děje špatně ve vašem programu.

507
00:27:43,000 --> 00:27:45,000
>> Printf má tendenci být velmi silná věc,

508
00:27:45,000 --> 00:27:47,000
ale je to velmi manuální proces.

509
00:27:47,000 --> 00:27:49,000
Musíte dát printf tady, printf tady,

510
00:27:49,000 --> 00:27:51,000
a pokud jste to uvnitř smyčky můžete dostat 100 řádků

511
00:27:51,000 --> 00:27:53,000
výstupu, který pak musí prosít přes.

512
00:27:53,000 --> 00:27:58,000
Není to jako velmi uživatelsky příjemný nebo interaktivní mechanismus pro ladění programů,

513
00:27:58,000 --> 00:28:00,000
ale naštěstí existuje alternativy.

514
00:28:00,000 --> 00:28:03,000
Tam je program, například, volal GDB, GNU Debugger,

515
00:28:03,000 --> 00:28:06,000
což je poněkud tajemný v tom, jak jej použít.

516
00:28:06,000 --> 00:28:08,000
Je to trochu složitější, ale upřímně řečeno,

517
00:28:08,000 --> 00:28:11,000
to je jedna z těch věcí, kde, pokud si dát v tomto týdnu a další

518
00:28:11,000 --> 00:28:14,000
další hodina pochopit něco jako GDB

519
00:28:14,000 --> 00:28:18,000
to vám ušetří pravděpodobně i desítky hodin v dlouhodobém horizontu,

520
00:28:18,000 --> 00:28:21,000
tak s tím, dovolte mi, abych vám ukázku, jak ta věc funguje.

521
00:28:21,000 --> 00:28:23,000
>> Jsem v terminálovém okně.

522
00:28:23,000 --> 00:28:26,000
Nech mě jít napřed a zkompilovat tento program, buggy3.

523
00:28:26,000 --> 00:28:28,000
Je to již aktuální.

524
00:28:28,000 --> 00:28:31,000
Dovolte mi, abych jej spustit stejně jako jsme to udělali na chvíli zpět, a opravdu, je rozbito.

525
00:28:31,000 --> 00:28:34,000
Ale proč je to? Možná jsem podělal odkládací funkci.

526
00:28:34,000 --> 00:28:37,000
Možná, že je to a, b. Tak nějak nevím, pohybující se kolem nich správně.

527
00:28:37,000 --> 00:28:39,000
Nech mě jít dál a dělat to.

528
00:28:39,000 --> 00:28:43,000
Spíše než jen spustit buggy3 dovolte mi, abych místo spuštění tohoto programu GDB,

529
00:28:43,000 --> 00:28:48,000
a já řeknu to spustit buggy3,

530
00:28:48,000 --> 00:28:52,000
a budu zahrnovat příkazového řádku argumentu,-TUI,

531
00:28:52,000 --> 00:28:55,000
a dáme to v budoucích problémů při spec připomenout.

532
00:28:55,000 --> 00:28:57,000
A teď tato černá a bílá rozhraní objevilo se, že opět,

533
00:28:57,000 --> 00:28:59,000
je trochu ohromující na první, protože tam je všechno

534
00:28:59,000 --> 00:29:02,000
Informace o záruce tady, ale aspoň je tu něco povědomého.

535
00:29:02,000 --> 00:29:04,000
V horní části okna je můj skutečný kód,

536
00:29:04,000 --> 00:29:08,000
a když jsem procházet sem dovolte mi, abych přejděte až na samotný vrchol mého souboru,

537
00:29:08,000 --> 00:29:11,000
a opravdu, tam je buggy3.c, a všimněte si, v dolní části tohoto okna

538
00:29:11,000 --> 00:29:13,000
Mám GDB řádku.

539
00:29:13,000 --> 00:29:16,000
>> To není stejná jako normálnímu John Harvard řádku.

540
00:29:16,000 --> 00:29:19,000
To je výzva, co se děje, aby mi dovolil řídit GDB.

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

542
00:29:21,000 --> 00:29:24,000
Debugger je program, který vám umožní projít

543
00:29:24,000 --> 00:29:27,000
provedení vašeho programu řádek po řádku po řádku,

544
00:29:27,000 --> 00:29:30,000
po jak dělat, co chcete s programem,

545
00:29:30,000 --> 00:29:33,000
i volání funkcí, nebo hledáte, je ještě důležitější,

546
00:29:33,000 --> 00:29:35,000
Na různých proměnné hodnoty.

547
00:29:35,000 --> 00:29:37,000
Pojďme dál a udělat to.

548
00:29:37,000 --> 00:29:40,000
Chystám se jít dopředu a zadejte běhu na řádku gdb je,

549
00:29:40,000 --> 00:29:43,000
tak zjistíte v levém dolním rohu na obrazovce jsem napsal běžet,

550
00:29:43,000 --> 00:29:45,000
a já jsem stiskněte klávesu Enter, a co to bylo?

551
00:29:45,000 --> 00:29:50,000
Je to doslova běžel můj program, ale já jsem dělal ne vlastně vidět hodně dál zde

552
00:29:50,000 --> 00:29:55,000
proto, že jsem vlastně řekl ladicí

553
00:29:55,000 --> 00:29:57,000
pozastavit v určitém okamžiku v čase.

554
00:29:57,000 --> 00:29:59,000
Jen zadáním běh spustí program.

555
00:29:59,000 --> 00:30:01,000
Nemám vlastně nic vidět. Nemůžu s ním manipulovat.

556
00:30:01,000 --> 00:30:03,000
>> Namísto toho nechte mě to udělat.

557
00:30:03,000 --> 00:30:08,000
V tomto GDB řádku, dejte mi místo zadejte pauzu, zadejte.

558
00:30:08,000 --> 00:30:10,000
To není to, co jsem chtěl napsat.

559
00:30:10,000 --> 00:30:13,000
Pojďme místo toho napište přestávka hlavní.

560
00:30:13,000 --> 00:30:15,000
Jinými slovy, chci nastavit něco, co nazývá zarážka,

561
00:30:15,000 --> 00:30:18,000
který je příhodně pojmenovaný protože to se zlomí nebo pozastavení

562
00:30:18,000 --> 00:30:21,000
provádění programu na příslušném místě.

563
00:30:21,000 --> 00:30:23,000
Hlavní je název mé funkce.

564
00:30:23,000 --> 00:30:25,000
Všimněte si, že GDB je docela chytrý.

565
00:30:25,000 --> 00:30:28,000
To přišel na to, že hlavní stane, kdo hrubě na řádku 18

566
00:30:28,000 --> 00:30:32,000
z buggy3.c, a pak zjistíte zde vlevo nahoře

567
00:30:32,000 --> 00:30:34,000
b + je hned vedle řádku 18.

568
00:30:34,000 --> 00:30:38,000
To je mi připomněl, že jsem si nastavit zarážku na řádku 18.

569
00:30:38,000 --> 00:30:42,000
Tentokrát, když jsem typ běh, budu běžet můj program

570
00:30:42,000 --> 00:30:45,000
až dokud nenarazí, že zarážku,

571
00:30:45,000 --> 00:30:48,000
takže program bude pauza pro mě na řádku 18.

572
00:30:48,000 --> 00:30:50,000
Jdeme na to, spustit.

573
00:30:50,000 --> 00:30:53,000
Nic Zdá se, že se stalo, ale s výpovědní lhůtou vlevo dole

574
00:30:53,000 --> 00:30:58,000
spuštění programu, buggy3, breakpoint 1 v hlavní na řádku buggy3.c 18.

575
00:30:58,000 --> 00:31:00,000
Co mohu dělat?

576
00:31:00,000 --> 00:31:03,000
>> Všimněte si, můžu začít psát věci, jako je tisk,

577
00:31:03,000 --> 00:31:08,000
není printf, tisk x, a nyní to je divné.

578
00:31:08,000 --> 00:31:11,000
$ 1 je jen zvědavost, jak uvidíme

579
00:31:11,000 --> 00:31:14,000
při každém tisku něco, co jste si nový $ hodnotu.

580
00:31:14,000 --> 00:31:18,000
To je tak, že můžete se vrátit zpět na předchozí hodnoty jen v případě,

581
00:31:18,000 --> 00:31:21,000
ale teď to, co na plátně mi říká, je, že hodnota x v tomto bodě příběhu

582
00:31:21,000 --> 00:31:26,000
je zřejmě 134514032.

583
00:31:26,000 --> 00:31:29,000
Co? Kde se to dokonce pocházet z?

584
00:31:29,000 --> 00:31:31,000
[Neslyšitelné-student]

585
00:31:31,000 --> 00:31:34,000
Opravdu, toto je to, co budeme říkat na odpadky hodnotu, a my jsme nemluvili o tom ještě,

586
00:31:34,000 --> 00:31:37,000
ale z důvodu, že byste jí inicializovat proměnné

587
00:31:37,000 --> 00:31:40,000
je samozřejmě tak, že mají nějakou hodnotu, kterou chcete je mít.

588
00:31:40,000 --> 00:31:44,000
Ale úlovek je připomenout, že můžete deklarovat proměnné

589
00:31:44,000 --> 00:31:46,000
jako jsem to udělal před chvílí v mém sigma například

590
00:31:46,000 --> 00:31:48,000
aniž by se skutečně dává jim hodnotu.

591
00:31:48,000 --> 00:31:50,000
Vzpomeňte si, co jsem udělal tady v sigma.

592
00:31:50,000 --> 00:31:52,000
Prohlásil jsem n, ale jakou cenu jsem dát?

593
00:31:52,000 --> 00:31:56,000
Žádné, protože jsem věděl, že v příštích několika řádků

594
00:31:56,000 --> 00:31:59,000
GetInt se bude starat o problému uvedení hodnoty uvnitř n.

595
00:31:59,000 --> 00:32:02,000
>> Ale v tomto bodě v příběhu řádku 11

596
00:32:02,000 --> 00:32:05,000
a řádek 12 a řádek 13 a řádek 14

597
00:32:05,000 --> 00:32:08,000
během těch několika řádků, co je hodnota n?

598
00:32:08,000 --> 00:32:10,000
V jazyce C si prostě nevím.

599
00:32:10,000 --> 00:32:14,000
Je to obecně nějaký popelářský hodnota, některé zcela náhodné číslo

600
00:32:14,000 --> 00:32:17,000
, který je v podstatě zbyly z některé předchozí funkce

601
00:32:17,000 --> 00:32:21,000
které proběhly, tak váš program běží

602
00:32:21,000 --> 00:32:24,000
Připomínám, že funkce dostane funkce, funkce, funkce.

603
00:32:24,000 --> 00:32:27,000
Všechny tyto snímky si dát na paměti, a pak ty funkce návratu,

604
00:32:27,000 --> 00:32:31,000
a stejně jako jsem navrhl s gumou jejich paměť je nakonec znovu použít.

605
00:32:31,000 --> 00:32:37,000
No, to jen tak se stane, že tato proměnná x v tomto programu

606
00:32:37,000 --> 00:32:41,000
Zdá se, že obsahuje nějaké odpadky hodnotu jako 134514032

607
00:32:41,000 --> 00:32:44,000
z nějakého předchozí funkce, ne ten, který jsem napsal.

608
00:32:44,000 --> 00:32:47,000
Mohlo by to být něco, co přichází účinně s operačním systémem,

609
00:32:47,000 --> 00:32:49,000
některé funkce pod kapotou.

610
00:32:49,000 --> 00:32:52,000
>> Dobře, to je v pořádku, ale pojďme se teď postoupit na další řádek.

611
00:32:52,000 --> 00:32:55,000
Pokud jsem typ "next" na mé GDB řádku a já stiskněte klávesu Enter,

612
00:32:55,000 --> 00:32:58,000
Všimněte si, že zvýraznění se přesune dolů na řádek 19,

613
00:32:58,000 --> 00:33:01,000
ale logické implikace je, že linka 18

614
00:33:01,000 --> 00:33:06,000
Nyní po spuštění, takže když jsem zase psát "print x"

615
00:33:06,000 --> 00:33:10,000
Měl bych teď vidět 1, a opravdu, já.

616
00:33:10,000 --> 00:33:14,000
Opět, $ věci je způsob, jak GDB vám připomene

617
00:33:14,000 --> 00:33:17,000
co historie tisku, že jste udělal.

618
00:33:17,000 --> 00:33:21,000
Teď mě nech jít dál a vytisknout y, a opravdu, y je nějaký blázen hodnota stejně,

619
00:33:21,000 --> 00:33:24,000
ale žádný velký problém, protože v souladu 19 se chystáme přidělit

620
00:33:24,000 --> 00:33:27,000
hodnota 2, tak mi dovolte zadejte "next" znovu.

621
00:33:27,000 --> 00:33:29,000
A teď jsme na printf řádku.

622
00:33:29,000 --> 00:33:31,000
Dovolte mi, abych to tiskové x.

623
00:33:31,000 --> 00:33:34,000
Dovolte mi, abych to tiskovou y. Upřímně řečeno, já začínám trochu unavený z tisku to.

624
00:33:34,000 --> 00:33:38,000
Dovolte mi, abych místo toho napište "displeje X" a "displeje y,"

625
00:33:38,000 --> 00:33:41,000
a teď pokaždé, když jsem zadejte příkaz v budoucnu

626
00:33:41,000 --> 00:33:45,000
Budu připomněl, co je x a y, co je x a y, co je x a y.

627
00:33:45,000 --> 00:33:48,000
>> Mohu také, jako vynětí půdy z produkce, typ "info locals."

628
00:33:48,000 --> 00:33:50,000
Info je speciální příkaz.

629
00:33:50,000 --> 00:33:52,000
Místní znamená, že mi ukazuje lokální proměnné.

630
00:33:52,000 --> 00:33:55,000
Jen v případě, když zapomenu, nebo je to blázen, komplikovaná funkce

631
00:33:55,000 --> 00:33:57,000
že já nebo někdo jiný napsal info obyvatelé vám řekne,

632
00:33:57,000 --> 00:34:00,000
jaké jsou všechny lokální proměnné uvnitř této lokální funkce

633
00:34:00,000 --> 00:34:03,000
které by vás mohly záleží, pokud chcete hrabat kolem.

634
00:34:03,000 --> 00:34:07,000
Nyní, printf se chystá vykonat, tak nechte mě jít dopředu a jen typu "next".

635
00:34:07,000 --> 00:34:10,000
Vzhledem k tomu, že jsme v tomto prostředí jsme ve skutečnosti viděl to

636
00:34:10,000 --> 00:34:14,000
provádět sem, ale všimnete, že to začíná být trochu rozbité zde.

637
00:34:14,000 --> 00:34:17,000
Povšimněme si ale, že to převažující obrazovku tam,

638
00:34:17,000 --> 00:34:21,000
takže to není ideální program zde, ale to je v pořádku, protože jsem si vždycky hrabat kolem

639
00:34:21,000 --> 00:34:23,000
pomocí tisku, když chci.

640
00:34:23,000 --> 00:34:26,000
>> Dovolte mi, abych zadejte další zase, a nyní je tu zajímavá část.

641
00:34:26,000 --> 00:34:29,000
V tomto bodě příběhu y je 2, a x je 1,

642
00:34:29,000 --> 00:34:32,000
jak navrhuje tady, a znovu,

643
00:34:32,000 --> 00:34:35,000
Důvod, proč se automaticky zobrazuje je nyní, protože jsem použil příkaz

644
00:34:35,000 --> 00:34:40,000
Displej x a y displej, takže ve chvíli, kdy píšu další

645
00:34:40,000 --> 00:34:43,000
v Teorie X a Y by se měl stát vyměnil.

646
00:34:43,000 --> 00:34:45,000
Nyní již víme, že to nebude ten případ,

647
00:34:45,000 --> 00:34:49,000
ale uvidíme za chvíli, jak můžeme ponořit hlouběji se zjistit, proč to je pravda.

648
00:34:49,000 --> 00:34:54,000
Další, a bohužel, y je stále 2 a x je stále 1, a mohu potvrdit, jak moc.

649
00:34:54,000 --> 00:34:56,000
Tisk x, y tisku.

650
00:34:56,000 --> 00:34:59,000
Skutečně, žádný odkládání se skutečně stalo, takže pojďme začít to znovu.

651
00:34:59,000 --> 00:35:01,000
Je zřejmé, swap je rozbité.

652
00:35:01,000 --> 00:35:04,000
Pojďme místo toho napište "Spustit".

653
00:35:04,000 --> 00:35:07,000
Dovolte mi říci ano, chci restartovat od začátku, zadejte.

654
00:35:07,000 --> 00:35:09,000
>> Teď jsem zpátky na řádku 18.

655
00:35:09,000 --> 00:35:11,000
Nyní všimnete x a y jsou odpadky hodnoty znovu.

656
00:35:11,000 --> 00:35:15,000
Dále, další, další, další.

657
00:35:15,000 --> 00:35:17,000
Kdybych nudit mohu také jen typ N pro další.

658
00:35:17,000 --> 00:35:21,000
Můžete jej zkrátit na nejkratší možnou posloupnost znaků.

659
00:35:21,000 --> 00:35:23,000
Swap je nyní rozděleny.

660
00:35:23,000 --> 00:35:25,000
Pojďme ponor, takže místo psaní další,

661
00:35:25,000 --> 00:35:30,000
teď budu psát krok tak, že jsem posílení uvnitř této funkce

662
00:35:30,000 --> 00:35:33,000
takže mohu projít, takže jsem narazila krok a pak zadejte.

663
00:35:33,000 --> 00:35:37,000
Všimněte si, že upozorňovat na skoky stanoví nižší v mém programu na řádek 36.

664
00:35:37,000 --> 00:35:39,000
Tak jaké jsou lokální proměnné?

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

666
00:35:41,000 --> 00:35:43,000
Nic zatím, protože jsme nedostali k této přímce,

667
00:35:43,000 --> 00:35:47,000
tak pojďme dál a říkat "next".

668
00:35:47,000 --> 00:35:50,000
Nyní se zdá, že mají TMP, tisk tmp.

669
00:35:50,000 --> 00:35:52,000
Garbage hodnota, ne? Myslím, že ano.

670
00:35:52,000 --> 00:35:55,000
Jak asi vytisknout, tiskové B, 1 a 2?

671
00:35:55,000 --> 00:35:58,000
V okamžiku, jakmile jsem typ next znovu

672
00:35:58,000 --> 00:36:02,000
tmp bude trvat na hodnotu 1, doufejme,

673
00:36:02,000 --> 00:36:05,000
protože tmp se bude přiřazena hodnota.

674
00:36:05,000 --> 00:36:08,000
>> Nyní pojďme si vytisknout, tiskové b,

675
00:36:08,000 --> 00:36:11,000
ale nyní tisknout tmp, a to je opravdu 1.

676
00:36:11,000 --> 00:36:14,000
Nech mě dělat dál. Nech mě dělat dál.

677
00:36:14,000 --> 00:36:16,000
Dokončil jsem odkládací funkci.

678
00:36:16,000 --> 00:36:19,000
Jsem stále uvnitř ní v řádku 40, tak mi dovolte tisku,

679
00:36:19,000 --> 00:36:22,000
print b, a je mi jedno, co tmp je.

680
00:36:22,000 --> 00:36:27,000
Vypadá to, že swap je správné, pokud jde o záměnu a a b.

681
00:36:27,000 --> 00:36:31,000
Ale když jsem teď psát dál, jsem skočit zpět na řádek 25,

682
00:36:31,000 --> 00:36:34,000
a samozřejmě, pokud zadám do x a y tisku

683
00:36:34,000 --> 00:36:38,000
jsou stále beze změny, takže jsme ani opraven problém.

684
00:36:38,000 --> 00:36:41,000
Ale diagnosticky teď možná s tímto programem GDB

685
00:36:41,000 --> 00:36:44,000
jsme alespoň dostali o krok blíže k pochopení

686
00:36:44,000 --> 00:36:47,000
co se děje špatně, aniž by museli vrhu náš kód tím, že printf tady,

687
00:36:47,000 --> 00:36:50,000
printf zde, printf tady a pak ji spustit znovu a znovu

688
00:36:50,000 --> 00:36:52,000
se snaží přijít na to, co se děje špatně.

689
00:36:52,000 --> 00:36:55,000
>> Chystám se jít dopředu a ukončete z toho úplně s ukončete.

690
00:36:55,000 --> 00:36:57,000
Bude to pak říct, "Quit vlastně je?" Ano.

691
00:36:57,000 --> 00:37:00,000
Teď jsem zpátky v mém běžném řádku, a já jsem udělal pomocí GDB.

692
00:37:00,000 --> 00:37:03,000
Jak stranou, nemusíte používat tento-Tui vlajkou.

693
00:37:03,000 --> 00:37:07,000
Ve skutečnosti, pokud jej vynecháte dostanete v podstatě dolní polovinu obrazovky.

694
00:37:07,000 --> 00:37:11,000
Kdybych zadejte přestávka hlavní a potom spusťte

695
00:37:11,000 --> 00:37:15,000
I stále můžete spustit svůj program, ale co to bude dělat je více textově

696
00:37:15,000 --> 00:37:18,000
Jen mi ukaž aktuální řádek jeden po druhém.

697
00:37:18,000 --> 00:37:21,000
-Tui, textová uživatelské rozhraní,

698
00:37:21,000 --> 00:37:25,000
Jen ukazuje více programu najednou, což je asi trochu koncepčně jednodušší.

699
00:37:25,000 --> 00:37:27,000
Ale opravdu, mohu jen dělat dál, příští, další,

700
00:37:27,000 --> 00:37:30,000
a já jdu vidět jeden řádek najednou, a pokud chci opravdu vidět, co se děje

701
00:37:30,000 --> 00:37:35,000
Můžu psát seznam a uvidíte spoustu sousedních řádků.

702
00:37:35,000 --> 00:37:39,000
>> Tam je video, které jsme požádali, aby se budete dívat na problém sady 3

703
00:37:39,000 --> 00:37:43,000
, ve kterém Nate zahrnuje některé složitosti GDB,

704
00:37:43,000 --> 00:37:46,000
a to je jedna z těch věcí, upřímně, kde někteří non-triviální procento z vás

705
00:37:46,000 --> 00:37:49,000
Nikdy se nedotýkejte GDB, a že bude špatné

706
00:37:49,000 --> 00:37:53,000
protože doslova skončí trávit více času v průběhu tohoto semestru

707
00:37:53,000 --> 00:37:56,000
honí chyby, pak byste, pokud jste vložili do této půlhodině / hod

708
00:37:56,000 --> 00:38:00,000
tento týden a příští učení se dostat pohodlně s GDB.

709
00:38:00,000 --> 00:38:02,000
Printf byl tvůj přítel.

710
00:38:02,000 --> 00:38:05,000
GDB by nyní měla být tvůj přítel.

711
00:38:05,000 --> 00:38:08,000
>> Jakékoliv dotazy týkající se GDB?

712
00:38:08,000 --> 00:38:12,000
A tady je stručný přehled některých z nejmocnějších a užitečné příkazy.

713
00:38:12,000 --> 00:38:15,000
Jo. >> Lze vytisknout řetězec?

714
00:38:15,000 --> 00:38:17,000
Můžete vytisknout řetězec? Absolutně.

715
00:38:17,000 --> 00:38:19,000
Nemusí to být jen celá čísla.

716
00:38:19,000 --> 00:38:22,000
Pokud je proměnná y je řetězec stačí zadat tisk s.

717
00:38:22,000 --> 00:38:24,000
To vám ukáže, co se tento řetězec proměnná je.

718
00:38:24,000 --> 00:38:26,000
[Neslyšitelné-student]

719
00:38:26,000 --> 00:38:28,000
To vám dá adresu a řetězec sám.

720
00:38:28,000 --> 00:38:32,000
To vám ukáže, jak.

721
00:38:32,000 --> 00:38:34,000
A poslední věc, jen proto, že se jedná o dobré vědět taky.

722
00:38:34,000 --> 00:38:37,000
Backtrace a rám, dovolte mi, abych se ponořit do tohoto jednoho minule,

723
00:38:37,000 --> 00:38:39,000
stejný přesný program s GDB.

724
00:38:39,000 --> 00:38:44,000
Nech mě jít napřed a spustit textovou verzi uživatelského rozhraní,

725
00:38:44,000 --> 00:38:46,000
rozbít hlavní.

726
00:38:46,000 --> 00:38:49,000
Nech mě jít napřed a znovu spustit. Tady jsem.

727
00:38:49,000 --> 00:38:55,000
Teď mě nech jít příště, příště, příště, příště, příště, krok, zadejte.

728
00:38:55,000 --> 00:39:00,000
>> A teď, že jsem teď v swapu záměrně, ale já na to: "Sakra, co byla hodnota x?"

729
00:39:00,000 --> 00:39:02,000
Nemůžu x už.

730
00:39:02,000 --> 00:39:05,000
Nemůžu y, protože to není v působnosti.

731
00:39:05,000 --> 00:39:07,000
Jsou to v kontextu, ale žádný problém.

732
00:39:07,000 --> 00:39:09,000
Můžu psát backtrace.

733
00:39:09,000 --> 00:39:13,000
To ukazuje mi všechny funkce, které byly provedeny až do tohoto bodu v čase.

734
00:39:13,000 --> 00:39:16,000
Všimněte si, že jeden na dně, hlavní, seřadí se hlavní

735
00:39:16,000 --> 00:39:18,000
je na spodní straně našem obrázku zde.

736
00:39:18,000 --> 00:39:22,000
Skutečnost, že swap je nad ní vedení s odkládací že nad ním v paměti tu,

737
00:39:22,000 --> 00:39:26,000
a když chci vrátit na hlavní dočasně můžu říct "rám."

738
00:39:26,000 --> 00:39:30,000
Jaké číslo? Hlavní je rám # 1.

739
00:39:30,000 --> 00:39:32,000
Chystám se jít dopředu a říct: "frame 1."

740
00:39:32,000 --> 00:39:36,000
>> Teď jsem zpátky v hlavním, a mohu tisknout x, a mohu vytisknout y,

741
00:39:36,000 --> 00:39:40,000
ale nemohu vytisknout nebo b.

742
00:39:40,000 --> 00:39:43,000
Ale můžu, když řeknu: "Dobře, počkejte. Kde je swap?"

743
00:39:43,000 --> 00:39:46,000
Nech mě jít dál a říct, "frame 0".

744
00:39:46,000 --> 00:39:48,000
Teď jsem tam, kde chci být, a jak stranou,

745
00:39:48,000 --> 00:39:52,000
je tu další příkazy taky, jako když jste opravdu nudit psaní další, další, další, další,

746
00:39:52,000 --> 00:39:56,000
lze obecně říci, věci jako "další 10," a že se bude pohybovat po dalších 10 řádků.

747
00:39:56,000 --> 00:39:59,000
Můžete také napsat "pokračovat", když opravdu vám dost s krokovým přes to.

748
00:39:59,000 --> 00:40:05,000
Pokračovat bude spusťte program bez přerušení, dokud nenarazí další zarážku,

749
00:40:05,000 --> 00:40:07,000
ať už ve smyčce nebo nižší dole ve vašem programu.

750
00:40:07,000 --> 00:40:11,000
>> V tomto případě se pokračuje až do konce, a program ukončen normálně.

751
00:40:11,000 --> 00:40:13,000
To je ozdobný způsob, nižší proces.

752
00:40:13,000 --> 00:40:16,000
Jen váš program ukončen normálně.

753
00:40:16,000 --> 00:40:24,000
Více o které ve videu a ladění zasedání přijít.

754
00:40:24,000 --> 00:40:26,000
To bylo hodně.

755
00:40:26,000 --> 00:40:35,000
Pojďme vzít naši 5-minut přestávku tady, a vrátíme se structs a soubory.

756
00:40:35,000 --> 00:40:38,000
>> Pokud jste se ponořila do tohoto týdne PSet již

757
00:40:38,000 --> 00:40:41,000
budete vědět, že budeme používat v distribučním kódu,

758
00:40:41,000 --> 00:40:45,000
zdrojový kód, který jsme Vám poskytli jako výchozí bod, některé nové techniky.

759
00:40:45,000 --> 00:40:50,000
Zejména, jsme zavedli tento nový klíčové názvem struktura, pro konstrukci,

760
00:40:50,000 --> 00:40:53,000
takže můžeme vytvořit vlastní proměnné druhů.

761
00:40:53,000 --> 00:40:57,000
Zavedli jsme také pojem souboru I / O, souboru vstup a výstup,

762
00:40:57,000 --> 00:41:00,000
a to je tak, že se může uložit stav

763
00:41:00,000 --> 00:41:03,000
svého Scramble palubě do souboru na disku

764
00:41:03,000 --> 00:41:06,000
tak, aby učební chlapi a chápu

765
00:41:06,000 --> 00:41:09,000
co se děje uvnitř vašeho programu, aniž byste museli ručně hrát

766
00:41:09,000 --> 00:41:11,000
desítky her shonu.

767
00:41:11,000 --> 00:41:13,000
Můžeme to udělat víc automatedly.

768
00:41:13,000 --> 00:41:18,000
>> Tato myšlenka struct řeší poměrně přesvědčivé problém.

769
00:41:18,000 --> 00:41:21,000
Předpokládejme, že chceme zavést nějaký program

770
00:41:21,000 --> 00:41:25,000
že nějak udržuje informace o studentech,

771
00:41:25,000 --> 00:41:28,000
a studenti mohou mít, například, ID, název

772
00:41:28,000 --> 00:41:31,000
a dům na místě, jako je Harvard, takže se jedná 3 kusy informací

773
00:41:31,000 --> 00:41:34,000
Chceme udržet kolem, tak mi dovolte pokračovat a začít psát trochu program zde,

774
00:41:34,000 --> 00:41:38,000
patří stdio.h.

775
00:41:38,000 --> 00:41:42,000
Dovolte mi, abych to patří cs50.h.

776
00:41:42,000 --> 00:41:44,000
A pak začít svůj hlavní funkci.

777
00:41:44,000 --> 00:41:46,000
Nebudu obtěžovat s žádnými argumenty příkazového řádku,

778
00:41:46,000 --> 00:41:49,000
a tady chci mít studenta, takže jsem chtěl říct

779
00:41:49,000 --> 00:41:54,000
Student má jméno, tak jsem chtěl říct, "název řetězce."

780
00:41:54,000 --> 00:41:59,000
Pak jsem chtěl říct, student také má ID, takže int id,

781
00:41:59,000 --> 00:42:03,000
a student má dům, tak jsem také chtěl říct "řetězec dům."

782
00:42:03,000 --> 00:42:06,000
Pak jsem si objednat to trochu čistěji takhle.

783
00:42:06,000 --> 00:42:11,000
Dobře, teď mám 3 proměnné, s nimiž se představují studenta, tak "studenta."

784
00:42:11,000 --> 00:42:15,000
>> A teď chci naplnit tyto hodnoty, tak nechte mě jít napřed a řekl něco jako

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

786
00:42:18,000 --> 00:42:21,000
Jméno dostane Davida.

787
00:42:21,000 --> 00:42:24,000
Řekněme, že dům dostane Mather,

788
00:42:24,000 --> 00:42:31,000
a pak budu dělat něco svévolně jako printf ("% s,

789
00:42:31,000 --> 00:42:37,000
jehož ID je% d, žije v% s.

790
00:42:37,000 --> 00:42:41,000
A teď, co chci připojit tady, jednu po druhé?

791
00:42:41,000 --> 00:42:47,000
Jméno, id, dům; return 0.

792
00:42:47,000 --> 00:42:50,000
Dobře, pokud jsem to podělal někde tady

793
00:42:50,000 --> 00:42:54,000
Myslím, že máme docela dobrý program, který ukládá jeden student.

794
00:42:54,000 --> 00:42:57,000
Samozřejmě, že to není tak zajímavé. Co když chci mít 2 studenty?

795
00:42:57,000 --> 00:42:59,000
To není velký problém. Mohu podpořit 2 lidí.

796
00:42:59,000 --> 00:43:03,000
Nech mě jít napřed a zdůraznit to a jít sem dolů,

797
00:43:03,000 --> 00:43:09,000
a mohu říci, "id = 456" pro někoho, jako je Rob, který žije v Kirkland.

798
00:43:09,000 --> 00:43:12,000
>> Dobře, počkejte, ale nemohu volat je totéž,

799
00:43:12,000 --> 00:43:15,000
a vypadá to, že budu muset kopírovat to,

800
00:43:15,000 --> 00:43:19,000
tak mi dovolte říci, že se bude jednat o Davidovi proměnné,

801
00:43:19,000 --> 00:43:23,000
a dovolte mi, abych některé kopie těchto pro Roba.

802
00:43:23,000 --> 00:43:27,000
Zavoláme to Rob, ale to nebude fungovat hned

803
00:43:27,000 --> 00:43:33,000
proto, že jsem-počkat, změňme mě ID1, name1 a house1.

804
00:43:33,000 --> 00:43:35,000
Rob bude 2, 2.

805
00:43:35,000 --> 00:43:42,000
Musím změnit zde, zde, zde, zde, zde, zde.

806
00:43:42,000 --> 00:43:45,000
Počkejte, co Tommy? Pojďme to udělat znovu.

807
00:43:45,000 --> 00:43:49,000
Samozřejmě, pokud si stále myslíte, že je to dobrý způsob, jak dělat to, není to,

808
00:43:49,000 --> 00:43:52,000
takže kopírovat / vložit špatné.

809
00:43:52,000 --> 00:43:55,000
Ale my jsme to vyřešil před týdnem.

810
00:43:55,000 --> 00:43:59,000
>> Co bylo naše řešení, když jsme chtěli mít více instancí stejného datového typu?

811
00:43:59,000 --> 00:44:01,000
[Studenti] pole.

812
00:44:01,000 --> 00:44:03,000
Pole, takže zkusím vyčistit toto nahoru.

813
00:44:03,000 --> 00:44:07,000
Dovolte mi, abych určitý prostor pro sebe v horní části, a dovolte mi, abych místo toho to tady.

814
00:44:07,000 --> 00:44:12,000
Budeme-li si tyto lidi, a místo toho budu říkat "int id,"

815
00:44:12,000 --> 00:44:14,000
a budu podporovat 3 z nás nyní.

816
00:44:14,000 --> 00:44:18,000
Já řeknu "názvy řetězců," a já podporovat 3 z nás,

817
00:44:18,000 --> 00:44:22,000
a pak jsem chtěl říct, "řetězec domy," a budu podporovat 3 z nás.

818
00:44:22,000 --> 00:44:26,000
Nyní zde místo David dostat své vlastní lokální proměnné

819
00:44:26,000 --> 00:44:28,000
můžeme zbavit těch.

820
00:44:28,000 --> 00:44:30,000
Že se cítí dobře, že jsme čištění to až.

821
00:44:30,000 --> 00:44:35,000
Pak mohu říci, David bude [0] a názvy [0]

822
00:44:35,000 --> 00:44:38,000
a domy [0].

823
00:44:38,000 --> 00:44:41,000
A pak Rob můžeme podobně ušetřit na toto téma.

824
00:44:41,000 --> 00:44:46,000
Pojďme dát to sem, takže to bude libovolně bude ids [1].

825
00:44:46,000 --> 00:44:50,000
On to bude jména [1],

826
00:44:50,000 --> 00:44:53,000
a pak konečně domy [1].

827
00:44:53,000 --> 00:44:57,000
>> Stále trochu nudné, a teď musím přijít na to,

828
00:44:57,000 --> 00:45:03,000
takže řekněme "jména [0], id [0], domy [0],

829
00:45:03,000 --> 00:45:06,000
a pojďme pluralize to.

830
00:45:06,000 --> 00:45:09,000
IDS, IDS, IDS.

831
00:45:09,000 --> 00:45:12,000
A opět, dělám to, tak znovu, jsem už uchylovat kopírovat / vložit znovu,

832
00:45:12,000 --> 00:45:14,000
takže šance jsou tam jiné řešení zde.

833
00:45:14,000 --> 00:45:18,000
Já si asi vyčistit to ještě výš, se smyčkou, nebo něco takového,

834
00:45:18,000 --> 00:45:21,000
Takže ve zkratce, je to trochu lepší, ale stále se cítí jako

835
00:45:21,000 --> 00:45:24,000
Já se uchylovat k kopírovat / vložit, ale i to, tvrdím,

836
00:45:24,000 --> 00:45:27,000
není opravdu zásadně správné řešení, protože

837
00:45:27,000 --> 00:45:29,000
co když někdy se rozhodneme víte co?

838
00:45:29,000 --> 00:45:32,000
Bychom měli být uložení e-mailové adresy pro Davida a Rob

839
00:45:32,000 --> 00:45:34,000
a všichni ostatní v tomto programu.

840
00:45:34,000 --> 00:45:36,000
Měli bychom také ukládat telefonní čísla.

841
00:45:36,000 --> 00:45:39,000
Měli bychom také ukládat čísla tísňového kontakt.

842
00:45:39,000 --> 00:45:41,000
Máme všechny tyto kousky dat, které chcete uložit,

843
00:45:41,000 --> 00:45:43,000
tak jak se vám jít o tom, že?

844
00:45:43,000 --> 00:45:46,000
>> Můžete deklarovat další pole v horní části, a pak ručně přidat

845
00:45:46,000 --> 00:45:49,000
e-mailová adresa [0], e-mailová adresa [1]

846
00:45:49,000 --> 00:45:51,000
Davidovi a Rob a tak dále.

847
00:45:51,000 --> 00:45:56,000
Ale je to opravdu jen předpoklad, z něhož tento design

848
00:45:56,000 --> 00:45:59,000
že jsem pomocí čest systém vědět, že

849
00:45:59,000 --> 00:46:03,000
[I] v každé z několika polí

850
00:46:03,000 --> 00:46:06,000
jen tak náhodou odkazovat na stejnou osobu,

851
00:46:06,000 --> 00:46:10,000
takže [0] v IDS je číslo 123,

852
00:46:10,000 --> 00:46:13,000
a budu předpokládat, že jména [0]

853
00:46:13,000 --> 00:46:16,000
je tatáž osoba jméno a domy [0]

854
00:46:16,000 --> 00:46:21,000
je tatáž osoba dům a tak dále pro všechny z různých polí, které jsem vytvářejí.

855
00:46:21,000 --> 00:46:24,000
Povšimněme si ale, že to není zásadní vazba

856
00:46:24,000 --> 00:46:27,000
mezi ty 3 kusy informací, id, jméno a dům,

857
00:46:27,000 --> 00:46:32,000
i když účetní jednotka se snažíme vzoru v tomto programu není pole.

858
00:46:32,000 --> 00:46:35,000
Pole jsou právě tento programový způsob, jak toho dosáhnout.

859
00:46:35,000 --> 00:46:38,000
Co opravdu chceme modelovat v našem programu, je osoba,

860
00:46:38,000 --> 00:46:41,000
podobně jako David, člověk jako Rob uvnitř, které

861
00:46:41,000 --> 00:46:46,000
nebo zapouzdření je jméno a ID a dům.

862
00:46:46,000 --> 00:46:49,000
>> Můžeme nějak vyjádřit tuto myšlenku zapouzdření

863
00:46:49,000 --> 00:46:52,000
kdy člověk má ID, jméno a dům

864
00:46:52,000 --> 00:46:55,000
a ne se uchýlit k opravdu hack, kdy jsme jen

865
00:46:55,000 --> 00:46:58,000
věřím, že konzola něco

866
00:46:58,000 --> 00:47:02,000
odkazuje na stejný lidské entity v každé z těchto různorodých polí?

867
00:47:02,000 --> 00:47:04,000
Můžeme skutečně udělat.

868
00:47:04,000 --> 00:47:08,000
Nech mě jít nad hlavním teď, a dovolte mi, abych vytvořit svůj vlastní datový typ

869
00:47:08,000 --> 00:47:10,000
pro opravdu poprvé.

870
00:47:10,000 --> 00:47:14,000
Využili jsme tuto techniku ​​v Scramble,

871
00:47:14,000 --> 00:47:17,000
ale tady budu pokračovat a vytvořit datový typ,

872
00:47:17,000 --> 00:47:19,000
a víte co, budu to nazývat student nebo osoba,

873
00:47:19,000 --> 00:47:23,000
a budu používat typedef pro definici typu.

874
00:47:23,000 --> 00:47:25,000
Chystám se říct, že je to struktura,

875
00:47:25,000 --> 00:47:29,000
a pak tato struktura bude typu studenta, budeme říkat,

876
00:47:29,000 --> 00:47:31,000
i když je to trochu ze dne teď pro mě.

877
00:47:31,000 --> 00:47:33,000
Řekneme "int id."

878
00:47:33,000 --> 00:47:35,000
Řekneme "název řetězce."

879
00:47:35,000 --> 00:47:37,000
Pak budeme říkat "string dům,"

880
00:47:37,000 --> 00:47:40,000
tak od nynějška do konce těchto pár řádků kódu

881
00:47:40,000 --> 00:47:45,000
Právě jsem učil řinčení, že existuje

882
00:47:45,000 --> 00:47:49,000
datový typ kromě ints, kromě řetězců, kromě zdvojnásobí, kromě plováky.

883
00:47:49,000 --> 00:47:54,000
>> Od této chvíle v časové linii 11, je nyní nový datový typ nazvaný studentů,

884
00:47:54,000 --> 00:47:58,000
a teď mohu prohlásit, studentské proměnnou kdekoliv chci,

885
00:47:58,000 --> 00:48:01,000
tak mi dovolte přejděte sem lidi.

886
00:48:01,000 --> 00:48:05,000
Teď můžu zbavit toho, a můžu jít zpátky dolů k Davidovi tady,

887
00:48:05,000 --> 00:48:10,000
a pro Davida mohu skutečně říct, že David,

888
00:48:10,000 --> 00:48:13,000
můžeme doslova pojmenovat proměnné po sobě,

889
00:48:13,000 --> 00:48:16,000
bude typu studenta.

890
00:48:16,000 --> 00:48:18,000
To by mohlo vypadat trochu divně, ale to není všechno, že různé

891
00:48:18,000 --> 00:48:22,000
od vyhlášení něco jako int nebo řetězec nebo plováku.

892
00:48:22,000 --> 00:48:24,000
To jen tak se stane, být nazýván studenta nyní,

893
00:48:24,000 --> 00:48:28,000
a když chci, aby něco uvnitř této struktury

894
00:48:28,000 --> 00:48:31,000
Nyní mám použít nový kus syntaxe, ale je to docela jednoduché,

895
00:48:31,000 --> 00:48:39,000
david.id = 123, david.name = "David" v hlavním D,

896
00:48:39,000 --> 00:48:42,000
a david.house = "Mather,"

897
00:48:42,000 --> 00:48:46,000
a teď mohu zbavit této věci zde.

898
00:48:46,000 --> 00:48:51,000
Všimněte si, že jsme nyní předělala náš program opravdu mnohem lépe

899
00:48:51,000 --> 00:48:54,000
v tom, že nyní náš program kopíruje reálný svět.

900
00:48:54,000 --> 00:48:57,000
>> Tam je real-svět pojem osoby nebo studenta.

901
00:48:57,000 --> 00:49:02,000
Zde máme nyní verzi C osoby nebo přesněji studenta.

902
00:49:02,000 --> 00:49:05,000
Uvnitř této osoby jsou tyto rozhodující vlastnosti,

903
00:49:05,000 --> 00:49:10,000
ID, název a dům, tak Rob podstatě stává totéž tady dole,

904
00:49:10,000 --> 00:49:14,000
tak studenti rob, a teď rob.id = 456,

905
00:49:14,000 --> 00:49:17,000
rob.name = "Rob."

906
00:49:17,000 --> 00:49:20,000
Skutečnost, že proměnná se nazývá Rob je trochu nesmyslné.

907
00:49:20,000 --> 00:49:22,000
Mohli jsme říkali, že je x nebo y nebo z..

908
00:49:22,000 --> 00:49:25,000
Právě jsme se jmenoval to Rob být sémanticky konzistentní,

909
00:49:25,000 --> 00:49:28,000
ale ve skutečnosti jméno je uvnitř této oblasti sám,

910
00:49:28,000 --> 00:49:30,000
takže teď mám tohle.

911
00:49:30,000 --> 00:49:33,000
To taky není cítit se jako nejlepší design v tom, že jsem pevný kódované David.

912
00:49:33,000 --> 00:49:35,000
Já jsem pevný kódované Roba.

913
00:49:35,000 --> 00:49:39,000
A ještě musím uchýlit k nějaké zkopírujte a vložte pokaždé Chci nové proměnné.

914
00:49:39,000 --> 00:49:43,000
Navíc jsem si zřejmě měl každý z těchto proměnných jméno,

915
00:49:43,000 --> 00:49:46,000
i když bych mnohem raději popisovat tyto proměnné

916
00:49:46,000 --> 00:49:48,000
 více druhově jako studenti.

917
00:49:48,000 --> 00:49:52,000
>> Nyní můžeme sloučit myšlenky, které funguje dobře pro nás

918
00:49:52,000 --> 00:49:56,000
a místo toho řekl: "Víš co, dej mi proměnnou s názvem studentů,

919
00:49:56,000 --> 00:50:01,000
a pojďme se to být o velikosti 3, "takže teď můžu upřesnit to dále,

920
00:50:01,000 --> 00:50:04,000
zbavit ručně deklarované David,

921
00:50:04,000 --> 00:50:08,000
a mohu místo toho řekl něco jako studenty [0] zde.

922
00:50:08,000 --> 00:50:11,000
Pak mohu říci, studenty [0] zde,

923
00:50:11,000 --> 00:50:14,000
studenti [0] tady, a tak dále, a můžu jít kolem

924
00:50:14,000 --> 00:50:16,000
a vyčistit, aby se pro Roba.

925
00:50:16,000 --> 00:50:19,000
Mohl bych také jít o nyní možná přidáním smyčky

926
00:50:19,000 --> 00:50:23,000
a pomocí GetString a GetInt skutečně dostat tyto hodnoty od uživatele.

927
00:50:23,000 --> 00:50:27,000
Mohl bych jít o přidání konstanta, protože to je obecně špatná praxe

928
00:50:27,000 --> 00:50:29,000
na pevný kód některé libovolné číslo jako 3 tady

929
00:50:29,000 --> 00:50:33,000
a pak už jen na paměti, že byste měli dát více než 3 studentů v něm.

930
00:50:33,000 --> 00:50:36,000
Bylo by asi bylo lepší použít # define v horní části mého souboru

931
00:50:36,000 --> 00:50:40,000
a faktor, který se, tak opravdu, nechte mě jít napřed a zevšeobecnit toto.

932
00:50:40,000 --> 00:50:43,000
>> Dovolte mi, abych otevřít příklad, který je mezi dnešní

933
00:50:43,000 --> 00:50:46,000
Příklady předem, structs1.

934
00:50:46,000 --> 00:50:49,000
To je více kompletní program, který používá # define sem

935
00:50:49,000 --> 00:50:51,000
a říká, že budeme mít 3 studentů ve výchozím nastavení.

936
00:50:51,000 --> 00:50:54,000
Tady jsem se prohlašuje, že třídní cenu studentů,

937
00:50:54,000 --> 00:50:57,000
takže učebna studentů, a teď jsem s použitím smyčky

938
00:50:57,000 --> 00:51:00,000
jen proto, aby kód trochu víc elegantní, naplnit třídu

939
00:51:00,000 --> 00:51:05,000
s vstup uživatele, tak iterovat od i = 0 až na studenty, což je 3.

940
00:51:05,000 --> 00:51:07,000
A pak jsem vyzve uživatele v této verzi

941
00:51:07,000 --> 00:51:10,000
 Co je na studenta ID, a já si to s GetInt.

942
00:51:10,000 --> 00:51:13,000
Co je na jméno studenta, a pak jsem si to s GetString.

943
00:51:13,000 --> 00:51:15,000
Co je na studenta dům? Chápu to s GetString.

944
00:51:15,000 --> 00:51:19,000
A pak v dolní zde jsem se rozhodl změnit

945
00:51:19,000 --> 00:51:22,000
jak jsem tisk těchto, a skutečně používat smyčky,

946
00:51:22,000 --> 00:51:24,000
A kdo jsem já tisk?

947
00:51:24,000 --> 00:51:27,000
Podle komentáři jsem tisk nikoho v Mather,

948
00:51:27,000 --> 00:51:30,000
a je to tak Roba a Tommym a tak dále, vlastně Tommy je v Mather.

949
00:51:30,000 --> 00:51:34,000
Tommy a David by být vytištěny v tomto případě, ale jak je to pracuje?

950
00:51:34,000 --> 00:51:40,000
Neviděli jsme tuto funkci dříve, ale hádat o tom, co to dělá.

951
00:51:40,000 --> 00:51:42,000
Porovná řetězce.

952
00:51:42,000 --> 00:51:45,000
>> Je to trochu jiné než zřejmé, jak se srovnává řetězce, protože se ukazuje,

953
00:51:45,000 --> 00:51:49,000
pokud se vrátí 0 to znamená, že řetězce jsou shodné.

954
00:51:49,000 --> 00:51:53,000
Pokud se vrátí -1 to znamená, že někdo přijde abecedně dříve než ten druhý,

955
00:51:53,000 --> 00:51:57,000
a je-li to vrátí 1 to znamená, že další slovo přijde abecedně

956
00:51:57,000 --> 00:52:00,000
dříve než ten druhý, a můžete se podívat na internetu nebo v manuálové stránky

957
00:52:00,000 --> 00:52:04,000
přesně zjistit, jakým způsobem je který, ale tohle všechno je teď dělá, je to říká

958
00:52:04,000 --> 00:52:09,000
v případě, že [i]. dům se rovná "Mather"

959
00:52:09,000 --> 00:52:13,000
pak jít dopředu a vytisknout tak, a tak je v Mather.

960
00:52:13,000 --> 00:52:16,000
Ale tady je to něco, co jsme ještě neviděli, a vrátíme k tomu.

961
00:52:16,000 --> 00:52:21,000
Nevzpomínám si, že by bylo nutné provést v některé z mých programů.

962
00:52:21,000 --> 00:52:24,000
Zdarma je zřejmě odkazuje na paměti, uvolnění paměti,

963
00:52:24,000 --> 00:52:31,000
ale co paměti jsem zřejmě uvolní v této smyčky ve spodní části tohoto programu?

964
00:52:31,000 --> 00:52:34,000
Vypadá to, že jsem uvolnění jméno osoby

965
00:52:34,000 --> 00:52:37,000
a osoba je dům, ale proč je to?

966
00:52:37,000 --> 00:52:41,000
>> Ukázalo se, že ve všech těchto týdnů, které jste dosud používali GetString

967
00:52:41,000 --> 00:52:45,000
jsme trochu bylo zavedení chybu v každém z vašich programů.

968
00:52:45,000 --> 00:52:51,000
GetString pamětí návrhu přiděluje tak, aby se mohli vrátit k vám řetězce,

969
00:52:51,000 --> 00:52:55,000
jako David, nebo Rob, a pak můžete dělat, co chcete,

970
00:52:55,000 --> 00:52:59,000
s tímto řetězcem ve vašem programu, protože jsme vyhrazena paměť pro vás.

971
00:52:59,000 --> 00:53:02,000
Problém je tentokrát pokaždé volat GetString

972
00:53:02,000 --> 00:53:05,000
my, autoři GetString, se ptá, operační systém

973
00:53:05,000 --> 00:53:07,000
aby nám trochu RAM pro tohoto řetězce.

974
00:53:07,000 --> 00:53:09,000
Dejte nám trochu RAM pro tuto další řetězce.

975
00:53:09,000 --> 00:53:11,000
Dejte nám trochu více paměti RAM pro tuto další řetězce.

976
00:53:11,000 --> 00:53:13,000
Co jste, programátor, nikdy dělal

977
00:53:13,000 --> 00:53:15,000
dává nám, že paměť zpátky,

978
00:53:15,000 --> 00:53:17,000
takže pro těch několik týdnů všechny programy, které jste napsali

979
00:53:17,000 --> 00:53:20,000
měli, co se nazývá paměťový skok, kterým se nadále používat

980
00:53:20,000 --> 00:53:24,000
více a více paměti pokaždé, když budete volat GetString, a to je v pořádku.

981
00:53:24,000 --> 00:53:27,000
Záměrně jsme se tomu, že v prvních týdnech, protože to není tak zajímavé

982
00:53:27,000 --> 00:53:29,000
mít na starosti o tom, kde řetězec pochází.

983
00:53:29,000 --> 00:53:34,000
Vše, co chci, je slovo, Rob se vrátil když uživatel zadá ji dovnitř

984
00:53:34,000 --> 00:53:38,000
>> Ale kupředu nyní musíme začít se více důmyslný o tom.

985
00:53:38,000 --> 00:53:42,000
Kdykoliv se alokovat paměť můžeme lépe nakonec předat jej zpět.

986
00:53:42,000 --> 00:53:45,000
Jinak v reálném světě na vašem počítači Mac nebo PC můžete mít občas zkušené

987
00:53:45,000 --> 00:53:50,000
příznaky, kde je počítač broušení k zastavení nakonec

988
00:53:50,000 --> 00:53:54,000
nebo hloupý točící plážový míč právě okupuje počítač je

989
00:53:54,000 --> 00:53:56,000
Celá pozornost a nemůžete dělat věci.

990
00:53:56,000 --> 00:54:00,000
To lze vysvětlit tím, libovolný počet chyb, ale mezi ty případné chyby

991
00:54:00,000 --> 00:54:03,000
jsou věci, tzv. úniky paměti, kdy někdo, kdo psal ten kus softwaru

992
00:54:03,000 --> 00:54:07,000
Používáte nepamatoval na volné paměti

993
00:54:07,000 --> 00:54:10,000
že on nebo ona požádala operační systém pro,

994
00:54:10,000 --> 00:54:14,000
nepoužíváte GetString, protože to CS50 věc, ale pomocí podobné funkce

995
00:54:14,000 --> 00:54:16,000
že požádat operační systém pro paměti.

996
00:54:16,000 --> 00:54:19,000
Pokud vy nebo oni šroub a nikdy skutečně vrátí, že paměť

997
00:54:19,000 --> 00:54:24,000
příznak, který může být, že program, zpomaluje a zpomaluje a zpomaluje

998
00:54:24,000 --> 00:54:26,000
pokud si vzpomenete, volat zdarma.

999
00:54:26,000 --> 00:54:28,000
>> Vrátíme se, kdy a proč byste volat zdarma,

1000
00:54:28,000 --> 00:54:32,000
ale pojďme toho jen dobré opatření a pokuste se spustit tento konkrétní program.

1001
00:54:32,000 --> 00:54:35,000
Toto bylo nazýváno structs1, zadejte.

1002
00:54:35,000 --> 00:54:40,000
Nech mě jít napřed a spustit 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, a vidíme Davida v Mather, Tommy je v Mather.

1005
00:54:50,000 --> 00:54:53,000
To je jen malý rozum zkontrolujte, zda program pracuje.

1006
00:54:53,000 --> 00:54:56,000
Nyní, bohužel, tento program je trochu frustrující v tom, že

1007
00:54:56,000 --> 00:55:00,000
Já jsem všechno, co práce, jsem napsal v 9 různých řetězců, stiskněte klávesu Enter,

1008
00:55:00,000 --> 00:55:04,000
Bylo mi řečeno, kdo byl v Mather, ale samozřejmě jsem věděl, kdo byl v Mather už proto, že jsem ji zadali.

1009
00:55:04,000 --> 00:55:07,000
Bylo by hezké, kdyby alespoň tento program je více jako databáze

1010
00:55:07,000 --> 00:55:10,000
a vlastně si pamatuje, co jsem napsal v

1011
00:55:10,000 --> 00:55:12,000
takže jsem nikdy muset zadávat tyto záznamy o studentech.

1012
00:55:12,000 --> 00:55:15,000
Možná je to jako registrarial systému.

1013
00:55:15,000 --> 00:55:21,000
>> Můžeme to udělat pomocí této techniky známé jako soubor I / O, sp vstup a výstup,

1014
00:55:21,000 --> 00:55:24,000
velmi obecný způsob, jak říct, kdykoliv budete chtít číst nebo zapisovat soubory

1015
00:55:24,000 --> 00:55:26,000
můžete to udělat s určitou sadu funkcí.

1016
00:55:26,000 --> 00:55:29,000
Nech mě jít napřed a otevřete tento příklad structs2.c,

1017
00:55:29,000 --> 00:55:33,000
která je téměř totožná, ale uvidíme, co to teď dělá.

1018
00:55:33,000 --> 00:55:36,000
V horní části souboru Prohlašuji třídu studentů.

1019
00:55:36,000 --> 00:55:38,000
Pak jsem naplnit třídy s vstup uživatele,

1020
00:55:38,000 --> 00:55:41,000
takže ty řádky kódu jsou přesně jako předtím.

1021
00:55:41,000 --> 00:55:45,000
Pak když jsem nalistujte tady vytisknout každý, kdo je v Mather libovolně jako předtím,

1022
00:55:45,000 --> 00:55:47,000
ale to je zajímavá nová funkce.

1023
00:55:47,000 --> 00:55:51,000
Tyto řádky kódu jsou nové, a oni představí tu něco,

1024
00:55:51,000 --> 00:55:55,000
SOUBOR, všechna velká písmena, a to má * tady stejně.

1025
00:55:55,000 --> 00:55:58,000
Dovolte mi přejít to tady, a * tady také.

1026
00:55:58,000 --> 00:56:00,000
>> Tato funkce jsme neviděli, fopen,

1027
00:56:00,000 --> 00:56:03,000
ale to znamená soubor otevřený, takže se pojďme prolistovat nich,

1028
00:56:03,000 --> 00:56:05,000
a to je něco, co se vrátíme v příštích psets,

1029
00:56:05,000 --> 00:56:10,000
ale tato linka zde v podstatě otevře soubor s názvem databáze,

1030
00:56:10,000 --> 00:56:13,000
a to konkrétně otevře jej v takovým způsobem, že to může dělat to, co k ní?

1031
00:56:13,000 --> 00:56:15,000
[Neslyšitelné-student]

1032
00:56:15,000 --> 00:56:19,000
Dobře, tak "w" prostě znamená, že to říká operační systém

1033
00:56:19,000 --> 00:56:21,000
otevření tohoto souboru takovým způsobem, že nemohu zapisovat.

1034
00:56:21,000 --> 00:56:23,000
Nechci si ho přečíst. Nechci, aby na něj jen podívají.

1035
00:56:23,000 --> 00:56:26,000
Chci to změnit a přidat věci potenciálně k němu,

1036
00:56:26,000 --> 00:56:28,000
a soubor se bude nazýván databáze.

1037
00:56:28,000 --> 00:56:30,000
To by mohlo být nazýván nic.

1038
00:56:30,000 --> 00:56:32,000
To by mohlo být database.txt. To by mohlo být. Db.

1039
00:56:32,000 --> 00:56:37,000
To by mohlo být slovo jako foo, ale já jsem svévolně zvolila název souboru databáze.

1040
00:56:37,000 --> 00:56:42,000
To je trochu rozumu kontrola, zda se vrátíme v velmi podrobně v průběhu času,

1041
00:56:42,000 --> 00:56:47,000
pokud fp, pro tento soubor ukazatel, není stejný NULL to znamená, že je vše v pořádku.

1042
00:56:47,000 --> 00:56:51,000
>> Dlouhý příběh krátký, funkce jako fopen někdy nedaří.

1043
00:56:51,000 --> 00:56:53,000
Možná soubor neexistuje. Možná jste z disku.

1044
00:56:53,000 --> 00:56:55,000
Možná nemáte oprávnění k této složce,

1045
00:56:55,000 --> 00:56:58,000
takže pokud fopen vrátí null něco špatného stalo.

1046
00:56:58,000 --> 00:57:02,000
Naopak, pokud fopen nevrátí null vše je v pořádku

1047
00:57:02,000 --> 00:57:04,000
a můžu začít psát do tohoto souboru.

1048
00:57:04,000 --> 00:57:06,000
Zde je nový trik.

1049
00:57:06,000 --> 00:57:08,000
To je pro smyčky, který je iterace nad každým z mých studentů,

1050
00:57:08,000 --> 00:57:10,000
a to vypadá tak podobné tomu, co jsme dělali předtím,

1051
00:57:10,000 --> 00:57:15,000
ale tato funkce je bratranec printf vyzvala fprintf pro soubor printf,

1052
00:57:15,000 --> 00:57:18,000
a všimněte si, že je to jiný pouze ve 2 způsoby.

1053
00:57:18,000 --> 00:57:20,000
Jeden, začíná f místo p,

1054
00:57:20,000 --> 00:57:23,000
ale pak jeho první argument je zřejmě to, co?

1055
00:57:23,000 --> 00:57:25,000
[Studenti] souboru. >> Je to soubor.

1056
00:57:25,000 --> 00:57:30,000
To, čemu se říká fp, které budeme nakonec šprýmaři odděleně, co soubor je ukazatel,

1057
00:57:30,000 --> 00:57:35,000
ale teď fp představuje pouze soubor, který jsem otevřel,

1058
00:57:35,000 --> 00:57:41,000
tak fprintf zde říká vytisknout tento návod ID do souboru, ne na obrazovce.

1059
00:57:41,000 --> 00:57:44,000
Vytiskněte jméno uživatele do souboru, ne na obrazovce,

1060
00:57:44,000 --> 00:57:47,000
dům do souboru, ne na obrazovce, a pak tady dole, samozřejmě,

1061
00:57:47,000 --> 00:57:50,000
zavřete soubor, a pak sem bez paměti.

1062
00:57:50,000 --> 00:57:53,000
>> Jediný rozdíl mezi touto verzí 2 a verze 1

1063
00:57:53,000 --> 00:57:58,000
je zavedení funkce fopen, a to soubor s příponou *

1064
00:57:58,000 --> 00:58:01,000
a tento pojem fprintf, takže se pojďme podívat, co konečný výsledek je.

1065
00:58:01,000 --> 00:58:03,000
Nech mě jít do mého terminálovém okně.

1066
00:58:03,000 --> 00:58:06,000
Dovolte mi, abych běžet structs2, zadejte.

1067
00:58:06,000 --> 00:58:09,000
Vypadá to, že je vše v pořádku. Pojďme spusťte 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, zadejte.

1070
00:58:19,000 --> 00:58:23,000
Vypadá to, že se choval stejně, ale když jsem teď dělat ls

1071
00:58:23,000 --> 00:58:28,000
upozornění, co soubor, je tady mezi všemi mém kódu, databáze,

1072
00:58:28,000 --> 00:58:32,000
takže se pojďme otevřít, gedit databáze, a podívej se na to.

1073
00:58:32,000 --> 00:58:34,000
Není to sexy formátů souborů.

1074
00:58:34,000 --> 00:58:38,000
Je to opravdu jeden kus datové linky na linku na řádek,

1075
00:58:38,000 --> 00:58:42,000
ale ti z vás, kteří používají aplikace Excel nebo CSV souborů, oddělených čárkou hodnoty,

1076
00:58:42,000 --> 00:58:47,000
Mohl jsem samozřejmě použil fprintf místo toho možná udělat něco takového

1077
00:58:47,000 --> 00:58:50,000
takže jsem mohl skutečně vytvořit ekvivalent souboru aplikace Excel

1078
00:58:50,000 --> 00:58:53,000
oddělením věci s čárkami, ne jen nové linky.

1079
00:58:53,000 --> 00:58:56,000
>> V tomto případě, pokud bych měl místo toho používat čárky místo nových linek

1080
00:58:56,000 --> 00:59:01,000
Mohl bych doslova otevřít tento soubor databáze v aplikaci Excel, pokud jsem místo, aby to vypadalo takhle.

1081
00:59:01,000 --> 00:59:03,000
Stručně řečeno, teď, že máme sílu psát k souborům

1082
00:59:03,000 --> 00:59:07,000
nyní můžeme začít přetrvávající údaje, držet to asi na disk

1083
00:59:07,000 --> 00:59:10,000
takže můžeme uchovávat informace kolem znovu a znovu.

1084
00:59:10,000 --> 00:59:14,000
Všimněte si pár dalších věcí, které jsou v současné době trochu známější.

1085
00:59:14,000 --> 00:59:16,000
V horní části tohoto souboru C máme typedef

1086
00:59:16,000 --> 00:59:21,000
protože jsme chtěli vytvořit datový typ, který představuje slovo,

1087
00:59:21,000 --> 00:59:25,000
tak tento typ se nazývá slovo, a uvnitř této struktury

1088
00:59:25,000 --> 00:59:27,000
je to trochu obsáhlejší teď.

1089
00:59:27,000 --> 00:59:30,000
Proč je slovo skládající se z zdánlivě pole?

1090
00:59:30,000 --> 00:59:33,000
Co je slovo jen intuitivně?

1091
00:59:33,000 --> 00:59:35,000
>> Je to pole znaků.

1092
00:59:35,000 --> 00:59:37,000
Je to posloupnost znaků, zády k sobě k sobě.

1093
00:59:37,000 --> 00:59:41,000
DOPISY ve všech uzávěrů se stane, že jsme svévolně říci, maximální délka

1094
00:59:41,000 --> 00:59:44,000
jakékoliv slovo ve slovníku, že jsme pomocí pro Scramble.

1095
00:59:44,000 --> 00:59:46,000
Proč mám 1?

1096
00:59:46,000 --> 00:59:48,000
Null znak.

1097
00:59:48,000 --> 00:59:51,000
Připomeňme, když jsme si příklad Bananagrams jsme potřebovali zvláštní hodnotu

1098
00:59:51,000 --> 00:59:55,000
na konci slova, aby se sledovat

1099
00:59:55,000 --> 00:59:59,000
, kde slova skutečně skončil, a jak problém set specifikace říká

1100
00:59:59,000 --> 01:00:03,000
zde jsme spojovali s dané slovo logickou hodnotu,

1101
01:00:03,000 --> 01:00:05,000
vlajka, abych tak řekl, true nebo false.

1102
01:00:05,000 --> 01:00:09,000
Našli jste toto slovo už proto, že si uvědomujeme,

1103
01:00:09,000 --> 01:00:13,000
Opravdu potřebujeme způsob, jak si pamatovat nejen to, co slovo je v Scramble

1104
01:00:13,000 --> 01:00:15,000
ale zda nebo ne vy, člověk, našli ho

1105
01:00:15,000 --> 01:00:20,000
takže pokud zjistíte, že slovo "jen", můžete nejen zadejte, zadejte, že, zadejte, že, zadejte

1106
01:00:20,000 --> 01:00:23,000
a získat 3 body, 3 body, 3 body, 3 body.

1107
01:00:23,000 --> 01:00:26,000
Chceme být schopni na blacklist, že slovo nastavením bool

1108
01:00:26,000 --> 01:00:29,000
na hodnotu true, pokud jste již našel, a tak to je důvod, proč jsme

1109
01:00:29,000 --> 01:00:31,000
zapouzdřeny to v této struktuře.

1110
01:00:31,000 --> 01:00:35,000
>> Teď, tady v Scramble tam je to jiné struct říká slovník.

1111
01:00:35,000 --> 01:00:39,000
Nepřítomnost zde je slovo typedef, protože v tomto případě

1112
01:00:39,000 --> 01:00:43,000
jsme potřebovali k zapouzdření myšlenku slovníku,

1113
01:00:43,000 --> 01:00:46,000
a slovník obsahuje spoustu slov,

1114
01:00:46,000 --> 01:00:49,000
jak vyplývá z tohoto pole, a kolik z těchto slov jsou tam?

1115
01:00:49,000 --> 01:00:51,000
No, ať je tato proměnná nazývá velikost říká.

1116
01:00:51,000 --> 01:00:53,000
Ale my to prostě potřebujeme jeden slovník.

1117
01:00:53,000 --> 01:00:55,000
Nepotřebujeme datový typ zvaný slovník.

1118
01:00:55,000 --> 01:00:58,000
Potřebujeme jen jeden z nich, tak to dopadá v C

1119
01:00:58,000 --> 01:01:03,000
že pokud nechcete říct typedef, stačí říct struct, pak uvnitř složených závorek

1120
01:01:03,000 --> 01:01:05,000
můžete dát své proměnné, pak dal jméno.

1121
01:01:05,000 --> 01:01:09,000
Toto je prohlašuje jeden variabilní s názvem slovník

1122
01:01:09,000 --> 01:01:11,000
, která vypadá takto.

1123
01:01:11,000 --> 01:01:16,000
Naopak, tyto řádky jsou vytváření opakovaně použitelných datovou strukturu nazvanou slovo

1124
01:01:16,000 --> 01:01:19,000
že můžete vytvořit více kopií, stejně jako jsme vytvořili

1125
01:01:19,000 --> 01:01:22,000
více kopií studentů.

1126
01:01:22,000 --> 01:01:24,000
>> Co to v konečném důsledku nám umožňují dělat?

1127
01:01:24,000 --> 01:01:30,000
Nech mě jít zpátky do, řekněme, jednodušší příklad z jednodušších časů,

1128
01:01:30,000 --> 01:01:34,000
a dovolte mi, abych otevřít, řekněme, compare1.c.

1129
01:01:34,000 --> 01:01:38,000
Problém je zde po ruce, je skutečně slupkou zpět

1130
01:01:38,000 --> 01:01:41,000
vrstva z řetězce a začnete off těchto školení kola

1131
01:01:41,000 --> 01:01:44,000
protože se ukázalo, že řetězec celou dobu

1132
01:01:44,000 --> 01:01:47,000
je, jak jsme slíbili v týdnu 1 opravdu jen přezdívku,

1133
01:01:47,000 --> 01:01:51,000
synonymum od CS50 knihovny po něčem, co vypadá trochu tajemná,

1134
01:01:51,000 --> 01:01:53,000
char *, a my jsme viděli tuto hvězdu před.

1135
01:01:53,000 --> 01:01:55,000
Viděli jsme to v rámci souborů.

1136
01:01:55,000 --> 01:01:59,000
>> Pojďme se nyní, proč jsme se skrýval tento detail nějakou dobu.

1137
01:01:59,000 --> 01:02:02,000
Zde je soubor s názvem compare1.c,

1138
01:02:02,000 --> 01:02:07,000
a to zřejmě žádá uživatele o 2 řetězce, s a t,

1139
01:02:07,000 --> 01:02:11,000
a pak se snaží porovnávat tyto řetězce pro rovnost v souladu 26,

1140
01:02:11,000 --> 01:02:14,000
a pokud jsou stejné, že říká: "Zadali jste totéž,"

1141
01:02:14,000 --> 01:02:17,000
a pokud to není rovno to říká, "Zadali jste různé věci."

1142
01:02:17,000 --> 01:02:19,000
Nech mě jít napřed a spustit tento program.

1143
01:02:19,000 --> 01:02:23,000
Nech mě jít do mého zdrojového adresáře, aby se compare1. Je sestaven v pořádku.

1144
01:02:23,000 --> 01:02:25,000
Dovolte mi, abych běžet compare1.

1145
01:02:25,000 --> 01:02:27,000
Budu přiblížíte, zadejte.

1146
01:02:27,000 --> 01:02:29,000
Řekni něco. HELLO.

1147
01:02:29,000 --> 01:02:32,000
Řeknu něco znovu. HELLO.

1148
01:02:32,000 --> 01:02:34,000
Rozhodně jsem neměl psát různé věci.

1149
01:02:34,000 --> 01:02:37,000
>> Zkusím to znovu. BYE BYE.

1150
01:02:37,000 --> 01:02:40,000
Rozhodně ne jiný, takže to, co se tady děje?

1151
01:02:40,000 --> 01:02:44,000
No, co se opravdu být porovnány v souladu 26?

1152
01:02:44,000 --> 01:02:46,000
[Neslyšitelné-student]

1153
01:02:46,000 --> 01:02:49,000
Ano, tak to ukazuje, že řetězec, datový typ, je tak trochu lež.

1154
01:02:49,000 --> 01:02:53,000
Řetězec je char *, ale to, co je char *?

1155
01:02:53,000 --> 01:02:56,000
Char *, jak se říká, je ukazatel,

1156
01:02:56,000 --> 01:03:00,000
a ukazatel je skutečně adresa,

1157
01:03:00,000 --> 01:03:05,000
částka umístění v paměti, a pokud jste náhodou zadali ve slově, jako HELLO,

1158
01:03:05,000 --> 01:03:08,000
stáhnout z minulých diskusí řetězců

1159
01:03:08,000 --> 01:03:16,000
to je jako slovo HELLO.

1160
01:03:16,000 --> 01:03:19,000
Pamatujte si, že slovo jako Hello může být reprezentována

1161
01:03:19,000 --> 01:03:22,000
jako pole znaků, jako je tento

1162
01:03:22,000 --> 01:03:25,000
a pak se zvláštním charakterem na konci nazývá nulový znak,

1163
01:03:25,000 --> 01:03:27,000
jako \ vyjadřuje,.

1164
01:03:27,000 --> 01:03:29,000
Co je vlastně řetězec?

1165
01:03:29,000 --> 01:03:32,000
Všimněte si, že toto je více kusy paměti,

1166
01:03:32,000 --> 01:03:36,000
a ve skutečnosti, je konec to znám pouze jednou se podíváte do celého řetězce

1167
01:03:36,000 --> 01:03:38,000
hledá pro speciální nulový znak.

1168
01:03:38,000 --> 01:03:41,000
Ale pokud je to kus paměti z mého počítače paměti,

1169
01:03:41,000 --> 01:03:44,000
pojďme libovolně říci, že tento řetězec prostě štěstí,

1170
01:03:44,000 --> 01:03:47,000
a to mám umístěn na samém počátku mého počítače RAM.

1171
01:03:47,000 --> 01:03:54,000
To je bajt 0, 1, 2, 3, 4, 5, 6 ...

1172
01:03:54,000 --> 01:04:02,000
>> Když řeknu, že něco jako GetString a já string s = GetString

1173
01:04:02,000 --> 01:04:04,000
co se opravdu se vrátil?

1174
01:04:04,000 --> 01:04:08,000
U těchto posledních několika týdnech, je to, co opravdu být uloženy v s

1175
01:04:08,000 --> 01:04:13,000
není tento řetězec sama o sobě, ale v tomto případě to, co je uloženo, je

1176
01:04:13,000 --> 01:04:18,000
číslo 0, protože to, co GetString vlastně dělá

1177
01:04:18,000 --> 01:04:20,000
je není fyzicky vrátí řetězec.

1178
01:04:20,000 --> 01:04:22,000
To není vlastně ani dělat koncepční smysl.

1179
01:04:22,000 --> 01:04:24,000
Co to udělá, návrat je číslo.

1180
01:04:24,000 --> 01:04:28,000
Toto číslo je adresa HELLO v paměti,

1181
01:04:28,000 --> 01:04:32,000
a řetězec je pak, když se slupkou zpět tato vrstva, řetězec ve skutečnosti neexistuje.

1182
01:04:32,000 --> 01:04:35,000
Je to jen zjednodušení v CS50 knihovně.

1183
01:04:35,000 --> 01:04:38,000
>> To je opravdu něco, co nazývá char *.

1184
01:04:38,000 --> 01:04:41,000
Char dává smysl, protože to, co je slovo, jako HELLO?

1185
01:04:41,000 --> 01:04:44,000
No, to je série znaků, řada znaků.

1186
01:04:44,000 --> 01:04:47,000
Char * znamená adresu charakteru,

1187
01:04:47,000 --> 01:04:50,000
tak co to znamená vrátit řetězec?

1188
01:04:50,000 --> 01:04:53,000
Pěkný, jednoduchý způsob, jak vrátit řetězec

1189
01:04:53,000 --> 01:04:57,000
je spíše než se snažit přijít na to, jak jsem se vrátit do 5 nebo 6 různých bajtů

1190
01:04:57,000 --> 01:05:01,000
dovolte mi vrátit se na adresu, která byte?

1191
01:05:01,000 --> 01:05:03,000
První z nich.

1192
01:05:03,000 --> 01:05:06,000
Jinými slovy, dovolte mi, abych vám adresu znaku v paměti.

1193
01:05:06,000 --> 01:05:10,000
To je to, co char * představuje, adresa jediného znaku v paměti.

1194
01:05:10,000 --> 01:05:12,000
Volat, že proměnné s.

1195
01:05:12,000 --> 01:05:15,000
Skladujte v s, že konkrétní adresu, kterou jsem svévolně řekl je 0,

1196
01:05:15,000 --> 01:05:19,000
jen aby to jednoduché, ale ve skutečnosti je to obecně větší počet.

1197
01:05:19,000 --> 01:05:21,000
>> Počkejte chvilku.

1198
01:05:21,000 --> 01:05:23,000
Pokud jste jen, že mi adresu prvního znaku, jak mohu vědět, co je adresa

1199
01:05:23,000 --> 01:05:25,000
druhého znaku, třetí, čtvrté a páté?

1200
01:05:25,000 --> 01:05:27,000
[Neslyšitelné-student]

1201
01:05:27,000 --> 01:05:31,000
Ty pouze vědět, kde na konci řetězce je prostřednictvím tohoto šikovného triku,

1202
01:05:31,000 --> 01:05:35,000
takže když použít něco jako printf, co printf doslova bere jako svůj argument,

1203
01:05:35,000 --> 01:05:39,000
připomenout, že používáme tento% s zástupný symbol, a potom předat

1204
01:05:39,000 --> 01:05:41,000
proměnná, která je ukládání řetězec.

1205
01:05:41,000 --> 01:05:47,000
Co jste opravdu absolvování je adresa prvního znaku tohoto řetězce.

1206
01:05:47,000 --> 01:05:50,000
Printf pak používá pro vedení nebo smyčky while obdržením této adresy,

1207
01:05:50,000 --> 01:05:53,000
Například, 0, tak ať mě k tomu teď,

1208
01:05:53,000 --> 01:06:02,000
printf ("% s \ n", s);

1209
01:06:02,000 --> 01:06:07,000
Když říkám printf ("% s \ n", s); to, co jsem opravdu poskytuje printf s

1210
01:06:07,000 --> 01:06:13,000
je adresa prvního znaku v s, což je v tomto libovolném případě je H.

1211
01:06:13,000 --> 01:06:16,000
>> Jak printf vědět, co přesně se má zobrazit na obrazovce?

1212
01:06:16,000 --> 01:06:19,000
Osoba, která provádí printf zaveden while nebo pro smyčce

1213
01:06:19,000 --> 01:06:23,000
, který říká, to postava rovnat speciální nulový znak?

1214
01:06:23,000 --> 01:06:25,000
Pokud ne, vytiskněte ji. A co tahle?

1215
01:06:25,000 --> 01:06:28,000
Pokud jej vytisknout, vytiskněte jej, tisknout, vytisknout.

1216
01:06:28,000 --> 01:06:32,000
Oh, tohle je zvláštní. Zastavte tisk a vraťte se do uživatele.

1217
01:06:32,000 --> 01:06:35,000
A to je doslova všechno, co se děje pod kapotou,

1218
01:06:35,000 --> 01:06:38,000
a to je hodně strávit v první den třídy,

1219
01:06:38,000 --> 01:06:43,000
ale teď je to opravdu stavebním kamenem pochopení všeho

1220
01:06:43,000 --> 01:06:46,000
že se děje na vnitřní straně naší paměti počítače,

1221
01:06:46,000 --> 01:06:49,000
a nakonec budeme dráždit Tento aparthotel s malou pomocí

1222
01:06:49,000 --> 01:06:51,000
od jednoho z našich přátel na Stanfordu.

1223
01:06:51,000 --> 01:06:56,000
>> Profesor Nick Parlante na Stanfordu učinil tento úžasný video sekvence

1224
01:06:56,000 --> 01:06:58,000
ze všech druhů různých jazycích, které zavedly

1225
01:06:58,000 --> 01:07:00,000
tento malý Claymation charakter Binky.

1226
01:07:00,000 --> 01:07:03,000
Hlas jste asi slyšet jen na několik sekund propašovat náhled

1227
01:07:03,000 --> 01:07:05,000
je to, že z Stanford profesor, a dostaneš

1228
01:07:05,000 --> 01:07:07,000
pouze 5 nebo 6 sekund tohoto práva nyní,

1229
01:07:07,000 --> 01:07:09,000
ale je to poznámka, na kterém se budeme uzavírat dnes

1230
01:07:09,000 --> 01:07:11,000
a začít ve středu.

1231
01:07:11,000 --> 01:07:15,000
Dám vám ukazatel zábava s Binkym, preview.

1232
01:07:15,000 --> 01:07:18,000
[♪ Music ♪] [Profesor Parlante] Ahoj, Binky.

1233
01:07:18,000 --> 01:07:21,000
Probuď se. Je čas na ukazatel zábavu.

1234
01:07:21,000 --> 01:07:24,000
[Binky] Co je to? Další informace o ukazateli?

1235
01:07:24,000 --> 01:07:26,000
Oh, dobrota!

1236
01:07:26,000 --> 01:07:29,000
>> Uvidíme se ve středu.

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]