1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [§ 6] [Další Komfortní]

2
00:00:01,000 --> 00:00:04,000
[Rob Bowden] [Harvard University]

3
00:00:04,000 --> 00:00:09,000
[To je CS50.] [CS50.TV]

4
00:00:09,000 --> 00:00:11,000
>> Můžeme zamířit do naší sekce otázek.

5
00:00:11,000 --> 00:00:17,000
Poslal jsem adresu URL pro prostor před.

6
00:00:17,000 --> 00:00:22,000
Začátek úseku otázek říct:

7
00:00:22,000 --> 00:00:26,000
zřejmě nejsem úplně unsick-je velmi jednoduchá otázka

8
00:00:26,000 --> 00:00:28,000
toho jen to, co je Valgrind?

9
00:00:28,000 --> 00:00:30,000
Co valgrind dělat?

10
00:00:30,000 --> 00:00:34,000
Každý, kdo chce říkat, co valgrind dělá?

11
00:00:34,000 --> 00:00:36,000
[Student] Kontrola memory leaks.

12
00:00:36,000 --> 00:00:41,000
Jo, valgrind je obecný paměti checker.

13
00:00:41,000 --> 00:00:44,000
To, na konci, vám řekne, pokud máte nějaké úniky paměti,

14
00:00:44,000 --> 00:00:49,000
což je většinou to, co jsme používat jej pro, protože pokud chcete

15
00:00:49,000 --> 00:00:54,000
dobře v problému sadě nebo chcete-li

16
00:00:54,000 --> 00:00:59,000
dostat na velkou tabuli, musíte mít žádné úniky paměti vůbec,

17
00:00:59,000 --> 00:01:01,000
a v případě, že máte nevracení paměti, že nemůžete najít,

18
00:01:01,000 --> 00:01:04,000
Také mějte na paměti, že vždy, když otevřete soubor

19
00:01:04,000 --> 00:01:07,000
a pokud nechcete zavřít, to je k nevracení paměti.

20
00:01:07,000 --> 00:01:10,000
>> Mnoho lidí, kteří hledají nějakou uzel že nejste uvolnění

21
00:01:10,000 --> 00:01:15,000
když ve skutečnosti, že neuzavřela slovník hned v prvním kroku.

22
00:01:15,000 --> 00:01:19,000
Také vám řekne, jestli máte nějaké neplatné čte nebo píše,

23
00:01:19,000 --> 00:01:22,000
což znamená, že pokud se pokusíte a nastavte hodnotu

24
00:01:22,000 --> 00:01:26,000
že je za konec haldy a není náhodou seg poruchy

25
00:01:26,000 --> 00:01:30,000
ale valgrind ji chytne, jako byste měli být skutečně psát tam,

26
00:01:30,000 --> 00:01:33,000
a proto byste rozhodně neměli mít žádné z nich jeden.

27
00:01:33,000 --> 00:01:38,000
Jak použít Valgrind?

28
00:01:38,000 --> 00:01:42,000
Jak použít Valgrind?

29
00:01:42,000 --> 00:01:45,000
>> Je to obecná otázka na

30
00:01:45,000 --> 00:01:49,000
druh spustit a podívat se na výstupu.

31
00:01:49,000 --> 00:01:51,000
Výstup je zaplaven mnohokrát.

32
00:01:51,000 --> 00:01:54,000
K dispozici je také zábavné chyby, kde, pokud máte nějaké hrozně špatnou věc

33
00:01:54,000 --> 00:01:59,000
děje ve smyčce, pak to bude nakonec říkat, "Way příliš mnoho chyb.

34
00:01:59,000 --> 00:02:03,000
Chystám se přestat počítat teď. "

35
00:02:03,000 --> 00:02:08,000
Je to v podstatě textová výstup, který budete muset analyzovat.

36
00:02:08,000 --> 00:02:13,000
Na konci, bude to vám žádné úniky paměti, že máte,

37
00:02:13,000 --> 00:02:16,000
kolik bloků, které mohou být užitečné, protože

38
00:02:16,000 --> 00:02:20,000
pokud je to jeden blok unfreed, pak je to obvykle snazší najít

39
00:02:20,000 --> 00:02:23,000
než 1000 bloků unfreed.

40
00:02:23,000 --> 00:02:26,000
1000 bloky unfreed pravděpodobně znamená, že nejste uvolnění

41
00:02:26,000 --> 00:02:30,000
propojené seznamy odpovídajícím způsobem, nebo tak něco.

42
00:02:30,000 --> 00:02:32,000
To je Valgrind.

43
00:02:32,000 --> 00:02:35,000
>> Nyní máme naši sekci otázek,

44
00:02:35,000 --> 00:02:38,000
které nemusíte stahovat.

45
00:02:38,000 --> 00:02:41,000
Můžete kliknout na mé jméno a vytáhněte je do prostoru.

46
00:02:41,000 --> 00:02:44,000
Nyní klikněte na mně.

47
00:02:44,000 --> 00:02:46,000
Revize 1 bude zásobník, který děláme jako první.

48
00:02:46,000 --> 00:02:55,000
Revize 2 bude fronta, a Revize 3 bude jednotlivě propojený seznam.

49
00:02:55,000 --> 00:02:58,000
Rozjezd s naší zásobníku.

50
00:02:58,000 --> 00:03:02,000
Jak se říká, že tady, zásobník je jedním z nejzákladnějších,

51
00:03:02,000 --> 00:03:07,000
Základní datové struktury informatiky.

52
00:03:07,000 --> 00:03:11,000
Velmi Typický příklad je

53
00:03:11,000 --> 00:03:13,000
stoh přihrádek v jídelně.

54
00:03:13,000 --> 00:03:16,000
Je to v podstatě vždy, když se zavádí do zásobníku,

55
00:03:16,000 --> 00:03:20,000
někdo říct, "Oh, jako hromada zásobníků."

56
00:03:20,000 --> 00:03:22,000
Můžete stohovat zásobníky se.

57
00:03:22,000 --> 00:03:24,000
Pak, když jdete na vytáhnout zásobník,

58
00:03:24,000 --> 00:03:31,000
první zásobník, který je dostat vytáhl je poslední, který byl uveden na stack.

59
00:03:31,000 --> 00:03:34,000
Stack i-jako to říká tady-

60
00:03:34,000 --> 00:03:37,000
máme segmentu paměti s názvem stack.

61
00:03:37,000 --> 00:03:40,000
A proč se tomu říká stack?

62
00:03:40,000 --> 00:03:42,000
>> Vzhledem k tomu, jako zásobníku datové struktury,

63
00:03:42,000 --> 00:03:46,000
to tlačí a objeví zásobníku rámečky na zásobníku,

64
00:03:46,000 --> 00:03:53,000
kde stack rámy jsou jako zvláštní volání funkce.

65
00:03:53,000 --> 00:03:57,000
A jako hromada, budete mít vždy vrátit

66
00:03:57,000 --> 00:04:03,000
z volání funkce dříve, než můžete dostat dolů do nižších zásobníku snímků znovu.

67
00:04:03,000 --> 00:04:08,000
Nemůžete mít hlavní hovoru foo blokování hovorů a bar vrátíte do hlavního přímo.

68
00:04:08,000 --> 00:04:14,000
Je to vždycky dodržet správný zásobník tlačí a praskání.

69
00:04:14,000 --> 00:04:18,000
Obě operace, jak jsem řekl, jsou tlak a pop.

70
00:04:18,000 --> 00:04:20,000
Ti jsou univerzální pojmy.

71
00:04:20,000 --> 00:04:26,000
Měli byste vědět, push a pop z hlediska komíny bez ohledu na to, co.

72
00:04:26,000 --> 00:04:28,000
Uvidíme fronty jsou trochu odlišné.

73
00:04:28,000 --> 00:04:32,000
To není opravdu univerzální termín, ale tlak a pop jsou univerzální pro komíny.

74
00:04:32,000 --> 00:04:34,000
Push jen dát na stack.

75
00:04:34,000 --> 00:04:37,000
Pop je sundat zásobníku.

76
00:04:37,000 --> 00:04:43,000
A zde vidíme máme typedef struct stoh,

77
00:04:43,000 --> 00:04:46,000
takže máme char ** řetězce.

78
00:04:46,000 --> 00:04:51,000
Nenechte se bojí žádnými **.

79
00:04:51,000 --> 00:04:54,000
To bude skončit pole řetězců

80
00:04:54,000 --> 00:04:58,000
nebo pole ukazatelů na znaky, kde

81
00:04:58,000 --> 00:05:00,000
ukazatele na znaky bývají řetězce.

82
00:05:00,000 --> 00:05:05,000
Nemusí to být řetězce, ale tady, oni budou mít řetězce.

83
00:05:05,000 --> 00:05:08,000
>> Máme pole řetězců.

84
00:05:08,000 --> 00:05:14,000
Máme velikost, která představuje, kolik prvky jsou v současné době na frontě,

85
00:05:14,000 --> 00:05:19,000
a pak máme kapacitu, což je, kolik prvků může být na zásobníku.

86
00:05:19,000 --> 00:05:22,000
Výkon by měl začít jako něco větší než 1,

87
00:05:22,000 --> 00:05:27,000
ale velikost bude začít jako 0.

88
00:05:27,000 --> 00:05:36,000
Nyní, tam jsou v podstatě tři různé způsoby, jak můžete myslet zásobníku.

89
00:05:36,000 --> 00:05:39,000
No, tam jsou pravděpodobně více, ale dva hlavní způsoby jsou

90
00:05:39,000 --> 00:05:43,000
můžete implementovat pomocí pole, nebo můžete implementovat pomocí spojového seznamu.

91
00:05:43,000 --> 00:05:48,000
Propojené seznamy jsou trochu triviální, aby se stohy z.

92
00:05:48,000 --> 00:05:51,000
Je velmi snadné, aby se stoh pomocí propojených seznamů,

93
00:05:51,000 --> 00:05:55,000
takže tady, budeme dělat hromadu pomocí matice,

94
00:05:55,000 --> 00:05:59,000
a pak pomocí polí, je tu také dva způsoby, jak si můžete myslet o tom.

95
00:05:59,000 --> 00:06:01,000
Předtím, když jsem řekl, máme kapacitu zásobníku,

96
00:06:01,000 --> 00:06:04,000
takže se vejde prvek na zásobníku.

97
00:06:04,000 --> 00:06:09,000
>> Jediný způsob, že by se mohlo stát, je, jakmile hit 10 prvků, pak jste udělal.

