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

2
00:00:03,000 --> 00:00:05,000
>> [Lexi Ross, Tommy MacWilliam, Lucas Freitas, Joseph Ong] [Harvardi Ülikool]

3
00:00:05,000 --> 00:00:08,000
>> [See on CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Hei, kõik.

5
00:00:10,000 --> 00:00:15,000
Tere tulemast läbivaatamise istungil viktoriin 0, mis toimub sel kolmapäeval.

6
00:00:15,000 --> 00:00:19,000
Mida me teeme täna, ma olen koos 3 teise TFS,

7
00:00:19,000 --> 00:00:24,000
ja koos me läheme läbi vaadata, mida me teinud oleme muidugi siiani.

8
00:00:24,000 --> 00:00:27,000
Ta ei kavatse olla 100% kõikehõlmav, kuid see peaks andma teile parema ülevaate

9
00:00:27,000 --> 00:00:31,000
mida sa juba maha ja mida sa ikka pead õppima enne kolmapäeva.

10
00:00:31,000 --> 00:00:34,000
Ja julgelt tõstke käsi küsimusi kui me läheme mööda,

11
00:00:34,000 --> 00:00:38,000
kuid pidage meeles, et me ka natuke aega lõpus-

12
00:00:38,000 --> 00:00:41,000
kui saame läbi koos paar minutit vaba-teha üldisi küsimusi,

13
00:00:41,000 --> 00:00:47,000
nii et hoidke seda meeles, ja nii me kavatseme alustada algusest koos 0-nädalal.

14
00:00:47,000 --> 00:00:50,000
>> [Küsitlus 0 ülevaates!] [Osa 0] [Lexi Ross] Aga enne me seda räägime

15
00:00:50,000 --> 00:00:53,000
logistika viktoriini.

16
00:00:53,000 --> 00:00:55,000
>> [Logistika] [viktoriin toimub kolmapäeval 10/10 asemel loeng]

17
00:00:55,000 --> 00:00:57,000
>> [(Vt http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf üksikasjad)] See on kolmapäev, 10. oktoober.

18
00:00:57,000 --> 00:01:00,000
>> See on sel kolmapäeval, ja kui sa lähed sellele link siin

19
00:01:00,000 --> 00:01:03,000
mis on kättesaadavad ka CS50.net-seal lingi-

20
00:01:03,000 --> 00:01:06,000
näete infot, kuhu minna põhinevad

21
00:01:06,000 --> 00:01:10,000
Teie perekonnanimi või kooli kuuluvus samuti

22
00:01:10,000 --> 00:01:14,000
see räägib täpselt, mida tegema katab ja tüüpi küsimusi, et sa lähed, et saada.

23
00:01:14,000 --> 00:01:19,000
Pea meeles, et siis on teil ka võimalus kontrollida, et viktoriin punktis,

24
00:01:19,000 --> 00:01:21,000
nii oma TF peaks minema üle mõned praktikas probleeme,

25
00:01:21,000 --> 00:01:29,000
ja see on teine ​​hea võimalus näha, kui teil on vaja veel õppida tasa tegema.

26
00:01:29,000 --> 00:01:32,000
Alustame algusest koos Bits n Bytes.

27
00:01:32,000 --> 00:01:35,000
Pea meeles, natuke on vaid 0 või 1,

28
00:01:35,000 --> 00:01:38,000
ja bait on kogumik 8 need bitti.

29
00:01:38,000 --> 00:01:42,000
Vaatame selle kogumise bitti siin.

30
00:01:42,000 --> 00:01:44,000
Me peaksime suutma aru saada, mitu bitti on.

31
00:01:44,000 --> 00:01:48,000
Kui me loota seal on ainult 8 neist kaheksa 0 või 1 tk.

32
00:01:48,000 --> 00:01:51,000
Ja kuna seal on 8 bitti, mis on 1 bait,

33
00:01:51,000 --> 00:01:53,000
ja olgem teisendada see kuueteistkümnendsüsteemis.

34
00:01:53,000 --> 00:01:58,000
Hexadecimal on alus 16, ja see on üsna lihtne teisendada

35
00:01:58,000 --> 00:02:01,000
number binaarne, mis on see, mis see on, et number kuueteistkümnendsüsteemis.

36
00:02:01,000 --> 00:02:04,000
Kõik me teeme, on me vaatame rühmad 4,

37
00:02:04,000 --> 00:02:07,000
ja me teisendada need asjakohased kuueteistkümnendsüsteemis numbrit.

38
00:02:07,000 --> 00:02:11,000
Alustame kõige parempoolsem grupis on 4, nii et 0011.

39
00:02:11,000 --> 00:02:16,000
See saab olema üks 1 ja teine ​​2, seega kokku, et teeb 3.

40
00:02:16,000 --> 00:02:19,000
Ja siis vaatame teiste ploki 4.

41
00:02:19,000 --> 00:02:24,000
1101. See saab olema üks 1, üks 4 ja üks 8.

42
00:02:24,000 --> 00:02:28,000
Koos, et see saab olema 13, mis teeb D.

43
00:02:28,000 --> 00:02:32,000
Ja me meeles pidama, et kuueteistkümnendsüsteemis me lihtsalt ei lähe 0 kuni 9.

44
00:02:32,000 --> 00:02:36,000
Me läheme 0 kuni F, nii et pärast 9, 10 vastab,

45
00:02:36,000 --> 00:02:40,000
11 B, jne, kus F on 15.

46
00:02:40,000 --> 00:02:44,000
Siin 13 on D,

47
00:02:44,000 --> 00:02:49,000
nii teisendada see koma kõik me teeme, on meil tegelikult

48
00:02:49,000 --> 00:02:52,000
ravida iga positsiooni võimsus 2.

49
00:02:52,000 --> 00:02:58,000
See on üks 1, üks 2, null 4s, null 8s, üks 16, jne,

50
00:02:58,000 --> 00:03:03,000
ja see on natuke raske arvutada oma peaga, kuid kui me minna järgmisele slaidile

51
00:03:03,000 --> 00:03:05,000
näeme, et vastus sellele.

52
00:03:05,000 --> 00:03:09,000
>> Sisuliselt me ​​läheme üle paremalt tagasi vasakule,

53
00:03:09,000 --> 00:03:14,000
ja me korrutades iga numbri vastav võimsus 2.

54
00:03:14,000 --> 00:03:19,000
Ja pidage meeles, Heksadesimaaliarvon me tähistavad need numbrid 0x alguses

55
00:03:19,000 --> 00:03:23,000
nii et me ei segi ajada kümnendmurruna.

56
00:03:23,000 --> 00:03:29,000
Jätkub, see on ASCII tabelis,

57
00:03:29,000 --> 00:03:35,000
ja mida me kasutada ASCII jaoks on kaardistada alates märki arvväärtused.

58
00:03:35,000 --> 00:03:39,000
Pea meeles, et krüptograafia pset me ulatuslikult kasutatud ASCII tabel

59
00:03:39,000 --> 00:03:43,000
et kasutada erinevaid meetodeid krüptograafia,

60
00:03:43,000 --> 00:03:47,000
Caesar ja Vigenère salakiri, teisendada erinevaid tähti

61
00:03:47,000 --> 00:03:52,000
aastal stringi järgi võtme abil kasutaja.

62
00:03:52,000 --> 00:03:56,000
Vaatame natuke ASCII matemaatikat.

63
00:03:56,000 --> 00:04:02,000
Vaadates "P" + 1 iseloomuga vorm, mis oleks Q,

64
00:04:02,000 --> 00:04:07,000
ja pidage meeles, et '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
Ja kuidas täpselt oleks me teisendada nende vahel 2 vormi?

66
00:04:10,000 --> 00:04:13,000
See ei ole tegelikult liiga raske.

67
00:04:13,000 --> 00:04:16,000
Selleks, et saada 5 me lahutame '0 '

68
00:04:16,000 --> 00:04:20,000
sest seal on 5 kohta vahel '0 'ja '5. "

69
00:04:20,000 --> 00:04:23,000
Selleks, et minna teist teed me lihtsalt lisada 0,

70
00:04:23,000 --> 00:04:25,000
nii et see on omamoodi nagu tavalisi aritmeetika.

71
00:04:25,000 --> 00:04:29,000
Pea meeles, et kui midagi on jutumärgid see, et see on märk

72
00:04:29,000 --> 00:04:37,000
ja seega vastab väärtus ASCII tabelis.

73
00:04:37,000 --> 00:04:40,000
Liikumine üldisem infotehnoloogia teemadel.

74
00:04:40,000 --> 00:04:43,000
Me õppisime mida algoritm on ja kuidas me seda kasutame programmeerimine

75
00:04:43,000 --> 00:04:45,000
rakendada algoritme.

76
00:04:45,000 --> 00:04:48,000
Mõned näited algoritmid on midagi väga lihtsat nagu

77
00:04:48,000 --> 00:04:51,000
kontrollida, kas arv on paaris või paaritu.

78
00:04:51,000 --> 00:04:54,000
Sel mäleta me mod number 2 ja vaadata, kas tulemus on 0.

79
00:04:54,000 --> 00:04:57,000
Kui nii, siis on isegi. Kui ei, siis see on imelik.

80
00:04:57,000 --> 00:04:59,000
Ja see näide tegelikult põhilised algoritm.

81
00:04:59,000 --> 00:05:02,000
>> Natuke rohkem kaasatud üks on binaarne otsing,

82
00:05:02,000 --> 00:05:05,000
mis me minna üle hiljem läbivaatamise istungil.

83
00:05:05,000 --> 00:05:09,000
Ja programmeerimine on termin, mida me kasutame, võttes algoritm

84
00:05:09,000 --> 00:05:15,000
ning muutes selle koodi arvuti ei loe.

85
00:05:15,000 --> 00:05:20,000
2 näiteid programmeerimine on Scratch,

86
00:05:20,000 --> 00:05:22,000
mis on see, mida me tegime nädal 0.

87
00:05:22,000 --> 00:05:25,000
Isegi kui me tegelikult ei kirjuta välja koodi see on viis, kuidas rakendatakse

88
00:05:25,000 --> 00:05:29,000
Selle algoritmi, mis trükib numbrid 1-10,

89
00:05:29,000 --> 00:05:32,000
ja siin me teeme sama C-keeles.

90
00:05:32,000 --> 00:05:41,000
Need on funktsionaalselt võrdne, lihtsalt kirjutatud erinevates keeltes või süntaks.

91
00:05:41,000 --> 00:05:44,000
Siis õppinud boolean väljendeid,

92
00:05:44,000 --> 00:05:48,000
ja tõeväärtus on väärtus, mis on kas õige või vale,

93
00:05:48,000 --> 00:05:51,000
ja siin Sageli boolean väljendeid

94
00:05:51,000 --> 00:05:55,000
minna sees tingimused, nii et kui (x ≤ 5)

95
00:05:55,000 --> 00:06:00,000
noh, me juba x = 5, nii et tingimus läheb hindab true.

96
00:06:00,000 --> 00:06:03,000
Ja kui see on tõsi, mis iganes kood on all seisukorras

97
00:06:03,000 --> 00:06:08,000
läheb hindab arvuti, nii et nöör läheb trükitakse

98
00:06:08,000 --> 00:06:12,000
standardväljundisse, ja mõiste tingimus

99
00:06:12,000 --> 00:06:16,000
viitab iganes on sulgudesse, kui avalduses.

100
00:06:16,000 --> 00:06:20,000
Pea kõik ettevõtjad.

101
00:06:20,000 --> 00:06:26,000
Pea meeles, see on && ja | | kui me üritame ühendada 2 või rohkem tingimust,

102
00:06:26,000 --> 00:06:30,000
== Ei = et kontrollida, kas 2 asja on võrdsed.

103
00:06:30,000 --> 00:06:36,000
Pea meeles, et = on loovutamise arvestades == on tõeväärtus operaator.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ ja siis lõplik 2 on iseenesestmõistetavad.

105
00:06:41,000 --> 00:06:45,000
Üldkontrolli boolean loogika siin.

106
00:06:45,000 --> 00:06:48,000
Ja boolean väljendid on oluline ka silmad,

107
00:06:48,000 --> 00:06:50,000
mis me lähme nüüd möödas.

108
00:06:50,000 --> 00:06:56,000
Me õppinud 3 tüüpi ring seni CS50 jaoks, samal ajal, ja teha samal ajal.

109
00:06:56,000 --> 00:06:59,000
Ja see on oluline teada, et kui kõige eesmärkidel

110
00:06:59,000 --> 00:07:02,000
saame tegelikult kasutada mis tahes tüüpi silmus üldiselt

111
00:07:02,000 --> 00:07:06,000
on olemas teatud tüüpi eesmärkidel või ühiseid jooni

112
00:07:06,000 --> 00:07:09,000
programmeerimise, et nõuavad spetsiaalselt üks neist ring

113
00:07:09,000 --> 00:07:13,000
et muuta see kõige tõhusam või elegantne koodi see nii.

114
00:07:13,000 --> 00:07:18,000
Lähme üle, mida kõik need silmad kipub kasutatakse kõige sagedamini.

115
00:07:18,000 --> 00:07:21,000
>> Aastal jaoks silmus me üldiselt juba teame, mitu korda me tahame kinnitada,.

116
00:07:21,000 --> 00:07:24,000
See, mida me panna seisukorras.

117
00:07:24,000 --> 00:07:28,000
Sest, i = 0, i <10 näiteks.

118
00:07:28,000 --> 00:07:31,000
Teame juba, et me tahame teha midagi 10 korda.

119
00:07:31,000 --> 00:07:34,000
Nüüd, kui silmus, üldiselt me ​​ei pruugi

120
00:07:34,000 --> 00:07:36,000
tea, mitu korda me tahame silmus jooksma.

121
00:07:36,000 --> 00:07:39,000
Aga me teame mingi tingimus, et me tahame seda

122
00:07:39,000 --> 00:07:41,000
alati olla tõsi või alati olla vale.

123
00:07:41,000 --> 00:07:44,000
Näiteks kui on määratud.

124
00:07:44,000 --> 00:07:46,000
Oletame, et on tõeväärtus muutuja.

125
00:07:46,000 --> 00:07:48,000
Kuigi see on tõsi tahame kood hinnata,

126
00:07:48,000 --> 00:07:52,000
nii natuke rohkem laiendatav, natuke laiem kui loop,

127
00:07:52,000 --> 00:07:55,000
kuid igal jaoks silmus saab ka ümber samas silmus.

128
00:07:55,000 --> 00:08:00,000
Lõpuks ei samas silmuseid, mis võib olla trickiest aru kohe,

129
00:08:00,000 --> 00:08:04,000
kasutatakse sageli kui me tahame hinnata esimesena koodi

130
00:08:04,000 --> 00:08:06,000
Enne esimest korda me kontrollida seisukorda.

131
00:08:06,000 --> 00:08:09,000
Ühise kasutamise puhul teha samas loop

132
00:08:09,000 --> 00:08:12,000
on see, kui sa tahad saada kasutaja sisend, ja sa tead sa tahad paluda kasutajal

133
00:08:12,000 --> 00:08:15,000
sisend vähemalt üks kord, kuid kui nad ei anna teile hea sisend kohe

134
00:08:15,000 --> 00:08:18,000
mida soovite säilitada paludes neid, kuni nad annavad teile hea sisend.

135
00:08:18,000 --> 00:08:21,000
See on kõige levinum kasutada ei samas loop,

136
00:08:21,000 --> 00:08:23,000
ja vaatame tegelikku koostist need silmad.

137
00:08:23,000 --> 00:08:27,000
Nad on tavaliselt alati kipuvad järgima neid mudeleid.

138
00:08:27,000 --> 00:08:30,000
>> On jaoks silmus sees sul on 3 komponenti:

139
00:08:30,000 --> 00:08:35,000
käivitamise, tavaliselt midagi int i = 0, kui i on loendur,

140
00:08:35,000 --> 00:08:40,000
seisund, kus me tahame öelda saan selle eest silmuse nii kaua, kui see tingimus kuulub endiselt,

141
00:08:40,000 --> 00:08:44,000
nagu i <10, ja siis lõpuks, uuendus, mis on see, kuidas me juurdekasvu

142
00:08:44,000 --> 00:08:47,000
counter muutuja igas punktis silmus.

143
00:08:47,000 --> 00:08:50,000
Ühine asi näha on lihtsalt i + +,

144
00:08:50,000 --> 00:08:52,000
mis tähendab juurdekasvu i 1. iga kord.

145
00:08:52,000 --> 00:08:55,000
Sa võiksid ka midagi sellist i + = 2,

146
00:08:55,000 --> 00:08:58,000
mis tähendab, lisage 2 kuni i iga kord, kui minna läbi silmuse.

147
00:08:58,000 --> 00:09:03,000
Ja siis tee seda lihtsalt viitab mingi koodi, mis tegelikult töötab osana silmus.

148
00:09:03,000 --> 00:09:09,000
Ja samas silmus, seekord me tegelikult initsialiseerimise väljaspool loop,

149
00:09:09,000 --> 00:09:12,000
Nii näiteks, oletame, et me üritame teha sama tüüpi loop nagu ma just kirjeldasin.

150
00:09:12,000 --> 00:09:16,000
Meil oleks öelda int i = 0 enne silmus hakkab.

151
00:09:16,000 --> 00:09:20,000
Siis võiks öelda, et kui ma <10 tee seda,

152
00:09:20,000 --> 00:09:22,000
nii sama ploki koodi nagu enne,

153
00:09:22,000 --> 00:09:26,000
ja seekord uuendatud osa kood, näiteks i + +,

154
00:09:26,000 --> 00:09:29,000
tegelikult läheb sees silmus.

155
00:09:29,000 --> 00:09:33,000
Ja lõpuks ka teha, samas on see sarnane samas loop,

156
00:09:33,000 --> 00:09:36,000
kuid me peame meeles pidama, et kood hindab kord

157
00:09:36,000 --> 00:09:40,000
enne nõuet kontrollitakse, et ta teeb palju mõttekam

158
00:09:40,000 --> 00:09:44,000
kui te vaatate seda järjekorras ülevalt alla.

159
00:09:44,000 --> 00:09:49,000
Aastal teha samas loop koodi hindab enne kui isegi vaadata samas seisukorras,

160
00:09:49,000 --> 00:09:55,000
arvestades samas loop, siis kontrolli kõigepealt.

161
00:09:55,000 --> 00:09:59,000
Avaldused ja muutujad.

162
00:09:59,000 --> 00:10:04,000
Kui me tahame luua uue muutuja me esimest soovid vormindada see.

163
00:10:04,000 --> 00:10:07,000
>> Näiteks int baar käivitab muutuja baar,

164
00:10:07,000 --> 00:10:10,000
kuid see ei anna talle raha, siis millised on baar väärtus nüüd?

165
00:10:10,000 --> 00:10:12,000
Me ei tea.

166
00:10:12,000 --> 00:10:14,000
See võiks olla mingi prügi raha, mis varem salvestatud mälu seal,

167
00:10:14,000 --> 00:10:16,000
ja me ei taha seda kasutada muutuja

168
00:10:16,000 --> 00:10:19,000
kuni me tegelikult annab see väärtus,

169
00:10:19,000 --> 00:10:21,000
nii me kuulutada see siin.

170
00:10:21,000 --> 00:10:24,000
Siis me initsialiseerida see olema 42 allpool.

171
00:10:24,000 --> 00:10:28,000
Nüüd, muidugi, me teame seda saab teha ühel real, int baar = 42.

172
00:10:28,000 --> 00:10:30,000
Aga et asi selge oleks mitu sammu, mis toimub,

173
00:10:30,000 --> 00:10:34,000
deklaratsiooni ja initsialiseerimise toimuvad eraldi siin.

174
00:10:34,000 --> 00:10:38,000
See juhtub üks samm, ja järgmise, int Baz = baar + 1,

175
00:10:38,000 --> 00:10:44,000
Selle alljärgnev kinnitus, et kaupa Baz, nii lõpus see koodiestossa

176
00:10:44,000 --> 00:10:48,000
kui me printida väärtus Baz oleks 44

177
00:10:48,000 --> 00:10:52,000
sest me kuulutame ja initsialiseerida see olema 1> baar,

178
00:10:52,000 --> 00:10:58,000
ja siis me juurdekasvu see veelkord + +.

179
00:10:58,000 --> 00:11:02,000
Käisime üle see päris lühidalt, aga see on hea, et on üldine

180
00:11:02,000 --> 00:11:04,000
mõista, mida niidid ja üritused.

181
00:11:04,000 --> 00:11:06,000
Meil peamiselt tegid seda Scratch,

182
00:11:06,000 --> 00:11:09,000
nii saab mõelda niidid mitu järjestused kood

183
00:11:09,000 --> 00:11:11,000
töötab samal ajal.

184
00:11:11,000 --> 00:11:14,000
Tegelikkuses see ilmselt ei tööta samal ajal,

185
00:11:14,000 --> 00:11:17,000
kuid omamoodi abstraktselt me ​​ei mõtle seda nii.

186
00:11:17,000 --> 00:11:20,000
>> Scratch, näiteks oli meil mitu haldjaid.

187
00:11:20,000 --> 00:11:22,000
Võiks täidesaatva erinevat koodi samal ajal.

188
00:11:22,000 --> 00:11:26,000
Võiks olla kõndides samal ajal kui teine ​​ütleb midagi

189
00:11:26,000 --> 00:11:29,000
teises osa ekraanist.

190
00:11:29,000 --> 00:11:34,000
Üritused on teine ​​viis eraldi välja loogika

191
00:11:34,000 --> 00:11:37,000
erinevate elementide oma koodi,

192
00:11:37,000 --> 00:11:40,000
ja Scratch suutsime simuleerida ürituste abil ülekanne,

193
00:11:40,000 --> 00:11:43,000
ja mis on tegelikult, kui saan, ei, kui kuulen,

194
00:11:43,000 --> 00:11:47,000
kuid sisuliselt on see võimalus edastada teavet

195
00:11:47,000 --> 00:11:49,000
ühest sprite teise.

196
00:11:49,000 --> 00:11:52,000
Näiteks võiksite edastada mängu üle,

197
00:11:52,000 --> 00:11:56,000
ja kui teise sprite saab mäng läbi,

198
00:11:56,000 --> 00:11:58,000
see reageerib teatud viisil.

199
00:11:58,000 --> 00:12:03,000
See on oluline mudeli mõista programmeerimisega.

200
00:12:03,000 --> 00:12:07,000
Lihtsalt minna üle põhilised Nädal 0, me oleme läinud üle siiani,

201
00:12:07,000 --> 00:12:10,000
Vaatame seda lihtsat C programm.

202
00:12:10,000 --> 00:12:14,000
Tekst võib olla natuke väike siit, kuid ma lähen üle ka kähku.

203
00:12:14,000 --> 00:12:20,000
Me sh 2 päisefaile ülaosas, cs50.h ja stdio.h.

204
00:12:20,000 --> 00:12:23,000
Me siis määratakse konstant nimega piir olema 100.

205
00:12:23,000 --> 00:12:26,000
Me seejärel rakendades meie peamine ülesanne.

206
00:12:26,000 --> 00:12:29,000
Kuna me ei kasuta käsurea argumente siin peame panema tühine

207
00:12:29,000 --> 00:12:32,000
kui argumente peamine.

208
00:12:32,000 --> 00:12:38,000
Me näeme int eespool peamine. See on naasmise tüüp, seega return 0 allosas.

209
00:12:38,000 --> 00:12:41,000
Ja me kasutame CS50 raamatukogu funktsiooni saada int

210
00:12:41,000 --> 00:12:45,000
küsida kasutaja sisend, ja me seda säilitada seda muutujat x,

211
00:12:45,000 --> 00:12:51,000
nii me kuulutame x eespool, ja me algväärtustamiseks x = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> Siis vaadata, kui kasutaja andis meile hea sisend.

213
00:12:53,000 --> 00:12:59,000
Kui see on ≥ piirväärtus tahame tagasi veakood 1 ja veateadet.

214
00:12:59,000 --> 00:13:02,000
Ja lõpuks, kui kasutaja on andnud meile hea sisend

215
00:13:02,000 --> 00:13:08,000
me lähme ruutu arvu ja välja trükkida, et tulemus.

216
00:13:08,000 --> 00:13:11,000
Lihtsalt veenduge, et need kõik hit kodu

217
00:13:11,000 --> 00:13:17,000
näete siltide eri osade koodi siin.

218
00:13:17,000 --> 00:13:19,000
Mainisin pidev, päisefaile.

219
00:13:19,000 --> 00:13:21,000
Oh, int x. Veenduge meeles pidada, et on kohalik muutuja.

220
00:13:21,000 --> 00:13:24,000
See vastandub see globaalne muutuja, mida me räägime

221
00:13:24,000 --> 00:13:27,000
natuke hiljem läbivaatamine istungil

222
00:13:27,000 --> 00:13:30,000
ja kutsume raamatukogu funktsiooni printf,

223
00:13:30,000 --> 00:13:34,000
nii et kui me ei lisanud stdio.h päisefail

224
00:13:34,000 --> 00:13:37,000
me ei saaks helistada printf.

225
00:13:37,000 --> 00:13:42,000
Ja ma usun, nool, et sai ära lõigatud siin on suunaga% d,

226
00:13:42,000 --> 00:13:45,000
mis on vormingu stringi printf.

227
00:13:45,000 --> 00:13:52,000
Ta ütleb välja printida see muutuv number,% d.

228
00:13:52,000 --> 00:13:58,000
Ja see on see 0-nädalal.

229
00:13:58,000 --> 00:14:06,000
Nüüd Lucas läheb jätkuvalt.

230
00:14:06,000 --> 00:14:08,000
Hei, kutid. Minu nimi on Lucas.

231
00:14:08,000 --> 00:14:10,000
Ma olen üliõpilane parimal maja loengusse, Mather,

232
00:14:10,000 --> 00:14:14,000
ja ma lähen rääkida natuke umbes nädal 1 ja 2.1.

233
00:14:14,000 --> 00:14:16,000
[Nädal 1 ja 2.1!] [Lucas Freitas]

234
00:14:16,000 --> 00:14:19,000
Nagu Lexi ütlesin, kui me hakkasime tõlkides oma koodi nullist C

235
00:14:19,000 --> 00:14:23,000
Üks asi, mida me märganud, et sa ei saa lihtsalt

236
00:14:23,000 --> 00:14:26,000
kirjutada oma koodi ja kasutada seda kasutades roheline lipp enam.

237
00:14:26,000 --> 00:14:30,000
Tegelikult on teil kasutada mõningaid samme, et muuta oma C programmi

238
00:14:30,000 --> 00:14:33,000
saada käivitatava faili.

239
00:14:33,000 --> 00:14:36,000
Põhimõtteliselt, mida te teete, kui olete kirjalikult programm on, et

240
00:14:36,000 --> 00:14:40,000
teil tõlkida oma ideed keeles kompilaator aru saavad,

241
00:14:40,000 --> 00:14:44,000
Nii et kui olete kirjalikult programmi C

242
00:14:44,000 --> 00:14:47,000
mida sa teed on tegelikult kirjalikult midagi, et teie kompilaatori hakkab aru saama,

243
00:14:47,000 --> 00:14:50,000
ja siis kompilaator saab tõlkida, et kood

244
00:14:50,000 --> 00:14:53,000
millekski, mida arvuti saab aru.

245
00:14:53,000 --> 00:14:55,000
>> Ja asi on, arvuti on tegelikult väga loll.

246
00:14:55,000 --> 00:14:57,000
Arvuti saab aru ainult 0. ja 1s,

247
00:14:57,000 --> 00:15:01,000
nii tegelikult esimeses arvutid inimesed tavaliselt programmeeritud

248
00:15:01,000 --> 00:15:04,000
kasutades 0. ja 1s, kuid mitte enam, jumal tänatud.

249
00:15:04,000 --> 00:15:07,000
Meil ei ole vaja meeles järjestused 0. ja 1s

250
00:15:07,000 --> 00:15:10,000
jaoks jaoks silmus või samas loop ja nii edasi.

251
00:15:10,000 --> 00:15:13,000
Sellepärast on meil kompilaator.

252
00:15:13,000 --> 00:15:17,000
Mis kompilaator ei ole see sisuliselt tähendab C-koodi,

253
00:15:17,000 --> 00:15:21,000
meie puhul on keel, et arvuti aru,

254
00:15:21,000 --> 00:15:25,000
mis on objekti kood, ja kompilaator, mida me kasutame

255
00:15:25,000 --> 00:15:30,000
nimetatakse rõkkama, et see on tegelikult sümbol rõkkama.

256
00:15:30,000 --> 00:15:33,000
Kui olete oma programmi, mida sa pead tegema 2 asja.

257
00:15:33,000 --> 00:15:37,000
Esiteks, sa pead koguma oma programmi, ja siis sa lähed sõitma oma programmi.

258
00:15:37,000 --> 00:15:41,000
Kompileerida programm teil on palju võimalusi seda teha.

259
00:15:41,000 --> 00:15:44,000
Esimene neist on teha rõkkama program.c

260
00:15:44,000 --> 00:15:47,000
kus programm on oma programmi nime.

261
00:15:47,000 --> 00:15:51,000
Sel juhul näete nad lihtsalt öeldes: "Hei, koostada oma tööprogrammi."

262
00:15:51,000 --> 00:15:56,000
Sa ei ütle "ma tahan seda nime minu programm" või midagi.

263
00:15:56,000 --> 00:15:58,000
>> Teine võimalus on anda nime oma programmi.

264
00:15:58,000 --> 00:16:02,000
Võite öelda rõkkama-o ja siis nimi, mida soovite

265
00:16:02,000 --> 00:16:06,000
käivitatava faili nimeks ja siis program.c.

266
00:16:06,000 --> 00:16:11,000
Ja saate ka teha teha programm, ja näha, kuidas esimesel 2 juhtumit

267
00:16:11,000 --> 00:16:15,000
Panin. C ja kolmas mul on ainult programme?

268
00:16:15,000 --> 00:16:18,000
Jah, sa tegelikult ei tohiks panna. C, kui te kasutate teha.

269
00:16:18,000 --> 00:16:22,000
Vastasel koostaja on tegelikult läheb kisa sind.

270
00:16:22,000 --> 00:16:24,000
Ja ka, ma ei tea kas te mäletate,

271
00:16:24,000 --> 00:16:29,000
kuid palju kordi me ka kasutatud-lcs50 või-lm.

272
00:16:29,000 --> 00:16:31,000
Seda nimetatakse siduda.

273
00:16:31,000 --> 00:16:35,000
See lihtsalt ütleb kompilaator, et te kasutate neid raamatukogudes seal,

274
00:16:35,000 --> 00:16:39,000
nii et kui soovite kasutada cs50.h sa tegelikult pead kirjutama

275
00:16:39,000 --> 00:16:43,000
rõkkama program.c-lcs50.

276
00:16:43,000 --> 00:16:45,000
Kui te ei tee seda, tõlkija ei kavatse teada

277
00:16:45,000 --> 00:16:50,000
et te kasutate neid funktsioone cs50.h.

278
00:16:50,000 --> 00:16:52,000
Ja kui soovite käivitada oma programmi teil on 2 võimalust.

279
00:16:52,000 --> 00:16:57,000
Kui sa ei rõkkama program.c te ei andnud nime oma programmi.

280
00:16:57,000 --> 00:17:01,000
Sa pead käivitada kasutades. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out on standard nime rõkkama annab oma programmi, kui sa ei anna talle nimi.

282
00:17:06,000 --> 00:17:11,000
Muidu sa lähed tegema. / Programm, kui sa andsid nime oma programmi,

283
00:17:11,000 --> 00:17:15,000
ja ka siis kui sa ei tee programmi nimi, et programm ei hakka

284
00:17:15,000 --> 00:17:23,000
juba läheb programmeerida sama nimega c fail.

285
00:17:23,000 --> 00:17:26,000
Siis me rääkisime andmetüübid ja andmed.

286
00:17:26,000 --> 00:17:31,000
>> Põhimõtteliselt andmetüübid on sama asi nagu kastikesed nad kasutavad

287
00:17:31,000 --> 00:17:35,000
salvestada väärtusi, nii andmetüübid on tegelikult nagu pokemons.

288
00:17:35,000 --> 00:17:39,000
Nad tulevad kõik suurused ja tüübid.

289
00:17:39,000 --> 00:17:43,000
Ma ei tea, kas see analoogia on mõtet.

290
00:17:43,000 --> 00:17:46,000
Andmete suurus tegelikult sõltub masina arhitektuuri.

291
00:17:46,000 --> 00:17:49,000
Kõik andmed suurused, et ma lähen näitan siin

292
00:17:49,000 --> 00:17:53,000
on tegelikult 32-bit masin, mis on nii meie seade,

293
00:17:53,000 --> 00:17:56,000
aga kui sul on tegelikult kodeerimine Mac või Windows ka

294
00:17:56,000 --> 00:17:59,000
ilmselt sa lähed on 64-bitine masin,

295
00:17:59,000 --> 00:18:03,000
nii et pea meeles, et andmed suurused, et ma lähen näitan siin

296
00:18:03,000 --> 00:18:06,000
on mõeldud 32-bit masin.

297
00:18:06,000 --> 00:18:08,000
Esimene, mida me nägime oli keskmine,

298
00:18:08,000 --> 00:18:10,000
mis on üsna lihtne.

299
00:18:10,000 --> 00:18:13,000
Sa kasutad int salvestada täisarv.

300
00:18:13,000 --> 00:18:16,000
Me nägime ka iseloomu, char.

301
00:18:16,000 --> 00:18:20,000
Kui soovite kasutada kirja või vähe sümbol oled ilmselt ei kavatse kasutada char.

302
00:18:20,000 --> 00:18:26,000
Char on 1 bait, mis tähendab 8 bitti, nagu Lexi ütles.

303
00:18:26,000 --> 00:18:31,000
Põhimõtteliselt on meil ASCII tabel, mis on 256

304
00:18:31,000 --> 00:18:34,000
võimalikke kombinatsioone 0. ja 1s,

305
00:18:34,000 --> 00:18:37,000
ja siis kui kirjutad char see saab tõlkida

306
00:18:37,000 --> 00:18:44,000
märk, et sisendite te arv, et teil on ASCII tabelis, nagu Lexi ütles.

307
00:18:44,000 --> 00:18:48,000
Meil on ka ujuki, mida me kasutame, et salvestada kümnendkraadides.

308
00:18:48,000 --> 00:18:53,000
Kui soovite valida 3.14, näiteks, sa lähed kasutada float

309
00:18:53,000 --> 00:18:55,000
või topelt, mis on rohkem täpsust.

310
00:18:55,000 --> 00:18:57,000
Ujuk on 4 baiti.

311
00:18:57,000 --> 00:19:01,000
Topelt on 8 baiti, seega ainus erinevus on täpsus.

312
00:19:01,000 --> 00:19:04,000
Meil on ka pikk, et kasutatakse täisarvud,

313
00:19:04,000 --> 00:19:09,000
ja näete 32-bit masin int ja pikk olema sama suurusega,

314
00:19:09,000 --> 00:19:13,000
nii see ei ole tõesti mõtet kasutada pika 32-bit masin.

315
00:19:13,000 --> 00:19:17,000
>> Aga kui te kasutate Mac ja 64-bit masin, tegelikult pikk on suurus 8,

316
00:19:17,000 --> 00:19:19,000
nii see tõesti sõltub arhitektuur.

317
00:19:19,000 --> 00:19:22,000
Sest 32-bit masin see ei ole mõtet kasutada pika tõesti.

318
00:19:22,000 --> 00:19:25,000
Ja siis pikk pikk, teiselt poolt, on 8 baiti,

319
00:19:25,000 --> 00:19:30,000
nii et see on väga hea, kui sa tahad olla enam täisarv.

320
00:19:30,000 --> 00:19:34,000
Ja lõpuks on meil string, mis on tegelikult char *,

321
00:19:34,000 --> 00:19:37,000
mis on viit char.

322
00:19:37,000 --> 00:19:40,000
See on väga lihtne mõelda, et suurus string saab olema nagu

323
00:19:40,000 --> 00:19:42,000
arvu märke, et teil on seal,

324
00:19:42,000 --> 00:19:45,000
kuid tegelikult char * ise

325
00:19:45,000 --> 00:19:49,000
on suurus kursor char, mis on 4 baiti.

326
00:19:49,000 --> 00:19:52,000
Suurus char * on 4 baiti.

327
00:19:52,000 --> 00:19:56,000
Ei ole oluline, kui teil on väike sõna või kirja või midagi.

328
00:19:56,000 --> 00:19:58,000
See saab olema 4 baiti.

329
00:19:58,000 --> 00:20:01,000
Samuti oleme õppinud natuke valu,

330
00:20:01,000 --> 00:20:04,000
nii nagu näete, kui teil on näiteks programm, mis ütleb,

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

332
00:20:08,000 --> 00:20:12,000
Kas te teate, mida see saab printida ekraanil?

333
00:20:12,000 --> 00:20:14,000
>> Keegi? >> [Õpilased] 2.

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

335
00:20:16,000 --> 00:20:20,000
Kui te seda teete 02/03 see läheb aina 1.5

336
00:20:20,000 --> 00:20:24,000
aga kuna me kasutame täisarv see läheb mööda komakohti,

337
00:20:24,000 --> 00:20:26,000
ja sa lähed on 1.

338
00:20:26,000 --> 00:20:29,000
Kui te ei taha, et juhtuma, mida saate teha, näiteks

339
00:20:29,000 --> 00:20:33,000
on kuulutada float y = x.

340
00:20:33,000 --> 00:20:40,000
Siis x, mis varem 3 nüüd saab olema 3,000 y.

341
00:20:40,000 --> 00:20:44,000
Ja siis saate printida y / 2.

342
00:20:44,000 --> 00:20:50,000
Tegelikult, ma peaks olema 2. seal.

343
00:20:50,000 --> 00:20:55,000
See saab teha 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
ja sa lähed, et saada 1.5.

345
00:20:58,000 --> 00:21:06,000
Ja meil on see .2 f lihtsalt küsida 2 kohta pärast üksuste komakohti.

346
00:21:06,000 --> 00:21:12,000
Kui teil on .3 f see saab olema tegelikult 1,500.

347
00:21:12,000 --> 00:21:16,000
Kui see on 2 see saab olema 1.50.

348
00:21:16,000 --> 00:21:18,000
Meil on ka antud juhul siin.

349
00:21:18,000 --> 00:21:22,000
Kui sa float x = 3.14 ja siis printf x

350
00:21:22,000 --> 00:21:24,000
sa lähed, et saada 3.14.

351
00:21:24,000 --> 00:21:29,000
Ja kui sa x = int x,

352
00:21:29,000 --> 00:21:34,000
mis tähendab raviks x kui int ja printida x nüüd

353
00:21:34,000 --> 00:21:36,000
sa lähed on 3.00.

354
00:21:36,000 --> 00:21:38,000
Kas see on loogiline?

355
00:21:38,000 --> 00:21:41,000
Sest sa kõigepealt puhastada x on täisarv, nii olete ignoreerides komakohti,

356
00:21:41,000 --> 00:21:45,000
ja siis te prindite x.

357
00:21:45,000 --> 00:21:47,000
Ja lõpuks, saate ka seda teha,

358
00:21:47,000 --> 00:21:52,000
int x = 65 ja siis kuulutada char c = x,

359
00:21:52,000 --> 00:21:56,000
ja siis, kui prindite c sa tegelikult hakka

360
00:21:56,000 --> 00:21:59,000
, Nii et põhimõtteliselt mida sa teed siin

361
00:21:59,000 --> 00:22:02,000
tõlgib täisarv sisse iseloomu,

362
00:22:02,000 --> 00:22:05,000
nagu ASCII tabel teeb.

363
00:22:05,000 --> 00:22:08,000
Rääkisime veel matemaatika ettevõtjad.

364
00:22:08,000 --> 00:22:14,000
Enamik neist on üsna lihtne, nii +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
ja ka me rääkisime mod, mis on ülejäänud jaotus 2 numbrit.

366
00:22:20,000 --> 00:22:23,000
Kui sul on 10% 3 näiteks

367
00:22:23,000 --> 00:22:27,000
see tähendab, jagage: 10 3, ja mis on ülejäänud?

368
00:22:27,000 --> 00:22:30,000
See saab olema 1, nii et see on tegelikult väga kasulik palju programme.

369
00:22:30,000 --> 00:22:38,000
Sest Vigenère ja Caesar Ma olen päris kindel, et kõik kutid kasutada mod.

370
00:22:38,000 --> 00:22:43,000
Umbes matemaatika ettevõtjad, olema väga ettevaatlik, kui kombineerida * ja /.

371
00:22:43,000 --> 00:22:48,000
>> Näiteks, kui sul (3/2) * 2 Mida sa hakka?

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

373
00:22:50,000 --> 00:22:54,000
Jah, 2, sest 02/03 saab olema 1.5,

374
00:22:54,000 --> 00:22:57,000
aga kuna sa teed operatsioonide vahel 2 täisarvud

375
00:22:57,000 --> 00:22:59,000
sa oled tegelikult lihtsalt läheb kaaluda 1

376
00:22:59,000 --> 00:23:03,000
ja siis 1 * 2 saab olema 2, et olla väga ettevaatlik

377
00:23:03,000 --> 00:23:07,000
kui teed aritmeetiline täisarvud, sest

378
00:23:07,000 --> 00:23:12,000
võite saada, et 2 = 3, sel juhul.

379
00:23:12,000 --> 00:23:14,000
Ja ka olema väga ettevaatlik tähtsam.

380
00:23:14,000 --> 00:23:21,000
Sa peaksid tavaliselt kasutada sulge, et olla kindel, et sa tead, mida sa teed.

381
00:23:21,000 --> 00:23:27,000
Mõned kasulikud otseteed, muidugi, üks on i + + või i + = 1

382
00:23:27,000 --> 00:23:30,000
või kasutades + =.

383
00:23:30,000 --> 00:23:34,000
See on sama asi nagu teeme i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Võite teha ka i - või I - = 1,

385
00:23:39,000 --> 00:23:42,000
mis on sama asi nagu ma = i -1,

386
00:23:42,000 --> 00:23:46,000
midagi, mida poisid kasutavad palju eest silmuseid, vähemalt.

387
00:23:46,000 --> 00:23:52,000
Samuti jaoks *, kui te kasutate * = ja kui te seda teete, näiteks

388
00:23:52,000 --> 00:23:57,000
i * = 2 on sama asi nagu öeldes i = i * 2,

389
00:23:57,000 --> 00:23:59,000
ja sama asja rajoon.

390
00:23:59,000 --> 00:24:08,000
Kui te seda teete i / = 2 see on sama asi nagu ma = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Nüüd umbes funktsioone.

392
00:24:10,000 --> 00:24:13,000
Te teada, et funktsioonid on väga hea strateegia säästa kood

393
00:24:13,000 --> 00:24:16,000
kui oled programmeerimine, nii et kui sa tahad seda ülesannet täita

394
00:24:16,000 --> 00:24:20,000
aastal kood uuesti ja uuesti, ilmselt soovite kasutada funktsiooni

395
00:24:20,000 --> 00:24:25,000
lihtsalt, et sa ei pea kopeeri ja kleebi kood ikka ja jälle.

396
00:24:25,000 --> 00:24:28,000
Tegelikult peamine on funktsioon, ja kui ma näitan sulle vormi funktsioon

397
00:24:28,000 --> 00:24:32,000
sa lähed, et näha, et see on päris selge.

398
00:24:32,000 --> 00:24:35,000
Samuti kasutame funktsioone mõned raamatukogud,

399
00:24:35,000 --> 00:24:39,000
näiteks printf, Getin, mis on pärit CS50 raamatukogu,

400
00:24:39,000 --> 00:24:43,000
ja muid funktsioone nagu toupper.

401
00:24:43,000 --> 00:24:46,000
Kõik need funktsioonid on tegelikult rakendatakse teiste raamatukogude,

402
00:24:46,000 --> 00:24:49,000
ja kui paned need lõastama faili alguses oma programmi

403
00:24:49,000 --> 00:24:53,000
sa räägid kas te saaksite mulle anda kood neid funktsioone

404
00:24:53,000 --> 00:24:57,000
nii et ma ei pea neid rakendama ise?

405
00:24:57,000 --> 00:25:00,000
Ja sa võid ka kirjutada oma funktsioone, nii et kui hakkate programmi

406
00:25:00,000 --> 00:25:04,000
sa mõistad, et raamatukogud ei ole kõiki funktsioone, mida vajate.

407
00:25:04,000 --> 00:25:10,000
Viimase pset, näiteks me kirjutas joonistada, rüselus ja lookup,

408
00:25:10,000 --> 00:25:13,000
ja see on väga oluline, et oleks võimalik kirjutada funktsioone

409
00:25:13,000 --> 00:25:17,000
sest nad on kasulikud, ja me kasutame neid kogu aeg programmeerimine,

410
00:25:17,000 --> 00:25:19,000
ja see säästab palju koodi.

411
00:25:19,000 --> 00:25:21,000
Vormi funktsioon on see üks.

412
00:25:21,000 --> 00:25:24,000
Meil on naasmise tüüp alguses. Mis on naasmise tüüp?

413
00:25:24,000 --> 00:25:27,000
See on lihtsalt, kui teie ülesanne läheb tagasi.

414
00:25:27,000 --> 00:25:29,000
Kui teil on funktsioon, näiteks faktoriaali,

415
00:25:29,000 --> 00:25:31,000
et läheb arvutada faktoriaali täisarv,

416
00:25:31,000 --> 00:25:34,000
ilmselt see läheb tagasi täisarv ka.

417
00:25:34,000 --> 00:25:37,000
Siis tagastab tüüp saab olema int.

418
00:25:37,000 --> 00:25:41,000
Printf tegelikult on tagasipöördumise tüüp tühine

419
00:25:41,000 --> 00:25:43,000
sest sa ei tule midagi.

420
00:25:43,000 --> 00:25:45,000
Sa lihtsalt printida asju ekraanil

421
00:25:45,000 --> 00:25:48,000
ja suitsetamisest funktsioon hiljem.

422
00:25:48,000 --> 00:25:51,000
Siis on funktsiooni nimi, mida saab valida.

423
00:25:51,000 --> 00:25:55,000
Sa peaksid olema vähe põhjendatud, nagu ei vali nime nagu xyz

424
00:25:55,000 --> 00:25:58,000
või nagu x2f.

425
00:25:58,000 --> 00:26:02,000
Proovige teha kuni nimi see on mõistlik.

426
00:26:02,000 --> 00:26:04,000
>> Näiteks, kui see on faktoriaal, ütleme faktoriaal.

427
00:26:04,000 --> 00:26:08,000
Kui see funktsioon, et saab teha midagi, name it juhtida.

428
00:26:08,000 --> 00:26:11,000
Ja siis on meil parameetrid, mida nimetatakse ka argumendid,

429
00:26:11,000 --> 00:26:14,000
mis on nagu vahendeid, et oma ülesannet vaja

430
00:26:14,000 --> 00:26:17,000
oma koodi ülesannet täita.

431
00:26:17,000 --> 00:26:20,000
Kui soovite arvutada faktoriaali arv

432
00:26:20,000 --> 00:26:23,000
Ilmselt peate arvu arvutada faktoriaali.

433
00:26:23,000 --> 00:26:27,000
Üks argument, et sa lähed on on arv ise.

434
00:26:27,000 --> 00:26:31,000
Ja siis see läheb midagi ja tagastab väärtuse lõpus

435
00:26:31,000 --> 00:26:35,000
kui see on tühine funktsioon.

436
00:26:35,000 --> 00:26:37,000
Vaatame näiteks.

437
00:26:37,000 --> 00:26:40,000
Kui ma tahan kirjutada funktsioon, mis võtab kõik numbrid array täisarvud,

438
00:26:40,000 --> 00:26:43,000
kõigepealt tagasi tüüp saab olema int

439
00:26:43,000 --> 00:26:46,000
sest mul on array täisarvud.

440
00:26:46,000 --> 00:26:51,000
Ja siis ma lähen on funktsiooni nimi nagu sumArray,

441
00:26:51,000 --> 00:26:54,000
ja siis ta vőtab massiiv ise, et int nums,

442
00:26:54,000 --> 00:26:58,000
ja siis pikkus array nii et ma tean, mitu numbrit mul summeerida.

443
00:26:58,000 --> 00:27:02,000
Siis on mul initsialiseerida muutuja nimega summa, näiteks 0,

444
00:27:02,000 --> 00:27:08,000
ja iga kord kui ma näen element massiivi Pean lisama, et see summa, nii et ma tegin jaoks silmus.

445
00:27:08,000 --> 00:27:15,000
Just nagu Lexi ütles, sa int i = 0, i <pikkuse ja i + +.

446
00:27:15,000 --> 00:27:20,000
Ja iga element massiivi tegin summa + = nums [i]

447
00:27:20,000 --> 00:27:24,000
ja siis ma tagasi summa, nii et see on väga lihtne, ja see säästab palju koodi

448
00:27:24,000 --> 00:27:28,000
kui te kasutate seda funktsiooni palju kordi.

449
00:27:28,000 --> 00:27:32,000
Siis võtsin pilk tingimused.

450
00:27:32,000 --> 00:27:38,000
Meil on, kui teine, ja teine, kui.

451
00:27:38,000 --> 00:27:42,000
Vaatame, milline on erinevus nende vahel.

452
00:27:42,000 --> 00:27:45,000
Heitke pilk nende 2-koodid. Mis on erinevus nende vahel?

453
00:27:45,000 --> 00:27:49,000
Esimene on-põhiliselt koodid tahad sa öelda

454
00:27:49,000 --> 00:27:51,000
kui number on +, -, või 0.

455
00:27:51,000 --> 00:27:55,000
Esimene ütleb, kas see on> 0, siis on see positiivne.

456
00:27:55,000 --> 00:28:00,000
Kui see on = 0, siis on see 0, ja kui see on <0, siis see on negatiivne.

457
00:28:00,000 --> 00:28:04,000
>> Ja teine ​​teeb kui teine, kui teine.

458
00:28:04,000 --> 00:28:07,000
Erinevus nende kahe vahel on, et see on tegelikult läheb

459
00:28:07,000 --> 00:28:13,000
kontrollida, kas> 0, <0 või = 0 kolm korda,

460
00:28:13,000 --> 00:28:17,000
nii et kui sul on number 2 näiteks, siis läheb siia tulla ja öelda

461
00:28:17,000 --> 00:28:21,000
if (x> 0), ja see saab öelda jah, et ma printida positiivne.

462
00:28:21,000 --> 00:28:25,000
Aga kuigi ma tean, et see on> 0 ja see ei kavatse olla 0 või <0

463
00:28:25,000 --> 00:28:29,000
Ma lähen ikkagi teha, on see 0, see on <0,

464
00:28:29,000 --> 00:28:33,000
nii et ma olen tegelikult läheb sees IFS, et ma ei pea

465
00:28:33,000 --> 00:28:38,000
sest ma juba tean, et ta ei kavatse täita mis tahes nendest tingimustest.

466
00:28:38,000 --> 00:28:41,000
Oskan kasutada, kui teine, kui teine ​​avaldus.

467
00:28:41,000 --> 00:28:45,000
Sisuliselt ütleb, et kui x = 0 ma printida positiivne.

468
00:28:45,000 --> 00:28:48,000
Kui see ei ole, ma lähen ka testida.

469
00:28:48,000 --> 00:28:51,000
Kui see on 2 ei ma lähen seda tegema.

470
00:28:51,000 --> 00:28:54,000
Põhimõtteliselt kui mul oleks x = 2 siis ütleksin

471
00:28:54,000 --> 00:28:57,000
if (x> 0), jah, nii trüki.

472
00:28:57,000 --> 00:29:00,000
Nüüd, kui ma tean, et see on> 0 ja et ta vastab esimese kui

473
00:29:00,000 --> 00:29:02,000
Ma isegi ei kavatse joosta see kood.

474
00:29:02,000 --> 00:29:09,000
Kood jookseb kiiremini, tegelikult 3 korda kiiremini, kui te kasutate seda.

475
00:29:09,000 --> 00:29:11,000
Meil on ka õppinud ja ja või.

476
00:29:11,000 --> 00:29:15,000
Ma ei lähe läbi, sest Lexi juba rääkinud neile.

477
00:29:15,000 --> 00:29:17,000
See on lihtsalt && ja | | operaator.

478
00:29:17,000 --> 00:29:21,000
>> Ainuke asi, ma ütlen, on olla ettevaatlik, kui sul on 3 tingimustele.

479
00:29:21,000 --> 00:29:24,000
Kasuta sulgudes, sest see on väga segane, kui teil on seisund,

480
00:29:24,000 --> 00:29:27,000
ja veel üks või teine.

481
00:29:27,000 --> 00:29:30,000
Kasuta sulgudes lihtsalt olla kindel, et teie tingimustele mõtet

482
00:29:30,000 --> 00:29:34,000
sest sel juhul, näiteks, võite ette kujutada, et

483
00:29:34,000 --> 00:29:38,000
see võiks olla esimene tingimus ja üks või teine

484
00:29:38,000 --> 00:29:41,000
või 2 tingimuste kombineerida ja

485
00:29:41,000 --> 00:29:45,000
või kolmas, nii lihtsalt olla ettevaatlik.

486
00:29:45,000 --> 00:29:48,000
Ja lõpuks, me rääkisime lülitid.

487
00:29:48,000 --> 00:29:53,000
Lüliti on väga kasulik, kui teil on muutuv.

488
00:29:53,000 --> 00:29:55,000
Oletame, et teil on muutuja nagu n

489
00:29:55,000 --> 00:29:59,000
mis võib olla 0, 1 või 2, ja kõikide nimetatud juhtudel

490
00:29:59,000 --> 00:30:01,000
sa lähed ülesande täitmiseks.

491
00:30:01,000 --> 00:30:04,000
Võite öelda lüliti muutuja, ja see näitab, et

492
00:30:04,000 --> 00:30:08,000
väärtus siis on nagu väärtus1 ma lähen seda teed,

493
00:30:08,000 --> 00:30:12,000
ja siis ma murda, mis tähendab, et ma ei kavatse vaadata mõne juhtudel

494
00:30:12,000 --> 00:30:15,000
sest me juba veendunud, et juhul

495
00:30:15,000 --> 00:30:20,000
ja siis väärtus2 ja nii edasi, ja ma ka ei ole vaikimisi sisse.

496
00:30:20,000 --> 00:30:24,000
See tähendab, et kui ta ei vasta ühele juhtudest, et mul oli

497
00:30:24,000 --> 00:30:29,000
et ma teen midagi, kuid see on vabatahtlik.

498
00:30:29,000 --> 00:30:36,000
See on kõik minu jaoks. Nüüd aga on Tommy.

499
00:30:36,000 --> 00:30:41,000
Olgu, see saab olema 3. nädal-ish.

500
00:30:41,000 --> 00:30:45,000
Need on mõned teemad, saadame katab, krüpto, ulatus, massiivid jne.

501
00:30:45,000 --> 00:30:49,000
Lihtsalt kiire sõna krüpto. Me ei lähe taguma seda kodus.

502
00:30:49,000 --> 00:30:52,000
>> Me tegime seda pset 2, kuid viktoriini veenduge, sa tead erinevus

503
00:30:52,000 --> 00:30:54,000
vahel Caesar salakiri ja Vigenère salakiri,

504
00:30:54,000 --> 00:30:57,000
kuidas need mõlemad ciphers töö ja mida ta on nagu krüptida

505
00:30:57,000 --> 00:30:59,000
ja dekrüpteerimiseks tekst, kasutades neid 2 ciphers.

506
00:30:59,000 --> 00:31:03,000
Pea meeles, et Caesar salakiri lihtsalt pöörleb iga märk sama summa võrra,

507
00:31:03,000 --> 00:31:06,000
tagades sa mod mitmeid tähte tähestikus.

508
00:31:06,000 --> 00:31:09,000
Ja Vigenère salakiri, teiselt poolt, pöörleb iga märk

509
00:31:09,000 --> 00:31:12,000
erinev summa, nii et mitte öelda

510
00:31:12,000 --> 00:31:15,000
iga märgi pööramisel 3 Vigenère pöörlema ​​hakkab iga märk

511
00:31:15,000 --> 00:31:17,000
erinev summa olenevalt mõned märksõna

512
00:31:17,000 --> 00:31:20,000
kus iga täht märksõna moodustab ligikaudu teistsuguse summa

513
00:31:20,000 --> 00:31:26,000
pööramiseks selge teksti.

514
00:31:26,000 --> 00:31:28,000
Vaatame kõigepealt rääkida muutuja ulatust.

515
00:31:28,000 --> 00:31:30,000
Seal on 2 erinevat tüüpi muutujad.

516
00:31:30,000 --> 00:31:33,000
Meil on kohalikud muutujad, ja need hakkavad olema määratletud

517
00:31:33,000 --> 00:31:36,000
väljaspool peamist või väljaspool mis tahes funktsiooni või blokaad,

518
00:31:36,000 --> 00:31:39,000
ja need on kättesaadavad kõikjal oma programmi.

519
00:31:39,000 --> 00:31:41,000
Kui teil on funktsioon ja selle funktsioon on samas silmus

520
00:31:41,000 --> 00:31:44,000
suur globaalne muutuja on kättesaadav kõikjal.

521
00:31:44,000 --> 00:31:48,000
Kohaliku muutuja, teiselt poolt, on scoped koht, kus see on määratletud.

522
00:31:48,000 --> 00:31:53,000
>> Kui teil on funktsioon siin, näiteks, on meil see funktsioon g,

523
00:31:53,000 --> 00:31:56,000
ja sees g on muutuja siin nimetatakse y,

524
00:31:56,000 --> 00:31:58,000
ja see tähendab, et see on kohaliku muutuja.

525
00:31:58,000 --> 00:32:00,000
Isegi kui see muutuja on kutsutud y

526
00:32:00,000 --> 00:32:03,000
ja seda muutujat nimetatakse J Need 2 funktsioonid

527
00:32:03,000 --> 00:32:06,000
pole aimugi, mida üksteise kohalike muutujad.

528
00:32:06,000 --> 00:32:10,000
Teiselt poolt, siin me ütleme, int x = 5,

529
00:32:10,000 --> 00:32:12,000
ja see ei kuulu ühegi funktsiooni.

530
00:32:12,000 --> 00:32:16,000
See on väljapoole peamine, nii et see on globaalne muutuja.

531
00:32:16,000 --> 00:32:20,000
See tähendab, et sees nende 2 funktsiooni, kui ütlen x - või x + +

532
00:32:20,000 --> 00:32:26,000
Ma tutvumise sama x kusjuures see y ja see y on erinevaid muutujaid.

533
00:32:26,000 --> 00:32:30,000
See vahe on globaalne muutuja ja kohaliku muutuja.

534
00:32:30,000 --> 00:32:33,000
Niipalju kui disain on mures, mõnikord on ilmselt parem idee

535
00:32:33,000 --> 00:32:37,000
hoida muutujad kohalike kui te võimalik

536
00:32:37,000 --> 00:32:39,000
alates võttes kamp globaalsed muutujad saavad väga segane.

537
00:32:39,000 --> 00:32:42,000
Kui teil on hunnik funktsioone kõik muutes sama asi

538
00:32:42,000 --> 00:32:45,000
võite unustada mis siis, kui see funktsioon kogemata muudab seda maailma,

539
00:32:45,000 --> 00:32:47,000
ja see teine ​​funktsioon ei tea seda,

540
00:32:47,000 --> 00:32:50,000
ja see ei saa päris segane nagu saad rohkem kood.

541
00:32:50,000 --> 00:32:53,000
Hoiame muutujad kohalike kui te võimalik

542
00:32:53,000 --> 00:32:56,000
on lihtsalt hea disain.

543
00:32:56,000 --> 00:33:00,000
Massiivid, pea meeles, on lihtsalt nimekirjade elemendid on sama tüüpi.

544
00:33:00,000 --> 00:33:04,000
Toas CI saa olla nimekiri nagu 1, 2.0, tere.

545
00:33:04,000 --> 00:33:06,000
Me lihtsalt ei saa seda teha.

546
00:33:06,000 --> 00:33:11,000
>> Kui me kuulutame massiivi C kõik elemendid olema sama tüüpi.

547
00:33:11,000 --> 00:33:14,000
Siin on mul massiivi 3 täisarvud.

548
00:33:14,000 --> 00:33:18,000
Siin on mul pikkus array, kuid kui ma lihtsalt tunnistada selles süntaks

549
00:33:18,000 --> 00:33:21,000
kus ma täpsustada, mis kõik elemendid on ma ei tehniliselt vaja see 3.

550
00:33:21,000 --> 00:33:25,000
Koostaja on piisavalt tark, et aru saada, kui suur massiiv peaks olema.

551
00:33:25,000 --> 00:33:28,000
Nüüd, kui ma tahan saada või seada väärtuse massiivi

552
00:33:28,000 --> 00:33:30,000
see on süntaks teha.

553
00:33:30,000 --> 00:33:33,000
See tegelikult muuta teise elemendi massiivist sest pidage meeles,

554
00:33:33,000 --> 00:33:36,000
numeratsioon algab 0, mitte 1.

555
00:33:36,000 --> 00:33:42,000
Kui ma tahan lugeda, et raha ma ei saa öelda midagi sellist int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Või kui ma tahan määrata, et väärtus, nagu ma siin teen,

557
00:33:44,000 --> 00:33:47,000
Võin öelda, massiiv [1] = 4.

558
00:33:47,000 --> 00:33:50,000
See aeg tutvumise elemente oma indeks

559
00:33:50,000 --> 00:33:52,000
või nende seisundit või kui nad on massiiv,

560
00:33:52,000 --> 00:33:57,000
ja et noteerimise alguspäeva 0.

561
00:33:57,000 --> 00:34:00,000
Saame ka massiive massiivid

562
00:34:00,000 --> 00:34:03,000
ja seda nimetatakse mitmemõõtmeline massiiv.

563
00:34:03,000 --> 00:34:05,000
Kui meil on mitmemõõtmeline array

564
00:34:05,000 --> 00:34:07,000
see tähendab, et meil on midagi ridade ja veergude

565
00:34:07,000 --> 00:34:11,000
ja see on lihtsalt üks viis visualiseerida seda või mõelda seda.

566
00:34:11,000 --> 00:34:14,000
Kui mul on mitmemõõtmeline array, mis tähendab, et ma lähen alustada vajavad

567
00:34:14,000 --> 00:34:17,000
rohkem kui 1 pealeht sest kui mul on võre

568
00:34:17,000 --> 00:34:19,000
lihtsalt ütlen, mida rida sul ei anna meile arv.

569
00:34:19,000 --> 00:34:22,000
See on tõesti lihtsalt läheb meile nimekirja numbreid.

570
00:34:22,000 --> 00:34:25,000
Oletame, et mul on see massiiv siin.

571
00:34:25,000 --> 00:34:30,000
Mul on massiiv nimega võrku, ja ma väidan et see on 2 rida ja 3 veergu,

572
00:34:30,000 --> 00:34:32,000
ja nii see on üks võimalus visualiseerida seda.

573
00:34:32,000 --> 00:34:37,000
Kui ma ütlen, ma tahan saada osa juures [1] [2]

574
00:34:37,000 --> 00:34:41,000
see tähendab, et kuna need on read ja alles seejärel veerud

575
00:34:41,000 --> 00:34:44,000
Ma lähen hüpata 1. RIDA kuna ma ütlesin 1.

576
00:34:44,000 --> 00:34:49,000
>> Siis ma lähen siia tulla kuni 2. veerus, ja ma lähen, et saada väärtus 6.

577
00:34:49,000 --> 00:34:51,000
Mõtet?

578
00:34:51,000 --> 00:34:55,000
Mitmemõõtmeline massiivid, pea meeles, on tehniliselt lihtsalt massiivi massiivid.

579
00:34:55,000 --> 00:34:57,000
Me võime olla massiive massiive massiivid.

580
00:34:57,000 --> 00:35:00,000
Me ei saa edasi minna, kuid tegelikult üks viis mõelda

581
00:35:00,000 --> 00:35:03,000
kuidas seda paigaldada ja mis toimub on visualiseerida seda

582
00:35:03,000 --> 00:35:09,000
aastal võre niimoodi.

583
00:35:09,000 --> 00:35:12,000
Kui võtame massiivid funktsioone, nad ei kavatse käituda

584
00:35:12,000 --> 00:35:16,000
natuke teisiti kui võtame regulaarselt muutujate funktsioonid

585
00:35:16,000 --> 00:35:18,000
nagu möödaminnes int või veepinnal.

586
00:35:18,000 --> 00:35:21,000
Kui me läbima int või char või mõni neist teistest andmetüüpidest

587
00:35:21,000 --> 00:35:24,000
me lihtsalt vaatasin kui funktsioon muudab

588
00:35:24,000 --> 00:35:28,000
muutuja väärtusega, et muutus ei kavatse propageerida üles

589
00:35:28,000 --> 00:35:32,000
et funktsiooni.

590
00:35:32,000 --> 00:35:35,000
Mis array, ning teiselt poolt, et juhtub.

591
00:35:35,000 --> 00:35:39,000
Kui ma mööda massiivi teatud funktsiooni ja selle funktsiooni muudab mõned elemendid,

592
00:35:39,000 --> 00:35:43,000
kui ma tulen tagasi üles funktsioon, mis nimetas seda

593
00:35:43,000 --> 00:35:47,000
minu massiiv on nüüd saab olema erinev, ja sõnavara, mis

594
00:35:47,000 --> 00:35:50,000
on massiivid on möödas, viidates, nagu me näha hiljem.

595
00:35:50,000 --> 00:35:53,000
See on seotud sellega, kuidas viiteid töö, kus need põhilised andmetüübid,

596
00:35:53,000 --> 00:35:55,000
teiselt poolt, on vastu võetud väärtus.

597
00:35:55,000 --> 00:35:59,000
>> Me ei mõtle, et kui koopia tegemine mõned muutuja ja siis möödaminnes koopia.

598
00:35:59,000 --> 00:36:01,000
Ei ole oluline, mida me teeme, et muutuja.

599
00:36:01,000 --> 00:36:06,000
Helistaja funktsioon ei ole teadlikud, et see oli muutunud.

600
00:36:06,000 --> 00:36:10,000
Massiivid on lihtsalt natuke erinev selles osas.

601
00:36:10,000 --> 00:36:13,000
Näiteks kui me just nägime, peamine on lihtsalt funktsioon

602
00:36:13,000 --> 00:36:15,000
mis võib võtta 2 argumendid.

603
00:36:15,000 --> 00:36:20,000
Esimene argument, et peamine ülesanne on argc või mitu argumenti,

604
00:36:20,000 --> 00:36:23,000
ja teine ​​argument on nn argv,

605
00:36:23,000 --> 00:36:27,000
ja need on tegelikud väärtused nendele argumentidele vastu.

606
00:36:27,000 --> 00:36:30,000
Oletame, et mul on programm nimega this.c,

607
00:36:30,000 --> 00:36:34,000
ja ma ütlen seda, ja ma lähen jooksma seda käsurida.

608
00:36:34,000 --> 00:36:38,000
Nüüd läbida mõned argumendid minu programm nimega seda,

609
00:36:38,000 --> 00:36:42,000
Ma võiks öelda midagi sellist. / See on CS 50.

610
00:36:42,000 --> 00:36:45,000
See on see, mida me ette kujutada David tegema iga päev terminalis.

611
00:36:45,000 --> 00:36:48,000
Aga nüüd peamine funktsioon sees, et programmi

612
00:36:48,000 --> 00:36:52,000
on need väärtused, nii argc on 4.

613
00:36:52,000 --> 00:36:56,000
See võib olla veidi segadusse, sest tegelikult me ​​ainult möödaminnes on CS 50.

614
00:36:56,000 --> 00:36:58,000
See on ainult 3.

615
00:36:58,000 --> 00:37:02,000
Kuid pidage meeles, et esimene osa argv või esimene argument

616
00:37:02,000 --> 00:37:05,000
on funktsiooni nimi ise.

617
00:37:05,000 --> 00:37:07,190
See tähendab, et meil on 4 asja siin,

618
00:37:07,190 --> 00:37:10,530
ja esimene element saab olema. / see.

619
00:37:10,530 --> 00:37:12,970
Ja see on esindatud string.

620
00:37:12,970 --> 00:37:18,590
Siis ülejäänud elemente, mida me tipitud pärast programmi nime.

621
00:37:18,590 --> 00:37:22,720
Nii nagu kõrvale, nagu me ilmselt nägi pset 2

622
00:37:22,720 --> 00:37:28,780
meeles pidada, et string 50 ≠ täisarv 50.

623
00:37:28,780 --> 00:37:32,520
Nii et me ei saa öelda midagi sellist, "int x = argv 3."

624
00:37:32,520 --> 00:37:36,470
>> See on lihtsalt ei hakka mõtet, sest see on string, ja see on täisarv.

625
00:37:36,470 --> 00:37:38,510
Nii et kui soovite teisendada vahel 2, pidage meeles, et me ei kavatse

626
00:37:38,510 --> 00:37:40,810
on see maagiline funktsioon nimega atoi.

627
00:37:40,810 --> 00:37:46,270
See võtab stringi ja tagastab täisarvu esindatud sees, et string.

628
00:37:46,270 --> 00:37:48,360
Nii et lihtne viga teha edasi viktoriin,

629
00:37:48,360 --> 00:37:51,590
lihtsalt mõtlesin, et see on automaatselt õige tüüp.

630
00:37:51,590 --> 00:37:53,860
Aga lihtsalt tean, et need on alati stringe

631
00:37:53,860 --> 00:38:00,920
isegi kui string sisaldab ainult täisarv või iseloomu või sularahaga.

632
00:38:00,920 --> 00:38:03,380
Nüüd räägime sõiduaega.

633
00:38:03,380 --> 00:38:06,700
Kui meil on kõik need algoritmid, et teha kõik need hullud asjad,

634
00:38:06,700 --> 00:38:11,580
see muutub tõesti kasulik küsida: "Kui kaua võtab aega nende?"

635
00:38:11,580 --> 00:38:15,500
Me esindame et midagi nimetatakse asümptootilisest märke.

636
00:38:15,500 --> 00:38:18,430
Nii et see tähendab, et - noh, ütleme, et me anname oma algoritmi

637
00:38:18,430 --> 00:38:20,840
mõned tõesti, tõesti, tõesti suur panus.

638
00:38:20,840 --> 00:38:23,840
Tahame küsida, "Kui kaua see aega võtab?

639
00:38:23,840 --> 00:38:26,370
Mitu sammu kulub meie algoritm joosta

640
00:38:26,370 --> 00:38:29,980
funktsioonina suurusest sisend? "

641
00:38:29,980 --> 00:38:33,080
Nii et esimene viisil saame kirjeldada läbijooksuaeg on suur O.

642
00:38:33,080 --> 00:38:35,380
Ja see on meie halvima sõiduaega.

643
00:38:35,380 --> 00:38:38,590
Nii et kui me soovime sortida massiivi, ja me anname oma algoritm massiivi

644
00:38:38,590 --> 00:38:41,000
See on järjekorras, kui see peaks olema tõusvas järjestuses,

645
00:38:41,000 --> 00:38:43,130
et see saab olema halvimal juhul.

646
00:38:43,130 --> 00:38:49,800
See on meie ülemise aastal maksimaalne aeg meie algoritm võtab.

647
00:38:49,800 --> 00:38:54,740
Teiselt poolt, see Ω läheb kirjeldada parimal juhul sõiduaega.

648
00:38:54,740 --> 00:38:58,210
Nii et kui me anname juba sorteeritud massiivi sorteerimine algoritm,

649
00:38:58,210 --> 00:39:00,940
Kui kaua läheb aega, et sortida?

650
00:39:00,940 --> 00:39:06,610
Ja see on siis kirjeldab alampiiri sõiduaega.

651
00:39:06,610 --> 00:39:10,980
Nii et siin on vaid mõned sõnad, et kirjeldada mõningaid ühiseid töötab korda.

652
00:39:10,980 --> 00:39:13,120
Need on tõusvas järjekorras.

653
00:39:13,120 --> 00:39:16,060
Kiireim sõiduaega meil nimetatakse samaks.

654
00:39:16,060 --> 00:39:19,800
>> See tähendab, et ükskõik kui palju elemente me anname oma algoritm,

655
00:39:19,800 --> 00:39:22,280
ükskõik kui suur meie massiiv on, sorteerimine

656
00:39:22,280 --> 00:39:26,510
või teha kõik me teeme, et massiivi alati võtta sama palju aega.

657
00:39:26,510 --> 00:39:30,270
Nii saame esindada et lihtsalt koos 1, mis on konstantne.

658
00:39:30,270 --> 00:39:32,410
Samuti vaadeldi logaritmiline läbijooksuaeg.

659
00:39:32,410 --> 00:39:34,800
Nii et midagi binaarne otsing on logaritmiline,

660
00:39:34,800 --> 00:39:37,140
kus me lõigatud probleem pooleks iga kord

661
00:39:37,140 --> 00:39:40,970
ja siis asjad lihtsalt saada suurem sealt.

662
00:39:40,970 --> 00:39:43,580
Ja kui sa kunagi kirjutamise O tahes faktoriaal algoritm,

663
00:39:43,580 --> 00:39:47,850
siis ilmselt ei tohiks käsitleda seda kui oma päev tööd.

664
00:39:47,850 --> 00:39:53,910
Kui me võrdleme töötab korda on oluline meeles pidada neid asju.

665
00:39:53,910 --> 00:39:57,760
Nii et kui mul on algoritm, mis on O (n), ja keegi teine

666
00:39:57,760 --> 00:40:03,590
on algoritm O (2n) need on tegelikult asümptootiliselt samaväärne.

667
00:40:03,590 --> 00:40:06,590
Nii et kui me ette kujutame n olema suur arv nagu eleventy miljardit:

668
00:40:06,590 --> 00:40:13,090
nii et kui me võrrelda eleventy miljardi midagi eleventy miljardit + 3

669
00:40:13,090 --> 00:40:17,640
äkki et 3 ei ole tegelikult teeb suur erinevus enam.

670
00:40:17,640 --> 00:40:20,980
Sellepärast me ei kavatse alustada kaaluda neid asju samaväärseks.

671
00:40:20,980 --> 00:40:24,220
Nii et asjad peaksid neid konstante siin, seal on 2 x seda, või lisades 3,

672
00:40:24,220 --> 00:40:27,180
need on vaid konstandid, ja need hakkavad langema üles.

673
00:40:27,180 --> 00:40:32,480
Nii et miks kõik 3 neist perspektiivis ajad on sama, mis öelda, et nad O (n).

674
00:40:32,480 --> 00:40:37,490
Samamoodi, kui meil on 2 muud perspektiivis korda oletame, et O (n ³ + 2n ²), võime lisada

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, ja siis on meil veel üks läbijooksuaeg see on lihtsalt O (n ³).

676
00:40:42,070 --> 00:40:46,290
Ka need on sama asi, sest need - need ei ole samad.

677
00:40:46,290 --> 00:40:49,840
Need on samad asjad, vabandust. Nii et need on samad, sest

678
00:40:49,840 --> 00:40:53,090
see n ³ läheb domineerima see 2n ².

679
00:40:53,090 --> 00:40:59,130
>> Mis ei ole sama asi on, kui me jooksime korda nagu O (n ³) ja O (n ²)

680
00:40:59,130 --> 00:41:02,820
sest see n ³ on palju suurem kui see n ².

681
00:41:02,820 --> 00:41:05,470
Nii et kui meil on eksponendid, äkki see hakkab tähtsust,

682
00:41:05,470 --> 00:41:08,280
aga kui me lihtsalt tegelevad tegureid nagu me oleme siin üleval,

683
00:41:08,280 --> 00:41:12,810
siis ei hakka üldse, kuna nad on lihtsalt kukub välja.

684
00:41:12,810 --> 00:41:16,760
Võtame pilk mõned algoritmid oleme näinud nii kaugele

685
00:41:16,760 --> 00:41:19,260
ja rääkida oma läbijooksuaeg.

686
00:41:19,260 --> 00:41:23,850
Esimene viis otsite arv nimekirjas, mida me nägime, oli lineaarne otsing.

687
00:41:23,850 --> 00:41:26,950
Ja rakendamiseks lineaarne otsing on super lihtne.

688
00:41:26,950 --> 00:41:30,490
Meil on lihtsalt nimekiri, ja me ei kavatse vaadata iga element nimekirja

689
00:41:30,490 --> 00:41:34,260
kuni leiame arvu me otsime.

690
00:41:34,260 --> 00:41:38,370
See tähendab, et halvimal juhul, seda O (n).

691
00:41:38,370 --> 00:41:40,860
Ja halvimal juhul siin võiks olla, kui element on

692
00:41:40,860 --> 00:41:45,710
viimane element, siis lineaarse otsing me peame vaatama iga element

693
00:41:45,710 --> 00:41:50,180
kuni jõuame viimane, et teada, et see oli tegelikult nimekirjas.

694
00:41:50,180 --> 00:41:52,910
Me ei saa lihtsalt loobuda pooleldi ja öelda: "See pole ilmselt olemas."

695
00:41:52,910 --> 00:41:55,980
Lineaarse otsing me peame vaatama kogu asi.

696
00:41:55,980 --> 00:41:59,090
Parimal juhul sõiduaega, teiselt poolt, on pidev

697
00:41:59,090 --> 00:42:04,200
sest parimal juhul element me otsime, on lihtsalt esimene nimekirjas.

698
00:42:04,200 --> 00:42:08,930
Nii see läheb meid täpselt 1 samm, ükskõik kui suur nimekiri on

699
00:42:08,930 --> 00:42:12,140
kui me otsime esimese elemendi iga kord.

700
00:42:12,140 --> 00:42:15,390
>> Nii et kui te otsite, pidage meeles, et see ei nõua, et meie nimekiri sorteeritakse.

701
00:42:15,390 --> 00:42:19,430
Sest me lihtsalt läheb üle vaatama iga element, ja see ei ole tegelikult küsimus

702
00:42:19,430 --> 00:42:23,560
Millises järjekorras need elemendid on paratamatu

703
00:42:23,560 --> 00:42:28,110
Arukam otsing algoritm on midagi binaarne otsing.

704
00:42:28,110 --> 00:42:31,500
Pea meeles, rakendamise Kahendotsingupuu on, kui sa lähed

705
00:42:31,500 --> 00:42:34,320
hoida vaadates keset nimekirja.

706
00:42:34,320 --> 00:42:38,000
Ja kuna me vaatleme keskel, nõuame, et nimekiri on järjestatud

707
00:42:38,000 --> 00:42:40,580
või muidu me ei tea, kus keskel on, ja me peame vaatama üle

708
00:42:40,580 --> 00:42:44,480
kogu nimekirja leida, ja siis sel hetkel me lihtsalt raiskame aega.

709
00:42:44,480 --> 00:42:48,480
Nii et kui meil on järjestatud nimekiri ja leiame keskel, me võrrelda keskel

710
00:42:48,480 --> 00:42:51,590
element me otsime.

711
00:42:51,590 --> 00:42:54,640
Kui see on liiga kõrge, siis me ei suuda unustada paremal pool

712
00:42:54,640 --> 00:42:57,810
sest me teame, et kui meie osa on juba liiga kõrge

713
00:42:57,810 --> 00:43:01,080
ja kõike paremal see element on isegi suurem,

714
00:43:01,080 --> 00:43:02,760
siis me ei pea vaatama enam.

715
00:43:02,760 --> 00:43:05,430
Kui teisest küljest, kui meie osa on liiga madal,

716
00:43:05,430 --> 00:43:08,700
me teame kõike vasakule, et element on ka liiga madal,

717
00:43:08,700 --> 00:43:11,390
nii see ei ole tõesti mõtet otsida seal kas.

718
00:43:11,390 --> 00:43:15,760
Nii, igal sammul ja iga kord kui me vaatame keskpunktis nimekirja,

719
00:43:15,760 --> 00:43:19,060
me ei kavatse lõigata meie probleem pooleks, sest äkki me teame

720
00:43:19,060 --> 00:43:23,040
terve hunnik numbreid, mis ei saa olla see, mida me otsime.

721
00:43:23,040 --> 00:43:26,950
>> Aastal pseudokoodi see välja midagi sellist,

722
00:43:26,950 --> 00:43:30,990
ja kuna me Lõikame nimekiri pooleks iga kord,

723
00:43:30,990 --> 00:43:34,920
meie halvima läbijooksuaeg hüppab lineaarne logaritmiline.

724
00:43:34,920 --> 00:43:39,260
Nii et äkki meil logi samme, et leida element nimekirja.

725
00:43:39,260 --> 00:43:42,460
Parimal juhul sõiduaega, kuigi on ikka konstantne

726
00:43:42,460 --> 00:43:45,180
sest nüüd, ütleme lihtsalt, et element me otsime, on

727
00:43:45,180 --> 00:43:48,380
alati täpselt keset esialgses nimekirjas.

728
00:43:48,380 --> 00:43:52,080
Nii saame kasvada meie nimekirjas nii suur kui tahame, kuid kui element me otsime on keskel,

729
00:43:52,080 --> 00:43:54,910
siis see on ainult kavatse võtta meile 1 samm.

730
00:43:54,910 --> 00:44:00,920
Nii et miks me O (log n) ja Ω (1) või pidev.

731
00:44:00,920 --> 00:44:04,510
Teeme reaalselt sõita Kahendotsingupuu selles nimekirjas.

732
00:44:04,510 --> 00:44:08,020
Ütleme, et me otsime element 164.

733
00:44:08,020 --> 00:44:11,650
Esimene asi, mida me ei kavatse teha, on leida keskpunktis selles nimekirjas.

734
00:44:11,650 --> 00:44:15,060
See lihtsalt nii juhtub, et keskpunktis alaneb nende vahel 2 numbrit,

735
00:44:15,060 --> 00:44:18,960
niiet lihtsalt suvaliselt öelda, iga kord keskpunktis jääb vahemikku 2 numbrit,

736
00:44:18,960 --> 00:44:21,150
olgem lihtsalt ümardada.

737
00:44:21,150 --> 00:44:24,330
Me lihtsalt vaja veenduda, et me seda teha igal sammul teed.

738
00:44:24,330 --> 00:44:29,040
Nii et me ümardada, ja me ei kavatse öelda, et 161 on keset meie nimekirjas.

739
00:44:29,040 --> 00:44:34,640
Nii et 161 <164, ja iga element vasakule 161

740
00:44:34,640 --> 00:44:39,120
Samuti on <164, nii et me teame, et see ei aita meid üldse

741
00:44:39,120 --> 00:44:42,690
hakata otsima üle siin, sest element me otsime saa seal olla.

742
00:44:42,690 --> 00:44:47,060
Mida me teha saame, on meil võimalik lihtsalt unustada, et kogu vasak pool nimekirja,

743
00:44:47,060 --> 00:44:51,700
ja nüüd võetakse arvesse ainult vasakust 161 aastast.

744
00:44:51,700 --> 00:44:54,050
>> Nii et jällegi, see on keskpunktis; olgem lihtsalt ümardada.

745
00:44:54,050 --> 00:44:56,260
Nüüd 175 on liiga suur.

746
00:44:56,260 --> 00:44:59,180
Nii et me teame, et see ei hakka meid otsin siit või siit,

747
00:44:59,180 --> 00:45:06,610
nii et me saame lihtsalt visata see ära, ja lõpuks me tabas 164.

748
00:45:06,610 --> 00:45:10,560
Iga küsimustele Kahendotsingupuu?

749
00:45:10,560 --> 00:45:14,180
Liigume edasi läbi otsida juba sorteeritud nimekirja

750
00:45:14,180 --> 00:45:17,660
tegelikult võttes Arvuloend suvalises järjekorras

751
00:45:17,660 --> 00:45:20,960
ja teha seda nimekirja kasvavas järjekorras.

752
00:45:20,960 --> 00:45:24,060
Esimene algoritm me vaatasime kutsuti mull sorteerida.

753
00:45:24,060 --> 00:45:27,300
Ja see oleks lihtsam osa algoritme nägime.

754
00:45:27,300 --> 00:45:32,970
Mull sorteerida ütleb, et kui mõni 2 elementi sees nimekiri on kohatu,

755
00:45:32,970 --> 00:45:36,500
mis tähendab, et on olemas kõrgem number vasakul väiksem arv,

756
00:45:36,500 --> 00:45:40,190
siis me ei kavatse vahetada neid, sest see tähendab, et nimekiri on

757
00:45:40,190 --> 00:45:42,860
"Rohkem järjestatud", kui see oli enne.

758
00:45:42,860 --> 00:45:45,180
Ja me lihtsalt läheb jätkata seda protsessi uuesti ja uuesti ja uuesti

759
00:45:45,180 --> 00:45:52,100
kuni lõpuks elemendid sellist mulli nende õigesse asukohta ja meil on järjestatud nimekirja.

760
00:45:52,100 --> 00:45:57,230
>> Läbijooksuaeg selle saab olema O (n ²). Miks?

761
00:45:57,230 --> 00:46:00,370
Noh, sest halvimal juhul me viime iga element, ja

762
00:46:00,370 --> 00:46:04,570
me hakkame lõpuks võrreldes seda iga teine ​​element nimekirjas.

763
00:46:04,570 --> 00:46:08,030
Aga parimal juhul on meil juba järjestatud nimekirja, mull sorteerida on

764
00:46:08,030 --> 00:46:12,230
lihtsalt lähe läbi kui, ütleme "Ei. Mul ei teinud vahetuslepingud, nii et ma olen teinud."

765
00:46:12,230 --> 00:46:17,410
Nii et meil on parimal juhul sõiduaega Ω (n).

766
00:46:17,410 --> 00:46:20,680
Lähme sõitma mull sorteerida nimekirjas.

767
00:46:20,680 --> 00:46:23,560
Või Esiteks, ärgem lihtsalt pilk mõned pseudokoodi tõesti kiiresti.

768
00:46:23,560 --> 00:46:28,160
Me tahame öelda, et me tahame jälgida, iga iteratsiooni silmus,

769
00:46:28,160 --> 00:46:32,190
jälgima, kas me muutnud elemente.

770
00:46:32,190 --> 00:46:37,610
Nii et selle põhjuseks on, me ei kavatse peatuda, kui me ei ole vahetasid mingeid elemente.

771
00:46:37,610 --> 00:46:41,980
Nii et alguses meie silmus me ei vahetaks midagi, seega me ütleme, et on vale.

772
00:46:41,980 --> 00:46:47,170
Nüüd läheme läbi nimekirja ja võrrelge element I osa i + 1

773
00:46:47,170 --> 00:46:50,310
ja kui see on nii, et on suurem number vasakul väiksem number,

774
00:46:50,310 --> 00:46:52,310
siis me lihtsalt läheb, et vahetada neid.

775
00:46:52,310 --> 00:46:54,490
>> Ja siis me lähme meeles pidada, et me vahetaks element.

776
00:46:54,490 --> 00:46:58,900
See tähendab, et me peame minema läbi nimekirja vähemalt 1 rohkem aega

777
00:46:58,900 --> 00:47:02,160
sest seisund, mille me lõpetasime on siis kogu nimekiri on juba sorteeritud,

778
00:47:02,160 --> 00:47:04,890
mis tähendab, et me ei ole teinud ühtegi vahetustehingud.

779
00:47:04,890 --> 00:47:09,960
Nii et miks meie seisund siin all on "samas kui mõned elemendid on vahetatud."

780
00:47:09,960 --> 00:47:13,720
Nii et nüüd lähme lihtsalt vaata seda töötab loendist.

781
00:47:13,720 --> 00:47:16,640
Mul on nimekiri 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Mull sorteerida kavatseb alustada kogu tee vasakul, ja see saab võrrelda

783
00:47:19,850 --> 00:47:24,700
i elemente, nii 0 kuni i + 1, mis on element 1.

784
00:47:24,700 --> 00:47:29,020
See saab öelda, hästi 5> 0, kuid praegu 5 on vasakule,

785
00:47:29,020 --> 00:47:32,500
nii mul on vaja, et vahetada 5 ja 0.

786
00:47:32,500 --> 00:47:35,470
Kui ma vahetada neid, äkki ma saaksin selle erinevaid nimekirja.

787
00:47:35,470 --> 00:47:38,260
Nüüd 5> 1, seega me ei kavatse vahetada neid.

788
00:47:38,260 --> 00:47:42,160
5 ei ole> 6, nii et me ei pea midagi tegema siin.

789
00:47:42,160 --> 00:47:46,690
Aga 6> 4, nii et me peame vahetama.

790
00:47:46,690 --> 00:47:49,740
Jällegi, me peame sõitma läbi kogu nimekiri lõpuks avastada

791
00:47:49,740 --> 00:47:52,330
et need on rikkis; me vahetada neid,

792
00:47:52,330 --> 00:47:57,120
ja siinkohal peame sõitma läbi nimekirja veel 1 kord

793
00:47:57,120 --> 00:48:05,390
veenduda, et kõik on oma järjekorras, ja siinkohal mull sorteerida on lõppenud.

794
00:48:05,390 --> 00:48:10,720
Erinev algoritm võtab mõned elemendid ja sorteerimine neist on valik omamoodi.

795
00:48:10,720 --> 00:48:15,740
Idee valik omamoodi on see, et me ei kavatse ehitada järjestatud osa loend

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

797
00:48:18,150 --> 00:48:23,170
>> Ja kuidas me teeme, mis on rajades vasakul segment nimekirja.

798
00:48:23,170 --> 00:48:27,510
Ja põhimõtteliselt, iga - iga samm, me viime väikseim element me oleme jätnud

799
00:48:27,510 --> 00:48:32,310
et ei ole järjestatud veel, ja me kavatseme liikuda see, et sorteerida segmendis.

800
00:48:32,310 --> 00:48:35,850
See tähendab, et peame pidevalt leida minimaalne sortimata element

801
00:48:35,850 --> 00:48:40,720
ja siis võtma, et minimaalne element ja swap see iganes

802
00:48:40,720 --> 00:48:45,090
vasemmanpuolimmaista element, mis ei järjestatud.

803
00:48:45,090 --> 00:48:50,890
Joosta aeg see saab olema O (n ²), sest halvimal juhul

804
00:48:50,890 --> 00:48:55,070
meil on vaja võrrelda iga element iga teine ​​element.

805
00:48:55,070 --> 00:48:59,250
Sest me ütleme, et kui hakkame vasakul pool nimekirjas, me vajame

806
00:48:59,250 --> 00:49:02,970
läbida kogu õige segmendi leida väikseim element.

807
00:49:02,970 --> 00:49:05,430
Ja siis jälle, me peame minema üle kogu õige segmendi ja

808
00:49:05,430 --> 00:49:08,210
käiks üle, et ikka ja jälle ja jälle.

809
00:49:08,210 --> 00:49:11,350
See saab olema n ². Me läheme pea jaoks silmus sees teise silmuse

810
00:49:11,350 --> 00:49:13,350
mis viitab n ².

811
00:49:13,350 --> 00:49:16,530
Parimal juhul mõtte, ütleme, et me anname seda juba järjestatud loetelu;

812
00:49:16,530 --> 00:49:19,270
me tegelikult ei tee midagi paremat kui n ².

813
00:49:19,270 --> 00:49:21,730
Kuna valik omamoodi on kuidagi võimalik teada, et

814
00:49:21,730 --> 00:49:25,540
minimaalne element on lihtsalt üks I juhtub olema vaadates.

815
00:49:25,540 --> 00:49:28,970
See ikka peab veenduma, et see on tegelikult minimaalsed.

816
00:49:28,970 --> 00:49:31,670
>> Ja ainus võimalus veendumaks, et see on minimaalne, kasutades seda algoritmi,

817
00:49:31,670 --> 00:49:34,640
on vaadata iga element uuesti.

818
00:49:34,640 --> 00:49:38,420
Nii et tõesti, kui annad talle - kui sa annad valik omamoodi juba järjestatud nimekirja,

819
00:49:38,420 --> 00:49:42,720
ta ei kavatse teha midagi paremat kui anda see nimekiri, mis ei ole järjestatud veel.

820
00:49:42,720 --> 00:49:46,320
Muide, kui see juhtub olema nii, et midagi on O (midagi)

821
00:49:46,320 --> 00:49:50,640
ja oomega midagi, saame lihtsalt öelda veel tabavalt, et see on θ midagi.

822
00:49:50,640 --> 00:49:52,760
Nii et kui sa näed, et tulla kuhugi, see on, mida see tähendab lihtsalt.

823
00:49:52,760 --> 00:49:57,580
>> Kui midagi on teeta n ², on nii suur O (n ²) ja Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Nii et parimal juhul ja halvimal juhul see ei tee vahet,

825
00:49:59,790 --> 00:50:04,400
algoritmi teeme sama asja iga kord.

826
00:50:04,400 --> 00:50:06,610
Nii et see on see, mida pseudokoodi valiku omamoodi võiks olla.

827
00:50:06,610 --> 00:50:10,630
Me põhiliselt ütlen, et ma tahan kinnitada, üle nimekirja

828
00:50:10,630 --> 00:50:15,180
vasakult paremale ja igal iteratsiooni silmus, ma lähen liikuda

829
00:50:15,180 --> 00:50:19,780
minimaalne element sellesse järjestatud osa nimekirjast.

830
00:50:19,780 --> 00:50:23,260
Ja kui ma liigutan midagi seal, ma ei ole kunagi vaja vaadata, et element uuesti.

831
00:50:23,260 --> 00:50:28,600
Sest niipea kui ma vahetada element vasakule segment nimekirja, on järjestatud

832
00:50:28,600 --> 00:50:32,600
sest me teeme kõike kasvavas järjekorras kasutades miinimummääradeks.

833
00:50:32,600 --> 00:50:38,740
Nii et me ütlesime, okei, me oleme positsioonis i, ja me peame vaatama kõiki elemente

834
00:50:38,740 --> 00:50:42,260
paremal i, et leida minimaalne.

835
00:50:42,260 --> 00:50:46,150
See tähendab, me tahame vaadata alates i + 1 aasta lõpuni nimekirja.

836
00:50:46,150 --> 00:50:51,610
Ja nüüd, kui element, mida me praegu vaadates on väiksem kui meie miinimum seni,

837
00:50:51,610 --> 00:50:54,190
mis pidage meeles, et me alustame miinimum maha lihtsalt olla

838
00:50:54,190 --> 00:50:57,020
mis iganes element me praegu; ma eeldada, et on minimaalne.

839
00:50:57,020 --> 00:51:00,270
Kui ma leian element, mis on väiksem, siis ma ütlen, ok,

840
00:51:00,270 --> 00:51:02,700
Noh, ma olen leidnud uue minimaalne.

841
00:51:02,700 --> 00:51:06,080
Ma mäletan, kui see miinimum oli.

842
00:51:06,080 --> 00:51:09,560
>> Nüüd, kui olen läbi käinud, et õigus sortimata segment,

843
00:51:09,560 --> 00:51:16,690
Võin öelda, et ma lähen vahetada minimaalse elemendi element, mis on positsioonil i.

844
00:51:16,690 --> 00:51:21,100
See saab üles ehitada oma nimekirja, minu järjestatud osa nimekirjast vasakult paremale,

845
00:51:21,100 --> 00:51:25,190
ja me ei ole kunagi vaja vaadata element uuesti, kui see on see osa.

846
00:51:25,190 --> 00:51:27,930
Kui oleme vahetasin ta.

847
00:51:27,930 --> 00:51:30,260
Nii et olgem joosta valik omamoodi selles nimekirjas.

848
00:51:30,260 --> 00:51:38,220
Sinine element siin saab olema I ja punane element saab olema minimaalne element.

849
00:51:38,220 --> 00:51:41,570
Nii et ma algab kõik viis vasakule nimekirjas, siis kell 5.

850
00:51:41,570 --> 00:51:44,610
Nüüd on vaja leida minimaalse sortimata element.

851
00:51:44,610 --> 00:51:49,480
Nii me ütleme 0 <5, 0 jääb minu uus miinimum.

852
00:51:49,480 --> 00:51:53,820
>> Aga ma ei saa lõpetada seal, sest kuigi me ei mõista, et 0 on kõige väiksemad,

853
00:51:53,820 --> 00:51:59,390
peame joosta iga muu elemendi nimekirja veenduda.

854
00:51:59,390 --> 00:52:01,760
Seega 1 on suurem, 6 on suurem, 4 on suurem.

855
00:52:01,760 --> 00:52:05,850
See tähendab, et pärast vaadates kõik need elemendid, olen määratud 0 on väikseim.

856
00:52:05,850 --> 00:52:09,800
Ma lähen, et vahetada 5 ja 0.

857
00:52:09,800 --> 00:52:15,480
Kui ma vahetada, et ma lähen, et saada uus nimekiri, ja ma tean, et ma ei ole kunagi vaja vaadata, et 0 taas

858
00:52:15,480 --> 00:52:19,380
sest kui olen vahetasid, siis ma olen järjestatud seda ja me oleme valmis.

859
00:52:19,380 --> 00:52:22,730
Nüüd see lihtsalt nii juhtub, et sinine osa on jälle 5

860
00:52:22,730 --> 00:52:26,030
ja me peame vaatama, 1, 6 ja 4 kindlaks, et 1

861
00:52:26,030 --> 00:52:31,520
on väikseim minimaalne element, nii me swap 1 ja 5.

862
00:52:31,520 --> 00:52:36,890
Jällegi, me peame vaatama - võrrelge 5 6 ja 4,

863
00:52:36,890 --> 00:52:39,830
ja me ei kavatse vahetada 4 ja 5, ning lõpuks võrrelda

864
00:52:39,830 --> 00:52:45,740
need 2 numbrit ja vahetada neid kuni saame meie järjestatud nimekirja.

865
00:52:45,740 --> 00:52:49,730
Iga küsimustele valik omamoodi?

866
00:52:49,730 --> 00:52:56,420
Okei. Liigume viimase teema siin, ja see on rekursioon.

867
00:52:56,420 --> 00:52:59,810
>> Rekursioon, pidage meeles, et see on tõesti meta asi, kus funktsioon

868
00:52:59,810 --> 00:53:02,740
korduvalt nimetab ennast.

869
00:53:02,740 --> 00:53:05,620
Nii et mingil hetkel, kui meie fuction on korduvalt nõudnud ise,

870
00:53:05,620 --> 00:53:10,100
seal peab olema mingi koht, kus me lõpetada helistab ise.

871
00:53:10,100 --> 00:53:13,670
Sest kui me seda ei tee, siis me lihtsalt jätkan seda teha igavesti,

872
00:53:13,670 --> 00:53:16,660
ja meie programm on lihtsalt ei hakka lõpetada.

873
00:53:16,660 --> 00:53:19,200
Me nimetame seda tingimust tugipunkti.

874
00:53:19,200 --> 00:53:22,570
Ja tugipunkti ütleb, mitte helistades funktsioon uuesti,

875
00:53:22,570 --> 00:53:25,330
Ma lähen tagasi mingi väärtus.

876
00:53:25,330 --> 00:53:28,080
Nii et kui me oleme tagasi raha, me oleme lõpetanud helistaja ise,

877
00:53:28,080 --> 00:53:32,550
ja ülejäänud kõned oleme teinud seni ka tagasi.

878
00:53:32,550 --> 00:53:36,050
Vastupidine olukord aluseks on rekursiivne juhul.

879
00:53:36,050 --> 00:53:39,050
Ja see on see, kui me tahame võtta uue kõne funktsioon, mille me oleme praegu sisse

880
00:53:39,050 --> 00:53:44,690
Ja me ilmselt, kuigi mitte alati, tahavad kasutada erinevaid argumente.

881
00:53:44,690 --> 00:53:48,940
>> Nii et kui meil on funktsioon nimega f ja f just helistas võtta 1 argument,

882
00:53:48,940 --> 00:53:52,010
ja me muudkui helistades f (1), f (1), f (1), ja see lihtsalt nii juhtub, et

883
00:53:52,010 --> 00:53:56,510
argument 1 kuulub rekursiivne juhul me veel kunagi lõpetada.

884
00:53:56,510 --> 00:54:01,620
Isegi kui meil on alust juhul, me peame tagama, et lõpuks me ei kavatse tabanud, et tugipunkti.

885
00:54:01,620 --> 00:54:04,250
Me ei ole lihtsalt hoida viibiv see rekursiivne juhul.

886
00:54:04,250 --> 00:54:09,870
Üldiselt, kui me nimetame end, me ilmselt läheb on erinev argument iga kord.

887
00:54:09,870 --> 00:54:12,700
Siin on tõesti lihtne rekursiivne funktsioon.

888
00:54:12,700 --> 00:54:15,090
Nii et see arvutab faktoriaali arv.

889
00:54:15,090 --> 00:54:17,790
Up üles siin oleme meie tugipunkt.

890
00:54:17,790 --> 00:54:22,330
Juhul kui n ≤ 1, me ei kavatse helistada faktoriaal uuesti.

891
00:54:22,330 --> 00:54:26,490
Me läheme lõpetada; me lihtsalt läheb tagasi mingi väärtus.

892
00:54:26,490 --> 00:54:30,170
Kui see ei ole tõsi, siis me ei kavatse tabanud meie rekursiivne puhul.

893
00:54:30,170 --> 00:54:33,550
Teade siin, et me ei ole just kutsudes faktoriaal (n), sest see ei oleks väga kasulik.

894
00:54:33,550 --> 00:54:36,810
Me läheme helistada faktoriaali midagi muud.

895
00:54:36,810 --> 00:54:40,850
>> Ja nii näete, lõpuks kui võtame faktoriaal (5) või midagi,

896
00:54:40,850 --> 00:54:45,900
me ei kavatse helistada faktoriaal (4) ja nii edasi, ja lõpuks me ei kavatse tabanud nimetatud aluspõhimõtted.

897
00:54:45,900 --> 00:54:51,730
Nii et see näeb hea välja. Vaatame, mis juhtub, kui me tegelikult teha selle.

898
00:54:51,730 --> 00:54:57,840
See on pinu, ja oletame, et peamine läheb nimetame seda funktsiooni argument (4).

899
00:54:57,840 --> 00:55:02,200
Nii et kui faktoriaali näeb ja = 4 faktoriaal helistab ise.

900
00:55:02,200 --> 00:55:05,010
Nüüd äkki on meil faktoriaal (3).

901
00:55:05,010 --> 00:55:10,780
Nii et need funktsioonid ei kavatse hoida kasvab kuni lõpuks me tabanud meie tugipunkt.

902
00:55:10,780 --> 00:55:17,830
Sel hetkel, tagastatav väärtus on see tagasi (nx tagastatav väärtus seda),

903
00:55:17,830 --> 00:55:21,290
tagastatav väärtus on nx tagastatav väärtus seda.

904
00:55:21,290 --> 00:55:23,290
Lõpuks peame tabanud mõned number.

905
00:55:23,290 --> 00:55:26,560
Ülaosas siin, ütleme return 1.

906
00:55:26,560 --> 00:55:30,650
See tähendab, et kui me tagasi, et number, saame pop see ära pinu.

907
00:55:30,650 --> 00:55:36,570
Nii et see faktoriaal (1) on tehtud.

908
00:55:36,570 --> 00:55:41,190
Kui 1 tagastab selle faktoriaal (1) naaseb, see tagasipöördumine 1.

909
00:55:41,190 --> 00:55:46,910
Tagastatav väärtus see, pidage meeles, oli nx tagastatav väärtus seda.

910
00:55:46,910 --> 00:55:50,720
Nii et äkki see mees teab, et ma tahan tagasi 2.

911
00:55:50,720 --> 00:55:55,910
>> Seega pidage meeles, tagastatav väärtus on see lihtsalt nx tagastatav väärtus siin.

912
00:55:55,910 --> 00:56:01,160
Nüüd saame öelda 3 x 2, ja lõpuks, siin saame öelda

913
00:56:01,160 --> 00:56:04,010
see on lihtsalt saab olema 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
Ja kui see naaseb, me pikali üks täisarv sees peamine.

915
00:56:09,570 --> 00:56:15,460
Iga küsimustele rekursioon?

916
00:56:15,460 --> 00:56:17,090
Hea küll. Nii et seal on rohkem aega küsimuste lõpus,

917
00:56:17,090 --> 00:56:23,360
kuid nüüd Joseph katab ülejäänud teemad.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] Olgu. Nüüd, et me rääkisime recursions,

