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

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

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

4
00:00:08,000 --> 00:00:10,000
>> Hej, wszyscy.

5
00:00:10,000 --> 00:00:15,000
Witamy w sesji przeglądu dla Quiz 0, co ma miejsce w środę.

6
00:00:15,000 --> 00:00:19,000
Co będziemy robić dziś w nocy, jestem z 3 innych TFS

7
00:00:19,000 --> 00:00:24,000
i razem będziemy przechodzić przegląd co zrobiliśmy w trakcie tej pory.

8
00:00:24,000 --> 00:00:27,000
To nie będzie 100% niepełna, ale powinno dać lepszy pomysł

9
00:00:27,000 --> 00:00:31,000
z tego, co już masz w dół, a co trzeba jeszcze studia przed środą.

10
00:00:31,000 --> 00:00:34,000
I czuć się swobodnie podnieść rękę z pytaniami, jak będziemy razem,

11
00:00:34,000 --> 00:00:38,000
ale należy pamiętać, że będziemy mieć trochę czasu na koniec

12
00:00:38,000 --> 00:00:41,000
jeśli mamy dotrzeć z kilku minut do zapasowe uwagi na ogólne pytania,

13
00:00:41,000 --> 00:00:47,000
więc miej to na uwadze, i tak mamy zamiar rozpocząć na początku z tygodnia 0.

14
00:00:47,000 --> 00:00:50,000
>> [Quiz 0 recenzję!] [Część 0] [Lexi Ross] Ale zanim to zrobimy Porozmawiajmy o

15
00:00:50,000 --> 00:00:53,000
logistyka w quizie.

16
00:00:53,000 --> 00:00:55,000
>> [Logistics] [Quiz odbędzie się w środę 10/10 w miejsce wykładu]

17
00:00:55,000 --> 00:00:57,000
>> [(Zobacz http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf szczegóły)] Jest to w środę, 10 października.

18
00:00:57,000 --> 00:01:00,000
>> To w środę, a jeśli się do tego adresu URL tutaj

19
00:01:00,000 --> 00:01:03,000
który jest również dostępny z CS50.net-tam jest link do niego-

20
00:01:03,000 --> 00:01:06,000
możesz zobaczyć informacje o tym, gdzie się udać na podstawie

21
00:01:06,000 --> 00:01:10,000
Twoje nazwisko lub powiązanie szkoły, jak również

22
00:01:10,000 --> 00:01:14,000
opowiada o co dokładnie quiz będzie obejmował i rodzaje pytań, które masz zamiar uzyskać.

23
00:01:14,000 --> 00:01:19,000
Pamiętaj, że będziesz mieć możliwość przejrzenia na quizie w przekroju,

24
00:01:19,000 --> 00:01:21,000
więc twoje TF należy przekraczania pewnych problemów praktyki,

25
00:01:21,000 --> 00:01:29,000
i to jest kolejna dobra okazja, aby zobaczyć, gdzie trzeba jeszcze uczyć się na quiz.

26
00:01:29,000 --> 00:01:32,000
Zacznijmy od początku z Bytes 'N' bitów.

27
00:01:32,000 --> 00:01:35,000
Zapamiętaj nieco tylko 0 lub 1,

28
00:01:35,000 --> 00:01:38,000
a bajt to zbiór 8 tych bitów.

29
00:01:38,000 --> 00:01:42,000
Przyjrzyjmy się tej kolekcji bitów tutaj.

30
00:01:42,000 --> 00:01:44,000
Powinniśmy być w stanie dowiedzieć się, ile bitów są.

31
00:01:44,000 --> 00:01:48,000
Gdzie możemy liczyć tam tylko 8 z nich, osiem 0 lub 1 jednostki.

32
00:01:48,000 --> 00:01:51,000
A ponieważ nie ma 8 bitów, to 1 bajt,

33
00:01:51,000 --> 00:01:53,000
i niech ją przekonwertować na system szesnastkowy.

34
00:01:53,000 --> 00:01:58,000
Szesnastkowy jest baza 16, i jest to dość łatwe do konwersji

35
00:01:58,000 --> 00:02:01,000
liczba w systemie binarnym, czyli co to jest do liczby w systemie szesnastkowym.

36
00:02:01,000 --> 00:02:04,000
Wszystko co robimy jest spojrzeć na grupy 4,

37
00:02:04,000 --> 00:02:07,000
i konwertować je do odpowiedniej cyfry szesnastkowe.

38
00:02:07,000 --> 00:02:11,000
Zaczynamy od prawej przeważającej grupy 4, więc 0011.

39
00:02:11,000 --> 00:02:16,000
To będzie jeden 1 i jeden 2, tak, że umożliwia 3 razem.

40
00:02:16,000 --> 00:02:19,000
A potem spójrzmy na drugim bloku 4.

41
00:02:19,000 --> 00:02:24,000
1101. To będzie jeden 1, jeden 4 i jeden 8.

42
00:02:24,000 --> 00:02:28,000
Razem, że to będzie 13, co sprawia, D.

43
00:02:28,000 --> 00:02:32,000
I będziemy pamiętać, że w systemie szesnastkowym nie pójść 0 do 9.

44
00:02:32,000 --> 00:02:36,000
Idziemy 0 do F, więc po 9, 10 odpowiada,

45
00:02:36,000 --> 00:02:40,000
11 do B, i tak dalej, gdzie F jest 15.

46
00:02:40,000 --> 00:02:44,000
O D 13 jest,

47
00:02:44,000 --> 00:02:49,000
tak, aby przekonwertować go na dziesiętne wszystko możemy zrobić, to tak naprawdę

48
00:02:49,000 --> 00:02:52,000
traktować każdą pozycję potęgi 2.

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

50
00:02:58,000 --> 00:03:03,000
i jest to trochę trudne do obliczenia w głowie, ale jeśli idziemy do następnego slajdu

51
00:03:03,000 --> 00:03:05,000
możemy zobaczyć odpowiedź.

52
00:03:05,000 --> 00:03:09,000
>> Zasadniczo będziemy naprzeciwko powrotem do lewej,

53
00:03:09,000 --> 00:03:14,000
i jesteśmy pomnożenie każdej cyfry przez odpowiednie potęgi 2.

54
00:03:14,000 --> 00:03:19,000
I pamiętaj, na szesnastkową oznaczymy te numery z 0x na początku

55
00:03:19,000 --> 00:03:23,000
więc nie mylić z liczbą dziesiętną.

56
00:03:23,000 --> 00:03:29,000
Kontynuując, to Tabela ASCII,

57
00:03:29,000 --> 00:03:35,000
i czego używamy ASCII jest mapowanie z znaków do wartości liczbowych.

58
00:03:35,000 --> 00:03:39,000
Zapamiętaj w Pset kryptograficznej podjęliśmy szerokie wykorzystanie tablicy ASCII

59
00:03:39,000 --> 00:03:43,000
Aby korzystać z różnych metod kryptografii

60
00:03:43,000 --> 00:03:47,000
Cezar i szyfr Vigenère przekonwertować różne litery

61
00:03:47,000 --> 00:03:52,000
w ciągu według klucza przez danego użytkownika.

62
00:03:52,000 --> 00:03:56,000
Przyjrzyjmy się trochę ASCII matematyki.

63
00:03:56,000 --> 00:04:02,000
Patrząc na "P" + 1, w postaci znaków, które byłyby Q

64
00:04:02,000 --> 00:04:07,000
i pamiętaj, że '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
I jak dokładnie chcemy konwertować pomiędzy tymi 2 formach?

66
00:04:10,000 --> 00:04:13,000
To nie jest naprawdę trudne.

67
00:04:13,000 --> 00:04:16,000
W celu uzyskania 5 odejmiemy '0 '

68
00:04:16,000 --> 00:04:20,000
ponieważ jest 5 miejsc pomiędzy '0 ', a '5.'

69
00:04:20,000 --> 00:04:23,000
Aby przejść na inny sposób po prostu dodać 0,

70
00:04:23,000 --> 00:04:25,000
, więc jest to coś w rodzaju regularnej arytmetyki.

71
00:04:25,000 --> 00:04:29,000
Pamiętaj tylko, że jeśli coś ma cudzysłowy wokół niego to znak

72
00:04:29,000 --> 00:04:37,000
i co odpowiada wartości w tabeli ASCII.

73
00:04:37,000 --> 00:04:40,000
Przeprowadzka do bardziej ogólnych zagadnień informatyki.

74
00:04:40,000 --> 00:04:43,000
Dowiedzieliśmy się, co algorytm jest i jak go używać programowania

75
00:04:43,000 --> 00:04:45,000
do realizacji algorytmów.

76
00:04:45,000 --> 00:04:48,000
Niektóre przykłady algorytmów są czymś naprawdę proste jak

77
00:04:48,000 --> 00:04:51,000
sprawdzenie, czy liczba jest parzysta czy nieparzysta.

78
00:04:51,000 --> 00:04:54,000
Za to pamiętam, że mod liczbę przez 2 i sprawdź, czy wynik jest 0.

79
00:04:54,000 --> 00:04:57,000
Jeśli tak, to nawet. Jeśli nie, to dziwne.

80
00:04:57,000 --> 00:04:59,000
I to jest przykład algorytm naprawdę podstawowe.

81
00:04:59,000 --> 00:05:02,000
>> Trochę bardziej zaangażowany jeden jest binary search,

82
00:05:02,000 --> 00:05:05,000
które będziemy później przejść w sesji przeglądarki.

83
00:05:05,000 --> 00:05:09,000
I programowanie jest termin, którego używamy do wykonywania algorytmu

84
00:05:09,000 --> 00:05:15,000
i konwertowanie jej do kodu, komputer może odczytać.

85
00:05:15,000 --> 00:05:20,000
2 przykłady programowania jest Scratch,

86
00:05:20,000 --> 00:05:22,000
czyli to, co zrobiliśmy w tygodniu 0.

87
00:05:22,000 --> 00:05:25,000
Mimo tego, że w rzeczywistości nie wpisać się kod to sposób realizacji

88
00:05:25,000 --> 00:05:29,000
ten algorytm, który drukuje numery 1-10,

89
00:05:29,000 --> 00:05:32,000
i tu to samo w języku programowania C.

90
00:05:32,000 --> 00:05:41,000
Są to funkcjonalny odpowiednik, tylko napisane w różnych językach lub składni.

91
00:05:41,000 --> 00:05:44,000
Potem dowiedziałem się o wyrażeniach logicznych,

92
00:05:44,000 --> 00:05:48,000
i logiczna jest wartość, która jest albo prawdziwe, albo fałszywe,

93
00:05:48,000 --> 00:05:51,000
i tutaj często wyrażeń logicznych