98
00:06:09,000 --> 00:06:13,000
Možná víte, že tam je horní hranice 10 věcí na světě

99
00:06:13,000 --> 00:06:16,000
že už nikdy nebudete muset více než 10 věcí, na vašeho stacku,

100
00:06:16,000 --> 00:06:20,000
V takovém případě můžete mít horní mez na velikosti vašeho stacku.

101
00:06:20,000 --> 00:06:23,000
Nebo můžete mít svůj stack být nespoutaný,

102
00:06:23,000 --> 00:06:27,000
ale pokud děláte pole, to znamená, že pokaždé trefíte 10 prvků,

103
00:06:27,000 --> 00:06:29,000
pak budete muset růst na 20 prvků, a když trefíte 20 prvků,

104
00:06:29,000 --> 00:06:33,000
budete muset pěstovat své pole na 30 prvků nebo 40 prvků.

105
00:06:33,000 --> 00:06:37,000
Budeš muset zvýšit kapacitu, což je to, co budeme dělat.

106
00:06:37,000 --> 00:06:40,000
Pokaždé jsme dosáhli maximální velikosti našeho stacku,

107
00:06:40,000 --> 00:06:46,000
když jsme se tlačit něco jiného na, budeme muset zvýšit kapacitu.

108
00:06:46,000 --> 00:06:50,000
Zde jsme tlačit prohlášeny za bool push (char * str).

109
00:06:50,000 --> 00:06:54,000
Char * str je řetězec, který jsme tlačí do fronty,

110
00:06:54,000 --> 00:06:58,000
a bool jen říká, jestli se nám to podařilo, nebo nepodařilo.

111
00:06:58,000 --> 00:07:00,000
>> Jak můžeme selhat?

112
00:07:00,000 --> 00:07:04,000
Jaká je pouze okolnost, že si můžete myslet

113
00:07:04,000 --> 00:07:07,000
kde bychom potřebovali vrátit false?

114
00:07:07,000 --> 00:07:09,000
Jo.

115
00:07:09,000 --> 00:07:12,000
[Student] Pokud je to plné a my jsme s použitím skákal implementace.

116
00:07:12,000 --> 00:07:17,000
Jo, tak jak definujeme-on odpověděl

117
00:07:17,000 --> 00:07:23,000
pokud je to plné a my jsme s použitím ohraničená implementace.

118
00:07:23,000 --> 00:07:26,000
Pak budeme určitě vrátí false.

119
00:07:26,000 --> 00:07:31,000
Jakmile jsme narazili 10 věcí v poli, můžeme nevejde 11, tak jsme se vrátit false.

120
00:07:31,000 --> 00:07:32,000
Co když to je neomezený? Jo.

121
00:07:32,000 --> 00:07:38,000
Pokud nemůžete rozbalit pole z nějakého důvodu.

122
00:07:38,000 --> 00:07:43,000
Jo, takže paměť je omezený zdroj,

123
00:07:43,000 --> 00:07:51,000
a nakonec, pokud budeme tlačit věci do fronty znovu a znovu,

124
00:07:51,000 --> 00:07:54,000
budeme se snažit a přidělit větší pole, aby se vešly

125
00:07:54,000 --> 00:07:59,000
větší kapacita, a malloc nebo co jsme pomocí se bude vracet false.

126
00:07:59,000 --> 00:08:02,000
No, bude malloc vrátí null.

127
00:08:02,000 --> 00:08:05,000
>> Pamatujte si, že pokaždé jste někdy volat malloc, měli byste být kontrola, zda je

128
00:08:05,000 --> 00:08:12,000
vrací null, jinak že je správnost odpočet.

129
00:08:12,000 --> 00:08:17,000
Protože chceme mít neomezenou stack,

130
00:08:17,000 --> 00:08:21,000
jediný případ, budeme se vracet false, je když se budeme snažit

131
00:08:21,000 --> 00:08:26,000
zvýšení kapacity a malloc nebo cokoliv vrátí false.

132
00:08:26,000 --> 00:08:30,000
Pak pop neakceptuje žádné argumenty,

133
00:08:30,000 --> 00:08:37,000
a vrátí řetězec, který je na vrcholu zásobníku.

134
00:08:37,000 --> 00:08:41,000
Ať už to bylo naposledy tlačil do fronty je to, co pop se vrací,

135
00:08:41,000 --> 00:08:44,000
a také ji odstraní ze zásobníku.

136
00:08:44,000 --> 00:08:50,000
A všimněte si, že se vrátí hodnotu null, pokud není nic na stacku.

137
00:08:50,000 --> 00:08:53,000
Je vždy možné, že zásobník je prázdný.

138
00:08:53,000 --> 00:08:55,000
V Javě, pokud jste zvyklí na to, nebo jiných jazyků,

139
00:08:55,000 --> 00:09:01,000
snaží se pop z prázdného zásobníku může způsobit výjimku nebo tak něco.

140
00:09:01,000 --> 00:09:09,000
>> Ale v C, null je tak trochu z mnoha případů, jak vyřizujeme tyto problémy.

141
00:09:09,000 --> 00:09:13,000
Vracet null je, jak budeme znamenat, že zásobník je prázdný.

142
00:09:13,000 --> 00:09:16,000
Připravili jsme kód, který bude testovat svůj stack funkčnost,

143
00:09:16,000 --> 00:09:19,000
provádět tlačit a pop.

144
00:09:19,000 --> 00:09:23,000
To nebude mnoho kódu.

145
00:09:23,000 --> 00:09:40,000
Budu-vlastně, než to uděláme, náznak, náznak-

146
00:09:40,000 --> 00:09:44,000
pokud jste ho ještě neviděli, malloc není jediná funkce,

147
00:09:44,000 --> 00:09:47,000
, která přiděluje paměť na haldě pro vás.

148
00:09:47,000 --> 00:09:51,000
Existuje rodina Alloc funkcí.

149
00:09:51,000 --> 00:09:53,000
První z nich je malloc, který jste zvyklí.

150
00:09:53,000 --> 00:09:56,000
Pak je tu calloc, který dělá to samé jako malloc,

151
00:09:56,000 --> 00:09:59,000
ale to bude nulu vše za vás.

152
00:09:59,000 --> 00:10:04,000
Pokud jste někdy chtěli nastavit vše na nulu po mallocing něco

153
00:10:04,000 --> 00:10:06,000
měli byste se právě používá calloc v první řadě místo psaní

154
00:10:06,000 --> 00:10:09,000
pro smyčce propadl se na celý blok paměti.

155
00:10:09,000 --> 00:10:15,000
>> Realloc je jako malloc a má spoustu zvláštních případech,

156
00:10:15,000 --> 00:10:19,000
ale v podstatě to, co dělá, je realloc

157
00:10:19,000 --> 00:10:24,000
to trvá ukazatel, který již byla přidělena.

158
00:10:24,000 --> 00:10:27,000
Realloc je funkce, kterou chcete platit pozornost zde.

159
00:10:27,000 --> 00:10:31,000
To trvá ukazatel, který již vrátil z malloc.

160
00:10:31,000 --> 00:10:35,000
Řekněme, že jste požádat malloc ukazatel na 10 bajtů.

161
00:10:35,000 --> 00:10:38,000
Později si uvědomíte, že jste chtěli 20 bajtů,

162
00:10:38,000 --> 00:10:42,000
takže volat realloc na tomto ukazateli s 20 bajtů,

163
00:10:42,000 --> 00:10:47,000
a realloc automaticky zkopírovat vše, co pro vás.

164
00:10:47,000 --> 00:10:51,000
Pokud jste právě volal malloc znovu, jako bych měl blok 10 bajtů.

165
00:10:51,000 --> 00:10:53,000
Teď potřebuji blok 20 bytů,

166
00:10:53,000 --> 00:10:58,000
takže když jsem malloc 20 bajtů, pak musím ručně zkopírovat do 10 bajtů z prvních věcí,

167
00:10:58,000 --> 00:11:01,000
do druhé věci a pak bez první věc.

168
00:11:01,000 --> 00:11:04,000
Realloc se bude zabývat, že pro vás.

169
00:11:04,000 --> 00:11:11,000
>> Všimněte si, že podpis bude void *,

170
00:11:11,000 --> 00:11:15,000
který je jen vrací ukazatel na blok paměti,

171
00:11:15,000 --> 00:11:17,000
pak void * ptr.

172
00:11:17,000 --> 00:11:22,000
Můžete si myslet void * jako obecný ukazatel.

173
00:11:22,000 --> 00:11:27,000
Obecně platí, že nikdy řešit void *,

174
00:11:27,000 --> 00:11:30,000
ale malloc vrací void *, a pak je to jen použít jako

175
00:11:30,000 --> 00:11:34,000
to vlastně bude char *.

176
00:11:34,000 --> 00:11:37,000
Předchozí void *, který byl vrácen malloc

177
00:11:37,000 --> 00:11:41,000
nyní bude předán realloc, a pak se velikost

178
00:11:41,000 --> 00:11:49,000
je nový počet bajtů, které chcete přidělit, takže vaše nová kapacita.

179
00:11:49,000 --> 00:11:57,000
Dám vám pár minut, a to v našem prostoru.

180
00:11:57,000 --> 00:12:02,000
Začněte s revize 1.

181
00:12:16,000 --> 00:12:21,000
Zastavím tě po snad o dost času provést Push,

182
00:12:21,000 --> 00:12:24,000
a pak ti dám další přestávku dělat pop.

183
00:12:24,000 --> 00:12:27,000
Ale to opravdu není tolik kód vůbec.

184
00:12:27,000 --> 00:12:35,000
Nejvíce kód je pravděpodobně rozšiřuje věci, rozšíření kapacity.

185
00:12:35,000 --> 00:12:39,000
Dobře, žádný tlak, aby se úplně hotový,

186
00:12:39,000 --> 00:12:47,000
ale tak dlouho, jak se cítíte, jako že jste na správné cestě, to je dobrý.

187
00:12:47,000 --> 00:12:53,000
>> Má někdo nějaký kód se cítí dobře s mým vytažení?

188
00:12:53,000 --> 00:12:59,000
Jo, budu, ale má někdo nějaké kód, který jsem si vytáhnout nahoru?

189
00:12:59,000 --> 00:13:05,000
Dobře, můžete začít, uložit ji, ať je to cokoli?

190
00:13:05,000 --> 00:13:09,000
Vždycky zapomenu, že krok.

191
00:13:09,000 --> 00:13:15,000
Dobře, při pohledu na tlak,

