1
00:00:00,000 --> 00:00:09,572

2
00:00:09,572 --> 00:00:12,030
ROB BOWDEN: Cześć, jestem Rob Bowden,
i porozmawiajmy o quiz0.

3
00:00:12,030 --> 00:00:13,280

4
00:00:13,280 --> 00:00:14,545
>> Więc pierwsze pytanie.

5
00:00:14,545 --> 00:00:17,750
To jest pytanie, gdzie
potrzebne do kodowania numeru

6
00:00:17,750 --> 00:00:21,270
127 w żarówki binarnych.

7
00:00:21,270 --> 00:00:23,550
Jeśli chcesz, możesz
zrobić regularnej konwersji

8
00:00:23,550 --> 00:00:25,950
z bi-- lub z przecinku na binarne.

9
00:00:25,950 --> 00:00:28,300
Ale to prawdopodobnie będzie
podjąć wiele czasu.

10
00:00:28,300 --> 00:00:31,750
To znaczy, można dowiedzieć się, że
OK 1 to tam, 2 jest tam

11
00:00:31,750 --> 00:00:33,650
4 znajduje się tam, 8 jest w środku.

12
00:00:33,650 --> 00:00:39,280
Łatwiejszy sposób, 127 128 minus jeden.

13
00:00:39,280 --> 00:00:42,013
Że żarówka świeci od lewej 128-bit.

14
00:00:42,013 --> 00:00:43,490

15
00:00:43,490 --> 00:00:47,860
Więc 127 jest tak naprawdę wszystko
innych żarówek,

16
00:00:47,860 --> 00:00:51,420
ponieważ jest to najbardziej wysunięta na lewo
żarówka minus 1.

17
00:00:51,420 --> 00:00:52,800
To wszystko na to pytanie.

18
00:00:52,800 --> 00:00:54,060
>> Pytanie pierwsze.

19
00:00:54,060 --> 00:00:56,710
Więc z 3 bitów można
reprezentują osiem różnych wartości.

20
00:00:56,710 --> 00:01:01,000
Dlaczego więc jest 7 największym nieujemną
dziesiętną liczbą całkowitą można reprezentować?

21
00:01:01,000 --> 00:01:04,050
Cóż, jeśli tylko możemy
reprezentują osiem różnych wartości,

22
00:01:04,050 --> 00:01:07,430
to co mamy zamiar być
reprezentujących wartości od 0 do 7.

23
00:01:07,430 --> 00:01:08,745
0 wykonuje się jedną z tych wartości.

24
00:01:08,745 --> 00:01:09,980

25
00:01:09,980 --> 00:01:11,190
>> Pytanie drugie.

26
00:01:11,190 --> 00:01:14,610
Z n bitów, ile odrębne
wartości można reprezentować?

27
00:01:14,610 --> 00:01:19,080
Tak, z n bitów, masz 2
Możliwe wartości dla każdego bitu.

28
00:01:19,080 --> 00:01:22,300
Więc mamy 2 możliwe wartości
pierwszy bit, 2 możliwe wartości

29
00:01:22,300 --> 00:01:24,450
na sekundę, 2
możliwe do trzeciej.

30
00:01:24,450 --> 00:01:28,730
I tak to jest 2 razy 2 razy 2 i
ostatecznie odpowiedź jest 2 do n.

31
00:01:28,730 --> 00:01:30,010

32
00:01:30,010 --> 00:01:31,100
>> Pytanie trzy.

33
00:01:31,100 --> 00:01:33,450
Co 0x50 binarnie?

34
00:01:33,450 --> 00:01:39,490
Więc pamiętaj, że ma bardzo heksadecymalny
prosta konwersja do pliku binarnego.

35
00:01:39,490 --> 00:01:43,180
Więc, po prostu trzeba spojrzeć na
5 i 0 niezależnie.

36
00:01:43,180 --> 00:01:45,110
Więc co jest 5 w formacie binarnym?

37
00:01:45,110 --> 00:01:48,400
0101, to 1 bit i 4 bit.

38
00:01:48,400 --> 00:01:49,900
Co znajduje się 0 w binarnym?

39
00:01:49,900 --> 00:01:50,520
Nie trudne.

40
00:01:50,520 --> 00:01:52,180
0000.

41
00:01:52,180 --> 00:01:54,970
Więc po prostu umieścić je razem, a
to pełny numer w formacie binarnym.

42
00:01:54,970 --> 00:01:57,640
01010000.

43
00:01:57,640 --> 00:02:00,439
A jeśli chciał mógłbyś
zdjąć ten skrajnie lewy zero.

44
00:02:00,439 --> 00:02:01,105
To bez znaczenia.

45
00:02:01,105 --> 00:02:02,920

46
00:02:02,920 --> 00:02:05,733
>> Tak więc alternatywnie
co jest 0x50 w przecinku?

47
00:02:05,733 --> 00:02:08,649
Jeśli chcesz, możesz could-- jeśli jesteś
bardziej komfortowo z pliku binarnego,

48
00:02:08,649 --> 00:02:11,340
można przyjąć, że odpowiedź binarny
i przekonwertować na dziesiętną.

49
00:02:11,340 --> 00:02:13,870
Albo może po prostu pamiętam
że szesnastkowym.

50
00:02:13,870 --> 00:02:21,140
Tak, że 0 jest na 0-te miejsce, a
5 znajduje się w 16 w pierwszym miejscu.

51
00:02:21,140 --> 00:02:25,990
Więc tutaj mamy 5 razy 16 do
pierwsze, plus 0 razy 16 do zera,

52
00:02:25,990 --> 00:02:27,520
80.

53
00:02:27,520 --> 00:02:29,710
A jeśli spojrzał na
Tytuł na pytanie,

54
00:02:29,710 --> 00:02:32,920
było CS 80, który był swego rodzaju
wskazówkę do odpowiedzi na ten problem.

55
00:02:32,920 --> 00:02:34,460

56
00:02:34,460 --> 00:02:35,420
>> Pytanie pięć.

57
00:02:35,420 --> 00:02:40,320
Mamy skrypt podstaw, które jest
4 razy powtarzając masło orzechowe galaretki.

58
00:02:40,320 --> 00:02:42,800
Jak więc teraz kod w C?

59
00:02:42,800 --> 00:02:47,730
Cóż, mamy here-- część w śmiały
jest tylko część, którą miał do wykonania.

60
00:02:47,730 --> 00:02:51,950
Mamy więc cztery pętli pętli 4, który jest
Czasy, printf-ing galaretki masło orzechowe,

61
00:02:51,950 --> 00:02:53,910
z nowej linii jako problem prosi.

62
00:02:53,910 --> 00:02:55,250

63
00:02:55,250 --> 00:02:57,490
>> Pytanie sześć, inny problem Scratch.