919
00:56:25,590 --> 00:56:27,840
Räägime natuke mida ühendada sorteerida on.

920
00:56:27,840 --> 00:56:31,740
Merge omamoodi on põhimõtteliselt üks viis sorteerimine nimekirja numbreid.

921
00:56:31,740 --> 00:56:36,430
Ja kuidas see toimib on koos ühendamise omamoodi teil on loetelu, ja mida me teeme, on

922
00:56:36,430 --> 00:56:39,120
ütleme, olgem jagada see jagatakse 2 poolt.

923
00:56:39,120 --> 00:56:42,750
Me esietendus liita omamoodi jälle vasakul pool,

924
00:56:42,750 --> 00:56:45,040
siis me joosta liita omamoodi paremal pool,

925
00:56:45,040 --> 00:56:50,240
ja mis annab meile nüüd 2 poolt, mis on järjestatud ja nüüd me ei kavatse ühendada need pooleks kokku.

926
00:56:50,240 --> 00:56:55,010
See on natuke raske näha ilma näiteks nii me tekevinään ja vaata, mis juhtub.

927
00:56:55,010 --> 00:56:59,590
Nii et kui hakkate seda nimekirja, siis jagati see jagatakse 2 poolt.

928
00:56:59,590 --> 00:57:02,300
Me perspektiivis liita omamoodi vasakul poolel esimesena.