192
00:13:15,000 --> 00:13:18,000
chceš vysvětlit svůj kód?

193
00:13:18,000 --> 00:13:24,000
[Student] Za prvé, jsem zvětšil velikost.

194
00:13:24,000 --> 00:13:28,000
Myslím, že bych snad měla mít, že-stejně, jsem zvětšil velikost,

195
00:13:28,000 --> 00:13:31,000
a vidím, jestli je to méně, než je kapacita.

196
00:13:31,000 --> 00:13:36,000
A pokud je to méně, než je kapacita, přidám do pole, že již máme.

197
00:13:36,000 --> 00:13:42,000
A pokud to není, jsem vynásobte kapacitu 2,

198
00:13:42,000 --> 00:13:50,000
a já přerozdělit řetězce pole, aby něco s větší kapacitou velikosti nyní.

199
00:13:50,000 --> 00:13:55,000
A pak, pokud se to nepodaří, řeknu uživatele a vrátí false,

200
00:13:55,000 --> 00:14:04,000
a pokud je to v pořádku, pak jsem dal řetězec v novém místě.

201
00:14:04,000 --> 00:14:07,000
>> [Rob B.] Také si všimněte, že jsme použili pěkný bitovou operátor zde

202
00:14:07,000 --> 00:14:09,000
vynásobit 2.

203
00:14:09,000 --> 00:14:11,000
Nezapomeňte, posun doleva se vždycky se vynásobí 2.

204
00:14:11,000 --> 00:14:15,000
Právo posun je rozdělen 2 tak dlouho, jak si vzpomenete, že to znamená,

205
00:14:15,000 --> 00:14:18,000
vydělte 2 jako v celé číslo děleno 2.

206
00:14:18,000 --> 00:14:20,000
To by mohlo zkrátit na 1 zde nebo tam.

207
00:14:20,000 --> 00:14:26,000
Ale posun doleva o 1 je vždycky třeba vynásobit 2,

208
00:14:26,000 --> 00:14:32,000
pokud přetečení hranice na celé číslo, a pak to nebude.

209
00:14:32,000 --> 00:14:34,000
Strana komentář.

210
00:14:34,000 --> 00:14:39,000
Rád dělám-to nebude měnit kódování jakýmkoliv způsobem,

211
00:14:39,000 --> 00:14:48,000
ale já bych něco takového dělat.

212
00:14:48,000 --> 00:14:51,000
Je to vlastně bude dělat to mírně delší.

213
00:15:04,000 --> 00:15:08,000
Možná to není ideální případ pro zobrazení této,

214
00:15:08,000 --> 00:15:14,000
ale já bych segmentu do těchto bloků-

215
00:15:14,000 --> 00:15:17,000
v pořádku, pokud tuto možnost, pokud se stane, a pak budu dělat něco,

216
00:15:17,000 --> 00:15:19,000
a pak se provádí funkce.

217
00:15:19,000 --> 00:15:22,000
Nepotřebuju, aby potom přejděte oči celou cestu dolů funkci

218
00:15:22,000 --> 00:15:25,000
vidět, co se stane po ostatnímu.

219
00:15:25,000 --> 00:15:27,000
Je to v případě, že pokud se stane, a pak jsem se vrátit.

220
00:15:27,000 --> 00:15:30,000
To také má pěkný výhodu všeho, nad tento rámec

221
00:15:30,000 --> 00:15:33,000
je nyní posunula ještě jednou doleva.

222
00:15:33,000 --> 00:15:40,000
Já už třeba, pokud jste někdy v blízkosti směšně dlouhý vedení,

223
00:15:40,000 --> 00:15:45,000
pak ty 4 bytů mohou pomoci, a také více vlevo je něco,

224
00:15:45,000 --> 00:15:48,000
méně ohromen se cítili, kdyby chtěli, v pořádku, musím si pamatovat

225
00:15:48,000 --> 00:15:53,000
Jsem v současné době v cyklu while uvnitř z jiného uvnitř smyčky for.

226
00:15:53,000 --> 00:15:58,000
Kdekoliv si můžete udělat toto daňové přiznání okamžitě, jsem něco jako.

227
00:15:58,000 --> 00:16:05,000
Je zcela volitelné a není v žádném případě očekávat.

228
00:16:05,000 --> 00:16:12,000
>> [Student] Měl by být velikost - v nepovede stavu?

229
00:16:12,000 --> 00:16:19,000
Poruchám podmínka je zde jsme nedokázali realloc, takže ano.

230
00:16:19,000 --> 00:16:22,000
Všimněte si, jak v nevyhovění stavu, pravděpodobně,

231
00:16:22,000 --> 00:16:26,000
pokud jsme volní věci později, budeme vždycky selhání

232
00:16:26,000 --> 00:16:29,000
bez ohledu na to, kolikrát se snažíme tlačit něco.

233
00:16:29,000 --> 00:16:32,000
Pokud budeme neustále tlačí, držíme increment velikosti,

234
00:16:32,000 --> 00:16:36,000
i když jsme se, že uvedení nic do zásobníku.

235
00:16:36,000 --> 00:16:39,000
Obvykle nemáme zvýšíte velikost až

236
00:16:39,000 --> 00:16:43,000
poté, co jsme úspěšně ji na zásobníku.

237
00:16:43,000 --> 00:16:50,000
Udělali bychom to, řekněme, buď tady a tady.

238
00:16:50,000 --> 00:16:56,000
A pak místo toho řekl s.size ≤ kapacitu, je to méně, než kapacita,

239
00:16:56,000 --> 00:17:01,000
jen proto, že jsme se přestěhovali, kde bylo všechno.

240
00:17:01,000 --> 00:17:07,000
>> A pamatujte, jediné místo, které bychom mohli případně vrátit false

241
00:17:07,000 --> 00:17:14,000
je tady, kde realloc vrátil null,

242
00:17:14,000 --> 00:17:19,000
a pokud jste náhodou na paměti standardní chyby,

243
00:17:19,000 --> 00:17:22,000
Možná byste mohli zvážit tento případ, kdy chcete vytisknout standardní chybu,

244
00:17:22,000 --> 00:17:26,000
tak fprintf stderr, ne jen tisknout přímo na standardní výstup.

245
00:17:26,000 --> 00:17:31,000
Opět, to není očekávání, ale pokud je to chyba,

246
00:17:31,000 --> 00:17:41,000
zadejte printf, pak budete chtít, aby se vytisklo na standardní chybový místo standardní výstup.

247
00:17:41,000 --> 00:17:44,000
>> Každý, kdo má něco jiného všimnout? Ano.

248
00:17:44,000 --> 00:17:47,000
[Student] Můžeš jít přes [neslyšitelnou]?

249
00:17:47,000 --> 00:17:55,000
[Rob B.] Ano, skutečná binariness to, nebo jen to, co to je?

250
00:17:55,000 --> 00:17:57,000
[Student] Takže vynásobte ji 2?

251
00:17:57,000 --> 00:17:59,000
[Rob B.] Jo, v podstatě.

252
00:17:59,000 --> 00:18:11,000
V binárním zemi, vždy máme sadu číslic.

253
00:18:11,000 --> 00:18:22,000
Přesun tento levé do 1 podstatě vloží jej sem na pravé straně.

254
00:18:22,000 --> 00:18:25,000
Zpět na toto, jen připomenutí, že vše, co v binární

255
00:18:25,000 --> 00:18:28,000
je síla 2, tak to představuje 2 na 0,

256
00:18:28,000 --> 00:18:30,000
to 2 na 1, to 2 na 2.

257
00:18:30,000 --> 00:18:33,000
Vložením 0 na pravé straně hned, jen jsme posun již všechno.

258
00:18:33,000 --> 00:18:38,000
Co se tehdy 2 k 0 je nyní 2 k 1, je 2 na 2.

259
00:18:38,000 --> 00:18:41,000
Na pravé straně, které jsme vložen

260
00:18:41,000 --> 00:18:44,000
je nutně bude 0,

261
00:18:44,000 --> 00:18:46,000
který dává smysl.

262
00:18:46,000 --> 00:18:49,000
Pokud jste někdy násobit číslo 2, nebude to skončit lichý,

263
00:18:49,000 --> 00:18:54,000
tak 2 k 0 místě by měla být 0,

264
00:18:54,000 --> 00:18:59,000
a to je to, co jsem napůl varoval předtím, je, pokud to náhodou posunout

265
00:18:59,000 --> 00:19:01,000
za počet bitů v celé číslo,

266
00:19:01,000 --> 00:19:04,000
pak 1 skončí až bude pryč.

267
00:19:04,000 --> 00:19:10,000
To je jediná starost, pokud se stalo, že se jednání s opravdu velkými kapacitami.

268
00:19:10,000 --> 00:19:15,000
Ale v tomto bodě, pak máte co do činění s řadou miliard věcí,

269
00:19:15,000 --> 00:19:25,000
které se nemusí vejít do paměti stejně.

270
00:19:25,000 --> 00:19:31,000
>> Nyní se dostaneme k popu, který je ještě jednodušší.

271
00:19:31,000 --> 00:19:36,000
Dalo by se to udělat jako, pokud jste náhodou pop spoustu,

272
00:19:36,000 --> 00:19:38,000
a teď jsi na poloviční kapacitu znovu.

273
00:19:38,000 --> 00:19:42,000
Dalo by se realloc zmenšit množství paměti máte,

274
00:19:42,000 --> 00:19:47,000
ale nemusíte se bát, že, takže jen realloc případ bude

275
00:19:47,000 --> 00:19:50,000
rostoucí paměti, nikdy zmenšuje paměť,

276
00:19:50,000 --> 00:19:59,000
která se chystá udělat pop super snadné.

277
00:19:59,000 --> 00:20:02,000
Nyní fronty, které se chystáte být jako komíny,

278
00:20:02,000 --> 00:20:06,000
ale pořadí, které budete mít věci se obrátí.

279
00:20:06,000 --> 00:20:10,000
Typický příklad fronty je linka,

280
00:20:10,000 --> 00:20:12,000
takže myslím, že pokud jste byli English, bych řekl,

281
00:20:12,000 --> 00:20:17,000
typický příklad fronty je fronta.

282
00:20:17,000 --> 00:20:22,000
Tak jako čáry, pokud jste první člověk v souladu,

283
00:20:22,000 --> 00:20:24,000
vy očekávat, že bude první osoba z řady.

284
00:20:24,000 --> 00:20:31,000
Pokud jste poslední osoba v souladu, se bude poslední, kdo opravit.

