1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Rozdział 4] [mniej wygodne]

2
00:00:02,000 --> 00:00:04,000
[Nate Hardison] [Harvard University]

3
00:00:04,000 --> 00:00:07,000
[To jest CS50.] [CS50.TV]

4
00:00:07,000 --> 00:00:10,000
>> Dobra, witamy z powrotem do sekcji.

5
00:00:10,000 --> 00:00:13,000
W tym tygodniu w dziale mamy zamiar zrobić kilka rzeczy.

6
00:00:13,000 --> 00:00:17,000
Jedziemy do pierwszego zestawu Problem podsumować 2,

7
00:00:17,000 --> 00:00:20,000
który jest zbiorem problemów Cezar i Vigenère.

8
00:00:20,000 --> 00:00:23,000
I wtedy będziemy nurkować w Quiz 0 recenzji

9
00:00:23,000 --> 00:00:26,000
i spędzić trochę czasu bieżnikowania co rozmawialiśmy o

10
00:00:26,000 --> 00:00:30,000
w każdym z wykładów tak daleko, a my też zrobić kilka problemów

11
00:00:30,000 --> 00:00:32,000
z poprzedniego roku quizy.

12
00:00:32,000 --> 00:00:36,000
W ten sposób macie dobry sposób na przygotowanie się do tego.

13
00:00:36,000 --> 00:00:40,000
>> Aby rozpocząć, mam uruchomiony się kilka dobrych rozwiązań

14
00:00:40,000 --> 00:00:45,000
do poprzedniego zestawu problemów, problem Set 2, do tej przestrzeni.

15
00:00:45,000 --> 00:00:48,000
Jeśli faceci wszyscy uderzyć ten link,

16
00:00:48,000 --> 00:00:53,000
i po kliknięciu na mój nazwę i kliknij na mojej pierwszej rewizji

17
00:00:53,000 --> 00:00:56,000
zobaczysz caesar.c, który jest dokładnie to, co patrzę.

18
00:00:56,000 --> 00:01:00,000
Porozmawiajmy o tym bardzo szybko.

19
00:01:00,000 --> 00:01:02,000
To jest tylko roztwór próbki.

20
00:01:02,000 --> 00:01:05,000
To niekoniecznie jest idealne rozwiązanie.

21
00:01:05,000 --> 00:01:08,000
Istnieje wiele różnych sposobów na napisanie tego

22
00:01:08,000 --> 00:01:10,000
ale jest kilka rzeczy, które chciałem, aby podświetlić

23
00:01:10,000 --> 00:01:13,000
które widziałem, jak byłem klasyfikacji, typowych błędów, które myślę, że

24
00:01:13,000 --> 00:01:18,000
Rozwiązanie to ma bardzo dobrą pracę obsługi.

25
00:01:18,000 --> 00:01:22,000
>> Pierwszy jest o jakiś komentarz nagłówka w górnej.

26
00:01:22,000 --> 00:01:25,000
Na liniach 1 do 7, aby zobaczyć szczegóły,

27
00:01:25,000 --> 00:01:28,000
Co dokładnie ten program robi.

28
00:01:28,000 --> 00:01:32,000
Dobry standard praktyka podczas pisania kodu C

29
00:01:32,000 --> 00:01:35,000
niezależnie od tego czy program jest zawarty w jednym pliku lub

30
00:01:35,000 --> 00:01:38,000
czy jest podzielona na wiele plików jest mieć jakiś

31
00:01:38,000 --> 00:01:40,000
orientowania komentarz na szczycie.

32
00:01:40,000 --> 00:01:43,000
Jest to również dla ludzi, którzy wychodzą i napisać kod w świecie rzeczywistym.

33
00:01:43,000 --> 00:01:47,000
To jest, gdzie oni umieścić informacje o prawach autorskich.

34
00:01:47,000 --> 00:01:50,000
Poniżej # zawiera.

35
00:01:50,000 --> 00:01:55,000
W linii 16 jest jeszcze to: # define, który wrócimy w tylko trochę.

36
00:01:55,000 --> 00:01:59,000
A następnie raz funkcja uruchamia raz główne starty,

37
00:01:59,000 --> 00:02:03,000
Ponieważ program został wszystkie zawarte w jednej funkcji

38
00:02:03,000 --> 00:02:09,000
Pierwszą rzeczą, która się dzieje i to jest bardzo idiomatyczne i typowy program C

39
00:02:09,000 --> 00:02:14,000
które ma w linii poleceń argumenty-jest to, że natychmiast sprawdza

40
00:02:14,000 --> 00:02:18,000
>> dla liczby argumentów, argc.

41
00:02:18,000 --> 00:02:24,000
Tutaj widzimy, że program oczekuje 2 argumenty dokładnie.

42
00:02:24,000 --> 00:02:27,000
Pamiętaj, że istnieje pierwszy argument, że to wyjątkowy

43
00:02:27,000 --> 00:02:29,000
to zawsze nazwa programu, który jest uruchomiony,

44
00:02:29,000 --> 00:02:31,000
nazwa pliku wykonywalnego.

45
00:02:31,000 --> 00:02:36,000
I tak, co to robi to uniemożliwia użytkownikowi uruchomienie programu

46
00:02:36,000 --> 00:02:42,000
z bardziej lub mniej argumentów.

47
00:02:42,000 --> 00:02:44,000
Powodem, dla którego chcesz sprawdzić, to od razu, ponieważ

48
00:02:44,000 --> 00:02:52,000
nie możemy faktycznie uzyskać dostęp do tej tablicy argv tu niezawodnie

49
00:02:52,000 --> 00:02:55,000
dopóki nie sprawdzane, aby zobaczyć, jak duże jest.

50
00:02:55,000 --> 00:02:58,000
>> Jednym z najczęstszych błędów widziałem było ludzie natychmiast iść

51
00:02:58,000 --> 00:03:01,000
i grab argv [1].

52
00:03:01,000 --> 00:03:06,000
Oni chwycić kluczowy argument z tablicy i nie do i sprawdzić na nim,

53
00:03:06,000 --> 00:03:11,000
a potem robią test na argc oraz następnego testu,

54
00:03:11,000 --> 00:03:16,000
czy pierwszy argument rzeczywiście całkowitą w tym samym czasie,

55
00:03:16,000 --> 00:03:20,000
i to nie działa, ponieważ w przypadku, że nie istnieją żadne argumenty podane

56
00:03:20,000 --> 00:03:26,000
będziesz chwytając argument, że tam nie ma lub stara się złapać jeden, który nie ma.

57
00:03:26,000 --> 00:03:29,000
>> Inne duże rzeczy, które należy zauważyć, jest to, że

58
00:03:29,000 --> 00:03:32,000
zawsze chcesz wydrukować jakiś pomocny komunikat o błędzie

59
00:03:32,000 --> 00:03:34,000
do użytkownika, aby zorientować im.

60
00:03:34,000 --> 00:03:37,000
Jestem pewien, że masz wszystkie programy działają, gdy nagle się zawiesi,

61
00:03:37,000 --> 00:03:41,000
i masz ten śmieszny mały okno, które pojawia się i mówi:

62
00:03:41,000 --> 00:03:44,000
coś strasznie tajemniczy i być może daje się kod błędu lub coś takiego

63
00:03:44,000 --> 00:03:47,000
że nie ma sensu.

64
00:03:47,000 --> 00:03:50,000
To jest miejsce, gdzie naprawdę chcesz przekazać coś jako

65
00:03:50,000 --> 00:03:54,000
i skierowane do użytkownika, tak, że kiedy go uruchomić idą "Och," face palm.

66
00:03:54,000 --> 00:03:58,000
"Wiem dokładnie, co robić. Wiem jak to naprawić."

67
00:03:58,000 --> 00:04:01,000
>> Jeśli nie wypisuje komunikatu, a następnie kończy się rzeczywiście

68
00:04:01,000 --> 00:04:04,000
pozostawiając użytkownikowi przejść badania kodu źródłowego

69
00:04:04,000 --> 00:04:07,000
dowiedzieć się, co poszło źle.

70
00:04:07,000 --> 00:04:11,000
Jest też kilka razy, że będziesz korzystać z różnych kodów błędów.

71
00:04:11,000 --> 00:04:14,000
Tutaj mamy tylko używane jeden powiedzieć był błąd,

72
00:04:14,000 --> 00:04:16,000
wystąpił błąd, nie było błędu.

73
00:04:16,000 --> 00:04:20,000
Większe programy, często programy, które są wywoływane przez inne programy,

74
00:04:20,000 --> 00:04:25,000
powróci jakiś specjalnych kodów błędów w różnych scenariuszach

75
00:04:25,000 --> 00:04:28,000
programowo komunikować, czego w innym wypadku

76
00:04:28,000 --> 00:04:32,000
wystarczy użyć miłą wiadomość dla Polski.

77
00:04:32,000 --> 00:04:35,000
Cool.

78
00:04:35,000 --> 00:04:37,000
Ponieważ pracujemy w dół, można zobaczyć, że wyciągnąć klucz z.

79
00:04:37,000 --> 00:04:40,000
Testujemy czy klucz pasuje.

80
00:04:40,000 --> 00:04:42,000
Dostajemy wiadomość od użytkownika.

81
00:04:42,000 --> 00:04:46,000
Powodem, że robię to w pętli while to zrobić i jest to coś, omówimy

82
00:04:46,000 --> 00:04:50,000
w nieco, ale okazuje się, że jeśli kontrola typu D

83
00:04:50,000 --> 00:04:54,000
gdy pojawi się monit, że GetString na terminalu

84
00:04:54,000 --> 00:04:59,000
co faktycznie robi to wysyła specjalny charakter

85
00:04:59,000 --> 00:05:01,000
do programu.

86
00:05:01,000 --> 00:05:05,000
To się nazywa ELF lub znak końca pliku.

87
00:05:05,000 --> 00:05:08,000
I w tym przypadku, nasz łańcuch wiadomość będzie null,

88
00:05:08,000 --> 00:05:14,000
więc to nie było coś, sprawdziliśmy w problemu ustawić się.

89
00:05:14,000 --> 00:05:17,000
>> Ale jak iść dalej, teraz, że zaczęliśmy rozmawiać o wskaźniki

90
00:05:17,000 --> 00:05:21,000
i dynamicznej alokacji pamięci na stercie,

91
00:05:21,000 --> 00:05:25,000
sprawdzanie wartości null, gdy masz funkcję, która może

92
00:05:25,000 --> 00:05:30,000
zwróci wartość null jako wartość jest coś, że będziesz chciał się dostać w zwyczaju robić.

93
00:05:30,000 --> 00:05:33,000
To jest tutaj przede wszystkim do ilustracji.

94
00:05:33,000 --> 00:05:36,000
Ale kiedy widzą getString w przyszłości,

95
00:05:36,000 --> 00:05:41,000
więc od problemu Zestaw 4 dalej, będziemy chcieli, aby o tym pamiętać.

96
00:05:41,000 --> 00:05:44,000
Powtarzam, to nie problem dla Problemu Zestaw 3 albo ponieważ nie okrył go jeszcze jest.

97
00:05:44,000 --> 00:05:53,000
Wreszcie docieramy do tej części, gdzie dostać się do głównej pętli szyfrowania

98
00:05:53,000 --> 00:05:57,000
i istnieje kilka rzeczy się tu dzieje.

99
00:05:57,000 --> 00:06:02,000
Najpierw iterować cały ciąg wiadomości.

100
00:06:02,000 --> 00:06:07,000
Tutaj mamy zachował strlen połączenie w stanie,

101
00:06:07,000 --> 00:06:12,000
których liczba z was nie zauważył to świetny sposób, aby przejść jest.

102
00:06:12,000 --> 00:06:15,000
Okazuje się, w tym przypadku nie jest to również wspaniałe,

103
00:06:15,000 --> 00:06:20,000
częściowo dlatego, że mamy do modyfikowania treści samej wiadomości

104
00:06:20,000 --> 00:06:27,000
wewnątrz pętli for, więc jeśli mamy wiadomość, że znajduje się 10 znaków,

105
00:06:27,000 --> 00:06:32,000
Po raz pierwszy zaczynamy że dla pętli strlen powróci co?

106
00:06:32,000 --> 00:06:35,000
10.

107
00:06:35,000 --> 00:06:40,000
>> Ale jeśli następnie zmodyfikować wiadomość, powiedzieć możemy modyfikować swoje 5 znak,

108
00:06:40,000 --> 00:06:46,000
i rzucać w znak \ 0 w 5. pozycji,

109
00:06:46,000 --> 00:06:49,000
w kolejnej iteracji strlen (komunikat) nie wróci to, co zrobił

110
00:06:49,000 --> 00:06:52,000
Pierwszy raz powtórzyć,

111
00:06:52,000 --> 00:06:56,000
ale to zamiast wrócić 5 bo rzucił w tym pustym terminatora

112
00:06:56,000 --> 00:06:59,000
a ciąg jego długość jest określona

113
00:06:59,000 --> 00:07:03,000
przez pozycję, że \ 0.

114
00:07:03,000 --> 00:07:09,000
W tym przypadku, jest to świetny sposób, aby przejść ponieważ jesteśmy modyfikując go w miejscu.

115
00:07:09,000 --> 00:07:13,000
Jednak można zauważyć, że jest to rzeczywiście zaskakująco proste do szyfrowania

116
00:07:13,000 --> 00:07:16,000
czy można dostać math prawidłowe.

117
00:07:16,000 --> 00:07:19,000
Wszystko, co niezbędne jest, aby sprawdzić, czy list, który patrzysz na

118
00:07:19,000 --> 00:07:21,000
jest wielkie i małe litery.

119
00:07:21,000 --> 00:07:24,000
>> Powodem musimy tylko sprawdzić to i nie mamy do sprawdzenia

120
00:07:24,000 --> 00:07:27,000
jest przypadek, ponieważ alpha

121
00:07:27,000 --> 00:07:30,000
jeśli litera nazwy, lub jeśli jest to małe

122
00:07:30,000 --> 00:07:33,000
to jest to zdecydowanie znak alfabetu,

123
00:07:33,000 --> 00:07:38,000
ponieważ nie mamy wielkie i małe cyfry.

124
00:07:38,000 --> 00:07:41,000
Inna sprawa, co robimy i to jest trochę skomplikowane-

125
00:07:41,000 --> 00:07:45,000
jest mamy zmodyfikowany standardowy szyfr Cezara formułę

126
00:07:45,000 --> 00:07:49,000
że daliśmy w specyfikacji zestaw problemów.

127
00:07:49,000 --> 00:07:52,000
Czym różni o to, że mamy odjąć

128
00:07:52,000 --> 00:07:58,000
w wielkiej stolicy sprawy, a następnie dodaliśmy kapitałowych

129
00:07:58,000 --> 00:08:02,000
w kopii na końcu.

130
00:08:02,000 --> 00:08:05,000
>> Wiem, niewielu z was zrobić to w kodzie.

131
00:08:05,000 --> 00:08:09,000
Czy ktoś z was to zrobić w swoich pismach?

132
00:08:09,000 --> 00:08:13,000
Ty to zrobiłeś. Czy możesz wyjaśnić, co to robi, Sahb?

133
00:08:13,000 --> 00:08:18,000
Odejmując go, bo zrobił mod zaraz po nim,

134
00:08:18,000 --> 00:08:21,000
trzeba się go, więc w ten sposób można dostać [kaszel] position.

135
00:08:21,000 --> 00:08:25,000
A następnie przez dodanie go później jesteś przesunięty na ten, który chcesz.

136
00:08:25,000 --> 00:08:27,000
Tak, dokładnie.

137
00:08:27,000 --> 00:08:32,000
Co Sahb powiedział, że kiedy chcemy dodać

