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

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

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

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

5
00:00:10,000 --> 00:00:15,000
Dobrodošli na pregledu seji za kviz 0, ki poteka v sredo.

6
00:00:15,000 --> 00:00:19,000
Kaj bomo nocoj, sem s 3 drugimi TF,

7
00:00:19,000 --> 00:00:24,000
in skupaj bomo šli skozi pregled, kaj smo naredili v letu doslej.

8
00:00:24,000 --> 00:00:27,000
To ne bo 100% celovit, vendar bi vam boljšo idejo

9
00:00:27,000 --> 00:00:31,000
tega, kar že imate dol in kaj je treba še preučiti, preden sredo.

10
00:00:31,000 --> 00:00:34,000
In vas prosimo, da dvigne roko z vprašanji, kot gremo skupaj,

11
00:00:34,000 --> 00:00:38,000
vendar ne pozabite, da bomo tudi malo časa na koncu

12
00:00:38,000 --> 00:00:41,000
če bomo končali z nekaj minut, da se rezervno storiti splošna vprašanja,

13
00:00:41,000 --> 00:00:47,000
tako da se vodijo v mislih, zato bomo začeli na začetku tedna z 0.

14
00:00:47,000 --> 00:00:50,000
>> [Kviz 0 mnenje!] [Part 0] [Lexi Ross] Toda preden to storimo, kaj je govoril o

15
00:00:50,000 --> 00:00:53,000
logistike kvizu.

16
00:00:53,000 --> 00:00:55,000
>> [Logistika] [Kviz poteka v sredo, 10/10 namesto predavanja]

17
00:00:55,000 --> 00:00:57,000
>> [(Glej http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf za podrobnosti)], je na sreda, 10. okt.

18
00:00:57,000 --> 00:01:00,000
>> To je v sredo, in če greš na ta URL tukaj,

19
00:01:00,000 --> 00:01:03,000
, ki je dostopen tudi iz CS50.net, tam je povezava na to-

20
00:01:03,000 --> 00:01:06,000
si lahko ogledate informacije o tem, kam iti na podlagi

21
00:01:06,000 --> 00:01:10,000
vaš priimek ali šole pripadnost kot tudi

22
00:01:10,000 --> 00:01:14,000
pripoveduje o tem, kaj bo kviz zajema in vrste vprašanj, ki jih boste dobili.

23
00:01:14,000 --> 00:01:19,000
Imejte v mislih, da boste imeli tudi priložnost za pregled za kviz v oddelku,

24
00:01:19,000 --> 00:01:21,000
Tako bi bilo vaše TFS se bo čez nekaj praktičnih problemov,

25
00:01:21,000 --> 00:01:29,000
in to je še ena dobra priložnost, da vidim, če ste še vedno treba preučiti pripravljen za kviz.

26
00:01:29,000 --> 00:01:32,000
Začnimo na začetku z bitov 'N' Bytes.

27
00:01:32,000 --> 00:01:35,000
Ne pozabite, malo je samo 0 ali 1,

28
00:01:35,000 --> 00:01:38,000
in bajt je zbirka teh 8 bitov.

29
00:01:38,000 --> 00:01:42,000
Oglejmo si to zbirko bitov tukaj.

30
00:01:42,000 --> 00:01:44,000
Morali bi biti sposobni ugotoviti, koliko bitov je.

31
00:01:44,000 --> 00:01:48,000
Če upoštevamo, da je samo 8 od njih 8 0 ali 1 enote.

32
00:01:48,000 --> 00:01:51,000
In ker tam je 8 bitov, to je 1 bajt,

33
00:01:51,000 --> 00:01:53,000
in naj se pretvori v šestnajstiško.

34
00:01:53,000 --> 00:01:58,000
Šestnajstiški je osnova 16, in to je zelo enostavno pretvorbo

35
00:01:58,000 --> 00:02:01,000
število v binarno, ki je tisto, kar pomeni, da je število v šestnajstiško.

36
00:02:01,000 --> 00:02:04,000
Vse mi je, da smo si na skupine po 4,

37
00:02:04,000 --> 00:02:07,000
in smo jih pretvoriti v ustrezno števko šestnajstiški.

38
00:02:07,000 --> 00:02:11,000
Začnemo z desne najbolj skupine 4, torej 0011.

39
00:02:11,000 --> 00:02:16,000
To bo še ena 1 in 1 2, tako skupaj, da naredi 3.

40
00:02:16,000 --> 00:02:19,000
In potem si oglejmo drugi blok 4.

41
00:02:19,000 --> 00:02:24,000
1101. To bo še ena 1, 1 4 in 1 8.

42
00:02:24,000 --> 00:02:28,000
Skupaj ki bo v 13, kar pomeni, D.

43
00:02:28,000 --> 00:02:32,000
In ne pozabite, da bomo v šestnajstiškem ne bomo iti od 0 do 9.

44
00:02:32,000 --> 00:02:36,000
Gremo 0 do F, tako da po 9, 10 ustreza,

45
00:02:36,000 --> 00:02:40,000
11 B, in tako dalje, kjer je F 15.

46
00:02:40,000 --> 00:02:44,000
Tukaj je 13 D,

47
00:02:44,000 --> 00:02:49,000
tako spremeniti, da decimalno vsi delamo, je, da smo dejansko

48
00:02:49,000 --> 00:02:52,000
zdravljenje vsakega položaja, moči 2.

49
00:02:52,000 --> 00:02:58,000
To je ena 1, 1 2, 4s nič, nič 8s, eden 16, in tako naprej,

50
00:02:58,000 --> 00:03:03,000
in to je malo težko izračunati v tvoji glavi, če pa gremo na naslednjo stran

51
00:03:03,000 --> 00:03:05,000
lahko vidimo odgovor na to vprašanje.

52
00:03:05,000 --> 00:03:09,000
>> V bistvu gremo nasproti nazaj na levo,

53
00:03:09,000 --> 00:03:14,000
in smo se pomnoži vsako številko z ustrezno močjo 2.

54
00:03:14,000 --> 00:03:19,000
In ne pozabite, za šestnajstiško označujemo te številke z 0x na začetku

55
00:03:19,000 --> 00:03:23,000
tako da ne bomo zamenjali z decimalno številko.

56
00:03:23,000 --> 00:03:29,000
Nadaljevanje je to ASCII tabela,

57
00:03:29,000 --> 00:03:35,000
in kaj bomo uporabili za ASCII je zemljevid od znakov, da numerične vrednosti.

58
00:03:35,000 --> 00:03:39,000
Ne pozabite na pset kriptografije smo široko uporabo ASCII tabele

59
00:03:39,000 --> 00:03:43,000
Za uporabo različnih metod kriptografije,

60
00:03:43,000 --> 00:03:47,000
Cezar in šifra Vigenère, pretvoriti različne črke

61
00:03:47,000 --> 00:03:52,000
v nizu po ključu, ki ga uporabnik.

62
00:03:52,000 --> 00:03:56,000
Oglejmo si malo ASCII matematiki.

63
00:03:56,000 --> 00:04:02,000
Če pogledamo na "P" + 1, v obliki znaka, ki bi bil Q,

64
00:04:02,000 --> 00:04:07,000
in ne pozabite, da '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
In kako bi pretvorbo med temi oblikami 2?

66
00:04:10,000 --> 00:04:13,000
To dejansko ni preveč težko.

67
00:04:13,000 --> 00:04:16,000
Da bi dobili 5 odštejemo 0 "

68
00:04:16,000 --> 00:04:20,000
ker so 5 mest med 0 "in '5."

69
00:04:20,000 --> 00:04:23,000
Da bi šel v drugo smer smo samo dodati 0,

70
00:04:23,000 --> 00:04:25,000
tako da je nekako tako kot redni aritmetiki.

71
00:04:25,000 --> 00:04:29,000
Zapomnite si, da ko nekaj je narekovaje okoli nje je znak

72
00:04:29,000 --> 00:04:37,000
in tako ustreza vrednosti v ASCII tabeli.

73
00:04:37,000 --> 00:04:40,000
Selitev v bolj splošne teme računalništva.

74
00:04:40,000 --> 00:04:43,000
Izvedeli smo, kaj je algoritem in kako jih uporabljamo programiranje

75
00:04:43,000 --> 00:04:45,000
za izvajanje algoritmov.

76
00:04:45,000 --> 00:04:48,000
Nekateri primeri algoritmov so nekaj zelo enostavno, kot

77
00:04:48,000 --> 00:04:51,000
preverjanje, ali je število sodo ali liho.

78
00:04:51,000 --> 00:04:54,000
Za to smo se spomnite mod številko z 2 in preverite, če je rezultat 0.

79
00:04:54,000 --> 00:04:57,000
Če je tako, je še. Če ne, to je čudno.

80
00:04:57,000 --> 00:04:59,000
In to je primer res osnovni algoritem.

81
00:04:59,000 --> 00:05:02,000
>> Malo bolj vključene 1 je binarno iskanje,

82
00:05:02,000 --> 00:05:05,000
ki bomo šli čez pozneje v zvezi s pregledom seji.

83
00:05:05,000 --> 00:05:09,000
In programiranje je izraz, ki ga uporabljamo za sprejemanje algoritem

84
00:05:09,000 --> 00:05:15,000
in se lahko pretvori kodo, da računalnik bere.

85
00:05:15,000 --> 00:05:20,000
2 Primeri programiranja je na praske,

86
00:05:20,000 --> 00:05:22,000
, ki je tisto, kar smo storili v tednu 0.

87
00:05:22,000 --> 00:05:25,000
Čeprav pravzaprav ne tip iz kodeksa je način izvajanja

88
00:05:25,000 --> 00:05:29,000
Ta algoritem, ki tiska številke 1-10,

89
00:05:29,000 --> 00:05:32,000
in tu storiti enako v programskem jeziku C.

90
00:05:32,000 --> 00:05:41,000
To so funkcionalno enakovreden, tako napisana v različnih jezikih ali sintakse.

91
00:05:41,000 --> 00:05:44,000
Nato smo se naučili o matematičnih izrazov,

92
00:05:44,000 --> 00:05:48,000
in boolean je vrednost, ki je bodisi resnična ali neresnična,

93
00:05:48,000 --> 00:05:51,000
in tukaj velikokrat boolean izrazi