285
00:20:31,000 --> 00:20:35,000
Říkáme, že FIFO vzorec, vzhledem k tomu, zásobník byl LIFO vzorec.

286
00:20:35,000 --> 00:20:40,000
Tato slova jsou velmi univerzální.

287
00:20:40,000 --> 00:20:46,000
>> Stejně jako zásobníky a na rozdíl od polí, fronty obvykle neumožňují přístup k prvkům ve středu.

288
00:20:46,000 --> 00:20:50,000
Zde, zásobník, máme tlak a pop.

289
00:20:50,000 --> 00:20:54,000
Zde jsme náhodou volali jim Zařadí a dequeue.

290
00:20:54,000 --> 00:20:58,000
Také jsem slyšel jen posun a unshift.

291
00:20:58,000 --> 00:21:02,000
Slyšel jsem lidi říkat tlak a pop také použít do front.

292
00:21:02,000 --> 00:21:05,000
Slyšel jsem vložit, odstranit,

293
00:21:05,000 --> 00:21:11,000
tak tlačit a pop, když mluvíte o komíny, se tlačí a objevovat.

294
00:21:11,000 --> 00:21:16,000
Pokud mluvíte o front, můžete vybrat slova, která chcete použít

295
00:21:16,000 --> 00:21:23,000
pro vložení a vyjmutí, a tam je žádný konsensus o tom, co by mělo být nazýván.

296
00:21:23,000 --> 00:21:27,000
Ale tady máme Zařadí a dequeue.

297
00:21:27,000 --> 00:21:37,000
Nyní, struct vypadá téměř shodný s zásobníku struct.

298
00:21:37,000 --> 00:21:40,000
Ale musíme sledovat hlavy.

299
00:21:40,000 --> 00:21:44,000
Myslím, že to říká tady, ale proč potřebujeme hlavu?

300
00:21:53,000 --> 00:21:57,000
Prototypy jsou v podstatě totožné s tlačit a pop.

301
00:21:57,000 --> 00:21:59,000
Můžete si ji představit jako push a pop.

302
00:21:59,000 --> 00:22:08,000
Jediný rozdíl je pop se vrací-místo posledního, to se vrací jako první.

303
00:22:08,000 --> 00:22:12,000
2, 1, 3, 4, nebo něco.

304
00:22:12,000 --> 00:22:14,000
A tady je začátek.

305
00:22:14,000 --> 00:22:17,000
Naše fronta je zcela plná, takže to čtyři elementy v něm.

306
00:22:17,000 --> 00:22:21,000
Konec naší fronty je v současné době 2,

307
00:22:21,000 --> 00:22:24,000
a teď jdeme vložit něco jiného.

308
00:22:24,000 --> 00:22:29,000
>> Když chceme vložit, aby něco jiného, ​​co jsme udělali pro zásobníku verzi

309
00:22:29,000 --> 00:22:36,000
je, že jsme rozšířili naši blok paměti.

310
00:22:36,000 --> 00:22:40,000
V čem je problém s tím?

311
00:22:40,000 --> 00:22:45,000
[Student] Přesunete 2.

312
00:22:45,000 --> 00:22:51,000
Co jsem říkal o konci fronty,

313
00:22:51,000 --> 00:22:57,000
to nedává smysl, že začneme na 1,

314
00:22:57,000 --> 00:23:01,000
pak chceme Dequeue 1, pak Dequeue 3, pak Dequeue 4,

315
00:23:01,000 --> 00:23:05,000
pak Dequeue 2, pak dequeue tuhle.

316
00:23:05,000 --> 00:23:08,000
Nemůžeme použít realloc teď,

317
00:23:08,000 --> 00:23:11,000
nebo přinejmenším, budete muset použít realloc jiným způsobem.

318
00:23:11,000 --> 00:23:15,000
Ale pravděpodobně by neměl používat realloc.

319
00:23:15,000 --> 00:23:18,000
Budete muset ručně zkopírovat svou paměť.

320
00:23:18,000 --> 00:23:21,000
>> Existují dvě funkce pro kopírování paměti.

321
00:23:21,000 --> 00:23:25,000
Je tu memcopy a memmove.

322
00:23:25,000 --> 00:23:29,000
Já jsem v současné době čtení manuálové stránky vidět, který z nich budete chtít použít.

323
00:23:29,000 --> 00:23:35,000
Dobře, memcopy, rozdíl je

324
00:23:35,000 --> 00:23:38,000
že memcopy a memmove, jeden se stará o věci správně

325
00:23:38,000 --> 00:23:41,000
kam kopírování do oblasti, která se stane překrývat oblast

326
00:23:41,000 --> 00:23:46,000
kopírujete z.

327
00:23:46,000 --> 00:23:50,000
Memcopy nezpracovává ji. Memmove dělá.

328
00:23:50,000 --> 00:23:59,000
Můžete myslet na problém jako-

329
00:23:59,000 --> 00:24:09,000
řekněme, že chci kopírovat toho chlapa,

330
00:24:09,000 --> 00:24:13,000
tito čtyři s tímhle chlapem přes.

331
00:24:13,000 --> 00:24:16,000
Na konci, co pole by měl vypadat

332
00:24:16,000 --> 00:24:26,000
Po kopírování je 2, 1, 2, 1, 3, 4, a pak některé věci na konci.

333
00:24:26,000 --> 00:24:29,000
To je však závisí na pořadí, ve kterém se vlastně kopírovat,

334
00:24:29,000 --> 00:24:32,000
protože pokud se neberou v úvahu skutečnost, že region jsme kopírování do

335
00:24:32,000 --> 00:24:35,000
překrývá ten jsme kopírování,

336
00:24:35,000 --> 00:24:46,000
pak bychom mohli udělat jako začátek tady, zkopírujte 2 do místa chceme jít,

337
00:24:46,000 --> 00:24:52,000
pak se přesunout naše ukazatele vpřed.

338
00:24:52,000 --> 00:24:56,000
>> Teď budeme mít tady a tady, a teď chceme kopírovat

339
00:24:56,000 --> 00:25:04,000
tenhle chlap nad tímhle chlápkem a přesunout naše ukazatele vpřed.

340
00:25:04,000 --> 00:25:07,000
Co budeme nakonec dostat je 2, 1, 2, 1, 2, 1

341
00:25:07,000 --> 00:25:10,000
místo odpovídající 2, 1, 2, 1, 3, 4, protože

342
00:25:10,000 --> 00:25:15,000
2, 1 přehlasovala původní 3, 4.

343
00:25:15,000 --> 00:25:19,000
Memmove úchyty, které správně.

344
00:25:19,000 --> 00:25:23,000
V tomto případě, v podstatě jen vždy memmove

345
00:25:23,000 --> 00:25:26,000
protože zpracovává správně.

346
00:25:26,000 --> 00:25:29,000
To obvykle neprovádí žádné horší.

347
00:25:29,000 --> 00:25:32,000
Myšlenka je místo od začátku a kopírování tímto způsobem

348
00:25:32,000 --> 00:25:35,000
jako jsme právě udělali tady, začíná od konce, a kopíruje,

349
00:25:35,000 --> 00:25:38,000
a v tomto případě, můžete mít nikdy problém.

350
00:25:38,000 --> 00:25:40,000
Neexistuje žádný výkon ztracena.

351
00:25:40,000 --> 00:25:47,000
Vždy používejte memmove. Nikdy starosti memcopy.

352
00:25:47,000 --> 00:25:51,000
A to je místo, kde budete muset zvlášť memmove

353
00:25:51,000 --> 00:26:01,000
zabalené-kolem část vaší frontě.

354
00:26:01,000 --> 00:26:04,000
Žádné starosti, pokud není zcela hotový.

355
00:26:04,000 --> 00:26:10,000
To je obtížnější, než zásobník, tlačení, a pop.

356
00:26:10,000 --> 00:26:15,000
>> Každý, kdo má jakýkoli kód, který jsme mohli pracovat s?

357
00:26:15,000 --> 00:26:21,000
I když úplně neúplné?

358
00:26:21,000 --> 00:26:23,000
[Student] Jo, je to úplně neúplné, ačkoli.

359
00:26:23,000 --> 00:26:27,000
Zcela neúplný je v pořádku, tak dlouho, jak budeme-můžete uložit revizi?

360
00:26:27,000 --> 00:26:32,000
Zapomněl jsem, že každý jednotlivý čas.

361
00:26:32,000 --> 00:26:39,000
Dobře, ignoruje, co se stane, když potřebujeme změnit velikost věci.

362
00:26:39,000 --> 00:26:42,000
Zcela ignorovat Resize.

363
00:26:42,000 --> 00:26:49,000
Vysvětlete tento kód.

364
00:26:49,000 --> 00:26:54,000
Jsem kontrolu v první řadě v případě, že je velikost menší než kopie první řadě

365
00:26:54,000 --> 00:27:01,000
a pak po tom, mám vložit-beru hlavu + velikost,

366
00:27:01,000 --> 00:27:05,000
a mohu ujistit, že se zalomí kolem kapacita pole,

367
00:27:05,000 --> 00:27:08,000
a mám vložit nový řetězec na této pozici.

368
00:27:08,000 --> 00:27:12,000
Pak jsem zvětšit velikost a vrátí true.

369
00:27:12,000 --> 00:27:22,000
>> [Rob B.] To je určitě jeden z těch případů, kdy budete chtít používat mod.

370
00:27:22,000 --> 00:27:25,000
Jakékoliv případě, kdy jste si obal kolem, pokud si myslíte, že obal kolem,

371
00:27:25,000 --> 00:27:29,000
bezprostřední myšlenka by měla být mod.

372
00:27:29,000 --> 00:27:36,000
Jako rychlý optimalizace / váš kód jeden řádek kratší,

373
00:27:36,000 --> 00:27:42,000
Všimněte si, že řádek bezprostředně po tohohle

374
00:27:42,000 --> 00:27:53,000
je pouze velikost + +, takže je sloučit, aby do tohoto řádku, velikost + +.

375
00:27:53,000 --> 00:27:58,000
Teď tady máme případ

376
00:27:58,000 --> 00:28:01,000
kde nemáme dostatek paměti,

377
00:28:01,000 --> 00:28:05,000
takže jsme se zvýšit naše kapacity 2.

378
00:28:05,000 --> 00:28:09,000
Myslím, že byste mohli mít stejný problém tady, ale můžeme ignorovat to teď,

379
00:28:09,000 --> 00:28:13,000
kde, pokud se vám nepodařilo zvýšit svou schopnost,