138
00:08:32,000 --> 00:08:36,000
nasze przesłanie i nasz klucz razem

139
00:08:36,000 --> 00:08:42,000
, a następnie, że mod, mod, że NUM_LETTERS,

140
00:08:42,000 --> 00:08:50,000
jeśli nie dostosowują naszą wiadomość do odpowiedniego zakresu od 0 do 25 najpierw

141
00:08:50,000 --> 00:08:54,000
to możemy skończyć się naprawdę dziwny numer

142
00:08:54,000 --> 00:08:59,000
ponieważ wartości, że mamy do czynienia, kiedy patrzymy na wiadomości [I],

143
00:08:59,000 --> 00:09:03,000
kiedy patrzymy na-tego charakteru naszego zwykłego tekstu wiadomości

144
00:09:03,000 --> 00:09:08,000
Wartość jest gdzieś w zakresie 65 do 122

145
00:09:08,000 --> 00:09:13,000
opiera się na wartościach ASCII litera A poprzez małą z.

146
00:09:13,000 --> 00:09:18,000
I tak, kiedy mod go 26 lub NUM_LETTERS,

147
00:09:18,000 --> 00:09:23,000
ponieważ to była nasza # define w prawym górnym rogu tu,

148
00:09:23,000 --> 00:09:28,000
że zamierza dać nam wartość znajduje się w zakresie 0 do 25,

149
00:09:28,000 --> 00:09:30,000
i musimy znaleźć sposób, aby następnie skalę, że z powrotem

150
00:09:30,000 --> 00:09:32,000
i zrobić to w odpowiednim zakresie ASCII.

151
00:09:32,000 --> 00:09:36,000
Najprostszym sposobem na to jest po prostu przeskalować wszystko w dół

152
00:09:36,000 --> 00:09:39,000
w zakresie od 0 do 25 na początku,

153
00:09:39,000 --> 00:09:43,000
a następnie przenieść wszystko z powrotem na końcu.

154
00:09:43,000 --> 00:09:46,000
>> Innym powszechnym błędem, że widziałem ludzi jest to, że do uruchomienia

155
00:09:46,000 --> 00:09:50,000
jeśli faktycznie nie zrobić tego od razu, skalowanie

156
00:09:50,000 --> 00:09:53,000
i dodać wiadomość i klucz razem i dodać je, powiedzmy,

157
00:09:53,000 --> 00:09:58,000
do char zmiennej, z tym problemu

158
00:09:58,000 --> 00:10:01,000
jest od wiadomości [i] jest stosunkowo duża liczba na początku-

159
00:10:01,000 --> 00:10:05,000
pamiętać, że to co najmniej 65, jeśli jest wielka litera-

160
00:10:05,000 --> 00:10:09,000
jeśli masz duży klucz, powiedzenia, coś jak 100,

161
00:10:09,000 --> 00:10:13,000
i dodać te 2 razem w podpisane char masz zamiar uzyskać przepełnienie.

162
00:10:13,000 --> 00:10:17,000
Będziesz uzyskać wartość, która jest większa niż 127,

163
00:10:17,000 --> 00:10:22,000
która jest największą wartością, która char zmienna może posiadać.

164
00:10:22,000 --> 00:10:26,000
Ponownie, to dlatego, że chcesz robić takie rzeczy na początku.

165
00:10:26,000 --> 00:10:29,000
Niektórzy ludzie mają wokół tej sprawy w ten czy inny i testowania

166
00:10:29,000 --> 00:10:33,000
aby zobaczyć, czy byłoby przepełnienie zanim to zrobi,

167
00:10:33,000 --> 00:10:36,000
ale w ten sposób radzi sobie z tym.

168
00:10:36,000 --> 00:10:40,000
, A następnie w tym roztworze, że wydrukowane na cały ciąg na końcu.

169
00:10:40,000 --> 00:10:45,000
Inne osoby wydrukowany znak na raz. Obie są niesamowite.

170
00:10:45,000 --> 00:10:51,000
W tym momencie, czy macie jakieś pytania, żadnych uwag na ten temat?

171
00:10:51,000 --> 00:10:56,000
Rzeczy, które lubisz, czego nie lubisz?

172
00:10:56,000 --> 00:10:58,000
>> Miałem pytanie.

173
00:10:58,000 --> 00:11:01,000
Może brakowało mi go w trakcie wyjaśnień, ale jak ten program

174
00:11:01,000 --> 00:11:07,000
pominąć przestrzenie do podłączenia do klucza długości tekstu?

175
00:11:07,000 --> 00:11:10,000
To jest po prostu szyfr Cezara. >> Och, przepraszam, tak.

176
00:11:10,000 --> 00:11:13,000
Tak, zobaczymy, że.

177
00:11:13,000 --> 00:11:16,000
W szyfru Cezara mamy wokół, że ponieważ

178
00:11:16,000 --> 00:11:18,000
tylko odwrócenie znaków.

179
00:11:18,000 --> 00:11:27,000
Mamy tylko obracać je, jakby były wielkie i małe litery.

180
00:11:27,000 --> 00:11:32,000
Macie całkiem dobrze o tym?

181
00:11:32,000 --> 00:11:34,000
Zapraszam do kopiowania tego domu, weź to,

182
00:11:34,000 --> 00:11:37,000
porównać go do tego, co wam napisałem.

183
00:11:37,000 --> 00:11:42,000
Zdecydowanie zachęcamy do wysyłania pytań o niego zbyt.

184
00:11:42,000 --> 00:11:46,000
I znowu sobie sprawę, że celem tutaj z Twoim problemem ustawia

185
00:11:46,000 --> 00:11:50,000
jest, aby nie wy napisać doskonały kodu dla swoich zbiorów problemowych.

186
00:11:50,000 --> 00:11:57,000
Jest to doświadczenie nauki. Tak.

187
00:11:57,000 --> 00:12:01,000
>> Powrót do zrobienia podczas pętli, jeżeli jest równy null,

188
00:12:01,000 --> 00:12:06,000
więc zerowy tylko nic nie znaczy, po prostu wciskamy Enter?

189
00:12:06,000 --> 00:12:12,000
Null jest specjalnym wartość wskaźnika,

190
00:12:12,000 --> 00:12:17,000
i używamy NULL, gdy chcemy powiedzieć

191
00:12:17,000 --> 00:12:23,000
mamy zmiennej wskaźnikowej, który jest skierowany do niczego.

192
00:12:23,000 --> 00:12:28,000
I tak zazwyczaj oznacza to, że ta zmienna, zmienna ta wiadomość

193
00:12:28,000 --> 00:12:35,000
jest pusta, i tutaj, ponieważ używamy CS50 specjalnego typu string,

194
00:12:35,000 --> 00:12:37,000
co jest CS50 typu string?

195
00:12:37,000 --> 00:12:42,000
Widziałeś, co to jest, kiedy David odsunął kaptur na wykład?

196
00:12:42,000 --> 00:12:44,000
To funky-to wskaźnik, prawda?

197
00:12:44,000 --> 00:12:48,000
Dobrze, tak. >> To char *.

198
00:12:48,000 --> 00:12:52,000
I tak naprawdę moglibyśmy zastąpić to

199
00:12:52,000 --> 00:12:56,000
tutaj z char * Wiadomość,

200
00:12:56,000 --> 00:13:04,000
i tak GetString funkcji, jeśli nie udało się w ciągu od użytkownika,

201
00:13:04,000 --> 00:13:08,000
Nie można analizować ciąg i jeden przypadek, w którym nie można analizować ciąg

202
00:13:08,000 --> 00:13:11,000
jest, jeśli użytkownik wpisze znak końca pliku, kontrola D

203
00:13:11,000 --> 00:13:17,000
która nie jest czymś normalny sposób, ale jeśli tak się stanie

204
00:13:17,000 --> 00:13:20,000
wówczas funkcja zwróci tę wartość null jako sposób na powiedzenie

205
00:13:20,000 --> 00:13:23,000
"Hej, nie miałem ciąg".

206
00:13:23,000 --> 00:13:27,000
Co by się stało, gdybyśmy nie umieścić wiadomość = null,

207
00:13:27,000 --> 00:13:30,000
które jest coś, czego nie robili jeszcze?

208
00:13:30,000 --> 00:13:32,000
Dlaczego miałoby to być problem?

209
00:13:32,000 --> 00:13:38,000
Bo wiem, że rozmawialiśmy trochę w wykładzie na temat wycieków pamięci.

210
00:13:38,000 --> 00:13:42,000
Tak, zróbmy to i zobaczmy, co się dzieje.

211
00:13:42,000 --> 00:13:44,000
>> Pytanie Bazylego było co się stanie, jeśli w rzeczywistości nie mają

212
00:13:44,000 --> 00:13:48,000
ten komunikat = null test?

213
00:13:48,000 --> 00:13:51,000
Miejmy przewinąć do góry.

214
00:13:51,000 --> 00:13:53,000
Macie może komentować to.

215
00:13:53,000 --> 00:13:55,000
Właściwie, ja zapisać go w wersji.

216
00:13:55,000 --> 00:13:58,000
Będzie to wersja 3.

217
00:13:58,000 --> 00:14:02,000
Co musisz zrobić, aby uruchomić ten program to musisz kliknąć tę ikonę adni tutaj

218
00:14:02,000 --> 00:14:04,000
i trzeba dodać argument do niego.

219
00:14:04,000 --> 00:14:10,000
Musisz dać mu kluczowy argument ponieważ chcemy przekazać w argumencie wiersza poleceń.

220
00:14:10,000 --> 00:14:13,000
Tutaj mam zamiar dać mu numer 3. Lubię 3.

221
00:14:13,000 --> 00:14:19,000
Teraz powiększanie powrotem, uruchomić program.

222
00:14:19,000 --> 00:14:24,000
Jest uruchomiony, kompilacji, budowania.

223
00:14:24,000 --> 00:14:27,000
Jedziemy. To czeka na monit.

224
00:14:27,000 --> 00:14:33,000
Jeśli wpisać coś jak hello-gdzie poszło?

225
00:14:33,000 --> 00:14:38,000
Och, mój program trwał zbyt długo biec. Byłem jawing zbyt długo.

226
00:14:38,000 --> 00:14:40,000
Tu idzie.

227
00:14:40,000 --> 00:14:43,000
Teraz wpisz w hello.

228
00:14:43,000 --> 00:14:46,000
Widzimy, że szyfruje odpowiednio.

229
00:14:46,000 --> 00:14:52,000
Teraz to, co się dzieje, gdy mamy szybką getString zwrócić NULL?

230
00:14:52,000 --> 00:14:57,000
Pamiętam, że my że naciśnięcie sterowania D w tym samym czasie.

231
00:14:57,000 --> 00:14:59,000
Będę przewijać się tutaj. Będziemy go uruchomić ponownie.

232
00:14:59,000 --> 00:15:01,000
Building. Nie idzie.

233
00:15:01,000 --> 00:15:04,000
Teraz, kiedy uderzy sterowania D

234
00:15:04,000 --> 00:15:12,000
Mam ten wiersz, który mówi opt/sandbox50/bin/run.sh, Segmentation fault.

235
00:15:12,000 --> 00:15:15,000
Czy widzieliście tego wcześniej?

236
00:15:15,000 --> 00:15:17,000
>> [Student] Dlaczego nie ma->> Przepraszam?

237
00:15:17,000 --> 00:15:20,000
[Student] Dlaczego nie ma rdzenia zrzutu w tym przypadku?

238
00:15:20,000 --> 00:15:26,000
Zrzutu jest-pytanie jest dlaczego nie ma zrzutu tutaj?

239
00:15:26,000 --> 00:15:29,000
Pytanie jest to, że może być, ale jest zrzutu plik

240
00:15:29,000 --> 00:15:31,000
który pobiera zapisane na twardym dysku.

241
00:15:31,000 --> 00:15:34,000
W tym przypadku mamy wyłączony zrzuty pamięci

242
00:15:34,000 --> 00:15:37,000
na serwerze roboczym tak, że nie mają ludzie seg niewysyłanie

243
00:15:37,000 --> 00:15:40,000
i budowanie ton wysypisk podstawowych.

244
00:15:40,000 --> 00:15:46,000
Ale można dostać.

245
00:15:46,000 --> 00:15:48,000
Zrzuca podstawowe są takie rzeczy, że często można wyłączyć,

246
00:15:48,000 --> 00:15:52,000
i czasem trzeba zrobić.

247
00:15:52,000 --> 00:15:55,000
Błąd segmentacji, aby odpowiedzieć na to pytanie, bazylia,

248
00:15:55,000 --> 00:16:00,000
mówi, że próbował uzyskać dostęp do wskaźnika

249
00:16:00,000 --> 00:16:05,000
że nie został ustawiony, aby wskazywały niczego.

250
00:16:05,000 --> 00:16:09,000
Zapamiętaj Binky w filmie, kiedy próbuje Binky

251
00:16:09,000 --> 00:16:12,000
przejść przejść wskaźnik, który nie jest skierowany do niczego?

252
00:16:12,000 --> 00:16:16,000
W tym przypadku myślę, że technicznie pointer wskazuje na coś.

253
00:16:16,000 --> 00:16:20,000
To wskazuje na null, która jest technicznie 0,

254
00:16:20,000 --> 00:16:25,000
ale, że określa się w segmencie, który nie jest dostępny

255
00:16:25,000 --> 00:16:28,000
przez program, więc masz winy segmentacji

256
00:16:28,000 --> 00:16:31,000
ponieważ nie masz dostępu do pamięci, która znajduje się w ważnym segmencie

257
00:16:31,000 --> 00:16:38,000
jak segmentu sterty lub segmentu stosu lub segmentu danych.

258
00:16:38,000 --> 00:16:40,000
Cool.

259
00:16:40,000 --> 00:16:48,000
Jeszcze jakieś pytania na temat Caesar?

260
00:16:48,000 --> 00:16:51,000
>> Idźmy dalej. Przyjrzyjmy Revision 2 bardzo szybko.

261
00:16:51,000 --> 00:17:00,000
To Vigenère.

262
00:17:00,000 --> 00:17:04,000
Tutaj w Vigenère

263
00:17:04,000 --> 00:17:06,000
będziemy chodzić przez ten jeden dość szybko, ponieważ, ponownie,

264
00:17:06,000 --> 00:17:10,000
Vigenère i Cezar są dość podobne.

265
00:17:10,000 --> 00:17:12,000
Comment nagłówek jest przed,

266
00:17:12,000 --> 00:17:17,000
# Define jest przed, aby uniknąć korzystania z tych magicznych liczb.

267
00:17:17,000 --> 00:17:21,000
Dobrą rzeczą jest to że chcemy, aby przejść do

268
00:17:21,000 --> 00:17:23,000
innego alfabetu, czy coś w tym stylu.

269
00:17:23,000 --> 00:17:26,000
Zamiast iść ręcznie zmienić wszystkie 26-tych w kodzie

270
00:17:26,000 --> 00:17:30,000
możemy zmienić na 27 lub usunąć go

271
00:17:30,000 --> 00:17:34,000
jeśli były przy użyciu różnych alfabetów różnych języków.

272
00:17:34,000 --> 00:17:38,000
Znowu mamy tę kontrolę liczenia argumentów,

273
00:17:38,000 --> 00:17:42,000
i naprawdę można prawie wziąć to jako szablon.

274
00:17:42,000 --> 00:17:46,000
Prawie każdy program piszesz powinien mieć-

275
00:17:46,000 --> 00:17:50,000
jeśli trwa argumentów wiersza poleceń-niektóre sekwencja linii

276
00:17:50,000 --> 00:17:55,000
że czyta się to na samym początku.

