1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Recenze] [Quiz 0]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi Ross, Tommy MacWilliam, Lucas Freitas, Joseph Ong] [Harvard University]

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

4
00:00:08,000 --> 00:00:10,000
>> Ahoj, všichni.

5
00:00:10,000 --> 00:00:15,000
Vítejte na přezkoumání zasedání pro Quiz 0, který se koná tuto středu.

6
00:00:15,000 --> 00:00:19,000
Co budeme dělat dnes večer, jsem s dalšími 3 TFS,

7
00:00:19,000 --> 00:00:24,000
a společně budeme procházet přezkum toho, co jsme udělali v průběhu tak daleko.

8
00:00:24,000 --> 00:00:27,000
Nebude to být 100% vyčerpávající, ale měl by vám lepší představu

9
00:00:27,000 --> 00:00:31,000
z toho, co už máte, to, co budete ještě potřebovat ke studiu před středou.

10
00:00:31,000 --> 00:00:34,000
A neváhejte zvednout ruku s dotazy, jak budeme spolu,

11
00:00:34,000 --> 00:00:38,000
ale mějte na paměti, že budeme mít také trochu času na konci roku

12
00:00:38,000 --> 00:00:41,000
pokud se dostaneme až s několika minut náhradních dělat obecných otázek,

13
00:00:41,000 --> 00:00:47,000
takže mějte na paměti, že, a tak budeme začít od začátku s týdnu 0.

14
00:00:47,000 --> 00:00:50,000
>> [Kvíz 0 recenzi!] [Část 0] [Lexi Ross] Ale dříve než my, že Pojďme mluvit o

15
00:00:50,000 --> 00:00:53,000
logistiky kvízu.

16
00:00:53,000 --> 00:00:55,000
>> [Logistics] [Quiz se uskuteční ve středu 10/10 namísto přednášky]

17
00:00:55,000 --> 00:00:57,000
>> [(Viz http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf pro podrobnosti)] Je ve středu 10. října.

18
00:00:57,000 --> 00:01:00,000
>> To je to středa, a pokud jdete na tuto adresu URL zde,

19
00:01:00,000 --> 00:01:03,000
který je také přístupný z CS50.net-tam odkaz na to,

20
00:01:03,000 --> 00:01:06,000
můžete zobrazit informace o tom, kde jít na základě

21
00:01:06,000 --> 00:01:10,000
Vaše příjmení nebo školy příslušnost, jakož i

22
00:01:10,000 --> 00:01:14,000
to řekne, co přesně ten kvíz bude týkat a typy otázek, které budete dostat.

23
00:01:14,000 --> 00:01:19,000
Mějte na paměti, že budete mít také možnost zkontrolovat pro kvíz v sekci,

24
00:01:19,000 --> 00:01:21,000
takže vaše TFS měla jít přes některé problémy praxe,

25
00:01:21,000 --> 00:01:29,000
a to je další dobrá šance vidět, kde jste ještě potřebovat ke studiu až na kvíz.

26
00:01:29,000 --> 00:01:32,000
Začněme na začátku s Bytes 'n' kousky.

27
00:01:32,000 --> 00:01:35,000
Nezapomeňte bit je jen 0 nebo 1,

28
00:01:35,000 --> 00:01:38,000
a byte je sbírka 8 těchto bitů.

29
00:01:38,000 --> 00:01:42,000
Pojďme se podívat na této kolekce bitů tady.

30
00:01:42,000 --> 00:01:44,000
Měli bychom být schopni zjistit, kolik bitů je.

31
00:01:44,000 --> 00:01:48,000
Pokud budeme počítat, že je to jen 8 z nich, osm 0 nebo 1 ks.

32
00:01:48,000 --> 00:01:51,000
A protože tam je 8 bitů, to je 1 byte,

33
00:01:51,000 --> 00:01:53,000
a pojďme převést na šestnáctkové.

34
00:01:53,000 --> 00:01:58,000
Hexadecimální je základ 16, a je to docela snadné převést

35
00:01:58,000 --> 00:02:01,000
číslo v binární, což je to, co to je, aby číslo v hexadecimální.

36
00:02:01,000 --> 00:02:04,000
Vše, co udělat, je se podíváme na skupiny 4,

37
00:02:04,000 --> 00:02:07,000
a my je převést na odpovídající hexadecimální číslice.

38
00:02:07,000 --> 00:02:11,000
Začneme s pravým většina skupiny 4, tak 0011.

39
00:02:11,000 --> 00:02:16,000
To se děje za jednu 1 a jeden 2, tak společně, že činí 3.

40
00:02:16,000 --> 00:02:19,000
A pak se pojďme podívat na další blok 4.

41
00:02:19,000 --> 00:02:24,000
1101. To se děje za jeden 1, jeden 4, a jeden 8.

42
00:02:24,000 --> 00:02:28,000
Společně, že to bude 13, což D.

43
00:02:28,000 --> 00:02:32,000
A budeme pamatovat, že v šestnáctkové soustavě nemáme jen tak 0 až 9.

44
00:02:32,000 --> 00:02:36,000
Jdeme 0 až F, takže po 9, 10, odpovídá,

45
00:02:36,000 --> 00:02:40,000
11 až B, et cetera, kde F je 15.

46
00:02:40,000 --> 00:02:44,000
Zde 13 je D,

47
00:02:44,000 --> 00:02:49,000
tak převést na desetinné vše, co děláme je, že jsme vlastně

48
00:02:49,000 --> 00:02:52,000
Ke každému pozici jako síla 2.

49
00:02:52,000 --> 00:02:58,000
To je jedna 1, jeden 2, nula 4s, nula 8s, jeden 16, et cetera,

50
00:02:58,000 --> 00:03:03,000
a je to trochu těžké spočítat v hlavě, ale když půjdeme na další snímek

51
00:03:03,000 --> 00:03:05,000
můžeme vidět odpověď.

52
00:03:05,000 --> 00:03:09,000
>> V podstatě budeme naproti zpátky doleva,

53
00:03:09,000 --> 00:03:14,000
a my jsme vynásobí jednotlivé číslice odpovídajícím síla 2.

54
00:03:14,000 --> 00:03:19,000
A pamatujte, na hexadecimální označíme těchto čísel 0x na začátku

55
00:03:19,000 --> 00:03:23,000
takže nepleťte si to s desetinné číslo.

56
00:03:23,000 --> 00:03:29,000
Pokračování, tohle je ASCII tabulka,

57
00:03:29,000 --> 00:03:35,000
a to, co používáme ASCII, je mapovat z postav do numerických hodnot.

58
00:03:35,000 --> 00:03:39,000
Nezapomeňte v PSet kryptografie jsme rozsáhlé použití ASCII tabulky

59
00:03:39,000 --> 00:03:43,000
aby bylo možné používat různé metody kryptografie,

60
00:03:43,000 --> 00:03:47,000
Caesar a Vigenère kód, převést různé dopisy

61
00:03:47,000 --> 00:03:52,000
v řetězci podle klíče daného uživatelem.

62
00:03:52,000 --> 00:03:56,000
Pojďme se podívat na trochu ASCII matematiky.

63
00:03:56,000 --> 00:04:02,000
Při pohledu na "P" + 1, v charakteru podobě, která by byla Q,

64
00:04:02,000 --> 00:04:07,000
a pamatujte, že '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
A jak přesně bychom převádět mezi těmito 2 formuláře?

66
00:04:10,000 --> 00:04:13,000
Vlastně to ani není příliš tvrdý.

67
00:04:13,000 --> 00:04:16,000
Aby bylo možné získat 5 odečteme '0 '

68
00:04:16,000 --> 00:04:20,000
protože tam jsou 5 míst mezi '0 'a '5.'

69
00:04:20,000 --> 00:04:23,000
Aby šel na druhou stranu jsme právě přidat 0,

70
00:04:23,000 --> 00:04:25,000
takže je to něco jako pravidelné aritmetiky.

71
00:04:25,000 --> 00:04:29,000
Jen nezapomeňte, že když se něco má uvozovky kolem něj, že je to postava

72
00:04:29,000 --> 00:04:37,000
a tedy odpovídá hodnotě v tabulce ASCII.

73
00:04:37,000 --> 00:04:40,000
Přesun do obecnějších témat počítačových věd.

74
00:04:40,000 --> 00:04:43,000
Naučili jsme se, co je algoritmus a jak je používáme programování

75
00:04:43,000 --> 00:04:45,000
realizovat algoritmy.

76
00:04:45,000 --> 00:04:48,000
Některé příklady algoritmů jsou něco opravdu jednoduchého, jako

77
00:04:48,000 --> 00:04:51,000
kontroly, zda je číslo sudé nebo liché.

78
00:04:51,000 --> 00:04:54,000
Za to si, jsme mod na číslo 2 a zkontrolujte, zda výsledek je 0.

79
00:04:54,000 --> 00:04:57,000
Pokud ano, je to ještě. Pokud tomu tak není, je to zvláštní.

80
00:04:57,000 --> 00:04:59,000
A to je příklad opravdu základní algoritmus.

81
00:04:59,000 --> 00:05:02,000
>> Trochu více se účastní jeden je binární vyhledávání,

82
00:05:02,000 --> 00:05:05,000
které půjdeme přes později v přezkumném jednání.

83
00:05:05,000 --> 00:05:09,000
A programování je termín používáme pro přijetí algoritmus

84
00:05:09,000 --> 00:05:15,000
a převedením na kódování počítač může číst.

85
00:05:15,000 --> 00:05:20,000
2 příklady programování je Scratch,

86
00:05:20,000 --> 00:05:22,000
což je to, co jsme dělali v týdnu 0.

87
00:05:22,000 --> 00:05:25,000
I když nemáme vlastně zadejte ven kód je způsob, kterým se provádí

88
00:05:25,000 --> 00:05:29,000
tento algoritmus, který tiskne čísla 1-10,

89
00:05:29,000 --> 00:05:32,000
a tady děláme totéž v C programovací jazyk.

90
00:05:32,000 --> 00:05:41,000
Jedná se o funkčně ekvivalentní, právě psané v různých jazycích nebo syntaxe.

91
00:05:41,000 --> 00:05:44,000
Pak jsme se dozvěděli o booleovských výrazech,

92
00:05:44,000 --> 00:05:48,000
a boolean je hodnota, která je true nebo false,

93
00:05:48,000 --> 00:05:51,000
a zde mnohdy booleovské výrazy