94
00:05:51,000 --> 00:05:55,000
Vstopimo pogojev, tako da, če (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
No, smo že x = 5, tako da je pogoj, da se bo ocenila, da res.

96
00:06:00,000 --> 00:06:03,000
In če je res, kar je koda pod pogojem,

97
00:06:03,000 --> 00:06:08,000
bo treba oceniti z računalnikom, tako da je niz se bo natisnjen

98
00:06:08,000 --> 00:06:12,000
na standardni izhod, in izraz stanja

99
00:06:12,000 --> 00:06:16,000
se nanaša na vse, kar je v oklepajih if stavku.

100
00:06:16,000 --> 00:06:20,000
Ne pozabite, vse izvajalce.

101
00:06:20,000 --> 00:06:26,000
Ne pozabite, da je && in | |, ko poskušamo sestavljena iz 2 ali več pogojev,

102
00:06:26,000 --> 00:06:30,000
== Ne = bi preverili, ali so 2 stvari enako.

103
00:06:30,000 --> 00:06:36,000
Ne pozabite, da je za dodelitev = ker je == logična operater.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ nato končno 2 sta samoumevna.

105
00:06:41,000 --> 00:06:45,000
Splošen pregled boolean logike tukaj.

106
00:06:45,000 --> 00:06:48,000
In boolean izrazi so pomembni tudi zank,

107
00:06:48,000 --> 00:06:50,000
ki bomo šli več kot sedaj.

108
00:06:50,000 --> 00:06:56,000
Izvedeli smo približno 3 vrste zank doslej CS50, za, medtem ko je, in ne časa.

109
00:06:56,000 --> 00:06:59,000
In to je pomembno, da veste, da medtem ko je v večini primerov

110
00:06:59,000 --> 00:07:02,000
lahko dejansko uporablja nobene vrste zanke na splošno

111
00:07:02,000 --> 00:07:06,000
obstajajo določene vrste razlogov ali splošnih vzorcev

112
00:07:06,000 --> 00:07:09,000
pri načrtovanju programov, ki so posebej klic za eno od teh zank

113
00:07:09,000 --> 00:07:13,000
da bi bilo najbolj učinkovito in eleganten to kodo na ta način.

114
00:07:13,000 --> 00:07:18,000
Pojdimo nad tem, kaj vsaka od teh zank kaže, da je za najbolj pogosto.

115
00:07:18,000 --> 00:07:21,000
>> V zanka smo na splošno že veš, kolikokrat želimo ponoviti.

116
00:07:21,000 --> 00:07:24,000
To je tisto, kar smo se v stanju.

117
00:07:24,000 --> 00:07:28,000
Za i = 0, i <10, na primer.

118
00:07:28,000 --> 00:07:31,000
Mi že vemo, da želimo narediti nekaj 10-krat.

119
00:07:31,000 --> 00:07:34,000
Zdaj, za nekaj časa zanke, na splošno ne nujno

120
00:07:34,000 --> 00:07:36,000
vem kolikokrat želimo zanka teči.

121
00:07:36,000 --> 00:07:39,000
Vemo pa, nekakšen pogoj, da želimo, da

122
00:07:39,000 --> 00:07:41,000
vedno res, ali vedno napačna.

123
00:07:41,000 --> 00:07:44,000
Na primer, nastavite časa.

124
00:07:44,000 --> 00:07:46,000
Recimo, da je to logična spremenljivka.

125
00:07:46,000 --> 00:07:48,000
Čeprav je to res želimo koda za ocenjevanje,

126
00:07:48,000 --> 00:07:52,000
Tako malo bolj razširiti, nekoliko bolj splošna kot za zanke,

127
00:07:52,000 --> 00:07:55,000
vendar pa lahko vsaka zanka tudi pretvori v while zanko.

128
00:07:55,000 --> 00:08:00,000
Končno, medtem ko je zank, ki so lahko najtezje razumeti takoj,

129
00:08:00,000 --> 00:08:04,000
se pogosto uporablja, kadar želimo ovrednotiti kodo 1.

130
00:08:04,000 --> 00:08:06,000
Pred prvo preverimo stanje.

131
00:08:06,000 --> 00:08:09,000
Skupna raba primeru, medtem ko je zanka

132
00:08:09,000 --> 00:08:12,000
je, ko želite, da se vnos uporabnika, in veste, da ste želeli vprašati uporabnika

133
00:08:12,000 --> 00:08:15,000
Za vnos vsaj enkrat, če pa vam ne dajejo dober prispevek takoj

134
00:08:15,000 --> 00:08:18,000
želite, da jih prosi, dokler ne dam dober znak.

135
00:08:18,000 --> 00:08:21,000
To je najpogostejša uporaba ne while zanko,

136
00:08:21,000 --> 00:08:23,000
in si oglejmo dejanske strukture teh zank.

137
00:08:23,000 --> 00:08:27,000
Navadno vedno običajno sledijo teh vzorcev.

138
00:08:27,000 --> 00:08:30,000
>> Na zanke za notranje imate 3 komponente:

139
00:08:30,000 --> 00:08:35,000
inicializacijo, ponavadi nekaj takega int i = 0, kjer je i števec,

140
00:08:35,000 --> 00:08:40,000
stanje, kjer želimo povedati teči ta zanka, dokler ta pogoj še vedno velja,

141
00:08:40,000 --> 00:08:44,000
Kot sem <10, nato pa na koncu, posodobitvi, ki je, kako smo prirastek

142
00:08:44,000 --> 00:08:47,000
števec spremenljivka za vsako točko v zanko.

143
00:08:47,000 --> 00:08:50,000
Običajna stvar, da vidite, da je ravno i + +,

144
00:08:50,000 --> 00:08:52,000
Kar pomeni, da prirastek po 1 vsak čas.

145
00:08:52,000 --> 00:08:55,000
Lahko bi tudi kaj takega i + = 2,

146
00:08:55,000 --> 00:08:58,000
kar pomeni, dodamo 2 do i vsakič, ko gredo skozi zanko.

147
00:08:58,000 --> 00:09:03,000
In potem se to nanaša samo na kodo, ki dejansko poteka kot del zanke.

148
00:09:03,000 --> 00:09:09,000
In za nekaj časa zanke, tokrat smo dejansko imeli inicializacijo zunaj zanke,

149
00:09:09,000 --> 00:09:12,000
Tako, na primer, recimo, da skušamo narediti isto vrsto zanke, kot sem opisal.

150
00:09:12,000 --> 00:09:16,000
Mi bi rekli, int i = 0, preden se zanka začne.

151
00:09:16,000 --> 00:09:20,000
Potem lahko rečemo, medtem ko je i <10 to,

152
00:09:20,000 --> 00:09:22,000
Tako isti kode, kot prej,

153
00:09:22,000 --> 00:09:26,000
in tokrat posodobitev del kode, na primer, i + +,

154
00:09:26,000 --> 00:09:29,000
dejansko gre znotraj zanke.

155
00:09:29,000 --> 00:09:33,000
In končno, za to pa, da je podobno kot while zanko,

156
00:09:33,000 --> 00:09:36,000
vendar se moramo zavedati, da bo koda oceni enkrat

157
00:09:36,000 --> 00:09:40,000
preden se preveri pogoj, tako da naredi veliko bolj smiselno

158
00:09:40,000 --> 00:09:44,000
če gledate na to, da od vrha do dna.

159
00:09:44,000 --> 00:09:49,000
V to zanko, medtem ko je koda ocenjuje, preden ga sploh pogledal while pogoj,

160
00:09:49,000 --> 00:09:55,000
ker while zanko, da najprej preveri.

161
00:09:55,000 --> 00:09:59,000
Izjave in spremenljivke.

162
00:09:59,000 --> 00:10:04,000
Ko smo želeli ustvariti novo spremenljivko želimo najprej inicializacijo.

163
00:10:04,000 --> 00:10:07,000
>> Na primer, int vrstica inicializira spremenljivko bar,

164
00:10:07,000 --> 00:10:10,000
vendar pa ne daje vrednost, tako da tisto, kar je vrednost bara je zdaj?

165
00:10:10,000 --> 00:10:12,000
Ne vemo.

166
00:10:12,000 --> 00:10:14,000
Lahko bi bilo nekaj smeti vrednost, ki je bil prej shranjen v spomin tam,

167
00:10:14,000 --> 00:10:16,000
in ne želimo, da bo uporabil ta spremenljivka

168
00:10:16,000 --> 00:10:19,000
dokler ne bomo dejansko dal to vrednost,

169
00:10:19,000 --> 00:10:21,000
zato smo jo razglaša tukaj.

170
00:10:21,000 --> 00:10:24,000
Potem smo inicializirati, da je 42 spodaj.

171
00:10:24,000 --> 00:10:28,000
Zdaj seveda vemo, to pa je mogoče v eni vrstici, int vrstica = 42.

172
00:10:28,000 --> 00:10:30,000
Ampak samo zato, da bi očistili več korakov, ki se odvijajo,

173
00:10:30,000 --> 00:10:34,000
deklaracija in inicializacija ločeno dogaja.

174
00:10:34,000 --> 00:10:38,000
To se zgodi v enem koraku, in naslednjič, int BAZ = vrstica + 1,

175
00:10:38,000 --> 00:10:44,000
To spodaj navedeno izjavo, da korakih Baz, tako da na koncu te kode bloka

176
00:10:44,000 --> 00:10:48,000
če smo bili za tiskanje vrednost Baz bi bilo 44

177
00:10:48,000 --> 00:10:52,000
ker smo jih razglasi za inicializacijo za 1> bar,

178
00:10:52,000 --> 00:10:58,000
in potem smo ga prirastek še enkrat z + +.

179
00:10:58,000 --> 00:11:02,000
Šli smo v tem precej kratko, vendar je dobro, da ima splošno

180
00:11:02,000 --> 00:11:04,000
razumevanje tega, kar niti in prireditve so.

181
00:11:04,000 --> 00:11:06,000
Mi v glavnem je to storila v Scratch,

182
00:11:06,000 --> 00:11:09,000
Tako si lahko zamislite niti kot več zaporedij z oznako

183
00:11:09,000 --> 00:11:11,000
teče ob istem času.

184
00:11:11,000 --> 00:11:14,000
V resnici pa verjetno ne teče ob istem času,

185
00:11:14,000 --> 00:11:17,000
ampak nekako abstraktno lahko razmišljamo o tem na tak način.

186
00:11:17,000 --> 00:11:20,000
>> V Scratch, na primer, smo imeli več sprites.

187
00:11:20,000 --> 00:11:22,000
Lahko bi se izvršilni drugačno kodo ob istem času.

188
00:11:22,000 --> 00:11:26,000
Lahko bi se peš, medtem ko drugi je rekel nekaj

189
00:11:26,000 --> 00:11:29,000
V drugem delu zaslona.

190
00:11:29,000 --> 00:11:34,000
Dogodki so še en način izloči logiko

191
00:11:34,000 --> 00:11:37,000
med različnimi elementi kodo,

192
00:11:37,000 --> 00:11:40,000
in Scratch smo lahko simulirajo dogajanja z uporabo oddajanje,

193
00:11:40,000 --> 00:11:43,000
in to je pravzaprav, ko dobim, ne, ko slišim,

194
00:11:43,000 --> 00:11:47,000
v bistvu pa je to način za prenos podatkov

195
00:11:47,000 --> 00:11:49,000
od enega do drugega Vilenjak.

196
00:11:49,000 --> 00:11:52,000
Na primer, boste morda želeli poslati v igro,

197
00:11:52,000 --> 00:11:56,000
in če še sprite prejme igre konec,

198
00:11:56,000 --> 00:11:58,000
se odziva na določen način.

199
00:11:58,000 --> 00:12:03,000
To je pomemben zgled za razumevanje za programiranje.

200
00:12:03,000 --> 00:12:07,000
Samo, da gredo nad osnovno 0. teden, kar sva šla čez tako daleč,

201
00:12:07,000 --> 00:12:10,000
Oglejmo si ta preprost program C.

202
00:12:10,000 --> 00:12:14,000
Besedilo je lahko malo majhen od tukaj, ampak bom šel nad njim res hitro.

203
00:12:14,000 --> 00:12:20,000
Mi smo tudi 2 header datoteke na vrhu, cs50.h in stdio.h.

204
00:12:20,000 --> 00:12:23,000
Mi smo potem opredelitev stalnega imenovano mejo za 100.

205
00:12:23,000 --> 00:12:26,000
Mi smo potem uresničili našo glavno funkcijo.

206
00:12:26,000 --> 00:12:29,000
Ker ne uporabljamo argumente v ukazni vrstici, tukaj moramo postaviti praznino

207
00:12:29,000 --> 00:12:32,000
kot argumente za glavni.

208
00:12:32,000 --> 00:12:38,000
Bomo videli zgoraj int main. To je vrnitev tip, zato se vrnete 0 na dnu.

209
00:12:38,000 --> 00:12:41,000
In mi smo z uporabo CS50 knjižnično funkcijo dobili int

210
00:12:41,000 --> 00:12:45,000
da od uporabnika zahteva za vnos, in jo shranite na to spremenljivko x,

211
00:12:45,000 --> 00:12:51,000
Tako izjavljamo x zgoraj, in jo inicializirati z x = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> Nato smo preverite, če je uporabnik nam je dal dober znak.

213
00:12:53,000 --> 00:12:59,000
Če je ≥ LIMIT želimo, da vrne kodo napake za 1 in natisniti sporočilo o napaki.

214
00:12:59,000 --> 00:13:02,000
In končno, če je uporabnik nam je dal dober prispevek

215
00:13:02,000 --> 00:13:08,000
bomo sprijazniti številko in natisnite ta rezultat.

216
00:13:08,000 --> 00:13:11,000
Samo se prepričajte, da so vsi hit domov

217
00:13:11,000 --> 00:13:17,000
si lahko ogledate nalepke različnih delih kode tukaj.

218
00:13:17,000 --> 00:13:19,000
Omenil sem konstantno, header datoteke.

219
00:13:19,000 --> 00:13:21,000
Oh, int x. Prepričajte se, da se spomnimo, da je lokalna spremenljivka.

220
00:13:21,000 --> 00:13:24,000
To je v nasprotju z globalno spremenljivko, ki se bomo pogovorili o

221
00:13:24,000 --> 00:13:27,000
Malo pozneje v zvezi s pregledom zasedanju

222
00:13:27,000 --> 00:13:30,000
in smo poklical knjižnično funkcijo printf,

223
00:13:30,000 --> 00:13:34,000
tako da če ne bi vključevala stdio.h glavo datoteke

224
00:13:34,000 --> 00:13:37,000
ne bi mogli poklicati printf.

225
00:13:37,000 --> 00:13:42,000
In mislim, da je puščica, da imam prekinil tukaj kaže na% d,

226
00:13:42,000 --> 00:13:45,000
ki je oblikovanje niz v printf.

227
00:13:45,000 --> 00:13:52,000
Pravi natisnete to spremenljivko, številka% d.

228
00:13:52,000 --> 00:13:58,000
In to je za 0. teden.

229
00:13:58,000 --> 00:14:06,000
Zdaj Lucas se bo nadaljevala.

230
00:14:06,000 --> 00:14:08,000
Hej, fantje. Moje ime je Lucas.

231
00:14:08,000 --> 00:14:10,000
Jaz sem v drugem letniku v najboljšem hiši v naselju, Mather,

232
00:14:10,000 --> 00:14:14,000
in bom še malo govorim o tednu 1 in 2,1.

233
00:14:14,000 --> 00:14:16,000
[Teden 1 in 2,1!] [Lucas Freitas]

234
00:14:16,000 --> 00:14:19,000
Kot Lexi je rekel, ko smo začeli prevajati kodo iz nič na C

235
00:14:19,000 --> 00:14:23,000
ena od stvari, ki smo opazili, je, da lahko ne samo

236
00:14:23,000 --> 00:14:26,000
napišite kodo in jo zagnati z zeleno zastavo več.

237
00:14:26,000 --> 00:14:30,000
Pravzaprav, boste morali uporabiti nekaj korakov, da bi vaš C programa,

238
00:14:30,000 --> 00:14:33,000
postala izvršljiva datoteka.

239
00:14:33,000 --> 00:14:36,000
V bistvu, kaj storiti, ko pišete program, ki je

240
00:14:36,000 --> 00:14:40,000
prevesti zamisli v jeziku, ki ga razumejo prevajalnik,

241
00:14:40,000 --> 00:14:44,000
tako da, ko pišete program v C

242
00:14:44,000 --> 00:14:47,000
kaj delaš, je dejansko pisanje nekaj, da vaš prevajalnik bo razumel,

243
00:14:47,000 --> 00:14:50,000
in potem prevajalnik bo prevesti to kodo

244
00:14:50,000 --> 00:14:53,000
v nekaj, kar bo vaš računalnik razume.

245
00:14:53,000 --> 00:14:55,000
>> In stvar je, računalnik je pravzaprav zelo neumno.

246
00:14:55,000 --> 00:14:57,000
Računalnik lahko razumem le 0s in 1s,

247
00:14:57,000 --> 00:15:01,000
Tako je dejansko v prvih računalnikov ljudje običajno programira

248
00:15:01,000 --> 00:15:04,000
z 0 in 1s, vendar ne več, hvala bogu.

249
00:15:04,000 --> 00:15:07,000
Nimamo zapomniti zaporedja za 0s in 1s

250
00:15:07,000 --> 00:15:10,000
Za zanka ali while zanko in tako naprej.

251
00:15:10,000 --> 00:15:13,000
Zato imamo prevajalnik.

252
00:15:13,000 --> 00:15:17,000
Kaj prevajalnik pa je v bistvu prevaja kodo C,

253
00:15:17,000 --> 00:15:21,000
v našem primeru, v jeziku, ki ga bo vaš računalnik razume,

254
00:15:21,000 --> 00:15:25,000
ki je predmet kodo in prevajalnik, ki smo ga uporabljate

255
00:15:25,000 --> 00:15:30,000
se imenuje Jek, tako da je to pravzaprav simbol za Jek.

256
00:15:30,000 --> 00:15:33,000
Ko imate program, moraš narediti 2 stvari.

257
00:15:33,000 --> 00:15:37,000
Najprej morate pripraviti svoj program, nato pa boste teči vaš program.

258
00:15:37,000 --> 00:15:41,000
Za pripravo svojega programa, da imate veliko možnosti, da to stori.

259
00:15:41,000 --> 00:15:44,000
Prva je, da to Jek program.c

260
00:15:44,000 --> 00:15:47,000
Program, v katerem je ime vašega programa.

261
00:15:47,000 --> 00:15:51,000
V tem primeru lahko vidite, oni samo rekel: "Hej, sestavi svoj program."

262
00:15:51,000 --> 00:15:56,000
Saj ne pravim, "Hočem to ime za svoj program" ali kaj podobnega.

263
00:15:56,000 --> 00:15:58,000
>> Druga možnost je kar ime vašega programa.

264
00:15:58,000 --> 00:16:02,000
Lahko rečemo, Jek-o in nato ime, ki ga želite

265
00:16:02,000 --> 00:16:06,000
izvedljivo datoteko, da bo imenovan kot in nato program.c.

266
00:16:06,000 --> 00:16:11,000
In lahko storite tudi, da program, in videli, kako je v prvih 2 primerih

267
00:16:11,000 --> 00:16:15,000
Sem dal c. In v tretjo imam samo programe?

268
00:16:15,000 --> 00:16:18,000
Ja, pravzaprav ne bi smelo postaviti C, če boste uporabili narediti..

269
00:16:18,000 --> 00:16:22,000
Sicer prevajalnik se dejansko dogaja, da kričati na vas.

270
00:16:22,000 --> 00:16:24,000
In tudi ne vem, če se vi spomnite,

271
00:16:24,000 --> 00:16:29,000
ampak veliko krat smo uporabili tudi lcs50-ali-lm.

272
00:16:29,000 --> 00:16:31,000
To se imenuje povezovanje.

273
00:16:31,000 --> 00:16:35,000
To samo pove prevajalniku, da boste uporabili te knjižnice tam,

274
00:16:35,000 --> 00:16:39,000
tako da, če želite uporabljati cs50.h boste dejansko morali vnesti

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

276
00:16:43,000 --> 00:16:45,000
Če tega ne boste storili, da prevajalnik ne bo vedel

277
00:16:45,000 --> 00:16:50,000
da uporabljate te funkcije v cs50.h.

278
00:16:50,000 --> 00:16:52,000
In če želite zagnati svoj program imate 2 možnosti.

279
00:16:52,000 --> 00:16:57,000
Če ste Jek program.c nisi dal ime vašega programa.

280
00:16:57,000 --> 00:17:01,000
Moraš teči z. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out je standardno ime, ki Jek daje svoj program, če ne ji dati ime.

282
00:17:06,000 --> 00:17:11,000
Drugače boš naredil. / Program, če je dal ime vašega programa,

283
00:17:11,000 --> 00:17:15,000
in tudi, če bi naredil programa ime programa, ki bo dobil

284
00:17:15,000 --> 00:17:23,000
se že dogaja, da je treba programirati isto ime kot datoteka c.

285
00:17:23,000 --> 00:17:26,000
Potem sva se pogovarjala vrste podatkov in podatkov.

286
00:17:26,000 --> 00:17:31,000
>> V bistvu podatkovni tipi so ista stvar kot majhne škatle, ki jih uporabljajo

287
00:17:31,000 --> 00:17:35,000
za shranjevanje vrednosti, tako da podatkovni tipi so dejansko tako kot pokemons.

288
00:17:35,000 --> 00:17:39,000
Pridejo v vseh velikosti in vrst.

289
00:17:39,000 --> 00:17:43,000
Ne vem, če je analogija smiselna.

290
00:17:43,000 --> 00:17:46,000
Podatki velikost je dejansko odvisna od stroja arhitekture.

291
00:17:46,000 --> 00:17:49,000
Vsi podatki, velikosti, ki jih bom tukaj prikaz

292
00:17:49,000 --> 00:17:53,000
dejansko za 32-bitni stroj, ki je v tem primeru naše naprave,

293
00:17:53,000 --> 00:17:56,000
ampak, če ste dejansko kodiranje Mac ali Windows tudi v

294
00:17:56,000 --> 00:17:59,000
Verjetno boš imel 64-bitni stroj,

295
00:17:59,000 --> 00:18:03,000
zato ne pozabite, da so podatki, velikosti, ki jih bom tukaj prikaz

296
00:18:03,000 --> 00:18:06,000
so za 32-bitni stroj.

297
00:18:06,000 --> 00:18:08,000
Prvo, kar smo videli, je int,

298
00:18:08,000 --> 00:18:10,000
kar je precej preprosta.

299
00:18:10,000 --> 00:18:13,000
Uporabite int za shranjevanje celo število.

300
00:18:13,000 --> 00:18:16,000
Videli smo tudi značaj, je char.

301
00:18:16,000 --> 00:18:20,000
Če želite uporabiti črke ali malo znak, da ste verjetno, da bo uporabila znak.

302
00:18:20,000 --> 00:18:26,000
Char ima 1 bajt, kar pomeni 8 bitov, kot Lexi dejal.

303
00:18:26,000 --> 00:18:31,000
V bistvu imamo ASCII tabelo, ki ima 256

304
00:18:31,000 --> 00:18:34,000
možne kombinacije 0s in 1s,

305
00:18:34,000 --> 00:18:37,000
in potem, ko vnesete znak, da gre za prevajanje

306
00:18:37,000 --> 00:18:44,000
znak, da se vložki ste številko, ki jih imate v ASCII tabeli, kot je dejal, Lexi.

307
00:18:44,000 --> 00:18:48,000
Imamo tudi plovec, ki ga uporabljamo za shranjevanje decimalne številke.

308
00:18:48,000 --> 00:18:53,000
Če želite izbrati 3,14, na primer, boste za uporabo float

309
00:18:53,000 --> 00:18:55,000
ali dvakrat, da ima večjo natančnost.

310
00:18:55,000 --> 00:18:57,000
Plovec je 4 bajte.

311
00:18:57,000 --> 00:19:01,000
Dvakrat je 8 bajtov, tako da je edina razlika je natančnost.

312
00:19:01,000 --> 00:19:04,000
Imamo tudi dolgo, da se uporablja za cela števila,

313
00:19:04,000 --> 00:19:09,000
in si lahko ogledate za 32-bitno strojno int in dolgo so enake velikosti,

314
00:19:09,000 --> 00:19:13,000
tako da ne res smiselno uporabiti dolgo v 32-bitni stroj.

315
00:19:13,000 --> 00:19:17,000
>> Toda, če uporabljate Mac in 64-bitni stroj, pravzaprav dolgo je velikost 8,

316
00:19:17,000 --> 00:19:19,000
tako da je res odvisno od arhitekture.

317
00:19:19,000 --> 00:19:22,000
Za 32-bitnih računalnikih, da ni smiselno uporabljati dolgo res.

318
00:19:22,000 --> 00:19:25,000
In potem dolgo dolgo, na drugi strani pa je 8 bajtov,

319
00:19:25,000 --> 00:19:30,000
tako da je zelo dobro, če hočeš imeti daljše celo število.

320
00:19:30,000 --> 00:19:34,000
In končno, imamo niz, ki je pravzaprav char *

321
00:19:34,000 --> 00:19:37,000
, ki je kazalec na znak.

322
00:19:37,000 --> 00:19:40,000
To je zelo enostavno, da misliš, da je velikost niza se bo kot

323
00:19:40,000 --> 00:19:42,000
število znakov, ki jih imajo tam,

324
00:19:42,000 --> 00:19:45,000
ampak dejansko char * sam

325
00:19:45,000 --> 00:19:49,000
je velikost kazalec na char, kar je 4 bajte.

326
00:19:49,000 --> 00:19:52,000
Velikost char * je 4 bajte.

327
00:19:52,000 --> 00:19:56,000
Ni važno, če imate majhne besedo ali pismo ali kaj podobnega.

328
00:19:56,000 --> 00:19:58,000
To se dogaja, da je 4 bajte.

329
00:19:58,000 --> 00:20:01,000
Prav tako smo se naučili nekaj o litje,

330
00:20:01,000 --> 00:20:04,000
Kot lahko vidite, če imate na primer program, ki pravi,

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

332
00:20:08,000 --> 00:20:12,000
Ali veste, kaj se dogaja za tiskanje na zaslonu?

333
00:20:12,000 --> 00:20:14,000
>> Nekdo? >> [Dijaki] 2.

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

335
00:20:16,000 --> 00:20:20,000
Ko boste to storili 3/2, da bo dobil 1,5,

336
00:20:20,000 --> 00:20:24,000
ker pa smo s celo število, da bo prezreti decimalni del,

337
00:20:24,000 --> 00:20:26,000
in boste imeli 1.

338
00:20:26,000 --> 00:20:29,000
Če ne želite, da se to zgodi, kaj lahko naredite, na primer,

339
00:20:29,000 --> 00:20:33,000
se razglasi plovec y = x.

340
00:20:33,000 --> 00:20:40,000
Nato x, ki se uporabljajo za 3 je sedaj bo 3,000 za y.

341
00:20:40,000 --> 00:20:44,000
In potem si lahko natisnete y / 2.

342
00:20:44,000 --> 00:20:50,000
Pravzaprav bi moral imeti 2. tam.

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

344
00:20:55,000 --> 00:20:58,000
in boš dobil 1,5.

345
00:20:58,000 --> 00:21:06,000
In imamo to 0,2 f samo prositi za 2 decimalni enot v decimalni del.

346
00:21:06,000 --> 00:21:12,000
Če imate 0,3 f da se bo dejansko imajo 1,500.

347
00:21:12,000 --> 00:21:16,000
Če je to 2 se bo 1.50.

348
00:21:16,000 --> 00:21:18,000
Imamo tudi ta primer tukaj.

349
00:21:18,000 --> 00:21:22,000
Če boste to storili float x = 3,14, nato pa vas printf x

350
00:21:22,000 --> 00:21:24,000
boste dobili 3,14.

351
00:21:24,000 --> 00:21:29,000
In če x = int x,

352
00:21:29,000 --> 00:21:34,000
kar pomeni, da zdravljenje x kot notr in tiskate x zdaj

353
00:21:34,000 --> 00:21:36,000
boste imeli 3,00.

354
00:21:36,000 --> 00:21:38,000
Ima to smisel?

355
00:21:38,000 --> 00:21:41,000
Ker ste 1. obravnava kot celo število x, tako da ste ignoriranje decimalni del,

356
00:21:41,000 --> 00:21:45,000
in nato tiskate x.

357
00:21:45,000 --> 00:21:47,000
In končno, lahko tudi to,

358
00:21:47,000 --> 00:21:52,000
int x = 65, nato pa razglasi char c = x,

359
00:21:52,000 --> 00:21:56,000
in potem, če tiskate c ste dejansko dogaja, da se

360
00:21:56,000 --> 00:21:59,000
, Tako da v bistvu, kaj delaš tukaj

361
00:21:59,000 --> 00:22:02,000
uresničuje celo število v znak,

362
00:22:02,000 --> 00:22:05,000
tako kot ASCII tabela ne.

363
00:22:05,000 --> 00:22:08,000
Pogovarjali smo se tudi o matematičnih operaterjev.

364
00:22:08,000 --> 00:22:14,000
Večina od njih so precej enostavna, tako +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
in prav tako smo se pogovarjali o Ministrstvo za obrambo, ki je preostanek delitve 2 številk.

366
00:22:20,000 --> 00:22:23,000
Če imate 10% 3, na primer:

367
00:22:23,000 --> 00:22:27,000
to pomeni, da delite 10 z 3, in kaj je ostalo?

368
00:22:27,000 --> 00:22:30,000
To bo 1, tako da je dejansko zelo uporaben za veliko programov.

369
00:22:30,000 --> 00:22:38,000
Za Vigenère in Cesar sem prepričan, da so vsi fantje uporabljajo mod.

370
00:22:38,000 --> 00:22:43,000
O matematiki subjektov, biti zelo previdni pri združevanju * in /.

371
00:22:43,000 --> 00:22:48,000
>> Na primer, če vam (3/2) * 2, kaj boš dobil?

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

373
00:22:50,000 --> 00:22:54,000
Ja, 2, saj 3/2 se bo 1,5,

374
00:22:54,000 --> 00:22:57,000
ker pa delaš operacij med 2 celih

375
00:22:57,000 --> 00:22:59,000
ste dejansko šele tekoč, da razmisli 1,

376
00:22:59,000 --> 00:23:03,000
in potem 1 * 2 se bo 2, tako zelo, zelo previdni

377
00:23:03,000 --> 00:23:07,000
pri tem aritmetike s števil, saj

378
00:23:07,000 --> 00:23:12,000
boste morda dobili, da 2 = 3, v tej zadevi.

379
00:23:12,000 --> 00:23:14,000
In tudi biti zelo previdni glede prednosti.

380
00:23:14,000 --> 00:23:21,000
Moral bi običajno uporabljajo oklepaje, da se prepričajte, da veste, kaj počnete.

381
00:23:21,000 --> 00:23:27,000
Nekaj ​​uporabnih bližnjic, seveda, ena je i + + ali i + = 1

382
00:23:27,000 --> 00:23:30,000
ali z + =.

383
00:23:30,000 --> 00:23:34,000
To je isto, kot počne i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Prav tako lahko storim - ali i - = 1,

385
00:23:39,000 --> 00:23:42,000
kar je enako kot i = i -1,

386
00:23:42,000 --> 00:23:46,000
nekaj vi uporabljate veliko v for zanke, vsaj.

387
00:23:46,000 --> 00:23:52,000
Tudi za *, če uporabljate * = in če ne, na primer,

388
00:23:52,000 --> 00:23:57,000
i * = 2, je isto, kot piše, da imam = i * 2,

389
00:23:57,000 --> 00:23:59,000
in ista stvar za delitev.

390
00:23:59,000 --> 00:24:08,000
Če boste to storili i / = 2 je isto kot i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Zdaj pa funkcijami.

392
00:24:10,000 --> 00:24:13,000
Ste se naučili, da so funkcije zelo dobra strategija, da shranite kodo

393
00:24:13,000 --> 00:24:16,000
ko ste programiranje, tako da, če želite izvesti isto opravilo

394
00:24:16,000 --> 00:24:20,000
V kodeksu znova in znova, verjetno želite uporabiti funkcijo

395
00:24:20,000 --> 00:24:25,000
samo zato, da vam ni treba kopirati in prilepiti kodo znova in znova.

396
00:24:25,000 --> 00:24:28,000
Pravzaprav je glavna funkcija je, in ko sem vam pokazal obliko funkcije

397
00:24:28,000 --> 00:24:32,000
boste videli, da je to zelo očitno.

398
00:24:32,000 --> 00:24:35,000
Uporabljamo tudi naloge iz nekaterih knjižnic,

399
00:24:35,000 --> 00:24:39,000
na primer, printf, getin, ki je iz knjižnice CS50,

400
00:24:39,000 --> 00:24:43,000
in druge funkcije, kot so toupper.

401
00:24:43,000 --> 00:24:46,000
Vse te funkcije so dejansko izvajajo v drugih knjižnicah,

402
00:24:46,000 --> 00:24:49,000
in ko si dal privezati tiste datoteke v začetku svojega programa

403
00:24:49,000 --> 00:24:53,000
praviš, da si lahko prosim dajte mi kodo za te funkcije

404
00:24:53,000 --> 00:24:57,000
tako da mi ni treba, da jih izvajati sam?

405
00:24:57,000 --> 00:25:00,000
In lahko tudi napišete svoje naloge, tako da, ko začnete programiranje

406
00:25:00,000 --> 00:25:04,000
Se zavedaš, da knjižnice nimajo vse funkcije, ki jih potrebujete.

407
00:25:04,000 --> 00:25:10,000
Za zadnje pset, na primer, smo pisali pripravi, hitrostno in iskanje,

408
00:25:10,000 --> 00:25:13,000
in to je zelo, zelo pomembno, da bi lahko napisali nalog

409
00:25:13,000 --> 00:25:17,000
ker so koristni, in ki jih uporabljamo jih ves čas v načrtovanje,

410
00:25:17,000 --> 00:25:19,000
in prihrani veliko kode.

411
00:25:19,000 --> 00:25:21,000
Oblika funkcije je to ena.

412
00:25:21,000 --> 00:25:24,000
Imamo vrsto vrnitev na začetku. Kaj je vrnitev tip?

413
00:25:24,000 --> 00:25:27,000
To je samo, ko bo funkcija vrača.

414
00:25:27,000 --> 00:25:29,000
Če imate funkcijo, na primer, faktorsko

415
00:25:29,000 --> 00:25:31,000
da se bo za izračun fakulteto celo število,

416
00:25:31,000 --> 00:25:34,000
Verjetno pa se bo vrnil tudi celo število.

417
00:25:34,000 --> 00:25:37,000
Nato se je donosnost vrsta se bo int.

418
00:25:37,000 --> 00:25:41,000
Printf dejansko ima neveljavno vrsto povratno

419
00:25:41,000 --> 00:25:43,000
ker si ne vrne ničesar.

420
00:25:43,000 --> 00:25:45,000
Ti si samo tiskanje stvari na zaslonu

421
00:25:45,000 --> 00:25:48,000
in zapustil funkcijo kasneje.

422
00:25:48,000 --> 00:25:51,000
Potem imate ime funkcije, ki jih lahko izberete.

423
00:25:51,000 --> 00:25:55,000
Moral bi biti malo razumni, tako kot ne izbrati ime, kot je xyz

424
00:25:55,000 --> 00:25:58,000
ali kot x2f.

425
00:25:58,000 --> 00:26:02,000
Poskusi, da bi se ime, ki ima smisel.

426
00:26:02,000 --> 00:26:04,000
>> Na primer, če je to fakulteto, pravijo fakulteto.

427
00:26:04,000 --> 00:26:08,000
Če je funkcija, ki se dogaja, da pripravi nekaj, poimenujte ga pripravi.

428
00:26:08,000 --> 00:26:11,000
In potem imamo parametrov, ki se prav tako imenujejo argumenti,

429
00:26:11,000 --> 00:26:14,000
ki so kot viri, ki svoje delovanje potrebuje

430
00:26:14,000 --> 00:26:17,000
s kodo za opravljanje svojih nalog.

431
00:26:17,000 --> 00:26:20,000
Če želite izračunati fakulteto števila

432
00:26:20,000 --> 00:26:23,000
Verjetno boste morali imeti številko izračuna fakulteto.

433
00:26:23,000 --> 00:26:27,000
Eden od argumentov, ki jih boste morali število sam.

434
00:26:27,000 --> 00:26:31,000
In potem se dogaja, da nekaj storiti in vrne vrednost na koncu

435
00:26:31,000 --> 00:26:35,000
razen če je nična funkcija.

436
00:26:35,000 --> 00:26:37,000
Poglejmo primer.

437
00:26:37,000 --> 00:26:40,000
Če hočem napisati funkcijo, ki sešteje vse številke v vrsto števil,

438
00:26:40,000 --> 00:26:43,000
Najprej se je donosnost vrsta se bo int

439
00:26:43,000 --> 00:26:46,000
ker imam niz celih števil.

440
00:26:46,000 --> 00:26:51,000
In potem bom imela ime funkcije, kot sumArray,

441
00:26:51,000 --> 00:26:54,000
in potem se dogaja, da array samo, da int nums,

442
00:26:54,000 --> 00:26:58,000
in potem je dolžina niza, tako da vem, koliko številk moram povzeti.

443
00:26:58,000 --> 00:27:02,000
Potem sem moral inicializirati spremenljivko z imenom vsoto, na primer, za 0,

444
00:27:02,000 --> 00:27:08,000
in se vsakič, ko vidim element v matriki sem ga dodala na vsoto, tako da sem za zanko.

445
00:27:08,000 --> 00:27:15,000
Tako kot je rekel Lexi, vam int i = 0, i <dolžino in i + +.

446
00:27:15,000 --> 00:27:20,000
In za vsak element v matriki sem vsota + = nums [i]

447
00:27:20,000 --> 00:27:24,000
in potem sem se vrnila vsoto, zato je zelo preprosta, saj prihrani veliko kode

448
00:27:24,000 --> 00:27:28,000
Če uporabljate to funkcijo, veliko krat.

449
00:27:28,000 --> 00:27:32,000
Nato smo si ogledali pogoji.

450
00:27:32,000 --> 00:27:38,000
Imamo, če drugega, in sicer, če.

451
00:27:38,000 --> 00:27:42,000
Poglejmo, kaj je razlika med tistimi.

452
00:27:42,000 --> 00:27:45,000
Oglejte si teh 2 številk. Kakšna je razlika med njima?

453
00:27:45,000 --> 00:27:49,000
Prva je, v bistvu oznaka želim povedati

454
00:27:49,000 --> 00:27:51,000
Če je število +, -, ali 0.

455
00:27:51,000 --> 00:27:55,000
Prva pravi, da če je> 0, potem je to pozitivno.

456
00:27:55,000 --> 00:28:00,000
Če je = 0, da potem je 0, in če je <0, potem je negativna.

457
00:28:00,000 --> 00:28:04,000
>> In druga počne, če pa če drugega.

458
00:28:04,000 --> 00:28:07,000
Razlika med njima je, da je ta dejansko dogaja, da

459
00:28:07,000 --> 00:28:13,000
preveri, če> 0, 0 <= 0 ali 3-krat,

460
00:28:13,000 --> 00:28:17,000
tako da, če imate številko 2, na primer, da se bo tu prišel in rekel

461
00:28:17,000 --> 00:28:21,000
if (x> 0) in to bo rekel ja, zato sem natisniti pozitiven.

462
00:28:21,000 --> 00:28:25,000
Toda čeprav vem, da je> 0 in je ne bo 0 ali <0

463
00:28:25,000 --> 00:28:29,000
Še vedno sem storil je 0, je <0,

464
00:28:29,000 --> 00:28:33,000
tako da sem dejansko dogaja znotraj investicijskih skladov, ki sem jih ni bilo

465
00:28:33,000 --> 00:28:38,000
ker že vem, da ne bo izpolnjeval nobenega od teh pogojev.

466
00:28:38,000 --> 00:28:41,000
Lahko uporabite, če drugega, če drug izjavo.

467
00:28:41,000 --> 00:28:45,000
V bistvu pravi, da če je x = 0 tiskam pozitivno.

468
00:28:45,000 --> 00:28:48,000
Če je ne, bom tudi preizkusiti.

469
00:28:48,000 --> 00:28:51,000
Če je 2 ne bom za to.

470
00:28:51,000 --> 00:28:54,000
V bistvu, če sem imel x = 2, bi rekli,

471
00:28:54,000 --> 00:28:57,000
if (x> 0), ja, tako natisniti.

472
00:28:57,000 --> 00:29:00,000
Zdaj, ko vem, da je> 0, in da se prepriča, če 1.

473
00:29:00,000 --> 00:29:02,000
Jaz sploh ne gre za izvajanje tega kodeksa.

474
00:29:02,000 --> 00:29:09,000
Kodeks deluje hitreje, pravzaprav, 3-krat hitreje, če boste uporabili to.

475
00:29:09,000 --> 00:29:11,000
Prav tako spoznali in in ali.

476
00:29:11,000 --> 00:29:15,000
Ne bom šel skozi to, ker Lexi že govorila o njih.

477
00:29:15,000 --> 00:29:17,000
To je samo && in | | operaterja.

478
00:29:17,000 --> 00:29:21,000
>> Edino, kar bom povedal, bodite previdni, če imate 3 pogoje.

479
00:29:21,000 --> 00:29:24,000
Uporabljajte oklepaje, ker je zelo zmedeno, če imate bolezen

480
00:29:24,000 --> 00:29:27,000
in še eno, ali še eden.

481
00:29:27,000 --> 00:29:30,000
Uporaba oklepajev samo, da se prepričajte, da so vaši pogoji smisla

482
00:29:30,000 --> 00:29:34,000
ker v tem primeru, na primer, si lahko predstavljate, da je

483
00:29:34,000 --> 00:29:38,000
da bi se lahko prvi pogoj in ena ali druga

484
00:29:38,000 --> 00:29:41,000
ali 2 Pogoji, povezani v in

485
00:29:41,000 --> 00:29:45,000
ali tretja, zato bodi previden.

486
00:29:45,000 --> 00:29:48,000
In končno, smo se pogovarjali o stikali.

487
00:29:48,000 --> 00:29:53,000
Stikalo je zelo koristno, če imate spremenljivko.

488
00:29:53,000 --> 00:29:55,000
Recimo, da imate spremenljivke, kot n

489
00:29:55,000 --> 00:29:59,000
da je lahko 0, 1 ali 2, in za vsako od teh zadev

490
00:29:59,000 --> 00:30:01,000
boš za izvedbo naloge.

491
00:30:01,000 --> 00:30:04,000
Lahko rečemo izbrati spremenljivko, in to pomeni, da

492
00:30:04,000 --> 00:30:08,000
vrednost pa je kot value1 bom za to,

493
00:30:08,000 --> 00:30:12,000
potem pa sem prekinil, kar pomeni, da ne bom videti v kateri koli od drugih primerih

494
00:30:12,000 --> 00:30:15,000
ker smo že prepričan, da zadevo

495
00:30:15,000 --> 00:30:20,000
in lahko potem value2 in tako naprej, prav tako pa imajo privzeto stikalo.

496
00:30:20,000 --> 00:30:24,000
To pomeni, da če ne izpolnjujejo nobenega od primerov, ki sem jih imel

497
00:30:24,000 --> 00:30:29,000
da bom naredil kaj drugega, ampak to je opcija.

498
00:30:29,000 --> 00:30:36,000
To je vse za mano. Zdaj pa so Tommyja.

499
00:30:36,000 --> 00:30:41,000
V redu, to se bo Teden 3-ish.

500
00:30:41,000 --> 00:30:45,000
To so nekatere od tem bomo lahko zajemajo, kripto, obseg, nizi, in tako naprej.

501
00:30:45,000 --> 00:30:49,000
Samo hiter beseda o Kripto. Ne bomo, da kladivo te domov.

502
00:30:49,000 --> 00:30:52,000
>> To smo storili v pset 2, ampak za kviz poskrbite, da boste vedeli razliko

503
00:30:52,000 --> 00:30:54,000
med cesarjem in šifra šifra Vigenère,

504
00:30:54,000 --> 00:30:57,000
kako oba dela teh šifer in kako je za šifriranje

505
00:30:57,000 --> 00:30:59,000
in dešifriranje besedila z uporabo teh 2 šifer.

506
00:30:59,000 --> 00:31:03,000
Ne pozabite, da Cezarjeva šifra preprosto vrti vsak znak za enak znesek,

507
00:31:03,000 --> 00:31:06,000
pazite, da mod s številom črk v abecedi.

508
00:31:06,000 --> 00:31:09,000
In šifra Vigenère, na drugi strani pa se vrti vsak znak

509
00:31:09,000 --> 00:31:12,000
po drugi znesek, tako kot pravi

510
00:31:12,000 --> 00:31:15,000
Vsak lik zavrti s 3 Vigenère bodo menjavali vsak znak

511
00:31:15,000 --> 00:31:17,000
po drugi znesek glede na nekatere ključne besede

512
00:31:17,000 --> 00:31:20,000
kjer je vsaka črka na ključno besedo predstavlja nekaj drugačnega zneska

513
00:31:20,000 --> 00:31:26,000
zavrteti jasno besedilo, ki ga.

514
00:31:26,000 --> 00:31:28,000
1. Naj govori o spremenljivo področje.

515
00:31:28,000 --> 00:31:30,000
Obstajata 2 različni tipi spremenljivk.

516
00:31:30,000 --> 00:31:33,000
Imamo lokalne spremenljivke, in te se bodo opredeljene

517
00:31:33,000 --> 00:31:36,000
izven glavne ali zunaj katerekoli funkcije ali bloka,

518
00:31:36,000 --> 00:31:39,000
in bo to dostopen kjerkoli v vašem programu.

519
00:31:39,000 --> 00:31:41,000
Če imate funkcijo, in v tej funkciji, je pa zanka

520
00:31:41,000 --> 00:31:44,000
velika globalna spremenljivka je dostopna povsod.

521
00:31:44,000 --> 00:31:48,000
Lokalna spremenljivka, na drugi strani pa je zajeta na mesto, kjer je določeno, da.

522
00:31:48,000 --> 00:31:53,000
>> Če imate funkcijo sem, na primer, imamo to funkcijo g,

523
00:31:53,000 --> 00:31:56,000
in notranjost g je spremenljivka y tukaj imenujejo,

524
00:31:56,000 --> 00:31:58,000
in to pomeni, da je to lokalna spremenljivka.

525
00:31:58,000 --> 00:32:00,000
Čeprav je ta spremenljivka y imenuje

526
00:32:00,000 --> 00:32:03,000
in to se imenuje spremenljivka y te 2 naloge

527
00:32:03,000 --> 00:32:06,000
Nimam pojma, kaj drug drugemu lokalne spremenljivke so.

528
00:32:06,000 --> 00:32:10,000
Po drugi strani pa je tu rečemo, int x = 5,

529
00:32:10,000 --> 00:32:12,000
in to je zunaj področja uporabe katerekoli funkcije.

530
00:32:12,000 --> 00:32:16,000
To je zunaj obsega glavni, tako da je to globalna spremenljivka.

531
00:32:16,000 --> 00:32:20,000
To pomeni, da znotraj teh 2 funkcij, ko sem rekel x - ali x + +

532
00:32:20,000 --> 00:32:26,000
Jaz sem dostopajo do istega x, s katerim je ta in ta y y so različne spremenljivke.

533
00:32:26,000 --> 00:32:30,000
To je razlika med globalne spremenljivke in lokalne spremenljivke.

534
00:32:30,000 --> 00:32:33,000
Kar se tiče oblikovanja, včasih pa je verjetno boljša ideja

535
00:32:33,000 --> 00:32:37,000
voditi lokalne spremenljivke, ko boste morda lahko

536
00:32:37,000 --> 00:32:39,000
saj imajo lahko kup globalnih spremenljivk zares zmedeno.

537
00:32:39,000 --> 00:32:42,000
Če imate kup funkcij, vse spreminja isto stvar

538
00:32:42,000 --> 00:32:45,000
Morda vam bodo pozabili, kaj če je ta funkcija naključno spreminja ta globalni,

539
00:32:45,000 --> 00:32:47,000
in to drugo nalogo, ne ve o tem,

540
00:32:47,000 --> 00:32:50,000
in ne dobite precej zmedeno, kot ste dobili več kode.

541
00:32:50,000 --> 00:32:53,000
Vodenje lokalne spremenljivke, ko boste morda lahko

542
00:32:53,000 --> 00:32:56,000
je samo dober dizajn.

543
00:32:56,000 --> 00:33:00,000
Polja, zapomni si, preprosto seznam elementov istega tipa.

544
00:33:00,000 --> 00:33:04,000
Znotraj industrije ne more imeti seznama, kot je 1, 2,0, zdravo.

545
00:33:04,000 --> 00:33:06,000
Mi samo ne more storiti.

546
00:33:06,000 --> 00:33:11,000
>> Ko smo se razglasi matriko C vsi elementi morajo biti istega tipa.

547
00:33:11,000 --> 00:33:14,000
Tukaj imam niz 3 cela števila.

548
00:33:14,000 --> 00:33:18,000
Tukaj imam dolžino niza, če pa sem samo razglasitvi te sintakse

549
00:33:18,000 --> 00:33:21,000
kje natančno, kaj vse elemente, ki so mi tehnično ni treba tega 3.

550
00:33:21,000 --> 00:33:25,000
Prevajalnik je dovolj pameten, da ugotovimo, kako velika naj bo matrika.

551
00:33:25,000 --> 00:33:28,000
Zdaj, ko hočem, da bi dobili ali pa nastavite vrednost matrike

552
00:33:28,000 --> 00:33:30,000
To je sintaksa za to.

553
00:33:30,000 --> 00:33:33,000
To bo dejansko spremeni drugi element matrike, saj se spomnite,

554
00:33:33,000 --> 00:33:36,000
številčenje se začne pri 0, 1 sploh ne.

555
00:33:36,000 --> 00:33:42,000
Če želim, da se glasi, da je vrednost lahko rečem kaj takega int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Ali pa, če želim nastaviti te vrednosti, tako kot delam tukaj,

557
00:33:44,000 --> 00:33:47,000
Lahko rečem, matrika [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Ta čas dostop do elementov, ki jih njihov indeks

559
00:33:50,000 --> 00:33:52,000
ali na njihov položaj ali če so v polju,

560
00:33:52,000 --> 00:33:57,000
in seznam se začne pri 0.

561
00:33:57,000 --> 00:34:00,000
Mi lahko tudi nizi nizov,

562
00:34:00,000 --> 00:34:03,000
in to se imenuje večdimenzionalni array.

563
00:34:03,000 --> 00:34:05,000
Ko imamo večdimenzionalni array

564
00:34:05,000 --> 00:34:07,000
to pomeni, da lahko kaj takega vrstic in stolpcev,

565
00:34:07,000 --> 00:34:11,000
in to je le eden od načinov za ponazoritev tega, ali razmišljate o tem.

566
00:34:11,000 --> 00:34:14,000
Ko sem imel večdimenzionalni array to pomeni, da bom za začetek potrebovali

567
00:34:14,000 --> 00:34:17,000
več kot 1 Indeks ker če imam omrežje

568
00:34:17,000 --> 00:34:19,000
Samo pravim, kaj ste v vrstici nam ne da več.

569
00:34:19,000 --> 00:34:22,000
To je res samo dogaja, da nam seznam številk.

570
00:34:22,000 --> 00:34:25,000
Recimo, da imam ta niz tukaj.

571
00:34:25,000 --> 00:34:30,000
Imam niz imenovano omrežje, in sem rekel, da je 2 vrstic in 3 stolpcev,

572
00:34:30,000 --> 00:34:32,000
in zato je to eden od načinov, da vizualizacijo.

573
00:34:32,000 --> 00:34:37,000
Ko sem rekel, da želim, da bi dobili vsaj en sestavni del [1] [2]

574
00:34:37,000 --> 00:34:41,000
to pomeni, da zato, ker so vrstice in šele nato stolpci

575
00:34:41,000 --> 00:34:44,000
Bom skočil na vrstico 1, saj sem rekel 1.

576
00:34:44,000 --> 00:34:49,000
>> Potem bom prišel sem v stolpcu 2, in jaz bom dobil vrednost 6.

577
00:34:49,000 --> 00:34:51,000
Smiselno?

578
00:34:51,000 --> 00:34:55,000
Večdimenzionalni nizi, ne pozabite, so tehnično le niz polj.

579
00:34:55,000 --> 00:34:57,000
Mi lahko nizov nizi nizi.

580
00:34:57,000 --> 00:35:00,000
Mi lahko naprej, ampak res eden od načinov, da razmišljajo o

581
00:35:00,000 --> 00:35:03,000
Kako se je to določeno in kaj se dogaja, je, da ga vizualno

582
00:35:03,000 --> 00:35:09,000
v mreži, kot je ta.

583
00:35:09,000 --> 00:35:12,000
Ko smo mimo polja za funkcije, ki jih bomo obnašali

584
00:35:12,000 --> 00:35:16,000
malo drugače kot takrat, ko se peljemo redne spremenljivk, funkcij

585
00:35:16,000 --> 00:35:18,000
kot uspešno int ali float.

586
00:35:18,000 --> 00:35:21,000
Ko se peljemo v int ali char ali katerokoli drugo vrst podatkov

587
00:35:21,000 --> 00:35:24,000
sva si ogledal če je funkcija spremeni

588
00:35:24,000 --> 00:35:28,000
Vrednost te spremenljivke, da se spremembe ne bodo širijo navzgor

589
00:35:28,000 --> 00:35:32,000
da kliče funkcijo.

590
00:35:32,000 --> 00:35:35,000
Z matriko, na drugi strani pa se bo to zgodilo.

591
00:35:35,000 --> 00:35:39,000
Če omedlim v matriki do neke funkcije in funkcije, ki spreminja nekatere elemente,

592
00:35:39,000 --> 00:35:43,000
Ko sem prišel nazaj na funkcijo, ki jo imenuje

593
00:35:43,000 --> 00:35:47,000
moja matrika je zdaj tekoč, da je drugačen, in za to besednjak

594
00:35:47,000 --> 00:35:50,000
je nizi so opravili s sklicevanjem, kot bomo videli kasneje.

595
00:35:50,000 --> 00:35:53,000
To je povezano s tem, kako dela kazalci, kadar so ti osnovni podatkovni tipi,

596
00:35:53,000 --> 00:35:55,000
Na drugi strani pa so opravili z vrednostjo.

597
00:35:55,000 --> 00:35:59,000
>> Mi lahko zamislite, da so izdelavo kopije neke spremenljivke, nato pa poteka v kopiji.

598
00:35:59,000 --> 00:36:01,000
Ni važno, kaj počnemo s to spremenljivko.

599
00:36:01,000 --> 00:36:06,000
Kličoča funkcija ne bo vedel, da je prišlo do spremembe.

600
00:36:06,000 --> 00:36:10,000
Polja so malce drugačna v tem pogledu.

601
00:36:10,000 --> 00:36:13,000
Na primer, kot smo pravkar videli, glavno je le funkcija

602
00:36:13,000 --> 00:36:15,000
da lahko v 2 argumentov.

603
00:36:15,000 --> 00:36:20,000
Prvi argument za glavno funkcijo je argc ali več trditev,

604
00:36:20,000 --> 00:36:23,000
in drugi argument imenovan argv,

605
00:36:23,000 --> 00:36:27,000
in to so dejanske vrednosti teh trditev.

606
00:36:27,000 --> 00:36:30,000
Recimo, da imam program, imenovan this.c,

607
00:36:30,000 --> 00:36:34,000
in sem rekel, da je to, in bom teči to v ukazni vrstici.

608
00:36:34,000 --> 00:36:38,000
Zdaj prenesti v nekaterih trditev, da moj program se imenuje to,

609
00:36:38,000 --> 00:36:42,000
Lahko bi rekel kaj takega. / To je 50 cs.

610
00:36:42,000 --> 00:36:45,000
To je tisto, predstavljamo David narediti vsak dan na terminalu.

611
00:36:45,000 --> 00:36:48,000
Toda zdaj je glavna funkcija znotraj tega programa

612
00:36:48,000 --> 00:36:52,000
ima te vrednosti, tako da argc je 4.

613
00:36:52,000 --> 00:36:56,000
Mogoče je malo zmedeno, ker smo res le mimogrede v je 50 cs.

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

615
00:36:58,000 --> 00:37:02,000
Ampak ne pozabite, da je prvi del argv ali prvi argument

616
00:37:02,000 --> 00:37:05,000
je ime same funkcije.

617
00:37:05,000 --> 00:37:07,190
To pomeni, da imamo 4 stvari tukaj,

618
00:37:07,190 --> 00:37:10,530
in prvi del se bo. / to.

619
00:37:10,530 --> 00:37:12,970
In bo ta predstavljen kot niz.

620
00:37:12,970 --> 00:37:18,590
Potem preostale točke, kar smo vnesli po imenu programa.

621
00:37:18,590 --> 00:37:22,720
Torej, tako kot prahi, kot bomo verjetno videli v pset 2,

622
00:37:22,720 --> 00:37:28,780
ne pozabite, da je niz 50 ≠ celo število 50.

623
00:37:28,780 --> 00:37:32,520
Torej ne moremo reči kaj takega, "int x = 3 argv".

624
00:37:32,520 --> 00:37:36,470
>> To je le ne bo imelo smisla, ker je to niz, in to je celo število.

625
00:37:36,470 --> 00:37:38,510
Torej, če želite spremeniti med 2, zapomni si, da bomo

626
00:37:38,510 --> 00:37:40,810
da je to čarobno funkcijo imenovano atoi.

627
00:37:40,810 --> 00:37:46,270
To traja niz in vrne celo število predstavlja znotraj tega niza.

628
00:37:46,270 --> 00:37:48,360
Torej, to je preprosto narobe, če bi na kvizu,

629
00:37:48,360 --> 00:37:51,590
Samo razmišljal, da bo ta samodejno pravilne vrste.

630
00:37:51,590 --> 00:37:53,860
Ampak samo vem, da ti bo vedno strune

631
00:37:53,860 --> 00:38:00,920
tudi če niz vsebuje samo celo število ali znak, ali lopatico.

632
00:38:00,920 --> 00:38:03,380
Torej, zdaj pa govorimo o teče čas.

633
00:38:03,380 --> 00:38:06,700
Ko imamo vse te algoritme, ki naredijo vse te nore stvari,

634
00:38:06,700 --> 00:38:11,580
postane zelo koristno vprašati vprašanje, "Kako dolgo traja?"

635
00:38:11,580 --> 00:38:15,500
Predstavljamo nekaj, kar ti da s asimptotična zapis.

636
00:38:15,500 --> 00:38:18,430
Torej to pomeni, da je - no, recimo, da damo algoritem

637
00:38:18,430 --> 00:38:20,840
nekateri res, res, res velik vložek.

638
00:38:20,840 --> 00:38:23,840
Želimo postaviti vprašanje: »Kako dolgo bo trajalo?

639
00:38:23,840 --> 00:38:26,370
Koliko korakov bo trajalo naš algoritem za vodenje

640
00:38:26,370 --> 00:38:29,980
v odvisnosti od velikosti vhodnih? "

641
00:38:29,980 --> 00:38:33,080
Torej, prvi način lahko opisali teči, ko je z velikim O.

642
00:38:33,080 --> 00:38:35,380
In to je naš najslabši časa vožnje.

643
00:38:35,380 --> 00:38:38,590
Torej, če želite razvrstiti array, in smo dali naš algoritem niz

644
00:38:38,590 --> 00:38:41,000
To je po vrstnem redu, ko bi moralo biti v naraščajočem vrstnem redu,

645
00:38:41,000 --> 00:38:43,130
da se bo v najslabšem primeru.

646
00:38:43,130 --> 00:38:49,800
To je naša zgornja meja v največji čas naš algoritem bo.

647
00:38:49,800 --> 00:38:54,740
Po drugi strani pa je to Ω gre za opis najboljšem primeru teče čas.

648
00:38:54,740 --> 00:38:58,210
Torej, če bi že urejen matriko za razvrščanje algoritem,

649
00:38:58,210 --> 00:39:00,940
kako dolgo bo trajalo, da ga rešiti?

650
00:39:00,940 --> 00:39:06,610
In to potem, opisuje spodnja meja za vodenje čas.

651
00:39:06,610 --> 00:39:10,980
Torej, tukaj je le nekaj besed, ki opisujejo nekatere skupne vožnjo krat.

652
00:39:10,980 --> 00:39:13,120
To so v naraščajočem vrstnem redu.

653
00:39:13,120 --> 00:39:16,060
Najhitrejši čas delovanja smo se imenuje konstantna.

654
00:39:16,060 --> 00:39:19,800
>> To pomeni, da ne glede na to, koliko elementov damo algoritem,

655
00:39:19,800 --> 00:39:22,280
ne glede na to kako velika je naša matrika, razvrščanje

656
00:39:22,280 --> 00:39:26,510
ali počne karkoli delamo z matriko bo vedno enako količino časa.

657
00:39:26,510 --> 00:39:30,270
Tako bomo lahko pomenijo, da samo z 1, ki je konstantna.

658
00:39:30,270 --> 00:39:32,410
Ogledali smo si tudi logaritemskem času izvajanja.

659
00:39:32,410 --> 00:39:34,800
Torej nekaj podobnega binarnega iskanja je logaritemska

660
00:39:34,800 --> 00:39:37,140
kjer smo zmanjšali težave v 1/2 vsakem trenutku

661
00:39:37,140 --> 00:39:40,970
in potem se stvari priti višje od tam.

662
00:39:40,970 --> 00:39:43,580
In če ste kdaj pišete O vseh faktorski algoritem,

663
00:39:43,580 --> 00:39:47,850
verjetno ne bi smeli upoštevati, da je to vaš dan službo.

664
00:39:47,850 --> 00:39:53,910
Ko smo primerjali vožnjo krat, da je pomembno imeti v mislih te stvari.

665
00:39:53,910 --> 00:39:57,760
Torej, če imam algoritem, ki je O (n), in nekdo drug

666
00:39:57,760 --> 00:40:03,590
je algoritem O (2n) so dejansko asimptotično enakovredni.

667
00:40:03,590 --> 00:40:06,590
Torej, če si predstavljamo, da je n velika številka, kot eleventy milijard:

668
00:40:06,590 --> 00:40:13,090
tako da, ko smo primerjali eleventy milijard ali kaj podobnega eleventy + 3 milijarde EUR,

669
00:40:13,090 --> 00:40:17,640
Nenadoma that 3 resnici ne naredi veliko razliko več.

670
00:40:17,640 --> 00:40:20,980
Zato bomo začeti razmišljati te stvari za enakovredne.

671
00:40:20,980 --> 00:40:24,220
Torej stvari, kot so te konstante tu, tam je 2 x tem, ali dodatkom 3,

672
00:40:24,220 --> 00:40:27,180
to so le konstante, in ti so padli gor.

673
00:40:27,180 --> 00:40:32,480
Torej, to je, zakaj vsi 3 te čase delovanja so enaki kot pravijo oni O (n).

674
00:40:32,480 --> 00:40:37,490
Podobno je, če imamo 2 ostalih časa delovanja, recimo O (n ³ + 2n ²), lahko dodamo

675
00:40:37,490 --> 00:40:42,070
+ N + 7, potem pa imamo še čas delovanja, ki je samo O (n ³).

676
00:40:42,070 --> 00:40:46,290
še enkrat, to so ista stvar, saj to - to ni isto.

677
00:40:46,290 --> 00:40:49,840
To so iste stvari, žal. To je torej enaka, saj

678
00:40:49,840 --> 00:40:53,090
this ³ n bo prevladovala this 2n ².

679
00:40:53,090 --> 00:40:59,130
>> Kaj ni ista stvar je, če smo teči večkrat kot O (n ³) in O (n ²)

680
00:40:59,130 --> 00:41:02,820
ker je to ³ n je veliko večja od te ² n.

681
00:41:02,820 --> 00:41:05,470
Torej, če imamo eksponenti, nenadoma se to začne važno,

682
00:41:05,470 --> 00:41:08,280
ko pa smo pravkar ukvarjajo z dejavniki, kot smo tukaj,

683
00:41:08,280 --> 00:41:12,810
potem ne bo važno, ker so le, da bo izstopiti.

684
00:41:12,810 --> 00:41:16,760
Oglejmo si nekaj algoritmov, ki smo jih videli do sedaj

685
00:41:16,760 --> 00:41:19,260
in govori o svojem času izvajanja.

686
00:41:19,260 --> 00:41:23,850
Prvi način iščejo več na seznamu, ki smo ga videli, je bila linearna iskanje.

687
00:41:23,850 --> 00:41:26,950
In izvajanje linearnega iskanja je zelo enostavna.

688
00:41:26,950 --> 00:41:30,490
Pravkar smo imeli seznam, in bomo pogled na vsakem en element na seznamu

689
00:41:30,490 --> 00:41:34,260
dokler ne najdemo številko, ki jo iščete.

690
00:41:34,260 --> 00:41:38,370
To pomeni, da v najslabšem primeru, to O (n).

691
00:41:38,370 --> 00:41:40,860
In lahko v najslabšem primeru tukaj, če je element

692
00:41:40,860 --> 00:41:45,710
zadnji element, nato pa z uporabo linearne iskanje moramo gledati na vsako posamezno elementa

693
00:41:45,710 --> 00:41:50,180
dokler ne pridemo do zadnjega, da bi vedeli, da je bilo dejansko na seznamu.

694
00:41:50,180 --> 00:41:52,910
Ne moremo odreči na pol poti in reče: "To je verjetno ni."

695
00:41:52,910 --> 00:41:55,980
Z linearno iskanju moramo gledati na celotno stvar.

696
00:41:55,980 --> 00:41:59,090
Najboljši primer časa vožnje, na drugi strani pa je stalno

697
00:41:59,090 --> 00:42:04,200
ker je v najboljšem primeru je element, ki ga iščemo, je le prvi na seznamu.

698
00:42:04,200 --> 00:42:08,930
Torej se dogaja, da nam točno 1 korak, ne glede na to, kako velik je seznam

699
00:42:08,930 --> 00:42:12,140
če iščemo prvi element vsakič.

700
00:42:12,140 --> 00:42:15,390
>> Torej, ko iščete, ne pozabite, da ne zahteva, da se razvrstijo naš seznam.

701
00:42:15,390 --> 00:42:19,430
Ker smo preprosto bo, da si v vsakem sam element, in to sploh ni pomembno

702
00:42:19,430 --> 00:42:23,560
kaj bi ti elementi so noter

703
00:42:23,560 --> 00:42:28,110
Bolj inteligenten iskanje algoritem, ki je nekaj podobnega kot binarno iskanje.

704
00:42:28,110 --> 00:42:31,500
Ne pozabite, da je izvajanje binarnega iskanja je, ko boste

705
00:42:31,500 --> 00:42:34,320
da si na sredini seznama.

706
00:42:34,320 --> 00:42:38,000
In ker smo iskali na sredini, zahtevamo, da je urejen seznam

707
00:42:38,000 --> 00:42:40,580
ali pa ne veste, kje je sredina in moramo gledati kot

708
00:42:40,580 --> 00:42:44,480
celoten seznam, da ga najdejo, in potem na tej točki smo samo zapravljaš čas.

709
00:42:44,480 --> 00:42:48,480
Torej, če imamo urejen seznam, in smo našli na sredini, bomo primerjali sredino

710
00:42:48,480 --> 00:42:51,590
na element, ki ga iščemo.

711
00:42:51,590 --> 00:42:54,640
Če je previsoka, potem lahko pozabimo na desni polovici

712
00:42:54,640 --> 00:42:57,810
saj vemo, da če je naš element je že prevelik

713
00:42:57,810 --> 00:43:01,080
in vse na desni strani tega elementa je še večja,

714
00:43:01,080 --> 00:43:02,760
potem nam ni treba iskati tam več.

715
00:43:02,760 --> 00:43:05,430
Če je na drugi strani, če je naš element je prenizka,

716
00:43:05,430 --> 00:43:08,700
Vemo vse, kar je levo od tega elementa je tudi prenizka,

717
00:43:08,700 --> 00:43:11,390
tako da ne res smiselno, da tam videti, bodisi.

718
00:43:11,390 --> 00:43:15,760
Na ta način, z vsakim korakom in vsakič, ko se ozremo na sredini seznama,

719
00:43:15,760 --> 00:43:19,060
bomo zmanjšali naš problem na pol, ker se nenadoma vemo,

720
00:43:19,060 --> 00:43:23,040
Cel kup številk, ki ne more biti tisti, ki ga iščemo.

721
00:43:23,040 --> 00:43:26,950
>> V psevdokod bi to videti nekako takole,

722
00:43:26,950 --> 00:43:30,990
in ker smo rezanje seznam v pol vsak čas,

723
00:43:30,990 --> 00:43:34,920
naša najslabšem primeru teče čas skoči iz linearnega v logaritemsko.

724
00:43:34,920 --> 00:43:39,260
Torej imamo nenadoma prijavo v korakih, da bi našli element na seznamu.

725
00:43:39,260 --> 00:43:42,460
Najboljši primer teče čas, čeprav je še vedno stalno

726
00:43:42,460 --> 00:43:45,180
ker zdaj, recimo, da je element, ki ga iščemo, je

727
00:43:45,180 --> 00:43:48,380
vedno točna sredina prvotnega seznama.

728
00:43:48,380 --> 00:43:52,080
Tako smo lahko raste naš seznam tako velika, kot smo želeli, če pa element, ki ga iščemo, je na sredini,

729
00:43:52,080 --> 00:43:54,910
Potem je samo še, da se nam 1 korak.

730
00:43:54,910 --> 00:44:00,920
Torej, to je, zakaj smo O (log n) in Ω (1) ali stalna.

731
00:44:00,920 --> 00:44:04,510
Poglejmo resnici vodi binarno iskanje na tem seznamu.

732
00:44:04,510 --> 00:44:08,020
Torej, recimo, da iščemo element 164.

733
00:44:08,020 --> 00:44:11,650
Prva stvar, ki smo jih naredili, je najti srednjo vrednost tega seznama.

734
00:44:11,650 --> 00:44:15,060
Samo tako se zgodi, da je sredina se bo padec med temi številkami 2,

735
00:44:15,060 --> 00:44:18,960
tako da je le arbitrarno reči, vsakič, ko sredina spada med 2 številk

736
00:44:18,960 --> 00:44:21,150
kaj je samo zaokroži navzgor.

737
00:44:21,150 --> 00:44:24,330
Vedeti pa je treba, da poskrbite, da to počnemo vsak korak s poti.

738
00:44:24,330 --> 00:44:29,040
Tako bomo zaokrožili, in bomo rekli, da 161 je sredi našega seznama.

739
00:44:29,040 --> 00:44:34,640
Torej 161 <164, in vsak element, na levi strani 161

740
00:44:34,640 --> 00:44:39,120
je tudi <164, tako da vemo, da to ne bo, da nam pomagajo na vseh

741
00:44:39,120 --> 00:44:42,690
, da začnete iskati tukaj, ker je element, ki ga iščemo, ne more biti tam.

742
00:44:42,690 --> 00:44:47,060
Torej, kaj lahko storimo, je, da lahko samo pozabiti, da je celoten levi polovici seznama,

743
00:44:47,060 --> 00:44:51,700
in zdaj mislijo samo z desno od 161 dalje.

744
00:44:51,700 --> 00:44:54,050
>> Torej, še enkrat, to je sredina, kaj je samo zaokroži navzgor.

745
00:44:54,050 --> 00:44:56,260
Zdaj 175 je prevelika.

746
00:44:56,260 --> 00:44:59,180
Torej vemo, da to ne bo nam pomagajo videti tukaj ali tukaj,

747
00:44:59,180 --> 00:45:06,610
tako da bomo lahko samo vrgel stran, in na koncu bomo zadeli 164.

748
00:45:06,610 --> 00:45:10,560
Vsa vprašanja v zvezi binarnem iskanju?

749
00:45:10,560 --> 00:45:14,180
Gremo naprej z iskanjem skozi že razvrščen seznam

750
00:45:14,180 --> 00:45:17,660
dejansko ob seznam številk, v poljubnem vrstnem redu

751
00:45:17,660 --> 00:45:20,960
in ponujanje tega seznama v naraščajočem vrstnem redu.

752
00:45:20,960 --> 00:45:24,060
Prvi algoritem smo pogledal je bil imenovan bubble sort.

753
00:45:24,060 --> 00:45:27,300
In to ne bi bilo enostavnejše od algoritmov smo jih videli.

754
00:45:27,300 --> 00:45:32,970
Bubble sort, ko pravi, da je vse 2 elementi v seznamu, so na svojem mestu,

755
00:45:32,970 --> 00:45:36,500
kar pomeni, da je večje število na levi strani manjše število,

756
00:45:36,500 --> 00:45:40,190
Nato se bomo, da jih swap, ker to pomeni, da bo seznam

757
00:45:40,190 --> 00:45:42,860
»Več razporejene", kot je bilo prej.

758
00:45:42,860 --> 00:45:45,180
In smo le, da bo ta proces nadaljevati znova in znova in znova

759
00:45:45,180 --> 00:45:52,100
dokler sčasoma elementi vrste balona na njihovo pravo mesto in imamo urejen seznam.

760
00:45:52,100 --> 00:45:57,230
>> Čas delovanja tega se bo O (n ²). Zakaj?

761
00:45:57,230 --> 00:46:00,370
No, saj v najslabšem primeru, da bomo lahko vse elemente in

762
00:46:00,370 --> 00:46:04,570
bomo na koncu ga primerja z vsakim drugim elementom v seznamu.

763
00:46:04,570 --> 00:46:08,030
Toda v najboljšem primeru imamo že urejen seznam, bubble sort je

764
00:46:08,030 --> 00:46:12,230
Samo šel skozi enkrat rekel "Ne. nisem naredil nobene zamenjave, zato sem naredil."

765
00:46:12,230 --> 00:46:17,410
Torej imamo najboljše sodno delovni čas Ω (n).

766
00:46:17,410 --> 00:46:20,680
Naj teče mehurček vrste na seznamu.

767
00:46:20,680 --> 00:46:23,560
Ali pa najprej, kaj je samo pogled na nekatere psevdokod res hitro.

768
00:46:23,560 --> 00:46:28,160
Želimo, da smo želeli, da bi spremljali, v vsaki ponovitvi zanke,

769
00:46:28,160 --> 00:46:32,190
spremljate na to, ali smo spremenili nobenih elementov.

770
00:46:32,190 --> 00:46:37,610
Torej, razlog za to je, bomo ustavi, ko nismo zamenjali nobenih elementov.

771
00:46:37,610 --> 00:46:41,980
Torej na začetku našega zanke nismo zamenjali ničesar, zato bomo rekli, da je lažna.

772
00:46:41,980 --> 00:46:47,170
Zdaj smo šli skozi seznam in primerjajte element i element i + 1

773
00:46:47,170 --> 00:46:50,310
in če je tako, da je večje število na levi strani manjše število,

774
00:46:50,310 --> 00:46:52,310
potem greš samo, da jih swap.

775
00:46:52,310 --> 00:46:54,490
>> In potem se bomo, da se spomnimo, da smo zamenjali element.

776
00:46:54,490 --> 00:46:58,900
To pomeni, da moramo iti skozi seznam najmanj 1 več časa

777
00:46:58,900 --> 00:47:02,160
ker je stanje, v katerem smo se ustavili, ko je celoten seznam že urejen,

778
00:47:02,160 --> 00:47:04,890
kar pomeni, da niso dosegli nobenega zamenjavo.

779
00:47:04,890 --> 00:47:09,960
Torej, to je, zakaj naš pogoj tukaj je ", medtem ko so bili zamenjani nekateri elementi."

780
00:47:09,960 --> 00:47:13,720
Torej, zdaj pa je samo pogled na to tekmovanje v teku na seznamu.

781
00:47:13,720 --> 00:47:16,640
Imam seznam 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Bubble sort se bo začela vso pot na levi strani, in to se dogaja za primerjavo

783
00:47:19,850 --> 00:47:24,700
i so elementi, tako med 0 in i + 1, ki je sestavni 1.

784
00:47:24,700 --> 00:47:29,020
To bo sicer tudi 5> 0, a zdaj 5 je na levi,

785
00:47:29,020 --> 00:47:32,500
tako da moram zamenjali 5 in 0.

786
00:47:32,500 --> 00:47:35,470
Ko sem jih zamenjal, kar naenkrat sem dobil to drug seznam.

787
00:47:35,470 --> 00:47:38,260
Zdaj 5> 1, zato se bomo, da jih swap.

788
00:47:38,260 --> 00:47:42,160
5 ni> 6, tako da nam ni treba storiti ničesar.

789
00:47:42,160 --> 00:47:46,690
Toda 6> 4, tako da moramo zamenjati.

790
00:47:46,690 --> 00:47:49,740
Spet moramo teči skozi celoten seznam na koncu odkril

791
00:47:49,740 --> 00:47:52,330
da so v drugačnem vrstnem redu, jih bomo zamenjali,

792
00:47:52,330 --> 00:47:57,120
in na tej točki moramo teči po seznamu 1 več časa

793
00:47:57,120 --> 00:48:05,390
se prepričajte, da je vse v redu, in na tej točki vrste mehurčkov je končan.

794
00:48:05,390 --> 00:48:10,720
Drugačen algoritem za sprejetje nekaterih elementov, in njihovo razvrščanje je izbira sort.

795
00:48:10,720 --> 00:48:15,740
Ideja je, da se uredi izbire bomo vzpostaviti urejen del seznama

796
00:48:15,740 --> 00:48:18,150
1 element naenkrat.

797
00:48:18,150 --> 00:48:23,170
>> In kako bomo to, da je z oblikovanjem levi segment na seznamu.

798
00:48:23,170 --> 00:48:27,510
In v bistvu je vsak - na vsakem koraku, da bomo lahko najmanjši element, ki smo jih ostalo

799
00:48:27,510 --> 00:48:32,310
ki ni bil razvrščen še, in bomo premaknili v to razvrščene segment.

800
00:48:32,310 --> 00:48:35,850
To pomeni, da moramo nenehno našli minimalno neurejen element

801
00:48:35,850 --> 00:48:40,720
in nato vzemite tega minimalnega element in ga zamenjali s koli

802
00:48:40,720 --> 00:48:45,090
levo Najbolj element, ki ni urejen.

803
00:48:45,090 --> 00:48:50,890
Čas delovanja tega se bo O (n ²), saj v najslabšem primeru

804
00:48:50,890 --> 00:48:55,070
moramo primerjati vsak element z vsakim drugim elementom.

805
00:48:55,070 --> 00:48:59,250
Ker smo si rekel, da če začnemo na levi polovici seznama, moramo

806
00:48:59,250 --> 00:49:02,970
iti skozi celoten desni segmentu najti najmanjši element.

807
00:49:02,970 --> 00:49:05,430
In potem spet, moramo iti čez celotno desno segment in

808
00:49:05,430 --> 00:49:08,210
nadaljuj več, da znova in znova in znova.

809
00:49:08,210 --> 00:49:11,350
To bo N, ². Bomo potrebovali za notranje zanke drugega za zanke

810
00:49:11,350 --> 00:49:13,350
kar kaže n ².

811
00:49:13,350 --> 00:49:16,530
V najboljšem primeru misli, recimo, da damo že razvrščen seznam;

812
00:49:16,530 --> 00:49:19,270
smo dejansko ne delajo nič bolje kot ² n.

813
00:49:19,270 --> 00:49:21,730
Ker je izbor sort ni mogel vedeti, da

814
00:49:21,730 --> 00:49:25,540
minimalni element je samo ena sem se zgodi, da bo gledal.

815
00:49:25,540 --> 00:49:28,970
Še vedno je treba prepričati, da je to pravzaprav minimalna.

816
00:49:28,970 --> 00:49:31,670
>> In edini način, da se prepričajte, da je minimalno, z uporabo tega algoritma,

817
00:49:31,670 --> 00:49:34,640
je pogled na vsako posamezno element znova.

818
00:49:34,640 --> 00:49:38,420
Torej res, če jo dal - če daš izbirnem razvrstite že urejen seznam,

819
00:49:38,420 --> 00:49:42,720
to ne bo naredil nič bolje, kot mu daje seznam, ki ni razvrščen še.

820
00:49:42,720 --> 00:49:46,320
Mimogrede, če se zgodi, da bo v primeru, da je nekaj O (nekaj)

821
00:49:46,320 --> 00:49:50,640
in omega nečesa, lahko samo rečem bolj na kratko, da je to θ nečesa.

822
00:49:50,640 --> 00:49:52,760
Torej, če ste videli, da pride do kamorkoli, to je tisto, ki samo pomeni.

823
00:49:52,760 --> 00:49:57,580
>> Če je nekaj theta n ², je tako velik O (n ²) in Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Torej, najboljši in najslabši primer, da ne bi razliko,

825
00:49:59,790 --> 00:50:04,400
algoritem bo naredil isto stvar vsak čas.

826
00:50:04,400 --> 00:50:06,610
Torej, to je tisto, kar bi lahko psevdokod za razvrščanje izbor izgledal.

827
00:50:06,610 --> 00:50:10,630
Mi smo v bistvu reči, da želim ponoviti čez seznam

828
00:50:10,630 --> 00:50:15,180
od leve proti desni, in na vsaki ponovitvi zanke, grem, da se premaknete

829
00:50:15,180 --> 00:50:19,780
minimalni element v ta izločen del seznama.

830
00:50:19,780 --> 00:50:23,260
In ko sem premakniti nekaj tam, nikoli nisem morali gledati na ta element ponovno.

831
00:50:23,260 --> 00:50:28,600
Ker je takoj, ko sem zamenjal element za na levi segment na seznamu, se razvrstijo it

832
00:50:28,600 --> 00:50:32,600
saj delamo vse, kar je v naraščajočem vrstnem redu z najnižjimi.

833
00:50:32,600 --> 00:50:38,740
Zato smo rekli, v redu, smo v položaj I, zato moramo gledati na vse elemente

834
00:50:38,740 --> 00:50:42,260
na desni strani i, da bi našli minimum.

835
00:50:42,260 --> 00:50:46,150
Torej to pomeni, da želimo videti od i + 1 do konca seznama.

836
00:50:46,150 --> 00:50:51,610
In zdaj, če je element, ki ga trenutno gledaš je manjše od našega vsaj do sedaj,

837
00:50:51,610 --> 00:50:54,190
ki Zapomnite si, da začenjamo minimalno dol da se samo

838
00:50:54,190 --> 00:50:57,020
ne glede na del smo trenutno, bom domnevala, da je minimalna.

839
00:50:57,020 --> 00:51:00,270
Če najdem element, ki je manjša od tiste, potem bom rekel, v redu,

840
00:51:00,270 --> 00:51:02,700
No, sem našel nov minimum.

841
00:51:02,700 --> 00:51:06,080
Bom se spomnite, kjer je bila ta najnižja.

842
00:51:06,080 --> 00:51:09,560
>> Torej, zdaj, ko sem šel skozi te pravice, nesortirani segment,

843
00:51:09,560 --> 00:51:16,690
Lahko rečem, da bom zamenjal minimalni element z elementom, ki je v položaj I.

844
00:51:16,690 --> 00:51:21,100
To se dogaja, da zgraditi svoj seznam, moj razporejene del seznama, od leve proti desni,

845
00:51:21,100 --> 00:51:25,190
in ne bomo nikoli treba gledati na element znova, ko je v tem delu.

846
00:51:25,190 --> 00:51:27,930
Ko smo jo zamenjali.

847
00:51:27,930 --> 00:51:30,260
Torej, kaj je teči izbiro vrste na tem seznamu.

848
00:51:30,260 --> 00:51:38,220
Modri ​​element tukaj se bo i in rdeča element se bo minimalna element.

849
00:51:38,220 --> 00:51:41,570
Torej, jaz se začne vso pot na levi strani seznama, tako da v 5.

850
00:51:41,570 --> 00:51:44,610
Zdaj moramo najti minimalno neurejen element.

851
00:51:44,610 --> 00:51:49,480
Tako smo rekli 0 <5, tako da je 0 moja nova minimalna.

852
00:51:49,480 --> 00:51:53,820
>> Ampak ne morem se ustaviti, ker čeprav lahko spoznamo, da je najmanjša 0,

853
00:51:53,820 --> 00:51:59,390
moramo teči z vsakim drugim elementom seznama in se prepričajte.

854
00:51:59,390 --> 00:52:01,760
Torej 1 je večja, je večja 6, 4 večji.

855
00:52:01,760 --> 00:52:05,850
To pomeni, da ko gledaš vse te elemente, sem se določijo 0 je najmanjše.

856
00:52:05,850 --> 00:52:09,800
Torej bom, da bi zamenjali 5 in 0.

857
00:52:09,800 --> 00:52:15,480
Ko sem zamenjal, da bom dobil nov seznam, in vem, da mi nikoli ni treba pogledati v tistem 0 znova

858
00:52:15,480 --> 00:52:19,380
ker ko sem ga zamenjal, sem ga sortirajo in smo končali.

859
00:52:19,380 --> 00:52:22,730
Zdaj je prav tako se zgodi, da je modra element je ponovno 5,

860
00:52:22,730 --> 00:52:26,030
pa moramo gledati na 1, je 6 in 4 določiti, 1

861
00:52:26,030 --> 00:52:31,520
je najmanjši element minimalna, tako da bomo zamenjali 1 in 5.

862
00:52:31,520 --> 00:52:36,890
Ponovno moramo pogledati - primerjava 5 do 6 in 4,

863
00:52:36,890 --> 00:52:39,830
in bomo zamenjali 4 in 5, in končno, primerjati

864
00:52:39,830 --> 00:52:45,740
ti 2 številke in jih menjajo, dokler ne bomo dobili naše urejen seznam.

865
00:52:45,740 --> 00:52:49,730
Vsa vprašanja v zvezi neke izbire?

866
00:52:49,730 --> 00:52:56,420
Ok. Naj se premaknete na zadnjo temo tukaj, in da je rekurzija.

867
00:52:56,420 --> 00:52:59,810
>> Rekurzija, zapomni si, je to res stvar, meta, kjer funkcija

868
00:52:59,810 --> 00:53:02,740
večkrat kliče sama.

869
00:53:02,740 --> 00:53:05,620
Torej, na neki točki, medtem ko je naš fuction je večkrat klical samega sebe,

870
00:53:05,620 --> 00:53:10,100
mora obstajati neki točki, na kateri smo se ustavili sebe kliče.

871
00:53:10,100 --> 00:53:13,670
Ker če tega ne bomo storili, potem smo le, da bo še naprej, da to stori vedno,

872
00:53:13,670 --> 00:53:16,660
in naš program, se le ne bo odpovedala.

873
00:53:16,660 --> 00:53:19,200
Temu pravimo stanje osnova drži.

874
00:53:19,200 --> 00:53:22,570
In osnovna pravi, namesto da bi funkcijo spet

875
00:53:22,570 --> 00:53:25,330
Grem vrne neko vrednost.

876
00:53:25,330 --> 00:53:28,080
Torej, ko smo vrnili vrednost, smo ustavili sebe kliče,

877
00:53:28,080 --> 00:53:32,550
in lahko ostali razpisov, ki smo jih do sedaj tudi vrne.

878
00:53:32,550 --> 00:53:36,050
Nasproti osnovne zadeve je rekurzivni primer.

879
00:53:36,050 --> 00:53:39,050
In to je, če želimo, da bo še en klic funkcije, ki jih trenutno noter

880
00:53:39,050 --> 00:53:44,690
In mi verjetno, čeprav ne vedno, želeli uporabiti različne argumente.

881
00:53:44,690 --> 00:53:48,940
>> Torej, če imamo funkcijo imenovano f in f pravkar klical da trditev 1,

882
00:53:48,940 --> 00:53:52,010
in mi kar naprej kliče f (1), f (1), f (1), in to samo zato, da se zgodi, da

883
00:53:52,010 --> 00:53:56,510
argument 1 pade v rekurzivni primeru, še vedno ne bo konec.

884
00:53:56,510 --> 00:54:01,620
Tudi če imamo osnovno zadevo, moramo poskrbeti, da sčasoma bomo zadel tisto osnovno zadevo.

885
00:54:01,620 --> 00:54:04,250
Ne samo da med bivanjem v tem primeru rekurziven.

886
00:54:04,250 --> 00:54:09,870
Na splošno, ko bomo klic, bomo verjetno dogaja, da imajo drugačno argumenta vsakič.

887
00:54:09,870 --> 00:54:12,700
Tu je zelo preprosta rekurzivna funkcija.

888
00:54:12,700 --> 00:54:15,090
Tako bo ta izračun fakulteto števila.

889
00:54:15,090 --> 00:54:17,790
Do vrha tukaj imamo osnovno zadevo.

890
00:54:17,790 --> 00:54:22,330
V primeru, da n ≤ 1, ne bova poklicati fakulteto znova.

891
00:54:22,330 --> 00:54:26,490
Bomo ustaviti, smo le, da bo vrnil nekaj vrednosti.

892
00:54:26,490 --> 00:54:30,170
Če to ni res, potem bomo zadeli naš rekurzivni primer.

893
00:54:30,170 --> 00:54:33,550
Obvestilo tukaj, da ne bomo samo opozarjajo fakulteto (n), ker to ne bi bilo zelo koristno.

894
00:54:33,550 --> 00:54:36,810
Mi jo bomo imenovali fakulteto nekaj drugega.

895
00:54:36,810 --> 00:54:40,850
>> In tako si lahko ogledate, če bomo na koncu opraviti faktorsko (5) ali nekaj,

896
00:54:40,850 --> 00:54:45,900
bomo klic fakulteto (4) in tako naprej, in na koncu bomo zadeli osnovno zadevo.

897
00:54:45,900 --> 00:54:51,730
Torej, to je v redu. Poglejmo, kaj se zgodi, ko smo dejansko vodijo to.

898
00:54:51,730 --> 00:54:57,840
To je sklad, in recimo, da se bo glavni poklicati to funkcijo s trditvijo (4).

899
00:54:57,840 --> 00:55:02,200
Torej, ko vidi in fakulteto = 4, se bo fakulteta sama poklicala.

900
00:55:02,200 --> 00:55:05,010
Zdaj pa kar naenkrat imamo fakulteto (3).

901
00:55:05,010 --> 00:55:10,780
Torej te funkcije se bodo še naprej naraščale, dokler na koncu smo zadeli naš osnovni primer.

902
00:55:10,780 --> 00:55:17,830
Na tej točki se vrne vrednost tega pa je donos (nx Vrnjena vrednost tega),

903
00:55:17,830 --> 00:55:21,290
Vrnjena vrednost tega je nx vrnjeno vrednost tega.

904
00:55:21,290 --> 00:55:23,290
Končno moramo zadeti nekaj več.

905
00:55:23,290 --> 00:55:26,560
Na vrhu tukaj, smo rekli vrnitev 1.

906
00:55:26,560 --> 00:55:30,650
To pomeni, da ko se bomo vrnili to številko, lahko to pop off dimnika.

907
00:55:30,650 --> 00:55:36,570
Torej, to fakulteto (1) se opravi.

908
00:55:36,570 --> 00:55:41,190
Ko se vrne 1, ta faktorski (1), se ta vrne vrnitev na 1..

909
00:55:41,190 --> 00:55:46,910
Vrnjena vrednost tega, ne pozabite, je nx vrnjeno vrednost tega.

910
00:55:46,910 --> 00:55:50,720
Tako nenadoma, ta človek ve, da želim, da se vrnete 2.

911
00:55:50,720 --> 00:55:55,910
>> Torej, ne pozabite, vrne vrednost tega je ravno nx vrnjena vrednost tukaj.

912
00:55:55,910 --> 00:56:01,160
Sedaj lahko rečemo, 3 x 2, in končno, tu lahko rečemo,

913
00:56:01,160 --> 00:56:04,010
To je le, da bo lahko 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
In ko bo ta vrne, pridemo do ene same notranjosti celo glavnih.

915
00:56:09,570 --> 00:56:15,460
Vsa vprašanja v zvezi rekurzije?

916
00:56:15,460 --> 00:56:17,090
V redu. Torej ni več časa za vprašanja, na koncu,

917
00:56:17,090 --> 00:56:23,360
zdaj pa bo Joseph pokrivajo preostale teme.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] V redu. Torej, zdaj, ko smo se pogovarjali o recursions,

919
00:56:25,590 --> 00:56:27,840
kaj je govoril malo o tem, kaj je nekako združiti.

920
00:56:27,840 --> 00:56:31,740
Spajanje vrsta je v bistvu še en način razvrščanja seznam številk.

921
00:56:31,740 --> 00:56:36,430
In kako deluje, je z neke spajanja imate seznam, kaj moramo storiti, je

922
00:56:36,430 --> 00:56:39,120
rečemo, kaj je to v delih 2 polovici.

923
00:56:39,120 --> 00:56:42,750
Mi bomo prvi vožnji z zlivanjem spet na levi polovici,

924
00:56:42,750 --> 00:56:45,040
potem bomo teči z zlivanjem na desni polovici,

925
00:56:45,040 --> 00:56:50,240
in da nam zdaj 2 polčasih, ki so razvrščeni, in zdaj bomo združiti tiste polovici skupaj.

926
00:56:50,240 --> 00:56:55,010
To je malce težko razumeti, ne da bi na primer, da bomo šli skozi predloge in videli, kaj se bo zgodilo.

927
00:56:55,010 --> 00:56:59,590
Torej, začnete s tega seznama, smo ga razdelili na 2 polovici.

928
00:56:59,590 --> 00:57:02,300
Vodimo z zlivanjem na levi polovici prvega.

929
00:57:02,300 --> 00:57:06,660
Torej, to je leva polovica, zdaj pa jih vodijo skozi ta seznam še enkrat

930
00:57:06,660 --> 00:57:09,800
, ki pride mimo vrste v spajanja, potem pa poglej, spet,

931
00:57:09,800 --> 00:57:13,270
na levi strani tega seznama in vodimo z zlivanjem na njej.

932
00:57:13,270 --> 00:57:15,880
Sedaj pa pridemo na seznam 2 številk

933
00:57:15,880 --> 00:57:19,010
in zdaj leva polovica je le 1 element časa, in ne moremo

934
00:57:19,010 --> 00:57:23,380
razdeljen seznam, ki je le 1 element na pol, tako da smo pravkar rekel, ko bomo imeli 50,

935
00:57:23,380 --> 00:57:26,400
ki je le 1 element, je to že urejeno.

936
00:57:26,400 --> 00:57:29,860
>> Ko bomo končali s tem, lahko vidimo, da smo lahko

937
00:57:29,860 --> 00:57:32,230
premaknete na desni polovici tega seznama

938
00:57:32,230 --> 00:57:36,480
in 3 tudi sortirajo in tako zdaj, ko so razporejene obe polovici tega seznama

939
00:57:36,480 --> 00:57:39,080
bomo lahko pridruži se te številke skupaj.

940
00:57:39,080 --> 00:57:45,320
Torej gledamo na 50 in 3, 3 je manjši od 50, tako, da gre v prvi in ​​nato 50 pride noter

941
00:57:45,320 --> 00:57:49,340
Zdaj naj bi to storili, bomo šli nazaj na ta seznam in jih razvrstite, da je desna polovica.

942
00:57:49,340 --> 00:57:52,440
42 je, da je lastna številka, tako da je že urejeno.

943
00:57:52,440 --> 00:57:57,850
Zdaj smo primerjali teh 2 in 3 je manjši od 42, tako da dobi dal na eni strani,

944
00:57:57,850 --> 00:58:02,340
Zdaj dobi dal v 42 in 50 postane dal noter

945
00:58:02,340 --> 00:58:07,220
No, to je razvrščenih, gremo vso pot nazaj na vrh, 1337 in 15.

946
00:58:07,220 --> 00:58:14,560
No, zdaj si na levi polovici tega seznama; 1337, je sam po sebi, tako da se sortirajo in enako velja 15 let.

947
00:58:14,560 --> 00:58:19,020
Torej, zdaj združimo ti 2 številk vrste, ki prvotni seznam, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
tako, da gre v prvi, potem gre noter 1337

949
00:58:23,060 --> 00:58:26,640
In zdaj smo razporejene v obeh polčasih prvotnega seznama gor.

950
00:58:26,640 --> 00:58:30,440
In vse, kar morate storiti, je združevanje teh.

951
00:58:30,440 --> 00:58:36,890
Upamo, da bomo v prvih 2 številke s tega seznama, 3 <15, zato gre v nekakšen niz prvi.

952
00:58:36,890 --> 00:58:44,460
15 <42, tako, da gre noter Zdaj, 42 <1337, ki gre noter

953
00:58:44,460 --> 00:58:51,010
50 <1337, tako da gre noter in ugotovili, da smo pravkar vzel 2 številke izven tega seznama.

954
00:58:51,010 --> 00:58:53,640
Torej ne bomo samo izmenično med 2 seznamov.

955
00:58:53,640 --> 00:58:56,050
Mi smo samo gledaš na začetku, in mi smo vzeli element

956
00:58:56,050 --> 00:59:00,270
To je manjši, nato pa ga je dala v naši matriki.

957
00:59:00,270 --> 00:59:04,080
Zdaj pa smo združili vse polovic in smo gotovi.

958
00:59:04,080 --> 00:59:07,780
>> Vsa vprašanja v zvezi z zlivanjem? Ja?

959
00:59:07,780 --> 00:59:14,190
[Študent] Če je razdeljeno na različne skupine, zakaj ne bi ti samo po delih once

960
00:59:14,190 --> 00:59:19,970
in imate 3 in 2 v skupini? [Ostali nepojmljivega vprašanje]

961
00:59:19,970 --> 00:59:24,940
Razlog - tako je vprašanje, zakaj se ne moreva ju združi v tej prvi fazi, ko smo jih imeli?

962
00:59:24,940 --> 00:59:29,530
Zato smo lahko storite, začnite na levi večina elementov na obeh straneh,

963
00:59:29,530 --> 00:59:33,040
in nato z manjšo ribo in jo dal v, je, da vemo, da so ti

964
00:59:33,040 --> 00:59:35,290
Posamezne liste so razvrščeni naročil.

965
00:59:35,290 --> 00:59:37,290
Torej, če gledam na levi večini elementov obeh polčasih,

966
00:59:37,290 --> 00:59:40,490
Vem, da si bo najmanjši elementi teh seznamov.

967
00:59:40,490 --> 00:59:43,930
Torej, da jih bom lahko dal v najmanjši element kotov pri tem velikem seznamu.

968
00:59:43,930 --> 00:59:47,810
Po drugi strani pa, če gledam na tiste 2 seznamov v drugem nivoju tam,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 15 in 1337, so tisti, ki niso razvrščeni.

970
00:59:51,640 --> 00:59:55,770
Torej, če gledam na 50 in 1337, bom dal 50 v mojem seznamu prvi.

971
00:59:55,770 --> 01:00:00,130
Ampak to ni res smiselno, ker 3 je najmanjši element od vseh teh.

972
01:00:00,130 --> 01:00:04,390
Torej je edini razlog, da smo lahko to združuje korak je, ker so naše sezname že urejeno.

973
01:00:04,390 --> 01:00:07,010
In zato moramo dol vse do dna

974
01:00:07,010 --> 01:00:09,800
ker ko smo imeli samo eno številko, veste, da je enotna številka

975
01:00:09,800 --> 01:00:14,120
sama po sebi je že razvrščenih seznam.

976
01:00:14,120 --> 01:00:19,360
>> Kakšno vprašanje? Ne?

977
01:00:19,360 --> 01:00:24,260
Kompleksnost? No, vidite, da je na vsakem koraku pa je konec številke,

978
01:00:24,260 --> 01:00:27,590
in lahko delimo na seznam v dnevniku 1/2 n-krat,

979
01:00:27,590 --> 01:00:31,700
ki je, če dobimo to n x n dnevnik zahtevnost.

980
01:00:31,700 --> 01:00:34,940
In boste videli, najboljši primer za spajanje vrste, n log n, in je prav tako se zgodi

981
01:00:34,940 --> 01:00:39,340
da je v najslabšem primeru, ali Ω tam je tudi n log n.

982
01:00:39,340 --> 01:00:42,480
Nekaj, da v mislih.

983
01:00:42,480 --> 01:00:45,750
Gremo naprej, gremo na nekaj super osnovno datoteko I / O.

984
01:00:45,750 --> 01:00:48,830
Če ste pogledal Scramble, boste opazili, smo neke vrste sistema

985
01:00:48,830 --> 01:00:51,270
kjer bi lahko napisali, da log datoteko, če ste prebrali kodo.

986
01:00:51,270 --> 01:00:53,730
Pa poglejmo, kako lahko to storite.

987
01:00:53,730 --> 01:00:57,450
No, imamo ovrednotenj, ki jih lahko mislili, da samo printf,

988
01:00:57,450 --> 01:01:01,720
ampak samo tiskanje v datoteko namesto, in zato je f na začetku.

989
01:01:01,720 --> 01:01:07,570
Ta vrsta kodo tu gor, kaj počne, je, kot ste verjetno videli v Scramble,

990
01:01:07,570 --> 01:01:12,310
gre skozi 2-dimenzionalni tisk diod ven po vrsticah, kaj so številke.

991
01:01:12,310 --> 01:01:17,850
V tem primeru printf natisne na svoj terminal ali kot temu pravimo standardni izhod oddelka.

992
01:01:17,850 --> 01:01:22,170
>> In zdaj, v tem primeru je vse, kar morate storiti, je zamenjati z printf ovrednotenj,

993
01:01:22,170 --> 01:01:26,770
povej, kaj jo želite natisniti, in v tem primeru je samo natisne do te datoteke

994
01:01:26,770 --> 01:01:32,230
namesto da bi ga natisnili na vaše terminal.

995
01:01:32,230 --> 01:01:36,500
No, potem se postavlja vprašanje: Kje bomo dobili to vrsto datoteke iz, kajne?

996
01:01:36,500 --> 01:01:39,840
Smo šli pa se prijavite na ta ovrednotenj fuction, vendar nismo vedeli, od kod je prišel.

997
01:01:39,840 --> 01:01:43,980
No, na začetku kode, kar smo imeli je bil ta kos kode tukaj,

998
01:01:43,980 --> 01:01:48,340
ki v bistvu pravi, da imenuje odprta datoteka log.txt.

999
01:01:48,340 --> 01:01:53,220
Kaj moramo storiti, potem je, da moramo zagotoviti, da se datoteka dejansko začela uspešno.

1000
01:01:53,220 --> 01:01:57,070
Zato bi bilo ne za več razlogov, nimate dovolj prostora na vašem računalniku, na primer.

1001
01:01:57,070 --> 01:01:59,790
Torej je vedno pomembno, preden to storite vse operacije z datoteko

1002
01:01:59,790 --> 01:02:03,300
da preveri, ali je bila ta datoteka odpre uspešno.

1003
01:02:03,300 --> 01:02:09,330
Torej, kaj je to, da je trditev, da fopen, no, lahko se nam odpre datoteko na več načinov.

1004
01:02:09,330 --> 01:02:13,510
Kaj lahko storimo, je, da lahko peljemo je w, kar pomeni, da prepišete datoteko, če že izhodi,

1005
01:02:13,510 --> 01:02:18,070
Mi lahko opraviti A, ki jih dodajte na konec datoteke, namesto da bi ga preglasil,

1006
01:02:18,070 --> 01:02:22,730
ali pa lahko določite r, kar pomeni, dajmo odpreti datoteko samo za branje.

1007
01:02:22,730 --> 01:02:24,890
Torej, če se program poskuša spreminjati datoteke,

1008
01:02:24,890 --> 01:02:30,140
kričati na njih, in ne dovolite, da to storite.

1009
01:02:30,140 --> 01:02:33,320
Nazadnje, ko sva končala z datoteko, končali dela operacije na to,

1010
01:02:33,320 --> 01:02:35,860
moramo prepričati, da smo zaprite datoteko.

1011
01:02:35,860 --> 01:02:38,830
In tako na koncu svojega programa, boste, da gredo še enkrat

1012
01:02:38,830 --> 01:02:42,120
To datoteko, ki ste jo odprli, in šele zapreti.

1013
01:02:42,120 --> 01:02:44,650
Torej, to je nekaj pomembno, da se prepričajte, veš.

1014
01:02:44,650 --> 01:02:47,180
Torej, ne pozabite, da lahko odprete datoteko, potem lahko pišete na datoteko,

1015
01:02:47,180 --> 01:02:51,270
ne operacije v datoteko, nato pa boste morali zapreti datoteko na koncu.

1016
01:02:51,270 --> 01:02:53,270
>> Vsa vprašanja v zvezi osnovne datoteke / I? Ja?

1017
01:02:53,270 --> 01:02:58,050
[Student vprašanje, nerazumljiv]

1018
01:02:58,050 --> 01:03:02,480
Prav tukaj. Vprašanje je, kje je ta datoteka log.txt zdi?

1019
01:03:02,480 --> 01:03:07,890
No, če si ji log.txt, jo ustvarja v isto mapo, kot izvedljive.

1020
01:03:07,890 --> 01:03:10,500
Torej, če Menda - >> [Student vprašanje, nerazumljiv]

1021
01:03:10,500 --> 01:03:18,830
Da. V isti mapi, ali v istem imeniku, kot jo imenuješ.

1022
01:03:18,830 --> 01:03:21,400
Zdaj spomin, kup in kup.

1023
01:03:21,400 --> 01:03:23,400
Torej, kako je spomin določena v računalniku?

1024
01:03:23,400 --> 01:03:26,270
No, lahko si predstavljate spomin kot nekakšno tega bloka tukaj.

1025
01:03:26,270 --> 01:03:30,260
In v spomin imamo, kar se imenuje kopico obtičal tam, in kup, ki je tam.

1026
01:03:30,260 --> 01:03:34,480
In kup raste navzdol in stack raste navzgor.

1027
01:03:34,480 --> 01:03:38,620
Tako kot Tommy omenjeno - oh, no, in smo te druge segmente 4, ki bom v 2. -

1028
01:03:38,620 --> 01:03:42,890
Kot je Tommy povedal že prej, saj veš, kako se imenujejo njegove funkcije in klic med seboj?

1029
01:03:42,890 --> 01:03:44,930
Gradijo to vrsto dimnika okvirja.

1030
01:03:44,930 --> 01:03:47,360
No, če je glavna zahteva foo, dobi foo dal na kup.

1031
01:03:47,360 --> 01:03:52,430
Foo poziva, bar se postavimo na sklad, in da dobi dal na sklad kasneje.

1032
01:03:52,430 --> 01:03:57,040
In ko se vrnejo, dobijo vsak vzletelo sklada.

1033
01:03:57,040 --> 01:04:00,140
Kaj vsaka od teh mest, in spomin držite?

1034
01:04:00,140 --> 01:04:03,110
No, na vrhu, ki je del besedila, ki vsebuje program sam.

1035
01:04:03,110 --> 01:04:06,390
Torej strojno kodo, to je tam, ko pripravijo svoj program.

1036
01:04:06,390 --> 01:04:08,520
Nato vsak inicializiran globalnih spremenljivk.

1037
01:04:08,520 --> 01:04:12,660
>> Torej imate globalne spremenljivke v programu, kot pravite, a = 5,

1038
01:04:12,660 --> 01:04:15,260
da dobi dal v ta segment, in prav na podlagi, da

1039
01:04:15,260 --> 01:04:18,990
imate nezaceto globalnih podatkov, ki jih je le int,

1040
01:04:18,990 --> 01:04:20,990
vendar ne boste rekli, da je enaka nič.

1041
01:04:20,990 --> 01:04:23,870
Zavedaj se, to so globalne spremenljivke, zato so zunaj glavnega.

1042
01:04:23,870 --> 01:04:28,560
Torej to pomeni, da vse globalne spremenljivke, ki so prijavljene, vendar se ni inicializiran.

1043
01:04:28,560 --> 01:04:32,310
Torej, kaj je v kup? Spomin razdelijo z malloc, ki jih bomo dobili v malo.

1044
01:04:32,310 --> 01:04:35,990
In končno, z dimnika imate lokalne spremenljivke

1045
01:04:35,990 --> 01:04:39,950
in bi vse funkcije, ki jih zahtevajo v katerem koli od njihovih parametrov.

1046
01:04:39,950 --> 01:04:43,720
Zadnja stvar, ne boste res moral vedeti, kaj storiti spremenljivke okolja,

1047
01:04:43,720 --> 01:04:46,700
ampak vsakič, ko zaženete program, je povezano nekaj, kot je

1048
01:04:46,700 --> 01:04:49,550
to je uporabniško ime osebe, ki je potekal program.

1049
01:04:49,550 --> 01:04:51,550
In to se dogaja, da je nekako na dnu.

1050
01:04:51,550 --> 01:04:54,540
V zvezi s pomnilniških naslovov, ki so šestnajstiških vrednosti,

1051
01:04:54,540 --> 01:04:58,170
vrednosti v zgornjem začetku na 0, in gredo vso pot navzdol do dna.

1052
01:04:58,170 --> 01:05:00,440
V tem primeru, če ste na 32-bitnem sistemu

1053
01:05:00,440 --> 01:05:05,390
naslov na dnu se bo 0x, nato af, ker to je 32 bitov,

1054
01:05:05,390 --> 01:05:10,890
kar je 8 bitov, in v tem primeru 8 bitov ustreza 8 šestnajstiških števk.

1055
01:05:10,890 --> 01:05:20,110
Torej, tukaj boste morali, kot so, 0xffffff, in tam boste imeli 0.

1056
01:05:20,110 --> 01:05:23,660
Torej, kaj so kazalci? Nekateri izmed vas morda ni zajeta v točki pred tem.

1057
01:05:23,660 --> 01:05:26,660
vendar smo si šel čez to v predavanju, tako da kazalec je samo podatkovni tip

1058
01:05:26,660 --> 01:05:34,030
trgovin, ki, namesto da bi neke vrste vrednosti, kot so 50, shranjuje naslov neke lokacije v pomnilniku.

1059
01:05:34,030 --> 01:05:36,020
Kot tisti spomin [nerazumljiv].

1060
01:05:36,020 --> 01:05:41,120
Torej v tem primeru, kar smo se, da imamo kazalec na celo število ali int *,

1061
01:05:41,120 --> 01:05:46,210
in vsebuje Ta šestnajstiški naslov 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Torej, kaj imamo, je, zdaj, ta kazalec kaže na določene lokacije v spominu,

1063
01:05:50,880 --> 01:05:56,020
in da je samo, vrednost 50 je v tem pomnilniško mesto.

1064
01:05:56,020 --> 01:06:01,810
Na nekaterih 32-bitnih sistemih, v vseh 32-bitnih sistemov, kazalci traja do 32 bitov ali 4 bajte.

1065
01:06:01,810 --> 01:06:06,020
Vendar pa, na primer, na 64-bitnem sistemu, kazalci so 64 bitov.

1066
01:06:06,020 --> 01:06:08,040
Torej, to je nekaj, kar boste želeli obdržati v mislih.

1067
01:06:08,040 --> 01:06:12,310
Torej, na koncu-bitni sistem, kazalec je konec bitov dolgo.

1068
01:06:12,310 --> 01:06:17,320
Kazalci so nekako težko prebavljive brez dodatnih stvari,

1069
01:06:17,320 --> 01:06:20,300
tako da je šel skozi primer dinamično dodeljevanje pomnilnika.

1070
01:06:20,300 --> 01:06:25,130
Kaj dinamično dodeljevanje pomnilnika naredi za vas, ali tisto, čemur pravimo malloc,

1071
01:06:25,130 --> 01:06:29,280
vam omogoča, da dodeli neke vrste podatkov zunaj nabora.

1072
01:06:29,280 --> 01:06:31,830
Torej so ti podatki nekako bolj trajna v času trajanja programa.

1073
01:06:31,830 --> 01:06:36,430
Ker, kot veste, če ugotovi x notranjost funkcije, in da funkcija vrne,

1074
01:06:36,430 --> 01:06:40,910
ne boste več imeli dostopa do podatkov, ki so shranjeni v x.

1075
01:06:40,910 --> 01:06:44,420
Kaj kazalci storimo, je, da nam shrani spomin ali shranjevanje vrednosti

1076
01:06:44,420 --> 01:06:46,840
v drugem segmentu pomnilnika, to je kup.

1077
01:06:46,840 --> 01:06:49,340
Zdaj, ko se vrnemo iz funkcije, dokler imamo kazalec

1078
01:06:49,340 --> 01:06:54,960
na to mesto v pomnilniku, potem kaj lahko storimo, je, da lahko samo pogled na vrednote tam.

1079
01:06:54,960 --> 01:06:58,020
Oglejmo si primer: To je naš spomin postavitev znova.

1080
01:06:58,020 --> 01:07:00,050
In imamo to funkcijo, glavni.

1081
01:07:00,050 --> 01:07:06,870
Kaj pa je - prav tako preprosto, kajne? - Int x = 5, ki je samo spremenljivka na stack v glavni.

1082
01:07:06,870 --> 01:07:12,450
>> Po drugi strani pa je zdaj izjavljamo kazalec, ki pokliče funkcijo giveMeThreeInts.

1083
01:07:12,450 --> 01:07:16,800
In zdaj gremo v to funkcijo in smo ustvarili novo žetonov okvir za to.

1084
01:07:16,800 --> 01:07:20,440
Vendar pa v tem okviru dimnika izjavljamo, int * temp,

1085
01:07:20,440 --> 01:07:23,210
ki mallocs 3 števil za nas.

1086
01:07:23,210 --> 01:07:25,880
Torej bo velikost notr nam, koliko bajtov je to int je,

1087
01:07:25,880 --> 01:07:29,620
in malloc nam omogoča, da veliko bajtov prostora na kup.

1088
01:07:29,620 --> 01:07:32,890
Torej v tem primeru, smo ustvarili dovolj prostora za 3 cela števila,

1089
01:07:32,890 --> 01:07:36,830
in kup je pot do tja, zato sem prišla na podlagi višje.

1090
01:07:36,830 --> 01:07:42,900
Ko končamo, smo prišli sem gor, morate samo 3 ints vrne,

1091
01:07:42,900 --> 01:07:47,000
in vrne naslov, v tem primeru več kot če je ta spomin.

1092
01:07:47,000 --> 01:07:51,250
In smo postavili kazalec = stikalo, in tam imamo samo še en kazalec.

1093
01:07:51,250 --> 01:07:54,550
Toda kaj, da se funkcija vrne kup tukaj in izgine.

1094
01:07:54,550 --> 01:07:59,250
Torej temp izgine, vendar smo še vedno ohranili naslov, kjer

1095
01:07:59,250 --> 01:08:01,850
tiste 3 cela so znotraj omrežja.

1096
01:08:01,850 --> 01:08:06,180
Torej, v tem sklopu so zajeta kazalci za lokalno zloženega okvirja,

1097
01:08:06,180 --> 01:08:09,860
ampak spomin, na katerega se nanašajo, na kup.

1098
01:08:09,860 --> 01:08:12,190
>> Ima to smisel?

1099
01:08:12,190 --> 01:08:14,960
[Študent] Lahko ponovite? >> [Joseph] Da.

1100
01:08:14,960 --> 01:08:20,270
Torej, če se vrnem samo malo, boste videli, da je temperatura dodeljena

1101
01:08:20,270 --> 01:08:23,500
nekaj pomnilnika na kup up there.

1102
01:08:23,500 --> 01:08:28,680
Torej, ko je funkcija, giveMeThreeInts vrne ta sklad tu bo izginila.

1103
01:08:28,680 --> 01:08:35,819
In z njim vseh spremenljivk, v tem primeru je to namig, da je bila dodeljena v okviru zloženi.

1104
01:08:35,819 --> 01:08:39,649
To bo izginila, ker pa smo se vrnili temp

1105
01:08:39,649 --> 01:08:46,330
in smo postavili kazalec = temp, kazalec se zdaj dogaja s točko isto mesto kot spomin na temp bil.

1106
01:08:46,330 --> 01:08:50,370
Torej sedaj, čeprav smo izgubili, da lokalni temp kazalec,

1107
01:08:50,370 --> 01:08:59,109
še vedno ohranjajo spomin naslov, kar je bilo kaže na notranjo stran te spremenljivke kazalca.

1108
01:08:59,109 --> 01:09:03,740
Vprašanja? To je lahko nekako zmedeno temo, če še niste šli preko njega v oddelku.

1109
01:09:03,740 --> 01:09:09,240
Mi lahko, bo vaš TF definitivno šel nad njo in seveda bomo lahko odgovorili na vprašanja

1110
01:09:09,240 --> 01:09:11,500
Na koncu pregleda seji za to.

1111
01:09:11,500 --> 01:09:14,220
Ampak to je neke vrste kompleksno temo, in imam več primerov, ki se bodo prikazala

1112
01:09:14,220 --> 01:09:18,790
, ki bo pomagal pojasniti, kaj pravzaprav so kazalci.

1113
01:09:18,790 --> 01:09:22,500
>> V tem primeru kazalci so enakovredni nizi,

1114
01:09:22,500 --> 01:09:25,229
tako da sem lahko uporabite ta kazalec se ista stvar kot int array.

1115
01:09:25,229 --> 01:09:29,840
Torej sem indeksiranje na 0 in spreminjanje prvo celo število za 1,

1116
01:09:29,840 --> 01:09:39,689
spreminjanje 2. celo število za 2 in 3. celo do 3.

1117
01:09:39,689 --> 01:09:44,210
Torej, več o kazalca. No, spomnim Binky.

1118
01:09:44,210 --> 01:09:48,319
V tem primeru smo namenili kazalec, ali pa razglasi kazalec,

1119
01:09:48,319 --> 01:09:52,760
ampak na začetku, ko sem razglasila kazalec, da je ne kaže, da kjerkoli v pomnilniku.

1120
01:09:52,760 --> 01:09:54,930
To je samo smeti vrednosti znotraj njega.

1121
01:09:54,930 --> 01:09:56,470
Torej, ne vem, če je to kazalec, ki kaže na.

1122
01:09:56,470 --> 01:10:01,630
To je naslov, ki je pravkar napolnjene z 0 in 1, kjer je bila prvotno prijavljena.

1123
01:10:01,630 --> 01:10:04,810
Ne morem storiti ničesar s tem, dokler nisem poklical malloc na njej

1124
01:10:04,810 --> 01:10:08,390
in potem mi daje malo prostora na kup, kjer sem lahko del vrednosti znotraj.

1125
01:10:08,390 --> 01:10:11,980
Potem spet, ne vem, kaj je notri tega spomina.

1126
01:10:11,980 --> 01:10:16,780
Torej prva stvar, ki sem storiti, je preveriti, ali je sistem imel dovolj pomnilnika

1127
01:10:16,780 --> 01:10:20,850
da mi vrne celo število 1 na prvem mestu, zato to počnem preveriti.

1128
01:10:20,850 --> 01:10:25,020
Če kazalec nič, kar pomeni, da ni dovolj prostora ali druge napake,

1129
01:10:25,020 --> 01:10:26,320
zato sem izhod iz mojega programa.

1130
01:10:26,320 --> 01:10:29,400
 Ampak, če vam uspe, zdaj lahko uporabim ta kazalec

1131
01:10:29,400 --> 01:10:35,020
in kaj je * kazalec pa je naslednji, kjer je naslov

1132
01:10:35,020 --> 01:10:38,480
, kjer je ta vrednost, in določa, da je enak 1.

1133
01:10:38,480 --> 01:10:41,850
Torej, tukaj, smo preverjanje, če je pomnilnik obstajala.

1134
01:10:41,850 --> 01:10:45,380
>> Ko veš, da obstaja, lahko vanjo

1135
01:10:45,380 --> 01:10:50,460
kakšno vrednost želite, da bi v njej, v tem primeru 1.

1136
01:10:50,460 --> 01:10:53,060
Ko bomo končali z njim, morate sprostiti, da kazalec

1137
01:10:53,060 --> 01:10:57,160
ker moramo priti nazaj v sistem, ki pomnilnika, ki ste ga zahtevali na prvem mestu.

1138
01:10:57,160 --> 01:10:59,690
Ker računalnik ne ve, kdaj bomo končali z njo.

1139
01:10:59,690 --> 01:11:02,510
V tem primeru smo to izrecno povedal, v redu, smo opravili s tem spomin.

1140
01:11:02,510 --> 01:11:10,780
Če kak drug postopek, ki ga potrebuje, nekateri drugi program potrebuje, vas prosimo, da gredo naprej in ga sprejeti.

1141
01:11:10,780 --> 01:11:15,110
Kaj lahko naredimo je, da lahko samo dobil naslov lokalnih spremenljivk na množici.

1142
01:11:15,110 --> 01:11:19,080
Torej, int x je v notranjosti zloženega okviru main.

1143
01:11:19,080 --> 01:11:23,060
In ko smo uporabi ta znak, to in izvajalec, kaj počne, je

1144
01:11:23,060 --> 01:11:27,310
je potrebno x in x je le nekaj podatkov v pomnilniku, vendar pa ima naslov.

1145
01:11:27,310 --> 01:11:33,790
To je nekje nahaja. Torej ga kliče in x, kaj pa je to nam daje naslov x.

1146
01:11:33,790 --> 01:11:38,430
S tem delamo kazalec točko, kjer je x v spominu.

1147
01:11:38,430 --> 01:11:41,710
Zdaj smo pač nekaj podobnega * x, bomo dobili 5 nazaj.

1148
01:11:41,710 --> 01:11:43,820
Zvezda se imenuje ga Dereferenciranje.

1149
01:11:43,820 --> 01:11:46,640
Slediš naslov in dobiš vrednost njej shranjene tam.

1150
01:11:51,000 --> 01:11:53,310
>> Kakšno vprašanje? Ja?

1151
01:11:53,310 --> 01:11:56,500
[Študent] Če ne naredite 3-konico stvar, pa še vedno prevedite?

1152
01:11:56,500 --> 01:11:59,490
Da. Če ne naredite 3-kazalec stvar, bo to še vedno v pripravi,

1153
01:11:59,490 --> 01:12:02,720
pa ti bom pokazal, kaj se dogaja v 2. in brez dela, da

1154
01:12:02,720 --> 01:12:04,860
To je tisto, čemur pravimo pomnilnika. Nisi dati sistemu

1155
01:12:04,860 --> 01:12:07,850
nazaj svoj spomin, tako da po nekaj časa program bo kopičijo

1156
01:12:07,850 --> 01:12:10,940
pomnilnika, ki je ne uporabljate, in nič drugega lahko uporabite.

1157
01:12:10,940 --> 01:12:15,750
Če ste že kdaj videli Firefox z 1,5 milijona kilobajtov na vašem računalniku,

1158
01:12:15,750 --> 01:12:17,840
v upravitelja opravil, da je to, kar se dogaja.

1159
01:12:17,840 --> 01:12:20,760
Imate pomnilnika v programu, da oni ne obdelujejo.

1160
01:12:23,080 --> 01:12:26,240
Torej, kako je kazalec aritmetična deluje?

1161
01:12:26,240 --> 01:12:29,480
No, kazalec aritmetična je neke vrste, kot so kazala v matriko.

1162
01:12:29,480 --> 01:12:36,370
V tem primeru imam kazalec, in kaj sem naredil je, da sem lahko kazalec točko prvega elementa

1163
01:12:36,370 --> 01:12:42,100
tega sklopa 3 celih da sem dodeljena.

1164
01:12:42,100 --> 01:12:46,670
Torej, kaj zdaj delam, star le kazalec spremeni prvi element na seznamu.

1165
01:12:46,670 --> 01:12:49,140
Star Kazalec 1 točke več kot tukaj.

1166
01:12:49,140 --> 01:12:53,140
Torej kazalec tja, je kazalec 1 tukaj, kazalec 2 je tukaj.

1167
01:12:53,140 --> 01:12:56,610
>> Torej samo dodal 1 je ista stvar kot se premikajo po tem polju.

1168
01:12:56,610 --> 01:12:59,880
Kaj moramo storiti, je, ko mi kazalec 1 dobiš naslov tukaj,

1169
01:12:59,880 --> 01:13:04,180
in da bi dobili vrednost, ti dal zvezdo od celotnega izraza

1170
01:13:04,180 --> 01:13:05,990
ga dereference.

1171
01:13:05,990 --> 01:13:09,940
Torej, v tem primeru, sem o prvo mesto v tem polju na 1,

1172
01:13:09,940 --> 01:13:13,970
2. mesto na 2. in 3. mesto na 3.

1173
01:13:13,970 --> 01:13:18,180
Torej, kaj počnem tukaj je jaz tiskanje naše kazalec 1,

1174
01:13:18,180 --> 01:13:19,970
ki mi daje samo 2.

1175
01:13:19,970 --> 01:13:23,650
Zdaj sem povečevanje kazalca, tako da kazalec kazalec enak 1,

1176
01:13:23,650 --> 01:13:26,780
, ki jo premika naprej.

1177
01:13:26,780 --> 01:13:30,810
In sedaj, če sem izpisal kazalec 1, kazalec 1 je trenutno 3,

1178
01:13:30,810 --> 01:13:33,990
, ki je v tem primeru natisne 3.

1179
01:13:33,990 --> 01:13:36,560
In da brez nečesa, kazalec, ki sem ga dal

1180
01:13:36,560 --> 01:13:40,540
mora biti obrnjena na začetku niza, ki sem ga dobil nazaj iz knjižnične funkcije malloc.

1181
01:13:40,540 --> 01:13:43,430
Torej, v tem primeru, če bi bil jaz poklical 3 tukaj, to ne bi bilo prav,

1182
01:13:43,430 --> 01:13:45,070
ker je v sredini polja.

1183
01:13:45,070 --> 01:13:48,820
Moram odšteti priti do izvirnega mesta

1184
01:13:48,820 --> 01:13:50,420
začetna 1. mesto, preden ga lahko rešil.

1185
01:13:56,300 --> 01:13:58,450
Torej, tukaj je bolj vključeni primer.

1186
01:13:58,450 --> 01:14:03,360
V tem primeru, bomo dodeljevanje 7 znakov v znakovni niz.

1187
01:14:03,360 --> 01:14:06,480
>> In v tem primeru, kar delamo, je, da smo v prvem zanka 6 od njih,

1188
01:14:06,480 --> 01:14:09,900
in smo jih nastavite do Z.

1189
01:14:09,900 --> 01:14:13,350
Torej, za int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Torej, kazalec + bom samo nam, v tem primeru,

1191
01:14:16,220 --> 01:14:20,860
kazalec, kazalec 1, 2 kazalca, kazalec 3, in tako naprej in tako naprej v krogu.

1192
01:14:20,860 --> 01:14:24,040
Kaj bo naredil, je, da postane ta naslov, dereferences, da bi dobil vrednost,

1193
01:14:24,040 --> 01:14:27,440
in spremembe, ki vrednost na Z.

1194
01:14:27,440 --> 01:14:30,350
Potem pa na koncu ne pozabite, da gre za niz, kajne?

1195
01:14:30,350 --> 01:14:33,560
Vse niti je končala z ničelno zaključku značaja.

1196
01:14:33,560 --> 01:14:38,620
Torej, kaj sem naredil je kazalec 6 sem dal noter null Terminator značaja

1197
01:14:38,620 --> 01:14:43,980
In zdaj, kaj sem v bistvu počne tukaj je printf izvedbenih za niz, kajne?

1198
01:14:43,980 --> 01:14:46,190
>> Torej, če ne zdaj, ko je printf je dosegel konec niza?

1199
01:14:46,190 --> 01:14:48,230
Ko zadene null zaključni znak.

1200
01:14:48,230 --> 01:14:52,030
Torej, v tem primeru moj originalni kazalec kaže na začetku tega polja.

1201
01:14:52,030 --> 01:14:56,410
Tiskam prvi znak ven. Jaz ga premaknite na eno.

1202
01:14:56,410 --> 01:14:58,420
Sem izpisal znak ven. Sem ga premakni se.

1203
01:14:58,420 --> 01:15:02,180
In jaz vztrajati početje to, dokler ne pridem do konca.

1204
01:15:02,180 --> 01:15:07,750
In zdaj je konec * kazalec se bo to dereference in dobili null zaključni znak nazaj.

1205
01:15:07,750 --> 01:15:11,780
In tako sem pa zanka deluje le, če je ta vrednost ni null zaključku značaj.

1206
01:15:11,780 --> 01:15:13,770
Torej, zdaj sem izhod iz te zanke.

1207
01:15:18,780 --> 01:15:21,180
In tako, če odštejemo 6 tega kazalca,

1208
01:15:21,180 --> 01:15:22,860
Grem nazaj vse do začetka.

1209
01:15:22,860 --> 01:15:27,880
Ne pozabite, da to delam zato, ker moram iti na začetek, da bi ga rešil.

1210
01:15:27,880 --> 01:15:30,270
>> Torej, vem, da je veliko. Kakšno vprašanje?

1211
01:15:30,270 --> 01:15:31,870
Prosim, ne?

1212
01:15:31,870 --> 01:15:36,610
[Student vprašanje nerazumljivo]

1213
01:15:36,610 --> 01:15:38,190
Lahko rečemo, da glasneje? Žal mi je.

1214
01:15:38,190 --> 01:15:44,140
[Študent] Na zadnji prosojnici tik preden se je sprostila kazalec,

1215
01:15:44,140 --> 01:15:47,300
kje ste dejansko spreminja vrednost kazalca?

1216
01:15:47,300 --> 01:15:50,370
[Joseph] Torej, tukaj. >> [Študent] V redu.

1217
01:15:50,370 --> 01:15:51,890
[Joseph] Torej, imam kazalec minus minus, desno,

1218
01:15:51,890 --> 01:15:54,140
ki premika stvari nazaj 1, potem pa sem jo osvobodil,

1219
01:15:54,140 --> 01:15:57,000
ker je ta kazalec je treba opozoriti, da na začetku niza.

1220
01:15:57,000 --> 01:16:00,420
[Študent] Ampak to ne bi bilo potrebno bi ga ustavil po tej progi.

1221
01:16:00,420 --> 01:16:03,130
[Joseph] Torej, če sem ustavil po tem, bi se to šteje pomnilnika,

1222
01:16:03,130 --> 01:16:04,810
ker nisem teči brezplačno.

1223
01:16:04,810 --> 01:16:11,290
[Študent] I [nerazumljivo] po prvih treh vrsticah, kjer ste imeli kazalec 1 [nerazumljivo].

1224
01:16:11,290 --> 01:16:13,140
[Joseph] Aha. Torej, kaj je vprašanje tam?

1225
01:16:13,140 --> 01:16:14,780
Žal mi je. Ne, ne. Gremo, gremo, prosim.

1226
01:16:14,780 --> 01:16:16,870
[Študent] Torej, ne boš spremembi vrednosti kazalca.

1227
01:16:16,870 --> 01:16:19,130
Ne bi moral storiti kazalec minus minus.

1228
01:16:19,130 --> 01:16:19,730
[Joseph] Da, točno tako.

1229
01:16:19,730 --> 01:16:21,890
Torej, ko sem naredil kazalec 1 in 2 kazalec,

1230
01:16:21,890 --> 01:16:24,410
Ne delam kazalec kazalec enaka 1.

1231
01:16:24,410 --> 01:16:27,260
Torej, kazalec ostane samo kaže na začetku niza.

1232
01:16:27,260 --> 01:16:31,460
Šele ko sem naredil plus plus, da določa vrednost kazalca nazaj noter,

1233
01:16:31,460 --> 01:16:33,550
da je dejansko premika to skupaj.

1234
01:16:36,860 --> 01:16:37,780
V redu.

1235
01:16:40,550 --> 01:16:42,030
Še vprašanja?

1236
01:16:44,680 --> 01:16:47,790
>> Tudi, če je to nekakšna velika, bo to zajeto v seji.

1237
01:16:47,790 --> 01:16:50,710
Vprašajte svojega poučevanja kolegi o tem, mi lahko odgovorite na vprašanja na koncu.

1238
01:16:53,510 --> 01:16:56,600
In ponavadi ne maramo, da to stori minus stvar.

1239
01:16:56,600 --> 01:16:59,760
To mora zahtevati me sledenja, koliko sem odmik v polje.

1240
01:16:59,760 --> 01:17:04,520
Torej, na splošno, to je samo, da pojasni, kako deluje aritmetične kazalec.

1241
01:17:04,520 --> 01:17:07,970
Toda tisto, kar ponavadi radi naredili je, da smo želeli ustvariti kopijo kazalca,

1242
01:17:07,970 --> 01:17:11,640
in potem bomo uporabili kopijo, ko smo se gibljejo v nizu.

1243
01:17:11,640 --> 01:17:14,660
Torej, v teh Če uporabljate izvod natisniti celoten niz,

1244
01:17:14,660 --> 01:17:19,040
vendar pa ne bi bilo treba storiti, kot kazalec minus 6 ali spremljate, koliko smo se preselili v to,

1245
01:17:19,040 --> 01:17:22,700
samo zato, ker vemo, da je naša prvotna točka še vedno opozarjajo na začetku seznama

1246
01:17:22,700 --> 01:17:25,340
in vse, kar smo spremenili je to kopija.

1247
01:17:25,340 --> 01:17:28,250
Torej, na splošno spremeni kopije izvirnega kazalca.

1248
01:17:28,250 --> 01:17:32,350
Ne poskušajte nekako podobno - Ne spremeni izvirne kopije.

1249
01:17:32,350 --> 01:17:35,290
Poskus, da spremeni samo kopije originala.

1250
01:17:41,540 --> 01:17:44,870
Torej, ste opazili, ko se peljemo niz v printf

1251
01:17:44,870 --> 01:17:48,990
vam ni treba dati zvezdo pred njim, kot smo naredili z vsemi drugimi dereferences, kajne?

1252
01:17:48,990 --> 01:17:54,180
Torej, če si natisnete celoten niz% s pričakuje, da je naslov,

1253
01:17:54,180 --> 01:17:57,610
in v tem primeru kazalca ali v tem primeru, kot je niz znakov.

1254
01:17:57,610 --> 01:18:00,330
>> Znaki, char * s, in polja so ista stvar.

1255
01:18:00,330 --> 01:18:03,690
Kazalec je znakov, znakov nizi so ista stvar.

1256
01:18:03,690 --> 01:18:05,720
In tako je vse, kar moramo storiti, je minil v kazalec.

1257
01:18:05,720 --> 01:18:08,150
Mi ne bi bilo treba prenesti v kot kazalec * ali kaj podobnega.

1258
01:18:13,110 --> 01:18:14,930
Torej, nizi in kazalci so ista stvar.

1259
01:18:14,930 --> 01:18:19,160
Ko delaš nekaj podobnega x [y] tukaj za matriko,

1260
01:18:19,160 --> 01:18:21,960
kaj počne pod pokrovom je je rekel, ok, to je znak array,

1261
01:18:21,960 --> 01:18:23,690
tako da je kazalec.

1262
01:18:23,690 --> 01:18:26,510
In tako x so ista stvar,

1263
01:18:26,510 --> 01:18:28,650
in kaj počne, je to dodaja y na x,

1264
01:18:28,650 --> 01:18:31,820
kar je isto, kot korak naprej v spominu, da je veliko.

1265
01:18:31,820 --> 01:18:34,930
In zdaj x + y nam daje neko naslov

1266
01:18:34,930 --> 01:18:37,570
in smo dereference naslov ali slediti puščico

1267
01:18:37,570 --> 01:18:41,640
da če se ta lokacija v pomnilniku je in smo dobili vrednost iz tega mesta v pomnilniku.

1268
01:18:41,640 --> 01:18:43,720
Torej, da gre za dve popolnoma ista stvar.

1269
01:18:43,720 --> 01:18:45,840
To je samo skladenjsko sladkor.

1270
01:18:45,840 --> 01:18:48,090
Prav to isto stvar. Oni so samo različni syntactics za seboj.

1271
01:18:51,500 --> 01:18:57,590
>> Torej, kaj lahko gre narobe s kazalci? Recimo, veliko. Ok. Torej, slabe stvari.

1272
01:18:57,590 --> 01:19:02,410
Nekatere slabe stvari, ki jih lahko storite, ne preverja, če je vaš klic malloc vrne null, kajne?

1273
01:19:02,410 --> 01:19:06,560
V tem primeru vas prosim, da sistem mi dali - kaj je to številka?

1274
01:19:06,560 --> 01:19:11,200
Kot 2000000000 krat 4, saj je velikost celo število je 4 bajte.

1275
01:19:11,200 --> 01:19:13,810
Jaz sem ga prosil za podobno 8000000000 bajtov.

1276
01:19:13,810 --> 01:19:17,270
Seveda je moj računalnik ne bo mogel, da mi toliko nazaj pomnilnika.

1277
01:19:17,270 --> 01:19:20,960
In mi ni preveril, če je to nič, tako da, ko smo poskušali ciljne datoteke tam -

1278
01:19:20,960 --> 01:19:24,270
sledite puščice, da če se bo - nimamo ta pomnilnik.

1279
01:19:24,270 --> 01:19:27,150
To je tisto, čemur pravimo Dereferenciranje null kazalec.

1280
01:19:27,150 --> 01:19:29,710
In to v bistvu povzroči, da segfault.

1281
01:19:29,710 --> 01:19:31,790
To je eden od načinov, kako lahko segfault.

1282
01:19:34,090 --> 01:19:38,090
Drugi slabe stvari, ki jih lahko storite - oh dobro.

1283
01:19:38,090 --> 01:19:40,650
To je bilo Dereferenciranje null kazalec. Ok.

1284
01:19:40,650 --> 01:19:45,160
Drugi slabe stvari - no, da se določi, da si dal ček tam

1285
01:19:45,160 --> 01:19:46,980
da preveri, ali je kazalec null

1286
01:19:46,980 --> 01:19:51,000
in izhod iz programa, če se zgodi, da malloc vrne null kazalec.

1287
01:19:55,110 --> 01:19:59,850
To je xkcd strip. Ljudje razumejo zdaj. Tako nekako.

1288
01:20:06,120 --> 01:20:09,350
>> Torej, spomin. In sem šel čez to.

1289
01:20:09,350 --> 01:20:12,000
Mi smo kliče malloc v zanki, ampak vsakič, ko pravimo malloc

1290
01:20:12,000 --> 01:20:14,370
smo izgubili sledi, kje je ta kazalec kaže na,

1291
01:20:14,370 --> 01:20:15,750
zato, ker smo ga clobbering.

1292
01:20:15,750 --> 01:20:18,410
Torej, prvi razpis za knjižnične funkcije malloc mi daje spomin tukaj.

1293
01:20:18,410 --> 01:20:19,990
Moje kazalec napotke za to.

1294
01:20:19,990 --> 01:20:23,020
Zdaj, jaz ne osvobodi, tako da zdaj kličem malloc znova.

1295
01:20:23,020 --> 01:20:26,070
Zdaj pa opozarja tukaj. Zdaj moj spomin je obrnjen tukaj.

1296
01:20:26,070 --> 01:20:27,640
Miške tukaj. Miške tukaj.

1297
01:20:27,640 --> 01:20:31,820
Ampak sem izgubil občutek za naslove vseh spomina več tukaj, da sem dodeljena.

1298
01:20:31,820 --> 01:20:35,100
In zdaj nimam nobenega sklicevanja na njih več.

1299
01:20:35,100 --> 01:20:37,230
Torej, ne morem osvoboditi izven te zanke.

1300
01:20:37,230 --> 01:20:39,390
In tako, da se določi nekaj takega,

1301
01:20:39,390 --> 01:20:42,250
Če ste pozabili prostega pomnilnika in dobiš to pomnilnika,

1302
01:20:42,250 --> 01:20:45,810
Moraš osvoboditi spomina znotraj te zanke, ko ste končali z njo.

1303
01:20:45,810 --> 01:20:51,400
No, to je tisto, kar se dogaja. Vem, da je veliko vas sovražijo to.

1304
01:20:51,400 --> 01:20:55,270
Ampak zdaj - yay! Dobiš kot 44.000 kilobajtov.

1305
01:20:55,270 --> 01:20:57,110
Torej, ti je obtičalo na koncu zanke,

1306
01:20:57,110 --> 01:20:59,770
in da se bo tako osvobodil na pomnilniško vsakič.

1307
01:20:59,770 --> 01:21:03,620
V bistvu, vaš program nima več pomnilnika.

1308
01:21:03,620 --> 01:21:08,150
>> In sedaj nekaj drugega, kar lahko naredite, je sprostiti nekaj pomnilnika, ki ste jih prosil za dvakrat.

1309
01:21:08,150 --> 01:21:11,060
V tem primeru boste malloc nekaj, spremenite svojo vrednost.

1310
01:21:11,060 --> 01:21:13,140
Si ga osvobodi enkrat, ker si rekel, da si naredil z njim.

1311
01:21:13,140 --> 01:21:14,940
Ampak potem smo ga osvobodili še enkrat.

1312
01:21:14,940 --> 01:21:16,730
To je nekaj, kar je zelo slabo.

1313
01:21:16,730 --> 01:21:18,820
To se ne bo sprva segfault,

1314
01:21:18,820 --> 01:21:23,350
ampak ko pa kaj ne je dvojno osvoboditev s tem pokvari vaš kup strukturo,

1315
01:21:23,350 --> 01:21:27,200
in boste izvedeli nekaj več o tem, če se odločite, da razred, kot CS61.

1316
01:21:27,200 --> 01:21:30,000
Ampak v bistvu po ko je vaš računalnik se bo zbunjeni

1317
01:21:30,000 --> 01:21:33,010
kaj pomnilniške lokacije, kjer in kadar je shranjen -

1318
01:21:33,010 --> 01:21:34,800
kjer se podatki shranjujejo v pomnilnik.

1319
01:21:34,800 --> 01:21:38,080
In tako sprostila kazalec dvakrat je slabo, če ne želite storiti.

1320
01:21:38,080 --> 01:21:41,600
>> Druge stvari, ki lahko kaj narobe, ne uporabljate sizeof.

1321
01:21:41,600 --> 01:21:44,460
Torej, v tem primeru boste malloc 8 bajtov,

1322
01:21:44,460 --> 01:21:46,700
in to je isto kot dveh celih števil, kajne?

1323
01:21:46,700 --> 01:21:49,580
Torej, to je popolnoma varen, vendar je to?

1324
01:21:49,580 --> 01:21:52,160
No, kot Lucas govoril o različnih arhitektur,

1325
01:21:52,160 --> 01:21:54,220
cela, so različnih dolžin.

1326
01:21:54,220 --> 01:21:57,970
Torej, na aparatu, ki ga uporabljate, cela okoli 4 bajte,

1327
01:21:57,970 --> 01:22:02,370
ampak na nek drug sistem, bi morali biti 8 bajtov ali pa morda 16 bajtov.

1328
01:22:02,370 --> 01:22:05,680
Torej, če sem to številko tukaj,

1329
01:22:05,680 --> 01:22:07,310
ta program bi lahko delovala na napravi,

1330
01:22:07,310 --> 01:22:10,360
vendar to ne bo dovolj pomnilnika za dodelitev na nekaterih drugih sistemih.

1331
01:22:10,360 --> 01:22:14,020
V tem primeru, to je tisto, kar mora upravljavec sizeof uporablja.

1332
01:22:14,020 --> 01:22:16,880
Ko pravimo sizeof (int), kaj to počne, je

1333
01:22:16,880 --> 01:22:21,910
 nam daje velikost celo število v sistemu, da program teče.

1334
01:22:21,910 --> 01:22:25,490
Torej, v tem primeru bo sizeof (int) vrne 4 na kaj takega aparata,

1335
01:22:25,490 --> 01:22:29,980
in zdaj bo to 4 * 2, kar je za 8,

1336
01:22:29,980 --> 01:22:32,330
ki je le, koliko prostora je potreben za 2 cela števila.

1337
01:22:32,330 --> 01:22:36,710
Na drugem sistemu, če je kot 16 int bajte ali 8 bajtov,

1338
01:22:36,710 --> 01:22:39,380
to je le, da bo dovolj, da se vrnete bajta za shranjevanje tega zneska.

1339
01:22:41,830 --> 01:22:45,310
>> In končno, konstrukti.

1340
01:22:45,310 --> 01:22:48,340
Torej, če boste želeli shraniti Sudoku deska v spomin, kako bi lahko to storimo?

1341
01:22:48,340 --> 01:22:51,570
Morda si mislite o kot spremenljivko za prvo stvar,

1342
01:22:51,570 --> 01:22:53,820
spremenljivka za drugo stvar, spremenljivka za tretjo stvar,

1343
01:22:53,820 --> 01:22:56,420
spremenljivka za četrto stvar - slabo, kajne?

1344
01:22:56,420 --> 01:23:00,750
Torej, ena izboljšava si lahko na vrhu je to, da bi 9 x 9 matriko.

1345
01:23:00,750 --> 01:23:04,480
To je v redu, kaj pa če bi želel povezati tudi druge stvari s svetom sudoku

1346
01:23:04,480 --> 01:23:06,490
všeč, kaj težavnost ladji,

1347
01:23:06,490 --> 01:23:11,740
ali, na primer, kaj je tvoj rezultat je, ali koliko časa je trajalo, da bi rešili ta forum?

1348
01:23:11,740 --> 01:23:14,970
Torej, kaj lahko naredite, je, da lahko ustvarite struct.

1349
01:23:14,970 --> 01:23:18,910
Kaj sem rekel je, v bistvu sem opredelitev te strukture tukaj,

1350
01:23:18,910 --> 01:23:23,230
in sem opredelitvi Sudoku odbora, ki je sestavljen iz krovu, ki je 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> In kaj ima to je namig na ime ravni.

1352
01:23:26,650 --> 01:23:30,730
Prav tako ima X in Y, ki so koordinate, kjer sem zdaj.

1353
01:23:30,730 --> 01:23:35,980
To je tudi čas, porabljen [nerazumljiv], in ima skupno število potez sem vnesenih doslej.

1354
01:23:35,980 --> 01:23:40,010
In tako se v tem primeru lahko združite cel kup podatkov v eno samo strukturo

1355
01:23:40,010 --> 01:23:42,790
namesto da bi ga ob tako plujejo okoli v tako različnih spremenljivk

1356
01:23:42,790 --> 01:23:44,540
da ne morem slediti.

1357
01:23:44,540 --> 01:23:49,720
In to nam omogoča imeti samo lepo sintakso za nekakšno sklicevanje različne stvari znotraj tega struct.

1358
01:23:49,720 --> 01:23:53,430
Pravkar sem lahko naredil board.board, in sem dobil Sudoku krovu nazaj.

1359
01:23:53,430 --> 01:23:56,320
Board.level, dobim kako težko je.

1360
01:23:56,320 --> 01:24:00,540
Board.x in board.y mi koordinate, kjer bi moral biti v vozilu.

1361
01:24:00,540 --> 01:24:04,730
In tako sem dostopu, kar imenujemo polja v struct.

1362
01:24:04,730 --> 01:24:08,840
Ta opredeljuje sudokuBoard, ki je tip, ki ga imam.

1363
01:24:08,840 --> 01:24:14,800
In zdaj smo tu. Imam spremenljivko, imenovano "svet" v sudokuBoard tipa.

1364
01:24:14,800 --> 01:24:18,820
In sedaj lahko dostopate do vseh področij, ki sestavljajo to strukturo tukaj.

1365
01:24:20,830 --> 01:24:22,450
>> Vsa vprašanja v zvezi s konstrukti? Ja?

1366
01:24:22,450 --> 01:24:25,890
[Študent] Za int x, y, ste prijavljeni tako v eno vrstico? >> [Joseph] Aha.

1367
01:24:25,890 --> 01:24:27,400
[Študent] Torej, bi si naredil, da z vsemi od njih?

1368
01:24:27,400 --> 01:24:31,200
Tako kot v X, Y vejica čas, da skupaj?

1369
01:24:31,200 --> 01:24:34,460
[Joseph] Ja, lahko zagotovo storiti, toda razlog, zakaj sem dal x in y na isti liniji -

1370
01:24:34,460 --> 01:24:36,330
in vprašanje je, zakaj smo lahko le to na isti liniji?

1371
01:24:36,330 --> 01:24:38,600
Zakaj ne bi samo dal vse to na isti liniji

1372
01:24:38,600 --> 01:24:42,090
x in y sta povezani med seboj,

1373
01:24:42,090 --> 01:24:44,780
in to je samo stilistično bolj pravilno, v smislu,

1374
01:24:44,780 --> 01:24:46,600
saj je združevanje dveh stvari na isti liniji

1375
01:24:46,600 --> 01:24:49,340
ki se je kot vrsta se nanašajo na isto stvar.

1376
01:24:49,340 --> 01:24:51,440
In jaz sem ti razdeliti narazen. To je samo ime nekaj.

1377
01:24:51,440 --> 01:24:53,720
Je funkcionalno nobene razlike kakršno.

1378
01:24:58,150 --> 01:24:59,270
Kakršna koli druga vprašanja o konstrukti?

1379
01:25:03,030 --> 01:25:06,620
Določite lahko Pokédex s struct.

1380
01:25:06,620 --> 01:25:11,720
Pokémon je število in ima pismo, lastnika, tip.

1381
01:25:11,720 --> 01:25:16,990
In potem, če imate niz Pokémon, lahko tvorijo Pokédex, kajne?

1382
01:25:16,990 --> 01:25:20,810
V redu, v redu. Torej, vprašanja o konstrukti. Tisti, ki so povezane s konstrukti.

1383
01:25:20,810 --> 01:25:25,270
>> Končno, GDB. Kaj GDB kaj si naredil? To vam omogoča, da debug vaš program.

1384
01:25:25,270 --> 01:25:27,650
In če niste uporabili GDB, jaz bi priporočil gledal kratek

1385
01:25:27,650 --> 01:25:31,250
in šele tekoč, kaj GDB je, kako delate z njim, kako bi ga uporabili,

1386
01:25:31,250 --> 01:25:32,900
in ga preizkusite na programu.

1387
01:25:32,900 --> 01:25:37,400
In kaj GDB lahko storite, je, da omogoča pavzo [nerazumljivo] do vašega programa

1388
01:25:37,400 --> 01:25:38,920
in praktično črta.

1389
01:25:38,920 --> 01:25:42,600
Na primer, želim izvedbo pavzo na liniji kot 3 svojega programa,

1390
01:25:42,600 --> 01:25:46,010
in medtem ko sem na liniji 3 lahko natisnete vse vrednote, ki so tam.

1391
01:25:46,010 --> 01:25:49,710
In tako pravimo, kot premori v skladu

1392
01:25:49,710 --> 01:25:52,350
se temu lahko rekli dajanje odmerka ob tej črti

1393
01:25:52,350 --> 01:25:55,920
in potem bomo lahko natisnete spremenljivk stanja programa v tistem času.

1394
01:25:55,920 --> 01:25:58,990
>> Mi lahko potem od tam korak skozi program line-by-line.

1395
01:25:58,990 --> 01:26:03,200
In potem bomo lahko ogledate na stanje dimnika v tistem času.

1396
01:26:03,200 --> 01:26:08,600
In tako, da se uporabi GDB, kar počnemo, je pravimo Jek na datoteko C,

1397
01:26:08,600 --> 01:26:11,290
vendar pa moramo dajati-ggdb zastavo.

1398
01:26:11,290 --> 01:26:15,850
In ko bomo končali s tem smo pravkar teče gdb ustvarjeno datoteko izhod.

1399
01:26:15,850 --> 01:26:18,810
In tako boste dobili nekaj podobnega maso besedila, kot je ta,

1400
01:26:18,810 --> 01:26:21,990
ampak res vse, kar morate storiti, je tip v poveljstvih na začetku.

1401
01:26:21,990 --> 01:26:24,250
Break glavni postavlja Prelomne na glavne.

1402
01:26:24,250 --> 01:26:28,470
Seznam navaja 400 vrstic kode, okoli vrstice 400.

1403
01:26:28,470 --> 01:26:31,410
In tako se v tem primeru lahko samo pogledajo okoli sebe in rekel, oh,

1404
01:26:31,410 --> 01:26:34,360
Želim, da nastavite prekinitveno točko na liniji 397, ki je v tej vrstici,

1405
01:26:34,360 --> 01:26:37,170
in potem je vaš program teče v ta korak in da se bo zlomil.

1406
01:26:37,170 --> 01:26:41,120
To se dogaja, da ustavite tam, in si lahko natisnete na primer vrednost nizka ali visoka.

1407
01:26:41,120 --> 01:26:46,410
In tako obstaja kup ukazov, kar morate vedeti,

1408
01:26:46,410 --> 01:26:48,660
in bo to slideshow šel na spletni strani,

1409
01:26:48,660 --> 01:26:54,000
tako da, če si želite referenčna ti je všeč ali pa jih postaviti na vaš goljufija stanja, vas prosimo.

1410
01:26:54,000 --> 01:27:00,650
>> Kul. To je bilo Kviz Pregled 0, in bomo ostal, če imate kakršnakoli vprašanja.

1411
01:27:00,650 --> 01:27:03,850
V redu.

1412
01:27:03,850 --> 01:27:09,030
>>  [Aplavz]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]