64
00:02:57,490 --> 00:03:00,210
Widzimy, że jesteśmy na zawsze w pętli.

65
00:03:00,210 --> 00:03:05,000
Mówimy zmienna i
a następnie zwiększając io 1.

66
00:03:05,000 --> 00:03:09,580
Teraz chcemy to zrobić w C. Są
wiele sposobów mogliśmy zrobić tego.

67
00:03:09,580 --> 00:03:12,840
Tu stało się zakodować
zawsze jako pętla while (true).

68
00:03:12,840 --> 00:03:16,600
Więc zadeklarować zmienną i, po prostu
jak mieliśmy zmienną I w Scratch.

69
00:03:16,600 --> 00:03:21,950
Deklaracja zmiennej i, i na wieki
while (true), to mówimy, zmienną i.

70
00:03:21,950 --> 00:03:25,260
Więc printf% ja-- lub można używałem% d.

71
00:03:25,260 --> 00:03:27,985
Mówimy, że zmienna i
następnie zwiększać ją, i ++.

72
00:03:27,985 --> 00:03:29,560

73
00:03:29,560 --> 00:03:30,830
>> Pytanie siedem.

74
00:03:30,830 --> 00:03:35,560
Teraz chcemy zrobić coś bardzo podobnego
Mario dot c od problemu ustawione.

75
00:03:35,560 --> 00:03:39,110
Chcemy, aby wydrukować te hashtags,
chcemy wydrukować pięć

76
00:03:39,110 --> 00:03:40,700
przez trzy prostokąta z tych skrótów.

77
00:03:40,700 --> 00:03:41,770

78
00:03:41,770 --> 00:03:43,162
Więc jak mamy zamiar to zrobić?

79
00:03:43,162 --> 00:03:45,370
Cóż, dajemy Ci całe
czek kodu, i po prostu

80
00:03:45,370 --> 00:03:47,560
wypełnić w funkcji siatki druku.

81
00:03:47,560 --> 00:03:49,540
>> Więc co PrintGrid wyglądać?

82
00:03:49,540 --> 00:03:51,480
Dobrze, że jesteś obok
Szerokość i wysokość.

83
00:03:51,480 --> 00:03:53,520
Mamy więc zewnętrznej 4
pętla, która jest zapętlenie

84
00:03:53,520 --> 00:03:57,650
przez wszystkie wiersze tego
siatki, które chcemy wydrukować.

85
00:03:57,650 --> 00:04:01,250
Następnie mamy 4 między zagnieżdżonych pętli,
to jest drukowanie na każdej kolumnie.

86
00:04:01,250 --> 00:04:06,210
Więc dla każdego wiersza, drukujemy na
każda kolumna, jeden hash.

87
00:04:06,210 --> 00:04:10,045
Następnie na końcu rzędu się drukowanie
pojedyncza linia, aby przejść do następnego wiersza.

88
00:04:10,045 --> 00:04:11,420
I to dla całej sieci.

89
00:04:11,420 --> 00:04:12,810

90
00:04:12,810 --> 00:04:13,675
>> Pytanie osiem.

91
00:04:13,675 --> 00:04:17,170
Funkcja jak PrintGrid mówi się,
wystąpiły działania niepożądane, ale nie powrotu

92
00:04:17,170 --> 00:04:17,670
wartość.

93
00:04:17,670 --> 00:04:19,209
Wyjaśnij różnicę.

94
00:04:19,209 --> 00:04:23,080
Więc to zależy od ciebie pamiętać
czego efektem ubocznym jest.

95
00:04:23,080 --> 00:04:25,180
Cóż, powrót value--
wiemy PrintGrid nie

96
00:04:25,180 --> 00:04:28,180
ma wartość zwracaną, ponieważ
tu mówi nieważne.

97
00:04:28,180 --> 00:04:31,150
Więc wszystko, co zwraca void
Naprawdę nic nie zwróci.

98
00:04:31,150 --> 00:04:32,200

99
00:04:32,200 --> 00:04:33,620
Tak więc to, co jest efektem ubocznym?

100
00:04:33,620 --> 00:04:36,620
Cóż, skutkiem ubocznym jest
coś, jakby nie ustępuje

101
00:04:36,620 --> 00:04:39,500
po zakończeniu czynności
że nie tylko wrócił,

102
00:04:39,500 --> 00:04:41,340
i to nie tylko z wejść.

103
00:04:41,340 --> 00:04:44,970
>> Tak więc, na przykład, moglibyśmy
zmienić wartość zmiennej globalnej.

104
00:04:44,970 --> 00:04:46,590
To byłby efekt uboczny.

105
00:04:46,590 --> 00:04:49,000
W tym konkretnym przypadku,
bardzo ważnym skutkiem ubocznym

106
00:04:49,000 --> 00:04:51,070
drukuje na ekranie.

107
00:04:51,070 --> 00:04:53,110
Więc to jest efekt uboczny
że PrintGrid ma.

108
00:04:53,110 --> 00:04:54,980
Drukujemy te rzeczy na ekranie.

109
00:04:54,980 --> 00:04:56,370
I można myśleć
że jako efekt uboczny

110
00:04:56,370 --> 00:04:58,690
ponieważ jest to coś, co
nie ustępuje po zakończeniu tej funkcji.

111
00:04:58,690 --> 00:05:01,481
To jest coś poza zakresem
tej funkcji, które ostatecznie

112
00:05:01,481 --> 00:05:03,380
ulega zmianie,
Zawartość ekranu.

113
00:05:03,380 --> 00:05:05,200

114
00:05:05,200 --> 00:05:05,839
>> Pytanie dziewięć.

115
00:05:05,839 --> 00:05:07,880
Rozważmy program poniżej,
do których numery linii

116
00:05:07,880 --> 00:05:09,740
zostały dodane
sake dyskusji.

117
00:05:09,740 --> 00:05:13,480
Tak więc w tym programie mamy tylko
dzwoniąc getString, przechowywanie go

118
00:05:13,480 --> 00:05:16,220
Do tej zmiennej s, a następnie
wydrukowaniem zmiennej s.

119
00:05:16,220 --> 00:05:16,720
OK.

120
00:05:16,720 --> 00:05:19,090
Więc dlaczego jedna linia jest obecna.

121
00:05:19,090 --> 00:05:20,920
#include CS50 kropka h.

122
00:05:20,920 --> 00:05:23,820
Dlaczego musimy #include CS50 dot h?

123
00:05:23,820 --> 00:05:26,180
Cóż my dzwoniąc
Funkcję getString,

124
00:05:26,180 --> 00:05:28,840
i GetString jest zdefiniowana
w bibliotece CS50.

125
00:05:28,840 --> 00:05:31,600
Więc jeśli nie mamy
#include CS50 kropka h,

126
00:05:31,600 --> 00:05:35,760
byśmy się, że ukryte oświadczenie
błędu funkcji GetString