277
00:17:55,000 --> 00:17:59,000
To jeden z pierwszych testów normalności, które chcesz zrobić.

278
00:17:59,000 --> 00:18:03,000
>> Oto co udało nam się nam upewnić się, że

279
00:18:03,000 --> 00:18:06,000
keyword był ważny, a to kontrola drugiej, że to zrobiliśmy.

280
00:18:06,000 --> 00:18:11,000
Zauważcie, że oddziela to od argc i 2.

281
00:18:11,000 --> 00:18:14,000
Zauważ, że w tym przypadku jedna rzecz, że mieliśmy do czynienia był zamiast

282
00:18:14,000 --> 00:18:18,000
wykorzystania do i chcieliśmy potwierdzić cały ciąg,

283
00:18:18,000 --> 00:18:21,000
i aby to zrobić trzeba rzeczywiście iść znak po znaku

284
00:18:21,000 --> 00:18:23,000
na ciąg.

285
00:18:23,000 --> 00:18:29,000
Nie ma dobrego sposobu, aby połączyć coś na nim

286
00:18:29,000 --> 00:18:31,000
, ponieważ, nawet na przykład w wrócę 0

287
00:18:31,000 --> 00:18:37,000
jeśli nie można analizować liczbę całkowitą, tak że nawet nie działa.

288
00:18:37,000 --> 00:18:42,000
Znowu miły komunikat informujący użytkownika, co dokładnie się stało.

289
00:18:42,000 --> 00:18:45,000
To tutaj, znowu, również obsłużyć przypadek, gdy

290
00:18:45,000 --> 00:18:50,000
użytkownik wpisze w D sterowania charakter losowy.

291
00:18:50,000 --> 00:18:54,000
>> A potem Charlotte miał pytanie wcześniej o tym, jak udało nam się przejść spacji

292
00:18:54,000 --> 00:18:57,000
w naszym łańcuchu tutaj.

293
00:18:57,000 --> 00:19:00,000
To było trochę podobne do tego, co zrobiliśmy z Myspace programu

294
00:19:00,000 --> 00:19:04,000
że my w sekcji, a sposób to działało

295
00:19:04,000 --> 00:19:08,000
jest to, że śledził kilka liter, które widziałem.

296
00:19:08,000 --> 00:19:13,000
Jak weszliśmy nad ciąg wiadomości, jak szliśmy przez znak po znaku,

297
00:19:13,000 --> 00:19:16,000
możemy śledzić indeks jako część naszej pętli for, a następnie również śledzone

298
00:19:16,000 --> 00:19:21,000
liczba liter, więc nie znaki specjalne, cyfry, nie-nie-białe znaki

299
00:19:21,000 --> 00:19:27,000
że widział w oddzielnej zmiennej.

300
00:19:27,000 --> 00:19:33,000
I wtedy to rozwiązanie modyfikuje klucz

301
00:19:33,000 --> 00:19:41,000
aby uzyskać rzeczywistą kluczową liczbą całkowitą, i robi, że w locie,

302
00:19:41,000 --> 00:19:47,000
tuż przed potem idzie do szyfrowania rzeczywisty charakter wiadomości.

303
00:19:47,000 --> 00:19:50,000
Istnieje kilka rozwiązań, które były doskonale zbyt wielkie

304
00:19:50,000 --> 00:19:58,000
które zmodyfikować klucz się podczas testowania dla klucza ważności.

305
00:19:58,000 --> 00:20:01,000
Oprócz upewniając się, że charakter i hasła

306
00:20:01,000 --> 00:20:05,000
został alfabetu również okazało, że do liczby całkowitej

307
00:20:05,000 --> 00:20:13,000
w zakresie 0 do 25, aby następnie przejść o to zrobić później w tej pętli for.

308
00:20:13,000 --> 00:20:18,000
Ponownie, można zobaczyć tutaj jest to naprawdę dokładnie ten sam kod

309
00:20:18,000 --> 00:20:22,000
że stosuje się w tym momencie Cezara.

310
00:20:22,000 --> 00:20:25,000
Robisz dokładnie to samo, więc rzeczywista Sztuką jest zastanawianie się

311
00:20:25,000 --> 00:20:30,000
jak zamienić słowo kluczowe w całkowitej.

312
00:20:30,000 --> 00:20:35,000
>> Jedna rzecz, że my tu, że jest trochę gęsty

313
00:20:35,000 --> 00:20:39,000
to powtórzono tę frazę, Myślę, że można nazwać to,

314
00:20:39,000 --> 00:20:45,000
3 oddzielne razy na liniach 58, 59 i 61.

315
00:20:45,000 --> 00:20:52,000
Może ktoś wyjaśnić, co dokładnie to zdanie nie?

316
00:20:52,000 --> 00:20:55,000
Jest dostęp znak, jak powiedziałeś.

317
00:20:55,000 --> 00:20:59,000
Tak, to jest [niesłyszalne] znak w słowo kluczowe,

318
00:20:59,000 --> 00:21:04,000
a więc jest to liczba liter widziałem, bo jesteś tylko poruszające

319
00:21:04,000 --> 00:21:06,000
keyword raz widziałeś list,

320
00:21:06,000 --> 00:21:10,000
tak, że będzie skutecznie pominąć spacje i takie tam.

321
00:21:10,000 --> 00:21:12,000
Tak, dokładnie.

322
00:21:12,000 --> 00:21:16,000
A potem, gdy już widziałem puste słowa kluczowego po prostu mod więc cofnąć się.

323
00:21:16,000 --> 00:21:18,000
Dokładnie. To idealne wytłumaczenie.

324
00:21:18,000 --> 00:21:23,000
Co Kevin powiedział, jest to, że chcemy, aby indeks do hasła.

325
00:21:23,000 --> 00:21:28,000
Chcemy uzyskać num_letters_seen charakter, jeśli chcesz,

326
00:21:28,000 --> 00:21:32,000
ale jeśli num_letters_seen przekracza długość słowa kluczowego,

327
00:21:32,000 --> 00:21:37,000
sposób możemy wrócić do odpowiedniego zakresu jest używamy operatora mod

328
00:21:37,000 --> 00:21:40,000
skutecznie otacza.

329
00:21:40,000 --> 00:21:43,000
Na przykład, jak w skrócie, nasze słowo kluczowe jest boczek,

330
00:21:43,000 --> 00:21:46,000
i to jest 5 liter.

331
00:21:46,000 --> 00:21:50,000
Ale widzieliśmy 6 liter w naszej zwykły tekst w tym momencie

332
00:21:50,000 --> 00:21:52,000
i szyfrowane 6.

333
00:21:52,000 --> 00:21:57,000
Skończymy dostępu do num_letters_seen,

334
00:21:57,000 --> 00:22:00,000
które jest 6 mod długość hasła, 5

335
00:22:00,000 --> 00:22:04,000
i tak będziemy mieć 1, a więc co zrobimy to my będziemy

336
00:22:04,000 --> 00:22:14,000
dostęp do pierwszego w środku charakter naszych słów kluczowych w tym punkcie.

337
00:22:14,000 --> 00:22:21,000
>> Wszystko w porządku, wszelkie pytania dotyczące Vigenère

338
00:22:21,000 --> 00:22:26,000
Zanim przejdziemy?

339
00:22:26,000 --> 00:22:31,000
Macie całkiem dobrze o tym?

340
00:22:31,000 --> 00:22:35,000
Cool, super.

341
00:22:35,000 --> 00:22:38,000
Chcę się upewnić, że chłopaki są coraz szansę zobaczyć kod

342
00:22:38,000 --> 00:22:48,000
które naszym zdaniem wygląda dobrze i ma szansę uczyć się od niego.

343
00:22:48,000 --> 00:22:53,000
To będzie ostatni będziemy używać spacji w chwili obecnej,

344
00:22:53,000 --> 00:22:59,000
i jedziemy do przejścia, a ja pójdę do cs50.net/lectures

345
00:22:59,000 --> 00:23:06,000
więc możemy zrobić trochę przeglądu quizu.

346
00:23:06,000 --> 00:23:10,000
Najlepszym sposobem, myślę zacząć robić quizu recenzję

347
00:23:10,000 --> 00:23:15,000
ma przyjść do tej strony wykładów, cs50.net/lectures,

348
00:23:15,000 --> 00:23:20,000
a pod każdym z działów tydzień, więc jeśli mogę się tu w tygodniu 0,

349
00:23:20,000 --> 00:23:27,000
Widzę, że mamy listę tematów, które zostały uwzględnione w tygodniu 0.

350
00:23:27,000 --> 00:23:31,000
>> Jeśli którykolwiek z tych tematów wydaje się obce dla Ciebie

351
00:23:31,000 --> 00:23:34,000
będziesz na pewno chcemy wrócić i przeszukać notatki wykładowe i ewentualnie

352
00:23:34,000 --> 00:23:39,000
nawet przejrzeć wykładów, oglądanie ich ponownie, jeśli chcesz

353
00:23:39,000 --> 00:23:44,000
aby czuć się za to, co się dzieje z każdym z tych tematów.

354
00:23:44,000 --> 00:23:49,000
Powiem dodatkowo ten rok jeden z chłodnych zasobów mamy

355
00:23:49,000 --> 00:23:55,000
Właśnie te spodenki, które stworzyliśmy, i jeśli spojrzeć w tygodniu 0,

356
00:23:55,000 --> 00:24:00,000
nie mamy wszystkich tematów, ale mamy sporo z nich,

357
00:24:00,000 --> 00:24:03,000
niektóre z nich trudniejsze, więc oglądając te spodenki ponownie

358
00:24:03,000 --> 00:24:08,000
Jest to dobry sposób, aby dostać się do prędkości.

359
00:24:08,000 --> 00:24:15,000
W szczególności mam zamiar umieścić w wtyczce do 3 na dole, bo ja te.

360
00:24:15,000 --> 00:24:20,000
Ale jeśli masz problemy z binarny, bity, sześciokątne, tego rodzaju rzeczy,

361
00:24:20,000 --> 00:24:22,000
binarny jest doskonałym miejscem, aby rozpocząć.

362
00:24:22,000 --> 00:24:25,000
ASCII jest kolejnym, który jest dobry, by zobaczyć też.

363
00:24:25,000 --> 00:24:31,000
Możesz nawet oglądać mnie w 1.5x prędkości jeśli mam zbyt wolny dla Ciebie.

364
00:24:31,000 --> 00:24:35,000
Od jego oceny, nie wahaj się tego zrobić.

365
00:24:35,000 --> 00:24:40,000
>> Wystarczy zacząć naprawdę szybko, mamy zamiar przejść przez kilka tych problemów quizu

366
00:24:40,000 --> 00:24:44,000
tylko szybko rezygnacji przez nich.

367
00:24:44,000 --> 00:24:50,000
Na przykład, spójrzmy na oryginał 16, że mam prawo się tu na forum.

368
00:24:50,000 --> 00:24:54,000
Mamy ten następującego obliczenia w formacie binarnym,

369
00:24:54,000 --> 00:24:56,000
i chcemy pokazać jakąkolwiek pracę.

370
00:24:56,000 --> 00:24:59,000
Dobra, mam zamiar dać to szansę.

371
00:24:59,000 --> 00:25:01,000
Wy powinien podążać z papieru,

372
00:25:01,000 --> 00:25:04,000
i zrobimy to bardzo szybko.

373
00:25:04,000 --> 00:25:06,000
Chcemy wykonać następujące obliczenia w formacie binarnym.

374
00:25:06,000 --> 00:25:16,000
Mam 00110010.

375
00:25:16,000 --> 00:25:27,000
I mam zamiar dodać do niego 00110010.

376
00:25:27,000 --> 00:25:30,000
Na matematyce geniuszy po wzdłuż w domu,

377
00:25:30,000 --> 00:25:35,000
ta jest skutecznie mnożąc przez 2.

378
00:25:35,000 --> 00:25:37,000
Zacznijmy.

379
00:25:37,000 --> 00:25:39,000
Będziemy śledzić ten sam algorytm dodawania, co robimy

380
00:25:39,000 --> 00:25:43,000
gdy dodamy liczb dziesiętnych razem.

381
00:25:43,000 --> 00:25:46,000
Naprawdę Jedyną różnicą jest to, że pętla powraca

382
00:25:46,000 --> 00:25:51,000
raz mamy 1 + 1 zamiast raz dojdziemy do 10.

383
00:25:51,000 --> 00:25:53,000
>> Jeśli zaczniemy od prawej, bardzo szybko, co jest pierwszą cyfrą?

384
00:25:53,000 --> 00:25:55,000
[Student] 0. >> [Nate H.] 0.

385
00:25:55,000 --> 00:25:58,000
Great, druga cyfra?

386
00:25:58,000 --> 00:26:00,000
[Student] 1.

387
00:26:00,000 --> 00:26:02,000
[Nate H.] Czy 1? 1 + 1 jest?

388
00:26:02,000 --> 00:26:04,000
[Student] 10.

389
00:26:04,000 --> 00:26:08,000
[Nate H.] Dokładnie, więc co to jest cyfra, że ​​piszę się u podnóża 2 te dodawane razem?

390
00:26:08,000 --> 00:26:11,000
[Student] 1, 0, lub 0, a następnie przenosić 1.

391
00:26:11,000 --> 00:26:15,000
[Nate H.] 0 i posiadać 1, dokładnie.

392
00:26:15,000 --> 00:26:18,000
Następna w kolejce jeden, Basil, teraz ty.

393
00:26:18,000 --> 00:26:20,000
Co trzeci? >> [Basil] 1.

394
00:26:20,000 --> 00:26:23,000
[Nate H.] 1, doskonały. Kevin?

395
00:26:23,000 --> 00:26:27,000
[Kevin] 0. >> [Nate H.] 0, Charlotte?

396
00:26:27,000 --> 00:26:30,000
[Charlotte] 0. >> [Nate H.] Tak, i co mam zrobić?

397
00:26:30,000 --> 00:26:32,000
[Student] 1.

398
00:26:32,000 --> 00:26:34,000
[Nate H.] I co mam zrobić? I wtedy nosić 1.

399
00:26:34,000 --> 00:26:36,000
Perfect, Sahb? >> [Sahb] Teraz masz 1.

400
00:26:36,000 --> 00:26:40,000
[Nate H.] I mogę zrobić coś tutaj?

401
00:26:40,000 --> 00:26:43,000
[Sahb] Następnie na następne masz 1 bo przeniesione 1.

402
00:26:43,000 --> 00:26:49,000
[Nate H.] Wielki, więc możemy zakończyć to.

403
00:26:49,000 --> 00:26:51,000
Cool.

404
00:26:51,000 --> 00:26:54,000
[Student] Czy 0 + 0 = 0?

405
00:26:54,000 --> 00:26:56,000
0 + 0 = 0.

406
00:26:56,000 --> 00:27:01,000
1 + 1, jak pan powiedział, jest 10, lub 1, 0, raczej.

407
00:27:01,000 --> 00:27:07,000
10 jest błędne, bo do mnie 10 oznacza liczbę 10,

408
00:27:07,000 --> 00:27:12,000
i to jest dziwactwo jak mamy reprezentowanie go, kiedy będziemy pisać.

409
00:27:12,000 --> 00:27:20,000
Reprezentujemy numer 2 do 1, 0, i nr 10 jest nieco inna.

410
00:27:20,000 --> 00:27:23,000
>> Co jest miłe o binarnych jest to, że naprawdę nie jest to, że wiele

411
00:27:23,000 --> 00:27:25,000
przypadkach trzeba się nauczyć.

412
00:27:25,000 --> 00:27:30,000
Jest 0 + 0 = 0, 0 + 1 = 1,