929
00:57:02,300 --> 00:57:06,660
Nii et vasakul pool ja nüüd võtame neid läbi selle nimekirja uuesti

930
00:57:06,660 --> 00:57:09,800
mis saab läks ühendamise sortida ja siis vaatame taas

931
00:57:09,800 --> 00:57:13,270
vasakul pool seda nimekirja ja võtame liita omamoodi ta.

932
00:57:13,270 --> 00:57:15,880
Nüüd pikali nimekirja 2 numbrit,

933
00:57:15,880 --> 00:57:19,010
ja nüüd vasakul pool on ainult 1 element pikk, ja me ei saa

934
00:57:19,010 --> 00:57:23,380
jagada loend, mis on ainult 1 element pooleks, nii me lihtsalt öelda, kui meil on 50,

935
00:57:23,380 --> 00:57:26,400
mis on vaid 1 element, see on juba järjestatud.

936
00:57:26,400 --> 00:57:29,860
>> Kui me ajanud, siis näeme, et me ei

937
00:57:29,860 --> 00:57:32,230
liikuda paremale poole sellest nimekirjast,

938
00:57:32,230 --> 00:57:36,480
ja 3 ka sorteeritud, ja nüüd nii, et mõlemad pooled selle nimekirja on järjestatud

939
00:57:36,480 --> 00:57:39,080
saame liituda need numbrid uuesti kokku.