127
00:05:35,760 --> 00:05:36,840
od kompilatora.

128
00:05:36,840 --> 00:05:40,110
Więc musimy zawierać library--
musimy dołączyć plik nagłówka,

129
00:05:40,110 --> 00:05:42,870
bo kompilator nie będzie
uznają, że GetString istnieje.

130
00:05:42,870 --> 00:05:44,380

131
00:05:44,380 --> 00:05:46,140
>> Wyjaśnij, dlaczego druga linia jest obecna.

132
00:05:46,140 --> 00:05:47,890
Tak więc standardowe io punkt h.

133
00:05:47,890 --> 00:05:50,430
To jest dokładnie to samo
jak w poprzednim problemu

134
00:05:50,430 --> 00:05:53,310
chyba zamiast zajmować się
GetString, mówimy o printf.

135
00:05:53,310 --> 00:05:56,654
Tak więc, jeśli nie powiedzieć, musimy
zawierać standardowe io dot h,

136
00:05:56,654 --> 00:05:58,820
wtedy nie będzie w stanie
użycie funkcji printf,

137
00:05:58,820 --> 00:06:00,653
ponieważ kompilator
nie wie o tym.

138
00:06:00,653 --> 00:06:01,750

139
00:06:01,750 --> 00:06:05,260
>> Why-- jakie jest znaczenie
o unieważnienie zgodnie cztery?

140
00:06:05,260 --> 00:06:08,010
Mamy tu więc int main (void).

141
00:06:08,010 --> 00:06:10,600
To się po prostu mówiąc, że
nie otrzymujesz żadnej linii poleceń

142
00:06:10,600 --> 00:06:12,280
argumenty do głównej.

143
00:06:12,280 --> 00:06:17,390
Pamiętaj, że możemy powiedzieć, int
Główne int argc wsporniki ciąg ARGV.

144
00:06:17,390 --> 00:06:20,400
Więc po prostu powiedzieć, powiedzieć, że nieważne
ignorują argumenty wiersza poleceń.

145
00:06:20,400 --> 00:06:21,840

146
00:06:21,840 --> 00:06:25,225
>> Wyjaśnić w odniesieniu do pamięci dokładnie
co GetString zgodne sześć powraca.

147
00:06:25,225 --> 00:06:27,040

148
00:06:27,040 --> 00:06:31,640
GetString wraca blok
pamięci, tablica znaków.

149
00:06:31,640 --> 00:06:34,870
To naprawdę powrót
wskaźnik do pierwszego znaku.

150
00:06:34,870 --> 00:06:37,170
Należy pamiętać, że łańcuch jest gwiazdą char.

151
00:06:37,170 --> 00:06:41,360
Tak s jest wskaźnikiem do pierwszego
znaków w ciąg jest co

152
00:06:41,360 --> 00:06:43,510
że użytkownik wszedł na klawiaturze.

153
00:06:43,510 --> 00:06:47,070
I że pamięć dzieje się malloced,
tak, że pamięć jest w kupie.

154
00:06:47,070 --> 00:06:49,080

155
00:06:49,080 --> 00:06:50,450
>> Pytanie 13.

156
00:06:50,450 --> 00:06:51,960
Rozważmy poniższy program.

157
00:06:51,960 --> 00:06:55,579
Więc cały ten program robi
jest printf-ing 1 podzielonej przez 10.

158
00:06:55,579 --> 00:06:57,370
Więc po opracowaniu i
wykonywane, program ten

159
00:06:57,370 --> 00:07:01,170
wyjścia 0.0, chociaż
1 podzielone przez 10 0.1.

160
00:07:01,170 --> 00:07:02,970
Więc dlaczego jest to 0.0?

161
00:07:02,970 --> 00:07:05,510
Cóż, to dlatego,
od całkowitej podziału.

162
00:07:05,510 --> 00:07:08,580
1 więc całkowita, 10 jest liczbą całkowitą.

163
00:07:08,580 --> 00:07:11,980
Więc 1 podzielone przez 10, wszystko
jest traktowane jako liczby całkowite,

164
00:07:11,980 --> 00:07:16,380
i C, gdy robimy podział liczby całkowitej,
możemy obciąć dowolny punkt dziesiętny.

165
00:07:16,380 --> 00:07:19,590
Tak więc 1 jest podzielona przez 10
0, a następnie próbujemy

166
00:07:19,590 --> 00:07:24,410
drukowanie, że pływak, tak
zera drukowane float wynosi 0,0.

167
00:07:24,410 --> 00:07:27,400
I dlatego mamy 0,0.

168
00:07:27,400 --> 00:07:28,940
>> Rozważmy poniższy program.

169
00:07:28,940 --> 00:07:31,280
Teraz mamy do drukowania 0,1.

170
00:07:31,280 --> 00:07:34,280
Więc nie ma dzielenia całkowitego,
jesteśmy po prostu drukowania 0,1,

171
00:07:34,280 --> 00:07:37,100
ale jesteśmy drukowanie
do 28 miejsc po przecinku.

172
00:07:37,100 --> 00:07:41,810
I mamy to 0,1000, cała masa
zer, 5 5 5, bla bla bla.

173
00:07:41,810 --> 00:07:45,495
Więc pytanie, dlaczego to robi
drukowanie, że zamiast dokładnie 0,1?

174
00:07:45,495 --> 00:07:46,620

175
00:07:46,620 --> 00:07:49,640
>> Więc tu jest teraz powodem
zmiennoprzecinkowych niedokładności.

176
00:07:49,640 --> 00:07:53,410
Pamiętaj, że pływak jest tylko 32 bitów.

177
00:07:53,410 --> 00:07:57,540
Więc możemy reprezentować tylko skończoną ilość
od wartości zmiennoprzecinkowe z tych 32

178
00:07:57,540 --> 00:07:58,560
bity.

179
00:07:58,560 --> 00:08:01,760
Cóż tam ostatecznie nieskończenie
wiele liczb zmiennoprzecinkowych,

180
00:08:01,760 --> 00:08:04,940
i nie ma nieskończenie wiele pływające
Wartości zadane w zakresie od 0 do 1,

181
00:08:04,940 --> 00:08:07,860
i jesteśmy oczywiście w stanie
stanowią nawet więcej wartości niż to.

182
00:08:07,860 --> 00:08:13,230
Mamy więc do poświęceń, aby
było w stanie stanowić większość wartości.

183
00:08:13,230 --> 00:08:16,960
>> Więc wartość jak 0.1, najwyraźniej
nie może stanowić, że dokładnie.

184
00:08:16,960 --> 00:08:22,500
Więc zamiast reprezentujących 0,1 robimy
Najlepsze, co możemy reprezentować ten 0.100000 5 5

185
00:08:22,500 --> 00:08:23,260
5.