94
00:05:51,000 --> 00:05:55,000
dovnitř podmínek, tak pokud (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
dobře, jsme již nastavili x = 5, takže tato podmínka bude hodnotit na true.

96
00:06:00,000 --> 00:06:03,000
A pokud je to pravda, co je kód pod podmínkou,

97
00:06:03,000 --> 00:06:08,000
se bude hodnocena na počítači, tak, že řetězec se bude vytištěn

98
00:06:08,000 --> 00:06:12,000
na standardní výstup, a termín stavu

99
00:06:12,000 --> 00:06:16,000
odkazuje na to, co je uvnitř závorek if.

100
00:06:16,000 --> 00:06:20,000
Nezapomeňte všechny operátory.

101
00:06:20,000 --> 00:06:26,000
Pamatujte si, že tyto && a | |, když se snažíme kombinovat 2 a více podmínek,

102
00:06:26,000 --> 00:06:30,000
== Ne = kontrolovat, zda 2 věci jsou si rovny.

103
00:06:30,000 --> 00:06:36,000
Pamatujte si, že = je pro přiřazení vzhledem k tomu, == je logický operátor.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ a pak v konečném znění 2 jsou zřejmé.

105
00:06:41,000 --> 00:06:45,000
Obecné přezkoumání booleovské logiky zde.

106
00:06:45,000 --> 00:06:48,000
A booleovské výrazy jsou také důležité ve smyčkách,

107
00:06:48,000 --> 00:06:50,000
které půjdeme pryč.

108
00:06:50,000 --> 00:06:56,000
Naučili jsme se asi 3 typy smyček tak daleko CS50, for, while, a to při.

109
00:06:56,000 --> 00:06:59,000
A to je důležité vědět, že zatímco pro většinu účelů

110
00:06:59,000 --> 00:07:02,000
můžeme skutečně použít jakýkoli typ smyčky obecně

111
00:07:02,000 --> 00:07:06,000
existují určité typy účely nebo společných vzorů

112
00:07:06,000 --> 00:07:09,000
v programování, které se specificky nazývají pro jeden z těchto smyček

113
00:07:09,000 --> 00:07:13,000
že aby bylo nejúčinnější nebo elegantní kód to tímto způsobem.

114
00:07:13,000 --> 00:07:18,000
Pojďme co každý z těchto smyček má tendenci být použity pro nejčastěji.

115
00:07:18,000 --> 00:07:21,000
>> V cyklu for jsme obecně již víme, kolikrát chceme iterovat.

116
00:07:21,000 --> 00:07:24,000
To je to, co jsme v podmínce.

117
00:07:24,000 --> 00:07:28,000
Pro, i = 0, i <10, například.

118
00:07:28,000 --> 00:07:31,000
My už víme, že chceme udělat něco 10krát.

119
00:07:31,000 --> 00:07:34,000
Nyní, po smyčce while, obvykle nemáme nutně

120
00:07:34,000 --> 00:07:36,000
Víš, kolikrát chceme smyčku spustit.

121
00:07:36,000 --> 00:07:39,000
Ale my víme nějakou podmínkou, že chceme, aby to

122
00:07:39,000 --> 00:07:41,000
být vždy pravdivé, nebo vždy false.

123
00:07:41,000 --> 00:07:44,000
Například, je nastavena při.

124
00:07:44,000 --> 00:07:46,000
Řekněme, že je to boolean proměnné.

125
00:07:46,000 --> 00:07:48,000
I když to je pravda chceme kód k vyhodnocení,

126
00:07:48,000 --> 00:07:52,000
tak trochu více rozšiřitelný, trochu obecnější než pro smyčce,

127
00:07:52,000 --> 00:07:55,000
ale každý pro smyčce lze také převést na smyčce while.

128
00:07:55,000 --> 00:08:00,000
Konečně, to while, které mohou být nejsložitější pochopit hned,

129
00:08:00,000 --> 00:08:04,000
se často používají, když chceme vyhodnotit kód první

130
00:08:04,000 --> 00:08:06,000
před prvním jsme zkontrolovat stav.

131
00:08:06,000 --> 00:08:09,000
Běžným příkladem použití dělat, když smyčka

132
00:08:09,000 --> 00:08:12,000
je, když se chcete dostat vstup uživatele, a víte, že chcete požádat uživatele

133
00:08:12,000 --> 00:08:15,000
pro vstup alespoň jednou, ale v případě, že nejsou ti dobrou vstup hned

134
00:08:15,000 --> 00:08:18,000
Chcete-li zachovat ptát se jich, dokud vám dobrou vstup.

135
00:08:18,000 --> 00:08:21,000
To je nejvíce obyčejné použití se while,

136
00:08:21,000 --> 00:08:23,000
a pojďme se podívat na vlastní struktury těchto smyček.

137
00:08:23,000 --> 00:08:27,000
Oni typicky vždy mají tendenci následovat tyto vzory.

138
00:08:27,000 --> 00:08:30,000
>> Na smyčky for uvnitř máte 3 složky:

139
00:08:30,000 --> 00:08:35,000
inicializace, obvykle něco jako int i = 0, kde i je počítadlo,

140
00:08:35,000 --> 00:08:40,000
stav, kdy chceme říci, spustit tento cyklus for tak dlouho, jak tento stav stále platí,

141
00:08:40,000 --> 00:08:44,000
jako i <10, a pak konečně, aktualizace, což je, jak jsme zvýšit

142
00:08:44,000 --> 00:08:47,000
čítač proměnnou v každém bodě smyčky.

143
00:08:47,000 --> 00:08:50,000
Běžná věc vidět, že je jen i + +,

144
00:08:50,000 --> 00:08:52,000
což znamená zvýšit i o 1 pokaždé.

145
00:08:52,000 --> 00:08:55,000
Dalo by se také udělat něco podobného i + = 2,

146
00:08:55,000 --> 00:08:58,000
což znamená, přidejte 2 až i pokaždé, když jdete přes smyčku.

147
00:08:58,000 --> 00:09:03,000
A pak to jen se odkazuje na nějaký kód, který vlastně běží jako součást smyčky.

148
00:09:03,000 --> 00:09:09,000
A pro smyčce while, tentokrát jsme vlastně tu inicializaci mimo smyčky,

149
00:09:09,000 --> 00:09:12,000
tak například, řekněme, že se snažíme dělat stejný typ smyčky, jak jsem právě popsal.

150
00:09:12,000 --> 00:09:16,000
Měli bychom říci, int i = 0 před smyčka začne.

151
00:09:16,000 --> 00:09:20,000
Pak bychom mohli říct, když i <10 to,

152
00:09:20,000 --> 00:09:22,000
takže stejný blok kódu jako předtím,

153
00:09:22,000 --> 00:09:26,000
a tentokrát aktualizace část kódu, například, i + +,

154
00:09:26,000 --> 00:09:29,000
vlastně jde uvnitř smyčky.

155
00:09:29,000 --> 00:09:33,000
A konečně, pro dělat, zatímco, to je podobný while,

156
00:09:33,000 --> 00:09:36,000
ale musíme mít na paměti, že kód bude hodnotit, jakmile

157
00:09:36,000 --> 00:09:40,000
před podmínka je kontrolována, takže je mnohem větší smysl

158
00:09:40,000 --> 00:09:44,000
když se podíváte na to v pořadí shora dolů.

159
00:09:44,000 --> 00:09:49,000
V dělat, když smyčka kód hodnotí ještě předtím, než se podívat na while stavu,

160
00:09:49,000 --> 00:09:55,000
vzhledem k tomu, while, zkontroluje jako první.

161
00:09:55,000 --> 00:09:59,000
Prohlášení a proměnné.

162
00:09:59,000 --> 00:10:04,000
Když chceme vytvořit novou proměnnou jsme nejprve chtít inicializovat.

163
00:10:04,000 --> 00:10:07,000
>> Například, int bar inicializuje proměnnou bar,

164
00:10:07,000 --> 00:10:10,000
ale to nedává hodnotu, takže to, co se nachází bar má hodnotu teď?

165
00:10:10,000 --> 00:10:12,000
Nevíme.

166
00:10:12,000 --> 00:10:14,000
Mohlo by to být nějaký odpadky hodnota, která byla dříve uložena v paměti tam,

167
00:10:14,000 --> 00:10:16,000
a nechceme použít tuto proměnnou

168
00:10:16,000 --> 00:10:19,000
dokud jsme vlastně dát hodnotu,

169
00:10:19,000 --> 00:10:21,000
tak jsme prohlásit ho zde.

170
00:10:21,000 --> 00:10:24,000
Pak jsme inicializovat, aby to bylo 42 níže.

171
00:10:24,000 --> 00:10:28,000
Teď, samozřejmě, víme, že to lze provést na jednom řádku, int bar = 42.

172
00:10:28,000 --> 00:10:30,000
Ale jen proto, aby se vymazat několik kroků, které se dějí,

173
00:10:30,000 --> 00:10:34,000
prohlášení a inicializace se děje odděleně zde.

174
00:10:34,000 --> 00:10:38,000
To se děje v jednom kroku, a příští, int baz = bar + 1,

175
00:10:38,000 --> 00:10:44,000
toto prohlášení níže, které se zvýší baz, takže na konci tohoto bloku kódu

176
00:10:44,000 --> 00:10:48,000
kdybychom vytisknout hodnotu baz by být 44

177
00:10:48,000 --> 00:10:52,000
protože jsme deklarovat a inicializovat ji na 1> bar,

178
00:10:52,000 --> 00:10:58,000
a pak jsme zvýšit ji ještě jednou + +.

179
00:10:58,000 --> 00:11:02,000
Šli jsme přes tento pěkný krátce, ale je to dobré mít obecnou

180
00:11:02,000 --> 00:11:04,000
pochopení toho, co témat a události jsou.

181
00:11:04,000 --> 00:11:06,000
Zaměřujeme se především to udělal v Scratch,

182
00:11:06,000 --> 00:11:09,000
takže si můžete myslet vláken as několika sekvencí kódu

183
00:11:09,000 --> 00:11:11,000
běží ve stejnou dobu.

184
00:11:11,000 --> 00:11:14,000
Ve skutečnosti, pravděpodobně neběží současně,

185
00:11:14,000 --> 00:11:17,000
ale druh abstraktně, můžeme myslet na to tímto způsobem.

186
00:11:17,000 --> 00:11:20,000
>> V Scratch, například, měli jsme více skřítky.

187
00:11:20,000 --> 00:11:22,000
Může to být provedení jiný kód ve stejnou dobu.

188
00:11:22,000 --> 00:11:26,000
Jeden by mohl být při chůzi druhý říká něco

189
00:11:26,000 --> 00:11:29,000
v jiné části obrazovky.

190
00:11:29,000 --> 00:11:34,000
Události jsou další způsob, jak oddělí logiku

191
00:11:34,000 --> 00:11:37,000
mezi různými prvky kódu,

192
00:11:37,000 --> 00:11:40,000
a Scratch jsme schopni simulovat události pomocí vysílání,

193
00:11:40,000 --> 00:11:43,000
a to je vlastně, když obdržím, ne, když slyším,

194
00:11:43,000 --> 00:11:47,000
ale v podstatě je to způsob, jak předávat informace

195
00:11:47,000 --> 00:11:49,000
z jednoho skřítka do druhého.

196
00:11:49,000 --> 00:11:52,000
Například, můžete chtít přenášet hru přes,

197
00:11:52,000 --> 00:11:56,000
a když jiný objekt sprite obdrží hru přes,

198
00:11:56,000 --> 00:11:58,000
reaguje určitým způsobem.

199
00:11:58,000 --> 00:12:03,000
Je to důležitý model pro pochopení pro programování.

200
00:12:03,000 --> 00:12:07,000
Stačí jít po základní týdne 0, co jsme pryč přes tak daleko,

201
00:12:07,000 --> 00:12:10,000
Pojďme se podívat na tento jednoduchý C program.

202
00:12:10,000 --> 00:12:14,000
Text může být trochu malý odtud, ale já půjdu přes to opravdu rychle.

203
00:12:14,000 --> 00:12:20,000
Jsme včetně 2 hlavičkové soubory v horním, cs50.h a stdio.h.

204
00:12:20,000 --> 00:12:23,000
Jsme pak definovat konstantní názvem limit je 100.

205
00:12:23,000 --> 00:12:26,000
Jsme pak provádí náš hlavní funkci.

206
00:12:26,000 --> 00:12:29,000
Vzhledem k tomu nemáme používat argumenty příkazového řádku zde musíme dát za neplatné

207
00:12:29,000 --> 00:12:32,000
jako argumenty pro hlavní.

208
00:12:32,000 --> 00:12:38,000
Vidíme int main výše. To je návratový typ, a proto vrátí 0 na dně.

209
00:12:38,000 --> 00:12:41,000
A my jsme pomocí CS50 knihovny funkcí získáte int

210
00:12:41,000 --> 00:12:45,000
požádat uživatele pro vstup, a uložíme ji v této proměnné x,

211
00:12:45,000 --> 00:12:51,000
tak prohlašujeme x výše, a inicializujeme ji x = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> Pak jsme zkontrolovat, zda uživatel dal nám dobrý vstup.

213
00:12:53,000 --> 00:12:59,000
Pokud je to ≥ LIMIT chceme vrátit kód chyby 1 a vytiskne chybové hlášení.

214
00:12:59,000 --> 00:13:02,000
A konečně, v případě, že uživatel je nám dobrý vstup

215
00:13:02,000 --> 00:13:08,000
budeme na náměstí číslo a vytiskne na to, že výsledek.

216
00:13:08,000 --> 00:13:11,000
Jen aby se ujistil, že ti všichni hit domů

217
00:13:11,000 --> 00:13:17,000
můžete vidět popisky různých částí kódu zde.

218
00:13:17,000 --> 00:13:19,000
Zmínil jsem se konstantní, hlavičkové soubory.

219
00:13:19,000 --> 00:13:21,000
Oh, int x. Ujistěte se, že si uvědomit, že je to lokální proměnná.

220
00:13:21,000 --> 00:13:24,000
To kontrastuje z globální proměnné, které budeme hovořit o

221
00:13:24,000 --> 00:13:27,000
trochu později v přezkumném jednání,

222
00:13:27,000 --> 00:13:30,000
a my jsme volání knihovní funkce printf,

223
00:13:30,000 --> 00:13:34,000
takže pokud jsme nezahrnula stdio.h hlavičkový soubor

224
00:13:34,000 --> 00:13:37,000
bychom nebyli schopni zavolat printf.

225
00:13:37,000 --> 00:13:42,000
A já věřím, šipka, která se dostal uřízl zde ukazuje na% d,

226
00:13:42,000 --> 00:13:45,000
který je formátovací řetězec, v printf.

227
00:13:45,000 --> 00:13:52,000
To říká, že vytisknout tuto proměnnou jako číslo,% d.

228
00:13:52,000 --> 00:13:58,000
A to je pro týden 0.

229
00:13:58,000 --> 00:14:06,000
Nyní Lucas se bude i nadále pokračovat.

230
00:14:06,000 --> 00:14:08,000
Ahoj, kluci. Mé jméno je Lucas.

231
00:14:08,000 --> 00:14:10,000
Jsem ve druháku v nejlepším domě na akademické půdě, Mather,

232
00:14:10,000 --> 00:14:14,000
a budu mluvit trochu o 1. týdne a 2,1.

233
00:14:14,000 --> 00:14:16,000
[Týden 1 a 2,1!] [Lucas Freitas]

234
00:14:16,000 --> 00:14:19,000
Jak Lexi říkal, když jsme začali překládat váš kód od nuly do C

235
00:14:19,000 --> 00:14:23,000
jedna z věcí, které jsme si všimli, je, že můžete nejen

236
00:14:23,000 --> 00:14:26,000
napsat svůj kód a spustit jej pomocí zelenou vlajkou už.

237
00:14:26,000 --> 00:14:30,000
Vlastně, budete muset použít některé kroky, aby se váš C program

238
00:14:30,000 --> 00:14:33,000
stát spustitelný soubor.

239
00:14:33,000 --> 00:14:36,000
V podstatě to, co děláte, když píšete program, je to, že

240
00:14:36,000 --> 00:14:40,000
můžete přeložit svůj nápad do jazyka, který kompilátor může pochopit,

241
00:14:40,000 --> 00:14:44,000
takže když píšete program v C

242
00:14:44,000 --> 00:14:47,000
to, co děláte je vlastně psát něco, co váš kompilátor bude rozumět,

243
00:14:47,000 --> 00:14:50,000
a pak kompilátor bude překládat tento kód

244
00:14:50,000 --> 00:14:53,000
do něčeho, že váš počítač bude rozumět.

245
00:14:53,000 --> 00:14:55,000
>> A věc je, počítač je vlastně velmi hloupá.

246
00:14:55,000 --> 00:14:57,000
Váš počítač může chápat pouze 0s a 1s,

247
00:14:57,000 --> 00:15:01,000
takže vlastně v prvních počítačích lidé obvykle naprogramován

248
00:15:01,000 --> 00:15:04,000
pomocí 0s a 1s, ale teď už ne, díky bohu.

249
00:15:04,000 --> 00:15:07,000
Nemáme si zapamatovat sekvence 0s a 1s

250
00:15:07,000 --> 00:15:10,000
pro cyklus for nebo while cyklu a tak dále.

251
00:15:10,000 --> 00:15:13,000
To je důvod, proč máme kompilátor.

252
00:15:13,000 --> 00:15:17,000
Co kompilátor dělá, je to v podstatě převádí C kód,

253
00:15:17,000 --> 00:15:21,000
V našem případě, na jazyk, který váš počítač bude rozumět,

254
00:15:21,000 --> 00:15:25,000
, která je předmětem kód a kompilátor že používáme

255
00:15:25,000 --> 00:15:30,000
se nazývá zvonění, takže to je vlastně symbol pro kovový zvuk.

256
00:15:30,000 --> 00:15:33,000
Máte-li svůj program, co musíte udělat, 2 věci.

257
00:15:33,000 --> 00:15:37,000
Za prvé, budete muset kompilovat svůj program, a pak budete ke spuštění programu.

258
00:15:37,000 --> 00:15:41,000
Chcete-li sestavit svůj program máte spoustu možností, aby tak učinily.

259
00:15:41,000 --> 00:15:44,000
První z nich je udělat řinčet program.c

260
00:15:44,000 --> 00:15:47,000
ve kterém programu je název programu.

261
00:15:47,000 --> 00:15:51,000
V tomto případě můžete vidět, že říkáš jen "Hej, kompilovat svůj program."

262
00:15:51,000 --> 00:15:56,000
Neříkáte "Chci tento název pro svůj program" nebo tak něco.

263
00:15:56,000 --> 00:15:58,000
>> Druhou možností je dát jméno do svého programu.

264
00:15:58,000 --> 00:16:02,000
Můžete říct, že klap-o a pak název, který chcete

265
00:16:02,000 --> 00:16:06,000
spustitelný soubor, který bude jmenován jako a pak program.c.

266
00:16:06,000 --> 00:16:11,000
A můžete také udělat, aby program, a uvidíte, jak v prvních 2 případech

267
00:16:11,000 --> 00:16:15,000
Dal jsem. C, a ve třetí jsem jen programy?

268
00:16:15,000 --> 00:16:18,000
Jo, vlastně by nemělo. C. při použití dělat.

269
00:16:18,000 --> 00:16:22,000
V opačném případě kompilátor bude skutečně křičet na vás.

270
00:16:22,000 --> 00:16:24,000
A také, já nevím, jestli jste pamatuji,

271
00:16:24,000 --> 00:16:29,000
ale hodně krát jsme také použili-lcs50 nebo-lm.

272
00:16:29,000 --> 00:16:31,000
To se nazývá propojení.

273
00:16:31,000 --> 00:16:35,000
Je to prostě říká kompilátoru, že budete používat tyto knihovny právě tam,

274
00:16:35,000 --> 00:16:39,000
takže pokud chcete použít cs50.h máte skutečně psát

275
00:16:39,000 --> 00:16:43,000
řinčení program.c-lcs50.

276
00:16:43,000 --> 00:16:45,000
Pokud tak neučiníte, že kompilátor nebude vědět

277
00:16:45,000 --> 00:16:50,000
, že používáte tyto funkce v cs50.h.

278
00:16:50,000 --> 00:16:52,000
A když chcete spustit program, máte 2 možnosti.

279
00:16:52,000 --> 00:16:57,000
Pokud jste řinčet program.c nedali jste jméno k vašemu programu.

280
00:16:57,000 --> 00:17:01,000
Musíte jej spustit pomocí. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out je standardní název, který řinčet dává svůj program, pokud nechcete dát mu jméno.

282
00:17:06,000 --> 00:17:11,000
Jinak budete dělat. / Program, pokud dal jméno programu,

283
00:17:11,000 --> 00:17:15,000
a také pokud jste udělat programu název, který program dostane

284
00:17:15,000 --> 00:17:23,000
se již bude naprogramovat stejný název jako soubor c.

285
00:17:23,000 --> 00:17:26,000
Pak jsme si povídali o datových typech a dat.

286
00:17:26,000 --> 00:17:31,000
>> V podstatě datové typy jsou totéž jako malé krabičky, které používají

287
00:17:31,000 --> 00:17:35,000
k uložení hodnot, tak datové typy jsou ve skutečnosti stejně jako pokémonů.

288
00:17:35,000 --> 00:17:39,000
Přicházejí ve všech velikostí a typů.

289
00:17:39,000 --> 00:17:43,000
Nevím, jestli to analogie smysl.

290
00:17:43,000 --> 00:17:46,000
Velikost dat skutečně záleží na architektury stroje.

291
00:17:46,000 --> 00:17:49,000
Všechny datové velikosti, že budu pro zobrazení zde

292
00:17:49,000 --> 00:17:53,000
jsou ve skutečnosti pro 32-bitové stroje, který je v případě našeho zařízení,

293
00:17:53,000 --> 00:17:56,000
ale pokud jste skutečně kódování vašeho počítače Mac nebo v systému Windows také

294
00:17:56,000 --> 00:17:59,000
Pravděpodobně budete mít 64-bit stroj,

295
00:17:59,000 --> 00:18:03,000
tak si pamatujte, že datové velikosti, že budu pro zobrazení zde

296
00:18:03,000 --> 00:18:06,000
jsou pro 32-bitové stroje.

297
00:18:06,000 --> 00:18:08,000
První z nich, že jsme viděli, bylo int,

298
00:18:08,000 --> 00:18:10,000
což je docela jednoduché.

299
00:18:10,000 --> 00:18:13,000
Můžete použít int uložit celé číslo.

300
00:18:13,000 --> 00:18:16,000
Viděli jsme také charakter, char.

301
00:18:16,000 --> 00:18:20,000
Pokud chcete použít písmeno nebo malý symbol budete pravděpodobně používat char.

302
00:18:20,000 --> 00:18:26,000
Char má 1 byte, což znamená 8 bitů, jako Lexi řekl.

303
00:18:26,000 --> 00:18:31,000
V podstatě máme ASCII tabulky, který má 256

304
00:18:31,000 --> 00:18:34,000
Možné kombinace 0s a 1s,

305
00:18:34,000 --> 00:18:37,000
a pak, když zadáte znak, že to bude překládat

306
00:18:37,000 --> 00:18:44,000
znak, který vstupy jste číslo, které máte v ASCII tabulce, jako Lexi řekl.

307
00:18:44,000 --> 00:18:48,000
Máme také plovák, který používáme k ukládání čísla v desítkové soustavě.

308
00:18:48,000 --> 00:18:53,000
Pokud si chcete vybrat 3,14, například, budete používat float

309
00:18:53,000 --> 00:18:55,000
nebo dvojité, který má větší přesnost.

310
00:18:55,000 --> 00:18:57,000
Float má 4 byty.

311
00:18:57,000 --> 00:19:01,000
Double má 8 bajtů, takže jediný rozdíl je přesnost.

312
00:19:01,000 --> 00:19:04,000
Máme také dlouhé, že se používá pro celá čísla,

313
00:19:04,000 --> 00:19:09,000
a je vidět na 32-bitové stroje int a dlouhý mají stejnou velikost,

314
00:19:09,000 --> 00:19:13,000
tak to nemá moc smysl používat dlouho v 32-bitové stroje.

315
00:19:13,000 --> 00:19:17,000
>> Ale pokud používáte Mac a 64-bit stroj, ve skutečnosti dlouhá má velikost 8,

316
00:19:17,000 --> 00:19:19,000
tak, že záleží na architektuře.

317
00:19:19,000 --> 00:19:22,000
Pro 32-bit stroje nemá smysl používat dlouhé opravdu.

318
00:19:22,000 --> 00:19:25,000
A pak dlouho dlouho, na druhé straně, má 8 bajtů,

319
00:19:25,000 --> 00:19:30,000
tak to je velmi dobré, pokud chcete mít delší celé číslo.

320
00:19:30,000 --> 00:19:34,000
A konečně, máme řetězec, který je ve skutečnosti char *,

321
00:19:34,000 --> 00:19:37,000
který je ukazatel na char.

322
00:19:37,000 --> 00:19:40,000
Je to velmi snadné si myslet, že velikost řetězce bude jako

323
00:19:40,000 --> 00:19:42,000
Počet znaků, které tam máte,

324
00:19:42,000 --> 00:19:45,000
ale ve skutečnosti char * sama

325
00:19:45,000 --> 00:19:49,000
má velikost ukazatel na char, který je 4 bajty.

326
00:19:49,000 --> 00:19:52,000
Velikost char * 4 byty.

327
00:19:52,000 --> 00:19:56,000
Nezáleží na tom, jestli máte malou slovo nebo písmeno nebo tak něco.

328
00:19:56,000 --> 00:19:58,000
Bude to mít 4 byty.

329
00:19:58,000 --> 00:20:01,000
Také jsme se naučili trochu o obsazení,

330
00:20:01,000 --> 00:20:04,000
takže jak vidíte, máte-li, například, program, který říká, že

331
00:20:04,000 --> 00:20:08,000
int x = 3 a potom printf ("% d", x / 2)

332
00:20:08,000 --> 00:20:12,000
to vy víte, co to bude tisknout na obrazovce?

333
00:20:12,000 --> 00:20:14,000
>> Někdo? >> [Studenti] 2.

334
00:20:14,000 --> 00:20:16,000
1. >> 1, jo.

335
00:20:16,000 --> 00:20:20,000
Pokud tak učiníte 3/2 to dostane 1,5,

336
00:20:20,000 --> 00:20:24,000
ale protože jsme použili celočíselnou to bude ignorovat desetinnou část,

337
00:20:24,000 --> 00:20:26,000
a budete mít 1.

338
00:20:26,000 --> 00:20:29,000
Pokud nechcete, aby se to stalo, co můžete udělat, například,

339
00:20:29,000 --> 00:20:33,000
je deklarovat plovák y = x.

340
00:20:33,000 --> 00:20:40,000
Pak x, které bývaly 3 se nyní bude 3,000 v y.

341
00:20:40,000 --> 00:20:44,000
A pak si můžete vytisknout y / 2.

342
00:20:44,000 --> 00:20:50,000
Vlastně, měl bych mít 2. tam.

343
00:20:50,000 --> 00:20:55,000
Bude to dělat 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
a budete se dostat 1,5.

345
00:20:58,000 --> 00:21:06,000
A máme tento 0,2 f jen požádat o 2 desetinná jednotek v desetinnou část.

346
00:21:06,000 --> 00:21:12,000
Máte-li 0,3 f, že to bude mít skutečně 1,500.

347
00:21:12,000 --> 00:21:16,000
Pokud je to 2 to bude 1,50.

348
00:21:16,000 --> 00:21:18,000
Máme také tento případ zde.

349
00:21:18,000 --> 00:21:22,000
Pokud si float x = 3,14 a pak vy printf x

350
00:21:22,000 --> 00:21:24,000
budete se 3,14.

351
00:21:24,000 --> 00:21:29,000
A pokud si x = int x,

352
00:21:29,000 --> 00:21:34,000
což znamená, že léčit x jako int a tisknete X nyní

353
00:21:34,000 --> 00:21:36,000
budete mít 3,00.

354
00:21:36,000 --> 00:21:38,000
Dává to smysl?

355
00:21:38,000 --> 00:21:41,000
Protože jste první léčbu x jako celé číslo, takže jste ignoroval desetinnou část,

356
00:21:41,000 --> 00:21:45,000
a pak tisknete x.

357
00:21:45,000 --> 00:21:47,000
A konečně, můžete si také udělat to,

358
00:21:47,000 --> 00:21:52,000
int x = 65, a pak prohlásit char c = x,

359
00:21:52,000 --> 00:21:56,000
a pak, pokud tisknete c jste vlastně dostane

360
00:21:56,000 --> 00:21:59,000
, Takže v podstatě to, co tady děláš

361
00:21:59,000 --> 00:22:02,000
je překládat celé číslo do charakteru,

362
00:22:02,000 --> 00:22:05,000
stejně jako ASCII tabulka dělá.

363
00:22:05,000 --> 00:22:08,000
Hovořili jsme také o matematických operátorů.

364
00:22:08,000 --> 00:22:14,000
Většina z nich jsou docela jednoduché, takže +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
a také se hovoří o mod, který je zbytek z dělení 2 čísla.

366
00:22:20,000 --> 00:22:23,000
Pokud máte 10% 3, například,

367
00:22:23,000 --> 00:22:27,000
to znamená rozdělit 10 do 3, a to, co je zbytek?

368
00:22:27,000 --> 00:22:30,000
Bude to být 1, takže je to vlastně velmi užitečné pro mnoho programů.

369
00:22:30,000 --> 00:22:38,000
Pro Vigenère a Caesar Jsem si jistý, že všichni z vás používá mod.

370
00:22:38,000 --> 00:22:43,000
O matematických operátorů, buďte velmi opatrní při kombinování * a /.

371
00:22:43,000 --> 00:22:48,000
>> Například, pokud si (3/2) * 2, co se vám dostane?

372
00:22:48,000 --> 00:22:50,000
[Studenti] 2.

373
00:22:50,000 --> 00:22:54,000
Jo, 2, protože 3/2 bude 1,5,

374
00:22:54,000 --> 00:22:57,000
ale protože děláte operace mezi 2 celá čísla

375
00:22:57,000 --> 00:22:59,000
jste vlastně jen tak, aby zvážila 1,

376
00:22:59,000 --> 00:23:03,000
a pak 1 * 2 bude 2, takže se velmi, velmi opatrní

377
00:23:03,000 --> 00:23:07,000
když dělá aritmetiku s celými čísly, protože

378
00:23:07,000 --> 00:23:12,000
se mohou vyskytnout, že 2 = 3, v tomto případě.

379
00:23:12,000 --> 00:23:14,000
A také být velmi opatrní přednost.

380
00:23:14,000 --> 00:23:21,000
Měli byste obvykle používají závorky si být jisti, že víte, co děláte.

381
00:23:21,000 --> 00:23:27,000
Některé užitečné zkratky, samozřejmě, jeden je i + + nebo i + = 1

382
00:23:27,000 --> 00:23:30,000
nebo pomocí + =.

383
00:23:30,000 --> 00:23:34,000
To je totéž, jako dělat i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Můžete si také udělat i - nebo i - = 1,

385
00:23:39,000 --> 00:23:42,000
který je totéž, jako i = i-1,

386
00:23:42,000 --> 00:23:46,000
Něco, co jste kluci používají hodně v cyklech for, nejméně.

387
00:23:46,000 --> 00:23:52,000
Také, pro *, pokud používáte * = a pokud ano, například,

388
00:23:52,000 --> 00:23:57,000
i * = 2 je totéž, jak říká i = i * 2,

389
00:23:57,000 --> 00:23:59,000
a totéž pro rozdělení.

390
00:23:59,000 --> 00:24:08,000
Pokud si i / = 2 je to totéž, jako i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Nyní o funkcích.

392
00:24:10,000 --> 00:24:13,000
Vy se dozvěděl, že funkce jsou velmi dobrá strategie pro uložení kódu

393
00:24:13,000 --> 00:24:16,000
když jste programování, takže pokud chcete provést stejný úkol

394
00:24:16,000 --> 00:24:20,000
v kódu znovu a znovu, pravděpodobně budete chtít použít funkci

395
00:24:20,000 --> 00:24:25,000
jen tak nemusíte kopírovat a vložit kód znovu a znovu.

396
00:24:25,000 --> 00:24:28,000
Vlastně, hlavní je funkce, a když jsem vám ukázat formát funkce

397
00:24:28,000 --> 00:24:32,000
budete vidět, že to je docela zřejmé.

398
00:24:32,000 --> 00:24:35,000
Používáme také funkce z některých knihoven,

399
00:24:35,000 --> 00:24:39,000
Například, printf, Getin, která je z knihovny CS50,

400
00:24:39,000 --> 00:24:43,000
a další funkce, jako je toupper.

401
00:24:43,000 --> 00:24:46,000
Všechny tyto funkce jsou skutečně prováděny v jiných knihovnách,

402
00:24:46,000 --> 00:24:49,000
a když dáte tyto postroje soubory na začátku programu

403
00:24:49,000 --> 00:24:53,000
říkáš, že můžete mi prosím dejte mi kód těchto funkcí

404
00:24:53,000 --> 00:24:57,000
takže nemám k jejich provedení, sám?

405
00:24:57,000 --> 00:25:00,000
A můžete také napsat své vlastní funkce, takže při spuštění programování

406
00:25:00,000 --> 00:25:04,000
Uvědomujete si, že knihovny nemají všechny funkce, které potřebujete.

407
00:25:04,000 --> 00:25:10,000
V posledním Pset, například, jsme psali čerpat, kódování, a vyhledávání,

408
00:25:10,000 --> 00:25:13,000
a je to velmi, velmi důležité, abychom byli schopni psát funkce

409
00:25:13,000 --> 00:25:17,000
protože jsou užitečné, a my jsme je používat po celou dobu v programování,

410
00:25:17,000 --> 00:25:19,000
a to ušetří spoustu kódu.

411
00:25:19,000 --> 00:25:21,000
Formát funkce je tenhle.

412
00:25:21,000 --> 00:25:24,000
Máme návratový typ na začátku. Co je návratový typ?

413
00:25:24,000 --> 00:25:27,000
Je to jen, když je vaše funkce bude vracet.

414
00:25:27,000 --> 00:25:29,000
Pokud máte funkci, například, faktoriál,

415
00:25:29,000 --> 00:25:31,000
, který se chystá k výpočtu faktoriálu celé číslo,

416
00:25:31,000 --> 00:25:34,000
Pravděpodobně to bude vrátit celé číslo také.

417
00:25:34,000 --> 00:25:37,000
Pak návratový typ bude int.

418
00:25:37,000 --> 00:25:41,000
Printf vlastně má návratový typ void

419
00:25:41,000 --> 00:25:43,000
protože nejste vracet nic.

420
00:25:43,000 --> 00:25:45,000
Ty pouze tisk věci na obrazovce

421
00:25:45,000 --> 00:25:48,000
a ukončení funkce poté.

422
00:25:48,000 --> 00:25:51,000
Pak máte název funkce, která si můžete vybrat.

423
00:25:51,000 --> 00:25:55,000
Ty by měly být trochu rozumný, jako nevybírejte jméno jako xyz

424
00:25:55,000 --> 00:25:58,000
nebo jako x2f.

425
00:25:58,000 --> 00:26:02,000
Snažte se, aby se o název, který dává smysl.

426
00:26:02,000 --> 00:26:04,000
>> Například, pokud je to faktoriál, říkají faktoriál.

427
00:26:04,000 --> 00:26:08,000
Pokud je to funkce, která se chystá na něco nakreslit, pojmenujte ji čerpat.

428
00:26:08,000 --> 00:26:11,000
A pak máme parametry, které jsou také nazývány argumenty,

429
00:26:11,000 --> 00:26:14,000
které jsou jako prostředky, které vaše funkce potřebuje

430
00:26:14,000 --> 00:26:17,000
od kódu k plnění svého úkolu.

431
00:26:17,000 --> 00:26:20,000
Pokud chcete vypočítat faktoriál čísla

432
00:26:20,000 --> 00:26:23,000
Pravděpodobně budete muset mít řadu pro výpočet faktoriálu.

433
00:26:23,000 --> 00:26:27,000
Jedním z argumentů, které budete mít, je samotné číslo.

434
00:26:27,000 --> 00:26:31,000
A pak, že to bude něco udělat a vrátit hodnotu na konci

435
00:26:31,000 --> 00:26:35,000
pokud je to neplatné funkce.

436
00:26:35,000 --> 00:26:37,000
Pojďme se podívat, příklad.

437
00:26:37,000 --> 00:26:40,000
Pokud chci napsat funkci, která sečte všechna čísla v matici celých čísel,

438
00:26:40,000 --> 00:26:43,000
v první řadě, návratový typ bude int

439
00:26:43,000 --> 00:26:46,000
protože mám řadu celých čísel.

440
00:26:46,000 --> 00:26:51,000
A pak budu mít název funkce, jako sumArray,

441
00:26:51,000 --> 00:26:54,000
a pak to bude trvat pole sám, na int nums,

442
00:26:54,000 --> 00:26:58,000
a pak délka pole, takže vím, kolik čísel musím shrnout.

443
00:26:58,000 --> 00:27:02,000
Pak jsem si inicializovat proměnnou s názvem částku, například na 0,

444
00:27:02,000 --> 00:27:08,000
a pokaždé, když vidím prvek v poli bych přidat do součtu, tak jsem udělal pro smyčce.

445
00:27:08,000 --> 00:27:15,000
Stejně jako Lexi řekl, ty int i = 0, i <délka a i + +.

446
00:27:15,000 --> 00:27:20,000
A pro každý prvek v poli jsem součet + = nums [i],

447
00:27:20,000 --> 00:27:24,000
a pak jsem se vrátil částku, takže je to velmi jednoduché, a to ušetří spoustu kódu

448
00:27:24,000 --> 00:27:28,000
Pokud používáte tuto funkci, mnohokrát.

449
00:27:28,000 --> 00:27:32,000
Pak jsme se podívali na podmínkách.

450
00:27:32,000 --> 00:27:38,000
Máme-li, jinak, a else if.

451
00:27:38,000 --> 00:27:42,000
Pojďme se podívat, jaký je rozdíl mezi těmito.

452
00:27:42,000 --> 00:27:45,000
Podívejte se na tyto 2 kódy. Jaký je rozdíl mezi nimi?

453
00:27:45,000 --> 00:27:49,000
První z nich, v podstatě kódy chtějí, abys

454
00:27:49,000 --> 00:27:51,000
pokud je číslo +, -, nebo 0.

455
00:27:51,000 --> 00:27:55,000
První z nich říká, že pokud je to> 0, pak je to pozitivní.

456
00:27:55,000 --> 00:28:00,000
Pokud je to = 0, pak je to 0, a pokud je to <0, pak je to negativní.

457
00:28:00,000 --> 00:28:04,000
>> A druhý dělá if, else if, else.

458
00:28:04,000 --> 00:28:07,000
Rozdíl mezi nimi je, že tohle je vlastně bude

459
00:28:07,000 --> 00:28:13,000
zkontrolujte, zda> 0, <0 nebo = 0 třikrát,

460
00:28:13,000 --> 00:28:17,000
takže pokud máte číslo 2, například, to přijde sem a říct

461
00:28:17,000 --> 00:28:21,000
if (x> 0), a bude to, že ano, tak jsem vytisknout pozitivní.

462
00:28:21,000 --> 00:28:25,000
Ale i když vím, že je to> 0 a nebude to na 0 nebo <0

463
00:28:25,000 --> 00:28:29,000
Jsem stále dělat, je to 0, je to <0,

464
00:28:29,000 --> 00:28:33,000
takže jsem vlastně děje uvnitř fondy, které jsem nemusela

465
00:28:33,000 --> 00:28:38,000
protože už vím, že to nebude splňovat některou z těchto podmínek.

466
00:28:38,000 --> 00:28:41,000
Mohu použít if, else if, else příkaz.

467
00:28:41,000 --> 00:28:45,000
Je to v podstatě říká, že pokud x = 0 tisknout pozitivní.

468
00:28:45,000 --> 00:28:48,000
Pokud tomu tak není, budu i tento test.

469
00:28:48,000 --> 00:28:51,000
Pokud to 2 není budu dělat to.

470
00:28:51,000 --> 00:28:54,000
V podstatě, pokud jsem měl x = 2 bys řekl

471
00:28:54,000 --> 00:28:57,000
if (x> 0), ano, tak tisknout.

472
00:28:57,000 --> 00:29:00,000
Teď, když vím, že je to> 0, a že je spokojen první, pokud

473
00:29:00,000 --> 00:29:02,000
Nejsem ani jít spustit tento kód.

474
00:29:02,000 --> 00:29:09,000
Kód běží rychleji, vlastně, 3 krát rychleji, pokud použijete tento.

475
00:29:09,000 --> 00:29:11,000
Také jsme se dozvěděli o a a nebo.

476
00:29:11,000 --> 00:29:15,000
Nebudu se projít, protože Lexi už mluvili o nich.

477
00:29:15,000 --> 00:29:17,000
Je to jen o && a | | provozovatel.

478
00:29:17,000 --> 00:29:21,000
>> Jediné, co řeknu, je být opatrný, když máte 3 podmínky.

479
00:29:21,000 --> 00:29:24,000
Použijte závorky, protože je to velmi matoucí, když máte podmínku

480
00:29:24,000 --> 00:29:27,000
a další jeden nebo jiný.

481
00:29:27,000 --> 00:29:30,000
Pomocí závorek jen pro jistotu, že vaše podmínky smysl

482
00:29:30,000 --> 00:29:34,000
protože v tomto případě, například, mohou si představit, že

483
00:29:34,000 --> 00:29:38,000
to by mohlo být první podmínka, a jeden nebo druhý

484
00:29:38,000 --> 00:29:41,000
nebo 2 podmínky spojené v a

485
00:29:41,000 --> 00:29:45,000
nebo třetí, takže stačí být opatrný.

486
00:29:45,000 --> 00:29:48,000
A konečně, mluvili jsme o přepínačích.

487
00:29:48,000 --> 00:29:53,000
Přepínač je velmi užitečné, když máte proměnnou.

488
00:29:53,000 --> 00:29:55,000
Řekněme, že máte proměnnou jako n

489
00:29:55,000 --> 00:29:59,000
, které mohou být 0, 1, nebo 2, a na každém z těchto případů

490
00:29:59,000 --> 00:30:01,000
budete k provedení úkolu.

491
00:30:01,000 --> 00:30:04,000
Můžete říct, že přepnout proměnnou, a znamená to, že

492
00:30:04,000 --> 00:30:08,000
hodnota pak je jako hodnota1 budu dělat to,

493
00:30:08,000 --> 00:30:12,000
a pak jsem se zlomit, což znamená, že nebudu dívat na některý z ostatních případech

494
00:30:12,000 --> 00:30:15,000
protože jsme již spokojeni, že případ

495
00:30:15,000 --> 00:30:20,000
a pak hodnota2 a tak dále, a já také může mít výchozí polohy.

496
00:30:20,000 --> 00:30:24,000
To znamená, že v případě, že nesplňuje žádný z případů, které jsem měl

497
00:30:24,000 --> 00:30:29,000
že budu dělat něco jiného, ​​ale to je volitelné.

498
00:30:29,000 --> 00:30:36,000
To je pro mě. Nyní se pojďme Tommy.

499
00:30:36,000 --> 00:30:41,000
Dobře, tohle bude týden 3-ish.

500
00:30:41,000 --> 00:30:45,000
To jsou některá z témat budeme pokrývat, crypto, rozsah, pole, et cetera.

501
00:30:45,000 --> 00:30:49,000
Jen slovíčko na crypto. Nebudeme se kladivem domů.

502
00:30:49,000 --> 00:30:52,000
>> Udělali jsme to v PSet 2, ale pro kvíz ujistěte se, že znáte rozdíl

503
00:30:52,000 --> 00:30:54,000
mezi Caesara a Vigenère kód,

504
00:30:54,000 --> 00:30:57,000
jak obě z těchto šifer práce a jaké to je k šifrování

505
00:30:57,000 --> 00:30:59,000
a dešifrování textu pomocí těchto 2 šifry.

506
00:30:59,000 --> 00:31:03,000
Nezapomeňte, Caesarova šifra jednoduše otočí každý znak stejnou částku,

507
00:31:03,000 --> 00:31:06,000
Díky, že jste mod počtem písmen v abecedě.

508
00:31:06,000 --> 00:31:09,000
A Vigenère kód, na druhé straně, se otáčí každý znak

509
00:31:09,000 --> 00:31:12,000
jinou částku, takže spíše než říkat

510
00:31:12,000 --> 00:31:15,000
Každá postava otáčí od 3 Vigenère bude otáčet každý znak

511
00:31:15,000 --> 00:31:17,000
o různé částky v závislosti na určité klíčové

512
00:31:17,000 --> 00:31:20,000
kde každý dopis na klíčové slovo představuje nějaké jiné množství

513
00:31:20,000 --> 00:31:26,000
otočit jasný text.

514
00:31:26,000 --> 00:31:28,000
Pojďme mluvit o první proměnnou rozsahu.

515
00:31:28,000 --> 00:31:30,000
K dispozici jsou 2 různé typy proměnných.

516
00:31:30,000 --> 00:31:33,000
Máme lokální proměnné, a ty se bude definovat

517
00:31:33,000 --> 00:31:36,000
mimo hlavní nebo mimo jakoukoli funkci nebo bloku,

518
00:31:36,000 --> 00:31:39,000
a ty budou dostupné kdekoliv ve vašem programu.

519
00:31:39,000 --> 00:31:41,000
Pokud máte funkci a v této funkci, je while

520
00:31:41,000 --> 00:31:44,000
Velký globální proměnná je přístupná všude.

521
00:31:44,000 --> 00:31:48,000
Lokální proměnná, na druhé straně, je rozsahem na místo, kde je definována.

522
00:31:48,000 --> 00:31:53,000
>> Pokud máte funkci zde například, máme tuto funkci g,

523
00:31:53,000 --> 00:31:56,000
a uvnitř g je proměnná zde nazývá y,

524
00:31:56,000 --> 00:31:58,000
a to znamená, že se jedná o lokální proměnná.

525
00:31:58,000 --> 00:32:00,000
I když je tato proměnná nazývá y

526
00:32:00,000 --> 00:32:03,000
a tato proměnná se nazývá Y tyto 2 funkce

527
00:32:03,000 --> 00:32:06,000
nemám ponětí, co každý jiný je lokální proměnné jsou.

528
00:32:06,000 --> 00:32:10,000
Na druhé straně, a to až tady říci int x = 5,

529
00:32:10,000 --> 00:32:12,000
a to je mimo rámec jakékoli funkce.

530
00:32:12,000 --> 00:32:16,000
Je to mimo rámec hlavní, takže to je globální proměnná.

531
00:32:16,000 --> 00:32:20,000
To znamená, že uvnitř těchto 2 funkcí, když řeknu, x - nebo x + +

532
00:32:20,000 --> 00:32:26,000
Já přístupu k témuž x přičemž toto y, a to y jsou různé proměnné.

533
00:32:26,000 --> 00:32:30,000
To je rozdíl mezi globální proměnné a lokální proměnné.

534
00:32:30,000 --> 00:32:33,000
Pokud jde o návrh se týká, někdy je to asi lepší nápad

535
00:32:33,000 --> 00:32:37,000
aby proměnné lokální, kdykoli si možná můžete

536
00:32:37,000 --> 00:32:39,000
protože mají spoustu globálních proměnných může dostat opravdu matoucí.

537
00:32:39,000 --> 00:32:42,000
Pokud máte spoustu funkcí všech modifikací totéž

538
00:32:42,000 --> 00:32:45,000
můžete zapomenout co když je tato funkce náhodou upravuje tento globální,

539
00:32:45,000 --> 00:32:47,000
a tato jiná funkce neví o tom,

540
00:32:47,000 --> 00:32:50,000
a to pěkně matoucí, jak si získat více kódu.

541
00:32:50,000 --> 00:32:53,000
Vedení proměnné lokální, kdykoli si možná můžete

542
00:32:53,000 --> 00:32:56,000
je prostě dobrý design.

543
00:32:56,000 --> 00:33:00,000
Matice, pamatujte, že jsou prostě seznamy prvků stejného typu.

544
00:33:00,000 --> 00:33:04,000
Uvnitř CI nemůže mít seznam jako 1, 2,0, ahoj.

545
00:33:04,000 --> 00:33:06,000
My prostě nemůžeme udělat, že.

546
00:33:06,000 --> 00:33:11,000
>> Když deklarujeme pole v C všechny prvky musí být stejného typu.

547
00:33:11,000 --> 00:33:14,000
Tady mám řadu 3 celých čísel.

548
00:33:14,000 --> 00:33:18,000
Tady mám délku pole, ale pokud jsem jen prohlášením v této syntaxi

549
00:33:18,000 --> 00:33:21,000
kde jsem určit, jaká všechny prvky jsou nemám technicky potřebovat 3.

550
00:33:21,000 --> 00:33:25,000
Kompilátor je dost chytrý na to, aby zjistili, jak velký by měl být pole.

551
00:33:25,000 --> 00:33:28,000
Teď, když chci získat nebo nastavit hodnotu pole

552
00:33:28,000 --> 00:33:30,000
To je syntaxe k tomu, že.

553
00:33:30,000 --> 00:33:33,000
To bude skutečně měnit druhý prvek pole, protože, pamatujte,

554
00:33:33,000 --> 00:33:36,000
Číslování začíná na 0, ne na 1.

555
00:33:36,000 --> 00:33:42,000
Pokud chci číst tuto hodnotu mohu říci něco jako int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Nebo když chci nastavit tuto hodnotu, jako bych tady,

557
00:33:44,000 --> 00:33:47,000
Mohu říci, array [1] = 4.

558
00:33:47,000 --> 00:33:50,000
V té době přístup k prvkům jejich index

559
00:33:50,000 --> 00:33:52,000
nebo jejich polohy, nebo kde jsou v poli,

560
00:33:52,000 --> 00:33:57,000
a že zápis začíná 0.

561
00:33:57,000 --> 00:34:00,000
Můžeme také pole polí,

562
00:34:00,000 --> 00:34:03,000
a to se nazývá multi-dimenzionální pole.

563
00:34:03,000 --> 00:34:05,000
Když máme multi-dimenzionální pole

564
00:34:05,000 --> 00:34:07,000
to znamená, že můžeme mít něco jako řádků a sloupců,

565
00:34:07,000 --> 00:34:11,000
a to je jen jeden způsob, jak vizualizaci tohoto nebo o tom přemýšlet.

566
00:34:11,000 --> 00:34:14,000
Když mám multi-dimenzionální pole, které znamená, že začnu potřebovat

567
00:34:14,000 --> 00:34:17,000
více než 1 index, protože když budu mít mřížku

568
00:34:17,000 --> 00:34:19,000
Jen říkám, co řádek jste v nedává číslo.

569
00:34:19,000 --> 00:34:22,000
To je opravdu jen nám dá seznam čísel.

570
00:34:22,000 --> 00:34:25,000
Řekněme, že mám toto pole zde.

571
00:34:25,000 --> 00:34:30,000
Mám pole s názvem síť, a já říkám, že tyto 2 řádky a 3 sloupce,

572
00:34:30,000 --> 00:34:32,000
a tak to je jeden ze způsobů, vizualizaci ji.

573
00:34:32,000 --> 00:34:37,000
Když řeknu, že já se chci dostat prvek na [1] [2]

574
00:34:37,000 --> 00:34:41,000
to znamená, že proto, že se jedná o řádky a pak sloupce

575
00:34:41,000 --> 00:34:44,000
Chystám se skočit na řádku 1, protože jsem řekla 1.

576
00:34:44,000 --> 00:34:49,000
>> Pak budu sem přišel do sloupce 2, a budu-li získat hodnotu 6.

577
00:34:49,000 --> 00:34:51,000
Smysl?

578
00:34:51,000 --> 00:34:55,000
Multi-dimenzionální pole, pamatujte, jsou technicky jen pole polí.

579
00:34:55,000 --> 00:34:57,000
Můžeme mít matice polí polí.

580
00:34:57,000 --> 00:35:00,000
Můžeme pokračovat, ale opravdu jediný způsob, jak přemýšlet o

581
00:35:00,000 --> 00:35:03,000
jak je právě toto stanoveny a co se děje, je představit si to

582
00:35:03,000 --> 00:35:09,000
v mřížce, jako je to.

583
00:35:09,000 --> 00:35:12,000
Když jsme se projít pole k funkcím, jdou chovat

584
00:35:12,000 --> 00:35:16,000
trochu jinak, než když jsme se projít pravidelné proměnné funkcí

585
00:35:16,000 --> 00:35:18,000
jako složením int nebo float.

586
00:35:18,000 --> 00:35:21,000
Když jsme se projít v int nebo char nebo některý z těchto jiných datových typů

587
00:35:21,000 --> 00:35:24,000
právě jsme se podívat na, pokud funkce mění

588
00:35:24,000 --> 00:35:28,000
hodnota této proměnné je tato změna nebude šířit do

589
00:35:28,000 --> 00:35:32,000
volající funkci.

590
00:35:32,000 --> 00:35:35,000
S pole, na druhé straně, se tak stalo.

591
00:35:35,000 --> 00:35:39,000
Pokud se projít v poli na nějakou funkci, a že funkce mění některé prvky,

592
00:35:39,000 --> 00:35:43,000
když jsem se vrátil do funkce, která je volána

593
00:35:43,000 --> 00:35:47,000
moje pole je nyní bude lišit, a slovník pro které

594
00:35:47,000 --> 00:35:50,000
je pole jsou předány formou odkazu, jak uvidíme později.

595
00:35:50,000 --> 00:35:53,000
To se týká jak ukazovátka práce, kde tyto základní datové typy,

596
00:35:53,000 --> 00:35:55,000
na druhé straně, jsou předány hodnotou.

597
00:35:55,000 --> 00:35:59,000
>> Můžeme to brát jako vytvoření kopie některé proměnné a pak předá v kopii.

598
00:35:59,000 --> 00:36:01,000
Nezáleží na tom, co uděláme s této proměnné.

599
00:36:01,000 --> 00:36:06,000
Volání funkce nebude vědom toho, že došlo ke změně.

600
00:36:06,000 --> 00:36:10,000
Pole jsou jen trochu liší v tomto ohledu.

601
00:36:10,000 --> 00:36:13,000
Například, jak jsme viděli, hlavní je prostě funkce

602
00:36:13,000 --> 00:36:15,000
které mohou mít v 2 argumenty.

603
00:36:15,000 --> 00:36:20,000
První argument hlavní funkci je argc, nebo počet argumentů,

604
00:36:20,000 --> 00:36:23,000
a druhý argument se nazývá argv,

605
00:36:23,000 --> 00:36:27,000
a ty jsou skutečné hodnoty těchto argumentů.

606
00:36:27,000 --> 00:36:30,000
Řekněme, že mám program s názvem this.c,

607
00:36:30,000 --> 00:36:34,000
a říkám, aby to, a já budu běžet do příkazového řádku.

608
00:36:34,000 --> 00:36:38,000
Nyní předat některé argumenty k mému programu volal toto,

609
00:36:38,000 --> 00:36:42,000
Mohl bych říct něco. / Je to cs 50.

610
00:36:42,000 --> 00:36:45,000
To je to, co si představujeme, David dělat každý den na terminálu.

611
00:36:45,000 --> 00:36:48,000
Ale teď je hlavní funkcí uvnitř tohoto programu

612
00:36:48,000 --> 00:36:52,000
má tyto hodnoty, tak argc je 4.

613
00:36:52,000 --> 00:36:56,000
To by mohlo být trochu matoucí, protože opravdu jsme jen procházet v je cs 50.

614
00:36:56,000 --> 00:36:58,000
To je jen 3.

615
00:36:58,000 --> 00:37:02,000
Ale pamatujte si, že první prvek argv nebo první argument

616
00:37:02,000 --> 00:37:05,000
je název funkce sám.

617
00:37:05,000 --> 00:37:07,190
Takže to znamená, že máme 4 věci tady,

618
00:37:07,190 --> 00:37:10,530
a první prvek bude. / tohle.

619
00:37:10,530 --> 00:37:12,970
A to bude reprezentován jako řetězec.

620
00:37:12,970 --> 00:37:18,590
Pak Zbývající prvky jsou tím, co jsme zadali v po názvu programu.

621
00:37:18,590 --> 00:37:22,720
Tedy stejně jako stranou, jak jsme asi viděli v PSet 2,

622
00:37:22,720 --> 00:37:28,780
nezapomeňte, že řetězec 50 se ≠ celočíselnou 50.

623
00:37:28,780 --> 00:37:32,520
Takže nemůžeme říct něco jako, 'int x = argv 3. "

624
00:37:32,520 --> 00:37:36,470
>> To se prostě nebude dávat smysl, protože je to řetězec, a to je celé číslo.

625
00:37:36,470 --> 00:37:38,510
Takže pokud chcete převést mezi 2, pamatujte, budeme

626
00:37:38,510 --> 00:37:40,810
mají to kouzlo funkci s názvem atoi.

627
00:37:40,810 --> 00:37:46,270
To trvá řetězec a vrátí celé číslo reprezentované uvnitř tohoto řetězce.

628
00:37:46,270 --> 00:37:48,360
Tak to je chybka se snadno vloudí na kvíz,

629
00:37:48,360 --> 00:37:51,590
si myslel, že to bude automaticky správný typ.

630
00:37:51,590 --> 00:37:53,860
Ale prostě vím, že to bude vždy řetězce

631
00:37:53,860 --> 00:38:00,920
i když řetězec obsahuje pouze celé číslo nebo znak, nebo plavat.

632
00:38:00,920 --> 00:38:03,380
Takže teď pojďme mluvit o jízdní doby.

633
00:38:03,380 --> 00:38:06,700
Když máme všechny tyto algoritmy, které umí všechny tyto šílené věci,

634
00:38:06,700 --> 00:38:11,580
se stává opravdu užitečné si položit otázku, "Jak dlouho trvá?"

635
00:38:11,580 --> 00:38:15,500
Zastupujeme že s tzv. asymptotické notace.

636
00:38:15,500 --> 00:38:18,430
Takže to znamená, že - no, řekněme, že jsme dát náš algoritmus

637
00:38:18,430 --> 00:38:20,840
některé opravdu, opravdu, opravdu velký vstup.

638
00:38:20,840 --> 00:38:23,840
Chceme si položit otázku, "Jak dlouho to bude trvat?

639
00:38:23,840 --> 00:38:26,370
Kolik kroků bude trvat naše algoritmus běžet

640
00:38:26,370 --> 00:38:29,980
v závislosti na velikosti vstupu? "

641
00:38:29,980 --> 00:38:33,080
Takže první způsob, jak můžeme popsat doba chodu je s velkým O.

642
00:38:33,080 --> 00:38:35,380
A tohle je náš nejhorší doba doběhu.

643
00:38:35,380 --> 00:38:38,590
Takže pokud chceme třídit pole, a dáváme náš algoritmus pole

644
00:38:38,590 --> 00:38:41,000
to v sestupném pořadí, kdy by mělo být ve vzestupném pořadí,

645
00:38:41,000 --> 00:38:43,130
že to bude nejhorší.

646
00:38:43,130 --> 00:38:49,800
To je naše horní mez v maximální dobu náš algoritmus bude trvat.

647
00:38:49,800 --> 00:38:54,740
Na druhé straně, tato Ω bude popisovat nejlepším případě chodu.

648
00:38:54,740 --> 00:38:58,210
Takže pokud dáme již seřazena pole na třídění algoritmu,

649
00:38:58,210 --> 00:39:00,940
jak dlouho bude trvat, než se tento oříšek?

650
00:39:00,940 --> 00:39:06,610
A to, pak, popisuje dolní mez na běh času.

651
00:39:06,610 --> 00:39:10,980
Takže tady jsou jen některá slova, která popisují některé běžné provozní dobu.

652
00:39:10,980 --> 00:39:13,120
Jsou ve vzestupném pořadí.

653
00:39:13,120 --> 00:39:16,060
Nejrychlejší doba chodu máme se nazývá konstanta.

654
00:39:16,060 --> 00:39:19,800
>> To znamená, že bez ohledu na to, kolik prvků jsme dát náš algoritmus,

655
00:39:19,800 --> 00:39:22,280
bez ohledu na to, jak velký náš pole je řazení je

656
00:39:22,280 --> 00:39:26,510
aneb co děláme na poli bude vždy stejné množství času.

657
00:39:26,510 --> 00:39:30,270
Takže můžeme prohlašujete, že jen s 1, která je konstantní.

658
00:39:30,270 --> 00:39:32,410
Také jsme se podívali na logaritmickém běhu.

659
00:39:32,410 --> 00:39:34,800
Takže něco jako binární vyhledávání je logaritmická,

660
00:39:34,800 --> 00:39:37,140
kde jsme zkrátili problém polovina pokaždé

661
00:39:37,140 --> 00:39:40,970
a pak se věci jen získat vyšší odtamtud.

662
00:39:40,970 --> 00:39:43,580
A pokud jste někdy psaní O každé faktoriál algoritmu,

663
00:39:43,580 --> 00:39:47,850
měli byste brát v úvahu to jako váš pracovní den.

664
00:39:47,850 --> 00:39:53,910
Když jsme tyto provozní dobu je důležité mít na paměti tyto věci.

665
00:39:53,910 --> 00:39:57,760
Takže pokud mám algoritmus, který je O (n), a někdo jiný

666
00:39:57,760 --> 00:40:03,590
je algoritmus O (2n) jsou vlastně asymptoticky ekvivalentní.

667
00:40:03,590 --> 00:40:06,590
Takže pokud bychom si představit, n být velké číslo jako Eleventy miliard:

668
00:40:06,590 --> 00:40:13,090
takže když jsme srovnání Eleventy miliardy na něco, jako je Eleventy miliard + 3,

669
00:40:13,090 --> 00:40:17,640
náhle, že 3 není opravdu velký rozdíl už.

670
00:40:17,640 --> 00:40:20,980
To je důvod, proč budeme začít zvažovat tyto věci za rovnocenné.

671
00:40:20,980 --> 00:40:24,220
Takže věci jako tyto konstanty, je tu 2 x to, nebo přidáním 3,

672
00:40:24,220 --> 00:40:27,180
to jsou jen konstanty, a ty jsou v úmyslu položit nahoru.

673
00:40:27,180 --> 00:40:32,480
Takže to je důvod, proč všechny 3 z těchto dobách chodu jsou stejné jako říkat, že oni to O (n).

674
00:40:32,480 --> 00:40:37,490
Podobně, pokud máme 2 další dobu chodu, řekněme O (n ³ + 2n ²), můžeme přidat

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, a pak máme další dobu běhu, který je jen O (n ³).

676
00:40:42,070 --> 00:40:46,290
Ani v tomto případě je to samé, protože to - to nejsou stejné.

677
00:40:46,290 --> 00:40:49,840
Jedná se o stejné věci, je mi líto. To jsou stejné, protože

678
00:40:49,840 --> 00:40:53,090
Tento ³ n se bude ovládat tento 2n ².

679
00:40:53,090 --> 00:40:59,130
>> Co není totéž, je-li jsme běžet časy jako O (n ³) a O (n ²)

680
00:40:59,130 --> 00:41:02,820
protože ³ n je mnohem větší než tento ² n.

681
00:41:02,820 --> 00:41:05,470
Takže pokud máme exponenty, najednou to začne záležet,

682
00:41:05,470 --> 00:41:08,280
ale když jsme jen jednání s faktory, jako my tady,

683
00:41:08,280 --> 00:41:12,810
pak to nebude záležet, protože se právě chystá odejít.

684
00:41:12,810 --> 00:41:16,760
Pojďme se podívat na některé z algoritmů jsme viděli doposud

685
00:41:16,760 --> 00:41:19,260
a mluvit o jejich běhu.

686
00:41:19,260 --> 00:41:23,850
První způsob pohledu na čísla v seznamu, který jsme viděli, byl lineární hledání.

687
00:41:23,850 --> 00:41:26,950
A provádění lineární hledání je super jednoduché.

688
00:41:26,950 --> 00:41:30,490
Musíme jen seznam, a budeme se dívat na každý jednotlivý prvek v seznamu

689
00:41:30,490 --> 00:41:34,260
dokud nenajdeme číslo jsme hledali.

690
00:41:34,260 --> 00:41:38,370
To znamená, že v nejhorším případě, to O (n).

691
00:41:38,370 --> 00:41:40,860
A v nejhorším případě zde může být v případě, že element je

692
00:41:40,860 --> 00:41:45,710
poslední prvek, pak pomocí lineární hledání, musíme se podívat na každý element

693
00:41:45,710 --> 00:41:50,180
dokud se na poslední, aby věděli, že to bylo vlastně v seznamu.

694
00:41:50,180 --> 00:41:52,910
Nemůžeme jen tak vzdal v půli cesty a řekl: "Je to asi není."

695
00:41:52,910 --> 00:41:55,980
S lineární hledání se musíme podívat na celou věc.

696
00:41:55,980 --> 00:41:59,090
Nejlepší případu doba doběhu, na druhé straně, je konstantní

697
00:41:59,090 --> 00:42:04,200
protože v nejlepším případě je prvek, kterého hledáme, je jen první v seznamu.

698
00:42:04,200 --> 00:42:08,930
Takže to bude trvat nám přesně 1 krok, bez ohledu na to, jak velký je seznam

699
00:42:08,930 --> 00:42:12,140
pokud hledáme pro první prvek pokaždé.

700
00:42:12,140 --> 00:42:15,390
>> Takže když hledáte, pamatujte, že nevyžaduje, že náš seznam být seřazeny.

701
00:42:15,390 --> 00:42:19,430
Vzhledem k tomu, že jsme prostě bude vypadat v průběhu každého jednotlivého prvku, a to nezáleží

702
00:42:19,430 --> 00:42:23,560
jakém pořadí tyto prvky jsou v.

703
00:42:23,560 --> 00:42:28,110
Více inteligentní vyhledávací algoritmus je něco jako binární vyhledávání.

704
00:42:28,110 --> 00:42:31,500
Pamatujte si, že implementace binárního vyhledávání je, když jdete na

705
00:42:31,500 --> 00:42:34,320
Dívej se na středu seznamu.

706
00:42:34,320 --> 00:42:38,000
A protože se díváme na středu, požadujeme, aby Seznam je řazen

707
00:42:38,000 --> 00:42:40,580
jinak nevíme, kde uprostřed je, a musíme se podívat na

708
00:42:40,580 --> 00:42:44,480
celý seznam najít, a pak na tom místě jsme jen ztrácíš čas.

709
00:42:44,480 --> 00:42:48,480
Takže pokud máme seřazený seznam a najdeme uprostřed, budeme srovnávat střed

710
00:42:48,480 --> 00:42:51,590
na prvek, kterého hledáme.

711
00:42:51,590 --> 00:42:54,640
Pokud je to příliš vysoká, pak můžeme zapomenout na pravou polovinu

712
00:42:54,640 --> 00:42:57,810
protože víme, že když náš element je již příliš vysoká

713
00:42:57,810 --> 00:43:01,080
a vše napravo od tohoto prvku je dokonce vyšší,

714
00:43:01,080 --> 00:43:02,760
pak nepotřebujeme hledat tam už.

715
00:43:02,760 --> 00:43:05,430
Tam, kde na druhé straně, pokud náš prvek je příliš nízká,

716
00:43:05,430 --> 00:43:08,700
víme všechno vlevo od tohoto prvku je také příliš nízká,

717
00:43:08,700 --> 00:43:11,390
tak to nemá moc smysl se podívat tam, a to buď.

718
00:43:11,390 --> 00:43:15,760
Tímto způsobem, s každým krokem a pokaždé, když se podíváte na středu seznamu,

719
00:43:15,760 --> 00:43:19,060
budeme řezat náš problém v polovině, protože najednou víme

720
00:43:19,060 --> 00:43:23,040
celá parta čísel, která nemůže být ten, kterého hledáme.

721
00:43:23,040 --> 00:43:26,950
>> V pseudokódu by vypadat nějak takto,

722
00:43:26,950 --> 00:43:30,990
a protože jsme řezání seznam v polovině každé době,

723
00:43:30,990 --> 00:43:34,920
naše nejhorších skoky Run Time z lineární do logaritmická.

724
00:43:34,920 --> 00:43:39,260
Takže najednou máme log-in kroků s cílem najít element v seznamu.

725
00:43:39,260 --> 00:43:42,460
Best case doba doběhu, i když je stále konstantní

726
00:43:42,460 --> 00:43:45,180
protože teď, řekněme, že prvek hledáme, je

727
00:43:45,180 --> 00:43:48,380
vždy přesný střed původního seznamu.

728
00:43:48,380 --> 00:43:52,080
Takže můžeme pěstovat naši nabídku tak velký, jak bychom chtěli, ale pokud element hledáme, je v polovině,

729
00:43:52,080 --> 00:43:54,910
pak je to jen bude nám trvat 1 krok.

730
00:43:54,910 --> 00:44:00,920
Takže to je důvod, proč jsme O (log n) a Ω (1), nebo konstantní.

731
00:44:00,920 --> 00:44:04,510
Pojďme skutečně spustit binární vyhledávání na tomto seznamu.

732
00:44:04,510 --> 00:44:08,020
Takže řekněme, že jsme hledali prvku 164.

733
00:44:08,020 --> 00:44:11,650
První věc, kterou se chystáte udělat, je najít střed tohoto seznamu.

734
00:44:11,650 --> 00:44:15,060
To jen tak se stane, že střed bude klesat mezi těmito 2 čísla,

735
00:44:15,060 --> 00:44:18,960
tak ať to prostě libovolně sice pokaždé, když střed spadá mezi 2 čísla,

736
00:44:18,960 --> 00:44:21,150
řekněme, zaokrouhlit nahoru.

737
00:44:21,150 --> 00:44:24,330
Potřebujeme jen ujistit, že jsme to na každém kroku na cestě.

738
00:44:24,330 --> 00:44:29,040
Takže budeme zaokrouhlovat, a budeme říkat, že 161 je uprostřed našeho seznamu.

739
00:44:29,040 --> 00:44:34,640
So 161 <164, a každý prvek vlevo 161

740
00:44:34,640 --> 00:44:39,120
je také <164, takže víme, že to nepomůže nám vůbec

741
00:44:39,120 --> 00:44:42,690
začít hledat tady, protože element jsme hledali nemůže být tam.

742
00:44:42,690 --> 00:44:47,060
Takže to, co můžeme udělat, je, že jsme se prostě zapomenout o tom celé levé poloviny seznamu,

743
00:44:47,060 --> 00:44:51,700
a nyní jen zvážila z práva na 161 kupředu.

744
00:44:51,700 --> 00:44:54,050
>> Takže znovu, je to střed, řekněme, zaokrouhlit nahoru.

745
00:44:54,050 --> 00:44:56,260
Nyní 175 je příliš velká.

746
00:44:56,260 --> 00:44:59,180
Tak jsme vím, že to nepomůže nám hledají tady nebo tady,

747
00:44:59,180 --> 00:45:06,610
takže můžeme jen hodit to pryč, a nakonec budeme hit 164.

748
00:45:06,610 --> 00:45:10,560
Jakékoliv dotazy týkající se binární vyhledávání?

749
00:45:10,560 --> 00:45:14,180
Pojďme dál od vyhledávání přes již tříděném seznamu

750
00:45:14,180 --> 00:45:17,660
skutečně vezme seznam čísel v libovolném pořadí

751
00:45:17,660 --> 00:45:20,960
a poskytování tohoto seznamu ve vzestupném pořadí.

752
00:45:20,960 --> 00:45:24,060
První algoritmus jsme se dívali na říkalo bubble sort.

753
00:45:24,060 --> 00:45:27,300
A to by bylo jednodušší z algoritmů, které jsme viděli.

754
00:45:27,300 --> 00:45:32,970
Bubble sort říká, že když nějaké 2 prvky uvnitř seznamu jsou na místě,

755
00:45:32,970 --> 00:45:36,500
což znamená, že je větší počet na levé straně nižšího počtu,

756
00:45:36,500 --> 00:45:40,190
pak budeme vyměnit je, protože to znamená, že seznam bude

757
00:45:40,190 --> 00:45:42,860
"Více seřazena", než tomu bylo dříve.

758
00:45:42,860 --> 00:45:45,180
A my jsme jen tak pro pokračování tohoto procesu znovu a znovu a znovu

759
00:45:45,180 --> 00:45:52,100
až nakonec prvky druh bubliny na jejich správné umístění a máme seřazený seznam.

760
00:45:52,100 --> 00:45:57,230
>> Běh času je to bude O (n ²). Proč?

761
00:45:57,230 --> 00:46:00,370
No, protože v nejhorším případě, budeme brát každý prvek, a

762
00:46:00,370 --> 00:46:04,570
budeme skončit srovnání s každou další prvek v seznamu.

763
00:46:04,570 --> 00:46:08,030
Ale v tom nejlepším případě, máme již seřazený seznam, bublina sort je

764
00:46:08,030 --> 00:46:12,230
jen tak projít jednou, řeknu "Ne. Neudělal jsem žádné swapy, tak jsem udělal."

765
00:46:12,230 --> 00:46:17,410
Takže máme nejlepší případovou doba chodu Ω (n).

766
00:46:17,410 --> 00:46:20,680
Spusťme bublina třídění v seznamu.

767
00:46:20,680 --> 00:46:23,560
Nebo první, pojďme se podívat na některé pseudokódu opravdu rychle.

768
00:46:23,560 --> 00:46:28,160
Chceme, že chceme sledovat, v každé iteraci smyčky,

769
00:46:28,160 --> 00:46:32,190
mít přehled o tom, zda jsme nebo nejsme měnit žádné prvky.

770
00:46:32,190 --> 00:46:37,610
Takže důvod pro to je, budeme zastavit, když jsme se vyměnili žádné prvky.

771
00:46:37,610 --> 00:46:41,980
Takže na začátku našeho cyklu jsme se vyměnili nic, tak budeme říkat, že je to pravda.

772
00:46:41,980 --> 00:46:47,170
Nyní, budeme procházet seznam a porovnejte prvek i pro element i + 1

773
00:46:47,170 --> 00:46:50,310
a je-li tomu tak, že je větší počet na levé straně menší počet,

774
00:46:50,310 --> 00:46:52,310
pak jsme jen tak vyměnit je.

775
00:46:52,310 --> 00:46:54,490
>> A pak budeme mít na paměti, že jsme vyměnili prvek.

776
00:46:54,490 --> 00:46:58,900
To znamená, že musíme projít seznam alespoň 1 více času

777
00:46:58,900 --> 00:47:02,160
protože stav, ve kterém jsme se zastavili je, když je celý seznam již řazeno,

778
00:47:02,160 --> 00:47:04,890
což znamená, jsme neprovedli žádné swapy.

779
00:47:04,890 --> 00:47:09,960
Takže to je důvod, proč naše podmínka tady dole je ", zatímco některé prvky byly prohozeny."

780
00:47:09,960 --> 00:47:13,720
Takže teď pojďme se podívat na to běží na seznamu.

781
00:47:13,720 --> 00:47:16,640
Mám seznam 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Bubble sort je začnou celou cestu vlevo, a to bude k porovnání

783
00:47:19,850 --> 00:47:24,700
se i prvky, takže 0 až i + 1, což je prvek 1.

784
00:47:24,700 --> 00:47:29,020
Bude to říct, i 5> 0, ale teď 5 je nalevo,

785
00:47:29,020 --> 00:47:32,500
tak musím vyměnit 5 a 0.

786
00:47:32,500 --> 00:47:35,470
Když jsem je swap, najednou jsem si to jiný seznam.

787
00:47:35,470 --> 00:47:38,260
Nyní 5> 1, takže budeme vyměnit je.

788
00:47:38,260 --> 00:47:42,160
5 není> 6, takže nemusíte dělat nic.

789
00:47:42,160 --> 00:47:46,690
Ale 6> 4, takže musíme vyměnit.

790
00:47:46,690 --> 00:47:49,740
Znovu musíme projít celý seznam nakonec objevit

791
00:47:49,740 --> 00:47:52,330
že tyto jsou mimo provoz, vyměníme je,

792
00:47:52,330 --> 00:47:57,120
a na tomto místě musíme projít seznam 1 více času

793
00:47:57,120 --> 00:48:05,390
aby se ujistil, že vše, co je v jeho pořadí, a v tomto bodě bubliny řadit dokončení.

794
00:48:05,390 --> 00:48:10,720
Jiný algoritmus pro přijetí některých prvků a jejich třídění je výběr sort.

795
00:48:10,720 --> 00:48:15,740
Myšlenka výběru druhu je, že budeme budovat seřazena část seznamu

796
00:48:15,740 --> 00:48:18,150
1 prvek najednou.

797
00:48:18,150 --> 00:48:23,170
>> A jak budeme dělat, že je tím, že staví na levé segment seznamu.

798
00:48:23,170 --> 00:48:27,510
A v podstatě každý - na každém kroku, budeme mít nejmenší prvek jsme vlevo

799
00:48:27,510 --> 00:48:32,310
která nebyla seřazena ještě, a budeme jej přesunout do té seřazeny segmentu.

800
00:48:32,310 --> 00:48:35,850
To znamená, že musíme neustále najít minimální směsný prvek

801
00:48:35,850 --> 00:48:40,720
a pak, že minimální prvek a vyměnit ji, co

802
00:48:40,720 --> 00:48:45,090
nejvíce vlevo prvek, který není seřazena.

803
00:48:45,090 --> 00:48:50,890
Spustit čas to bude O (n ²), protože v nejhorším případě

804
00:48:50,890 --> 00:48:55,070
musíme porovnat každý jednotlivý prvek ke každému jinému prvku.

805
00:48:55,070 --> 00:48:59,250
Vzhledem k tomu, říkáme, že pokud začneme na levé polovině seznamu, musíme

806
00:48:59,250 --> 00:49:02,970
projít celou pravou segmentu najít nejmenší prvek.

807
00:49:02,970 --> 00:49:05,430
A pak, opět musíme jít přes celou pravou část a

808
00:49:05,430 --> 00:49:08,210
dál nad tím znovu a znovu a znovu.

809
00:49:08,210 --> 00:49:11,350
To bude mít n ². Budeme potřebovat pro smyčky uvnitř jiného pro smyčky

810
00:49:11,350 --> 00:49:13,350
což naznačuje, n ².

811
00:49:13,350 --> 00:49:16,530
V nejlepším případě myšlení, řekněme, že jej již seřazený seznam;

812
00:49:16,530 --> 00:49:19,270
jsme vlastně neděláme nic lépe, než ² n.

813
00:49:19,270 --> 00:49:21,730
Vzhledem k tomu, Výběr způsob má žádný způsob, jak zjistit, že

814
00:49:21,730 --> 00:49:25,540
minimální prvek je jen jeden I stalo se dívá.

815
00:49:25,540 --> 00:49:28,970
To ještě potřebuje, aby se ujistil, že je to vlastně minimum.

816
00:49:28,970 --> 00:49:31,670
>> A jediný způsob, jak se ujistit, že je to minimum, pomocí tohoto algoritmu,

817
00:49:31,670 --> 00:49:34,640
je podívat se na každý jednotlivý prvek znovu.

818
00:49:34,640 --> 00:49:38,420
Takže opravdu, pokud mi ji - pokud dáte výběrem Třídit již seřazený seznam,

819
00:49:38,420 --> 00:49:42,720
to nebude o nic lépe, než dávat to seznam, který není seřazena ještě.

820
00:49:42,720 --> 00:49:46,320
Mimochodem, pokud se to stane, že je pravda, že něco je O (něco)

821
00:49:46,320 --> 00:49:50,640
a omega něčeho, můžeme jen říct stručněji, že je to θ něco.

822
00:49:50,640 --> 00:49:52,760
Takže pokud vidíte, že přijít kamkoliv, to je to, co to znamená jen.

823
00:49:52,760 --> 00:49:57,580
>> Pokud je něco theta n ², je to tak velký O (n ²) a Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Takže nejlepším případě a nejhorší případ, to neznamená, že rozdíl,

825
00:49:59,790 --> 00:50:04,400
algoritmus se chystá udělat stejnou věc pokaždé.

826
00:50:04,400 --> 00:50:06,610
Tak tohle je to, co pseudokód pro výběr druhu by mohl vypadat.

827
00:50:06,610 --> 00:50:10,630
Jsme v podstatě říct, že chci iteraci seznam

828
00:50:10,630 --> 00:50:15,180
zleva doprava, a na každé opakování smyčky, budu se pohybovat

829
00:50:15,180 --> 00:50:19,780
Minimální prvek do tohoto tříděného části seznamu.

830
00:50:19,780 --> 00:50:23,260
A jednou jsem přesunout tam něco, nikdy jsem třeba podívat se na tento prvek znovu.

831
00:50:23,260 --> 00:50:28,600
Vzhledem k tomu, jakmile jsem vyměnit prvek do levého segmentu seznamu, je seřazena it

832
00:50:28,600 --> 00:50:32,600
protože děláme všechno ve vzestupném pořadí pomocí minima.

833
00:50:32,600 --> 00:50:38,740
Tak jsme si řekli, jo, jsme na pozici i, a musíme se podívat na všechny prvky

834
00:50:38,740 --> 00:50:42,260
vpravo i s cílem nalézt minimální.

835
00:50:42,260 --> 00:50:46,150
Takže to znamená, že chceme vypadat od i + 1 na konec seznamu.

836
00:50:46,150 --> 00:50:51,610
A nyní, v případě, že prvek, který jsme v současné době při pohledu na méně než naše minimum tak daleko,

837
00:50:51,610 --> 00:50:54,190
které, pamatujte, začínáme minimální off být jen

838
00:50:54,190 --> 00:50:57,020
bez ohledu na element jsme v současné době, budu předpokládat, že je to minimum.

839
00:50:57,020 --> 00:51:00,270
Pokud najdu prvek, který je menší než to, že pak budu říkat, jo,

840
00:51:00,270 --> 00:51:02,700
dobře, jsem našel novou minimální.

841
00:51:02,700 --> 00:51:06,080
Budu si pamatovat, kde který minimum bylo.

842
00:51:06,080 --> 00:51:09,560
>> Takže teď, poté, co jsem prošel toto právo netříděného segmentu,

843
00:51:09,560 --> 00:51:16,690
Můžu říct, že jsem jít vyměnit minimální prvek s prvkem, který je v poloze I.

844
00:51:16,690 --> 00:51:21,100
To bude vybudovat svůj seznam, moje seřazena část seznamu zleva doprava,

845
00:51:21,100 --> 00:51:25,190
a nemáme vůbec třeba se podívat na prvek znovu, jakmile je to v této části.

846
00:51:25,190 --> 00:51:27,930
Jakmile jsme vyměnili ho.

847
00:51:27,930 --> 00:51:30,260
Takže pojďme běžet výběr druhu na tomto seznamu.

848
00:51:30,260 --> 00:51:38,220
Modrý prvek zde bude i, a červený prvek bude minimální prvek.

849
00:51:38,220 --> 00:51:41,570
Tak jsem spustí celou cestu vlevo od seznamu, tak na 5.

850
00:51:41,570 --> 00:51:44,610
Nyní musíme najít minimální směsný prvek.

851
00:51:44,610 --> 00:51:49,480
Tak jsme říci, 0 <5, takže 0 je můj nový minimum.

852
00:51:49,480 --> 00:51:53,820
>> Ale já se nemůže zastavit tam, protože i když jsme si uvědomit, že 0 je nejmenší,

853
00:51:53,820 --> 00:51:59,390
musíme projít každý jiný prvek seznamu, aby se ujistil.

854
00:51:59,390 --> 00:52:01,760
Takže 1 je větší, 6 je větší, 4 je větší.

855
00:52:01,760 --> 00:52:05,850
To znamená, že po pohledu na všechny tyto prvky, jsem určuje 0 je nejmenší.

856
00:52:05,850 --> 00:52:09,800
Takže budu přestavení 5 a 0.

857
00:52:09,800 --> 00:52:15,480
Jakmile jsem vyměnit, že jdu si pořídit nový seznam, a já vím, že jsem nikdy nebudete muset dívat na této 0 znovu

858
00:52:15,480 --> 00:52:19,380
protože jakmile jsem vyměnil to, jsem seřazena, a jsme hotovi.

859
00:52:19,380 --> 00:52:22,730
Nyní je jen tak se stane, že modrý prvek je opět 5,

860
00:52:22,730 --> 00:52:26,030
a musíme se podívat na 1, 6 a 4 určit, že 1

861
00:52:26,030 --> 00:52:31,520
je nejmenší minimální prvek, takže budeme vyměnit 1 a 5.

862
00:52:31,520 --> 00:52:36,890
Opět, musíme se podívat na - porovnejte 5 na 6 a 4,

863
00:52:36,890 --> 00:52:39,830
a budeme zaměnit 4 a 5, a konečně, tyto

864
00:52:39,830 --> 00:52:45,740
tato 2 čísla a vyměnit je, dokud jsme si naše seřazený seznam.

865
00:52:45,740 --> 00:52:49,730
Jakékoliv dotazy týkající se výběru druhu?

866
00:52:49,730 --> 00:52:56,420
Dobře. Pojďme na poslední téma zde, a že je rekurze.

867
00:52:56,420 --> 00:52:59,810
>> Rekurze, pamatujte, je to opravdu meta věc, kde funkce

868
00:52:59,810 --> 00:53:02,740
opakovaně volá sám.

869
00:53:02,740 --> 00:53:05,620
Takže v určitém okamžiku, zatímco naše fuction je opakovaně volá sama,

870
00:53:05,620 --> 00:53:10,100
zde musí být nějaký bod, ve kterém jsme se přestat volat sami.

871
00:53:10,100 --> 00:53:13,670
Protože pokud to neuděláme, pak jsme jen tak, aby i nadále dělat navždy,

872
00:53:13,670 --> 00:53:16,660
a náš program se prostě nebude ukončit.

873
00:53:16,660 --> 00:53:19,200
Říkáme tato podmínka referenční případ.

874
00:53:19,200 --> 00:53:22,570
A základní věc říká, spíše než volání funkce znovu,

875
00:53:22,570 --> 00:53:25,330
Já jsem prostě jít vrátit nějakou hodnotu.

876
00:53:25,330 --> 00:53:28,080
Takže jakmile jsme vrátili hodnotu, zastavili jsme volat sami,

877
00:53:28,080 --> 00:53:32,550
a zbytek volání jsme doposud vytvořili mohou také vracet.

878
00:53:32,550 --> 00:53:36,050
Naproti základní věci je rekurzivní případ.

879
00:53:36,050 --> 00:53:39,050
A to je, když chceme, aby se další volání funkce, že jsme v současné době palců

880
00:53:39,050 --> 00:53:44,690
A my asi, i když ne vždy, chcete použít různé argumenty.

881
00:53:44,690 --> 00:53:48,940
>> Takže pokud máme funkci nazvanou f a f právě volal vzít 1 argument,

882
00:53:48,940 --> 00:53:52,010
a my jsme dál označovat f (1), f (1), f (1), a to jen tak se stane, že

883
00:53:52,010 --> 00:53:56,510
Argument 1 spadá do rekurzivní případě, my ještě nikdy nezastaví.

884
00:53:56,510 --> 00:54:01,620
I když máme základní případ, musíme se ujistit, že nakonec budeme se zasáhnout, že základní věci.

885
00:54:01,620 --> 00:54:04,250
Nechceme jen držet pobyt v tomto případě rekurzivní.

886
00:54:04,250 --> 00:54:09,870
Obecně platí, že když jsme si říkali, že jsme pravděpodobně bude mít jiný argument, pokaždé.

887
00:54:09,870 --> 00:54:12,700
Zde je opravdu jednoduchý rekurzivní funkce.

888
00:54:12,700 --> 00:54:15,090
Takže to bude počítat faktoriál čísla.

889
00:54:15,090 --> 00:54:17,790
Nahoru Nahoru tady máme základní případ.

890
00:54:17,790 --> 00:54:22,330
V případě, že n ≤ 1, my nebudeme volat faktoriál znovu.

891
00:54:22,330 --> 00:54:26,490
Budeme se zastavit; jsme jen tak vrátit nějakou hodnotu.

892
00:54:26,490 --> 00:54:30,170
Pokud to není pravda, pak budeme hit naší rekurzivní případ.

893
00:54:30,170 --> 00:54:33,550
Všimněte si, že nejsme jen volat faktoriál (n), protože to by nebylo moc užitečné.

894
00:54:33,550 --> 00:54:36,810
Budeme volat faktoriál něco jiného.

895
00:54:36,810 --> 00:54:40,850
>> A tak můžete vidět, případně jestli míjíme faktoriál (5), nebo tak něco,

896
00:54:40,850 --> 00:54:45,900
budeme volat faktoriál (4), a tak dále, a nakonec budeme hit tohoto základního případu.

897
00:54:45,900 --> 00:54:51,730
Tak to vypadá dobře. Podívejme se, co se stane, když ve skutečnosti spustit tento.

898
00:54:51,730 --> 00:54:57,840
To je stack, a řekněme, že hlavní bude volat tuto funkci s argumentem (4).

899
00:54:57,840 --> 00:55:02,200
Takže jakmile faktoriál vidí a = 4, bude faktoriál volat sebe.

900
00:55:02,200 --> 00:55:05,010
Nyní, najednou, máme faktoriál (3).

901
00:55:05,010 --> 00:55:10,780
Takže tyto funkce budou nadále zvyšovat, až nakonec jsme narazili náš základní věc.

902
00:55:10,780 --> 00:55:17,830
V tomto bodě, návratová hodnota je návrat (nx návratová hodnota tohoto),

903
00:55:17,830 --> 00:55:21,290
návratová hodnota je nx návratová hodnota tohoto.

904
00:55:21,290 --> 00:55:23,290
Nakonec musíme zasáhnout určitý počet.

905
00:55:23,290 --> 00:55:26,560
Na vrcholu zde, říkáme návrat 1.

906
00:55:26,560 --> 00:55:30,650
To znamená, že jakmile se vrátíme toto číslo, můžeme pop to ze zásobníku.

907
00:55:30,650 --> 00:55:36,570
Takže tato faktoriál (1) je provedeno.

908
00:55:36,570 --> 00:55:41,190
Při 1 vrátí, tento faktoriál (1) přiznání, tento návrat k 1.

909
00:55:41,190 --> 00:55:46,910
Návratová hodnota tohoto, pamatujte, byl nx návratová hodnota tohoto.

910
00:55:46,910 --> 00:55:50,720
Tak náhle, tenhle chlap ví, že bych se chtěl vrátit 2.

911
00:55:50,720 --> 00:55:55,910
>> Takže si pamatujte, vrátí hodnota je jen nx návratová hodnota tady.

912
00:55:55,910 --> 00:56:01,160
Takže teď můžeme říci, 3 x 2, a konečně, zde můžeme říci,

913
00:56:01,160 --> 00:56:04,010
je to jen bude 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
A jakmile se vrátí, dostaneme se na jednotlivé celočíselné uvnitř hlavní.

915
00:56:09,570 --> 00:56:15,460
Jakékoliv dotazy týkající se rekurze?

916
00:56:15,460 --> 00:56:17,090
Dobrá. Takže tam je více času na otázky na konci,

917
00:56:17,090 --> 00:56:23,360
ale nyní Joseph bude týkat zbývajících témat.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] Dobře. Takže teď, že jsme mluvili o rekurze,