380
00:28:13,000 --> 00:28:18,000
pak budete chtít snížit kapacitu 2 znovu.

381
00:28:18,000 --> 00:28:24,000
Další krátká poznámka je, stejně jako vy můžete udělat + =,

382
00:28:24,000 --> 00:28:30,000
můžete také udělat << =.

383
00:28:30,000 --> 00:28:43,000
Téměř vše může jít před rovná, + =, | =, & =, << =.

384
00:28:43,000 --> 00:28:52,000
Char * new je náš nový blok paměti.

385
00:28:52,000 --> 00:28:55,000
Oh, tady.

386
00:28:55,000 --> 00:29:02,000
>> Co si lidé myslí o typu našeho nového bloku paměti?

387
00:29:02,000 --> 00:29:06,000
[Student] To by mělo být char **.

388
00:29:06,000 --> 00:29:12,000
Myšlení zpět k našemu struct sem,

389
00:29:12,000 --> 00:29:14,000
Řetězce je to, co jsme přerozdělení.

390
00:29:14,000 --> 00:29:21,000
Děláme celou novou dynamické úložiště pro prvky ve frontě.

391
00:29:21,000 --> 00:29:25,000
Co budeme se zařazování na seznam řetězců je to, co jsme mallocing teď,

392
00:29:25,000 --> 00:29:30,000
a tak nové bude char **.

393
00:29:30,000 --> 00:29:34,000
Je to bude pole řetězců.

394
00:29:34,000 --> 00:29:38,000
Tak co je tomu v případě, který se budeme vracet false?

395
00:29:38,000 --> 00:29:41,000
[Student] Měli bychom dělat char *?

396
00:29:41,000 --> 00:29:44,000
[Rob B.] Ano, dobrý nápad.

397
00:29:44,000 --> 00:29:46,000
[Student] Co to bylo?

398
00:29:46,000 --> 00:29:49,000
[Rob B.] Chtěli jsme udělat velikost char *, protože jsme již-

399
00:29:49,000 --> 00:29:53,000
To by ve skutečnosti bylo velmi velký problém, protože sizeof (char) bude 1.

400
00:29:53,000 --> 00:29:55,000
Sizeof char * bude 4,

401
00:29:55,000 --> 00:29:58,000
takže hodně krát, když máte co do činění s ints,

402
00:29:58,000 --> 00:30:01,000
máte tendenci se dostat pryč s ním, protože velikost int a velikosti int *

403
00:30:01,000 --> 00:30:04,000
na 32-bitovém systému se bude totéž.

404
00:30:04,000 --> 00:30:09,000
Ale tady, sizeof (char) a sizeof (char *) jsou nyní bude totéž.

405
00:30:09,000 --> 00:30:15,000
>> Co je okolnost, kdy se vrátíme false?

406
00:30:15,000 --> 00:30:17,000
[Student] Nové je null.

407
00:30:17,000 --> 00:30:23,000
Jo, když nový je null, vracíme false,

408
00:30:23,000 --> 00:30:34,000
a já jdu hodit tady-

409
00:30:34,000 --> 00:30:37,000
[Student] [neslyšitelné]

410
00:30:37,000 --> 00:30:39,000
[Rob B.] Jo, to je v pořádku.

411
00:30:39,000 --> 00:30:46,000
Dalo by se buď udělat 2 krát kapacity nebo kapacity shift 1 a pak jen nastavit to sem, nebo co.

412
00:30:46,000 --> 00:30:52,000
Uděláme to, jak jsme to.

413
00:30:52,000 --> 00:30:56,000
Kapacita >> = 1.

414
00:30:56,000 --> 00:31:08,000
A už nikdy muset obávat, že 1 je místo

415
00:31:08,000 --> 00:31:12,000
protože jsi odešel posunuty o 1, takže se 1 místo je nutně 0,

416
00:31:12,000 --> 00:31:16,000
tak správně řazení o 1, jste stále bude v pořádku.

417
00:31:16,000 --> 00:31:19,000
[Student] Potřebujete si udělat před návratem?

418
00:31:19,000 --> 00:31:29,000
[Rob B.] Ano, to je absolutně žádný smysl.

419
00:31:29,000 --> 00:31:36,000
>> Nyní předpokládejme, že budeme nakonec vrací hodnotu true do konce.

420
00:31:36,000 --> 00:31:39,000
Způsob, jakým budeme dělat tyto memmoves,

421
00:31:39,000 --> 00:31:45,000
musíme být opatrní s tím, jak děláme.

422
00:31:45,000 --> 00:31:50,000
Má někdo nějaké návrhy na to, jak děláme?

423
00:32:17,000 --> 00:32:21,000
Tady je náš start.

424
00:32:21,000 --> 00:32:28,000
Je samozřejmé, chceme od začátku znovu

425
00:32:28,000 --> 00:32:35,000
a kopírování věcí v odtamtud, 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
Jak to děláte, že?

427
00:32:41,000 --> 00:32:52,000
Za prvé, musím se podívat na manuálové stránce pro memmove znovu.

428
00:32:52,000 --> 00:32:57,000
Memmove, pořadí argumentů je vždy důležité.

429
00:32:57,000 --> 00:33:01,000
Chceme, aby naše cíle první, zdroj druhý, velikost třetí.

430
00:33:01,000 --> 00:33:06,000
Existuje mnoho funkcí, které zvrátí zdroj a cíl.

431
00:33:06,000 --> 00:33:11,000
Destinace, zdroj bývá konzistentní poněkud.

432
00:33:17,000 --> 00:33:21,000
Move, co je to vrací?

433
00:33:21,000 --> 00:33:27,000
Vrací ukazatel na místo určení, z jakéhokoliv důvodu budete chtít, že.

434
00:33:27,000 --> 00:33:32,000
Jsem si obrázek přečíst, ale chceme přestěhovat do našeho cíle.

435
00:33:32,000 --> 00:33:35,000
>> Co je naším cílem bude?

436
00:33:35,000 --> 00:33:37,000
[Student] Nové.

437
00:33:37,000 --> 00:33:39,000
[Rob B.] Ano, a kde jsme kopírování?

438
00:33:39,000 --> 00:33:43,000
První věc, kterou kopírujete, je to 1, 3, 4.

439
00:33:43,000 --> 00:33:50,000
Co je-to 1, 3, 4.

440
00:33:50,000 --> 00:33:55,000
Jaká je adresa tohoto 1?

441
00:33:55,000 --> 00:33:58,000
Jaká je adresa tohoto 1?

442
00:33:58,000 --> 00:34:01,000
[Student] [neslyšitelné]

443
00:34:01,000 --> 00:34:03,000
[Rob B.] Head + adresa prvního prvku.

444
00:34:03,000 --> 00:34:05,000
Jak se dostat na první prvek v poli?

445
00:34:05,000 --> 00:34:10,000
[Student] Queue.

446
00:34:10,000 --> 00:34:15,000
[Rob B.] Ano, q.strings.

447
00:34:15,000 --> 00:34:20,000
Pamatujte si, že zde, naše hlava je 1.

448
00:34:20,000 --> 00:34:24,000
Látat to. Jen si myslím, že je to jako mávnutím kouzelného proutku,

449
00:34:24,000 --> 00:34:29,000
Zde, naše hlava je 1. Chystám se změnit můj barvu taky.

450
00:34:29,000 --> 00:34:36,000
A tady je řetězce.

451
00:34:36,000 --> 00:34:41,000
To, můžeme buď napsat to stejně jako my tady

452
00:34:41,000 --> 00:34:43,000
s hlavami + q.strings.

453
00:34:43,000 --> 00:34:51,000
Mnoho lidí také zapisovat a q.strings [hlava].

454
00:34:51,000 --> 00:34:55,000
To není opravdu nic méně efektivní.

455
00:34:55,000 --> 00:34:58,000
Můžete si myslet, ze to, jak jste se dereferencing ji a pak se dostat adresu,

456
00:34:58,000 --> 00:35:04,000
ale kompilátor bude překládat, co jsme měli předtím tak, q.strings + hlava.

457
00:35:04,000 --> 00:35:06,000
Ať tak či onak si chcete myslet na to.

458
00:35:06,000 --> 00:35:11,000
>> A kolik bytů si chceme kopírovat?

459
00:35:11,000 --> 00:35:15,000
[Student] Kapacita - hlava.

460
00:35:15,000 --> 00:35:18,000
Kapacita - hlava.

461
00:35:18,000 --> 00:35:21,000
A pak můžete vždy zapsat příklad

462
00:35:21,000 --> 00:35:23,000
zjistit, jestli je to pravda.

463
00:35:23,000 --> 00:35:26,000
[Student] Je třeba rozdělit do 2 pak.

464
00:35:26,000 --> 00:35:30,000
Jo, takže myslím, že bychom mohli použít velikost.

465
00:35:30,000 --> 00:35:35,000
Stále máme velikost je-

466
00:35:35,000 --> 00:35:39,000
pomocí velikosti, musíme velikost stejnou jako 4.

467
00:35:39,000 --> 00:35:42,000
Naše velikost je 4. Naše hlava je 1.

468
00:35:42,000 --> 00:35:46,000
Chceme zkopírovat tyto 3 prvky.

469
00:35:46,000 --> 00:35:54,000
To je příčetnost zkontrolujte, zda velikost - hlava je správně 3.

470
00:35:54,000 --> 00:35:58,000
A přichází sem, jak jsme řekli dříve,

471
00:35:58,000 --> 00:36:00,000
pokud jsme použili kapacitu, pak bychom museli dělit 2

472
00:36:00,000 --> 00:36:04,000
proto, že jsme už stalo naší schopnosti, a tak místo toho, budeme používat velikost.

473
00:36:11,000 --> 00:36:13,000
Že kopií, které porce.

474
00:36:13,000 --> 00:36:18,000
Nyní musíme zkopírovat druhou část, část, která je nalevo od začátku.

475
00:36:18,000 --> 00:36:28,000
>> To bude memmove do jaké pozici?

476
00:36:28,000 --> 00:36:32,000
[Student] Plus velikost - hlava.

477
00:36:32,000 --> 00:36:38,000
Ano, tak jsme již zkopírováno ve velikosti - hlava bajtů,

478
00:36:38,000 --> 00:36:43,000
a tak tam, kde chceme zkopírovat zbývající bajtů je nový

479
00:36:43,000 --> 00:36:48,000
a pak velikost minus stejně, počet bytů jsme již zkopírováno a.