186
00:08:23,260 --> 00:08:26,306
I to jest bardzo blisko, ale
dla wielu zastosowań

187
00:08:26,306 --> 00:08:28,430
musisz się martwić
zmiennoprzecinkowych niedokładności,

188
00:08:28,430 --> 00:08:30,930
dlatego, że po prostu nie może stanowić
wszystkie pływające punkty dokładnie.

189
00:08:30,930 --> 00:08:32,500

190
00:08:32,500 --> 00:08:33,380
>> Pytanie 15.

191
00:08:33,380 --> 00:08:34,679
Rozważmy poniższy kod.

192
00:08:34,679 --> 00:08:36,630
Jesteśmy po prostu drukowania 1 plus 1.

193
00:08:36,630 --> 00:08:38,289
Więc nie ma tu sztuczka.

194
00:08:38,289 --> 00:08:41,780
1 plus 1 ma wartość 2, a
to, że mamy do drukowania.

195
00:08:41,780 --> 00:08:42,789
To po prostu drukuje dwa.

196
00:08:42,789 --> 00:08:43,850

197
00:08:43,850 --> 00:08:44,700
>> Pytanie 16.

198
00:08:44,700 --> 00:08:49,450
Teraz mamy do drukowania charakter
1 plus znak 1.

199
00:08:49,450 --> 00:08:52,110
Więc dlaczego nie
wydrukować to samo?

200
00:08:52,110 --> 00:08:57,680
Cóż znak znak 1 plus
1, postać 1 ma wartość ASCII 49.

201
00:08:57,680 --> 00:09:04,840
Więc to jest naprawdę mówi 49 oraz 49, a
ostatecznie to będzie drukować 98.

202
00:09:04,840 --> 00:09:06,130
Więc to nie drukuje 2.

203
00:09:06,130 --> 00:09:08,070

204
00:09:08,070 --> 00:09:09,271
>> Pytanie 17.

205
00:09:09,271 --> 00:09:11,520
Zakończenie wdrażania
nieparzystych poniżej w taki sposób,

206
00:09:11,520 --> 00:09:14,615
że funkcja zwraca true, jeśli
n jest nieparzyste i false jeśli n jest parzyste.

207
00:09:14,615 --> 00:09:16,710

208
00:09:16,710 --> 00:09:19,330
To jest wielki cel
dla operatora mod.

209
00:09:19,330 --> 00:09:24,530
Więc bierzemy argument n,
jeśli n mod 2 jest równa 1, oraz

210
00:09:24,530 --> 00:09:28,030
oznacza to, że n podzielony
przez 2 miał resztę.

211
00:09:28,030 --> 00:09:33,270
Jeśli n dzieli się przez 2 miał resztę, że
Oznacza to, że n jest nieparzyste, więc wracamy prawda.

212
00:09:33,270 --> 00:09:34,910
Indziej return false.

213
00:09:34,910 --> 00:09:39,070
Ty też mógł to zrobić n mod 2 równych
zero, return false, w przeciwnym wypadku zwraca wartość true.

214
00:09:39,070 --> 00:09:41,600

215
00:09:41,600 --> 00:09:43,640
>> Rozważmy funkcję rekurencyjną poniżej.

216
00:09:43,640 --> 00:09:46,920
Tak więc, jeśli n jest mniejsze niż lub
równej 1, powrót 1

217
00:09:46,920 --> 00:09:50,430
else return n razy f n minus jeden.

218
00:09:50,430 --> 00:09:52,556
Więc co to jest funkcja?

219
00:09:52,556 --> 00:09:54,305
Cóż, to jest po prostu
silnia funkcja.

220
00:09:54,305 --> 00:09:55,410

221
00:09:55,410 --> 00:09:57,405
To jest ładnie reprezentowany
jak n silnia.

222
00:09:57,405 --> 00:09:58,720

223
00:09:58,720 --> 00:10:02,310
>> Więc pytanie 19 teraz, chcemy
skorzystać z tej funkcji rekurencyjnej.

224
00:10:02,310 --> 00:10:04,530
Chcemy, aby to wielokrotnie.

225
00:10:04,530 --> 00:10:05,874
Więc jak to zrobić?

226
00:10:05,874 --> 00:10:07,790
Cóż dla pracowników
rozwiązanie, i znowu tam

227
00:10:07,790 --> 00:10:11,090
wiele sposobów mogłeś zrobić
że zaczynamy z tego produktu int

228
00:10:11,090 --> 00:10:11,812
jest równa 1.

229
00:10:11,812 --> 00:10:13,520
I przez to
pętli, będziemy

230
00:10:13,520 --> 00:10:17,590
być pomnożenie produkt ostatecznie
skończyć z pełnym silni.

231
00:10:17,590 --> 00:10:21,870
Więc dla int i równa się dwa, i to
mniejsza lub równa n, i ++.

232
00:10:21,870 --> 00:10:24,130
>> Można się zastanawiać, dlaczego i równa się dwa.

233
00:10:24,130 --> 00:10:28,380
Cóż, należy pamiętać, że mamy tu do
upewnij się, że w naszym przypadku bazą jest prawidłowe.

234
00:10:28,380 --> 00:10:32,180
Tak więc, jeśli n jest mniejszy niż lub równy
1, jesteśmy po prostu wraca jeden.

235
00:10:32,180 --> 00:10:34,830
Więc tutaj, że zaczynają się i równa się dwa.

236
00:10:34,830 --> 00:10:39,090
Cóż, gdybym był jeden, potem the-- lub
jeśli n były 1, to dla pętli

237
00:10:39,090 --> 00:10:40,600
nie wykonywać w ogóle.

238
00:10:40,600 --> 00:10:43,190
I tak po prostu
Produkt zwrot, który jest jeden.

239
00:10:43,190 --> 00:10:45,920
Podobnie, jeśli brak było
coś mniej niż 1--

240
00:10:45,920 --> 00:10:49,290
gdyby było 0, ujemne 1, whatever--
my nadal powrocie 1,

241
00:10:49,290 --> 00:10:52,260
który jest dokładnie to, co
wersja rekurencyjna robi.

242
00:10:52,260 --> 00:10:54,660
>> Teraz, gdy n jest większe
niż 1, wtedy będziemy

243
00:10:54,660 --> 00:10:56,550
zrobić co najmniej jeden
iteracji pętli.

244
00:10:56,550 --> 00:11:00,630
Więc powiedzmy, n wynosi 5, a następnie jesteśmy
zrobi razy produktu wynosi 2.

245
00:11:00,630 --> 00:11:02,165
Teraz produkt jest 2.

246
00:11:02,165 --> 00:11:04,040
Teraz mamy zamiar zrobić
Czasy produktu wynosi 3.

247
00:11:04,040 --> 00:11:04,690
Teraz jest 6.

248
00:11:04,690 --> 00:11:07,500
Czasy produktu wynosi 4, teraz jest 24.