940
00:57:39,080 --> 00:57:45,320
Nii et me vaatame 50 ja 3; 3 on väiksem kui 50, nii et see läheb esimesse ja siis 50 on sisse

941
00:57:45,320 --> 00:57:49,340
Nüüd on see tehtud; läheme tagasi kuni selle nimekirja sorteerida ning see on paremal pool.

942
00:57:49,340 --> 00:57:52,440
42 on ta enda number, nii et see on juba järjestatud.

943
00:57:52,440 --> 00:57:57,850
Nii et nüüd me võrdleme neid 2 ja 3 on väiksem kui 42, nii et saab panna esmalt

944
00:57:57,850 --> 00:58:02,340
nüüd 42 saab panna, ja 50 saab panna sisse

945
00:58:02,340 --> 00:58:07,220
Nüüd, see on järjestatud me minna kogu tee tagasi tippu, 1337 ja 15.

946
00:58:07,220 --> 00:58:14,560
Noh, me nüüd vaatame vasakule poole sellest nimekirjast; 1337 on iseenesest nii see sorteeritakse ja sama 15.

947
00:58:14,560 --> 00:58:19,020
Nüüd me ühendame need 2 numbrit sorteerida, et esialgses nimekirjas, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
nii läheb see esimene, siis 1337 läheb sisse