919
00:56:25,590 --> 00:56:27,840
pojďme mluvit trochu o tom, co sloučit druh je.

920
00:56:27,840 --> 00:56:31,740
Sloučit druh je v podstatě jiný způsob řazení seznamu čísel.

921
00:56:31,740 --> 00:56:36,430
A jak to funguje, je, s řadit slučovací máte seznam, a to, co děláme, je

922
00:56:36,430 --> 00:56:39,120
říkáme, pojďme rozdělit to do 2 poloviny.

923
00:56:39,120 --> 00:56:42,750
Budeme první běh sloučení druh znovu na levé polovině,

924
00:56:42,750 --> 00:56:45,040
pak budeme spouštět sloučení řazení na pravé polovině,

925
00:56:45,040 --> 00:56:50,240
a to nám dává nyní 2 poloviny, které jsou seřazeny, a teď budeme kombinovat tyto poloviny spolu.

926
00:56:50,240 --> 00:56:55,010
Je to trochu těžké vidět bez příkladu, takže pojedeme přes pohyby a uvidíme, co se stane.

927
00:56:55,010 --> 00:56:59,590
Takže začnete s tímto seznamem, rozdělili jsme jej do 2 poloviny.

928
00:56:59,590 --> 00:57:02,300
Provozujeme sloučení řazení na levé polovině první.