249
00:11:07,500 --> 00:11:10,420
Czasy produktu wynosi 5, teraz jest 120.

250
00:11:10,420 --> 00:11:16,730
Tak więc ostatecznie, mamy powrót
120, który jest prawidłowo 5 silni.

251
00:11:16,730 --> 00:11:17,510
>> Pytanie 20.

252
00:11:17,510 --> 00:11:22,480
To jest jeden, gdzie trzeba wypełnić
W tabeli z dowolnym algorytmie

253
00:11:22,480 --> 00:11:25,735
wszystko, co widzieliśmy, że
wpisuje te algorytmicznego bieg

254
00:11:25,735 --> 00:11:28,060
Czasy te asymptotyczne czasów pracy.

255
00:11:28,060 --> 00:11:33,270
Więc co jest algorytm, który
jest omega 1, ale duże O n?

256
00:11:33,270 --> 00:11:35,970
Więc nie może być nieskończenie
wiele odpowiedzi tutaj.

257
00:11:35,970 --> 00:11:39,790
Który widzieliśmy prawdopodobnie najbardziej
często jest tak liniowa wyszukiwarek.

258
00:11:39,790 --> 00:11:42,050
>> Tak więc w najlepszym wypadku
Scenariusz, poz jesteśmy

259
00:11:42,050 --> 00:11:44,050
szukasz jest w
początku listy

260
00:11:44,050 --> 00:11:47,400
i tak w omega z krokiem 1,
Pierwszą rzeczą, którą sprawdzić,

261
00:11:47,400 --> 00:11:49,740
po prostu natychmiast wrócić
że znaleźliśmy ten element.

262
00:11:49,740 --> 00:11:52,189
W najgorszym przypadku,
Element jest na końcu,

263
00:11:52,189 --> 00:11:53,730
lub element nie ma na liście w ogóle.

264
00:11:53,730 --> 00:11:56,700
Musimy więc szukać
Cała lista, wszystkie n

265
00:11:56,700 --> 00:11:58,480
elementy, a to dlatego, że to o n.

266
00:11:58,480 --> 00:11:59,670

267
00:11:59,670 --> 00:12:04,880
>> Więc teraz jest to coś, co jest zarówno
omega n log n, a duże O n log n.

268
00:12:04,880 --> 00:12:08,650
Cóż, co najbardziej istotne
widzieliśmy tutaj jest połączyć rodzaju.

269
00:12:08,650 --> 00:12:12,950
Więc połączyć rodzaj, pamiętaj,
jest ostatecznie Theta

270
00:12:12,950 --> 00:12:16,920
log n, gdzie n jest zdefiniowane theta
gdy oba omega i duże O są takie same.

271
00:12:16,920 --> 00:12:17,580
Zarówno n log n.

272
00:12:17,580 --> 00:12:18,690

273
00:12:18,690 --> 00:12:21,970
>> Co znajduje się coś, co jest omega
N, i O, n kwadratu?

274
00:12:21,970 --> 00:12:23,990
Cóż, znowu nie ma
wiele możliwych odpowiedzi.

275
00:12:23,990 --> 00:12:26,440
Tu stanie powiedzieć, sortowanie bąbelkowe.

276
00:12:26,440 --> 00:12:28,840
Sortowanie przez wstawianie tutaj również działa.

277
00:12:28,840 --> 00:12:31,400
Pamiętaj, że sortowanie bąbelkowe
tam gdzie ma to optymalizacja,

278
00:12:31,400 --> 00:12:34,630
jeśli jesteś w stanie uzyskać
przez całą listę

279
00:12:34,630 --> 00:12:37,402
bez konieczności zrobić
wszelkie swapy, to dobrze,

280
00:12:37,402 --> 00:12:40,110
możemy od razu wrócić, że
Lista została posortowana na początku.

281
00:12:40,110 --> 00:12:43,185
Tak więc w najlepszym przypadku,
to tylko omega n.

282
00:12:43,185 --> 00:12:45,960
Jeśli to nie jest po prostu ładnie
posortowana lista na początek,

283
00:12:45,960 --> 00:12:48,270
następnie mamy O n kwadratu swapy.

284
00:12:48,270 --> 00:12:49,330

285
00:12:49,330 --> 00:12:55,610
I wreszcie mamy wyboru rodzaju
dla n do kwadratu, jak i duże O. omega

286
00:12:55,610 --> 00:12:56,850
>> Pytanie 21.

287
00:12:56,850 --> 00:12:58,870
Co znajduje się liczba całkowita przepełnienia?

288
00:12:58,870 --> 00:13:02,160
Wyzdrowieć, podobnie jak powyżej,
mamy tylko skończenie wiele bitów

289
00:13:02,160 --> 00:13:04,255
z oznacza liczbę całkowitą,
Może więc 32 bitów.

290
00:13:04,255 --> 00:13:06,300

291
00:13:06,300 --> 00:13:09,180
Powiedzmy, że mamy podpisaną całkowitą.

292
00:13:09,180 --> 00:13:12,800
Wtedy ostatecznie najwyższa
liczba dodatnia możemy reprezentować

293
00:13:12,800 --> 00:13:15,910
wynosi od 2 do 31 minus 1.

294
00:13:15,910 --> 00:13:19,370
Więc co się dzieje, gdy próbujemy
następnie zwiększyć tę liczbę całkowitą?

295
00:13:19,370 --> 00:13:25,320
Cóż, mamy zamiar przejść od 2 do 31
minus 1, w dół do negatywnej 2

296
00:13:25,320 --> 00:13:26,490
do 31.

297
00:13:26,490 --> 00:13:29,470
Tak więc jest to całkowita przepełnienia
kiedy trzymasz zwiększając,

298
00:13:29,470 --> 00:13:32,330
i ostatecznie nie można
nic wyższa i to właśnie

299
00:13:32,330 --> 00:13:34,520
owija całą drogę
wokół do wartości ujemnej.

300
00:13:34,520 --> 00:13:35,850

301
00:13:35,850 --> 00:13:37,779
>> Co o przepełnienie bufora?

302
00:13:37,779 --> 00:13:39,820
Więc bufor overflow--
pamiętam, co jest bufor.

303
00:13:39,820 --> 00:13:41,000
To tylko fragment pamięci.

304
00:13:41,000 --> 00:13:43,350
Coś w tablicy jest bufor.

305
00:13:43,350 --> 00:13:46,120
Tak jest w przypadku przepełnienia bufora
próby uzyskania dostępu do pamięci

306
00:13:46,120 --> 00:13:47,880
poza końcem tablicy.

307
00:13:47,880 --> 00:13:50,410
Więc jeśli masz
tablica rozmiarów 5 i Ciebie

308
00:13:50,410 --> 00:13:53,700
próby uzyskania dostępu wspornik tablicy
5 lub 6 lub wspornik wspornik 7