480
00:36:48,000 --> 00:36:52,000
A pak, kde jsme kopírování?

481
00:36:52,000 --> 00:36:54,000
[Student] Q.strings [0].

482
00:36:54,000 --> 00:36:56,000
[Rob B.] Ano, q.strings.

483
00:36:56,000 --> 00:37:02,000
Můžeme buď udělat a q.strings [0].

484
00:37:02,000 --> 00:37:05,000
To je výrazně méně časté než tohle.

485
00:37:05,000 --> 00:37:14,000
Pokud to jen bude 0, pak budete tendenci vidět q.strings.

486
00:37:14,000 --> 00:37:16,000
To je místo, kde jsme kopírování.

487
00:37:16,000 --> 00:37:18,000
Kolik bytů nám zbývá zkopírovat? >> [Student] 10.

488
00:37:18,000 --> 00:37:20,000
Právo.

489
00:37:20,000 --> 00:37:25,000
[Student] Ještě musíme vynásobit 5 - 10 krát větší než velikost bajtů nebo tak něco?

490
00:37:25,000 --> 00:37:30,000
Jo, tak to je místo, kde-co přesně se kopírování?

491
00:37:30,000 --> 00:37:32,000
[Student] [neslyšitelné]

492
00:37:32,000 --> 00:37:34,000
Jaký je typ věci jsme kopírování?

493
00:37:34,000 --> 00:37:36,000
[Student] [neslyšitelné]

494
00:37:36,000 --> 00:37:41,000
Jo, takže char * s, že jsme kopírování, nevíme, kde ty jsou zasílány z.

495
00:37:41,000 --> 00:37:47,000
No, kde to ukázal, jako struny, skončíme to tlačil do fronty

496
00:37:47,000 --> 00:37:49,000
nebo enqueuing do fronty.

497
00:37:49,000 --> 00:37:51,000
Pokud ty jsou zasílány z, nemáme ponětí.

498
00:37:51,000 --> 00:37:56,000
Potřebujeme jen sledovat char * s sami.

499
00:37:56,000 --> 00:38:00,000
Nechceme kopírovat velikosti - hlava bytů.

500
00:38:00,000 --> 00:38:03,000
Chceme kopírovat velikosti - hlava char * s,

501
00:38:03,000 --> 00:38:11,000
takže budeme násobit tím sizeof (char *).

502
00:38:11,000 --> 00:38:17,000
Stejná sem, hlava * sizeof (char *).

503
00:38:17,000 --> 00:38:24,000
>> [Student] Co [neslyšitelné]?

504
00:38:24,000 --> 00:38:26,000
Toto právo tady?

505
00:38:26,000 --> 00:38:28,000
[Student] Ne, pod tím je velikost - hlava.

506
00:38:28,000 --> 00:38:30,000
[Rob B.] Toto právo tady?

507
00:38:30,000 --> 00:38:32,000
Ukazatel aritmetika.

508
00:38:32,000 --> 00:38:35,000
Jak ukazatel aritmetický bude fungovat, je

509
00:38:35,000 --> 00:38:40,000
automaticky násobí podle velikosti typu, že máme co do činění s.

510
00:38:40,000 --> 00:38:46,000
Stejně jako tady, nový + (velikost - hlava)

511
00:38:46,000 --> 00:38:56,000
je přesně ekvivalentní a nové [velikost - hlava]

512
00:38:56,000 --> 00:39:00,000
dokud očekáváme, že se pracovat správně,

513
00:39:00,000 --> 00:39:04,000
protože pokud máme co do činění s int pole, pak nemáme index int-

514
00:39:04,000 --> 00:39:07,000
nebo jestli je to z velikosti 5 a chcete 4. prvek, pak jsme index do

515
00:39:07,000 --> 00:39:10,000
int array [4].

516
00:39:10,000 --> 00:39:14,000
Ty nedělej-[4] * velikost int.

517
00:39:14,000 --> 00:39:21,000
, Který zpracovává automaticky, a tento případ

518
00:39:21,000 --> 00:39:29,000
Je doslova ekvivalentní, takže držák syntaxe

519
00:39:29,000 --> 00:39:34,000
je jen tak být přeměněn na to co nejdříve zkompilovat.

520
00:39:34,000 --> 00:39:38,000
To je něco, co musíte být opatrní, aby

521
00:39:38,000 --> 00:39:42,000
Při přidávání velikost - hlava

522
00:39:42,000 --> 00:39:45,000
Přidáváte ne jeden bajt.

523
00:39:45,000 --> 00:39:53,000
Jste přidáním jednoho char *, což může být jeden bytů nebo cokoliv.

524
00:39:53,000 --> 00:39:56,000
>> Další otázky?

525
00:39:56,000 --> 00:40:04,000
Dobře, Dequeue bude jednodušší.

526
00:40:04,000 --> 00:40:11,000
Dám vám chvilku realizovat.

527
00:40:11,000 --> 00:40:18,000
Oh, a myslím, že to je stejná situace, kdy

528
00:40:18,000 --> 00:40:21,000
co enqueue případě, pokud budeme enqueuing null,

529
00:40:21,000 --> 00:40:24,000
Možná chceme zvládnout, možná nemáme.

530
00:40:24,000 --> 00:40:27,000
Budeme to dělat znovu tady, ale stejně jako naše zásobníku případě.

531
00:40:27,000 --> 00:40:34,000
Pokud budeme Zařadí null, mohli bychom chtít ignorovat.

532
00:40:34,000 --> 00:40:40,000
Každý, kdo má nějaký kód, který jsem si vytáhnout nahoru?

533
00:40:40,000 --> 00:40:45,000
[Student] Mám jen Dequeue.

534
00:40:45,000 --> 00:40:56,000
Verze 2 je, že-v pořádku.

535
00:40:56,000 --> 00:40:59,000
Chcete-li vysvětlit?

536
00:40:59,000 --> 00:41:01,000
[Student] Za prvé, musíte se ujistěte, že je něco, co ve frontě

537
00:41:01,000 --> 00:41:07,000
a že velikost klesá o 1.

538
00:41:07,000 --> 00:41:11,000
Musíte to udělat, a pak se vrátíte hlavu

539
00:41:11,000 --> 00:41:13,000
a pak přesunout hlavu 1.

540
00:41:13,000 --> 00:41:19,000
Dobře, tak tam je rohová případ, musíme vzít v úvahu. Jo.

541
00:41:19,000 --> 00:41:24,000
[Student] Pokud je vaše hlava je na poslední prvek,

542
00:41:24,000 --> 00:41:26,000
pak nechcete hlava bodu mimo pole.

543
00:41:26,000 --> 00:41:29,000
>> Jo, takže jakmile hlava udeří konec našeho pole,

544
00:41:29,000 --> 00:41:35,000
když jsme dequeue, by naše hlava se modded zpět na 0.

545
00:41:35,000 --> 00:41:40,000
Bohužel, nemůžeme to, že v jednom kroku.

546
00:41:40,000 --> 00:41:44,000
Myslím, že tak, jak jsem si asi stanovit, že je

547
00:41:44,000 --> 00:41:52,000
to bude char *, co se vracíme,

548
00:41:52,000 --> 00:41:55,000
bez ohledu na vaše jméno proměnné chce být.

549
00:41:55,000 --> 00:42:02,000
Pak chceme mod hlavu o naší schopnosti

550
00:42:02,000 --> 00:42:10,000
a pak se vrátit ret.

551
00:42:10,000 --> 00:42:14,000
Hodně lidí tady by se mohly do-

552
00:42:14,000 --> 00:42:19,000
To je případ-Budeš vidět lidi dělat, když se hlava

553
00:42:19,000 --> 00:42:29,000
je větší než kapacita, to hlavou - kapacita.

554
00:42:29,000 --> 00:42:36,000
A to je právě pracuje kolem toho, co mod je.

555
00:42:36,000 --> 00:42:41,000
Vedoucí mod = kapacita je mnohem čistší

556
00:42:41,000 --> 00:42:51,000
z obalu kolem, než-li hlava větší než kapacita hlavou - kapacita.

557
00:42:51,000 --> 00:42:56,000
>> Otázky?

558
00:42:56,000 --> 00:43:02,000
Dobře, poslední věc, kterou jsme si nechali je náš propojený seznam.

559
00:43:02,000 --> 00:43:07,000
Ty by mohly být použity na některé propojené seznamu chování, pokud jste

560
00:43:07,000 --> 00:43:11,000
souvisí seznamy ve vašich hash tabulkách, pokud jste hash tabulky.

561
00:43:11,000 --> 00:43:15,000
Vřele doporučuji dělat hash tabulky.

562
00:43:15,000 --> 00:43:17,000
Možná jste již udělali trie,

563
00:43:17,000 --> 00:43:23,000
ale pokusy jsou těžší.

564
00:43:23,000 --> 00:43:27,000
Teoreticky, jsou asymptoticky lepší.

565
00:43:27,000 --> 00:43:30,000
Ale stačí se podívat na velkou tabuli,

566
00:43:30,000 --> 00:43:35,000
a snaží se nikdy dělat lépe, a zabírají více paměti.

567
00:43:35,000 --> 00:43:43,000
Vše o snaží skončí bytí horší pro další práci.

568
00:43:43,000 --> 00:43:49,000
Je to to, co David Malan řešením je vždy

569
00:43:49,000 --> 00:43:56,000
Je vždycky příspěvků jeho trie roztoku, a podíváme se, kde v současné době je.

570
00:43:56,000 --> 00:44:00,000
Co bylo, že v rámci, David J?

571
00:44:00,000 --> 00:44:06,000
Je to # 18, tak, že to není příliš špatný,

572
00:44:06,000 --> 00:44:09,000
a že to bude jeden z nejlepších snaží si můžete myslet

573
00:44:09,000 --> 00:44:17,000
nebo jeden z nejlepších snaží o trie.

574
00:44:17,000 --> 00:44:23,000
Je to dokonce ani jeho originální řešení?

575
00:44:23,000 --> 00:44:29,000
Mám pocit, že trie řešení mají tendenci být více v tomto rozsahu použití RAM.

576
00:44:29,000 --> 00:44:33,000
>> Jděte dolů až na samý vrchol, a RAM využití je v jednotlivých číslic.

577
00:44:33,000 --> 00:44:36,000
Jděte dolů ke dnu, a pak začnete vidět pokusí

578
00:44:36,000 --> 00:44:41,000
kde dostanete naprosto masivní paměti RAM,

579
00:44:41,000 --> 00:44:45,000
a pokusy jsou obtížnější.