949
00:58:23,060 --> 00:58:26,640
Ja nüüd me järjestatud nii poolitatud esialgses nimekirjas üles tippu.

950
00:58:26,640 --> 00:58:30,440
Ja kõik me peame tegema, on ühendada need.

951
00:58:30,440 --> 00:58:36,890
Me vaatame esimesed 2 numbrit sellest lehest, 3 <15, siis see läheb omamoodi massiivi esimene.

952
00:58:36,890 --> 00:58:44,460
15 <42, nii et see läheb sisse Nüüd, 42 <1337, mis läheb sisse

953
00:58:44,460 --> 00:58:51,010
50 <1337, nii see läheb sisse Ja märkate, et me lihtsalt võttis 2 numbrit välja selle nimekirja.

954
00:58:51,010 --> 00:58:53,640
Nii et me ei ole just vaheldumisi 2 on loetletud.

955
00:58:53,640 --> 00:58:56,050
Me lihtsalt otsin alguses, ja me võtame osa

956
00:58:56,050 --> 00:59:00,270
mis on väiksemad ja siis paneb see meie massiivi.

957
00:59:00,270 --> 00:59:04,080
Nüüd oleme ühinenud kõik pooleks ja me oleme valmis.

958
00:59:04,080 --> 00:59:07,780
>> Küsimusi ühendada sorteerida? Jah?