929
00:57:02,300 --> 00:57:06,660
Tak to je levá polovina, a teď jsme se spustit je přes tento seznam znovu

930
00:57:06,660 --> 00:57:09,800
která je předána do druhu korespondence, a pak se podíváme, znovu,

931
00:57:09,800 --> 00:57:13,270
na levé straně tohoto seznamu, a pořádáme sloučení druh na něm.

932
00:57:13,270 --> 00:57:15,880
Teď, dostaneme se do seznamu čísel 2,

933
00:57:15,880 --> 00:57:19,010
a teď levá polovina je jen 1 prvek dlouho, a my nemůžeme

934
00:57:19,010 --> 00:57:23,380
rozdělit seznam, který je jen 1 prvek do poloviny, a tak jsme jen říct, až budeme mít 50,

935
00:57:23,380 --> 00:57:26,400
který je jen 1 prvek, je to už jsou seřazena.

936
00:57:26,400 --> 00:57:29,860
>> Jakmile jsme hotovi s tím, můžeme vidět, že můžeme

937
00:57:29,860 --> 00:57:32,230
přejít na pravé polovině tohoto seznamu,

938
00:57:32,230 --> 00:57:36,480
a 3 je také tříděn, a tak teď, že obě poloviny tohoto seznamu jsou seřazeny