413
00:27:30,000 --> 00:27:34,000
1 + 1 jest 0, a następnie podejmuje się 1,

414
00:27:34,000 --> 00:27:37,000
a następnie można zobaczyć tutaj, na trzeciej kolumnie od prawej

415
00:27:37,000 --> 00:27:40,000
mieliśmy ten 1, 1 i 1.

416
00:27:40,000 --> 00:27:43,000
I 1 + 1 + 1 jest 1,

417
00:27:43,000 --> 00:27:45,000
i nosisz inny 1.

418
00:27:45,000 --> 00:27:48,000
Kiedy robisz binarny dodatek, całkiem proste.

419
00:27:48,000 --> 00:27:51,000
Zrobię jeszcze kilka z nich, aby sprawdzić siebie rozsądek

420
00:27:51,000 --> 00:27:54,000
przed wyjazdem, ponieważ jest to w

421
00:27:54,000 --> 00:28:00,000
prawdopodobnie coś, co zobaczymy na quiz.

422
00:28:00,000 --> 00:28:03,000
Teraz zróbmy to następny także.

423
00:28:03,000 --> 00:28:06,000
Zróbmy problemu 17.

424
00:28:06,000 --> 00:28:12,000
Zamierzamy przekształcić numer binarny na dziesiętny.

425
00:28:12,000 --> 00:28:28,000
Mam 10100111001.

426
00:28:28,000 --> 00:28:33,000
Zapamiętaj w binarnym wideo, które zrobiłem

427
00:28:33,000 --> 00:28:36,000
Szedłem przez kilka przykładów, i pokazał, jak

428
00:28:36,000 --> 00:28:41,000
wszystko działa, gdy robisz to w układzie dziesiętnym.

429
00:28:41,000 --> 00:28:45,000
Kiedy pracujesz w reprezentacji dziesiętnej Myślę, że jesteśmy

430
00:28:45,000 --> 00:28:48,000
w tym momencie w naszym życiu, tak biegła w nim, że

431
00:28:48,000 --> 00:28:53,000
jest to dość łatwe do tuszować mechanikę, jak to rzeczywiście działa.

432
00:28:53,000 --> 00:28:59,000
>> Ale żeby zrobić szybki zakręcić, jeśli mam numer 137

433
00:28:59,000 --> 00:29:06,000
to naprawdę oznacza i ponownie, to w reprezentacji dziesiętnej-

434
00:29:06,000 --> 00:29:19,000
Numer 137 oznacza, że ​​w po przecinku mam 1 x 100 + 10 + 3 x 7 x 1.

435
00:29:19,000 --> 00:29:22,000
To wszystko jest pobyt na ekranie.

436
00:29:22,000 --> 00:29:29,000
A jeśli spojrzeć na te liczby tu,

437
00:29:29,000 --> 00:29:34,000
100, 10 i 1, widać, że są one właściwie wszystkie moce 10.

438
00:29:34,000 --> 00:29:43,000
Mam 10 ², 10 ¹ i 10 do zera.

439
00:29:43,000 --> 00:29:48,000
Mamy podobną rodzaju rzeczy w formacie binarnym,

440
00:29:48,000 --> 00:29:55,000
wyjątkiem tego, że nasza baza, jak my to nazywamy, jest 2 zamiast 10.

441
00:29:55,000 --> 00:29:58,000
Te 10s, że napisałem tu na dole,

442
00:29:58,000 --> 00:30:02,000
to 10 ², 10 ¹, 10 do zera, 10 jest nasza baza,

443
00:30:02,000 --> 00:30:08,000
i wykładnikiem, 0, 1, lub 2,

444
00:30:08,000 --> 00:30:14,000
jest implikowane przez pozycję cyfry w liczbie, że piszesz.

445
00:30:14,000 --> 00:30:21,000
1, jeśli spojrzymy na to, to 1 jest w 2. pozycji.

446
00:30:21,000 --> 00:30:27,000
3 znajduje się w pozycji 1. i 7 jest w 0-szy pozycji.

447
00:30:27,000 --> 00:30:35,000
To, w jaki sposób uzyskać różne wykładniki poniżej dla naszych baz.

448
00:30:35,000 --> 00:30:40,000
>> Po tym wszystkim we'll-faktycznie, wiesz co?

449
00:30:40,000 --> 00:30:43,000
Zrobimy, skąd mój przycisk Cofnij iść?

450
00:30:43,000 --> 00:30:45,000
Nie idzie.

451
00:30:45,000 --> 00:30:47,000
Kocham to cofnąć rzeczy.

452
00:30:47,000 --> 00:30:51,000
Po tym myślę, że dla mnie przynajmniej

453
00:30:51,000 --> 00:30:54,000
Najprostszym sposobem, aby rozpocząć konwersję ilości binarny

454
00:30:54,000 --> 00:30:57,000
lub liczba szesnastkowa, gdzie podstawą jest 16

455
00:30:57,000 --> 00:31:02,000
, a nie 10 lub 2 jest iść do przodu i pisać

456
00:31:02,000 --> 00:31:09,000
podstawy i wykładniki dla wszystkich liczb w mojej liczbę binarną na górze.

457
00:31:09,000 --> 00:31:14,000
Jeśli zaczniemy od lewej do prawej, raz,

458
00:31:14,000 --> 00:31:17,000
co jest raczej sprzeczne z intuicją,

459
00:31:17,000 --> 00:31:23,000
Ja przywrócić czarny tutaj mamy 2 do 0-te pozycji

460
00:31:23,000 --> 00:31:27,000
a następnie mamy 2 ¹, 2 ²,

461
00:31:27,000 --> 00:31:33,000
i 2 do 3, 2 do 4, 2 do 5, 6,

462
00:31:33,000 --> 00:31:39,000
7, 8, 9, i 10.

463
00:31:39,000 --> 00:31:41,000
Te numery pisałem obecnie są wszystkie wykładniki.

464
00:31:41,000 --> 00:31:48,000
Tylko napisałem baz tutaj w pierwszej 3 tylko dla przestrzeni.

465
00:31:48,000 --> 00:31:50,000
>> W tym momencie mam zamiar iść do przodu i jestem naprawdę zamiar wymazać

466
00:31:50,000 --> 00:31:53,000
rzeczy, które zrobiliśmy w postaci dziesiętnej, jeśli to jest w porządku.

467
00:31:53,000 --> 00:31:57,000
Masz wszystko zrozumiałam.

468
00:31:57,000 --> 00:32:05,000
Ci z Was, oglądając online na pewno będą w stanie cofnąć mnie, jeśli chcesz.

469
00:32:05,000 --> 00:32:07,000
Przełączenie z powrotem na wstrzykiwacz.

470
00:32:07,000 --> 00:32:12,000
Teraz, co możemy zrobić, jeśli faceci nie są całkowicie do prędkości swoimi uprawnieniami 2,

471
00:32:12,000 --> 00:32:15,000
to całkowicie cool.

472
00:32:15,000 --> 00:32:18,000
To się zdarza. Rozumiem.

473
00:32:18,000 --> 00:32:23,000
Miałem kiedyś rozmowę kwalifikacyjną, gdzie powiedziano mi, muszę znać wszystkie uprawnienia 2

474
00:32:23,000 --> 00:32:26,000
się przez 2 do 30 miejsca.

475
00:32:26,000 --> 00:32:29,000
To nie była praca, co mam.

476
00:32:29,000 --> 00:32:32,000
W każdym razie, że chłopaki mogą iść do przodu i nie matematyka tutaj

477
00:32:32,000 --> 00:32:35,000
ale z binarnym to nie ma sensu,

478
00:32:35,000 --> 00:32:38,000
i ani nie ma sensu z dziesiętnym czy albo,

479
00:32:38,000 --> 00:32:43,000
się do matematyki, gdzie masz zer.

480
00:32:43,000 --> 00:32:49,000
Widać mam 0 tu, 0 o, 0 o, 0 o, 0 o, 0 tutaj.

481
00:32:49,000 --> 00:32:52,000
Dlaczego może nie ma sensu do faktycznego matematyki

482
00:32:52,000 --> 00:32:56,000
obliczyć odpowiednią moc 2 w tej pozycji?

483
00:32:56,000 --> 00:32:59,000
Dokładnie, jak Charlotte mówi, będzie to 0.

484
00:32:59,000 --> 00:33:05,000
Może także zaoszczędzić czas, jeśli obliczenia uprawnień 2 nie jest twoja mocna strona.

485
00:33:05,000 --> 00:33:10,000
W tym przypadku musimy tylko go obliczyć na 2 do 0, które jest-?

486
00:33:10,000 --> 00:33:12,000
[Student] 1.

487
00:33:12,000 --> 00:33:14,000
[H. Nate] 1, 2 do 3, który jest-?

488
00:33:14,000 --> 00:33:16,000
[Student] 8. >> [Nate H.] 8.

489
00:33:16,000 --> 00:33:18,000
2 do 4?

490
00:33:18,000 --> 00:33:21,000
[Student] 2. Przykro mi, 1.

491
00:33:21,000 --> 00:33:26,000
[Nate H.] 2 do 4 jest 16, dokładnie.

492
00:33:26,000 --> 00:33:28,000
2 do 5, Kevin? >> 32.

493
00:33:28,000 --> 00:33:32,000
[Nate H.] 32, 2 do 8?

494
00:33:32,000 --> 00:33:38,000
[Student] 32 x 8, 256.

495
00:33:38,000 --> 00:33:41,000
[Nate H.] Perfect.

496
00:33:41,000 --> 00:33:43,000
I 2 do 10?

497
00:33:43,000 --> 00:33:45,000
[Student] 1024.

498
00:33:45,000 --> 00:33:49,000
[Nate H.] Tak, 1024.

499
00:33:49,000 --> 00:33:57,000
>> Gdy mamy tych liczb możemy suma ich wszystkich.

500
00:33:57,000 --> 00:34:01,000
I to jest to naprawdę ważne, aby zrobić kilka rzeczy.

501
00:34:01,000 --> 00:34:07,000
Jednym z nich jest iść powoli i sprawdzić swoją pracę.

502
00:34:07,000 --> 00:34:10,000
Można powiedzieć, że jest 1 na końcu tej liczby

503
00:34:10,000 --> 00:34:15,000
więc powinienem pewno się nieparzystą liczbę jako mojego wyniku

504
00:34:15,000 --> 00:34:18,000
bo wszyscy inni to będzie jeszcze numery

505
00:34:18,000 --> 00:34:21,000
zważywszy, że jest to liczba binarna.

506
00:34:21,000 --> 00:34:24,000
Inną rzeczą do zrobienia jest, jeśli można dostać się do tego punktu na teście

507
00:34:24,000 --> 00:34:27,000
i napisałeś go tak daleko

508
00:34:27,000 --> 00:34:30,000
i masz mało czasu

509
00:34:30,000 --> 00:34:33,000
spojrzeć na liczbę punktów, że ten problem jest wart.

510
00:34:33,000 --> 00:34:40,000
Problem ten, jak widać, jeśli odwrócić z powrotem do mojego laptopa naprawdę szybko-

511
00:34:40,000 --> 00:34:44,000
problem ten jest warte 2 punkty, więc nie jest to coś w rodzaju dodatku

512
00:34:44,000 --> 00:34:47,000
należy przechodzić jeśli jesteś naprawdę na czasie.

513
00:34:47,000 --> 00:34:52,000
Ale będziemy wrócić do iPad, a my przez to przejść bardzo szybko.

514
00:34:52,000 --> 00:34:54,000
>> Lubię robić małe numery 1-ci

515
00:34:54,000 --> 00:34:56,000
ponieważ uważam, że łatwiej.

516
00:34:56,000 --> 00:35:00,000
Lubię 32 i 8, bo idą razem dość łatwo, a otrzymamy 50.

517
00:35:00,000 --> 00:35:03,000
16 i 1 dostaje 17.

518
00:35:03,000 --> 00:35:05,000
Nie mamy 57,

519
00:35:05,000 --> 00:35:14,000
a następnie możemy zrobić resztę tego, więc może zrobić 57, 156.

520
00:35:14,000 --> 00:35:16,000
Chodź.

521
00:35:16,000 --> 00:35:19,000
Człowiek, dobrze, zobaczymy.

522
00:35:19,000 --> 00:35:27,000
Mieliśmy 57, 256 i 1024.

523
00:35:27,000 --> 00:35:31,000
W tym momencie, wolałbym po prostu przejść.

524
00:35:31,000 --> 00:35:35,000
Nie mam zielonego pojęcia. I oczywiście trzeba czytać w tej sprawie.

525
00:35:35,000 --> 00:35:40,000
7, 6 i 4, dostaniesz 17.

526
00:35:40,000 --> 00:35:42,000
1, 5, 5, 2, 13.

527
00:35:42,000 --> 00:35:45,000
Potem mamy 3, a następnie dostać 1.

528
00:35:45,000 --> 00:35:52,000
1337.

529
00:35:52,000 --> 00:35:55,000
Easter egg, kto?

530
00:35:55,000 --> 00:35:59,000
Ktoś rozpozna ten numer?

531
00:35:59,000 --> 00:36:02,000
Chris rozpoznaje numer. Co to znaczy, Chris?

532
00:36:02,000 --> 00:36:04,000
[Chris] Leet.

533
00:36:04,000 --> 00:36:11,000
Leet, więc jeśli spojrzeć na to, wygląda Leet.

534
00:36:11,000 --> 00:36:15,000
Stuff Hacker. Uważaj na tego rodzaju rzeczy w perspektywie średnioterminowej oraz quiz, a raczej.

535
00:36:15,000 --> 00:36:19,000
Jeśli zauważysz tego rodzaju rzeczy, a ty zastanawiasz "Huh"

536
00:36:19,000 --> 00:36:22,000
że może faktycznie coś znaczyć.

537
00:36:22,000 --> 00:36:24,000
Nie wiem. David lubi wprowadzenie go w.

538
00:36:24,000 --> 00:36:26,000
Jest to dobry sposób na zdrowy rozsądek to sprawdzić.

539
00:36:26,000 --> 00:36:30,000
Jak dobrze, widzę, co się dzieje.

540
00:36:30,000 --> 00:36:34,000
>> To tydzień 0/Week 1 rzeczy.

541
00:36:34,000 --> 00:36:39,000
Jeśli mamy wrócić do naszego laptopa teraz,

542
00:36:39,000 --> 00:36:46,000
pomniejszyć, i kilka innych rzeczy.

543
00:36:46,000 --> 00:36:50,000
Jest ASCII, które robiliśmy dużo z zestawów problemowych.

544
00:36:50,000 --> 00:36:55,000
To pojęcie kapitału A. Co to jest naprawdę?

545
00:36:55,000 --> 00:36:57,000
Wiedząc to dziesiętna liczba całkowita.

546
00:36:57,000 --> 00:37:00,000
65 jest to, co to jest odwzorowane w ASCII tabeli

547
00:37:00,000 --> 00:37:03,000
i właśnie dlatego, jak komputer zapisuje je,

548
00:37:03,000 --> 00:37:06,000
i tak byliśmy już uciec z faktycznie piśmie

549
00:37:06,000 --> 00:37:09,000
Kapitał postać i charakter małe

550
00:37:09,000 --> 00:37:14,000
w niektórych z tych rozwiązań i mechanizmów problemowych, które robiłeś.

551
00:37:14,000 --> 00:37:16,000
Kilka innych rzeczy.

552
00:37:16,000 --> 00:37:25,000
Mamy oświadczenia, wyrażeń logicznych, warunki, pętle, zmienne i nici.

553
00:37:25,000 --> 00:37:29,000
>> Ci wszyscy wydają się mieć sens w większości?