959
00:59:07,780 --> 00:59:14,190
[Student] Kui see on osadeks jaotamine eri rühmadesse, miks ei ole nad lihtsalt jagada seda üks kord

960
00:59:14,190 --> 00:59:19,970
ja sul on 3 ja 2 grupiga? [Välis küsimus arusaamatult]

961
00:59:19,970 --> 00:59:24,940
Põhjus - nii on küsimus selles, miks me ei võiks lihtsalt ühendada neid, et esimene samm pärast meil on neid?

962
00:59:24,940 --> 00:59:29,530
Põhjus, miks me seda teha, alustage kõige vasakpoolsemad elemente mõlemalt poolt,

963
00:59:29,530 --> 00:59:33,040
ja siis võta väiksemat ja pane see, et me teame, et need

964
00:59:33,040 --> 00:59:35,290
üksikute nimekirjad on järjestatud tellimusi.

965
00:59:35,290 --> 00:59:37,290
Nii et kui ma vaatan vasemmanpuolimmaista elemente nii pooleks,

966
00:59:37,290 --> 00:59:40,490
Ma tean, et nad ei kavatse olla väiksemad elemendid need nimekirjad.

967
00:59:40,490 --> 00:59:43,930
Ma võin neid ellu väikseim element täpid selle suure nimekirja.

968
00:59:43,930 --> 00:59:47,810
Teiselt poolt, kui ma vaatan neid 2 on loetletud teises tasandil seal,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 ja 15, need on sorteerimata.

970
00:59:51,640 --> 00:59:55,770
Nii et kui ma vaatan 50 ja 1337, ma panen 50 minu nimekirjas esimene.

971
00:59:55,770 --> 01:00:00,130
Aga see ei ole tegelikult mõtet, sest 3 on väikseim element välja kõik need.

972
01:00:00,130 --> 01:00:04,390
Nii et ainus põhjus, miks me seda teha ühendades samm on, sest meie nimekirjad on juba järjestatud.

973
01:00:04,390 --> 01:00:07,010
Mistõttu me peame maha kõik viis põhjas

974
01:00:07,010 --> 01:00:09,800
sest kui meil on lihtsalt ühe numbri, sa tead, et üks number

975
01:00:09,800 --> 01:00:14,120
ja iseenesest on juba järjestatud nimekirja.

976
01:00:14,120 --> 01:00:19,360
>> Kas on küsimusi? Ei?

977
01:00:19,360 --> 01:00:24,260
Keerukus? Noh, näete, et iga samm seal lõpus numbrid,

978
01:00:24,260 --> 01:00:27,590
ja saame jagada nimekirja pooleks log n korda,

979
01:00:27,590 --> 01:00:31,700
mis on koht, kus saame seda n x log n keerukus.

980
01:00:31,700 --> 01:00:34,940
Ja näete parimal juhul ühendamise sorteerida on n log n, ja see just nii juhtub

981
01:00:34,940 --> 01:00:39,340
et halvimal juhul või Ω seal on ka n log n.

982
01:00:39,340 --> 01:00:42,480
Midagi meeles pidada.

983
01:00:42,480 --> 01:00:45,750
Liikudes edasi, lähme edasi mõned superpõhiõiguseks faili I / O.

984
01:00:45,750 --> 01:00:48,830
Kui sa vaatasid rüselus, märkad meil oli mingisugune süsteem

985
01:00:48,830 --> 01:00:51,270
kuhu võiks kirjutada logifaili kui sa loed läbi koodi.

986
01:00:51,270 --> 01:00:53,730
Vaatame, kuidas sa võiksid seda teha.

987
01:00:53,730 --> 01:00:57,450
Noh, meil on fprintf, mis sa ei mõtle nagu lihtsalt printf,

988
01:00:57,450 --> 01:01:01,720
vaid lihtsalt faili printimiseks asemel, ja seega f alguses.

989
01:01:01,720 --> 01:01:07,570
Selline kood siia üles, mida ta teeb, nagu te olete näinud ka rüselus,

990
01:01:07,570 --> 01:01:12,310
see läheb läbi oma 2-mõõtmeline massiiv trüki välja rida-realt mis numbrid on.

991
01:01:12,310 --> 01:01:17,850
Sel juhul printf prindib välja oma terminali või mida me kutsume standardväljundisse punkti.

992
01:01:17,850 --> 01:01:22,170
>> Ja nüüd, sel juhul kõik me peame tegema, on asendada printf koos fprintf,

993
01:01:22,170 --> 01:01:26,770
öelge mida fail, mida soovite printida, ja sel juhul lihtsalt trükib välja selle faili

994
01:01:26,770 --> 01:01:32,230
selle asemel et lasta välja trükkida oma terminal.

995
01:01:32,230 --> 01:01:36,500
Noh, siis tekib küsimus: Kui me saame sellist faili, eks?

996
01:01:36,500 --> 01:01:39,840
Me sooritanud sisse see fprintf fuction kuid meil polnud aimugi, kus see tuli.

997
01:01:39,840 --> 01:01:43,980
Noh, alguses kood, mis meil oli, oli see patakas kood siia,

998
01:01:43,980 --> 01:01:48,340
mis põhimõtteliselt ütleb, et avatud fail nõuab log.txt.

999
01:01:48,340 --> 01:01:53,220
Mida me teeme pärast seda on meil veenduda, et fail on tegelikult avati edukalt.

1000
01:01:53,220 --> 01:01:57,070
Seega ei pruugi ühtida Mitmetel põhjustel; teil ei ole piisavalt ruumi arvutis, näiteks.

1001
01:01:57,070 --> 01:01:59,790
Nii see on alati oluline enne kui teha mingeid toiminguid failiga

1002
01:01:59,790 --> 01:02:03,300
et me kontrollime, kas see fail avati edukalt.

1003
01:02:03,300 --> 01:02:09,330
Mis siis, et see on argument, et fopen, noh, me avada faili mitmeti.

1004
01:02:09,330 --> 01:02:13,510
Mida me saame teha on, me edastame selle w, mis tähendab alistada faili, kui see väljub juba,

1005
01:02:13,510 --> 01:02:18,070
Me ei liigu, mis nad lisab faili lõppu asemel ülekaaluka see,

1006
01:02:18,070 --> 01:02:22,730
või saame määrata r, mis tähendab, lähme avage fail ainult lugemiseks.

1007
01:02:22,730 --> 01:02:24,890
Nii et kui programm püüab teha muudatusi faili,

1008
01:02:24,890 --> 01:02:30,140
karju neid ja ei lase neil seda teha.

1009
01:02:30,140 --> 01:02:33,320
Lõpuks, kui me teinud failiga, Valmis teevad operatsioone see,

1010
01:02:33,320 --> 01:02:35,860
me peame tagama, me sulgeda fail.

1011
01:02:35,860 --> 01:02:38,830
Ja nii lõpuks oma programmi, te ei kavatse anda need uuesti

1012
01:02:38,830 --> 01:02:42,120
Selle faili avanud, ja kohe sulgeda.

1013
01:02:42,120 --> 01:02:44,650
Nii et see on midagi olulist, et sa pead veenduge, et te teete.

1014
01:02:44,650 --> 01:02:47,180
Seega pidage meeles, saate avada faili, siis võite kirjutada faili

1015
01:02:47,180 --> 01:02:51,270
teha toiminguid faili, kuid siis sa pead sulgeda fail lõpus.

1016
01:02:51,270 --> 01:02:53,270
>> Kõik küsimused üldiste faili I / O? Jah?

1017
01:02:53,270 --> 01:02:58,050
[Student küsimus, arusaamatult]

1018
01:02:58,050 --> 01:03:02,480
Siinsamas. Küsimus on selles, kus ei see log.txt faili ilmuvad?

1019
01:03:02,480 --> 01:03:07,890
Noh, kui sa lihtsalt anna see log.txt, loob see samas kataloogis käivitatav.

1020
01:03:07,890 --> 01:03:10,500
Nii et kui Sa - >> [Student küsimus, arusaamatult]

1021
01:03:10,500 --> 01:03:18,830
Jah. Samas kaustas, või samas kataloogis, nagu sa seda nimetad.

1022
01:03:18,830 --> 01:03:21,400
Nüüd mälu, korstnat ning hunnik.

1023
01:03:21,400 --> 01:03:23,400
Niisiis, kuidas on mälu sätestatud arvuti?

1024
01:03:23,400 --> 01:03:26,270
Noh, te võite ette kujutada mälu omamoodi seda plokki siin.

1025
01:03:26,270 --> 01:03:30,260
Ja mälu on meil, mida nimetatakse hunnik ummikus seal ja korstna et seal all.

1026
01:03:30,260 --> 01:03:34,480
Ja hunnik kasvab allapoole ja korstna kasvab ülespoole.

1027
01:03:34,480 --> 01:03:38,620
Nii nagu Tommy mainitud - oh, hästi, ja meil on need teised 4 segmenti, mis ma saan teises -

1028
01:03:38,620 --> 01:03:42,890
Nagu Tommy ütlesin, sa tead, kuidas oma ülesandeid nimetavad end ja kutsuvad üksteist?

1029
01:03:42,890 --> 01:03:44,930
Nad püstitavad selline freimi.

1030
01:03:44,930 --> 01:03:47,360
Noh, kui peamised kõned suva, suva saab panna virna.

1031
01:03:47,360 --> 01:03:52,430
Foo nõuab, baar saada on panna virna, ja et saab panna virna pärast.

1032
01:03:52,430 --> 01:03:57,040
Ja kui nad pöörduvad nad iga saada maha võetud pinu.

1033
01:03:57,040 --> 01:04:00,140
Mida kõik need kohad ja mälu omada?

1034
01:04:00,140 --> 01:04:03,110
Noh, top, mis on tekstiosa, sisaldab programm ise.

1035
01:04:03,110 --> 01:04:06,390
Nii et masin kood, mis on seal, kui sa kompileerida programm.

1036
01:04:06,390 --> 01:04:08,520
Järgmiseks tahes käivitub globaalsed muutujad.

1037
01:04:08,520 --> 01:04:12,660
>> Nii et teil on globaalsed muutujad oma programmi, ja sa ütled nagu, = 5,

1038
01:04:12,660 --> 01:04:15,260
et saab panna selle segmendi ja õigus all, et

1039
01:04:15,260 --> 01:04:18,990
teil on uninitialized globaalsete andmete, mis on lihtsalt int,

1040
01:04:18,990 --> 01:04:20,990
aga sa ei saa öelda, et see on võrdne midagi.

1041
01:04:20,990 --> 01:04:23,870
Aru need on globaalsed muutujad, nii et nad on väljaspool peamist.

1042
01:04:23,870 --> 01:04:28,560
Nii et see tähendab kõiki globaalseid muutujaid, mis on deklareeritud, kuid ei ole vormindatud.

1043
01:04:28,560 --> 01:04:32,310
Mis siis on hunnik? Mälu eraldamisel kasutatakse malloc, mis me jõuame ka natuke.

1044
01:04:32,310 --> 01:04:35,990
Ja lõpuks, kui pinu teil on lokaalsete muutujate

1045
01:04:35,990 --> 01:04:39,950
ja kõik funktsioonid võite helistada igal oma parameetrid.

1046
01:04:39,950 --> 01:04:43,720
Viimane asi, sa tõesti ei pea teadma, mida keskkonnamuutujaid teha,

1047
01:04:43,720 --> 01:04:46,700
kuid kui sa jooksed programm, seal on midagi seotud, nagu

1048
01:04:46,700 --> 01:04:49,550
see on isiku nimi, kes jooksis programm.

1049
01:04:49,550 --> 01:04:51,550
Ja see saab olema omamoodi allosas.

1050
01:04:51,550 --> 01:04:54,540
Seoses mälu aadressid, mis on kuueteistkümnendväärtused,

1051
01:04:54,540 --> 01:04:58,170
väärtused ülaosas start kell 0, ja nad lähevad kõik viis alaserva.

1052
01:04:58,170 --> 01:05:00,440
Sel juhul kui sa oled 32-bitine süsteem,

1053
01:05:00,440 --> 01:05:05,390
aadress allosas saab olema 0x, millele järgneb automaatne teravustamine, sest see on 32 bitti,

1054
01:05:05,390 --> 01:05:10,890
mis on 8 baiti, ja sel juhul 8 baiti vastab kuni 8 kuueteistkümnendarvudega.

1055
01:05:10,890 --> 01:05:20,110
Nii et siin all sa lähed on, nagu, 0xffffff, ja seal sa lähed on 0.

1056
01:05:20,110 --> 01:05:23,660
Millised on viiteid? Mõned teist ei katnud seda osa enne.

1057
01:05:23,660 --> 01:05:26,660
kuid me ei lähe üle selle loengu, et osuti on lihtsalt andmetüüp

1058
01:05:26,660 --> 01:05:34,030
mis kauplustes asemel mingi väärtus nagu 50, siis salvestab aadress mõned asukohta mälus.

1059
01:05:34,030 --> 01:05:36,020
Nagu et mälu [arusaamatu].

1060
01:05:36,020 --> 01:05:41,120
Nii et antud juhul, mida meil on, meil on viit täisarv või int *,

1061
01:05:41,120 --> 01:05:46,210
ja see sisaldab seda kuueteistkümnendsüsteemis aadress 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Mis meil on, nüüd on see osuti osutab teatud asukohta mälus,

1063
01:05:50,880 --> 01:05:56,020
ja see on lihtsalt, väärtus 50 on selles mälukohta.

1064
01:05:56,020 --> 01:06:01,810
On mõned 32-bitised süsteemid, kõigi 32-bitiste süsteemide, viiteid asuda 32 bitti või 4 baiti.

1065
01:06:01,810 --> 01:06:06,020
Aga näiteks 64-bitine süsteem, osuti on 64 bitti.

1066
01:06:06,020 --> 01:06:08,040
Nii et see on midagi, mida sa tahad meeles pidada.

1067
01:06:08,040 --> 01:06:12,310
Nii et lõpuks-bitine süsteem, osuti on lõpuks bitti pikk.

1068
01:06:12,310 --> 01:06:17,320
Näiturid on omamoodi raske seedida ilma ekstra asju,

1069
01:06:17,320 --> 01:06:20,300
nii lähme läbi näide dünaamiline mälu eraldamisel.

1070
01:06:20,300 --> 01:06:25,130
Mis dünaamiline mälu eraldamise ei teile, või mida me kutsume malloc,

1071
01:06:25,130 --> 01:06:29,280
see võimaldab teil eraldada mingi andmed väljaspool etteantud.

1072
01:06:29,280 --> 01:06:31,830
Nii et see info on omamoodi püsivam ajaks programm.

