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

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

3
00:00:05,000 --> 00:00:08,000
>> [Ez a CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Hé, mindenki.

5
00:00:10,000 --> 00:00:15,000
Üdvözöljük a felülvizsgálati ülésen Quiz 0, ami zajlik e szerdán.

6
00:00:15,000 --> 00:00:19,000
Mit fogunk csinálni ma este, én vagyok a 3 másik TF,

7
00:00:19,000 --> 00:00:24,000
és együtt fogunk átmenni felülvizsgálatát mit tettünk folyamán eddig.

8
00:00:24,000 --> 00:00:27,000
Ez nem lesz 100%-os átfogó, de meg kell adni egy jobb ötletem

9
00:00:27,000 --> 00:00:31,000
, amit már le, és mit is kell tanulni, mielőtt szerdán.

10
00:00:31,000 --> 00:00:34,000
És bátran emelje fel a kezét kérdések megyünk végig,

11
00:00:34,000 --> 00:00:38,000
de ne feledje, hogy mi is van egy kis idő a végén

12
00:00:38,000 --> 00:00:41,000
ha átjutni egy pár percet, hogy tartalék-to do általános kérdések,

13
00:00:41,000 --> 00:00:47,000
úgy, hogy tartsa szem előtt, és így fogunk kezdeni az elején a 0. héten.

14
00:00:47,000 --> 00:00:50,000
>> [Kvíz 0 Review!] [Part 0] [Lexi Ross] De mielőtt ezt tesszük beszéljünk

15
00:00:50,000 --> 00:00:53,000
A logisztika a kvíz.

16
00:00:53,000 --> 00:00:55,000
>> [Logistics] [Quiz kerül sor, szerdán 10/10 helyett Előadás]

17
00:00:55,000 --> 00:00:57,000
>> [(Lásd http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf részletek)] Ez a szerda, október 10.

18
00:00:57,000 --> 00:01:00,000
>> Ez szerdán, és ha megy az URL itt,

19
00:01:00,000 --> 00:01:03,000
amely szintén elérhető a CS50.net-Van egy linket it-

20
00:01:03,000 --> 00:01:06,000
látható információkat hol alapuló

21
00:01:06,000 --> 00:01:10,000
Az utolsó név vagy az iskola helye, valamint a

22
00:01:10,000 --> 00:01:14,000
azt mondja, hogy pontosan mi a kvíz fedezi, és a fajta kérdés, hogy fogsz kapni.

23
00:01:14,000 --> 00:01:19,000
Ne feledje, hogy akkor is van esélye, hogy vizsgálja felül a kvíz szakaszban,

24
00:01:19,000 --> 00:01:21,000
így a TF kell megy át néhány gyakorlatot problémák,

25
00:01:21,000 --> 00:01:29,000
és ez egy jó esély arra, hogy hol is kell tanulni fel a kvíz.

26
00:01:29,000 --> 00:01:32,000
Kezdjük az elején a Bits 'n' Bytes.

27
00:01:32,000 --> 00:01:35,000
Ne feledje, egy kicsit csak 0 vagy 1,

28
00:01:35,000 --> 00:01:38,000
és egy byte van egy gyűjtemény a 8 e bit.

29
00:01:38,000 --> 00:01:42,000
Nézzük meg ezt a gyűjteményt bitek itt.

30
00:01:42,000 --> 00:01:44,000
Meg kell tudnia, hogy kitaláljuk, hogy hány bit van.

31
00:01:44,000 --> 00:01:48,000
Ahol számít ott csak 8 közülük nyolc 0 vagy 1 db.

32
00:01:48,000 --> 00:01:51,000
És mivel ott van 8 bit, ez 1 byte,

33
00:01:51,000 --> 00:01:53,000
és menjünk átalakítani, hogy hexadecimális.

34
00:01:53,000 --> 00:01:58,000
Hexadecimális a 16 alap, és ez elég könnyű konvertálni

35
00:01:58,000 --> 00:02:01,000
egy számot bináris, ami, hogy mi az, hogy egy számot hexadecimális.

36
00:02:01,000 --> 00:02:04,000
Minden, amit tennie nézzük csoportok 4,

37
00:02:04,000 --> 00:02:07,000
, és átalakítani őket, hogy a megfelelő hexadecimális számjegyet.

38
00:02:07,000 --> 00:02:11,000
Kezdjük a jobb szélső csoport 4, így a 0011.

39
00:02:11,000 --> 00:02:16,000
Ez lesz egy 1 és egy 2, így együtt, ami 3.

40
00:02:16,000 --> 00:02:19,000
És akkor nézzük meg a többi blokk a 4.

41
00:02:19,000 --> 00:02:24,000
1101. Ez lesz az egyik 1, egy 4 és egy 8.

42
00:02:24,000 --> 00:02:28,000
Együtt ez lesz 13, ami D.

43
00:02:28,000 --> 00:02:32,000
És akkor ne feledjük, hogy a hexadecimális mi nem csak go 0 és 9 között.

44
00:02:32,000 --> 00:02:36,000
Mi megy 0-tól F, így azután 9, 10 felel meg,

45
00:02:36,000 --> 00:02:40,000
11 B, satöbbi ahol F 15.

46
00:02:40,000 --> 00:02:44,000
Itt 13 jelentése D,

47
00:02:44,000 --> 00:02:49,000
úgy átalakítani, hogy a tizedes minden, amit tennie, hogy mi valójában

48
00:02:49,000 --> 00:02:52,000
kezelik minden egyes pozíció, mint a hatalom a 2.

49
00:02:52,000 --> 00:02:58,000
Ez egy 1, egy 2, nulla 4s, 8s nulla, egy 16, et cetera,

50
00:02:58,000 --> 00:03:03,000
és ez egy kicsit nehéz, hogy kiszámolja a fejedben, de ha megyünk a következő diára

51
00:03:03,000 --> 00:03:05,000
láthatjuk a választ.

52
00:03:05,000 --> 00:03:09,000
>> Lényegében megyünk át jobbról balra vissza,

53
00:03:09,000 --> 00:03:14,000
és mi megszorozzuk az egyes számjegy a megfelelő 2-hatvány.

54
00:03:14,000 --> 00:03:19,000
És ne feledd, a hexadecimális mi jelöljük ezeket a számokat 0x elején

55
00:03:19,000 --> 00:03:23,000
így nem keverjük össze, hogy egy decimális szám.

56
00:03:23,000 --> 00:03:29,000
Folytatva, ez egy ASCII táblázat,

57
00:03:29,000 --> 00:03:35,000
és mire használjuk az ASCII hogy térképet karakterek numerikus értékek.

58
00:03:35,000 --> 00:03:39,000
Ne feledje, a kriptográfia Pset tettünk széles körben használják az ASCII táblázat

59
00:03:39,000 --> 00:03:43,000
annak érdekében, hogy használjon különféle módszereket kriptográfia,

60
00:03:43,000 --> 00:03:47,000
A Caesar és a Vigenère titkosítást, átalakítására, különböző betűk

61
00:03:47,000 --> 00:03:52,000
egy string szerint a kulcs a felhasználó által megadott.

62
00:03:52,000 --> 00:03:56,000
Nézzünk egy kicsit ASCII matek.

63
00:03:56,000 --> 00:04:02,000
Keresi a 'P' + 1, jellegű formában lenne Q,

64
00:04:02,000 --> 00:04:07,000
és ne feledjük, hogy '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
És pontosan hogyan tudnánk konvertálni között 2 nyomtatványok?

66
00:04:10,000 --> 00:04:13,000
Ez valójában nem túl nehéz.

67
00:04:13,000 --> 00:04:16,000
Annak érdekében, hogy 5 levonjuk '0 '

68
00:04:16,000 --> 00:04:20,000
mert van 5 hely a '0 'és az '5.'

69
00:04:20,000 --> 00:04:23,000
Annak érdekében, hogy menj a másik irányba már csak hozzá a 0,

70
00:04:23,000 --> 00:04:25,000
így ez a fajta, mint a rendszeres számtani.

71
00:04:25,000 --> 00:04:29,000
Ne feledd, hogy ha valami van idézőjelek körül ez a karakter

72
00:04:29,000 --> 00:04:37,000
és így értéknek felel meg az ASCII táblázatban.

73
00:04:37,000 --> 00:04:40,000
Költözünk általános számítógép-tudomány témák.

74
00:04:40,000 --> 00:04:43,000
Megtanultuk, mi az az algoritmus, és hogyan használjuk programozás

75
00:04:43,000 --> 00:04:45,000
végrehajtására algoritmusok.

76
00:04:45,000 --> 00:04:48,000
Néhány példa az algoritmusok valami igazán egyszerű, mint

77
00:04:48,000 --> 00:04:51,000
annak ellenőrzése, hogy a szám páros vagy páratlan.

78
00:04:51,000 --> 00:04:54,000
Erre emlékszem, mod a számot 2 és ellenőrizze, hogy az eredmény 0.

79
00:04:54,000 --> 00:04:57,000
Ha igen, ez még. Ha nem, ez furcsa.

80
00:04:57,000 --> 00:04:59,000
És ez egy példa egy nagyon alap algoritmus.

81
00:04:59,000 --> 00:05:02,000
>> Egy kicsit a nagyobb részt az egyik bináris keresés,

82
00:05:02,000 --> 00:05:05,000
amely megyünk át később a felülvizsgálat során.

83
00:05:05,000 --> 00:05:09,000
És a programozás a kifejezést használja az olyan algoritmust

84
00:05:09,000 --> 00:05:15,000
és átkonvertálja a kódot a számítógép olvasni.

85
00:05:15,000 --> 00:05:20,000
2 példát programozás Scratch,

86
00:05:20,000 --> 00:05:22,000
amit mi tette Hét 0.

87
00:05:22,000 --> 00:05:25,000
Annak ellenére, hogy valójában nem írja ki a kódot, ez egy módja a végrehajtási

88
00:05:25,000 --> 00:05:29,000
ezt az algoritmust, amely kinyomtatja a számok 1-10,

89
00:05:29,000 --> 00:05:32,000
és itt nem ugyanaz a C programozási nyelv.

90
00:05:32,000 --> 00:05:41,000
Ezek funkcionálisan egyenértékű, csak írt különböző nyelveken, vagy szintaxist.

91
00:05:41,000 --> 00:05:44,000
Ezután értesült boolean kifejezéseket,

92
00:05:44,000 --> 00:05:48,000
és egy boolean olyan érték, hogy ez igaz vagy hamis,

93
00:05:48,000 --> 00:05:51,000
és itt sokszor logikai kifejezések

94
00:05:51,000 --> 00:05:55,000
bemenni a feltételek, így ha (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
nos, már meg x = 5, tehát ez a feltétel fogja értékelni, hogy igaz.

96
00:06:00,000 --> 00:06:03,000
És ha ez igaz, bármi kód alatt a feltétel

97
00:06:03,000 --> 00:06:08,000
fogja értékelni kell a számítógép, így húr fog nyomtatni

98
00:06:08,000 --> 00:06:12,000
a szabványos kimenetre, és a kifejezés feltétel

99
00:06:12,000 --> 00:06:16,000
utal, amit a zárójelben az if.

100
00:06:16,000 --> 00:06:20,000
Ne feledje, a piaci szereplők.

101
00:06:20,000 --> 00:06:26,000
Ne feledd, hogy a && és | | amikor próbálunk össze 2 vagy több feltételt,

102
00:06:26,000 --> 00:06:30,000
== Nem = ellenőrizni, hogy 2 dolgot egyenlő.

103
00:06:30,000 --> 00:06:36,000
Ne feledje, hogy = Az hozzárendelés mivel == egy logikai operátort.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ majd az utolsó 2 magától értetődő.

105
00:06:41,000 --> 00:06:45,000
Az általános felülvizsgálatát boolean logika itt.

106
00:06:45,000 --> 00:06:48,000
És boolean kifejezések is fontos hurkok,

107
00:06:48,000 --> 00:06:50,000
amely megyünk át most.

108
00:06:50,000 --> 00:06:56,000
Megismertük 3 típusú hurkok eddigi CS50, for, while, és nem kicsit.

109
00:06:56,000 --> 00:06:59,000
És ez fontos tudni, hogy míg a legtöbb célra

110
00:06:59,000 --> 00:07:02,000
tudjuk ténylegesen használni bármilyen típusú hurok általában

111
00:07:02,000 --> 00:07:06,000
vannak bizonyos célra, vagy közös mintákat

112
00:07:06,000 --> 00:07:09,000
programozás, amelyek kifejezetten szükségessé egy ilyen hurok

113
00:07:09,000 --> 00:07:13,000
hogy hogy ez a leghatékonyabb vagy elegáns kódolni azt az említett módon.

114
00:07:13,000 --> 00:07:18,000
Menjünk át mi minden egyes ilyen hurkok általában használt leggyakrabban.

115
00:07:18,000 --> 00:07:21,000
>> A for ciklus általában azt már tudjuk, hogy hányszor akarjuk navigálhat.

116
00:07:21,000 --> 00:07:24,000
Ez az, amit teszünk a feltételt.

117
00:07:24,000 --> 00:07:28,000
A, i = 0, i <10, például.

118
00:07:28,000 --> 00:07:31,000
Azt már tudjuk, hogy tenni akarnak valamit 10-szer.

119
00:07:31,000 --> 00:07:34,000
Most egy darabig hurok, általában nem feltétlenül

120
00:07:34,000 --> 00:07:36,000
tudom, hányszor szeretnénk a hurkot futtatni.

121
00:07:36,000 --> 00:07:39,000
De tudjuk, hogy valamilyen feltétellel, hogy azt akarjuk, hogy

122
00:07:39,000 --> 00:07:41,000
mindig igaz, vagy mindig hamis.

123
00:07:41,000 --> 00:07:44,000
Például, míg a be van állítva.

124
00:07:44,000 --> 00:07:46,000
Tegyük fel, hogy ez egy logikai változó.

125
00:07:46,000 --> 00:07:48,000
Bár ez igaz akarjuk a kódot, hogy értékelje,

126
00:07:48,000 --> 00:07:52,000
így egy kicsit jobban bővíthető, egy kicsit általánosabb, mint a for ciklus,

127
00:07:52,000 --> 00:07:55,000
de bármely a hurok is átalakíthatók a közben hurok.

128
00:07:55,000 --> 00:08:00,000
Végül, do while ciklusok, amely lehet a legnehezebb megérteni azonnal,

129
00:08:00,000 --> 00:08:04,000
gyakran használják, ha azt akarjuk, hogy értékelje az első megfelelő kód

130
00:08:04,000 --> 00:08:06,000
mielőtt az első alkalom, hogy ellenőrizze az állapotát.

131
00:08:06,000 --> 00:08:09,000
Közös használata esetén egy do while

132
00:08:09,000 --> 00:08:12,000
amikor azt szeretnénk, hogy felhasználói, és tudod, azt szeretnénk, hogy felkéri a felhasználót,

133
00:08:12,000 --> 00:08:15,000
a bemeneti legalább egyszer, de ha nem adnak Önnek jó input azonnal

134
00:08:15,000 --> 00:08:18,000
meg akarja tartani kérve őket, amíg el nem adja meg a helyes bemenet.

135
00:08:18,000 --> 00:08:21,000
Ez a leggyakoribb használata nem while ciklus,

136
00:08:21,000 --> 00:08:23,000
és nézzük meg a tényleges szerkezetét e hurkok.

137
00:08:23,000 --> 00:08:27,000
Ezek jellemzően mindig hajlamosak követni ezeket a mintákat.

138
00:08:27,000 --> 00:08:30,000
>> A for ciklus belsejében van 3 részből áll:

139
00:08:30,000 --> 00:08:35,000
inicializálás, jellemzően valami hasonlót int i = 0, ahol i a számláló,

140
00:08:35,000 --> 00:08:40,000
állapot, ahol szeretnénk mondani futtatni ezt a for ciklus, amíg ez az állapot még fennáll,

141
00:08:40,000 --> 00:08:44,000
mint i <10, és végül, frissítés, amely hogyan növelni

142
00:08:44,000 --> 00:08:47,000
a számláló változót minden ponton a hurok.

143
00:08:47,000 --> 00:08:50,000
A közös dolog, hogy ott is csak i + +,

144
00:08:50,000 --> 00:08:52,000
ami azt jelenti, növeljük i 1-jéig minden alkalommal.

145
00:08:52,000 --> 00:08:55,000
Te is valami ilyesmit i + = 2,

146
00:08:55,000 --> 00:08:58,000
ami azt jelenti, adjunk hozzá 2-i minden egyes alkalommal, amikor átmegy a hurok.

147
00:08:58,000 --> 00:09:03,000
És akkor az ezt csak kifejezés bármely olyan kód, amely ténylegesen fut részeként a hurok.

148
00:09:03,000 --> 00:09:09,000
És egy ideig hurok, ezúttal ténylegesen az inicializálás kívül a hurok,

149
00:09:09,000 --> 00:09:12,000
így például, mondjuk mi próbálunk tenni az azonos típusú hurok, ahogy csak le.

150
00:09:12,000 --> 00:09:16,000
Azt mondanám, int i = 0, mielőtt a ciklus kezdődik.

151
00:09:16,000 --> 00:09:20,000
Akkor mondhatnánk, míg én <10 Ehhez,

152
00:09:20,000 --> 00:09:22,000
így ugyanazt a blokk-kód, mint korábban,

153
00:09:22,000 --> 00:09:26,000
és ezúttal a frissítés része a kód, például, i + +,

154
00:09:26,000 --> 00:09:29,000
valóban megy belsejében a hurok.

155
00:09:29,000 --> 00:09:33,000
És végül, egy do while, ez hasonló a while ciklus,

156
00:09:33,000 --> 00:09:36,000
de meg kell emlékezni, hogy a kód értékelni fogja, ha

157
00:09:36,000 --> 00:09:40,000
mielőtt a feltétel meg van jelölve, így teszi sokkal több értelme

158
00:09:40,000 --> 00:09:44,000
ha nézzük sorrendjében fentről lefelé.

159
00:09:44,000 --> 00:09:49,000
A do while ciklus a kódot, értékeli, mielőtt még nézd meg a közben feltétel,

160
00:09:49,000 --> 00:09:55,000
mivel a while ciklus, ellenőrzi először.

161
00:09:55,000 --> 00:09:59,000
Nyilatkozatok és változókat.

162
00:09:59,000 --> 00:10:04,000
Ha azt akarjuk, hogy hozzon létre egy új változót először szeretnénk inicializálni azt.

163
00:10:04,000 --> 00:10:07,000
>> Például, int bar inicializálja a változót bár,

164
00:10:07,000 --> 00:10:10,000
de nem adja meg egy értéket, akkor mi van bár értékét most?

165
00:10:10,000 --> 00:10:12,000
Nem tudjuk.

166
00:10:12,000 --> 00:10:14,000
Lehet, hogy valami szemetet értéket, amelyet korábban a memóriában tárolt ott,

167
00:10:14,000 --> 00:10:16,000
és nem akarjuk használni, hogy a változó

168
00:10:16,000 --> 00:10:19,000
amíg mi valójában, hogy ez egy érték,

169
00:10:19,000 --> 00:10:21,000
így állapítsa meg itt.

170
00:10:21,000 --> 00:10:24,000
Aztán inicializálni, hogy legyen 42 alatt.

171
00:10:24,000 --> 00:10:28,000
Most, persze, tudjuk, hogy ez lehet tenni egy sorban, int bar = 42.

172
00:10:28,000 --> 00:10:30,000
De csak, hogy törölje a több lépésben folynak,

173
00:10:30,000 --> 00:10:34,000
a nyilatkozatot és az inicializáló történnek külön van.

174
00:10:34,000 --> 00:10:38,000
Ez történik egy lépés, és a következő egy, int baz = bar + 1,

175
00:10:38,000 --> 00:10:44,000
ez a kijelentés alatt, hogy a BAZ lépésekben, így a végén ezt a kódot mondat

176
00:10:44,000 --> 00:10:48,000
ha volt, hogy nyomtassa ki az értékét BAZ lenne 44

177
00:10:48,000 --> 00:10:52,000
mert nyilvánítja és inicializálni legyenek az 1> bar,

178
00:10:52,000 --> 00:10:58,000
és akkor mi megnöveljük még egyszer a + +.

179
00:10:58,000 --> 00:11:02,000
Mentünk át ezt a szép röviden, de jó, hogy van egy általános

180
00:11:02,000 --> 00:11:04,000
megértésének szálak és események.

181
00:11:04,000 --> 00:11:06,000
Mi elsősorban tette ezt Scratch,

182
00:11:06,000 --> 00:11:09,000
így gondolja, a szálak a többszörös szekvenciák kód

183
00:11:09,000 --> 00:11:11,000
fut egyszerre.

184
00:11:11,000 --> 00:11:14,000
A valóságban valószínűleg nem fut egyszerre,

185
00:11:14,000 --> 00:11:17,000
hanem valami elvont tudjuk gondolni rá ilyen módon.

186
00:11:17,000 --> 00:11:20,000
>> A Scratch, például, mi volt a több sprite.

187
00:11:20,000 --> 00:11:22,000
Meg lehetne végrehajtó különböző kód egy időben.

188
00:11:22,000 --> 00:11:26,000
Az egyik lehet gyaloglás, míg a másik mond valamit

189
00:11:26,000 --> 00:11:29,000
egy másik részén a képernyőn.

190
00:11:29,000 --> 00:11:34,000
Az események másik módja különválasztja a logikai

191
00:11:34,000 --> 00:11:37,000
különböző elemei a kódot,

192
00:11:37,000 --> 00:11:40,000
és a Scratch tudtuk szimulálni események a Broadcast,

193
00:11:40,000 --> 00:11:43,000
és ez tulajdonképpen Mikor kapom, nem amikor hallom,

194
00:11:43,000 --> 00:11:47,000
de lényegében ez egy módja annak, hogy az információ átadása

195
00:11:47,000 --> 00:11:49,000
egyik sprite a másik.

196
00:11:49,000 --> 00:11:52,000
Például érdemes lehet továbbítani vége a játéknak,

197
00:11:52,000 --> 00:11:56,000
és ha egy másik sprite kap game over,

198
00:11:56,000 --> 00:11:58,000
válaszol egy bizonyos módon.

199
00:11:58,000 --> 00:12:03,000
Ez egy fontos modell, hogy megértsék a programozáshoz.

200
00:12:03,000 --> 00:12:07,000
Csak, hogy menjen át az alap 0. héten, amit mi már ment át eddig,

201
00:12:07,000 --> 00:12:10,000
nézzük meg ezt az egyszerű C program.

202
00:12:10,000 --> 00:12:14,000
A szöveg lehet egy kicsit kicsi innen, de megyek rajta igazán gyors.

203
00:12:14,000 --> 00:12:20,000
Mi ilyenek például a 2 header fájlokat a tetején, és cs50.h stdio.h.

204
00:12:20,000 --> 00:12:23,000
Mi majd meghatározó állandó nevű határérték 100 fő.

205
00:12:23,000 --> 00:12:26,000
Mi majd végrehajtása a fő funkciója.

206
00:12:26,000 --> 00:12:29,000
Mivel mi nem használjuk parancssori argumentumok itt kell tenni void

207
00:12:29,000 --> 00:12:32,000
az érvek fő.

208
00:12:32,000 --> 00:12:38,000
Látjuk int fent fő. Ez a visszatérési típusa, ezért vissza 0 alján.

209
00:12:38,000 --> 00:12:41,000
És mi a CS50 könyvtári funkciót kap int

210
00:12:41,000 --> 00:12:45,000
hogy felkéri a felhasználót a bemeneti, és tárolja ezt a változót x,

211
00:12:45,000 --> 00:12:51,000
így állapítsa x fent, és inicializálja azt x = getInt.

212
00:12:51,000 --> 00:12:53,000
>> Ezután ellenőrizze, hogy ha a felhasználó adott nekünk jó bemenet.

213
00:12:53,000 --> 00:12:59,000
Ha ez ≥ LIMIT szeretnénk visszatérni hibakód 1 és nyomtassa ki egy hibaüzenetet.

214
00:12:59,000 --> 00:13:02,000
És végül, ha a felhasználó által adott nekünk jó bemenet

215
00:13:02,000 --> 00:13:08,000
megyünk tér a számot, és nyomtassa ki az eredményt.

216
00:13:08,000 --> 00:13:11,000
Csak, hogy győződjön meg arról, hogy ezek minden hit otthon

217
00:13:11,000 --> 00:13:17,000
láthatjuk a címkéket különböző részei a kód itt.

218
00:13:17,000 --> 00:13:19,000
Már említettem állandó header fájlokat.

219
00:13:19,000 --> 00:13:21,000
Oh, int x. Ügyeljen arra, hogy ne feledje, hogy ez egy lokális változó.

220
00:13:21,000 --> 00:13:24,000
Ez ellentétben ez egy globális változó, amely fogunk beszélni

221
00:13:24,000 --> 00:13:27,000
Egy kicsit később a felülvizsgálat ülésen,

222
00:13:27,000 --> 00:13:30,000
és mi hív a könyvtár printf függvény,

223
00:13:30,000 --> 00:13:34,000
tehát ha nem tartalmazza a stdio.h header file

224
00:13:34,000 --> 00:13:37,000
akkor nem lesz képes hívni printf.

225
00:13:37,000 --> 00:13:42,000
És azt hiszem, a nyilat, hogy van vágva itt rámutatni, hogy a% d,

226
00:13:42,000 --> 00:13:45,000
amely formázási string printf.

227
00:13:45,000 --> 00:13:52,000
Azt mondja, nyomtassa ki ezt a változót, mint egy szám,% d.

228
00:13:52,000 --> 00:13:58,000
És ez azt Week 0.

229
00:13:58,000 --> 00:14:06,000
Most Lucas fog folytatni.

230
00:14:06,000 --> 00:14:08,000
Hé, srácok. A nevem Lucas.

231
00:14:08,000 --> 00:14:10,000
Vagyok másodéves a legjobb ház a kampuszon, Mather,

232
00:14:10,000 --> 00:14:14,000
és fogok beszélni egy kicsit hét 1 és 2,1.

233
00:14:14,000 --> 00:14:16,000
[Hét 1 és 2,1!] [Lucas Freitas]

234
00:14:16,000 --> 00:14:19,000
Ahogy Lexi mondtam, amikor elkezdtük fordítani a kódot a Scratch-C

235
00:14:19,000 --> 00:14:23,000
az egyik dolog, amit észrevettem, hogy nem lehet csak a

236
00:14:23,000 --> 00:14:26,000
írjuk meg a kódot, és futtatni egy zöld zászló többé.

237
00:14:26,000 --> 00:14:30,000
Igazából, meg kell használni néhány lépést, hogy a C program

238
00:14:30,000 --> 00:14:33,000
válik egy futtatható fájl.

239
00:14:33,000 --> 00:14:36,000
Alapvetően mit csinálsz, ha írsz egy programot, hogy a

240
00:14:36,000 --> 00:14:40,000
Ön lefordítani a te ötleted egy nyelvet, hogy a fordító tudja megérteni,

241
00:14:40,000 --> 00:14:44,000
így amikor írsz egy programot C

242
00:14:44,000 --> 00:14:47,000
mit csinálsz valójában ír valamit, hogy a fordító fog megérteni,

243
00:14:47,000 --> 00:14:50,000
majd a fordító fogja fordítani, hogy a kódex

244
00:14:50,000 --> 00:14:53,000
valami, hogy a számítógép meg fogja érteni.

245
00:14:53,000 --> 00:14:55,000
>> És a dolog, a számítógép valójában nagyon buta.

246
00:14:55,000 --> 00:14:57,000
A számítógép csak megértsék 0s és 1s,

247
00:14:57,000 --> 00:15:01,000
így valójában az első számítógépek az emberek általában programozott

248
00:15:01,000 --> 00:15:04,000
használatával 0s és 1s, de már nem, hála Istennek.

249
00:15:04,000 --> 00:15:07,000
Nem kell megjegyeznie a szekvenciákat 0s és 1s

250
00:15:07,000 --> 00:15:10,000
egy for ciklus vagy egy ideig hurok és így tovább.

251
00:15:10,000 --> 00:15:13,000
Ezért van egy fordító.

252
00:15:13,000 --> 00:15:17,000
Milyen fordító csinál, alapvetően átalakítja a C kód,

253
00:15:17,000 --> 00:15:21,000
a mi esetünkben, hogy egy nyelvet, hogy a számítógép meg fogja érteni,

254
00:15:21,000 --> 00:15:25,000
amely a tárgykód, és a fordító, hogy mi a

255
00:15:25,000 --> 00:15:30,000
hívják csenget, így ez valójában a szimbólum csenget.

256
00:15:30,000 --> 00:15:33,000
Amikor a program, nem kell mást tennie 2 dolog.

257
00:15:33,000 --> 00:15:37,000
Először is, meg kell fordítani a programot, és akkor fogod futtatni a programot.

258
00:15:37,000 --> 00:15:41,000
Ha le szeretnéd fordítani a programot, hogy van egy csomó lehetőség erre.

259
00:15:41,000 --> 00:15:44,000
Az első az, hogy nem csenget program.c

260
00:15:44,000 --> 00:15:47,000
amely program a neve a program.

261
00:15:47,000 --> 00:15:51,000
Ebben az esetben láthatjuk ők csak azt mondom: "Hé, lefordítja a programot."

262
00:15:51,000 --> 00:15:56,000
Ugye nem azt mondja: "Azt akarom, ezt a nevet a program", vagy ilyesmi.

263
00:15:56,000 --> 00:15:58,000
>> A második opció ad egy nevet a program.

264
00:15:58,000 --> 00:16:02,000
Azt lehet mondani, csengés-o, majd a kívánt nevet

265
00:16:02,000 --> 00:16:06,000
a futtatható fájlt nevezzük majd program.c.

266
00:16:06,000 --> 00:16:11,000
És akkor is megcsináljuk program, és látom, hogy az első 2 esetben

267
00:16:11,000 --> 00:16:15,000
Tettem. C, és a harmadik, akit csak a programok?

268
00:16:15,000 --> 00:16:18,000
Igen, tényleg nem kellene. C használatakor tenni.

269
00:16:18,000 --> 00:16:22,000
Ellenkező esetben a fordító valóban fog kiabálni veled.

270
00:16:22,000 --> 00:16:24,000
És azt is, nem tudom, ha a srácok emlékszel,

271
00:16:24,000 --> 00:16:29,000
de sokszor mi is használták-lcs50 vagy-lm.

272
00:16:29,000 --> 00:16:31,000
Ezt hívják össze.

273
00:16:31,000 --> 00:16:35,000
Csak mondja a fordító fogja használni ezeket a könyvtárak ott,

274
00:16:35,000 --> 00:16:39,000
így ha szeretnénk használni cs50.h valóban kell beírni

275
00:16:39,000 --> 00:16:43,000
zengés program.c-lcs50.

276
00:16:43,000 --> 00:16:45,000
Ha nem teszed, a fordító nem fog tudni

277
00:16:45,000 --> 00:16:50,000
hogy az Ön által használt e funkciók cs50.h.

278
00:16:50,000 --> 00:16:52,000
És ha szeretné futtatni a programot, van 2 lehetőség.

279
00:16:52,000 --> 00:16:57,000
Ha nem csenget program.c Ön nem adott nevet a program.

280
00:16:57,000 --> 00:17:01,000
Meg kell futtatni a. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out egy szabványos név csenget ad a program, ha nem adja meg a nevet.

282
00:17:06,000 --> 00:17:11,000
Egyébként fogsz tenni. / Programot, ha adott egy nevet a program,

283
00:17:11,000 --> 00:17:15,000
és akkor is, ha te make programot a név egy program fog kapni

284
00:17:15,000 --> 00:17:23,000
már megy programozható ugyanazt a nevet, mint a c fájlt.

285
00:17:23,000 --> 00:17:26,000
Aztán beszéltünk adattípusok és adatok.

286
00:17:26,000 --> 00:17:31,000
>> Alapvetően adattípusok ugyanaz, mint a kis dobozok az általuk használt

287
00:17:31,000 --> 00:17:35,000
tárolni értékek, így adattípusok ténylegesen mint pokemons.

288
00:17:35,000 --> 00:17:39,000
Jönnek minden méretben és típusban.

289
00:17:39,000 --> 00:17:43,000
Nem tudom, ha ez analógia értelme.

290
00:17:43,000 --> 00:17:46,000
Az adat mérete valójában függ a gépen architektúrára.

291
00:17:46,000 --> 00:17:49,000
Minden adat méretek fogok mutatni itt

292
00:17:49,000 --> 00:17:53,000
valójában a 32-bites gép, ez a helyzet a mi készülék,

293
00:17:53,000 --> 00:17:56,000
de ha valóban kódolás a Mac vagy a Windows is

294
00:17:56,000 --> 00:17:59,000
Valószínűleg fogsz egy 64-bites gép,

295
00:17:59,000 --> 00:18:03,000
úgy emlékszem, hogy az adatok méretek fogok mutatni itt

296
00:18:03,000 --> 00:18:06,000
vannak a 32-bites gép.

297
00:18:06,000 --> 00:18:08,000
Az első az, hogy láttunk egy int,

298
00:18:08,000 --> 00:18:10,000
ami elég egyértelmű.

299
00:18:10,000 --> 00:18:13,000
Ön használja int tárolni egy egész.

300
00:18:13,000 --> 00:18:16,000
Azt is látta, hogy a karakter, a karakter.

301
00:18:16,000 --> 00:18:20,000
Ha szeretné használni egy levelet vagy egy kis jel, amit valószínűleg fogja használni a kar.

302
00:18:20,000 --> 00:18:26,000
A char van 1 byte, ami azt jelenti, 8 bit, mint Lexi mondta.

303
00:18:26,000 --> 00:18:31,000
Alapvetően van egy ASCII táblázat, amely 256

304
00:18:31,000 --> 00:18:34,000
lehetséges kombinációját 0s és 1s,

305
00:18:34,000 --> 00:18:37,000
majd amikor egy char ez lesz lefordítani

306
00:18:37,000 --> 00:18:44,000
A karaktert bemenetek egy szám van az ASCII tábla, mint Lexi mondta.

307
00:18:44,000 --> 00:18:48,000
Mi is az úszót, amit használ, hogy tárolja decimális számokat.

308
00:18:48,000 --> 00:18:53,000
Ha szeretné választani 3,14, például fogod használni float

309
00:18:53,000 --> 00:18:55,000
vagy kettős, amely több pontossággal.

310
00:18:55,000 --> 00:18:57,000
Az úszó a 4 bájt.

311
00:18:57,000 --> 00:19:01,000
A kettős már 8 bájt, így az egyetlen különbség a pontosság.

312
00:19:01,000 --> 00:19:04,000
Mi is van egy hosszú, hogy használnak egész szám,

313
00:19:04,000 --> 00:19:09,000
és láthatjuk a 32-bites gép int és egy hosszú azonos méretű,

314
00:19:09,000 --> 00:19:13,000
így nem igazán van értelme használni a hosszú 32-bites gép.

315
00:19:13,000 --> 00:19:17,000
>> De ha egy Mac és 64-bites gép, valójában egy hosszú van 8-as méret,

316
00:19:17,000 --> 00:19:19,000
így valójában attól függ, az építészet.

317
00:19:19,000 --> 00:19:22,000
A 32-bites gépen nincs értelme, hogy egy hosszú igazán.

318
00:19:22,000 --> 00:19:25,000
És azután egy hosszú, hosszú, a másik viszont már 8 bájt,

319
00:19:25,000 --> 00:19:30,000
ezért nagyon jó, ha azt szeretnénk, hogy egy hosszabb egész.

320
00:19:30,000 --> 00:19:34,000
És végül, van húr, ami valójában a char *,

321
00:19:34,000 --> 00:19:37,000
amely egy mutató char.

322
00:19:37,000 --> 00:19:40,000
Nagyon könnyű azt gondolni, hogy a méret a string lesz, mint

323
00:19:40,000 --> 00:19:42,000
karakterek számát, hogy van ott,

324
00:19:42,000 --> 00:19:45,000
de valójában a char * maga

325
00:19:45,000 --> 00:19:49,000
van akkora, mint egy mutató egy char, ami 4 bájt.

326
00:19:49,000 --> 00:19:52,000
Akkora, mint egy char * 4 bájt.

327
00:19:52,000 --> 00:19:56,000
Nem számít, ha van egy kis szó vagy írni, vagy ilyesmi.

328
00:19:56,000 --> 00:19:58,000
Ez lesz 4 bájt.

329
00:19:58,000 --> 00:20:01,000
Azt is megtanultam egy kicsit casting,

330
00:20:01,000 --> 00:20:04,000
így láthatja, ha, például, egy program, amely azt mondja,

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

332
00:20:08,000 --> 00:20:12,000
nem tudjátok, mit fog nyomtatni a képernyőn?

333
00:20:12,000 --> 00:20:14,000
>> Valaki? >> [Students] 2.

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

335
00:20:16,000 --> 00:20:20,000
Ha ezt 3/2 ez lesz, hogy 1,5,

336
00:20:20,000 --> 00:20:24,000
de mivel mi használ integer ez lesz figyelmen kívül hagyni a tizedes rész,

337
00:20:24,000 --> 00:20:26,000
és mész van 1.

338
00:20:26,000 --> 00:20:29,000
Ha nem akarja, hogy megtörténjen, mit lehet tenni, például,

339
00:20:29,000 --> 00:20:33,000
A nyilvánítja a float y = x.

340
00:20:33,000 --> 00:20:40,000
Ekkor x, hogy régen 3 most lesz 3,000 y.

341
00:20:40,000 --> 00:20:44,000
És akkor kinyomtathatja a y / 2.

342
00:20:44,000 --> 00:20:50,000
Igazából kellett volna a 2. ott.

343
00:20:50,000 --> 00:20:55,000
Ez fog tenni 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
és fogsz kapni 1.5.

345
00:20:58,000 --> 00:21:06,000
És mi van a .2 f csak kérni, 2 tizedes egység a tizedes rész.

346
00:21:06,000 --> 00:21:12,000
Ha van .3 f ez megy, hogy ténylegesen 1.500.

347
00:21:12,000 --> 00:21:16,000
Ha ez 2, akkor lesz 1.50.

348
00:21:16,000 --> 00:21:18,000
Mi is ez a helyzet.

349
00:21:18,000 --> 00:21:22,000
Ha nem float x = 3,14 és akkor printf x

350
00:21:22,000 --> 00:21:24,000
fogsz kapni 3.14.

351
00:21:24,000 --> 00:21:29,000
És ha x = int x,

352
00:21:29,000 --> 00:21:34,000
ami azt jelenti, x kezelik, mint egy int, és a nyomtatás x most

353
00:21:34,000 --> 00:21:36,000
mész, hogy a 3,00.

354
00:21:36,000 --> 00:21:38,000
Van ennek értelme?

355
00:21:38,000 --> 00:21:41,000
Mert először kezeljék x egészként, szóval figyelmen kívül hagyja a tizedes rész,

356
00:21:41,000 --> 00:21:45,000
majd te nyomtatás x.

357
00:21:45,000 --> 00:21:47,000
És végül, akkor is ezt,

358
00:21:47,000 --> 00:21:52,000
int x = 65, és akkor nyilvánítja a char c = x,

359
00:21:52,000 --> 00:21:56,000
majd ha kinyomtatja a c te tényleg fog kapni

360
00:21:56,000 --> 00:21:59,000
Az, hogy alapvetően mit csinálsz itt

361
00:21:59,000 --> 00:22:02,000
A fordításának értéke a karakter,

362
00:22:02,000 --> 00:22:05,000
csakúgy, mint az ASCII táblázat nem.

363
00:22:05,000 --> 00:22:08,000
Mi is beszéltünk matematikai operátorok.

364
00:22:08,000 --> 00:22:14,000
Legtöbbjük nagyon egyszerű, így a +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
és mi is beszélgettünk mod, amely a fennmaradó egy részlege 2 szám.

366
00:22:20,000 --> 00:22:23,000
Ha a 10%-ot 3, például,

367
00:22:23,000 --> 00:22:27,000
ez azt jelenti, osztani 10-3, és mi a maradék?

368
00:22:27,000 --> 00:22:30,000
Ez lesz 1, tehát ez valóban nagyon hasznos, sok a programokat.

369
00:22:30,000 --> 00:22:38,000
A Vigenère Caesar és biztos vagyok benne, hogy minden ti használt mod.

370
00:22:38,000 --> 00:22:43,000
A matematikai operátorok, legyen nagyon óvatos, amikor kombinálja * és /.

371
00:22:43,000 --> 00:22:48,000
>> Például, ha nem (3/2) * 2 mit fog kapni?

372
00:22:48,000 --> 00:22:50,000
[Diákok] 2.

373
00:22:50,000 --> 00:22:54,000
Igen, 2, mert a 3/2 lesz 1,5,

374
00:22:54,000 --> 00:22:57,000
de mivel csinálsz műveletek között 2 egész szám

375
00:22:57,000 --> 00:22:59,000
te tényleg csak úgy, hogy fontolja meg 1,

376
00:22:59,000 --> 00:23:03,000
majd az 1 * 2 lesz 2, ezért legyen nagyon óvatos

377
00:23:03,000 --> 00:23:07,000
amikor egy számtani egészek, mert

378
00:23:07,000 --> 00:23:12,000
lehet hogy kapsz egy 2 = 3, ebben az esetben.

379
00:23:12,000 --> 00:23:14,000
És azt is nagyon óvatos elsőbbséget.

380
00:23:14,000 --> 00:23:21,000
Akkor általában használ zárójeleket kell arról, hogy tudod, mit csinálsz.

381
00:23:21,000 --> 00:23:27,000
Néhány hasznos hivatkozások, persze, az egyik i + + vagy az i + = 1

382
00:23:27,000 --> 00:23:30,000
vagy használ + =.

383
00:23:30,000 --> 00:23:34,000
Ez ugyanaz, mint ennek i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Azt is tudom - vagy i - = 1,

385
00:23:39,000 --> 00:23:42,000
ami ugyanaz, mint i = i -1,

386
00:23:42,000 --> 00:23:46,000
valami srácok használja sokat a hurkok, legalább.

387
00:23:46,000 --> 00:23:52,000
Is, a *, ha használja a * = és ha igen, például,

388
00:23:52,000 --> 00:23:57,000
i * = 2, az ugyanaz, mint a mondás i = i * 2,

389
00:23:57,000 --> 00:23:59,000
és ugyanezt alá.

390
00:23:59,000 --> 00:24:08,000
Ha nem i / = 2 ez ugyanaz, mint i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Most körülbelül funkciók.

392
00:24:10,000 --> 00:24:13,000
Srácok, megtudta, hogy a funkciók egy nagyon jó stratégia, hogy mentse-kód

393
00:24:13,000 --> 00:24:16,000
közben programozása, ezért ha azt szeretnénk, hogy végezze el ugyanazt a feladatot

394
00:24:16,000 --> 00:24:20,000
kódot újra és újra, valószínűleg használni kívánt funkció

395
00:24:20,000 --> 00:24:25,000
Csak így nem kell másolni és beilleszteni a kódot újra és újra.

396
00:24:25,000 --> 00:24:28,000
Valójában, a fő egy olyan funkció, és amikor megmutatom a formátum egy függvény

397
00:24:28,000 --> 00:24:32,000
fogod látni, hogy ez elég nyilvánvaló.

398
00:24:32,000 --> 00:24:35,000
Arra is használjuk a funkciók bizonyos könyvtárak,

399
00:24:35,000 --> 00:24:39,000
például printf, GetIn bonyolódik, a CS50 könyvtár,

400
00:24:39,000 --> 00:24:43,000
és egyéb funkciók, mint például toupper.

401
00:24:43,000 --> 00:24:46,000
Az összes említett funkció ténylegesen megvalósított más könyvtárak,

402
00:24:46,000 --> 00:24:49,000
és ha fel azokat hevederrögzítési fájlok elején a program

403
00:24:49,000 --> 00:24:53,000
azt mondod, legyen szíves add meg a kódot ezeket a funkciókat

404
00:24:53,000 --> 00:24:57,000
így nem kell végrehajtani őket magam?

405
00:24:57,000 --> 00:25:00,000
És te is írni a saját funkcióját, így amikor elindítja programozás

406
00:25:00,000 --> 00:25:04,000
rájössz, hogy a könyvtárak nem rendelkeznek az összes funkciót, hogy szükség van.

407
00:25:04,000 --> 00:25:10,000
Az utolsó Pset, például írtunk dolgozzon, tülekedés, és keresési,

408
00:25:10,000 --> 00:25:13,000
és ez nagyon-nagyon fontos, hogy képes legyen írni funkciók

409
00:25:13,000 --> 00:25:17,000
mert hasznos, és mi használjuk őket minden alkalommal a programozás,

410
00:25:17,000 --> 00:25:19,000
és ez ment egy csomó kódot.

411
00:25:19,000 --> 00:25:21,000
A formátum a funkció ez.

412
00:25:21,000 --> 00:25:24,000
Van visszatérési típus az elején. Mi a visszatérési típus?

413
00:25:24,000 --> 00:25:27,000
Csak, ha a funkció megy vissza.

414
00:25:27,000 --> 00:25:29,000
Ha van egy funkció, például a faktoriális,

415
00:25:29,000 --> 00:25:31,000
hogy fog számítani a faktoriálisát egész szám,

416
00:25:31,000 --> 00:25:34,000
Valószínűleg ez lesz, hogy visszatérjen egy egész is.

417
00:25:34,000 --> 00:25:37,000
Ezután a visszatérési típus lesz int.

418
00:25:37,000 --> 00:25:41,000
Printf valójában egy visszatérési típusa void

419
00:25:41,000 --> 00:25:43,000
azért, mert te nem küldött vissza semmit.

420
00:25:43,000 --> 00:25:45,000
Te csak nyomtat dolgokat a képernyőn

421
00:25:45,000 --> 00:25:48,000
és kilépés a funkció utána.

422
00:25:48,000 --> 00:25:51,000
Akkor a nevét a funkció közül választhat.

423
00:25:51,000 --> 00:25:55,000
Meg kell egy kicsit elfogadható, mint a nem, válasszon egy nevet, mint xyz

424
00:25:55,000 --> 00:25:58,000
vagy hasonló x2F.

425
00:25:58,000 --> 00:26:02,000
Próbáld ki, hogy egy nevet, hogy van értelme.

426
00:26:02,000 --> 00:26:04,000
>> Például, ha ez faktoriális, mondjuk faktoriális.

427
00:26:04,000 --> 00:26:08,000
Ha ez a funkció, hogy megy, hogy készítsen valamit, nevezd meg rajzolni.

428
00:26:08,000 --> 00:26:11,000
És akkor mi van a paraméterek, amelyek szintén nevezik érveket,

429
00:26:11,000 --> 00:26:14,000
amelyek olyanok, mint a források, hogy a funkció szüksége

430
00:26:14,000 --> 00:26:17,000
saját kód feladatát elvégezze.

431
00:26:17,000 --> 00:26:20,000
Ha szeretné kiszámítani Egy szám faktoriálisát

432
00:26:20,000 --> 00:26:23,000
Valószínűleg szükség van egy sor kiszámításához faktoriális.

433
00:26:23,000 --> 00:26:27,000
Az egyik érv, hogy te megy, hogy a szám maga.

434
00:26:27,000 --> 00:26:31,000
És akkor fog valamit csinálni, és visszatér az értéket a végén

435
00:26:31,000 --> 00:26:35,000
kivéve, ha ez egy void függvény.

436
00:26:35,000 --> 00:26:37,000
Nézzünk egy példát.

437
00:26:37,000 --> 00:26:40,000
Ha akarok írni egy függvényt, amely összegzi a számokat egy tömbben egész számok,

438
00:26:40,000 --> 00:26:43,000
Először is, a visszatérési típus lesz int

439
00:26:43,000 --> 00:26:46,000
mert van egy sor egészek.

440
00:26:46,000 --> 00:26:51,000
És akkor megyek, ha a függvény neve, mint a sumArray,

441
00:26:51,000 --> 00:26:54,000
és akkor fog tartani magát a tömböt, hogy int nums,

442
00:26:54,000 --> 00:26:58,000
majd a hossza a tömb, így tudom, hány szám van összefoglalni.

443
00:26:58,000 --> 00:27:02,000
Aztán kell inicializálni egy változó hívott összeg, például a 0,

444
00:27:02,000 --> 00:27:08,000
és minden alkalommal látok egy elemet a tömb hozzá kell tennem, hogy összeget, ezért csináltam egy for ciklus.

445
00:27:08,000 --> 00:27:15,000
Ahogy Lexi azt mondta, te int i = 0, i <hossz és az I + +.

446
00:27:15,000 --> 00:27:20,000
És minden egyes elem a tömbben tettem összeg + = nums [i],

447
00:27:20,000 --> 00:27:24,000
és aztán vissza az összeget, így nagyon egyszerű, és ez ment egy csomó kód

448
00:27:24,000 --> 00:27:28,000
ha ezt a funkciót használja sokszor.

449
00:27:28,000 --> 00:27:32,000
Aztán vett egy pillantást a feltételeket.

450
00:27:32,000 --> 00:27:38,000
Van, ha más, és más, ha.

451
00:27:38,000 --> 00:27:42,000
Lássuk, mi a különbség a között.

452
00:27:42,000 --> 00:27:45,000
Vessen egy pillantást a 2 kódok. Mi a különbség a kettő között?

453
00:27:45,000 --> 00:27:49,000
Az első már-alapvetően a kódokat akarom, hogy mondd

454
00:27:49,000 --> 00:27:51,000
ha a szám +, -, vagy 0.

455
00:27:51,000 --> 00:27:55,000
Az első azt mondja, ha ez> 0, akkor ez pozitív.

456
00:27:55,000 --> 00:28:00,000
Ha ez az = 0, akkor ez 0, és ha ez <0, akkor ez negatív.

457
00:28:00,000 --> 00:28:04,000
>> És a másik csinál, ha mást, ha mást.

458
00:28:04,000 --> 00:28:07,000
A különbség a kettő között az, hogy ez a most éppen fog

459
00:28:07,000 --> 00:28:13,000
ellenőrizze,> 0, <0 vagy = 0 háromszor,

460
00:28:13,000 --> 00:28:17,000
így ha a 2-es szám, például ez lesz, hogy jöjjön ide, és mondja

461
00:28:17,000 --> 00:28:21,000
if (x> 0), és ez fogja mondani, hogy igen, úgyhogy nyomtatni pozitív.

462
00:28:21,000 --> 00:28:25,000
De annak ellenére, hogy tudom, hogy ez> 0, és ez nem lesz 0 vagy <0

463
00:28:25,000 --> 00:28:29,000
Én még mindig csinálni ez 0, ez <0,

464
00:28:29,000 --> 00:28:33,000
úgyhogy tényleg lesz benne az IFS, hogy nem kell

465
00:28:33,000 --> 00:28:38,000
mert már tudom, hogy ez nem fog kielégíteni minden ilyen feltételeket.

466
00:28:38,000 --> 00:28:41,000
Tudom használni, ha else if, else utasítás.

467
00:28:41,000 --> 00:28:45,000
Ez alapvetően azt mondja, ha x = 0 I nyomtatása pozitív.

468
00:28:45,000 --> 00:28:48,000
Ha ez nem, megyek is tesztelni ezt.

469
00:28:48,000 --> 00:28:51,000
Ha ez 2 nem fogom ezt tenni.

470
00:28:51,000 --> 00:28:54,000
Alapvetően ha már x = 2, akkor azt mondanám,

471
00:28:54,000 --> 00:28:57,000
if (x> 0), igen, így kinyomtatni.

472
00:28:57,000 --> 00:29:00,000
Most, hogy tudom, hogy ez> 0 és hogy teljesülnek az első, ha

473
00:29:00,000 --> 00:29:02,000
Én nem is fogja futtatni ezt a kódot.

474
00:29:02,000 --> 00:29:09,000
A kód gyorsabban fut, valójában 3-szor gyorsabb, ha ezt használja.

475
00:29:09,000 --> 00:29:11,000
Mi is tanultunk és és vagy.

476
00:29:11,000 --> 00:29:15,000
Én nem megyek át, mert Lexi már beszéltem róluk.

477
00:29:15,000 --> 00:29:17,000
Ez csak a && és | | operátor.

478
00:29:17,000 --> 00:29:21,000
>> Az egyetlen dolog, azt mondom ez legyen óvatos, ha van 3 feltételeket.

479
00:29:21,000 --> 00:29:24,000
Használj zárójeleket, mert ez nagyon zavaró, ha van egy állapot

480
00:29:24,000 --> 00:29:27,000
és egy másik, vagy egy másikat.

481
00:29:27,000 --> 00:29:30,000
Használj zárójeleket, csak hogy biztos, hogy a feltételek értelme

482
00:29:30,000 --> 00:29:34,000
mert ebben az esetben például, el lehet képzelni, hogy a

483
00:29:34,000 --> 00:29:38,000
ez lehet az első feltétel, és egy vagy a másik

484
00:29:38,000 --> 00:29:41,000
vagy a 2 feltételek kombinált egy és

485
00:29:41,000 --> 00:29:45,000
illetve a harmadik, úgyhogy légy óvatos.

486
00:29:45,000 --> 00:29:48,000
És végül, beszélgettünk kapcsolók.

487
00:29:48,000 --> 00:29:53,000
A kapcsoló nagyon hasznos, ha van egy változó.

488
00:29:53,000 --> 00:29:55,000
Tegyük fel, hogy van egy változó, mint n

489
00:29:55,000 --> 00:29:59,000
amely lehet 0, 1, vagy 2, és minden egyes ilyen esetek

490
00:29:59,000 --> 00:30:01,000
fogsz egy feladatot.

491
00:30:01,000 --> 00:30:04,000
Azt lehet mondani, kapcsoljuk be a változó, és azt jelzi, hogy

492
00:30:04,000 --> 00:30:08,000
az érték, akkor olyan, mint érték1 fogom ezt tenni,

493
00:30:08,000 --> 00:30:12,000
és aztán szünet, ami azt jelenti, nem fogom nézni bármely más esetben

494
00:30:12,000 --> 00:30:15,000
mert már meggyőződtek arról, hogy az esetben

495
00:30:15,000 --> 00:30:20,000
majd érték2, és így tovább, és én is egy alapértelmezett kapcsoló.

496
00:30:20,000 --> 00:30:24,000
Ez azt jelenti, ha az nem felel meg olyan esetekben, hogy volt

497
00:30:24,000 --> 00:30:29,000
hogy fogok csinálni valami mást, de ez nem kötelező.

498
00:30:29,000 --> 00:30:36,000
Ennyi nekem. Most vessünk Tommy.

499
00:30:36,000 --> 00:30:41,000
Rendben, ez lesz a héten 3-ish.

500
00:30:41,000 --> 00:30:45,000
Ezek közül néhány a témák fogunk kiterjedő, crypto, hatály, tömbök, satöbbi.

501
00:30:45,000 --> 00:30:49,000
Csak egy gyors szót crypto. Nem megyünk a kalapács e haza.

502
00:30:49,000 --> 00:30:52,000
>> Tettük ezt Pset 2, de a kvíz győződjön meg arról, mi a különbség

503
00:30:52,000 --> 00:30:54,000
között a Caesar titkosítás és a Vigenère titkosítást,

504
00:30:54,000 --> 00:30:57,000
milyen e két titkosítási munka és milyen érzés, hogy titkosítja

505
00:30:57,000 --> 00:30:59,000
és dekódolja szöveget E 2 titkosítást.

506
00:30:59,000 --> 00:31:03,000
Ne feledje, a Caesar titkosítás egyszerűen elfordul minden karaktert az azonos mennyiségű,

507
00:31:03,000 --> 00:31:06,000
ügyelve arra, hogy mod száma betűk az ábécé.

508
00:31:06,000 --> 00:31:09,000
És a Vigenère rejtjel, másrészt, forog az egyes karakterek

509
00:31:09,000 --> 00:31:12,000
egy másik összeget, így ahelyett, mondván:

510
00:31:12,000 --> 00:31:15,000
minden karakter forgatható 3 Vigenère forogni fog minden egyes karakter

511
00:31:15,000 --> 00:31:17,000
egy másik összeget, attól függően néhány kulcsszó

512
00:31:17,000 --> 00:31:20,000
ahol minden egyes levél a kulcsszó jelentése néhány eltérő összeg

513
00:31:20,000 --> 00:31:26,000
forgatni a tiszta szöveget.

514
00:31:26,000 --> 00:31:28,000
Nézzük először beszélni változó hatályát.

515
00:31:28,000 --> 00:31:30,000
Vannak 2 különböző típusú változók.

516
00:31:30,000 --> 00:31:33,000
Van lokális változók, és ezek fogják meghatározni

517
00:31:33,000 --> 00:31:36,000
ezen kívül a fő vagy azon kívül minden olyan funkciót, vagy blokk,

518
00:31:36,000 --> 00:31:39,000
és ezek lesz elérhető bárhol a programban.

519
00:31:39,000 --> 00:31:41,000
Ha van egy funkció, és ezzel a feladattal a while

520
00:31:41,000 --> 00:31:44,000
A nagy globális változó elérhető mindenhol.

521
00:31:44,000 --> 00:31:48,000
Egy helyi változót, a másik viszont hatókörű arra a helyre, ahol meg van határozva.

522
00:31:48,000 --> 00:31:53,000
>> Ha van egy funkciója van, például, van ez a funkció g,

523
00:31:53,000 --> 00:31:56,000
és belső A g-van egy változó itt nevű y,

524
00:31:56,000 --> 00:31:58,000
és ez azt jelenti, hogy ez egy helyi változó.

525
00:31:58,000 --> 00:32:00,000
Annak ellenére, hogy ez a változó neve y

526
00:32:00,000 --> 00:32:03,000
és ez a változó neve y e 2 funkció

527
00:32:03,000 --> 00:32:06,000
Fogalmam sincs, mi egymás lokális változók.

528
00:32:06,000 --> 00:32:10,000
Másrészt, fel itt azt mondjuk, int x = 5,

529
00:32:10,000 --> 00:32:12,000
és ez kívül esik minden funkciót.

530
00:32:12,000 --> 00:32:16,000
Ez hatályán kívül legfontosabb, így ez egy globális változót.

531
00:32:16,000 --> 00:32:20,000
Ez azt jelenti, hogy a belső e 2 akkor működik, ha azt mondom, x - x vagy + +

532
00:32:20,000 --> 00:32:26,000
Én éri el ugyanazt x amely e y és y e különböző változók.

533
00:32:26,000 --> 00:32:30,000
Ez a különbség egy globális változó, és egy helyi változót.

534
00:32:30,000 --> 00:32:33,000
Ami a design illeti, néha talán jobb ötlet

535
00:32:33,000 --> 00:32:37,000
tartani a helyi változók, amikor csak lehetséges

536
00:32:37,000 --> 00:32:39,000
mivel tekintettel egy csomó globális változók igazán zavaró.

537
00:32:39,000 --> 00:32:42,000
Ha van egy csomó funkció valamennyi módosító ugyanazt

538
00:32:42,000 --> 00:32:45,000
lehet elfelejteni mi van, ha ezt a funkciót véletlenül módosítja ezt a globális,

539
00:32:45,000 --> 00:32:47,000
és ez az egyéb funkció nem tud róla,

540
00:32:47,000 --> 00:32:50,000
és nem kap elég zavaró, ahogy minél több kódot.

541
00:32:50,000 --> 00:32:53,000
Tartása változók helyi amikor csak lehetséges

542
00:32:53,000 --> 00:32:56,000
csak a jó design.

543
00:32:56,000 --> 00:33:00,000
Tömbök, ne feledd, egyszerűen listák elemeinek az azonos típusú.

544
00:33:00,000 --> 00:33:04,000
Belül CI nem lehet a listán, mint 1, 2,0, hello.

545
00:33:04,000 --> 00:33:06,000
Csak nem tehetjük.

546
00:33:06,000 --> 00:33:11,000
>> Amikor állapítsa tömb C-ben minden elemet kell lennie, azonos típusú.

547
00:33:11,000 --> 00:33:14,000
Itt van egy sor 3 egészek.

548
00:33:14,000 --> 00:33:18,000
Itt van a hossza a tömb, de ha én csak megállapító e szintaxis

549
00:33:18,000 --> 00:33:21,000
ahol nevezze meg az összes elem tudom technikailag nem kell ebben a 3.

550
00:33:21,000 --> 00:33:25,000
A fordító elég okos ahhoz, hogy kitaláljuk, milyen nagy a tömb kell.

551
00:33:25,000 --> 00:33:28,000
Most, amikor akarok, vagy állítsa az értéket egy tömb

552
00:33:28,000 --> 00:33:30,000
ez a szintaxis erre.

553
00:33:30,000 --> 00:33:33,000
Ez valóban módosítja a második eleme a tömb, mert emlékszem,

554
00:33:33,000 --> 00:33:36,000
számozás 0-tól indul, nem pedig 1.

555
00:33:36,000 --> 00:33:42,000
Ha azt szeretnénk, hogy olvastam, hogy értéket tudok mondani valamit, mint int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Vagy ha azt szeretnénk beállítani ezt az értéket, mint csinálok itt,

557
00:33:44,000 --> 00:33:47,000
Azt lehet mondani, array [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Ez az idő elérése elemeket azok index

559
00:33:50,000 --> 00:33:52,000
vagy pozíció vagy ha azok a tömbben,

560
00:33:52,000 --> 00:33:57,000
és hogy a tőzsdei 0-tól indul.

561
00:33:57,000 --> 00:34:00,000
Azt is, hogy tömbök tömbök,

562
00:34:00,000 --> 00:34:03,000
és ezt hívják multi-dimenziós tömb.

563
00:34:03,000 --> 00:34:05,000
Ha van egy több dimenziós tömb

564
00:34:05,000 --> 00:34:07,000
azt jelenti, hogy mi is van valami hasonló sorok és oszlopok

565
00:34:07,000 --> 00:34:11,000
és ez csak az egyik módja a vizualizációs ez vagy rágondolok.

566
00:34:11,000 --> 00:34:14,000
Ha van egy több dimenziós tömb azt jelenti, hogy fogok kezdeni szüksége

567
00:34:14,000 --> 00:34:17,000
Több mint 1 index, mert ha van egy rács

568
00:34:17,000 --> 00:34:19,000
csak azt mondom, amit a sorban vagyunk, nem ad nekünk egy számot.

569
00:34:19,000 --> 00:34:22,000
Ez tényleg csak fog adni nekünk egy listát a számok.

570
00:34:22,000 --> 00:34:25,000
Tegyük fel, hogy van ez a tömb van.

571
00:34:25,000 --> 00:34:30,000
Van egy sor úgynevezett grid, és azt mondom, hogy a 2 sort és 3 oszlopot,

572
00:34:30,000 --> 00:34:32,000
és így ez az egyik módja a megjelenítésére is.

573
00:34:32,000 --> 00:34:37,000
Amikor azt mondom, azt akarom, hogy az elem a [1] [2]

574
00:34:37,000 --> 00:34:41,000
azt jelenti, hogy mivel ezek a sorok, majd az első oszlop

575
00:34:41,000 --> 00:34:44,000
Fogok ugrani 1 sor, mert én mondtam 1.

576
00:34:44,000 --> 00:34:49,000
>> Akkor fogok gyere ide, hogy a 2. oszlopban, és megyek, hogy az érték 6.

577
00:34:49,000 --> 00:34:51,000
Értelme?

578
00:34:51,000 --> 00:34:55,000
Többdimenziós tömbök, ne feledd, technikailag csak egy sor tömbök.

579
00:34:55,000 --> 00:34:57,000
Mi lehet tömbök tömbök tömbök.

580
00:34:57,000 --> 00:35:00,000
Mi folyamatosan megy, de valóban az egyik módja annak, hogy gondolni

581
00:35:00,000 --> 00:35:03,000
hogyan kerül megállapított, és mi van, hogy elképzelni is

582
00:35:03,000 --> 00:35:09,000
egy rács, mint ez.

583
00:35:09,000 --> 00:35:12,000
Amikor át tömbök a funkciókat, ők fognak viselkedni

584
00:35:12,000 --> 00:35:16,000
egy kicsit másképp, mint amikor át rendszeres változók funkciók

585
00:35:16,000 --> 00:35:18,000
mint a tompított int vagy float.

586
00:35:18,000 --> 00:35:21,000
Amikor át egy int vagy char vagy ezek más adattípusok

587
00:35:21,000 --> 00:35:24,000
épp most vett egy pillantást, ha a funkció módosítja

588
00:35:24,000 --> 00:35:28,000
értékét a változó, hogy a változás nem fog terjeszteni up

589
00:35:28,000 --> 00:35:32,000
a hívó funkciót.

590
00:35:32,000 --> 00:35:35,000
Egy sor, másrészt, hogy a fog történni.

591
00:35:35,000 --> 00:35:39,000
Ha elmegyek egy tömbben néhány funkció és a funkció megváltoztatja egyes elemei,

592
00:35:39,000 --> 00:35:43,000
mikor jön vissza a funkció nevezték

593
00:35:43,000 --> 00:35:47,000
a tömb most lesz más, és a szókincs az adott

594
00:35:47,000 --> 00:35:50,000
a tömbök kerülnek átadásra való hivatkozással, mint látni fogjuk később.

595
00:35:50,000 --> 00:35:53,000
Ez összefügg azzal, hogy a munka mutatókat, amennyiben ezeket az alapvető adattípusok,

596
00:35:53,000 --> 00:35:55,000
másrészt, szerint adódnak át érték.

597
00:35:55,000 --> 00:35:59,000
>> Azt gondolni, hogy mivel a másolás néhány változó, majd halad a másolatot.

598
00:35:59,000 --> 00:36:01,000
Nem számít, hogy mit teszünk, hogy változó.

599
00:36:01,000 --> 00:36:06,000
A hívó függvény nem lesz tisztában azzal, hogy megváltozott.

600
00:36:06,000 --> 00:36:10,000
Tömbök csak egy kicsit más ebben a tekintetben.

601
00:36:10,000 --> 00:36:13,000
Például, amint azt most láttuk, a fő-egyszerűen egy függvény

602
00:36:13,000 --> 00:36:15,000
amely át tudja venni a 2 érveket.

603
00:36:15,000 --> 00:36:20,000
Az első érv, hogy a fő funkciója argc, vagy a számos érvet,

604
00:36:20,000 --> 00:36:23,000
és a második argumentum neve argv,

605
00:36:23,000 --> 00:36:27,000
és ezek a pillanatnyi értékeket ezen érvek.

606
00:36:27,000 --> 00:36:30,000
Tegyük fel, hogy van egy program neve this.c,

607
00:36:30,000 --> 00:36:34,000
és azt mondom, hogy ez, és én fogom futtatni ezt a parancsot.

608
00:36:34,000 --> 00:36:38,000
Most, hogy át néhány érvet a saját nevű program ezt

609
00:36:38,000 --> 00:36:42,000
Tudnék mondani valamit, mint a. / Ez cs 50.

610
00:36:42,000 --> 00:36:45,000
Ez az, amit elképzelni David csinálni minden nap a terminált.

611
00:36:45,000 --> 00:36:48,000
De most a fő funkciója belsejében, hogy a program

612
00:36:48,000 --> 00:36:52,000
vannak ezek az értékek, így argc 4 lehet.

613
00:36:52,000 --> 00:36:56,000
Lehet, hogy egy kicsit zavaró, mert tényleg mi csak halad a cs 50.

614
00:36:56,000 --> 00:36:58,000
Ez csak 3.

615
00:36:58,000 --> 00:37:02,000
De ne feledjük, hogy az első eleme argv vagy az első argumentum

616
00:37:02,000 --> 00:37:05,000
a neve a funkció is.

617
00:37:05,000 --> 00:37:07,190
Tehát ez azt jelenti, hogy 4 dolog van,

618
00:37:07,190 --> 00:37:10,530
és az első elem lesz. / ezt.

619
00:37:10,530 --> 00:37:12,970
És ez lesz képviseli, mint egy húr.

620
00:37:12,970 --> 00:37:18,590
Ezután a többi elem, amit beírt neve után a program.

621
00:37:18,590 --> 00:37:22,720
Tehát csak mint egy félre, ahogy valószínűleg látta Pset 2,

622
00:37:22,720 --> 00:37:28,780
ne feledjük, hogy a szöveg 50-≠ az egész 50.

623
00:37:28,780 --> 00:37:32,520
Tehát nem lehet azt mondani valamit, mint a "int x = argv 3.

624
00:37:32,520 --> 00:37:36,470
>> Ez egyszerűen nem megy, hogy értelme, mert ez egy string, és ez egy egész szám.

625
00:37:36,470 --> 00:37:38,510
Tehát, ha szeretné konvertálni a 2, ne feledd, fogunk

626
00:37:38,510 --> 00:37:40,810
ezt a mágikus nevezett funkció atoi.

627
00:37:40,810 --> 00:37:46,270
Hogy vesz egy karakterláncot, és visszaadja az egész képviselő belül az adott string.

628
00:37:46,270 --> 00:37:48,360
Szóval ez egy egyszerű hiba, hogy a kvíz,

629
00:37:48,360 --> 00:37:51,590
Csak arra gondoltam, hogy ez automatikusan a megfelelő típusú.

630
00:37:51,590 --> 00:37:53,860
De tudjuk, hogy ezek mindig karakterláncok

631
00:37:53,860 --> 00:38:00,920
még akkor is, ha a húr csak tartalmaz egy egész, vagy egy karakter vagy egy úszó.

632
00:38:00,920 --> 00:38:03,380
És most beszéljünk működési idő.

633
00:38:03,380 --> 00:38:06,700
Amikor minden ilyen algoritmusok mindent megtesz ezek az őrült dolgokat,

634
00:38:06,700 --> 00:38:11,580
válik igazán hasznos feltenni a kérdést: "Mennyi ideig nem vesznek?"

635
00:38:11,580 --> 00:38:15,500
Azt kijelenti, hogy valami úgynevezett aszimptotikus jelöléssel.

636
00:38:15,500 --> 00:38:18,430
Tehát ez azt jelenti, hogy - nos, mondjuk azt, hogy mi a algoritmust

637
00:38:18,430 --> 00:38:20,840
Néhány nagyon, nagyon, nagyon nagy bemenet.

638
00:38:20,840 --> 00:38:23,840
Szeretnénk feltenni a kérdést: "Meddig fog ez tartani?

639
00:38:23,840 --> 00:38:26,370
Hány lépést fog tartani a mi algoritmus futtatásához

640
00:38:26,370 --> 00:38:29,980
függvényében a méret a bemenet? "

641
00:38:29,980 --> 00:38:33,080
Tehát az első lehetőség, hogy írni fut az idő a nagy O.

642
00:38:33,080 --> 00:38:35,380
És ez a mi legrosszabb futás idő.

643
00:38:35,380 --> 00:38:38,590
Tehát, ha azt akarjuk, hogy rendezni egy tömb, és hogy mi algoritmus egy tömb

644
00:38:38,590 --> 00:38:41,000
ez csökkenő sorrendben, amikor kell lennie növekvő sorrendben,

645
00:38:41,000 --> 00:38:43,130
ez lesz a legrosszabb esetben.

646
00:38:43,130 --> 00:38:49,800
Ez a mi felső határa a maximális időtartamot algoritmusunk fog.

647
00:38:49,800 --> 00:38:54,740
Másrészt, ez Ω fog leírni legjobb eset működési idő.

648
00:38:54,740 --> 00:38:58,210
Tehát, ha adunk egy már rendezett tömbben egy válogató algoritmus,

649
00:38:58,210 --> 00:39:00,940
mennyi ideig fog tartani, hogy rendezni ez?

650
00:39:00,940 --> 00:39:06,610
És ez, majd leír egy alsó korlátot a működési idő.

651
00:39:06,610 --> 00:39:10,980
Tehát itt van, csak néhány szót, amelyek leírják néhány gyakori üzemidő.

652
00:39:10,980 --> 00:39:13,120
Ezek növekvő sorrendben.

653
00:39:13,120 --> 00:39:16,060
A leggyorsabb futási idő van az úgynevezett állandó.

654
00:39:16,060 --> 00:39:19,800
>> Ez azt jelenti, nem számít, hány elemet adunk meg algoritmus,

655
00:39:19,800 --> 00:39:22,280
nem számít, milyen nagy a tömb, válogatás az

656
00:39:22,280 --> 00:39:26,510
avagy bármit csinálunk a tömb mindig ugyanannyi idő alatt.

657
00:39:26,510 --> 00:39:30,270
Így tudjuk képviselt, hogy csak egy 1, amely egy konstans.

658
00:39:30,270 --> 00:39:32,410
Mi is nézett logaritmikus futási időben.

659
00:39:32,410 --> 00:39:34,800
Tehát valami hasonló bináris keresés logaritmikus,

660
00:39:34,800 --> 00:39:37,140
ha vágjuk a probléma felében minden alkalommal

661
00:39:37,140 --> 00:39:40,970
és akkor a dolgok csak kap magasabb onnan.

662
00:39:40,970 --> 00:39:43,580
És ha valaha is írt egy O minden faktoriális algoritmus,

663
00:39:43,580 --> 00:39:47,850
akkor valószínűleg nem kell figyelembe ezt, mint a napi munkát.

664
00:39:47,850 --> 00:39:53,910
Ha összevetjük üzemidő fontos szem előtt tartani ezeket a dolgokat.

665
00:39:53,910 --> 00:39:57,760
Tehát, ha van egy olyan algoritmust, ami O (n), és valaki más

666
00:39:57,760 --> 00:40:03,590
már egy algoritmus O (2n) ezek valójában aszimptotikusan ekvivalens.

667
00:40:03,590 --> 00:40:06,590
Tehát, ha azt képzeljük, n, hogy egy nagy szám, mint eleventy milliárd:

668
00:40:06,590 --> 00:40:13,090
így amikor mi összehasonlítjuk eleventy milliárd ilyesmit eleventy milliárd + 3,

669
00:40:13,090 --> 00:40:17,640
hirtelen, hogy 3 nem igazán egy nagy különbség többé.

670
00:40:17,640 --> 00:40:20,980
Ezért fogjuk kezdeni tekintve ezek a dolgok, hogy egyenértékűek.

671
00:40:20,980 --> 00:40:24,220
Így a dolgok, mint ezek itt állandók, van 2 x e, vagy hozzáadásával a 3,

672
00:40:24,220 --> 00:40:27,180
ezek csak állandók, és ezek fognak dobni fel.

673
00:40:27,180 --> 00:40:32,480
Szóval ezért mind a 3 ilyen futási idők ugyanaz, mint azt ők O (n).

674
00:40:32,480 --> 00:40:37,490
Hasonlóképpen, ha van 2 másik futási idő, mondjuk O (n ³ + 2n ²), adjuk hozzá

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, és akkor van egy másik futási időben ez csak O (n ³).

676
00:40:42,070 --> 00:40:46,290
ismét, ezek az ugyanaz dolog, mert ezek - ezek nem azonosak.

677
00:40:46,290 --> 00:40:49,840
Ezek ugyanazok a dolgok, sajnálom. Tehát ezek az ugyanaz, mert

678
00:40:49,840 --> 00:40:53,090
ez n ³ fog uralni ezt a 2n ².

679
00:40:53,090 --> 00:40:59,130
>> Mi nem ugyanaz a dolog, ha már fut időkben O (n ³) és az O (n ²)

680
00:40:59,130 --> 00:41:02,820
mert ez N ³ jelentése sokkal nagyobb, mint ez az NZ.

681
00:41:02,820 --> 00:41:05,470
Tehát, ha van kitevő, hirtelen ez kezd számít,

682
00:41:05,470 --> 00:41:08,280
de ha mi csak foglalkozunk tényezők, mint mi itt,

683
00:41:08,280 --> 00:41:12,810
akkor ez nem lesz baj, mert ők csak lesz lemorzsolódás.

684
00:41:12,810 --> 00:41:16,760
Vessünk egy pillantást néhány algoritmusok láttuk eddig

685
00:41:16,760 --> 00:41:19,260
és beszélni a futási időt.

686
00:41:19,260 --> 00:41:23,850
Az első módszer a keresett számot a listán, hogy láttuk, volt lineáris keresés.

687
00:41:23,850 --> 00:41:26,950
És végrehajtása lineáris keresés szuper egyszerű.

688
00:41:26,950 --> 00:41:30,490
Csak van egy lista, és megyünk nézni minden egyes elem a listán

689
00:41:30,490 --> 00:41:34,260
amíg meg nem találjuk a számot keresünk.

690
00:41:34,260 --> 00:41:38,370
Tehát ez azt jelenti, hogy a legrosszabb esetben ez O (n).

691
00:41:38,370 --> 00:41:40,860
És a legrosszabb esetben is lehetne, ha az elem

692
00:41:40,860 --> 00:41:45,710
Az utolsó elem, akkor lineáris keresést meg kell nézni minden egyes elemét

693
00:41:45,710 --> 00:41:50,180
addig, amíg eljutunk az utolsó ahhoz, hogy tudjuk, hogy ez valójában a listában.

694
00:41:50,180 --> 00:41:52,910
Egyszerűen nem adja fel félúton, és azt mondják: "Valószínűleg nincs ott."

695
00:41:52,910 --> 00:41:55,980
A lineáris keresés van, hogy nézd meg az egészet.

696
00:41:55,980 --> 00:41:59,090
A legjobb esetben működési idő, a másik viszont konstans

697
00:41:59,090 --> 00:42:04,200
mert a legjobb esetben is az elem keresünk, csak az első a listán.

698
00:42:04,200 --> 00:42:08,930
Így fog vinni bennünket pontosan 1 lépés, nem számít, milyen nagy a lista

699
00:42:08,930 --> 00:42:12,140
ha keresünk, az első elemet minden alkalommal.

700
00:42:12,140 --> 00:42:15,390
>> Tehát, ha keres, ne feledd, hogy nem követeli meg, hogy a listát rendezve.

701
00:42:15,390 --> 00:42:19,430
Mert mi csak megy, hogy nézd át minden egyes elemét, és ez nem igazán számít,

702
00:42:19,430 --> 00:42:23,560
Milyen sorrendben ezek az elemek be

703
00:42:23,560 --> 00:42:28,110
Egy intelligens keresési algoritmus olyasmi, mint a bináris keresés.

704
00:42:28,110 --> 00:42:31,500
Ne feledje, a végrehajtás a bináris keresés, ha mész

705
00:42:31,500 --> 00:42:34,320
nézz a közepén a listán.

706
00:42:34,320 --> 00:42:38,000
És mert éppen a közepén, azt követeli meg, hogy a lista rendezve

707
00:42:38,000 --> 00:42:40,580
vagy pedig nem tudjuk, hogy hol a középső van, és van, hogy nézd át

708
00:42:40,580 --> 00:42:44,480
A teljes lista, hogy megtalálja, majd ezen a ponton mi csak időpocsékolás.

709
00:42:44,480 --> 00:42:48,480
Tehát ha van egy rendezett listát, és megtaláljuk a középső, fogjuk összehasonlítani a középső

710
00:42:48,480 --> 00:42:51,590
az elem keresünk.

711
00:42:51,590 --> 00:42:54,640
Ha ez túl magas, akkor tudjuk elfelejteni a jobb felét

712
00:42:54,640 --> 00:42:57,810
mert tudjuk, hogy ha a mi elem már túl magas

713
00:42:57,810 --> 00:43:01,080
és minden jobbra ez az elem még magasabb,

714
00:43:01,080 --> 00:43:02,760
akkor nem kell nézni ott többé.

715
00:43:02,760 --> 00:43:05,430
Amennyiben másrészt, ha a mi elem túl alacsony,

716
00:43:05,430 --> 00:43:08,700
tudjuk, hogy mindent a bal oldalon ez az elem is túl alacsony,

717
00:43:08,700 --> 00:43:11,390
így nem igazán értelme nézni ott sem.

718
00:43:11,390 --> 00:43:15,760
Így minden lépést, és minden alkalommal, amikor megnézzük a felezőpontja a lista

719
00:43:15,760 --> 00:43:19,060
fogunk vágni mi problémánk a felére, mert hirtelen tudjuk

720
00:43:19,060 --> 00:43:23,040
egy csomó szám, hogy nem lehet az, amit keresünk.

721
00:43:23,040 --> 00:43:26,950
>> Ebben pszeudokód ez valahogy így néz ki,

722
00:43:26,950 --> 00:43:30,990
és mert mi vágás a listát felében minden egyes alkalommal,

723
00:43:30,990 --> 00:43:34,920
a legrosszabb futási ugrik lineáris logaritmikus.

724
00:43:34,920 --> 00:43:39,260
Olyan hirtelen van bejelentkezés lépéseket annak érdekében, hogy megtalálják egy elemet a listán.

725
00:43:39,260 --> 00:43:42,460
A legjobb eset futás időben, bár még mindig állandó

726
00:43:42,460 --> 00:43:45,180
mert most, mondjuk, hogy az elem keresünk a

727
00:43:45,180 --> 00:43:48,380
mindig a pontos közepén az eredeti lista.

728
00:43:48,380 --> 00:43:52,080
Így nőhet a listán olyan nagy, mint szeretnénk, de ha az elemet keresünk, van a közepén,

729
00:43:52,080 --> 00:43:54,910
akkor ez csak akkor fog minket 1 lépés.

730
00:43:54,910 --> 00:44:00,920
Szóval ezért vagyunk O (log n) és Ω (1) vagy állandó.

731
00:44:00,920 --> 00:44:04,510
Nézzük ténylegesen megtett bináris keresés ezen a listán.

732
00:44:04,510 --> 00:44:08,020
Szóval azt mondják, hogy amit keresünk az elem 164.

733
00:44:08,020 --> 00:44:11,650
Az első dolog, fogunk tennie, hogy megtalálja a felezőpontja ezt a listát.

734
00:44:11,650 --> 00:44:15,060
Ez csak azért történik, hogy a középpont fog esni közötti 2 szám,

735
00:44:15,060 --> 00:44:18,960
úgyhogy csak önkényesen mondjuk, minden alkalommal, amikor a középpont esik a 2 számot,

736
00:44:18,960 --> 00:44:21,150
mondjuk csak felhajt.

737
00:44:21,150 --> 00:44:24,330
Csak meg kell győződjön meg róla, tesszük ezt minden lépésnél.

738
00:44:24,330 --> 00:44:29,040
Szóval megy felhajt, és fogjuk azt mondani, hogy 161 a középső a mi listáját.

739
00:44:29,040 --> 00:44:34,640
So 161 <164, és minden eleme balra 161

740
00:44:34,640 --> 00:44:39,120
is <164, így tudjuk, hogy ez nem fog segíteni nekünk egyáltalán

741
00:44:39,120 --> 00:44:42,690
kezdeni ide, mert az elem keresünk, nem lehet ott.

742
00:44:42,690 --> 00:44:47,060
Szóval mit tehetünk mi, csak felejtsd el, hogy az egész bal fele a lista

743
00:44:47,060 --> 00:44:51,700
és most csak úgy a jobb a 161 kezdve.

744
00:44:51,700 --> 00:44:54,050
>> Tehát még egyszer, ez a középpont, mondjuk csak felhajt.

745
00:44:54,050 --> 00:44:56,260
Most 175 túl nagy.

746
00:44:56,260 --> 00:44:59,180
Tehát tudjuk, hogy ez nem fog segíteni nekünk keres itt vagy itt,

747
00:44:59,180 --> 00:45:06,610
így tudjuk csak dobja azt el, és végül mi nyomja a 164.

748
00:45:06,610 --> 00:45:10,560
Bármilyen kérdésre bináris keresés?

749
00:45:10,560 --> 00:45:14,180
Menjünk el az kereső segítségével egy már rendezett lista

750
00:45:14,180 --> 00:45:17,660
ténylegesen figyelembe számok listájának bármilyen sorrendben

751
00:45:17,660 --> 00:45:20,960
és hogy ezt a listát növekvő sorrendben.

752
00:45:20,960 --> 00:45:24,060
Az első algoritmust néztük hívták bubble sort.

753
00:45:24,060 --> 00:45:27,300
És ez lenne egyszerűbb az algoritmus, amit láttunk.

754
00:45:27,300 --> 00:45:32,970
Bubble sort azt mondja, hogy ha bármelyik 2 elem belsejében a listán a helyén,

755
00:45:32,970 --> 00:45:36,500
vagyis van egy nagyobb számú balra egy kisebb számú,

756
00:45:36,500 --> 00:45:40,190
akkor fogunk cserélni őket, mert ez azt jelenti, hogy a lista lesz

757
00:45:40,190 --> 00:45:42,860
"Több rendezett", mint korábban volt.

758
00:45:42,860 --> 00:45:45,180
És mi csak folytatjuk ezt a folyamatot újra és újra és újra

759
00:45:45,180 --> 00:45:52,100
amíg végül az elemek milyen buborék azok megfelelő helyre, és van egy rendezett listát.

760
00:45:52,100 --> 00:45:57,230
>> A futási idő ennek lesz O (n ²). Miért?

761
00:45:57,230 --> 00:46:00,370
Nos, azért, mert a legrosszabb esetben, megyünk, hogy minden elem, és

762
00:46:00,370 --> 00:46:04,570
fogunk a végén összehasonlítva minden más elemet a listában.

763
00:46:04,570 --> 00:46:08,030
De a legjobb esetben, van egy már rendezett lista, bubble sort a

764
00:46:08,030 --> 00:46:12,230
Csak megy, hogy menjen át egyszer mondja: "Nem. Én nem semmi swap, ezért kész vagyok."

765
00:46:12,230 --> 00:46:17,410
Tehát van egy best-case futási ideje Ω (n).

766
00:46:17,410 --> 00:46:20,680
Fussunk buborék rendezés a listán.

767
00:46:20,680 --> 00:46:23,560
Vagy az első, nézzük csak meg néhány pszeudokód nagyon gyorsan.

768
00:46:23,560 --> 00:46:28,160
Azt akarjuk mondani szeretnénk nyomon követni, minden iteráció a hurok,

769
00:46:28,160 --> 00:46:32,190
nyomon követni e vagy sem mi változott olyan elemeket.

770
00:46:32,190 --> 00:46:37,610
Tehát az oka, hogy, mi fog megállni, ha még nem cserélték olyan elemeket.

771
00:46:37,610 --> 00:46:41,980
Tehát az elején a mi hurok még nem cserélt semmit, úgyhogy mondhatjuk, hogy ez hamis.

772
00:46:41,980 --> 00:46:47,170
Most megyünk végig a listát, és hasonlítsa össze elem i elem i + 1

773
00:46:47,170 --> 00:46:50,310
és ha ez az eset, hogy van egy nagyobb szám balra egy kisebb szám,

774
00:46:50,310 --> 00:46:52,310
akkor mi csak fogja cserélni őket.

775
00:46:52,310 --> 00:46:54,490
>> És akkor fogunk emlékezni, hogy cserélték egy elem.

776
00:46:54,490 --> 00:46:58,900
Ez azt jelenti, hogy meg kell, hogy menjen át a listát legalább 1 több időt

777
00:46:58,900 --> 00:47:02,160
mert az állapot, amelyben álltunk, amikor a teljes lista már rendezve,

778
00:47:02,160 --> 00:47:04,890
ami azt jelenti, nem tettek semmilyen swap.

779
00:47:04,890 --> 00:47:09,960
Szóval ezért a feltétel itt lent van ", miközben bizonyos elemei már cseréltek."

780
00:47:09,960 --> 00:47:13,720
És most nézzük csak ezt nézd meg fut egy listán.

781
00:47:13,720 --> 00:47:16,640
Megvan a lista 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Bubble sort fog kezdeni végig a bal oldalon, és ez lesz összehasonlítani

783
00:47:19,850 --> 00:47:24,700
az i elemeket, így 0 és i + 1, ami az 1 elem.

784
00:47:24,700 --> 00:47:29,020
Ez fogja mondani, jól 5> 0, de most 5-ös a baloldalt,

785
00:47:29,020 --> 00:47:32,500
így kell cserélni az 5 és a 0-ra.

786
00:47:32,500 --> 00:47:35,470
Amikor cserélni őket, hirtelen én kap ez a különböző listát.

787
00:47:35,470 --> 00:47:38,260
Most 5> 1, így fogunk cserélni őket.

788
00:47:38,260 --> 00:47:42,160
5 nem> 6, így nem kell semmit itt.

789
00:47:42,160 --> 00:47:46,690
De 6> 4, ezért meg kell cserélni.

790
00:47:46,690 --> 00:47:49,740
Ismét meg kell végigmenni a teljes lista, hogy végül felfedezze

791
00:47:49,740 --> 00:47:52,330
hogy ezek elromlott, mi cserélni őket,

792
00:47:52,330 --> 00:47:57,120
és ezen a ponton meg kell végigmenni az 1-lista több időt

793
00:47:57,120 --> 00:48:05,390
meggyőződni arról, hogy minden a saját érdekében, és ezen a ponton bubble sort befejeződött.

794
00:48:05,390 --> 00:48:10,720
Egy másik algoritmust vesz bizonyos elemeit és rendezési őket kiválasztás sort.

795
00:48:10,720 --> 00:48:15,740
Az ötlet mögött kiválasztás sort, hogy fogunk felépíteni egy rendezett részét a lista

796
00:48:15,740 --> 00:48:18,150
1 elem egy időben.

797
00:48:18,150 --> 00:48:23,170
>> És ahogy fogjuk csinálni egyáltalán kiépítése bal szegmense a listán.

798
00:48:23,170 --> 00:48:27,510
És tulajdonképpen, minden - minden lépés, megyünk, hogy a legkisebb elem hagytuk

799
00:48:27,510 --> 00:48:32,310
amelyet még nem rendezett még, és fogjuk mozgatni ebbe a rendezett szegmensben.

800
00:48:32,310 --> 00:48:35,850
Ez azt jelenti, meg kell, hogy folyamatosan megtalálják a minimum rendezetlen elem

801
00:48:35,850 --> 00:48:40,720
majd vegye, hogy a minimális elemet, és cserélni azt bármilyen

802
00:48:40,720 --> 00:48:45,090
bal szélső elem, amely nincs rendezve.

803
00:48:45,090 --> 00:48:50,890
A futási idő ennek lesz O (n ²), mert a legrosszabb esetben

804
00:48:50,890 --> 00:48:55,070
kell összehasonlítani minden egyes elem az összes többi elem.

805
00:48:55,070 --> 00:48:59,250
Mert azt mondjuk, hogy ha indul a bal felét a lista, szükségünk van

806
00:48:59,250 --> 00:49:02,970
hogy menjen át az egész jogot szegmens, hogy megtalálják a legkisebb elem.

807
00:49:02,970 --> 00:49:05,430
És akkor ismét el kell menni az egész jobb szegmens és

808
00:49:05,430 --> 00:49:08,210
folyamatosan megy át, hogy újra és újra és újra.

809
00:49:08,210 --> 00:49:11,350
Ez lesz n ². Mi lesz szükségünk a for ciklus belsejében egy másik a loop

810
00:49:11,350 --> 00:49:13,350
ami azt sugallja, n ².

811
00:49:13,350 --> 00:49:16,530
A legjobb esetben gondolat, nézzük azt mondjuk, hogy ez egy már rendezett listát;

812
00:49:16,530 --> 00:49:19,270
valójában nem tesszük jobban, mint n ².

813
00:49:19,270 --> 00:49:21,730
Mivel a kiválasztás sort nem tudhatja, hogy

814
00:49:21,730 --> 00:49:25,540
a minimális elem csak az egyik én történetesen nézi.

815
00:49:25,540 --> 00:49:28,970
Meg kell még, hogy győződjön meg arról, hogy ez valójában a minimum.

816
00:49:28,970 --> 00:49:31,670
>> És az egyetlen módja annak, hogy győződjön meg arról, hogy ez a minimum, ezt az algoritmust,

817
00:49:31,670 --> 00:49:34,640
hogy nézd meg minden egyes elemét újra.

818
00:49:34,640 --> 00:49:38,420
Szóval tényleg, ha megadja, hogy - ha adsz kiválasztás sort egy már rendezett lista

819
00:49:38,420 --> 00:49:42,720
ez nem fog csinálni jobban, mint hogy ez a lista nem rendezett még.

820
00:49:42,720 --> 00:49:46,320
By the way, ha ez történik, hogy a helyzet, hogy valami O (valamit)

821
00:49:46,320 --> 00:49:50,640
és az omega valami, akkor csak annyit látna tömören, hogy ez θ valamit.

822
00:49:50,640 --> 00:49:52,760
Tehát, ha úgy látja, hogy jön sehova, ez az, amit ez csak jelent.

823
00:49:52,760 --> 00:49:57,580
>> Ha valami theta n ², ez mind a nagy O (n ²) és Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Így a legjobb esetben, és legrosszabb esetben, hogy nem tesz különbséget,

825
00:49:59,790 --> 00:50:04,400
az algoritmus fog nem ugyanaz a dolog minden alkalommal.

826
00:50:04,400 --> 00:50:06,610
Szóval ez az, amit pszeudokód kiválasztás sort is néz ki.

827
00:50:06,610 --> 00:50:10,630
Mi alapvetően fogja mondani, hogy akarom navigálhat át a listát

828
00:50:10,630 --> 00:50:15,180
balról jobbra, és minden iteráció a hurok, fogok mozogni

829
00:50:15,180 --> 00:50:19,780
a minimális elem ebbe rendezett részét a lista.

830
00:50:19,780 --> 00:50:23,260
És ha mozgok valamit ott, soha nem kell nézni, hogy az elemet újra.

831
00:50:23,260 --> 00:50:28,600
Mert amint csere egy elemet a bal oldali szegmens a lista, ez rendezve

832
00:50:28,600 --> 00:50:32,600
mert mi csinálunk mindent, növekvő sorrendben használatával minimumok.

833
00:50:32,600 --> 00:50:38,740
Tehát azt mondta, rendben vagyunk pozícióban i, és meg kell nézni az összes elemet

834
00:50:38,740 --> 00:50:42,260
jobbra az i-ben annak érdekében, hogy megtalálják a legkisebb.

835
00:50:42,260 --> 00:50:46,150
Tehát ez azt jelenti, hogy meg akarom nézni, i + 1-től az a lista végére.

836
00:50:46,150 --> 00:50:51,610
És most, ha az elem, hogy mi jelenleg keresi a kevesebb, mint a minimális eddig,

837
00:50:51,610 --> 00:50:54,190
amely ne feledd, kezdünk a minimális le, hogy csak

838
00:50:54,190 --> 00:50:57,020
bármilyen elem vagyunk jelenleg, fogom feltételezni, hogy ez a minimum.

839
00:50:57,020 --> 00:51:00,270
Ha találok egy elem, ami kisebb, akkor fogok mondani, oké,

840
00:51:00,270 --> 00:51:02,700
nos, én találtam egy új minimum.

841
00:51:02,700 --> 00:51:06,080
Fogok emlékezni, ha a minimális volt.

842
00:51:06,080 --> 00:51:09,560
>> Tehát most, ha egyszer már ment keresztül ez a jog rendezetlen szegmensben,

843
00:51:09,560 --> 00:51:16,690
Azt lehet mondani, megyek, hogy a csere a legkisebb elem az elem, hogy a helyén van i.

844
00:51:16,690 --> 00:51:21,100
Ez fogja felépíteni a listámon, a rendezett része a lista balról jobbra,

845
00:51:21,100 --> 00:51:25,190
és mi soha nem kell nézni egy elemet még egyszer, hogy ez az adott rész.

846
00:51:25,190 --> 00:51:27,930
Amint már cserélni azt.

847
00:51:27,930 --> 00:51:30,260
Szóval futni kiválasztás sort ezen a listán.

848
00:51:30,260 --> 00:51:38,220
A kék elem itt lesz az én, és a piros elem lesz a legkisebb elem.

849
00:51:38,220 --> 00:51:41,570
Tehát én kezdődik, egészen a bal oldalán a listán, így az 5.

850
00:51:41,570 --> 00:51:44,610
Most arra van szükség, hogy megtalálják a legkisebb rendezetlen elem.

851
00:51:44,610 --> 00:51:49,480
Tehát mondjuk 0 <5, tehát a 0 az új minimum.

852
00:51:49,480 --> 00:51:53,820
>> De nem áll meg ott, mert bár mi is elismerik, hogy a 0 a legkisebb,

853
00:51:53,820 --> 00:51:59,390
meg kell végigmenni minden más eleme a lista, hogy megbizonyosodjon arról.

854
00:51:59,390 --> 00:52:01,760
Tehát 1 nagyobb, 6 nagyobb, 4 nagyobb.

855
00:52:01,760 --> 00:52:05,850
Ez azt jelenti, hogy miután nézi az összes ezeket az elemeket, amit meghatározott 0 a legkisebb.

856
00:52:05,850 --> 00:52:09,800
Szóval fogom cserélni az 5 és a 0-ra.

857
00:52:09,800 --> 00:52:15,480
Amint csere, hogy megyek, hogy egy új listát, és tudom, hogy soha nem kell nézni, hogy a 0 ismét

858
00:52:15,480 --> 00:52:19,380
mert egyszer én már cserélték, én már rendezett, és készen vagyunk.

859
00:52:19,380 --> 00:52:22,730
Most már csak azért történik, hogy a kék elem ismét a 5,

860
00:52:22,730 --> 00:52:26,030
és meg kell nézni a 1, a 6 és a 4 annak megállapítására, hogy az 1

861
00:52:26,030 --> 00:52:31,520
a legkisebb minimum elem, úgyhogy majd cserélni az 1 és az 5.

862
00:52:31,520 --> 00:52:36,890
Ismét meg kell nézni - hasonlítsa össze az 5 és a 6 és a 4,

863
00:52:36,890 --> 00:52:39,830
és mi fogjuk cserélni a 4 és az 5, és végül hasonlítsa össze

864
00:52:39,830 --> 00:52:45,740
E 2 számok és cserélni őket, amíg megkapjuk a rendezett lista.

865
00:52:45,740 --> 00:52:49,730
Van még kérdése kiválasztási sort?

866
00:52:49,730 --> 00:52:56,420
Oké. Menjünk az utolsó téma itt, és ez rekurziót.

867
00:52:56,420 --> 00:52:59,810
>> Rekurziót, ne feledd, ez tényleg meta dolog, ha egy funkciót

868
00:52:59,810 --> 00:53:02,740
többször nevezi magát.

869
00:53:02,740 --> 00:53:05,620
Tehát egy bizonyos ponton, míg a fuction többször nevezte magát,

870
00:53:05,620 --> 00:53:10,100
van szükség, hogy néhány ponton, ahol megállunk hívó magunkat.

871
00:53:10,100 --> 00:53:13,670
Mert ha nem tesszük ezt, akkor mi csak folytatjuk ezt örökké,

872
00:53:13,670 --> 00:53:16,660
és a program, csak nem fog felmondani.

873
00:53:16,660 --> 00:53:19,200
Nevezzük ezt a feltételt az alapeset.

874
00:53:19,200 --> 00:53:22,570
És az alapeset szerint ahelyett, hogy hív egy függvényt újra,

875
00:53:22,570 --> 00:53:25,330
Én csak megy vissza valamilyen értéket.

876
00:53:25,330 --> 00:53:28,080
Tehát, ha mi már vissza egy értéket, már megállt hívó magunkat,

877
00:53:28,080 --> 00:53:32,550
és a többi a hívások tettük eddig is visszatérhet.

878
00:53:32,550 --> 00:53:36,050
Ennek az ellenkezője az alapeset a rekurzív helyzet.

879
00:53:36,050 --> 00:53:39,050
És ez az, amikor azt szeretnénk, hogy egy másik hívást a funkció, hogy mi vagyunk a jelenleg be

880
00:53:39,050 --> 00:53:44,690
És valószínűleg, bár nem minden esetben, a használni kívánt különböző érveket.

881
00:53:44,690 --> 00:53:48,940
>> Tehát ha van egy függvény neve f, és f hívott vegyél be 1 érvet,

882
00:53:48,940 --> 00:53:52,010
és mi csak hívogatnak f (1), f (1), f (1), és ez csak azért történik, hogy

883
00:53:52,010 --> 00:53:56,510
az érvelés 1 beleesik rekurzív ügyben, még mindig soha nem fog megállni.

884
00:53:56,510 --> 00:54:01,620
Még ha van egy alapesetet, meg kell, hogy győződjön meg arról, hogy végül mi lesz a hit, hogy az alapeset.

885
00:54:01,620 --> 00:54:04,250
Mi nem csak tartsa tartózkodik ebben rekurzív ügyben.

886
00:54:04,250 --> 00:54:09,870
Általában, ha hívjuk magunkat, mi valószínűleg megy, hogy egy másik érv minden alkalommal.

887
00:54:09,870 --> 00:54:12,700
Itt van egy nagyon egyszerű rekurzív függvény.

888
00:54:12,700 --> 00:54:15,090
Tehát ez lehet kiszámítani a faktoriálisát egy számot.

889
00:54:15,090 --> 00:54:17,790
Up tetejére Itt megvan a alapeset.

890
00:54:17,790 --> 00:54:22,330
Abban az esetben, ha n ≤ 1, nem fogunk hívni faktoriális újra.

891
00:54:22,330 --> 00:54:26,490
Fogunk állítani, mi csak megy vissza valamilyen értéket.

892
00:54:26,490 --> 00:54:30,170
Ha ez nem igaz, akkor fogunk ütni a rekurzív ügyben.

893
00:54:30,170 --> 00:54:33,550
Figyeljük meg, hogy itt mi nem csak hívja faktoros (n), mert az nem lenne nagyon hasznos.

894
00:54:33,550 --> 00:54:36,810
Fogunk hívni faktoriálisát valami mást.

895
00:54:36,810 --> 00:54:40,850
>> És látod, végül ha átadjuk a faktoriális (5) vagy valami,

896
00:54:40,850 --> 00:54:45,900
fogunk hívni faktoros (4), és így tovább, és végül meg fogjuk ütni ez az alapeset.

897
00:54:45,900 --> 00:54:51,730
Szóval ez jól néz ki. Lássuk, mi történik, ha a ténylegesen megtett ezt.

898
00:54:51,730 --> 00:54:57,840
Ez a verem, és mondjuk, hogy fő fogja hívni ezt a funkciót egy argumentum (4).

899
00:54:57,840 --> 00:55:02,200
Tehát, ha látja és faktoriális = 4, faktoriális hívja magát.

900
00:55:02,200 --> 00:55:05,010
Most, hirtelen, már faktoriális (3).

901
00:55:05,010 --> 00:55:10,780
Tehát ezek a funkciók fognak nőni, amíg végül elérjük bázisunkat ügyben.

902
00:55:10,780 --> 00:55:17,830
Ezen a ponton, a visszatérési értéke ez a visszatérés (nx a visszatérési értékét),

903
00:55:17,830 --> 00:55:21,290
a visszatérési értéke ez nx a visszatérési értéke.

904
00:55:21,290 --> 00:55:23,290
Végül meg kell hit néhány számot.

905
00:55:23,290 --> 00:55:26,560
A tetején van, mondjuk vissza 1.

906
00:55:26,560 --> 00:55:30,650
Ez azt jelenti, hogy ha egyszer visszatér ez a szám, akkor pop ezt le a köteget.

907
00:55:30,650 --> 00:55:36,570
Tehát ez a faktoriális (1) történik.

908
00:55:36,570 --> 00:55:41,190
Ha 1 visszatér, ez a faktoriális (1) visszatér, ez a visszatérés 1-re.

909
00:55:41,190 --> 00:55:46,910
A visszatérési értékét, ne feledd, volt nx a visszatérési értéke.

910
00:55:46,910 --> 00:55:50,720
Olyan hirtelen, ez a srác tudja, hogy szeretnék visszatérni 2.

911
00:55:50,720 --> 00:55:55,910
>> Úgy emlékszem vissza értéke ez csak nx a visszatérési érték itt.

912
00:55:55,910 --> 00:56:01,160
Így most azt mondhatjuk, 3 x 2, és végül, itt elmondhatjuk

913
00:56:01,160 --> 00:56:04,010
ez csak lesz 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
És ha ez visszatér, akkor feküdj egyetlen egész belsejében fő.

915
00:56:09,570 --> 00:56:15,460
Bármilyen kérdésre rekurzió?

916
00:56:15,460 --> 00:56:17,090
Rendben van. Tehát több időt a kérdésekre a végén,

917
00:56:17,090 --> 00:56:23,360
de most Joseph fedezi a fennmaradó témaköröket.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] Rendben. Tehát most, hogy már beszéltünk recursions,

919
00:56:25,590 --> 00:56:27,840
beszéljünk egy kicsit arról, hogy mi egyesítése rendezés.

920
00:56:27,840 --> 00:56:31,740
Merge rendezés alapvetően másik módja a válogatás a számok listája.

921
00:56:31,740 --> 00:56:36,430
És hogyan működik ez, a merge sort van egy lista, és mit teszünk

922
00:56:36,430 --> 00:56:39,120
mondjuk, menjünk szét ezt a 2 fél.

923
00:56:39,120 --> 00:56:42,750
Majd első indításakor merge sort ismét a bal felét,

924
00:56:42,750 --> 00:56:45,040
akkor fogjuk futtatni egyesítése sort a jobb felét,

925
00:56:45,040 --> 00:56:50,240
és ez ad nekünk most 2 fél amelyek rendezve, és most fogunk kombinálni ezeket felét együtt.

926
00:56:50,240 --> 00:56:55,010
Ez egy kicsit nehéz látni anélkül, hogy példát, így megyünk át a mozgás, és meglátjuk, mi történik.

927
00:56:55,010 --> 00:56:59,590
Így kezdődik ez a lista, akkor osztott be 2 fél.

928
00:56:59,590 --> 00:57:02,300
Futunk egyesítése sort a bal felén először.

929
00:57:02,300 --> 00:57:06,660
Szóval ez a bal fele, és most fut őket ezen a listán újra

930
00:57:06,660 --> 00:57:09,800
amelyek egyre vezetünk egyesítése sort, majd megnézzük újra,

931
00:57:09,800 --> 00:57:13,270
a bal oldalon a listában, és futunk egyesítése sort rajta.

932
00:57:13,270 --> 00:57:15,880
Most kap le egy listát a 2 szám,

933
00:57:15,880 --> 00:57:19,010
és most a bal fele csak 1 elem hosszú, és nem tudunk

934
00:57:19,010 --> 00:57:23,380
szét egy listát, hogy csak 1 elemet a fele, így csak azt mondom, ha van 50,

935
00:57:23,380 --> 00:57:26,400
amely mindössze 1 elem, ez már rendezve.

936
00:57:26,400 --> 00:57:29,860
>> Ha végeztünk vele, azt látjuk, hogy tudjuk

937
00:57:29,860 --> 00:57:32,230
lépni a jobb oldalán ezen a listán,

938
00:57:32,230 --> 00:57:36,480
és 3 is válogatni, és így most, hogy mindkét felét ezen a listán vannak rendezve

939
00:57:36,480 --> 00:57:39,080
tudunk csatlakozni ezeket a számokat újra együtt.

940
00:57:39,080 --> 00:57:45,320
Így néz ki a 50 és 3, 3 kisebb, mint 50, így megy az első, majd 50 bejön

941
00:57:45,320 --> 00:57:49,340
Most, hogy kész, megyünk vissza a lista és a rendezés ez jobb felét.

942
00:57:49,340 --> 00:57:52,440
42 van saját száma, így ez már rendezve.

943
00:57:52,440 --> 00:57:57,850
Tehát most összehasonlítjuk ezeket 2 és 3 kisebb, mint 42, úgy, hogy kap fel az első,

944
00:57:57,850 --> 00:58:02,340
Most 42 gets hozott, és 50 lesz helyezze be

945
00:58:02,340 --> 00:58:07,220
Nos, ez válogatni, menjünk egészen vissza a csúcsra, 1337 és 15.

946
00:58:07,220 --> 00:58:14,560
Nos, most nézd meg a bal oldali felét listán; 1337 jelentése önmagában így ez válogatni és ugyanaz a 15.

947
00:58:14,560 --> 00:58:19,020
Tehát most kombináljuk ezeket 2 szám rendezni, hogy az eredeti listán, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
így megy az első, majd 1337 bemegy

949
00:58:23,060 --> 00:58:26,640
És most sorrendje mindkét felét az eredeti lista top up.

950
00:58:26,640 --> 00:58:30,440
És minden, amit meg kell tennie, hogy kombinálni ezeket.

951
00:58:30,440 --> 00:58:36,890
Nézzük az első 2 szám ez a lista, 3 <15, így megy az a fajta tömb első.

952
00:58:36,890 --> 00:58:44,460
15 <42, így megy be most, 42 <1337, hogy megy be

953
00:58:44,460 --> 00:58:51,010
50 <1337, így megy be És észre, hogy mi csak volt 2 szám le ezt a listát.

954
00:58:51,010 --> 00:58:53,640
Szóval nem csak felváltva a 2 listákat.

955
00:58:53,640 --> 00:58:56,050
Mi csak nézte az elején, és szedi az elem

956
00:58:56,050 --> 00:59:00,270
ez a kisebb, majd helyezze be a tömb.

957
00:59:00,270 --> 00:59:04,080
Most már összevonták az összes fél, és készen vagyunk.

958
00:59:04,080 --> 00:59:07,780
>> Bármilyen kérdése merge sort? Igen?

959
00:59:07,780 --> 00:59:14,190
[Student] Ha ez felosztása különböző csoportok, miért nem ők csak osztott egyszer

960
00:59:14,190 --> 00:59:19,970
és van 3 és 2 a csoportban? [Külföld kérdés értelmetlen]

961
00:59:19,970 --> 00:59:24,940
Az ok - így a kérdés az, hogy miért nem tudunk csak egyesíteni őket, hogy az első lépés után már őket?

962
00:59:24,940 --> 00:59:29,530
Az ok, meg tudjuk csinálni, kezdje a bal szélső elemeit mindkét oldalon,

963
00:59:29,530 --> 00:59:33,040
majd megteszi a kisebb és tedd, hogy mi tudjuk, hogy ezek

964
00:59:33,040 --> 00:59:35,290
az egyes listák vannak rendezve megrendeléseket.

965
00:59:35,290 --> 00:59:37,290
Tehát, ha nézem a bal szélső elemeit mindkét felét,

966
00:59:37,290 --> 00:59:40,490
Tudom, hogy ők lesznek a legkisebb elemeit a listákra.

967
00:59:40,490 --> 00:59:43,930
Szóval lehet őket a legkisebb eleme foltok e nagy lista.

968
00:59:43,930 --> 00:59:47,810
Másrészt, ha megnézzük azokat 2 lista a második szinten ott,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 és 15, ezek nem válogatják szét.

970
00:59:51,640 --> 00:59:55,770
Tehát, ha ránézek 50 és 1337, fogok tenni 50-listámon az első.

971
00:59:55,770 --> 01:00:00,130
De ez nem igazán értelme, mivel 3 a legkisebb eleme az összes ilyen.

972
01:00:00,130 --> 01:00:04,390
Tehát az egyetlen oka annak, hogy megteheti ezt ötvözi a lépés, mert a listák már rendezve.

973
01:00:04,390 --> 01:00:07,010
Éppen ezért van, hogy le egészen az aljára

974
01:00:07,010 --> 01:00:09,800
mert amikor már csak egy szám, tudod, hogy egy szám

975
01:00:09,800 --> 01:00:14,120
önmagában már rendezett listát.

976
01:00:14,120 --> 01:00:19,360
>> Van még kérdése? Nem?

977
01:00:19,360 --> 01:00:24,260
A komplexitás? Nos, akkor láthatjuk, hogy minden egyes lépés van vége számok,

978
01:00:24,260 --> 01:00:27,590
és mi lehet osztani a listát a felére log n-szer,

979
01:00:27,590 --> 01:00:31,700
ami ha megkapjuk ezt a n x log n összetettségét.

980
01:00:31,700 --> 01:00:34,940
És látni fogja a legjobb esetben a merge sort n log n, és ez csak azért történik,

981
01:00:34,940 --> 01:00:39,340
hogy a legrosszabb eset, vagy az Ω ott, is n log n.

982
01:00:39,340 --> 01:00:42,480
Valami, hogy tartsa szem előtt.

983
01:00:42,480 --> 01:00:45,750
Továbblépve, menjünk be néhány szuper alapvető file I / O.

984
01:00:45,750 --> 01:00:48,830
Ha nézett Scramble, észre fogod venni, volt valami rendszer

985
01:00:48,830 --> 01:00:51,270
ahol meg lehet írni egy log fájlt, ha olvassa el a kódot.

986
01:00:51,270 --> 01:00:53,730
Lássuk, hogyan lehet csinálni.

987
01:00:53,730 --> 01:00:57,450
Hát, van fprintf, amit lehet gondolni, mint csak printf,

988
01:00:57,450 --> 01:01:01,720
de csak a nyomtatás helyett egy fájlba, és így az f elején.

989
01:01:01,720 --> 01:01:07,570
Ez a fajta kód ide, mit csinál az, ahogy azt láttuk Scramble,

990
01:01:07,570 --> 01:01:12,310
megy át a 2-dimenziós tömb Nyomtatásra ki egy sorral, amit a számok.

991
01:01:12,310 --> 01:01:17,850
Ebben az esetben a printf kinyomtatja a terminálhoz vagy hívjuk a standard kimenetre szakasz.

992
01:01:17,850 --> 01:01:22,170
>> És most, ebben az esetben, minden, amit meg kell tennie, hogy cserélje ki a printf fprintf,

993
01:01:22,170 --> 01:01:26,770
megmondani, hogy mit kívánt fájlt nyomtatni, és ebben az esetben csak kinyomtatja az adott fájl

994
01:01:26,770 --> 01:01:32,230
nyomtatás helyett ki a terminál.

995
01:01:32,230 --> 01:01:36,500
Nos, akkor ez felveti a kérdést: Hol kap ez a fajta fájl, igaz?

996
01:01:36,500 --> 01:01:39,840
Mentünk be az e fprintf fuction de fogalmam sem volt, honnan jött.

997
01:01:39,840 --> 01:01:43,980
Nos, korai a kódot, amit az volt a kódrészletet ide,

998
01:01:43,980 --> 01:01:48,340
amely lényegében azt mondja, hogy nyissa meg a fájlt hív log.txt.

999
01:01:48,340 --> 01:01:53,220
Mit teszünk utána, hogy van, hogy győződjön meg arról, hogy a fájl valójában nyitva sikeresen.

1000
01:01:53,220 --> 01:01:57,070
Tehát lehet, hogy nem több okból, akkor nincs elég hely a számítógépen, például.

1001
01:01:57,070 --> 01:01:59,790
Szóval ez mindig fontos, mielőtt tegye műveleteket a fájl

1002
01:01:59,790 --> 01:02:03,300
hogy ellenőrizze, hogy a fájl megnyílt sikeresen.

1003
01:02:03,300 --> 01:02:09,330
Tehát mi, hogy egy, ez az érvelés a fopen, nos, akkor nyisson meg egy fájlt több módon is.

1004
01:02:09,330 --> 01:02:13,510
Mit tehetünk, mi is add w, ami felülírja a fájlt, ha kilép már,

1005
01:02:13,510 --> 01:02:18,070
Mi lehet át egy olyan, amit csatolnia a végén a fájl helyett kényszerítő azt,

1006
01:02:18,070 --> 01:02:22,730
vagy mi megadhatja r, ami azt jelenti, hadd nyissa meg a fájlt csak olvasható.

1007
01:02:22,730 --> 01:02:24,890
Tehát, ha a program megpróbál, hogy bármilyen változás a fájlt,

1008
01:02:24,890 --> 01:02:30,140
kiabálni, és ne hagyd, hogy csináljuk.

1009
01:02:30,140 --> 01:02:33,320
Végül, miután végeztünk a fájl, befejezte ezt műveleteket rajta,

1010
01:02:33,320 --> 01:02:35,860
meg kell, hogy győződjön meg arról, zárjuk be a fájlt.

1011
01:02:35,860 --> 01:02:38,830
És így a végén a program, akkor megy át őket újra

1012
01:02:38,830 --> 01:02:42,120
ezt a fájlt, amit megnyitott, és csak zárja be.

1013
01:02:42,120 --> 01:02:44,650
Tehát ez valami fontos, amit meg kell győződjön meg róla csinálni.

1014
01:02:44,650 --> 01:02:47,180
Úgy emlékszem, meg tudja nyitni a fájlt, akkor írj a fájlt,

1015
01:02:47,180 --> 01:02:51,270
do műveleteket a fájlt, de akkor meg kell zárja be a fájlt a végén.

1016
01:02:51,270 --> 01:02:53,270
>> Van még kérdése az alapvető fájl I / O? Igen?

1017
01:02:53,270 --> 01:02:58,050
[Student kérdés, érthetetlen]

1018
01:02:58,050 --> 01:03:02,480
Itt van. A kérdés az, ha ez log.txt fájl jelenik meg?

1019
01:03:02,480 --> 01:03:07,890
Nos, ha csak add log.txt, hogy létrehozza ugyanabban a könyvtárban a futtatható.

1020
01:03:07,890 --> 01:03:10,500
Tehát ha Te - >> [Student kérdést, érthetetlen]

1021
01:03:10,500 --> 01:03:18,830
Igen. Ugyanebben a mappában, vagy ugyanabban a könyvtárban, ahogy te nevezed.

1022
01:03:18,830 --> 01:03:21,400
Most memória, verem, és a kupac.

1023
01:03:21,400 --> 01:03:23,400
Hogy van memória lefektetett a számítógép?

1024
01:03:23,400 --> 01:03:26,270
Nos, el lehet képzelni, memória fajta a blokk itt.

1025
01:03:26,270 --> 01:03:30,260
És a memóriában van az úgynevezett a halom ragadt ott, és a köteget, hogy van ott lent.

1026
01:03:30,260 --> 01:03:34,480
És a halom nő lefelé, és a köteget nő felfelé.

1027
01:03:34,480 --> 01:03:38,620
Így például Tommy említettük - ó, nos, és mi van az egyéb 4 szegmens, amit kapsz, hogy a második -

1028
01:03:38,620 --> 01:03:42,890
Ahogy korábban is mondtam Tommy, tudod, hogy ellátja nevezik magukat, és hívja egymást?

1029
01:03:42,890 --> 01:03:44,930
Építik fel ezt a fajta stack frame.

1030
01:03:44,930 --> 01:03:47,360
Nos, ha a fő kéri ize ize kap fektetni a verem.

1031
01:03:47,360 --> 01:03:52,430
Foo hív, bár kap a fektetni a verem, és hogy kap fektetni a stack után.

1032
01:03:52,430 --> 01:03:57,040
És ahogy visszatérnek, mindegyikük kap levették a verem.

1033
01:03:57,040 --> 01:04:00,140
Mi minden ezeken a helyeken és memória tartani?

1034
01:04:00,140 --> 01:04:03,110
Nos, a felső, amely a szöveg szegmens tartalmazza a program maga.

1035
01:04:03,110 --> 01:04:06,390
Tehát a gépi kód, ez van, ha egyszer fordítsa le a program.

1036
01:04:06,390 --> 01:04:08,520
Ezután minden inicializált globális változókat.

1037
01:04:08,520 --> 01:04:12,660
>> Szóval globális változók a program, és azt mondod, mint, a = 5,

1038
01:04:12,660 --> 01:04:15,260
hogy lesz be ebben a szegmensben, és jobbra az említett,

1039
01:04:15,260 --> 01:04:18,990
Ha bármilyen inicializált globális adatok, ami csak int a,

1040
01:04:18,990 --> 01:04:20,990
de nem mondom, hogy ez egyenlő a semmit.

1041
01:04:20,990 --> 01:04:23,870
Ismerd fel, ezek a globális változókat, ezért ők kívül fő.

1042
01:04:23,870 --> 01:04:28,560
Tehát ez azt jelenti, olyan globális változók, amelyek deklarált, de nem inicializálva.

1043
01:04:28,560 --> 01:04:32,310
Szóval, mi van a kupac? Memory felosztása egy malloc, amit kapsz, hogy egy kicsit.

1044
01:04:32,310 --> 01:04:35,990
És végül, a stack bármilyen lokális változók

1045
01:04:35,990 --> 01:04:39,950
és minden funkciót lehet hívni, hogy egyes paramétereket.

1046
01:04:39,950 --> 01:04:43,720
Az utolsó dolog, nem igazán tudni, hogy mi a környezeti változókat nem,

1047
01:04:43,720 --> 01:04:46,700
de ha futtatni programot, van valami jár, mint a

1048
01:04:46,700 --> 01:04:49,550
ez a felhasználónevét, aki futott a program.

1049
01:04:49,550 --> 01:04:51,550
És ez lesz valami az alján.

1050
01:04:51,550 --> 01:04:54,540
Ami a memória címek, amelyek hexadecimális értékek,

1051
01:04:54,540 --> 01:04:58,170
az értékek a felső 0-val kezdődnek, és mennek egészen az aljára.

1052
01:04:58,170 --> 01:05:00,440
Ebben az esetben, ha a 32-bites rendszer,

1053
01:05:00,440 --> 01:05:05,390
a cím alján lesz 0x, majd af, mert ez 32 bit,

1054
01:05:05,390 --> 01:05:10,890
ami 8 bájt, és ebben az esetben a 8 bájt megfelel 8 hexadecimális számjegy.

1055
01:05:10,890 --> 01:05:20,110
Szóval itt lent mész van, mint, 0xffffff, és ott fogsz hogy 0-ra.

1056
01:05:20,110 --> 01:05:23,660
Tehát mi a mutatókat? Néhányan lehet, hogy nem vonatkozik ez a szakasz előtt.

1057
01:05:23,660 --> 01:05:26,660
de nem megy át rajta az előadás, így a mutató csak egy adattípus

1058
01:05:26,660 --> 01:05:34,030
amely tárolja, ahelyett, hogy valamilyen érték, mint a 50, tárolja a címét egy olyan helyszín a memóriában.

1059
01:05:34,030 --> 01:05:36,020
Mint az a memória [érthetetlen].

1060
01:05:36,020 --> 01:05:41,120
Tehát ebben az esetben, amit nem, van egy mutató egy egész szám vagy egy int *

1061
01:05:41,120 --> 01:05:46,210
és tartalmazza ezt a hexadecimális címét 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Szóval mi van, az, most ez a mutató néhány helyen a memóriában,

1063
01:05:50,880 --> 01:05:56,020
és ez csak egy, az érték az 50 most ezt a memóriahelyet.

1064
01:05:56,020 --> 01:06:01,810
Néhány 32-bites rendszerek, az összes 32-bites rendszerek, pointerek vegye fel 32 bites vagy 4 bájt.

1065
01:06:01,810 --> 01:06:06,020
De például, egy 64-bites rendszer, pointers 64 bit.

1066
01:06:06,020 --> 01:06:08,040
Szóval ez valami, akkor szeretné, hogy tartsa szem előtt.

1067
01:06:08,040 --> 01:06:12,310
Szóval vége bites rendszeren, a mutató vége bit hosszú.

1068
01:06:12,310 --> 01:06:17,320
Mutatók a fajta nehéz megemészteni nélkül extra dolgokat,

1069
01:06:17,320 --> 01:06:20,300
úgyhogy menjünk át egy példa a dinamikus memória kiosztás.

1070
01:06:20,300 --> 01:06:25,130
Milyen dinamikus memória kiosztás tesz Önnek, vagy mit nevezünk malloc,

1071
01:06:25,130 --> 01:06:29,280
ez lehetővé teszi, kiosztani valamilyen adatot kívül a készlet.

1072
01:06:29,280 --> 01:06:31,830
Szóval, ez az adat a fajta tartósabb az a program időtartama alatt.

1073
01:06:31,830 --> 01:06:36,430
Mert mint tudjuk, ha kijelentem x egy függvényen belül, és hogy a függvény,

1074
01:06:36,430 --> 01:06:40,910
már nem férhetnek hozzá az adatokhoz, hogy tárolták x.

1075
01:06:40,910 --> 01:06:44,420
Milyen mutatók tegyük ők azok, ossza meg velünk tárolni memóriájában vagy boltban értékek

1076
01:06:44,420 --> 01:06:46,840
egy más területén emlékezet, azaz a halom.

1077
01:06:46,840 --> 01:06:49,340
Most, ha egyszer vissza out funkció, mindaddig, amíg van egy mutató

1078
01:06:49,340 --> 01:06:54,960
arra a helyre a memóriában, akkor mit tehetünk mi csak nézd meg az értékeket is.

1079
01:06:54,960 --> 01:06:58,020
Nézzünk egy példát: Ez a mi memória elrendezés újra.

1080
01:06:58,020 --> 01:07:00,050
És mi van ezt a funkciót, a fő.

1081
01:07:00,050 --> 01:07:06,870
Mit csinál ez - oké, olyan egyszerű, igaz? - Int x = 5, ez csak egy változót a verem a fő.

1082
01:07:06,870 --> 01:07:12,450
>> Másrészt, most nyilvánítja egy mutató, amely felhívja a funkciót giveMeThreeInts.

1083
01:07:12,450 --> 01:07:16,800
És most menj be ezt a funkciót, és hozzon létre egy új verem keret is.

1084
01:07:16,800 --> 01:07:20,440
Azonban ebben stack frame kijelentjük, int * temp,

1085
01:07:20,440 --> 01:07:23,210
amely mallocs 3 egész számunkra.

1086
01:07:23,210 --> 01:07:25,880
Tehát mérete int ad nekünk, hogy hány bájt ez int az,

1087
01:07:25,880 --> 01:07:29,620
és malloc ad nekünk, hogy hány bájt helyet a kupac.

1088
01:07:29,620 --> 01:07:32,890
Tehát ebben az esetben, hoztunk létre elegendő helyet a 3 egész szám,

1089
01:07:32,890 --> 01:07:36,830
és a kupac felfelé van, ezért én lehívott feljebb.

1090
01:07:36,830 --> 01:07:42,900
Ha készen vagyunk, akkor gyere vissza ide, csak akkor kell 3 ints vissza,

1091
01:07:42,900 --> 01:07:47,000
és visszatér a cím, ebben az esetben, ha több mint hogy az emlékezet.

1092
01:07:47,000 --> 01:07:51,250
És mi meg pointer = kapcsolót, és ott van csak egy mutató.

1093
01:07:51,250 --> 01:07:54,550
De mi van, hogy a függvény egymásra itt és eltűnik.

1094
01:07:54,550 --> 01:07:59,250
Szóval temp eltűnik, de még mindig fenntartja a címét, ahol a

1095
01:07:59,250 --> 01:08:01,850
a 3 egészek belső hálózatra.

1096
01:08:01,850 --> 01:08:06,180
Tehát ez meg az pointers hatókörű helyileg a halmozott keret,

1097
01:08:06,180 --> 01:08:09,860
de a memória, amelyre azok vonatkoznak van a kupac.

1098
01:08:09,860 --> 01:08:12,190
>> Van ennek értelme?

1099
01:08:12,190 --> 01:08:14,960
[Student] Megismételné? >> [Joseph] Igen.

1100
01:08:14,960 --> 01:08:20,270
Szóval ha visszamegyek egy kicsit, akkor láthatjuk, hogy temp kiosztott

1101
01:08:20,270 --> 01:08:23,500
némi memóriát a heap odafent.

1102
01:08:23,500 --> 01:08:28,680
Tehát, ha ezt a funkciót, giveMeThreeInts visszatér, ez a verem itt fog tűnni.

1103
01:08:28,680 --> 01:08:35,819
És azzal bármely változó, ebben az esetben, ez a mutató, amit osztják fel egymásra keretben.

1104
01:08:35,819 --> 01:08:39,649
Ez fog tűnni, de amióta visszatért temp

1105
01:08:39,649 --> 01:08:46,330
és mi meg pointer = temp, pointer van most megy pont ugyanolyan emlékét helyen temp volt.

1106
01:08:46,330 --> 01:08:50,370
Tehát most, még ha elveszítjük temp, hogy a helyi mutató,

1107
01:08:50,370 --> 01:08:59,109
még mindig fenntartják a memória cím, hogy mit mutatott a belsejében a változó mutató.

1108
01:08:59,109 --> 01:09:03,740
Kérdései vannak? Ez lehet egyfajta zavaros téma, ha még nem ment rajta szakaszban.

1109
01:09:03,740 --> 01:09:09,240
Tudjuk, a TF biztosan megy át, és persze tudunk válaszolni a kérdésekre

1110
01:09:09,240 --> 01:09:11,500
végén a felülvizsgálat ülés erre.

1111
01:09:11,500 --> 01:09:14,220
De ez a fajta egy összetett téma, és én már több példa, hogy fog megjelenni

1112
01:09:14,220 --> 01:09:18,790
, ami segít tisztázni, mi pointers valójában.

1113
01:09:18,790 --> 01:09:22,500
>> Ebben az esetben a pointerek egyenértékűek a tömbök,

1114
01:09:22,500 --> 01:09:25,229
így tudom csak használni ezt a mutatót, mint ugyanaz a dolog, mint egy int tömb.

1115
01:09:25,229 --> 01:09:29,840
Szóval indexálásának a 0, és megváltoztatja az első értéke 1,

1116
01:09:29,840 --> 01:09:39,689
megváltoztatja a második integer 2-re, és a 3. egész szám 3-ra.

1117
01:09:39,689 --> 01:09:44,210
Tehát inkább a mutatók. Nos, emlékszem Muci.

1118
01:09:44,210 --> 01:09:48,319
Ebben az esetben is kiosztott egy mutató, vagy mi nyilvánítsák mutató,

1119
01:09:48,319 --> 01:09:52,760
de kezdetben, amikor csak nyilvánítsák mutatót, ez nem mutat bárhol a memóriában.

1120
01:09:52,760 --> 01:09:54,930
Ez csak szemét értékei benne.

1121
01:09:54,930 --> 01:09:56,470
Szóval fogalmam sincs, hol ez a mutató mutat.

1122
01:09:56,470 --> 01:10:01,630
Meg van egy cím, amely éppen tele 0-val és 1-es, ahol azt eredetileg bejelentették.

1123
01:10:01,630 --> 01:10:04,810
Nem tudok mit kezdeni ezzel, amíg nem hívja malloc rajta

1124
01:10:04,810 --> 01:10:08,390
és akkor ad nekem egy kis hely a heap ahol tudok tenni értékeket belül.

1125
01:10:08,390 --> 01:10:11,980
Aztán megint, nem tudom, mi van benne a memória.

1126
01:10:11,980 --> 01:10:16,780
Tehát az első dolog, amit meg kell tennie, hogy ellenőrizze, hogy a rendszer már elég memória

1127
01:10:16,780 --> 01:10:20,850
hogy adjon nekem vissza 1 egész az első helyen, ezért csinálom ezt ellenőrizze.

1128
01:10:20,850 --> 01:10:25,020
Ha a mutató nulla, ami azt jelenti, hogy nem volt elég hely, vagy más hiba lépett fel,

1129
01:10:25,020 --> 01:10:26,320
úgyhogy kell lépni az én program.

1130
01:10:26,320 --> 01:10:29,400
 De ha mégis sikerül, most már tudom használni, hogy a pointer

1131
01:10:29,400 --> 01:10:35,020
és mi * mutató csinál, ebből az következik, ha a cím

1132
01:10:35,020 --> 01:10:38,480
, ahol ez az érték, és ez határozza meg, hogy 1-gyel egyenlő.

1133
01:10:38,480 --> 01:10:41,850
Szóval ide, mi ellenőrizni kell, hogy a memória létezett.

1134
01:10:41,850 --> 01:10:45,380
>> Ha már tudja, hogy létezik, akkor tegye bele

1135
01:10:45,380 --> 01:10:50,460
milyen értéket akarsz tenni bele, ebben az esetben 1.

1136
01:10:50,460 --> 01:10:53,060
Ha végeztünk vele, meg kell szabadítani, hogy a mutató

1137
01:10:53,060 --> 01:10:57,160
mert vissza kell mennem a rendszerbe, hogy az emlékezet, amit kértek, az első helyen.

1138
01:10:57,160 --> 01:10:59,690
Mivel a számítógép nem tudja, mikor végeztünk vele.

1139
01:10:59,690 --> 01:11:02,510
Ebben az esetben mi kifejezetten mondom, oké, készen vagyunk ezzel a memória.

1140
01:11:02,510 --> 01:11:10,780
Ha más folyamat szüksége van, egy másik program szüksége van rá, nyugodtan menjen előre, és vedd el.

1141
01:11:10,780 --> 01:11:15,110
Amit mi is tennie, hogy mi csak kap címét lokális változók a forgatáson.

1142
01:11:15,110 --> 01:11:19,080
Szóval int x belül van egymásra keret fő.

1143
01:11:19,080 --> 01:11:23,060
És amikor ezt a jelet, ez és az üzemeltető, hogy mit csinál,

1144
01:11:23,060 --> 01:11:27,310
tart x, x, mindössze néhány adatot a memóriában, de van egy cím.

1145
01:11:27,310 --> 01:11:33,790
Ez található valahol. Tehát hívás és x, hogy ez mire jó ez ad nekünk a címét x.

1146
01:11:33,790 --> 01:11:38,430
Ezáltal tesszük mutató pont, ahol x a memóriában.

1147
01:11:38,430 --> 01:11:41,710
Most már csak valami ilyesmit * x, fogunk kap 5 vissza.

1148
01:11:41,710 --> 01:11:43,820
A csillag neve dereferencing meg.

1149
01:11:43,820 --> 01:11:46,640
Azt követi a cím és a kap az értékét, hogy az ott tárolt.

1150
01:11:51,000 --> 01:11:53,310
>> Van még kérdése? Igen?

1151
01:11:53,310 --> 01:11:56,500
[Student] Ha nem teszed a 3-hegyes dolog, nem is mindig összeállításához?

1152
01:11:56,500 --> 01:11:59,490
Igen. Ha nem teszed a 3-as mutató dolog, ez még mindig tart összeállítására,

1153
01:11:59,490 --> 01:12:02,720
de én megmutatom, hogy mi történik a második, és anélkül, hogy, hogy a

1154
01:12:02,720 --> 01:12:04,860
ez az, amit nevezünk memóriavesztés. Te nem így a rendszer

1155
01:12:04,860 --> 01:12:07,850
vissza a memóriába, így egy idő után a program fog felhalmozni

1156
01:12:07,850 --> 01:12:10,940
memóriát, hogy ez nem használ, és semmi más nem tudja használni.

1157
01:12:10,940 --> 01:12:15,750
Ha valaha is látott Firefox 1,5 millió kilobyte-os számítógép,

1158
01:12:15,750 --> 01:12:17,840
A feladatkezelő, ez az, ami folyik itt.

1159
01:12:17,840 --> 01:12:20,760
Van egy memóriavesztés a program, hogy ők nem szállítanak.

1160
01:12:23,080 --> 01:12:26,240
Szóval, hogyan működik pointer aritmetikai munkát?

1161
01:12:26,240 --> 01:12:29,480
Nos, pointer aritmetika fajta, mint indexelő egy tömb.

1162
01:12:29,480 --> 01:12:36,370
Ebben az esetben van egy mutatót, és amit csinálok teszek mutató pont az első elemet

1163
01:12:36,370 --> 01:12:42,100
E tömb 3-egészek, hogy én már kiosztották.

1164
01:12:42,100 --> 01:12:46,670
Akkor most mit csináljak, star mutató csak megváltoztatja az első elem a listában.

1165
01:12:46,670 --> 01:12:49,140
Csillagok pointer +1 pont ide.

1166
01:12:49,140 --> 01:12:53,140
Szóval mutató ide, mutató 1 fölött van itt, pointer 2 van itt.

1167
01:12:53,140 --> 01:12:56,610
>> Szóval, csak hogy 1 ugyanaz a dolog, mint mozgó mentén tömbben.

1168
01:12:56,610 --> 01:12:59,880
Mit teszünk akkor, amikor mi pointer 1 megkapod a címet ide,

1169
01:12:59,880 --> 01:13:04,180
és annak érdekében, hogy az érték itt, hogy egy csillag az egész kifejezés

1170
01:13:04,180 --> 01:13:05,990
A dereference meg.

1171
01:13:05,990 --> 01:13:09,940
Tehát ebben az esetben én amelyben az első helyen ebben a tömbben 1,

1172
01:13:09,940 --> 01:13:13,970
második helyen a 2, és a harmadik hely 3-ra.

1173
01:13:13,970 --> 01:13:18,180
Akkor mit csinálok ide az én nyomtat a mutató +1,

1174
01:13:18,180 --> 01:13:19,970
ami csak ad nekem 2.

1175
01:13:19,970 --> 01:13:23,650
Most növelésének mutató, így a mutató értéke mutató +1,

1176
01:13:23,650 --> 01:13:26,780
ami mozog előre.

1177
01:13:26,780 --> 01:13:30,810
És most, ha ki kell nyomtatni mutató +1, 1 mutató most 3,

1178
01:13:30,810 --> 01:13:33,990
ami ebben az esetben kinyomtatja 3.

1179
01:13:33,990 --> 01:13:36,560
És annak érdekében, hogy szabad valamit, a mutatót, hogy én, hogy ez

1180
01:13:36,560 --> 01:13:40,540
kell mutatniuk elején a tömbben, mely kaptam vissza malloc.

1181
01:13:40,540 --> 01:13:43,430
Tehát ebben az esetben, ha én hívni 3 itt, ez nem lehet igaz,

1182
01:13:43,430 --> 01:13:45,070
mert a közepén a tömbben.

1183
01:13:45,070 --> 01:13:48,820
El kell levonni, hogy az eredeti helyére

1184
01:13:48,820 --> 01:13:50,420
A kezdeti első helyre, mielőtt szabadíthat meg.

1185
01:13:56,300 --> 01:13:58,450
Szóval, itt van egy nagyobb szerepet példa.

1186
01:13:58,450 --> 01:14:03,360
Ebben az esetben, mi elosztása 7 karakter egy karakter tömbben.

1187
01:14:03,360 --> 01:14:06,480
>> És ebben az esetben, hogy mit csinálunk a mi hurok az első 6 őket,

1188
01:14:06,480 --> 01:14:09,900
és mi beállítás, hogy Z.

1189
01:14:09,900 --> 01:14:13,350
Így int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Szóval, pointer + én majd csak nekünk, ebben az esetben,

1191
01:14:16,220 --> 01:14:20,860
mutató, mutató +1, mutató +2, mutató 3, és így tovább, és így tovább a hurok.

1192
01:14:20,860 --> 01:14:24,040
Mit fog csinálni ez lesz ezt a címet, dereferences azt, hogy az érték,

1193
01:14:24,040 --> 01:14:27,440
és módosításokat értéket a Z.

1194
01:14:27,440 --> 01:14:30,350
Aztán a végén emlékszik ez egy string, ugye?

1195
01:14:30,350 --> 01:14:33,560
Minden strings kell, hogy vessen véget a lezáró null karaktert.

1196
01:14:33,560 --> 01:14:38,620
Szóval, mit csinálok a mutató 6 tettem a null terminátor karakter be

1197
01:14:38,620 --> 01:14:43,980
És most mit csinál itt tulajdonképpen hajt végre printf egy string, ugye?

1198
01:14:43,980 --> 01:14:46,190
>> Tehát, ha nem printf most, amikor ez elérte a végét a húr?

1199
01:14:46,190 --> 01:14:48,230
Amikor eléri a lezáró null karaktert.

1200
01:14:48,230 --> 01:14:52,030
Tehát ebben az esetben az eredeti mutató a tömb elején.

1201
01:14:52,030 --> 01:14:56,410
Én kinyomtatni az első karakter ki. Úgy helyezze át egy.

1202
01:14:56,410 --> 01:14:58,420
Nyomtatásakor a karakter ki. Úgy helyezze át.

1203
01:14:58,420 --> 01:15:02,180
És én csinálom ezt, amíg azt elérjük a végét.

1204
01:15:02,180 --> 01:15:07,750
És most a végén * pointer lesz dereference ezt, és kap a null lezáró karakter vissza.

1205
01:15:07,750 --> 01:15:11,780
És így a while ciklus fut, csak akkor, ha ez az érték nem null lezáró karaktert.

1206
01:15:11,780 --> 01:15:13,770
Szóval, most lépjen ki ebből a hurok.

1207
01:15:18,780 --> 01:15:21,180
És ha kell vonni 6 e mutató,

1208
01:15:21,180 --> 01:15:22,860
Megyek vissza egészen az elején.

1209
01:15:22,860 --> 01:15:27,880
Ne feledje, hogy én csinálom ezt, mert el kell menni az elején annak érdekében, hogy kiszabadítsa azt.

1210
01:15:27,880 --> 01:15:30,270
>> Szóval, tudom, hogy volt egy csomó. Van kérdés?

1211
01:15:30,270 --> 01:15:31,870
Kérlek, ugye?

1212
01:15:31,870 --> 01:15:36,610
[Student kérdés értelmetlen]

1213
01:15:36,610 --> 01:15:38,190
Tudsz mondani, hogy hangosabban? Bocsánat.

1214
01:15:38,190 --> 01:15:44,140
[Student] Az utolsó dia jobbra, mielőtt kiszabadította a mutatót,

1215
01:15:44,140 --> 01:15:47,300
ahol arra valóban értékének megváltoztatásáról a mutató?

1216
01:15:47,300 --> 01:15:50,370
[Joseph] Szóval, itt van. >> [Student] Ó, oké.

1217
01:15:50,370 --> 01:15:51,890
[Joseph] Szóval, van egy mutató mínusz mínusz, igaz,

1218
01:15:51,890 --> 01:15:54,140
ami mozog a dolog hát egyet, és aztán szabad azt,

1219
01:15:54,140 --> 01:15:57,000
mert ez a mutató ki kell emelni, hogy az elején a tömbben.

1220
01:15:57,000 --> 01:16:00,420
[Student] De ez nem szükséges már abbahagyta ezt követően sor.

1221
01:16:00,420 --> 01:16:03,130
[Joseph] Szóval, ha én már nem ez után, ez tekinthető memóriavesztés,

1222
01:16:03,130 --> 01:16:04,810
mert nem fut az ingyenes.

1223
01:16:04,810 --> 01:16:11,290
[Student] I [érthetetlen], miután az első három sor, ahol meg kellett mutató +1 [érthetetlen].

1224
01:16:11,290 --> 01:16:13,140
[Joseph] Uh-huh. Szóval, mi a kérdés ott van?

1225
01:16:13,140 --> 01:16:14,780
Bocsánat. Nem, nem. Menj, menj, kérlek.

1226
01:16:14,780 --> 01:16:16,870
[Student] Szóval, te nem változó értékét mutató.

1227
01:16:16,870 --> 01:16:19,130
Akkor nem kellett volna tennie mutató mínusz mínusz.

1228
01:16:19,130 --> 01:16:19,730
[Joseph] Igen, pontosan.

1229
01:16:19,730 --> 01:16:21,890
Szóval, amikor én mutató +1 és mutató +2,

1230
01:16:21,890 --> 01:16:24,410
Nem csinálok mutató értéke mutató +1.

1231
01:16:24,410 --> 01:16:27,260
Így a mutató csak marad mutatott elején a tömbben.

1232
01:16:27,260 --> 01:16:31,460
Ez csak akkor tudom, plusz, plusz, hogy meghatározza az értéket vissza a házba a mutatót,

1233
01:16:31,460 --> 01:16:33,550
hogy ténylegesen mozog ezen mentén.

1234
01:16:36,860 --> 01:16:37,780
Rendben van.

1235
01:16:40,550 --> 01:16:42,030
További kérdések?

1236
01:16:44,680 --> 01:16:47,790
>> Ismét, ha ez a fajta elsöprő, ez fedezi az ülésen.

1237
01:16:47,790 --> 01:16:50,710
Kérdezze meg a tanítás más róla, és mi lehet válaszolni a kérdésekre a végén.

1238
01:16:53,510 --> 01:16:56,600
És általában mi nem tetszik, hogy ezt mínusz dolgot.

1239
01:16:56,600 --> 01:16:59,760
Ez megkövetelni számomra, hogy nyomon követhetőek, mennyi, amit ellensúlyozott a tömbben.

1240
01:16:59,760 --> 01:17:04,520
Szóval, általában ez csak megmagyarázni, hogyan mutató számtani működik.

1241
01:17:04,520 --> 01:17:07,970
De mi van, mi általában szeretnénk tennie szeretnénk létrehozni egy példányt a mutatót,

1242
01:17:07,970 --> 01:17:11,640
és aztán ezt a példányt használhatja, amikor mi mozog a húr.

1243
01:17:11,640 --> 01:17:14,660
Szóval, ezek az esetben, ha a másolat felhasználásával nyomtassa ki a teljes szöveget,

1244
01:17:14,660 --> 01:17:19,040
de nem kell tennie, mint a mutató mínusz 6, illetve nyomon követhetjük, hogy mennyire mozgott ebben,

1245
01:17:19,040 --> 01:17:22,700
csak azért, mert tudjuk, hogy az eredeti pontot is rámutatott, hogy az elején a lista

1246
01:17:22,700 --> 01:17:25,340
és minden, amit megváltoztatni volt ez a példány.

1247
01:17:25,340 --> 01:17:28,250
Tehát általában megváltoztathatja másolatot az eredeti mutató.

1248
01:17:28,250 --> 01:17:32,350
Ne próbálja meg rendezni a hasonló - ne változtassa eredeti példányban.

1249
01:17:32,350 --> 01:17:35,290
Próbálok változtatni csak a másolatot az eredeti.

1250
01:17:41,540 --> 01:17:44,870
Szóval, azt veszi észre, amikor átadjuk a string printf

1251
01:17:44,870 --> 01:17:48,990
nem kell, hogy egy csillag előtte, mint tettük az összes többi dereferences, ugye?

1252
01:17:48,990 --> 01:17:54,180
Tehát, ha nyomtassa ki az egész szöveget% s vár egy cím,

1253
01:17:54,180 --> 01:17:57,610
és ebben az esetben egy mutató vagy ebben az esetben, mint egy sor karakter.

1254
01:17:57,610 --> 01:18:00,330
>> Színészek, char * s, és a tömbök ugyanaz a dolog.

1255
01:18:00,330 --> 01:18:03,690
Pointer, hogy karakter, és a karakter tömbök ugyanaz a dolog.

1256
01:18:03,690 --> 01:18:05,720
És így minden, amit meg kell tennie, hogy adja át a mutató.

1257
01:18:05,720 --> 01:18:08,150
Nem kell átadni, mint a * mutató, vagy ilyesmi.

1258
01:18:13,110 --> 01:18:14,930
Szóval, tömbök és mutatók is ugyanaz a dolog.

1259
01:18:14,930 --> 01:18:19,160
Ha csinálsz valami ilyesmit x [y] ide egy tömb,

1260
01:18:19,160 --> 01:18:21,960
mit csinál a motorháztető alatt van mondja, oké, ez egy karakter tömb,

1261
01:18:21,960 --> 01:18:23,690
így ez a mutató.

1262
01:18:23,690 --> 01:18:26,510
És így x is ugyanaz a dolog,

1263
01:18:26,510 --> 01:18:28,650
és így mit csinál ez növeli y az x,

1264
01:18:28,650 --> 01:18:31,820
ami ugyanaz, mint halad előre a memóriában, hogy sok.

1265
01:18:31,820 --> 01:18:34,930
És most x + y ad valamiféle cím,

1266
01:18:34,930 --> 01:18:37,570
és mi dereference a címet, vagy kövesse a nyíl

1267
01:18:37,570 --> 01:18:41,640
hogy ha ez a hely a memória, és megkapjuk az értéket ki ezen a helyen a memóriában.

1268
01:18:41,640 --> 01:18:43,720
Szóval, így ez a két pontosan ugyanaz a dolog.

1269
01:18:43,720 --> 01:18:45,840
Ez csak egy szintaktikai cukor.

1270
01:18:45,840 --> 01:18:48,090
Ez nem ugyanaz a dolog. Ők csak más syntactics egymásnak.

1271
01:18:51,500 --> 01:18:57,590
>> Szóval, mi baj a mutató? Mint sok. Oké. Szóval, a rossz dolgokat.

1272
01:18:57,590 --> 01:19:02,410
Vannak rossz dolgok, amit tehetünk, nem ellenőrzi, ha a malloc hívás visszatér null, igaz?

1273
01:19:02,410 --> 01:19:06,560
Ebben az esetben, azt kérem, hogy a rendszer ad nekem - mi ez a szám?

1274
01:19:06,560 --> 01:19:11,200
Mint a 2 milliárd alkalommal 4, mert a mérete egész szám 4 bájt.

1275
01:19:11,200 --> 01:19:13,810
Azt kérdeztem azt mint 8 milliárd bájt.

1276
01:19:13,810 --> 01:19:17,270
Természetesen a számítógép nem lesz képes adni nekem, hogy sok memóriát vissza.

1277
01:19:17,270 --> 01:19:20,960
És mi nem ellenőrizte, ha ez nulla, így amikor megpróbáljuk dereference hogy ott -

1278
01:19:20,960 --> 01:19:24,270
kövesse a nyilat, ahol ez lesz - nincs, hogy a memória.

1279
01:19:24,270 --> 01:19:27,150
Ezt hívjuk dereferencing egy null pointer.

1280
01:19:27,150 --> 01:19:29,710
És ez lényegében azt okozza, hogy segfault.

1281
01:19:29,710 --> 01:19:31,790
Ez az egyik módja lehet segfault.

1282
01:19:34,090 --> 01:19:38,090
További rossz dolog, amit tehetünk - hát igen.

1283
01:19:38,090 --> 01:19:40,650
Ez volt dereferencing egy null pointer. Oké.

1284
01:19:40,650 --> 01:19:45,160
Egyéb rossz dolgok - nos, hogy rögzíti, hogy az imént egy csekket ott

1285
01:19:45,160 --> 01:19:46,980
hogy ellenőrzi, hogy a mutató értéke null

1286
01:19:46,980 --> 01:19:51,000
és lépjen ki a program, ha ez történik, hogy a malloc vissza null pointer.

1287
01:19:55,110 --> 01:19:59,850
Ez a xkcd képregény. Az emberek megértik most. Olyasmi.

1288
01:20:06,120 --> 01:20:09,350
>> Szóval, memória. És mentem át ezt.

1289
01:20:09,350 --> 01:20:12,000
Mi hívja malloc egy hurok, de minden alkalommal hívjuk malloc

1290
01:20:12,000 --> 01:20:14,370
vagyunk vesztes pályán, ahol ez a mutató mutat,

1291
01:20:14,370 --> 01:20:15,750
mert mi felülírja azt.

1292
01:20:15,750 --> 01:20:18,410
Szóval, az első hívás malloc ad nekem memória ide.

1293
01:20:18,410 --> 01:20:19,990
Erre mutató mutatókat ezt.

1294
01:20:19,990 --> 01:20:23,020
Nos, én nem szabadít meg, így most hívom malloc újra.

1295
01:20:23,020 --> 01:20:26,070
Most mutat ide. Most a memóriát mutat ide.

1296
01:20:26,070 --> 01:20:27,640
Egér ide. Egér ide.

1297
01:20:27,640 --> 01:20:31,820
De elvesztettem pályán a címeket az összes memóriát ide, hogy én különítettek el.

1298
01:20:31,820 --> 01:20:35,100
És így most nem kell semmiféle utalást rájuk többé.

1299
01:20:35,100 --> 01:20:37,230
Szóval, nem tudom kiszabadítani őket kívül a hurok.

1300
01:20:37,230 --> 01:20:39,390
Így annak érdekében, hogy rögzítse ilyesmit,

1301
01:20:39,390 --> 01:20:42,250
Ha elfelejtette a szabad memória és megkapod ezt memóriavesztés,

1302
01:20:42,250 --> 01:20:45,810
Meg kell szabadítani a memória belsejében loop miután végeztél vele.

1303
01:20:45,810 --> 01:20:51,400
Nos, ez az, ami történik. Tudom, hogy sok utálod ezt.

1304
01:20:51,400 --> 01:20:55,270
De most - yay! Kapsz mint 44.000 kilobyte.

1305
01:20:55,270 --> 01:20:57,110
Szóval szabad a végén a hurok,

1306
01:20:57,110 --> 01:20:59,770
és ez megy, csak szabad a memória minden alkalommal.

1307
01:20:59,770 --> 01:21:03,620
Lényegében a program nincs memóriavesztés többé.

1308
01:21:03,620 --> 01:21:08,150
>> És most valami más, amit tehetünk, szabadítson fel memóriát, amit kért kétszer.

1309
01:21:08,150 --> 01:21:11,060
Ebben az esetben, ha malloc valamit, meg nem változtatja az értékét.

1310
01:21:11,060 --> 01:21:13,140
Ingyen egyszer, mert azt mondta, hogy végeztem vele.

1311
01:21:13,140 --> 01:21:14,940
De aztán kiszabadította újra.

1312
01:21:14,940 --> 01:21:16,730
Ez olyan dolog, hogy elég rossz.

1313
01:21:16,730 --> 01:21:18,820
Ez nem fog kezdetben segfault,

1314
01:21:18,820 --> 01:21:23,350
de egy idő után, hogy ez mit jelent a kettős szabadít ezt megrontja a kupac szerkezetét,

1315
01:21:23,350 --> 01:21:27,200
és akkor tanulni egy kicsit többet erről, ha úgy dönt, hogy egy osztály, mint a CS61.

1316
01:21:27,200 --> 01:21:30,000
De lényegében egy idő után a számítógép megy összezavarodnak

1317
01:21:30,000 --> 01:21:33,010
mi memória helyek, ahol és amennyiben ez tárolják -

1318
01:21:33,010 --> 01:21:34,800
ahol az adatok a memóriában tárolódnak.

1319
01:21:34,800 --> 01:21:38,080
És így felszabadítva egy mutatót kétszer olyan rossz dolog, amit nem akarsz.

1320
01:21:38,080 --> 01:21:41,600
>> Más dolog, hogy a rosszra nem használja sizeof.

1321
01:21:41,600 --> 01:21:44,460
Tehát ebben az esetben malloc 8 byte,

1322
01:21:44,460 --> 01:21:46,700
és ez ugyanaz, mint a két egész szám, ugye?

1323
01:21:46,700 --> 01:21:49,580
Szóval, ez tökéletesen biztonságos, de ez?

1324
01:21:49,580 --> 01:21:52,160
Nos, mint Lucas beszélt különböző architektúrák,

1325
01:21:52,160 --> 01:21:54,220
egészek különböző hosszúságú.

1326
01:21:54,220 --> 01:21:57,970
Szóval, az a készülék, hogy az Ön által használt, egészek mintegy 4 byte,

1327
01:21:57,970 --> 01:22:02,370
de más rendszerben ezek lehetnek 8 byte vagy azok lehetnek 16 bájt.

1328
01:22:02,370 --> 01:22:05,680
Tehát, ha csak ezt a számot ide,

1329
01:22:05,680 --> 01:22:07,310
ez a program is működik a készülék,

1330
01:22:07,310 --> 01:22:10,360
de ez nem lesz elegendő memóriát valamilyen más rendszer.

1331
01:22:10,360 --> 01:22:14,020
Ebben az esetben, ez az, amit a sizeof operátor használják.

1332
01:22:14,020 --> 01:22:16,880
Mikor hívjuk sizeof (int), hogy ez mire is

1333
01:22:16,880 --> 01:22:21,910
 ad nekünk a mérete integer a rendszer, hogy a program fut.

1334
01:22:21,910 --> 01:22:25,490
Tehát ebben az esetben, sizeof (int) ad vissza 4 valami, mint a készülék,

1335
01:22:25,490 --> 01:22:29,980
és most ez az akarat 4 * 2, amely 8,

1336
01:22:29,980 --> 01:22:32,330
ami csak meg, mekkora hely szükséges a két egész szám.

1337
01:22:32,330 --> 01:22:36,710
Egy másik rendszer, ha egy int, mint 16 bájt vagy 8 bájt,

1338
01:22:36,710 --> 01:22:39,380
ez csak fog visszatérni ahhoz byte tárolni ezt az összeget.

1339
01:22:41,830 --> 01:22:45,310
>> És végül, struktúrákat.

1340
01:22:45,310 --> 01:22:48,340
Tehát, ha akarta, hogy tárolja a sudoku tábla a memória, hogyan lehet ezt megtenni?

1341
01:22:48,340 --> 01:22:51,570
Azt hihetnénk, hogy olyan, mint egy változó, az első dolog,

1342
01:22:51,570 --> 01:22:53,820
változó a második dolog, egy változó a harmadik dolog,

1343
01:22:53,820 --> 01:22:56,420
változó a negyedik dolog - rossz, igaz?

1344
01:22:56,420 --> 01:23:00,750
Szóval, egy javulás akkor lehet, hogy a tetején ez, hogy egy 9 x 9 tömb.

1345
01:23:00,750 --> 01:23:04,480
Ez rendben van, de mi van, ha akarta társítani más dolgokat a sudoku tábla

1346
01:23:04,480 --> 01:23:06,490
tetszik, amit nehéz a tábla,

1347
01:23:06,490 --> 01:23:11,740
vagy például, mi a pontszám, vagy mennyi idő ez hozott megoldani ezen a fórumon?

1348
01:23:11,740 --> 01:23:14,970
Nos, hogy mit tehetünk, akkor létrehozhat egy struct.

1349
01:23:14,970 --> 01:23:18,910
Amit tulajdonképpen mondani, én ezt a struktúrát meghatározó ide,

1350
01:23:18,910 --> 01:23:23,230
és én vagyok meghatározása sudoku tábla, amely egy fórumon, hogy a 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> És mi van azt mutatókat a nevét a szintet.

1352
01:23:26,650 --> 01:23:30,730
Azt is x és y, amelyek a koordinátái, ahol én most.

1353
01:23:30,730 --> 01:23:35,980
Azt is időt [érthetetlen], és azt a teljes számú mozog, amit bevisszük eddig.

1354
01:23:35,980 --> 01:23:40,010
És ebben az esetben, tudok csoportosítani egy csomó adatot csak egy szerkezet

1355
01:23:40,010 --> 01:23:42,790
ahelyett, hogy, mint a repülő körül, mint a különböző változók

1356
01:23:42,790 --> 01:23:44,540
hogy nem tudok igazán nyomon követni.

1357
01:23:44,540 --> 01:23:49,720
És ez lehetővé teszi számunkra, hogy csak szép szintaxist fajta hivatkozás különböző dolgok belsejében struct.

1358
01:23:49,720 --> 01:23:53,430
Én csak ezt board.board, és megkapom a sudoku tábla vissza.

1359
01:23:53,430 --> 01:23:56,320
Board.level, értem, milyen kemény ez.

1360
01:23:56,320 --> 01:24:00,540
Board.x board.y és add nekem a koordinátáit, ahol lehet a fórumon.

1361
01:24:00,540 --> 01:24:04,730
És így én hozzáférés hívjuk a mezőket struct.

1362
01:24:04,730 --> 01:24:08,840
Ez határozza meg sudokuBoard, amely egy olyan típusú, hogy van.

1363
01:24:08,840 --> 01:24:14,800
És most itt vagyunk. Nekem van egy változó úgynevezett "board" típusú sudokuBoard.

1364
01:24:14,800 --> 01:24:18,820
És így most már hozzáférhet az összes mezőt, hogy töltsük fel ezt a struktúrát ide.

1365
01:24:20,830 --> 01:24:22,450
>> Bármilyen kérdése struktúrákat? Igen?

1366
01:24:22,450 --> 01:24:25,890
[Student] Az int x, y, akkor kijelentette, mind egy sorban? >> [Joseph] Uh-huh.

1367
01:24:25,890 --> 01:24:27,400
[Student] Szóval, lehet csak megtenni az összes velük?

1368
01:24:27,400 --> 01:24:31,200
Mint x, y vessző-szor, hogy a teljes?

1369
01:24:31,200 --> 01:24:34,460
[Joseph] Igen, akkor biztosan nem, de azért tettem x és y ugyanabban a sorban -

1370
01:24:34,460 --> 01:24:36,330
és az a kérdés, hogy miért mi csak ezt ugyanabban a sorban?

1371
01:24:36,330 --> 01:24:38,600
Miért nem az imént mindezen ugyanabban a sorban van

1372
01:24:38,600 --> 01:24:42,090
x és y kapcsolódnak egymáshoz,

1373
01:24:42,090 --> 01:24:44,780
és ez még csak stilisztikailag inkább helyes, abban az értelemben,

1374
01:24:44,780 --> 01:24:46,600
mert ez csoportosítására két dolgot ugyanabban a sorban

1375
01:24:46,600 --> 01:24:49,340
hogy mint egyfajta kapcsolódnak a ugyanaz a dolog.

1376
01:24:49,340 --> 01:24:51,440
És én csak megosztani ezeket egymástól. Ez csak egy stílus dolog.

1377
01:24:51,440 --> 01:24:53,720
A funkcionálisan nincs különbség nélkül.

1378
01:24:58,150 --> 01:24:59,270
Bármely más kérdésre struktúrákat?

1379
01:25:03,030 --> 01:25:06,620
Megadhatunk egy Pokédex egy struct.

1380
01:25:06,620 --> 01:25:11,720
A Pokémon egy számot, és azt a levelet, a tulajdonos, a típus.

1381
01:25:11,720 --> 01:25:16,990
És ha van egy sor Pokémon, tudod, hogy egy Pokédex, ugye?

1382
01:25:16,990 --> 01:25:20,810
Oké, király. Szóval, kérdések struktúrákat. Ezek kapcsolatos struktúrákat.

1383
01:25:20,810 --> 01:25:25,270
>> Végül a GDB. Mit jelent a GDB engedi csinálni? Ez lehetővé teszi, hibakeresés a program.

1384
01:25:25,270 --> 01:25:27,650
És ha még nem használta GDB, azt javasolta nézni a rövid

1385
01:25:27,650 --> 01:25:31,250
és csak megy, hogy mit GDB, hogyan dolgozik vele, hogyan lehet használni,

1386
01:25:31,250 --> 01:25:32,900
és tesztelni azt a program.

1387
01:25:32,900 --> 01:25:37,400
És mi GDB segítségével tennie, ez lehetővé teszi, szüneteltetheti a [érthetetlen]-ig a program

1388
01:25:37,400 --> 01:25:38,920
és gyakorlati vonal.

1389
01:25:38,920 --> 01:25:42,600
Például, azt akarom szüneteltetni végrehajtást, mint 3-as vonal az én program,

1390
01:25:42,600 --> 01:25:46,010
és míg én vagyok a 3. sorban tudom kinyomtatni az összes értékek vannak.

1391
01:25:46,010 --> 01:25:49,710
És amit mi, mint szüneteltetése sorban

1392
01:25:49,710 --> 01:25:52,350
A hívjuk ezt amivel egy töréspont az adott vonal

1393
01:25:52,350 --> 01:25:55,920
és akkor nyomtassa ki a változók állapotát a program abban az időben.

1394
01:25:55,920 --> 01:25:58,990
>> Tudunk majd onnan végig a programot line-by-line.

1395
01:25:58,990 --> 01:26:03,200
És akkor nézd meg az állam a stack idején.

1396
01:26:03,200 --> 01:26:08,600
És így használata érdekében GDB, mit teszünk, hívjuk csenget a C fájlt,

1397
01:26:08,600 --> 01:26:11,290
de van, hogy adja át a-ggdb zászló.

1398
01:26:11,290 --> 01:26:15,850
És ha mi történik, hogy csak fut gdb a kapott kimeneti fájl.

1399
01:26:15,850 --> 01:26:18,810
És így kapsz néhány hasonló tömegű szövegben, mint ez,

1400
01:26:18,810 --> 01:26:21,990
de tényleg csak annyit kell tennie, hogy írja be a parancsokat az elején.

1401
01:26:21,990 --> 01:26:24,250
Szünet fő helyez töréspont a fő.

1402
01:26:24,250 --> 01:26:28,470
List 400 felsorolja a sornyi kódot körül sor 400.

1403
01:26:28,470 --> 01:26:31,410
És ebben az esetben, ha csak körülnézel, és azt mondják, ó,

1404
01:26:31,410 --> 01:26:34,360
Szeretném beállítani a töréspont sorban 397, ami ezen a vonalon,

1405
01:26:34,360 --> 01:26:37,170
majd a program fut be ezt a lépést, és ez fog törni.

1406
01:26:37,170 --> 01:26:41,120
Ez lesz szünet van, és akkor ki kell nyomtatni, például értéke alacsony vagy magas.

1407
01:26:41,120 --> 01:26:46,410
És van egy csomó parancsok, amit tudnod kell,

1408
01:26:46,410 --> 01:26:48,660
és ez a diavetítés megy fel a honlapon,

1409
01:26:48,660 --> 01:26:54,000
így ha csak azt, hogy hivatkozni ilyen, vagy hasonló tedd a cheat lapok, nyugodtan.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. Ez volt Quiz Beszámoló 0, és mi sehova, ha bármilyen kérdése van.

1411
01:27:00,650 --> 01:27:03,850
Rendben van.

1412
01:27:03,850 --> 01:27:09,030
>>  [Taps]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]