580
00:44:45,000 --> 00:44:53,000
Ne zcela stojí za to, ale vzdělávací zkušenosti, pokud jste jeden.

581
00:44:53,000 --> 00:44:56,000
Poslední věc, kterou je náš propojený seznam,

582
00:44:56,000 --> 00:45:04,000
a tyto tři věci, komíny, fronty, a propojené seznamy,

583
00:45:04,000 --> 00:45:09,000
budoucí věc, kterou kdy udělal v informatice

584
00:45:09,000 --> 00:45:12,000
Předpokládejme, že jste obeznámeni s těmito věcmi.

585
00:45:12,000 --> 00:45:19,000
Jsou to jen natolik zásadní pro všechno.

586
00:45:19,000 --> 00:45:25,000
>> Souvisí seznamy, a tady jsme singly spojový seznam se bude naše realizace.

587
00:45:25,000 --> 00:45:34,000
Co jednotlivě spojeny znamená ve srovnání s dvojnásobně spojené? Ano.

588
00:45:34,000 --> 00:45:37,000
[Student] To jen ukazuje na další ukazatele, spíše než na ukazatele,

589
00:45:37,000 --> 00:45:39,000
jako ten předcházející je i ten, za ní.

590
00:45:39,000 --> 00:45:44,000
Jo, tak v formátu obrazu, co jsem to udělal?

591
00:45:44,000 --> 00:45:48,000
Mám dvě věci. Mám obraz a obraz.

592
00:45:48,000 --> 00:45:51,000
V obrazu formátu, naše jednotlivě propojené seznamy,

593
00:45:51,000 --> 00:45:57,000
nevyhnutelně, máme nějaký ukazatel na hlavu našeho seznamu,

594
00:45:57,000 --> 00:46:02,000
a pak v našem seznamu, budeme muset ukazatele,

595
00:46:02,000 --> 00:46:05,000
a možná tento bodů na hodnotu null.

596
00:46:05,000 --> 00:46:08,000
Je to něco jako tvůj typický výkres singly propojeného seznamu.

597
00:46:08,000 --> 00:46:14,000
Dvojnásobně spojový seznam, můžete jít zpět.

598
00:46:14,000 --> 00:46:19,000
Kdybych vám žádný uzel v seznamu, můžete nutně dostat do

599
00:46:19,000 --> 00:46:23,000
jiné uzel v seznamu, pokud se jedná o dvojnásobně spojový seznam.

600
00:46:23,000 --> 00:46:27,000
Ale když jsem vám třetí uzel v seznamu a je to jednotlivě propojený seznam,

601
00:46:27,000 --> 00:46:30,000
žádný způsob, jak jste někdy dostane do první a druhé uzlů.

602
00:46:30,000 --> 00:46:34,000
A je tu výhody a detriments, a jeden zřejmý

603
00:46:34,000 --> 00:46:42,000
je vám zaberou více velikosti, a vy budete muset sledovat, kde se tyto věci směřují nyní.

604
00:46:42,000 --> 00:46:49,000
Ale my jsme jen o singly spojené.

605
00:46:49,000 --> 00:46:53,000
>> Pár věcí budeme muset realizovat.

606
00:46:53,000 --> 00:47:00,000
Vaše typedef struct node, int i: struct node * next; uzel.

607
00:47:00,000 --> 00:47:09,000
To typedef by měla být vypálena do vaší mysli.

608
00:47:09,000 --> 00:47:14,000
Quiz 1 by měl být rád dát typedef propojeného seznamu uzlu,

609
00:47:14,000 --> 00:47:18,000
a vy byste měli být schopni okamžitě čmárat, že se

610
00:47:18,000 --> 00:47:22,000
bez přemýšlení o tom.

611
00:47:22,000 --> 00:47:27,000
Myslím, že pár otázek, proč potřebujeme struct sem?

612
00:47:27,000 --> 00:47:32,000
Proč nemůže říci uzlu *?

613
00:47:32,000 --> 00:47:35,000
[Student] [neslyšitelné]

614
00:47:35,000 --> 00:47:38,000
Jo.

615
00:47:38,000 --> 00:47:44,000
Jediná věc, která definuje uzel jako věc

616
00:47:44,000 --> 00:47:47,000
je typedef sám.

617
00:47:47,000 --> 00:47:55,000
Ale jak tohoto bodu, když jsme trochu rozebrat pomocí této definice struct uzel,

618
00:47:55,000 --> 00:48:01,000
jsme neskončili naší typedef dosud, takže od té doby typedef nebylo dokončeno,

619
00:48:01,000 --> 00:48:05,000
uzel neexistuje.

620
00:48:05,000 --> 00:48:12,000
Ale struct uzel se, a tento uzel ve zde,

621
00:48:12,000 --> 00:48:14,000
to by mohlo také být nazýváno něco jiného.

622
00:48:14,000 --> 00:48:16,000
To by mohlo být nazýván n.

623
00:48:16,000 --> 00:48:19,000
Mohlo by to být nazýván provázaný seznam uzlu.

624
00:48:19,000 --> 00:48:21,000
Mohlo by to být jen něco.

625
00:48:21,000 --> 00:48:26,000
Ale to struct node potřebuje být nazýván totéž jako tento struct uzel.

626
00:48:26,000 --> 00:48:29,000
Co říkáte to má také být tady,

627
00:48:29,000 --> 00:48:32,000
a aby také odpovídá na druhý bod na otázky

628
00:48:32,000 --> 00:48:37,000
což je důvod, proč, mnohokrát, když vidíte structs a typedefs z structs,

629
00:48:37,000 --> 00:48:42,000
uvidíte anonymní structs, kde budete jen vidět typedef struct,

630
00:48:42,000 --> 00:48:47,000
provádění struct, slovník, nebo cokoliv jiného.

631
00:48:47,000 --> 00:48:51,000
>> Proč tady se musíme říci uzel?

632
00:48:51,000 --> 00:48:54,000
Proč to nemůže být anonymní struct?

633
00:48:54,000 --> 00:48:56,000
Je to skoro stejná odpověď.

634
00:48:56,000 --> 00:48:58,000
[Student] Musíte se na ni odvolávat v rámci struct.

635
00:48:58,000 --> 00:49:04,000
Jo, v struct, musíte se odkazovat na struct sám.

636
00:49:04,000 --> 00:49:10,000
Pokud nedáte struct jméno, pokud je to anonymní struct, nemůžete na něj odkazují.

637
00:49:10,000 --> 00:49:17,000
A v neposlední řadě, by toto vše mělo být poněkud přímočaré,

638
00:49:17,000 --> 00:49:20,000
a oni by vám měly pomoci si uvědomit, pokud píšete to stanoví

639
00:49:20,000 --> 00:49:24,000
že děláte něco špatně, pokud tyto druhy věcí nedávají smysl.

640
00:49:24,000 --> 00:49:28,000
V neposlední řadě, proč to musí být struct uzel *?

641
00:49:28,000 --> 00:49:34,000
Proč to nemůže být jen struct uzel dál?

642
00:49:34,000 --> 00:49:37,000
[Student] Ukazatel na další struct.

643
00:49:37,000 --> 00:49:39,000
To nevyhnutelně to, co chceme.

644
00:49:39,000 --> 00:49:42,000
Proč by se to nikdy nestane struct uzel dál?

645
00:49:42,000 --> 00:49:50,000
Proč to musí být struct node * next? Jo.

646
00:49:50,000 --> 00:49:53,000
[Student] Je to jako nekonečné smyčce.

647
00:49:53,000 --> 00:49:55,000
Jo.

648
00:49:55,000 --> 00:49:57,000
[Student] byl by to pořád v jednom.

649
00:49:57,000 --> 00:50:02,000
Jo, jen si na to, jak bychom to velikost nebo tak něco.

650
00:50:02,000 --> 00:50:08,000
Velikost struct je v podstatě + nebo - někteří vzor zde nebo tam.

651
00:50:08,000 --> 00:50:15,000
Je to v podstatě bude součet velikostí věcí v struct.

652
00:50:15,000 --> 00:50:18,000
To tady, aniž by se cokoliv změnilo, jeho velikost je bude snadné.

653
00:50:18,000 --> 00:50:24,000
Velikost struct uzel bude velikost i + velikosti vedle.

654
00:50:24,000 --> 00:50:27,000
Velikost i bude 4. Velikost příštího roku se bude 4.

655
00:50:27,000 --> 00:50:30,000
Velikost struct uzel bude 8.

656
00:50:30,000 --> 00:50:34,000
Pokud nemáme k *, myslel sizeof,

657
00:50:34,000 --> 00:50:37,000
pak sizeof (i) bude 4.

658
00:50:37,000 --> 00:50:43,000
Velikost struct uzel vedle bude velikost i + velikost struct uzel další

659
00:50:43,000 --> 00:50:46,000
+ Velikost i + velikosti struct uzel další.

660
00:50:46,000 --> 00:50:55,000
Bylo by nekonečná rekurze uzlů.

661
00:50:55,000 --> 00:51:00,000
Z tohoto důvodu je to, jak věci mají být.

662
00:51:00,000 --> 00:51:03,000
>> Opět, rozhodně zapamatovat, že,

663
00:51:03,000 --> 00:51:06,000
nebo alespoň pochopit natolik, že je možné být schopen

664
00:51:06,000 --> 00:51:12,000
Důvodem tím, co by to mělo vypadat.

665
00:51:12,000 --> 00:51:14,000
Věci budeme chtít realizovat.

666
00:51:14,000 --> 00:51:18,000
Pokud délka seznamu-

667
00:51:18,000 --> 00:51:21,000
můžete podvádět a udržet kolem

668
00:51:21,000 --> 00:51:24,000
globální délka nebo tak něco, ale my nebudeme dělat, že.

669
00:51:24,000 --> 00:51:28,000
Budeme počítat délku seznamu.

670
00:51:28,000 --> 00:51:34,000
Máme obsahuje, tak, že je v podstatě jako vyhledávání,

671
00:51:34,000 --> 00:51:41,000
takže máme propojený seznam celých čísel zjistit, jestli to číslo je v připojeném seznamu.

672
00:51:41,000 --> 00:51:44,000
Prepend bude pro vložení na začátku seznamu.

673
00:51:44,000 --> 00:51:46,000
Append bude vkládat na konci.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted bude vložit do tříděného pozici v seznamu.

675
00:51:53,000 --> 00:52:01,000
Insert_sorted druh předpokládá, že jste nikdy nepoužívali předřazený nebo připojený ve špatných cestách.