939
00:57:36,480 --> 00:57:39,080
můžeme spojit tato čísla dohromady.

940
00:57:39,080 --> 00:57:45,320
Tak jsme se podívat na 50 a 3, 3 je menší než 50, tak to jde v první a poté 50 vypovídací

941
00:57:45,320 --> 00:57:49,340
Nyní, to, že udělal, se vrátíme do tohoto seznamu a seřadit je to pravé polovině.

942
00:57:49,340 --> 00:57:52,440
42 je jeho vlastní číslo, takže to už jsou seřazena.

943
00:57:52,440 --> 00:57:57,850
Nyní tedy porovnávat 2 a 3, je menší než 42, tak, že se dostane dát do první,

944
00:57:57,850 --> 00:58:02,340
nyní 42 dostane dát do, a 50 dostane dát dovnitř

945
00:58:02,340 --> 00:58:07,220
Nyní, to je seřazena, jdeme celou cestu zpět na vrchol, 1337 a 15.

946
00:58:07,220 --> 00:58:14,560
No, se nyní podíváme na levé polovině tohoto seznamu; 1337 je samo o sobě, takže to jsou seřazena a to samé s 15.

947
00:58:14,560 --> 00:58:19,020
Takže teď jsme se spojit tyto 2 čísla takové, které původní seznam, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
tak to jde v první, pak 1337 jde dovnitř