554
00:37:29,000 --> 00:37:35,000
Część z tej terminologii jest trochę funky czasami.

555
00:37:35,000 --> 00:37:46,000
Lubię myśleć, że oświadczenia, jak w większości coś, kończy się średnikiem.

556
00:37:46,000 --> 00:37:51,000
Oświadczenia takie jak x = 7, który określa zmienną,

557
00:37:51,000 --> 00:37:54,000
przypuszczalnie nazywa x = 7.

558
00:37:54,000 --> 00:38:01,000
Przypuszczalnie x jest typ, który może zapisać numer 7,

559
00:38:01,000 --> 00:38:05,000
więc jest to int lub ewentualnie float lub krótkie lub char,

560
00:38:05,000 --> 00:38:07,000
coś takiego.

561
00:38:07,000 --> 00:38:12,000
Wyrażenie logiczne jest przy użyciu tych podwójnych wynosi

562
00:38:12,000 --> 00:38:17,000
i huk jest równa lub nie równy, mniejszy, większy niż,

563
00:38:17,000 --> 00:38:22,000
mniejsza lub równa, wszystkie tego rodzaju rzeczy.

564
00:38:22,000 --> 00:38:28,000
Warunki są więc jeśli else.

565
00:38:28,000 --> 00:38:32,000
Chcę pamiętać, że nie może mieć innego bez odpowiadających jeśli.

566
00:38:32,000 --> 00:38:37,000
Podobnie, nie może mieć innego, jeśli nie odpowiada, jeśli.

567
00:38:37,000 --> 00:38:40,000
Pętle, przywołać 3 rodzaje pętli byliśmy młotkiem w ciebie

568
00:38:40,000 --> 00:38:43,000
przez kilka ostatnich odcinków i zestawów problemowych.

569
00:38:43,000 --> 00:38:46,000
Pracy nie zaś kiedy dostajesz wejściowych użytkownika,

570
00:38:46,000 --> 00:38:51,000
przy pętli while aż określonego warunku jest prawdziwa,

571
00:38:51,000 --> 00:38:56,000
a następnie za pomocą tych pętli, jeśli trzeba

572
00:38:56,000 --> 00:39:01,000
wiedzieć, które iteracji pętli jesteś obecnie na to, jak o tym myślę.

573
00:39:01,000 --> 00:39:07,000
Lub jeśli robisz dla każdego znaku w ciągu znaków Chcę coś zrobić,

574
00:39:07,000 --> 00:39:15,000
dla każdego elementu w tablicy Chcę coś zrobić, aby tego elementu.

575
00:39:15,000 --> 00:39:18,000
>> Tematy i wydarzenia.

576
00:39:18,000 --> 00:39:21,000
Te nie zostały objęte tak wyraźnie w C,

577
00:39:21,000 --> 00:39:23,000
ale pamiętaj, że od podstaw.

578
00:39:23,000 --> 00:39:26,000
Jest to pojęcie o różnych skryptów.

579
00:39:26,000 --> 00:39:32,000
To jest także to pojęcie transmitowały wydarzenie.

580
00:39:32,000 --> 00:39:37,000
Niektórzy ludzie nie używali nadawania w swoich projektach początkowo

581
00:39:37,000 --> 00:39:40,000
która jest całkowicie cool,

582
00:39:40,000 --> 00:39:46,000
ale są to 2 różne sposoby obchodzenia się większy problem tzw współbieżności,

583
00:39:46,000 --> 00:39:49,000
co jest jak masz programy do wykonania

584
00:39:49,000 --> 00:39:54,000
lub pozornie wykonania jednocześnie?

585
00:39:54,000 --> 00:39:59,000
Różne zadania uruchomione podczas innych zadań są również wyświetlane.

586
00:39:59,000 --> 00:40:01,000
W ten sposób system operacyjny wydaje się działać.

587
00:40:01,000 --> 00:40:04,000
Dlatego, chociaż na przykład

588
00:40:04,000 --> 00:40:10,000
Mam swoją przeglądarkę działa, można również włączyć Spotify i odtworzyć utwór.

589
00:40:10,000 --> 00:40:14,000
To więcej koncepcyjnego rzeczą do zrozumienia.

590
00:40:14,000 --> 00:40:17,000
Chciałbym spojrzeć na krótkich wątków

591
00:40:17,000 --> 00:40:21,000
jeśli chcesz dowiedzieć się więcej o tym.

592
00:40:21,000 --> 00:40:26,000
>> Zobaczymy, wierzę, że może być

593
00:40:26,000 --> 00:40:31,000
problem związany z jednym z nich.

594
00:40:31,000 --> 00:40:35,000
Ponownie, myślę wątki i wydarzenia nie są czymś, co omówimy w C

595
00:40:35,000 --> 00:40:41,000
tylko dlatego, że jest to znacznie trudniejsze niż w Scratch.

596
00:40:41,000 --> 00:40:44,000
Nie należy martwić się o to nie, ale na pewno rozumieją pojęć,

597
00:40:44,000 --> 00:40:47,000
zrozumieć, co się dzieje.

598
00:40:47,000 --> 00:40:52,000
Zanim przejdziemy dalej, wszelkie pytania na temat Tygodnia 0 materialne?

599
00:40:52,000 --> 00:40:55,000
Każdy czuje się całkiem dobrze?

600
00:40:55,000 --> 00:41:03,000
Zrozumieć zmienne i co zmienną jest?

601
00:41:03,000 --> 00:41:08,000
>> Idziemy dalej. Tydzień 1.

602
00:41:08,000 --> 00:41:12,000
Kilka rzeczy tutaj nie szczególnie objęte

603
00:41:12,000 --> 00:41:21,000
w przeglądzie quizu koniecznie i są również bardziej koncepcyjne rzeczy do przemyślenia.

604
00:41:21,000 --> 00:41:30,000
Pierwszym jest to, że pojęcie o tym, co kod źródłowy, kompilatory i kod obiektu są.

605
00:41:30,000 --> 00:41:32,000
Ktoś? Bazyli.

606
00:41:32,000 --> 00:41:37,000
Jest obiektem kodu to znaczy kod źródłowy, co należy umieścić brzękiem,

607
00:41:37,000 --> 00:41:42,000
i kod obiektu jest co dzyń stawia się tak, że komputer może odczytać program.

608
00:41:42,000 --> 00:41:44,000
Dokładnie.

609
00:41:44,000 --> 00:41:47,000
Kod źródłowy jest kod C, że faktycznie wpisz się.

610
00:41:47,000 --> 00:41:50,000
Kod obiektu to co masz z brzękiem.

611
00:41:50,000 --> 00:41:54,000
To 0s i 1s w tym formacie binarnym.

612
00:41:54,000 --> 00:41:59,000
Więc co się dzieje, gdy masz kilka plików obiektowych,

613
00:41:59,000 --> 00:42:04,000
powiedzieć, że jesteś kompilacji projektu lub programu, który używa wielu plików kodu źródłowego,

614
00:42:04,000 --> 00:42:09,000
które umownie otrzymują. rozszerzenie c.

615
00:42:09,000 --> 00:42:13,000
Dlatego mamy caesar.c, vigenère.c.

616
00:42:13,000 --> 00:42:18,000
Jeśli piszesz programy Java dać im rozszerzenia. Java.

617
00:42:18,000 --> 00:42:24,000
Programy Pythona mają rozszerzenie. Py często.

618
00:42:24,000 --> 00:42:26,000
>> Gdy masz kilka. Plików C, należy je skompilować.

619
00:42:26,000 --> 00:42:29,000
Clang wypluwa wszystkie te śmieci binarnego.

620
00:42:29,000 --> 00:42:33,000
Następnie, ponieważ chcesz tylko 1 program,

621
00:42:33,000 --> 00:42:37,000
masz łącze linkera wszystkie te pliki razem obiektu

622
00:42:37,000 --> 00:42:40,000
w 1 pliku wykonywalnego.

623
00:42:40,000 --> 00:42:45,000
To jest także to, co dzieje się, gdy używasz CS50 biblioteki, na przykład.

624
00:42:45,000 --> 00:42:50,000
Biblioteka CS50 jest zarówno to. Plik nagłówka h

625
00:42:50,000 --> 00:42:53,000
który można przeczytać, że # includecs50.h.

626
00:42:53,000 --> 00:42:58,000
A potem to także specjalny plik binarny biblioteki

627
00:42:58,000 --> 00:43:02,000
że został skompilowany to 0s i 1s,

628
00:43:02,000 --> 00:43:08,000
a-l flag, więc jeśli wrócimy do naszych pomieszczeń i mamy naprawdę szybko

629
00:43:08,000 --> 00:43:11,000
na to, co się tutaj dzieje, kiedy patrzymy na nasze polecenia dzyń,

630
00:43:11,000 --> 00:43:15,000
co mamy to jest nasz plik kod źródłowy tutaj.

631
00:43:15,000 --> 00:43:18,000
Są kilka flag kompilatora.

632
00:43:18,000 --> 00:43:22,000
I wtedy na samym końcu, te-l Link flagi w

633
00:43:22,000 --> 00:43:30,000
rzeczywiste pliki binarne dla tych 2 bibliotek, CS50 bibliotece, a następnie biblioteki matematycznej.

634
00:43:30,000 --> 00:43:35,000
>> Zrozumienie celów każdego typu plików '

635
00:43:35,000 --> 00:43:38,000
w procesie kompilacji jest coś będziesz chciał być w stanie

636
00:43:38,000 --> 00:43:43,000
dać przynajmniej szczegółowy przegląd.

637
00:43:43,000 --> 00:43:46,000
Kod źródłowy jest cala Object kod wychodzi.

638
00:43:46,000 --> 00:43:53,000
Pliki kodu obiektowego połączyć razem, a otrzymasz piękny, plik wykonywalny.

639
00:43:53,000 --> 00:43:55,000
Cool.

640
00:43:55,000 --> 00:43:58,000
Jest to również, gdzie można uzyskać błędy w wielu punktach

641
00:43:58,000 --> 00:44:00,000
w procesie kompilacji.

642
00:44:00,000 --> 00:44:04,000
To tam, na przykład, jeśli wziąć tę flagę łączenia,

643
00:44:04,000 --> 00:44:10,000
CS50 flag i pominąć go w pomieszczeniach lub gdy używasz kodu,

644
00:44:10,000 --> 00:44:13,000
to gdzie dostaniesz błąd w fazie łączenia,

645
00:44:13,000 --> 00:44:18,000
i linker powiedzieć: "Hej, nazwałeś GetString funkcja

646
00:44:18,000 --> 00:44:20,000
że jest w CS50 biblioteki. "

647
00:44:20,000 --> 00:44:25,000
"Mówiłeś, że to było w CS50 bibliotece, a nie mogę znaleźć kodu do niego."

648
00:44:25,000 --> 00:44:28,000
To miejsce, gdzie należy połączyć go, a to jest osobny

649
00:44:28,000 --> 00:44:33,000
z błędu kompilatora ponieważ kompilator patrzy na składni i tego typu rzeczy.

650
00:44:33,000 --> 00:44:38,000
Dobrze jest wiedzieć, co się dzieje, kiedy.

651
00:44:38,000 --> 00:44:42,000
>> Inne rzeczy wiedzieć.

652
00:44:42,000 --> 00:44:49,000
Chciałbym powiedzieć, na pewno chcesz spojrzeć na krótki na Rzutowanie wykonane przez Jordan

653
00:44:49,000 --> 00:44:55,000
aby zrozumieć, co ints są pod maską,

654
00:44:55,000 --> 00:44:58,000
jakie znaki są pod maską.

655
00:44:58,000 --> 00:45:02,000
Kiedy mówimy o ASCII i naprawdę spojrzeć na ASCII tabeli

656
00:45:02,000 --> 00:45:07,000
co to robi daje nam pod kapturem wygląd

657
00:45:07,000 --> 00:45:13,000
w jaki sposób komputer faktycznie reprezentuje kapitał i cyfry 7

658
00:45:13,000 --> 00:45:17,000
i przecinek i znak zapytania.

659
00:45:17,000 --> 00:45:20,000
Komputer posiada również specjalne sposoby reprezentowania

660
00:45:20,000 --> 00:45:23,000
numer 7 jako liczba całkowita.

661
00:45:23,000 --> 00:45:27,000
Posiada specjalny sposób reprezentują liczbę 7 jako liczba zmiennoprzecinkowa,

662
00:45:27,000 --> 00:45:29,000
a te są bardzo różne.

663
00:45:29,000 --> 00:45:32,000
Rzutowanie jest to, jak mówisz, że komputer "Hej, chcę konwertować

664
00:45:32,000 --> 00:45:37,000
z jednej reprezentacji na inną reprezentację. "

665
00:45:37,000 --> 00:45:40,000
Dlaczego nie spojrzeć na to.

666
00:45:40,000 --> 00:45:44,000
>> Chciałbym również spojrzeć na krótki na bibliotekach brakuje kompilatorów.

667
00:45:44,000 --> 00:45:47,000
Ci, Dyskusja na temat procesu kompilacji,

668
00:45:47,000 --> 00:45:53,000
co biblioteka jest, i idź na niektóre z tych pytań, które mogą Ci się zapytał.

669
00:45:53,000 --> 00:45:55,000
Pytania na temat Tygodnia 1 materiału?

670
00:45:55,000 --> 00:46:03,000
Czy są jakieś tematy, które wydają się w tutaj trudne chcesz okładka?

671
00:46:03,000 --> 00:46:07,000
Próbuję cios przez większość tych wcześniejszych tematów tak, że możemy dostać się do

672
00:46:07,000 --> 00:46:13,000
wskaźniki i zrobić trochę rekursji.

673
00:46:13,000 --> 00:46:15,000
Myśli?

674
00:46:15,000 --> 00:46:19,000
Coś na pokrycie?

675
00:46:19,000 --> 00:46:21,000
Czas na czekoladę może?

676
00:46:21,000 --> 00:46:23,000
Chłopaki pracują przez nią.

677
00:46:23,000 --> 00:46:26,000
Zamierzam zachować popijając kawę.

678
00:46:26,000 --> 00:46:31,000
Tydzień 2.

679
00:46:31,000 --> 00:46:34,000
Dobre, dobre połączenie.

680
00:46:34,000 --> 00:46:38,000
W Tygodniu 2 rozmawialiśmy trochę więcej o funkcjach.

681
00:46:38,000 --> 00:46:43,000
>> W pierwszych kilku zestawów problemów tak naprawdę nie pisać żadnych funkcji w ogóle

682
00:46:43,000 --> 00:46:45,000
inne niż która funkcja?

683
00:46:45,000 --> 00:46:47,000
[Student] Main. >> Main, dokładnie.

684
00:46:47,000 --> 00:46:51,000
I tak widziałem różne kostiumy, że główny nosi.

685
00:46:51,000 --> 00:46:54,000
Jest to, w którym to ma żadnych argumentów,

686
00:46:54,000 --> 00:46:58,000
i po prostu powiedzieć, pustkę w nawiasach,

687
00:46:58,000 --> 00:47:01,000
i wtedy ten drugi, gdzie chcesz odebrać argumenty linii poleceń,

688
00:47:01,000 --> 00:47:08,000
i jak widzieliśmy, że tam masz int argc i argv tablicę ciągów

689
00:47:08,000 --> 00:47:13,000
czy teraz, że mamy rzeczywiście narażone ciąg być char *, że jest

690
00:47:13,000 --> 00:47:20,000
mamy zamiar zacząć pisać go jako char * argv i następnie nawiasach.

691
00:47:20,000 --> 00:47:22,000
W zestawie 3 Problem, chłopaki widziałem kilka funkcji,

692
00:47:22,000 --> 00:47:27,000
i wprowadził kilka funkcji, rysowanie patrzeć, Scramble.