1073
01:06:31,830 --> 01:06:36,430
Sest nagu te teate, kui te deklareerite x sees funktsiooni, ja et tagastab funktsioon,

1074
01:06:36,430 --> 01:06:40,910
sa ei pea enam juurdepääs andmetele, mis oli salvestatud x.

1075
01:06:40,910 --> 01:06:44,420
Mis suunanäitajaks tehkem on nad andke meile salvestada mällu või kaupluse väärtused

1076
01:06:44,420 --> 01:06:46,840
erinevas segmendis mälu, nimelt hunnik.

1077
01:06:46,840 --> 01:06:49,340
Nüüd, kui me tagasi välja funktsioon, nii kaua kui meil on pointer

1078
01:06:49,340 --> 01:06:54,960
selle asukohta mälus, siis mida me teha saame, on meil võimalik lihtsalt pilk väärtusi seal.

1079
01:06:54,960 --> 01:06:58,020
Vaatame näiteks: See on meie mälu paigutus uuesti.

1080
01:06:58,020 --> 01:07:00,050
Ja meil on see funktsioon, peamised.

1081
01:07:00,050 --> 01:07:06,870
Mis see on - okei, nii lihtne, eks? - Int x = 5, see on lihtsalt muutuja korstnat peamine.

1082
01:07:06,870 --> 01:07:12,450
>> Teiselt poolt, nüüd me kuulutame pointer, milles kutsutakse funktsioon giveMeThreeInts.

1083
01:07:12,450 --> 01:07:16,800
Ja nüüd me läheme sinna see funktsioon ja me luua uue freimi ta.

1084
01:07:16,800 --> 01:07:20,440
Kuid see freimi, me kuulutame int * temp,

1085
01:07:20,440 --> 01:07:23,210
mis mallocs 3 täisarvud meile.

1086
01:07:23,210 --> 01:07:25,880
Nii suurus int annab meile mitu baiti see int on,

1087
01:07:25,880 --> 01:07:29,620
ja malloc annab meile, et paljud baiti ruumi hunnik.

1088
01:07:29,620 --> 01:07:32,890
Nii et sel juhul oleme loonud piisavalt ruumi 3 täisarvud,

1089
01:07:32,890 --> 01:07:36,830
ja hunnik on viis sinna, mistõttu ma olen ära, kõrgemal.

1090
01:07:36,830 --> 01:07:42,900
Kui me oleme valmis, me tuleme tagasi siia, sa vaja ainult 3 ints tagasi,

1091
01:07:42,900 --> 01:07:47,000
ja ta naaseb aadress, käesoleval juhul üle, kui et mälu on.

1092
01:07:47,000 --> 01:07:51,250
Ja seadsime pointer = lüliti, ja seal on meil lihtsalt üks osuti.

1093
01:07:51,250 --> 01:07:54,550
Aga mida see tagastab funktsioon on laotud siin ja kaob.

1094
01:07:54,550 --> 01:07:59,250
Nii temp kaob, kuid me siiski säilitada aadress, kus

1095
01:07:59,250 --> 01:08:01,850
need 3 täisarvud on sees vooluvõrku.

1096
01:08:01,850 --> 01:08:06,180
Nii et selles komplektis, osuti on scoped kohalikke laotud raam,

1097
01:08:06,180 --> 01:08:09,860
aga mälu, millele nad viitavad on hunnik.

1098
01:08:09,860 --> 01:08:12,190
>> Kas see on loogiline?

1099
01:08:12,190 --> 01:08:14,960
[Student] Kas te saaksite seda korrata? >> [Joseph] Jah.

1100
01:08:14,960 --> 01:08:20,270
Nii et kui ma lähen tagasi natuke, näed, et temp eraldatud

1101
01:08:20,270 --> 01:08:23,500
mõned mälu hunnik seal.

1102
01:08:23,500 --> 01:08:28,680
Nii et kui see funktsioon, giveMeThreeInts naaseb, see korstna siin läheb kaduma.

1103
01:08:28,680 --> 01:08:35,819
Ja see kõik muutujad, antud juhul see pointer, mis oli eraldatud laotud raam.

1104
01:08:35,819 --> 01:08:39,649
See läheb kaduma, kuid kuna me tagasi temp

1105
01:08:39,649 --> 01:08:46,330
ja seadsime pointer = temp, osuti on nüüd lähed juhtida sama mälu asukohta temp oli.

1106
01:08:46,330 --> 01:08:50,370
Nüüd, kuigi me kaotame temp, et kohalikud pointer,

1107
01:08:50,370 --> 01:08:59,109
me siiski säilitada mälu aadressi, mis see oli suunatud sissepoole selle muutuja pointer.

1108
01:08:59,109 --> 01:09:03,740
Küsimused? See võib olla mingi segane teema, kui te ei ole läinud üle punktis.

1109
01:09:03,740 --> 01:09:09,240
Saame, oma TF kindlasti minna sellest üle ja muidugi saame vastata küsimustele

1110
01:09:09,240 --> 01:09:11,500
aasta lõpus läbivaatamise istungil selle eest.

1111
01:09:11,500 --> 01:09:14,220
Aga see on omamoodi keeruline teema, ja mul on rohkem näiteid, et ei kavatse näidata üles

1112
01:09:14,220 --> 01:09:18,790
mis aitab selgitada, mida osuti tegelikult on.

1113
01:09:18,790 --> 01:09:22,500
>> Sel juhul osuti on samaväärne massiivid

1114
01:09:22,500 --> 01:09:25,229
et ma saaks lihtsalt kasutada seda pointer kui sama asi nagu int massiiv.

1115
01:09:25,229 --> 01:09:29,840
Nii et ma olen indekseerimise arvesse 0, ja muutes esimest täisarv 1,

1116
01:09:29,840 --> 01:09:39,689
muutuvas teine ​​täisarv 2 ja 3. täisarv 3.

1117
01:09:39,689 --> 01:09:44,210
Nii et rohkem viiteid. Noh, mäletate Binky.

1118
01:09:44,210 --> 01:09:48,319
Sellisel juhul oleme eraldatud pointer, või me kuulutasime pointer,

1119
01:09:48,319 --> 01:09:52,760
kuid esialgu, kui ma lihtsalt deklareeritud pointer, see ei osutades kuskil mälus.

1120
01:09:52,760 --> 01:09:54,930
See on lihtsalt prügi väärtused sees on.

1121
01:09:54,930 --> 01:09:56,470
Nii et ma ei tea, kus see osuti osutab.

1122
01:09:56,470 --> 01:10:01,630
See on aadress, mis on lihtsalt täis 0-ja 1-ndatel, kus see algselt deklareeritud.

1123
01:10:01,630 --> 01:10:04,810
Ma ei saa midagi teha selle kuni ma kutsun malloc peal

1124
01:10:04,810 --> 01:10:08,390
ja siis see annab mulle vähe ruumi hunnik kus ma saan panna väärtused sees.

1125
01:10:08,390 --> 01:10:11,980
Aga samas, ma ei tea, mis seal sees on see mälu.

1126
01:10:11,980 --> 01:10:16,780
Nii et esimene asi, mida ma pean tegema, on vaadata, kas süsteem oli piisavalt mälu

1127
01:10:16,780 --> 01:10:20,850
mulle tagasi 1 täisarv esiteks, mistõttu ma teen seda kontrollida.

1128
01:10:20,850 --> 01:10:25,020
Kui osuti on null, mis tähendab, et tal ei ole piisavalt ruumi või mingi muu viga,

1129
01:10:25,020 --> 01:10:26,320
nii et ma peaks väljuda mu programmi.

1130
01:10:26,320 --> 01:10:29,400
 Aga kui see õnnestuks, nüüd ma saan kasutada, et osuti

1131
01:10:29,400 --> 01:10:35,020
ja mida * pointer ei ole see järgmiselt kus aadress on

1132
01:10:35,020 --> 01:10:38,480
et kui see väärtus on, ja see teeb ta võrdne 1.

1133
01:10:38,480 --> 01:10:41,850
Nii siin, me uurime, kui et mälu olemas.

1134
01:10:41,850 --> 01:10:45,380
>> Kui tead, see on olemas, võid panna sinna

1135
01:10:45,380 --> 01:10:50,460
Mis väärtus, mida soovite pannakse ta, sel juhul 1.

1136
01:10:50,460 --> 01:10:53,060
Kui me teinud seda, mida vaja vabastada, et osuti

1137
01:10:53,060 --> 01:10:57,160
sest me peame minema tagasi süsteemi, mis mälu, et sa palusid esiteks.

1138
01:10:57,160 --> 01:10:59,690
Kuna arvuti ei tea, kui me teinud seda.

1139
01:10:59,690 --> 01:11:02,510
Sel juhul me selgesõnaliselt öelnud seda, okei, me oleme valmis selle mälu.

1140
01:11:02,510 --> 01:11:10,780
Kui mõni teine ​​protsess seda vajab, mõni teine ​​programm seda vajab, võid vabalt minna ja võtta see.

1141
01:11:10,780 --> 01:11:15,110
Mida saame teha ka ei saa me lihtsalt saada aadressile kohalike muutujate kogum.

1142
01:11:15,110 --> 01:11:19,080
Nii int x on sees laotud raami peamine.

1143
01:11:19,080 --> 01:11:23,060
Ja kui me kasutame seda ampersand see ja operaator, mida ta teeb on

1144
01:11:23,060 --> 01:11:27,310
kulub x ja x on lihtsalt mõned andmed mällu, kuid see on aadress.

1145
01:11:27,310 --> 01:11:33,790
See asub kuskil. Nii kutsudes & x, mida see teeb, on see annab meile aadressi x.

1146
01:11:33,790 --> 01:11:38,430
Seda tehes teeme osuti punkti, kus x on mälu.

1147
01:11:38,430 --> 01:11:41,710
Nüüd me lihtsalt ei midagi * x, me ei kavatse saada 5 tagasi.

1148
01:11:41,710 --> 01:11:43,820
Star nimetatakse viite mahavõtmine ta.

1149
01:11:43,820 --> 01:11:46,640
Sa järgige aadress ja sa saad väärtust see seal ladustatud.

1150
01:11:51,000 --> 01:11:53,310
>> Kas on küsimusi? Jah?

1151
01:11:53,310 --> 01:11:56,500
[Student] Kui sa ei tee 3-otsaga asi, see ikka kompileerida?

1152
01:11:56,500 --> 01:11:59,490
Jah. Kui sa ei tee 3-pointer asi, see on ikka veel koostamisel,

1153
01:11:59,490 --> 01:12:02,720
kuid ma näitan sulle, mis juhtub teist ja ilma tehes,

1154
01:12:02,720 --> 01:12:04,860
see on, mida me nimetame mälu leke. Sa ei anna süsteem

1155
01:12:04,860 --> 01:12:07,850
tagasi oma mälu, nii et mõne aja pärast programmi saab koguneda

1156
01:12:07,850 --> 01:12:10,940
mälu, et see ei kasuta, ja ei midagi muud seda kasutada.

1157
01:12:10,940 --> 01:12:15,750
Kui sa oled kunagi näinud Firefox 1,5 miljonit kilobaiti arvuti

1158
01:12:15,750 --> 01:12:17,840
aastal Task Manager, mis on mis toimub.

1159
01:12:17,840 --> 01:12:20,760
Sul on mälu leke programmis, et nad ei käitle.

1160
01:12:23,080 --> 01:12:26,240
Niisiis, kuidas pointer aritmeetika toimib?

1161
01:12:26,240 --> 01:12:29,480
Noh, pointer aritmeetika on omamoodi nagu indekseerimine massiivi.

1162
01:12:29,480 --> 01:12:36,370
Sel juhul on mul pointer, ja mida ma teen on ma teha kursor punkti esimese osa

1163
01:12:36,370 --> 01:12:42,100
Selle massiivi 3 täisarvud, et ma olen eraldatud.

1164
01:12:42,100 --> 01:12:46,670
Nii et nüüd ma teen, täht osuti lihtsalt muutub esimene element nimekirjas.

1165
01:12:46,670 --> 01:12:49,140
Star osuti +1 punkte siin.

1166
01:12:49,140 --> 01:12:53,140
Nii et kursor asub siin, osuti +1 on siin, osuti 2 on siin.

1167
01:12:53,140 --> 01:12:56,610
>> Nii lihtsalt lisada 1 on sama asi nagu liigub mööda seda massiivi.

1168
01:12:56,610 --> 01:12:59,880
Mida me teeme on, kui me teeme pointer 1 saad aadress siia,

1169
01:12:59,880 --> 01:13:04,180
ja selleks, et saada väärtus siin, paned täht alates kogu avaldis

1170
01:13:04,180 --> 01:13:05,990
kuni dereference ta.

1171
01:13:05,990 --> 01:13:09,940
Niisiis, sel juhul ma panen esimest asukohta selles massiivi 1

1172
01:13:09,940 --> 01:13:13,970
teine ​​asukoht 2 ja kolmandas kohas kuni 3.

1173
01:13:13,970 --> 01:13:18,180
Siis mida ma teen siin on mul trükkimine meie osuti +1,

1174
01:13:18,180 --> 01:13:19,970
mis lihtsalt annab mulle 2.

1175
01:13:19,970 --> 01:13:23,650
Nüüd ma incrementing osuti, nii osuti võrdub osuti +1,

1176
01:13:23,650 --> 01:13:26,780
mis liigub see edasi.

1177
01:13:26,780 --> 01:13:30,810
Ja nii nüüd kui ma välja printida osuti +1, osuti +1 on nüüd 3,

1178
01:13:30,810 --> 01:13:33,990
mis antud juhul prindib välja 3.

1179
01:13:33,990 --> 01:13:36,560
Ja selleks, et tasuta midagi, pointer, et ma annan selle

1180
01:13:36,560 --> 01:13:40,540
tuleb osutades alguses massiivi mille sain tagasi malloc.

1181
01:13:40,540 --> 01:13:43,430
Niisiis, sel juhul kui ma kõne 3 siin, see ei ole õige,

1182
01:13:43,430 --> 01:13:45,070
sest see on keset massiivi.

1183
01:13:45,070 --> 01:13:48,820
Ma pean lahutama, et saada oma algsesse asukohta

1184
01:13:48,820 --> 01:13:50,420
esialgse esimene spot enne kui ma võin vabastada ta.

1185
01:13:56,300 --> 01:13:58,450
Nii, siin on rohkem kaasatud näiteks.

1186
01:13:58,450 --> 01:14:03,360
Sel juhul me eraldades 7 sümbolit iseloomu massiivi.

1187
01:14:03,360 --> 01:14:06,480
>> Ja sel juhul, mida me teeme on meil silmuspõletamise üle esimene neist 6,

1188
01:14:06,480 --> 01:14:09,900
ja me milles neil Z.

1189
01:14:09,900 --> 01:14:13,350
Niisiis, int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Niisiis, pointer + i lihtsalt annab meile sel juhul,

1191
01:14:16,220 --> 01:14:20,860
pointer, pointer +1, osuti +2, osuti +3, ja nii edasi ja nii edasi silmus.

1192
01:14:20,860 --> 01:14:24,040
Mis see saab teha, on see läheb sellele aadressile, dereferences, et saada väärtus,

1193
01:14:24,040 --> 01:14:27,440
ja muutusi, mis väärtust Z.

1194
01:14:27,440 --> 01:14:30,350
Siis lõpus meenub see string, eks?

1195
01:14:30,350 --> 01:14:33,560
Kõik stringid peavad lõppema null lõpetatakse märk.

1196
01:14:33,560 --> 01:14:38,620
Niisiis, mida ma teen on osuti 6 panin null terminaator iseloomu sisse

1197
01:14:38,620 --> 01:14:43,980
Ja nüüd, mida ma põhimõtteliselt teed siin rakendab printf jaoks string, eks?

1198
01:14:43,980 --> 01:14:46,190
>> Seega, kui ei printf nüüd, kui ta on jõudnud string?

1199
01:14:46,190 --> 01:14:48,230
Kui see tabab null lõpetatakse märk.

1200
01:14:48,230 --> 01:14:52,030
Niisiis, sel juhul minu originaal osuti osutab alguses massiivi.

1201
01:14:52,030 --> 01:14:56,410
Ma printida esimene märk välja. Ma seda üle ühe.

1202
01:14:56,410 --> 01:14:58,420
Ma printida, et märk välja. Ma liigutada üle.

1203
01:14:58,420 --> 01:15:02,180
Ja ma saan seda teha enne, kui ma jõuda lõppu.

1204
01:15:02,180 --> 01:15:07,750
Ja nüüd lõpuks * pointer dereference see ja saada null lõpetatakse märk tagasi.

1205
01:15:07,750 --> 01:15:11,780
Ja nii minu kui silmus jookseb ainult, et väärtus ei ole null lõpetatakse märk.

1206
01:15:11,780 --> 01:15:13,770
Nii, nüüd ma väljuda see silmus.

1207
01:15:18,780 --> 01:15:21,180
Ja nii kui ma lahutan 6 alates käesoleva pointer,

1208
01:15:21,180 --> 01:15:22,860
Ma lähen tagasi kõik viis alguses.

1209
01:15:22,860 --> 01:15:27,880
Pea meeles, et ma teen seda, sest ma pean minema algul, et vabastada ta.

1210
01:15:27,880 --> 01:15:30,270
>> Niisiis, ma tean, et oli palju. Kas on küsimusi?

1211
01:15:30,270 --> 01:15:31,870
Palun, jah?

1212
01:15:31,870 --> 01:15:36,610
[Student küsimus arusaamatult]

1213
01:15:36,610 --> 01:15:38,190
Kas oskate öelda, et valjem? Vabandust.

1214
01:15:38,190 --> 01:15:44,140
[Student] Viimasel slaidil õigus enne vabanenud pointer,

1215
01:15:44,140 --> 01:15:47,300
kus sa tegelikult muutuv väärtus pointer?

1216
01:15:47,300 --> 01:15:50,370
[Joseph] Niisiis, siin. >> [Student] Oh, okei.

1217
01:15:50,370 --> 01:15:51,890
[Joseph] Nii, mul on osuti miinus miinus, paremale,

1218
01:15:51,890 --> 01:15:54,140
mis liigub asi võrra tagasi ja siis ma vaba ta,

1219
01:15:54,140 --> 01:15:57,000
sest see pointer tuleb märkida, et alguses massiivi.

1220
01:15:57,000 --> 01:16:00,420
[Student] Aga et ei oleks vaja olnud te lõpetasite pärast, et rida.

1221
01:16:00,420 --> 01:16:03,130
[Joseph] Niisiis, kui ma poleks peatunud pärast seda, seda võiks pidada Mälulekke

1222
01:16:03,130 --> 01:16:04,810
sest ma ei jooksnud tasuta.

1223
01:16:04,810 --> 01:16:11,290
[Student] I [arusaamatu] pärast esimese kolme kuhu oli osuti 1 [arusaamatu].

1224
01:16:11,290 --> 01:16:13,140
[Joseph] Ja-jah. Niisiis, milline on küsimus olemas?

1225
01:16:13,140 --> 01:16:14,780
Vabandust. Ei, ei. Mine, mine, palun.

1226
01:16:14,780 --> 01:16:16,870
[Student] Niisiis, te ei muuda väärtus suunanäitajaks.

1227
01:16:16,870 --> 01:16:19,130
Sa ei oleks pidanud tegema osuti miinus miinus.

1228
01:16:19,130 --> 01:16:19,730
[Joseph] Jah, just.

1229
01:16:19,730 --> 01:16:21,890
Niisiis, kui ma osuti +1 ja osuti +2,

1230
01:16:21,890 --> 01:16:24,410
Ma ei tee pointer võrdub osuti +1.

1231
01:16:24,410 --> 01:16:27,260
Niisiis, osuti lihtsalt jääb suunaga alguses massiivi.

1232
01:16:27,260 --> 01:16:31,460
See on ainult siis, kui ma teen pluss pluss, et see seab väärtus tagasi sees osuti,

1233
01:16:31,460 --> 01:16:33,550
et ta tegelikult liigub see mööda.

1234
01:16:36,860 --> 01:16:37,780
Hea küll.

1235
01:16:40,550 --> 01:16:42,030
Veel küsimusi?

1236
01:16:44,680 --> 01:16:47,790
>> Jällegi, kui see on omamoodi suur, see kaetakse istung.

1237
01:16:47,790 --> 01:16:50,710
Küsige oma õpetamise mehe about it, ja me võime vastata lõpus.

1238
01:16:53,510 --> 01:16:56,600
Ja tavaliselt me ​​ei taha seda teha miinus asi.

1239
01:16:56,600 --> 01:16:59,760
See on nõuda mind jälgida, kui palju ma olen kompenseerida massiiv.

1240
01:16:59,760 --> 01:17:04,520
Nii et üldiselt see on lihtsalt selgitada, kuidas pointer aritmeetika töötab.