949
00:58:23,060 --> 00:58:26,640
A teď jsou seřazena obě poloviny původního seznamu až nahoru.

950
00:58:26,640 --> 00:58:30,440
A vše, co musíme udělat, je spojit tyto.

951
00:58:30,440 --> 00:58:36,890
Dívali jsme se na prvních 2 čísel v tomto seznamu, 3 <15, tak to jde do třídění pole jako první.

952
00:58:36,890 --> 00:58:44,460
15 <42, tak to jde dovnitř Teď, 42 <1337, která vede dovnitř

953
00:58:44,460 --> 00:58:51,010
50 <1337, tak to jde dovnitř a zjistíte, že jsme si vzal 2 čísla off tohoto seznamu.

954
00:58:51,010 --> 00:58:53,640
Takže jsme nejen střídavě mezi 2 seznamy.

955
00:58:53,640 --> 00:58:56,050
Jsme jen se dívá na začátku, a my jsme se ujali prvek

956
00:58:56,050 --> 00:59:00,270
to je menší a pak uvedení do našeho pole.

957
00:59:00,270 --> 00:59:04,080
Nyní jsme se spojil všechny polovin a jsme hotovi.

958
00:59:04,080 --> 00:59:07,780
>> Jakékoliv dotazy týkající se korespondence druh? Ano?

959
00:59:07,780 --> 00:59:14,190
[Student] Pokud je to rozdělení do různých skupin, proč to prostě rozdělit jednou

960
00:59:14,190 --> 00:59:19,970
a máte 3 a 2 ve skupině? [Zbytek otázky nesrozumitelné]

961
00:59:19,970 --> 00:59:24,940
Důvod - takže otázkou je, proč nemůžeme prostě sloučit je v této první fázi poté, co jsme si je vzít?

962
00:59:24,940 --> 00:59:29,530
Důvodem, proč to udělat, začít na levé většina prvků na obou stranách,

963
00:59:29,530 --> 00:59:33,040
a pak ten menší a vložte jej do, je to, že víme, že tyto

964
00:59:33,040 --> 00:59:35,290
Jednotlivé seznamy jsou v seřazena objednávky.

965
00:59:35,290 --> 00:59:37,290
Takže pokud jsem při pohledu na levou většina prvků obou polovin,

966
00:59:37,290 --> 00:59:40,490
Já vím, že to bude nejmenší prvky těchto seznamů.

967
00:59:40,490 --> 00:59:43,930
Tak jsem je dát do nejmenších prvků místech této velké seznamu.

968
00:59:43,930 --> 00:59:47,810
Na druhou stranu, když se na těchto 2 seznamů v druhém stupni se tam,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 a 15, jsou ty, které nejsou seřazeny.

970
00:59:51,640 --> 00:59:55,770
Takže když se podívám na 50 a 1337, já dám 50 do mého seznamu jako první.

971
00:59:55,770 --> 01:00:00,130
Ale to není opravdu smysl, protože 3 je nejmenší prvek ze všech z nich.

972
01:00:00,130 --> 01:00:04,390
Takže jediný důvod, proč můžeme udělat tento krok, kombinující proto, že naše seznamy jsou již seřazeny.

973
01:00:04,390 --> 01:00:07,010
Což je důvod, proč jsme se pustit celou cestu až na dno

974
01:00:07,010 --> 01:00:09,800
protože když máme jen jedno číslo, víte, že jedno číslo

975
01:00:09,800 --> 01:00:14,120
samo o sobě je již seřazený seznam.

976
01:00:14,120 --> 01:00:19,360
>> Nějaké otázky? Ne?

977
01:00:19,360 --> 01:00:24,260
Složitost? No, vidíte, že v každém kroku je tu konec čísla,

978
01:00:24,260 --> 01:00:27,590
a můžeme rozdělit seznam na poloviny protokolu n časy,

979
01:00:27,590 --> 01:00:31,700
která je místo, kde jsme stáhni n x n log složitost.

980
01:00:31,700 --> 01:00:34,940
A uvidíte nejlepší případ řadit sloučení je n log n, a to jen tak náhodou

981
01:00:34,940 --> 01:00:39,340
že nejhorší případ, nebo Ω tam je také n log n.

982
01:00:39,340 --> 01:00:42,480
Něco mít na paměti.

983
01:00:42,480 --> 01:00:45,750
Pohybující se na, pojďme na některé extra základního souboru I / O.

984
01:00:45,750 --> 01:00:48,830
Pokud jste se dívali na Scramble, všimnete si, měli jsme nějaký systém

985
01:00:48,830 --> 01:00:51,270
kde byste mohl napsat do souboru protokolu, pokud budete číst pomocí kódu.

986
01:00:51,270 --> 01:00:53,730
Podívejme se, jak byste mohli udělat.

987
01:00:53,730 --> 01:00:57,450
No, máme fprintf, které si můžete myslet, jak jen printf,

988
01:00:57,450 --> 01:01:01,720
ale jen tisk do souboru místo, a proto f na začátku.

989
01:01:01,720 --> 01:01:07,570
Tento druh kódu se zde, co to dělá, je, jak jste mohli vidět v Scramble,

990
01:01:07,570 --> 01:01:12,310
jde přes 2-rozměrné pole tisk z řádcích, co ta čísla jsou.

991
01:01:12,310 --> 01:01:17,850
V tomto případě, printf vypíše na terminál nebo to, co nazýváme standardní výstupní sekce.

992
01:01:17,850 --> 01:01:22,170
>> A teď, v tomto případě, vše, co musíte udělat, je nahradit printf s fprintf,

993
01:01:22,170 --> 01:01:26,770
říct, že to, co soubor, který chcete tisknout, a v tomto případě to prostě vytiskne ji k tomuto souboru

994
01:01:26,770 --> 01:01:32,230
místo tisku to na terminál.

995
01:01:32,230 --> 01:01:36,500
No, pak to vyvolává otázku: Kde se dostaneme tento druh souboru z, že jo?

996
01:01:36,500 --> 01:01:39,840
Jsme míjeli přihlásit do tohoto fprintf fuction, ale neměli jsme ponětí, odkud pochází.

997
01:01:39,840 --> 01:01:43,980
No, brzy v kódu, co jsme měli byl tento kus kódu tady,

998
01:01:43,980 --> 01:01:48,340
který v podstatě říká, že open file volá log.txt.

999
01:01:48,340 --> 01:01:53,220
Co děláme po tom je, že jsme se ujistit, že soubor je skutečně úspěšně otevřen.

1000
01:01:53,220 --> 01:01:57,070
Tak to by mohlo selhat z mnoha důvodů, nemáte dostatek místa na vašem počítači, například.

1001
01:01:57,070 --> 01:01:59,790
Takže je to vždy důležité než to uděláte jakékoli operace se souborem

1002
01:01:59,790 --> 01:02:03,300
že jsme zkontrolovat, zda soubor byl úspěšně otevřen.

1003
01:02:03,300 --> 01:02:09,330
Takže to, co, že, to je argument funkce fopen, dobře, můžeme otevřít soubor v mnoha ohledech.

1004
01:02:09,330 --> 01:02:13,510
Co můžeme udělat, je, můžeme předat w, což znamená, že přepsat soubor, pokud to vystoupí již,

1005
01:02:13,510 --> 01:02:18,070
Můžeme předat A, který se připojí na konec souboru namísto přepsání to,

1006
01:02:18,070 --> 01:02:22,730
nebo můžeme určit r, což znamená, pojďme otevřít soubor jen pro čtení.

1007
01:02:22,730 --> 01:02:24,890
Takže pokud se program pokusí provést změny v souboru,

1008
01:02:24,890 --> 01:02:30,140
křičí na ně a nenechte jim to.

1009
01:02:30,140 --> 01:02:33,320
Nakonec, když jsme hotovi s soubor, udělal tím operace na něm,

1010
01:02:33,320 --> 01:02:35,860
musíme se ujistit, že soubor zavřete.

1011
01:02:35,860 --> 01:02:38,830
A tak na konci programu, budete předat znovu

1012
01:02:38,830 --> 01:02:42,120
tohoto souboru, které jste otevřeli, a jen zavřete jej.

1013
01:02:42,120 --> 01:02:44,650
Tak tohle je něco důležité, že budete muset ujistěte se, že.

1014
01:02:44,650 --> 01:02:47,180
Takže pamatujte si můžete otevřít soubor, pak můžete napsat do souboru,

1015
01:02:47,180 --> 01:02:51,270
to operace v souboru, ale pak budete muset uzavřít spis na konci.

1016
01:02:51,270 --> 01:02:53,270
>> Jakékoliv dotazy týkající se základního souboru I / O? Ano?

1017
01:02:53,270 --> 01:02:58,050
[Student otázka, nesrozumitelným]

1018
01:02:58,050 --> 01:03:02,480
Právě tady. Otázkou je, kde to log.txt soubor se objeví?

1019
01:03:02,480 --> 01:03:07,890
No, pokud jste právě dát Log.txt, vytvoří ve stejném adresáři jako spustitelný soubor.

1020
01:03:07,890 --> 01:03:10,500
Takže pokud Jsi - >> [Student otázka, nesrozumitelným]

1021
01:03:10,500 --> 01:03:18,830
Ano. Ve stejné složce, nebo ve stejném adresáři, jak to nazýváte.

1022
01:03:18,830 --> 01:03:21,400
Nyní paměť, zásobník, a haldy.

1023
01:03:21,400 --> 01:03:23,400
Tak, jak je paměť stanovenými v počítači?

1024
01:03:23,400 --> 01:03:26,270
No, umíte si představit, paměť jako druh tohoto bloku zde.

1025
01:03:26,270 --> 01:03:30,260
A v paměti máme to, co se nazývá haldy uvízl tam, a zásobník, který je tam dole.

1026
01:03:30,260 --> 01:03:34,480
A haldy roste směrem dolů a zásobník roste směrem vzhůru.

1027
01:03:34,480 --> 01:03:38,620
Tak jako Tommy uvedeno - oh, dobře, a my máme tyto jiné 4 segmenty, které budu dostanou v druhé -

1028
01:03:38,620 --> 01:03:42,890
Jak Tommy řekl dříve, víte, jak jeho funkce se nazývají a volat navzájem?

1029
01:03:42,890 --> 01:03:44,930
Ty vytvářejí tento druh zásobníku rámu.

1030
01:03:44,930 --> 01:03:47,360
No, jsou-li hlavní calls foo, dostane foo kladen na zásobníku.

1031
01:03:47,360 --> 01:03:52,430
Foo calls bar, bar get kladen na zásobníku, a který se dal na stack po.

1032
01:03:52,430 --> 01:03:57,040
A pokud se vrátí, každý se dostanou svlečen zásobníku.

1033
01:03:57,040 --> 01:04:00,140
Co každý z těchto míst a paměť držet?

1034
01:04:00,140 --> 01:04:03,110
No, horní, která je text segmentu, obsahuje vlastní program.

1035
01:04:03,110 --> 01:04:06,390
Takže strojového kódu, je to tam, jakmile kompilaci programu.

1036
01:04:06,390 --> 01:04:08,520
Další, každý inicializaci globální proměnné.

1037
01:04:08,520 --> 01:04:12,660
>> Takže budete mít globální proměnné ve vašem programu, a vy říkáte, jako, a = 5,

1038
01:04:12,660 --> 01:04:15,260
, který se dal v tomto segmentu, a přímo pod to,

1039
01:04:15,260 --> 01:04:18,990
Máte nějaké neinicializovaná globální data, která je jen INT,

1040
01:04:18,990 --> 01:04:20,990
ale neříkejte, že je to stejné na cokoliv.

1041
01:04:20,990 --> 01:04:23,870
Uvědomte si, to jsou globální proměnné, takže jste mimo ze dne main.

1042
01:04:23,870 --> 01:04:28,560
Takže to znamená, žádné globální proměnné, které jsou deklarovány, ale nejsou inicializovány.

1043
01:04:28,560 --> 01:04:32,310
Takže to, co je v haldě? Paměť alokovány s pomocí malloc, který se dostaneme v trochu.

1044
01:04:32,310 --> 01:04:35,990
A konečně, s zásobník mít žádné lokální proměnné

1045
01:04:35,990 --> 01:04:39,950
a všechny funkce, které by se dalo nazvat všech svých parametrů.

1046
01:04:39,950 --> 01:04:43,720
Poslední věc, nemáte opravdu vědět, co proměnné prostředí udělat,

1047
01:04:43,720 --> 01:04:46,700
ale vždy, když spustíte program, tam je něco spojené, jako

1048
01:04:46,700 --> 01:04:49,550
toto je uživatelské jméno osoby, která běžel program.

1049
01:04:49,550 --> 01:04:51,550
A to bude trochu na dně.

1050
01:04:51,550 --> 01:04:54,540
Z hlediska paměťových adres, které jsou hexadecimální hodnoty,

1051
01:04:54,540 --> 01:04:58,170
hodnoty při horním začínají na 0, a oni jdou celou cestu až na dno.

1052
01:04:58,170 --> 01:05:00,440
V tomto případě, pokud jste na 32-bitovém systému,

1053
01:05:00,440 --> 01:05:05,390
adresa, na spodní části bude 0x, následovaný AF, protože to je 32 bitů,

1054
01:05:05,390 --> 01:05:10,890
která je 8 bajtů, a v tomto případě 8 bajtů odpovídá 8 hexadecimálních číslic.

1055
01:05:10,890 --> 01:05:20,110
Tak tady budeš mít, rád, 0xffffff, a tam budeš mít 0.

1056
01:05:20,110 --> 01:05:23,660
Takže jaké jsou ukazatele? Někteří z vás nemusí vztahovat to v části před.

1057
01:05:23,660 --> 01:05:26,660
ale my jsme se jít přes něj v přednášce, takže ukazatel je jen datový typ

1058
01:05:26,660 --> 01:05:34,030
které ukládá, místo nějakého druhu hodnoty, jako je 50, uloží adresu na nějaké místo v paměti.

1059
01:05:34,030 --> 01:05:36,020
Stejně jako tento paměti [nesrozumitelné].

1060
01:05:36,020 --> 01:05:41,120
Takže v tomto případě, to, co jsme, je, že máme ukazatel na celé číslo nebo int *,

1061
01:05:41,120 --> 01:05:46,210
a obsahuje tuto hexadecimální adresu 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Takže to, co máme, je, nyní se tento ukazatel na nějaké místo v paměti,

1063
01:05:50,880 --> 01:05:56,020
a to je jen, hodnota 50 je v tomto místě paměti.

1064
01:05:56,020 --> 01:06:01,810
Na některých 32-bitových systémech, ve všech 32-bitových systémech, ukazatele zabírají 32 bitů nebo 4 bajty.

1065
01:06:01,810 --> 01:06:06,020
Ale, například, na 64-bitovém systému, ukazatele jsou 64 bitů.

1066
01:06:06,020 --> 01:06:08,040
Tak to je něco, co budete chtít mít na paměti.

1067
01:06:08,040 --> 01:06:12,310
Tak na konec-bit systému, ukazatel koncové bitů.

1068
01:06:12,310 --> 01:06:17,320
Ukazatele jsou druh těžko stravitelné bez zbytečných věcí,

1069
01:06:17,320 --> 01:06:20,300
takže se pojďme projít příklad dynamického přidělování paměti.

1070
01:06:20,300 --> 01:06:25,130
Co dynamické přidělování paměti pro vás dělá, nebo to, co nazýváme malloc,

1071
01:06:25,130 --> 01:06:29,280
To vám umožní přidělit nějaký údajů mimo sady.

1072
01:06:29,280 --> 01:06:31,830
Takže tato data je něco trvalejšího pro celou dobu trvání programu.

1073
01:06:31,830 --> 01:06:36,430
Vzhledem k tomu, jak víte, pokud jste deklarovat x uvnitř funkce, a že funkce vrací,

1074
01:06:36,430 --> 01:06:40,910
již nemáte přístup k datům, který byl uskladněn v x.