309
00:13:53,700 --> 00:13:56,610
czy coś poza
koniec, lub nawet coś

310
00:13:56,610 --> 00:14:00,790
Uchwyt tablicy below-- negatywne 1--
wszystkie z nich są przepełnienia bufora.

311
00:14:00,790 --> 00:14:02,810
Jesteś dotykania pamięci w złych sposobów.

312
00:14:02,810 --> 00:14:04,090

313
00:14:04,090 --> 00:14:04,730
>> Pytanie 23.

314
00:14:04,730 --> 00:14:05,760

315
00:14:05,760 --> 00:14:09,100
Więc w tym jednym trzeba
wdrożyć strlen.

316
00:14:09,100 --> 00:14:11,630
I powiedzieć, że można
Zakładamy, e nie będzie pusty,

317
00:14:11,630 --> 00:14:13,790
więc nie masz do
wykonywać żadnej czek na null.

318
00:14:13,790 --> 00:14:16,190
I istnieje wiele sposobów
można tego zrobić.

319
00:14:16,190 --> 00:14:18,440
Tu po prostu wziąć prosty.

320
00:14:18,440 --> 00:14:21,780
Zaczynamy z licznikiem, n. n jest
liczenie, ile znaków jest.

321
00:14:21,780 --> 00:14:25,560
Więc zaczynamy od 0, a potem
iteracji przez całą listę.

322
00:14:25,560 --> 00:14:29,092
>> S jest równe 0 wspornik
znak null terminator?

323
00:14:29,092 --> 00:14:31,425
Pamiętaj szukamy
znak null terminator

324
00:14:31,425 --> 00:14:33,360
aby określić, jak długo nasz łańcuch jest.

325
00:14:33,360 --> 00:14:35,890
Że ma zamiar zakończyć
wszelkie istotne ciąg.

326
00:14:35,890 --> 00:14:39,400
Więc jest równa s wspornik 0
do terminator null?

327
00:14:39,400 --> 00:14:42,850
Jeśli nie jest, to będziemy
spojrzeć na ów uchwyt wspornika 1, s 2.

328
00:14:42,850 --> 00:14:45,050
Wciąż tu, dopóki nie
znaleźć NUL.

329
00:14:45,050 --> 00:14:48,580
Kiedy już go znajdziesz, to n zawiera
Całkowita długość łańcucha,

330
00:14:48,580 --> 00:14:49,942
a może po prostu wrócić, że.

331
00:14:49,942 --> 00:14:51,180

332
00:14:51,180 --> 00:14:51,865
>> Pytanie 24.

333
00:14:51,865 --> 00:14:53,010

334
00:14:53,010 --> 00:14:56,050
Więc to jest ten, w którym
trzeba zrobić kompromis.

335
00:14:56,050 --> 00:14:59,810
Więc jedno jest dobre w jednym
sposób, ale w jaki sposób to jest złe?

336
00:14:59,810 --> 00:15:02,980
Więc, ma tendencję do scalania sortowania
szybciej niż sortowanie bąbelkowe.

337
00:15:02,980 --> 00:15:06,530
Mimo, that-- dobrze,
tutaj jest kilka odpowiedzi.

338
00:15:06,530 --> 00:15:12,930
Ale głównym z nich jest to, że sortowanie bąbelkowe
jest omega n na liście sortowane.

339
00:15:12,930 --> 00:15:14,950
>> Pamiętaj, że stół właśnie widzieliśmy wcześniej.

340
00:15:14,950 --> 00:15:17,600
Więc bańka sortuje omega
n, najlepszy scenariusz

341
00:15:17,600 --> 00:15:20,010
jest to w stanie po prostu przejść nad
Lista raz, określić

342
00:15:20,010 --> 00:15:22,270
hej, to jest to już
klasyfikowane i powrotu.

343
00:15:22,270 --> 00:15:25,960
Sortowanie przez scalanie, bez względu na to, co
zrobić, to omega n log n.

344
00:15:25,960 --> 00:15:29,200
Więc dla posortowanej listy, bańki
rodzaj będzie szybciej.

345
00:15:29,200 --> 00:15:30,870

346
00:15:30,870 --> 00:15:32,430
>> Co teraz o związane list?

347
00:15:32,430 --> 00:15:36,070
Tak powiązana lista może rosnąć i kurczyć
aby zmieścić tak wiele elementów, ile potrzeba.

348
00:15:36,070 --> 00:15:38,489
Mimo, that-- tak
zwykle bezpośrednie porównanie

349
00:15:38,489 --> 00:15:40,280
będzie związane
listy z tablicy.

350
00:15:40,280 --> 00:15:41,600

351
00:15:41,600 --> 00:15:44,050
Dlatego, mimo że tablice mogą
łatwo rosnąć i kurczyć

352
00:15:44,050 --> 00:15:47,130
aby zmieścić tak wiele elementów
w razie potrzeby, wykaz związane

353
00:15:47,130 --> 00:15:49,600
porównaniu z an array--
tablica ma swobodny dostęp.

354
00:15:49,600 --> 00:15:52,960
Możemy w dowolnym indeksu
zwłaszcza element tablicy.

355
00:15:52,960 --> 00:15:56,430
>> Tak dla połączonej listy, nie możemy
wystarczy przejść do piątego elementu,

356
00:15:56,430 --> 00:16:00,260
musimy przechodzić od początku
aż dojdziemy do piątego elementu.

357
00:16:00,260 --> 00:16:03,990
I to się dzieje, aby powstrzymać nas od
robi coś takiego wyszukiwania binarnego.

358
00:16:03,990 --> 00:16:08,150
Mówiąc o poszukiwaniu binarnego, wyszukiwania binarnego
wydaje się być szybszy od wyszukiwania liniowego.

359
00:16:08,150 --> 00:16:11,120
Mimo, that--
tak, jedną z możliwych rzeczy

360
00:16:11,120 --> 00:16:13,380
jest to, że nie można zrobić binarne
szukaj na połączonych list

361
00:16:13,380 --> 00:16:14,730
można tylko zrobić na tablicach.

362
00:16:14,730 --> 00:16:18,030
Ale chyba ważniejsze,
nie możesz zrobić wyszukiwanie binarne

363
00:16:18,030 --> 00:16:20,690
na tablicy, która nie jest posortowane.

364
00:16:20,690 --> 00:16:23,990
Z góry może trzeba uporządkować
tablicy, a dopiero potem można

365
00:16:23,990 --> 00:16:25,370
zrobić wyszukiwanie binarne.

366
00:16:25,370 --> 00:16:27,660
Więc jeśli coś nie jest
sortowane, aby rozpocząć,

367
00:16:27,660 --> 00:16:29,250
to wyszukiwarka liniowy może być szybciej.

368
00:16:29,250 --> 00:16:30,620

