1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Recenzia] [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šetci.

5
00:00:10,000 --> 00:00:15,000
Vitajte na preskúmanie zasadnutí pre Quiz 0, ktorý sa koná túto stredu.

6
00:00:15,000 --> 00:00:19,000
Čo budeme robiť dnes večer, som s ďalšími 3 TFS,

7
00:00:19,000 --> 00:00:24,000
a spoločne budeme prechádzať preskúmanie toho, čo sme urobili v priebehu tak ďaleko.

8
00:00:24,000 --> 00:00:27,000
Nebude to byť 100% vyčerpávajúce, ale mal by vám lepšiu predstavu

9
00:00:27,000 --> 00:00:31,000
z toho, čo už máte, to, čo budete ešte potrebovať k štúdiu pred stredou.

10
00:00:31,000 --> 00:00:34,000
A neváhajte zdvihnúť ruku s otázky, ako budeme spolu,

11
00:00:34,000 --> 00:00:38,000
ale majte na pamäti, že budeme mať aj trochu času na konci roka

12
00:00:38,000 --> 00:00:41,000
ak sa dostaneme až s niekoľkými minút náhradných robiť všeobecných otázok,

13
00:00:41,000 --> 00:00:47,000
takže majte na pamäti, že, a tak budeme začať od začiatku s týždni 0.

14
00:00:47,000 --> 00:00:50,000
>> [Kvíz 0 recenziu!] [Časť 0] [Lexi Ross] Ale skôr ako my, že Poďme hovoriť o

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

16
00:00:53,000 --> 00:00:55,000
>> [Logistics] [Quiz sa uskutoční v stredu 10/10 namiesto prednášky]

17
00:00:55,000 --> 00:00:57,000
>> [(Pozri http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf pre podrobnosti)] Je v stredu 10. októbra.

18
00:00:57,000 --> 00:01:00,000
>> To je to streda, a ak idete na túto adresu URL tu,

19
00:01:00,000 --> 00:01:03,000
ktorý je tiež prístupný z CS50.net-tam odkaz na to,

20
00:01:03,000 --> 00:01:06,000
môžete zobraziť informácie o tom, kde ísť na základe

21
00:01:06,000 --> 00:01:10,000
Vaše priezvisko alebo školy príslušnosť, ako aj

22
00:01:10,000 --> 00:01:14,000
to povie, čo presne ten kvíz bude týkať a typy otázok, ktoré budete dostať.

23
00:01:14,000 --> 00:01:19,000
Majte na pamäti, že budete mať tiež možnosť skontrolovať pre kvíz v sekcii,

24
00:01:19,000 --> 00:01:21,000
takže vaše TFS mala ísť cez niektoré problémy praxe,

25
00:01:21,000 --> 00:01:29,000
a to je ďalšia dobrá šanca vidieť, kde ste ešte potrebovať k štúdiu až na kvíz.

26
00:01:29,000 --> 00:01:32,000
Začnime na začiatku s Bytes 'n' kúsky.

27
00:01:32,000 --> 00:01:35,000
Nezabudnite bit je len 0 alebo 1,

28
00:01:35,000 --> 00:01:38,000
a byte je zbierka 8 týchto bitov.

29
00:01:38,000 --> 00:01:42,000
Poďme sa pozrieť na tejto kolekcie bitov tu.

30
00:01:42,000 --> 00:01:44,000
Mali by sme byť schopní zistiť, koľko bitov je.

31
00:01:44,000 --> 00:01:48,000
Ak budeme počítať, že je to len 8 z nich, osem 0 alebo 1 ks.

32
00:01:48,000 --> 00:01:51,000
A pretože tam je 8 bitov, to je 1 byte,

33
00:01:51,000 --> 00:01:53,000
a poďme previesť na šestnástkovej.

34
00:01:53,000 --> 00:01:58,000
Hexadecimálne je základ 16, a je to celkom jednoduché previesť

35
00:01:58,000 --> 00:02:01,000
číslo v binárnej, čo je to, čo to je, aby číslo v hexadecimálnej.

36
00:02:01,000 --> 00:02:04,000
Všetko, čo urobiť, je sa pozrieme na skupiny 4,

37
00:02:04,000 --> 00:02:07,000
a my ich previesť na zodpovedajúce hexadecimálne číslice.

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

39
00:02:11,000 --> 00:02:16,000
To sa deje za jednu 1 a jeden 2, tak spoločne, že robí 3.

40
00:02:16,000 --> 00:02:19,000
A potom sa poďme pozrieť na ďalší blok 4.

41
00:02:19,000 --> 00:02:24,000
1101. To sa deje za jeden 1, jeden 4, a jeden 8.

42
00:02:24,000 --> 00:02:28,000
Spoločne, že to bude 13, čo D.

43
00:02:28,000 --> 00:02:32,000
A budeme pamätať, že v šestnástkovej sústave nemáme len tak 0 až 9.

44
00:02:32,000 --> 00:02:36,000
Ideme 0 až F, takže po 9, 10, zodpovedá,

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
Tu 13 je D,

47
00:02:44,000 --> 00:02:49,000
tak previesť na desatinné všetko, čo robíme je, že sme vlastne

48
00:02:49,000 --> 00:02:52,000
Ku každému pozíciu ako sila 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 ťažké spočítať v hlave, ale keď pôjdeme na ďalšiu snímku

51
00:03:03,000 --> 00:03:05,000
môžeme vidieť odpoveď.

52
00:03:05,000 --> 00:03:09,000
>> V podstate budeme naproti staré doľava,

53
00:03:09,000 --> 00:03:14,000
a my sme vynásobí jednotlivé číslice zodpovedajúcim sila 2.

54
00:03:14,000 --> 00:03:19,000
A pamätajte, na hexadecimálne označíme týchto čísel 0x na začiatku

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

56
00:03:23,000 --> 00:03:29,000
Pokračovanie, toto je ASCII tabuľka,

57
00:03:29,000 --> 00:03:35,000
a to, čo používame ASCII, je mapovať z postáv do numerických hodnôt.

58
00:03:35,000 --> 00:03:39,000
Nezabudnite v PSet kryptografie sme rozsiahle použitie ASCII tabuľky

59
00:03:39,000 --> 00:03:43,000
aby bolo možné používať rôzne metódy kryptografie,

60
00:03:43,000 --> 00:03:47,000
Caesar a Vigenère kód, previesť rôzne listy

61
00:03:47,000 --> 00:03:52,000
v reťazci podľa kľúča daného užívateľom.

62
00:03:52,000 --> 00:03:56,000
Poďme sa pozrieť na trochu ASCII matematiky.

63
00:03:56,000 --> 00:04:02,000
Pri pohľade na "P" + 1, v charaktere podobe, ktorá by bola Q,

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

65
00:04:07,000 --> 00:04:10,000
A ako presne by sme prevádzať medzi týmito 2 formulára?

66
00:04:10,000 --> 00:04:13,000
Vlastne to ani nie je príliš tvrdý.

67
00:04:13,000 --> 00:04:16,000
Aby bolo možné získať 5 odpočítame '0 '

68
00:04:16,000 --> 00:04:20,000
pretože tam sú 5 miest medzi '0 'a '5.'

69
00:04:20,000 --> 00:04:23,000
Aby išiel na druhú stranu sme práve pridať 0,

70
00:04:23,000 --> 00:04:25,000
takže je to niečo ako pravidelné aritmetiky.

71
00:04:25,000 --> 00:04:29,000
Len nezabudnite, že keď sa niečo má úvodzovky okolo neho, že je to postava

72
00:04:29,000 --> 00:04:37,000
a teda zodpovedá hodnote v tabuľke ASCII.

73
00:04:37,000 --> 00:04:40,000
Presun do všeobecnejších tém počítačových vied.

74
00:04:40,000 --> 00:04:43,000
Naučili sme sa, čo je algoritmus a ako ich používame programovanie

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

76
00:04:45,000 --> 00:04:48,000
Niektoré príklady algoritmov sú niečo naozaj jednoduchého, ako

77
00:04:48,000 --> 00:04:51,000
kontroly, či je číslo párne alebo nepárne.

78
00:04:51,000 --> 00:04:54,000
Za to si, sme mod na číslo 2 a skontrolujte, či výsledok je 0.

79
00:04:54,000 --> 00:04:57,000
Ak áno, je to ešte. Ak tomu tak nie je, je to zvláštne.

80
00:04:57,000 --> 00:04:59,000
A to je príklad naozaj základné algoritmus.

81
00:04:59,000 --> 00:05:02,000
>> Trochu viac sa zúčastňuje jeden je binárne vyhľadávanie,

82
00:05:02,000 --> 00:05:05,000
ktoré pôjdeme cez neskôr v prieskumnom pojednávaní.

83
00:05:05,000 --> 00:05:09,000
A programovanie je termín používame pre prijatie algoritmus

84
00:05:09,000 --> 00:05:15,000
a prevedením na kódovanie počítač môže čítať.

85
00:05:15,000 --> 00:05:20,000
2 príklady programovania je Scratch,

86
00:05:20,000 --> 00:05:22,000
čo je to, čo sme robili v týždni 0.

87
00:05:22,000 --> 00:05:25,000
Aj keď nemáme vlastne zadajte von kód je spôsob, ktorým sa vykonáva

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

89
00:05:29,000 --> 00:05:32,000
a tu sme to isté v C programovací jazyk.

90
00:05:32,000 --> 00:05:41,000
Jedná sa o funkčne ekvivalentný, práve písané v rôznych jazykoch alebo syntaxe.

91
00:05:41,000 --> 00:05:44,000
Potom sme sa dozvedeli o booleovských výrazoch,

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

93
00:05:48,000 --> 00:05:51,000
a tu mnohokrát booleovské výrazy

94
00:05:51,000 --> 00:05:55,000
dovnútra podmienok, tak ak (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
dobre, sme už nastavili x = 5, takže táto podmienka bude hodnotiť na true.

96
00:06:00,000 --> 00:06:03,000
A ak je to pravda, čo je kód pod podmienkou,

97
00:06:03,000 --> 00:06:08,000
sa bude hodnotená na počítači, tak, že reťazec sa bude vytlačený

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

99
00:06:12,000 --> 00:06:16,000
odkazuje na to, čo je vo vnútri zátvoriek if.

100
00:06:16,000 --> 00:06:20,000
Nezabudnite všetkých operátorov.

101
00:06:20,000 --> 00:06:26,000
Pamätajte si, že tieto && a | |, keď sa snažíme kombinovať 2 a viac podmienok,

102
00:06:26,000 --> 00:06:30,000
== Nie = kontrolovať, či 2 veci sú si rovné.

103
00:06:30,000 --> 00:06:36,000
Pamätajte si, že = je pre priradenie vzhľadom k tomu, == je logický operátor.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ a potom v konečnom znení 2 sú zrejmé.

105
00:06:41,000 --> 00:06:45,000
Všeobecné preskúmanie booleovské logiky tu.

106
00:06:45,000 --> 00:06:48,000
A booleovské výrazy sú tiež dôležité v slučkách,

107
00:06:48,000 --> 00:06:50,000
ktoré pôjdeme preč.

108
00:06:50,000 --> 00:06:56,000
Naučili sme sa asi 3 typy slučiek tak ďaleko CS50, for, while, a to pri.

109
00:06:56,000 --> 00:06:59,000
A to je dôležité vedieť, že zatiaľ čo pre väčšinu účelov

110
00:06:59,000 --> 00:07:02,000
môžeme skutočne použiť akýkoľvek typ slučky všeobecne

111
00:07:02,000 --> 00:07:06,000
existujú určité typy účely alebo spoločných vzorov

112
00:07:06,000 --> 00:07:09,000
v programovaní, ktoré sa špecificky nazývajú pre jeden z týchto slučiek

113
00:07:09,000 --> 00:07:13,000
že aby bolo najúčinnejšie alebo elegantné kód to týmto spôsobom.

114
00:07:13,000 --> 00:07:18,000
Poďme čo každý z týchto slučiek má tendenciu byť použité pre najčastejšie.

115
00:07:18,000 --> 00:07:21,000
>> V cykle for sme všeobecne už vieme, koľkokrát chceme určiť iteráciou.

116
00:07:21,000 --> 00:07:24,000
To je to, čo sme v podmienke.

117
00:07:24,000 --> 00:07:28,000
Pre, i = 0, i <10, napríklad.

118
00:07:28,000 --> 00:07:31,000
My už vieme, že chceme urobiť niečo 10 krát.

119
00:07:31,000 --> 00:07:34,000
Teraz, po slučke while, obvykle nemáme nutne

120
00:07:34,000 --> 00:07:36,000
Vieš, koľkokrát chceme slučku spustiť.

121
00:07:36,000 --> 00:07:39,000
Ale my vieme nejakú podmienkou, že chceme, aby to

122
00:07:39,000 --> 00:07:41,000
byť vždy pravdivé, alebo vždy false.

123
00:07:41,000 --> 00:07:44,000
Napríklad, je nastavená pri.

124
00:07:44,000 --> 00:07:46,000
Povedzme, že je to boolean premennej.

125
00:07:46,000 --> 00:07:48,000
Aj keď to je pravda chceme kód na vyhodnotenie,

126
00:07:48,000 --> 00:07:52,000
tak trochu viac rozšíriteľný, trochu všeobecnejšie než pre sláčiky,

127
00:07:52,000 --> 00:07:55,000
ale každý pre slučke možno tiež previesť na slučke while.

128
00:07:55,000 --> 00:08:00,000
Napokon, to while, ktoré môžu byť najzložitejšie pochopiť hneď,

129
00:08:00,000 --> 00:08:04,000
sa často používajú, keď chceme vyhodnotiť kód prvý

130
00:08:04,000 --> 00:08:06,000
pred prvým sme skontrolovať stav.

131
00:08:06,000 --> 00:08:09,000
Bežným príkladom použitia robiť, keď slučka

132
00:08:09,000 --> 00:08:12,000
je, keď sa chcete dostať vstup užívateľa, a viete, že chcete požiadať užívateľa

133
00:08:12,000 --> 00:08:15,000
pre vstup aspoň raz, ale v prípade, že nie sú ti dobrú vstup hneď

134
00:08:15,000 --> 00:08:18,000
Ak chcete zachovať pýtať sa ich, kým vám dobrú vstup.

135
00:08:18,000 --> 00:08:21,000
To je najviac obyčajné použitie sa while,

136
00:08:21,000 --> 00:08:23,000
a poďme sa pozrieť na vlastné štruktúry týchto slučiek.

137
00:08:23,000 --> 00:08:27,000
Oni typicky vždy majú tendenciu nasledovať tieto vzory.

138
00:08:27,000 --> 00:08:30,000
>> Na slučky for vnútri máte 3 zložky:

139
00:08:30,000 --> 00:08:35,000
inicializácia, zvyčajne niečo ako int i = 0, kde i je počítadlo,

140
00:08:35,000 --> 00:08:40,000
stav, keď chceme povedať, spustiť tento cyklus for tak dlho, ako tento stav stále platí,

141
00:08:40,000 --> 00:08:44,000
ako aj <10, a potom konečne, aktualizácie, čo je, ako sme zvýšiť

142
00:08:44,000 --> 00:08:47,000
čítač premennú v každom bode slučky.

143
00:08:47,000 --> 00:08:50,000
Bežná vec vidieť, že je len i + +,

144
00:08:50,000 --> 00:08:52,000
čo znamená zvýšiť aj o 1 zakaždým.

145
00:08:52,000 --> 00:08:55,000
Dalo by sa tiež urobiť niečo podobné aj + = 2,

146
00:08:55,000 --> 00:08:58,000
čo znamená, pridajte 2 až i zakaždým, keď idete cez slučku.

147
00:08:58,000 --> 00:09:03,000
A potom to len sa odkazuje na nejaký kód, ktorý vlastne beží ako súčasť slučky.

148
00:09:03,000 --> 00:09:09,000
A pre sláčiky while, tentoraz sme vlastne tu inicializácii mimo slučky,

149
00:09:09,000 --> 00:09:12,000
tak napríklad, povedzme, že sa snažíme robiť rovnaký typ slučky, ako som práve opísal.

150
00:09:12,000 --> 00:09:16,000
Mali by sme povedať, int i = 0 pred slučka začne.

151
00:09:16,000 --> 00:09:20,000
Potom by sme mohli povedať, keď aj <10 to,

152
00:09:20,000 --> 00:09:22,000
takže rovnaký blok kódu ako predtým,

153
00:09:22,000 --> 00:09:26,000
a tentoraz aktualizácia časť kódu, napríklad, i + +,

154
00:09:26,000 --> 00:09:29,000
vlastne ide vnútri slučky.

155
00:09:29,000 --> 00:09:33,000
A konečne, pre robiť, zatiaľ čo, to je podobný while,

156
00:09:33,000 --> 00:09:36,000
ale musíme mať na pamäti, že kód bude hodnotiť, akonáhle

157
00:09:36,000 --> 00:09:40,000
pred podmienka je kontrolovaná, takže je oveľa väčší zmysel

158
00:09:40,000 --> 00:09:44,000
keď sa pozriete na to v poradí zhora nadol.

159
00:09:44,000 --> 00:09:49,000
V robiť, keď slučka kód hodnotí ešte predtým, než sa pozrieť na while stavu,

160
00:09:49,000 --> 00:09:55,000
vzhľadom k tomu, while, skontroluje ako prvý.

161
00:09:55,000 --> 00:09:59,000
Vyhlásenie a premenné.

162
00:09:59,000 --> 00:10:04,000
Keď chceme vytvoriť novú premennú sme najprv chcieť inicializovať.

163
00:10:04,000 --> 00:10:07,000
>> Napríklad, int bar inicializuje premennú bar,

164
00:10:07,000 --> 00:10:10,000
ale to nedáva hodnotu, takže to, čo sa nachádza bar má hodnotu teraz?

165
00:10:10,000 --> 00:10:12,000
Nevieme.

166
00:10:12,000 --> 00:10:14,000
Mohlo by to byť nejaký odpadky hodnota, ktorá bola predtým uložená v pamäti tam,

167
00:10:14,000 --> 00:10:16,000
a nechceme použiť túto premennú

168
00:10:16,000 --> 00:10:19,000
kým sme vlastne dať hodnotu,

169
00:10:19,000 --> 00:10:21,000
tak sme vyhlásiť ju tu.

170
00:10:21,000 --> 00:10:24,000
Potom sme inicializovať, aby to bolo 42 nižšie.

171
00:10:24,000 --> 00:10:28,000
Teraz, samozrejme, vieme, že sa to dá urobiť na jednom riadku, int bar = 42.

172
00:10:28,000 --> 00:10:30,000
Ale len preto, aby sa vymazať niekoľko krokov, ktoré sa dejú,

173
00:10:30,000 --> 00:10:34,000
vyhlásenia a inicializácia sa deje oddelene tu.

174
00:10:34,000 --> 00:10:38,000
To sa deje v jednom kroku, a budúci, int baz = bar + 1,

175
00:10:38,000 --> 00:10:44,000
toto vyhlásenie nižšie, ktoré sa zvýši baz, takže na konci tohto bloku kódu

176
00:10:44,000 --> 00:10:48,000
keby sme vytlačiť hodnotu baz by byť 44

177
00:10:48,000 --> 00:10:52,000
pretože sme deklarovať a inicializovať ju na 1> bar,

178
00:10:52,000 --> 00:10:58,000
a potom sme zvýšiť ju ešte raz + +.

179
00:10:58,000 --> 00:11:02,000
Išli sme cez tento pekný krátko, ale je to dobré mať všeobecnú

180
00:11:02,000 --> 00:11:04,000
pochopenie toho, čo tém a udalosti sú.

181
00:11:04,000 --> 00:11:06,000
Zameriavame sa predovšetkým to urobil v Scratch,

182
00:11:06,000 --> 00:11:09,000
takže si môžete myslieť vlákien as niekoľkými sekvencií kódu

183
00:11:09,000 --> 00:11:11,000
beží v rovnakom čase.

184
00:11:11,000 --> 00:11:14,000
V skutočnosti, pravdepodobne nebeží súčasne,

185
00:11:14,000 --> 00:11:17,000
ale druh abstraktne, môžeme myslieť na to týmto spôsobom.

186
00:11:17,000 --> 00:11:20,000
>> V Scratch, napríklad, mali sme viac škriatkov.

187
00:11:20,000 --> 00:11:22,000
Môže to byť prevedenie iný kód v rovnakom čase.

188
00:11:22,000 --> 00:11:26,000
Jeden by mohol byť pri chôdzi druhý hovorí niečo

189
00:11:26,000 --> 00:11:29,000
v inej časti obrazovky.

190
00:11:29,000 --> 00:11:34,000
Udalosti sú ďalší spôsob, ako oddelí logiku

191
00:11:34,000 --> 00:11:37,000
medzi rôznymi prvkami kódu,

192
00:11:37,000 --> 00:11:40,000
a Scratch sme schopní simulovať udalosti pomocou vysielania,

193
00:11:40,000 --> 00:11:43,000
a to je vlastne, keď dostanem, nie, keď počujem,

194
00:11:43,000 --> 00:11:47,000
ale v podstate je to spôsob, ako odovzdávať informácie

195
00:11:47,000 --> 00:11:49,000
z jedného škriatka do druhého.

196
00:11:49,000 --> 00:11:52,000
Napríklad, môžete chcieť prenášať hru cez,

197
00:11:52,000 --> 00:11:56,000
a keď iný objekt sprite dostane hru cez,

198
00:11:56,000 --> 00:11:58,000
reaguje určitým spôsobom.

199
00:11:58,000 --> 00:12:03,000
Je to dôležitý model pre pochopenie pre programovanie.

200
00:12:03,000 --> 00:12:07,000
Stačí ísť po základnej týždňa 0, čo sme preč cez tak ďaleko,

201
00:12:07,000 --> 00:12:10,000
Poďme sa pozrieť na tento jednoduchý C program.

202
00:12:10,000 --> 00:12:14,000
Text môže byť trochu malý odtiaľ, ale ja pôjdem cez to naozaj rýchlo.

203
00:12:14,000 --> 00:12:20,000
Sme vrátane 2 hlavičkové súbory v hornom, cs50.h a stdio.h.

204
00:12:20,000 --> 00:12:23,000
Sme potom definovať konštantné názvom limity na 100.

205
00:12:23,000 --> 00:12:26,000
Sme potom robí náš hlavnú funkciu.

206
00:12:26,000 --> 00:12:29,000
Vzhľadom k tomu nemáme používať argumenty príkazového riadku tu musíme dať za neplatné

207
00:12:29,000 --> 00:12:32,000
ako argumenty pre hlavné.

208
00:12:32,000 --> 00:12:38,000
Vidíme int main vyššie. To je návratový typ, a preto vráti 0 na dne.

209
00:12:38,000 --> 00:12:41,000
A my sme pomocou CS50 knižnice funkcií získate int

210
00:12:41,000 --> 00:12:45,000
požiadať užívateľa pre vstup, a uložíme ju v tejto premennej x,

211
00:12:45,000 --> 00:12:51,000
tak prehlasujeme x vyššie, a inicializuje ju x = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> Potom sme skontrolovať, či používateľ dal nám dobrý vstup.

213
00:12:53,000 --> 00:12:59,000
Ak je to ≥ LIMIT chceme vrátiť kód chyby 1 a vytlačí chybové hlásenie.

214
00:12:59,000 --> 00:13:02,000
A konečne, v prípade, že používateľ je nám dobrý vstup

215
00:13:02,000 --> 00:13:08,000
budeme na námestí číslo a vytlačí na to, že výsledok.

216
00:13:08,000 --> 00:13:11,000
Len aby sa ubezpečil, že ti všetci hit domov

217
00:13:11,000 --> 00:13:17,000
môžete vidieť štítky rôznych častí kódu tu.

218
00:13:17,000 --> 00:13:19,000
Zmienil som sa konštantná, hlavičkové súbory.

219
00:13:19,000 --> 00:13:21,000
Oh, int x. Uistite sa, že si uvedomiť, že je to lokálna premenná.

220
00:13:21,000 --> 00:13:24,000
To kontrastuje z globálne premenné, ktoré budeme hovoriť o

221
00:13:24,000 --> 00:13:27,000
trochu neskôr v prieskumnom pojednávaní,

222
00:13:27,000 --> 00:13:30,000
a my sme volaní knižničný funkcie printf,

223
00:13:30,000 --> 00:13:34,000
takže ak sme nezahrnula stdio.h hlavičkový súbor

224
00:13:34,000 --> 00:13:37,000
by sme neboli schopní zavolať printf.

225
00:13:37,000 --> 00:13:42,000
A ja verím, šípka, ktorá sa dostal odrezal tu ukazuje na% d,

226
00:13:42,000 --> 00:13:45,000
ktorý je formátovací reťazec, v printf.

227
00:13:45,000 --> 00:13:52,000
To hovorí, že vytlačiť túto premennú ako počet,% d

228
00:13:52,000 --> 00:13:58,000
A to je pre týždeň 0.

229
00:13:58,000 --> 00:14:06,000
Teraz Lucas sa bude aj naďalej pokračovať.

230
00:14:06,000 --> 00:14:08,000
Ahoj, chlapci. Moje meno je Lucas.

231
00:14:08,000 --> 00:14:10,000
Som v druháku v najlepšom dome na akademickej pôde, Mather,

232
00:14:10,000 --> 00:14:14,000
a budem hovoriť trochu o 1. týždňa a 2,1.

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

234
00:14:16,000 --> 00:14:19,000
Ako Lexi hovoril, keď sme začali prekladať váš kód od nuly do C

235
00:14:19,000 --> 00:14:23,000
jedna z vecí, ktoré sme si všimli, je, že môžete nielen

236
00:14:23,000 --> 00:14:26,000
napísať svoj kód a spustiť ho pomocou zelenú vlajkou už.

237
00:14:26,000 --> 00:14:30,000
Vlastne, budete musieť použiť niektoré kroky, aby sa váš C program

238
00:14:30,000 --> 00:14:33,000
stať spustiteľný súbor.

239
00:14:33,000 --> 00:14:36,000
V podstate to, čo robíte, keď píšete program, je to, že

240
00:14:36,000 --> 00:14:40,000
môžete preložiť svoj nápad do jazyka, ktorý kompilátor môže pochopiť,

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

242
00:14:44,000 --> 00:14:47,000
to, čo robíte je vlastne písať niečo, čo váš kompilátor bude rozumieť,

243
00:14:47,000 --> 00:14:50,000
a potom kompilátor bude prekladať tento kód

244
00:14:50,000 --> 00:14:53,000
do niečoho, že váš počítač bude rozumieť.

245
00:14:53,000 --> 00:14:55,000
>> A vec je, počítač je vlastne veľmi hlúpa.

246
00:14:55,000 --> 00:14:57,000
Váš počítač môže chápať iba 0s a 1s,

247
00:14:57,000 --> 00:15:01,000
takže vlastne v prvých počítačoch ľudia zvyčajne naprogramovaný

248
00:15:01,000 --> 00:15:04,000
pomocou 0s a 1s, ale teraz už nie, vďaka bohu.

249
00:15:04,000 --> 00:15:07,000
Nemáme si zapamätať sekvencie 0s a 1s

250
00:15:07,000 --> 00:15:10,000
pre cyklus for alebo while cyklu a tak ďalej.

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

252
00:15:13,000 --> 00:15:17,000
Čo kompilátor robí, je to v podstate prevádza C kód,

253
00:15:17,000 --> 00:15:21,000
V našom prípade, na jazyk, ktorý váš počítač bude rozumieť,

254
00:15:21,000 --> 00:15:25,000
, Ktorá je predmetom kód a kompilátor že používame

255
00:15:25,000 --> 00:15:30,000
sa nazýva zvonenie, takže to je vlastne symbol pre kovový zvuk.

256
00:15:30,000 --> 00:15:33,000
Ak máte svoj program, čo musíte urobiť, 2 veci.

257
00:15:33,000 --> 00:15:37,000
Po prvé, budete musieť kompilovať svoj program, a potom budete na spustenie programu.

258
00:15:37,000 --> 00:15:41,000
Ak chcete zostaviť svoj program máte veľa možností, aby tak urobili.

259
00:15:41,000 --> 00:15:44,000
Prvá z nich je urobiť rinčať program.c

260
00:15:44,000 --> 00:15:47,000
v ktorom programe je názov programu.

261
00:15:47,000 --> 00:15:51,000
V tomto prípade môžete vidieť, že hovoríš len "Hej, kompilovať svoj program."

262
00:15:51,000 --> 00:15:56,000
Vy nehovoríte "Chcem tento názov pre svoj program" alebo tak niečo.

263
00:15:56,000 --> 00:15:58,000
>> Druhou možnosťou je dať meno do svojho programu.

264
00:15:58,000 --> 00:16:02,000
Môžete povedať, že klap-o a potom názov, ktorý chcete

265
00:16:02,000 --> 00:16:06,000
spustiteľný súbor, ktorý bude vymenovaný ako a potom program.c.

266
00:16:06,000 --> 00:16:11,000
A môžete tiež urobiť, aby program, a uvidíte, ako v prvých 2 prípadoch

267
00:16:11,000 --> 00:16:15,000
Dal som. C, a v tretej som len programy?

268
00:16:15,000 --> 00:16:18,000
Jo, vlastne by nemalo. C. pri použití robiť.

269
00:16:18,000 --> 00:16:22,000
V opačnom prípade kompilátor bude skutočne kričať na vás.

270
00:16:22,000 --> 00:16:24,000
A tiež, ja neviem, či ste pamätám,

271
00:16:24,000 --> 00:16:29,000
ale veľa krát sme tiež použili-lcs50 alebo-lm.

272
00:16:29,000 --> 00:16:31,000
To sa nazýva prepojenie.

273
00:16:31,000 --> 00:16:35,000
Je to jednoducho hovorí kompilátora, že budete používať tieto knižnice práve tam,

274
00:16:35,000 --> 00:16:39,000
takže ak chcete použiť cs50.h máte skutočne písať

275
00:16:39,000 --> 00:16:43,000
rinčanie program.c-lcs50.

276
00:16:43,000 --> 00:16:45,000
Ak tak neurobíte, že kompilátor nebude vedieť

277
00:16:45,000 --> 00:16:50,000
, Že používate tieto funkcie v cs50.h.

278
00:16:50,000 --> 00:16:52,000
A keď chcete spustiť program, máte 2 možnosti.

279
00:16:52,000 --> 00:16:57,000
Ak ste rinčať program.c nedali ste meno k vášmu programu.

280
00:16:57,000 --> 00:17:01,000
Musíte ho spustiť pomocou. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out je štandardný názov, ktorý rinčať dáva svoj program, ak nechcete dať mu meno.

282
00:17:06,000 --> 00:17:11,000
Inak budete robiť. / Program, ak dal meno programu,

283
00:17:11,000 --> 00:17:15,000
a tiež ak ste urobiť programu názov, ktorý program dostane

284
00:17:15,000 --> 00:17:23,000
sa už bude naprogramovať rovnaký názov ako súbor c

285
00:17:23,000 --> 00:17:26,000
Potom sme sa rozprávali o dátových typoch a dát.

286
00:17:26,000 --> 00:17:31,000
>> V podstate dátové typy sú to isté ako malé krabičky, ktoré používajú

287
00:17:31,000 --> 00:17:35,000
na uloženie hodnôt, tak dátové typy sú v skutočnosti rovnako ako pokemonov.

288
00:17:35,000 --> 00:17:39,000
Prichádzajú vo všetkých veľkostí a typov.

289
00:17:39,000 --> 00:17:43,000
Neviem, či to analógia zmysel.

290
00:17:43,000 --> 00:17:46,000
Veľkosť dát skutočne záleží na architektúry stroja.

291
00:17:46,000 --> 00:17:49,000
Všetky dátové veľkosti, že budem pre zobrazenie tu

292
00:17:49,000 --> 00:17:53,000
sú v skutočnosti pre 32-bitové stroje, ktorý je v prípade nášho zariadenia,

293
00:17:53,000 --> 00:17:56,000
ale ak ste skutočne kódovanie vášho počítača Mac alebo v systéme Windows tiež

294
00:17:56,000 --> 00:17:59,000
Pravdepodobne budete mať 64-bit stroj,

295
00:17:59,000 --> 00:18:03,000
tak si pamätajte, že dátovej veľkosti, že budem pre zobrazenie tu

296
00:18:03,000 --> 00:18:06,000
sú pre 32-bitové stroje.

297
00:18:06,000 --> 00:18:08,000
Prvý z nich, že sme videli, bolo int,

298
00:18:08,000 --> 00:18:10,000
čo je celkom jednoduché.

299
00:18:10,000 --> 00:18:13,000
Môžete použiť int uložiť celé číslo.

300
00:18:13,000 --> 00:18:16,000
Videli sme tiež charakter, char.

301
00:18:16,000 --> 00:18:20,000
Ak chcete použiť písmeno alebo malý symbol budete pravdepodobne používať char.

302
00:18:20,000 --> 00:18:26,000
Char má 1 byte, čo znamená 8 bitov, ako Lexi povedal.

303
00:18:26,000 --> 00:18:31,000
V podstate máme ASCII tabuľky, ktorý má 256

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

305
00:18:34,000 --> 00:18:37,000
a potom, keď zadáte znak, že to bude prekladať

306
00:18:37,000 --> 00:18:44,000
znak, ktorý vstupy ste číslo, ktoré máte v ASCII tabuľke, ako Lexi povedal.

307
00:18:44,000 --> 00:18:48,000
Máme aj plavák, ktorý používame na ukladanie čísla v desiatkovej sústave.

308
00:18:48,000 --> 00:18:53,000
Ak si chcete vybrať 3,14, napríklad, budete používať float

309
00:18:53,000 --> 00:18:55,000
alebo dvojité, ktorý má väčšiu presnosť.

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 bajtov, takže jediný rozdiel je presnosť.

312
00:19:01,000 --> 00:19:04,000
Máme tiež dlhé, že sa používa pre celé čísla,

313
00:19:04,000 --> 00:19:09,000
a je vidieť na 32-bitové stroje int a dlhý majú rovnakú veľkosť,

314
00:19:09,000 --> 00:19:13,000
tak to nemá moc zmysel používať dlho v 32-bitovej stroje.

315
00:19:13,000 --> 00:19:17,000
>> Ale ak používate Mac a 64-bit stroj, v skutočnosti dlhá má veľkosť 8,

316
00:19:17,000 --> 00:19:19,000
tak, že záleží na architektúre.

317
00:19:19,000 --> 00:19:22,000
Pre 32-bit stroje nemá zmysel používať dlhé naozaj.

318
00:19:22,000 --> 00:19:25,000
A potom dlho dlho, na druhej strane, má 8 bajtov,

319
00:19:25,000 --> 00:19:30,000
tak to je veľmi dobré, ak chcete mať dlhšiu celé číslo.

320
00:19:30,000 --> 00:19:34,000
A konečne, máme reťazec, ktorý je v skutočnosti char *,

321
00:19:34,000 --> 00:19:37,000
ktorý je ukazovateľ na char.

322
00:19:37,000 --> 00:19:40,000
Je to veľmi jednoduché si myslieť, že veľkosť reťazca bude ako

323
00:19:40,000 --> 00:19:42,000
Počet znakov, ktoré tam máte,

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

325
00:19:45,000 --> 00:19:49,000
má veľkosť ukazovateľ na char, ktorý je 4 bajty.

326
00:19:49,000 --> 00:19:52,000
Veľkosť char * 4 byty.

327
00:19:52,000 --> 00:19:56,000
Nezáleží na tom, či máte malú slovo alebo písmeno alebo tak niečo.

328
00:19:56,000 --> 00:19:58,000
Bude to mať 4 byty.

329
00:19:58,000 --> 00:20:01,000
Tiež sme sa naučili trochu o obsadenie,

330
00:20:01,000 --> 00:20:04,000
takže ako vidíte, ak máte, napríklad, program, ktorý hovorí, ž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 viete, čo to bude tlačiť na obrazovke?

333
00:20:12,000 --> 00:20:14,000
>> Niekto? >> [Študenti] 2.

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

335
00:20:16,000 --> 00:20:20,000
Ak tak urobíte 3/2 to dostane 1,5,

336
00:20:20,000 --> 00:20:24,000
ale pretože sme použili celočíselnú to bude ignorovať desatinnú časť,

337
00:20:24,000 --> 00:20:26,000
a budete mať 1.

338
00:20:26,000 --> 00:20:29,000
Ak nechcete, aby sa to stalo, čo môžete urobiť, napríklad,

339
00:20:29,000 --> 00:20:33,000
je deklarovať plavák y = x.

340
00:20:33,000 --> 00:20:40,000
Potom x, ktoré bývali 3 sa teraz bude 3,000 v y.

341
00:20:40,000 --> 00:20:44,000
A potom si môžete vytlačiť y / 2.

342
00:20:44,000 --> 00:20:50,000
Vlastne, mal by som mať 2. tam.

343
00:20:50,000 --> 00:20:55,000
Bude to robiť 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
a budete sa dostať 1,5.

345
00:20:58,000 --> 00:21:06,000
A máme tento 0,2 f len požiadať o 2 desatinné jednotiek v desatinnú časť.

346
00:21:06,000 --> 00:21:12,000
Ak máte 0,3 f, že to bude mať skutočne 1,500.

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

348
00:21:16,000 --> 00:21:18,000
Máme aj tento prípad tu.

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

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

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

352
00:21:29,000 --> 00:21:34,000
čo znamená, že liečiť x ako int a tlačíte X teraz

353
00:21:34,000 --> 00:21:36,000
budete mať 3,00.

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

355
00:21:38,000 --> 00:21:41,000
Pretože ste prvý liečbu x ako celé číslo, takže ste ignoroval desatinnú časť,

356
00:21:41,000 --> 00:21:45,000
a potom tlačíte x.

357
00:21:45,000 --> 00:21:47,000
A konečne, môžete si tiež urobiť to,

358
00:21:47,000 --> 00:21:52,000
int x = 65, a potom vyhlásiť char c = x,

359
00:21:52,000 --> 00:21:56,000
a potom, ak tlačíte c ste vlastne dostane

360
00:21:56,000 --> 00:21:59,000
, Takže v podstate to, čo tu robíš

361
00:21:59,000 --> 00:22:02,000
je prekladať celé číslo do charakteru,

362
00:22:02,000 --> 00:22:05,000
rovnako ako ASCII tabuľka robí.

363
00:22:05,000 --> 00:22:08,000
Hovorili sme tiež o matematických operátorov.

364
00:22:08,000 --> 00:22:14,000
Väčšina z nich sú celkom jednoduché, takže +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
a tiež sa hovorí o mod, ktorý je zvyšok z delenia 2 čísla.

366
00:22:20,000 --> 00:22:23,000
Ak máte 10% 3, napríklad,

367
00:22:23,000 --> 00:22:27,000
to znamená rozdeliť 10 do 3, a to, čo je zvyšok?

368
00:22:27,000 --> 00:22:30,000
Bude to byť 1, takže je to vlastne veľmi užitočné pre mnoho programov.

369
00:22:30,000 --> 00:22:38,000
Pre Vigenère a Caesar Som si istý, že všetci z vás používa mod.

370
00:22:38,000 --> 00:22:43,000
O matematických operátorov, buďte veľmi opatrní pri kombinovaní * a /.

371
00:22:43,000 --> 00:22:48,000
>> Napríklad, ak si (3/2) * 2, čo sa vám dostane?

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

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

374
00:22:54,000 --> 00:22:57,000
ale pretože robíte operácie medzi 2 celé čísla

375
00:22:57,000 --> 00:22:59,000
ste vlastne len tak, aby zvážila 1,

376
00:22:59,000 --> 00:23:03,000
a potom 1 * 2 bude 2, takže sa veľmi, veľmi opatrní

377
00:23:03,000 --> 00:23:07,000
keď robí aritmetiku s celými číslami, pretože

378
00:23:07,000 --> 00:23:12,000
sa môžu vyskytnúť, že 2 = 3, v tomto prípade.

379
00:23:12,000 --> 00:23:14,000
A tiež byť veľmi opatrní prednosť.

380
00:23:14,000 --> 00:23:21,000
Mali by ste zvyčajne používajú zátvorky si byť istí, že viete, čo robíte.

381
00:23:21,000 --> 00:23:27,000
Niektoré užitočné skratky, samozrejme, jeden je aj + + alebo i + = 1

382
00:23:27,000 --> 00:23:30,000
alebo pomocou + =.

383
00:23:30,000 --> 00:23:34,000
To je to isté, ako robiť i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Môžete si tiež urobiť aj - alebo aj - = 1,

385
00:23:39,000 --> 00:23:42,000
ktorý je to isté, ako i = i-1,

386
00:23:42,000 --> 00:23:46,000
Niečo, čo ste chlapci používajú veľa v cykloch for, najmenej.

387
00:23:46,000 --> 00:23:52,000
Tiež, pre *, ak používate * = a ak áno, napríklad,

388
00:23:52,000 --> 00:23:57,000
i * = 2 je to isté, ako hovorí i = i * 2,

389
00:23:57,000 --> 00:23:59,000
a to isté pre rozdelenie.

390
00:23:59,000 --> 00:24:08,000
Ak si aj / = 2 je to to isté, ako i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Teraz o funkciách.

392
00:24:10,000 --> 00:24:13,000
Vy sa dozvedel, že funkcie sú veľmi dobrá stratégia pre uloženie kódu

393
00:24:13,000 --> 00:24:16,000
keď ste programovanie, takže ak chcete vykonať rovnakú úlohu

394
00:24:16,000 --> 00:24:20,000
v kóde znovu a znovu, pravdepodobne budete chcieť použiť funkciu

395
00:24:20,000 --> 00:24:25,000
len tak nemusíte kopírovať a vložiť kód znovu a znovu.

396
00:24:25,000 --> 00:24:28,000
Vlastne, hlavné je funkcia, a keď som vám ukázať formát funkcie

397
00:24:28,000 --> 00:24:32,000
budete vidieť, že to je celkom zrejmé.

398
00:24:32,000 --> 00:24:35,000
Používame tiež funkcie z niektorých knižníc,

399
00:24:35,000 --> 00:24:39,000
Napríklad, printf, Getin, ktorá je z knižnice CS50,

400
00:24:39,000 --> 00:24:43,000
a ďalšie funkcie, ako je toupper.

401
00:24:43,000 --> 00:24:46,000
Všetky tieto funkcie sú skutočne vykonávané v iných knižniciach,

402
00:24:46,000 --> 00:24:49,000
a keď dáte tieto postroja súbory na začiatku programu

403
00:24:49,000 --> 00:24:53,000
hovoríš, že môžete mi prosím dajte mi kód týchto funkcií

404
00:24:53,000 --> 00:24:57,000
takže nemám na ich vykonanie, sám?

405
00:24:57,000 --> 00:25:00,000
A môžete tiež napísať svoje vlastné funkcie, takže pri spustení programovanie

406
00:25:00,000 --> 00:25:04,000
Uvedomujete si, že knižnice nemajú všetky funkcie, ktoré potrebujete.

407
00:25:04,000 --> 00:25:10,000
V poslednom Pset, napríklad, sme písali čerpať, kódovanie, a vyhľadávanie,

408
00:25:10,000 --> 00:25:13,000
a je to veľmi, veľmi dôležité, aby sme boli schopní písať funkcie

409
00:25:13,000 --> 00:25:17,000
pretože sú užitočné, a my sme ich používať po celú dobu v programovaní,

410
00:25:17,000 --> 00:25:19,000
a to ušetrí veľa kódu.

411
00:25:19,000 --> 00:25:21,000
Formát funkcia je tento.

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

413
00:25:24,000 --> 00:25:27,000
Je to len, keď je vaša funkcia bude vracať.

414
00:25:27,000 --> 00:25:29,000
Ak máte funkciu, napríklad, faktoriál,

415
00:25:29,000 --> 00:25:31,000
, Ktorý sa chystá na výpočet faktoriálu celé číslo,

416
00:25:31,000 --> 00:25:34,000
Pravdepodobne to bude vrátiť celé číslo tiež.

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

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

419
00:25:41,000 --> 00:25:43,000
pretože nie ste vracať nič.

420
00:25:43,000 --> 00:25:45,000
Tie iba tlač veci na obrazovke

421
00:25:45,000 --> 00:25:48,000
a ukončenie funkcie potom.

422
00:25:48,000 --> 00:25:51,000
Potom máte názov funkcie, ktorá si môžete vybrať.

423
00:25:51,000 --> 00:25:55,000
Tie by mali byť trochu rozumný, ako nevyberajte meno ako xyz

424
00:25:55,000 --> 00:25:58,000
alebo ako x2f.

425
00:25:58,000 --> 00:26:02,000
Snažte sa, aby sa o názov, ktorý dáva zmysel.

426
00:26:02,000 --> 00:26:04,000
>> Napríklad, ak je to faktoriál, hovoria faktoriál.

427
00:26:04,000 --> 00:26:08,000
Ak je to funkcia, ktorá sa chystá na niečo nakresliť, pomenujte ju čerpať.

428
00:26:08,000 --> 00:26:11,000
A potom máme parametre, ktoré sú tiež nazývané argumenty,

429
00:26:11,000 --> 00:26:14,000
ktoré sú ako prostriedky, ktoré vaše funkcie potrebuje

430
00:26:14,000 --> 00:26:17,000
od kódu na plnenie svojej úlohy.

431
00:26:17,000 --> 00:26:20,000
Ak chcete vypočítať faktoriál čísla

432
00:26:20,000 --> 00:26:23,000
Pravdepodobne budete musieť mať rad pre výpočet faktoriálu.

433
00:26:23,000 --> 00:26:27,000
Jedným z argumentov, ktoré budete mať, je samotné číslo.

434
00:26:27,000 --> 00:26:31,000
A potom, že to bude niečo urobiť a vrátiť hodnotu na konci

435
00:26:31,000 --> 00:26:35,000
ak je to neplatné funkcie.

436
00:26:35,000 --> 00:26:37,000
Poďme sa pozrieť, príklad.

437
00:26:37,000 --> 00:26:40,000
Ak chcem napísať funkciu, ktorá spočíta všetky čísla v matici celých čísel,

438
00:26:40,000 --> 00:26:43,000
v prvom rade, návratový typ bude int

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

440
00:26:46,000 --> 00:26:51,000
A potom budem mať názov funkcie, ako sumArray,

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

442
00:26:54,000 --> 00:26:58,000
a potom dĺžka poľa, takže viem, koľko čísel musím zhrnúť.

443
00:26:58,000 --> 00:27:02,000
Potom som si inicializovať premennú s názvom čiastku, napríklad na 0,

444
00:27:02,000 --> 00:27:08,000
a zakaždým, keď vidím prvok v poli by som pridať do súčtu, tak som urobil pre sláčiky.

445
00:27:08,000 --> 00:27:15,000
Rovnako ako Lexi povedal, ty int i = 0, i <dĺžka a i + +.

446
00:27:15,000 --> 00:27:20,000
A pre každý prvok v poli som súčet + = nums [i],

447
00:27:20,000 --> 00:27:24,000
a potom som sa vrátil sumu, takže je to veľmi jednoduché, a to ušetrí veľa kódu

448
00:27:24,000 --> 00:27:28,000
Ak používate túto funkciu, mnohokrát.

449
00:27:28,000 --> 00:27:32,000
Potom sme sa pozreli na podmienkach.

450
00:27:32,000 --> 00:27:38,000
Ak máme, inak, a else if.

451
00:27:38,000 --> 00:27:42,000
Poďme sa pozrieť, aký je rozdiel medzi týmito.

452
00:27:42,000 --> 00:27:45,000
Pozrite sa na tieto 2 kódy. Aký je rozdiel medzi nimi?

453
00:27:45,000 --> 00:27:49,000
Prvý z nich, v podstate kódy chcú, aby si

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

455
00:27:51,000 --> 00:27:55,000
Prvý z nich hovorí, že ak je to> 0, potom je to pozitívne.

456
00:27:55,000 --> 00:28:00,000
Ak je to = 0, potom je to 0, a ak je to <0, potom je to negatívne.

457
00:28:00,000 --> 00:28:04,000
>> A druhý robí if, else if, else.

458
00:28:04,000 --> 00:28:07,000
Rozdiel medzi nimi je, že toto je vlastne bude

459
00:28:07,000 --> 00:28:13,000
skontrolujte, či> 0, <0 alebo = 0 trikrát,

460
00:28:13,000 --> 00:28:17,000
takže ak máte číslo 2, napríklad, to príde sem a povedať

461
00:28:17,000 --> 00:28:21,000
if (x> 0), a bude to, že áno, tak som vytlačiť pozitívne.

462
00:28:21,000 --> 00:28:25,000
Ale aj keď viem, že je to> 0 a nebude to na 0 alebo <0

463
00:28:25,000 --> 00:28:29,000
Som stále robiť, je to 0, je to <0,

464
00:28:29,000 --> 00:28:33,000
takže som vlastne deje vnútri fondy, ktoré som nemusela

465
00:28:33,000 --> 00:28:38,000
pretože už viem, že to nebude spĺňať niektorú z týchto podmienok.

466
00:28:38,000 --> 00:28:41,000
Môžem použiť if, else if, else príkaz.

467
00:28:41,000 --> 00:28:45,000
Je to v podstate hovorí, že ak x = 0 tlačiť pozitívne.

468
00:28:45,000 --> 00:28:48,000
Ak tomu tak nie je, budem aj tento test.

469
00:28:48,000 --> 00:28:51,000
Ak to 2 nie je budem robiť to.

470
00:28:51,000 --> 00:28:54,000
V podstate, ak som mal x = 2 by si povedal

471
00:28:54,000 --> 00:28:57,000
if (x> 0), áno, tak tlačiť.

472
00:28:57,000 --> 00:29:00,000
Teraz, keď viem, že je to> 0, a že je spokojný prvé, ak

473
00:29:00,000 --> 00:29:02,000
Nie som ani ísť spustiť tento kód.

474
00:29:02,000 --> 00:29:09,000
Kód beží rýchlejšie, vlastne, 3 krát rýchlejšie, ak použijete tento.

475
00:29:09,000 --> 00:29:11,000
Tiež sme sa dozvedeli o a a alebo.

476
00:29:11,000 --> 00:29:15,000
Nebudem sa prejsť, pretože Lexi už hovorili o nich.

477
00:29:15,000 --> 00:29:17,000
Je to len o && a | | prevádzkovateľ.

478
00:29:17,000 --> 00:29:21,000
>> Jediné, čo poviem, je byť opatrný, keď máte 3 podmienky.

479
00:29:21,000 --> 00:29:24,000
Použite zátvorky, pretože je to veľmi mätúce, keď máte podmienku

480
00:29:24,000 --> 00:29:27,000
a ďalší jeden alebo iný.

481
00:29:27,000 --> 00:29:30,000
Pomocou zátvoriek len pre istotu, že vaše podmienky zmysel

482
00:29:30,000 --> 00:29:34,000
pretože v tomto prípade, napríklad, môžu si predstaviť, že

483
00:29:34,000 --> 00:29:38,000
to by mohlo byť prvá podmienka, a jeden alebo druhý

484
00:29:38,000 --> 00:29:41,000
alebo 2 podmienky spojené v a

485
00:29:41,000 --> 00:29:45,000
alebo tretej, takže stačí byť opatrný.

486
00:29:45,000 --> 00:29:48,000
A konečne, hovorili sme o prepínačoch.

487
00:29:48,000 --> 00:29:53,000
Prepínač je veľmi užitočné, keď máte premennú.

488
00:29:53,000 --> 00:29:55,000
Povedzme, že máte premennú ako n

489
00:29:55,000 --> 00:29:59,000
, Ktoré môžu byť 0, 1, alebo 2, a na každom z týchto prípadov

490
00:29:59,000 --> 00:30:01,000
budete na vykonanie úlohy.

491
00:30:01,000 --> 00:30:04,000
Môžete povedať, že prepnúť premennú, a znamená to, že

492
00:30:04,000 --> 00:30:08,000
hodnota potom je ako hodnota1 budem robiť to,

493
00:30:08,000 --> 00:30:12,000
a potom som sa zlomiť, čo znamená, že nebudem pozerať na niektorý z ostatných prípadoch

494
00:30:12,000 --> 00:30:15,000
pretože sme už spokojní, že prípad

495
00:30:15,000 --> 00:30:20,000
a potom hodnota2 a tak ďalej, a ja tiež môže mať východiskovej polohy.

496
00:30:20,000 --> 00:30:24,000
To znamená, že v prípade, že nespĺňa žiadny z prípadov, ktoré som mal

497
00:30:24,000 --> 00:30:29,000
že budem robiť niečo iné, ale to je voliteľné.

498
00:30:29,000 --> 00:30:36,000
To je pre mňa. Teraz sa poďme Tommy.

499
00:30:36,000 --> 00:30:41,000
Dobre, toto bude týždeň 3-ish.

500
00:30:41,000 --> 00:30:45,000
To sú niektoré z tém budeme pokrývať, crypto, rozsah, pole, et cetera.

501
00:30:45,000 --> 00:30:49,000
Len slovíčko na crypto. Nebudeme sa kladivom domov.

502
00:30:49,000 --> 00:30:52,000
>> Urobili sme to v PSet 2, ale pre kvíz uistite sa, že poznáte rozdiel

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

504
00:30:54,000 --> 00:30:57,000
ako obe z týchto šifier práce a aké to je na šifrovanie

505
00:30:57,000 --> 00:30:59,000
a dešifrovanie textu pomocou týchto 2 šifry.

506
00:30:59,000 --> 00:31:03,000
Nezabudnite, Caesarovho šifra jednoducho otočí každý znak rovnakú sumu,

507
00:31:03,000 --> 00:31:06,000
Vďaka, že ste mod počtom písmen v abecede.

508
00:31:06,000 --> 00:31:09,000
A Vigenère kód, na druhej strane, sa otáča každý znak

509
00:31:09,000 --> 00:31:12,000
inú sumu, takže skôr než hovoriť

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

511
00:31:15,000 --> 00:31:17,000
o rôzne sumy v závislosti na určité kľúčové

512
00:31:17,000 --> 00:31:20,000
kde každý list na kľúčové slovo predstavuje nejaké iné množstvo

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

514
00:31:26,000 --> 00:31:28,000
Poďme hovoriť o prvú premennú rozsahu.

515
00:31:28,000 --> 00:31:30,000
K dispozícii sú 2 rôzne typy premenných.

516
00:31:30,000 --> 00:31:33,000
Máme lokálne premenné, a tie sa bude definovať

517
00:31:33,000 --> 00:31:36,000
mimo hlavnej alebo mimo akúkoľvek funkciu alebo bloku,

518
00:31:36,000 --> 00:31:39,000
a tie budú dostupné kdekoľvek vo vašom programe.

519
00:31:39,000 --> 00:31:41,000
Ak máte funkciu a v tejto funkcii, je while

520
00:31:41,000 --> 00:31:44,000
Veľký globálne premenná je prístupná všade.

521
00:31:44,000 --> 00:31:48,000
Lokálne premenná, na druhej strane, je rozsahom na miesto, kde je definovaná.

522
00:31:48,000 --> 00:31:53,000
>> Ak máte funkciu tu napríklad, máme túto funkciu g,

523
00:31:53,000 --> 00:31:56,000
a vo vnútri g je premenná tu nazýva y,

524
00:31:56,000 --> 00:31:58,000
a to znamená, že sa jedná o lokálne premenná.

525
00:31:58,000 --> 00:32:00,000
Aj keď je táto premenná nazýva y

526
00:32:00,000 --> 00:32:03,000
a táto premenná sa nazýva Y tieto 2 funkcie

527
00:32:03,000 --> 00:32:06,000
nemám potuchy, čo každý iný je lokálne premenné sú.

528
00:32:06,000 --> 00:32:10,000
Na druhej strane, a to až tu povedať int x = 5,

529
00:32:10,000 --> 00:32:12,000
a to je mimo akejkoľvek funkcie.

530
00:32:12,000 --> 00:32:16,000
Je to mimo rámec hlavnej, takže to je globálna premenná.

531
00:32:16,000 --> 00:32:20,000
To znamená, že vo vnútri týchto 2 funkcií, keď poviem, x - alebo x + +

532
00:32:20,000 --> 00:32:26,000
Ja prístupu k rovnakému x pričom toto y, a to y sú rôzne premenné.

533
00:32:26,000 --> 00:32:30,000
To je rozdiel medzi globálne premenné a lokálne premenné.

534
00:32:30,000 --> 00:32:33,000
Pokiaľ ide o návrh sa týka, niekedy je to asi lepší nápad

535
00:32:33,000 --> 00:32:37,000
aby premenné lokálne, kedykoľvek si možno môžete

536
00:32:37,000 --> 00:32:39,000
pretože majú veľa globálnych premenných môže dostať naozaj mätúce.

537
00:32:39,000 --> 00:32:42,000
Ak máte veľa funkcií všetkých modifikácií to isté

538
00:32:42,000 --> 00:32:45,000
môžete zabudnúť čo keď je táto funkcia náhodou upravuje tento globálny,

539
00:32:45,000 --> 00:32:47,000
a táto iná funkcia nevie o tom,

540
00:32:47,000 --> 00:32:50,000
a to pekne mätúce, ako si získať viac kódu.

541
00:32:50,000 --> 00:32:53,000
Vedenie premenné lokálne, kedykoľvek si možno môžete

542
00:32:53,000 --> 00:32:56,000
je jednoducho dobrý dizajn.

543
00:32:56,000 --> 00:33:00,000
Matice, pamätajte, že sú jednoducho zoznamy prvkov rovnakého typu.

544
00:33:00,000 --> 00:33:04,000
Vnútri CI nemôže mať zoznam ako 1, 2,0, ahoj.

545
00:33:04,000 --> 00:33:06,000
My jednoducho nemôžeme urobiť, že.

546
00:33:06,000 --> 00:33:11,000
>> Keď deklarujeme pole v C všetky prvky musia byť rovnakého typu.

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

548
00:33:14,000 --> 00:33:18,000
Tu mám dĺžku poľa, ale ak som len vyhlásením v tejto syntaxi

549
00:33:18,000 --> 00:33:21,000
kde som určiť, aká všetky prvky sú nemám technicky potrebovať 3.

550
00:33:21,000 --> 00:33:25,000
Kompilátor je dosť šikovný na to, aby zistili, aký veľký by mal byť poľa.

551
00:33:25,000 --> 00:33:28,000
Teraz, keď chcem získať alebo nastaviť hodnotu poľa

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 skutočne meniť druhý prvok poľa, pretože, pamätajte,

554
00:33:33,000 --> 00:33:36,000
Číslovanie začína na 0, nie na 1.

555
00:33:36,000 --> 00:33:42,000
Ak chcem čítať túto hodnotu môžem povedať niečo ako int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Alebo keď chcem nastaviť túto hodnotu, ako by som tu,

557
00:33:44,000 --> 00:33:47,000
Môžem povedať, array [1] = 4.

558
00:33:47,000 --> 00:33:50,000
V tej dobe prístup k prvkom ich index

559
00:33:50,000 --> 00:33:52,000
alebo ich polohy, alebo kde sú v poli,

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

561
00:33:57,000 --> 00:34:00,000
Môžeme tiež polia polí,

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

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

564
00:34:05,000 --> 00:34:07,000
to znamená, že môžeme mať niečo ako riadkov a stĺpcov,

565
00:34:07,000 --> 00:34:11,000
a to je len jeden spôsob, ako vizualizáciu tohto alebo o tom premýšľať.

566
00:34:11,000 --> 00:34:14,000
Keď mám multi-dimenzionální pole, ktoré znamená, že začnem potrebovať

567
00:34:14,000 --> 00:34:17,000
viac ako 1 index, pretože keď budem mať mriežku

568
00:34:17,000 --> 00:34:19,000
Len hovorím, čo riadok ste v nedáva číslo.

569
00:34:19,000 --> 00:34:22,000
To je naozaj len nám dá zoznam čísel.

570
00:34:22,000 --> 00:34:25,000
Povedzme, že mám toto pole tu.

571
00:34:25,000 --> 00:34:30,000
Mám pole s názvom sieť, a ja hovorím, že tieto 2 riadky a 3 stĺpce,

572
00:34:30,000 --> 00:34:32,000
a tak to je jeden zo spôsobov, vizualizáciu ju.

573
00:34:32,000 --> 00:34:37,000
Keď poviem, že ja sa chcem dostať prvok na [1] [2]

574
00:34:37,000 --> 00:34:41,000
to znamená, že preto, že sa jedná o riadky a potom stĺpce

575
00:34:41,000 --> 00:34:44,000
Chystám sa skočiť na riadku 1, pretože som povedala 1.

576
00:34:44,000 --> 00:34:49,000
>> Potom budem sem prišiel do stĺpca 2, a ak budem získať hodnotu 6.

577
00:34:49,000 --> 00:34:51,000
Skontrolujte, zmysel?

578
00:34:51,000 --> 00:34:55,000
Multi-dimenzionální pole, pamätajte, sú technicky len polia polí.

579
00:34:55,000 --> 00:34:57,000
Môžeme mať matice polí polí.

580
00:34:57,000 --> 00:35:00,000
Môžeme pokračovať, ale naozaj jediný spôsob, ako premýšľať o

581
00:35:00,000 --> 00:35:03,000
ako je práve toto stanovené a čo sa deje, je predstaviť si to

582
00:35:03,000 --> 00:35:09,000
v mriežke, ako je to.

583
00:35:09,000 --> 00:35:12,000
Keď sme sa prejsť pole k funkciám, idú správať

584
00:35:12,000 --> 00:35:16,000
trochu inak, ako keď sme sa prejsť pravidelné premenné funkcií

585
00:35:16,000 --> 00:35:18,000
ako zložením int alebo float.

586
00:35:18,000 --> 00:35:21,000
Keď sme sa prejsť v int alebo char alebo niektorý z týchto iných dátových typov

587
00:35:21,000 --> 00:35:24,000
práve sme sa pozrieť na, ak funkcia mení

588
00:35:24,000 --> 00:35:28,000
hodnota tejto premennej je táto zmena nebude šíriť do

589
00:35:28,000 --> 00:35:32,000
volajúci funkciu.

590
00:35:32,000 --> 00:35:35,000
S pole, na druhej strane, sa tak stalo.

591
00:35:35,000 --> 00:35:39,000
Ak sa prejsť v poli na nejakú funkciu, a že funkcia mení niektoré prvky,

592
00:35:39,000 --> 00:35:43,000
keď som sa vrátil do funkcie, ktorá je volaná

593
00:35:43,000 --> 00:35:47,000
moje pole je teraz bude líšiť, a slovník pre ktoré

594
00:35:47,000 --> 00:35:50,000
je polia sú odovzdané formou odkazu, ako uvidíme neskôr.

595
00:35:50,000 --> 00:35:53,000
To sa týka ako ukazovátka práce, kde tieto základné dátové typy,

596
00:35:53,000 --> 00:35:55,000
na druhej strane, sú odovzdané hodnotou.

597
00:35:55,000 --> 00:35:59,000
>> Môžeme to brať ako vytvorenie kópie niektoré premenné a potom odovzdá v kópii.

598
00:35:59,000 --> 00:36:01,000
Nezáleží na tom, čo urobíme s tejto premennej.

599
00:36:01,000 --> 00:36:06,000
Volanie funkcie nebude vedomý toho, že došlo k zmene.

600
00:36:06,000 --> 00:36:10,000
Polia sú len trochu líši v tomto ohľade.

601
00:36:10,000 --> 00:36:13,000
Napríklad, ako sme videli, hlavné je jednoducho funkcie

602
00:36:13,000 --> 00:36:15,000
ktoré môžu mať v 2 argumenty.

603
00:36:15,000 --> 00:36:20,000
Prvý argument hlavnú funkciu je argc, alebo počet argumentov,

604
00:36:20,000 --> 00:36:23,000
a druhý argument sa nazýva ArGV,

605
00:36:23,000 --> 00:36:27,000
a tie sú skutočné hodnoty týchto argumentov.

606
00:36:27,000 --> 00:36:30,000
Povedzme, že mám program s názvom this.c,

607
00:36:30,000 --> 00:36:34,000
a hovorím, aby to, a ja budem bežať do príkazového riadku.

608
00:36:34,000 --> 00:36:38,000
Teraz odovzdať niektoré argumenty k môjmu programu volal toto,

609
00:36:38,000 --> 00:36:42,000
Mohol by som povedať niečo. / Je to sk 50.

610
00:36:42,000 --> 00:36:45,000
To je to, čo si predstavujeme, David robiť každý deň na termináli.

611
00:36:45,000 --> 00:36:48,000
Ale teraz je hlavnou funkciou vnútri tohto programu

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

613
00:36:52,000 --> 00:36:56,000
To by mohlo byť trochu mätúce, pretože naozaj sme len prechádzať v je cs 50.

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

615
00:36:58,000 --> 00:37:02,000
Ale pamätajte si, že prvý prvok ArGV alebo prvý argument

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

617
00:37:05,000 --> 00:37:07,190
Takže to znamená, že máme 4 veci tu,

618
00:37:07,190 --> 00:37:10,530
a prvý prvok bude. / toto.

619
00:37:10,530 --> 00:37:12,970
A to bude reprezentovaný ako reťazec.

620
00:37:12,970 --> 00:37:18,590
Potom Zostávajúce prvky sú tým, čo sme zadali v po názvu programu.

621
00:37:18,590 --> 00:37:22,720
Teda rovnako ako stranou, ako sme asi videli v PSet 2,

622
00:37:22,720 --> 00:37:28,780
nezabudnite, že reťazec 50 sa ≠ celočíselnú 50.

623
00:37:28,780 --> 00:37:32,520
Takže nemôžeme povedať niečo ako, 'int x = ArGV 3. "

624
00:37:32,520 --> 00:37:36,470
>> To sa jednoducho nebude dávať zmysel, pretože je to reťazec, a to je celé číslo.

625
00:37:36,470 --> 00:37:38,510
Takže ak chcete previesť medzi 2, pamätajte, budeme

626
00:37:38,510 --> 00:37:40,810
majú to kúzlo funkciu s názvom atoi.

627
00:37:40,810 --> 00:37:46,270
To trvá reťazec a vráti celé číslo reprezentované vnútri tohto reťazca.

628
00:37:46,270 --> 00:37:48,360
Tak to je chybička sa ľahko vlúdi na kvíz,

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

630
00:37:51,590 --> 00:37:53,860
Ale proste viem, že to bude vždy reťazca

631
00:37:53,860 --> 00:38:00,920
aj keď reťazec obsahuje iba celé číslo alebo znak, alebo plávať.

632
00:38:00,920 --> 00:38:03,380
Takže teraz poďme hovoriť o jazdné doby.

633
00:38:03,380 --> 00:38:06,700
Keď máme všetky tieto algoritmy, ktoré vedia všetky tieto šialené veci,

634
00:38:06,700 --> 00:38:11,580
sa stáva naozaj užitočné si položiť otázku, "Ako dlho trvá?"

635
00:38:11,580 --> 00:38:15,500
Zastupujeme že s tzv asymptotickej notácie.

636
00:38:15,500 --> 00:38:18,430
Takže to znamená, že - no, povedzme, že sme dať náš algoritmus

637
00:38:18,430 --> 00:38:20,840
niektoré naozaj, naozaj, naozaj veľký vstup.

638
00:38:20,840 --> 00:38:23,840
Chceme si položiť otázku, "Ako dlho to bude trvať?

639
00:38:23,840 --> 00:38:26,370
Koľko krokov bude trvať naše algoritmus bežať

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

641
00:38:29,980 --> 00:38:33,080
Takže prvý spôsob, ako môžeme popísať doba chodu je s veľkým O.

642
00:38:33,080 --> 00:38:35,380
A toto je náš najhoršie doba dobehu.

643
00:38:35,380 --> 00:38:38,590
Takže ak chceme triediť pole, a dávame náš algoritmus poľa

644
00:38:38,590 --> 00:38:41,000
to v zostupnom poradí, kedy by malo byť vo vzostupnom poradí,

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

646
00:38:43,130 --> 00:38:49,800
To je naša horná hranica v maximálnu dobu náš algoritmus bude trvať.

647
00:38:49,800 --> 00:38:54,740
Na druhej strane, táto Ω bude popisovať najlepšom prípade chodu.

648
00:38:54,740 --> 00:38:58,210
Takže ak dáme už zoradené poľa na triedenie algoritmu,

649
00:38:58,210 --> 00:39:00,940
ako dlho bude trvať, než si vybrať to?

650
00:39:00,940 --> 00:39:06,610
A to, potom, popisuje dolná hranica na prevádzke.

651
00:39:06,610 --> 00:39:10,980
Takže tu sú len niektoré slová, ktoré popisujú niektoré bežné prevádzkovú dobu.

652
00:39:10,980 --> 00:39:13,120
Sú vo vzostupnom poradí.

653
00:39:13,120 --> 00:39:16,060
Najrýchlejší čas chodu máme sa nazýva konštanta.

654
00:39:16,060 --> 00:39:19,800
>> To znamená, že bez ohľadu na to, koľko prvkov dávame naše algoritmus,

655
00:39:19,800 --> 00:39:22,280
bez ohľadu na to, aký veľký náš pole je radenie je

656
00:39:22,280 --> 00:39:26,510
alebo čo robíme na poli bude vždy rovnaké množstvo času.

657
00:39:26,510 --> 00:39:30,270
Takže môžeme vyhlasujete, že len s 1, ktorá je konštantná.

658
00:39:30,270 --> 00:39:32,410
Tiež sme sa pozreli na logaritmickom behu.

659
00:39:32,410 --> 00:39:34,800
Takže niečo ako binárny vyhľadávania je logaritmická,

660
00:39:34,800 --> 00:39:37,140
kde sme skrátili problém polovica zakaždým

661
00:39:37,140 --> 00:39:40,970
a potom sa veci len získať vyššiu odtiaľ.

662
00:39:40,970 --> 00:39:43,580
A ak ste niekedy písanie O každej faktoriál algoritmu,

663
00:39:43,580 --> 00:39:47,850
mali by ste brať do úvahy to ako váš pracovný deň.

664
00:39:47,850 --> 00:39:53,910
Keď sme tieto prevádzkovú dobu je dôležité mať na pamäti tieto veci.

665
00:39:53,910 --> 00:39:57,760
Takže ak mám algoritmus, ktorý je O (n), a niekto iný

666
00:39:57,760 --> 00:40:03,590
je algoritmus O (2n) sú vlastne asymptoticky ekvivalentné.

667
00:40:03,590 --> 00:40:06,590
Takže ak by sme si predstaviť, n byť veľké číslo ako Eleventy miliárd:

668
00:40:06,590 --> 00:40:13,090
takže keď sme porovnaniu Eleventy miliardy na niečo, ako je Eleventy miliárd + 3,

669
00:40:13,090 --> 00:40:17,640
náhle, že 3 nie je naozaj veľký rozdiel už.

670
00:40:17,640 --> 00:40:20,980
To je dôvod, prečo budeme začať zvažovať tieto veci za rovnocenné.

671
00:40:20,980 --> 00:40:24,220
Takže veci ako tieto konštanty, je tu 2 x tento, alebo pridaním 3,

672
00:40:24,220 --> 00:40:27,180
to sú len konštanty, a tie sú v úmysle položiť hore.

673
00:40:27,180 --> 00:40:32,480
Takže to je dôvod, prečo všetky 3 z týchto dobách chodu sú rovnaké ako hovoriť, že oni to O (n).

674
00:40:32,480 --> 00:40:37,490
Podobne, ak máme 2 ďalší dobu chodu, povedzme O (n ³ + 2n ²), môžeme pridať

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, a potom máme ďalšiu dobu behu to je len O (n ³).

676
00:40:42,070 --> 00:40:46,290
Opäť sa jedná o to isté, pretože ty - to nie sú rovnaké.

677
00:40:46,290 --> 00:40:49,840
Jedná sa o rovnaké veci, je mi ľúto. To sú rovnaké, pretože

678
00:40:49,840 --> 00:40:53,090
this ³ n sa bude ovládať tento 2n ².

679
00:40:53,090 --> 00:40:59,130
>> Čo nie je to isté, je, ak sme bežať časy ako O (n ³) a O (n ²)

680
00:40:59,130 --> 00:41:02,820
pretože ³ n je oveľa väčší ako tento ² n

681
00:41:02,820 --> 00:41:05,470
Takže ak máme exponentmi, zrazu to začne na tom,

682
00:41:05,470 --> 00:41:08,280
ale keď sme len rokovania s faktormi, ako sme my tu,

683
00:41:08,280 --> 00:41:12,810
potom to nebude záležať, pretože sa práve chystá odísť.

684
00:41:12,810 --> 00:41:16,760
Poďme sa pozrieť na niektoré z algoritmov sme videli doteraz

685
00:41:16,760 --> 00:41:19,260
a hovoriť o ich behu.

686
00:41:19,260 --> 00:41:23,850
Prvý spôsob, ako sa pozerať na čísla v zozname, ktorý sme videli, bol lineárny hľadanie.

687
00:41:23,850 --> 00:41:26,950
A vykonávanie lineárny hľadanie je super jednoduché.

688
00:41:26,950 --> 00:41:30,490
Musíme len zoznam, a budeme sa pozerať na každý jednotlivý prvok v zozname

689
00:41:30,490 --> 00:41:34,260
kým nenájdeme číslo sme hľadali.

690
00:41:34,260 --> 00:41:38,370
To znamená, že v najhoršom prípade, to O (n).

691
00:41:38,370 --> 00:41:40,860
A v najhoršom prípade tu môže byť v prípade, že element je

692
00:41:40,860 --> 00:41:45,710
posledný prvok, potom pomocou lineárnej hľadanie, musíme sa pozrieť na každý element

693
00:41:45,710 --> 00:41:50,180
kým sa na poslednú, aby vedel, že to bolo vlastne v zozname.

694
00:41:50,180 --> 00:41:52,910
Nemôžeme len tak vzdal v polovici cesty a povedal: "Je to asi nie je."

695
00:41:52,910 --> 00:41:55,980
S lineárne hľadanie sa musíme pozrieť na celú vec.

696
00:41:55,980 --> 00:41:59,090
Najlepšie prípadu doba dobehu, na druhej strane, je konštantná

697
00:41:59,090 --> 00:42:04,200
pretože v najlepšom prípade element sme hľadali, je len prvý v zozname.

698
00:42:04,200 --> 00:42:08,930
Takže to bude trvať nám presne 1 krok, bez ohľadu na to, aký veľký je zoznam

699
00:42:08,930 --> 00:42:12,140
ak hľadáme pre prvý prvok zakaždým.

700
00:42:12,140 --> 00:42:15,390
>> Takže keď hľadáte, pamätajte, že nevyžaduje, aby náš zoznam byť zoradené.

701
00:42:15,390 --> 00:42:19,430
Vzhľadom k tomu, že sme jednoducho bude vyzerať v priebehu každého jednotlivého prvku, a to nezáleží

702
00:42:19,430 --> 00:42:23,560
akom poradí tieto prvky sú v

703
00:42:23,560 --> 00:42:28,110
Viac inteligentný vyhľadávací algoritmus je niečo ako binárny vyhľadávanie.

704
00:42:28,110 --> 00:42:31,500
Pamätajte si, že implementácia binárneho vyhľadávania je, keď budete

705
00:42:31,500 --> 00:42:34,320
Pozeraj sa na stredu zozname.

706
00:42:34,320 --> 00:42:38,000
A pretože sa pozeráme na stredu, požadujeme, aby tento zoznam je zoradený

707
00:42:38,000 --> 00:42:40,580
inak nevieme, kde uprostred je, a musíme sa pozrieť na

708
00:42:40,580 --> 00:42:44,480
celý zoznam nájsť, a potom na tom mieste sme len strácaš čas.

709
00:42:44,480 --> 00:42:48,480
Takže ak máme zoradený zoznam a nájdeme uprostred, budeme porovnávať stred

710
00:42:48,480 --> 00:42:51,590
na prvok, ktorého hľadáme.

711
00:42:51,590 --> 00:42:54,640
Ak je to príliš vysoká, potom môžeme zabudnúť na pravú polovicu

712
00:42:54,640 --> 00:42:57,810
pretože vieme, že ak naše element je už príliš vysoká

713
00:42:57,810 --> 00:43:01,080
a všetko napravo od tohto prvku je dokonca vyššia,

714
00:43:01,080 --> 00:43:02,760
potom nepotrebujeme hľadať tam už.

715
00:43:02,760 --> 00:43:05,430
Tam, kde na druhej strane, ak náš prvok je príliš nízka,

716
00:43:05,430 --> 00:43:08,700
vieme všetko vľavo od tohto prvku je tiež príliš nízka,

717
00:43:08,700 --> 00:43:11,390
tak to nemá moc zmysel sa pozrieť tam, a to buď.

718
00:43:11,390 --> 00:43:15,760
Týmto spôsobom, s každým krokom a zakaždým sme sa pozrieť na stredu zozname,

719
00:43:15,760 --> 00:43:19,060
budeme rezať náš problém v polovici, pretože zrazu vieme

720
00:43:19,060 --> 00:43:23,040
celá partia čísel, ktorá nemôže byť ten, ktorého hľadáme.

721
00:43:23,040 --> 00:43:26,950
>> V pseudokódu by vyzerať nejako takto,

722
00:43:26,950 --> 00:43:30,990
a pretože sme rezanie zoznam v polovici každej dobe,

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

724
00:43:34,920 --> 00:43:39,260
Takže zrazu máme log-in krokov s cieľom nájsť element v zozname.

725
00:43:39,260 --> 00:43:42,460
Najlepšie-case doba dobehu, aj keď je stále konštantná

726
00:43:42,460 --> 00:43:45,180
pretože teraz, povedzme, že prvok hľadáme, je

727
00:43:45,180 --> 00:43:48,380
vždy presný stred pôvodného zoznamu.

728
00:43:48,380 --> 00:43:52,080
Takže môžeme pestovať našu ponuku tak veľký, ako by sme chceli, ale v prípade, že element hľadáme, je v polovici,

729
00:43:52,080 --> 00:43:54,910
potom je to len bude nám trvať 1 krok.

730
00:43:54,910 --> 00:44:00,920
Takže to je dôvod, prečo sme O (log n) a Ω (1), alebo konštantné.

731
00:44:00,920 --> 00:44:04,510
Poďme skutočne spustiť binárny vyhľadávania na tomto zozname.

732
00:44:04,510 --> 00:44:08,020
Takže povedzme, že sme hľadali prvku 164.

733
00:44:08,020 --> 00:44:11,650
Prvá vec, ktorú sa chystáme urobiť, je nájsť stred tohto zoznamu.

734
00:44:11,650 --> 00:44:15,060
To len tak sa stane, že stred bude klesať medzi týmito 2 čísla,

735
00:44:15,060 --> 00:44:18,960
tak nech to jednoducho ľubovoľne síce zakaždým, keď stred patrí medzi 2 čísla,

736
00:44:18,960 --> 00:44:21,150
povedzme, zaokrúhliť nahor.

737
00:44:21,150 --> 00:44:24,330
Potrebujeme len uistiť, že sme to na každom kroku na ceste.

738
00:44:24,330 --> 00:44:29,040
Takže budeme zaokrúhľovať, a budeme hovoriť, že 161 je uprostred nášho zoznamu.

739
00:44:29,040 --> 00:44:34,640
So 161 <164, a každý prvok vľavo 161

740
00:44:34,640 --> 00:44:39,120
je tiež <164, takže vieme, že to nepomôže nám vôbec

741
00:44:39,120 --> 00:44:42,690
začať hľadať tu, pretože prvok sme hľadali nemôže byť tam.

742
00:44:42,690 --> 00:44:47,060
Takže to, čo môžeme urobiť, je, že sme sa jednoducho zabudnúť o tom celej ľavej polovice zoznamu,

743
00:44:47,060 --> 00:44:51,700
a teraz len zvážila z práva na 161 dopredu.

744
00:44:51,700 --> 00:44:54,050
>> Takže znova, je to stred, povedzme, zaokrúhliť nahor.

745
00:44:54,050 --> 00:44:56,260
Teraz 175 je príliš veľká.

746
00:44:56,260 --> 00:44:59,180
Tak sme viem, že to nepomôže nám hľadajú tu alebo tu,

747
00:44:59,180 --> 00:45:06,610
takže môžeme len hodiť to preč, a nakoniec budeme hit 164.

748
00:45:06,610 --> 00:45:10,560
Akékoľvek otázky týkajúce sa binárne vyhľadávanie?

749
00:45:10,560 --> 00:45:14,180
Poďme ďalej od vyhľadávania cez už triedenom zozname

750
00:45:14,180 --> 00:45:17,660
skutočne vezme zoznam čísel v ľubovoľnom poradí

751
00:45:17,660 --> 00:45:20,960
a poskytovanie tohto zoznamu vo vzostupnom poradí.

752
00:45:20,960 --> 00:45:24,060
Prvý algoritmus sme sa pozerali na hovorilo bubble sort.

753
00:45:24,060 --> 00:45:27,300
A to by bolo jednoduchšie z algoritmov, ktoré sme videli.

754
00:45:27,300 --> 00:45:32,970
Bubble sort hovorí, že keď nejaké 2 prvky vnútri zozname sú na mieste,

755
00:45:32,970 --> 00:45:36,500
čo znamená, že je väčší počet na ľavej strane nižšieho počtu,

756
00:45:36,500 --> 00:45:40,190
potom budeme vymeniť je, pretože to znamená, že zoznam bude

757
00:45:40,190 --> 00:45:42,860
"Viac zoradená", ako tomu bolo predtým.

758
00:45:42,860 --> 00:45:45,180
A my sme len tak pre pokračovanie tohto procesu znovu a znovu a znovu

759
00:45:45,180 --> 00:45:52,100
až nakoniec prvky druh bubliny na ich správne umiestnenie a máme zoradený zoznam.

760
00:45:52,100 --> 00:45:57,230
>> Beh času to bude O (n ²). Prečo?

761
00:45:57,230 --> 00:46:00,370
No, pretože v najhoršom prípade, budeme brať každý prvok, a

762
00:46:00,370 --> 00:46:04,570
budeme skončiť porovnaní s každou ďalší prvok v zozname.

763
00:46:04,570 --> 00:46:08,030
Ale v tom najlepšom prípade, máme už zoradený zoznam, bublina sort je

764
00:46:08,030 --> 00:46:12,230
len tak prejsť raz, poviem "Nie. Neurobil som žiadne swapy, tak som urobil."

765
00:46:12,230 --> 00:46:17,410
Takže máme Najlepšia prípadová doba chodu Ω (n).

766
00:46:17,410 --> 00:46:20,680
Spustí bublina triedenie v zozname.

767
00:46:20,680 --> 00:46:23,560
Alebo prvé, poďme sa pozrieť na niektoré pseudokódu naozaj rýchlo.

768
00:46:23,560 --> 00:46:28,160
Chceme, že chceme sledovať, v každej iterácii slučky,

769
00:46:28,160 --> 00:46:32,190
mať prehľad o tom, či sme alebo nie sme meniť žiadne prvky.

770
00:46:32,190 --> 00:46:37,610
Takže dôvod pre to, že budeme zastaviť, keď sme sa vymenili žiadne prvky.

771
00:46:37,610 --> 00:46:41,980
Takže na začiatku nášho cyklu sme sa vymenili nič, tak budeme hovoriť, že je to pravda.

772
00:46:41,980 --> 00:46:47,170
Teraz, budeme prechádzať zoznam a porovnajte prvok aj pre element i + 1

773
00:46:47,170 --> 00:46:50,310
a ak je to tak, že je väčší počet na ľavej strane menší počet,

774
00:46:50,310 --> 00:46:52,310
potom sme len tak vymeniť je.

775
00:46:52,310 --> 00:46:54,490
>> A potom budeme pamätať, že sme vymenili prvok.

776
00:46:54,490 --> 00:46:58,900
To znamená, že musíme prejsť zoznam najmenej 1 viac času

777
00:46:58,900 --> 00:47:02,160
, Pretože tento stav, v ktorom sa zastavil je, keď je celý zoznam už zoradené,

778
00:47:02,160 --> 00:47:04,890
čo znamená, sme nevykonali žiadne swapy.

779
00:47:04,890 --> 00:47:09,960
Takže to je dôvod, prečo naše podmienka tu dole je ", zatiaľ čo niektoré prvky boli prehodenie."

780
00:47:09,960 --> 00:47:13,720
Takže teraz poďme sa pozrieť na to beží na zozname.

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

782
00:47:16,640 --> 00:47:19,850
Bubble sort je začnú celú cestu vľavo, a to bude k porovnaniu

783
00:47:19,850 --> 00:47:24,700
sa aj prvky, takže 0 až i + 1, čo je prvok 1.

784
00:47:24,700 --> 00:47:29,020
Bude to povedať, aj 5> 0, ale teraz 5 je naľavo,

785
00:47:29,020 --> 00:47:32,500
tak musím vymeniť 5 a 0.

786
00:47:32,500 --> 00:47:35,470
Keď som ich swap, zrazu som si to iný zoznam.

787
00:47:35,470 --> 00:47:38,260
Teraz 5> 1, takže budeme vymeniť je.

788
00:47:38,260 --> 00:47:42,160
5 nie je> 6, takže nemusíte robiť nič.

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

790
00:47:46,690 --> 00:47:49,740
Znovu musíme prejsť celý zoznam nakoniec objaviť

791
00:47:49,740 --> 00:47:52,330
že tieto sú mimo prevádzky, vymeníme ich,

792
00:47:52,330 --> 00:47:57,120
a na tomto mieste musíme prejsť zoznam 1 viac času

793
00:47:57,120 --> 00:48:05,390
aby sa ubezpečil, že všetko, čo je v jeho poradí, a na tomto mieste bubliny radiť dokončenie.

794
00:48:05,390 --> 00:48:10,720
Iný algoritmus pre prijatie niektorých prvkov a ich triedenie je výber sort.

795
00:48:10,720 --> 00:48:15,740
Myšlienka výbere druhu je, že budeme budovať zoradená časť zoznamu

796
00:48:15,740 --> 00:48:18,150
1 prvok naraz.

797
00:48:18,150 --> 00:48:23,170
>> A spôsob, akým budeme k tomu, že je tým, budovanie ľavej segment zoznamu.

798
00:48:23,170 --> 00:48:27,510
A v podstate každý - na každom kroku, budeme mať najmenší prvok sme vľavo

799
00:48:27,510 --> 00:48:32,310
ktorá nebola zoradená ešte, a budeme ho presunúť do tej zoradené segmentu.

800
00:48:32,310 --> 00:48:35,850
To znamená, že musíme neustále nájsť minimálne zmiešaný prvok

801
00:48:35,850 --> 00:48:40,720
a potom, že minimálny prvok a vymeniť ju s tým, čo

802
00:48:40,720 --> 00:48:45,090
najviac vľavo prvok, ktorý nie je zoradená.

803
00:48:45,090 --> 00:48:50,890
Spustiť čas to bude O (n ²), pretože v najhoršom prípade

804
00:48:50,890 --> 00:48:55,070
musíme porovnať každý jednotlivý prvok ku každému inému prvku.

805
00:48:55,070 --> 00:48:59,250
Vzhľadom k tomu, hovoríme, že ak začneme na ľavej polovici zoznamu, musíme

806
00:48:59,250 --> 00:49:02,970
prejsť celú pravú segmente nájsť najmenší prvok.

807
00:49:02,970 --> 00:49:05,430
A potom, opäť musíme ísť cez celú pravú časť a

808
00:49:05,430 --> 00:49:08,210
ďalej nad tým znovu a znovu a znovu.

809
00:49:08,210 --> 00:49:11,350
To bude mať n ². Budeme potrebovať cyklu for vnútri iné pre slučky

810
00:49:11,350 --> 00:49:13,350
čo naznačuje, n ².

811
00:49:13,350 --> 00:49:16,530
V najlepšom prípade myslenia, povedzme, že ho už zoradený zoznam;

812
00:49:16,530 --> 00:49:19,270
sme vlastne nerobíme nič lepšie, ako ² n

813
00:49:19,270 --> 00:49:21,730
Vzhľadom k tomu, Výber spôsob má žiadny spôsob, ako zistiť, že

814
00:49:21,730 --> 00:49:25,540
minimálny prvok je len jeden A stalo sa pozerá.

815
00:49:25,540 --> 00:49:28,970
To ešte potrebuje, aby sa ubezpečil, že je to skutočne minimum.

816
00:49:28,970 --> 00:49:31,670
>> A jediný spôsob, ako sa uistiť, že je to minimum, pomocou tohto algoritmu,

817
00:49:31,670 --> 00:49:34,640
je pozrieť sa na každý jednotlivý prvok znovu.

818
00:49:34,640 --> 00:49:38,420
Takže naozaj, ak mi ju - ak dáte výběrem Triediť už zoradený zoznam,

819
00:49:38,420 --> 00:49:42,720
to nebude o nič lepšie, než dávať to zoznam, ktorý nie je zoradená ešte.

820
00:49:42,720 --> 00:49:46,320
Mimochodom, ak sa to stane, že je pravda, že niečo je O (niečo)

821
00:49:46,320 --> 00:49:50,640
a omega niečoho, môžeme len povedať stručnejšie, že je to θ niečo.

822
00:49:50,640 --> 00:49:52,760
Takže ak uvidíte, že prísť kamkoľvek, to je to, čo to znamená len.

823
00:49:52,760 --> 00:49:57,580
>> Ak je niečo theta n ², je to tak veľký O (n ²) a Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
So najlepšom prípade a najhorší prípad, to neznamená, že rozdiel,

825
00:49:59,790 --> 00:50:04,400
algoritmus sa chystá urobiť rovnakú vec zakaždým.

826
00:50:04,400 --> 00:50:06,610
Tak toto je to, čo pseudokód pre výber druhu by mohol vyzerať.

827
00:50:06,610 --> 00:50:10,630
Sme v podstate povedať, že chcem, aby iterácii zoznam

828
00:50:10,630 --> 00:50:15,180
zľava doprava, a na každé opakovanie slučky, budem sa pohybovať

829
00:50:15,180 --> 00:50:19,780
Minimálna prvok do tohto triedeného časti zoznamu.

830
00:50:19,780 --> 00:50:23,260
A raz som presunúť tam niečo, nikdy som potrebné pozrieť sa na tento prvok znovu.

831
00:50:23,260 --> 00:50:28,600
Vzhľadom k tomu, akonáhle som vymeniť prvok do ľavého segmentu zoznamu, je zoradená to

832
00:50:28,600 --> 00:50:32,600
pretože robíme všetko vo vzostupnom poradí pomocou minima.

833
00:50:32,600 --> 00:50:38,740
Tak sme si povedali, jo, sme na pozícii i, a musíme sa pozrieť na všetky prvky

834
00:50:38,740 --> 00:50:42,260
vpravo aj s cieľom nájsť minimálne.

835
00:50:42,260 --> 00:50:46,150
Takže to znamená, že chceme pozerať od i + 1 na koniec zoznamu.

836
00:50:46,150 --> 00:50:51,610
A teraz, v prípade, že prvok, ktorý sme v súčasnej dobe pri pohľade na menej než naše minimum tak ďaleko,

837
00:50:51,610 --> 00:50:54,190
ktoré, pamätajte, začíname minimálne off byť len

838
00:50:54,190 --> 00:50:57,020
bez ohľadu na element sme v súčasnej dobe, budem predpokladať, že je to minimum.

839
00:50:57,020 --> 00:51:00,270
Ak nájdem prvok, ktorý je menší ako to, že potom budem hovoriť, jo,

840
00:51:00,270 --> 00:51:02,700
dobre, som našiel novú minimálnu.

841
00:51:02,700 --> 00:51:06,080
Budem si pamätať kde to minimum bolo.

842
00:51:06,080 --> 00:51:09,560
>> Takže teraz, potom, čo som prešiel toto právo netriedeného segmentu,

843
00:51:09,560 --> 00:51:16,690
Môžem povedať, že som ísť vymeniť minimálne prvok s prvkom, ktorý je v polohe I.

844
00:51:16,690 --> 00:51:21,100
To bude vybudovať svoj zoznam, moja zoradená časť zoznamu zľava doprava,

845
00:51:21,100 --> 00:51:25,190
a my už nikdy musieť pozrieť na prvok znova, akonáhle je to v tejto časti.

846
00:51:25,190 --> 00:51:27,930
Akonáhle sme vymenili ho.

847
00:51:27,930 --> 00:51:30,260
Takže poďme bežať výber druhu na tomto zozname.

848
00:51:30,260 --> 00:51:38,220
Modrý prvok tu bude aj, a červený prvok bude minimálny prvok.

849
00:51:38,220 --> 00:51:41,570
Tak som spustí celú cestu vľavo od zoznamu, tak na 5.

850
00:51:41,570 --> 00:51:44,610
Teraz musíme nájsť minimálne zmiešaný prvok.

851
00:51:44,610 --> 00:51:49,480
Takže hovoríme 0 <5, takže 0 je môj nový minimum.

852
00:51:49,480 --> 00:51:53,820
>> Ale ja sa nemôže zastaviť tam, pretože aj keď sme si uvedomiť, že 0 je najmenší,

853
00:51:53,820 --> 00:51:59,390
musíme prejsť každý iný prvok zoznamu, aby sa ubezpečil.

854
00:51:59,390 --> 00:52:01,760
Takže 1 je väčší, 6 je väčšie, 4 je väčšia.

855
00:52:01,760 --> 00:52:05,850
To znamená, že potom, čo pri pohľade na všetky tieto prvky, som určuje 0 je najmenší.

856
00:52:05,850 --> 00:52:09,800
Takže budem prestavenie 5 a 0.

857
00:52:09,800 --> 00:52:15,480
Akonáhle som vymeniť to, že budem získať nový zoznam, a ja viem, že som nikdy nebudete musieť pozerať na tejto 0 znova

858
00:52:15,480 --> 00:52:19,380
pretože akonáhle som vymenil to, som zoradená, a sme hotoví.

859
00:52:19,380 --> 00:52:22,730
Teraz je len tak sa stane, že modrý prvok je opäť 5,

860
00:52:22,730 --> 00:52:26,030
a musíme sa pozrieť na 1, 6 a 4 určiť, že 1

861
00:52:26,030 --> 00:52:31,520
je najmenší minimálny prvok, takže budeme vymeniť 1 a 5.

862
00:52:31,520 --> 00:52:36,890
Opäť, musíme sa pozrieť na - porovnajte 5 na 6 a 4,

863
00:52:36,890 --> 00:52:39,830
a budeme zameniť 4 a 5, a konečne, tieto

864
00:52:39,830 --> 00:52:45,740
táto 2 čísla a vymeniť ich, kým sme si naše zoradený zoznam.

865
00:52:45,740 --> 00:52:49,730
Akékoľvek otázky týkajúce sa výberu druhu?

866
00:52:49,730 --> 00:52:56,420
Dobre. Poďme k poslednému téme tu, a to je rekurzia.

867
00:52:56,420 --> 00:52:59,810
>> Rekurzia, pamätajte, je to naozaj meta vec, kde funkcie

868
00:52:59,810 --> 00:53:02,740
opakovane volá sám.

869
00:53:02,740 --> 00:53:05,620
Takže v určitom okamihu, kým naša fuction je opakovane volá sama,

870
00:53:05,620 --> 00:53:10,100
tu musí byť nejaký bod, v ktorom sme sa zastavili volať sami.

871
00:53:10,100 --> 00:53:13,670
Pretože ak to neurobíme, potom sme len tak, aby aj naďalej robiť navždy,

872
00:53:13,670 --> 00:53:16,660
a náš program sa jednoducho nebude ukončiť.

873
00:53:16,660 --> 00:53:19,200
Hovoríme táto podmienka referenčný prípad.

874
00:53:19,200 --> 00:53:22,570
A základná vec hovorí, skôr ako volanie funkcie znovu,

875
00:53:22,570 --> 00:53:25,330
Ja som jednoducho ísť vrátiť nejakú hodnotu.

876
00:53:25,330 --> 00:53:28,080
Takže akonáhle sme vrátili hodnotu, zastavili sme volať sami,

877
00:53:28,080 --> 00:53:32,550
a zvyšok výziev sme doteraz vytvorili môžu tiež vracať.

878
00:53:32,550 --> 00:53:36,050
Naproti základné veci je rekurzívny prípad.

879
00:53:36,050 --> 00:53:39,050
A to je, keď chceme, aby sa ďalšie volanie funkcie, že sme v súčasnej dobe palcov

880
00:53:39,050 --> 00:53:44,690
A my asi, aj keď nie vždy, chcete použiť rôzne argumenty.

881
00:53:44,690 --> 00:53:48,940
>> Takže ak máme funkciu nazvanú f a f práve volal vziať 1 argument,

882
00:53:48,940 --> 00:53:52,010
a my sme ďalej označovať f (1), f (1), f (1), a to len tak sa stane, že

883
00:53:52,010 --> 00:53:56,510
argument 1 patrí do rekurzívne prípade, my ešte nikdy nezastaví.

884
00:53:56,510 --> 00:54:01,620
Aj keď máme základné prípad, musíme sa uistiť, že nakoniec budeme sa zasiahnuť, že základné veci.

885
00:54:01,620 --> 00:54:04,250
Nechceme len držať pobyt v tomto prípade rekurzívne.

886
00:54:04,250 --> 00:54:09,870
Všeobecne platí, že keď si hovoríme, že sme pravdepodobne bude mať iný argument, zakaždým.

887
00:54:09,870 --> 00:54:12,700
Tu je naozaj jednoduchý rekurzívny funkcie.

888
00:54:12,700 --> 00:54:15,090
Takže to bude počítať faktoriál čísla.

889
00:54:15,090 --> 00:54:17,790
Hore Hore tu máme základné prípad.

890
00:54:17,790 --> 00:54:22,330
V prípade, že n ≤ 1, my nebudeme volať faktoriál znova.

891
00:54:22,330 --> 00:54:26,490
Budeme sa zastaviť; sme len tak vrátiť nejakú hodnotu.

892
00:54:26,490 --> 00:54:30,170
Ak to nie je pravda, potom budeme hit našej rekurzívne prípad.

893
00:54:30,170 --> 00:54:33,550
Všimnite si, že nie sme len volať faktoriál (n), pretože to by nebolo moc užitočné.

894
00:54:33,550 --> 00:54:36,810
Budeme volať faktoriál niečo iné.

895
00:54:36,810 --> 00:54:40,850
>> A tak môžete vidieť, prípadne či míňame faktoriál (5), alebo tak niečo,

896
00:54:40,850 --> 00:54:45,900
budeme volať faktoriál (4), a tak ďalej, a nakoniec budeme hit tohto základného prípadu.

897
00:54:45,900 --> 00:54:51,730
Tak to vyzerá dobre. Pozrime sa, čo sa stane, keď v skutočnosti spustiť tento.

898
00:54:51,730 --> 00:54:57,840
To je stack, a povedzme, že hlavné bude volať túto funkciu s argumentom (4).

899
00:54:57,840 --> 00:55:02,200
Takže akonáhle faktoriál vidí a = 4, bude faktoriál volať seba.

900
00:55:02,200 --> 00:55:05,010
Teraz, naraz, máme faktoriál (3).

901
00:55:05,010 --> 00:55:10,780
Takže tieto funkcie budú naďalej zvyšovať, až nakoniec sme narazili náš základnú vec.

902
00:55:10,780 --> 00:55:17,830
V tomto bode, návratová hodnota je návrat (nx návratová hodnota tohto),

903
00:55:17,830 --> 00:55:21,290
návratová hodnota je nx návratová hodnota tohto.

904
00:55:21,290 --> 00:55:23,290
Nakoniec musíme zasiahnuť určitý počet.

905
00:55:23,290 --> 00:55:26,560
Na vrchole tu, hovoríme návrat 1.

906
00:55:26,560 --> 00:55:30,650
To znamená, že akonáhle sa vrátime toto číslo, môžeme pop tohoto zásobníka.

907
00:55:30,650 --> 00:55:36,570
Takže táto faktoriál (1) je vykonané.

908
00:55:36,570 --> 00:55:41,190
Pri 1 vráti, tento faktoriál (1) priznanie, tento návrat k 1.

909
00:55:41,190 --> 00:55:46,910
Návratová hodnota tohto, pamätajte, bol nx vrátená hodnota tohto.

910
00:55:46,910 --> 00:55:50,720
Tak náhle, tento chlap vie, že by som sa chcel vrátiť 2.

911
00:55:50,720 --> 00:55:55,910
>> Takže si pamätajte, vráti hodnota je len nx návratová hodnota tu.

912
00:55:55,910 --> 00:56:01,160
Takže teraz môžeme povedať, 3 x 2, a konečne, tu môžeme povedať,

913
00:56:01,160 --> 00:56:04,010
je to len bude 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
A akonáhle sa vráti, dostaneme sa na jednotlivé celočíselné vnútri hlavnej.

915
00:56:09,570 --> 00:56:15,460
Akékoľvek otázky týkajúce sa rekurzia?

916
00:56:15,460 --> 00:56:17,090
Dobrá. Takže tam je viac času na otázky na konci,

917
00:56:17,090 --> 00:56:23,360
ale teraz Joseph bude týkať zvyšných tém.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] Dobre. Takže teraz, že sme hovorili o rekurzia,

919
00:56:25,590 --> 00:56:27,840
poďme hovoriť trochu o tom, čo zlúčiť druh je.

920
00:56:27,840 --> 00:56:31,740
Zlúčiť druh je v podstate iný spôsob radenia zoznamu čísel.

921
00:56:31,740 --> 00:56:36,430
A ako to funguje, je, s radiť zlučovacie máte zoznam, a to, čo robíme, je

922
00:56:36,430 --> 00:56:39,120
hovoríme, poďme rozdeliť to do 2 polovice.

923
00:56:39,120 --> 00:56:42,750
Budeme prvý beh zlúčenie druh znovu na ľavej polovici,

924
00:56:42,750 --> 00:56:45,040
potom budeme spúšťať zlúčenie radenia na pravej polovici,

925
00:56:45,040 --> 00:56:50,240
a to nám dáva teraz 2 polovice, ktoré sú zoradené, a teraz budeme kombinovať tieto polovice spolu.

926
00:56:50,240 --> 00:56:55,010
Je to trochu ťažké vidieť bez príklade, takže budeme prechádzať pohyby a uvidíme, čo sa stane.

927
00:56:55,010 --> 00:56:59,590
Takže začnete s týmto zoznamom, rozdelili sme ho do 2 polovice.

928
00:56:59,590 --> 00:57:02,300
Prevádzkujeme zlúčenie radenie na ľavej polovici prvej.

929
00:57:02,300 --> 00:57:06,660
Tak to je ľavá polovica, a teraz sme sa spustiť je cez tento zoznam znovu

930
00:57:06,660 --> 00:57:09,800
ktorá je odovzdaná do druhu korešpondencie, a potom sa pozrieme, znovu,

931
00:57:09,800 --> 00:57:13,270
na ľavej strane tohto zoznamu, a organizujeme zlúčenie druh na ňom.

932
00:57:13,270 --> 00:57:15,880
Teraz, dostaneme sa do zoznamu čísel 2,

933
00:57:15,880 --> 00:57:19,010
a teraz ľavá polovica je len 1 prvok dlho, a my nemôžeme

934
00:57:19,010 --> 00:57:23,380
rozdeliť zoznam, ktorý je len 1 prvok do polovice, a tak sme len povedať, až budeme mať 50,

935
00:57:23,380 --> 00:57:26,400
ktorý je len 1 prvok, je to už sú zoradené.

936
00:57:26,400 --> 00:57:29,860
>> Akonáhle sme hotoví s tým, môžeme vidieť, že môžeme

937
00:57:29,860 --> 00:57:32,230
prejsť na pravej polovici tohto zoznamu,

938
00:57:32,230 --> 00:57:36,480
a 3 je tiež triedený, a tak teraz, že obe polovice tohto zoznamu sú zoradené

939
00:57:36,480 --> 00:57:39,080
môžeme spojiť tieto čísla dohromady.

940
00:57:39,080 --> 00:57:45,320
Tak sme sa pozrieť na 50 a 3, 3 je menší ako 50, tak to ide v prvej a potom 50 vypovedaciu

941
00:57:45,320 --> 00:57:49,340
Teraz, to, že urobil, sa vrátime do tohto zoznamu a zoradiť je to pravej polovici.

942
00:57:49,340 --> 00:57:52,440
42 je jeho vlastné číslo, takže to už sú zoradené.

943
00:57:52,440 --> 00:57:57,850
Teraz teda porovnávať 2 a 3, je menšia ako 42, tak, že sa dostane dať do prvej,

944
00:57:57,850 --> 00:58:02,340
teraz 42 dostane dať do, a 50 dostane dať dovnútra

945
00:58:02,340 --> 00:58:07,220
Teraz, to je zoradená, ideme celú cestu späť na vrchol, 1337 a 15.

946
00:58:07,220 --> 00:58:14,560
No, sa teraz pozrieme na ľavej polovici tohto zoznamu; 1337 je samo o sebe, takže to sú zoradené a to isté s 15.

947
00:58:14,560 --> 00:58:19,020
Takže teraz sme sa spojiť tieto 2 čísla zoradiť, že pôvodný zoznam, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
tak to ide v prvej, potom 1337 ide dovnútra

949
00:58:23,060 --> 00:58:26,640
A teraz sú zoradené obe polovice pôvodného zoznamu až hore.

950
00:58:26,640 --> 00:58:30,440
A všetko, čo musíme urobiť, je spojiť tieto.

951
00:58:30,440 --> 00:58:36,890
Pozerali sme sa na prvých 2 čísel v tomto zozname, 3 <15, tak to ide do triedenia poľa ako prvý.

952
00:58:36,890 --> 00:58:44,460
15 <42, tak to ide dovnútra Teraz, 42 <1337, že ide dovnútra

953
00:58:44,460 --> 00:58:51,010
50 <1337, tak to ide dovnútra a zistíte, že sme si vzal 2 čísla off tohto zoznamu.

954
00:58:51,010 --> 00:58:53,640
Takže sme nielen striedavo medzi 2 zoznamy.

955
00:58:53,640 --> 00:58:56,050
Sme len sa pozerá na začiatku, a my sme sa ujali prvok

956
00:58:56,050 --> 00:59:00,270
že je menší a potom uvedenie do nášho poľa.

957
00:59:00,270 --> 00:59:04,080
Teraz sme sa spojil všetky polovíc a sme hotoví.

958
00:59:04,080 --> 00:59:07,780
>> Akékoľvek otázky týkajúce sa korešpondencie druh? Áno?

959
00:59:07,780 --> 00:59:14,190
[Študent] Ak je to rozdelenie do rôznych skupín, prečo to jednoducho rozdeliť raz

960
00:59:14,190 --> 00:59:19,970
a máte 3 a 2 v skupine? [Zvyšok otázky nezrozumiteľné]

961
00:59:19,970 --> 00:59:24,940
Dôvod - takže otázkou je, prečo nemôžeme jednoducho zlúčiť v tom prvom kroku potom, čo sme si ich vziať?

962
00:59:24,940 --> 00:59:29,530
Dôvod, prečo by sme to urobiť, spustite na ľavej väčšina prvkov na oboch stranách,

963
00:59:29,530 --> 00:59:33,040
a potom ten menší a vložte ho do, je to, že vieme, že tieto

964
00:59:33,040 --> 00:59:35,290
Jednotlivé zoznamy sú v zoradené objednávky.

965
00:59:35,290 --> 00:59:37,290
Takže ak som pri pohľade na ľavú väčšina prvkov oboch polovíc,

966
00:59:37,290 --> 00:59:40,490
Ja viem, že to bude najmenšie prvky týchto zoznamov.

967
00:59:40,490 --> 00:59:43,930
Tak som ich dať do najmenších prvkov miestach tejto veľkej zoznamu.

968
00:59:43,930 --> 00:59:47,810
Na druhú stranu, keď sa na týchto 2 zoznamov v druhom stupni sa tam,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 a 15, sú tie, ktoré nie sú zoradené.

970
00:59:51,640 --> 00:59:55,770
Takže keď sa pozriem na 50 a 1337, ja dám 50 do môjho zoznamu ako prvý.

971
00:59:55,770 --> 01:00:00,130
Ale to nie je naozaj zmysel, pretože 3 je najmenší prvok zo všetkých z nich.

972
01:00:00,130 --> 01:00:04,390
Takže jediný dôvod, prečo môžeme urobiť tento krok, kombinujúci preto, že naše zoznamy sú už zoradené.

973
01:00:04,390 --> 01:00:07,010
Čo je dôvod, prečo sme sa pustiť celú cestu až na dno

974
01:00:07,010 --> 01:00:09,800
pretože keď máme len jedno číslo, viete, že jedno číslo

975
01:00:09,800 --> 01:00:14,120
samo o sebe je už zoradený zoznam.

976
01:00:14,120 --> 01:00:19,360
>> Nejaké otázky? Nie?

977
01:00:19,360 --> 01:00:24,260
Zložitosť? No, vidíte, že v každom kroku je tu koniec čísla,

978
01:00:24,260 --> 01:00:27,590
a môžeme rozdeliť zoznam na polovice protokolu n časy,

979
01:00:27,590 --> 01:00:31,700
ktorá je miesto, kde sme stáhni n x n log zložitosť.

980
01:00:31,700 --> 01:00:34,940
A uvidíte to najlepšie prípad radiť zlúčenie je n log n, a to len tak náhodou

981
01:00:34,940 --> 01:00:39,340
že najhorší prípad, alebo Ω tam je tiež n log n

982
01:00:39,340 --> 01:00:42,480
Niečo mať na pamäti.

983
01:00:42,480 --> 01:00:45,750
Pohybujúce sa na, poďme na niektoré extra základný súbor I / O.

984
01:00:45,750 --> 01:00:48,830
Ak ste sa pozerali na Scramble, všimnete si, mali sme nejaký systém

985
01:00:48,830 --> 01:00:51,270
kde by ste mohli napísať do súboru denníka, ak budete čítať pomocou kódu.

986
01:00:51,270 --> 01:00:53,730
Pozrime sa, ako by ste mohli urobiť.

987
01:00:53,730 --> 01:00:57,450
No, máme fprintf, ktoré si môžete myslieť, ako len printf,

988
01:00:57,450 --> 01:01:01,720
ale len tlač do súboru miesto, a preto f na začiatku.

989
01:01:01,720 --> 01:01:07,570
Tento druh kódu sa tu, čo to robí, je, ako ste mohli vidieť v Scramble,

990
01:01:07,570 --> 01:01:12,310
to ide cez 2-rozmerné pole tlač z riadkoch, čo tie čísla sú.

991
01:01:12,310 --> 01:01:17,850
V tomto prípade, printf vypíše na terminál alebo to, čo nazývame štandardné výstupné sekcie.

992
01:01:17,850 --> 01:01:22,170
>> A teraz, v tomto prípade, všetko, čo musíte urobiť, je nahradiť printf s fprintf,

993
01:01:22,170 --> 01:01:26,770
povedať, že to, čo súbor, ktorý chcete tlačiť, a v tomto prípade to jednoducho vytlačí ju k tomuto súboru

994
01:01:26,770 --> 01:01:32,230
miesto tlače to na terminál.

995
01:01:32,230 --> 01:01:36,500
No, potom to vyvoláva otázku: Kde sa dostaneme tento druh súboru z, že jo?

996
01:01:36,500 --> 01:01:39,840
Sme míňali prihlásiť do tohto fprintf fuction, ale nemali sme potuchy, odkiaľ pochádza.

997
01:01:39,840 --> 01:01:43,980
No, čoskoro v kóde, čo sme mali, bola to kus kódu tu,

998
01:01:43,980 --> 01:01:48,340
ktorý v podstate hovorí, že open file volá log.txt.

999
01:01:48,340 --> 01:01:53,220
Čo robíme po tom je, že sme sa uistiť, že súbor je skutočne úspešne otvorený.

1000
01:01:53,220 --> 01:01:57,070
Tak to by mohlo zlyhať z mnohých dôvodov, nemáte dostatok miesta na vašom počítači, napríklad.

1001
01:01:57,070 --> 01:01:59,790
Takže je to vždy dôležité než to urobíte akékoľvek operácie so súborom

1002
01:01:59,790 --> 01:02:03,300
že sme skontrolovať, či súbor bol úspešne otvorený.

1003
01:02:03,300 --> 01:02:09,330
Takže to, čo, že, to je argument funkcie fopen, dobre, môžeme otvoriť súbor v mnohých ohľadoch.

1004
01:02:09,330 --> 01:02:13,510
Čo môžeme urobiť, je, môžeme odovzdať w, čo znamená, že prepísať súbor, ak to vystúpi už,

1005
01:02:13,510 --> 01:02:18,070
Môžeme odovzdať A, ktorý sa pripojí na koniec súboru namiesto prepísanie to,

1006
01:02:18,070 --> 01:02:22,730
alebo môžeme určiť r, čo znamená, poďme otvoriť súbor len na čítanie.

1007
01:02:22,730 --> 01:02:24,890
Takže ak sa program pokúsi vykonať zmeny v súbore,

1008
01:02:24,890 --> 01:02:30,140
kričí na ne, a nie nechať ich robiť to.

1009
01:02:30,140 --> 01:02:33,320
Nakoniec, keď sme hotoví s súbor, urobil tým operácie na ňom,

1010
01:02:33,320 --> 01:02:35,860
musíme sa uistiť, že súbor zatvorte.

1011
01:02:35,860 --> 01:02:38,830
A tak na konci programu, budete odovzdať znova

1012
01:02:38,830 --> 01:02:42,120
Tento súbor, ktorý ste otvorili, a len zatvorte ho.

1013
01:02:42,120 --> 01:02:44,650
Tak toto je niečo dôležité, že budete musieť uistite sa, že.

1014
01:02:44,650 --> 01:02:47,180
Takže pamätajte si môžete otvoriť súbor, potom môžete napísať do súboru,

1015
01:02:47,180 --> 01:02:51,270
to operácia v súbore, ale potom budete musieť uzavrieť spis na konci.

1016
01:02:51,270 --> 01:02:53,270
>> Akékoľvek otázky o populácie vstupné /? Áno?

1017
01:02:53,270 --> 01:02:58,050
[Študent otázka, nezrozumiteľným]

1018
01:02:58,050 --> 01:03:02,480
Práve tu. Otázkou je, kde to log.txt súbor sa objaví?

1019
01:03:02,480 --> 01:03:07,890
No, ak ste práve dať Log.txt, vytvorí v rovnakom adresári ako spustiteľný súbor.

1020
01:03:07,890 --> 01:03:10,500
Takže ak Si - >> [Student otázka, nezrozumiteľným]

1021
01:03:10,500 --> 01:03:18,830
Áno. V rovnakej zložke, alebo v rovnakom adresári, ako to nazývate.

1022
01:03:18,830 --> 01:03:21,400
Teraz pamäť, zásobník, a haldy.

1023
01:03:21,400 --> 01:03:23,400
Tak, ako je pamäť stanovenými v počítači?

1024
01:03:23,400 --> 01:03:26,270
No, viete si predstaviť, pamäť ako druh tohto bloku tu.

1025
01:03:26,270 --> 01:03:30,260
A v pamäti máme to, čo sa nazýva haldy uviazol tam, a zásobník, ktorý je tam dole.

1026
01:03:30,260 --> 01:03:34,480
A haldy rastie smerom dole a zásobník rastie smerom nahor.

1027
01:03:34,480 --> 01:03:38,620
Tak ako Tommy uvedené - oh, dobre, a my máme tieto iné 4 segmenty, ktoré dostanem v druhej -

1028
01:03:38,620 --> 01:03:42,890
Ako Tommy povedal skôr, že viete, ako jeho funkcie sa nazývajú a volať navzájom?

1029
01:03:42,890 --> 01:03:44,930
Budujú sa tento druh zásobníka rámu.

1030
01:03:44,930 --> 01:03:47,360
No, ak sú hlavné vyzýva foo, dostane foo kladený na zásobníku.

1031
01:03:47,360 --> 01:03:52,430
Foo volá bar, bar sa si dať do fronty, a ktorý sa dal na stack po.

1032
01:03:52,430 --> 01:03:57,040
A ako sa vráti, každý sa dostanú nahý zásobníka.

1033
01:03:57,040 --> 01:04:00,140
Čo každý z týchto miest a pamäť držať?

1034
01:04:00,140 --> 01:04:03,110
No, horná, ktorá je text segment, obsahuje vlastný program.

1035
01:04:03,110 --> 01:04:06,390
Takže strojového kódu, je to tam, akonáhle kompilovať svoj program.

1036
01:04:06,390 --> 01:04:08,520
Ďalšie, každý inicializácii globálne premenné.

1037
01:04:08,520 --> 01:04:12,660
>> Takže máte globálne premenné v programe, a vy hovoríte, ako, a = 5,

1038
01:04:12,660 --> 01:04:15,260
, Ktorý sa dal v tomto segmente, a priamo pod to,

1039
01:04:15,260 --> 01:04:18,990
Máte nejaké neinicializovaný globálne dáta, ktorá je len INT,

1040
01:04:18,990 --> 01:04:20,990
ale nehovorte, že je to rovnaké na čokoľvek.

1041
01:04:20,990 --> 01:04:23,870
Uvedomte si, to sú globálne premenné, takže sú mimo hlavnej.

1042
01:04:23,870 --> 01:04:28,560
Takže to znamená, žiadne globálne premenné, ktoré sú deklarované, ale nie sú inicializované.

1043
01:04:28,560 --> 01:04:32,310
Takže to, čo je v halde? Pamäť alokujú pomocou malloc, ktorý sa dostaneme za chvíľu.

1044
01:04:32,310 --> 01:04:35,990
A konečne, s zásobník máte lokálne premenné

1045
01:04:35,990 --> 01:04:39,950
a všetky funkcie, ktoré by sa dalo nazvať všetkých svojich parametrov.

1046
01:04:39,950 --> 01:04:43,720
Posledná vec, nemáte naozaj vedieť, čo premenné prostredie urobiť,

1047
01:04:43,720 --> 01:04:46,700
ale zakaždým, keď spustíte program, tam je niečo spojené, ako

1048
01:04:46,700 --> 01:04:49,550
toto je užívateľské meno osoby, ktorá bežal program.

1049
01:04:49,550 --> 01:04:51,550
A to bude trochu na dne.

1050
01:04:51,550 --> 01:04:54,540
Pokiaľ ide o adresy pamäte, ktoré sú hexadecimálne hodnoty,

1051
01:04:54,540 --> 01:04:58,170
hodnoty v hornom začínajú na 0, a oni idú celú cestu až na dno.

1052
01:04:58,170 --> 01:05:00,440
V tomto prípade, ak ste na 32-bitovom systéme,

1053
01:05:00,440 --> 01:05:05,390
adresa v dolnej časti bude 0x, nasledovaný AF, pretože to je 32 bitov,

1054
01:05:05,390 --> 01:05:10,890
ktorá je 8 bytov, a v tomto prípade 8 bytov zodpovedá 8 hexadecimálnych číslic.

1055
01:05:10,890 --> 01:05:20,110
Tak tu budeš mať, rád, 0xffffff, a tam budeš mať 0.

1056
01:05:20,110 --> 01:05:23,660
Takže aké sú ukazovatele? Niektorí z vás nemusí vzťahovať to v časti pred.

1057
01:05:23,660 --> 01:05:26,660
ale my sme sa ísť cez neho v prednáške, takže ukazovateľ je len dátový typ

1058
01:05:26,660 --> 01:05:34,030
ktoré ukladá, namiesto nejakého druhu hodnoty, ako je 50, uloží adresu na nejaké miesto v pamäti.

1059
01:05:34,030 --> 01:05:36,020
Ako ten pamäte [nezrozumiteľné].

1060
01:05:36,020 --> 01:05:41,120
Takže v tomto prípade, to, čo sme, je, že máme ukazovateľ na celé číslo alebo int *,

1061
01:05:41,120 --> 01:05:46,210
a obsahuje túto hexadecimálne adresu 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Takže to, čo máme, je, teraz sa tento ukazovateľ na nejaké miesto v pamäti,

1063
01:05:50,880 --> 01:05:56,020
a to je len, hodnota 50 je v tomto mieste pamäti.

1064
01:05:56,020 --> 01:06:01,810
Na niektorých 32-bitových systémoch, vo všetkých 32-bitových systémov, ukazovatele zaberajú 32 bitov alebo 4 bajty.

1065
01:06:01,810 --> 01:06:06,020
Ale, napríklad, na 64-bitovom systéme, ukazovatele je 64 bitov.

1066
01:06:06,020 --> 01:06:08,040
Tak to je niečo, čo budete chcieť mať na pamäti.

1067
01:06:08,040 --> 01:06:12,310
Tak na koniec-bit systému, ukazovateľ koncové bitov.

1068
01:06:12,310 --> 01:06:17,320
Ukazovatele sú trochu ťažko stráviteľné bez zbytočných vecí,

1069
01:06:17,320 --> 01:06:20,300
takže sa poďme prejsť príklad dynamického prideľovania pamäte.

1070
01:06:20,300 --> 01:06:25,130
Čo dynamické prideľovanie pamäte pre vás robí, alebo to, čo nazývame malloc,

1071
01:06:25,130 --> 01:06:29,280
To vám umožní prideliť nejaký údajov mimo sady.

1072
01:06:29,280 --> 01:06:31,830
Takže tieto dáta je niečo trvalejšieho pre celú dobu trvania programu.

1073
01:06:31,830 --> 01:06:36,430
Vzhľadom k tomu, ako viete, ak ste deklarovať x vnútri funkcie, a že funkcia vracia,

1074
01:06:36,430 --> 01:06:40,910
už nemáte prístup k dátam, ktorá bola uložená v x.

1075
01:06:40,910 --> 01:06:44,420
Čo ukazovatele nám urobiť, je, že nám tieto pamäťové alebo obchod hodnôt

1076
01:06:44,420 --> 01:06:46,840
v inom segmente pamäti, a to haldy.

1077
01:06:46,840 --> 01:06:49,340
Teraz, keď sa vrátime z funkcie, tak dlho, ako máme ukazovateľ

1078
01:06:49,340 --> 01:06:54,960
na tomto mieste v pamäti, potom to, čo môžeme urobiť, je, že sme sa len pozrieť na hodnoty tam.

1079
01:06:54,960 --> 01:06:58,020
Poďme sa pozrieť na príklad: Toto je naša pamäť layout znovu.

1080
01:06:58,020 --> 01:07:00,050
A my máme túto funkciu, hlavné.

1081
01:07:00,050 --> 01:07:06,870
Čo to urobí, je - v poriadku, tak jednoduché, že jo? - Int x = 5, to je len premenná na zásobníku v main.

1082
01:07:06,870 --> 01:07:12,450
>> Na druhú stranu, teraz deklarujeme ukazovateľ, ktorý volá funkciu giveMeThreeInts.

1083
01:07:12,450 --> 01:07:16,800
A tak teraz pôjdeme do tejto funkcie a vytvoríme nový zásobníka rámec pre neho.

1084
01:07:16,800 --> 01:07:20,440
Avšak v tomto zásobníku ráme, vyhlasujeme int * teplota,

1085
01:07:20,440 --> 01:07:23,210
ktoré v celých mallocs 3 pre nás.

1086
01:07:23,210 --> 01:07:25,880
Takže veľkosť int dá nám, koľko bytov to int je,

1087
01:07:25,880 --> 01:07:29,620
a malloc nám dáva, že veľa bytov priestoru na halde.

1088
01:07:29,620 --> 01:07:32,890
Takže v tomto prípade, sme vytvorili dostatočný priestor pre 3 celých čísel,

1089
01:07:32,890 --> 01:07:36,830
a haldy je spôsob, ako sa tam, čo je dôvod, prečo som vypracovaná to vyššie.

1090
01:07:36,830 --> 01:07:42,900
Akonáhle sme hotoví, vrátime sa sem, budete potrebovať len 3 ints vrátil,

1091
01:07:42,900 --> 01:07:47,000
a vráti adresu, v tomto prípade viac ako kedykoľvek že pamäť je.

1092
01:07:47,000 --> 01:07:51,250
A sme si stanovili ukazovatele = prepínač, a tam máme len ďalší ukazovateľ.

1093
01:07:51,250 --> 01:07:54,550
Ale čo to vráti funkcia je stohovať tu a zmizne.

1094
01:07:54,550 --> 01:07:59,250
Takže teplota zmizne, ale stále zachovať adresu, kde

1095
01:07:59,250 --> 01:08:01,850
tie 3 čísla sú vo vnútri siete.

1096
01:08:01,850 --> 01:08:06,180
Takže v tejto sade, ukazovateľov sú rozsahom lokálne pre skladanom rámu,

1097
01:08:06,180 --> 01:08:09,860
ale pamäť, na ktoré sa vzťahujú sa na hromadu.

1098
01:08:09,860 --> 01:08:12,190
>> Dává to zmysel?

1099
01:08:12,190 --> 01:08:14,960
[Študent] Mohli by ste to zopakovať? >> [Joseph] Áno.

1100
01:08:14,960 --> 01:08:20,270
Takže keď som sa vrátiť len trochu, uvidíte, že teplota pridelené

1101
01:08:20,270 --> 01:08:23,500
niektoré pamäte na halde up there.

1102
01:08:23,500 --> 01:08:28,680
Takže keď táto funkcia, giveMeThreeInts vráti, to stack tu zmizne.

1103
01:08:28,680 --> 01:08:35,819
A s ním akékoľvek premenných, v tomto prípade, to ukazovateľ, ktorý bol rozdelený v skladanom ráme.

1104
01:08:35,819 --> 01:08:39,649
To je zmizne, ale od tej doby sme sa vrátili temp

1105
01:08:39,649 --> 01:08:46,330
a dali sme sa ukazovateľ = temp, ukazovateľ sa teraz bude ukazovať rovnakú pamäť na umiestnenie ako teplota bola.

1106
01:08:46,330 --> 01:08:50,370
Takže teraz, aj keď strácame temp, že miestne ukazovatele,

1107
01:08:50,370 --> 01:08:59,109
sme ešte udržať adresu pamäte, čo to bolo ukázal dovnútra tejto premennej ukazovatele.

1108
01:08:59,109 --> 01:09:03,740
Otázky? To môže byť trochu mätúce tému, ak ste nešla nad ním v oddiele.

1109
01:09:03,740 --> 01:09:09,240
Môžeme, bude váš TF určite ísť cez neho, a samozrejme budeme môcť odpovedať na otázky

1110
01:09:09,240 --> 01:09:11,500
na konci sledovaného relácie za to.

1111
01:09:11,500 --> 01:09:14,220
Ale to je trochu zložité témy, a mám ďalšie príklady, ktoré sa chystáte ukázať

1112
01:09:14,220 --> 01:09:18,790
ktoré pomôžu objasniť, čo vlastne sú ukazovatele.

1113
01:09:18,790 --> 01:09:22,500
>> V tomto prípade, ukazovatele sú ekvivalentné polí,

1114
01:09:22,500 --> 01:09:25,229
tak som si použite tento ukazovateľ ako rovnakú vec ako int pole.

1115
01:09:25,229 --> 01:09:29,840
Takže som indexovanie do 0, a zmeniť prvé číslo na 1,

1116
01:09:29,840 --> 01:09:39,689
zmenou druhý číslo na 2 a 3. celé číslo 3.

1117
01:09:39,689 --> 01:09:44,210
Takže viac na ukazovateli. No, spomínam Binky.

1118
01:09:44,210 --> 01:09:48,319
V tomto prípade sme pridelené ukazovateľ, alebo sme deklarovali ukazovateľ,

1119
01:09:48,319 --> 01:09:52,760
ale spočiatku, keď som vyhlásil ukazovateľ, to nie je poukazuje na kdekoľvek v pamäti.

1120
01:09:52,760 --> 01:09:54,930
Je to len odpadky hodnoty vnútri nej.

1121
01:09:54,930 --> 01:09:56,470
Takže nemám potuchy, kde tento ukazovateľ ukazuje.

1122
01:09:56,470 --> 01:10:01,630
Má adresu, ktorá je len plná 0 a 1, kde bol pôvodne deklarovaný.

1123
01:10:01,630 --> 01:10:04,810
Nemôžem nič robiť s tým, kým som volať malloc na to

1124
01:10:04,810 --> 01:10:08,390
a potom mi to dáva málo miesta na halde, kde sa môžem obrátiť hodnoty vnútri.

1125
01:10:08,390 --> 01:10:11,980
Potom znova, ja neviem, čo je vo vnútri tejto pamäte.

1126
01:10:11,980 --> 01:10:16,780
Takže prvá vec, ktorú musím urobiť, je skontrolovať, či systém mal dostatok pamäte

1127
01:10:16,780 --> 01:10:20,850
aby ma späť 1 celé číslo na prvom mieste, čo je dôvod, prečo to robím kontrolu.

1128
01:10:20,850 --> 01:10:25,020
Ak je ukazovateľ null, to znamená, že nemá dostatok miesta alebo nejakej inej chybe,

1129
01:10:25,020 --> 01:10:26,320
tak som mal ukončiť z môjho programu.

1130
01:10:26,320 --> 01:10:29,400
 Ale ak sa to podarí, teraz môžem používať tento ukazovateľ

1131
01:10:29,400 --> 01:10:35,020
a čo * ukazovateľ robí, je, že idú tam, kde je adresa

1132
01:10:35,020 --> 01:10:38,480
tam, kde táto hodnota je, a to nastaví sa rovná 1.

1133
01:10:38,480 --> 01:10:41,850
Tak tu, sme kontrolu, či sa pamäť existuje.

1134
01:10:41,850 --> 01:10:45,380
>> Akonáhle budete vedieť, že existuje, môžete si dať do neho

1135
01:10:45,380 --> 01:10:50,460
akú hodnotu chcete dať do nej, v tomto prípade 1.

1136
01:10:50,460 --> 01:10:53,060
Akonáhle sme hotoví s ním, je potrebné uvoľniť tento ukazovateľ

1137
01:10:53,060 --> 01:10:57,160
pretože sa musíme dostať späť do systému, ktorý pamäti, že budete požiadaní v prvom rade.

1138
01:10:57,160 --> 01:10:59,690
Vzhľadom k tomu, že počítač nevie, kedy sme s ním urobil.

1139
01:10:59,690 --> 01:11:02,510
V tomto prípade sme explicitne hovoriť, áno, my sme urobili s týmto pamäte.

1140
01:11:02,510 --> 01:11:10,780
Ak nejaká iná proces potrebuje, iný program potrebuje, neváhajte ísť dopredu a vziať ju.

1141
01:11:10,780 --> 01:11:15,110
Čo môžeme urobiť, je tiež môžeme len získať adresu lokálnych premenných na televízore.

1142
01:11:15,110 --> 01:11:19,080
Takže int x je vnútri skladaného rámu main.

1143
01:11:19,080 --> 01:11:23,060
A keď budeme mať túto ampersand, tento a prevádzkovateľ, čo robí, je

1144
01:11:23,060 --> 01:11:27,310
trvá x, a x je len niektoré údaje v pamäti, ale má adresu.

1145
01:11:27,310 --> 01:11:33,790
Je umiestnený niekde. Takže volanie a x, čo to robí, je, že nám dáva adresu x.

1146
01:11:33,790 --> 01:11:38,430
Tým, že robíme ukazovateľ miesto, kde x je v pamäti.

1147
01:11:38,430 --> 01:11:41,710
Teraz už len urobiť niečo ako * x, budeme si 5 späť.

1148
01:11:41,710 --> 01:11:43,820
Hviezda sa nazýva dereferencing to.

1149
01:11:43,820 --> 01:11:46,640
Môžete sledovať adresu a dostanete hodnotu toho tu uložené.

1150
01:11:51,000 --> 01:11:53,310
>> Nejaké otázky? Áno?

1151
01:11:53,310 --> 01:11:56,500
[Študent] Ak nechcete robiť 3-špicatý vec, to ešte kompiláciu?

1152
01:11:56,500 --> 01:11:59,490
Áno. Ak nechcete robiť 3-ukazovateľ vec, je to stále bude zostavovať,

1153
01:11:59,490 --> 01:12:02,720
ale ja ti ukážem, čo sa deje v druhej, a bez toho, že

1154
01:12:02,720 --> 01:12:04,860
že to, čo nazývame pretečeniu pamäte. Nedávate systému

1155
01:12:04,860 --> 01:12:07,850
späť svoju pamäť, takže po chvíli program bude hromadiť

1156
01:12:07,850 --> 01:12:10,940
pamäti, že to nie je pomocou, a nič iné ju použiť.

1157
01:12:10,940 --> 01:12:15,750
Ak ste niekedy videli Firefox s 1500000 kb na vašom počítači,

1158
01:12:15,750 --> 01:12:17,840
v Správcovi úloh, že to, čo sa deje.

1159
01:12:17,840 --> 01:12:20,760
Máte pretečeniu pamäte v programe, že nie ste manipuláciu.

1160
01:12:23,080 --> 01:12:26,240
Tak, ako sa ukazovateľ aritmetický práce?

1161
01:12:26,240 --> 01:12:29,480
No, ukazovateľ aritmetický je niečo ako indexovanie do poľa.

1162
01:12:29,480 --> 01:12:36,370
V tomto prípade, mám ukazovateľ, a to, čo robím je, že som, aby ukazovateľ bod na prvý prvok

1163
01:12:36,370 --> 01:12:42,100
tohto poľa 3 celých čísel, ktoré som pridelené.

1164
01:12:42,100 --> 01:12:46,670
Takže teraz, čo mám robiť, star pointer len zmení prvý prvok v zozname.

1165
01:12:46,670 --> 01:12:49,140
Hviezda ukazovateľ 1 bodov za tu.

1166
01:12:49,140 --> 01:12:53,140
Takže ukazovateľ je tu, ukazovateľ 1 je tu, ukazovateľ 2 je tu.

1167
01:12:53,140 --> 01:12:56,610
>> Takže len pridať 1 je to isté, ako pohybujúce sa tohto poľa.

1168
01:12:56,610 --> 01:12:59,880
Čo máme urobiť, je, keď robíme ukazovateľ 1 dostanete adresu sem,

1169
01:12:59,880 --> 01:13:04,180
a za účelom získať hodnotu v tú môžete dať hviezdu z celého výrazu

1170
01:13:04,180 --> 01:13:05,990
k dereferencia to.

1171
01:13:05,990 --> 01:13:09,940
Takže, v tomto prípade, som nastavenie prvého umiestnenia v tomto poli na hodnotu 1,

1172
01:13:09,940 --> 01:13:13,970
druhej umiestnenie na 2, a tretie umiestnenie na 3..

1173
01:13:13,970 --> 01:13:18,180
Potom to, čo robím tu je mi tlačí náš ukazovateľ 1,

1174
01:13:18,180 --> 01:13:19,970
ktorý len mi dáva 2.

1175
01:13:19,970 --> 01:13:23,650
Teraz som zvyšovanie ukazovateľ, takže ukazovateľ rovná ukazovateľ 1,

1176
01:13:23,650 --> 01:13:26,780
ktorý sa pohybuje dopredu.

1177
01:13:26,780 --> 01:13:30,810
A tak teraz, keď som vytlačiť ukazovateľ 1, ukazovateľ +1 je teraz 3,

1178
01:13:30,810 --> 01:13:33,990
čo v tomto prípade sa vytlačí 3.

1179
01:13:33,990 --> 01:13:36,560
A aby uvoľnila niečo, ukazovateľ, že dám ju

1180
01:13:36,560 --> 01:13:40,540
musí smerovať na začiatku poľa, ktoré som sa vrátil z malloc.

1181
01:13:40,540 --> 01:13:43,430
Takže, v tomto prípade, ak by som mal zavolať 3 tu, by to nebolo správne,

1182
01:13:43,430 --> 01:13:45,070
, Pretože je to v strede poľa.

1183
01:13:45,070 --> 01:13:48,820
Musím odpočítať dostať do pôvodného umiestnenia

1184
01:13:48,820 --> 01:13:50,420
Počiatočná prvé miesto, ako som si uvoľniť ju.

1185
01:13:56,300 --> 01:13:58,450
Takže, tu je viac zapojiť príklad.

1186
01:13:58,450 --> 01:14:03,360
V tomto prípade, sme prideľovanie 7 znakov pole znakov.

1187
01:14:03,360 --> 01:14:06,480
>> A v tomto prípade to, čo robíme, je, že sme looping cez prvú 6 z nich,

1188
01:14:06,480 --> 01:14:09,900
a my sme nastavením na Z.

1189
01:14:09,900 --> 01:14:13,350
Takže, pre int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Takže, ukazovateľ + i sa len nám, v tomto prípade,

1191
01:14:16,220 --> 01:14:20,860
ukazovateľ, ukazovateľ 1, ukazovateľ +2, ukazovateľ 3, a tak ďalej a tak ďalej v slučke.

1192
01:14:20,860 --> 01:14:24,040
Čo to urobí, je, že dostane tú adresu, dereferences to, aby si hodnoty,

1193
01:14:24,040 --> 01:14:27,440
a zmeny, aby hodnota v Z.

1194
01:14:27,440 --> 01:14:30,350
Potom na konci si pamätám, je reťazec, nie?

1195
01:14:30,350 --> 01:14:33,560
Všetky reťazce majú skončiť s nulovým ukončovacie znak.

1196
01:14:33,560 --> 01:14:38,620
Takže, čo robím, je ukazovátko 6 I dal null zakončenie znak a

1197
01:14:38,620 --> 01:14:43,980
A teraz, čo som v podstate robil tu vykonáva printf pre reťazec, nie?

1198
01:14:43,980 --> 01:14:46,190
>> Takže, keď to printf teraz, keď je to na konci reťazca?

1199
01:14:46,190 --> 01:14:48,230
Keď zasiahne null ukončujúce znak.

1200
01:14:48,230 --> 01:14:52,030
Takže, v tomto prípade, moje pôvodné ukazovateľ ukazuje na začiatku tohto poľa.

1201
01:14:52,030 --> 01:14:56,410
Aj vytlačiť prvý znak von. Aj presunúť cez jedného.

1202
01:14:56,410 --> 01:14:58,420
Aj vytlačiť túto postavu von. Aj pohybovať nad.

1203
01:14:58,420 --> 01:15:02,180
A ja si to tak, kým som sa dostať na koniec.

1204
01:15:02,180 --> 01:15:07,750
A teraz koniec * ukazovateľ bude dereferencia a dostať sa na null ukončujúci znak späť.

1205
01:15:07,750 --> 01:15:11,780
A tak môj while beží iba v prípade, že hodnota nie je null ukončovacie znak.

1206
01:15:11,780 --> 01:15:13,770
Tak, teraz som opustiť z tejto slučky.

1207
01:15:18,780 --> 01:15:21,180
A tak keď som odpočítať 6 z tohto ukazovateľa,

1208
01:15:21,180 --> 01:15:22,860
Vrátim sa celú cestu na začiatok.

1209
01:15:22,860 --> 01:15:27,880
Nezabudnite, robím to preto, že musím ísť na začiatok, aby sa oslobodil ho.

1210
01:15:27,880 --> 01:15:30,270
>> Takže som vedel, že to veľa. Sú nejaké otázky?

1211
01:15:30,270 --> 01:15:31,870
Prosím, áno?

1212
01:15:31,870 --> 01:15:36,610
[Študent otázka nezrozumiteľná]

1213
01:15:36,610 --> 01:15:38,190
Môžete povedať, že hlasnejšie? Prepáčte.

1214
01:15:38,190 --> 01:15:44,140
[Študent] Na poslednom snímke tesne predtým, než budete oslobodený ukazovateľ,

1215
01:15:44,140 --> 01:15:47,300
kde sa skutočne zmene hodnoty ukazovateľa?

1216
01:15:47,300 --> 01:15:50,370
[Joseph] Tak, tu. >> [Študent] Oh, dobre.

1217
01:15:50,370 --> 01:15:51,890
[Joseph] Tak, mám ukazovateľ mínus mínus, vpravo,

1218
01:15:51,890 --> 01:15:54,140
ktorý sa pohybuje na vec späť o jeden, a potom som oslobodiť to,

1219
01:15:54,140 --> 01:15:57,000
pretože tento ukazovateľ je potrebné zdôrazniť na začiatku poľa.

1220
01:15:57,000 --> 01:16:00,420
[Študent] Ale to by nebola potrebná, keby ste prestal po tomto riadku.

1221
01:16:00,420 --> 01:16:03,130
[Joseph] Takže, keď som prestal po tomto, by to bolo považované za únik pamäte,

1222
01:16:03,130 --> 01:16:04,810
pretože som nebežal zadarmo.

1223
01:16:04,810 --> 01:16:11,290
[Študent] I [nezrozumiteľné] po prvých troch riadkoch, kde ste mali ukazovateľ 1 [nezrozumiteľné].

1224
01:16:11,290 --> 01:16:13,140
[Joseph] Uh-huh. Takže, čo je otázka tam?

1225
01:16:13,140 --> 01:16:14,780
Prepáčte. Nie, nie. Choď, choď, prosím.

1226
01:16:14,780 --> 01:16:16,870
[Študent] Takže, nie ste zmenou hodnoty ukazovateľov.

1227
01:16:16,870 --> 01:16:19,130
Tie by sa musel urobiť ukazovateľ mínus mínus.

1228
01:16:19,130 --> 01:16:19,730
[Joseph] Áno, presne tak.

1229
01:16:19,730 --> 01:16:21,890
Takže, keď som si ukazovateľ 1 a ukazovateľ 2,

1230
01:16:21,890 --> 01:16:24,410
Nerobím ukazovateľ rovná ukazovateľ 1.

1231
01:16:24,410 --> 01:16:27,260
Takže, ukazovateľ len zostane ukazuje na začiatku poľa.

1232
01:16:27,260 --> 01:16:31,460
Je to len vtedy, keď robím plus plus, že nastaví hodnotu späť do ukazovatele,

1233
01:16:31,460 --> 01:16:33,550
že to vlastne pohybuje to spolu.

1234
01:16:36,860 --> 01:16:37,780
Dobrá.

1235
01:16:40,550 --> 01:16:42,030
Ďalšie otázky?

1236
01:16:44,680 --> 01:16:47,790
>> Opäť platí, že ak je to druh ohromujúci, bude to zahrnuté v relácii.

1237
01:16:47,790 --> 01:16:50,710
Opýtajte sa svojho vyučujúceho, kolegu o tom, a my môžeme odpovedať na otázky na konci.

1238
01:16:53,510 --> 01:16:56,600
A zvyčajne sa nám nepáči to urobiť mínus vec.

1239
01:16:56,600 --> 01:16:59,760
To je vyžadujú, aby som sledovanie toho, ako veľmi som posun v poli.

1240
01:16:59,760 --> 01:17:04,520
Takže, všeobecne, je to len vysvetliť, ako funguje ukazovateľ aritmetické.

1241
01:17:04,520 --> 01:17:07,970
Ale to, čo zvyčajne radi urobili je, že sme chceli vytvoriť kópiu ukazovatele,

1242
01:17:07,970 --> 01:17:11,640
a potom budeme používať túto kópiu, keď ideme okolo v reťazci.

1243
01:17:11,640 --> 01:17:14,660
Takže, v týchto prípadoch použiť kópie vytlačiť celý reťazec,

1244
01:17:14,660 --> 01:17:19,040
ale nemáme robiť ako ukazovateľ mínus 6 alebo sledovať, ako veľmi sme sa presťahovali v tomto,

1245
01:17:19,040 --> 01:17:22,700
len preto, že vieme, že náš pôvodný bod je stále poukazoval na začiatok zoznamu

1246
01:17:22,700 --> 01:17:25,340
a všetko, čo zmenil je to kópia.

1247
01:17:25,340 --> 01:17:28,250
Takže, všeobecne meniť kópie pôvodného ukazovateľ.

1248
01:17:28,250 --> 01:17:32,350
Nesnažte sa nejako ako - nerob zmeniť originály.

1249
01:17:32,350 --> 01:17:35,290
Snažiť sa zmeniť iba kópia originálu.

1250
01:17:41,540 --> 01:17:44,870
Takže, si všimnete, keď míňame reťazec do printf

1251
01:17:44,870 --> 01:17:48,990
nemusíte dať hviezdu pred ním, ako sme to urobili so všetkými ostatnými dereferences, že jo?

1252
01:17:48,990 --> 01:17:54,180
Takže, ak môžete vytlačiť celý reťazec% s očakáva, že je adresa,

1253
01:17:54,180 --> 01:17:57,610
a v tomto prípade ukazovateľ alebo v tomto prípade ako pole znakov.

1254
01:17:57,610 --> 01:18:00,330
>> Postavy, char * s, a polia sú to isté.

1255
01:18:00,330 --> 01:18:03,690
Ukazovateľ je znakov, a pole znakov sú to isté.

1256
01:18:03,690 --> 01:18:05,720
A tak, všetko, čo musíte urobiť, je odovzdať ukazovateľ.

1257
01:18:05,720 --> 01:18:08,150
Nemáme odovzdať ako * ukazovateľ alebo niečo podobné.

1258
01:18:13,110 --> 01:18:14,930
Takže, polia a ukazovatele sú to isté.

1259
01:18:14,930 --> 01:18:19,160
Keď robíte niečo ako x [y] sem na pole,

1260
01:18:19,160 --> 01:18:21,960
čo to robí pod kapotou je to hovorí, jo, je to pole znakov,

1261
01:18:21,960 --> 01:18:23,690
takže je to ukazovateľ.

1262
01:18:23,690 --> 01:18:26,510
A tak x je to isté,

1263
01:18:26,510 --> 01:18:28,650
a tak to, čo robí, je, že pridá y na x,

1264
01:18:28,650 --> 01:18:31,820
ktorý je to isté, ako vpred v pamäti, že veľa.

1265
01:18:31,820 --> 01:18:34,930
A teraz x + y nám dáva nejaký adresy,

1266
01:18:34,930 --> 01:18:37,570
a my dereferencia adresu alebo sledovať šípku

1267
01:18:37,570 --> 01:18:41,640
kde toto miesto v pamäti, je, a dostaneme hodnotu z tohto umiestnenia v pamäti.

1268
01:18:41,640 --> 01:18:43,720
Takže, takže tieto dva sú presne to isté.

1269
01:18:43,720 --> 01:18:45,840
Je to len syntaktickú cukor.

1270
01:18:45,840 --> 01:18:48,090
Oni robia rovnakú vec. Sú to len rôzne syntactics pre seba.

1271
01:18:51,500 --> 01:18:57,590
>> Takže, čo môže pokaziť s ukazovateľmi? Rovnako ako, veľa. Dobre. Takže, zlé veci.

1272
01:18:57,590 --> 01:19:02,410
Niektoré zlé veci, ktoré môžete urobiť, nie sú kontroly, či vaše malloc volanie vráti null, nie?

1273
01:19:02,410 --> 01:19:06,560
V tomto prípade, sa pýtam systém, aby mi - čo je to číslo?

1274
01:19:06,560 --> 01:19:11,200
Ako 2000000000 krát 4, pretože veľkosť celé číslo je 4 bajty.

1275
01:19:11,200 --> 01:19:13,810
Pýtam sa ho, ako 8000000000 bajtov.

1276
01:19:13,810 --> 01:19:17,270
Samozrejme môj počítač sa nebude môcť dať mi toľko pamäte späť.

1277
01:19:17,270 --> 01:19:20,960
A my sme to zistili, či ak to je null, takže keď sa snažíme dereferencia to tam -

1278
01:19:20,960 --> 01:19:24,270
sledovať šípku na miesto, kde to bude - nemáme, že pamäť.

1279
01:19:24,270 --> 01:19:27,150
To je to, čo nazývame dereferencing nulový ukazovateľ.

1280
01:19:27,150 --> 01:19:29,710
A to v podstate spôsobí, že sa segfault.

1281
01:19:29,710 --> 01:19:31,790
To je jeden zo spôsobov, ako si môžete segfault.

1282
01:19:34,090 --> 01:19:38,090
Ďalšie zlé veci, ktoré môžete urobiť - oh dobre.

1283
01:19:38,090 --> 01:19:40,650
To bolo dereferencing nulový ukazovateľ. Dobre.

1284
01:19:40,650 --> 01:19:45,160
Ďalšie zlé veci - dobre, opraviť, že ste práve dal šek tam

1285
01:19:45,160 --> 01:19:46,980
, Ktorý kontroluje, či je ukazovateľ null

1286
01:19:46,980 --> 01:19:51,000
a ukončite z programu, ak sa to stane, že malloc vracia nulový ukazovateľ.

1287
01:19:55,110 --> 01:19:59,850
To je xkcd komické. Ľudia pochopili to hneď. Tak nejako.

1288
01:20:06,120 --> 01:20:09,350
>> Tak, pamäť. A išiel som nad tým.

1289
01:20:09,350 --> 01:20:12,000
Sme volania malloc v slučke, ale zakaždým, keď hovoríme malloc

1290
01:20:12,000 --> 01:20:14,370
strácame prehľad o tom, kde tento ukazovateľ ukazuje na,

1291
01:20:14,370 --> 01:20:15,750
preto, že sme tresnúť ho.

1292
01:20:15,750 --> 01:20:18,410
Takže, počiatočné volanie malloc mi dáva pamäť tu.

1293
01:20:18,410 --> 01:20:19,990
Moje ukazovateľ ukazovatele na toto.

1294
01:20:19,990 --> 01:20:23,020
Teraz, nemám uvoľniť, takže teraz hovorím malloc znova.

1295
01:20:23,020 --> 01:20:26,070
Teraz to ukazuje tu. Teraz má pamäť ukazuje tu.

1296
01:20:26,070 --> 01:20:27,640
Polohovacie tu. Polohovacie tu.

1297
01:20:27,640 --> 01:20:31,820
Ale ja som stratil prehľad o adresách všetkých pamäti tamto, že som pridelená.

1298
01:20:31,820 --> 01:20:35,100
A tak teraz nemám žiadny odkaz na ne už.

1299
01:20:35,100 --> 01:20:37,230
Takže, nemôžem oslobodiť mimo tento slučky.

1300
01:20:37,230 --> 01:20:39,390
A tak za účelom stanovenia niečo také,

1301
01:20:39,390 --> 01:20:42,250
ak ste zabudli voľnej pamäte a získajte tento pretečeniu pamäte,

1302
01:20:42,250 --> 01:20:45,810
Musíte uvoľniť pamäť vo vnútri tejto slučky, akonáhle budete hotoví s ním.

1303
01:20:45,810 --> 01:20:51,400
No, to je to, čo sa stane. Viem, že veľa z vás neznášam.

1304
01:20:51,400 --> 01:20:55,270
Ale teraz - yay! Tu získate ako 44.000 KB.

1305
01:20:55,270 --> 01:20:57,110
Takže, vy uvoľniť, na konci slučky,

1306
01:20:57,110 --> 01:20:59,770
a že sa to jednoducho uvoľniť pamäť zakaždým.

1307
01:20:59,770 --> 01:21:03,620
V podstate, váš program nemá pretečeniu pamäte už.

1308
01:21:03,620 --> 01:21:08,150
>> A teraz niečo iné, čo môžete urobiť, je uvoľniť pamäť, ktorú ste žiadal dvakrát.

1309
01:21:08,150 --> 01:21:11,060
V tomto prípade je malloc niečo, zmeniť jeho hodnotu.

1310
01:21:11,060 --> 01:21:13,140
Môžete uvoľniť ho raz, pretože si hovoril, že sa s tým.

1311
01:21:13,140 --> 01:21:14,940
Ale potom sme oslobodení znovu.

1312
01:21:14,940 --> 01:21:16,730
To je niečo, čo je dosť zlé.

1313
01:21:16,730 --> 01:21:18,820
To nebude spočiatku segfault,

1314
01:21:18,820 --> 01:21:23,350
ale po chvíli, čo to robí, je dvojaký uvoľnenie tomuto korumpujú svoj haldy štruktúru,

1315
01:21:23,350 --> 01:21:27,200
a naučíte trochu viac o tom, ak sa rozhodnete vziať triedu ako CS61.

1316
01:21:27,200 --> 01:21:30,000
Ale v podstate po chvíli váš počítač bude zmiasť

1317
01:21:30,000 --> 01:21:33,010
o tom, čo pamäťové miesta sú tie, kde a kedy je to uložené -

1318
01:21:33,010 --> 01:21:34,800
, Kde sú údaje uložené v pamäti.

1319
01:21:34,800 --> 01:21:38,080
A tak uvoľnenie ukazovateľ dvakrát, je zlé, že nechcete robiť.

1320
01:21:38,080 --> 01:21:41,600
>> Ďalšie veci, ktoré sa môžu pokaziť nepoužíva sizeof.

1321
01:21:41,600 --> 01:21:44,460
Takže, v tomto prípade malloc 8 bajtov,

1322
01:21:44,460 --> 01:21:46,700
a to je to isté ako dve celé čísla, nie?

1323
01:21:46,700 --> 01:21:49,580
Tak, to je úplne bezpečné, ale je to?

1324
01:21:49,580 --> 01:21:52,160
No, ako Lucas hovoril o na rôznych architektúrach,

1325
01:21:52,160 --> 01:21:54,220
čísla sú rôznych dĺžok.

1326
01:21:54,220 --> 01:21:57,970
Takže, na zariadenia, ktoré používate, čísla sú asi 4 byty,

1327
01:21:57,970 --> 01:22:02,370
ale na nejakom inom systéme, ktoré by mohli byť 8 bajtov alebo by mohli byť 16 bytov.

1328
01:22:02,370 --> 01:22:05,680
Takže, ak som použiť toto číslo sem,

1329
01:22:05,680 --> 01:22:07,310
tento program by mohol pracovať na zariadenia,

1330
01:22:07,310 --> 01:22:10,360
ale to nebude alokovať dostatok pamäte na nejakom inom systéme.

1331
01:22:10,360 --> 01:22:14,020
V tomto prípade, je to, čo operátor sizeof sa používa.

1332
01:22:14,020 --> 01:22:16,880
Keď zavoláme sizeof (int), čo to robí, je

1333
01:22:16,880 --> 01:22:21,910
 to nám dáva veľkosť celé číslo v systéme, ktorý beží program.

1334
01:22:21,910 --> 01:22:25,490
Takže, v tomto prípade, bude sizeof (int) vráti 4 na niečo také zariadenia,

1335
01:22:25,490 --> 01:22:29,980
a teraz táto vôľa 4 * 2, čo je 8,

1336
01:22:29,980 --> 01:22:32,330
, Ktorý je len množstvo priestoru potrebné pre dvoch celých čísel.

1337
01:22:32,330 --> 01:22:36,710
Na inom systéme, ak int je ako 16 bajtov alebo 8 bajtov,

1338
01:22:36,710 --> 01:22:39,380
to len tak vrátiť dostatok bytov pre uloženie túto sumu.

1339
01:22:41,830 --> 01:22:45,310
>> A konečne, struct.

1340
01:22:45,310 --> 01:22:48,340
Takže, ak ste chceli uložiť sudoku dosku v pamäti, možno ako to urobíme?

1341
01:22:48,340 --> 01:22:51,570
Môžete si myslieť, zo ako premenné pre prvú vec,

1342
01:22:51,570 --> 01:22:53,820
premenná pre druhú vec, premenná pre tretiu vec,

1343
01:22:53,820 --> 01:22:56,420
premenná pre štvrté vec - zlý, nie?

1344
01:22:56,420 --> 01:23:00,750
Takže, jedna zlepšenie môžete vykonať na vrchole je to, aby sa 9 x 9 poľa.

1345
01:23:00,750 --> 01:23:04,480
To je v poriadku, ale čo keď ste chceli pridružiť aj iné veci s radou sudoku

1346
01:23:04,480 --> 01:23:06,490
ako to, čo obtiažnosť doske je,

1347
01:23:06,490 --> 01:23:11,740
alebo, napríklad, aké sú vaše skóre, alebo ako dlho to trvalo vám vyriešiť tento program?

1348
01:23:11,740 --> 01:23:14,970
No, čo môžete urobiť, je, že môžete vytvoriť struct.

1349
01:23:14,970 --> 01:23:18,910
Čo som v podstate hovorí, je, že som vymedzenie túto štruktúru tu,

1350
01:23:18,910 --> 01:23:23,230
a ja som definovanie sudoku doska, ktorá sa skladá z dosky, ktorá je 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> A to, čo má, že má ukazovateľ na meno úrovne.

1352
01:23:26,650 --> 01:23:30,730
Má tiež X a Y, ktoré sú súradnice, kde som teraz.

1353
01:23:30,730 --> 01:23:35,980
To má tiež čas strávený [nezrozumiteľný], a to má celkový počet ťahov som zadaných doteraz.

1354
01:23:35,980 --> 01:23:40,010
A tak v tomto prípade, môžem zoskupiť veľa dát do jediného štruktúry

1355
01:23:40,010 --> 01:23:42,790
namiesto toho, aby ju ako lietanie okolo ako rôzne premenné

1356
01:23:42,790 --> 01:23:44,540
že nemôžem sledovať.

1357
01:23:44,540 --> 01:23:49,720
A to nám umožňuje mať len peknú syntax pre druh odkazovanie rôzne veci vo vnútri tohto struct.

1358
01:23:49,720 --> 01:23:53,430
Ja si proste board.board, a mám sudoku dosku späť.

1359
01:23:53,430 --> 01:23:56,320
Board.level, som si, ako ťažké to je.

1360
01:23:56,320 --> 01:24:00,540
Board.x a board.y daj mi súradnice, kde by som mohol byť na doske.

1361
01:24:00,540 --> 01:24:04,730
A tak som prístup, čo nazývame pole v struct.

1362
01:24:04,730 --> 01:24:08,840
Toto definuje sudokuBoard, čo je typ, ktorý mám.

1363
01:24:08,840 --> 01:24:14,800
A teraz sme tu. Mám premennú s názvom "board" typu sudokuBoard.

1364
01:24:14,800 --> 01:24:18,820
A tak teraz môžem pristupovať všetky polia, ktorá tvorí túto štruktúru tu.

1365
01:24:20,830 --> 01:24:22,450
>> Akékoľvek otázky structs? Áno?

1366
01:24:22,450 --> 01:24:25,890
[Študent] Pre int x, y, ste vyhlásil obaja na jednom riadku? >> [Joseph] Uh-huh.

1367
01:24:25,890 --> 01:24:27,400
[Študent] Takže, mohol by si urobiť so všetkými z nich?

1368
01:24:27,400 --> 01:24:31,200
Rovnako ako v roku X, Y čiarka časy, že celkové?

1369
01:24:31,200 --> 01:24:34,460
[Joseph] Áno, mohol by ste určite urobiť, ale dôvod, prečo som dal x a y na rovnakom riadku -

1370
01:24:34,460 --> 01:24:36,330
a otázkou je, prečo môžeme len to na rovnakom riadku?

1371
01:24:36,330 --> 01:24:38,600
Prečo sme len dať všetky tieto na rovnakom riadku je

1372
01:24:38,600 --> 01:24:42,090
x a y sú vo vzájomnom vzťahu,

1373
01:24:42,090 --> 01:24:44,780
a je to len štylisticky presnejšie, v tom zmysle,

1374
01:24:44,780 --> 01:24:46,600
pretože je to zoskupenie dve veci na rovnakom riadku

1375
01:24:46,600 --> 01:24:49,340
že ako druh sa vzťahujú k rovnakej veci.

1376
01:24:49,340 --> 01:24:51,440
A ja jednoducho rozdeliť tieto od seba. Je to len štýl vec.

1377
01:24:51,440 --> 01:24:53,720
Je funkčne nie je rozdiel vôbec.

1378
01:24:58,150 --> 01:24:59,270
Akékoľvek ďalšie otázky týkajúce sa structs?

1379
01:25:03,030 --> 01:25:06,620
Môžete definovať Pokédex s struct.

1380
01:25:06,620 --> 01:25:11,720
Pokémon má svoje číslo a má list, vlastníka, typ.

1381
01:25:11,720 --> 01:25:16,990
A potom, ak máte pole Pokémon, môžete vytvoriť Pokédex, že jo?

1382
01:25:16,990 --> 01:25:20,810
Dobre, v pohode. Takže, otázky týkajúce sa structs. Tí, ktorí sú príbuzní k structs.

1383
01:25:20,810 --> 01:25:25,270
>> Konečne, GDB. Čo GDB nechať urobiť? To vám umožní ladiť svoj program.

1384
01:25:25,270 --> 01:25:27,650
A ak ste nepoužili GDB, by som odporučil sledovať krátke

1385
01:25:27,650 --> 01:25:31,250
a len tak nad tým, čo GDB je, ako s ním pracovať, ako by ste mohli použiť,

1386
01:25:31,250 --> 01:25:32,900
a vyskúšať na programe.

1387
01:25:32,900 --> 01:25:37,400
A tak to, čo GDB môžete urobiť, je, že umožňuje Pozastaviť [nezrozumiteľné] až do vášho programu

1388
01:25:37,400 --> 01:25:38,920
a praktické línie.

1389
01:25:38,920 --> 01:25:42,600
Napríklad, chcem pozastaviť plnenie v súlade ako 3 z môjho programu,

1390
01:25:42,600 --> 01:25:46,010
a keď som na riadku 3 môžem vytlačiť všetky hodnoty, ktoré sú tam.

1391
01:25:46,010 --> 01:25:49,710
A tak to, čo nazývame ako zastavil v rade

1392
01:25:49,710 --> 01:25:52,350
je nazývame uvedenie zarážku na tomto riadku

1393
01:25:52,350 --> 01:25:55,920
a potom môžeme vytlačiť premenné na stave programu v tej dobe.

1394
01:25:55,920 --> 01:25:58,990
>> Môžeme potom odtiaľ krokovať program riadok po riadku.

1395
01:25:58,990 --> 01:26:03,200
A potom sme sa pozrieť na stav zásobníka v tej dobe.

1396
01:26:03,200 --> 01:26:08,600
A tak aby bolo možné používať GDB, čo robíme, je hovoríme rinčanie na súbor C,

1397
01:26:08,600 --> 01:26:11,290
ale musíme odovzdať-ggdb vlajkou.

1398
01:26:11,290 --> 01:26:15,850
A akonáhle sme skončili s tým sme len spustiť gdb na výslednom výstupného súboru.

1399
01:26:15,850 --> 01:26:18,810
A tak si trochu ako hmotnosť textu ako je tento,

1400
01:26:18,810 --> 01:26:21,990
ale naozaj všetko, čo musíte urobiť, je zadať príkazy na začiatku.

1401
01:26:21,990 --> 01:26:24,250
Prestávka hlavné kladie zarážku na hlavnej.

1402
01:26:24,250 --> 01:26:28,470
Zoznam 400 uvádza riadky kódu okolo riadku 400.

1403
01:26:28,470 --> 01:26:31,410
A tak v tomto prípade stačí sa pozrieť okolo seba a povedať, oh,

1404
01:26:31,410 --> 01:26:34,360
Chcem nastaviť zarážku na riadku 397, ktorý je v tomto riadku,

1405
01:26:34,360 --> 01:26:37,170
a potom sa váš program beží do tohto kroku, a to rozbije.

1406
01:26:37,170 --> 01:26:41,120
Bude to pauze, a môžete tlačiť, napríklad, hodnota nízka alebo vysoká.

1407
01:26:41,120 --> 01:26:46,410
A tak tam sú banda príkazy, ktoré potrebujete vedieť,

1408
01:26:46,410 --> 01:26:48,660
a to slideshow bude stúpať na webových stránkach,

1409
01:26:48,660 --> 01:26:54,000
takže ak si len chcete odkazovať týchto alebo ako dať ich na svoje ťaháky, neváhajte.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. To bolo Quiz Review 0, a budeme držať okolo, ak máte nejaké 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]