1075
01:06:40,910 --> 01:06:44,420
Co ukazatele nám udělat, je, že nám tyto paměťové nebo obchod hodnot

1076
01:06:44,420 --> 01:06:46,840
v jiném segmentu paměti, a to haldy.

1077
01:06:46,840 --> 01:06:49,340
Nyní, jakmile se vrátíme z funkcí, tak dlouho, jak budeme mít ukazatel

1078
01:06:49,340 --> 01:06:54,960
na dané místo v paměti, pak to, co můžeme udělat, je, že jsme se jen podívat na hodnoty tam.

1079
01:06:54,960 --> 01:06:58,020
Pojďme se podívat na příklad: Toto je naše paměť layout znovu.

1080
01:06:58,020 --> 01:07:00,050
A my máme tuto funkci, hlavní.

1081
01:07:00,050 --> 01:07:06,870
Co to udělá, je - v pořádku, tak jednoduché, že jo? - Int x = 5, to je jen variabilní na zásobníku v main.

1082
01:07:06,870 --> 01:07:12,450
>> Na druhou stranu, teď deklarujeme ukazatel, který volá funkci giveMeThreeInts.

1083
01:07:12,450 --> 01:07:16,800
A tak teď půjdeme do této funkce a vytvoříme nový zásobníku rámec pro něj.

1084
01:07:16,800 --> 01:07:20,440
Nicméně v tomto zásobníku rámu, prohlašujeme int * teplota,

1085
01:07:20,440 --> 01:07:23,210
které v celých mallocs 3 pro nás.

1086
01:07:23,210 --> 01:07:25,880
Takže velikost z int dá nám, kolik bytů to int je,

1087
01:07:25,880 --> 01:07:29,620
a malloc nám dává, že mnoho bytů z místa na haldě.

1088
01:07:29,620 --> 01:07:32,890
Takže v tomto případě, jsme vytvořili dostatečný prostor pro 3 celých čísel,

1089
01:07:32,890 --> 01:07:36,830
a haldy je způsob, jak se tam, což je důvod, proč jsem vypracována to výš.

1090
01:07:36,830 --> 01:07:42,900
Jakmile jsme hotovi, vrátíme se sem, budete potřebovat pouze 3 ints vrátil,

1091
01:07:42,900 --> 01:07:47,000
a vrátí adresu, v tomto případě více než kdy že paměť je.

1092
01:07:47,000 --> 01:07:51,250
A jsme si stanovili ukazatele = přepínač, a tam máme jen další ukazatel.

1093
01:07:51,250 --> 01:07:54,550
Ale co to vrátí funkce je stohovat zde a zmizí.

1094
01:07:54,550 --> 01:07:59,250
Takže teplota zmizí, ale stále ještě udržet adresu kde

1095
01:07:59,250 --> 01:08:01,850
ty 3 čísla jsou uvnitř sítě.

1096
01:08:01,850 --> 01:08:06,180
Takže v této sadě, jsou ukazatele jsou rozsahem lokálně pro skládaného rámu,

1097
01:08:06,180 --> 01:08:09,860
ale paměť, na které se vztahují se na hromadu.

1098
01:08:09,860 --> 01:08:12,190
>> Dává to smysl?

1099
01:08:12,190 --> 01:08:14,960
[Student] Mohl byste to zopakovat? >> [Joseph] Ano.

1100
01:08:14,960 --> 01:08:20,270
Takže když jsem se vrátit jen trochu, uvidíte, že teplota přidělené

1101
01:08:20,270 --> 01:08:23,500
některé paměti na haldě up there.

1102
01:08:23,500 --> 01:08:28,680
Takže když tato funkce, giveMeThreeInts vrací, to stack zde zmizí.

1103
01:08:28,680 --> 01:08:35,819
A s ním jakékoli proměnných, v tomto případě, to ukazatel, který byl rozdělen v skládaném rámu.

1104
01:08:35,819 --> 01:08:39,649
, Který se chystá zmizet, ale od té doby jsme se vrátili temp

1105
01:08:39,649 --> 01:08:46,330
a dali jsme se ukazatel = temp, ukazatel se nyní bude ukazovat stejnou paměť umístění váhy temp was.

1106
01:08:46,330 --> 01:08:50,370
Takže teď, i když ztrácíme temp, že místní ukazatele,

1107
01:08:50,370 --> 01:08:59,109
jsme ještě udržet adresu paměti, co to bylo ukázal dovnitř té proměnné ukazatele.

1108
01:08:59,109 --> 01:09:03,740
Otázky? To může být trochu matoucí topic, pokud jste už nad ním v oddíle.

1109
01:09:03,740 --> 01:09:09,240
Můžeme, bude váš TF určitě jít přes něj, a samozřejmě budeme moci odpovědět na otázky

1110
01:09:09,240 --> 01:09:11,500
na konci sledovaného relace za to.

1111
01:09:11,500 --> 01:09:14,220
Ale to je trochu složité téma, a mám další příklady, které se chystáte ukázat

1112
01:09:14,220 --> 01:09:18,790
které pomohou objasnit, co vlastně jsou ukazatele.

1113
01:09:18,790 --> 01:09:22,500
>> V tomto případě, ukazatele odpovídají polí,

1114
01:09:22,500 --> 01:09:25,229
takže můžu jen použít tento ukazatel jako stejnou věc jako int pole.

1115
01:09:25,229 --> 01:09:29,840
Takže jsem indexování do 0, a změnit první číslo na 1,

1116
01:09:29,840 --> 01:09:39,689
změnou druhý číslo na 2 a 3. celé číslo 3.

1117
01:09:39,689 --> 01:09:44,210
Takže více na ukazateli. No, vzpomínám Binky.

1118
01:09:44,210 --> 01:09:48,319
V tomto případě jsme si přiděleno ukazatel, nebo jsme prohlásil ukazatel,

1119
01:09:48,319 --> 01:09:52,760
ale zpočátku, když jsem prohlásil ukazatel, to neodkazuje kdekoli v paměti.

1120
01:09:52,760 --> 01:09:54,930
Je to jen odpadky hodnoty uvnitř ní.

1121
01:09:54,930 --> 01:09:56,470
Takže nemám ponětí, kde tento ukazatel ukazuje.

1122
01:09:56,470 --> 01:10:01,630
To má adresu, která je jen plná 0 a 1, kde byl původně deklarován.

1123
01:10:01,630 --> 01:10:04,810
Nemůžu nic dělat s tím, dokud jsem volat malloc na to

1124
01:10:04,810 --> 01:10:08,390
a pak mi to dává málo místa na haldě, kde se můžu obrátit hodnoty uvnitř.

1125
01:10:08,390 --> 01:10:11,980
Pak znovu, nevím, co je uvnitř této paměti.

1126
01:10:11,980 --> 01:10:16,780
Takže první věc, kterou musím udělat, je zkontrolovat, zda systém měl dostatek paměti

1127
01:10:16,780 --> 01:10:20,850
aby mě zpět 1 celé číslo na prvním místě, což je důvod, proč to dělám kontrolu.

1128
01:10:20,850 --> 01:10:25,020
Pokud je ukazatel null, to znamená, že nemá dostatek místa nebo nějaké jiné chybě,

1129
01:10:25,020 --> 01:10:26,320
tak jsem měl ukončit z mého programu.

1130
01:10:26,320 --> 01:10:29,400
 Ale pokud se to podaří, teď mohu používat tento ukazatel

1131
01:10:29,400 --> 01:10:35,020
a co * ukazatel dělá, je, že jdou tam, kde je adresa

1132
01:10:35,020 --> 01:10:38,480
tam, kde tato hodnota je, a to nastaví se rovná 1.

1133
01:10:38,480 --> 01:10:41,850
Tak tady, jsme kontrolu, zda se paměť existuje.

1134
01:10:41,850 --> 01:10:45,380
>> Jakmile budete vědět, že existuje, můžete si dát do něj

1135
01:10:45,380 --> 01:10:50,460
jakou hodnotu chcete dát do ní, v tomto případě 1.

1136
01:10:50,460 --> 01:10:53,060
Jakmile jsme hotovi s ním, je třeba uvolnit tento ukazatel

1137
01:10:53,060 --> 01:10:57,160
protože se musíme dostat zpět do systému, který paměti, že budete požádáni v první řadě.

1138
01:10:57,160 --> 01:10:59,690
Vzhledem k tomu, že počítač neví, kdy jsme s ním udělal.

1139
01:10:59,690 --> 01:11:02,510
V tomto případě jsme explicitně říkat, ano, my jsme udělali s tímto paměti.

1140
01:11:02,510 --> 01:11:10,780
Pokud nějaká jiná proces potřebuje, jiný program potřebuje, neváhejte jít dopředu a vzít ji.

1141
01:11:10,780 --> 01:11:15,110
Co můžeme udělat, je také můžeme jen získat adresu lokálních proměnných na televizoru.

1142
01:11:15,110 --> 01:11:19,080
Takže int x je uvnitř skládaného rámu main.

1143
01:11:19,080 --> 01:11:23,060
A když budeme mít tuto ampersand, tento a provozovatel, co dělá, je

1144
01:11:23,060 --> 01:11:27,310
trvá x, a x je jen některé údaje v paměti, ale má adresu.

1145
01:11:27,310 --> 01:11:33,790
Je umístěn někde. Takže volání a x, co to dělá, je, že nám dává adresu x.

1146
01:11:33,790 --> 01:11:38,430
Tím, že děláme ukazatel místo, kde x je v paměti.

1147
01:11:38,430 --> 01:11:41,710
Teď už jen udělat něco jako * x, budeme si 5 zpět.

1148
01:11:41,710 --> 01:11:43,820
Hvězda se nazývá dereferencing to.

1149
01:11:43,820 --> 01:11:46,640
Můžete sledovat adresu a dostanete hodnotu toho zde uložené.

1150
01:11:51,000 --> 01:11:53,310
>> Nějaké otázky? Ano?

1151
01:11:53,310 --> 01:11:56,500
[Student] Pokud nechcete dělat 3-špičatý věc, to ještě kompilaci?

1152
01:11:56,500 --> 01:11:59,490
Ano. Pokud nechcete dělat 3-ukazatel věc, je to stále bude sestavovat,

1153
01:11:59,490 --> 01:12:02,720
ale já ti ukážu, co se děje v druhé, a bez toho, že

1154
01:12:02,720 --> 01:12:04,860
že to, co nazýváme nevracení paměti. Nedáváte systému

1155
01:12:04,860 --> 01:12:07,850
zpět svou paměť, takže po chvíli program bude hromadit

1156
01:12:07,850 --> 01:12:10,940
paměti, že to není pomocí, a nic jiného ji použít.

1157
01:12:10,940 --> 01:12:15,750
Pokud jste někdy viděli Firefox s 1500000 kb na vašem počítači,

1158
01:12:15,750 --> 01:12:17,840
v Správci úloh, že to, co se děje.

1159
01:12:17,840 --> 01:12:20,760
Máte nevracení paměti v programu, že nejste manipulaci.

1160
01:12:23,080 --> 01:12:26,240
Tak, jak se pointerovou aritmetiku práce?

1161
01:12:26,240 --> 01:12:29,480
No, ukazatel aritmetika je něco jako indexování do pole.

1162
01:12:29,480 --> 01:12:36,370
V tomto případě, mám ukazatel, a to, co dělám je, že jsem, aby ukazatel bod na první prvek

1163
01:12:36,370 --> 01:12:42,100
tohoto pole 3 celých čísel, která jsem přiděleny.

1164
01:12:42,100 --> 01:12:46,670
Takže teď, co mám dělat, star pointer jen změní první prvek v seznamu.

1165
01:12:46,670 --> 01:12:49,140
Hvězda ukazatel 1 bodů za zde.

1166
01:12:49,140 --> 01:12:53,140
Takže ukazatel je tady, ukazatel 1 je tady, ukazatel 2 je tady.

1167
01:12:53,140 --> 01:12:56,610
>> Takže jen přidat 1 je totéž, jako pohybující se tohoto pole.

1168
01:12:56,610 --> 01:12:59,880
Co máme udělat, je, když děláme ukazatel 1 dostanete adresu sem,

1169
01:12:59,880 --> 01:13:04,180
a za účelem získat hodnotu v tu můžete dát hvězdu z celého výrazu

1170
01:13:04,180 --> 01:13:05,990
k dereference to.

1171
01:13:05,990 --> 01:13:09,940
Takže, v tomto případě, jsem nastavení prvního umístění v tomto poli na hodnotu 1,

1172
01:13:09,940 --> 01:13:13,970
druhé umístění na 2, a třetí umístění na 3..

1173
01:13:13,970 --> 01:13:18,180
Pak to, co dělám tady je mi tiskne náš ukazatel 1,

1174
01:13:18,180 --> 01:13:19,970
který jen mi dává 2.

1175
01:13:19,970 --> 01:13:23,650
Teď jsem zvyšování ukazatel, takže ukazatel rovná ukazatel 1,

1176
01:13:23,650 --> 01:13:26,780
který se pohybuje dopředu.

1177
01:13:26,780 --> 01:13:30,810
A tak teď, když jsem vytisknout ukazatel 1, ukazatel +1 je nyní 3,

1178
01:13:30,810 --> 01:13:33,990
což v tomto případě se vytiskne 3.

1179
01:13:33,990 --> 01:13:36,560
A aby uvolnila něco, ukazatel, že dám ji

1180
01:13:36,560 --> 01:13:40,540
musí směřovat na začátku pole, které jsem se vrátil z malloc.

1181
01:13:40,540 --> 01:13:43,430
Takže, v tomto případě, pokud bych měl zavolat 3 tady, by to nebylo správné,

1182
01:13:43,430 --> 01:13:45,070
, protože je to ve středu pole.

1183
01:13:45,070 --> 01:13:48,820
Musím odečíst dostat do původního umístění

1184
01:13:48,820 --> 01:13:50,420
Počáteční první místo, než jsem si uvolnit ji.

1185
01:13:56,300 --> 01:13:58,450
Takže, tady je více zapojit příklad.

1186
01:13:58,450 --> 01:14:03,360
V tomto případě, jsme přidělování 7 znaků pole znaků.

1187
01:14:03,360 --> 01:14:06,480
>> A v tomto případě to, co děláme, je, že jsme looping přes první 6 z nich,

1188
01:14:06,480 --> 01:14:09,900
a my jsme nastavením na Z.

1189
01:14:09,900 --> 01:14:13,350
Takže, pro int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Takže, ukazatel + i se jen nám, v tomto případě,

1191
01:14:16,220 --> 01:14:20,860
ukazatel, ukazatel 1, ukazatel +2, ukazatel 3, a tak dále a tak dále ve smyčce.

1192
01:14:20,860 --> 01:14:24,040
Co to udělá, je, že dostane tu adresu, dereferences to, aby si hodnoty,

1193
01:14:24,040 --> 01:14:27,440
a změny, aby hodnota v Z.

1194
01:14:27,440 --> 01:14:30,350
Pak na konci si pamatuju, je řetězec, ne?

1195
01:14:30,350 --> 01:14:33,560
Všechny řetězce mají skončit s nulovým ukončovací znak.

1196
01:14:33,560 --> 01:14:38,620
Takže, co dělám, je ukazovátko 6 I dal null zakončení znak a.

1197
01:14:38,620 --> 01:14:43,980
A teď, co jsem v podstatě dělal tady provádí printf pro řetězec, ne?

1198
01:14:43,980 --> 01:14:46,190
>> Takže, když to printf teď, když je to dosažení konce řetězce?

1199
01:14:46,190 --> 01:14:48,230
Když zasáhne null ukončující znak.

1200
01:14:48,230 --> 01:14:52,030
Takže, v tomto případě, mé původní ukazatel ukazuje na začátku tohoto pole.

1201
01:14:52,030 --> 01:14:56,410
I vytisknout první znak ven. I přesunout přes jednoho.

1202
01:14:56,410 --> 01:14:58,420
I vytisknout tuto postavu ven. I pohybovat nad.

1203
01:14:58,420 --> 01:15:02,180
A já si to tak, dokud jsem se dostat na konec.

1204
01:15:02,180 --> 01:15:07,750
A teď konec * ukazatel bude dereference a dostat se na null ukončující znak zpět.

1205
01:15:07,750 --> 01:15:11,780
A tak můj while běží pouze v případě, že hodnota není null ukončovací znak.

1206
01:15:11,780 --> 01:15:13,770
Tak, teď jsem opustit z této smyčky.

1207
01:15:18,780 --> 01:15:21,180
A tak když jsem odečíst 6 z tohoto ukazatele,

1208
01:15:21,180 --> 01:15:22,860
Vrátím se celou cestu na začátek.

1209
01:15:22,860 --> 01:15:27,880
Nezapomeňte, dělám to proto, že musím jít na začátek, aby se osvobodil ho.

1210
01:15:27,880 --> 01:15:30,270
>> Takže jsem věděl, že to hodně. Jsou nějaké dotazy?

1211
01:15:30,270 --> 01:15:31,870
Prosím, ano?

1212
01:15:31,870 --> 01:15:36,610
[Student otázka nesrozumitelná]

1213
01:15:36,610 --> 01:15:38,190
Můžete říct, že hlasitěji? Promiňte.

1214
01:15:38,190 --> 01:15:44,140
[Student] Na posledním snímku těsně předtím, než jste osvobodil ukazatel,

1215
01:15:44,140 --> 01:15:47,300
kde se skutečně změně hodnoty ukazatele?

1216
01:15:47,300 --> 01:15:50,370
[Joseph] Tak, tady. >> [Student] Oh, dobře.

1217
01:15:50,370 --> 01:15:51,890
[Joseph] Tak, mám ukazatel minus minus, vpravo,

1218
01:15:51,890 --> 01:15:54,140
který se pohybuje na věc zpět o jeden, a pak jsem osvobodit to,

1219
01:15:54,140 --> 01:15:57,000
protože tento ukazatel je třeba zdůraznit na začátku pole.

1220
01:15:57,000 --> 01:16:00,420
[Student] Ale to by nebyla nutná, kdybyste přestal po tomto řádku.

1221
01:16:00,420 --> 01:16:03,130
[Joseph] Takže, když jsem přestal po tomto, by to bylo považováno za únik paměti,

1222
01:16:03,130 --> 01:16:04,810
protože jsem neběžel zdarma.

1223
01:16:04,810 --> 01:16:11,290
[Student] I [nesrozumitelné] po prvních třech řádcích, kde jste měli ukazatel 1 [nesrozumitelné].

1224
01:16:11,290 --> 01:16:13,140
[Joseph] Uh-huh. Takže, co je otázka tam?

1225
01:16:13,140 --> 01:16:14,780
Promiňte. Ne, ne. Jdi, jdi, prosím.

1226
01:16:14,780 --> 01:16:16,870
[Student] Takže, nejste změnou hodnoty ukazatelů.

1227
01:16:16,870 --> 01:16:19,130
Ty by se musel udělat ukazatel minus minus.

1228
01:16:19,130 --> 01:16:19,730
[Joseph] Ano, přesně tak.

1229
01:16:19,730 --> 01:16:21,890
Takže, když jsem si ukazatel 1 a ukazatel 2,

1230
01:16:21,890 --> 01:16:24,410
Nedělám ukazatel rovná ukazatel 1.

1231
01:16:24,410 --> 01:16:27,260
Takže, ukazatel jen zůstane ukazuje na začátku pole.

1232
01:16:27,260 --> 01:16:31,460
Je to pouze tehdy, když dělám plus plus, že nastaví hodnotu zpět do ukazatele,

1233
01:16:31,460 --> 01:16:33,550
že to vlastně pohybuje to spolu.

1234
01:16:36,860 --> 01:16:37,780
Dobrá.

1235
01:16:40,550 --> 01:16:42,030
Další otázky?

1236
01:16:44,680 --> 01:16:47,790
>> Opět platí, že pokud je to druh ohromující, bude to zahrnuty v relaci.

1237
01:16:47,790 --> 01:16:50,710
Zeptejte se svého vyučujícího, kolegu o tom, a my můžeme odpovídat na otázky na konci.

1238
01:16:53,510 --> 01:16:56,600
A obvykle se nám nelíbí to udělat minus věc.

1239
01:16:56,600 --> 01:16:59,760
To je vyžadují, abych sledování toho, jak moc jsem posun v poli.

1240
01:16:59,760 --> 01:17:04,520
Takže, obecně, je to jen vysvětlit, jak funguje ukazatel aritmetické.