1241
01:17:04,520 --> 01:17:07,970
Aga mida me tavaliselt tahaksin teha, on meile meeldib luua koopia pointer,

1242
01:17:07,970 --> 01:17:11,640
ja siis me kasutame seda koopiat, kui me liigume ringi string.

1243
01:17:11,640 --> 01:17:14,660
Niisiis, nendes Kui kasutate koopia printida kogu stringi,

1244
01:17:14,660 --> 01:17:19,040
kuid me ei pea tegema nagu osuti miinus 6 või jälgida, kui palju me kolisime selles,

1245
01:17:19,040 --> 01:17:22,700
lihtsalt sellepärast, et me teame, et meie algne mõte on ikka osutas alguses nimekirja

1246
01:17:22,700 --> 01:17:25,340
ja kõik, mida me muuta oli see koopia.

1247
01:17:25,340 --> 01:17:28,250
Nii et üldiselt muuda koopiad oma algse pointer.

1248
01:17:28,250 --> 01:17:32,350
Ärge püüdke omamoodi nagu - ära muuda eksemplaris.

1249
01:17:32,350 --> 01:17:35,290
Proovin muuta ainult koopiad oma originaal.

1250
01:17:41,540 --> 01:17:44,870
Niisiis, te teate, kui võtame string printf

1251
01:17:44,870 --> 01:17:48,990
sa ei pea panna täht ees on nagu me tegime kõigi teiste dereferences, eks?

1252
01:17:48,990 --> 01:17:54,180
Niisiis, kui sa välja printida kogu string% s loodab on aadress,

1253
01:17:54,180 --> 01:17:57,610
ja sel juhul osuti või antud juhul, nagu array tähemärki.

1254
01:17:57,610 --> 01:18:00,330
>> Tegelased, char * s, ja massiivid on sama asi.

1255
01:18:00,330 --> 01:18:03,690
Pointer on märki ja iseloomu massiivid on sama asi.

1256
01:18:03,690 --> 01:18:05,720
Ja nii kõik me peame tegema, on läbida pointer.

1257
01:18:05,720 --> 01:18:08,150
Me ei pea läbima nagu * pointer või midagi sellist.

1258
01:18:13,110 --> 01:18:14,930
Niisiis, massiivid ja viiteid on sama asi.

1259
01:18:14,930 --> 01:18:19,160
Kui sa teed midagi x [y] üle siin massiiv,

1260
01:18:19,160 --> 01:18:21,960
mida ta teeb kapoti alla on ta ütleb, okei, see on märk massiiv,

1261
01:18:21,960 --> 01:18:23,690
nii et see on osuti.

1262
01:18:23,690 --> 01:18:26,510
Ja nii x on sama asi,

1263
01:18:26,510 --> 01:18:28,650
ja mis siis see ei ole see lisab y x,

1264
01:18:28,650 --> 01:18:31,820
mis on sama asi nagu liigub edasi mälu, et palju.

1265
01:18:31,820 --> 01:18:34,930
Ja nüüd x + y annab meile mingi aadressi,

1266
01:18:34,930 --> 01:18:37,570
ja me dereference aadress või Järgige noolt

1267
01:18:37,570 --> 01:18:41,640
et kui see asukohta mälus on ja saame raha välja, et asukohta mälus.

1268
01:18:41,640 --> 01:18:43,720
Nii, et need kaks on täpselt sama asi.

1269
01:18:43,720 --> 01:18:45,840
See on lihtsalt süntaktiliste suhkur.

1270
01:18:45,840 --> 01:18:48,090
Nad teevad sama asja. Nad on lihtsalt erinevad süntaktika teineteise jaoks.

1271
01:18:51,500 --> 01:18:57,590
>> Niisiis, mis võib minna valesti viiteid? Nagu, väga palju. Okei. Niisiis, halbu asju.

1272
01:18:57,590 --> 01:19:02,410
Mõned halvad asjad, mida saate teha ei kontrollida, kas teie malloc kõne tagastab null, eks?

1273
01:19:02,410 --> 01:19:06,560
Sellisel juhul ma palun süsteem mulle - mis see number?

1274
01:19:06,560 --> 01:19:11,200
Nagu 2 miljardit korda 4, sest suurus täisarv on 4 baiti.

1275
01:19:11,200 --> 01:19:13,810
Ma küsin seda nagu 8 miljardit baiti.

1276
01:19:13,810 --> 01:19:17,270
Muidugi minu arvuti ei kavatse olla võimeline andma mulle, et palju mälu tagasi.

1277
01:19:17,270 --> 01:19:20,960
Ja me ei kontrollinud, kui see on null, nii et kui me püüame dereference see sinna -

1278
01:19:20,960 --> 01:19:24,270
Järgige noolt, kus see läheb - me ei ole seda mälu.

1279
01:19:24,270 --> 01:19:27,150
See on see, mida me nimetame viite mahavõtmine nullviida.

1280
01:19:27,150 --> 01:19:29,710
Ja see sisuliselt põhjustab teile segfault.

1281
01:19:29,710 --> 01:19:31,790
See on üks viis, kuidas saate segfault.

1282
01:19:34,090 --> 01:19:38,090
Muud halbu asju, mida saate teha - oh well.

1283
01:19:38,090 --> 01:19:40,650
See oli viite mahavõtmine nullviida. Okei.

1284
01:19:40,650 --> 01:19:45,160
Muud halbu asju - noh, määrata, et sa lihtsalt panna kontrolli seal

1285
01:19:45,160 --> 01:19:46,980
mis kontrollib, kas osuti on null

1286
01:19:46,980 --> 01:19:51,000
ja väljuda programmist, kui juhtub, et malloc tagastab null pointer.

1287
01:19:55,110 --> 01:19:59,850
See on XKCD koomiline. Inimesed mõistavad seda nüüd. Või midagi.

1288
01:20:06,120 --> 01:20:09,350
>> Niisiis, mälu. Ja ma läksin üle selle.

1289
01:20:09,350 --> 01:20:12,000
Me nimetame malloc tsüklina, kuid iga kord kui me kutsume malloc

1290
01:20:12,000 --> 01:20:14,370
me kaotada jälgida, kui see osuti osutab,

1291
01:20:14,370 --> 01:20:15,750
sest me clobbering ta.

1292
01:20:15,750 --> 01:20:18,410
Niisiis, esimese kõne malloc annab mulle mälu siin.

1293
01:20:18,410 --> 01:20:19,990
Minu kursor viiteid sellele.

1294
01:20:19,990 --> 01:20:23,020
Nüüd ma ei vabastaks see, et nüüd ma kutsun malloc uuesti.

1295
01:20:23,020 --> 01:20:26,070
Nüüd toob ta siia. Nüüd minu mälu on suunaga siia.

1296
01:20:26,070 --> 01:20:27,640
Juhtides siin. Juhtides siin.

1297
01:20:27,640 --> 01:20:31,820
Aga ma olen kaotanud jälgida, aadressid kõik mälu siin, et ma eraldatud.

1298
01:20:31,820 --> 01:20:35,100
Ja nüüd ma ei pea ühtegi viidet neid enam.

1299
01:20:35,100 --> 01:20:37,230
Niisiis, ma ei saa vabastada neid väljaspool seda ahela.

1300
01:20:37,230 --> 01:20:39,390
Ja seda selleks, et määrata midagi sellist,

1301
01:20:39,390 --> 01:20:42,250
kui te unustate vaba ja sa saad seda Mälulekke

1302
01:20:42,250 --> 01:20:45,810
Sul on vaba mälu sees see silmus, kui olete teinud seda.

1303
01:20:45,810 --> 01:20:51,400
Noh, see on, mis juhtub. Ma tean palju sa vihkad seda.

1304
01:20:51,400 --> 01:20:55,270
Aga nüüd - jee! Sa saad nagu 44000 kilobaiti.

1305
01:20:55,270 --> 01:20:57,110
Niisiis, sa vabastama selle aasta lõpus loop,

1306
01:20:57,110 --> 01:20:59,770
ja mis läheb lihtsalt vaba mälu iga kord.

1307
01:20:59,770 --> 01:21:03,620
Sisuliselt oma programmi ei ole mäluleke enam.

1308
01:21:03,620 --> 01:21:08,150
>> Ja nüüd midagi, mida saate teha on vaba mõned mälu, et olete küsinud kaks korda.

1309
01:21:08,150 --> 01:21:11,060
Sel juhul sa malloc midagi, muudad oma väärtust.

1310
01:21:11,060 --> 01:21:13,140
You Tasuta ta kunagi, sest sa ütlesid, et sa olid teinud seda.

1311
01:21:13,140 --> 01:21:14,940
Aga siis me vabanenud uuesti.

1312
01:21:14,940 --> 01:21:16,730
See on midagi, mis on päris halb.

1313
01:21:16,730 --> 01:21:18,820
Ta ei kavatse esialgu segfault,

1314
01:21:18,820 --> 01:21:23,350
kuid mõne aja pärast, mida see on topelt vabastades see korrumpeerib oma hunnik struktuur,

1315
01:21:23,350 --> 01:21:27,200
ja saate teada natuke rohkem sellest, kui otsustate võtta klassi nagu CS61.

1316
01:21:27,200 --> 01:21:30,000
Aga põhiliselt mõne aja pärast arvuti ei hakka segi

1317
01:21:30,000 --> 01:21:33,010
mida mälu kohad on, kus ja kui see on salvestatud -

1318
01:21:33,010 --> 01:21:34,800
kus andmeid hoitakse mälus.

1319
01:21:34,800 --> 01:21:38,080
Ja nii vabastades osuti kaks korda on halb asi, et sa ei taha seda teha.

1320
01:21:38,080 --> 01:21:41,600
>> Muud asjad, mis võivad valesti minna ei kasuta sizeof.

1321
01:21:41,600 --> 01:21:44,460
Niisiis, sel juhul te malloc 8 baiti,

1322
01:21:44,460 --> 01:21:46,700
ja see on sama asi nagu kaks täisarvu, eks?

1323
01:21:46,700 --> 01:21:49,580
Niisiis, see on täiesti ohutu, kuid see on?

1324
01:21:49,580 --> 01:21:52,160
Noh, nagu Lucas rääkis erinevate arhitektuuride,

1325
01:21:52,160 --> 01:21:54,220
täisarvud on erineva pikkusega.

1326
01:21:54,220 --> 01:21:57,970
Niisiis, aparaat, et te kasutate, täisarvud on umbes 4 baiti,

1327
01:21:57,970 --> 01:22:02,370
kuid mõnel teisel süsteemi nad võivad olla 8 baiti või nad võivad olla 16 baiti.

1328
01:22:02,370 --> 01:22:05,680
Niisiis, kui ma lihtsalt kasutada seda numbrit siia,

1329
01:22:05,680 --> 01:22:07,310
see programm võib töötada seadme

1330
01:22:07,310 --> 01:22:10,360
kuid ta ei kavatse eraldada piisavalt mälu mõnel teisel süsteemi.

1331
01:22:10,360 --> 01:22:14,020
Sel juhul on see, mida sizeof operaator kasutatakse.

1332
01:22:14,020 --> 01:22:16,880
Kui me kutsume sizeof (int), mida see teeb, on

1333
01:22:16,880 --> 01:22:21,910
 see annab meile suuruse täisarv süsteemi, et programm töötab.

1334
01:22:21,910 --> 01:22:25,490
Niisiis, sel juhul, sizeof (int) naaseb 4 midagi seadme

1335
01:22:25,490 --> 01:22:29,980
ja nüüd see tahe 4 * 2, mis on 8,

1336
01:22:29,980 --> 01:22:32,330
mis on lihtsalt palju ruumi vaja kaks täisarvu.

1337
01:22:32,330 --> 01:22:36,710
On erinevat süsteemi, kui int on nagu 16 baiti või 8 baiti,

1338
01:22:36,710 --> 01:22:39,380
see lihtsalt läheb tagasi piisavalt baiti salvestada et summa.

1339
01:22:41,830 --> 01:22:45,310
>> Ja lõpuks, structs.

1340
01:22:45,310 --> 01:22:48,340
Niisiis, kui sa tahad säilitada sudoku pardal mälu, kuidas võiks seda teha?

1341
01:22:48,340 --> 01:22:51,570
Võite mõelda nagu muutuja esimene asi,

1342
01:22:51,570 --> 01:22:53,820
muutuja teine ​​asi, muutuja Kolmas asi,

1343
01:22:53,820 --> 01:22:56,420
muutuja neljandat asi - halb, eks?

1344
01:22:56,420 --> 01:23:00,750
Niisiis, üks paranemine saad teha peal seda on teha 9 x 9 rida.

1345
01:23:00,750 --> 01:23:04,480
See on hea, aga kui sa tahad siduda muid asju koos sudoku pardal

1346
01:23:04,480 --> 01:23:06,490
nagu mida on raske laual on,

1347
01:23:06,490 --> 01:23:11,740
või näiteks, mida teie skoor on või kui palju aega see on võetud teil lahendada selle foorumi?

1348
01:23:11,740 --> 01:23:14,970
Noh, mida saate teha, on saate luua struktuure.

1349
01:23:14,970 --> 01:23:18,910
Mida ma põhimõtteliselt öelda on ma määratledes selle struktuuri üle siin,

1350
01:23:18,910 --> 01:23:23,230
ja ma määratlemisel sudoku pardal, mis koosneb pardal, mis on 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> Ja mis see on see on viiteid nimi tasandil.

1352
01:23:26,650 --> 01:23:30,730
Samuti on x ja y, mis on koordinaadid, kus ma olen praegu.

1353
01:23:30,730 --> 01:23:35,980
Samuti on aega [arusaamatu], ja see on kokku käigud olen sisestanud nii kaugele.

1354
01:23:35,980 --> 01:23:40,010
Ja nii sel juhul, ma ei saa rühmitada terve hunnik andmeid arvesse ainult üks struktuur

1355
01:23:40,010 --> 01:23:42,790
selle asemel, et nagu ringi lendama nagu erinevaid muutujaid

1356
01:23:42,790 --> 01:23:44,540
et ma ei saa tõesti jälgida.

1357
01:23:44,540 --> 01:23:49,720
Ja see võimaldab meil on lihtsalt kena süntaks omamoodi viitamine erinevaid asju sees see struct.

1358
01:23:49,720 --> 01:23:53,430
Ma ei lihtsalt ei board.board, ja ma saan sudoku pardal tagasi.

1359
01:23:53,430 --> 01:23:56,320
Board.level, ma saan kui raske see on.

1360
01:23:56,320 --> 01:24:00,540
Board.x ja board.y anna mulle koordinaadid, kus ma oleks pardal.

1361
01:24:00,540 --> 01:24:04,730
Ja nii ma tutvumise mida me kutsume väljad struct.

1362
01:24:04,730 --> 01:24:08,840
See määratleb sudokuBoard, mis on teatud tüüpi, et mul on.

1363
01:24:08,840 --> 01:24:14,800
Ja nüüd me oleme siin. Mul on muutuja nimega "pardal"-tüüpi sudokuBoard.

1364
01:24:14,800 --> 01:24:18,820
Ja nüüd ma ei pääse kõik väljad, mis moodustavad selle struktuuri üle siin.

1365
01:24:20,830 --> 01:24:22,450
>> Küsimusi structs? Jah?

1366
01:24:22,450 --> 01:24:25,890
[Student] Sest int x, y, sa deklareeritud nii ühes reas? >> [Joseph] Ja-jah.

1367
01:24:25,890 --> 01:24:27,400
[Student] Niisiis, kas te võiksite lihtsalt teha, et neid kõiki?

1368
01:24:27,400 --> 01:24:31,200
Sarnaselt x, y koma korda kokku?

1369
01:24:31,200 --> 01:24:34,460
[Joseph] Jah, võid kindlasti teha, kuid põhjus panin x ja y samal joonel -

1370
01:24:34,460 --> 01:24:36,330
ja küsimus on, miks me just seda samal joonel?

1371
01:24:36,330 --> 01:24:38,600
Miks me lihtsalt ei pane kõiki neid samal real on

1372
01:24:38,600 --> 01:24:42,090
x ja y on omavahel seotud,

1373
01:24:42,090 --> 01:24:44,780
ja see on lihtsalt stilistiliselt õigem, mõnes mõttes

1374
01:24:44,780 --> 01:24:46,600
sest see on rühmituse kaks asja samal joonel

1375
01:24:46,600 --> 01:24:49,340
et nagu omamoodi seotud sama asi.

1376
01:24:49,340 --> 01:24:51,440
Ja ma lihtsalt jagada need laiali. See on lihtsalt stiilis asi.

1377
01:24:51,440 --> 01:24:53,720
See funktsionaalselt mingit vahet üldse.

1378
01:24:58,150 --> 01:24:59,270
Muid küsimusi structs?

1379
01:25:03,030 --> 01:25:06,620
Saate määrata Pokedex koos struktuure.

1380
01:25:06,620 --> 01:25:11,720
Pokémon on mitmeid ja see on kirjas, omanik, tüüp.

1381
01:25:11,720 --> 01:25:16,990
Ja siis kui sul on array Pokémon, mida saate teha kuni Pokedex, eks?

1382
01:25:16,990 --> 01:25:20,810
Okei, lahe. Nii küsimustele structs. Need on seotud structs.

1383
01:25:20,810 --> 01:25:25,270
>> Lõpuks GDB. Mis GDB lase sul teha? See võimaldab teil siluda oma programmi.

1384
01:25:25,270 --> 01:25:27,650
Ja kui te ei ole kasutanud GDB, oleksin soovitatav vaadates lühike

1385
01:25:27,650 --> 01:25:31,250
ja lihtsalt läheb üle, mida GDB on, kuidas te töötate koos sellega, kuidas te võite seda kasutada,

1386
01:25:31,250 --> 01:25:32,900
ja testida seda programmi.

1387
01:25:32,900 --> 01:25:37,400
Ja mis GDB saate teha, on see laseb paus [arusaamatu] oma programmi

1388
01:25:37,400 --> 01:25:38,920
ja praktiline joon.

1389
01:25:38,920 --> 01:25:42,600
Näiteks, ma tahan pausi täitmine on nagu rida 3 minu programm,

1390
01:25:42,600 --> 01:25:46,010
ja kuigi ma olen rida 3 saan printida välja kõik väärtused, mis on seal.

1391
01:25:46,010 --> 01:25:49,710
Ja nii me kutsume nagu pausid rida

1392
01:25:49,710 --> 01:25:52,350
on me nimetame seda panna Katkestuspunkti et liin

1393
01:25:52,350 --> 01:25:55,920
ja siis saame välja printida muutujad riik programmi sel ajal.

1394
01:25:55,920 --> 01:25:58,990
>> Seejärel saame sealt sammu programmi kaudu rida-realt.

1395
01:25:58,990 --> 01:26:03,200
Ja siis saame vaadata, millises seisukorras on virnas ajal.

1396
01:26:03,200 --> 01:26:08,600
Ja seda selleks, et kasutada GDB, mida me teeme, on me kutsume rõkkama kohta C faili

1397
01:26:08,600 --> 01:26:11,290
aga meil on edastada see-ggdb lipp.

1398
01:26:11,290 --> 01:26:15,850
Ja kui me teinud, et me lihtsalt joosta gdb kohta saadud väljundfaili.

1399
01:26:15,850 --> 01:26:18,810
Ja nii saad mõned nagu mass teksti niimoodi,

1400
01:26:18,810 --> 01:26:21,990
aga tõesti kõik mida sa pead tegema, on tüüpi käske alguses.

1401
01:26:21,990 --> 01:26:24,250
Break peamine paneb Katkestuspunkti peamine.

1402
01:26:24,250 --> 01:26:28,470
Nimekiri 400 loetletakse rida koodi ümber liin 400.

1403
01:26:28,470 --> 01:26:31,410
Ja nii sel juhul võid lihtsalt ringi vaadata ja öelda, oh,

1404
01:26:31,410 --> 01:26:34,360
Ma tahan, et seada murdepunkti real 397, mis on sellel joonel,

1405
01:26:34,360 --> 01:26:37,170
ja siis teie programm jookseb, et samm ja see läheb katki.

1406
01:26:37,170 --> 01:26:41,120
See saab peatada seal, ja saad välja printida, näiteks väärtus on madal või kõrge.

1407
01:26:41,120 --> 01:26:46,410
Ja nii on hunnik käske, mida pead teadma,

1408
01:26:46,410 --> 01:26:48,660
ja see slideshow tõusevad veebilehel,

1409
01:26:48,660 --> 01:26:54,000
nii et kui tahad lihtsalt viide neid vms panna neid oma cheat lehed, julgelt.

1410
01:26:54,000 --> 01:27:00,650
>> Lahe. See oli viktoriin Review 0, ja me kinni umbes, kui teil on mingeid küsimusi.

1411
01:27:00,650 --> 01:27:03,850
Hea küll.

1412
01:27:03,850 --> 01:27:09,030
>>  [Aplaus]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]