94
00:05:51,000 --> 00:05:55,000
wejdź na warunkach, więc jeśli (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
dobrze, już ustawione x = 5, więc, że warunek ten będzie ocenić wartość true.

96
00:06:00,000 --> 00:06:03,000
A jeśli to prawda, co kod jest pod warunkiem

97
00:06:03,000 --> 00:06:08,000
zostanie ocenione przez komputer, tak że łańcuch ma być wydrukowany

98
00:06:08,000 --> 00:06:12,000
do standardowego wyjścia, a warunek określony

99
00:06:12,000 --> 00:06:16,000
odnosi się do tego, co jest wewnątrz nawiasów w if.

100
00:06:16,000 --> 00:06:20,000
Pamiętam wszystkich operatorów.

101
00:06:20,000 --> 00:06:26,000
Pamiętaj, że to && i | |, kiedy staramy się połączyć 2 lub więcej warunków,

102
00:06:26,000 --> 00:06:30,000
== Nie = do sprawdzenia, czy 2 rzeczy są równe.

103
00:06:30,000 --> 00:06:36,000
Pamiętaj, że = jest do przypisania natomiast == jest boolean operator.

104
00:06:36,000 --> 00:06:41,000
≤, ≥, a następnie ostateczna 2 są oczywiste.

105
00:06:41,000 --> 00:06:45,000
Ogólny przegląd boolean logiki tutaj.

106
00:06:45,000 --> 00:06:48,000
I wyrażeń logicznych są również ważne w pętli,

107
00:06:48,000 --> 00:06:50,000
którym pojedziemy już koniec.

108
00:06:50,000 --> 00:06:56,000
Dowiedzieliśmy się o 3 rodzaje pętli dotąd w CS50, for, while i do while.

109
00:06:56,000 --> 00:06:59,000
I ważne jest aby wiedzieć, że, podczas gdy w większości zastosowań

110
00:06:59,000 --> 00:07:02,000
rzeczywiście możemy używać żadnych pętli ogólnie

111
00:07:02,000 --> 00:07:06,000
pewne rodzaje celów lub wspólnych wzorów

112
00:07:06,000 --> 00:07:09,000
w programowaniu, które specyficznie zadzwonić na jeden z tych pętli

113
00:07:09,000 --> 00:07:13,000
które sprawiają, że najbardziej wydajne i eleganckie do kodu to w ten sposób.

114
00:07:13,000 --> 00:07:18,000
Chodźmy czym każdy z tych obwodów bywa najczęściej stosuje.

115
00:07:18,000 --> 00:07:21,000
>> W pętli for na ogół już wiedzą, ile razy chcemy iteracyjne.

116
00:07:21,000 --> 00:07:24,000
To, co wkładamy w stanie.

117
00:07:24,000 --> 00:07:28,000
W, i = 0, i <10, na przykład.

118
00:07:28,000 --> 00:07:31,000
Wiemy już, że chcemy zrobić coś 10 razy.

119
00:07:31,000 --> 00:07:34,000
Teraz, w pętli, na ogół nie koniecznie

120
00:07:34,000 --> 00:07:36,000
wiem, ile razy chcemy pętli uruchomić.

121
00:07:36,000 --> 00:07:39,000
Ale wiemy jakieś warunkiem, że chcemy, aby

122
00:07:39,000 --> 00:07:41,000
zawsze prawdziwe lub zawsze false.

123
00:07:41,000 --> 00:07:44,000
Na przykład, gdy jest ustawiony.

124
00:07:44,000 --> 00:07:46,000
Powiedzmy, że jest logiczna zmienna.

125
00:07:46,000 --> 00:07:48,000
Choć to prawda, że ​​chcemy kod do oceny,

126
00:07:48,000 --> 00:07:52,000
więc trochę bardziej rozszerzalny, nieco bardziej ogólne niż do pętli,

127
00:07:52,000 --> 00:07:55,000
ale każdy dla pętli można także przekształcić do pętli.

128
00:07:55,000 --> 00:08:00,000
Wreszcie, czy pętle while, które mogą wydawać się trudne do zrozumienia od razu,

129
00:08:00,000 --> 00:08:04,000
są często, gdy chcemy oceny kod najpierw

130
00:08:04,000 --> 00:08:06,000
przed pierwszym momencie możemy sprawdzić stan.

131
00:08:06,000 --> 00:08:09,000
Typowym przykładem użycia zrobić, gdy pętla

132
00:08:09,000 --> 00:08:12,000
jest wtedy, gdy chcesz uzyskać dane wprowadzone przez użytkownika, i wiesz, że chcesz zwrócić się do użytkownika

133
00:08:12,000 --> 00:08:15,000
do wprowadzania co najmniej raz, ale jeśli nie daje dobre wejście od zaraz

134
00:08:15,000 --> 00:08:18,000
chcesz zachować prośbą do dają dobre wejście.

135
00:08:18,000 --> 00:08:21,000
To najczęściej używane są podczas pętli,

136
00:08:21,000 --> 00:08:23,000
i spójrzmy na rzeczywistej strukturze tych pętli.

137
00:08:23,000 --> 00:08:27,000
Zazwyczaj zawsze mają tendencję do tych wzorów.

138
00:08:27,000 --> 00:08:30,000
>> W pętli for wewnątrz masz 3 elementy:

139
00:08:30,000 --> 00:08:35,000
inicjalizacji, zazwyczaj coś jak int i = 0 gdzie i jest licznik,

140
00:08:35,000 --> 00:08:40,000
stan, w którym chcemy powiedzieć uruchomić to dla pętli tak długo jak ten warunek nadal posiada,

141
00:08:40,000 --> 00:08:44,000
jak i <10, a następnie w końcu aktualizacji, który jest, jak zwiększamy

142
00:08:44,000 --> 00:08:47,000
Licznik zmiennej w każdym punkcie w pętli.

143
00:08:47,000 --> 00:08:50,000
Wspólna rzecz, aby zobaczyć jest tylko i + +,

144
00:08:50,000 --> 00:08:52,000
co oznacza, że ​​inkrementacja i przez 1 za każdym razem.

145
00:08:52,000 --> 00:08:55,000
Można też zrobić coś tak jak ja + = 2,

146
00:08:55,000 --> 00:08:58,000
co oznacza, dodać 2 do i za każdym razem przejść przez pętlę.

147
00:08:58,000 --> 00:09:03,000
, A następnie do tego tylko odnosi się do kodu, który faktycznie działa jako część pętli.

148
00:09:03,000 --> 00:09:09,000
A dla pętli while, tym razem faktycznie mają inicjalizacji poza pętli

149
00:09:09,000 --> 00:09:12,000
tak na przykład, powiedzmy, że chcemy zrobić ten sam typ pętli jak już opisany.

150
00:09:12,000 --> 00:09:16,000
Chcemy powiedzieć int i = 0 zanim pętla zaczyna.

151
00:09:16,000 --> 00:09:20,000
Wtedy możemy powiedzieć, gdy i <10 to zrobić,

152
00:09:20,000 --> 00:09:22,000
tak samo, jak blok kodu wcześniej

153
00:09:22,000 --> 00:09:26,000
i tym razem część aktualizacja kodu, na przykład, i + +

154
00:09:26,000 --> 00:09:29,000
faktycznie idzie wewnątrz pętli.

155
00:09:29,000 --> 00:09:33,000
I wreszcie, na zrobić, gdy, jest podobna do pętli while,

156
00:09:33,000 --> 00:09:36,000
ale trzeba pamiętać, że kod będzie oceniać raz

157
00:09:36,000 --> 00:09:40,000
przed warunek jest sprawdzany, więc jest o wiele więcej sensu

158
00:09:40,000 --> 00:09:44,000
jeśli spojrzeć na to w porządku góry do dołu.

159
00:09:44,000 --> 00:09:49,000
W pętli while zrobić kod ocenia zanim jeszcze spojrzeć na stanie, gdy,

160
00:09:49,000 --> 00:09:55,000
natomiast pętli while, sprawdza najpierw.

161
00:09:55,000 --> 00:09:59,000
Oświadczenia i zmiennych.

162
00:09:59,000 --> 00:10:04,000
Gdy chcemy utworzyć nową zmienną najpierw chcą go zainicjować.

163
00:10:04,000 --> 00:10:07,000
>> Na przykład, int bar inicjalizuje zmienną bar,

164
00:10:07,000 --> 00:10:10,000
ale to nie daje mu wartość, więc co to jest wartość baru teraz?

165
00:10:10,000 --> 00:10:12,000
Nie wiemy.

166
00:10:12,000 --> 00:10:14,000
To może być jakaś wartość śmieci, które zostało wcześniej zapisane w pamięci tam,

167
00:10:14,000 --> 00:10:16,000
a my nie chcemy używać tej zmiennej

168
00:10:16,000 --> 00:10:19,000
aż rzeczywiście dać mu wartość,

169
00:10:19,000 --> 00:10:21,000
więc uznać je tutaj.

170
00:10:21,000 --> 00:10:24,000
Następnie zainicjować za 42 poniżej.

171
00:10:24,000 --> 00:10:28,000
Teraz, oczywiście, wiemy, można to zrobić w jednej linii, int = 42 bar.

172
00:10:28,000 --> 00:10:30,000
Ale tak się wyczyścić wielu kroków, które są dzieje,

173
00:10:30,000 --> 00:10:34,000
deklaracja i inicjalizacja dzieje się tutaj oddzielnie.

174
00:10:34,000 --> 00:10:38,000
To dzieje się na jednym etapie, a kolejny, int baz = bar + 1,

175
00:10:38,000 --> 00:10:44,000
Stwierdzenie to poniżej, baz przyrosty, więc na końcu tego bloku kodu

176
00:10:44,000 --> 00:10:48,000
gdybyśmy wydrukować wartość baz byłoby 44

177
00:10:48,000 --> 00:10:52,000
bo zadeklarować i zainicjować go za 1> bar,

178
00:10:52,000 --> 00:10:58,000
a potem zwiększamy ją jeszcze raz z + +.

179
00:10:58,000 --> 00:11:02,000
Udaliśmy się nad tym dość krótko, ale dobrze jest mieć ogólne

180
00:11:02,000 --> 00:11:04,000
zrozumienie co wątki i zdarzenia.

181
00:11:04,000 --> 00:11:06,000
Zajmujemy się głównie to zrobił w Scratch,

182
00:11:06,000 --> 00:11:09,000
więc można myśleć gwintów wielu sekwencji kodu

183
00:11:09,000 --> 00:11:11,000
działa się w tym samym czasie.

184
00:11:11,000 --> 00:11:14,000
W rzeczywistości, to prawdopodobnie nie działa w tym samym czasie,

185
00:11:14,000 --> 00:11:17,000
ale rodzaju abstrakcyjnie możemy myśleć o tym w ten sposób.

186
00:11:17,000 --> 00:11:20,000
>> W Scratch, na przykład, mieliśmy kilka ikonek.

187
00:11:20,000 --> 00:11:22,000
Może być inny kod wykonujący się w tym samym czasie.

188
00:11:22,000 --> 00:11:26,000
Można chodzić, a drugi mówi coś

189
00:11:26,000 --> 00:11:29,000
w innej części ekranu.

190
00:11:29,000 --> 00:11:34,000
Wydarzenia są kolejnym sposobem na oddzielenie logiki

191
00:11:34,000 --> 00:11:37,000
poszczególnych elementów kodu,

192
00:11:37,000 --> 00:11:40,000
i Scratch byliśmy w stanie symulować zdarzenia używając audycji,

193
00:11:40,000 --> 00:11:43,000
i to faktycznie po otrzymaniu, nie, gdy słyszę,

194
00:11:43,000 --> 00:11:47,000
ale zasadniczo jest to sposób przekazywania informacji

195
00:11:47,000 --> 00:11:49,000
z jednego do drugiego ikonki.

196
00:11:49,000 --> 00:11:52,000
Na przykład, może chcesz przekazać Game Over

197
00:11:52,000 --> 00:11:56,000
i kiedy otrzyma kolejny sprite gra skończy,

198
00:11:56,000 --> 00:11:58,000
reaguje w pewien sposób.

199
00:11:58,000 --> 00:12:03,000
Jest to ważne do zrozumienia modelem dla programowania.

200
00:12:03,000 --> 00:12:07,000
Wystarczy przejść przez podstawowego tygodniu 0, co udało nam się do tej pory już ponad,

201
00:12:07,000 --> 00:12:10,000
Przyjrzyjmy się tym prostym programie C.

202
00:12:10,000 --> 00:12:14,000
Tekst może być trochę mały stąd, ale pójdę nad nim naprawdę szybko.

203
00:12:14,000 --> 00:12:20,000
Jesteśmy w tym 2 nagłówków plików na górze, cs50.h i stdio.h.

204
00:12:20,000 --> 00:12:23,000
Mamy następnie zdefiniowania stałej o nazwie limit wynosi 100.

205
00:12:23,000 --> 00:12:26,000
Mamy następnie realizując naszą główną funkcję.

206
00:12:26,000 --> 00:12:29,000
Ponieważ nie używamy argumentów wiersza poleceń tutaj musimy położyć pustkę

207
00:12:29,000 --> 00:12:32,000
jako argumenty dla main.

208
00:12:32,000 --> 00:12:38,000
Widzimy powyżej int main. To typ zwracany, 0 w tym samym powrócić do dołu.

209
00:12:38,000 --> 00:12:41,000
I używamy CS50 biblioteki funkcji dostać int

210
00:12:41,000 --> 00:12:45,000
poprosić użytkownika o wprowadzenie, i zapisać go w tej zmiennej x,

211
00:12:45,000 --> 00:12:51,000
więc oświadczam x powyżej, a my go zainicjować z x = getInt.

212
00:12:51,000 --> 00:12:53,000
>> Następnie należy sprawdzić, czy użytkownik dał nam dobre wejście.

213
00:12:53,000 --> 00:12:59,000
Jeśli jest to LIMIT ≥ chcemy zwrócić kod błędu 1 i wydrukować komunikat o błędzie.

214
00:12:59,000 --> 00:13:02,000
I wreszcie, jeśli użytkownik dał nam dobre wejście

215
00:13:02,000 --> 00:13:08,000
idziemy do kwadratu liczby i wydrukować tego rezultatu.

216
00:13:08,000 --> 00:13:11,000
Wystarczy upewnić się, że te wszystkie hit home

217
00:13:11,000 --> 00:13:17,000
widać etykiety różnych części kodu tutaj.

218
00:13:17,000 --> 00:13:19,000
Wspomniałem stałe, nagłówków plików.

219
00:13:19,000 --> 00:13:21,000
Oh, int x. Należy zapamiętać, że to zmienna lokalna.

220
00:13:21,000 --> 00:13:24,000
To kontrastuje go od zmiennej globalnej, które będziemy rozmawiać o

221
00:13:24,000 --> 00:13:27,000
Nieco później w sesji przeglądarki,

222
00:13:27,000 --> 00:13:30,000
i mamy wywołanie funkcji biblioteki printf,

223
00:13:30,000 --> 00:13:34,000
więc jeśli nie są wliczone w pliku nagłówkowego stdio.h

224
00:13:34,000 --> 00:13:37,000
nie bylibyśmy w stanie wywołać printf.

225
00:13:37,000 --> 00:13:42,000
I wierzę, że strzałka dostałem uciąć tu wskazując na% d,

226
00:13:42,000 --> 00:13:45,000
która jest łańcuchem formatowanie printf.

227
00:13:45,000 --> 00:13:52,000
Mówi wydrukować tej zmiennej jako liczby,% d.

228
00:13:52,000 --> 00:13:58,000
I że jest to dla Tygodnia 0.

229
00:13:58,000 --> 00:14:06,000
Teraz Lucas będzie nadal.

230
00:14:06,000 --> 00:14:08,000
Hej, chłopaki. Nazywam się Lucas.

231
00:14:08,000 --> 00:14:10,000
Jestem studentem drugiego roku w najlepszym domu na terenie kampusu, Mather,

232
00:14:10,000 --> 00:14:14,000
i mam zamiar porozmawiać trochę o tydzień 1 i 2,1.

233
00:14:14,000 --> 00:14:16,000
[Tydzień 1 i 2,1!] [Lucas Freitas]

234
00:14:16,000 --> 00:14:19,000
Jako Lexi mówił, kiedy zaczęliśmy tłumaczyć kodu od podstaw w C

235
00:14:19,000 --> 00:14:23,000
jedną z rzeczy, które zauważyłem jest to, że można nie tylko

236
00:14:23,000 --> 00:14:26,000
napisać kod i uruchomić go za pomocą zieloną flagę już.

237
00:14:26,000 --> 00:14:30,000
Faktycznie, trzeba użyć pewnych kroków, aby dokonać program C

238
00:14:30,000 --> 00:14:33,000
się plik wykonywalny.

239
00:14:33,000 --> 00:14:36,000
Zasadniczo to, co robisz, gdy jesteś pisania programu jest to, że

240
00:14:36,000 --> 00:14:40,000
można przetłumaczyć swój pomysł na język kompilator może zrozumieć,

241
00:14:40,000 --> 00:14:44,000
więc kiedy piszesz program w C

242
00:14:44,000 --> 00:14:47,000
co robisz jest rzeczywiście coś pisze, że kompilator będzie zrozumieć,

243
00:14:47,000 --> 00:14:50,000
a następnie kompilator będzie tłumaczyć, że kod

244
00:14:50,000 --> 00:14:53,000
w coś, że komputer będzie zrozumieć.

245
00:14:53,000 --> 00:14:55,000
>> I rzeczą jest, komputer jest rzeczywiście bardzo głupie.

246
00:14:55,000 --> 00:14:57,000
Twój komputer może zrozumieć tylko 0s i 1s,

247
00:14:57,000 --> 00:15:01,000
tak naprawdę w pierwszych komputerach ludzie zazwyczaj zaprogramowane

248
00:15:01,000 --> 00:15:04,000
używając 0s i 1s, ale już nie, dzięki Bogu.

249
00:15:04,000 --> 00:15:07,000
Nie mamy zapamiętać sekwencje 0s i 1s

250
00:15:07,000 --> 00:15:10,000
w pętli do lub na pętli, i tak dalej.

251
00:15:10,000 --> 00:15:13,000
Dlatego mamy kompilator.

252
00:15:13,000 --> 00:15:17,000
Co kompilator robi to w zasadzie tłumaczy kod C,

253
00:15:17,000 --> 00:15:21,000
w naszym przypadku, do języka, że ​​komputer będzie zrozumieć,

254
00:15:21,000 --> 00:15:25,000
który jest przedmiotem kod i kompilator, że używamy

255
00:15:25,000 --> 00:15:30,000
nazywa dzyń, więc jest to rzeczywiście symbol brzękiem.

256
00:15:30,000 --> 00:15:33,000
Jeśli masz program, musisz zrobić 2 rzeczy.

257
00:15:33,000 --> 00:15:37,000
Po pierwsze, musisz skompilować program, a następnie masz zamiar uruchomić program.

258
00:15:37,000 --> 00:15:41,000
Aby skompilować program masz wiele możliwości, aby to zrobić.

259
00:15:41,000 --> 00:15:44,000
Pierwszy z nich to zrobić program.c dzyń

260
00:15:44,000 --> 00:15:47,000
, w którym program jest nazwa programu.

261
00:15:47,000 --> 00:15:51,000
W tym przypadku widać, są one po prostu mówiąc "Hej, skompilować mój program."

262
00:15:51,000 --> 00:15:56,000
Nie mówimy: "Chcę tę nazwę dla mojego programu" lub cokolwiek.

263
00:15:56,000 --> 00:15:58,000
>> Druga opcja daje nazwę programu.

264
00:15:58,000 --> 00:16:02,000
Można powiedzieć, dzyń-o, a następnie imię, które chcesz

265
00:16:02,000 --> 00:16:06,000
Plik wykonywalny być nazwany i program.c.

266
00:16:06,000 --> 00:16:11,000
I można to zrobić również zrobić program i zobaczyć, jak w ciągu pierwszych 2 przypadkach

267
00:16:11,000 --> 00:16:15,000
Włożyłem. C, oraz w trzeciej mam tylko programy?

268
00:16:15,000 --> 00:16:18,000
Tak, rzeczywiście nie należy umieszczać. C podczas korzystania zrobić.

269
00:16:18,000 --> 00:16:22,000
W przeciwnym wypadku kompilator faktycznie się krzyczeć na Ciebie.

270
00:16:22,000 --> 00:16:24,000
A także, że nie wiem, czy wy pamiętajcie,

271
00:16:24,000 --> 00:16:29,000
ale wiele razy korzystaliśmy również-lcs50 lub-lm.

272
00:16:29,000 --> 00:16:31,000
To się nazywa łączenie.

273
00:16:31,000 --> 00:16:35,000
To po prostu mówi kompilatorowi, że będzie korzystać z tych bibliotek tam,

274
00:16:35,000 --> 00:16:39,000
więc jeśli chcesz używać cs50.h rzeczywiście trzeba wpisać

275
00:16:39,000 --> 00:16:43,000
dzyń program.c-lcs50.

276
00:16:43,000 --> 00:16:45,000
Jeśli tego nie robią, to kompilator nie będzie wiedział

277
00:16:45,000 --> 00:16:50,000
że używasz tych funkcji w cs50.h.

278
00:16:50,000 --> 00:16:52,000
A kiedy chcesz uruchomić program masz 2 opcje.

279
00:16:52,000 --> 00:16:57,000
Jeśli tak program.c Clang nie daliście nazwę programu.

280
00:16:57,000 --> 00:17:01,000
Musisz uruchomić go za pomocą. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out jest standardowy nazwa dzyń daje program, jeśli nie dajesz mu nazwę.

282
00:17:06,000 --> 00:17:11,000
W przeciwnym razie będziemy robić. / Program, jeśli dał nazwę programu,

283
00:17:11,000 --> 00:17:15,000
a także, jeśli nam się zaprogramować nazwę, że program dostanie

284
00:17:15,000 --> 00:17:23,000
już będzie zaprogramować taką samą nazwę jak plik C.

285
00:17:23,000 --> 00:17:26,000
Potem rozmawialiśmy o typach danych i danych.

286
00:17:26,000 --> 00:17:31,000
>> Zasadniczo typy danych to samo jak małe pudełka, które wykorzystują

287
00:17:31,000 --> 00:17:35,000
do przechowywania wartości, więc typy danych są rzeczywiście jak stworki.

288
00:17:35,000 --> 00:17:39,000
Pochodzą one we wszystkich rozmiarach i rodzajach.

289
00:17:39,000 --> 00:17:43,000
Nie wiem, czy to analogia sens.

290
00:17:43,000 --> 00:17:46,000
Rozmiar dane rzeczywiście zależy od architektury maszyny.

291
00:17:46,000 --> 00:17:49,000
Wszystkie dane rozmiary, że zamierzam tu pokazać

292
00:17:49,000 --> 00:17:53,000
w rzeczywistości dla 32-bitowego, który jest w przypadku urządzenia, w naszym

293
00:17:53,000 --> 00:17:56,000
ale jeśli faktycznie kodowanie komputera Mac lub w Windows również

294
00:17:56,000 --> 00:17:59,000
Prawdopodobnie będziesz mieć 64-bitową maszynę,

295
00:17:59,000 --> 00:18:03,000
więc pamiętać, że rozmiary danych, które mam zamiar tu pokazać

296
00:18:03,000 --> 00:18:06,000
są na maszynie 32-bitowej.

297
00:18:06,000 --> 00:18:08,000
Pierwszy, który widzieliśmy, był int,

298
00:18:08,000 --> 00:18:10,000
co jest dość proste.

299
00:18:10,000 --> 00:18:13,000
Użyć int przechowywać liczbę całkowitą.

300
00:18:13,000 --> 00:18:16,000
Widzieliśmy również znak, char.

301
00:18:16,000 --> 00:18:20,000
Jeśli chcesz korzystać z list lub trochę symbol jesteś prawdopodobnie będzie używać char.

302
00:18:20,000 --> 00:18:26,000
Char ma 1 bajt, co oznacza 8 bitów, jak Lexi powiedział.

303
00:18:26,000 --> 00:18:31,000
Zasadniczo mamy ASCII tabeli, która ma 256

304
00:18:31,000 --> 00:18:34,000
możliwe kombinacje 0s i 1s,

305
00:18:34,000 --> 00:18:37,000
a następnie po wpisaniu char to będzie tłumaczyć

306
00:18:37,000 --> 00:18:44,000
znak, że wejścia wy numer, który masz w tabeli ASCII, jak Lexi powiedział.

307
00:18:44,000 --> 00:18:48,000
Mamy też pływak, którego używamy do przechowywania liczb dziesiętnych.

308
00:18:48,000 --> 00:18:53,000
Jeśli chcesz wybrać 3,14, na przykład, masz zamiar używać pacy

309
00:18:53,000 --> 00:18:55,000
lub podwójny, który ma więcej precyzji.

310
00:18:55,000 --> 00:18:57,000
Pływak ma 4 bajty.

311
00:18:57,000 --> 00:19:01,000
Double ma 8 bajtów, więc jedyną różnicą jest precyzja.

312
00:19:01,000 --> 00:19:04,000
Mamy również długi, że jest używany do liczb całkowitych,

313
00:19:04,000 --> 00:19:09,000
i można zobaczyć na komputerze 32-bitowym int i długo mieć ten sam rozmiar,

314
00:19:09,000 --> 00:19:13,000
tak naprawdę nie ma sensu używać długo w komputerze 32-bitowym.

315
00:19:13,000 --> 00:19:17,000
>> Ale jeśli używasz komputera Mac i 64-bit, faktycznie długo ma rozmiar 8,

316
00:19:17,000 --> 00:19:19,000
więc to naprawdę zależy od architektury.

317
00:19:19,000 --> 00:19:22,000
Dla maszyny 32-bitowej nie ma sensu używać długo naprawdę.

318
00:19:22,000 --> 00:19:25,000
A następnie długo długo, z drugiej strony, jest 8 bajtów,

319
00:19:25,000 --> 00:19:30,000
tak to jest bardzo dobry, jeśli chcesz mieć dłuższą całkowitą.

320
00:19:30,000 --> 00:19:34,000
I wreszcie, mamy ciąg, który jest faktycznie char *,

321
00:19:34,000 --> 00:19:37,000
który jest wskaźnikiem do char.

322
00:19:37,000 --> 00:19:40,000
To bardzo proste, aby myśleć, że wielkość znaków ma być jak

323
00:19:40,000 --> 00:19:42,000
liczba znaków, które tam masz,

324
00:19:42,000 --> 00:19:45,000
ale faktycznie sam char *

325
00:19:45,000 --> 00:19:49,000
ma wielkość wskaźnika do char, które jest 4 bajty.

326
00:19:49,000 --> 00:19:52,000
Rozmiar char * jest 4 bajty.

327
00:19:52,000 --> 00:19:56,000
To nie ma znaczenia, jeśli masz małe słowo lub list czy coś.

328
00:19:56,000 --> 00:19:58,000
To będzie 4 bajty.

329
00:19:58,000 --> 00:20:01,000
Dowiedzieliśmy się także trochę o castingu

330
00:20:01,000 --> 00:20:04,000
więc jak widać, jeśli, na przykład, program, który mówi

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

332
00:20:08,000 --> 00:20:12,000
Wiecie co to będzie drukować na ekranie?

333
00:20:12,000 --> 00:20:14,000
>> Ktoś? >> [Uczniowie] 2.

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

335
00:20:16,000 --> 00:20:20,000
Kiedy robisz 3/2 to dostanie 1,5,

336
00:20:20,000 --> 00:20:24,000
ale skoro używamy integer to będzie ignorować dziesiętną część,

337
00:20:24,000 --> 00:20:26,000
i będziesz mieć 1.

338
00:20:26,000 --> 00:20:29,000
Jeśli nie chcesz, aby tak się stało, co można zrobić, na przykład,

339
00:20:29,000 --> 00:20:33,000
jest stwierdzenie, float y = x.

340
00:20:33,000 --> 00:20:40,000
Wtedy x, które dawniej były 3 teraz będzie 3,000 w y.

341
00:20:40,000 --> 00:20:44,000
A następnie można wydrukować r / 2.

342
00:20:44,000 --> 00:20:50,000
Właściwie powinienem mieć 2. tam.

343
00:20:50,000 --> 00:20:55,000
To zrobi 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
i masz zamiar się 1,5.

345
00:20:58,000 --> 00:21:06,000
I mamy to 0,2 f prostu poprosić o 2 jednostkach dziesiętnych w części dziesiętnej.

346
00:21:06,000 --> 00:21:12,000
Jeśli masz .3 f to się rzeczywiście 1,500.

347
00:21:12,000 --> 00:21:16,000
Jeśli to 2 to będzie 1,50.

348
00:21:16,000 --> 00:21:18,000
Mamy też w tej sprawie tutaj.

349
00:21:18,000 --> 00:21:22,000
Jeśli nie pływaka x = 3,14 i wtedy printf x

350
00:21:22,000 --> 00:21:24,000
masz zamiar dostać 3,14.

351
00:21:24,000 --> 00:21:29,000
I jeśli x = int x,

352
00:21:29,000 --> 00:21:34,000
co oznacza, że ​​traktuje x jako int i wypisać x teraz

353
00:21:34,000 --> 00:21:36,000
będziesz mieć 3,00.

354
00:21:36,000 --> 00:21:38,000
Czy to ma sens?

355
00:21:38,000 --> 00:21:41,000
Bo jesteś najpierw działając x jako liczba całkowita, a więc jesteś ignorując dziesiętną część,

356
00:21:41,000 --> 00:21:45,000
a następnie drukuje się x.

357
00:21:45,000 --> 00:21:47,000
I wreszcie, można to zrobić,

358
00:21:47,000 --> 00:21:52,000
int x = 65, a następnie zadeklarować char c = x,

359
00:21:52,000 --> 00:21:56,000
, a następnie, jeśli wydrukować c. jesteś rzeczywiście dostanie

360
00:21:56,000 --> 00:21:59,000
, Więc w zasadzie co tu robisz

361
00:21:59,000 --> 00:22:02,000
przekłada liczbę całkowitą do charakteru,

362
00:22:02,000 --> 00:22:05,000
jak ASCII Tabela robi.

363
00:22:05,000 --> 00:22:08,000
Rozmawialiśmy także o operatorów matematycznych.

364
00:22:08,000 --> 00:22:14,000
Większość z nich są bardzo proste, więc +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
a także rozmawialiśmy o modzie, która pozostała do podziału 2 liczb.

366
00:22:20,000 --> 00:22:23,000
Jeśli masz 10% 3, na przykład,

367
00:22:23,000 --> 00:22:27,000
to znaczy podzielić 10 przez 3, a co reszta?

368
00:22:27,000 --> 00:22:30,000
To będzie 1, więc jest to naprawdę bardzo przydatne dla wielu programów.

369
00:22:30,000 --> 00:22:38,000
Dla Vigenère i Cezara Jestem pewien, że wszyscy z was stosować mod.

370
00:22:38,000 --> 00:22:43,000
O operatorów matematycznych, być bardzo ostrożnym podczas łączenia * i /.

371
00:22:43,000 --> 00:22:48,000
>> Na przykład, jeśli nie (3/2) * 2, co masz zamiar dostać?

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

373
00:22:50,000 --> 00:22:54,000
Tak, 2, ponieważ 3/2 będzie 1.5

374
00:22:54,000 --> 00:22:57,000
ale skoro robisz operacji pomiędzy 2 liczb

375
00:22:57,000 --> 00:22:59,000
jesteś rzeczywiście tak będzie badać, 1,

376
00:22:59,000 --> 00:23:03,000
a następnie 1 * 2 będzie 2, więc być bardzo ostrożny

377
00:23:03,000 --> 00:23:07,000
przy wykonywaniu arytmetyki liczb całkowitych, ponieważ z

378
00:23:07,000 --> 00:23:12,000
można dostać, że 2 = 3, w tym przypadku.

379
00:23:12,000 --> 00:23:14,000
A także być bardzo ostrożnym pierwszeństwa.

380
00:23:14,000 --> 00:23:21,000
Należy zazwyczaj użyć nawiasów, aby upewnić się, że wiesz co robisz.

381
00:23:21,000 --> 00:23:27,000
Niektóre użyteczne skróty, Oczywiście, jest i + + + i i = 1

382
00:23:27,000 --> 00:23:30,000
lub przy użyciu + =.

383
00:23:30,000 --> 00:23:34,000
To jest to samo, co robi i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Można również zrobić i - lub i - = 1,

385
00:23:39,000 --> 00:23:42,000
co jest to samo, co i = i -1,

386
00:23:42,000 --> 00:23:46,000
coś, czego faceci używają dużo w pętli, co najmniej.

387
00:23:46,000 --> 00:23:52,000
Ponadto, dla *, jeśli używasz * = a jeśli nie, na przykład,

388
00:23:52,000 --> 00:23:57,000
i * = 2 jest to samo, co mówią i = i * 2,

389
00:23:57,000 --> 00:23:59,000
i to samo do podziału.

390
00:23:59,000 --> 00:24:08,000
Jeśli nie i / = 2 to jest to samo co i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Teraz o funkcji.

392
00:24:10,000 --> 00:24:13,000
Dowiedzieliśmy się, że chłopaki są funkcje bardzo dobra strategia, aby zapisać kod

393
00:24:13,000 --> 00:24:16,000
gdy jesteś programowania, więc jeśli chcesz, aby wykonać to samo zadanie

394
00:24:16,000 --> 00:24:20,000
w kodzie, po raz kolejny, prawdopodobnie chcesz użyć funkcji

395
00:24:20,000 --> 00:24:25,000
tak więc nie musisz skopiować i wkleić kod w kółko.

396
00:24:25,000 --> 00:24:28,000
Faktycznie, głównym jest funkcją, a kiedy pokazać format funkcji

397
00:24:28,000 --> 00:24:32,000
masz zamiar zobaczyć, że to jest dość oczywiste.

398
00:24:32,000 --> 00:24:35,000
Mamy również korzystać z funkcji z niektórych bibliotek,

399
00:24:35,000 --> 00:24:39,000
na przykład, printf, Getin, który jest z biblioteki, CS50,

400
00:24:39,000 --> 00:24:43,000
oraz inne funkcje, takie jak toupper.

401
00:24:43,000 --> 00:24:46,000
Wszystkie te funkcje są w rzeczywistości realizowane w innych bibliotek,

402
00:24:46,000 --> 00:24:49,000
i kiedy można umieścić te pliki Tether na początku programu

403
00:24:49,000 --> 00:24:53,000
mówisz, czy możesz dać mi kod dla tych funkcji

404
00:24:53,000 --> 00:24:57,000
więc nie mam do ich wdrożenia przez siebie?

405
00:24:57,000 --> 00:25:00,000
Można także pisać własne funkcje, więc kiedy rozpocząć programowanie

406
00:25:00,000 --> 00:25:04,000
zdajesz sobie sprawę, że biblioteki nie mają wszystkie funkcje, które potrzebujesz.

407
00:25:04,000 --> 00:25:10,000
Dla ostatniego PSET, np. pisaliśmy rysować, Scramble, i wyszukiwania,

408
00:25:10,000 --> 00:25:13,000
i to jest bardzo, bardzo ważne, aby móc napisać funkcje

409
00:25:13,000 --> 00:25:17,000
dlatego, że są przydatne, a używamy ich cały czas w programowaniu,

410
00:25:17,000 --> 00:25:19,000
i oszczędza dużo kodu.

411
00:25:19,000 --> 00:25:21,000
Format funkcji jest ta.

412
00:25:21,000 --> 00:25:24,000
Mamy zwracany typ na początku. Co to jest typ zwracany?

413
00:25:24,000 --> 00:25:27,000
To jest tylko wtedy, gdy funkcja ma zamiar wrócić.

414
00:25:27,000 --> 00:25:29,000
Jeśli masz funkcję, na przykład, silni,

415
00:25:29,000 --> 00:25:31,000
, który ma obliczyć silnię liczby całkowitej,

416
00:25:31,000 --> 00:25:34,000
Prawdopodobnie to będzie zwracać liczbę całkowitą również.

417
00:25:34,000 --> 00:25:37,000
Następnie zwracany typ będzie int.

418
00:25:37,000 --> 00:25:41,000
Printf faktycznie ma pustkę Zwraca typ

419
00:25:41,000 --> 00:25:43,000
ponieważ nie jesteś powrocie nic.

420
00:25:43,000 --> 00:25:45,000
Jesteś po prostu drukowanie rzeczy na ekranie

421
00:25:45,000 --> 00:25:48,000
i wyjście z funkcji później.

422
00:25:48,000 --> 00:25:51,000
Potem masz nazwę funkcji, które można wybrać.

423
00:25:51,000 --> 00:25:55,000
Trzeba mieć trochę rozsądne, jak nie wybrać nazwę jak xyz

424
00:25:55,000 --> 00:25:58,000
lub jak x2F.

425
00:25:58,000 --> 00:26:02,000
Spróbuj uzupełnić nazwę, która ma sens.

426
00:26:02,000 --> 00:26:04,000
>> Na przykład, jeśli jest to silni, powiedzmy silnię.

427
00:26:04,000 --> 00:26:08,000
Jeśli jest to funkcja, która będzie narysować coś, nazwij go narysować.

428
00:26:08,000 --> 00:26:11,000
A potem mają parametry, które są również nazywane argumenty,

429
00:26:11,000 --> 00:26:14,000
które są jak zasobów, że funkcja musi

430
00:26:14,000 --> 00:26:17,000
z kodu do wykonywania jego zadania.

431
00:26:17,000 --> 00:26:20,000
Jeśli chcesz obliczyć silni liczby

432
00:26:20,000 --> 00:26:23,000
prawdopodobnie trzeba mieć numer do obliczenia silni.

433
00:26:23,000 --> 00:26:27,000
Jednym z argumentów, że będziemy mieć to numer sam.

434
00:26:27,000 --> 00:26:31,000
I wtedy to będzie coś zrobić i zwraca wartość na koniec

435
00:26:31,000 --> 00:26:35,000
chyba, że ​​jest to funkcja nieważne.

436
00:26:35,000 --> 00:26:37,000
Zobaczmy przykład.

437
00:26:37,000 --> 00:26:40,000
Jeśli chcę napisać funkcję, która sumuje wszystkie liczby w tablicy liczb całkowitych,

438
00:26:40,000 --> 00:26:43,000
Po pierwsze, jest typu powrotu będzie int

439
00:26:43,000 --> 00:26:46,000
ponieważ mam tablicę liczb całkowitych.

440
00:26:46,000 --> 00:26:51,000
I wtedy będę miała nazwę funkcji jak sumArray,

441
00:26:51,000 --> 00:26:54,000
a następnie zajmie się tablica, int nums,

442
00:26:54,000 --> 00:26:58,000
a następnie długość tablicy, więc wiem, ile liczb mam do podsumowania.

443
00:26:58,000 --> 00:27:02,000
Następnie trzeba zainicjować zmienną sumę, na przykład, do 0,

444
00:27:02,000 --> 00:27:08,000
i za każdym razem widzę elementu w tablicy należy dodać go do sumy, więc zrobiłem dla pętli.

445
00:27:08,000 --> 00:27:15,000
Podobnie jak Lexi mówi, robisz int i = 0, i długość <i i + +.

446
00:27:15,000 --> 00:27:20,000
I dla każdego elementu w tablicy zrobiłem suma + = nums [i],

447
00:27:20,000 --> 00:27:24,000
a następnie wróciłem sumę, więc jest to bardzo proste, a to oszczędza dużo kodu

448
00:27:24,000 --> 00:27:28,000
jeśli korzystasz z tej funkcji, wiele razy.

449
00:27:28,000 --> 00:27:32,000
Potem przyjrzał się warunków.

450
00:27:32,000 --> 00:27:38,000
Mamy if, else i else if.

451
00:27:38,000 --> 00:27:42,000
Zobaczmy, jaka jest różnica między tymi.

452
00:27:42,000 --> 00:27:45,000
Spójrz na tych 2 kodów. Jaka jest różnica między nimi?

453
00:27:45,000 --> 00:27:49,000
Pierwszy ma-w zasadzie kody żebyś powiedział

454
00:27:49,000 --> 00:27:51,000
Jeśli liczba jest +, -, lub 0.

455
00:27:51,000 --> 00:27:55,000
Pierwsza mówi, że jeśli to jest> 0 to jest to pozytywne.

456
00:27:55,000 --> 00:28:00,000
Jeśli to = 0, a następnie to 0, a jeśli jest to <0 to jest to negatywne.

457
00:28:00,000 --> 00:28:04,000
>> , A drugi robi if, else if, else.

458
00:28:04,000 --> 00:28:07,000
Różnica między nimi jest, że ta faktycznie się

459
00:28:07,000 --> 00:28:13,000
sprawdzić, czy> 0, <0 lub = 0 trzy razy,

460
00:28:13,000 --> 00:28:17,000
więc jeśli masz numer 2, na przykład, że będzie tu przyjść i powiedzieć:

461
00:28:17,000 --> 00:28:21,000
if (x> 0), a to się, że tak, więc wydrukować pozytywne.

462
00:28:21,000 --> 00:28:25,000
Ale chociaż wiem, że to jest> 0 i nie będzie 0 lub <0

463
00:28:25,000 --> 00:28:29,000
Wciąż będziemy robić to jest 0, to jest <0,

464
00:28:29,000 --> 00:28:33,000
więc jestem naprawdę dzieje się wewnątrz ifs, że nie muszą

465
00:28:33,000 --> 00:28:38,000
bo już wiem, że to nie będzie spełniać żadnego z tych warunków.

466
00:28:38,000 --> 00:28:41,000
Można używać, jeśli else if, else.

467
00:28:41,000 --> 00:28:45,000
To w zasadzie mówi, że jeśli x = 0 wydrukować pozytywne.

468
00:28:45,000 --> 00:28:48,000
Jeśli tak nie jest, mam zamiar również przetestować.

469
00:28:48,000 --> 00:28:51,000
Jeśli to 2 nie będę tego robić.

470
00:28:51,000 --> 00:28:54,000
Zasadniczo jeśli miałem x = 2 powiedziałbyś

471
00:28:54,000 --> 00:28:57,000
if (x> 0), tak, więc drukuj.

472
00:28:57,000 --> 00:29:00,000
Teraz wiem, że to jest> 0 i że spełnione najpierw, jeśli

473
00:29:00,000 --> 00:29:02,000
Nie jestem nawet zamiar uruchomić ten kod.

474
00:29:02,000 --> 00:29:09,000
Kod działa szybciej, faktycznie, 3 razy szybciej, jeśli używasz tego.

475
00:29:09,000 --> 00:29:11,000
Dowiedzieliśmy się także o AND i OR.

476
00:29:11,000 --> 00:29:15,000
Nie zamierzam przejść przez to, ponieważ Lexi już mówił o nich.

477
00:29:15,000 --> 00:29:17,000
To tylko && i | operator |.

478
00:29:17,000 --> 00:29:21,000
>> Jedyne co powiem, to należy uważać, gdy masz 3 warunki.

479
00:29:21,000 --> 00:29:24,000
Użyć nawiasów, bo to bardzo mylące, gdy występuje stan

480
00:29:24,000 --> 00:29:27,000
i jeszcze jeden lub drugi.

481
00:29:27,000 --> 00:29:30,000
Użyj nawiasów tylko mieć pewność, że twoje warunki sensu

482
00:29:30,000 --> 00:29:34,000
, ponieważ w tym przypadku, na przykład, można sobie wyobrazić, że

483
00:29:34,000 --> 00:29:38,000
może to być stan pierwszy i jeden lub inne

484
00:29:38,000 --> 00:29:41,000
lub 2 połączone w warunkach i

485
00:29:41,000 --> 00:29:45,000
lub trzeci, więc po prostu uważać.

486
00:29:45,000 --> 00:29:48,000
I wreszcie, rozmawialiśmy o przełącznikach.

487
00:29:48,000 --> 00:29:53,000
Przełącznik jest bardzo przydatna, gdy masz zmienną.

488
00:29:53,000 --> 00:29:55,000
Powiedzmy, że masz zmienną jak n

489
00:29:55,000 --> 00:29:59,000
, że mogą się 0, 1, lub 2, a w każdym z tych przypadków,

490
00:29:59,000 --> 00:30:01,000
masz zamiar wykonać zadanie.

491
00:30:01,000 --> 00:30:04,000
Można powiedzieć, włączyć zmienną, a oznacza to, że

492
00:30:04,000 --> 00:30:08,000
napięcie wtedy jest jak value1 zamierzam to zrobić,

493
00:30:08,000 --> 00:30:12,000
a potem przerwa, co oznacza, że ​​nie będę patrzeć na którykolwiek z pozostałych przypadkach

494
00:30:12,000 --> 00:30:15,000
bo już przekonany, że przypadek

495
00:30:15,000 --> 00:30:20,000
a następnie wartość2 i tak dalej, i ja również może mieć przełącznik domyślnego.

496
00:30:20,000 --> 00:30:24,000
Oznacza to, że jeśli nie spełnia żadnego z przypadków, które miałem

497
00:30:24,000 --> 00:30:29,000
że będę robić coś innego, ale to jest opcjonalne.

498
00:30:29,000 --> 00:30:36,000
To wszystko dla mnie. Teraz mają Tommy.

499
00:30:36,000 --> 00:30:41,000
W porządku, to będzie tydzień 3-owski.

500
00:30:41,000 --> 00:30:45,000
Są to niektóre z tematów, będziemy zalewami crypto, zakresu tablic, et cetera.

501
00:30:45,000 --> 00:30:49,000
Wystarczy szybkie słowo na kryptografii. Nie będziemy wbijać ten dom.

502
00:30:49,000 --> 00:30:52,000
>> Zrobiliśmy to w Pset 2, ale w quizie należy znać różnicę

503
00:30:52,000 --> 00:30:54,000
między szyfru Cezara i szyfrem Vigenère

504
00:30:54,000 --> 00:30:57,000
jak zarówno tych, którzy pracy szyfrów i jak to jest do szyfrowania

505
00:30:57,000 --> 00:30:59,000
i tekst odszyfrować użyciu tych 2 szyfry.

506
00:30:59,000 --> 00:31:03,000
Pamiętaj, szyfr Cezara po prostu obraca każdy znak w tej samej wysokości,

507
00:31:03,000 --> 00:31:06,000
upewniając się, że mod przez liczbę liter w alfabecie.

508
00:31:06,000 --> 00:31:09,000
I szyfr Vigenère drugiej strony, każdy znak obraca

509
00:31:09,000 --> 00:31:12,000
o innej wysokości, więc zamiast mówić

510
00:31:12,000 --> 00:31:15,000
co obracać znaku przez 3 Vigenère obraca każdy znak

511
00:31:15,000 --> 00:31:17,000
o różny w zależności od niektórych kluczowych

512
00:31:17,000 --> 00:31:20,000
gdzie każda litera w kluczowych reprezentuje trochę inną kwotę

513
00:31:20,000 --> 00:31:26,000
obrócić wyraźny tekst.

514
00:31:26,000 --> 00:31:28,000
Niech najpierw rozmawiają o zasięg zmiennych.

515
00:31:28,000 --> 00:31:30,000
Są 2 różne rodzaje zmiennych.

516
00:31:30,000 --> 00:31:33,000
Mamy zmienne lokalne, a te zostaną określone

517
00:31:33,000 --> 00:31:36,000
poza głównym lub poza dowolnej funkcji lub bloku,

518
00:31:36,000 --> 00:31:39,000
i będą one dostępne w dowolnym miejscu w programie.

519
00:31:39,000 --> 00:31:41,000
Jeśli masz funkcję i w tej funkcji jest pętla

520
00:31:41,000 --> 00:31:44,000
duża zmienna globalna jest dostępna wszędzie.

521
00:31:44,000 --> 00:31:48,000
Lokalne zmienne, z drugiej strony, jest ograniczony do miejsca, w którym jest to określone.

522
00:31:48,000 --> 00:31:53,000
>> Jeśli masz funkcję o, na przykład, mamy tę funkcję g,

523
00:31:53,000 --> 00:31:56,000
G i wewnątrz jest zmienną o nazwie Y

524
00:31:56,000 --> 00:31:58,000
co oznacza, że ​​jest to zmienna lokalna.

525
00:31:58,000 --> 00:32:00,000
Nawet jeśli ta zmienna nazywa y

526
00:32:00,000 --> 00:32:03,000
i ta zmienna nazywa y te 2 funkcje

527
00:32:03,000 --> 00:32:06,000
nie mam pojęcia co dla siebie lokalne zmienne.

528
00:32:06,000 --> 00:32:10,000
Z drugiej strony, tu powiedzieć int x = 5,

529
00:32:10,000 --> 00:32:12,000
i jest poza zakresem żadnej funkcji.

530
00:32:12,000 --> 00:32:16,000
To jest poza zakresem główną, więc jest to zmienna globalna.

531
00:32:16,000 --> 00:32:20,000
To oznacza, że ​​w środku tych 2 funkcji, gdy mówię, x - czy x + +

532
00:32:20,000 --> 00:32:26,000
Mam dostęp do tego samego x przy czym ta y i to Y są różne zmienne.

533
00:32:26,000 --> 00:32:30,000
To jest różnica między zmienną globalną i zmiennej lokalnej.

534
00:32:30,000 --> 00:32:33,000
O ile chodzi o design, czasami to chyba lepszy pomysł

535
00:32:33,000 --> 00:32:37,000
zachować zmienne lokalne, gdy to tylko możliwe

536
00:32:37,000 --> 00:32:39,000
ponieważ mając kilka zmiennych globalnych można uzyskać naprawdę kłopotliwe.

537
00:32:39,000 --> 00:32:42,000
Jeśli masz kilka funkcji wszystkie zmiany to samo

538
00:32:42,000 --> 00:32:45,000
można zapomnieć, co jeśli ta funkcja przypadkowo modyfikuje ten globalny,

539
00:32:45,000 --> 00:32:47,000
a to inna funkcja nie wie o tym,

540
00:32:47,000 --> 00:32:50,000
i robi się dość skomplikowane, jak dostać więcej kodu.

541
00:32:50,000 --> 00:32:53,000
Utrzymywanie zmienne lokalne, gdy to tylko możliwe

542
00:32:53,000 --> 00:32:56,000
jest po prostu dobry design.

543
00:32:56,000 --> 00:33:00,000
Macierze, Pamiętaj, są po prostu wykaz elementów tego samego typu.

544
00:33:00,000 --> 00:33:04,000
Wewnątrz CI nie może mieć listę takich jak 1, 2,0, hello.

545
00:33:04,000 --> 00:33:06,000
Po prostu nie mogę tego zrobić.

546
00:33:06,000 --> 00:33:11,000
>> Kiedy stwierdzenie tablicy w C wszystkie elementy muszą być tego samego typu.

547
00:33:11,000 --> 00:33:14,000
Tutaj mam tablicę 3 liczb całkowitych.

548
00:33:14,000 --> 00:33:18,000
Tutaj mam długość tablicy, ale jeśli ja tylko deklarując go w tej składni

549
00:33:18,000 --> 00:33:21,000
gdzie mogę określić wszystkie elementy nie są technicznie potrzebujemy 3.

550
00:33:21,000 --> 00:33:25,000
Kompilator jest na tyle sprytny, aby dowiedzieć się, jak duża tablica powinna być.

551
00:33:25,000 --> 00:33:28,000
Teraz, gdy chcę uzyskać lub ustawić wartość tablicy

552
00:33:28,000 --> 00:33:30,000
to jest składnia to zrobić.

553
00:33:30,000 --> 00:33:33,000
To będzie faktycznie zmienić drugi element tablicy, bo pamiętam,

554
00:33:33,000 --> 00:33:36,000
Numeracja zaczyna się od 0, a nie na 1.

555
00:33:36,000 --> 00:33:42,000
Jeśli chcę przeczytać tę wartość można powiedzieć coś takiego int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Albo, jeżeli chcesz ustawić tę wartość, tak jak ja tutaj robię,

557
00:33:44,000 --> 00:33:47,000
Mogę powiedzieć, tablica [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Że czas dostępu do elementów poprzez ich indeks

559
00:33:50,000 --> 00:33:52,000
lub ich pozycji lub gdy są w tablicy,

560
00:33:52,000 --> 00:33:57,000
i że wpis zaczyna się 0.

561
00:33:57,000 --> 00:34:00,000
Możemy również tablice tablic,

562
00:34:00,000 --> 00:34:03,000
i to się nazywa wielowymiarową tablicę.

563
00:34:03,000 --> 00:34:05,000
Kiedy mamy tablicę wielowymiarową

564
00:34:05,000 --> 00:34:07,000
co oznacza, że ​​możemy mieć coś jak wierszy i kolumn,

565
00:34:07,000 --> 00:34:11,000
i jest to tylko jeden ze sposobów wizualizacji to czy o tym myśleć.

566
00:34:11,000 --> 00:34:14,000
Kiedy mam tablicę wielowymiarową, która oznacza, że ​​zamierzam rozpocząć konieczności

567
00:34:14,000 --> 00:34:17,000
więcej niż 1 index bo jeśli mam siatkę

568
00:34:17,000 --> 00:34:19,000
tylko, że to, co jesteś w wiersz nie daje nam liczbę.

569
00:34:19,000 --> 00:34:22,000
To się naprawdę da nam listę numerów.

570
00:34:22,000 --> 00:34:25,000
Powiedzmy, że mam tę tablicę tutaj.

571
00:34:25,000 --> 00:34:30,000
Mam tablicę o nazwie sieci, a ja mówię, że to 2 wiersze i 3 kolumny,

572
00:34:30,000 --> 00:34:32,000
i więc jest to sposób wizualizacji.

573
00:34:32,000 --> 00:34:37,000
Kiedy mówię, że chcę, aby uzyskać element w [1] [2]

574
00:34:37,000 --> 00:34:41,000
to znaczy, że ponieważ są rzędy kolumny, a potem

575
00:34:41,000 --> 00:34:44,000
Mam zamiar przejść do wiersza 1 od powiedziałem 1.

576
00:34:44,000 --> 00:34:49,000
>> Potem mam zamiar przyjść tutaj do kolumny 2, a ja zamierzam uzyskać wartość 6.

577
00:34:49,000 --> 00:34:51,000
Ma sens?

578
00:34:51,000 --> 00:34:55,000
Tablice wielowymiarowe, pamiętaj, są technicznie tylko tablica tablic.

579
00:34:55,000 --> 00:34:57,000
Możemy mieć tablice tablice tablic.

580
00:34:57,000 --> 00:35:00,000
Możemy iść dalej, ale naprawdę jeden sposób myślenia o

581
00:35:00,000 --> 00:35:03,000
jak to jest określone i co się dzieje to jest wizualizacja

582
00:35:03,000 --> 00:35:09,000
w siatce jak ta.

583
00:35:09,000 --> 00:35:12,000
Kiedy mijamy tablicę do funkcji, że będziemy zachowywać się

584
00:35:12,000 --> 00:35:16,000
trochę inaczej niż wtedy, gdy mijamy regularne zmienne do funkcji

585
00:35:16,000 --> 00:35:18,000
jak przekazywanie int lub float.

586
00:35:18,000 --> 00:35:21,000
Gdy przechodzimy w rodzaju int lub char lub dowolnym z tych danych

587
00:35:21,000 --> 00:35:24,000
właśnie przyjrzał jeśli funkcja modyfikuje

588
00:35:24,000 --> 00:35:28,000
wartość tej zmiennej, że zmiana nie będzie rozprzestrzeniać się

589
00:35:28,000 --> 00:35:32,000
do wywoływania funkcji.

590
00:35:32,000 --> 00:35:35,000
W tablicy, z drugiej strony, że tak się stanie.

591
00:35:35,000 --> 00:35:39,000
Jeśli przechodzą w tablicy do niektórych funkcji, a funkcja zmienia niektóre z elementów,

592
00:35:39,000 --> 00:35:43,000
kiedy wrócę do funkcji, która wywołała go

593
00:35:43,000 --> 00:35:47,000
moja tablica jest teraz będzie inaczej, i za to słownictwo

594
00:35:47,000 --> 00:35:50,000
jest tablice są przekazywane przez referencję, jak zobaczymy później.

595
00:35:50,000 --> 00:35:53,000
Związane jest to w jaki sposób działają wskaźniki, gdzie te podstawowe typy danych,

596
00:35:53,000 --> 00:35:55,000
z drugiej strony, są przekazywane przez wartość.

597
00:35:55,000 --> 00:35:59,000
>> Możemy myśleć, że wykonanie kopii jakiejś zmiennej, a następnie przechodzi w kopii.

598
00:35:59,000 --> 00:36:01,000
To nie ma znaczenia, co robimy z tej zmiennej.

599
00:36:01,000 --> 00:36:06,000
Funkcji wywołującej nie będzie wiedział, że zmieniono.

600
00:36:06,000 --> 00:36:10,000
Tablice są tylko trochę różni się w tym względzie.

601
00:36:10,000 --> 00:36:13,000
Na przykład, tak, jak zamierzaliśmy, głównym jest po prostu funkcja

602
00:36:13,000 --> 00:36:15,000
, które mogą podjąć w 2 argumenty.

603
00:36:15,000 --> 00:36:20,000
Pierwszy argument funkcji głównej jest argc, lub liczbę argumentów

604
00:36:20,000 --> 00:36:23,000
i drugi argument jest nazywany argv,

605
00:36:23,000 --> 00:36:27,000
i to są rzeczywiste wartości tych argumentów.

606
00:36:27,000 --> 00:36:30,000
Powiedzmy, że mam program o nazwie this.c,

607
00:36:30,000 --> 00:36:34,000
i mówię, aby to, i mam zamiar uruchomić to w wierszu poleceń.

608
00:36:34,000 --> 00:36:38,000
Teraz, aby przejść w niektórych argumentów do mojego programu nazwali to,

609
00:36:38,000 --> 00:36:42,000
Mógłbym powiedzieć coś. / To jest cs 50.

610
00:36:42,000 --> 00:36:45,000
To jest to, co możemy sobie wyobrazić David zrobić codziennie w terminalu.

611
00:36:45,000 --> 00:36:48,000
Ale teraz główny wewnątrz funkcja tego programu

612
00:36:48,000 --> 00:36:52,000
ma te wartości, więc argc jest 4.

613
00:36:52,000 --> 00:36:56,000
To może być trochę mylące, bo tak naprawdę jesteśmy tylko przechodząc jest cs 50.

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

615
00:36:58,000 --> 00:37:02,000
Ale pamiętaj, że pierwszy element argv lub pierwszy argument

616
00:37:02,000 --> 00:37:05,000
jest nazwa samej funkcji.

617
00:37:05,000 --> 00:37:07,190
Więc to oznacza, że ​​mamy 4 rzeczy tu,

618
00:37:07,190 --> 00:37:10,530
oraz pierwszy element będzie. / to.

619
00:37:10,530 --> 00:37:12,970
I to będzie reprezentowany jako ciąg.

620
00:37:12,970 --> 00:37:18,590
Wtedy pozostałe elementy, co wpisane w po nazwie programu.

621
00:37:18,590 --> 00:37:22,720
Tak, jak na bok, jak zapewne widzieliśmy w Pset 2,

622
00:37:22,720 --> 00:37:28,780
pamiętać, że ciąg 50 jest ≠ całkowitą 50.

623
00:37:28,780 --> 00:37:32,520
Więc nie możemy powiedzieć coś w stylu: "int x = argv 3".

624
00:37:32,520 --> 00:37:36,470
>> Że po prostu nie będzie sensu, bo to jest ciąg, a to jest liczbą całkowitą.

625
00:37:36,470 --> 00:37:38,510
Tak więc, jeśli chcesz przekonwertować między 2, pamiętaj, będziemy

626
00:37:38,510 --> 00:37:40,810
mają magiczną funkcję o nazwie atoi.

627
00:37:40,810 --> 00:37:46,270
Która pobiera ciąg i zwraca liczbę całkowitą reprezentowany wewnątrz tego łańcucha.

628
00:37:46,270 --> 00:37:48,360
Więc to jest proste, aby błąd w quizie,

629
00:37:48,360 --> 00:37:51,590
myśląc, że to będzie automatycznie odpowiedniego typu.

630
00:37:51,590 --> 00:37:53,860
Ale wiedz, że to zawsze będzie smyczki

631
00:37:53,860 --> 00:38:00,920
nawet, jeśli ciąg zawiera tylko liczbę całkowitą lub znak lub pacą.

632
00:38:00,920 --> 00:38:03,380
Więc teraz porozmawiajmy o czas pracy.

633
00:38:03,380 --> 00:38:06,700
Gdy mamy wszystkie te algorytmy, które te wszystkie szalone rzeczy,

634
00:38:06,700 --> 00:38:11,580
staje się bardzo przydatne, by zadać pytanie: "Jak długo oni brać?"

635
00:38:11,580 --> 00:38:15,500
Oświadczamy, że z czymś zwanym asymptotycznej notacji.

636
00:38:15,500 --> 00:38:18,430
Więc to oznacza, że ​​- no cóż, powiedzmy, że dajemy naszym algorytmu

637
00:38:18,430 --> 00:38:20,840
niektóre naprawdę, naprawdę, naprawdę duże wejście.

638
00:38:20,840 --> 00:38:23,840
Chcemy zadać pytanie: "Jak długo to potrwa?

639
00:38:23,840 --> 00:38:26,370
Ile kroków zajmie nasz algorytm, aby uruchomić

640
00:38:26,370 --> 00:38:29,980
w funkcji wielkości wejściowych? "

641
00:38:29,980 --> 00:38:33,080
Więc pierwszy sposób możemy opisać czas jest prowadzony z dużym O.

642
00:38:33,080 --> 00:38:35,380
A to nasz najgorszy czas praca.

643
00:38:35,380 --> 00:38:38,590
Więc jeśli chcemy sortować tablicę i dajemy nasz algorytm tablicy

644
00:38:38,590 --> 00:38:41,000
że to w porządku malejącym, kiedy powinien być w porządku rosnącym,

645
00:38:41,000 --> 00:38:43,130
że będzie to najgorszy przypadek.

646
00:38:43,130 --> 00:38:49,800
To jest nasza górna granica w maksymalnej długości czasu nasz algorytm weźmie.

647
00:38:49,800 --> 00:38:54,740
Z drugiej strony, ta Ω będzie opisać najlepszym razie czas pracy.

648
00:38:54,740 --> 00:38:58,210
Więc jeśli dajemy już posortowaną tablicę do algorytmu sortowania,

649
00:38:58,210 --> 00:39:00,940
jak długo to zajmie się rozwiązać to?

650
00:39:00,940 --> 00:39:06,610
I to, a następnie, opisuje dolną granicę czasu pracy.

651
00:39:06,610 --> 00:39:10,980
Więc tutaj to tylko niektóre słowa, które opisują pewne wspólne razy z rzędu.

652
00:39:10,980 --> 00:39:13,120
Są to w kolejności rosnącej.

653
00:39:13,120 --> 00:39:16,060
Najszybszy czas pracy mamy nazywa się stała.

654
00:39:16,060 --> 00:39:19,800
>> To oznacza, że ​​bez względu na to jak wiele elementów dajemy algorytm,

655
00:39:19,800 --> 00:39:22,280
nie ważne jak duże nasza tablica jest, jego sortowanie

656
00:39:22,280 --> 00:39:26,510
lub robi cokolwiek robimy do tablicy zawsze będzie taką samą ilość czasu.

657
00:39:26,510 --> 00:39:30,270
Tak więc można, że ​​stanowią tylko z 1, która jest stała.

658
00:39:30,270 --> 00:39:32,410
Przyglądaliśmy się także logarytmicznym czasie wykonywania.

659
00:39:32,410 --> 00:39:34,800
Więc coś jak wyszukiwanie binarne jest logarytmiczna,

660
00:39:34,800 --> 00:39:37,140
gdzie tniemy problem w pół przy każdym

661
00:39:37,140 --> 00:39:40,970
i rzeczy po prostu wyższy od tego.

662
00:39:40,970 --> 00:39:43,580
A jeśli kiedykolwiek pisania O każdej czynnikowego algorytmu,

663
00:39:43,580 --> 00:39:47,850
prawdopodobnie nie powinien uznać to za dzień pracy.

664
00:39:47,850 --> 00:39:53,910
Kiedy porównać czas ważne jest, aby pamiętać o tych rzeczach.

665
00:39:53,910 --> 00:39:57,760
Więc jeśli mam algorytm, który jest O (n), a ktoś inny

666
00:39:57,760 --> 00:40:03,590
jest algorytm O (2n) są to właściwie asymptotycznie równoważne.

667
00:40:03,590 --> 00:40:06,590
Jeśli więc wyobrazić n być duża liczba jak eleventy mld:

668
00:40:06,590 --> 00:40:13,090
więc kiedy mamy porównanie eleventy mld do czegoś eleventy mld + 3,

669
00:40:13,090 --> 00:40:17,640
nagle, że +3 naprawdę nie robi dużą różnicę już.

670
00:40:17,640 --> 00:40:20,980
Dlatego mamy zamiar rozpocząć rozważa te rzeczy za równoważne.

671
00:40:20,980 --> 00:40:24,220
Więc takie rzeczy jak tych stałych tutaj, jest 2 x ta lub dodając 3,

672
00:40:24,220 --> 00:40:27,180
to tylko stałe, a te będą spadać w górę.

673
00:40:27,180 --> 00:40:32,480
To dlatego wszystkie 3 z tych czasów przebiegu są takie same jak mówią oni O (n).

674
00:40:32,480 --> 00:40:37,490
Podobnie, jeśli mamy 2 inne czas pracy, powiedzmy, O (n ³ + 2n ²), możemy dodać

675
00:40:37,490 --> 00:40:42,070
+ N + 7, a następnie mamy kolejny czas pracy, który jest po prostu O (³ n).

676
00:40:42,070 --> 00:40:46,290
ponownie, to samo, ponieważ są - nie są takie same.

677
00:40:46,290 --> 00:40:49,840
Są to te same rzeczy, przepraszam. Więc to są takie same, ponieważ

678
00:40:49,840 --> 00:40:53,090
ta ³ n ma zamiar zdominować ten 2n ².

679
00:40:53,090 --> 00:40:59,130
>> Co to jest nie to samo jest, jeśli mamy uruchomić razy jak O (³ n) i O (n ²)

680
00:40:59,130 --> 00:41:02,820
bo ³ n jest znacznie większy niż ten ² n.

681
00:41:02,820 --> 00:41:05,470
Więc jeśli mamy wykładniki, nagle zaczyna to znaczenia,

682
00:41:05,470 --> 00:41:08,280
ale gdy mamy po prostu do czynienia z czynnikami, jak jesteśmy tu,

683
00:41:08,280 --> 00:41:12,810
wtedy to nie będzie się liczyć, ponieważ są one po prostu się wypaść.

684
00:41:12,810 --> 00:41:16,760
Rzućmy okiem na niektóre z algorytmów widzieliśmy do tej pory

685
00:41:16,760 --> 00:41:19,260
i porozmawiać o ich czasie pracy.

686
00:41:19,260 --> 00:41:23,850
Pierwsze spojrzenie na liczby w liście, że widzieliśmy, był liniowy wyszukiwania.

687
00:41:23,850 --> 00:41:26,950
I realizacja liniowej wyszukiwania jest bardzo prosta.

688
00:41:26,950 --> 00:41:30,490
Musimy tylko listę, i będziemy patrzeć na każdego elementu na liście

689
00:41:30,490 --> 00:41:34,260
dopóki nie znajdziemy liczby szukamy.

690
00:41:34,260 --> 00:41:38,370
To oznacza, że ​​w najgorszym przypadku, to O (n).

691
00:41:38,370 --> 00:41:40,860
A w najgorszym przypadku może tu być, jeśli element jest

692
00:41:40,860 --> 00:41:45,710
Ostatnim elementem, a następnie za pomocą wyszukiwania liniowego musimy patrzeć na każdego elementu

693
00:41:45,710 --> 00:41:50,180
aż dojdziemy do ostatniej, aby wiedzieć, że to rzeczywiście się na liście.

694
00:41:50,180 --> 00:41:52,910
Nie możemy po prostu zrezygnować w połowie drogi i powiedzieć: "To chyba nie tam."

695
00:41:52,910 --> 00:41:55,980
Z liniowym poszukiwaniu musimy spojrzeć na całą sprawę.

696
00:41:55,980 --> 00:41:59,090
Najlepiej przypadku czasu pracy, z drugiej strony, jest stała

697
00:41:59,090 --> 00:42:04,200
bo w najlepszym przypadku element szukamy jest tylko pierwszy z listy.

698
00:42:04,200 --> 00:42:08,930
Więc to zajmie nam dokładnie 1 krok, nie ważne jak duża lista jest

699
00:42:08,930 --> 00:42:12,140
jeśli patrzymy na każdym pierwszym elementem.

700
00:42:12,140 --> 00:42:15,390
>> Więc kiedy szukać, pamiętaj, że nie oznacza to, że nasza lista jest sortowana.

701
00:42:15,390 --> 00:42:19,430
Bo my po prostu będziemy patrzeć na każdego elementu, a to naprawdę nie ma znaczenia

702
00:42:19,430 --> 00:42:23,560
jakiej kolejności te elementy są w.

703
00:42:23,560 --> 00:42:28,110
Bardziej inteligentny algorytm wyszukiwania jest coś takiego jak wyszukiwanie binarne.

704
00:42:28,110 --> 00:42:31,500
Pamiętaj, że realizacja wyszukiwania binarnego jest kiedy masz zamiar

705
00:42:31,500 --> 00:42:34,320
Patrz na środku listy.

706
00:42:34,320 --> 00:42:38,000
A ponieważ szukamy w środku, wymagamy, że lista jest sortowana

707
00:42:38,000 --> 00:42:40,580
albo nie wiemy, gdzie jest środek, a my mamy patrzeć na

708
00:42:40,580 --> 00:42:44,480
Cała lista go znaleźć, a następnie w tym punkcie jesteśmy po prostu marnowanie czasu.

709
00:42:44,480 --> 00:42:48,480
Więc jeśli mamy posortowaną listę i znaleźć środek, będziemy porównywać środku

710
00:42:48,480 --> 00:42:51,590
do elementu szukamy.

711
00:42:51,590 --> 00:42:54,640
Jeśli jest zbyt wysoki, to możemy zapomnieć prawą połowę

712
00:42:54,640 --> 00:42:57,810
ponieważ wiemy, że jeśli nasz element jest już zbyt wysoka

713
00:42:57,810 --> 00:43:01,080
i wszystko, co na prawo od tego elementu jest jeszcze wyższa,

714
00:43:01,080 --> 00:43:02,760
wtedy nie trzeba szukać już tam.

715
00:43:02,760 --> 00:43:05,430
W przypadku, gdy z drugiej strony, jeżeli nasz elementem jest zbyt niska,

716
00:43:05,430 --> 00:43:08,700
Wiemy wszystko w lewo tego elementu jest zbyt niska,

717
00:43:08,700 --> 00:43:11,390
więc nie ma sensu szukać tam, albo.

718
00:43:11,390 --> 00:43:15,760
W ten sposób, przy każdym kroku i za każdym razem patrzymy na w połowie listy,

719
00:43:15,760 --> 00:43:19,060
będziemy ciąć nasz problem w pół bo nagle wiemy

720
00:43:19,060 --> 00:43:23,040
cała masa liczb, które nie mogą być jeden szukamy.

721
00:43:23,040 --> 00:43:26,950
>> W Pseudokod byłoby to wyglądać tak,

722
00:43:26,950 --> 00:43:30,990
i dlatego mamy cięcia listę w pół przy każdym pojedynczym,

723
00:43:30,990 --> 00:43:34,920
naszych najgorszych skoków czasie wykonywania z liniowej na logarytmiczną.

724
00:43:34,920 --> 00:43:39,260
Więc nagle mamy logowania kroków w celu znalezienia elementu w liście.

725
00:43:39,260 --> 00:43:42,460
Best-case Czas ucieka, choć wciąż jest stała

726
00:43:42,460 --> 00:43:45,180
ponieważ teraz, po prostu powiedzieć, że element szukamy jest

727
00:43:45,180 --> 00:43:48,380
zawsze dokładnie połowy pierwotnej liście.

728
00:43:48,380 --> 00:43:52,080
Więc możemy rozwijać naszą listę tak duża, jak chcemy, ale jeśli element szukamy jest w środku,

729
00:43:52,080 --> 00:43:54,910
potem to tylko zajmie nam 1 krok.

730
00:43:54,910 --> 00:44:00,920
To dlatego, że jesteśmy O (log n) i Ω (1) lub stała.

731
00:44:00,920 --> 00:44:04,510
Miejmy faktycznie uruchomić wyszukiwanie binarne na tej liście.

732
00:44:04,510 --> 00:44:08,020
Więc powiedzmy, że szukamy elementu 164.

733
00:44:08,020 --> 00:44:11,650
Pierwszą rzeczą, jaką chcemy zrobić, to znaleźć punkt środkowy tej listy.

734
00:44:11,650 --> 00:44:15,060
Tak się składa, że ​​punkt środkowy będzie spadać między tymi 2 liczb

735
00:44:15,060 --> 00:44:18,960
więc po prostu arbitralnie powiedzieć, za każdym razem punkt środkowy przypada między 2 liczb

736
00:44:18,960 --> 00:44:21,150
niech po prostu zaokrąglić w górę.

737
00:44:21,150 --> 00:44:24,330
Musimy tylko się upewnić, możemy to zrobić na każdym kroku sposób.

738
00:44:24,330 --> 00:44:29,040
Więc idziemy do zaokrąglenia w górę, a my zamierzamy mówić, że 161 jest w środku naszej liście.

739
00:44:29,040 --> 00:44:34,640
Tak 161 <164, a każdy z elementów 161 lewej

740
00:44:34,640 --> 00:44:39,120
jest <164, więc wiemy, że to nie pomoże nam w ogóle

741
00:44:39,120 --> 00:44:42,690
zacząć szukać tutaj, ponieważ element szukamy, nie może tam być.

742
00:44:42,690 --> 00:44:47,060
Więc co możemy zrobić, to możemy zapomnieć o tym całym pół lewym listy

743
00:44:47,060 --> 00:44:51,700
i teraz pod uwagę tylko z prawej strony 161 wzwyż.

744
00:44:51,700 --> 00:44:54,050
>> Więc jeszcze raz, to jest punkt środkowy, niech po prostu zaokrąglić w górę.

745
00:44:54,050 --> 00:44:56,260
Teraz 175 jest zbyt duża.

746
00:44:56,260 --> 00:44:59,180
Więc wiemy, to nie pomoże nam szukają tutaj lub tutaj,

747
00:44:59,180 --> 00:45:06,610
więc możemy po prostu wyrzucić, że daleko, a ostatecznie będziemy hit 164.

748
00:45:06,610 --> 00:45:10,560
Wszelkie pytania dotyczące binarnego wyszukiwania?

749
00:45:10,560 --> 00:45:14,180
Przejdźmy od poszukiwania przez już posortowanej listy

750
00:45:14,180 --> 00:45:17,660
faktycznie biorąc listę numerów w dowolnej kolejności

751
00:45:17,660 --> 00:45:20,960
i uczynienie tej listy w kolejności rosnącej.

752
00:45:20,960 --> 00:45:24,060
Pierwszy algorytm przyjrzeliśmy nazwano sortowanie bąbelkowe.

753
00:45:24,060 --> 00:45:27,300
I to byłoby prostsze z algorytmów, które widzieliśmy.

754
00:45:27,300 --> 00:45:32,970
Sortowanie bąbelkowe mówi, że kiedy jakieś 2 elementy wewnątrz liście są nie na miejscu,

755
00:45:32,970 --> 00:45:36,500
co oznacza, że ​​jest większa liczba z lewej mniejszej ilości,

756
00:45:36,500 --> 00:45:40,190
Następnie idziemy, aby zamienić je, ponieważ to oznacza, że ​​lista będzie

757
00:45:40,190 --> 00:45:42,860
Bardziej "posortowane", niż to było wcześniej.

758
00:45:42,860 --> 00:45:45,180
A my po prostu będziemy kontynuować ten proces jeszcze raz i jeszcze raz i jeszcze raz

759
00:45:45,180 --> 00:45:52,100
aż w końcu rodzaju elementy z bańki do ich właściwej lokalizacji i mamy posortowaną listę.

760
00:45:52,100 --> 00:45:57,230
>> Czas pracy to będzie O (n ²). Dlaczego?

761
00:45:57,230 --> 00:46:00,370
Ano dlatego, że w najgorszym przypadku, mamy zamiar wziąć każdy element, a

762
00:46:00,370 --> 00:46:04,570
będziemy do końca się porównując ją do każdego innego elementu na liście.

763
00:46:04,570 --> 00:46:08,030
Ale w najlepszym przypadku, mamy już posortowana lista, bańka sort'S

764
00:46:08,030 --> 00:46:12,230
po prostu się przejść raz, mówią: "Nie. Nie robiłem żadnych swapów, więc mam zrobić".

765
00:46:12,230 --> 00:46:17,410
Mamy więc najlepszym razie czas pracy Ω (n).

766
00:46:17,410 --> 00:46:20,680
Uciekajmy sortowania bąbelkowego na liście.

767
00:46:20,680 --> 00:46:23,560
Lub najpierw, po prostu spojrzeć na niektóre Pseudokod naprawdę szybko.

768
00:46:23,560 --> 00:46:28,160
Chcemy powiedzieć, że chcą, aby śledzić, w każdej iteracji pętli,

769
00:46:28,160 --> 00:46:32,190
śledzić czy nie zmienialiśmy żadnych elementów.

770
00:46:32,190 --> 00:46:37,610
Tak więc powodem jest, jedziemy do zatrzymania, gdy nie zamieniły się żadnych elementów.

771
00:46:37,610 --> 00:46:41,980
Tak więc na początku naszej pętli nie zamieniłem nic, więc możemy powiedzieć, że jest fałszywe.

772
00:46:41,980 --> 00:46:47,170
Teraz mamy zamiar przejść przez listę i porównaj element i do elementu i + 1

773
00:46:47,170 --> 00:46:50,310
i, jeśli jest to tak, że nie jest większa liczba z lewej mniejszej ilości,

774
00:46:50,310 --> 00:46:52,310
to mamy po prostu się do zamiany.

775
00:46:52,310 --> 00:46:54,490
>> I wtedy będziemy pamiętać, że zamieniłem element.

776
00:46:54,490 --> 00:46:58,900
To oznacza, że ​​musimy przejść przez listę co najmniej 1 więcej czasu

777
00:46:58,900 --> 00:47:02,160
bo stan, w którym zatrzymaliśmy się, kiedy cała lista jest już posortowane,

778
00:47:02,160 --> 00:47:04,890
co oznacza, że ​​nie dokonano żadnych swapów.

779
00:47:04,890 --> 00:47:09,960
To dlatego nasz stan tu jest "niektóre elementy zostały zamienione.

780
00:47:09,960 --> 00:47:13,720
Więc teraz niech tylko spojrzeć na to uruchomiony na liście.

781
00:47:13,720 --> 00:47:16,640
Mam listę 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Sortowanie bąbelkowe ruszy całą drogę w lewo, a to będzie porównać

783
00:47:19,850 --> 00:47:24,700
elementy I, tak, i od 0 do 1 +, który jest elementem 1.

784
00:47:24,700 --> 00:47:29,020
To się znaczy, oraz 5> 0, ale teraz 5 jest po lewej stronie,

785
00:47:29,020 --> 00:47:32,500
więc trzeba zamienić 5 i 0.

786
00:47:32,500 --> 00:47:35,470
Kiedy zamienić je, nagle pojawia się ten inną listę.

787
00:47:35,470 --> 00:47:38,260
Teraz 5> 1, więc mamy zamiar zamienić je.

788
00:47:38,260 --> 00:47:42,160
5 nie jest> 6, więc nie musimy nic robić tutaj.

789
00:47:42,160 --> 00:47:46,690
Ale 6> 4, więc musimy zamienić.

790
00:47:46,690 --> 00:47:49,740
Znowu trzeba uruchomić całą listę, aby w końcu odkryć,

791
00:47:49,740 --> 00:47:52,330
że są one w porządku, my je zamieniać,

792
00:47:52,330 --> 00:47:57,120
iw tym momencie musimy uruchomić listę 1 więcej czasu

793
00:47:57,120 --> 00:48:05,390
się upewnić, że wszystko jest w porządku, i na tym etapie sortowania bąbelkowego zakończeniu.

794
00:48:05,390 --> 00:48:10,720
Inny algorytm do podjęcia pewnych elementów i sortowanie ich jest swego wyboru.

795
00:48:10,720 --> 00:48:15,740
Ideą rodzaju selekcji jest, że będziemy budować posortowaną część listy

796
00:48:15,740 --> 00:48:18,150
1 element w tym samym czasie.

797
00:48:18,150 --> 00:48:23,170
>> A sposób, w jaki zamierzamy zrobić to poprzez budowanie lewy segment listy.

798
00:48:23,170 --> 00:48:27,510
I w zasadzie każdy - na każdym kroku, będziemy mieć najmniejszy element zostawiliśmy

799
00:48:27,510 --> 00:48:32,310
, które nie zostały posortowane jeszcze, i mamy zamiar przenieść go do tego sortowanie segmencie.

800
00:48:32,310 --> 00:48:35,850
To oznacza, że ​​musimy stale znaleźć minimalną niesortowanych elementu

801
00:48:35,850 --> 00:48:40,720
a następnie podjąć ten najmniejszy element i zamienić go z tym, co

802
00:48:40,720 --> 00:48:45,090
lewej najbardziej elementem, który nie jest posortowana.

803
00:48:45,090 --> 00:48:50,890
Czas pracy to będzie O (n ²), ponieważ w najgorszym przypadku

804
00:48:50,890 --> 00:48:55,070
musimy porównać każdy element do każdego innego elementu.

805
00:48:55,070 --> 00:48:59,250
Bo mówisz, że jeśli zaczniemy w lewej części listy, musimy

806
00:48:59,250 --> 00:49:02,970
przejść przez cały segment słusznie najmniejszy element.

807
00:49:02,970 --> 00:49:05,430
A potem jeszcze raz, musimy przejść przez całą prawą segment i

808
00:49:05,430 --> 00:49:08,210
wracamy się, że w kółko i od nowa.

809
00:49:08,210 --> 00:49:11,350
To będzie ² n. Będziemy potrzebować do wewnątrz pętli innego dla pętli

810
00:49:11,350 --> 00:49:13,350
co sugeruje ² n.

811
00:49:13,350 --> 00:49:16,530
W najlepszym przypadku, myśli, powiedzmy, że daje mu już posortowaną listę;

812
00:49:16,530 --> 00:49:19,270
tak naprawdę nie robi nic lepszego niż ² n.

813
00:49:19,270 --> 00:49:21,730
Ponieważ rodzaj wyboru nie ma możliwości, wiedząc, że

814
00:49:21,730 --> 00:49:25,540
Minimalny element jest tylko jeden I zdarzyć się patrzy.

815
00:49:25,540 --> 00:49:28,970
Nadal musi się upewnić, że to rzeczywiście minimum.

816
00:49:28,970 --> 00:49:31,670
>> I jedynym sposobem, aby upewnić się, że jest to minimum, za pomocą tego algorytmu,

817
00:49:31,670 --> 00:49:34,640
jest spojrzenie na każdego elementu ponownie.

818
00:49:34,640 --> 00:49:38,420
Tak naprawdę, jeśli dać to - jeśli dać selekcji Sortuj tak już posortowanej listy,

819
00:49:38,420 --> 00:49:42,720
nie zrobi lepiej niż dając mu listę, która nie jest jeszcze posortowana.

820
00:49:42,720 --> 00:49:46,320
Przy okazji, jeśli zdarza się tak, że coś jest O (coś)

821
00:49:46,320 --> 00:49:50,640
i omega czegoś, możemy tylko powiedzieć, bardziej zwięźle, że to θ czegoś.

822
00:49:50,640 --> 00:49:52,760
Więc jeśli widzisz, że pojawią się wszędzie, że to, co po prostu oznacza, że.

823
00:49:52,760 --> 00:49:57,580
>> Jeśli coś jest theta n ², jest to zarówno duże O (n ²) i Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Więc najlepszym przypadku i najgorszym wypadku, to nie ma znaczenia,

825
00:49:59,790 --> 00:50:04,400
Algorytm ma zamiar zrobić to samo za każdym razem.

826
00:50:04,400 --> 00:50:06,610
Więc to jest to, co do rodzaju karnetu Pseudokod mogłoby wyglądać.

827
00:50:06,610 --> 00:50:10,630
Jesteśmy w zasadzie powiedzieć, że chcę iteracyjne nad listy

828
00:50:10,630 --> 00:50:15,180
od lewej do prawej strony, a na każdej iteracji pętli, mam zamiar przenieść

829
00:50:15,180 --> 00:50:19,780
Minimalny element w tym sortowanie części listy.

830
00:50:19,780 --> 00:50:23,260
I raz przenieść coś tam, nigdy nie trzeba spojrzeć na ten element ponownie.

831
00:50:23,260 --> 00:50:28,600
Ponieważ, jak tylko element wymiany w segmencie do lewej na liście, to posortowane

832
00:50:28,600 --> 00:50:32,600
dlatego robimy wszystko co w kolejności rosnącej przy użyciu minimum.

833
00:50:32,600 --> 00:50:38,740
Więc powiedział, dobrze, jesteśmy na pozycji I i musimy patrzeć na wszystkie elementy

834
00:50:38,740 --> 00:50:42,260
z prawej I w celu znalezienia minimum.

835
00:50:42,260 --> 00:50:46,150
To znaczy, że chcemy wygląda z i + 1 do końca listy.

836
00:50:46,150 --> 00:50:51,610
A teraz, jeśli element, który mamy obecnie, patrząc na mniej niż nasze minimum tak daleko,

837
00:50:51,610 --> 00:50:54,190
które, pamiętaj, zaczynamy off minimalną po prostu być

838
00:50:54,190 --> 00:50:57,020
cokolwiek elementem jesteśmy obecnie na, będę zakładać, że to minimum.

839
00:50:57,020 --> 00:51:00,270
Jeśli znaleźć element, który jest mniejszy niż, to ja powiem, dobrze,

840
00:51:00,270 --> 00:51:02,700
dobrze, znalazłem nowe minimum.

841
00:51:02,700 --> 00:51:06,080
Będę pamiętam gdzie, że minimum było.

842
00:51:06,080 --> 00:51:09,560
>> Więc teraz, kiedy już przeszła przez to prawo segmencie niesegregowanych,

843
00:51:09,560 --> 00:51:16,690
Mogę powiedzieć, że zamierzam zamienić najmniejszy element z elementem, który jest w pozycji I.

844
00:51:16,690 --> 00:51:21,100
To zbuduje mój list, moja posortowane część listy od lewej do prawej,

845
00:51:21,100 --> 00:51:25,190
i nie zawsze trzeba spojrzeć na element kolejny raz, że to w tej części.

846
00:51:25,190 --> 00:51:27,930
Kiedy już zamieniłem go.

847
00:51:27,930 --> 00:51:30,260
Więc uruchom rodzaju selekcja na tej liście.

848
00:51:30,260 --> 00:51:38,220
Niebieski elementem tu będzie i, a czerwony element będzie minimalny element.

849
00:51:38,220 --> 00:51:41,570
Więc rozpoczyna się aż na lewej liście, więc w 5.

850
00:51:41,570 --> 00:51:44,610
Teraz musimy znaleźć minimalną niesortowanych element.

851
00:51:44,610 --> 00:51:49,480
Tak więc możemy powiedzieć, 0 <5, więc 0 jest moim nowym minimum.

852
00:51:49,480 --> 00:51:53,820
>> Ale nie mogę się tam zatrzymać, bo choć możemy uznać, że 0 jest najmniejszy,

853
00:51:53,820 --> 00:51:59,390
musimy przechodzić przez każdego innego elementu na liście, aby się upewnić.

854
00:51:59,390 --> 00:52:01,760
Tak więc 1 jest większa, 6 jest większy, 4 jest większy.

855
00:52:01,760 --> 00:52:05,850
To oznacza, że ​​po obejrzeniu tych wszystkich elementów, jakie określono 0 jest najmniejszy.

856
00:52:05,850 --> 00:52:09,800
Więc mam zamiar zamienić 5 i 0.

857
00:52:09,800 --> 00:52:15,480
Kiedyś zamienić, że mam zamiar dostać nową listę, i wiem, że nigdy nie trzeba szukać w tym 0 raz

858
00:52:15,480 --> 00:52:19,380
bo raz ja zamieniłem go, mam go i posortowane skończymy.

859
00:52:19,380 --> 00:52:22,730
Teraz to po prostu tak się dzieje, że niebieski element jest ponownie 5,

860
00:52:22,730 --> 00:52:26,030
i musimy spojrzeć na 1, 6 i 4 w celu określenia, że ​​1

861
00:52:26,030 --> 00:52:31,520
jest najmniejszy element minimalny, więc będziemy zamieniać 1 i 5.

862
00:52:31,520 --> 00:52:36,890
Ponownie, musimy patrzeć - porównanie 5 do 6 i 4,

863
00:52:36,890 --> 00:52:39,830
i jedziemy do wymiany 4 i 5, a na końcu, porównaj

864
00:52:39,830 --> 00:52:45,740
te 2 numery i zamienić je aż dostajemy naszą posortowaną listę.

865
00:52:45,740 --> 00:52:49,730
Wszelkie pytania dotyczące rodzaju selekcji?

866
00:52:49,730 --> 00:52:56,420
Okay. Przejdźmy do ostatniego tematu tutaj, i to jest rekurencja.

867
00:52:56,420 --> 00:52:59,810
>> Rekurencja, pamiętaj, jest to naprawdę rzecz meta gdzie funkcja

868
00:52:59,810 --> 00:53:02,740
wielokrotnie nazywa siebie.

869
00:53:02,740 --> 00:53:05,620
W pewnym momencie, podczas gdy nasz fuction jest wielokrotnie nazywając siebie,

870
00:53:05,620 --> 00:53:10,100
tam musi być jakiś punkt, w którym nie nazywać siebie.

871
00:53:10,100 --> 00:53:13,670
Bo jeśli tego nie robią, to jesteśmy po prostu będzie nadal robić to zawsze,

872
00:53:13,670 --> 00:53:16,660
a nasz program nie jest po prostu się kończy.

873
00:53:16,660 --> 00:53:19,200
Nazywamy ten stan bazowym.

874
00:53:19,200 --> 00:53:22,570
I bazowym mówi, niż wywołanie funkcji ponownie,

875
00:53:22,570 --> 00:53:25,330
Mam zamiar wrócić jakąś wartość.

876
00:53:25,330 --> 00:53:28,080
Więc raz wróciliśmy wartość, wstrzymaliśmy nazywając siebie,

877
00:53:28,080 --> 00:53:32,550
i reszta połączeń zrobiliśmy do tej pory może powrócić.

878
00:53:32,550 --> 00:53:36,050
Przeciwieństwem do przypadku bazowego jest recursive przypadek.

879
00:53:36,050 --> 00:53:39,050
I to jest, gdy chcemy dokonać innego wywołanie funkcji, że jesteśmy obecnie w.

880
00:53:39,050 --> 00:53:44,690
I prawdopodobnie, choć nie zawsze, chcesz używać różnych argumentów.

881
00:53:44,690 --> 00:53:48,940
>> Więc jeśli mamy funkcję o nazwie f, f nazywany po prostu wziąć 1 argument,

882
00:53:48,940 --> 00:53:52,010
i po prostu zachować wywołanie f (1), f (1), f (1), a tak się składa, że

883
00:53:52,010 --> 00:53:56,510
Argument 1 wpada rekurencyjnego przypadku mamy jeszcze nigdy nie powstrzyma.

884
00:53:56,510 --> 00:54:01,620
Nawet jeśli mamy przypadek bazowy, musimy upewnić się, że w końcu będziemy hit tej sprawy podstawowej.

885
00:54:01,620 --> 00:54:04,250
My nie tylko zachować pobyt w tej cyklicznej przypadku.

886
00:54:04,250 --> 00:54:09,870
Generalnie, gdy nazywamy samych siebie, prawdopodobnie będziesz mieć inny argumentem za każdym razem.

887
00:54:09,870 --> 00:54:12,700
Tutaj jest naprawdę prosta funkcja rekurencyjna.

888
00:54:12,700 --> 00:54:15,090
Więc to będzie obliczyć silnię liczby.

889
00:54:15,090 --> 00:54:17,790
Do góry tutaj mamy przypadek bazowy.

890
00:54:17,790 --> 00:54:22,330
W przypadku, gdy n ≤ 1, to nie zamierzasz zadzwonić silnia ponownie.

891
00:54:22,330 --> 00:54:26,490
Mamy zamiar się zatrzymać, jesteśmy po prostu powróci jakąś wartość.

892
00:54:26,490 --> 00:54:30,170
Jeśli nie jest to prawdą, to mamy zamiar uderzyć naszą rekurencyjną sprawę.

893
00:54:30,170 --> 00:54:33,550
Zauważcie, że nie jesteśmy po prostu wywołanie silnia (n), ponieważ nie byłoby to bardzo pomocne.

894
00:54:33,550 --> 00:54:36,810
Będziemy dzwonić silni coś innego.

895
00:54:36,810 --> 00:54:40,850
>> A więc widać, w końcu jeśli mijamy czynnikowego (5) lub coś,

896
00:54:40,850 --> 00:54:45,900
mamy zamiar zadzwonić silnia (4) i tak dalej, aż w końcu będziemy uderzać ten przypadek bazowy.

897
00:54:45,900 --> 00:54:51,730
Tak to wygląda. Zobaczmy, co się dzieje, gdy faktycznie uruchomić to.

898
00:54:51,730 --> 00:54:57,840
To jest komin, a powiedzmy, że główny będzie wywołać tę funkcję z argumentem (4).

899
00:54:57,840 --> 00:55:02,200
Więc raz silni widzi i = 4, silni wywoła się.

900
00:55:02,200 --> 00:55:05,010
Teraz, nagle, mamy silnia (3).

901
00:55:05,010 --> 00:55:10,780
Więc te funkcje będą stale rosnąć, aż w końcu trafiliśmy naszą sprawę bazowej.

902
00:55:10,780 --> 00:55:17,830
W tym momencie, wartość zwracana jest to zwrot (nx Wartość zwracana to),

903
00:55:17,830 --> 00:55:21,290
Wartość zwracana jest nx Wartość zwracana to.

904
00:55:21,290 --> 00:55:23,290
W końcu muszą trafić jakąś liczbę.

905
00:55:23,290 --> 00:55:26,560
Na górze tutaj mówimy, powrót 1.

906
00:55:26,560 --> 00:55:30,650
To oznacza, że ​​kiedy powróci ten numer, możemy wyskoczyć to ze stosu.

907
00:55:30,650 --> 00:55:36,570
Więc to silnia (1) jest wykonywana.

908
00:55:36,570 --> 00:55:41,190
Kiedy 1 wraca, to silni (1) zwroty, to powrót do 1.

909
00:55:41,190 --> 00:55:46,910
Wartość zwracana to, pamiętaj, to nx Wartość zwracana to.

910
00:55:46,910 --> 00:55:50,720
Tak nagle, ten facet wie, że chcę wrócić 2.

911
00:55:50,720 --> 00:55:55,910
>> Więc pamiętaj, powrót wartość to tylko nx Wartość zwracana tutaj.

912
00:55:55,910 --> 00:56:01,160
Więc teraz możemy powiedzieć, 3 x 2, a na końcu, tutaj możemy powiedzieć

913
00:56:01,160 --> 00:56:04,010
jest to po prostu będzie to 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
A kiedy to zwraca, ale dostać się do jednego środka całkowitą od main.

915
00:56:09,570 --> 00:56:15,460
Wszelkie pytania dotyczące rekursji?

916
00:56:15,460 --> 00:56:17,090
Dobrze. Więc jest więcej czasu na pytania na końcu,

917
00:56:17,090 --> 00:56:23,360
ale teraz Joseph obejmie pozostałe tematy.

918
00:56:23,360 --> 00:56:25,590
>> [Józef Ong] Dobrze. Więc teraz, że rozmawialiśmy o rekursji,

919
00:56:25,590 --> 00:56:27,840
Porozmawiajmy trochę o tym, co scalania sortowania jest.

920
00:56:27,840 --> 00:56:31,740
Merge sort jest zasadniczo inny sposób sortowania listy numerów.

921
00:56:31,740 --> 00:56:36,430
I jak działa to z rodzaju łączenia masz listę i co możemy zrobić, to

922
00:56:36,430 --> 00:56:39,120
możemy powiedzieć, niech podzielić to na 2 połówki.

923
00:56:39,120 --> 00:56:42,750
Będziemy pierwszym uruchomieniu seryjnej sortowanie znowu na lewej połowie

924
00:56:42,750 --> 00:56:45,040
wtedy możemy uruchomić seryjnej sortowanie na prawej połowie,

925
00:56:45,040 --> 00:56:50,240
i to daje nam teraz 2 połówki, które są sortowane, a teraz mamy zamiar połączyć te połówki.

926
00:56:50,240 --> 00:56:55,010
Jest to trochę trudne do zobaczenia, bez przykładu, więc pojedziemy przez ruchy i zobaczyć, co się dzieje.

927
00:56:55,010 --> 00:56:59,590
Więc gdy z tej listy, możemy podzielić go na 2 części.

928
00:56:59,590 --> 00:57:02,300
Prowadzimy seryjnej sortowania na lewej połowie pierwszego.

929
00:57:02,300 --> 00:57:06,660
Więc to jest lewa połowa, a teraz je uruchomić po tej liście ponownie

930
00:57:06,660 --> 00:57:09,800
, które zostanie przekazane do sortowania korespondencji seryjnej, a następnie szukać ponownie,

931
00:57:09,800 --> 00:57:13,270
po lewej stronie tej listy i prowadzimy seryjnej sortowanie na nim.

932
00:57:13,270 --> 00:57:15,880
Teraz możemy zabrać się do listy 2 liczb

933
00:57:15,880 --> 00:57:19,010
i obecnie jest tylko lewa część 1 elementu, i nie może być

934
00:57:19,010 --> 00:57:23,380
podzielić listę, która znajduje się tylko 1 element na pół, więc po prostu powiedzieć, kiedy będziemy mieli 50,

935
00:57:23,380 --> 00:57:26,400
która jest tylko 1 element, to już załatwione.

936
00:57:26,400 --> 00:57:29,860
>> Gdy skończymy z tym, widzimy, że możemy

937
00:57:29,860 --> 00:57:32,230
przenieść się do prawej części tej listy,

938
00:57:32,230 --> 00:57:36,480
i 3 jest również posortowane i tak się, że obie połówki są posortowane liście

939
00:57:36,480 --> 00:57:39,080
możemy połączyć te numery z powrotem.

940
00:57:39,080 --> 00:57:45,320
Tak to wygląda w 50 i 3, 3 jest mniejsza niż 50, to jest w tak, a potem 50 wkracza

941
00:57:45,320 --> 00:57:49,340
Teraz to się robi, wracamy do tej listy i sortowania jest zaraz pół.

942
00:57:49,340 --> 00:57:52,440
42 jest jego własny numer, więc to już posortowane.

943
00:57:52,440 --> 00:57:57,850
Tak teraz porównanie tych 2 i 3 jest mniejsza niż 42, tak, że zostaje wprowadzone w pierwsze

944
00:57:57,850 --> 00:58:02,340
teraz 42 zostanie wprowadzone, a 50 dostaje wtrącił

945
00:58:02,340 --> 00:58:07,220
Teraz, to jest posortowana, jedziemy z powrotem do góry, 1337 i 15.

946
00:58:07,220 --> 00:58:14,560
Cóż, teraz spójrz na lewej połowie tej listy; 1337 jest sama więc jest sortowane i samo z 15.

947
00:58:14,560 --> 00:58:19,020
Więc teraz połączyć te 2 numery do sortowania, który oryginalną listę, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
tak to jest w pierwszym, a następnie 1337 idzie w.

949
00:58:23,060 --> 00:58:26,640
A teraz mamy posortowane obie połówki oryginalnej listy na górze.

950
00:58:26,640 --> 00:58:30,440
A wszystko, co musimy zrobić, to połączyć te.

951
00:58:30,440 --> 00:58:36,890
Patrzymy na pierwsze 2 numery na liście, 3 <15, więc idzie do tablicy sortowania pierwszy.

952
00:58:36,890 --> 00:58:44,460
15 <42 tak dalej w. Teraz, 42 <1337, które przechodzi w.

953
00:58:44,460 --> 00:58:51,010
50 <1337, więc to idzie w. I zauważyć, że po prostu wziął 2 numerów off z tej listy.

954
00:58:51,010 --> 00:58:53,640
Więc nie tylko przemian między 2 list.

955
00:58:53,640 --> 00:58:56,050
Po prostu patrząc na początku, i bierzemy element

956
00:58:56,050 --> 00:59:00,270
który jest mniejszy, a następnie wprowadzenie go do naszej tablicy.

957
00:59:00,270 --> 00:59:04,080
Teraz mamy połączone wszystkie połówki i skończymy.

958
00:59:04,080 --> 00:59:07,780
>> Wszelkie pytania dotyczące scalania sortowania? Tak?

959
00:59:07,780 --> 00:59:14,190
[Student] Jeśli jest podział na różne grupy, dlaczego nie po prostu podzielić go raz

960
00:59:14,190 --> 00:59:19,970
i masz 3 i 2 w grupie? [Reszta niezrozumiały Pytanie]

961
00:59:19,970 --> 00:59:24,940
Powód - więc pytanie, dlaczego po prostu nie możemy połączyć je w tym pierwszym etapie, po je mamy?

962
00:59:24,940 --> 00:59:29,530
Powodem możemy to zrobić, należy uruchomić w lewym większości elementów po obu stronach,

963
00:59:29,530 --> 00:59:33,040
a następnie podjąć mniejszy i umieścić go w to, że wiemy, że te

964
00:59:33,040 --> 00:59:35,290
Poszczególne listy są posortowane zamówień.

965
00:59:35,290 --> 00:59:37,290
Więc jeśli ja patrząc na lewo większości elementów obu połówek,

966
00:59:37,290 --> 00:59:40,490
Wiem, że masz zamiar być najmniejsze elementy tych list.

967
00:59:40,490 --> 00:59:43,930
Więc mogę umieścić je w najmniejszych plam elementem tej dużej listy.

968
00:59:43,930 --> 00:59:47,810
Z drugiej strony, jeżeli patrzeć na tych 2 wymienia się na drugim poziomie Tam

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 i 15, te, które nie są posortowane.

970
00:59:51,640 --> 00:59:55,770
Więc jeśli spojrzeć na 50 i 1337, mam zamiar postawić 50 na mojej liście w pierwszej kolejności.

971
00:59:55,770 --> 01:00:00,130
Ale to naprawdę nie ma sensu, bo 3 jest najmniejszy element z wszystkich tych.

972
01:00:00,130 --> 01:00:04,390
Więc tylko dlatego możemy zrobić ten krok, łącząc to dlatego, że nasze listy są już posortowane.

973
01:00:04,390 --> 01:00:07,010
Dlatego musimy schodzić aż do dna

974
01:00:07,010 --> 01:00:09,800
bo gdy mamy tylko jeden numer, wiesz, że jeden numer

975
01:00:09,800 --> 01:00:14,120
samo w sobie jest już posortowana lista.

976
01:00:14,120 --> 01:00:19,360
>> Masz pytanie? No?

977
01:00:19,360 --> 01:00:24,260
Złożoność? Cóż, widać, że na każdym kroku tam numery końcowe,

978
01:00:24,260 --> 01:00:27,590
i możemy podzielić listę w dzienniku pół n razy,

979
01:00:27,590 --> 01:00:31,700
czyli tam, gdzie mamy ten n log x n złożoność.

980
01:00:31,700 --> 01:00:34,940
I zobaczysz najlepsze etui do sortowania korespondencji seryjnej jest n log n, i tak się

981
01:00:34,940 --> 01:00:39,340
, że w najgorszym przypadku, lub Ω tam, jest również n log n.

982
01:00:39,340 --> 01:00:42,480
Coś pamiętać.

983
01:00:42,480 --> 01:00:45,750
Idąc dalej, chodźmy na kilka super podstawowego pliku I / O.

984
01:00:45,750 --> 01:00:48,830
Jeżeli spojrzysz na Scramble, zauważysz, że mieliśmy jakieś systemu

985
01:00:48,830 --> 01:00:51,270
gdzie można zapisać do pliku dziennika, jeśli przeczytać kodu.

986
01:00:51,270 --> 01:00:53,730
Zobaczmy, jak można to zrobić.

987
01:00:53,730 --> 01:00:57,450
Cóż, mamy fprintf, co można myśleć, jak tylko printf,

988
01:00:57,450 --> 01:01:01,720
, ale tylko do pliku drukowania, zamiast, a zatem f na początku.

989
01:01:01,720 --> 01:01:07,570
Ten rodzaj kodu w górę, to co robi jest, jak może widzieliście w Scramble,

990
01:01:07,570 --> 01:01:12,310
przechodzi przez swojego 2-wymiarowej tablicy drukowania z kolejny wiersz, jakie numery są.

991
01:01:12,310 --> 01:01:17,850
W tym przypadku, printf wypisuje do terminala lub to, co nazywamy standardowe wyjście sekcji.

992
01:01:17,850 --> 01:01:22,170
>> A teraz, w tym przypadku, wszystko co musisz zrobić, to wymienić printf z fprintf,

993
01:01:22,170 --> 01:01:26,770
powiedzieć to, co plik, który chcesz wydrukować, i w tym przypadku to po prostu wypisuje ją do tego pliku

994
01:01:26,770 --> 01:01:32,230
zamiast wysyłać go do terminalu.

995
01:01:32,230 --> 01:01:36,500
Cóż, to nasuwa się pytanie: Gdzie możemy dostać tego rodzaju pliku, z, prawda?

996
01:01:36,500 --> 01:01:39,840
Mijaliśmy się zalogować do tego fprintf fuction ale nie mieliśmy pojęcia, skąd się wziął.

997
01:01:39,840 --> 01:01:43,980
Cóż, na początku kodu, co mieliśmy było to kawałek kodu tutaj,

998
01:01:43,980 --> 01:01:48,340
które zasadniczo mówi, że otwarty plik nazywa log.txt.

999
01:01:48,340 --> 01:01:53,220
Co robimy po to musimy się upewnić, że plik jest otwarty pomyślnie.

1000
01:01:53,220 --> 01:01:57,070
Więc może to nie dla wielu powodów nie masz wystarczająco dużo miejsca na komputerze, na przykład.

1001
01:01:57,070 --> 01:01:59,790
Więc to jest zawsze ważne, przed wykonaniem jakichkolwiek operacji z plikiem

1002
01:01:59,790 --> 01:02:03,300
że możemy sprawdzić, czy plik został otwarty pomyślnie.

1003
01:02:03,300 --> 01:02:09,330
Więc, co to, to jest to argument dla fopen, dobrze, możemy otworzyć plik na wiele sposobów.

1004
01:02:09,330 --> 01:02:13,510
Co możemy zrobić, jest, możemy przekazać go w, co oznacza, zastąpić go, jeśli wychodzi już,

1005
01:02:13,510 --> 01:02:18,070
Można przekazać A, które dołącza się do końca, zamiast pliku nadrzędnego to,

1006
01:02:18,070 --> 01:02:22,730
lub możemy podać r, co oznacza, otwórzmy plik jako tylko do odczytu.

1007
01:02:22,730 --> 01:02:24,890
Jeśli więc program próbuje wprowadzić zmiany w pliku,

1008
01:02:24,890 --> 01:02:30,140
krzyczeć na nich i nie pozwól im tego zrobić.

1009
01:02:30,140 --> 01:02:33,320
Wreszcie, kiedy już skończysz z pliku, done robienia operacji na nim,

1010
01:02:33,320 --> 01:02:35,860
Musimy upewnić się, że zamykamy plik.

1011
01:02:35,860 --> 01:02:38,830
I tak na koniec programu, masz zamiar przekazać je ponownie

1012
01:02:38,830 --> 01:02:42,120
ten plik, który otwiera i po prostu zamknąć.

1013
01:02:42,120 --> 01:02:44,650
Więc to jest coś ważnego, że musisz upewnić się, że tak.

1014
01:02:44,650 --> 01:02:47,180
Więc pamiętaj możesz otworzyć plik, a następnie można zapisać do pliku,

1015
01:02:47,180 --> 01:02:51,270
robić operacji w pliku, ale potem trzeba zamknąć plik na końcu.

1016
01:02:51,270 --> 01:02:53,270
>> Wszelkie pytania dotyczące podstawowego pliku I / O? Tak?

1017
01:02:53,270 --> 01:02:58,050
[Pytanie Student, niezrozumiały]

1018
01:02:58,050 --> 01:03:02,480
Tutaj. Pytanie, skąd to log.txt plik pojawi?

1019
01:03:02,480 --> 01:03:07,890
Cóż, jeśli tylko dać Log.txt, tworzy go w tym samym katalogu co plik wykonywalny.

1020
01:03:07,890 --> 01:03:10,500
Więc jeśli Jeste - >> [Pytanie Student, niezrozumiały]

1021
01:03:10,500 --> 01:03:18,830
Tak. W tym samym folderze, w tym samym katalogu, jak to nazwać.

1022
01:03:18,830 --> 01:03:21,400
Teraz pamięć stosu i sterty.

1023
01:03:21,400 --> 01:03:23,400
Więc jak to jest określone w pamięci komputera?

1024
01:03:23,400 --> 01:03:26,270
Cóż, można sobie wyobrazić jako rodzaj pamięci tego bloku tutaj.

1025
01:03:26,270 --> 01:03:30,260
A w pamięci mamy to, co nazywa się sterty utknął tam i stosu, który jest na dole.

1026
01:03:30,260 --> 01:03:34,480
I rośnie w dół i kupa stos rośnie w górę.

1027
01:03:34,480 --> 01:03:38,620
Więc jak Tommy wspomniał - oh, no i mamy inne 4 segmenty, które dostanę w drugim -

1028
01:03:38,620 --> 01:03:42,890
Jako Tommy powiedział wcześniej, wiesz, jak nazywają się jego funkcje i dzwonić do siebie?

1029
01:03:42,890 --> 01:03:44,930
Budują ten rodzaj stosu ramki.

1030
01:03:44,930 --> 01:03:47,360
Cóż, jeśli główne połączenia foo foo pobiera umieścić na stosie.

1031
01:03:47,360 --> 01:03:52,430
Foo nazywa bar, dostać postawmy na stosie, i że zostanie położony na stosie po.

1032
01:03:52,430 --> 01:03:57,040
A jak wrócą, każdy się zdjąć ze stosu.

1033
01:03:57,040 --> 01:04:00,140
Czego każde z tych miejsc pamięci i trzymać?

1034
01:04:00,140 --> 01:04:03,110
Oraz, u góry, które jest segment tekstu zawiera samego programu.

1035
01:04:03,110 --> 01:04:06,390
Więc kodu maszynowego, to tam, raz skompilować program.

1036
01:04:06,390 --> 01:04:08,520
Następnie każdy zainicjowany zmienne globalne.

1037
01:04:08,520 --> 01:04:12,660
>> Więc masz zmienne globalne w programie, a ty mówisz jak, a = 5,

1038
01:04:12,660 --> 01:04:15,260
który pobiera umieścić w tym segmencie, a tuż pod tym,

1039
01:04:15,260 --> 01:04:18,990
masz niezainicjowane dane globalne, które jest po prostu int,

1040
01:04:18,990 --> 01:04:20,990
ale nie powiedzieć, że jest równa niczym.

1041
01:04:20,990 --> 01:04:23,870
Uświadom sobie, są to zmienne globalne, więc są one poza głównym.

1042
01:04:23,870 --> 01:04:28,560
Więc to oznacza wszelkie zmienne globalne, które są zadeklarowane, ale nie są zainicjowane.

1043
01:04:28,560 --> 01:04:32,310
Więc co jest w kupie? Pamięć przydzielona za pomocą malloc, co dostaniemy w trochę.

1044
01:04:32,310 --> 01:04:35,990
I w końcu, w stosie jakichkolwiek lokalne zmienne

1045
01:04:35,990 --> 01:04:39,950
i wszystkie funkcje można wywołać w każdym z parametrów.

1046
01:04:39,950 --> 01:04:43,720
Ostatnia sprawa, naprawdę nie wiedzieć, co zrobić, zmienne środowiskowe,

1047
01:04:43,720 --> 01:04:46,700
ale przy każdym uruchomieniu programu, jest coś związane, jak

1048
01:04:46,700 --> 01:04:49,550
jest to nazwa osoby, która prowadziła ten program.

1049
01:04:49,550 --> 01:04:51,550
I że będzie rodzaju na dole.

1050
01:04:51,550 --> 01:04:54,540
W zakresie, adresy pamięci, które są szesnastkowy,

1051
01:04:54,540 --> 01:04:58,170
wartościami w górę zaczynają się 0, a oni przejść całą drogę w dół.

1052
01:04:58,170 --> 01:05:00,440
W tym przypadku, jeśli jesteś na systemie 32-bitowym,

1053
01:05:00,440 --> 01:05:05,390
adres na dole będzie 0x, następnie af, bo to 32 bity,

1054
01:05:05,390 --> 01:05:10,890
który jest 8 bajtów, w tym przypadku 8 bajtów odpowiada 8 cyfr szesnastkowych.

1055
01:05:10,890 --> 01:05:20,110
Więc tu masz zamiar mieć jakieś 0xFFFFFF i tam będziesz mieć 0.

1056
01:05:20,110 --> 01:05:23,660
Więc jakie są wskaźniki? Niektórzy z was mogą nie objęły tego w sekcji przed.

1057
01:05:23,660 --> 01:05:26,660
ale poszedł nad nim w wykładzie, więc wskaźnik jest tylko typ danych

1058
01:05:26,660 --> 01:05:34,030
które przechowuje, zamiast jakiejś wartości, jak 50, przechowuje adres jakiegoś miejsca w pamięci.

1059
01:05:34,030 --> 01:05:36,020
Jak tej pamięci [niezrozumiałe].

1060
01:05:36,020 --> 01:05:41,120
Więc w tym przypadku to, co mamy, jest, mamy wskaźnik do liczby całkowitej lub * int,

1061
01:05:41,120 --> 01:05:46,210
i zawiera tę szesnastkowy adres 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Więc co mamy, jest, teraz, ten wskaźnik jest w pewnym miejscu w pamięci,

1063
01:05:50,880 --> 01:05:56,020
i to tylko, wartość 50 jest w tym miejscu pamięci.

1064
01:05:56,020 --> 01:06:01,810
W niektórych systemach 32-bitowych, na wszystkich 32-bitowych systemów, wskaźniki zajmują 32 bitów lub 4 bajtów.

1065
01:06:01,810 --> 01:06:06,020
Ale, na przykład, w systemie 64-bitowym, wskaźniki są 64 bity.

1066
01:06:06,020 --> 01:06:08,040
Więc to coś będziesz chciał pamiętać.

1067
01:06:08,040 --> 01:06:12,310
Więc na koniec-bitowym systemie, wskaźnik jest bity końcowe długo.

1068
01:06:12,310 --> 01:06:17,320
Wskaźniki są rodzajem ciężkostrawne bez dodatkowych rzeczy,

1069
01:06:17,320 --> 01:06:20,300
więc chodźmy na przykładzie dynamicznej alokacji pamięci.

1070
01:06:20,300 --> 01:06:25,130
Co dynamiczny przydział pamięci nie dla Ciebie, lub to, co nazywamy malloc,

1071
01:06:25,130 --> 01:06:29,280
to pozwala przeznaczyć jakąś danych poza zestawu.

1072
01:06:29,280 --> 01:06:31,830
Tak więc tego rodzaju danych jest bardziej trwały w czasie trwania programu.

1073
01:06:31,830 --> 01:06:36,430
Bo jak wiadomo, jeśli deklarują x wewnątrz danej funkcji i że funkcja powraca,

1074
01:06:36,430 --> 01:06:40,910
nie masz już dostępu do danych, które zostały zapisane w x.

1075
01:06:40,910 --> 01:06:44,420
Jakie wskaźniki zróbmy to pozwolili nam przechowywać pamięci lub przechowywania wartości

1076
01:06:44,420 --> 01:06:46,840
w innym segmencie, czyli pamięci sterty.

1077
01:06:46,840 --> 01:06:49,340
Teraz, gdy wracamy z funkcji, tak długo, jak mamy wskaźnik

1078
01:06:49,340 --> 01:06:54,960
do tego miejsca w pamięci, to co możemy zrobić, to możemy tylko patrzeć na wartości tam.

1079
01:06:54,960 --> 01:06:58,020
Spójrzmy na przykład: To jest nasz układ pamięci ponownie.

1080
01:06:58,020 --> 01:07:00,050
I mamy tę funkcję main.

1081
01:07:00,050 --> 01:07:06,870
Co robi jest - w porządku, tak proste, prawda? - Int x = 5, to po prostu zmienna na stosie w main.

1082
01:07:06,870 --> 01:07:12,450
>> Z drugiej strony, teraz zadeklarować wskaźnik, który wzywa do giveMeThreeInts funkcyjnych.

1083
01:07:12,450 --> 01:07:16,800
A więc teraz przejść do tej funkcji i tworzymy nowe ramki stosu dla niego.

1084
01:07:16,800 --> 01:07:20,440
Jednakże, w tym ramki stosu, deklarujemy int * temp,

1085
01:07:20,440 --> 01:07:23,210
które w mallocs 3 liczb dla nas.

1086
01:07:23,210 --> 01:07:25,880
Więc rozmiar int da nam jak wiele bajtów to int jest

1087
01:07:25,880 --> 01:07:29,620
i malloc daje nam, że wiele bajtów miejsca na stercie.

1088
01:07:29,620 --> 01:07:32,890
Więc w tym przypadku, stworzyliśmy wystarczająco dużo miejsca dla 3 liczb całkowitych,

1089
01:07:32,890 --> 01:07:36,830
i kupa jest tam droga, dlatego mam wyciągnąć go wyżej.

1090
01:07:36,830 --> 01:07:42,900
Gdy skończymy, wrócimy tu, trzeba tylko 3 ints wrócił,

1091
01:07:42,900 --> 01:07:47,000
i zwraca adres, w tym przypadku ponad jeżeli jest pamięć.

1092
01:07:47,000 --> 01:07:51,250
I wyznaczamy pointer = przełącznik i tam mamy tylko inny wskaźnik.

1093
01:07:51,250 --> 01:07:54,550
Ale co, że funkcja zwraca jest ułożone tu i znika.

1094
01:07:54,550 --> 01:07:59,250
Tak więc temperatura znika, ale w dalszym ciągu utrzymuje się adres, gdzie

1095
01:07:59,250 --> 01:08:01,850
te 3 liczby całkowite są wewnątrz sieci.

1096
01:08:01,850 --> 01:08:06,180
Tak więc w tym zestawie, to wskaźniki są Buforuj lokalnie na sterach ramce

1097
01:08:06,180 --> 01:08:09,860
lecz pamięć, do której odnoszą się w stos.

1098
01:08:09,860 --> 01:08:12,190
>> Czy to ma sens?

1099
01:08:12,190 --> 01:08:14,960
[Student] Czy mógłbyś powtórzyć? >> [Józef] Tak.

1100
01:08:14,960 --> 01:08:20,270
Więc jeśli wrócę tylko trochę, zobaczysz, że temp przydzielone

1101
01:08:20,270 --> 01:08:23,500
część pamięci na stercie tam.

1102
01:08:23,500 --> 01:08:28,680
Więc kiedy ta funkcja, giveMeThreeInts powróci, ten stos tutaj zniknie.

1103
01:08:28,680 --> 01:08:35,819
I to każdej ze zmiennych, w tym przypadku, to wskaźnik, że ułożone w przeznaczono ramy.

1104
01:08:35,819 --> 01:08:39,649
Że zniknie, ale odkąd wróciliśmy temp.

1105
01:08:39,649 --> 01:08:46,330
i ustawić wskaźnika = temp, wskaźnik jest teraz będzie wskazywać samą pamięć lokalizacji jako temp był.

1106
01:08:46,330 --> 01:08:50,370
Więc teraz, choć tracimy temp, że lokalny wskaźnik,

1107
01:08:50,370 --> 01:08:59,109
nadal zachowuje adres pamięci to, co wskazywał wewnątrz tej zmiennej wskaźnika.

1108
01:08:59,109 --> 01:09:03,740
Pytania? To może być trochę mylące temacie jeśli nie przeszedłby przez to w sekcji.

1109
01:09:03,740 --> 01:09:09,240
Możemy, twój TF pewno tam nad nim i oczywiście możemy odpowiedzieć na pytania

1110
01:09:09,240 --> 01:09:11,500
na końcu sesji przeglądarki do tego.

1111
01:09:11,500 --> 01:09:14,220
Ale to jest coś w rodzaju złożonego tematu, a mam więcej przykładów, które będą wykazywały się

1112
01:09:14,220 --> 01:09:18,790
, które pomogą wyjaśnić co wskaźniki rzeczywistości.

1113
01:09:18,790 --> 01:09:22,500
>> W tym przypadku, są równoważne wskaźniki tablic

1114
01:09:22,500 --> 01:09:25,229
, więc można po prostu użyć tego wskaźnika jako to samo co int tablicy.

1115
01:09:25,229 --> 01:09:29,840
Więc jestem indeksowanie do 0 i zmieniając pierwszą liczbę całkowitą 1,

1116
01:09:29,840 --> 01:09:39,689
zmieniając całkowitą do drugiego 2, i 3. do 3 całkowitą.

1117
01:09:39,689 --> 01:09:44,210
Więc tylko na wskaźniki. Cóż, pamiętam Binky.

1118
01:09:44,210 --> 01:09:48,319
W tym przypadku mamy przydzielone wskaźnik lub zadeklarowaliśmy wskaźnik,

1119
01:09:48,319 --> 01:09:52,760
ale na początku, gdy tylko ogłoszony wskaźnik, to nie wskazując nigdzie w pamięci.

1120
01:09:52,760 --> 01:09:54,930
To tylko wartości śmieci w jej wnętrzu.

1121
01:09:54,930 --> 01:09:56,470
Więc nie mam pojęcia, gdzie to jest wskaźnik wskazujący.

1122
01:09:56,470 --> 01:10:01,630
To ma adres, który jest po prostu wypełniony 0 i 1 jest gdzie początkowo zostało zgłoszone.

1123
01:10:01,630 --> 01:10:04,810
Nie mogę nic zrobić z tym, aż zadzwonię malloc na nim

1124
01:10:04,810 --> 01:10:08,390
a to daje mi trochę miejsca na stercie, gdzie można umieścić wartości środka.

1125
01:10:08,390 --> 01:10:11,980
Potem znowu, nie wiem co jest w środku tej pamięci.

1126
01:10:11,980 --> 01:10:16,780
Więc pierwszą rzeczą, którą musisz zrobić, to sprawdzić, czy system ma wystarczającą ilość pamięci

1127
01:10:16,780 --> 01:10:20,850
dać mi z powrotem 1 całkowitą na pierwszym miejscu, dlatego robię to sprawdzić.

1128
01:10:20,850 --> 01:10:25,020
Jeśli wskaźnik jest null, co oznacza, że ​​nie ma wystarczającej ilości miejsca lub innego błędu,

1129
01:10:25,020 --> 01:10:26,320
więc powinienem wyjść z mojego programu.

1130
01:10:26,320 --> 01:10:29,400
 Ale jeśli to nie udało, teraz mogę użyć tego wskaźnika

1131
01:10:29,400 --> 01:10:35,020
i to, co robi, to wskaźnik * wynika, gdy adres jest

1132
01:10:35,020 --> 01:10:38,480
w przypadku, gdy wartość ta jest, i ustawia się wartość 1.

1133
01:10:38,480 --> 01:10:41,850
Więc tutaj, sprawdzamy, czy ta pamięć istniała.

1134
01:10:41,850 --> 01:10:45,380
>> Gdy wiesz, że istnieje, to można umieścić w nim

1135
01:10:45,380 --> 01:10:50,460
jaką wartość chcesz umieścić w nim, w tym przypadku 1.

1136
01:10:50,460 --> 01:10:53,060
Kiedy skończysz z nim, trzeba uwolnić tego wskaźnika

1137
01:10:53,060 --> 01:10:57,160
ponieważ musimy wrócić do systemu pamięci, że pytasz w pierwszej kolejności.

1138
01:10:57,160 --> 01:10:59,690
Ponieważ komputer nie wie, kiedy mamy z nim zrobić.

1139
01:10:59,690 --> 01:11:02,510
W tym przypadku mamy wyraźnie powiedzieć, ok, skończyliśmy z tym pamięci.

1140
01:11:02,510 --> 01:11:10,780
Jeśli inny proces potrzebuje, jakiś inny program potrzebuje, tutaj śmiało wziąć.

1141
01:11:10,780 --> 01:11:15,110
Co możemy zrobić, to możemy po prostu adres zmiennych lokalnych odbiornika.

1142
01:11:15,110 --> 01:11:19,080
Więc int x jest wewnątrz ułożone ramki głównej.

1143
01:11:19,080 --> 01:11:23,060
I kiedy użyć tego znaku handlowego, to i operator, co robi jest

1144
01:11:23,060 --> 01:11:27,310
trwa x, a x jest tylko niektóre dane w pamięci, ale nie ma adresu.

1145
01:11:27,310 --> 01:11:33,790
Znajduje się gdzieś. Poprzez wywołanie & x, co robi to jest to daje nam adres x.

1146
01:11:33,790 --> 01:11:38,430
W ten sposób robimy punkt wskaźnika, gdzie x jest w pamięci.

1147
01:11:38,430 --> 01:11:41,710
Teraz tylko coś jak * x, mamy zamiar dostać 5 plecy.

1148
01:11:41,710 --> 01:11:43,820
Gwiazda nazywa dereferencji go.

1149
01:11:43,820 --> 01:11:46,640
Możesz śledzić adres i uzyskać wartość z niego tam przechowywane.

1150
01:11:51,000 --> 01:11:53,310
>> Masz pytanie? Tak?

1151
01:11:53,310 --> 01:11:56,500
[Student] Jeśli nie zrobić 3-spiczasty rzeczy, to jeszcze skompilować?

1152
01:11:56,500 --> 01:11:59,490
Tak. Jeśli nie zrobić 3-wskaźnik rzeczy, to jeszcze zamierza skompilować,

1153
01:11:59,490 --> 01:12:02,720
ale pokażę ci, co się dzieje w drugim, a nie robiąc, że

1154
01:12:02,720 --> 01:12:04,860
że to, co nazywamy wyciek pamięci. Nie dajesz systemowi

1155
01:12:04,860 --> 01:12:07,850
kopię swojej pamięci, więc po jakimś czasie program będzie gromadzić

1156
01:12:07,850 --> 01:12:10,940
pamięci, która nie jest pomocą, a nic innego nie może go użyć.

1157
01:12:10,940 --> 01:12:15,750
Jeśli kiedykolwiek widziałeś Firefoksa z 1,5 milionów kilobajtów na komputerze,

1158
01:12:15,750 --> 01:12:17,840
w Menedżerze zadań, to co się dzieje.

1159
01:12:17,840 --> 01:12:20,760
Masz wyciek pamięci w programie, że nie jesteś obsługi.

1160
01:12:23,080 --> 01:12:26,240
Więc w jaki sposób wskaźnik pracy arytmetyka?

1161
01:12:26,240 --> 01:12:29,480
Cóż, arytmetyka wskaźnik jest coś w rodzaju indeksowania do tablicy.

1162
01:12:29,480 --> 01:12:36,370
W tym przypadku, mam wskaźnik, a co mogę zrobić, to zrobię punkt wskaźnik do pierwszego elementu

1163
01:12:36,370 --> 01:12:42,100
tej tablicy 3 liczby całkowite, że już przydzielone.

1164
01:12:42,100 --> 01:12:46,670
Więc co teraz mam zrobić, wskaźnik gwiazda zmienia tylko pierwszy element na liście.

1165
01:12:46,670 --> 01:12:49,140
Gwiazda wskaźnik +1 punktów tutaj.

1166
01:12:49,140 --> 01:12:53,140
Tak wskaźnik jest tutaj, wskaźnik +1 jest tutaj, wskaźnik +2 jest tutaj.

1167
01:12:53,140 --> 01:12:56,610
>> Więc po prostu dodając 1 to samo co poruszanie się tej tablicy.

1168
01:12:56,610 --> 01:12:59,880
Co możemy zrobić, to kiedy robimy wskaźnik +1 dostajesz adres tutaj,

1169
01:12:59,880 --> 01:13:04,180
i aby uzyskać wartość w tutaj, można umieścić gwiazdę od całego wyrażenia

1170
01:13:04,180 --> 01:13:05,990
do nieprawidłowego go.

1171
01:13:05,990 --> 01:13:09,940
Tak więc, w tym przypadku, jestem wyznaczenia pierwszego miejsca w tej tablicy 1,

1172
01:13:09,940 --> 01:13:13,970
Lokalizacja na 2 sekundy, a trzecie miejsce do 3.

1173
01:13:13,970 --> 01:13:18,180
Wtedy to, co robię tutaj jest mi drukowanie nasz wskaźnik 1,

1174
01:13:18,180 --> 01:13:19,970
który po prostu daje mi 2.

1175
01:13:19,970 --> 01:13:23,650
Teraz jestem zwiększający wskaźnik, więc wskaźnik wynosi wskaźnik 1,

1176
01:13:23,650 --> 01:13:26,780
który porusza się do przodu.

1177
01:13:26,780 --> 01:13:30,810
I tak teraz, czy mogę wydrukować wskaźnik 1, wskaźnik +1 jest teraz 3,

1178
01:13:30,810 --> 01:13:33,990
w tym przypadku, który drukuje się 3.

1179
01:13:33,990 --> 01:13:36,560
Oraz w celu swobodnego czegoś, wskazówka, że ​​dam ją

1180
01:13:36,560 --> 01:13:40,540
może być skierowana na początku tablicą powrocie z malloc.

1181
01:13:40,540 --> 01:13:43,430
Tak więc, w tym przypadku, gdybym miał zadzwonić 3 tutaj, to nie byłoby w porządku,

1182
01:13:43,430 --> 01:13:45,070
, ponieważ znajduje się on w środku tablicy.

1183
01:13:45,070 --> 01:13:48,820
Muszę odjąć aby dostać się do oryginalnej lokalizacji

1184
01:13:48,820 --> 01:13:50,420
Początkowy 1-cia spot przed mogę uwolnić go.

1185
01:13:56,300 --> 01:13:58,450
Tak, tu jest bardziej zaangażowani przykładem.

1186
01:13:58,450 --> 01:14:03,360
W tym przypadku mamy do rozdziału 7 znaków w tablicy znaków.

1187
01:14:03,360 --> 01:14:06,480
>> I w tym przypadku to, co robimy, to jesteśmy w pętli na pierwszym 6 z nich,

1188
01:14:06,480 --> 01:14:09,900
i jesteśmy ustawiając je do Z.

1189
01:14:09,900 --> 01:14:13,350
Tak więc, na int i = 0, i> 6, i + +

1190
01:14:13,350 --> 01:14:16,220
Zatem wskaźnik + będzie po prostu dać nam, w tym przypadku,

1191
01:14:16,220 --> 01:14:20,860
Wskaźnik, wskaźnik +1, wskaźnik +2, wskaźnik +3, i tak dalej, i tak dalej w pętli.

1192
01:14:20,860 --> 01:14:24,040
Co to będzie zrobić, to robi się z tego adresu, dereferences to, aby uzyskać wartość,

1193
01:14:24,040 --> 01:14:27,440
a zmiany tej wartości do Z.

1194
01:14:27,440 --> 01:14:30,350
Następnie na koniec pamiętaj, to ciąg znaków, tak?

1195
01:14:30,350 --> 01:14:33,560
Wszystkie łańcuchy muszą kończyć się znakiem NULL kończącego.

1196
01:14:33,560 --> 01:14:38,620
Więc, co mogę zrobić, to w wskaźnik 6 stawiam znak null terminator w.

1197
01:14:38,620 --> 01:14:43,980
A teraz o co mi właściwie robi tu realizuje printf dla łańcucha, prawda?

1198
01:14:43,980 --> 01:14:46,190
>> Tak więc, gdy nie printf teraz, kiedy to skończył się ciąg?

1199
01:14:46,190 --> 01:14:48,230
Gdy trafi na znak null falowy.

1200
01:14:48,230 --> 01:14:52,030
Tak więc, w tym przypadku, moje oryginalne wskaźnik wskazuje na początek tablicy.

1201
01:14:52,030 --> 01:14:56,410
Wydrukować pierwszy znak na zewnątrz. I przenieść ją na jeden.

1202
01:14:56,410 --> 01:14:58,420
Wydrukować ten znak na zewnątrz. I przenieść ją.

1203
01:14:58,420 --> 01:15:02,180
I robić to aż do końca.

1204
01:15:02,180 --> 01:15:07,750
A teraz * wskaźnik końcowy będzie dereference to i uzyskać znak null kończącą się.

1205
01:15:07,750 --> 01:15:11,780
A więc moja pętla działa tylko wtedy, gdy wartość nie jest znak null kończące.

1206
01:15:11,780 --> 01:15:13,770
Tak, teraz mogę wyjść z tej pętli.

1207
01:15:18,780 --> 01:15:21,180
I tak, jeśli odjąć 6 z tego wskaźnika,

1208
01:15:21,180 --> 01:15:22,860
Wrócę aż do początku.

1209
01:15:22,860 --> 01:15:27,880
Pamiętaj, że to robię, bo muszę iść na początku w celu uwolnienia go.

1210
01:15:27,880 --> 01:15:30,270
>> Tak, wiem, że było dużo. Czy są jakieś pytania?

1211
01:15:30,270 --> 01:15:31,870
Proszę, tak?

1212
01:15:31,870 --> 01:15:36,610
[Niezrozumiały pytanie uczniowski]

1213
01:15:36,610 --> 01:15:38,190
Można powiedzieć, że głośniej? Przepraszam.

1214
01:15:38,190 --> 01:15:44,140
[Student] Na ostatnim slajdzie tuż przed uwolnionym wskaźnik,

1215
01:15:44,140 --> 01:15:47,300
gdzie się faktycznie zmieniając wartość wskaźnika?

1216
01:15:47,300 --> 01:15:50,370
[Józef] Tak, jest tutaj. >> [Student] Oh, w porządku.

1217
01:15:50,370 --> 01:15:51,890
[Józef] Tak, mam wskaźnik minus minus, w prawo,

1218
01:15:51,890 --> 01:15:54,140
który porusza się o jeden rzeczy, a potem zwolnić go,

1219
01:15:54,140 --> 01:15:57,000
ponieważ wskaźnik ma być skierowana na początku tablicy.

1220
01:15:57,000 --> 01:16:00,420
[Student] Ale to nie byłaby potrzebna, gdybyś zatrzymał się po tej linii.

1221
01:16:00,420 --> 01:16:03,130
[Józef] Więc, gdybym zatrzymał się po to, to byłoby uznane za wyciek pamięci,

1222
01:16:03,130 --> 01:16:04,810
bo nie uruchomić darmo.

1223
01:16:04,810 --> 01:16:11,290
[Student] I [niezrozumiały] po pierwszych trzech liniach, gdzie mieli wskaźnik 1 [niezrozumiałe].

1224
01:16:11,290 --> 01:16:13,140
[Józef] Uh-huh. Więc, co to pytanie tutaj?

1225
01:16:13,140 --> 01:16:14,780
Przepraszam. Nie, nie. Idź, idź, proszę.

1226
01:16:14,780 --> 01:16:16,870
[Student] Tak, nie jesteś zmianę wartości wskaźników.

1227
01:16:16,870 --> 01:16:19,130
Nie musiałby zrobić wskaźnik minus minus.

1228
01:16:19,130 --> 01:16:19,730
[Józef] Tak, dokładnie.

1229
01:16:19,730 --> 01:16:21,890
Tak więc, gdy zrobić wskaźnik i wskaźnik 2 +1,

1230
01:16:21,890 --> 01:16:24,410
Nie robię wskaźnik równy wskaźnik +1.

1231
01:16:24,410 --> 01:16:27,260
Tak więc, pozostaje tylko wskaźnik wskazuje na początku tablicy.

1232
01:16:27,260 --> 01:16:31,460
Dopiero gdy ja plus plus, że ustawia wartość z powrotem do wskaźnika,

1233
01:16:31,460 --> 01:16:33,550
faktycznie porusza to razem.

1234
01:16:36,860 --> 01:16:37,780
Dobrze.

1235
01:16:40,550 --> 01:16:42,030
Więcej pytań?

1236
01:16:44,680 --> 01:16:47,790
>> Ponownie, jeśli jest to rodzaj przytłaczające, zostanie to opisane w sesji.

1237
01:16:47,790 --> 01:16:50,710
Zapytaj kolegów nauczania o tym, a my możemy odpowiedzieć na pytania na końcu.

1238
01:16:53,510 --> 01:16:56,600
I zazwyczaj nie chcemy zrobić ten minus rzecz.

1239
01:16:56,600 --> 01:16:59,760
To musi wymagać mnie śledzenie jak wiele się offset w tablicy.

1240
01:16:59,760 --> 01:17:04,520
Tak w ogóle, to po prostu wyjaśnić, jak działa wskaźnik arytmetycznych.

1241
01:17:04,520 --> 01:17:07,970
Ale to, co zwykle jak zrobić, to chcemy, aby utworzyć kopię wskaźnika,

1242
01:17:07,970 --> 01:17:11,640
i wtedy będziemy używać tej kopii, gdy idziemy po w ciągu.

1243
01:17:11,640 --> 01:17:14,660
Tak więc, w przypadku korzystania z tych kopii, aby wydrukować cały ciąg,

1244
01:17:14,660 --> 01:17:19,040
ale nie trzeba robić jak wskaźnik minus 6 lub śledzić ile przeszliśmy w tym,

1245
01:17:19,040 --> 01:17:22,700
tylko dlatego, że wiemy, że nasz pierwotny punkt nadal wskazywał na początku listy

1246
01:17:22,700 --> 01:17:25,340
i wszystko to, co to było zmieniane kopia.

1247
01:17:25,340 --> 01:17:28,250
Tak w ogóle, zmiany kopie oryginalnego wskaźnika.

1248
01:17:28,250 --> 01:17:32,350
Nie staraj się coś w rodzaju - don't zmieniać oryginalne kopie.

1249
01:17:32,350 --> 01:17:35,290
Próba zmiany tylko kopie oryginału.

1250
01:17:41,540 --> 01:17:44,870
Tak więc, można zauważyć, gdy mijamy ciąg do printf

1251
01:17:44,870 --> 01:17:48,990
nie musisz postawić gwiazdkę przed nim tak jak my z wszystkimi dereferences innych, prawda?

1252
01:17:48,990 --> 01:17:54,180
Tak więc, jeśli wydrukować cały ciąg% s oczekuje jest adres,

1253
01:17:54,180 --> 01:17:57,610
w tym przypadku, a wskaźnik lub jak w tym przypadku w postaci tablicy.

1254
01:17:57,610 --> 01:18:00,330
>> Postacie, char * s, i tablice są tak samo.

1255
01:18:00,330 --> 01:18:03,690
Pointer jest znaków i tablic znaków to samo.

1256
01:18:03,690 --> 01:18:05,720
I tak, wszystko co musisz zrobić, to przekazać w wskaźnika.

1257
01:18:05,720 --> 01:18:08,150
Nie mamy do przekazania w jak * wskaźnik lub coś podobnego.

1258
01:18:13,110 --> 01:18:14,930
Więc, tablice i wskaźniki to samo.

1259
01:18:14,930 --> 01:18:19,160
Kiedy robisz coś jak x [y] tutaj na tablicy,

1260
01:18:19,160 --> 01:18:21,960
co robi pod maską jest to mówiąc, dobrze, że jest to tablica znaków,

1261
01:18:21,960 --> 01:18:23,690
więc jest to wskaźnik.

1262
01:18:23,690 --> 01:18:26,510
A więc x to samo,

1263
01:18:26,510 --> 01:18:28,650
i tak to, co robi, jest to dodaje y do x,

1264
01:18:28,650 --> 01:18:31,820
co jest tym samym, co naprzód w pamięci, że dużo.

1265
01:18:31,820 --> 01:18:34,930
I teraz x + y daje nam jakiś adres,

1266
01:18:34,930 --> 01:18:37,570
i nieprawidłowego adresu lub śledzić strzałkę

1267
01:18:37,570 --> 01:18:41,640
w przypadku gdy lokalizacja w pamięci jest i uzyskać wartość z tej lokalizacji w pamięci.

1268
01:18:41,640 --> 01:18:43,720
Tak, więc te dwa są dokładnie tym samym.

1269
01:18:43,720 --> 01:18:45,840
To jest po prostu syntaktyczne cukru.

1270
01:18:45,840 --> 01:18:48,090
Robią to samo. Są po prostu różne syntactics dla siebie.

1271
01:18:51,500 --> 01:18:57,590
>> Więc, co może pójść źle z wskaźniki? Jak, partii. Okay. Tak, złe rzeczy.

1272
01:18:57,590 --> 01:19:02,410
Złe rzeczy, które możesz zrobić nie sprawdzasz, czy wywołanie malloc zwraca null, prawda?

1273
01:19:02,410 --> 01:19:06,560
W tym przypadku, pytam system dać mi - co to za numer?

1274
01:19:06,560 --> 01:19:11,200
Jak 2 miliardów razy 4, bo rozmiar jest liczbą całkowitą 4 bajty.

1275
01:19:11,200 --> 01:19:13,810
Pytam go, jak 8 miliardów bajtów.

1276
01:19:13,810 --> 01:19:17,270
Oczywiście komputer nie będzie w stanie dać mi tyle powrotem pamięci.

1277
01:19:17,270 --> 01:19:20,960
I nie, czy ta jest nieważna, więc kiedy staramy się dereference to tam -

1278
01:19:20,960 --> 01:19:24,270
śledzić strzałkę, gdzie to będzie - nie ma tej pamięci.

1279
01:19:24,270 --> 01:19:27,150
To jest to, co nazywamy dereferencji wskaźnika pustego.

1280
01:19:27,150 --> 01:19:29,710
I to w zasadzie jest ci powodem do segfault.

1281
01:19:29,710 --> 01:19:31,790
Jest to jeden ze sposobów, można wysypać.

1282
01:19:34,090 --> 01:19:38,090
Innych złych rzeczy można zrobić - no cóż.

1283
01:19:38,090 --> 01:19:40,650
To było dereferencji wskaźnika pustego. Okay.

1284
01:19:40,650 --> 01:19:45,160
Inne złe rzeczy - dobrze, by to naprawić wystarczy umieścić tam czek

1285
01:19:45,160 --> 01:19:46,980
która sprawdza, czy wskaźnik jest null

1286
01:19:46,980 --> 01:19:51,000
i wyjść z programu, jeżeli zdarza się, że malloc zwraca wskaźnika pustego.

1287
01:19:55,110 --> 01:19:59,850
To xkcd komiks. Ludzie rozumieją go teraz. Jakby.

1288
01:20:06,120 --> 01:20:09,350
>> Tak, pamięć. I poszedłem nad tym.

1289
01:20:09,350 --> 01:20:12,000
Nazywamy malloc w pętli, ale za każdym razem wywołujemy malloc

1290
01:20:12,000 --> 01:20:14,370
tracimy orientację, gdzie wskaźnik ten jest skierowany do,

1291
01:20:14,370 --> 01:20:15,750
ponieważ jesteśmy przebijania go.

1292
01:20:15,750 --> 01:20:18,410
Tak, pierwsze wywołanie malloc daje mi pamięć tutaj.

1293
01:20:18,410 --> 01:20:19,990
Moje wskazówki wskaźnik do tego.

1294
01:20:19,990 --> 01:20:23,020
Teraz, nie uwolnić go, więc teraz ja nazywam malloc ponownie.

1295
01:20:23,020 --> 01:20:26,070
Teraz podkreśla tutaj. Teraz moja pamięć jest skierowany tutaj.

1296
01:20:26,070 --> 01:20:27,640
Wskazując tutaj. Wskazując tutaj.

1297
01:20:27,640 --> 01:20:31,820
Ale ja straciłem z adresami wszystkich pamięci tutaj, że przydzielone.

1298
01:20:31,820 --> 01:20:35,100
A więc teraz nie mam żadnego odniesienia do nich więcej.

1299
01:20:35,100 --> 01:20:37,230
Tak więc, nie mogę uwolnić ich poza tym pętli.

1300
01:20:37,230 --> 01:20:39,390
I tak, aby naprawić coś takiego,

1301
01:20:39,390 --> 01:20:42,250
jeśli zapomnisz wolnej pamięci i masz ten wyciek pamięci,

1302
01:20:42,250 --> 01:20:45,810
Musisz zwolnić pamięć wewnątrz tej pętli raz jesteś z nim zrobić.

1303
01:20:45,810 --> 01:20:51,400
Cóż, to jest to, co się dzieje. Wiem dużo o tobie nienawidzę tego.

1304
01:20:51,400 --> 01:20:55,270
Ale teraz - yay! Otrzymasz jak 44.000 kilobajtach.

1305
01:20:55,270 --> 01:20:57,110
Tak więc, można zwolnić ją na końcu pętli

1306
01:20:57,110 --> 01:20:59,770
oraz że zamierza po prostu zwolnić pamięć za każdym razem.

1307
01:20:59,770 --> 01:21:03,620
Zasadniczo, twój program nie ma wyciek pamięci anymore.

1308
01:21:03,620 --> 01:21:08,150
>> A teraz jeszcze coś można zrobić, to zwolnić trochę pamięci, że już poprosił o dwa razy.

1309
01:21:08,150 --> 01:21:11,060
W tym przypadku, możesz coś malloc, zmienić jego wartość.

1310
01:21:11,060 --> 01:21:13,140
Możesz zwolnić go raz, bo mówił, że z nim zrobić.

1311
01:21:13,140 --> 01:21:14,940
Ale potem uwolnił go ponownie.

1312
01:21:14,940 --> 01:21:16,730
To jest coś, co jest bardzo złe.

1313
01:21:16,730 --> 01:21:18,820
To nie będzie początkowo segfault,

1314
01:21:18,820 --> 01:21:23,350
ale po jakimś czasie, co to nie jest podwójnie uwalniając ta psuje swoją strukturę sterty,

1315
01:21:23,350 --> 01:21:27,200
a dowiesz się nieco więcej o tym, jeśli zdecydujesz się wziąć udział w zajęciach jak CS61.

1316
01:21:27,200 --> 01:21:30,000
Ale zasadniczo po czasie, gdy komputer będzie się mylić

1317
01:21:30,000 --> 01:21:33,010
komórki pamięci o tym, co, gdzie i są tam, gdzie jest przechowywana -

1318
01:21:33,010 --> 01:21:34,800
w których dane są przechowywane w pamięci.

1319
01:21:34,800 --> 01:21:38,080
I tak uwolnienie wskaźnik dwukrotnie jest złe, że nie chcę tego robić.

1320
01:21:38,080 --> 01:21:41,600
>> Inne rzeczy, które mogą pójść źle nie używa sizeof.

1321
01:21:41,600 --> 01:21:44,460
Tak więc, w tym przypadku malloc 8 bajtów,

1322
01:21:44,460 --> 01:21:46,700
i to jest to samo, co dwóch liczb całkowitych, prawda?

1323
01:21:46,700 --> 01:21:49,580
Tak, że jest całkowicie bezpieczne, ale to?

1324
01:21:49,580 --> 01:21:52,160
Cóż, jak Lucas mówił o na różnych architekturach

1325
01:21:52,160 --> 01:21:54,220
całkowite mają różne długości.

1326
01:21:54,220 --> 01:21:57,970
Tak, na urządzeniu, którego używasz, liczby całkowite są około 4 bajty,

1327
01:21:57,970 --> 01:22:02,370
ale na innym systemie może być 8 bajtów lub mogą być one 16 bajtów.

1328
01:22:02,370 --> 01:22:05,680
Tak więc, jeśli po prostu użyć tego numeru tutaj,

1329
01:22:05,680 --> 01:22:07,310
ten program może działać na urządzenie,

1330
01:22:07,310 --> 01:22:10,360
ale to nie będzie przydzielić wystarczającej ilości pamięci na innym systemie.

1331
01:22:10,360 --> 01:22:14,020
W tym przypadku, jest to, co jest operator sizeof stosuje.

1332
01:22:14,020 --> 01:22:16,880
Gdy dzwonimy sizeof (int), co robi to jest

1333
01:22:16,880 --> 01:22:21,910
 daje nam wielkość liczby całkowitej w systemie, że program jest uruchomiony.

1334
01:22:21,910 --> 01:22:25,490
Tak więc, w tym przypadku, sizeof (int) zwraca 4 na coś takiego urządzenia,

1335
01:22:25,490 --> 01:22:29,980
Teraz wola i 4 * 2, które są 8

1336
01:22:29,980 --> 01:22:32,330
która jest tylko ilość miejsca niezbędnego do dwóch liczb całkowitych.

1337
01:22:32,330 --> 01:22:36,710
Na innym komputerze, jeśli int jest jak 16 bajtów lub 8 bajtów,

1338
01:22:36,710 --> 01:22:39,380
to jest po prostu powróci tyle bajtów do przechowywania tej kwoty.

1339
01:22:41,830 --> 01:22:45,310
>> I wreszcie, kodowanym.

1340
01:22:45,310 --> 01:22:48,340
Tak więc, jeśli chcesz przechowywać planszę sudoku w pamięci, w jaki sposób możemy to zrobić?

1341
01:22:48,340 --> 01:22:51,570
Można o tym myśleć jak zmienna dla pierwszej rzeczy,

1342
01:22:51,570 --> 01:22:53,820
Zmienna do drugiej rzeczy, zmiennej w trzecim rzeczy,

1343
01:22:53,820 --> 01:22:56,420
zmienna w czwartym rzeczy - źle, prawda?

1344
01:22:56,420 --> 01:23:00,750
Zatem jeden poprawę można dokonać na górze to zrobić 9 x 9 tablicę.

1345
01:23:00,750 --> 01:23:04,480
To dobrze, ale co jeśli chce włączyć inne rzeczy z planszy sudoku

1346
01:23:04,480 --> 01:23:06,490
jak to, co trudność zarządu jest

1347
01:23:06,490 --> 01:23:11,740
lub, na przykład, co twój wynik jest, lub ile czasu zabrało Ci rozwiązać ten dział?

1348
01:23:11,740 --> 01:23:14,970
Cóż, co można zrobić, to można utworzyć strukturę.

1349
01:23:14,970 --> 01:23:18,910
Co mam w zasadzie powiedzieć, że definiuję tę strukturę tutaj,

1350
01:23:18,910 --> 01:23:23,230
i jestem definiowania planszę sudoku, który składa się z płyty, która jest 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> I co to ma to ma wskaźniki do nazwy poziomu.

1352
01:23:26,650 --> 01:23:30,730
Posiada również xiy, które są współrzędne, gdzie jestem teraz.

1353
01:23:30,730 --> 01:23:35,980
Ma też czas spędzony [niezrozumiałe], i ma liczbę ruchów jakie wprowadzane do tej pory.

1354
01:23:35,980 --> 01:23:40,010
I tak w tym przypadku, można zgrupować całą masę danych do tylko jednej struktury

1355
01:23:40,010 --> 01:23:42,790
zamiast je jak latają w jak różnych zmiennych

1356
01:23:42,790 --> 01:23:44,540
że tak naprawdę nie można śledzić.

1357
01:23:44,540 --> 01:23:49,720
A to pozwala nam mieć tylko ładny składnię typu odwołującego różne rzeczy wewnątrz tej struktury.

1358
01:23:49,720 --> 01:23:53,430
Ja tylko mogę board.board i dostaję planszę sudoku powrotem.

1359
01:23:53,430 --> 01:23:56,320
Board.level, rozumiem, jak trudne to jest.

1360
01:23:56,320 --> 01:24:00,540
Board.x i board.y mi współrzędne, gdzie mogę być w zarządzie.

1361
01:24:00,540 --> 01:24:04,730
A więc mam dostęp do tego, co nazywamy pola struktury.

1362
01:24:04,730 --> 01:24:08,840
To definiuje sudokuBoard, który jest typ, który mam.

1363
01:24:08,840 --> 01:24:14,800
A teraz jesteśmy tutaj. Mam zmienną o nazwie "deska" z sudokuBoard typu.

1364
01:24:14,800 --> 01:24:18,820
A więc teraz mogę uzyskać dostęp do wszystkich pól, które tworzą tę strukturę tutaj.

1365
01:24:20,830 --> 01:24:22,450
>> Wszelkie pytania dotyczące elemencie? Tak?

1366
01:24:22,450 --> 01:24:25,890
[Student] Dla int x, y, to uznane zarówno w jednej linii? >> [Józef] Uh-huh.

1367
01:24:25,890 --> 01:24:27,400
[Student] Tak, można po prostu zrobić z nich wszystkich?

1368
01:24:27,400 --> 01:24:31,200
Jak w x, y czasy, że całkowite przecinek?

1369
01:24:31,200 --> 01:24:34,460
[Józef] Tak, na pewno można to zrobić, ale powodem umieścić xiy na tej samej linii -

1370
01:24:34,460 --> 01:24:36,330
i pytanie jest dlaczego możemy po prostu to zrobić na tej samej linii?

1371
01:24:36,330 --> 01:24:38,600
Dlaczego nie możemy po prostu umieścić wszystkie z nich w tej samej linii jest

1372
01:24:38,600 --> 01:24:42,090
X i Y są powiązane ze sobą,

1373
01:24:42,090 --> 01:24:44,780
i jest to tylko stylistycznie bardziej poprawne, w pewnym sensie,

1374
01:24:44,780 --> 01:24:46,600
bo to zgrupowanie dwóch rzeczy w tym samym wierszu

1375
01:24:46,600 --> 01:24:49,340
że podobnie jak rodzaj odnosi się do tego samego.

1376
01:24:49,340 --> 01:24:51,440
A ja po prostu podzielić te strzępy. To jest po prostu coś w stylu.

1377
01:24:51,440 --> 01:24:53,720
To sprawia, że ​​funkcjonalnie nie zmieniają.

1378
01:24:58,150 --> 01:24:59,270
Wszelkie inne pytania dotyczące elemencie?

1379
01:25:03,030 --> 01:25:06,620
Można zdefiniować Pokedex z struct.

1380
01:25:06,620 --> 01:25:11,720
Pokémon ma numer i ma list, właściciela, typu.

1381
01:25:11,720 --> 01:25:16,990
A potem, jeśli masz tablicę Pokémon można tworzą Pokedex, prawda?

1382
01:25:16,990 --> 01:25:20,810
Okay, cool. Tak, pytania na elemencie. Są podobne do struktur.

1383
01:25:20,810 --> 01:25:25,270
>> Wreszcie, GDB. Co GDB pozwala zrobić? Pozwala debugować program.

1384
01:25:25,270 --> 01:25:27,650
A jeśli nie był używany GDB, chciałbym zaleca oglądanie krótkich

1385
01:25:27,650 --> 01:25:31,250
i po prostu się nad tym, co GDB jest, jak z nim pracować, jak można z niego korzystać,

1386
01:25:31,250 --> 01:25:32,900
i testowania w programie.

1387
01:25:32,900 --> 01:25:37,400
I co z tego GDB pozwala zrobić to że pozwala wstrzymać [niezrozumiały] do swojego programu

1388
01:25:37,400 --> 01:25:38,920
i praktyczne line.

1389
01:25:38,920 --> 01:25:42,600
Na przykład chcę, aby wstrzymać wykonanie jak linii 3 w moim programie,

1390
01:25:42,600 --> 01:25:46,010
a ja jestem na linii 3 można wydrukować wszystkie wartości, które są tam.

1391
01:25:46,010 --> 01:25:49,710
A więc to, co nazywamy jak zatrzymując się w linii

1392
01:25:49,710 --> 01:25:52,350
jest nazywamy to oddanie punkt przerwania na tej linii

1393
01:25:52,350 --> 01:25:55,920
a następnie możemy wydrukować zmienne na stanie programu w tym czasie.

1394
01:25:55,920 --> 01:25:58,990
>> Możemy następnie stamtąd krok po kroku program linia po linii.

1395
01:25:58,990 --> 01:26:03,200
, A następnie można sprawdzić stan stosu w czasie.

1396
01:26:03,200 --> 01:26:08,600
I tak w celu korzystania z GDB, co możemy zrobić, to nazywamy brzękiem na plik C,

1397
01:26:08,600 --> 01:26:11,290
ale musimy przekazać go flagą-ggdb.

1398
01:26:11,290 --> 01:26:15,850
A kiedy skończymy, że po prostu uruchomić gdb na wynikowego pliku wyjściowego.

1399
01:26:15,850 --> 01:26:18,810
I tak trochę jak masę tekstu tak,

1400
01:26:18,810 --> 01:26:21,990
ale tak naprawdę wszystko, co musisz zrobić, to wpisać w poleceniach na początku.

1401
01:26:21,990 --> 01:26:24,250
Złamać główny stawia przerwania na main.

1402
01:26:24,250 --> 01:26:28,470
Lista 400 wymieniono linie kodu wokół linii 400.

1403
01:26:28,470 --> 01:26:31,410
A więc w tym przypadku można po prostu rozejrzeć się i powiedzieć, oh,

1404
01:26:31,410 --> 01:26:34,360
Chcę, aby ustawić punkt przerwania na linii 397, która jest ta linia,

1405
01:26:34,360 --> 01:26:37,170
a następnie program biegnie do niego i to się złamać.

1406
01:26:37,170 --> 01:26:41,120
To będzie wstrzymać tam, i można wydrukować, na przykład, wartości niskie lub wysokie.

1407
01:26:41,120 --> 01:26:46,410
I tak istnieje kilka poleceń, które musisz wiedzieć,

1408
01:26:46,410 --> 01:26:48,660
i ten pokaz będzie się na stronie internetowej,

1409
01:26:48,660 --> 01:26:54,000
więc jeśli chcesz po prostu odwołać je lub jak umieścić je na swoich oszukiwać arkuszy, tutaj.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. To był Quiz weryfikacja 0 i będziemy trzymać się, jeśli masz jakiekolwiek pytania.

1411
01:27:00,650 --> 01:27:03,850
Dobrze.

1412
01:27:03,850 --> 01:27:09,030
>>  [Oklaski]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]