1241
01:17:04,520 --> 01:17:07,970
Ale to, co obvykle rádi udělali je, že jsme chtěli vytvořit kopii ukazatele,

1242
01:17:07,970 --> 01:17:11,640
a pak budeme používat tuto kopii, když jdeme kolem v řetězci.

1243
01:17:11,640 --> 01:17:14,660
Takže, v těchto případech použít kopie vytisknout celý řetězec,

1244
01:17:14,660 --> 01:17:19,040
ale nemáme dělat jako ukazatel minus 6 nebo sledovat, jak moc jsme se přestěhovali v tomto,

1245
01:17:19,040 --> 01:17:22,700
jen proto, že víme, že náš původní bod je stále poukazoval na začátek seznamu

1246
01:17:22,700 --> 01:17:25,340
a vše, co změnil je to kopie.

1247
01:17:25,340 --> 01:17:28,250
Takže, obecně měnit kopie původního ukazatel.

1248
01:17:28,250 --> 01:17:32,350
Nesnažte se nějak jako - nedělej změnit originály.

1249
01:17:32,350 --> 01:17:35,290
Snažit se změnit pouze kopie originálu.

1250
01:17:41,540 --> 01:17:44,870
Takže, si všimnete, když míjíme řetězec do printf

1251
01:17:44,870 --> 01:17:48,990
nemusíte dát hvězdu před ním jako jsme to udělali se všemi ostatními dereferences, že jo?

1252
01:17:48,990 --> 01:17:54,180
Takže, pokud můžete vytisknout celý řetězec% s očekává, že je adresa,

1253
01:17:54,180 --> 01:17:57,610
a v tomto případě ukazatel nebo v tomto případě jako pole znaků.

1254
01:17:57,610 --> 01:18:00,330
>> Postavy, char * s, a pole jsou totéž.

1255
01:18:00,330 --> 01:18:03,690
Ukazatel je znaků, a pole znaků jsou totéž.

1256
01:18:03,690 --> 01:18:05,720
A tak, vše, co musíte udělat, je předat ukazatel.

1257
01:18:05,720 --> 01:18:08,150
Nemáme předat jako * ukazatel nebo něco podobného.

1258
01:18:13,110 --> 01:18:14,930
Takže, pole a ukazatele jsou totéž.

1259
01:18:14,930 --> 01:18:19,160
Když děláte něco jako x [y] sem na pole,

1260
01:18:19,160 --> 01:18:21,960
co to dělá pod kapotou je to říká, jo, je to pole znaků,

1261
01:18:21,960 --> 01:18:23,690
takže je to ukazatel.

1262
01:18:23,690 --> 01:18:26,510
A tak x je totéž,

1263
01:18:26,510 --> 01:18:28,650
a tak to, co dělá, je, že přidá y na x,

1264
01:18:28,650 --> 01:18:31,820
který je totéž, jako kupředu v paměti, že mnoho.

1265
01:18:31,820 --> 01:18:34,930
A teď x + y nám dává nějaký adresy,

1266
01:18:34,930 --> 01:18:37,570
a my dereference adresu nebo sledovat šipku

1267
01:18:37,570 --> 01:18:41,640
kde toto místo v paměti, je, a dostaneme hodnotu z tohoto umístění v paměti.

1268
01:18:41,640 --> 01:18:43,720
Takže, takže tyto dva jsou přesně totéž.

1269
01:18:43,720 --> 01:18:45,840
Je to jen syntaktický cukr.

1270
01:18:45,840 --> 01:18:48,090
Oni dělají stejnou věc. Jsou to jen různé syntactics pro sebe.

1271
01:18:51,500 --> 01:18:57,590
>> Takže, co může pokazit s ukazateli? Stejně jako, hodně. Dobře. Takže, špatné věci.

1272
01:18:57,590 --> 01:19:02,410
Některé špatné věci, které můžete udělat, nejsou kontroly, zda vaše malloc volání vrátí null, ne?

1273
01:19:02,410 --> 01:19:06,560
V tomto případě, se ptám systém, aby mi - co je to číslo?

1274
01:19:06,560 --> 01:19:11,200
Jako 2000000000 krát 4, protože velikost celé číslo je 4 bajty.

1275
01:19:11,200 --> 01:19:13,810
Ptám se ho, jako 8000000000 bajtů.

1276
01:19:13,810 --> 01:19:17,270
Samozřejmě můj počítač se nebude moci dát mi tolik paměti zpátky.

1277
01:19:17,270 --> 01:19:20,960
A my jsme to zjistili, zda-li to je null, takže když se snažíme dereference to tam -

1278
01:19:20,960 --> 01:19:24,270
sledovat šipku na místo, kde to bude - nemáme, že paměť.

1279
01:19:24,270 --> 01:19:27,150
To je to, co nazýváme dereferencing nulový ukazatel.

1280
01:19:27,150 --> 01:19:29,710
A to v podstatě způsobí, že se segfault.

1281
01:19:29,710 --> 01:19:31,790
To je jeden ze způsobů, jak si můžete segfault.

1282
01:19:34,090 --> 01:19:38,090
Další špatné věci, které můžete udělat - oh dobře.

1283
01:19:38,090 --> 01:19:40,650
To bylo dereferencing nulový ukazatel. Dobře.

1284
01:19:40,650 --> 01:19:45,160
Další špatné věci - dobře, opravit, že jste právě dal šek tam

1285
01:19:45,160 --> 01:19:46,980
, který kontroluje, zda je ukazatel null

1286
01:19:46,980 --> 01:19:51,000
a ukončete z programu, pokud se to stane, že malloc vrací nulový ukazatel.

1287
01:19:55,110 --> 01:19:59,850
To je xkcd komické. Lidé pochopili to hned. Tak nějak.

1288
01:20:06,120 --> 01:20:09,350
>> Tak, paměť. A šel jsem nad tím.

1289
01:20:09,350 --> 01:20:12,000
Jsme volání malloc ve smyčce, ale pokaždé, když říkáme malloc

1290
01:20:12,000 --> 01:20:14,370
ztrácíme přehled o tom, kde tento ukazatel ukazuje na,

1291
01:20:14,370 --> 01:20:15,750
proto, že jsme praštit ho.

1292
01:20:15,750 --> 01:20:18,410
Takže, počáteční volání malloc mi dává paměť tady.

1293
01:20:18,410 --> 01:20:19,990
Moje ukazatel ukazatele na toto.

1294
01:20:19,990 --> 01:20:23,020
Teď, nemám uvolnit, takže teď říkám malloc znovu.

1295
01:20:23,020 --> 01:20:26,070
Teď to ukazuje tady. Nyní má paměť ukazuje tady.

1296
01:20:26,070 --> 01:20:27,640
Polohovací tady. Polohovací tady.

1297
01:20:27,640 --> 01:20:31,820
Ale já jsem ztratil přehled o adresách všech paměti támhle, že jsem přidělena.

1298
01:20:31,820 --> 01:20:35,100
A tak teď nemám žádný odkaz na ně už.

1299
01:20:35,100 --> 01:20:37,230
Takže, nemůžu osvobodit mimo tento smyčky.

1300
01:20:37,230 --> 01:20:39,390
A tak za účelem stanovení něco takového,

1301
01:20:39,390 --> 01:20:42,250
pokud jste zapomněl volné paměti a stáhni nevracení paměti,

1302
01:20:42,250 --> 01:20:45,810
Musíte uvolnit paměť uvnitř této smyčky, jakmile budete hotovi s ním.

1303
01:20:45,810 --> 01:20:51,400
No, to je to, co se stane. Vím, že spousta z vás nesnáším.

1304
01:20:51,400 --> 01:20:55,270
Ale teď - yay! Zde získáte jako 44.000 KB.

1305
01:20:55,270 --> 01:20:57,110
Takže, vy uvolnit, na konci smyčky,

1306
01:20:57,110 --> 01:20:59,770
a že se to prostě uvolnit paměť pokaždé.

1307
01:20:59,770 --> 01:21:03,620
V podstatě, váš program nemá nevracení paměti už.

1308
01:21:03,620 --> 01:21:08,150
>> A teď něco jiného, ​​co můžete udělat, je uvolnit paměť, kterou jste žádal dvakrát.

1309
01:21:08,150 --> 01:21:11,060
V tomto případě je malloc něco, změnit jeho hodnotu.

1310
01:21:11,060 --> 01:21:13,140
Můžete uvolnit jej jednou, protože jsi říkal, že se s tím.

1311
01:21:13,140 --> 01:21:14,940
Ale pak jsme osvobozeni znovu.

1312
01:21:14,940 --> 01:21:16,730
To je něco, co je dost špatné.

1313
01:21:16,730 --> 01:21:18,820
To nebude zpočátku segfault,

1314
01:21:18,820 --> 01:21:23,350
ale po chvíli, co to dělá, je dvojí uvolnění tomuto korumpuje svůj haldy strukturu,

1315
01:21:23,350 --> 01:21:27,200
a naučíte trochu víc o tom, pokud se rozhodnete vzít třídu jako CS61.

1316
01:21:27,200 --> 01:21:30,000
Ale v podstatě po chvíli váš počítač bude zmást

1317
01:21:30,000 --> 01:21:33,010
o tom, co paměťová místa jsou ta, kde a kdy je to uloženo -

1318
01:21:33,010 --> 01:21:34,800
, kde jsou data uložena v paměti.

1319
01:21:34,800 --> 01:21:38,080
A tak uvolnění ukazatel dvakrát, je špatné, že nechcete dělat.

1320
01:21:38,080 --> 01:21:41,600
>> Další věci, které se mohou pokazit nepoužívá sizeof.

1321
01:21:41,600 --> 01:21:44,460
Takže, v tomto případě malloc 8 bajtů,

1322
01:21:44,460 --> 01:21:46,700
a to je to samé jako dvě celá čísla, ne?

1323
01:21:46,700 --> 01:21:49,580
Tak, to je naprosto bezpečné, ale je to?

1324
01:21:49,580 --> 01:21:52,160
No, jak Lucas mluvil o na různých architekturách,

1325
01:21:52,160 --> 01:21:54,220
čísla jsou různých délek.

1326
01:21:54,220 --> 01:21:57,970
Takže, na zařízení, které používáte, čísla jsou asi 4 byty,

1327
01:21:57,970 --> 01:22:02,370
ale na nějakém jiném systému, které by mohly být 8 bajtů nebo může být 16 bytů.

1328
01:22:02,370 --> 01:22:05,680
Takže, pokud jsem použít toto číslo sem,

1329
01:22:05,680 --> 01:22:07,310
tento program by mohl pracovat na zařízení,

1330
01:22:07,310 --> 01:22:10,360
ale to nebude alokovat dostatek paměti na nějakém jiném systému.

1331
01:22:10,360 --> 01:22:14,020
V tomto případě, je to, co operátor sizeof se používá.

1332
01:22:14,020 --> 01:22:16,880
Když zavoláme sizeof (int), co to dělá, je

1333
01:22:16,880 --> 01:22:21,910
 to nám dává velikost celé číslo v systému, který běží program.

1334
01:22:21,910 --> 01:22:25,490
Takže, v tomto případě, bude sizeof (int) vrátí 4 na něco takového zařízení,

1335
01:22:25,490 --> 01:22:29,980
a nyní tato vůle 4 * 2, což je 8,

1336
01:22:29,980 --> 01:22:32,330
, který je jen množství prostoru potřebné pro dvou celých čísel.

1337
01:22:32,330 --> 01:22:36,710
Na jiném systému, pokud int je jako 16 bajtů nebo 8 bajtů,

1338
01:22:36,710 --> 01:22:39,380
to jen tak vrátit dostatek bytů pro uložení tuto částku.

1339
01:22:41,830 --> 01:22:45,310
>> A konečně, struct.

1340
01:22:45,310 --> 01:22:48,340
Takže, pokud jste chtěli uložit sudoku desku v paměti, možná jak to uděláme?

1341
01:22:48,340 --> 01:22:51,570
Můžete si myslet, ze jako proměnné pro první věc,

1342
01:22:51,570 --> 01:22:53,820
proměnná pro druhou věc, proměnná pro třetí věc,

1343
01:22:53,820 --> 01:22:56,420
proměnná pro čtvrté věc - špatný, ne?

1344
01:22:56,420 --> 01:23:00,750
Takže, jedna zlepšení můžete provést na vrcholu je to, aby se 9 x 9 pole.

1345
01:23:00,750 --> 01:23:04,480
To je v pořádku, ale co když jste chtěli přidružit i jiné věci s radou sudoku

1346
01:23:04,480 --> 01:23:06,490
jako to, co obtížnost desce je,

1347
01:23:06,490 --> 01:23:11,740
nebo, například, jaké jsou vaše skóre, nebo jak dlouho to trvalo vám vyřešit tento program?

1348
01:23:11,740 --> 01:23:14,970
No, co můžete udělat, je, že můžete vytvořit struct.

1349
01:23:14,970 --> 01:23:18,910
Co jsem v podstatě říká, je, že jsem vymezení tuto strukturu tady,

1350
01:23:18,910 --> 01:23:23,230
a já jsem definování sudoku deska, která se skládá z desky, která je 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> A co to má to má ukazatele na název úrovně.

1352
01:23:26,650 --> 01:23:30,730
Má také X a Y, které jsou souřadnice, kde jsem teď.

1353
01:23:30,730 --> 01:23:35,980
To má také čas strávený [nesrozumitelný], a to má celkový počet tahů jsem zadaných doposud.

1354
01:23:35,980 --> 01:23:40,010
A tak v tomto případě, mohu seskupit spoustu dat do jediného struktury

1355
01:23:40,010 --> 01:23:42,790
místo toho, aby ji jako létání kolem jako různé proměnné

1356
01:23:42,790 --> 01:23:44,540
že nemůžu sledovat.

1357
01:23:44,540 --> 01:23:49,720
A to nám umožňuje mít jen hezkou syntaxi pro druh odkazování různé věci uvnitř tohoto struct.

1358
01:23:49,720 --> 01:23:53,430
Já si prostě board.board, a mám sudoku desku zpět.

1359
01:23:53,430 --> 01:23:56,320
Board.level, jsem si, jak těžké to je.

1360
01:23:56,320 --> 01:24:00,540
Board.x a board.y dej mi souřadnice, kde bych mohl být na desce.

1361
01:24:00,540 --> 01:24:04,730
A tak jsem přístup, co nazýváme pole v struct.

1362
01:24:04,730 --> 01:24:08,840
Toto definuje sudokuBoard, což je typ, který mám.

1363
01:24:08,840 --> 01:24:14,800
A teď jsme tady. Mám proměnnou s názvem "board" typu sudokuBoard.

1364
01:24:14,800 --> 01:24:18,820
A tak teď můžu přistupovat všechna pole, která tvoří tuto strukturu tady.

1365
01:24:20,830 --> 01:24:22,450
>> Jakékoliv otázky structs? Ano?

1366
01:24:22,450 --> 01:24:25,890
[Student] Pro int x, y, jste prohlásil oba na jednom řádku? >> [Joseph] Uh-huh.

1367
01:24:25,890 --> 01:24:27,400
[Student] Takže, mohl by si udělat se všemi z nich?

1368
01:24:27,400 --> 01:24:31,200
Stejně jako v roce X, Y čárka časy, že celkové?

1369
01:24:31,200 --> 01:24:34,460
[Joseph] Ano, mohl byste určitě udělat, ale důvod, proč jsem dal x a y na stejném řádku -

1370
01:24:34,460 --> 01:24:36,330
a otázkou je, proč můžeme jen to na stejném řádku?

1371
01:24:36,330 --> 01:24:38,600
Proč jsme jen dát všechny tyto na stejném řádku je

1372
01:24:38,600 --> 01:24:42,090
x a y jsou ve vzájemném vztahu,

1373
01:24:42,090 --> 01:24:44,780
a je to jen stylisticky přesnější, v tom smyslu,

1374
01:24:44,780 --> 01:24:46,600
protože je to seskupení dvě věci na stejném řádku

1375
01:24:46,600 --> 01:24:49,340
že jako druh se vztahují ke stejné věci.

1376
01:24:49,340 --> 01:24:51,440
A já prostě rozdělit tyto od sebe. Je to jen styl věc.

1377
01:24:51,440 --> 01:24:53,720
Je funkčně není rozdíl vůbec.

1378
01:24:58,150 --> 01:24:59,270
Jakékoliv další otázky týkající se structs?

1379
01:25:03,030 --> 01:25:06,620
Můžete definovat Pokédex s struct.

1380
01:25:06,620 --> 01:25:11,720
Pokémon má své číslo a má dopis, vlastníka, typ.

1381
01:25:11,720 --> 01:25:16,990
A pak, pokud máte pole Pokémon, můžete vytvořit Pokédex, že jo?

1382
01:25:16,990 --> 01:25:20,810
Dobře, v pohodě. Takže, otázky týkající se structs. Ti, kteří jsou příbuzní k structs.

1383
01:25:20,810 --> 01:25:25,270
>> Konečně, GDB. Co GDB nechat udělat? To vám umožní ladit svůj program.

1384
01:25:25,270 --> 01:25:27,650
A pokud jste nepoužili GDB, bych doporučil sledovat krátké

1385
01:25:27,650 --> 01:25:31,250
a jen tak nad tím, co GDB je, jak s ním pracovat, jak byste mohli použít,

1386
01:25:31,250 --> 01:25:32,900
a vyzkoušet na programu.

1387
01:25:32,900 --> 01:25:37,400
A tak to, co GDB můžete udělat, je, že umožňuje Pozastavit [nesrozumitelné] až do vašeho programu

1388
01:25:37,400 --> 01:25:38,920
a praktické linie.

1389
01:25:38,920 --> 01:25:42,600
Například, chci pozastavit plnění v souladu jako 3 z mého programu,

1390
01:25:42,600 --> 01:25:46,010
a když jsem na řádku 3 mohu vytisknout všechny hodnoty, které jsou tam.

1391
01:25:46,010 --> 01:25:49,710
A tak to, co nazýváme jako zastavil v řadě

1392
01:25:49,710 --> 01:25:52,350
je nazýváme uvedení zarážku na tomto řádku

1393
01:25:52,350 --> 01:25:55,920
a pak můžeme vytisknout proměnné na stavu programu v té době.

1394
01:25:55,920 --> 01:25:58,990
>> Můžeme pak odtamtud krokovat program řádek po řádku.

1395
01:25:58,990 --> 01:26:03,200
A pak jsme se podívat na stav zásobníku v té době.

1396
01:26:03,200 --> 01:26:08,600
A tak aby bylo možné používat GDB, co děláme, je říkáme řinčení na soubor C,

1397
01:26:08,600 --> 01:26:11,290
ale musíme předat-ggdb vlajkou.

1398
01:26:11,290 --> 01:26:15,850
A jakmile jsme skončili s tím jsme jen spustit gdb na výsledném výstupního souboru.

1399
01:26:15,850 --> 01:26:18,810
A tak si trochu jako hmotnost textu jako je tento,

1400
01:26:18,810 --> 01:26:21,990
ale opravdu vše, co musíte udělat, je zadat příkazy na začátku.

1401
01:26:21,990 --> 01:26:24,250
Přestávka hlavní klade zarážku na hlavní.

1402
01:26:24,250 --> 01:26:28,470
Seznam 400 uvádí řádky kódu kolem řádku 400.

1403
01:26:28,470 --> 01:26:31,410
A tak v tomto případě stačí se podívat kolem sebe a říci, oh,

1404
01:26:31,410 --> 01:26:34,360
Chci nastavit zarážku na řádku 397, který je v tomto řádku,

1405
01:26:34,360 --> 01:26:37,170
a pak se váš program běží do tohoto kroku, a to rozbije.

1406
01:26:37,170 --> 01:26:41,120
Bude to pauze, a můžete tisknout, například, hodnota nízká nebo vysoká.

1407
01:26:41,120 --> 01:26:46,410
A tak tam jsou banda příkazy, které potřebujete vědět,

1408
01:26:46,410 --> 01:26:48,660
a to slideshow bude stoupat na webových stránkách,

1409
01:26:48,660 --> 01:26:54,000
takže pokud si jen chcete odkazovat těchto nebo jako dát je na své taháky, neváhejte.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. To bylo Quiz Review 0, a budeme držet kolem, pokud máte nějaké otázky.

1411
01:27:00,650 --> 01:27:03,850
Dobrá.

1412
01:27:03,850 --> 01:27:09,030
>>  [Potlesk]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]