369
00:16:30,620 --> 00:16:31,740
>> Pytanie 27.

370
00:16:31,740 --> 00:16:34,770
Więc rozważyć poniżej program,
co będzie w następnym slajdzie.

371
00:16:34,770 --> 00:16:37,790
I to jest jeden, gdzie jesteśmy
będzie chciał, aby jednoznacznie stwierdzić,

372
00:16:37,790 --> 00:16:39,980
wartości różnych zmiennych.

373
00:16:39,980 --> 00:16:41,990
Więc spójrzmy na to.

374
00:16:41,990 --> 00:16:43,160
>> Więc linii jeden.

375
00:16:43,160 --> 00:16:45,457
Mamy int x jest równa 1.

376
00:16:45,457 --> 00:16:47,040
To jedyna rzecz, która się stało.

377
00:16:47,040 --> 00:16:50,440
Tak więc w pierwszej linii, widzimy w naszym
Stół, że y, a, b, i tmp są

378
00:16:50,440 --> 00:16:51,540
zaciemnione.

379
00:16:51,540 --> 00:16:52,280
Więc co jest x?

380
00:16:52,280 --> 00:16:53,860
Cóż, po prostu ustawić go na wartość 1.

381
00:16:53,860 --> 00:16:55,020

382
00:16:55,020 --> 00:16:58,770
A potem druga linia, dobrze,
możemy zobaczyć, że Y jest ustawiony na 2,

383
00:16:58,770 --> 00:17:00,550
i tabela jest już
wypełnione dla nas.

384
00:17:00,550 --> 00:17:03,040
Tak x oznacza 1, y oznacza 2.

385
00:17:03,040 --> 00:17:05,890
>> Teraz linia trzy, teraz jesteśmy
wewnątrz funkcji swap.

386
00:17:05,890 --> 00:17:07,560
Co możemy przejść do wymiany?

387
00:17:07,560 --> 00:17:11,609
Minęliśmy ampersand x dla
, oraz handlowego y dla b.

388
00:17:11,609 --> 00:17:15,160
Gdy problem wcześniej
stwierdził, że adres x

389
00:17:15,160 --> 00:17:17,520
jest 0x10 i adres y jest 0x14.

390
00:17:17,520 --> 00:17:18,970

391
00:17:18,970 --> 00:17:21,909
Tak więc i b są równe
0x10 i 0x14, odpowiednio.

392
00:17:21,909 --> 00:17:23,670

393
00:17:23,670 --> 00:17:26,250
>> Teraz w linii trzech, jakie są X i Y?

394
00:17:26,250 --> 00:17:28,554
Cóż, nic się nie zmieniło
o x i y w tym momencie.

395
00:17:28,554 --> 00:17:30,470
Mimo, że są one
wewnątrz ramy głównej stos arkuszy

396
00:17:30,470 --> 00:17:32,469
nadal mają takie same
Wartości przedtem.

397
00:17:32,469 --> 00:17:34,030
Nie modyfikować żadnej pamięci.

398
00:17:34,030 --> 00:17:35,710
Tak x oznacza 1, y oznacza 2.

399
00:17:35,710 --> 00:17:36,550

400
00:17:36,550 --> 00:17:37,050
Dobrze.

401
00:17:37,050 --> 00:17:40,300
Więc teraz powiedzieliśmy int tmp równa gwiazda.

402
00:17:40,300 --> 00:17:44,410
Więc w linii cztery, wszystko
są identyczne, z wyjątkiem tmp.

403
00:17:44,410 --> 00:17:47,130
Nie zmieniły się żadnych wartości
niczego z wyjątkiem tmp.

404
00:17:47,130 --> 00:17:49,230
Wyznaczamy tmp równą gwiazda.

405
00:17:49,230 --> 00:17:50,620
Co to jest gwiazda?

406
00:17:50,620 --> 00:17:56,240
No, a punkty x, więc gwiazda
ma równej x, który oznacza 1.

407
00:17:56,240 --> 00:18:00,080
Więc wszystko jest kopiowany
w dół, a tmp jest ustawiony na 1.

408
00:18:00,080 --> 00:18:01,110
>> Teraz następna linia.

409
00:18:01,110 --> 00:18:03,380
Gwiazda gwiazda równa się b.

410
00:18:03,380 --> 00:18:10,000
Więc po linii five-- dobrze znowu wszystko
to samo z wyjątkiem, co gwiazda jest.

411
00:18:10,000 --> 00:18:10,830
Co to jest gwiazda?

412
00:18:10,830 --> 00:18:13,720
Cóż, po prostu powiedziała gwiazda jest x.

413
00:18:13,720 --> 00:18:16,400
Więc zmieniamy x równego gwiazdkowy b.

414
00:18:16,400 --> 00:18:18,960
Co to jest gwiazda b? y. Punkty B do y.

415
00:18:18,960 --> 00:18:21,030
Tak gwiazda b jest r.

416
00:18:21,030 --> 00:18:25,140
Więc ustawiamy x równe y,
i wszystko inne jest takie samo.

417
00:18:25,140 --> 00:18:29,130
Widzimy więc, w następnym rzędzie, że x jest teraz
2, a reszta jest po prostu kopiowane.

418
00:18:29,130 --> 00:18:31,120
>> Teraz w następnej linii, gwiazda b równa tmp.

419
00:18:31,120 --> 00:18:34,740
Cóż, po prostu powiedziała gwiazda b jest y,
więc ustawiamy y równa tmp.

420
00:18:34,740 --> 00:18:37,450
Wszystko inne jest takie samo,
więc wszystko zostanie skopiowane w dół.

421
00:18:37,450 --> 00:18:42,050
Jesteśmy ustawienie y równą PZT, który jest
jeden, a wszystko inne jest takie samo.

422
00:18:42,050 --> 00:18:43,210
>> Teraz wreszcie linia siedem.

423
00:18:43,210 --> 00:18:44,700
Jesteśmy z powrotem w głównej funkcji.

424
00:18:44,700 --> 00:18:46,350
Jesteśmy po zakończeniu wymiany.

425
00:18:46,350 --> 00:18:48,972
Straciliśmy A, B, i
tmp, ale w końcu mamy

426
00:18:48,972 --> 00:18:51,180
nie zmieniając żadnych wartości
nic w tym momencie,

427
00:18:51,180 --> 00:18:52,800
po prostu skopiować X i Y w dół.

428
00:18:52,800 --> 00:18:56,490
I widzimy, że X i Y są
teraz 2 i 1, a nie 1 i 2.

429
00:18:56,490 --> 00:18:58,160
Swap z powodzeniem realizowane.

430
00:18:58,160 --> 00:18:59,500

431
00:18:59,500 --> 00:19:00,105
>> Pytanie 28.

432
00:19:00,105 --> 00:19:01,226