693
00:47:27,000 --> 00:47:31,000
Prototypy były napisane dla Ciebie.

694
00:47:31,000 --> 00:47:33,000
>> Co chciałem porozmawiać o tutaj z funkcji bardzo szybko

695
00:47:33,000 --> 00:47:38,000
to, że są 3 części do nich, kiedy tylko napisać funkcję.

696
00:47:38,000 --> 00:47:43,000
Musisz określić typ wartości funkcji.

697
00:47:43,000 --> 00:47:46,000
Musisz podać nazwę dla funkcji, a następnie trzeba określić

698
00:47:46,000 --> 00:47:51,000
Lista argumentów lub listy parametrów.

699
00:47:51,000 --> 00:47:57,000
Na przykład, jeśli miałbym napisać funkcję, aby podsumować kilka liczb całkowitych

700
00:47:57,000 --> 00:48:03,000
, a następnie wróć do mnie sumę, co byłoby moim typie reklamacji

701
00:48:03,000 --> 00:48:06,000
gdybym chciał podsumować liczby całkowite, a następnie zwrócić sumę?

702
00:48:06,000 --> 00:48:12,000
Następnie nazwa funkcji.

703
00:48:12,000 --> 00:48:27,000
Jeśli pójdę dalej i napisać na zielono, ta część jest typ zwracany.

704
00:48:27,000 --> 00:48:34,000
Ta część jest nazwa.

705
00:48:34,000 --> 00:48:40,000
A następnie w nawiasach

706
00:48:40,000 --> 00:48:46,000
Tu podam argumenty,

707
00:48:46,000 --> 00:48:56,000
często w skrócie args, czasami nazywany params dla parametrów.

708
00:48:56,000 --> 00:49:00,000
A jeśli masz, wystarczy podać jeden.

709
00:49:00,000 --> 00:49:06,000
Jeśli masz wiele oddzielić każdy przecinkiem.

710
00:49:06,000 --> 00:49:13,000
I dla każdego argumentu, który otrzymał 2 rzeczy, które są-Kevin?

711
00:49:13,000 --> 00:49:18,000
[Kevin] Musisz podać rodzaj i nazwę.

712
00:49:18,000 --> 00:49:21,000
A następnie imię i nazwisko to nazwa, że ​​masz zamiar używać

713
00:49:21,000 --> 00:49:25,000
odnieść się do tego argumentu w funkcji SUM,

714
00:49:25,000 --> 00:49:27,000
w funkcji, którą aktualnie pisze.

715
00:49:27,000 --> 00:49:32,000
>> Nie musisz się na przykład, jeśli mam zamiar Reasumując

716
00:49:32,000 --> 00:49:41,000
powiedzieć, tablica liczb całkowitych-we'll zrobić int tablicy,

717
00:49:41,000 --> 00:49:46,000
i dam sobie niektóre nawiasy klamrowe nie-

718
00:49:46,000 --> 00:49:51,000
potem, kiedy przekazać tablicę do funkcji SUMA

719
00:49:51,000 --> 00:49:55,000
I przekazać go na pierwszej pozycji na liście argumentów.

720
00:49:55,000 --> 00:49:59,000
Ale tablica, że ​​przechodzą w nie musi mieć arr nazw.

721
00:49:59,000 --> 00:50:07,000
Układ będzie, jak odnoszę się do tego argumentu w ciele funkcji.

722
00:50:07,000 --> 00:50:10,000
Inne rzeczy, które musimy wziąć pod uwagę,

723
00:50:10,000 --> 00:50:14,000
i to jest nieco inna od funkcji, ale myślę, że to ważny punkt,

724
00:50:14,000 --> 00:50:20,000
jest to, że w C kiedy piszę funkcji takich jak ta

725
00:50:20,000 --> 00:50:29,000
skąd mam wiedzieć, ile elementów znajduje się w tej tablicy?

726
00:50:29,000 --> 00:50:31,000
To jest trochę podchwytliwe pytanie.

727
00:50:31,000 --> 00:50:35,000
Rozmawialiśmy o tym trochę w zeszłotygodniowym sekcji.

728
00:50:35,000 --> 00:50:40,000
Skąd mam wiedzieć, liczbę elementów wewnątrz tablicy w C?

729
00:50:40,000 --> 00:50:44,000
Czy jest jakiś sposób?

730
00:50:44,000 --> 00:50:49,000
>> Okazuje się, że nie sposób się dowiedzieć.

731
00:50:49,000 --> 00:50:52,000
Musisz przekazać go osobno.

732
00:50:52,000 --> 00:50:55,000
Istnieje trik, który można zrobić

733
00:50:55,000 --> 00:51:00,000
jeśli jesteś w tej samej funkcji, w której tablica została uznana,

734
00:51:00,000 --> 00:51:04,000
i pracy z tablicy stosu.

735
00:51:04,000 --> 00:51:06,000
Ale to działa tylko jeśli jesteś w tej samej funkcji.

736
00:51:06,000 --> 00:51:09,000
Kiedy przekazać tablicę do innej funkcji lub, jeśli już zadeklarował tablicę

737
00:51:09,000 --> 00:51:12,000
i umieścić tę tablicę na stercie, użyłeś malloc

738
00:51:12,000 --> 00:51:15,000
 i tego rodzaju rzeczy, to wszystkie zakłady są wyłączone.

739
00:51:15,000 --> 00:51:18,000
Wtedy faktycznie musi przekazywać

740
00:51:18,000 --> 00:51:21,000
Specjalny argument lub inny parametr

741
00:51:21,000 --> 00:51:23,000
mówi ci, jak duża tablica jest.

742
00:51:23,000 --> 00:51:28,000
W tym przypadku, chciałbym użyć przecinka-Przepraszam, to będzie wyłączenie ekranu tu

743
00:51:28,000 --> 00:51:32,000
i chciałbym przekazać w innym argumentem

744
00:51:32,000 --> 00:51:40,000
 i nazywają to int len ​​na długości.

745
00:51:40,000 --> 00:51:44,000
>> Jedna rzecz, która może pochodzić z quizu

746
00:51:44,000 --> 00:51:49,000
prosi cię do zapisu lub wykonania szczególnego funkcję o nazwie coś.

747
00:51:49,000 --> 00:51:54,000
Jeśli nie daje prototyp, więc cała ta sprawa tutaj

748
00:51:54,000 --> 00:51:58,000
ten cały bałagan nazywa deklarację funkcji lub prototyp funkcji,

749
00:51:58,000 --> 00:52:01,000
jest to jedna z pierwszych rzeczy, które będziesz chciał do paznokci w dół, jeśli nie jest podana

750
00:52:01,000 --> 00:52:03,000
ci od razu na quiz.

751
00:52:03,000 --> 00:52:06,000
Inny trik nauczyłem jest to, że

752
00:52:06,000 --> 00:52:11,000
powiedzieć, że dają ci prototyp funkcji, a my mówimy, "Hej, masz to napisać".

753
00:52:11,000 --> 00:52:16,000
Wewnątrz nawiasów klamrowych, które masz na quiz

754
00:52:16,000 --> 00:52:20,000
jeśli zauważysz, że istnieje rodzaj powrotu i można zauważyć, że typ zwracany

755
00:52:20,000 --> 00:52:25,000
jest czymś innym niż pustką, co oznacza, że ​​funkcja nie zwraca nic,

756
00:52:25,000 --> 00:52:28,000
następnie jedna rzecz na pewno chcesz to zrobić, to napisać

757
00:52:28,000 --> 00:52:33,000
jakiś instrukcji return na końcu funkcji.

758
00:52:33,000 --> 00:52:40,000
Return, w tym przypadku, możemy umieścić puste, ponieważ chcemy, aby wypełnić puste.

759
00:52:40,000 --> 00:52:44,000
Ale to dostaje myślisz w odpowiedni sposób o tym, jak ja mam podejść do tego problemu?

760
00:52:44,000 --> 00:52:49,000
I przypomina ci, że będziemy musieli zwrócić wartość

761
00:52:49,000 --> 00:52:51,000
do wywołującego funkcji.

762
00:52:51,000 --> 00:52:54,000
>> Tak. >> [Student] Czy styl stosuje się, gdy piszemy kod na quizie?

763
00:52:54,000 --> 00:52:58,000
Takich jak wgniecenia i tego typu rzeczy? >> [Student] Tak.

764
00:52:58,000 --> 00:53:00,000
Nie, to nie tak dużo.

765
00:53:00,000 --> 00:53:09,000
Myślę, że dużo, to jest coś, będziemy wyjaśnienie na quizie, w dniu,

766
00:53:09,000 --> 00:53:15,000
ale zazwyczaj martwić # obejmuje i tego rodzaju rzeczy, to jest rodzaj zewnątrz.

767
00:53:15,000 --> 00:53:17,000
[Student] Czy trzeba komentować odręcznego kodu?

768
00:53:17,000 --> 00:53:19,000
Czy trzeba komentować odręcznego kodu?

769
00:53:19,000 --> 00:53:24,000
Komentując zawsze jest dobre, jeśli martwisz się o częściowej ulgi

770
00:53:24,000 --> 00:53:29,000
lub chcesz przekazać sens do równiarka.

771
00:53:29,000 --> 00:53:33,000
Ale, znowu, wyjaśnienia na quizie siebie na dzień quizu,

772
00:53:33,000 --> 00:53:39,000
ale nie wierzę, że będziesz zobowiązany napisać komentarz, nie.

773
00:53:39,000 --> 00:53:42,000
Zazwyczaj nie, ale na pewno coś takiego, gdzie

774
00:53:42,000 --> 00:53:45,000
można przekazać sens, jak "Hej, to jest tam, gdzie idę z nim."

775
00:53:45,000 --> 00:53:49,000
A czasami, które mogą pomóc z częściowym kredytu.

776
00:53:49,000 --> 00:53:51,000
Cool.

777
00:53:51,000 --> 00:53:53,000
>> Bazyli.

778
00:53:53,000 --> 00:53:56,000
[Basil] Jaka jest różnica między oświadczając, powiedzmy, int Lang

779
00:53:56,000 --> 00:54:03,000
w argumentach lub parametrów w porównaniu deklarowanie zmiennej w funkcji?

780
00:54:03,000 --> 00:54:05,000
Wow, kawa zszedł tchawicę.

781
00:54:05,000 --> 00:54:07,000
[Basil] Podoba które rzeczy chcemy umieścić w argumentach.

782
00:54:07,000 --> 00:54:09,000
Tak, to jest dobre pytanie.

783
00:54:09,000 --> 00:54:11,000
Jak wybrać, jakie rzeczy, które chcesz umieścić w argumentach

784
00:54:11,000 --> 00:54:17,000
wobec jakich rzeczy należy zrobić wewnątrz funkcji?

785
00:54:17,000 --> 00:54:24,000
W tym przypadku mamy włączone oba te jako argumenty

786
00:54:24,000 --> 00:54:29,000
ponieważ są one czymś, co każdy, kto ma zamiar używać funkcji SUMA

787
00:54:29,000 --> 00:54:32,000
musi określić te rzeczy.

788
00:54:32,000 --> 00:54:35,000
>> Funkcja suma, jak rozmawialiśmy, nie ma sposobu, by dowiedzieć

789
00:54:35,000 --> 00:54:40,000
jak duża tablica jest dostaje od swojego rozmówcy lub ktokolwiek jest za pomocą funkcji SUMA.

790
00:54:40,000 --> 00:54:44,000
To nie ma możliwości dowiedzenia się, jak duży, że tablica jest.

791
00:54:44,000 --> 00:54:48,000
Powodem mijamy na tej długości tu jako argument

792
00:54:48,000 --> 00:54:51,000
dlatego, że jest coś, co my w zasadzie mówi abonenta z funkcji,

793
00:54:51,000 --> 00:54:55,000
kto ma zamiar używać funkcji SUMA: "Hej, nie tylko trzeba dać nam tablicę

794
00:54:55,000 --> 00:54:59,000
z wskazówki, trzeba też powiedzieć, jak duża tablica dałeś nam jest. "

795
00:54:59,000 --> 00:55:03,000
[Basil] Ci będzie być zarówno argumenty wiersza poleceń?

796
00:55:03,000 --> 00:55:06,000
Nie, to są rzeczywiste argumenty, które chcesz przekazać do funkcji.

797
00:55:06,000 --> 00:55:10,000
>> Pozwól mi zrobić nową stronę tutaj.

798
00:55:10,000 --> 00:55:13,000
[Basil] Podoba imię minie-

799
00:55:13,000 --> 00:55:24,000
[Nate H.] Jeśli mam int main (void)

800
00:55:24,000 --> 00:55:27,000
i mam zamiar umieścić w 0 powrotu tu na dole,

801
00:55:27,000 --> 00:55:31,000
i powiedzieć, że chcesz wywołać funkcję SUMA.

802
00:55:31,000 --> 00:55:42,000
Chcę powiedzieć, int x = suma ();

803
00:55:42,000 --> 00:55:46,000
Aby skorzystać z funkcji suma muszę zdać zarówno tablicy, że chcę, aby podsumować

804
00:55:46,000 --> 00:55:51,000
i długość tablicy, więc, gdy jest to

805
00:55:51,000 --> 00:55:54,000
zakładając miałem tablicę wskazówki,

806
00:55:54,000 --> 00:56:12,000
że miałem int numbaz [] = 1, 2, 3,

807
00:56:12,000 --> 00:56:16,000
rodzaj użytkowania, który włamał się składni tam,

808
00:56:16,000 --> 00:56:21,000
to co chciałbym zrobić, to w sumie chciałbym przekazać w

809
00:56:21,000 --> 00:56:27,000
zarówno numbaz i numer 3

810
00:56:27,000 --> 00:56:30,000
powiedzieć funkcji Sum "Dobra, tu jest tablica chcę żebyś Podsumowując".

811
00:56:30,000 --> 00:56:34,000
"Tu jest jego wielkość."

812
00:56:34,000 --> 00:56:39,000
Czy to ma sens? Czy to wyjaśniło Twoje pytanie?

813
00:56:39,000 --> 00:56:42,000
>> Pod wieloma względami to nie równolegle, co robimy z głównym

814
00:56:42,000 --> 00:56:44,000
kiedy mamy argumenty wiersza poleceń.

815
00:56:44,000 --> 00:56:47,000
Program jak Caesar szyfrowania, na przykład, że potrzebne

816
00:56:47,000 --> 00:56:53,000
Argumenty wiersza poleceń, nie będzie w stanie nic zrobić.

817
00:56:53,000 --> 00:56:57,000
Nie wiem, jak do szyfrowania, jeśli nie powiedzieć, to to, co kluczowe w użyciu

818
00:56:57,000 --> 00:57:03,000
lub, jeśli nie powiedzieć to, co łańcuch chciał zaszyfrować.

819
00:57:03,000 --> 00:57:08,000
Skłoniło do wejścia, to jest, gdy mamy 2 różne mechanizmy

820
00:57:08,000 --> 00:57:14,000
podejmowania wejście od użytkownika, na przy informacji od użytkownika.

821
00:57:14,000 --> 00:57:19,000
Na problem Ustaw 1 widzieliśmy to getInt, getString, GetFloat drogę

822
00:57:19,000 --> 00:57:26,000
zachęcania do wejścia, i że nazywa się przy użyciu standardowego strumienia wejściowego.

823
00:57:26,000 --> 00:57:28,000
To jest nieco inny.

824
00:57:28,000 --> 00:57:31,000
To coś, co można zrobić w tym samym czasie, w przeciwieństwie do

825
00:57:31,000 --> 00:57:35,000
po wywołaniu programu, po uruchomieniu program uruchomiony.