676
00:52:01,000 --> 00:52:09,000
>> Insert_sorted když jste provádění insert_sorted-

677
00:52:09,000 --> 00:52:13,000
Řekněme, že máme propojený seznam.

678
00:52:13,000 --> 00:52:18,000
To je to, co v současné době vypadá, 2, 4, 5.

679
00:52:18,000 --> 00:52:24,000
Chci vložit 3, tak dlouho, jak seznam sám je již řazeno,

680
00:52:24,000 --> 00:52:27,000
je snadné zjistit, kde 3 patří.

681
00:52:27,000 --> 00:52:29,000
Začínám na 2.

682
00:52:29,000 --> 00:52:32,000
Dobře, 3 je větší než 2, takže chci jít dál.

683
00:52:32,000 --> 00:52:35,000
Oh, 4 je příliš velký, takže vím, že 3 je jít mezi 2 a 4,

684
00:52:35,000 --> 00:52:39,000
a já musím opravit ukazatele a všechno to okolo.

685
00:52:39,000 --> 00:52:43,000
Ale pokud bychom neměli striktně používat insert_sorted,

686
00:52:43,000 --> 00:52:50,000
Líbí řekněme, že jsem předřadit 6,

687
00:52:50,000 --> 00:52:55,000
pak můj propojený seznam se stane tohle.

688
00:52:55,000 --> 00:53:01,000
To teď nemá smysl, tak pro insert_sorted, můžete jen předpokládat,

689
00:53:01,000 --> 00:53:04,000
že seznam je seřazen, i když operace existují

690
00:53:04,000 --> 00:53:09,000
které mohou způsobit, že se nebude seřazena, a to je to.

691
00:53:09,000 --> 00:53:20,000
Najít užitečné vložka-tak to jsou hlavní věci, které budete muset provést.

692
00:53:20,000 --> 00:53:24,000
>> Pro tuto chvíli, se chvíli dělat délku a obsahuje,

693
00:53:24,000 --> 00:53:30,000
a ty by měla být relativně rychle.

694
00:53:41,000 --> 00:53:48,000
Blíží zavírací doba, takže někdo něco pro délku nebo obsahuje?

695
00:53:48,000 --> 00:53:50,000
Chystají se být téměř totožné.

696
00:53:50,000 --> 00:53:57,000
[Student] Délka.

697
00:53:57,000 --> 00:54:01,000
Pojďme se podívat, revize.

698
00:54:01,000 --> 00:54:04,000
Dobře.

699
00:54:12,000 --> 00:54:15,000
Chcete-li vysvětlit?

700
00:54:15,000 --> 00:54:21,000
[Student] Právě jsem vytvořit ukazatel uzel a inicializovat ji jako první, což je naše globální proměnné,

701
00:54:21,000 --> 00:54:27,000
a pak jsem zkontrolovat, jestli je to null a tak jsem se nedostal seg chybu a vrátit 0, pokud tomu tak je.

702
00:54:27,000 --> 00:54:34,000
Jinak jsem průchozí, sledování v rámci celé číslo

703
00:54:34,000 --> 00:54:38,000
kolikrát jsem vstoupil na další prvek seznamu

704
00:54:38,000 --> 00:54:43,000
a ve stejném operace inkrementu rovněž přístup, že skutečný prvek,

705
00:54:43,000 --> 00:54:47,000
a pak jsem neustále, aby zkontrolovat, zda je to null,

706
00:54:47,000 --> 00:54:56,000
a, pokud je to nula, potom se přeruší a jen vrací počet prvků jsem přístupné.

707
00:54:56,000 --> 00:55:01,000
>> [Rob B.] Má někdo nějaké připomínky na cokoli?

708
00:55:01,000 --> 00:55:06,000
To vypadá dobře správnost moudrý.

709
00:55:06,000 --> 00:55:10,000
[Student] Já si nemyslím, že je třeba uzel == null.

710
00:55:10,000 --> 00:55:13,000
Jo, takže pokud uzel == null return 0.

711
00:55:13,000 --> 00:55:18,000
Ale pokud uzel == null pak-oh, je správnost problém.

712
00:55:18,000 --> 00:55:23,000
Bylo to jen vracíte i, ale to není v působnosti teď.

713
00:55:23,000 --> 00:55:30,000
Potřebujete k tomu jen int i, takže i = 0.

714
00:55:30,000 --> 00:55:34,000
Ale pokud uzel je null, pak jsem se ještě bude 0,

715
00:55:34,000 --> 00:55:39,000
a budeme se vrátit 0, takže tento případ je totožný.

716
00:55:39,000 --> 00:55:48,000
Dalším společným věc je mít k dispozici prohlášení

717
00:55:48,000 --> 00:55:51,000
uzlu uvnitř smyčky for.

718
00:55:51,000 --> 00:55:54,000
Dalo by se říci, oh, no.

719
00:55:54,000 --> 00:55:56,000
Pojďme držet to jako tohle.

720
00:55:56,000 --> 00:55:59,000
Asi bych dal int i = 0 zde,

721
00:55:59,000 --> 00:56:05,000
pak uzel * node = první zde.

722
00:56:05,000 --> 00:56:11,000
A to je asi, jak-jak se zbavit teď.

723
00:56:11,000 --> 00:56:14,000
Toto je pravděpodobně, jak bych napsal.

724
00:56:14,000 --> 00:56:21,000
Dalo by se také, při pohledu na něj takhle.

725
00:56:21,000 --> 00:56:25,000
To je pro smyčky struktury tady

726
00:56:25,000 --> 00:56:30,000
by měla být téměř stejně přirozené pro vás jako pro int i = 0

727
00:56:30,000 --> 00:56:33,000
i je menší než délka pole i + +.

728
00:56:33,000 --> 00:56:38,000
Pokud to, jak se iterovat přes pole, to je to, jak jste iteraci propojeného seznamu.

729
00:56:38,000 --> 00:56:45,000
>> To by mělo být druhou přirozeností, v určitém okamžiku.

730
00:56:45,000 --> 00:56:50,000
S tím na mysli, to bude téměř to samé.

731
00:56:50,000 --> 00:56:57,000
Budeš chtít iteraci propojenou seznam.

732
00:56:57,000 --> 00:57:02,000
Pokud uzel-Nemám ponětí, co je hodnota nazývá.

733
00:57:02,000 --> 00:57:04,000
Uzlu i.

734
00:57:04,000 --> 00:57:15,000
Pokud je hodnota v tomto uzlu = i vrátit true, a to je vše.

735
00:57:15,000 --> 00:57:18,000
Všimněte si, že jediný způsob, jak se někdy vrátí false

736
00:57:18,000 --> 00:57:23,000
je-li nám iterovat přes celý propojeného seznamu a nikdy vrátit true,

737
00:57:23,000 --> 00:57:29,000
tak to je to, co to dělá.

738
00:57:29,000 --> 00:57:36,000
Jako vedlejší poznámku, budeme pravděpodobně nebude mít připojit nebo předřadit.

739
00:57:36,000 --> 00:57:39,000
>> Rychlé poslední poznámka.

740
00:57:39,000 --> 00:57:52,000
Pokud vidíte klíčového slova static, takže řekněme static int count = 0,

741
00:57:52,000 --> 00:57:56,000
a uděláme počet + +, můžete v podstatě si ji představit jako globální proměnné,

742
00:57:56,000 --> 00:58:00,000
i když jsem právě řekl, to není, jak budeme realizovat délku.

743
00:58:00,000 --> 00:58:06,000
Dělám to tady, a pak počítat + +.

744
00:58:06,000 --> 00:58:11,000
Každý způsob, jak můžeme zadat uzel do naší propojeného seznamu jsme navýšením naše počet.

745
00:58:11,000 --> 00:58:15,000
Bod je to, co statické klíčové slovo znamená.

746
00:58:15,000 --> 00:58:20,000
Pokud jsem měl int count = 0, že by normální stará globální proměnná.

747
00:58:20,000 --> 00:58:25,000
Co static int count znamená, že se jedná o globální proměnnou tohoto souboru.

748
00:58:25,000 --> 00:58:28,000
Je nemožné, aby nějaký jiný soubor,

749
00:58:28,000 --> 00:58:34,000
Líbí myslet PSet 5, pokud jste začali.

750
00:58:34,000 --> 00:58:39,000
Máte oba speller.c, a máte dictionary.c,

751
00:58:39,000 --> 00:58:42,000
a pokud jste právě deklarovat věc globální, pak nic speller.c

752
00:58:42,000 --> 00:58:45,000
lze přistupovat dictionary.c a naopak.

753
00:58:45,000 --> 00:58:48,000
Globální proměnné jsou přístupné jakékoliv. Oddíl C,

754
00:58:48,000 --> 00:58:54,000
ale statické proměnné jsou přístupné pouze v rámci samotného souboru,

755
00:58:54,000 --> 00:59:01,000
tak uvnitř spell checker nebo uvnitř dictionary.c,

756
00:59:01,000 --> 00:59:06,000
tohle je o tom, jak bych deklarovat svou proměnnou pro velikost mého pole

757
00:59:06,000 --> 00:59:10,000
nebo velikost mého počtu slov ve slovníku.

758
00:59:10,000 --> 00:59:15,000
Vzhledem k tomu, nechci deklarovat globální proměnné, že někdo má přístup k,

759
00:59:15,000 --> 00:59:18,000
Opravdu jen o to pro své vlastní účely.

760
00:59:18,000 --> 00:59:21,000
>> Dobrou věc, o to je také celé jméno kolize věci.

761
00:59:21,000 --> 00:59:27,000
Pokud nějaký jiný soubor se pokusí použít globální proměnnou s názvem znaků, věci jdou velmi, velmi špatné,

762
00:59:27,000 --> 00:59:33,000
tak to pěkně drží věci bezpečné, a jen vy můžete přistupovat,

763
00:59:33,000 --> 00:59:38,000
a nikdo jiný nemůže, a pokud někdo jiný deklaruje globální proměnnou s názvem počítat,

764
00:59:38,000 --> 00:59:43,000
pak to nebude v rozporu s vaší statické proměnné s názvem znaků.

765
00:59:43,000 --> 00:59:47,000
To je to, co statické je. Je soubor globální proměnná.

766
00:59:47,000 --> 00:59:52,000
>> Otázky týkající se něco?

767
00:59:52,000 --> 00:59:59,000
All set. Bye.

768
00:59:59,000 --> 01:00:03,000
[CS50.TV]