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

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

3
00:00:05,000 --> 00:00:08,000
>> [Tämä on CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Hei, kaikki.

5
00:00:10,000 --> 00:00:15,000
Tervetuloa tarkastelun istuntoon Quiz 0, joka tapahtuu tänä keskiviikkona.

6
00:00:15,000 --> 00:00:19,000
Mitä me teemme tänään, olen 3 muuta TF,

7
00:00:19,000 --> 00:00:24,000
ja yhdessä olemme menossa läpi katsaus mitä olemme tehneet aikana toistaiseksi.

8
00:00:24,000 --> 00:00:27,000
Se ei tule olemaan 100% kattava, mutta se pitäisi antaa sinulle paremman käsityksen

9
00:00:27,000 --> 00:00:31,000
mitä sinulla jo on alas ja mitä vielä tutkia ennen keskiviikkona.

10
00:00:31,000 --> 00:00:34,000
Ja vapaasti nostaa käden kysymyksiä kuin menemme eteenpäin,

11
00:00:34,000 --> 00:00:38,000
mutta pitää muistaa, että me myös vähän aikaa lopussa,

12
00:00:38,000 --> 00:00:41,000
jos saamme läpi muutaman minuutin vara-tehdä yleisiin kysymyksiin,

13
00:00:41,000 --> 00:00:47,000
niin pitää tämä mielessä, ja niin aiomme aloittaa alusta kanssa viikolla 0.

14
00:00:47,000 --> 00:00:50,000
>> [Quiz 0 arvostelu!] [Part 0] [Lexi Ross] Mutta ennen kuin teemme, että puhutaanpa

15
00:00:50,000 --> 00:00:53,000
logistiikka tietovisa.

16
00:00:53,000 --> 00:00:55,000
>> [Logistics] [Tietovisa tapahtuu keskiviikkona 10/10 sijasta luento]

17
00:00:55,000 --> 00:00:57,000
>> [(Katso http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf lisätietoja)] on keskiviikkona, Lokakuu 10th.

18
00:00:57,000 --> 00:01:00,000
>> Se on tänä keskiviikkona, ja jos menet tätä URL täällä,

19
00:01:00,000 --> 00:01:03,000
joka pääsee myös CS50.net-siellä linkki siihen,

20
00:01:03,000 --> 00:01:06,000
näet tietoja minne mennä perustuvat

21
00:01:06,000 --> 00:01:10,000
sukunimesi tai koulun kuuluminen sekä

22
00:01:10,000 --> 00:01:14,000
Se kertoo, mitä Quiz kattaa sekä tyyppisiä kysymyksiä, että olet menossa.

23
00:01:14,000 --> 00:01:19,000
Muista, että sinulla on myös mahdollisuus tarkistaa ja tietokilpailu jaksossa,

24
00:01:19,000 --> 00:01:21,000
joten TF pitäisi mennä yli joitakin käytännön ongelmia,

25
00:01:21,000 --> 00:01:29,000
ja se on toinen hyvä mahdollisuus nähdä, missä sinun pitää vielä opiskella varten tietokilpailu.

26
00:01:29,000 --> 00:01:32,000
Aloitetaan alusta kanssa Bits 'n' Bytes.

27
00:01:32,000 --> 00:01:35,000
Muista vähän on vain 0 tai 1,

28
00:01:35,000 --> 00:01:38,000
ja tavu on kokoelma 8 näiden bittiä.

29
00:01:38,000 --> 00:01:42,000
Katsotaanpa tämä kokoelma bittejä täällä.

30
00:01:42,000 --> 00:01:44,000
Meidän pitäisi pystyä selvittää, kuinka monta bittiä on.

31
00:01:44,000 --> 00:01:48,000
Jos me laskemme siellä on vain 8 niistä kahdeksan 0 tai 1 kpl.

32
00:01:48,000 --> 00:01:51,000
Ja koska siellä on 8 bittiä, joka on 1 tavu,

33
00:01:51,000 --> 00:01:53,000
ja mennään muuntaa sen heksadesimaalinen.

34
00:01:53,000 --> 00:01:58,000
Heksadesimaali on pohja 16, ja se on melko helppo muuntaa

35
00:01:58,000 --> 00:02:01,000
numeron binary, joka on mitä se on, että numero heksadesimaalimuodossa.

36
00:02:01,000 --> 00:02:04,000
Kaikki mitä teemme on katsomme ryhmien 4,

37
00:02:04,000 --> 00:02:07,000
ja me muuntaa ne sopivaan heksadesimaaliluku.

38
00:02:07,000 --> 00:02:11,000
Aloitamme äärimmäisenä oikealla ryhmä 4, niin 0011.

39
00:02:11,000 --> 00:02:16,000
Se tulee olemaan yksi 1 ja yksi 2, niin yhdessä joka tekee 3.

40
00:02:16,000 --> 00:02:19,000
Ja sitten katsokaamme muut lohkon 4.

41
00:02:19,000 --> 00:02:24,000
1101. Tämä tulee olemaan yksi 1, yksi 4 ja yksi 8.

42
00:02:24,000 --> 00:02:28,000
Yhdessä, että tulee olemaan 13, mikä tekee D.

43
00:02:28,000 --> 00:02:32,000
Ja me muistamme, että heksadesimaali emme vain mene 0 kautta 9.

44
00:02:32,000 --> 00:02:36,000
Käymme 0 F, niin sen jälkeen 9, 10 vastaa,

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

46
00:02:40,000 --> 00:02:44,000
Tässä 13 on D,

47
00:02:44,000 --> 00:02:49,000
niin muuntaa sen desimaalin kaikki mitä teemme on oikeastaan

48
00:02:49,000 --> 00:02:52,000
Kohtelemme asema teho 2.

49
00:02:52,000 --> 00:02:58,000
Se on yksi 1 yksi 2, nolla 4s, nolla 8s, yksi 16, jne.,

50
00:02:58,000 --> 00:03:03,000
ja se on hieman vaikea laskea oman pään, mutta jos menemme seuraavaan diaan

51
00:03:03,000 --> 00:03:05,000
Voimme nähdä vastauksen tuohon.

52
00:03:05,000 --> 00:03:09,000
>> Pohjimmiltaan olemme menossa poikki oikealta takaisin vasemmalle,

53
00:03:09,000 --> 00:03:14,000
ja me kertomalla kunkin numeron vastaavalla voimalla 2.

54
00:03:14,000 --> 00:03:19,000
Ja muistakaa, heksadesimaaliluvussa merkitsemme näitä numeroita 0x alussa

55
00:03:19,000 --> 00:03:23,000
joten älä sekoita sitä desimaaliluku.

56
00:03:23,000 --> 00:03:29,000
Jatkuu, tämä on ASCII-taulukko,

57
00:03:29,000 --> 00:03:35,000
ja mitä käytämme ASCII on kartan merkkejä numeerisia arvoja.

58
00:03:35,000 --> 00:03:39,000
Muistakaa salakirjoituksessa PSET teimme laajaa käyttöä ASCII taulukon

59
00:03:39,000 --> 00:03:43,000
voidakseen käyttää erilaisia ​​menetelmiä salaus,

60
00:03:43,000 --> 00:03:47,000
Caesar ja Vigenère cipher, muuntaa eri kirjaimia

61
00:03:47,000 --> 00:03:52,000
in merkkijono mukaan avain käyttäjän antamien.

62
00:03:52,000 --> 00:03:56,000
Katsotaanpa hieman ASCII matematiikka.

63
00:03:56,000 --> 00:04:02,000
Tarkasteltaessa P + 1, luonteeltaan muodossa olisi Q,

64
00:04:02,000 --> 00:04:07,000
ja muista, että '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
Ja miten tarkalleen voisimme muuntaa nuo 2 lomakkeita?

66
00:04:10,000 --> 00:04:13,000
Se ei ole oikeastaan ​​liian kova.

67
00:04:13,000 --> 00:04:16,000
Jotta saat 5 vähennämme '0 '

68
00:04:16,000 --> 00:04:20,000
koska on olemassa 5 paikkoja välillä '0 'ja '5. "

69
00:04:20,000 --> 00:04:23,000
Jotta mennä toiseen suuntaan me vain lisätä 0,

70
00:04:23,000 --> 00:04:25,000
joten se on tavallaan kuin säännöllistä aritmeettinen.

71
00:04:25,000 --> 00:04:29,000
Vain muistaa, että kun jotain on lainausmerkkejä sen ympärille on merkki

72
00:04:29,000 --> 00:04:37,000
ja näin ollen vastaa arvoa ASCII-taulukossa.

73
00:04:37,000 --> 00:04:40,000
Muutto yleisempi tietojenkäsittelytiede aiheita.

74
00:04:40,000 --> 00:04:43,000
Opimme mitä algoritmi on ja miten käytämme ohjelmointi

75
00:04:43,000 --> 00:04:45,000
toteuttaa algoritmeja.

76
00:04:45,000 --> 00:04:48,000
Joitakin esimerkkejä algoritmit ovat jotain todella yksinkertaisia, kuten

77
00:04:48,000 --> 00:04:51,000
tarkistetaan, onko numero on parillinen tai pariton.

78
00:04:51,000 --> 00:04:54,000
Tästä muistan me mod numero 2 ja tarkista jos tulos on 0.

79
00:04:54,000 --> 00:04:57,000
Jos näin on, se on jopa. Jos ei, se on outoa.

80
00:04:57,000 --> 00:04:59,000
Ja se on esimerkki todella perus algoritmi.

81
00:04:59,000 --> 00:05:02,000
>> Vähän enemmän mukana yksi binäärihakupuu,

82
00:05:02,000 --> 00:05:05,000
jonka me mennä yli myöhemmin tarkistaa istuntoon.

83
00:05:05,000 --> 00:05:09,000
Ja ohjelmointi on termi käytämme ottaen algoritmin

84
00:05:09,000 --> 00:05:15,000
ja muuntamalla se koodata tietokone voi lukea.

85
00:05:15,000 --> 00:05:20,000
2 Esimerkkejä ohjelmointi on Scratch,

86
00:05:20,000 --> 00:05:22,000
joka on mitä teimme Viikko 0.

87
00:05:22,000 --> 00:05:25,000
Vaikka emme oikeastaan ​​kirjoita ulos koodin se tapa toteuttaa

88
00:05:25,000 --> 00:05:29,000
Tämän algoritmin, joka tulostaa numerot 1-10,

89
00:05:29,000 --> 00:05:32,000
ja täällä teemme sama C-ohjelmointikielellä.

90
00:05:32,000 --> 00:05:41,000
Nämä ovat toiminnallisesti samanarvoisia, vain kirjoitettu eri kielillä tai syntaksia.

91
00:05:41,000 --> 00:05:44,000
Sitten oppivat boolean ilmaisuja,

92
00:05:44,000 --> 00:05:48,000
ja boolean on arvo, joka on joko tosi tai epätosi,

93
00:05:48,000 --> 00:05:51,000
ja tässä Usein Boolen

94
00:05:51,000 --> 00:05:55,000
mennä sisälle edellytykset, joten jos (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
No, me jo x = 5, niin että ehto tulee arvioida todellista.

96
00:06:00,000 --> 00:06:03,000
Ja jos se on totta, mitä koodi on alla ehto

97
00:06:03,000 --> 00:06:08,000
aiotaan arvioida tietokoneella, niin että merkkijono aiotaan tulostaa

98
00:06:08,000 --> 00:06:12,000
vakiotulosteeseen, ja termi kunnossa

99
00:06:12,000 --> 00:06:16,000
viittaa mikä on sulkeiden sisällä, jos ilmoitus.

100
00:06:16,000 --> 00:06:20,000
Muista kaikki toimijat.

101
00:06:20,000 --> 00:06:26,000
Muistakaa se && ja | | kun yritämme yhdistää 2 tai useampia ehtoja,

102
00:06:26,000 --> 00:06:30,000
== Ei = tarkistaa, onko 2 asiat ovat yhtä.

103
00:06:30,000 --> 00:06:36,000
Muista, että = on tehtävä taas == on boolean operaattorin.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ ja sitten lopullinen 2 ovat itsestään selviä.

105
00:06:41,000 --> 00:06:45,000
Yleinen katsaus Boolen logiikkaa täällä.

106
00:06:45,000 --> 00:06:48,000
Ja boolean ilmaisut ovat myös tärkeitä silmukoita,

107
00:06:48,000 --> 00:06:50,000
joka menemme ohi.

108
00:06:50,000 --> 00:06:56,000
Opimme noin 3 tyyppisiä silmukoita toistaiseksi CS50 varten, kun taas, ja tehdä samalla.

109
00:06:56,000 --> 00:06:59,000
Ja se on tärkeää tietää, että vaikka useimpiin tarkoituksiin

110
00:06:59,000 --> 00:07:02,000
voimme itse käyttää mitä tahansa silmukan yleensä

111
00:07:02,000 --> 00:07:06,000
olemassa tiettyjä tarkoituksia tai yhteisiä kuvioita

112
00:07:06,000 --> 00:07:09,000
ohjelmatyössä että nimenomaan vaativat näistä silmukoista

113
00:07:09,000 --> 00:07:13,000
jotka tekevät sen tehokkainta tai tyylikäs koodaamaan sitä sillä tavalla.

114
00:07:13,000 --> 00:07:18,000
Mennään yli, mitä kukin näistä silmukoita yleensä käytetään useimmiten.

115
00:07:18,000 --> 00:07:21,000
>> Vuonna varten silmukka me yleensä jo tietää, kuinka monta kertaa haluamme toistaa.

116
00:07:21,000 --> 00:07:24,000
Sitähän me laittaa kunnossa.

117
00:07:24,000 --> 00:07:28,000
Varten, i = 0, i <10, esimerkiksi.

118
00:07:28,000 --> 00:07:31,000
Tiedämme jo, että haluamme tehdä jotain 10 kertaa.

119
00:07:31,000 --> 00:07:34,000
Nyt, kun silmukka, yleensä emme välttämättä

120
00:07:34,000 --> 00:07:36,000
tietää, kuinka monta kertaa me haluamme silmukan ajaa.

121
00:07:36,000 --> 00:07:39,000
Mutta me tiedämme jonkinlainen edellytyksellä, että haluamme sen

122
00:07:39,000 --> 00:07:41,000
aina totta tai aina väärä.

123
00:07:41,000 --> 00:07:44,000
Esimerkiksi, kun on asetettu.

124
00:07:44,000 --> 00:07:46,000
Sanotaan, että on Boolen muuttuja.

125
00:07:46,000 --> 00:07:48,000
Vaikka se on totta haluamme koodin arvioida,

126
00:07:48,000 --> 00:07:52,000
joten hieman enemmän laajeneva, hieman yleisempää kuin on silmukka,

127
00:07:52,000 --> 00:07:55,000
mutta mitä tahansa for-silmukka voi myös muuntaa samalla silmukan.

128
00:07:55,000 --> 00:08:00,000
Lopuksi, tehdä, kun silmukoita, jotka voivat olla hankalin ymmärtää heti,

129
00:08:00,000 --> 00:08:04,000
käytetään usein, kun halutaan arvioida koodin ensimmäinen

130
00:08:04,000 --> 00:08:06,000
ennen ensimmäistä kertaa tarkista kunnossa.

131
00:08:06,000 --> 00:08:09,000
Yhteiseen käyttöön tapauksessa tehdä, kun silmukka

132
00:08:09,000 --> 00:08:12,000
on kun haluat saada käyttäjä syöttää, ja tiedät haluat kysyä käyttäjälle

133
00:08:12,000 --> 00:08:15,000
syötteen ainakin kerran, mutta jos he eivät anna sinulle hyvä syöttää heti

134
00:08:15,000 --> 00:08:18,000
haluat pitää pyytää heitä kunnes he antavat sinulle hyvän tulon.

135
00:08:18,000 --> 00:08:21,000
Se yleisin käyttö ei taas silmukka,

136
00:08:21,000 --> 00:08:23,000
ja katsokaamme todellista rakennetta näiden silmukoita.

137
00:08:23,000 --> 00:08:27,000
Ne yleensä aina taipumus seurata näitä kuvioita.

138
00:08:27,000 --> 00:08:30,000
>> Käytössä on silmukan sisäpuolella sinulla on 3 osaa:

139
00:08:30,000 --> 00:08:35,000
Alustuksen tyypillisesti jotain int i = 0, missä i on laskuri,

140
00:08:35,000 --> 00:08:40,000
tila, jossa haluamme sanoa suorittaa tätä silmukka niin kauan kuin tämä ehto on edelleen voimassa

141
00:08:40,000 --> 00:08:44,000
kuten i <10, ja sitten lopuksi, päivitys, joka on, miten kasvattaa

142
00:08:44,000 --> 00:08:47,000
laskinmuuttuja jokaisessa vaiheessa silmukka.

143
00:08:47,000 --> 00:08:50,000
Yhteinen asia nähdä siellä on vain i + +,

144
00:08:50,000 --> 00:08:52,000
mikä tarkoittaa kasvattaa I 1 joka kerta.

145
00:08:52,000 --> 00:08:55,000
Voit myös tehdä jotain i + = 2,

146
00:08:55,000 --> 00:08:58,000
mikä tarkoittaa lisätään 2 i aina mennä läpi silmukan.

147
00:08:58,000 --> 00:09:03,000
Ja sitten tehdä tämän vain tarkoittaa mitä tahansa koodia, joka todella toimii osana silmukan.

148
00:09:03,000 --> 00:09:09,000
Ja vaikka silmukka, tällä kertaa meillä on todellakin alustuksen ulkopuolella silmukan,

149
00:09:09,000 --> 00:09:12,000
niin esimerkiksi sanokaamme me yritämme tehdä samantyyppisiä kaareen juuri kuvattu.

150
00:09:12,000 --> 00:09:16,000
Sanoisimme int i = 0 ennen silmukan alkua.

151
00:09:16,000 --> 00:09:20,000
Silloin voisimme sanoa, kun i <10 tehdä tämän,

152
00:09:20,000 --> 00:09:22,000
joten sama koodilohko kuin ennen,

153
00:09:22,000 --> 00:09:26,000
ja tällä kertaa päivitys osa koodia, esimerkiksi i + +,

154
00:09:26,000 --> 00:09:29,000
todellisuudessa menee sisälle silmukan.

155
00:09:29,000 --> 00:09:33,000
Ja lopuksi tehdä samalla, se on samanlainen kun silmukka,

156
00:09:33,000 --> 00:09:36,000
mutta meidän on muistettava, että koodi arvioi kerran

157
00:09:36,000 --> 00:09:40,000
ennen ehdon täyttymistä valvotaan, joten se tekee paljon enemmän järkeä

158
00:09:40,000 --> 00:09:44,000
jos tarkastellaan sitä luokkaa ylhäältä alas.

159
00:09:44,000 --> 00:09:49,000
Vuonna do while-silmukka koodi arvioi ennen kuin edes katsomaan taas kunnossa,

160
00:09:49,000 --> 00:09:55,000
taas kun silmukka, se tarkistaa ensin.

161
00:09:55,000 --> 00:09:59,000
Lausunnot ja muuttujia.

162
00:09:59,000 --> 00:10:04,000
Kun haluamme luoda uusi muuttuja haluamme ensin alustaa sen.

163
00:10:04,000 --> 00:10:07,000
>> Esimerkiksi int baari alustaa muuttujan bar,

164
00:10:07,000 --> 00:10:10,000
mutta se ei anna sitä arvoa, joten mikä on baarin arvo nyt?

165
00:10:10,000 --> 00:10:12,000
Emme tiedä.

166
00:10:12,000 --> 00:10:14,000
Se voisi olla joitakin roska-arvo, joka oli aiemmin tallennettu muistiin siellä,

167
00:10:14,000 --> 00:10:16,000
ja emme halua käyttää tätä muuttujaa

168
00:10:16,000 --> 00:10:19,000
kunnes me oikeastaan ​​antaa sille arvoa,

169
00:10:19,000 --> 00:10:21,000
joten julistaa sen täällä.

170
00:10:21,000 --> 00:10:24,000
Sitten alustaa sen olevan 42 alle.

171
00:10:24,000 --> 00:10:28,000
Nythän me tiedämme tämä voidaan tehdä yhdellä rivillä, int bar = 42.

172
00:10:28,000 --> 00:10:30,000
Mutta vain tehdä selväksi useita vaiheita, jotka ovat meneillään,

173
00:10:30,000 --> 00:10:34,000
ilmoitus ja alustus tapahtuu tässä erikseen.

174
00:10:34,000 --> 00:10:38,000
Se tapahtuu yksi askel, ja seuraava, int Baz = bar + 1,

175
00:10:38,000 --> 00:10:44,000
Tässä lausumassa todetaan, että kerrallaan Baz, joten lopussa tämän koodieston

176
00:10:44,000 --> 00:10:48,000
jos me tulostaa arvon Baz olisi 44

177
00:10:48,000 --> 00:10:52,000
sillä me julistamme ja alustaa sen olevan 1> bar,

178
00:10:52,000 --> 00:10:58,000
ja sitten kasvattaa sitä vielä kerran + +.

179
00:10:58,000 --> 00:11:02,000
Meillä meni tässä melko lyhyesti, mutta se on hyvä olla yleistä

180
00:11:02,000 --> 00:11:04,000
ymmärtää mitä kierteet ja tapahtumat ovat.

181
00:11:04,000 --> 00:11:06,000
Olemme pääasiassa teki tämän Scratch,

182
00:11:06,000 --> 00:11:09,000
joten voit ajatella viestiketjut moninkertaiset sekvenssit koodia

183
00:11:09,000 --> 00:11:11,000
käynnissä samaan aikaan.

184
00:11:11,000 --> 00:11:14,000
Tosiasiassa se luultavasti ei ole käynnissä samaan aikaan,

185
00:11:14,000 --> 00:11:17,000
mutta tavallaan abstractly voimme ajatella sitä sillä tavalla.

186
00:11:17,000 --> 00:11:20,000
>> Scratch Esimerkiksi meillä oli useita sprites.

187
00:11:20,000 --> 00:11:22,000
Se voitaisiin suorittamalla eri koodi samaan aikaan.

188
00:11:22,000 --> 00:11:26,000
Yksi voisi kävelet ja muut sanoo jotain

189
00:11:26,000 --> 00:11:29,000
eri näytön osasta.

190
00:11:29,000 --> 00:11:34,000
Tapahtumat ovat toinen tapa erottamista logiikka

191
00:11:34,000 --> 00:11:37,000
eri osien koodisi,

192
00:11:37,000 --> 00:11:40,000
ja Scratch pystyimme simuloida tapahtumia käyttäen Broadcast,

193
00:11:40,000 --> 00:11:43,000
ja se on oikeastaan ​​kun saan, ei kun kuulen,

194
00:11:43,000 --> 00:11:47,000
mutta pohjimmiltaan se on tapa välittää tietoa

195
00:11:47,000 --> 00:11:49,000
yhdestä sprite toiseen.

196
00:11:49,000 --> 00:11:52,000
Esimerkiksi, saatat haluta lähettää game over,

197
00:11:52,000 --> 00:11:56,000
ja kun toinen sprite saa pelin aikana,

198
00:11:56,000 --> 00:11:58,000
se vastaa tietyllä tavalla.

199
00:11:58,000 --> 00:12:03,000
On tärkeää malli ymmärtää ohjelmoinnin.

200
00:12:03,000 --> 00:12:07,000
Vain mennä yli perus Viikko 0, mitä olemme menneet yli niin pitkälle,

201
00:12:07,000 --> 00:12:10,000
Katsotaanpa tätä yksinkertaista C-ohjelma.

202
00:12:10,000 --> 00:12:14,000
Tekstin voi olla hieman pieni täältä, mutta menen aikana se todella nopeasti.

203
00:12:14,000 --> 00:12:20,000
Olemme lukien 2 header tiedostoja yläosassa, cs50.h ja stdio.h.

204
00:12:20,000 --> 00:12:23,000
Olemme sitten määritellään vakio nimeltään rajan olevan 100.

205
00:12:23,000 --> 00:12:26,000
Olemme toteuttaa sitten meidän päätehtävä.

206
00:12:26,000 --> 00:12:29,000
Koska emme käytä komentoriviargumentteja täällä meidän laittaa void

207
00:12:29,000 --> 00:12:32,000
koska perustelut tärkein.

208
00:12:32,000 --> 00:12:38,000
Näemme int edellä main. Se palautuva, joten palauta 0 alareunassa.

209
00:12:38,000 --> 00:12:41,000
Ja käytämme CS50 kirjaston funktion saada int

210
00:12:41,000 --> 00:12:45,000
pyytää käyttäjältä syötettä, ja me tallentaa sen tämän muuttujan x,

211
00:12:45,000 --> 00:12:51,000
niin me julistamme x edellä, ja me alustaa se x = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> Me sitten tarkistaa onko käyttäjä antoi meille hyvän tulon.

213
00:12:53,000 --> 00:12:59,000
Jos se on ≥ RAJA haluamme palauttaa virhekoodin 1 ja tulostaa virheilmoituksen.

214
00:12:59,000 --> 00:13:02,000
Ja lopuksi, jos käyttäjä on antanut meille hyvän tulo

215
00:13:02,000 --> 00:13:08,000
aiomme sovittaa numero ja tulostaa tämä tulos.

216
00:13:08,000 --> 00:13:11,000
Vain varmista, että ne kaikki osui

217
00:13:11,000 --> 00:13:17,000
näet tarroja eri osien koodi tähän.

218
00:13:17,000 --> 00:13:19,000
Mainitsin vakio, header-tiedostot.

219
00:13:19,000 --> 00:13:21,000
Voi, int x. Varmista muistaa, että on paikallinen muuttuja.

220
00:13:21,000 --> 00:13:24,000
Joka eroaa sen globaali muuttuja, jonka me puhumme

221
00:13:24,000 --> 00:13:27,000
hieman myöhemmin tarkistaa istuntoon,

222
00:13:27,000 --> 00:13:30,000
ja pyydämme kirjaston funktion printf,

223
00:13:30,000 --> 00:13:34,000
joten jos emme olisi mukana stdio.h otsikkotiedosto

224
00:13:34,000 --> 00:13:37,000
emme voi soittaa printf.

225
00:13:37,000 --> 00:13:42,000
Ja uskon nuolta katkesi täällä on osoittaa% d,

226
00:13:42,000 --> 00:13:45,000
mikä on muotoilun merkkijono printf.

227
00:13:45,000 --> 00:13:52,000
Se sanoo tulostaa tämän muuttujan numero,% d.

228
00:13:52,000 --> 00:13:58,000
Ja tämä on se viikko 0.

229
00:13:58,000 --> 00:14:06,000
Nyt Lucas tulee jatkumaan.

230
00:14:06,000 --> 00:14:08,000
Hei, kaverit. Nimeni on Lucas.

231
00:14:08,000 --> 00:14:10,000
Olen toisen vuoden opiskelija parhaiten talon kampuksella, Mather,

232
00:14:10,000 --> 00:14:14,000
ja aion puhua hieman siitä Viikko 1 ja 2,1.

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

234
00:14:16,000 --> 00:14:19,000
Kuten Lexi sanoi, kun aloimme kääntää koodi tyhjästä C

235
00:14:19,000 --> 00:14:23,000
yksi asioista, huomasimme, että et voi vain

236
00:14:23,000 --> 00:14:26,000
kirjoita koodi ja aja se käyttäen vihreää lippua enää.

237
00:14:26,000 --> 00:14:30,000
Oikeastaan, sinun täytyy käyttää joitakin toimia voit tehdä C-ohjelma

238
00:14:30,000 --> 00:14:33,000
tullut suoritettavan tiedoston.

239
00:14:33,000 --> 00:14:36,000
Periaatteessa mitä teet, kun olet kirjoittamassa ohjelmassa on, että

240
00:14:36,000 --> 00:14:40,000
käännät ideasi kieli kääntäjä voi ymmärtää,

241
00:14:40,000 --> 00:14:44,000
joten kun kirjoitat ohjelman C

242
00:14:44,000 --> 00:14:47,000
mitä teet on todella kirjoittaa jotain, että kääntäjä tulee ymmärtää,

243
00:14:47,000 --> 00:14:50,000
ja sitten kääntäjä on menossa kääntämään että koodia

244
00:14:50,000 --> 00:14:53,000
jotain, että tietokone ymmärtää.

245
00:14:53,000 --> 00:14:55,000
>> Ja asia on, tietokone on todella tyhmä.

246
00:14:55,000 --> 00:14:57,000
Tietokone voi vain ymmärtää 0s ja 1s,

247
00:14:57,000 --> 00:15:01,000
niin oikeastaan ​​ensimmäiset tietokoneet ihmiset yleensä ohjelmoitu

248
00:15:01,000 --> 00:15:04,000
käyttäen 0s ja 1s, mutta ei enää, kiitos Jumalalle.

249
00:15:04,000 --> 00:15:07,000
Meillä ei ole muistaa sekvenssit 0s ja 1s

250
00:15:07,000 --> 00:15:10,000
ja for-silmukka tai kun silmukka ja niin edelleen.

251
00:15:10,000 --> 00:15:13,000
Siksi meillä on kääntäjä.

252
00:15:13,000 --> 00:15:17,000
Mitä kääntäjä tekee se pohjimmiltaan kääntää C-koodia,

253
00:15:17,000 --> 00:15:21,000
meidän tapauksessamme, on kieli, että tietokone ymmärtää,

254
00:15:21,000 --> 00:15:25,000
joka on kohdekoodin, ja kääntäjä, että käytämme

255
00:15:25,000 --> 00:15:30,000
kutsutaan clang, joten tämä on todella symboli clang.

256
00:15:30,000 --> 00:15:33,000
Kun sinulla on ohjelma, sinun täytyy tehdä 2 asioita.

257
00:15:33,000 --> 00:15:37,000
Ensinnäkin, sinun täytyy kääntää ohjelma, ja sitten olet menossa ajaa ohjelmaa.

258
00:15:37,000 --> 00:15:41,000
Voit kääntää ohjelma sinulla on paljon vaihtoehtoja tehdä niin.

259
00:15:41,000 --> 00:15:44,000
Ensimmäinen on tehdä clang program.c

260
00:15:44,000 --> 00:15:47,000
jossa ohjelmassa on nimi ohjelman.

261
00:15:47,000 --> 00:15:51,000
Tällöin näet he vain sanovat "Hei, kääntää minun ohjelma."

262
00:15:51,000 --> 00:15:56,000
Et sano "Haluan tämän nimen minun ohjelma" tai jotain.

263
00:15:56,000 --> 00:15:58,000
>> Toinen vaihtoehto on antaa nimen omaan ohjelmaan.

264
00:15:58,000 --> 00:16:02,000
Voit sanoa clang-o ja sitten haluamasi nimi

265
00:16:02,000 --> 00:16:06,000
suoritettava tiedosto nimetään ja sitten program.c.

266
00:16:06,000 --> 00:16:11,000
Ja voit myös tehdä tehdä ohjelman, ja nähdä miten ensimmäisen 2 tapausta

267
00:16:11,000 --> 00:16:15,000
Laitoin. C, ja kolmas minulla on vain ohjelmia?

268
00:16:15,000 --> 00:16:18,000
Joo, te todella pitäisi laittaa. C Kun käytät tehdä.

269
00:16:18,000 --> 00:16:22,000
Muutoin kääntäjä on todella menossa huutaa sinulle.

270
00:16:22,000 --> 00:16:24,000
Ja myös, en tiedä jos te muistatte,

271
00:16:24,000 --> 00:16:29,000
mutta paljon kertaa olemme myös käytetty-lcs50 tai-lm.

272
00:16:29,000 --> 00:16:31,000
Tätä kutsutaan yhdistää.

273
00:16:31,000 --> 00:16:35,000
Se vain kertoo kääntäjälle, että voit käyttää niitä kirjastoja oikeassa,

274
00:16:35,000 --> 00:16:39,000
joten jos haluat käyttää cs50.h sinun todella täytyy kirjoittaa

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

276
00:16:43,000 --> 00:16:45,000
Jos et tee sitä, kääntäjä ei aio tiedä

277
00:16:45,000 --> 00:16:50,000
että käytät näitä toimintoja cs50.h.

278
00:16:50,000 --> 00:16:52,000
Ja kun haluat ajaa ohjelman sinulla on 2 vaihtoehtoa.

279
00:16:52,000 --> 00:16:57,000
Jos et clang program.c et anna nimen omaan ohjelmaan.

280
00:16:57,000 --> 00:17:01,000
Sinun täytyy käyttää sitä käyttämällä. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out on tavallinen nimi clang antaa ohjelman, jos et anna sille nimi.

282
00:17:06,000 --> 00:17:11,000
Muuten aiot tehdä. / Ohjelma jos annoit nimen omaan ohjelmaan,

283
00:17:11,000 --> 00:17:15,000
ja jos et tee ohjelma nimi ohjelma on menossa

284
00:17:15,000 --> 00:17:23,000
on jo menossa ohjelmoitava sama nimi kuin C-tiedoston.

285
00:17:23,000 --> 00:17:26,000
Sitten puhuimme tietotyypit ja tiedon.

286
00:17:26,000 --> 00:17:31,000
>> Pohjimmiltaan tietotyypit ovat sama asia kuin vähän laatikoita ne käyttävät

287
00:17:31,000 --> 00:17:35,000
tallentaa arvoja, joten tietotyypit ovat oikeastaan ​​aivan Pokemons.

288
00:17:35,000 --> 00:17:39,000
Ne tulevat kaikki koot ja tyypit.

289
00:17:39,000 --> 00:17:43,000
En tiedä, jos se vastaavasti järkevää.

290
00:17:43,000 --> 00:17:46,000
Datan koko todella riippuu koneen arkkitehtuuri.

291
00:17:46,000 --> 00:17:49,000
Kaikki tiedot koot aion näyttää tässä

292
00:17:49,000 --> 00:17:53,000
ovat itse asiassa 32-bittinen kone, joka on osalta meidän laite,

293
00:17:53,000 --> 00:17:56,000
mutta jos olet todella koodaus Macin tai Windowsin myös

294
00:17:56,000 --> 00:17:59,000
luultavasti olet menossa on 64-bittinen kone,

295
00:17:59,000 --> 00:18:03,000
Muista siis, että tiedot koot aion näyttää tässä

296
00:18:03,000 --> 00:18:06,000
ovat 32-bittinen kone.

297
00:18:06,000 --> 00:18:08,000
Ensimmäinen että näimme oli int-

298
00:18:08,000 --> 00:18:10,000
joka on melko yksinkertainen.

299
00:18:10,000 --> 00:18:13,000
Voit käyttää int tallentaa kokonaisluku.

300
00:18:13,000 --> 00:18:16,000
Näimme myös merkki, char.

301
00:18:16,000 --> 00:18:20,000
Jos haluat käyttää kirjain tai hieman symboli olet todennäköisesti aio käyttää char.

302
00:18:20,000 --> 00:18:26,000
Char on 1 tavu, mikä tarkoittaa, 8 bittiä, kuten Lexi mainittu.

303
00:18:26,000 --> 00:18:31,000
Periaatteessa meillä on ASCII taulukon, joka on 256

304
00:18:31,000 --> 00:18:34,000
mahdollisia yhdistelmiä 0 ja 1s,

305
00:18:34,000 --> 00:18:37,000
ja sitten kun kirjoitat char se tulee kääntää

306
00:18:37,000 --> 00:18:44,000
merkki siitä, että tulot sinulla useita, että sinulla on ASCII taulukon, kuten Lexi sanoi.

307
00:18:44,000 --> 00:18:48,000
Meillä on myös uimuri, jota käytämme tallentaa desimaalilukuja.

308
00:18:48,000 --> 00:18:53,000
Jos haluat valita 3,14, esimerkiksi aiot käyttää float

309
00:18:53,000 --> 00:18:55,000
tai kaksinkertainen, jossa on enemmän tarkkuutta.

310
00:18:55,000 --> 00:18:57,000
Float on 4 tavua.

311
00:18:57,000 --> 00:19:01,000
Kaksinkertainen on 8 tavua, joten ainoa ero on tarkkuus.

312
00:19:01,000 --> 00:19:04,000
Meillä on myös pitkä, että käytetään kokonaislukuja,

313
00:19:04,000 --> 00:19:09,000
ja voit nähdä 32-bittinen kone int ja pitkä on sama koko,

314
00:19:09,000 --> 00:19:13,000
joten se ei todellakaan järkevää käyttää pitkään 32-bittinen kone.

315
00:19:13,000 --> 00:19:17,000
>> Mutta jos käytät Mac ja 64-bittinen kone, todella pitkä on koko 8,

316
00:19:17,000 --> 00:19:19,000
niin se riippuu oikeastaan ​​arkkitehtuuriin.

317
00:19:19,000 --> 00:19:22,000
Sillä 32-bittinen kone se ei ole järkevää käyttää pitkää todella.

318
00:19:22,000 --> 00:19:25,000
Ja sitten pitkä pitkä, toisaalta, on 8 tavua,

319
00:19:25,000 --> 00:19:30,000
joten se on erittäin hyvä, jos haluat olla pidempi kokonaisluku.

320
00:19:30,000 --> 00:19:34,000
Ja lopuksi, meillä on merkkijono, joka on oikeastaan ​​char *,

321
00:19:34,000 --> 00:19:37,000
joka on osoitin char.

322
00:19:37,000 --> 00:19:40,000
Se on hyvin helppo ajatella, että koko merkkijono tulee olemaan kuten

323
00:19:40,000 --> 00:19:42,000
merkkien määrä että olet siellä,

324
00:19:42,000 --> 00:19:45,000
mutta todellisuudessa char * itse

325
00:19:45,000 --> 00:19:49,000
on koko osoittimen char, joka on 4 tavua.

326
00:19:49,000 --> 00:19:52,000
Koko char * on 4 tavua.

327
00:19:52,000 --> 00:19:56,000
Sillä ei ole väliä, jos sinulla on pieni sana tai kirjain tai mitään.

328
00:19:56,000 --> 00:19:58,000
Se tulee olemaan 4 tavua.

329
00:19:58,000 --> 00:20:01,000
Opimme myös hieman siitä valu,

330
00:20:01,000 --> 00:20:04,000
niin näet, jos sinulla on esimerkiksi ohjelma, joka kertoo

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

332
00:20:08,000 --> 00:20:12,000
Tiedättekö mitä se tulee tulostaa näytölle?

333
00:20:12,000 --> 00:20:14,000
>> Joku? >> [Opiskelijat] 2.

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

335
00:20:16,000 --> 00:20:20,000
Kun teet 3/2 se tulee saada 1,5,

336
00:20:20,000 --> 00:20:24,000
mutta koska käytämme kokonaisluku se tulee jättää desimaaliosan,

337
00:20:24,000 --> 00:20:26,000
ja olet menossa on 1.

338
00:20:26,000 --> 00:20:29,000
Jos et halua, että tapahtuu mitä voit tehdä, esimerkiksi

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

340
00:20:33,000 --> 00:20:40,000
Sitten x että aiemmin 3 nyt olemaan 3,000 y.

341
00:20:40,000 --> 00:20:44,000
Ja sitten voit tulostaa y / 2.

342
00:20:44,000 --> 00:20:50,000
Oikeastaan ​​minun pitäisi olla 2. tuolla.

343
00:20:50,000 --> 00:20:55,000
Se tulee tehdä 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
ja aiot saada 1,5.

345
00:20:58,000 --> 00:21:06,000
Ja meillä on tämä .2 f vain pyytää 2 desimaalin yksiköitä desimaaliosan.

346
00:21:06,000 --> 00:21:12,000
Jos sinulla on .3 f se tulee olemaan todella 1,500.

347
00:21:12,000 --> 00:21:16,000
Jos se on 2 se tulee olemaan 1,50.

348
00:21:16,000 --> 00:21:18,000
Meillä on myös tässä asiassa.

349
00:21:18,000 --> 00:21:22,000
Jos et float x = 3,14 ja sitten printf x

350
00:21:22,000 --> 00:21:24,000
aiot saada 3,14.

351
00:21:24,000 --> 00:21:29,000
Ja jos et x = int x,

352
00:21:29,000 --> 00:21:34,000
mikä tarkoittaa kohdella x kuten int ja tulostat x nyt

353
00:21:34,000 --> 00:21:36,000
olet menossa on 3,00.

354
00:21:36,000 --> 00:21:38,000
Onko siinä järkeä?

355
00:21:38,000 --> 00:21:41,000
Koska olet ensimmäinen käsittelemällä x kuin kokonaisluku, niin olet unohdetaan desimaaliosan,

356
00:21:41,000 --> 00:21:45,000
ja sitten olet tulostat x.

357
00:21:45,000 --> 00:21:47,000
Ja lopuksi, voit myös tehdä tämän,

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

359
00:21:52,000 --> 00:21:56,000
ja sitten jos tulostat c olet todella menossa

360
00:21:56,000 --> 00:21:59,000
, Joten periaatteessa mitä teet täällä

361
00:21:59,000 --> 00:22:02,000
on kääntää kokonaisluvun merkki,

362
00:22:02,000 --> 00:22:05,000
aivan kuten ASCII taulukossa ei.

363
00:22:05,000 --> 00:22:08,000
Olemme myös puhuneet matemaattisia operaattoreita.

364
00:22:08,000 --> 00:22:14,000
Useimmat niistä ovat melko suoraviivaista, niin +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
ja myös puhuimme mod, joka on jäljellä jako 2 numeroa.

366
00:22:20,000 --> 00:22:23,000
Jos on 10% 3, esimerkiksi

367
00:22:23,000 --> 00:22:27,000
se tarkoittaa jakaa 10 3, ja mikä on jäljellä?

368
00:22:27,000 --> 00:22:30,000
Se tulee olemaan 1, joten se on oikeastaan ​​erittäin hyödyllinen paljon ohjelmia.

369
00:22:30,000 --> 00:22:38,000
Saat Vigenère ja Caesar olen melko varma, että te kaikki kaverit käyttää mod.

370
00:22:38,000 --> 00:22:43,000
Tietoja matematiikka toimijoiden olla hyvin varovainen, kun yhdistetään * ja /.

371
00:22:43,000 --> 00:22:48,000
>> Esimerkiksi, jos teet (3/2) * 2, mitä aiot saada?

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

373
00:22:50,000 --> 00:22:54,000
Niin, 2, koska 3/2 tulee olemaan 1,5,

374
00:22:54,000 --> 00:22:57,000
mutta koska teet toimintojen välillä 2 kokonaislukujen

375
00:22:57,000 --> 00:22:59,000
olet todella vain menossa harkitsemaan 1,

376
00:22:59,000 --> 00:23:03,000
ja sitten 1 * 2 tulee olemaan 2, niin hyvin, hyvin varovainen

377
00:23:03,000 --> 00:23:07,000
kun teet aritmeettinen kokonaisluvuilla koska

378
00:23:07,000 --> 00:23:12,000
saatat saada että 2 = 3, tässä tapauksessa.

379
00:23:12,000 --> 00:23:14,000
Ja myös olla hyvin varovainen edelle.

380
00:23:14,000 --> 00:23:21,000
Sinun tulisi yleensä käyttää sulkeita olla varma, että tiedät mitä olet tekemässä.

381
00:23:21,000 --> 00:23:27,000
Joitakin hyödyllisiä pikakuvakkeita, tietenkin yksi on i + + tai i + = 1

382
00:23:27,000 --> 00:23:30,000
tai käyttämällä + =.

383
00:23:30,000 --> 00:23:34,000
Se on sama asia kuin teet i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Voit myös tehdä i - tai i - = 1,

385
00:23:39,000 --> 00:23:42,000
joka on sama asia kuin i = i -1,

386
00:23:42,000 --> 00:23:46,000
jotain kaverit käyttää paljon silmukoita, ainakin.

387
00:23:46,000 --> 00:23:52,000
Myös, *, jos käytät * = ja jos et esimerkiksi

388
00:23:52,000 --> 00:23:57,000
i * = 2 on sama asia kuin sanomalla i = i * 2,

389
00:23:57,000 --> 00:23:59,000
ja sama asia jako.

390
00:23:59,000 --> 00:24:08,000
Jos et i / = 2 se on sama asia kuin i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Nyt noin toiminnoista.

392
00:24:10,000 --> 00:24:13,000
Te oppineet, että toiminnot ovat erittäin hyvä strategia säästää code

393
00:24:13,000 --> 00:24:16,000
kun olet ohjelmoinnin, joten jos haluat suorittaa saman tehtävän

394
00:24:16,000 --> 00:24:20,000
koodin uudestaan ​​ja uudestaan, luultavasti haluat käyttää toimintoa

395
00:24:20,000 --> 00:24:25,000
vain niin sinun ei tarvitse kopioida ja liittää koodi uudestaan ​​ja uudestaan.

396
00:24:25,000 --> 00:24:28,000
Oikeastaan ​​tärkein on tehtävä, ja kun minä näytän sinulle muotoa funktion

397
00:24:28,000 --> 00:24:32,000
te tulette näkemään, että se on aika selvää.

398
00:24:32,000 --> 00:24:35,000
Käytämme myös toimintoja joistakin kirjastoista,

399
00:24:35,000 --> 00:24:39,000
Esimerkiksi, printf, GetIn, joka on peräisin CS50 kirjastosta,

400
00:24:39,000 --> 00:24:43,000
ja muita toimintoja, kuten toupper.

401
00:24:43,000 --> 00:24:46,000
Kaikki nämä toiminnot on tosiasiallisesti täytäntöön muissa kirjastoissa,

402
00:24:46,000 --> 00:24:49,000
ja kun laitat ne lieka tiedostot alussa ohjelma

403
00:24:49,000 --> 00:24:53,000
sanot voitteko antaa minulle koodin näitä toimintoja

404
00:24:53,000 --> 00:24:57,000
joten minun ei tarvitse toteuttaa niitä itse?

405
00:24:57,000 --> 00:25:00,000
Ja voit myös kirjoittaa omia funktioita, joten kun aloitat ohjelmoinnin

406
00:25:00,000 --> 00:25:04,000
huomaat, että kirjastot eivät ole kaikki toiminnot, joita tarvitset.

407
00:25:04,000 --> 00:25:10,000
Viimeisen PSET esimerkiksi kirjoitimme piirtää, ryntäily, ja lookup,

408
00:25:10,000 --> 00:25:13,000
ja se on hyvin, hyvin tärkeää pystyä kirjoittamaan toiminnot

409
00:25:13,000 --> 00:25:17,000
koska ne ovat hyödyllisiä, ja käytämme niitä kaiken aikaa ohjelmointi,

410
00:25:17,000 --> 00:25:19,000
ja se säästää paljon koodia.

411
00:25:19,000 --> 00:25:21,000
Muoto toiminto on tämä.

412
00:25:21,000 --> 00:25:24,000
Meillä on palautuva alussa. Mikä on palautuva?

413
00:25:24,000 --> 00:25:27,000
Se on vain kun toiminto on palaamassa.

414
00:25:27,000 --> 00:25:29,000
Jos sinulla on toiminto, esimerkiksi kertoma,

415
00:25:29,000 --> 00:25:31,000
, joka on menossa laskemaan kertoman kokonaisluku,

416
00:25:31,000 --> 00:25:34,000
luultavasti se tulee palauttaa kokonaisluvun myös.

417
00:25:34,000 --> 00:25:37,000
Sitten palautuva tulee olemaan Int.

418
00:25:37,000 --> 00:25:41,000
Printf todella on palautuva void

419
00:25:41,000 --> 00:25:43,000
koska et palaa mitään.

420
00:25:43,000 --> 00:25:45,000
Olet vain tulostaa asioita näytön

421
00:25:45,000 --> 00:25:48,000
ja lopetus-toiminto jälkeenpäin.

422
00:25:48,000 --> 00:25:51,000
Sitten sinulla on funktion nimi, että voit valita.

423
00:25:51,000 --> 00:25:55,000
Sinun pitäisi olla hieman kohtuullinen, kuten eivät valitse nimi kuten xyz

424
00:25:55,000 --> 00:25:58,000
tai kuten x2f.

425
00:25:58,000 --> 00:26:02,000
Yritä keksiä nimi järkeä.

426
00:26:02,000 --> 00:26:04,000
>> Esimerkiksi, jos se on kertoma, sano kertoma.

427
00:26:04,000 --> 00:26:08,000
Jos se on toiminto, joka on menossa tekemään jotain, nimeä se piirtää.

428
00:26:08,000 --> 00:26:11,000
Ja sitten meillä on parametrit, joita kutsutaan myös väitteitä,

429
00:26:11,000 --> 00:26:14,000
jotka ovat kuin resursseja, että toiminto tarvitsee

430
00:26:14,000 --> 00:26:17,000
mistä koodi hoitamaan tehtäväänsä.

431
00:26:17,000 --> 00:26:20,000
Jos haluat laskea luvun kertoman

432
00:26:20,000 --> 00:26:23,000
luultavasti sinun täytyy olla numero laskea kertoma.

433
00:26:23,000 --> 00:26:27,000
Yksi väitteistä, että olet menossa on on numero itse.

434
00:26:27,000 --> 00:26:31,000
Ja sitten se tulee tehdä jotain ja palauttaa arvon lopussa

435
00:26:31,000 --> 00:26:35,000
ellei se mitätön tehtävä.

436
00:26:35,000 --> 00:26:37,000
Katsotaanpa esimerkki.

437
00:26:37,000 --> 00:26:40,000
Jos haluan kirjoittaa funktio, joka summaa kaikki numerot joukko kokonaislukuja,

438
00:26:40,000 --> 00:26:43,000
ensinnäkin, että palautuva tulee olemaan int

439
00:26:43,000 --> 00:26:46,000
koska minulla on joukko kokonaislukuja.

440
00:26:46,000 --> 00:26:51,000
Ja sitten aion olla funktion nimi kuten sumArray,

441
00:26:51,000 --> 00:26:54,000
ja sitten se tulee viemään array itse on int nums,

442
00:26:54,000 --> 00:26:58,000
ja sitten pituus array joten tiedän, kuinka monta numeroa minun täytyy tiivistää.

443
00:26:58,000 --> 00:27:02,000
Sitten minun täytyy alustaa muuttuja nimeltä summan, esimerkiksi 0,

444
00:27:02,000 --> 00:27:08,000
ja joka kerta näen alkio Lisäisin sen summan, joten tein varten silmukka.

445
00:27:08,000 --> 00:27:15,000
Aivan kuten Lexi sanoi, et int i = 0, i <pituus ja i + +.

446
00:27:15,000 --> 00:27:20,000
Ja jokainen alkio tein summa + = nums [i]

447
00:27:20,000 --> 00:27:24,000
ja sitten palasin summa, joten se on hyvin yksinkertainen, ja se säästää paljon koodia

448
00:27:24,000 --> 00:27:28,000
Jos käytät tätä toimintoa paljon kertaa.

449
00:27:28,000 --> 00:27:32,000
Sitten otimme tarkastella olosuhteissa.

450
00:27:32,000 --> 00:27:38,000
Meillä on if, else, ja else if.

451
00:27:38,000 --> 00:27:42,000
Katsotaan, mitä eroa näiden.

452
00:27:42,000 --> 00:27:45,000
Katsokaa näitä 2 koodeja. Mikä on ero niiden välillä?

453
00:27:45,000 --> 00:27:49,000
Ensimmäinen on, pohjimmiltaan koodit haluaa sinun kertovan

454
00:27:49,000 --> 00:27:51,000
jos numero on +, - tai 0.

455
00:27:51,000 --> 00:27:55,000
Ensimmäinen sanoo, jos se on> 0, se on positiivista.

456
00:27:55,000 --> 00:28:00,000
Jos se on = 0 niin se on 0, ja jos se on <0 niin se on negatiivinen.

457
00:28:00,000 --> 00:28:04,000
>> Ja toinen on tekemässä, jos muuta, jos muuta.

458
00:28:04,000 --> 00:28:07,000
Ero näiden kahden välillä on se, että tämä on todella menossa

459
00:28:07,000 --> 00:28:13,000
tarkista> 0, <0 tai = 0 kolme kertaa,

460
00:28:13,000 --> 00:28:17,000
joten jos sinulla on numero 2, esimerkiksi, se tulee tänne ja sanovat

461
00:28:17,000 --> 00:28:21,000
if (x> 0), ja se tulee sanoa kyllä, niin voin tulostaa positiivinen.

462
00:28:21,000 --> 00:28:25,000
Mutta vaikka tiedän, että se on> 0 ja se ei tule olemaan 0 tai <0

463
00:28:25,000 --> 00:28:29,000
Aion silti tehdä, on se 0, on se <0,

464
00:28:29,000 --> 00:28:33,000
joten olen todella menossa sisälle IFS, etten tarvitse

465
00:28:33,000 --> 00:28:38,000
koska tiedän jo, että se ei aio täytä mitään näistä edellytyksistä.

466
00:28:38,000 --> 00:28:41,000
Voin käyttää, jos if, else selvitys.

467
00:28:41,000 --> 00:28:45,000
Se pohjimmiltaan sanoo, että jos x = 0 voin tulostaa positiivinen.

468
00:28:45,000 --> 00:28:48,000
Jos se ei ole, aion myös testata tätä.

469
00:28:48,000 --> 00:28:51,000
Jos se on 2 ei aion tehdä tämän.

470
00:28:51,000 --> 00:28:54,000
Periaatteessa jos olisin x = 2 sanoisit

471
00:28:54,000 --> 00:28:57,000
if (x> 0), kyllä, niin tulosta tämä.

472
00:28:57,000 --> 00:29:00,000
Nyt tiedän, että se on> 0 ja että se täyttää ensin, jos

473
00:29:00,000 --> 00:29:02,000
En edes aio suorittaa tämän koodin.

474
00:29:02,000 --> 00:29:09,000
Koodi toimii nopeammin, jopa 3 kertaa nopeammin, jos käytät tätä.

475
00:29:09,000 --> 00:29:11,000
Olemme myös oppineet ja ja tai.

476
00:29:11,000 --> 00:29:15,000
En aio käydä läpi tämän takia Lexi jo puhui heille.

477
00:29:15,000 --> 00:29:17,000
Se on vain && ja | | operaattori.

478
00:29:17,000 --> 00:29:21,000
>> Ainoa asia sanon on oltava varovainen, kun sinulla on 3 edellytykset.

479
00:29:21,000 --> 00:29:24,000
Käytä suluissa koska se on hyvin hämmentävää, kun olet kunnossa

480
00:29:24,000 --> 00:29:27,000
ja toinen tai toinen.

481
00:29:27,000 --> 00:29:30,000
Käytä sulkeita vain olla varma, että olosuhteet järkeä

482
00:29:30,000 --> 00:29:34,000
koska siinä tapauksessa, esimerkiksi, voitte kuvitella, että

483
00:29:34,000 --> 00:29:38,000
se voisi olla ensimmäinen ehto ja yksi tai muiden

484
00:29:38,000 --> 00:29:41,000
tai 2 edellytykset yhdistetään ja

485
00:29:41,000 --> 00:29:45,000
tai kolmas, joten vain olla varovainen.

486
00:29:45,000 --> 00:29:48,000
Ja lopuksi, puhuimme kytkimet.

487
00:29:48,000 --> 00:29:53,000
Kytkin on erittäin hyödyllinen, kun sinulla on vaihteleva.

488
00:29:53,000 --> 00:29:55,000
Oletetaan, että sinulla on vaihteleva kuten n

489
00:29:55,000 --> 00:29:59,000
, joka voi olla 0, 1 tai 2, ja kukin näistä tapauksista

490
00:29:59,000 --> 00:30:01,000
aiot suorittaa tehtävän.

491
00:30:01,000 --> 00:30:04,000
Voit sanoa vaihtaa muuttuja, ja se osoittaa, että

492
00:30:04,000 --> 00:30:08,000
arvo sitten on kuin arvo1 aion tehdä tämän,

493
00:30:08,000 --> 00:30:12,000
ja sitten rikkoa, mikä tarkoittaa, en aio katsoa mitään muita tapauksia

494
00:30:12,000 --> 00:30:15,000
koska olemme jo tyytyväisiä, että asia

495
00:30:15,000 --> 00:30:20,000
ja sitten arvo2 ja niin edelleen, ja olen myös voi olla oletuksena kytkin.

496
00:30:20,000 --> 00:30:24,000
Tämä tarkoittaa, että jos se ei täytä mitään niistä asioista, jotka olin

497
00:30:24,000 --> 00:30:29,000
että aion tehdä jotain muuta, mutta se on vapaaehtoista.

498
00:30:29,000 --> 00:30:36,000
Siinä kaikki minulle. Nyt on Tommy.

499
00:30:36,000 --> 00:30:41,000
Okei, tämä tulee olemaan viikon 3-ish.

500
00:30:41,000 --> 00:30:45,000
Nämä ovat joitakin aiheita me voidaan kattaa, Crypto, laajuus, taulukot, jne..

501
00:30:45,000 --> 00:30:49,000
Just a quick sanaa salauksen. Emme aio vasara tämän kotiin.

502
00:30:49,000 --> 00:30:52,000
>> Teimme tämän PSET 2, mutta tietokilpailu varmista, että tiedät eron

503
00:30:52,000 --> 00:30:54,000
välillä Caesar cipher ja Vigenère cipher,

504
00:30:54,000 --> 00:30:57,000
miten molemmat näistä ciphers työn ja millaista salata

505
00:30:57,000 --> 00:30:59,000
ja purkaa tekstiä nuo 2 ciphers.

506
00:30:59,000 --> 00:31:03,000
Muista, Caesar cipher yksinkertaisesti kiertää jokaisen merkin saman verran,

507
00:31:03,000 --> 00:31:06,000
tekee varmasti mod useissa kirjaimia.

508
00:31:06,000 --> 00:31:09,000
Ja Vigenère salakirjoituksen, toisaalta, pyörii kunkin merkin

509
00:31:09,000 --> 00:31:12,000
jonka eri määrällä, joten mieluummin kuin sanomalla

510
00:31:12,000 --> 00:31:15,000
jokainen merkki käännetään 3 Vigenère pyörii kunkin merkin

511
00:31:15,000 --> 00:31:17,000
jonka eri summan riippuen joitakin avainsanan

512
00:31:17,000 --> 00:31:20,000
jossa jokainen kirjain avainsanan edustaa hieman eri määrä

513
00:31:20,000 --> 00:31:26,000
kiertää selkeää tekstiä.

514
00:31:26,000 --> 00:31:28,000
Katsotaanpa ensin puhua muuttuja soveltamisalasta.

515
00:31:28,000 --> 00:31:30,000
On 2 erilaisia ​​muuttujia.

516
00:31:30,000 --> 00:31:33,000
Meillä on paikallisia muuttujia, ja nämä ovat aiotaan määritellä

517
00:31:33,000 --> 00:31:36,000
ulkopuolella pää-tai ulkopuolella mitään toimintoa tai estää,

518
00:31:36,000 --> 00:31:39,000
ja nämä ovat käytettävissä missä tahansa ohjelmassa.

519
00:31:39,000 --> 00:31:41,000
Jos sinulla on tarkoituksensa ja että toiminto on taas silmukka

520
00:31:41,000 --> 00:31:44,000
iso globaali muuttuja on käytettävissä kaikkialla.

521
00:31:44,000 --> 00:31:48,000
Paikallisen muuttujan, toisaalta, on scoped paikkaan, jossa se on määritetty.

522
00:31:48,000 --> 00:31:53,000
>> Jos sinulla on funktio esimerkiksi täällä meillä on tämä toiminto g,

523
00:31:53,000 --> 00:31:56,000
ja sisältä g on muuttuja tässä kutsutaan y,

524
00:31:56,000 --> 00:31:58,000
ja se tarkoittaa, että tämä on paikallinen muuttuja.

525
00:31:58,000 --> 00:32:00,000
Vaikka tämä muuttuja on nimeltään y

526
00:32:00,000 --> 00:32:03,000
ja tämä muuttuja on nimeltään y nämä 2 tehtävät

527
00:32:03,000 --> 00:32:06,000
ei ole aavistustakaan mitä toistensa paikallisia muuttujia ovat.

528
00:32:06,000 --> 00:32:10,000
Toisaalta, täällä sanomme int x = 5,

529
00:32:10,000 --> 00:32:12,000
ja tämä on kuulu mitään toimintoa.

530
00:32:12,000 --> 00:32:16,000
Se ulkopuolelle tärkein, joten tämä on globaali muuttuja.

531
00:32:16,000 --> 00:32:20,000
Tämä tarkoittaa, että sisällä näitä 2 toimii kun sanon x - tai x + +

532
00:32:20,000 --> 00:32:26,000
Olen käyttää samaa x, jolloin tämä y ja tämä y ovat erilaisia ​​muuttujia.

533
00:32:26,000 --> 00:32:30,000
Se ero globaali muuttuja ja paikallinen muuttuja.

534
00:32:30,000 --> 00:32:33,000
Sikäli kuin suunnittelun osalta, joskus se on luultavasti parempi idea

535
00:32:33,000 --> 00:32:37,000
pitää muuttujien paikalliseen aina kun mahdollista

536
00:32:37,000 --> 00:32:39,000
koska ottaa kasan globaaleja muuttujia voi saada todella sekava.

537
00:32:39,000 --> 00:32:42,000
Jos sinulla on nippu toimii kaikkien muuttaa samaa

538
00:32:42,000 --> 00:32:45,000
saatat unohtaa mitä jos tämä toiminto vahingossa muuttaa tämän maailmanlaajuisen,

539
00:32:45,000 --> 00:32:47,000
ja tämä toinen toiminto ei tiedä siitä,

540
00:32:47,000 --> 00:32:50,000
ja se saada melko sekava saat enemmän koodia.

541
00:32:50,000 --> 00:32:53,000
Keeping muuttujia paikallisten aina kun mahdollista

542
00:32:53,000 --> 00:32:56,000
On vain hyvää suunnittelua.

543
00:32:56,000 --> 00:33:00,000
Arrays, muistakaa, ovat yksinkertaisesti luettelot elementtejä samaa tyyppiä.

544
00:33:00,000 --> 00:33:04,000
Sisällä CI ei voi olla luettelossa, kuten 1, 2,0, hei.

545
00:33:04,000 --> 00:33:06,000
Emme vain voi tehdä sitä.

546
00:33:06,000 --> 00:33:11,000
>> Kun me julistamme array C kaikilla elementeillä on oltava samaa tyyppiä.

547
00:33:11,000 --> 00:33:14,000
Tässä olen valikoima 3 kokonaislukuja.

548
00:33:14,000 --> 00:33:18,000
Tässä olen pituus array, mutta jos olen vain toteavan tämän syntaksin

549
00:33:18,000 --> 00:33:21,000
missä voin määrittää, mitä kaikki elementit En ole teknisesti tarvitse tätä 3.

550
00:33:21,000 --> 00:33:25,000
Kääntäjä on fiksu selvittää, miten suuri joukko olisi.

551
00:33:25,000 --> 00:33:28,000
Nyt kun haluan saada tai asettaa arvon taulukon

552
00:33:28,000 --> 00:33:30,000
Tässä on syntaksi tehdä niin.

553
00:33:30,000 --> 00:33:33,000
Tämä todella muuttaa toista alkiota, koska muistan,

554
00:33:33,000 --> 00:33:36,000
numerointi alkaa 0, ei 1.

555
00:33:36,000 --> 00:33:42,000
Jos haluan lukea, että arvo voin sanoa jotain int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Tai jos haluan asettaa tämän arvon, kuten olen täällä,

557
00:33:44,000 --> 00:33:47,000
Voin sanoa array [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Tuo aika päästä elementit niiden indeksin

559
00:33:50,000 --> 00:33:52,000
tai asemansa tai jos ne ovat array,

560
00:33:52,000 --> 00:33:57,000
ja että listaus alkaa 0.

561
00:33:57,000 --> 00:34:00,000
Voimme myös paneelit paneelit,

562
00:34:00,000 --> 00:34:03,000
ja tätä kutsutaan moni-ulotteinen taulukko.

563
00:34:03,000 --> 00:34:05,000
Kun meillä on moniulotteinen array

564
00:34:05,000 --> 00:34:07,000
se tarkoittaa, että voimme saada jotain rivejä ja sarakkeita,

565
00:34:07,000 --> 00:34:11,000
ja tämä on vain yksi tapa visualisoida tätä tai ajatellut sitä.

566
00:34:11,000 --> 00:34:14,000
Kun minulla on moniulotteinen array joka tarkoittaa aion aloittaa tarvitseville

567
00:34:14,000 --> 00:34:17,000
yli 1 indeksiä, koska jos minulla on ruudukko

568
00:34:17,000 --> 00:34:19,000
vain sanoa mitä rivillä olet ei anna meille numero.

569
00:34:19,000 --> 00:34:22,000
Se on oikeastaan ​​vain antaa meille listan numeroita.

570
00:34:22,000 --> 00:34:25,000
Sanotaan olen tätä array täällä.

571
00:34:25,000 --> 00:34:30,000
Olen array nimeltään grid, ja sanon sen 2 riviä ja 3 saraketta,

572
00:34:30,000 --> 00:34:32,000
ja niin tämä on yksi tapa katsella sitä.

573
00:34:32,000 --> 00:34:37,000
Kun sanon haluan saada elementti [1] [2]

574
00:34:37,000 --> 00:34:41,000
tämä tarkoittaa, että koska nämä ovat rivit ensin ja sitten sarakkeita

575
00:34:41,000 --> 00:34:44,000
Aion hypätä rivin 1 jälkeen sanoin 1.

576
00:34:44,000 --> 00:34:49,000
>> Sitten aion tulla tänne 2 sarakkeessa, ja aion saada arvoa 6.

577
00:34:49,000 --> 00:34:51,000
Järkeä?

578
00:34:51,000 --> 00:34:55,000
Moniulotteinen taulukot, muistakaa, ovat teknisesti vain joukko matriiseja.

579
00:34:55,000 --> 00:34:57,000
Voimme olla ryhmät ryhmät matriiseja.

580
00:34:57,000 --> 00:35:00,000
Voimme jatkaa, mutta todella yksi tapa ajatella

581
00:35:00,000 --> 00:35:03,000
miten tämä on aseteltu ja mitä tapahtuu on visualisoida sitä

582
00:35:03,000 --> 00:35:09,000
in grid näin.

583
00:35:09,000 --> 00:35:12,000
Kun ohitamme matriiseja toimintoihin, he aikovat käyttäytyä

584
00:35:12,000 --> 00:35:16,000
hieman eri tavalla kuin silloin, kun välitämme säännölliset muuttujia toiminnot

585
00:35:16,000 --> 00:35:18,000
kuin ohimennen int tai float.

586
00:35:18,000 --> 00:35:21,000
Kun me kulkea int tai char tai näistä muista tietotyyppien

587
00:35:21,000 --> 00:35:24,000
me vain otti katsomaan jos toiminto muuttaa

588
00:35:24,000 --> 00:35:28,000
arvo, että muuttuja, että muutos ei tule levittää ylös

589
00:35:28,000 --> 00:35:32,000
kutsuvaan toiminto.

590
00:35:32,000 --> 00:35:35,000
Jossa joukko, toisaalta, että näin tapahtuu.

591
00:35:35,000 --> 00:35:39,000
Jos minä kulkea array jokin funktio ja funktio muuttaa joitakin elementtejä,

592
00:35:39,000 --> 00:35:43,000
kun tulen takaisin ylös toiminto kutsui

593
00:35:43,000 --> 00:35:47,000
minun array nyt olemaan erilainen, ja sanastoa, että

594
00:35:47,000 --> 00:35:50,000
on paneelit ovat läpäisseet viitataan, kuten näemme myöhemmin.

595
00:35:50,000 --> 00:35:53,000
Tämä liittyy siihen, miten viitteitä työtä, jossa nämä perustiedot tietotyypit,

596
00:35:53,000 --> 00:35:55,000
Toisaalta, johdetaan arvosta.

597
00:35:55,000 --> 00:35:59,000
>> Voimme ajatella, että tehdään kopio joidenkin muuttujan ja sitten ohimennen kopio.

598
00:35:59,000 --> 00:36:01,000
Sillä ei ole väliä, mitä me teemme, että vaihteleva.

599
00:36:01,000 --> 00:36:06,000
Soittamalla toiminto ei ole tietoinen siitä, että se on muuttunut.

600
00:36:06,000 --> 00:36:10,000
Taulukot ovat vain hieman erilainen tässä suhteessa.

601
00:36:10,000 --> 00:36:13,000
Esimerkiksi, kuten juuri näki, tärkein on yksinkertaisesti funktio

602
00:36:13,000 --> 00:36:15,000
joka voi toteuttaa 2 väitteitä.

603
00:36:15,000 --> 00:36:20,000
Ensimmäinen argumentti päätehtävä on argc tai useita väitteitä,

604
00:36:20,000 --> 00:36:23,000
ja toinen argumentti on nimeltään argv,

605
00:36:23,000 --> 00:36:27,000
ja ne ovat todellisia arvoja nämä väitteet.

606
00:36:27,000 --> 00:36:30,000
Sanotaan Minulla on ohjelma nimeltä this.c,

607
00:36:30,000 --> 00:36:34,000
ja sanon tekevät tätä, ja aion suorittaa tämän komentoriviltä.

608
00:36:34,000 --> 00:36:38,000
Nyt siirtää joidenkin väitteiden minun ohjelma nimeltä tätä,

609
00:36:38,000 --> 00:36:42,000
Voisin sanoa jotain. / Tämä on CS 50.

610
00:36:42,000 --> 00:36:45,000
Tämä on mitä me kuvitella Daavid tehdä joka päivä terminaalista.

611
00:36:45,000 --> 00:36:48,000
Mutta nyt päätehtävä sisällä että ohjelman

612
00:36:48,000 --> 00:36:52,000
on näitä arvoja, joten argc on 4.

613
00:36:52,000 --> 00:36:56,000
Se voi olla hieman sekava, koska oikeastaan ​​olemme vain ohimennen on CS 50.

614
00:36:56,000 --> 00:36:58,000
Se on vain 3.

615
00:36:58,000 --> 00:37:02,000
Mutta muista, että ensimmäinen osa argv tai ensimmäisen argumentin

616
00:37:02,000 --> 00:37:05,000
on funktion nimi itse.

617
00:37:05,000 --> 00:37:07,190
Joten se tarkoittaa, että meillä on 4 asioita täällä,

618
00:37:07,190 --> 00:37:10,530
ja ensimmäisen elementin tulee olemaan. / tätä.

619
00:37:10,530 --> 00:37:12,970
Ja tämä on edustettuina merkkijono.

620
00:37:12,970 --> 00:37:18,590
Sitten loput elementit ovat mitä kirjoitit jälkeen ohjelman nimi.

621
00:37:18,590 --> 00:37:22,720
Eli aivan kuten syrjään, koska me luultavasti näimme PSET 2,

622
00:37:22,720 --> 00:37:28,780
Muista, että merkkijono 50 ≠ kokonaisluku 50.

623
00:37:28,780 --> 00:37:32,520
Joten emme voi sanoa jotain, 'int x = argv 3. "

624
00:37:32,520 --> 00:37:36,470
>> Se vain ei ole järkeä, koska tämä on merkkijono, ja tämä on kokonaisluku.

625
00:37:36,470 --> 00:37:38,510
Joten jos haluat muuntaa 2, muistakaa, me aiomme

626
00:37:38,510 --> 00:37:40,810
on tämä maaginen toiminto nimeltään atoi.

627
00:37:40,810 --> 00:37:46,270
Se vie merkkijono ja palauttaa kokonaisluvun oli sisällä merkkijonon.

628
00:37:46,270 --> 00:37:48,360
Niin, että helppo virhe tehdä siitä tietokilpailu,

629
00:37:48,360 --> 00:37:51,590
vain ajatella, että tämä tulee automaattisesti oikean tyyppinen.

630
00:37:51,590 --> 00:37:53,860
Mutta juuri tietää, että nämä ovat aina merkkijonoja

631
00:37:53,860 --> 00:38:00,920
vaikka merkkijono sisältää vain kokonaisluku tai merkin tai float.

632
00:38:00,920 --> 00:38:03,380
Joten nyt Puhutaan käyntiaika.

633
00:38:03,380 --> 00:38:06,700
Kun meillä on kaikki nämä algoritmit tehdä kaikki nämä hulluja asioita,

634
00:38:06,700 --> 00:38:11,580
se on todella hyödyllistä kysyä, "Kuinka kauan ne kestää?"

635
00:38:11,580 --> 00:38:15,500
Me edustamme, että jotain kutsutaan asymptoottinen merkintä.

636
00:38:15,500 --> 00:38:18,430
Joten tämä tarkoittaa, että - no, sanokaamme annamme algoritmi

637
00:38:18,430 --> 00:38:20,840
todella, todella, todella iso panos.

638
00:38:20,840 --> 00:38:23,840
Haluamme kysyä, "Kuinka kauan se vie?

639
00:38:23,840 --> 00:38:26,370
Kuinka monta askelta kestää meidän algoritmi ajaa

640
00:38:26,370 --> 00:38:29,980
funktiona koko panos? "

641
00:38:29,980 --> 00:38:33,080
Eli ensimmäinen tapa voimme kuvata ajoaika on iso O.

642
00:38:33,080 --> 00:38:35,380
Ja tämä on meidän pahin ajoaika.

643
00:38:35,380 --> 00:38:38,590
Jos siis haluat lajitella taulukon, ja annamme algoritmi array

644
00:38:38,590 --> 00:38:41,000
se laskevassa järjestyksessä, kun sen pitäisi olla nousevassa järjestyksessä,

645
00:38:41,000 --> 00:38:43,130
että tulee olemaan pahin.

646
00:38:43,130 --> 00:38:49,800
Tämä on meidän yläraja on maksimiaika meidän algoritmi vie.

647
00:38:49,800 --> 00:38:54,740
Toisaalta, tämä Ω tulee kuvaamaan parhaassa tapauksessa ajoaikaan.

648
00:38:54,740 --> 00:38:58,210
Joten jos annamme jo lajiteltu array lajittelu algoritmin,

649
00:38:58,210 --> 00:39:00,940
kuinka kauan kestää lajitella?

650
00:39:00,940 --> 00:39:06,610
Ja tämän jälkeen, kuvataan alaraja ajoaikaan.

651
00:39:06,610 --> 00:39:10,980
Joten tässä on vain muutamia sanoja, jotka kuvaavat joitakin yhteisiä käyntiaikoja.

652
00:39:10,980 --> 00:39:13,120
Nämä ovat nousevassa järjestyksessä.

653
00:39:13,120 --> 00:39:16,060
Nopein käyntiaika meillä kutsutaan jatkuvasti.

654
00:39:16,060 --> 00:39:19,800
>> Tämä tarkoittaa ei väliä kuinka monta elementtiä annamme algoritmi,

655
00:39:19,800 --> 00:39:22,280
ei väliä kuinka iso meidän array on, lajittelu se

656
00:39:22,280 --> 00:39:26,510
tai tekee mitä teemme on array ottaa aina saman verran aikaa.

657
00:39:26,510 --> 00:39:30,270
Joten meillä voi edustaa, että pelkästään 1, joka on vakio.

658
00:39:30,270 --> 00:39:32,410
Olemme myös katsoi logaritminen ajoaika.

659
00:39:32,410 --> 00:39:34,800
Eli jotain binäärihakupuu on logaritminen,

660
00:39:34,800 --> 00:39:37,140
jossa leikataan ongelman puoli aina

661
00:39:37,140 --> 00:39:40,970
ja sitten kaikki menee enemmän sieltä.

662
00:39:40,970 --> 00:39:43,580
Ja jos olet joskus kirjallisesti O tahansa kertoma algoritmin,

663
00:39:43,580 --> 00:39:47,850
luultavasti ei pitäisi harkita tätä teidän päivä työtä.

664
00:39:47,850 --> 00:39:53,910
Kun vertaamme käyntiaikoja on tärkeää pitää mielessä nämä asiat.

665
00:39:53,910 --> 00:39:57,760
Joten jos minulla on algoritmi, joka on O (n), ja joku muu

666
00:39:57,760 --> 00:40:03,590
on algoritmi O (2n), että nämä ovat asymptoottisesti vastaavat.

667
00:40:03,590 --> 00:40:06,590
Joten jos me kuvittelemme n: n iso numero kuten Eleventy miljardia:

668
00:40:06,590 --> 00:40:13,090
joten kun olemme vertaamalla Eleventy miljardin jotain Eleventy miljardia + 3,

669
00:40:13,090 --> 00:40:17,640
yhtäkkiä että +3 ei oikeastaan ​​tee suurta eroa enää.

670
00:40:17,640 --> 00:40:20,980
Siksi aiomme alkaa harkita näitä asioita vastaaviksi.

671
00:40:20,980 --> 00:40:24,220
Joten asiat kuten nämä vakiot täällä, siellä on 2 x tämän, tai lisäämällä 3,

672
00:40:24,220 --> 00:40:27,180
nämä ovat vain vakioita, ja nämä ovat menossa pudota ylös.

673
00:40:27,180 --> 00:40:32,480
Joten siksi kaikki 3 näistä ajoajat ovat samat kuin sanomalla he O (n).

674
00:40:32,480 --> 00:40:37,490
Vastaavasti jos meillä on 2 muuta ajoajat, sanokaamme O (n ³ + 2n ²), voimme lisätä

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, ja sitten meillä on toinen ajoaika, joka on vain O (n ³).

676
00:40:42,070 --> 00:40:46,290
kerran, nämä ovat sama asia, koska nämä - nämä eivät ole samoja.

677
00:40:46,290 --> 00:40:49,840
Nämä ovat samoja asioita, sorry. Nämä ovat siis samat, koska

678
00:40:49,840 --> 00:40:53,090
tämä n ³ tulee hallitsemaan tätä 2n ².

679
00:40:53,090 --> 00:40:59,130
>> Mikä ei ole sama asia on, jos olemme ajaa aikoina O (n ³) ja O (n ²)

680
00:40:59,130 --> 00:41:02,820
koska tämä n ³ on paljon suurempi kuin tämän n ².

681
00:41:02,820 --> 00:41:05,470
Eli jos meillä on potensseja, yhtäkkiä tämä alkaa merkitystä,

682
00:41:05,470 --> 00:41:08,280
mutta kun olemme juuri tekemisissä tekijät kuin me olemme täällä,

683
00:41:08,280 --> 00:41:12,810
niin se ei tule väliä, koska he ovat juuri menossa pudota pois.

684
00:41:12,810 --> 00:41:16,760
Otetaan katsomaan joitakin algoritmeja olemme nähneet tähän mennessä

685
00:41:16,760 --> 00:41:19,260
ja puhuvat käyntiaika.

686
00:41:19,260 --> 00:41:23,850
Ensimmäinen tapa on etsiä numeron luettelosta, että näimme, oli lineaarinen haku.

687
00:41:23,850 --> 00:41:26,950
Ja täytäntöönpano lineaarinen etsintä on super yksinkertainen.

688
00:41:26,950 --> 00:41:30,490
Meillä on vain listan, ja aiomme tarkastella jokaisen elementti luettelossa

689
00:41:30,490 --> 00:41:34,260
kunnes löydämme määrä etsimme.

690
00:41:34,260 --> 00:41:38,370
Niin se tarkoittaa, että pahimmassa tapauksessa, tämä O (n).

691
00:41:38,370 --> 00:41:40,860
Ja pahimmassa tapauksessa tässä voisi olla, jos elementti on

692
00:41:40,860 --> 00:41:45,710
viimeinen elementti, sitten käyttämällä lineaarista hakua meidän täytyy tarkastella jokaisen elementin

693
00:41:45,710 --> 00:41:50,180
kunnes saamme viimeinen jotta tietää, että se oli todella luettelossa.

694
00:41:50,180 --> 00:41:52,910
Emme voi vain antaa periksi puolitiehen ja sanoa: "Se ei todennäköisesti ole olemassa."

695
00:41:52,910 --> 00:41:55,980
Lineaarinen haku meidän täytyy tarkastella koko juttu.

696
00:41:55,980 --> 00:41:59,090
Parhaassa tapauksessa käynnissä ajan, toisaalta, on vakio

697
00:41:59,090 --> 00:42:04,200
koska parhaassa tapauksessa elementin etsimme on vain ensimmäinen luettelossa.

698
00:42:04,200 --> 00:42:08,930
Joten se vie meidät tasan 1 vaihe, ei väliä kuinka suuri luettelo on

699
00:42:08,930 --> 00:42:12,140
jos etsimme ensimmäinen elementti joka kerta.

700
00:42:12,140 --> 00:42:15,390
>> Joten kun haet, muistakaa, se ei vaadi, että luettelo voidaan lajitella.

701
00:42:15,390 --> 00:42:19,430
Koska me yksinkertaisesti menossa katsomaan yli jokaisen elementin, ja se ei ole väliä

702
00:42:19,430 --> 00:42:23,560
missä järjestyksessä näitä tekijöitä ovat tuumaa

703
00:42:23,560 --> 00:42:28,110
Enemmän älykkäitä hakualgoritmi on jotain binäärihakupuu.

704
00:42:28,110 --> 00:42:31,500
Muista, täytäntöönpano binäärihakupuu on, kun olet menossa

705
00:42:31,500 --> 00:42:34,320
pitää etsiä keskelle luettelosta.

706
00:42:34,320 --> 00:42:38,000
Ja koska me tarkastelemme keskellä, vaadimme, että luettelo on järjestetty

707
00:42:38,000 --> 00:42:40,580
tai muuten emme tiedä missä keskellä on, ja meidän on katsottava yli

708
00:42:40,580 --> 00:42:44,480
koko lista löytää se, ja sitten siinä vaiheessa olemme vain tuhlaa aikaa.

709
00:42:44,480 --> 00:42:48,480
Eli jos meillä on lajiteltu lista ja löydämme keskellä, aiomme verrata keskelle

710
00:42:48,480 --> 00:42:51,590
sen elementin etsimme.

711
00:42:51,590 --> 00:42:54,640
Jos se on liian korkea, niin voimme unohtaa oikea puoli

712
00:42:54,640 --> 00:42:57,810
koska tiedämme, että jos meidän osa on jo liian suuri

713
00:42:57,810 --> 00:43:01,080
ja kaikki oikealle tämä elementti on vielä suurempi,

714
00:43:01,080 --> 00:43:02,760
meidän ei tarvitse katsoa sinne enää.

715
00:43:02,760 --> 00:43:05,430
Jos toisaalta, jos meidän elementti on liian alhainen,

716
00:43:05,430 --> 00:43:08,700
tiedämme kaiken vasemmalla että elementti on myös liian alhainen,

717
00:43:08,700 --> 00:43:11,390
joten se ei oikeastaan ​​järkeä katsoa sinne, joko.

718
00:43:11,390 --> 00:43:15,760
Näin jokaisella askeleella ja joka kerta katsomme keskipisteessä luettelon

719
00:43:15,760 --> 00:43:19,060
aiomme leikata meidän ongelma puoli, sillä yhtäkkiä tiedämme

720
00:43:19,060 --> 00:43:23,040
koko joukko numeroita, jotka eivät voi olla yksi etsimme.

721
00:43:23,040 --> 00:43:26,950
>> Pseudokoodilla tämä näyttää tältä,

722
00:43:26,950 --> 00:43:30,990
ja koska olemme leikkaus luettelon puoli joka ikinen kerta,

723
00:43:30,990 --> 00:43:34,920
meidän pahin käyntiaika hyppää lineaarisesta logaritminen.

724
00:43:34,920 --> 00:43:39,260
Joten yhtäkkiä meillä on log-vaiheissa, jotta löydettäisiin elementti luettelosta.

725
00:43:39,260 --> 00:43:42,460
Paras tapaus käyntiaika, vaikka on vielä vakio

726
00:43:42,460 --> 00:43:45,180
koska nyt haluan vain sanoa, että elementti etsimme on

727
00:43:45,180 --> 00:43:48,380
aina tarkka keskellä alkuperäisen luettelon.

728
00:43:48,380 --> 00:43:52,080
Joten voimme kasvattaa luetteloa yhtä suuri kuin haluamme, mutta jos elementti etsimme on keskellä,

729
00:43:52,080 --> 00:43:54,910
niin se vain vie meidät 1 askeleen.

730
00:43:54,910 --> 00:44:00,920
Joten siksi olemme O (log n) ja Ω (1) tai vakio.

731
00:44:00,920 --> 00:44:04,510
Mennään todella ajaa binäärihakupuu tällä listalla.

732
00:44:04,510 --> 00:44:08,020
Joten sanoa, että me etsimme elementin 164.

733
00:44:08,020 --> 00:44:11,650
Ensimmäinen asia aiomme tehdä, on löytää midpoint luettelon.

734
00:44:11,650 --> 00:44:15,060
Se vain on niin, että keskipiste on menossa laskevan näiden 2 numeroiden

735
00:44:15,060 --> 00:44:18,960
joten katsotaanpa vain mielivaltaisesti sanoa, joka kerta keskipiste osuu 2 numeroa,

736
00:44:18,960 --> 00:44:21,150
Haluan vain pyöristää ylöspäin.

737
00:44:21,150 --> 00:44:24,330
Meidän täytyy vain varmistaa teemme tämän joka askeleella.

738
00:44:24,330 --> 00:44:29,040
Joten menemme pyöristää ylöspäin, ja aiomme sanoa, että 161 on keskellä meidän listan.

739
00:44:29,040 --> 00:44:34,640
Joten 161 <164, ja jokainen elementti vasemmalle 161

740
00:44:34,640 --> 00:44:39,120
On myös <164, joten tiedämme, että se ei auta meitä lainkaan

741
00:44:39,120 --> 00:44:42,690
lähteä etsimään tänne koska osa etsimme voi olla siellä.

742
00:44:42,690 --> 00:44:47,060
Joten mitä voimme tehdä on, voimme vain unohtaa, että koko vasen puoli luettelon,

743
00:44:47,060 --> 00:44:51,700
ja nyt vain katsoa pois oikeus 161 eteenpäin.

744
00:44:51,700 --> 00:44:54,050
>> Joten jälleen, tämä on keskipiste, mennään vain pyöristää ylöspäin.

745
00:44:54,050 --> 00:44:56,260
Nyt 175 on liian iso.

746
00:44:56,260 --> 00:44:59,180
Joten me tiedämme se ei auta meitä etsivät täällä tai täällä,

747
00:44:59,180 --> 00:45:06,610
joten voimme vain heittää sen pois, ja lopulta me osuma 164.

748
00:45:06,610 --> 00:45:10,560
Mahdolliset kysymykset binäärihakupuu?

749
00:45:10,560 --> 00:45:14,180
Siirrytään etsimisestä kautta jo lajitellaan luettelossa

750
00:45:14,180 --> 00:45:17,660
todella ottaa listan numerot tahansa järjestyksessä

751
00:45:17,660 --> 00:45:20,960
ja antaa tämän luettelon nousevassa järjestyksessä.

752
00:45:20,960 --> 00:45:24,060
Ensimmäinen algoritmi me katsoimme oli nimeltään Bubble sort.

753
00:45:24,060 --> 00:45:27,300
Ja tämä olisi yksinkertaisempi ja algoritmien näimme.

754
00:45:27,300 --> 00:45:32,970
Bubble sort sanoo, että kun jokin 2 Sisällä luetteloon ovat paikallaan,

755
00:45:32,970 --> 00:45:36,500
siten on olemassa suurempi määrä vasemmalla puolella on pienempi määrä,

756
00:45:36,500 --> 00:45:40,190
Sitten aiomme vaihtaa niitä, koska se tarkoittaa, että luettelo on

757
00:45:40,190 --> 00:45:42,860
"Enemmän lajiteltu" kuin se oli ennen.

758
00:45:42,860 --> 00:45:45,180
Ja olemme juuri menossa jatkaa tätä prosessia uudestaan ​​ja uudestaan ​​ja uudestaan

759
00:45:45,180 --> 00:45:52,100
kunnes lopulta elementit sellainen kupla niiden oikeaan paikkaan, ja meillä on järjestetty luettelo.

760
00:45:52,100 --> 00:45:57,230
>> Käyntiaika Tämän tulee olla O (n ²). Miksi?

761
00:45:57,230 --> 00:46:00,370
No, koska pahimmassa tapauksessa aiomme ryhtyä jokaisen elementin, ja

762
00:46:00,370 --> 00:46:04,570
aiomme päätyä vertaamalla sitä joka toinen elementti luettelossa.

763
00:46:04,570 --> 00:46:08,030
Mutta parhaassa tapauksessa meillä on jo järjestetty luettelo, kupla sort n

764
00:46:08,030 --> 00:46:12,230
juuri menossa läpi kerran, sano "Ei. en tee mitään swapit, joten olen valmis."

765
00:46:12,230 --> 00:46:17,410
Joten meillä on parhaassa tapauksessa käyntiaika Ω (n).

766
00:46:17,410 --> 00:46:20,680
Katsotaanpa ajaa kupla lajitella luettelon.

767
00:46:20,680 --> 00:46:23,560
Tai ensin, mennään katsokaa joitakin pseudokoodilla todella nopeasti.

768
00:46:23,560 --> 00:46:28,160
Haluamme sanoa haluamme seurata, joka iterointia silmukan,

769
00:46:28,160 --> 00:46:32,190
pitää kirjaa vai ei muutimme mitään elementtejä.

770
00:46:32,190 --> 00:46:37,610
Eli syy siihen on, me aiomme lopettaa, kun emme ole vaihtanut mitään osia.

771
00:46:37,610 --> 00:46:41,980
Joten alussa meidän silmukan emme ole vaihtanut mitään, joten sanomme että on väärä.

772
00:46:41,980 --> 00:46:47,170
Nyt aiomme käydä listan läpi ja vertaa elementti I osa i + 1

773
00:46:47,170 --> 00:46:50,310
ja jos se on totta, että on olemassa suurempi määrä vasemmalla puolella pienempi määrä,

774
00:46:50,310 --> 00:46:52,310
Sitten olemme juuri menossa vaihtaa niitä.

775
00:46:52,310 --> 00:46:54,490
>> Ja sitten me aiomme muistaa, että me vaihdettu elementti.

776
00:46:54,490 --> 00:46:58,900
Tämä tarkoittaa, että meidän täytyy mennä läpi listan vähintään 1 enemmän aikaa

777
00:46:58,900 --> 00:47:02,160
koska tila, jossa pysähdyimme on kun koko lista on jo järjestetty,

778
00:47:02,160 --> 00:47:04,890
eli emme ole tehneet mitään swapit.

779
00:47:04,890 --> 00:47:09,960
Joten siksi tilaamme tänne on "taas jotkut elementit on vaihdettu."

780
00:47:09,960 --> 00:47:13,720
Joten nyt mennään Katsokaapa tätä käynnissä luettelossa.

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

782
00:47:16,640 --> 00:47:19,850
Bubble sort aikoo aloittaa aina vasemmalla, ja se tulee verrata

783
00:47:19,850 --> 00:47:24,700
i elementtejä, joten 0-i + 1, joka on elementin 1.

784
00:47:24,700 --> 00:47:29,020
Se tulee sanoa, hyvin 5> 0, mutta nyt 5 on vasemmalla,

785
00:47:29,020 --> 00:47:32,500
joten minun täytyy vaihtaa 5 ja 0.

786
00:47:32,500 --> 00:47:35,470
Kun minä vaihtaa niitä, yhtäkkiä saan tämän eri luettelo.

787
00:47:35,470 --> 00:47:38,260
Nyt 5> 1, joten aiomme vaihtaa niitä.

788
00:47:38,260 --> 00:47:42,160
5 ei> 6, joten meidän ei tarvitse tehdä mitään täällä.

789
00:47:42,160 --> 00:47:46,690
Mutta 6> 4, joten meidän täytyy vaihtaa.

790
00:47:46,690 --> 00:47:49,740
Jälleen meidän käydä läpi koko luetteloa lopulta löytää

791
00:47:49,740 --> 00:47:52,330
että nämä ovat epäkunnossa, me vaihtaa niitä,

792
00:47:52,330 --> 00:47:57,120
ja tässä vaiheessa meidän käydä läpi listan 1 enemmän aikaa

793
00:47:57,120 --> 00:48:05,390
varmistaa, että kaikki on sen järjestyksessä, ja tässä vaiheessa kupla lajitella on päättynyt.

794
00:48:05,390 --> 00:48:10,720
Eri algoritmi ottaa joitakin osia ja lajittelu on valinta tavallaan.

795
00:48:10,720 --> 00:48:15,740
Ideana valinta sort että aiomme rakentaa lajiteltu osan luettelossa

796
00:48:15,740 --> 00:48:18,150
1 elementti kerrallaan.

797
00:48:18,150 --> 00:48:23,170
>> Ja miten aiomme tehdä se on luomalla vasemmalla segmentin listan.

798
00:48:23,170 --> 00:48:27,510
Ja pohjimmiltaan jokainen - on jokainen askel, aiomme ottaa pienimmän alkion meillä on jäljellä

799
00:48:27,510 --> 00:48:32,310
jota ei ole lajiteltu vielä, ja me aiomme siirtää sen että lajiteltu segmenttiin.

800
00:48:32,310 --> 00:48:35,850
Tämä tarkoittaa, että meidän on jatkuvasti löytää pienin lajittelemattoman elementti

801
00:48:35,850 --> 00:48:40,720
ja sitten ottaa sen pienin alkio ja vaihtaa sen kanssa, mitä

802
00:48:40,720 --> 00:48:45,090
Vasemmassa elementti, jota ei ole lajiteltu.

803
00:48:45,090 --> 00:48:50,890
Ajoaika Tämän tulee olla O (n ²), koska pahimmassa tapauksessa

804
00:48:50,890 --> 00:48:55,070
meidän vertailla jokainen elementti joka toinen elementti.

805
00:48:55,070 --> 00:48:59,250
Koska sanomme, että jos aloitamme vasemmalla puolella luettelon, tarvitsemme

806
00:48:59,250 --> 00:49:02,970
käydä läpi koko oikea segmentti löytää pienin alkio.

807
00:49:02,970 --> 00:49:05,430
Ja sitten taas, meidän on mentävä koko oikea segmentti ja

808
00:49:05,430 --> 00:49:08,210
jatkakaa yli että yhä uudestaan ​​ja uudestaan.

809
00:49:08,210 --> 00:49:11,350
Tämä tulee olemaan n. ². Olemme menossa varten silmukan sisällä toinen silmukka

810
00:49:11,350 --> 00:49:13,350
mikä viittaa n ².

811
00:49:13,350 --> 00:49:16,530
Parhaassa tapauksessa ajatus, sanokaamme annamme sen jo järjestetty luettelo;

812
00:49:16,530 --> 00:49:19,270
emme oikeastaan ​​tee mitään parempaa kuin n ².

813
00:49:19,270 --> 00:49:21,730
Koska valinta sort ei voi mitenkään tietää, että

814
00:49:21,730 --> 00:49:25,540
pienin elementti on vain yksi Satun katsot.

815
00:49:25,540 --> 00:49:28,970
Se vielä varmistaa, että tämä on todella pienin.

816
00:49:28,970 --> 00:49:31,670
>> Ja ainoa tapa varmistaa, että se on vähintään käyttämällä tämän algoritmin

817
00:49:31,670 --> 00:49:34,640
on tarkastella jokaisen elementin uudelleen.

818
00:49:34,640 --> 00:49:38,420
Siis todella, jos annat sen - jos annat valinta lajitella jo järjestetty luettelo,

819
00:49:38,420 --> 00:49:42,720
se ei aio tehdä mitään paremmin kuin antaa sille luettelon, joka ei ole lajiteltu vielä.

820
00:49:42,720 --> 00:49:46,320
Muuten, jos se sattuu olemaan siinä tapauksessa, että jotain on O (jotain)

821
00:49:46,320 --> 00:49:50,640
ja omega jotain, voimme vain sanoa lyhyemmin, että se on θ jotain.

822
00:49:50,640 --> 00:49:52,760
Joten jos näet että keksiä missään, sitähän se juuri tarkoittaa.

823
00:49:52,760 --> 00:49:57,580
>> Jos jotain on theta n ², se on niin iso O (n ²) ja Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Joten paras asia ja pahimmassa tapauksessa se ei tee eroa,

825
00:49:59,790 --> 00:50:04,400
algoritmi aikoo tehdä saman joka kerta.

826
00:50:04,400 --> 00:50:06,610
Joten tämä on mitä pseudokoodi valinnassa tavallaan voisi näyttää.

827
00:50:06,610 --> 00:50:10,630
Olemme periaatteessa aio sanoa, että haluan toistaa yli luettelo

828
00:50:10,630 --> 00:50:15,180
vasemmalta oikealle, ja kunkin iterointia silmukan, aion siirtyä

829
00:50:15,180 --> 00:50:19,780
pienin elementti tähän lajitellaan osaan luettelosta.

830
00:50:19,780 --> 00:50:23,260
Ja kun minä liikkua jotain siellä, en koskaan tarvitse katsoa, ​​että osa uudelleen.

831
00:50:23,260 --> 00:50:28,600
Koska heti kun vaihtaa osa vasemmalla segmentin listan, se on lajiteltu

832
00:50:28,600 --> 00:50:32,600
koska teemme kaiken nousevassa järjestyksessä käyttämällä minimit.

833
00:50:32,600 --> 00:50:38,740
Joten sanoimme, okei, me olemme asennossa I, ja meidän on tarkasteltava kaikkia tekijöitä

834
00:50:38,740 --> 00:50:42,260
oikealle i, jotta löydettäisiin minimiin.

835
00:50:42,260 --> 00:50:46,150
Niin se tarkoittaa, että haluamme katsoa alkaen i + 1 loppuun luettelosta.

836
00:50:46,150 --> 00:50:51,610
Ja nyt, jos elementti me tarkastelee parhaillaan on pienempi kuin meidän pienin tähän mennessä,

837
00:50:51,610 --> 00:50:54,190
joka, muistakaa, me aloitamme minimi pois vain olla

838
00:50:54,190 --> 00:50:57,020
mitä elementti olemme parhaillaan; Oletan että se minimi.

839
00:50:57,020 --> 00:51:00,270
Jos löydän elementti, joka on pienempi kuin, niin aion sanoa, okei,

840
00:51:00,270 --> 00:51:02,700
No, olen löytänyt uuden minimi.

841
00:51:02,700 --> 00:51:06,080
Aion muistaa missä se minimi oli.

842
00:51:06,080 --> 00:51:09,560
>> Joten nyt, kun olen käynyt läpi, että oikeus lajittelemattoman segmentti,

843
00:51:09,560 --> 00:51:16,690
Voin sanoa aion vaihtaa pienin elementti elementti, joka on asennossa I.

844
00:51:16,690 --> 00:51:21,100
Se tulee rakentaa oma lista, minun lajiteltu osa listan vasemmalta oikealle,

845
00:51:21,100 --> 00:51:25,190
ja me ei koskaan tarvitse katsoa elementin uudelleen, kun se on tuossa osassa.

846
00:51:25,190 --> 00:51:27,930
Kun olemme vaihtanut sitä.

847
00:51:27,930 --> 00:51:30,260
Joten ajaa valinta lajitella tällä listalla.

848
00:51:30,260 --> 00:51:38,220
Sininen tekijä tässä tulee olemaan minä, ja punainen elementti tulee olemaan pienin alkio.

849
00:51:38,220 --> 00:51:41,570
Joten minä alkaa aina vasemmalla puolella listan, niin kello 5.

850
00:51:41,570 --> 00:51:44,610
Nyt meidän on löydettävä minimi lajittelemattoman elementti.

851
00:51:44,610 --> 00:51:49,480
Niinpä sanomme 0 <5, niin 0 on minun uusi minimi.

852
00:51:49,480 --> 00:51:53,820
>> Mutta en voi lopettaa tähän, sillä vaikka voimme tunnustaa, että 0 on pienin,

853
00:51:53,820 --> 00:51:59,390
meidän läpi joka toinen elementti luettelosta varmistaa.

854
00:51:59,390 --> 00:52:01,760
Joten 1 on isompi, 6 on isompi, 4 on isompi.

855
00:52:01,760 --> 00:52:05,850
Tämä tarkoittaa, että kun tarkastellaan kaikkia näitä elementtejä, olen määritelty 0 on pienin.

856
00:52:05,850 --> 00:52:09,800
Joten aion vaihtaa 5 ja 0.

857
00:52:09,800 --> 00:52:15,480
Kun olen swap, että aion saada uuden listan, ja tiedän, että minun ei tarvitse katsoa, ​​että 0 uudestaan

858
00:52:15,480 --> 00:52:19,380
koska kerran olen vaihtanut sen, olen lajitellaan, ja olemme tehneet.

859
00:52:19,380 --> 00:52:22,730
Nyt se vain niin, että sininen elementti on jälleen 5,

860
00:52:22,730 --> 00:52:26,030
ja meidän on tarkasteltava 1, 6 ja 4 määrittää, että 1

861
00:52:26,030 --> 00:52:31,520
on pienin pienin alkio, niin me vaihtaa 1 ja 5.

862
00:52:31,520 --> 00:52:36,890
Jälleen meidän täytyy tarkastella - vertaa 5 6 ja 4,

863
00:52:36,890 --> 00:52:39,830
ja aiomme vaihtaa 4 ja 5, ja lopuksi vertailla

864
00:52:39,830 --> 00:52:45,740
nuo 2 numerot ja vaihtaa niitä kunnes saamme lajiteltu luettelo.

865
00:52:45,740 --> 00:52:49,730
Kaikki kysymykset valintaan lajitella?

866
00:52:49,730 --> 00:52:56,420
Okei. Mennään siirtyä viimeiseen viestiin täällä, ja se on rekursion.

867
00:52:56,420 --> 00:52:59,810
>> Rekursio, muistakaa, on tämä todella meta juttu jos toiminto

868
00:52:59,810 --> 00:53:02,740
toistuvasti kutsuu itseään.

869
00:53:02,740 --> 00:53:05,620
Joten jossain vaiheessa, kun meidän fuction on toistuvasti itseään kutsuva,

870
00:53:05,620 --> 00:53:10,100
siellä on oltava jossain vaiheessa, jossa pysähdymme vaaditaan itseämme.

871
00:53:10,100 --> 00:53:13,670
Koska jos emme tee sitä, niin olemme juuri menossa jatkaa tehdä tätä ikuisesti,

872
00:53:13,670 --> 00:53:16,660
ja meidän ohjelma ei vain aio lopettaa.

873
00:53:16,660 --> 00:53:19,200
Kutsumme tätä edellytystä perustapaus.

874
00:53:19,200 --> 00:53:22,570
Ja perustapauksen sanoo, eikä soittaa taas toiminnassa,

875
00:53:22,570 --> 00:53:25,330
Aion palata jotain arvoa.

876
00:53:25,330 --> 00:53:28,080
Joten kun olemme takaisin arvoon, olemme lopettaneet itseämme,

877
00:53:28,080 --> 00:53:32,550
ja loput puhelujen olemme tehneet tähän mennessä myös palata.

878
00:53:32,550 --> 00:53:36,050
Vastakohta perustapaus on rekursiivinen tapauksessa.

879
00:53:36,050 --> 00:53:39,050
Ja tämä on, kun haluamme tehdä toisen puhelun toiminto, että olemme tällä hetkellä tuumaa

880
00:53:39,050 --> 00:53:44,690
Ja me varmaan, mutta ei aina, haluat käyttää eri argumentteja.

881
00:53:44,690 --> 00:53:48,940
>> Eli jos meillä on toiminto nimeltään F-ja F soitti juuri ottaa 1 väitettä,

882
00:53:48,940 --> 00:53:52,010
ja me vain pitää soittaa f (1), f (1), f (1), ja se vain niin, että

883
00:53:52,010 --> 00:53:56,510
argumentti 1 putoaa rekursiivinen tapauksessa emme vielä koskaan lopeta.

884
00:53:56,510 --> 00:54:01,620
Vaikka meillä on pohja tapauksessa meidän täytyy varmistaa, että lopulta me aiomme lyödä että perustapaus.

885
00:54:01,620 --> 00:54:04,250
Emme vain pitää pysyä tässä rekursiivinen tapauksessa.

886
00:54:04,250 --> 00:54:09,870
Yleensä, kun me kutsumme itseämme, emme luultavasti olemaan erilainen argumentti joka kerta.

887
00:54:09,870 --> 00:54:12,700
Täällä on todella yksinkertainen rekursiivinen funktio.

888
00:54:12,700 --> 00:54:15,090
Joten tämä laskee luvun kertoman.

889
00:54:15,090 --> 00:54:17,790
Ylös täällä meillä perustapaus.

890
00:54:17,790 --> 00:54:22,330
Siinä tapauksessa, että n ≤ 1, emme aio soittaa kertoma uudelleen.

891
00:54:22,330 --> 00:54:26,490
Aiomme lopettaa, olemme juuri menossa takaisin jotain arvoa.

892
00:54:26,490 --> 00:54:30,170
Jos tämä ei ole totta, niin aiomme iski rekursiivinen tapauksessa.

893
00:54:30,170 --> 00:54:33,550
Huomaa, että me emme vain soittamalla factorial (n), koska se ei olisi kovin hyödyllinen.

894
00:54:33,550 --> 00:54:36,810
Aiomme soittaa kertoma jotain muuta.

895
00:54:36,810 --> 00:54:40,850
>> Ja niin näette, lopulta jos ohitamme factorial (5) tai jotain,

896
00:54:40,850 --> 00:54:45,900
aiomme soittaa factorial (4) ja niin edelleen, ja lopulta aiomme iskeä perustapauksen.

897
00:54:45,900 --> 00:54:51,730
Joten tämä näyttää hyvältä. Katsotaan mitä tapahtuu, kun me todella ajaa tätä.

898
00:54:51,730 --> 00:54:57,840
Tämä on pino, ja sanotaan, että tärkein aikoo kutsua tätä toimintoa argumentti (4).

899
00:54:57,840 --> 00:55:02,200
Joten kun kertoma näkee ja = 4, kertoma soittaa itse.

900
00:55:02,200 --> 00:55:05,010
Nyt, yhtäkkiä meillä on factorial (3).

901
00:55:05,010 --> 00:55:10,780
Joten nämä toiminnot ovat menossa kasvamistaan ​​kunnes lopulta me iski perustapaus.

902
00:55:10,780 --> 00:55:17,830
Tässä vaiheessa paluuta arvo on paluuta (nx paluuarvo tämän),

903
00:55:17,830 --> 00:55:21,290
Return arvo on nx palauttaa arvon tämän.

904
00:55:21,290 --> 00:55:23,290
Lopulta meidän osuma joitakin numero.

905
00:55:23,290 --> 00:55:26,560
Huipulla täällä sanomme paluu 1.

906
00:55:26,560 --> 00:55:30,650
Tämä tarkoittaa, että kun palaamme, että määrä, voimme pop tästä pinosta.

907
00:55:30,650 --> 00:55:36,570
Joten tämä kertoma (1) on tehty.

908
00:55:36,570 --> 00:55:41,190
Kun 1 palaa, tämä factorial (1) palaa, tätä paluuta 1.

909
00:55:41,190 --> 00:55:46,910
Paluuarvo tätä, muista, oli nx palauttaa arvon tämän.

910
00:55:46,910 --> 00:55:50,720
Joten yhtäkkiä, tämä kaveri tietää, että haluan palata 2.

911
00:55:50,720 --> 00:55:55,910
>> Joten muistakaa, palauta arvo on vain NX paluuarvo täällä.

912
00:55:55,910 --> 00:56:01,160
Joten nyt voimme sanoa 3 x 2, ja lopuksi, täällä voimme sanoa

913
00:56:01,160 --> 00:56:04,010
tämä on vain olemaan 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
Ja kun tämä palaa, pääsemme yhden kokonaisluvun sisällä tärkein.

915
00:56:09,570 --> 00:56:15,460
Kysyttävää rekursio?

916
00:56:15,460 --> 00:56:17,090
Selvä. Joten siellä on enemmän aikaa kysymysten lopussa,

917
00:56:17,090 --> 00:56:23,360
mutta nyt Joseph kattaa loput aiheet.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] Selvä. Joten nyt olemme puhuneet rekursioiden,

919
00:56:25,590 --> 00:56:27,840
Puhutaan vähän mitä yhdistää sort on.

920
00:56:27,840 --> 00:56:31,740
Yhdistä sort on periaatteessa toinen tapa lajittelu numeroiden luettelosta.

921
00:56:31,740 --> 00:56:36,430
Ja miten se toimii on, jossa merge sort sinulla on luettelo, ja mitä teemme, on

922
00:56:36,430 --> 00:56:39,120
sanomme, hajaannutaan tämän huomioon 2 puolikasta.

923
00:56:39,120 --> 00:56:42,750
Me ensin suorittaa sulautua järjestä uudelleen vasemmalla puoli,

924
00:56:42,750 --> 00:56:45,040
Sitten me ajaa yhdistää lajitella oikealla puoli,

925
00:56:45,040 --> 00:56:50,240
ja se antaa meille nyt 2 puolikasta että lajitellaan, ja nyt aiomme yhdistää nämä puoliskot yhteen.

926
00:56:50,240 --> 00:56:55,010
Se on hieman vaikea nähdä ilman esim. niin menemme läpi liikkeet ja katso mitä tapahtuu.

927
00:56:55,010 --> 00:56:59,590
Joten aloitat tämän luettelon me jakaa sen 2 puolikasta.

928
00:56:59,590 --> 00:57:02,300
Otamme yhdistää lajitella vasemmalla puoli ensin.

929
00:57:02,300 --> 00:57:06,660
Niin, että vasen puoli, ja nyt me ajaa ne läpi tämän listan uudelleen

930
00:57:06,660 --> 00:57:09,800
joka saa siirtyi merge lajitella, ja sitten katsomme, jälleen,

931
00:57:09,800 --> 00:57:13,270
vasemmalla puolella tämän luettelon ja otamme yhdistää sort sitä.

932
00:57:13,270 --> 00:57:15,880
Nyt pääsemme luettelon 2 numeroa,

933
00:57:15,880 --> 00:57:19,010
ja nyt vasen puoli on vain 1 elementti pitkä, ja emme voi

934
00:57:19,010 --> 00:57:23,380
jakaa luettelo, joka on vain 1 elementin puoli, joten voimme vain sanoa, kun meillä on 50,

935
00:57:23,380 --> 00:57:26,400
joka on vain 1 elementti, se on jo lajiteltu.

936
00:57:26,400 --> 00:57:29,860
>> Kun olemme tehneet sen, voimme nähdä, että voimme

937
00:57:29,860 --> 00:57:32,230
siirtyä oikealla puolella tämän luettelon

938
00:57:32,230 --> 00:57:36,480
ja 3 on myös lajitellaan, ja niin nyt, että molemmat puoliskot luettelon lajitellaan

939
00:57:36,480 --> 00:57:39,080
Voimme liittyä näihin numeroihin takaisin yhteen.

940
00:57:39,080 --> 00:57:45,320
Joten katsomme 50 ja 3, 3 on pienempi kuin 50, niin se menee sisään ensin ja sen jälkeen 50 tulee sisään

941
00:57:45,320 --> 00:57:49,340
Nyt se on tehty, palaamme tuohon luetteloon ja lajitella se oikea puoli.

942
00:57:49,340 --> 00:57:52,440
42 on se oma numero, joten se on jo lajiteltu.

943
00:57:52,440 --> 00:57:57,850
Nyt siis verrata näitä 2 ja 3 on pienempi kuin 42, niin että saa laittaa ensimmäiseen,

944
00:57:57,850 --> 00:58:02,340
nyt 42 saa laittaa, ja 50 saa laittaa sisään

945
00:58:02,340 --> 00:58:07,220
Nyt se lajitellaan, menemme aina takaisin alkuun, 1337 ja 15.

946
00:58:07,220 --> 00:58:14,560
No, nyt tarkastelemme vasen puoli luettelo, 1337 on itsessään niin se lajitellaan ja sama 15.

947
00:58:14,560 --> 00:58:19,020
Joten nyt me yhdistää nämä 2 numeroa lajitella että alkuperäisessä luettelossa, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
niin se menee ensin, sitten 1337 menee sisään

949
00:58:23,060 --> 00:58:26,640
Ja nyt me lajitellaan molemmat puoliskot alkuperäisen listan ylös.

950
00:58:26,640 --> 00:58:30,440
Ja meidän täytyy tehdä, on yhdistää nämä.

951
00:58:30,440 --> 00:58:36,890
Katsomme 2 ensimmäistä numeroa tämän luettelon 3 <15, niin se menee tavallaan array ensin.

952
00:58:36,890 --> 00:58:44,460
15 <42, niin se menee sisään nyt, 42 <1337, joka menee sisään

953
00:58:44,460 --> 00:58:51,010
50 <1337, niin se menee sisään ja huomaa, että me vain otti 2 numeroa pois tästä luettelosta.

954
00:58:51,010 --> 00:58:53,640
Joten emme vain vuorotellen 2 luetellaan.

955
00:58:53,640 --> 00:58:56,050
Olemme vain etsivät alussa, ja viemme elementti

956
00:58:56,050 --> 00:59:00,270
joka on pienempi ja sitten laitat sen meidän array.

957
00:59:00,270 --> 00:59:04,080
Nyt olemme yhdisti kaikki puolikkaat ja olemme tehneet.

958
00:59:04,080 --> 00:59:07,780
>> Kysyttävää yhdistää tavallaan? Kyllä?

959
00:59:07,780 --> 00:59:14,190
[Student] Jos se jakaminen eri ryhmiin, miksi he eivät vain jakaa sitä kerran

960
00:59:14,190 --> 00:59:19,970
ja sinulla on 3 ja 2 ryhmässä? [Ulkomaat kysymyksen käsittämätön]

961
00:59:19,970 --> 00:59:24,940
Syy - joten kysymys kuuluu, miksi emme voi vain yhdistää ne, jotka ensimmäisessä vaiheessa kun me ne?

962
00:59:24,940 --> 00:59:29,530
Syy voimme tehdä tämän, aloita äärimmäisenä vasemmalla elementtejä molemmin puolin,

963
00:59:29,530 --> 00:59:33,040
ja sitten ottaa pienempi ja laita se, että tiedämme, että nämä

964
00:59:33,040 --> 00:59:35,290
yksittäiset luettelot ovat lajiteltu tilauksia.

965
00:59:35,290 --> 00:59:37,290
Joten jos Etsin äärimmäisenä vasemmalla elementtejä molemmat puoliskot,

966
00:59:37,290 --> 00:59:40,490
Tiedän, että he aikovat olla pienin osa näistä listoista.

967
00:59:40,490 --> 00:59:43,930
Voin siis laittaa ne pienin osa täplät tämän suuren luettelon.

968
00:59:43,930 --> 00:59:47,810
Toisaalta, jos katson noita 2 luetellaan toisen tason tuolla,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 ja 15, jotka eivät ole lajiteltu.

970
00:59:51,640 --> 00:59:55,770
Joten jos katson 50 ja 1337, aion laittaa 50 otetaan listallani ensin.

971
00:59:55,770 --> 01:00:00,130
Mutta se ei ole oikeastaan ​​mitään järkeä, koska 3 on pienin osa pois kaikki nämä.

972
01:00:00,130 --> 01:00:04,390
Joten ainoa syy voimme tehdä yhdistämällä askel on, koska meidän luettelot ovat jo lajiteltu.

973
01:00:04,390 --> 01:00:07,010
Sen takia meidän täytyy saada alas kaikki pohjaan

974
01:00:07,010 --> 01:00:09,800
koska kun meillä on vain yksi numero, te tiedätte, että yhden numeron

975
01:00:09,800 --> 01:00:14,120
itsessään on jo lajiteltu luettelo.

976
01:00:14,120 --> 01:00:19,360
>> Kysyttävää? Ei?

977
01:00:19,360 --> 01:00:24,260
Monimutkaisuus? No, voit nähdä, että kussakin vaiheessa siellä lopussa numeroita,

978
01:00:24,260 --> 01:00:27,590
ja voimme jakaa luettelon puoli log n kertaa,

979
01:00:27,590 --> 01:00:31,700
mikä on kun saamme tämän n x log n monimutkaisuutta.

980
01:00:31,700 --> 01:00:34,940
Ja näet paras asia Yhdistämisen tavallaan on n log n, ja aivan sattumalta

981
01:00:34,940 --> 01:00:39,340
että pahimmassa tapauksessa, tai Ω siellä, on myös N log N.

982
01:00:39,340 --> 01:00:42,480
Jotain pitää mielessä.

983
01:00:42,480 --> 01:00:45,750
Liikettä, mennään edelleen joitakin super perus tiedoston I / O.

984
01:00:45,750 --> 01:00:48,830
Jos katsoisit Scramble, huomaat meillä oli jonkinlainen järjestelmä

985
01:00:48,830 --> 01:00:51,270
jossa voisit kirjoittaa lokitiedostoon, jos luet läpi koodin.

986
01:00:51,270 --> 01:00:53,730
Katsotaanpa, miten voit tehdä sen.

987
01:00:53,730 --> 01:00:57,450
No, meillä on fprintf, jonka voit ajatella kuin vain printf,

988
01:00:57,450 --> 01:01:01,720
mutta vain tulostat tiedoston sijaan, ja siten f alussa.

989
01:01:01,720 --> 01:01:07,570
Tällainen koodin tänne, mitä se tekee on, kuten ehkä nähneet Scramble,

990
01:01:07,570 --> 01:01:12,310
se menee läpi 2-ulotteinen taulukko tulostamisen rivi riviltä mitä numerot ovat.

991
01:01:12,310 --> 01:01:17,850
Tällöin printf tulostaa omaan terminaaliin tai mitä kutsumme vakiotulosteeseen §.

992
01:01:17,850 --> 01:01:22,170
>> Ja nyt, tässä tapauksessa, meidän täytyy tehdä, on korvata printf kanssa fprintf,

993
01:01:22,170 --> 01:01:26,770
kertoa, mitä tiedosto, jonka haluat tulostaa, ja tässä tapauksessa se vain tulostaa sen ulos, että tiedosto

994
01:01:26,770 --> 01:01:32,230
sijaan tulostaa sen ulos puhelimesi.

995
01:01:32,230 --> 01:01:36,500
No, niin että herää kysymys: Mistä saamme tällaisen tiedoston, eikö?

996
01:01:36,500 --> 01:01:39,840
Ohitimme kirjautumaan sisään tähän fprintf fuction mutta meillä ei ollut aavistustakaan mistä se tuli.

997
01:01:39,840 --> 01:01:43,980
No, alussa koodin, mikä meillä oli tämä kimpale koodin tänne,

998
01:01:43,980 --> 01:01:48,340
joka pohjimmiltaan sanoo, että avoin tiedosto kutsuu log.txt.

999
01:01:48,340 --> 01:01:53,220
Mitä teemme sen jälkeen on meidän on varmistettava, että tiedosto on todella avattu onnistuneesti.

1000
01:01:53,220 --> 01:01:57,070
Joten se voi epäonnistua useista syistä, sinulla ei ole tarpeeksi tilaa tietokoneen, esimerkiksi.

1001
01:01:57,070 --> 01:01:59,790
Joten se on aina tärkeää ennen kuin teet mitään toimintoja tiedoston mukana

1002
01:01:59,790 --> 01:02:03,300
että voimme tarkistaa onko tiedosto avattiin onnistuneesti.

1003
01:02:03,300 --> 01:02:09,330
Joten mitä se, joka on argumentti fopen, hyvin, voimme avata tiedoston monin tavoin.

1004
01:02:09,330 --> 01:02:13,510
Mitä voimme tehdä on, voimme siirtää sen paino, mikä tarkoittaa ohittaa tiedoston, jos se poistuu jo,

1005
01:02:13,510 --> 01:02:18,070
Voimme siirtää, ne liittää tiedoston loppuun eikä pakottavista sitä,

1006
01:02:18,070 --> 01:02:22,730
tai voimme määrittää r, mikä tarkoittaa, katsotaanpa avata tiedoston vain luku-.

1007
01:02:22,730 --> 01:02:24,890
Joten jos ohjelma yrittää tehdä muutoksia tiedostoon,

1008
01:02:24,890 --> 01:02:30,140
huutaa niitä ja älä anna heidän tehdä sitä.

1009
01:02:30,140 --> 01:02:33,320
Lopuksi, kun olemme tehneet tiedosto Done tekee toimintansa sitä,

1010
01:02:33,320 --> 01:02:35,860
Meidän täytyy varmistaa, suljemme tiedoston.

1011
01:02:35,860 --> 01:02:38,830
Ja niin lopussa oman ohjelman, aiot siirtää ne uudelleen

1012
01:02:38,830 --> 01:02:42,120
Tämä tiedosto avataan ja sulje se.

1013
01:02:42,120 --> 01:02:44,650
Joten tämä on jotain tärkeää, että olet varmasti tehdä.

1014
01:02:44,650 --> 01:02:47,180
Joten muistakaa voit avata tiedoston, voit kirjoittaa tiedostoon,

1015
01:02:47,180 --> 01:02:51,270
tehdä toimintaa tiedoston, mutta sitten sinun täytyy sulkea tiedoston lopussa.

1016
01:02:51,270 --> 01:02:53,270
>> Kaikki kysymykset perusterveydenhuoltoon tiedoston I / O? Kyllä?

1017
01:02:53,270 --> 01:02:58,050
[Student kysymys, käsittämättömällä]

1018
01:02:58,050 --> 01:03:02,480
Täällä. Kysymys on, mistä tämä log.txt tiedosto näyttää?

1019
01:03:02,480 --> 01:03:07,890
No, jos vain antaa sen log.txt, se luo sitä samassa hakemistossa kuin suoritettavan.

1020
01:03:07,890 --> 01:03:10,500
Joten jos Sinä - >> [Student kysymys, käsittämättömällä]

1021
01:03:10,500 --> 01:03:18,830
Kyllä. Samassa kansiossa, tai samassa hakemistossa, kuten sitä kutsut.

1022
01:03:18,830 --> 01:03:21,400
Nyt muistin, pino, ja kasaan.

1023
01:03:21,400 --> 01:03:23,400
Joten miten on muisti säädettyihin tietokoneen?

1024
01:03:23,400 --> 01:03:26,270
No, voitte kuvitella muistissa tavallaan tämän lohkon täältä.

1025
01:03:26,270 --> 01:03:30,260
Ja muistin meillä on ns kasan jumissa siellä, ja pino se siellä.

1026
01:03:30,260 --> 01:03:34,480
Ja kasa kasvaa alaspäin ja pino kasvaa ylöspäin.

1027
01:03:34,480 --> 01:03:38,620
Niin Tommy mainittiin - No, ja meillä on nämä muut 4 segmentit menen toiseen -

1028
01:03:38,620 --> 01:03:42,890
Kuten Tommy sanoi aiemmin, tiedät miten hän toimii kutsuvat itseään ja kutsuvat toisiaan?

1029
01:03:42,890 --> 01:03:44,930
Ne rakentaa tällainen pinokehys.

1030
01:03:44,930 --> 01:03:47,360
No, jos tärkeimmät puhelut foo foo saa laittaa pinoon.

1031
01:03:47,360 --> 01:03:52,430
Foo kutsuu, baari saada n laittaa pinon, ja että saa laittaa pinon jälkeen.

1032
01:03:52,430 --> 01:03:57,040
Ja kun he palaavat, he kukin saavat ottaa pinosta.

1033
01:03:57,040 --> 01:04:00,140
Mitä kukin näistä paikoista ja muistin pidä?

1034
01:04:00,140 --> 01:04:03,110
No, alkuun, joka on tekstiä segmentti, joka sisältää itse ohjelmaa.

1035
01:04:03,110 --> 01:04:06,390
Joten kone koodia, joka on olemassa, kun käännät ohjelman.

1036
01:04:06,390 --> 01:04:08,520
Seuraavaksi kaikki alustetaan globaalien muuttujien.

1037
01:04:08,520 --> 01:04:12,660
>> Joten sinulla on globaaleja muuttujia ohjelmassa, ja sanot kaltaiset = 5,

1038
01:04:12,660 --> 01:04:15,260
että saa laittaa kyseisen segmentin, ja oikeutta siitä,

1039
01:04:15,260 --> 01:04:18,990
teillä alustamattoman maailmanlaajuisia tietoja, mikä on vain int-

1040
01:04:18,990 --> 01:04:20,990
mutta et sano se vastaa mitään.

1041
01:04:20,990 --> 01:04:23,870
Toteuta nämä ovat globaaleja muuttujia, joten he ulkopuolella tärkein.

1042
01:04:23,870 --> 01:04:28,560
Joten tämä tarkoittaa globaalien muuttujien jotka on ilmoitettu, mutta eivät nollaudu.

1043
01:04:28,560 --> 01:04:32,310
Joten mitä kasaan? Varatun muistin avulla malloc, jonka me saamme vuonna hieman.

1044
01:04:32,310 --> 01:04:35,990
Ja lopuksi, joissa pinon teillä paikallisia muuttujia

1045
01:04:35,990 --> 01:04:39,950
ja kaikki toiminnot saatat soittaa mitään niiden parametrit.

1046
01:04:39,950 --> 01:04:43,720
Viimeinen asia, et todellakaan tarvitse tietää, mitä ympäristömuuttujat tehdä,

1047
01:04:43,720 --> 01:04:46,700
mutta kun ajaa ohjelmaa, siellä on jotain liittyy, kuten

1048
01:04:46,700 --> 01:04:49,550
tämä on käyttäjätunnus henkilön juoksi ohjelman.

1049
01:04:49,550 --> 01:04:51,550
Ja se tulee olemaan eräänlainen alareunassa.

1050
01:04:51,550 --> 01:04:54,540
Kannalta muistin osoitteet, jotka ovat heksadesimaalilukujen

1051
01:04:54,540 --> 01:04:58,170
arvot huipulla alussa 0, ja ne menevät kaikki alas pohjaan.

1052
01:04:58,170 --> 01:05:00,440
Tässä tapauksessa, jos olet 32-bittinen järjestelmä,

1053
01:05:00,440 --> 01:05:05,390
osoite alareunassa tulee olemaan 0x, jota seurasi af, koska se on 32 bittiä,

1054
01:05:05,390 --> 01:05:10,890
joka on 8 tavua, ja tässä tapauksessa 8 tavua vastaa 8 heksadesimaalilukua.

1055
01:05:10,890 --> 01:05:20,110
Joten tänne olet menossa on, kuten, 0xffffff, ja siellä olet menossa on 0.

1056
01:05:20,110 --> 01:05:23,660
Mitkä ovat osoittimia? Jotkut teistä eivät välttämättä kattaneet tämän jakson ennen.

1057
01:05:23,660 --> 01:05:26,660
mutta meillä ei mennä yli sen luento, joten osoitin on vain tietotyyppi

1058
01:05:26,660 --> 01:05:34,030
joka tallentaa sen sijaan, että jonkinlainen arvo kuin 50, se tallentaa osoitteen noin paikkaan muistissa.

1059
01:05:34,030 --> 01:05:36,020
Kuten että muisti [käsittämättömällä].

1060
01:05:36,020 --> 01:05:41,120
Joten tässä tapauksessa, mitä meillä on, meillä on osoitin kokonaisluku tai int *

1061
01:05:41,120 --> 01:05:46,210
ja se sisältää tämän heksadesimaaliluvut osoitteen 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Joten mitä meillä on nyt, tämä osoitin jossain paikassa muistissa,

1063
01:05:50,880 --> 01:05:56,020
ja se on vain, arvo 50 on tällä muistipaikka.

1064
01:05:56,020 --> 01:06:01,810
Joissakin 32-bittisissä järjestelmissä, kaikki 32-bittisissä järjestelmissä, osoittimet vievät 32 bittiä tai 4 tavua.

1065
01:06:01,810 --> 01:06:06,020
Mutta, esimerkiksi 64-bittisessä järjestelmässä, osoittimet ovat 64 bittiä.

1066
01:06:06,020 --> 01:06:08,040
Niin, että on jotain sinun kannattaa pitää mielessä.

1067
01:06:08,040 --> 01:06:12,310
Joten pää-bittisessä järjestelmässä, osoitin on lopussa bittiä pitkä.

1068
01:06:12,310 --> 01:06:17,320
Osoittimet ovat tavallaan vaikea sulattaa ilman ylimääräisiä asioita,

1069
01:06:17,320 --> 01:06:20,300
joten mennään läpi esimerkki dynaamisen muistin jakamista.

1070
01:06:20,300 --> 01:06:25,130
Mitä dynaaminen muisti jakaminen tekee sinulle, vai mitä kutsumme malloc,

1071
01:06:25,130 --> 01:06:29,280
sen avulla voit jakaa jonkinlainen tietojen ulkopuolelle asetettu.

1072
01:06:29,280 --> 01:06:31,830
Joten tämä tieto on tavallaan enemmän pysyväksi ohjelman keston ajaksi.

1073
01:06:31,830 --> 01:06:36,430
Sillä kuten tiedätte, jos julistaa x sisällä funktion, ja että funktio palaa,

1074
01:06:36,430 --> 01:06:40,910
sinulla ei enää ole pääsyä tietoihin, jotka on tallennettu x.

1075
01:06:40,910 --> 01:06:44,420
Mitä viitteitä tehkäämme on ne meidän tallentaa muistiin tai tallentaa arvot

1076
01:06:44,420 --> 01:06:46,840
eri segmentin muistia, eli kasaan.

1077
01:06:46,840 --> 01:06:49,340
Nyt kun palaamme pois toiminnon, niin kauan kuin meillä on osoitin

1078
01:06:49,340 --> 01:06:54,960
kyseiseen paikkaan muistissa, niin mitä voimme tehdä on, voimme vain katsoa arvoja siellä.

1079
01:06:54,960 --> 01:06:58,020
Katsotaanpa esimerkki: Tämä on muistia layout uudelleen.

1080
01:06:58,020 --> 01:07:00,050
Ja meillä on tämä toiminto, tärkein.

1081
01:07:00,050 --> 01:07:06,870
Mitä se on - okei, niin yksinkertaista, eikö? - Int x = 5, se on vain muuttuja pinon tärkein.

1082
01:07:06,870 --> 01:07:12,450
>> Toisaalta, nyt julistaa osoittimen, joka kutsuu funktiota giveMeThreeInts.

1083
01:07:12,450 --> 01:07:16,800
Ja nyt me menemme toiminnon ja luomme uuden pinokehys sitä.

1084
01:07:16,800 --> 01:07:20,440
Kuitenkin tässä pinokehys, me julistamme int * temp-

1085
01:07:20,440 --> 01:07:23,210
joka mallocs 3 kokonaislukuja meille.

1086
01:07:23,210 --> 01:07:25,880
Joten koko int antaa meille kuinka monta tavua tämä int on,

1087
01:07:25,880 --> 01:07:29,620
ja malloc antaa meille, että monta tavua tilaa kasaan.

1088
01:07:29,620 --> 01:07:32,890
Joten tässä tapauksessa, olemme luoneet tarpeeksi tilaa 3 kokonaislukuja,

1089
01:07:32,890 --> 01:07:36,830
ja keko asti olemassa, minkä vuoksi olen laatinut sen ylemmäksi.

1090
01:07:36,830 --> 01:07:42,900
Kun olemme valmiita, palaamme tänne, sinun tarvitsee vain 3 ints palasi,

1091
01:07:42,900 --> 01:07:47,000
ja se palaa osoite, tässä tapauksessa yli kun tämä muisti on.

1092
01:07:47,000 --> 01:07:51,250
Ja asetamme osoittimen = kytkin, ja siellä meillä on vain yksi osoitin.

1093
01:07:51,250 --> 01:07:54,550
Mutta mitä se funktio palauttaa kasataan tänne ja katoaa.

1094
01:07:54,550 --> 01:07:59,250
Joten temp katoaa, mutta silti säilyttää osoite, jossa

1095
01:07:59,250 --> 01:08:01,850
ne 3 kokonaisluvut ovat sisällä sähköverkkoon.

1096
01:08:01,850 --> 01:08:06,180
Joten tämä asettaa, osoittimet ovat scoped paikallisesti pinottu runko,

1097
01:08:06,180 --> 01:08:09,860
mutta muisti, johon ne viittaavat on kasaan.

1098
01:08:09,860 --> 01:08:12,190
>> Onko siinä järkeä?

1099
01:08:12,190 --> 01:08:14,960
[Opiskelija] Voisitko toistaa? >> [Joseph] Kyllä.

1100
01:08:14,960 --> 01:08:20,270
Joten jos menen vain vähän, huomaat että temp jaettu

1101
01:08:20,270 --> 01:08:23,500
muistia kasaan siellä.

1102
01:08:23,500 --> 01:08:28,680
Joten kun tämä toiminto, giveMeThreeInts palaa, tämä pino täällä on häviämässä.

1103
01:08:28,680 --> 01:08:35,819
Ja sen kanssa mitä tahansa muuttujien, tässä tapauksessa, tämä osoitin, joka on myönnetty pinottu kehyksessä.

1104
01:08:35,819 --> 01:08:39,649
Tämä on häviämässä, mutta koska palasimme temp

1105
01:08:39,649 --> 01:08:46,330
ja asetamme osoittimen = lämpötila, osoittimen nyt menossa osoittamaan samaa muistia sijainnin temp oli.

1106
01:08:46,330 --> 01:08:50,370
Joten nyt, vaikka menetämme temp, että paikalliset osoitin,

1107
01:08:50,370 --> 01:08:59,109
meillä on edelleen muistiosoite mitä se osoittaa sisällä että muuttujan osoitin.

1108
01:08:59,109 --> 01:09:03,740
Kysymyksiä? Se voi olla sellainen sekava viesti, jos et ole mennyt yli sen osassa.

1109
01:09:03,740 --> 01:09:09,240
Voimme, sinun TF varmasti mennä sen yli ja tietenkin voimme vastata kysymyksiin

1110
01:09:09,240 --> 01:09:11,500
lopussa tarkastelun istunnon tämän.

1111
01:09:11,500 --> 01:09:14,220
Mutta tämä on eräänlainen monimutkainen aihe, ja minulla on enemmän esimerkkejä, jotka tulevat näkyviin

1112
01:09:14,220 --> 01:09:18,790
joka auttaa selvittämään, mitä viitteitä todellisuudessa ovat.

1113
01:09:18,790 --> 01:09:22,500
>> Tässä tapauksessa osoittimet ovat vastaavat ryhmät,

1114
01:09:22,500 --> 01:09:25,229
joten en voi vain käyttää tätä osoitinta samaa kuin int array.

1115
01:09:25,229 --> 01:09:29,840
Joten olen indeksointivaiheen 0, ja muuttamalla ensimmäinen kokonaisluku 1,

1116
01:09:29,840 --> 01:09:39,689
muuttamalla toinen kokonaisluku 2, ja kolmas kokonaisluku 3.

1117
01:09:39,689 --> 01:09:44,210
Joten enemmän viitteitä. No, muistaa Binky.

1118
01:09:44,210 --> 01:09:48,319
Tässä tapauksessa olemme varattu osoitin tai me julisti osoitin,

1119
01:09:48,319 --> 01:09:52,760
mutta aluksi, kun olen vain julisti osoittimen, se ei osoita minnekään muistiin.

1120
01:09:52,760 --> 01:09:54,930
Se on vain roskaa arvoja sen sisälle.

1121
01:09:54,930 --> 01:09:56,470
Joten minulla ei ole aavistustakaan, missä tämä osoitin osoittaa.

1122
01:09:56,470 --> 01:10:01,630
Se on osoite, joka on vain täynnä 0: n ja 1: n, jossa se alun perin ilmoitettu.

1123
01:10:01,630 --> 01:10:04,810
En voi tehdä mitään tätä kunnes pyydän malloc sitä

1124
01:10:04,810 --> 01:10:08,390
ja sitten se antaa minulle hieman tilaa kasaan jossa voin laittaa arvot sisälle.

1125
01:10:08,390 --> 01:10:11,980
Sitten taas, en tiedä mitä on sisällä tämän muistin.

1126
01:10:11,980 --> 01:10:16,780
Joten ensimmäinen asia minun täytyy tehdä, on tarkistaa, onko järjestelmä oli riittävästi muistia

1127
01:10:16,780 --> 01:10:20,850
antaa minulle takaisin 1 kokonaisluku ensimmäinen paikka, joka on miksi teen tätä tarkista.

1128
01:10:20,850 --> 01:10:25,020
Jos osoitin on nolla, mikä tarkoittaa, että se ei ole tarpeeksi tilaa tai jokin muu virhe,

1129
01:10:25,020 --> 01:10:26,320
joten minun pitäisi poistua ulos ohjelmasta.

1130
01:10:26,320 --> 01:10:29,400
 Mutta jos se ei onnistu, nyt voin käyttää että osoitin

1131
01:10:29,400 --> 01:10:35,020
ja mitä * osoitin ei se seuraa missä osoite on

1132
01:10:35,020 --> 01:10:38,480
missä se arvo on, ja siinä se on 1.

1133
01:10:38,480 --> 01:10:41,850
Joten tänne, me tarkistaa jos muisti olemassa.

1134
01:10:41,850 --> 01:10:45,380
>> Kun tiedät sen olemassa, voit ottaa sen

1135
01:10:45,380 --> 01:10:50,460
Mitä arvoa haluat laittaa siihen; tässä tapauksessa 1.

1136
01:10:50,460 --> 01:10:53,060
Kun olemme tehneet sen, sinun täytyy vapauttaa että osoitin

1137
01:10:53,060 --> 01:10:57,160
koska meidän täytyy saada takaisin järjestelmän muistin pyysit ensiksi.

1138
01:10:57,160 --> 01:10:59,690
Koska tietokone ei tiedä milloin olemme tehneet sen.

1139
01:10:59,690 --> 01:11:02,510
Tässä tapauksessa me nimenomaan kertoa sen, okei, olemme tehneet, että muistia.

1140
01:11:02,510 --> 01:11:10,780
Jos jokin muu prosessi tarvitsee, jokin muu ohjelma tarvitsee sitä rohkeasti mennä eteenpäin ja ottaa sen.

1141
01:11:10,780 --> 01:11:15,110
Mitä voimme myös tehdä on, voimme vain saada osoitteen paikalliset muuttujat päälle.

1142
01:11:15,110 --> 01:11:19,080
Joten int x sisällä pinottu kehyksen tärkeimpien.

1143
01:11:19,080 --> 01:11:23,060
Ja kun käytämme tätä et-merkki, tämä ja operaattori, mitä se tekee on

1144
01:11:23,060 --> 01:11:27,310
se vie x, ja x on vain joitakin tietoja muistissa, mutta se on osoite.

1145
01:11:27,310 --> 01:11:33,790
Se sijaitsee jossain. Joten soittamalla & x, mitä tämä tekee se antaa meille osoitteen x.

1146
01:11:33,790 --> 01:11:38,430
Tekemällä tämän, Teemme osoitin kohtaan, johon x on muistissa.

1147
01:11:38,430 --> 01:11:41,710
Nyt me vain tehdä jotain * x, aiomme saada 5 takaisin.

1148
01:11:41,710 --> 01:11:43,820
Tähti on nimeltään dereferencing sitä.

1149
01:11:43,820 --> 01:11:46,640
Seuraat osoite ja saat arvoa se tallennetaan siellä.

1150
01:11:51,000 --> 01:11:53,310
>> Kysyttävää? Kyllä?

1151
01:11:53,310 --> 01:11:56,500
[Opiskelija] Jos et tee 3-huomautti juttu, ei se vielä koota?

1152
01:11:56,500 --> 01:11:59,490
Kyllä. Jos et tee 3-osoittimen juttu, se on vielä menossa kääntää,

1153
01:11:59,490 --> 01:12:02,720
mutta minä näytän sinulle, mitä tapahtuu toisessa, eikä tee sitä,

1154
01:12:02,720 --> 01:12:04,860
sitähän me kutsumme muistivuoto. Et anna järjestelmän

1155
01:12:04,860 --> 01:12:07,850
varmuuskopioida sen muisti, niin sen jälkeen, kun ohjelma on menossa kerääntyä

1156
01:12:07,850 --> 01:12:10,940
muistin että se ei käytä, ja mikään muu ei voi käyttää sitä.

1157
01:12:10,940 --> 01:12:15,750
Jos olet koskaan nähnyt Firefox 1500000 kilotavua tietokoneeseen,

1158
01:12:15,750 --> 01:12:17,840
Tehtävienhallinnan, että mitä tapahtuu.

1159
01:12:17,840 --> 01:12:20,760
Sinulla muistivuoto ohjelmassa, että he eivät käsittele.

1160
01:12:23,080 --> 01:12:26,240
Joten miten osoittimen aritmeettinen työtä?

1161
01:12:26,240 --> 01:12:29,480
No, osoitin aritmeettinen on tavallaan kuin indeksointi osaksi array.

1162
01:12:29,480 --> 01:12:36,370
Tässä tapauksessa minulla on osoitin, ja mitä teen, on tehtävä osoitin pisteen ensimmäisen osan

1163
01:12:36,370 --> 01:12:42,100
Tämän joukon 3 kokonaislukujen että olen varattu.

1164
01:12:42,100 --> 01:12:46,670
Mitä nyt teen, tähti osoitin vain muuttaa ensimmäinen elementti luettelossa.

1165
01:12:46,670 --> 01:12:49,140
Star osoitin +1 pistettä tänne.

1166
01:12:49,140 --> 01:12:53,140
Joten osoitin on täällä, osoitin +1 on täällä, osoitin +2 on täällä.

1167
01:12:53,140 --> 01:12:56,610
>> Joten lisäämällä 1 on sama asia kuin liikkuvat pitkin array.

1168
01:12:56,610 --> 01:12:59,880
Mitä teemme, kun teemme osoitin +1 saat osoitteen tänne,

1169
01:12:59,880 --> 01:13:04,180
ja saadakseen arvo täällä, laitat tähti alkaen koko lauseke

1170
01:13:04,180 --> 01:13:05,990
ja dereference sitä.

1171
01:13:05,990 --> 01:13:09,940
Joten tässä tapauksessa, olen jossa ensimmäinen sijainnin tässä array 1,

1172
01:13:09,940 --> 01:13:13,970
toisessa paikassa 2, ja kolmannen sijainnin 3.

1173
01:13:13,970 --> 01:13:18,180
Sitten mitä teen täällä on olen tulostamista meidän osoitin +1,

1174
01:13:18,180 --> 01:13:19,970
joka vain antaa minulle 2.

1175
01:13:19,970 --> 01:13:23,650
Nyt olen mukaa osoitin, joten osoitin vastaa osoitin +1,

1176
01:13:23,650 --> 01:13:26,780
joka liikkuu eteenpäin.

1177
01:13:26,780 --> 01:13:30,810
Ja nyt jos tulostaa osoitin +1, osoitin +1 on nyt 3,

1178
01:13:30,810 --> 01:13:33,990
joka tässä tapauksessa tulostuu 3.

1179
01:13:33,990 --> 01:13:36,560
Ja jotta vapaa jotakin, osoitin, että annan sen

1180
01:13:36,560 --> 01:13:40,540
tulee osoittaa alussa array jonka sain takaisin malloc.

1181
01:13:40,540 --> 01:13:43,430
Eli tässä tapauksessa, jos olisin soittaa 3 täällä, tämä ei olisi oikein,

1182
01:13:43,430 --> 01:13:45,070
koska se on keskellä jono.

1183
01:13:45,070 --> 01:13:48,820
Minun on vähennettävä päästä alkuperäiseen sijaintiin

1184
01:13:48,820 --> 01:13:50,420
ensimmäinen ensimmäinen piste ennen kuin voin vapauttaa sen.

1185
01:13:56,300 --> 01:13:58,450
Joten, tässä on enemmän mukana esimerkki.

1186
01:13:58,450 --> 01:14:03,360
Tässä tapauksessa me jaetaan 7 merkkiä luonteeltaan array.

1187
01:14:03,360 --> 01:14:06,480
>> Ja tässä tapauksessa mitä teemme on me silmukoiden yli 6 ensimmäisen niistä,

1188
01:14:06,480 --> 01:14:09,900
ja me asettamalla ne Z.

1189
01:14:09,900 --> 01:14:13,350
Joten int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Joten, osoitin + Annan meille, tässä tapauksessa,

1191
01:14:16,220 --> 01:14:20,860
osoitin, osoitin +1, osoitin +2, osoitin +3, ja niin edelleen, ja niin edelleen silmukka.

1192
01:14:20,860 --> 01:14:24,040
Mitä se aikoo tehdä, on se saa kyseiseen osoitteeseen, dereferences sitä saada arvon,

1193
01:14:24,040 --> 01:14:27,440
ja muutoksia, jotka arvoa Z.

1194
01:14:27,440 --> 01:14:30,350
Sitten lopussa muistaa tämä on merkkijono, eikö?

1195
01:14:30,350 --> 01:14:33,560
Kaikki jouset on päättyä null päättämisestä luonnetta.

1196
01:14:33,560 --> 01:14:38,620
Joten, mitä teen on osoittimen 6 Laitoin null terminaattori merkki tuumaa

1197
01:14:38,620 --> 01:14:43,980
Ja nyt, mitä minä olen periaatteessa tekemässä täällä toteuttaa printf varten merkkijonon, eikö?

1198
01:14:43,980 --> 01:14:46,190
>> Joten, kun ei printf nyt kun se pääsi loppuun merkkijonon?

1199
01:14:46,190 --> 01:14:48,230
Kun se osuu null päättämisestä luonnetta.

1200
01:14:48,230 --> 01:14:52,030
Eli tässä tapauksessa minun alkuperäinen osoitin osoittaa alussa array.

1201
01:14:52,030 --> 01:14:56,410
Olen tulostaa ensimmäinen merkki pois. En siirrä se yli.

1202
01:14:56,410 --> 01:14:58,420
Olen tulostaa kyseisen merkin pois. Ehdotan sen yli.

1203
01:14:58,420 --> 01:15:02,180
Ja pidän tätä kunnes pääsen loppuun.

1204
01:15:02,180 --> 01:15:07,750
Ja nyt loppu * osoitin epäviittausongelman tätä ja saada nolla päättämisestä merkin taakse.

1205
01:15:07,750 --> 01:15:11,780
Ja niin minun kun silmukka suoritetaan vain, kun kyseistä arvoa ei ole nolla päättämisestä luonnetta.

1206
01:15:11,780 --> 01:15:13,770
Joten, nyt suljen pois tästä silmukan.

1207
01:15:18,780 --> 01:15:21,180
Ja niin jos en vähennä 6 tästä osoitin,

1208
01:15:21,180 --> 01:15:22,860
Palaan aina alkuun.

1209
01:15:22,860 --> 01:15:27,880
Muista, teen tämän, koska minun täytyy mennä alkuun, jotta sen vapauttamiseksi.

1210
01:15:27,880 --> 01:15:30,270
>> Joten tiedän, että oli paljon. Onko kysyttävää?

1211
01:15:30,270 --> 01:15:31,870
Pyydän, kyllä?

1212
01:15:31,870 --> 01:15:36,610
[Student kysymys käsittämättömällä]

1213
01:15:36,610 --> 01:15:38,190
Voitteko sanoa että kovempaa? Anteeksi.

1214
01:15:38,190 --> 01:15:44,140
[Opiskelija] On viimeisen dian juuri ennen vapautti osoitin,

1215
01:15:44,140 --> 01:15:47,300
missä olit todella muuttuu arvo osoittimen?

1216
01:15:47,300 --> 01:15:50,370
[Joseph] Niin, täällä. >> [Student] Ai, okei.

1217
01:15:50,370 --> 01:15:51,890
[Joseph] Joten olen osoitin miinus miinus, oikealle,

1218
01:15:51,890 --> 01:15:54,140
joka liikkuu asia takaisin, ja sitten minä vapauttaa sitä,

1219
01:15:54,140 --> 01:15:57,000
koska tämä osoitin on korostettava alkuun jono.

1220
01:15:57,000 --> 01:16:00,420
[Opiskelija] Mutta ei tarvittaisi oli lopetit sen jälkeen linja.

1221
01:16:00,420 --> 01:16:03,130
[Joseph] Joten, jos olisin lopettanut tämän jälkeen, se katsotaan muistivuoto,

1222
01:16:03,130 --> 01:16:04,810
koska en juosta vapaasti.

1223
01:16:04,810 --> 01:16:11,290
[Student] I [käsittämättömiä] jälkeen kolme ensimmäistä riviä, jos sinulla on ollut osoitin +1 [käsittämättömällä].

1224
01:16:11,290 --> 01:16:13,140
[Joseph] Uh-huh. Joten, mitä kysymys siellä?

1225
01:16:13,140 --> 01:16:14,780
Anteeksi. Ei, ei. Mene, mene, kiitos.

1226
01:16:14,780 --> 01:16:16,870
[Student] Niin, et muuttaa arvoa viitteitä.

1227
01:16:16,870 --> 01:16:19,130
Et olisi pitänyt tehdä osoitin miinus miinus.

1228
01:16:19,130 --> 01:16:19,730
[Joseph] Kyllä, täsmälleen.

1229
01:16:19,730 --> 01:16:21,890
Joten, kun en osoitin +1 ja osoitin +2,

1230
01:16:21,890 --> 01:16:24,410
En tee osoitin vastaa osoitin +1.

1231
01:16:24,410 --> 01:16:27,260
Niin, osoitin vain pysyy osoittaa alussa jono.

1232
01:16:27,260 --> 01:16:31,460
Vasta kun minä plus plus että se asettaa arvon takaisin sisälle osoitin,

1233
01:16:31,460 --> 01:16:33,550
että se todella liikkuu tämän mukana.

1234
01:16:36,860 --> 01:16:37,780
Selvä.

1235
01:16:40,550 --> 01:16:42,030
Lisää kysymyksiä?

1236
01:16:44,680 --> 01:16:47,790
>> Jälleen, jos tämä on tavallaan ylivoimainen, tämä katetaan istunto.

1237
01:16:47,790 --> 01:16:50,710
Kysy opetus stipendiaatti siitä, ja voimme vastata kysymyksiin lopussa.

1238
01:16:53,510 --> 01:16:56,600
Ja yleensä me halua tehdä tätä miinus juttu.

1239
01:16:56,600 --> 01:16:59,760
Tämä on vaatia minua pitää kirjaa siitä, kuinka paljon olen siirtymän array.

1240
01:16:59,760 --> 01:17:04,520
Niin, yleensä, tämä on vain selittää, miten osoittimen aritmeettinen toimii.

1241
01:17:04,520 --> 01:17:07,970
Mutta mitä me yleensä haluavat tehdä on haluamme luoda kopion osoitin,

1242
01:17:07,970 --> 01:17:11,640
ja sitten me käyttää kyseistä kopiota kun olemme liikkuu merkkijono.

1243
01:17:11,640 --> 01:17:14,660
Eli näissä tapauksessa käytät kopioida tulostaa koko merkkijonon,

1244
01:17:14,660 --> 01:17:19,040
mutta meillä ei ole tehdä kuten osoitin miinus 6 tai seurata, kuinka paljon muutimme tähän,

1245
01:17:19,040 --> 01:17:22,700
vain koska tiedämme, että alkuperäinen piste on edelleen viittasivat listan alkuun

1246
01:17:22,700 --> 01:17:25,340
ja kaikki me muuttaneet oli tämä kopio.

1247
01:17:25,340 --> 01:17:28,250
Niin, yleensä muuttaa kopioita alkuperäisen osoittimen.

1248
01:17:28,250 --> 01:17:32,350
Älä yritä tavallaan kuin - älä muuta alkuperäistä kappaletta.

1249
01:17:32,350 --> 01:17:35,290
Yritetään muuttaa vain kopioita alkuperäisistä.

1250
01:17:41,540 --> 01:17:44,870
Joten, huomaat kun ohitamme merkkijono printf

1251
01:17:44,870 --> 01:17:48,990
sinun ei tarvitse laittaa tähti edessä kuin teimme kaikkien muiden dereferences, eikö?

1252
01:17:48,990 --> 01:17:54,180
Joten, jos tulostaa koko merkkijono% s odottaa on osoite,

1253
01:17:54,180 --> 01:17:57,610
ja tässä tapauksessa osoitin tai tässä tapauksessa, kuten erilaisia ​​merkkejä.

1254
01:17:57,610 --> 01:18:00,330
>> Hahmot, char * s, ja ryhmät ovat sama asia.

1255
01:18:00,330 --> 01:18:03,690
Pointer on merkkejä, ja merkki ryhmät ovat sama asia.

1256
01:18:03,690 --> 01:18:05,720
Ja niin, meidän täytyy tehdä, on kulkea osoitin.

1257
01:18:05,720 --> 01:18:08,150
Meillä ei tarvitse kulkea kuin * osoitin tai mitään sellaista.

1258
01:18:13,110 --> 01:18:14,930
Niin, taulukot ja osoittimet ovat sama asia.

1259
01:18:14,930 --> 01:18:19,160
Kun teet jotain x [y] yli täällä array,

1260
01:18:19,160 --> 01:18:21,960
mitä se tekee konepellin alle on se sanoo, okei, se on merkki array,

1261
01:18:21,960 --> 01:18:23,690
joten se on osoitin.

1262
01:18:23,690 --> 01:18:26,510
Ja niin x on sama asia,

1263
01:18:26,510 --> 01:18:28,650
ja niin mitä se tekee on se lisää y x,

1264
01:18:28,650 --> 01:18:31,820
joka on sama asia kuin eteenpäin muistiin, että paljon.

1265
01:18:31,820 --> 01:18:34,930
Ja nyt x + y antaa meille jonkinlaisen osoitteen,

1266
01:18:34,930 --> 01:18:37,570
ja me dereference osoite tai seuraa nuolta

1267
01:18:37,570 --> 01:18:41,640
missä se paikkaan muistissa on ja saamme arvo pois, että sijainti muistissa.

1268
01:18:41,640 --> 01:18:43,720
Joten, joten nämä kaksi ovat täsmälleen sama asia.

1269
01:18:43,720 --> 01:18:45,840
Se on vain syntaktinen sokeri.

1270
01:18:45,840 --> 01:18:48,090
He tekevät samaa. He vain eri syntactics toisilleen.

1271
01:18:51,500 --> 01:18:57,590
>> Joten, mikä voi mennä vikaan viitteitä? Like, paljon. Okei. Joten, pahoja asioita.

1272
01:18:57,590 --> 01:19:02,410
Joitakin huonoja asioita voit tehdä ole tarkistaa jos malloc puhelu palautuu null, eikö?

1273
01:19:02,410 --> 01:19:06,560
Tässä tapauksessa pyydän järjestelmä antaa minulle - mikä on se määrä?

1274
01:19:06,560 --> 01:19:11,200
Kuten 2000000000 kertaa 4, koska koko kokonaisluku on 4 tavua.

1275
01:19:11,200 --> 01:19:13,810
Pyydän sitä kuten 8000000000 tavua.

1276
01:19:13,810 --> 01:19:17,270
Tietenkin minun tietokone ei pystynyt antamaan minulle paljon muistia takaisin.

1277
01:19:17,270 --> 01:19:20,960
Ja me ei tarkista, onko se tyhjä, joten kun yritämme dereference se tuonne -

1278
01:19:20,960 --> 01:19:24,270
seuraa nuolta minne se menee - meillä ei ole, että muisti.

1279
01:19:24,270 --> 01:19:27,150
Tämä on mitä me kutsumme dereferencing nollaosoittimen.

1280
01:19:27,150 --> 01:19:29,710
Ja tämä lähinnä aiheuttaa voit segfault.

1281
01:19:29,710 --> 01:19:31,790
Tämä on yksi tavoista, joilla voit segfault.

1282
01:19:34,090 --> 01:19:38,090
Muita huonoja asioita voit tehdä - noh.

1283
01:19:38,090 --> 01:19:40,650
Se oli dereferencing nollaosoittimen. Okei.

1284
01:19:40,650 --> 01:19:45,160
Muita huonoja asioita - hyvin, vahvistaa, että olet vain laittaa sekin siellä

1285
01:19:45,160 --> 01:19:46,980
joka tarkistaa, onko osoitin on null

1286
01:19:46,980 --> 01:19:51,000
ja lähteneet ohjelmaan, jos käy niin, että malloc palauttaa nollaosoittimen.

1287
01:19:55,110 --> 01:19:59,850
Se xkcd koominen. Ihmiset ymmärtävät nyt. Tavallaan.

1288
01:20:06,120 --> 01:20:09,350
>> Niin, muistin. Ja menin tämän.

1289
01:20:09,350 --> 01:20:12,000
Olemme soittamalla malloc vuonna silmukka, mutta joka kerta kun soittaa malloc

1290
01:20:12,000 --> 01:20:14,370
menetämme raidan jos osoitin on osoittaa,

1291
01:20:14,370 --> 01:20:15,750
koska olemme clobbering sitä.

1292
01:20:15,750 --> 01:20:18,410
Joten, ensimmäinen puhelu malloc antaa minulle muistiin tänne.

1293
01:20:18,410 --> 01:20:19,990
Minun osoitin viitteitä tähän.

1294
01:20:19,990 --> 01:20:23,020
Nyt en vapauttaa sitä, joten nyt kutsun malloc uudelleen.

1295
01:20:23,020 --> 01:20:26,070
Nyt se osoittaa tänne. Nyt minun muisti osoittaa tänne.

1296
01:20:26,070 --> 01:20:27,640
Pointing tänne. Pointing tänne.

1297
01:20:27,640 --> 01:20:31,820
Mutta olen kadottaa osoitteet kaikkien muistin tänne, että olen varattu.

1298
01:20:31,820 --> 01:20:35,100
Ja nyt minulla ei ole mitään viittausta niihin enää.

1299
01:20:35,100 --> 01:20:37,230
Joten en voi vapauttaa heidät ulkopuolelle tämän silmukan.

1300
01:20:37,230 --> 01:20:39,390
Ja niin jotta korjata jotain tällaista,

1301
01:20:39,390 --> 01:20:42,250
Jos unohdat vapaata muistia ja saat tämän muistivuoto,

1302
01:20:42,250 --> 01:20:45,810
Sinun täytyy vapauttaa muistia, tämän silmukan kun olet tehnyt sen kanssa.

1303
01:20:45,810 --> 01:20:51,400
No, tämä on mitä tapahtuu. Tiedän paljon vihaat tätä.

1304
01:20:51,400 --> 01:20:55,270
Mutta nyt - yay! Saat kuten 44000 kilotavua.

1305
01:20:55,270 --> 01:20:57,110
Niin, et vapauttaa sen lopussa silmukan,

1306
01:20:57,110 --> 01:20:59,770
ja että menee vain vapauttaa muistia aina.

1307
01:20:59,770 --> 01:21:03,620
Pohjimmiltaan, sinun ohjelma ei muistivuoto enää.

1308
01:21:03,620 --> 01:21:08,150
>> Ja nyt jotain muuta voit tehdä on vapauttaa muistia, että olet pyytänyt kahdesti.

1309
01:21:08,150 --> 01:21:11,060
Tässä tapauksessa sinun malloc jotain, muutat sen arvoa.

1310
01:21:11,060 --> 01:21:13,140
Voit vapauttaa sen kerran, koska sanoit tehnyt sitä.

1311
01:21:13,140 --> 01:21:14,940
Mutta sitten vapautti sen taas.

1312
01:21:14,940 --> 01:21:16,730
Tämä on jotain, joka on aika paha.

1313
01:21:16,730 --> 01:21:18,820
Se ei tule aluksi segfault,

1314
01:21:18,820 --> 01:21:23,350
mutta sen jälkeen, kun Mikä tämä on kaksinkertainen vapauttaa tämä turmelee keon rakenteeseen,

1315
01:21:23,350 --> 01:21:27,200
ja opit hieman enemmän tästä, jos haluat ottaa luokkaa kuin CS61.

1316
01:21:27,200 --> 01:21:30,000
Mutta pohjimmiltaan jälkeen, kun tietokone on menossa sekaisin

1317
01:21:30,000 --> 01:21:33,010
mitä muistipaikkaa missä ja mihin se on tallennettu -

1318
01:21:33,010 --> 01:21:34,800
jossa data tallennetaan muistiin.

1319
01:21:34,800 --> 01:21:38,080
Ja niin vapauttaa osoitin kahdesti on huono asia, että et halua tehdä.

1320
01:21:38,080 --> 01:21:41,600
>> Muita asioita, jotka voivat mennä pieleen ei käytä sizeof.

1321
01:21:41,600 --> 01:21:44,460
Eli tässä tapauksessa sinun malloc 8 tavua,

1322
01:21:44,460 --> 01:21:46,700
ja se on sama asia kuin kaksi kokonaislukua, eikö?

1323
01:21:46,700 --> 01:21:49,580
Niin, se on täysin turvallista, mutta onko se?

1324
01:21:49,580 --> 01:21:52,160
No, kuten Lucas puhui eri arkkitehtuurit,

1325
01:21:52,160 --> 01:21:54,220
kokonaisluvut ovat eripituisia.

1326
01:21:54,220 --> 01:21:57,970
Niin, laite, käytät, kokonaisluvut ovat noin 4 tavua,

1327
01:21:57,970 --> 01:22:02,370
mutta jokin muu järjestelmä ne voivat olla 8 tavua tai ne voivat olla 16 tavua.

1328
01:22:02,370 --> 01:22:05,680
Joten, jos vain käyttää tätä numeroa tänne,

1329
01:22:05,680 --> 01:22:07,310
tämä ohjelma voi työskennellä laitteen

1330
01:22:07,310 --> 01:22:10,360
mutta se ei aio käyttää riittävästi muistia jonkin muun järjestelmän.

1331
01:22:10,360 --> 01:22:14,020
Tässä tapauksessa, tämä on mitä sizeof operaattori käytetään.

1332
01:22:14,020 --> 01:22:16,880
Kun me kutsumme sizeof (int), mitä tämä tekee, on

1333
01:22:16,880 --> 01:22:21,910
 se antaa meille koko kokonaisluku järjestelmän, että ohjelma on käynnissä.

1334
01:22:21,910 --> 01:22:25,490
Eli tässä tapauksessa, sizeof (int) palauttaa 4 jotain laitetta,

1335
01:22:25,490 --> 01:22:29,980
ja nyt tämä tahto 4 * 2, joka on 8,

1336
01:22:29,980 --> 01:22:32,330
joka on vain paljon tilaa tarvitaan kaksi kokonaislukua.

1337
01:22:32,330 --> 01:22:36,710
Toisella koneella, jos int on kuin 16 tavua tai 8 tavua,

1338
01:22:36,710 --> 01:22:39,380
se vain tulee palata tarpeeksi tavua tallentaa tätä määrää.

1339
01:22:41,830 --> 01:22:45,310
>> Ja lopuksi, tietueet.

1340
01:22:45,310 --> 01:22:48,340
Joten, jos halusi tallentaa sudoku hallituksen muistissa, miten voisi teemme tämän?

1341
01:22:48,340 --> 01:22:51,570
Saatat ajatella kuin muuttuja ensimmäinen asia,

1342
01:22:51,570 --> 01:22:53,820
muuttuja toinen asia, muuttuja kolmas asia,

1343
01:22:53,820 --> 01:22:56,420
muuttuja Neljäs asia - paha, eikö?

1344
01:22:56,420 --> 01:23:00,750
Niin, yksi parannus voit tehdä tämän päälle on tehdä 9 x 9 array.

1345
01:23:00,750 --> 01:23:04,480
Se on hienoa, mutta mitä jos halusi liittää muita asioita sudoku hallituksen

1346
01:23:04,480 --> 01:23:06,490
kuten mitä vaikeus lauta on,

1347
01:23:06,490 --> 01:23:11,740
tai esimerkiksi mitä pisteet on, tai kuinka paljon aikaa se on vienyt sinua ratkaisemaan tämän hallituksen?

1348
01:23:11,740 --> 01:23:14,970
No, mitä voit tehdä, on voit luoda struct.

1349
01:23:14,970 --> 01:23:18,910
Mitä olen periaatteessa sanonta on olen määritellään tämä rakenne tänne,

1350
01:23:18,910 --> 01:23:23,230
ja olen määrittelemällä sudoku hallituksen, joka koostuu aluksella, joka on 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> Ja mitä se on se on viitteitä nimen tasolle.

1352
01:23:26,650 --> 01:23:30,730
Se on myös x ja y, jotka ovat koordinaatit missä olen juuri nyt.

1353
01:23:30,730 --> 01:23:35,980
Se on myös aika [käsittämättömiä], ja se on määrä liikkuu olen syötetään tähän mennessä.

1354
01:23:35,980 --> 01:23:40,010
Ja niin tässä tapauksessa voin ryhmitellä koko joukko dataa vain yksi rakenne

1355
01:23:40,010 --> 01:23:42,790
sen sijaan, niin kuin lentävät ympäriinsä kuin eri muuttujien

1356
01:23:42,790 --> 01:23:44,540
että en todellakaan voi seurata.

1357
01:23:44,540 --> 01:23:49,720
Ja tämä antaa meille on vain mukavaa syntaksi tavallaan viitataan eri asioita sisällä tämän struct.

1358
01:23:49,720 --> 01:23:53,430
Voin vain tehdä board.board, ja saan sudoku hallituksen takana.

1359
01:23:53,430 --> 01:23:56,320
Board.level, saan kuinka kova se on.

1360
01:23:56,320 --> 01:24:00,540
Board.x ja board.y anna minulle koordinaatit missä voisin olla aluksella.

1361
01:24:00,540 --> 01:24:04,730
Ja niin olen päästä kutsumme kentät struct.

1362
01:24:04,730 --> 01:24:08,840
Tämä määrittää sudokuBoard, joka on tyyppi, joka minulla on.

1363
01:24:08,840 --> 01:24:14,800
Ja nyt olemme täällä. Olen muuttuja nimeltä "board" tyyppi sudokuBoard.

1364
01:24:14,800 --> 01:24:18,820
Ja nyt voin käyttää kaikkia kenttiä, jotka muodostavat tämän rakenteen tänne.

1365
01:24:20,830 --> 01:24:22,450
>> Kysyttävää tietueet? Kyllä?

1366
01:24:22,450 --> 01:24:25,890
[Student] For int x, y, te julisti molemmat yhdellä rivillä? >> [Joseph] Uh-huh.

1367
01:24:25,890 --> 01:24:27,400
[Student] Joten, voisitko tehdä, että ne kaikki?

1368
01:24:27,400 --> 01:24:31,200
Kuten x, y pilkku kertaa yhteensä?

1369
01:24:31,200 --> 01:24:34,460
[Joseph] Kyllä, voit varmasti tehdä, mutta esittämäni x ja y samalla linjalla -

1370
01:24:34,460 --> 01:24:36,330
ja kysymys on, miksi voimme vain tehdä tämän samalla linjalla?

1371
01:24:36,330 --> 01:24:38,600
Miksi emme vain laittaa kaikki nämä samalla rivillä on

1372
01:24:38,600 --> 01:24:42,090
x ja y ovat sukua toisilleen,

1373
01:24:42,090 --> 01:24:44,780
ja tämä on vain tyylillisesti oikeampi, tavallaan

1374
01:24:44,780 --> 01:24:46,600
koska se ryhmittelyä kaksi asiaa samalla linjalla

1375
01:24:46,600 --> 01:24:49,340
että kuten tavallaan liittyy sama asia.

1376
01:24:49,340 --> 01:24:51,440
Ja minä vain jakaa nämä toisistaan. Se on vain tyyli juttu.

1377
01:24:51,440 --> 01:24:53,720
Se toiminnallisesti ole väliä millään.

1378
01:24:58,150 --> 01:24:59,270
Kaikki muut kysymykset tietueet?

1379
01:25:03,030 --> 01:25:06,620
Voit määrittää Pokedex jossa struct.

1380
01:25:06,620 --> 01:25:11,720
Pokémon on numero ja se on kirje, omistaja, tyyppi.

1381
01:25:11,720 --> 01:25:16,990
Ja sitten jos sinulla on joukko Pokémon, voit tehdä jopa Pokedex, eikö?

1382
01:25:16,990 --> 01:25:20,810
Okei, viileä. Joten kysymyksiä tietueet. Nämä liittyvät tietueet.

1383
01:25:20,810 --> 01:25:25,270
>> Lopuksi, GDB. Mitä GDB voit tehdä? Sen avulla voit debug ohjelman.

1384
01:25:25,270 --> 01:25:27,650
Ja jos et ole käyttänyt GDB, olisin suositellut katsomassa lyhyt

1385
01:25:27,650 --> 01:25:31,250
ja juuri menee yli mitä GDB on, miten työskennellä sen kanssa, miten voit käyttää sitä,

1386
01:25:31,250 --> 01:25:32,900
ja testata sitä ohjelmaa.

1387
01:25:32,900 --> 01:25:37,400
Ja niin mitä GDB voit tehdä on se antaa tauko [käsittämätön] oman ohjelman

1388
01:25:37,400 --> 01:25:38,920
ja käytännön linjan.

1389
01:25:38,920 --> 01:25:42,600
Esimerkiksi haluan keskeyttää suorituksen kuten linja 3 minun ohjelma

1390
01:25:42,600 --> 01:25:46,010
ja kun olen rivillä 3 voin tulostaa kaikki arvot, jotka ovat siellä.

1391
01:25:46,010 --> 01:25:49,710
Ja niin me kutsumme kuin pysähtyen linjassa

1392
01:25:49,710 --> 01:25:52,350
on me kutsumme tätä asettaa keskeytyskohdan että linja

1393
01:25:52,350 --> 01:25:55,920
ja sitten voimme tulostaa muuttujien tilan ohjelman tuolloin.

1394
01:25:55,920 --> 01:25:58,990
>> Voimme sitten sieltä selata ohjelman rivi riviltä.

1395
01:25:58,990 --> 01:26:03,200
Ja sitten voimme tarkastella tilaa pinon tuolloin.

1396
01:26:03,200 --> 01:26:08,600
Ja niin, jotta voit käyttää GDB, mitä teemme, on me kutsumme clang on C-tiedosto,

1397
01:26:08,600 --> 01:26:11,290
mutta meidän on kuljettava se-ggdb lippua.

1398
01:26:11,290 --> 01:26:15,850
Ja kun olemme tehneet, että me vain ajaa GDB on tuloksena tuotoksen tiedosto.

1399
01:26:15,850 --> 01:26:18,810
Ja niin saat joitakin kuten massa tekstiä näin,

1400
01:26:18,810 --> 01:26:21,990
mutta oikeastaan ​​kaikki sinun tarvitsee vain kirjoittaa komentoja alussa.

1401
01:26:21,990 --> 01:26:24,250
Rikkoa tärkein asettaa keskeytyskohdan tärkein.

1402
01:26:24,250 --> 01:26:28,470
Luettelo 400 luettelee koodia noin rivin 400.

1403
01:26:28,470 --> 01:26:31,410
Ja niin tässä tapauksessa voit vain katsella ympärilleen ja sanoa, OH,

1404
01:26:31,410 --> 01:26:34,360
Haluan asettaa keskeytyskohdan linja 397, joka on tätä linjaa,

1405
01:26:34,360 --> 01:26:37,170
ja sitten käynnistyy tuohon vaiheeseen ja se tulee katkaista.

1406
01:26:37,170 --> 01:26:41,120
Se tulee keskeyttää siellä, ja voit tulostaa, esimerkiksi arvo matala tai korkea.

1407
01:26:41,120 --> 01:26:46,410
Ja niin on olemassa joukko komentoja, sinun täytyy tietää,

1408
01:26:46,410 --> 01:26:48,660
ja tämä diaesitys menee ylös verkkosivuilla,

1409
01:26:48,660 --> 01:26:54,000
joten jos haluat vain viitata näihin tai haluat laittaa ne huijata lakanat, rohkeasti.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. Se oli Quiz arvostelu 0, ja me kiinni noin, jos sinulla on kysyttävää.

1411
01:27:00,650 --> 01:27:03,850
Selvä.

1412
01:27:03,850 --> 01:27:09,030
>>  [Aplodit]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]