826
00:57:35,000 --> 00:57:41,000
Argumenty wiersza poleceń wszystkim określone są w momencie startu biegu programu.

827
00:57:41,000 --> 00:57:47,000
Byliśmy zmieszaniu obu tych.

828
00:57:47,000 --> 00:57:52,000
Kiedy używamy argumentów do funkcji, to jest podobnie jak argumenty wiersza polecenia do main.

829
00:57:52,000 --> 00:57:56,000
Jest to przy wywołaniu funkcji, musisz poinformować go

830
00:57:56,000 --> 00:58:05,000
co dokładnie potrzebuje w celu wykonywania swoich zadań.

831
00:58:05,000 --> 00:58:08,000
Inną dobrą rzeczą patrzeć i dam ci spojrzeć na to w swoim wolnym czasie,

832
00:58:08,000 --> 00:58:11,000
i został pokryty w quizie-było to pojęcie zakresu

833
00:58:11,000 --> 00:58:15,000
i zmienne lokalne porównaniu zmiennych globalnych.

834
00:58:15,000 --> 00:58:18,000
Czy zwracać uwagę na to.

835
00:58:18,000 --> 00:58:23,000
>> Teraz, gdy jesteśmy już na tej innej rzeczy,

836
00:58:23,000 --> 00:58:27,000
w Tygodniu 3 zaczęliśmy rozmawiać o wyszukiwanie i sortowanie.

837
00:58:27,000 --> 00:58:32,000
Wyszukiwanie i sortowania, przynajmniej CS50,

838
00:58:32,000 --> 00:58:39,000
jest bardzo wprowadzenie do niektórych z bardziej teoretycznych części informatyki.

839
00:58:39,000 --> 00:58:42,000
Problem poszukiwania, problem sortowania

840
00:58:42,000 --> 00:58:46,000
są duże, kanoniczne problemy.

841
00:58:46,000 --> 00:58:52,000
Jak znaleźć konkretny numer w tablicy miliardów liczb całkowitych?

842
00:58:52,000 --> 00:58:55,000
Jak znaleźć konkretnej nazwy wewnątrz książki telefonicznej

843
00:58:55,000 --> 00:58:59,000
która jest przechowywana na komputerze przenośnym?

844
00:58:59,000 --> 00:59:04,000
A więc wprowadzenie tego pojęcia asymptotycznych czasów przebiegu

845
00:59:04,000 --> 00:59:11,000
naprawdę oszacować, jak długo, jak ciężko to problemem są

846
00:59:11,000 --> 00:59:14,000
jak długo się do rozwiązania.

847
00:59:14,000 --> 00:59:20,000
W Uważam, 2011 w quizie jest problem, że myślę zasługi

848
00:59:20,000 --> 00:59:27,000
obejmujące bardzo szybko, co jest ta, problem 12.

849
00:59:27,000 --> 00:59:32,000
O nie, to Omega.

850
00:59:32,000 --> 00:59:41,000
>> Tutaj mówimy o najszybszym możliwym czasie wykonywania

851
00:59:41,000 --> 00:59:46,000
dla konkretnego algorytmu i najwolniejszy możliwy czas run.

852
00:59:46,000 --> 00:59:52,000
Ta Omega i O są tak naprawdę na skróty.

853
00:59:52,000 --> 00:59:55,000
Są skróty notacji za powiedzenie

854
00:59:55,000 --> 00:59:59,000
jak szybko, w przypadku możliwie najlepszy będzie nasz run algorytm,

855
00:59:59,000 --> 01:00:06,000
i jak wolno w przypadku najgorszym możliwym będzie nasz algorytm uruchomić?

856
01:00:06,000 --> 01:00:10,000
Zróbmy kilka z nich, a te zostały również objęte

857
01:00:10,000 --> 01:00:13,000
w notacji asymptotycznej na krótko, co gorąco polecam.

858
01:00:13,000 --> 01:00:17,000
Jackson zrobił naprawdę dobrą robotę.

859
01:00:17,000 --> 01:00:23,000
Z wyszukiwaniem binarnym, mówimy o binarnym wyszukiwanie jako algorytm,

860
01:00:23,000 --> 01:00:28,000
a my zazwyczaj o tym mówić w kategoriach jej wielkiego O.

861
01:00:28,000 --> 01:00:30,000
Co to jest duże O?

862
01:00:30,000 --> 01:00:34,000
Co to jest najwolniejszy możliwy czas pracy wyszukiwania binarnego?

863
01:00:34,000 --> 01:00:36,000
[Student] N ²?

864
01:00:36,000 --> 01:00:41,000
Zamknij Chyba podobny do tego.

865
01:00:41,000 --> 01:00:43,000
To dużo szybciej niż.

866
01:00:43,000 --> 01:00:45,000
[Student] Binary? >> Tak, binary search.

867
01:00:45,000 --> 01:00:47,000
[Student] To log n.

868
01:00:47,000 --> 01:00:49,000
Log n, więc co robi log n oznacza?

869
01:00:49,000 --> 01:00:51,000
Jest to o połowę każdej iteracji.

870
01:00:51,000 --> 01:00:56,000
Dokładnie, tak w przypadku najwolniejszego możliwym

871
01:00:56,000 --> 01:01:00,000
powiedzieć, jeśli masz posortowaną tablicę

872
01:01:00,000 --> 01:01:08,000
miliona liczb i liczby szukasz

873
01:01:08,000 --> 01:01:14,000
jest albo pierwszy element tablicy lub elementu ostatniego w tablicy.

874
01:01:14,000 --> 01:01:18,000
Pamiętaj, binarnie algorytm wyszukiwania działa patrząc na środkowym elemencie,

875
01:01:18,000 --> 01:01:21,000
zobaczyć, czy to mecz, który szukasz.

876
01:01:21,000 --> 01:01:23,000
Jeśli tak, to świetnie, że znalazłeś to.

877
01:01:23,000 --> 01:01:27,000
>> W przypadku możliwie najlepszy, jak szybko działa wyszukiwanie binarne?

878
01:01:27,000 --> 01:01:29,000
[Studenci] 1.

879
01:01:29,000 --> 01:01:32,000
1, to jest stała czasowa, duże O z 1. Tak.

880
01:01:32,000 --> 01:01:36,000
[Student] Mam pytanie. Kiedy mówisz zaloguj n, to znaczy w odniesieniu do podstawy 2, prawda?

881
01:01:36,000 --> 01:01:40,000
Tak, tak, to jest inna sprawa.

882
01:01:40,000 --> 01:01:44,000
Mówimy n log, i myślę, kiedy byłem w szkole średniej

883
01:01:44,000 --> 01:01:48,000
I zawsze założyć, że log był podstawą 10.

884
01:01:48,000 --> 01:01:57,000
Tak, tak, tak, zaloguj 2 podstawa jest zazwyczaj co używamy.

885
01:01:57,000 --> 01:02:02,000
Znowu wraca do binarnego wyszukiwania, jeśli szukasz albo

886
01:02:02,000 --> 01:02:05,000
element na końcu lub na element początku

887
01:02:05,000 --> 01:02:08,000
ponieważ zaczynają się w środku, a potem wyrzucić

888
01:02:08,000 --> 01:02:13,000
zależności od tego, pół nie spełnia kryteriów, które szukasz,

889
01:02:13,000 --> 01:02:15,000
i przejść do następnej pół i pół następnego i pół następnego.

890
01:02:15,000 --> 01:02:19,000
Jeśli szukam największego elementu w tablicy liczb całkowitych mln

891
01:02:19,000 --> 01:02:25,000
Zamierzam go co najwyżej połowę dzienniku 1 mln razy

892
01:02:25,000 --> 01:02:28,000
zanim w końcu przetestować i zobaczyć, że element Szuka

893
01:02:28,000 --> 01:02:33,000
największa w lub najwyższy wskaźnik tablicy

894
01:02:33,000 --> 01:02:38,000
i że będzie log n, zaloguj 1 milion razy.

895
01:02:38,000 --> 01:02:40,000
>> Sortowanie bąbelkowe.

896
01:02:40,000 --> 01:02:43,000
Czy faceci pamiętam algorytmu sortowania bąbelkowego?

897
01:02:43,000 --> 01:02:47,000
Kevin, możesz dać mi szybko zakręcić, co się stało w algorytmie sortowania bąbelkowego?

898
01:02:47,000 --> 01:02:50,000
[Kevin] Zasadniczo to przechodzi wszystko w liście.

899
01:02:50,000 --> 01:02:52,000
Wygląda to na dwóch pierwszych.

900
01:02:52,000 --> 01:02:55,000
Jeśli pierwsza jest większa od drugiej it swapów nich.

901
01:02:55,000 --> 01:02:58,000
Następnie porównuje drugi i trzeci, to samo, swapy,

902
01:02:58,000 --> 01:03:00,000
trzecie i czwarte, w dół.

903
01:03:00,000 --> 01:03:03,000
Większe numery nastąpi do końca.

904
01:03:03,000 --> 01:03:07,000
I po pętli jednak wielu skończysz.

905
01:03:07,000 --> 01:03:11,000
Dokładnie, tak to, co powiedział, jest to, że Kevin będziemy obserwować większych liczb

906
01:03:11,000 --> 01:03:15,000
Bańka do końca tablicy.

907
01:03:15,000 --> 01:03:19,000
Na przykład, czy przeszkadza iść z nami przez ten przykład, jeśli jest to nasza tablica?

908
01:03:19,000 --> 01:03:21,000
[Kevin] Będziesz się 2 i 3.

909
01:03:21,000 --> 01:03:23,000
3 jest większa niż 2, więc zamienić je.

910
01:03:23,000 --> 01:03:29,000
[Nate H.] Prawo, więc zamiana tych, a więc mamy 2, 3, 6, 4 i 9.

911
01:03:29,000 --> 01:03:31,000
[Kevin] Następnie porównać 3 i 6.

912
01:03:31,000 --> 01:03:33,000
3 jest mniejsza niż 6, więc zostaw je,

913
01:03:33,000 --> 01:03:37,000
6 i 4, można zamienić je, ponieważ 4 jest mniejsza niż 6.

914
01:03:37,000 --> 01:03:42,000
[Nate H.] Prawo, więc mam 2, 3, 4, 6, 9.

915
01:03:42,000 --> 01:03:46,000
[Kevin] A 9 jest większa niż 6, więc zostaw.

916
01:03:46,000 --> 01:03:48,000
I chcesz przejść z powrotem przez to ponownie.

917
01:03:48,000 --> 01:03:50,000
>> [Nate H.] Czy mogę zrobić w tym momencie? >> [Kevin] L.

918
01:03:50,000 --> 01:03:52,000
A dlaczego nie zrobiłem w tym momencie?

919
01:03:52,000 --> 01:03:54,000
Bo to wygląda jak moja tablica jest sortowana. Patrzę na niego.

920
01:03:54,000 --> 01:03:57,000
[Kevin] Przejdź przez nią ponownie i upewnij się, że nie ma więcej swapy

921
01:03:57,000 --> 01:04:00,000
zanim będzie można w pełni zatrzymać.

922
01:04:00,000 --> 01:04:04,000
Dokładnie, więc trzeba iść dalej przez i upewnij się, że nie istnieją żadne swapy

923
01:04:04,000 --> 01:04:06,000
że można zrobić w tym momencie.

924
01:04:06,000 --> 01:04:08,000
To był naprawdę szczęśliwy, jak pan powiedział, że skończyło się

925
01:04:08,000 --> 01:04:12,000
tylko o 1, aby przejść i mamy załatwione.

926
01:04:12,000 --> 01:04:16,000
Ale aby to zrobić w ogólnym przypadku będziemy rzeczywiście trzeba to zrobić w kółko.

927
01:04:16,000 --> 01:04:20,000
I faktycznie, to był przykład przypadku najlepszym możliwym

928
01:04:20,000 --> 01:04:24,000
jak widzieliśmy w problem.

929
01:04:24,000 --> 01:04:28,000
Widzieliśmy, że najlepsza sprawa N.

930
01:04:28,000 --> 01:04:32,000
Przeszliśmy przez tablicy 1 raz.

931
01:04:32,000 --> 01:04:35,000
Co jest najgorszym możliwym przypadku tego algorytmu?

932
01:04:35,000 --> 01:04:37,000
[Kevin] N ².

933
01:04:37,000 --> 01:04:41,000
A co to wygląda? Co by wygląd tablicy tak będzie wymagać czasu ² n?

934
01:04:41,000 --> 01:04:43,000
[Kevin] [niesłyszalne] posortowane.

935
01:04:43,000 --> 01:04:51,000
Dokładnie, więc gdybym miał tablicy 9, 7, 6, 5, 2,

936
01:04:51,000 --> 01:04:54,000
najpierw 9 by bańka całą drogę.

937
01:04:54,000 --> 01:04:59,000
Po 1 iteracji mielibyśmy 7, 6, 5, 2, 9.

938
01:04:59,000 --> 01:05:07,000
Następnie 7 będzie się pęcherzyków, 6, 5, 2, 7, 9, i tak dalej, i tak dalej.

939
01:05:07,000 --> 01:05:13,000
>> Musielibyśmy przejść całej tablicy n razy,

940
01:05:13,000 --> 01:05:16,000
i rzeczywiście można uzyskać nieco bardziej precyzyjna niż ta

941
01:05:16,000 --> 01:05:23,000
bo raz mamy przeniósł 9 się aż do ostatniej możliwej pozycji

942
01:05:23,000 --> 01:05:26,000
wiemy, że nie musimy się porównać z tym elementem ponownie.

943
01:05:26,000 --> 01:05:29,000
Gdy zaczynamy się pęcherzyków na 7

944
01:05:29,000 --> 01:05:35,000
wiemy, że możemy zatrzymać po 7 jest tuż przed 9

945
01:05:35,000 --> 01:05:37,000
skoro mamy już porównał 9 do niego.

946
01:05:37,000 --> 01:05:46,000
Jeśli zrobisz to w inteligentny sposób, że nie jest dobrze, myślę, że wiele czasu.

947
01:05:46,000 --> 01:05:49,000
Nie idziesz do porównania wszystkich możliwych kombinacji [niesłyszalne]

948
01:05:49,000 --> 01:05:55,000
za każdym razem przejść przez każdej iteracji.

949
01:05:55,000 --> 01:05:59,000
Ale nadal, gdy mówimy o tym górne możemy powiedzieć, że

950
01:05:59,000 --> 01:06:04,000
szukasz na n ² porównań przez całą drogę.

951
01:06:04,000 --> 01:06:12,000
>> Wróćmy, a ponieważ zaczynamy się trochę mało czasu

952
01:06:12,000 --> 01:06:15,000
Chciałbym powiedzieć, powinno się przejść przez resztę tej tabeli,

953
01:06:15,000 --> 01:06:17,000
wypełnić to wszystko.

954
01:06:17,000 --> 01:06:20,000
Pomyśl o przykładach. Pomyśl o konkretnych przykładach.

955
01:06:20,000 --> 01:06:22,000
To naprawdę przydatne i pomocne uwagi.

956
01:06:22,000 --> 01:06:25,000
Narysuj go.

957
01:06:25,000 --> 01:06:28,000
Jest to rodzaj tabeli, jak przejść przez w informatyce

958
01:06:28,000 --> 01:06:32,000
trzeba naprawdę zacząć wiedzieć te przez serce.

959
01:06:32,000 --> 01:06:34,000
Są to rodzaje pytań można uzyskać w wywiadach.

960
01:06:34,000 --> 01:06:36,000
Są różne rzeczy, które są dobre, by wiedzieć,

961
01:06:36,000 --> 01:06:41,000
i myślę o tych przypadkach krawędzi, naprawdę dowiedzieć się, jak myśleć o