433
00:19:01,226 --> 00:19:03,100
Załóżmy, że możesz napotkać
komunikaty o błędach

434
00:19:03,100 --> 00:19:06,790
poniżej w godzinach pracy
w przyszłym roku jako CA lub TF.

435
00:19:06,790 --> 00:19:08,930
Doradzić, jak rozwiązać każdy z tych błędów.

436
00:19:08,930 --> 00:19:11,160
Tak nieokreślone odniesienie do getString.

437
00:19:11,160 --> 00:19:12,540
Dlaczego można zobaczyć?

438
00:19:12,540 --> 00:19:15,380
No cóż, jeśli student korzysta
GetString w kodzie,

439
00:19:15,380 --> 00:19:20,310
Hash one prawidłowo ujęte CS50
kropka h zawierać bibliotekę CS50.

440
00:19:20,310 --> 00:19:22,380
>> Cóż, co one
trzeba naprawić ten błąd?

441
00:19:22,380 --> 00:19:26,810
Muszą zrobić lcs50 kreska na
wiersz poleceń, gdy są kompilacji.

442
00:19:26,810 --> 00:19:29,501
Więc jeśli nie przejdzie
dzyń kreska lcs50, są

443
00:19:29,501 --> 00:19:32,000
nie będzie mieć rzeczywisty
Kod, który implementuje getString.

444
00:19:32,000 --> 00:19:33,190

445
00:19:33,190 --> 00:19:34,170
>> Pytanie 29.

446
00:19:34,170 --> 00:19:36,190
Pośrednio deklarując
Funkcja biblioteki strlen.

447
00:19:36,190 --> 00:19:37,550

448
00:19:37,550 --> 00:19:40,360
No to teraz, nie mają
zrobić właściwego mieszania obejmują.

449
00:19:40,360 --> 00:19:41,440

450
00:19:41,440 --> 00:19:45,410
W tym konkretnym przypadku, nagłówek pliku
muszą to jest ciąg kropka h,

451
00:19:45,410 --> 00:19:48,710
i tym smyczkowy dot h, obecnie
student-- teraz kompilator

452
00:19:48,710 --> 00:19:51,750
ma dostęp do
deklaracje strlen,

453
00:19:51,750 --> 00:19:54,120
i wie, że kod
używa poprawnie strlen.

454
00:19:54,120 --> 00:19:55,380

455
00:19:55,380 --> 00:19:56,580
>> Pytanie 30.

456
00:19:56,580 --> 00:20:00,240
Więcej procent konwersji
niż argumentów danych.

457
00:20:00,240 --> 00:20:01,540
Więc co to jest?

458
00:20:01,540 --> 00:20:06,470
Dobrze pamiętam, że to procent
signs-- jak są one istotne dla printf.

459
00:20:06,470 --> 00:20:08,890
Więc w printf możemy percent--
możemy wydrukować coś

460
00:20:08,890 --> 00:20:11,380
jak procent i interpretacja odwrotnego ukośnika n.

461
00:20:11,380 --> 00:20:15,310
Albo możemy drukować jak procent i,
Przestrzeń, procent i, przestrzeń, procent i.

462
00:20:15,310 --> 00:20:18,950
Tak więc dla każdego z tych
procent objawy, musimy

463
00:20:18,950 --> 00:20:21,560
przekazać zmienną na końcu printf.

464
00:20:21,560 --> 00:20:26,980
>> Więc jeśli mówimy nawias printf procent
i interpretacja odwrotnego ukośnika n bliskie paren,

465
00:20:26,980 --> 00:20:30,270
dobrze, możemy powiedzieć, że jesteśmy
zamiar wydrukować liczbę całkowitą,

466
00:20:30,270 --> 00:20:33,970
ale potem nie przechodzą printf
całkowita rzeczywiście wydrukować.

467
00:20:33,970 --> 00:20:37,182
Więc tutaj więcej procent
konwersje niż argumentów danych?

468
00:20:37,182 --> 00:20:39,390
To mówi, że mamy
cała masa procentach,

469
00:20:39,390 --> 00:20:42,445
i nie mamy wystarczająco dużo zmiennych
rzeczywiście wypełnienie tych procentach.

470
00:20:42,445 --> 00:20:44,850

471
00:20:44,850 --> 00:20:50,010
>> I to na pewno, na pytanie 31,
zdecydowanie stracił 40 bajtów w jednym bloków.

472
00:20:50,010 --> 00:20:52,350
Więc to jest błąd Valgrind.

473
00:20:52,350 --> 00:20:54,720
Ten mówi, że
gdzieś w kodzie,

474
00:20:54,720 --> 00:20:59,010
masz przydział, który jest 40
bajtów duży więc malloced 40 bajtów,

475
00:20:59,010 --> 00:21:00,515
i nigdy nie uwolnił go.

476
00:21:00,515 --> 00:21:02,480

477
00:21:02,480 --> 00:21:05,140
Najprawdopodobniej wystarczy
znaleźć jakiś wyciek pamięci,

478
00:21:05,140 --> 00:21:07,650
i dowiedzieć się, gdzie trzeba
uwolnić ten blok pamięci.

479
00:21:07,650 --> 00:21:08,780

480
00:21:08,780 --> 00:21:11,910
>> I pytanie 32,
nieważny zapis wielkości 4.

481
00:21:11,910 --> 00:21:13,250
Znowu jest to błąd Valgrind.

482
00:21:13,250 --> 00:21:15,440
To nie musi robić
z wycieków pamięci teraz.

483
00:21:15,440 --> 00:21:20,750
Jest to najbardziej likely-- To znaczy, że to
jakiś nieprawidłowych praw pamięci.

484
00:21:20,750 --> 00:21:23,270
I najprawdopodobniej jest to jakiś
rodzaju przepełnienia bufora.

485
00:21:23,270 --> 00:21:26,560
Gdzie masz tablicę, może
Tablica całkowita, i niech

486
00:21:26,560 --> 00:21:30,115
mówią, że to od rozmiaru 5, a
spróbuj dotknąć wspornik tablicy 5.

487
00:21:30,115 --> 00:21:34,150
Więc jeśli próbujesz pisać, że
wartość, to nie jest bułka z pamięci

488
00:21:34,150 --> 00:21:37,440
że faktycznie mają dostęp do, i
więc masz zamiar uzyskać ten błąd,

489
00:21:37,440 --> 00:21:39,272
mówiąc, nieprawidłowy zapis wielkości 4.

490
00:21:39,272 --> 00:21:42,480
Valgrind będzie rozpoznać, że jesteś
próbując dotknąć pamięci niewłaściwie.

491
00:21:42,480 --> 00:21:43,980
>> I to dla quiz0.

492
00:21:43,980 --> 00:21:47,065
Jestem Rob Bowden, a to jest CS50.

493
00:21:47,065 --> 00:21:51,104