962
01:06:41,000 --> 01:06:45,000
wiedząc, że na bańce sortować najgorszy możliwy tablicę

963
01:06:45,000 --> 01:06:52,000
sortować z tym jest taki, który znajduje się w odwrotnej kolejności.

964
01:06:52,000 --> 01:06:58,000
>> Wskaźniki. Porozmawiajmy trochę o wskaźniki.

965
01:06:58,000 --> 01:07:03,000
W ciągu ostatnich kilku minut mamy tutaj

966
01:07:03,000 --> 01:07:11,000
Wiem, że to jest coś, wraz z pliku I / O, który jest dość nowy.

967
01:07:11,000 --> 01:07:19,000
Kiedy mówimy o wskaźniki powód chcemy rozmawiać o wskaźniki

968
01:07:19,000 --> 01:07:24,000
Jest tak, ponieważ, gdy wszystko pracujemy w C

969
01:07:24,000 --> 01:07:33,000
jesteśmy naprawdę na poziomie dość niskim w porównaniu do większości nowoczesnych języków programowania.

970
01:07:33,000 --> 01:07:38,000
Jesteśmy rzeczywiście w stanie manipulować zmienne w pamięci,

971
01:07:38,000 --> 01:07:43,000
dowiedzieć się, gdzie są one faktycznie się w naszej pamięci.

972
01:07:43,000 --> 01:07:46,000
Kiedy już przeszli do podjęcia zajęcia systemu operacyjnego zobaczysz

973
01:07:46,000 --> 01:07:48,000
że jest znów rodzaj abstrakcji.

974
01:07:48,000 --> 01:07:50,000
To nie jest faktycznie prawdą.

975
01:07:50,000 --> 01:07:52,000
Mamy pamięci wirtualnej, która ukrywa te informacje od nas.

976
01:07:52,000 --> 01:07:58,000
>> Ale teraz można założyć, że gdy masz program,

977
01:07:58,000 --> 01:08:02,000
na przykład podczas uruchamiania uruchomić program-szyfr Cezara

978
01:08:02,000 --> 01:08:06,000
Będę przełączyć z powrotem do mojego iPada naprawdę szybko-

979
01:08:06,000 --> 01:08:12,000
, że na samym początku programu, jeśli masz, powiedzmy,

980
01:08:12,000 --> 01:08:15,000
4 gigabajty pamięci RAM na komputerze przenośnym,

981
01:08:15,000 --> 01:08:21,000
dostaniesz uchylił ten kawałek, a my nazywamy to RAM.

982
01:08:21,000 --> 01:08:25,000
I rozpoczyna się w miejscu, mamy zamiar zadzwonić 0,

983
01:08:25,000 --> 01:08:30,000
i kończy się w miejscu, które będziemy nazywać 4 gigabajty.

984
01:08:30,000 --> 01:08:37,000
Naprawdę nie mogę napisać. Człowiek, który włamał.

985
01:08:37,000 --> 01:08:40,000
Gdy program wykonuje

986
01:08:40,000 --> 01:08:44,000
system operacyjny rzeźbi pamięć RAM,

987
01:08:44,000 --> 01:08:51,000
i określa różne segmenty dla różnych części programu, aby żyjemy

988
01:08:51,000 --> 01:08:58,000
Tu obszar ten jest swego rodzaju ziemi niczyjej.

989
01:08:58,000 --> 01:09:02,000
Kiedy iść trochę dalej tutaj

990
01:09:02,000 --> 01:09:05,000
masz rzeczywiście miejsce, gdzie

991
01:09:05,000 --> 01:09:09,000
Kod dla życia programu.

992
01:09:09,000 --> 01:09:13,000
Że rzeczywisty kod binarny, plik wykonywalny, faktycznie jest ładowany do pamięci

993
01:09:13,000 --> 01:09:17,000
podczas uruchamiania programu, a żyje w segmencie kodu.

994
01:09:17,000 --> 01:09:22,000
A jak Twój program wykonuje procesor wygląda na tym segmencie kodu

995
01:09:22,000 --> 01:09:24,000
dowiedzieć się, co to jest następna instrukcja?

996
01:09:24,000 --> 01:09:27,000
Jaki jest następny wiersz kodu muszę wykonać?

997
01:09:27,000 --> 01:09:31,000
>> Istnieje również segment danych, a to jest w przypadku gdy te stałe łańcuchowe

998
01:09:31,000 --> 01:09:34,000
przechowywana że używałeś.

999
01:09:34,000 --> 01:09:42,000
A potem dalej się tam to jest miejsce zwane sterty.

1000
01:09:42,000 --> 01:09:46,000
Mamy dostęp do pamięci, tam za pomocą malloc,

1001
01:09:46,000 --> 01:09:49,000
, a następnie w kierunku samej górze programu

1002
01:09:49,000 --> 01:09:52,000
tam stos,

1003
01:09:52,000 --> 01:09:57,000
i tam graliśmy w większości na początku.

1004
01:09:57,000 --> 01:09:59,000
To nie jest w skali, ani nic.

1005
01:09:59,000 --> 01:10:03,000
Wiele z tego jest bardzo zależne od maszyny,

1006
01:10:03,000 --> 01:10:10,000
zależne od systemu operacyjnego, ale jest to stosunkowo jak rzeczy się pofragmentowane up.

1007
01:10:10,000 --> 01:10:17,000
Po uruchomieniu programu i zadeklarować zmienną o nazwie x-

1008
01:10:17,000 --> 01:10:27,000
Zamierzam wyciągnąć kolejne pole na dole, a to będzie RAM również.

1009
01:10:27,000 --> 01:10:29,000
I zamierzam szukać.

1010
01:10:29,000 --> 01:10:34,000
Będziemy rysować postrzępione linie, aby wskazać to tylko niewielka część pamięci RAM

1011
01:10:34,000 --> 01:10:38,000
i nie wszyscy o tym jak wyciągnąć na szczycie.

1012
01:10:38,000 --> 01:10:43,000
>> Jeśli oświadczam zmienną całkowitą o nazwie x,

1013
01:10:43,000 --> 01:10:49,000
następnie co rzeczywiście się jest odwzorowaniem

1014
01:10:49,000 --> 01:10:54,000
, które są przechowywane w tablicy symboli mojego programu

1015
01:10:54,000 --> 01:11:00,000
który łączy X Nazwa tego regionu pamięci Narysowaliśmy

1016
01:11:00,000 --> 01:11:03,000
tu między pionowymi kreskami.

1017
01:11:03,000 --> 01:11:08,000
Jeśli mam linii kodu w moim programie, który mówi x = 7

1018
01:11:08,000 --> 01:11:15,000
procesor wie, "Och, dobrze, wiem, że żyje x w tym miejscu w pamięci."

1019
01:11:15,000 --> 01:11:25,000
"Mam zamiar iść do przodu i napisać 7 tam."

1020
01:11:25,000 --> 01:11:28,000
Jak to jest wiedzieć, co to jest miejsce w pamięci?

1021
01:11:28,000 --> 01:11:30,000
Cóż, to wszystko zrobić w czasie kompilacji.

1022
01:11:30,000 --> 01:11:34,000
Kompilator dba o przydzielenie gdzie każda ze zmiennych zamiar iść

1023
01:11:34,000 --> 01:11:40,000
i utworzenie specjalnego mapowanie a raczej łączenie kropek

1024
01:11:40,000 --> 01:11:43,000
między symbolem i dokąd zmierza, zmienna nazwisko

1025
01:11:43,000 --> 01:11:46,000
i gdzie to się żyje w pamięci.

1026
01:11:46,000 --> 01:11:50,000
Ale okazuje się, że rzeczywiście możemy uzyskać do niego dostęp w naszych programach, jak również.

1027
01:11:50,000 --> 01:11:55,000
To dostaje ważne, gdy zaczynamy mówić o niektórych struktur danych,

1028
01:11:55,000 --> 01:11:58,000
które jest pojęciem, które mamy zamiar wprowadzić później.

1029
01:11:58,000 --> 01:12:09,000
>> Ale teraz, co można wiedzieć, jest to, że można utworzyć wskaźnik do tej lokalizacji, x.

1030
01:12:09,000 --> 01:12:12,000
Na przykład, można utworzyć zmiennej wskaźnika.

1031
01:12:12,000 --> 01:12:16,000
Kiedy tworzymy zmienną wskaźnika używamy notacji gwiazdy.

1032
01:12:16,000 --> 01:12:21,000
W tym przypadku, to mówi, że zamierzam utworzyć wskaźnik do int.

1033
01:12:21,000 --> 01:12:24,000
To typ, tak jak każdy inny.

1034
01:12:24,000 --> 01:12:27,000
Dajemy mu zmienną jak y,

1035
01:12:27,000 --> 01:12:32,000
a potem ustawić go równa adresu do adresu.

1036
01:12:32,000 --> 01:12:38,000
W tym przypadku, możemy ustawić y zwrócić do x

1037
01:12:38,000 --> 01:12:43,000
poprzez adres X, co robimy z tym ampersand,

1038
01:12:43,000 --> 01:12:55,000
a następnie ruszyliśmy do punktu y do niego.

1039
01:12:55,000 --> 01:12:59,000
Co to w zasadzie nie jest, jeśli przyjrzymy się naszej pamięci

1040
01:12:59,000 --> 01:13:02,000
to tworzy oddzielną zmienną.

1041
01:13:02,000 --> 01:13:04,000
To się nazywają to y,

1042
01:13:04,000 --> 01:13:06,000
a kiedy ta linia kodu wykonuje

1043
01:13:06,000 --> 01:13:13,000
to faktycznie zamierza stworzyć mały wskaźnik które zazwyczaj wyciągnąć jak strzała,

1044
01:13:13,000 --> 01:13:15,000
i ustawia y wskazać x.

1045
01:13:15,000 --> 01:13:17,000
Tak.

1046
01:13:17,000 --> 01:13:19,000
[Student] Jeśli x jest już wskaźnik, możesz sobie zrobić

1047
01:13:19,000 --> 01:13:22,000
int * y = x, zamiast do znaku handlowego?

1048
01:13:22,000 --> 01:13:24,000
Tak.

1049
01:13:24,000 --> 01:13:27,000
Jeśli x jest już wskaźnik, to można ustawić 2 wskaźniki równe do siebie,

1050
01:13:27,000 --> 01:13:30,000
w tym przypadku y nie wskazuje na x,

1051
01:13:30,000 --> 01:13:34,000
ale to wskazywać na cokolwiek x wskazuje na.

1052
01:13:34,000 --> 01:13:37,000
Niestety, mamy czas.

1053
01:13:37,000 --> 01:13:44,000
>> Co chciałbym powiedzieć w tym momencie, możemy mówić o tym w trybie offline,

1054
01:13:44,000 --> 01:13:49,000
ale chciałbym powiedzieć, zacząć działać poprzez ten problem, nr 14.

1055
01:13:49,000 --> 01:13:53,000
Można tam zobaczyć już trochę wypełnić dla ciebie.

1056
01:13:53,000 --> 01:13:57,000
Można zobaczyć, że gdy ogłosimy 2 wskaźniki, int * x i y *,

1057
01:13:57,000 --> 01:14:01,000
i pamiętać, że wskazując * obok zmiennej było coś, co zostało zrobione w zeszłym roku.

1058
01:14:01,000 --> 01:14:05,000
Okazuje się, że to jest podobne do tego, co robimy w tym roku.

1059
01:14:05,000 --> 01:14:11,000
To nie ma znaczenia, gdzie piszesz * kiedy deklarując wskaźnik.

1060
01:14:11,000 --> 01:14:17,000
Ale mamy napisane * obok typu

1061
01:14:17,000 --> 01:14:24,000
bo to bardzo jasno, że jesteś deklarowania zmiennej wskaźnika.

1062
01:14:24,000 --> 01:14:27,000
Można zobaczyć, że deklarowania 2 wskaźników daje nam 2 pola.

1063
01:14:27,000 --> 01:14:31,000
Tu, kiedy zbiór X równą malloc

1064
01:14:31,000 --> 01:14:34,000
co to mówi, jest uchylenie pamięci w stercie.

1065
01:14:34,000 --> 01:14:41,000
To małe pudełko tu, to koło, znajduje się na stercie.

1066
01:14:41,000 --> 01:14:43,000
X jest z nią.

1067
01:14:43,000 --> 01:14:46,000
Należy pamiętać, że y nie jest jeszcze wskazanie do niczego.

1068
01:14:46,000 --> 01:14:50,000
Aby uzyskać pamięci, aby zapisać numer 42 w x

1069
01:14:50,000 --> 01:14:55,000
będziemy używać notacji, co?

1070
01:14:55,000 --> 01:14:59,000
[Student] * x = 42.

1071
01:14:59,000 --> 01:15:01,000
Dokładnie, * x = 42.

1072
01:15:01,000 --> 01:15:06,000
To oznacza, śledzić strzałkę i rzucić 42 tam.

1073
01:15:06,000 --> 01:15:09,000
Tu, gdzie możemy ustawić Y i X mamy y wskazując na x.

1074
01:15:09,000 --> 01:15:13,000
Ponownie, to jest właśnie to, co powiedział Kevin, gdzie możemy ustawić y równa x.

1075
01:15:13,000 --> 01:15:15,000
Y nie wskazuje X.

1076
01:15:15,000 --> 01:15:19,000
Raczej jest to, co wskazuje na to wskazuje na x oraz.

1077
01:15:19,000 --> 01:15:24,000
>> I wreszcie w ostatnim polu są 2 możliwe rzeczy, które mogliśmy zrobić.

1078
01:15:24,000 --> 01:15:28,000
Jeden to moglibyśmy powiedzieć * x = 13.

1079
01:15:28,000 --> 01:15:33,000
Inna rzecz, można powiedzieć,-Alex, czy wiesz, co możemy zrobić tutaj?

1080
01:15:33,000 --> 01:15:37,000
Można powiedzieć, * x = 13 or-

1081
01:15:37,000 --> 01:15:41,000
[Student] Można powiedzieć, int cokolwiek.

1082
01:15:41,000 --> 01:15:45,000
[Nate H.] Jeżeli zostały określone jako int Zmienna mogliśmy zrobić.

1083
01:15:45,000 --> 01:15:49,000
Możemy też powiedzieć, * y = 13, ponieważ są one zarówno wskazując tym samym miejscu,

1084
01:15:49,000 --> 01:15:51,000
więc możemy użyć zmiennej się tam dostać.

1085
01:15:51,000 --> 01:15:56,000
Tak. >> [Student] Co to będzie wyglądać, jeśli tylko powiedzieć, int x jest 13?

1086
01:15:56,000 --> 01:16:00,000
To byłoby zadeklarowanie nowej zmiennej o nazwie x, co nie działa.

1087
01:16:00,000 --> 01:16:04,000
Musielibyśmy kolizji ponieważ zadeklarowane x jest wskaźnikiem tutaj.

1088
01:16:04,000 --> 01:16:10,000
[Student] Jeśli po prostu musieliśmy to stwierdzenie samo w sobie, co to będzie wyglądać pod względem okręgu?

1089
01:16:10,000 --> 01:16:14,000
Jeśli mielibyśmy x = 13 to będziemy mieć pole, a zamiast strzałki

1090
01:16:14,000 --> 01:16:16,000
coming out of the box chcemy wyciągnąć go tylko jako 13.

1091
01:16:16,000 --> 01:16:19,000
[Student] W polu. Okay.

1092
01:16:19,000 --> 01:16:24,000
>> Dziękuję za oglądanie, i powodzenia na Quiz 0.

1093
01:16:24,000 --> 01:16:28,000
[CS50.TV]