1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Viikko 4]

2
00:00:03,000 --> 00:00:05,000
[David J. Malan] [Harvardin yliopisto]

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

4
00:00:08,000 --> 00:00:12,000
>> Selvä, tämä on CS50, ja tämä on alku viikolla 4,

5
00:00:12,000 --> 00:00:16,000
ja tämä on yksi hitain mahdollista lajittelualgoritmeja.

6
00:00:16,000 --> 00:00:19,000
Kumpi oli se, että me vain katselin siellä?

7
00:00:19,000 --> 00:00:24,000
Se oli kupla lajitella, jotta iso O (n ^ 2) + summa,

8
00:00:24,000 --> 00:00:28,000
ja olemme todella ole ainoita tässä maailmassa tunnu tietävän

9
00:00:28,000 --> 00:00:30,000
mikä kupla lajitella on tai sen käyntiaika.

10
00:00:30,000 --> 00:00:33,000
Itse asiassa tämä oli haastattelun Eric Schmidt Google

11
00:00:33,000 --> 00:00:45,000
ja entinen senaattori Barack Obama vain muutama vuosi sitten.

12
00:00:45,000 --> 00:00:48,000
>> Nyt, senaattori, olette täällä Google,

13
00:00:48,000 --> 00:00:54,000
ja haluan ajatella puheenjohtajuuskauden työhaastattelu.

14
00:00:54,000 --> 00:00:58,000
Nyt on vaikea saada työtä presidenttinä, ja olet menossa läpi jäykkyys nyt.

15
00:00:58,000 --> 00:01:00,000
On myös vaikea saada työtä Google.

16
00:01:00,000 --> 00:01:05,000
Meillä on kysymyksiä, ja pyydämme ehdokkaita kysymyksiä,

17
00:01:05,000 --> 00:01:10,000
ja tämä yksi on Larry Schwimmer.

18
00:01:10,000 --> 00:01:14,000
Te kaverit ajattelevat olen tosissasi? Se on täällä.

19
00:01:14,000 --> 00:01:18,000
Mikä on tehokkain tapa lajitella miljoonaa 32-bittisiä kokonaislukuja?

20
00:01:18,000 --> 00:01:21,000
[Naurua]

21
00:01:21,000 --> 00:01:24,000
Hyvin

22
00:01:24,000 --> 00:01:26,000
Olen pahoillani. >> Ei, ei, ei, ei.

23
00:01:26,000 --> 00:01:34,000
Mielestäni kupla lajitella olisi väärä tapa edetä.

24
00:01:34,000 --> 00:01:39,000
>> Tule, joka kertoi hänelle tästä?

25
00:01:39,000 --> 00:01:43,000
Viime viikolla muistaa otimme tauon koodin, ainakin päivä,

26
00:01:43,000 --> 00:01:46,000
ja alkoi keskittyä jonkin korkeamman tason ideoita ja ongelmanratkaisu yleisemmin

27
00:01:46,000 --> 00:01:49,000
yhteydessä etsiminen ja lajittelu,

28
00:01:49,000 --> 00:01:53,000
ja me otettiin jotain, emme läimäyttää tätä nimeä viime viikolla,

29
00:01:53,000 --> 00:01:56,000
mutta asymptoottinen notaatio, Big O, Big Omega,

30
00:01:56,000 --> 00:02:00,000
ja joskus Big Theta notaatio, ja nämä olivat vain tapoja

31
00:02:00,000 --> 00:02:02,000
kuvata käyntiaika algoritmeja,

32
00:02:02,000 --> 00:02:05,000
kuinka paljon aikaa kuluu algoritmin ajaa.

33
00:02:05,000 --> 00:02:08,000
>> Ja ehkä muistaa, että puhuitte käyntiaika suhteen koko

34
00:02:08,000 --> 00:02:11,000
tulon, jota yleensä kutsumme n riippumatta ongelma voi olla,

35
00:02:11,000 --> 00:02:13,000
missä n on ihmisten määrä huoneessa,

36
00:02:13,000 --> 00:02:17,000
sivumäärä puhelinluettelosta, ja aloimme kirjoittaa asioita

37
00:02:17,000 --> 00:02:21,000
kuten O (n ^ 2) tai O (n) tai O (n log n),

38
00:02:21,000 --> 00:02:24,000
ja vaikka matematiikka ei oikein toiminut niin täydellisesti

39
00:02:24,000 --> 00:02:28,000
ja se oli n ² - n / 2 tai jotain

40
00:02:28,000 --> 00:02:31,000
me sen sijaan vain heittää pois joitakin alemman asteen termit,

41
00:02:31,000 --> 00:02:34,000
ja motivaatio on, että me todella haluamme

42
00:02:34,000 --> 00:02:37,000
eräänlainen objektiivinen tapa arvioida

43
00:02:37,000 --> 00:02:39,000
ohjelmien suorituskykyä tai suorituskyvyn algoritmit

44
00:02:39,000 --> 00:02:42,000
että loppujen lopuksi ei ole mitään tekemistä, esimerkiksi

45
00:02:42,000 --> 00:02:45,000
kanssa tietokoneen nopeudesta tänään.

46
00:02:45,000 --> 00:02:47,000
>> Esimerkiksi, jos toteuttaa kupla lajitella,

47
00:02:47,000 --> 00:02:50,000
tai voit toteuttaa yhdistää lajitella tai valinta lajitella tänään tietokoneella,

48
00:02:50,000 --> 00:02:53,000
2 GHz tietokone, ja käytät sitä,

49
00:02:53,000 --> 00:02:56,000
ja se vie jonkin määrän sekunnissa, ensi vuonna siellä 3 GHz

50
00:02:56,000 --> 00:02:59,000
tai 4 GHz tietokone, ja saatat sitten väittää, että "Vau, minun algoritmi

51
00:02:59,000 --> 00:03:03,000
on nyt kaksi kertaa niin nopeasti ", kun todellisuudessa se ei tietenkään pidä paikkaansa.

52
00:03:03,000 --> 00:03:06,000
Se on vain laitteisto on saanut nopeammin, mutta tietokone

53
00:03:06,000 --> 00:03:10,000
ei ole, ja niin me todella haluamme heittää pois asioita, kuten

54
00:03:10,000 --> 00:03:13,000
2 kerrannaisina tai 3 kerrannaisina, kun se tulee kuvataan

55
00:03:13,000 --> 00:03:17,000
kuinka nopeasti tai kuinka hidas algoritmi on ja oikeastaan ​​vain keskittyä

56
00:03:17,000 --> 00:03:20,000
n: tai jokin tekijä niiden

57
00:03:20,000 --> 00:03:24,000
Joissakin voiman kuin tapauksessa lajittelee viime viikolla.

58
00:03:24,000 --> 00:03:27,000
Ja muistuttaa, että sen avulla merge sort

59
00:03:27,000 --> 00:03:31,000
pystyimme tekemään niin paljon paremmin kuin kupla lajitella ja valinta lajitella

60
00:03:31,000 --> 00:03:33,000
ja jopa lisäys lajitella.

61
00:03:33,000 --> 00:03:36,000
>> Saimme alas n log n, ja jälleen,

62
00:03:36,000 --> 00:03:39,000
Muistutan, että log n tarkoittaa yleensä jotain, joka kasvaa

63
00:03:39,000 --> 00:03:43,000
hitaammin sitten n, joten n log n tähän asti oli hyvä

64
00:03:43,000 --> 00:03:45,000
koska se oli pienempi kuin n ².

65
00:03:45,000 --> 00:03:47,000
Mutta saavuttamaan n log n kanssa Merge sort

66
00:03:47,000 --> 00:03:51,000
Mikä oli perus alkio ajatus, että meillä oli hyödyntää

67
00:03:51,000 --> 00:03:54,000
että me myös velkarahalla takaisin viikolla 0?

68
00:03:54,000 --> 00:03:58,000
Miten voimme ratkaista lajittelu ongelma taitavasti Yhdistäminen tavallaan?

69
00:03:58,000 --> 00:04:04,000
Mikä oli avain näkemystä, kenties?

70
00:04:04,000 --> 00:04:07,000
Kuka tahansa.

71
00:04:07,000 --> 00:04:09,000
Okei, ota askel taaksepäin.

72
00:04:09,000 --> 00:04:11,000
Kuvaile yhdistää lajitella omin sanoin.

73
00:04:11,000 --> 00:04:15,000
Miten se toimii?

74
00:04:15,000 --> 00:04:17,000
Okei, me soutaa takaisin viikossa 0.

75
00:04:17,000 --> 00:04:19,000
Okei, joo.

76
00:04:19,000 --> 00:04:22,000
[Äänetön-opiskelija]

77
00:04:22,000 --> 00:04:26,000
Okei, hyvä, joten jaoimme joukko numeroita 2 kpl.

78
00:04:26,000 --> 00:04:29,000
Meillä lajitellaan kukin näistä kappaletta, ja sitten yhdistimme ne,

79
00:04:29,000 --> 00:04:33,000
ja olemme nähneet tätä ajatusta ennen ottaa ongelma, että tämä on iso

80
00:04:33,000 --> 00:04:36,000
ja pilkkominen se ylös ongelma, että tämä on iso tai näin iso.

81
00:04:36,000 --> 00:04:38,000
>> Recall puhelinluettelon esimerkki.

82
00:04:38,000 --> 00:04:42,000
Muistuttaa itsestään laskenta algoritmin viikkoa sitten

83
00:04:42,000 --> 00:04:45,000
niin yhdistää lajitella teki yhteenvedon tämän pseudokoodilla täällä.

84
00:04:45,000 --> 00:04:48,000
Kun olet antanut n osia, ensin se oli järki tarkistaa.

85
00:04:48,000 --> 00:04:51,000
Jos n <2, niin älä tee yhtään mitään

86
00:04:51,000 --> 00:04:55,000
koska jos n <2, niin n on luonnollisesti 0 tai 1,

87
00:04:55,000 --> 00:04:57,000
joten jos se on joko 0 tai 1 ei ole mitään lajitella.

88
00:04:57,000 --> 00:04:59,000
Olet valmis.

89
00:04:59,000 --> 00:05:01,000
Luettelo on jo triviaalisti lajitellaan.

90
00:05:01,000 --> 00:05:04,000
Mutta muuten jos sinulla 2 tai useampia elementtejä mennä eteenpäin ja jakaa ne

91
00:05:04,000 --> 00:05:06,000
osaksi 2 puolikkaat, vasemmalle ja oikealle.

92
00:05:06,000 --> 00:05:09,000
Lajittele kukin näistä puolikkaat, ja sitten yhdistää lajiteltu puolikkaat.

93
00:05:09,000 --> 00:05:13,000
Mutta ongelma tässä on se, että ensi silmäyksellä tämä tuntuu olemme punting.

94
00:05:13,000 --> 00:05:17,000
Tämä on pyöreä määritelmän, että jos olen pyytänyt sinua lajitella nämä n elementtiä

95
00:05:17,000 --> 00:05:22,000
ja sanot "Hyvä on, me lajitella ne n / 2 ja nuo n / 2 elementtiä"

96
00:05:22,000 --> 00:05:27,000
Sitten minun seuraava kysymys tulee olemaan "Hieno, miten lajitella n / 2 alkiota?"

97
00:05:27,000 --> 00:05:30,000
>> Mutta koska rakenne tämän ohjelman

98
00:05:30,000 --> 00:05:33,000
koska on perustapauksen, niin sanotusti,

99
00:05:33,000 --> 00:05:39,000
tämä erityinen tapaus, joka sanoo jos n <jokin kiinteä arvo kuin 2 paluun välittömästi.

100
00:05:39,000 --> 00:05:42,000
Älä vastaa tähän samaan pyöreä vastaus.

101
00:05:42,000 --> 00:05:46,000
Tämä prosessi, tämä syklisyys lopulta päättyy.

102
00:05:46,000 --> 00:05:50,000
Jos pyydän teitä "Järjestys nämä n elementit" ja te sanotte, "Hieno, lajitella nämä N / 2"

103
00:05:50,000 --> 00:05:53,000
Sitten te sanotte, "Hieno, lajitella nämä n / 4, N / 8, n/16"

104
00:05:53,000 --> 00:05:56,000
lopulta sinun jaat tarpeeksi iso joukko

105
00:05:56,000 --> 00:05:59,000
että sinulla on vain 1 elementti vasemmalle, jolloin voit sanoa,

106
00:05:59,000 --> 00:06:02,000
"Tässä, tässä on lajiteltu yksittäinen tekijä."

107
00:06:02,000 --> 00:06:06,000
Sitten loisto tämän algoritmin tänne on peräisin siitä

108
00:06:06,000 --> 00:06:09,000
että kun sinulla on kaikki nämä erikseen lajiteltu luettelot,

109
00:06:09,000 --> 00:06:12,000
jotka kaikki ovat kooltaan 1, joka näyttää olevan hyödytön,

110
00:06:12,000 --> 00:06:15,000
kun aloitat ne yhdistetään ja että ne yhdistetään

111
00:06:15,000 --> 00:06:19,000
voit rakentaa vihdoin kuten Rob teki videon vihdoin lajiteltu luettelo.

112
00:06:19,000 --> 00:06:22,000
>> Mutta tämä ajatus ulottuu kauas lajittelua.

113
00:06:22,000 --> 00:06:26,000
On tämä ajatus upotettu ohjelmaan kutsutaan rekursio,

114
00:06:26,000 --> 00:06:29,000
ajatus jonka olet ohjelmaa,

115
00:06:29,000 --> 00:06:32,000
ja ratkaisemaan joitakin ongelmia soitat itse,

116
00:06:32,000 --> 00:06:36,000
tai laittaa yhteydessä ohjelmointikieliä olet funktio,

117
00:06:36,000 --> 00:06:39,000
ja jotta voidaan ratkaista ongelma, olet funktion kutsut itseäsi

118
00:06:39,000 --> 00:06:42,000
uudestaan ​​ja uudestaan ​​ja uudestaan, mutta toiminto

119
00:06:42,000 --> 00:06:44,000
ei voi kutsua itseäsi äärettömän monta kertaa.

120
00:06:44,000 --> 00:06:47,000
Lopulta sinun täytyy pohja pois, niin sanotusti,

121
00:06:47,000 --> 00:06:49,000
ja joitakin kovakoodatuilla base edellyttäen, että sanoo

122
00:06:49,000 --> 00:06:53,000
tässä vaiheessa lopettaa kutsua itseäsi niin että koko prosessi

123
00:06:53,000 --> 00:06:56,000
Lopuksi ei itse lopeta.

124
00:06:56,000 --> 00:06:58,000
Mitä tämä oikeastaan ​​tarkoittaa, että recurse?

125
00:06:58,000 --> 00:07:01,000
>> Katsotaanpa, jos voimme tehdä yksinkertaisen, triviaali esimerkki vaikkapa

126
00:07:01,000 --> 00:07:03,000
3 ihmistä kanssani täällä lavalla, jos joku on mukava.

127
00:07:03,000 --> 00:07:06,000
1, tule ylös, 2 ja 3.

128
00:07:06,000 --> 00:07:09,000
Jos 3 haluavat tulla tänne.

129
00:07:09,000 --> 00:07:12,000
Jos haluat seistä vieressä minulle täällä linja, olettaa, että ongelma käsillä

130
00:07:12,000 --> 00:07:15,000
on hyvin triviaalisti laskea joukko ihmisiä, jotka ovat täällä.

131
00:07:15,000 --> 00:07:18,000
Mutta rehellisesti, olen kyllästynyt kaikkien näiden laskenta esimerkit.

132
00:07:18,000 --> 00:07:21,000
Tämä vie jonkin aikaa, 1, 2, ja piste, piste, piste.

133
00:07:21,000 --> 00:07:23,000
Se tulee kestää ikuisesti.

134
00:07:23,000 --> 00:07:25,000
Olen mieluummin vain punt tämän ongelman kokonaan avulla-mikä on nimesi?

135
00:07:25,000 --> 00:07:27,000
Sara. >> Sara, okei.

136
00:07:27,000 --> 00:07:29,000
Kelly. >> Kelly ja?

137
00:07:29,000 --> 00:07:31,000
>> Willy. >> Willy, Sara, Kelly, ja Willy.

138
00:07:31,000 --> 00:07:34,000
Juuri nyt olen ollut kysyi joku

139
00:07:34,000 --> 00:07:37,000
kuinka monet ihmiset ovat jopa tässä vaiheessa, ja minulla ei ole aavistustakaan.

140
00:07:37,000 --> 00:07:40,000
Tämä on todella pitkä lista, joten sen sijaan aion tehdä tämän tempun.

141
00:07:40,000 --> 00:07:43,000
Aion kysyä henkilölle viereeni tekemään suurimman osan työstä,

142
00:07:43,000 --> 00:07:46,000
ja kun hän on tehnyt tekee suurimman osan työstä

143
00:07:46,000 --> 00:07:49,000
Aion tehdä vähiten työtä mahdollista ja vain lisää 1

144
00:07:49,000 --> 00:07:51,000
mihin tahansa hänen vastaus on, joten tässä mennään.

145
00:07:51,000 --> 00:07:54,000
Minulta on kysytty, kuinka monet ihmiset ovat lavalla.

146
00:07:54,000 --> 00:07:57,000
Kuinka monta ihmistä lavalla vasemmalla sinä?

147
00:07:57,000 --> 00:08:00,000
Vasen minua? >> Okei, mutta älä huijaa.

148
00:08:00,000 --> 00:08:04,000
Se on hyvä, se on oikein, mutta jos haluamme jatkaa tätä logiikkaa

149
00:08:04,000 --> 00:08:08,000
Oletetaan, että olet samalla haluat punt tämän ongelman vasemmalla teitä,

150
00:08:08,000 --> 00:08:11,000
niin kuin vastauksen suoraan mennä eteenpäin ja vain sysätä.

151
00:08:11,000 --> 00:08:14,000
Voi, kuinka monet ihmiset ovat vasemmalla minua?

152
00:08:14,000 --> 00:08:16,000
Kuinka monet ihmiset ovat vasemmalle?

153
00:08:16,000 --> 00:08:18,000
1.

154
00:08:18,000 --> 00:08:27,000
[Naurua]

155
00:08:27,000 --> 00:08:30,000
Okei, joten 0, joten mitä nyt Willy on tehnyt

156
00:08:30,000 --> 00:08:33,000
on olet palannut vastauksesi tähän suuntaan sanomalla 0.

157
00:08:33,000 --> 00:08:36,000
Nyt, mitä teidän pitäisi tehdä? >> 1.

158
00:08:36,000 --> 00:08:39,000
Okei, joten olet 1, niin sanot, "Okei, aion lisätä 1

159
00:08:39,000 --> 00:08:41,000
mihin tahansa Willy n määrä oli "niin 1 + 0.

160
00:08:41,000 --> 00:08:43,000
Olet nyt 1 niin vastauksesi oikealla on nyt-

161
00:08:43,000 --> 00:08:45,000
1. >> Ja minun olisi 2.

162
00:08:45,000 --> 00:08:48,000
Hyvä, niin otat edellinen vastaus on 1,

163
00:08:48,000 --> 00:08:51,000
lisäämällä pieni määrä työtä haluat tehdä, mikä on +1.

164
00:08:51,000 --> 00:08:55,000
Sinulla on nyt 2, ja voit sitten ojentaa minulle mikä arvo?

165
00:08:55,000 --> 00:08:57,000
3, tarkoitan, anteeksi, 2.

166
00:08:57,000 --> 00:08:59,000
Hyvä.

167
00:08:59,000 --> 00:09:02,000
>> No, meillä oli 0 vasemmalle.

168
00:09:02,000 --> 00:09:05,000
Sitten meillä oli 1, ja sitten lisätään 2,

169
00:09:05,000 --> 00:09:07,000
ja nyt olet ojentamassa minulle numero 2,

170
00:09:07,000 --> 00:09:10,000
ja niin minä sanon, okei, +1, 3.

171
00:09:10,000 --> 00:09:13,000
On tosiaan 3 henkilöä vieressäni minua tässä vaiheessa,

172
00:09:13,000 --> 00:09:16,000
jotta olisimme voineet tietysti tehdä tämän hyvin lineaarisesti,

173
00:09:16,000 --> 00:09:19,000
erittäin paljon ilmeinen muoti, mutta mitä me todella?

174
00:09:19,000 --> 00:09:21,000
Otimme ongelma koko 3 aluksi.

175
00:09:21,000 --> 00:09:24,000
Sitten purettiin se ongelma koko 2,

176
00:09:24,000 --> 00:09:27,000
Sitten ongelma koko 1, ja sitten lopulta perustapauksessa

177
00:09:27,000 --> 00:09:29,000
oli todella, oh, siellä ei ole ketään,

178
00:09:29,000 --> 00:09:33,000
jolloin Willy palasi tehokkaasti kovakoodatuilla vastaus pari kertaa,

179
00:09:33,000 --> 00:09:36,000
ja toinen sitten kuplina ylös, kuplina ylös, kuplina ylös,

180
00:09:36,000 --> 00:09:39,000
ja sitten lisäämällä tähän vielä yksi 1

181
00:09:39,000 --> 00:09:41,000
olemme toteuttaneet tätä perusajatusta rekursion.

182
00:09:41,000 --> 00:09:44,000
>> Nyt, tässä tapauksessa se ei todellakaan ratkaise ongelmaa

183
00:09:44,000 --> 00:09:46,000
yhtään tehokkaammin silloin olemme nähneet tähän mennessä.

184
00:09:46,000 --> 00:09:48,000
Mutta ajattele algoritmit olemme tehneet lavalle toistaiseksi.

185
00:09:48,000 --> 00:09:51,000
Meillä oli 8 paperinpaloja tauluun

186
00:09:51,000 --> 00:09:55,000
video kun Sean oli etsimässä numero 7, ja mitä hän oikeasti tekee?

187
00:09:55,000 --> 00:09:58,000
No, hän ei tee minkäänlaista hajota ja hallitse.

188
00:09:58,000 --> 00:10:01,000
Hän ei tee minkäänlaista rekursion.

189
00:10:01,000 --> 00:10:03,000
Pikemminkin hän vain teki tämän lineaarinen algoritmi.

190
00:10:03,000 --> 00:10:07,000
Mutta kun esittelimme ajatuksen lajiteltu numeroita lavalla elää viime viikolla

191
00:10:07,000 --> 00:10:09,000
Sitten meillä oli tämä vaisto menee keskelle,

192
00:10:09,000 --> 00:10:13,000
jolloin meillä oli pienempi luettelon koon 4 tai toisen luettelon koon 4,

193
00:10:13,000 --> 00:10:17,000
ja sitten meillä oli täsmälleen sama ongelma, joten toistuva, toistetaan, toistetaan.

194
00:10:17,000 --> 00:10:19,000
Toisin sanoen, me recursed.

195
00:10:19,000 --> 00:10:24,000
Paljon kiitoksia meidän 3 Vapaaehtoiset osoittamiseksi rekursion kanssamme.

196
00:10:24,000 --> 00:10:28,000
>> Katsotaan jos emme voi tehdä tätä nyt vähän konkreettisempaa,

197
00:10:28,000 --> 00:10:30,000
ratkaista ongelma, joka jälleen voisimme tehdä melko helposti,

198
00:10:30,000 --> 00:10:34,000
mutta käytämme sitä ponnahduslautana täytäntöön tätä perusajatusta.

199
00:10:34,000 --> 00:10:37,000
Jos haluan laskea summattu joukko numeroita,

200
00:10:37,000 --> 00:10:39,000
Esimerkiksi, jos ohitat määrä 3,

201
00:10:39,000 --> 00:10:42,000
Haluan antaa teille arvon sigma 3,

202
00:10:42,000 --> 00:10:46,000
niin summa 3 + 2 + 1 + 0.

203
00:10:46,000 --> 00:10:48,000
Haluan saada takaisin vastauksen 6,

204
00:10:48,000 --> 00:10:51,000
niin me täytäntöön tämän sigma toimintoa, tämä summattu toiminto

205
00:10:51,000 --> 00:10:54,000
että, jälleen, vie tulo ja palauttaa sitten summattu

206
00:10:54,000 --> 00:10:57,000
tuosta määrästä kaikki alas 0.

207
00:10:57,000 --> 00:10:59,000
Voisimme tehdä melko yksinkertaisesti, eikö?

208
00:10:59,000 --> 00:11:01,000
Voisimme tehdä tästä jonkinlainen kiehkura rakenteen,

209
00:11:01,000 --> 00:11:04,000
joten anna minun mennä eteenpäin ja saada tämä alkoi.

210
00:11:04,000 --> 00:11:07,000
>> Sisällytä stdio.h.

211
00:11:07,000 --> 00:11:09,000
Otan itseni tärkein työskennellä täällä.

212
00:11:09,000 --> 00:11:12,000
Säästetään tätä sigma.c.

213
00:11:12,000 --> 00:11:14,000
Sitten aion mennä tänne, ja aion julistaa int n,

214
00:11:14,000 --> 00:11:18,000
ja aion tehdä seuraavat, kun käyttäjä ei tee yhteistyötä.

215
00:11:18,000 --> 00:11:22,000
Vaikka käyttäjä ei ole antanut minulle positiivinen luku

216
00:11:22,000 --> 00:11:26,000
anna minun mennä eteenpäin ja pyytää heitä n = GetInt,

217
00:11:26,000 --> 00:11:28,000
ja haluan antaa heille joitakin ohjeita siitä, mitä tehdä,

218
00:11:28,000 --> 00:11:33,000
joten printf ("Positiivinen kokonaisluku please").

219
00:11:33,000 --> 00:11:39,000
Just jotain suhteellisen yksinkertaista, kuten tämä, niin että kun me osuma linja 14

220
00:11:39,000 --> 00:11:42,000
meillä on nyt positiivinen kokonaisluku oletettavasti n..

221
00:11:42,000 --> 00:11:44,000
>> Nyt asialle jotain.

222
00:11:44,000 --> 00:11:50,000
Anna minun mennä eteenpäin ja laske summattu, joten int summa = sigma (n).

223
00:11:50,000 --> 00:11:54,000
Sigma on vain summattu, joten olen vain kirjallisesti sitä harrastaja tavalla.

224
00:11:54,000 --> 00:11:56,000
Me vain kutsumme sitä sigma siellä.

225
00:11:56,000 --> 00:11:58,000
Tuo summa, ja nyt aion tulostaa tuloksen,

226
00:11:58,000 --> 00:12:08,000
printf ("summa on% d, \ n", summa).

227
00:12:08,000 --> 00:12:11,000
Ja sitten palaan 0 hyvä toimenpide.

228
00:12:11,000 --> 00:12:15,000
Olemme tehneet kaiken tämän ohjelma vaatii paitsi mielenkiintoinen osa,

229
00:12:15,000 --> 00:12:18,000
joka on todella toteuttaa sigma toimintoa.

230
00:12:18,000 --> 00:12:22,000
>> Päästä minut tänne pohjaan, ja haluan julistaa toiminnon sigma.

231
00:12:22,000 --> 00:12:26,000
Se sai ottaa muuttuja on tyyppiä Integer,

232
00:12:26,000 --> 00:12:30,000
ja mitä tietotyyppi haluan palata oletettavasti Sigma?

233
00:12:30,000 --> 00:12:34,000
Int, koska haluan sen vastaamaan odotuksia linjalla 15.

234
00:12:34,000 --> 00:12:37,000
Täällä haluan mennä eteenpäin ja toteuttaa tämän

235
00:12:37,000 --> 00:12:41,000
vuonna melko mutkattomasti.

236
00:12:41,000 --> 00:12:45,000
>> Mennään eteenpäin ja sanoa int summa = 0,

237
00:12:45,000 --> 00:12:47,000
ja nyt aion mennä on hieman for silmukka täällä

238
00:12:47,000 --> 00:12:50,000
että menee sanoa jotain tällaista,

239
00:12:50,000 --> 00:13:01,000
for (int i = 0; i <= luku; i + +) summa + = i.

240
00:13:01,000 --> 00:13:05,000
Ja sitten aion palata summa.

241
00:13:05,000 --> 00:13:07,000
Olisin voinut toteuttaa tämän monin tavoin.

242
00:13:07,000 --> 00:13:09,000
Olisin voinut käyttää while-silmukka.

243
00:13:09,000 --> 00:13:11,000
Olisin voinut ohittaa käyttämällä summamuuttuja jos halusin,

244
00:13:11,000 --> 00:13:15,000
mutta lyhyesti sanottuna meillä vain on tehtävä, että jos en hölmö vakuuttaa summa on 0.

245
00:13:15,000 --> 00:13:18,000
Sitten se toistetaan alkaen 0. läpi numero,

246
00:13:18,000 --> 00:13:23,000
ja jokaisen iteraation se lisää, että käypä arvo on summa ja palaa sitten summa.

247
00:13:23,000 --> 00:13:25,000
>> Nyt siellä on hieman optimointi täällä.

248
00:13:25,000 --> 00:13:29,000
Tämä on luultavasti hukkaan askel, mutta olkoon niin. Se on hieno nyt.

249
00:13:29,000 --> 00:13:32,000
Olemme ainakin on perusteellinen ja menee 0 koko matkan ylös.

250
00:13:32,000 --> 00:13:34,000
Ei kovin kova ja melko yksinkertainen,

251
00:13:34,000 --> 00:13:37,000
mutta se osoittautuu, että sigma toiminnon meillä on samat mahdollisuudet

252
00:13:37,000 --> 00:13:39,000
kuten teimme täällä lavalla.

253
00:13:39,000 --> 00:13:42,000
Lavalla me vain laskea kuinka monta ihmistä oli vierelläni,

254
00:13:42,000 --> 00:13:47,000
vaan jos haluaisimme laskea numero 3 + 2 + 1

255
00:13:47,000 --> 00:13:51,000
siitä alas 0 voisimme samalla ruuhi toiminnon

256
00:13:51,000 --> 00:13:55,000
että minä sen sijaan kuvailla olevan rekursiivinen.

257
00:13:55,000 --> 00:13:57,000
Täällä Tehdään nopea järki tarkistaa ja varmista En hölmö.

258
00:13:57,000 --> 00:14:00,000
>> Tiedän, että ainakin yksi asia tässä ohjelmassa että tein väärin.

259
00:14:00,000 --> 00:14:04,000
Kun Löin kirjoita aion saada minkäänlaista huutaa minua?

260
00:14:04,000 --> 00:14:06,000
Mitä minä olla huusi noin?

261
00:14:06,000 --> 00:14:11,000
Joo, unohdin prototyyppi, joten olen käyttäen toiminto nimeltään Sigma linjalla 15,

262
00:14:11,000 --> 00:14:16,000
mutta se ei ilmoitettu vasta linja 22, joten olen paras ennakoivasti mennä tänne

263
00:14:16,000 --> 00:14:22,000
ja julistaa prototyyppi, ja sanon int sigma (int numero), ja se on siinä.

264
00:14:22,000 --> 00:14:24,000
Se on toteutettu alareunassa.

265
00:14:24,000 --> 00:14:27,000
>> Tai toinen tapa voisin ratkaista,

266
00:14:27,000 --> 00:14:30,000
Voisin siirtää toiminnon siellä, mikä ei ole huono,

267
00:14:30,000 --> 00:14:32,000
mutta ainakin kun ohjelmat alkavat saada pitkä, rehellisesti,

268
00:14:32,000 --> 00:14:35,000
Minusta siinä on jotain arvoa aina ottaa pääasiassa yläreunassa

269
00:14:35,000 --> 00:14:38,000
niin että te lukija voi avata tiedostoa ja sitten heti nähdä

270
00:14:38,000 --> 00:14:40,000
mitä ohjelma tekee ilman etsiä sitä

271
00:14:40,000 --> 00:14:42,000
etsivät että päätehtävä.

272
00:14:42,000 --> 00:14:49,000
Mennään alas minun pääteikkunaa täällä, yritä tehdä sigma tehdä sigma,

273
00:14:49,000 --> 00:14:51,000
ja minä mokasin täälläkin.

274
00:14:51,000 --> 00:14:55,000
Implisiittiset ilmoitus toiminnan GetInt tarkoittaa olen unohtanut tehdä mitä muuta?

275
00:14:55,000 --> 00:14:57,000
[Äänetön-opiskelija]

276
00:14:57,000 --> 00:15:00,000
Hyvä, joten ilmeisesti yleinen virhe, joten katsotaanpa laittaa tämän tänne,

277
00:15:00,000 --> 00:15:04,000
cs50.h, ja nyt mennään takaisin minun pääteikkuna.

278
00:15:04,000 --> 00:15:08,000
>> Minä tyhjentää näytön, ja minä uusintana tehdä sigma.

279
00:15:08,000 --> 00:15:11,000
Se näyttää koottu. Saanen nyt ajaa sigma.

280
00:15:11,000 --> 00:15:15,000
Minä kirjoita numero 3, ja sain 6, joten ei tiukkaa tarkastus,

281
00:15:15,000 --> 00:15:18,000
mutta ainakin se näyttää toimivan ensi silmäyksellä, mutta nyt mennään repiä sen lisäksi,

282
00:15:18,000 --> 00:15:21,000
ja mennään todella hyödyntää ajatusta rekursio, jälleen

283
00:15:21,000 --> 00:15:24,000
on hyvin yksinkertainen tilanteessa niin, että muutaman viikon kuluttua

284
00:15:24,000 --> 00:15:27,000
kun alamme tutkia harrastaja tietorakenteita kuin ryhmät

285
00:15:27,000 --> 00:15:30,000
meillä on toinen työkalu työkalupakin, jonka kanssa

286
00:15:30,000 --> 00:15:33,000
käsitellä tietoa rakenteita kuten näemme.

287
00:15:33,000 --> 00:15:36,000
Tämä on iteratiivinen lähestymistapa, loop-lähestymistapaa.

288
00:15:36,000 --> 00:15:39,000
>> Saanen sen sijaan nyt tähän.

289
00:15:39,000 --> 00:15:44,000
Saanen sen sijaan sanoa, että summattu numero

290
00:15:44,000 --> 00:15:48,000
alas 0 ei todellakaan ole sama asia kuin

291
00:15:48,000 --> 00:15:53,000
numero + sigma (numero - 1).

292
00:15:53,000 --> 00:15:57,000
Toisin sanoen, kuten lavalla I punted kullekin ihmiset viereeni,

293
00:15:57,000 --> 00:16:00,000
ja ne puolestaan ​​pidetty punting kunnes vihdoin pohjansa Willy,

294
00:16:00,000 --> 00:16:03,000
joka joutui palaamaan kovakoodatuilla vastaukseksi esimerkiksi 0.

295
00:16:03,000 --> 00:16:07,000
Täällä nyt olemme samalla punting sigma

296
00:16:07,000 --> 00:16:10,000
Sama toiminto kuin oli alun perin nimeltään, mutta avain käsityksen tästä

297
00:16:10,000 --> 00:16:12,000
on, että emme ole vaatimassa sigma identtisesti.

298
00:16:12,000 --> 00:16:14,000
Emme ohimennen n.

299
00:16:14,000 --> 00:16:17,000
Olemme selvästi ohimennen - 1,

300
00:16:17,000 --> 00:16:20,000
joten hieman pienempi ongelma, hieman pienempi ongelma.

301
00:16:20,000 --> 00:16:23,000
>> Valitettavasti tämä ei ole aivan vielä ratkaisua, ja ennen kuin korjata

302
00:16:23,000 --> 00:16:26,000
mitä voidaan hyppäämällä ulos ilmeinen jossain teistä

303
00:16:26,000 --> 00:16:28,000
anna minun mennä eteenpäin ja uusintana tehdä.

304
00:16:28,000 --> 00:16:30,000
Vaikuttaa koota kunnossa.

305
00:16:30,000 --> 00:16:32,000
Saanen uusintana Sigma 6.

306
00:16:32,000 --> 00:16:37,000
Oho, haluan uusinta Sigma 6.

307
00:16:37,000 --> 00:16:42,000
Olemme nähneet tämän ennenkin, vaikkakin vahingossa viime kerralla samoin.

308
00:16:42,000 --> 00:16:48,000
Miksi saan tämän arvoituksellinen segmentointi vika? Joo.

309
00:16:48,000 --> 00:16:50,000
[Äänetön-opiskelija]

310
00:16:50,000 --> 00:16:53,000
Ei ole pohja tapauksessa ja erityisesti, mitä todennäköisesti tapahtui?

311
00:16:53,000 --> 00:16:58,000
Tämä on oire mitä käyttäytymistä?

312
00:16:58,000 --> 00:17:00,000
Sano se hieman kovempaa.

313
00:17:00,000 --> 00:17:02,000
[Äänetön-opiskelija]

314
00:17:02,000 --> 00:17:05,000
Se on loputon silmukka tehokkaasti, ja ongelma ääretön silmukat

315
00:17:05,000 --> 00:17:08,000
kun niihin liittyy rekursiota tässä tapauksessa funktio kutsuu itseään,

316
00:17:08,000 --> 00:17:10,000
mitä tapahtuu joka kerta kun soittaa funktio?

317
00:17:10,000 --> 00:17:13,000
No, muistelen miten säädettyihin muistin tietokoneen.

318
00:17:13,000 --> 00:17:16,000
Sanoimme, että tämä kimpale muistia kutsutaan pino, joka on alareunassa,

319
00:17:16,000 --> 00:17:19,000
ja joka kerta kun soittaa funktio hieman muistia saa laittaa

320
00:17:19,000 --> 00:17:24,000
tätä ns pino sisältää funktion paikallinen muuttujia tai parametreja,

321
00:17:24,000 --> 00:17:27,000
joten jos sigma puhelut sigma puhelut sigma vaatii sigma

322
00:17:27,000 --> 00:17:29,000
 kehottaa Sigma Mihin tämä tarina päättyy?

323
00:17:29,000 --> 00:17:31,000
>> No, se lopulta ylitykset yhteensä

324
00:17:31,000 --> 00:17:33,000
muistia että sinulla on käytettävissä tietokoneen.

325
00:17:33,000 --> 00:17:37,000
Voit ylivuoto segmentin että sinun pitäisi pysyä sisällä,

326
00:17:37,000 --> 00:17:40,000
ja saat tämän segmentointi vika, ydin polkumyynnillä,

327
00:17:40,000 --> 00:17:43,000
ja mitä ydin polkumyynnillä tarkoittaa, että minulla on nyt tiedosto nimeltä ydin

328
00:17:43,000 --> 00:17:46,000
joka on tiedosto, joka sisältää nollia ja ykkösiä

329
00:17:46,000 --> 00:17:49,000
että oikeastaan ​​tulevaisuudessa diagnostisesti hyödyllisiä.

330
00:17:49,000 --> 00:17:52,000
Jos se ei ole selvää, missä teidän kuoriainen

331
00:17:52,000 --> 00:17:54,000
voit itse tehdä vähän rikosteknisen analyysin, niin sanotusti,

332
00:17:54,000 --> 00:17:58,000
tämän core dump tiedoston, joka taas on vain koko joukko nollia ja ykkösiä

333
00:17:58,000 --> 00:18:02,000
että pohjimmiltaan edustaa valtion oman ohjelman muistiin

334
00:18:02,000 --> 00:18:05,000
hetkellä kaatui tällä tavalla.

335
00:18:05,000 --> 00:18:11,000
>> Fix tässä on, että emme voi vain sokeasti palata sigma,

336
00:18:11,000 --> 00:18:14,000
numero + sigma on hieman pienempi ongelma.

337
00:18:14,000 --> 00:18:16,000
Meidän on jonkinlainen pohja tässä tapauksessa,

338
00:18:16,000 --> 00:18:19,000
ja mitä pitäisi perustapaus lienee?

339
00:18:19,000 --> 00:18:22,000
[Äänetön-opiskelija]

340
00:18:22,000 --> 00:18:25,000
Okei, niin kauan kuin numero on positiivinen meidän pitäisi oikeastaan ​​palauttaa tämän,

341
00:18:25,000 --> 00:18:29,000
tai toisin sanoin, jos numero on, eli <= 0

342
00:18:29,000 --> 00:18:32,000
Tiedätkö mitä, minä menen eteenpäin ja palaa 0,

343
00:18:32,000 --> 00:18:36,000
aivan kuten Willy teki, ja muuten, aion mennä eteenpäin

344
00:18:36,000 --> 00:18:41,000
ja palauta, joten se ei ole niin paljon lyhyempi

345
00:18:41,000 --> 00:18:44,000
kuin iteratiivinen versio me lyöty jopa ensin käyttämällä varten silmukka,

346
00:18:44,000 --> 00:18:48,000
mutta huomaa, että siellä on tällainen eleganssia sitä.

347
00:18:48,000 --> 00:18:51,000
Sen sijaan palauttaa joidenkin määrän ja suorittaa kaikki tämä matematiikka

348
00:18:51,000 --> 00:18:54,000
ja lisäämällä asioita paikallisia muuttujia

349
00:18:54,000 --> 00:18:57,000
sinä sen sijaan sanomalla "Okei, jos tämä on erittäin helppo ongelma,

350
00:18:57,000 --> 00:19:01,000
kuten numero on <0, haluan heti palata 0 ".

351
00:19:01,000 --> 00:19:03,000
>> Emme vaivautuisi tukemiseen negatiivisia lukuja,

352
00:19:03,000 --> 00:19:05,000
joten aion kova koodi arvo 0.

353
00:19:05,000 --> 00:19:08,000
Mutta muuten toteuttaa tämän ajatuksen yhteenlaskua

354
00:19:08,000 --> 00:19:11,000
kaikki nämä numerot yhteen voit tehokkaasti ottaa pikkupurtavaa

355
00:19:11,000 --> 00:19:14,000
pois ongelman, aivan kuten me teimme täällä lavalla,

356
00:19:14,000 --> 00:19:18,000
Sitten punt loput ongelman seuraava henkilö,

357
00:19:18,000 --> 00:19:20,000
mutta tässä tapauksessa seuraava henkilö itse.

358
00:19:20,000 --> 00:19:22,000
Se samannimistä toimintoa.

359
00:19:22,000 --> 00:19:25,000
Vain siirtää sitä pienempiä ja pienempiä ongelma joka kerta,

360
00:19:25,000 --> 00:19:28,000
ja vaikka meillä ei aivan virallisesti asioita koodi tähän

361
00:19:28,000 --> 00:19:33,000
tämä on juuri sitä, mitä oli tekeillä viikolla 0 ja puhelinluettelosta.

362
00:19:33,000 --> 00:19:36,000
Tämä on juuri sitä, mitä oli tekeillä viimeisen viikon Sean

363
00:19:36,000 --> 00:19:39,000
ja meidän mielenosoituksia etsiä numeroita.

364
00:19:39,000 --> 00:19:42,000
Se vie ongelman ja jakamalla se uudestaan ​​ja uudestaan.

365
00:19:42,000 --> 00:19:44,000
>> Toisin sanoen, on olemassa tapa nyt kääntää

366
00:19:44,000 --> 00:19:47,000
Tämän reaalimaailman rakenteen, tämän korkeamman rakenteen

367
00:19:47,000 --> 00:19:51,000
hajota ja hallitse ja tehdä jotain uudestaan ​​ja uudestaan

368
00:19:51,000 --> 00:19:56,000
koodin, joten tämä on jotain näemme jälleen ajan.

369
00:19:56,000 --> 00:20:00,000
Nyt, sivuun, jos olet uusi rekursio sinun pitäisi ainakin ymmärtää nyt

370
00:20:00,000 --> 00:20:02,000
miksi tämä on hauska.

371
00:20:02,000 --> 00:20:05,000
Aion mennä google.com,

372
00:20:05,000 --> 00:20:17,000
ja aion etsiä vinkkejä ja niksejä rekursio, kirjoita.

373
00:20:17,000 --> 00:20:21,000
Kerro henkilö vieressäsi jos niitä ei nauraa juuri nyt.

374
00:20:21,000 --> 00:20:23,000
Tarkoititko rekursio?

375
00:20:23,000 --> 00:20:25,000
Did you mean-ah, siellä mennään.

376
00:20:25,000 --> 00:20:28,000
Okei, nyt on loput kaikille.

377
00:20:28,000 --> 00:20:30,000
Pieni pääsiäismuna upotettu jossain siellä Google.

378
00:20:30,000 --> 00:20:33,000
Sivuhuomautuksena, yksi linkeistä laitamme kurssin verkkosivuilla

379
00:20:33,000 --> 00:20:36,000
tänään on juuri tämä ruudukon eri lajittelualgoritmeja,

380
00:20:36,000 --> 00:20:39,000
joista me katsoimme viime viikolla, mutta mitä mukavaa tästä visualisointi

381
00:20:39,000 --> 00:20:43,000
kuin yrität wrap mieltäsi noin erilaisia ​​asioita, jotka liittyvät algoritmit

382
00:20:43,000 --> 00:20:46,000
tietää, että voit helposti nyt aloittaa erilaisilla tuloa.

383
00:20:46,000 --> 00:20:50,000
Tulot kaikki käänteinen, tulot enimmäkseen lajiteltu, tulot satunnainen ja niin edelleen.

384
00:20:50,000 --> 00:20:53,000
Kun yrittää jälleen erottaa nämä asiat mielessäsi

385
00:20:53,000 --> 00:20:57,000
ymmärtävät, että tämä URL kurssin verkkosivuilla Luennot sivulla

386
00:20:57,000 --> 00:21:00,000
saattaa auttaa syystä läpi joitakin niistä.

387
00:21:00,000 --> 00:21:05,000
>> Tänään vihdoin ratkaista tämän ongelman taas takaisin,

388
00:21:05,000 --> 00:21:08,000
mikä oli tämän swap toiminto ei vain toiminut,

389
00:21:08,000 --> 00:21:12,000
ja mikä oli perustavanlaatuinen ongelma tämän toiminnon swap,

390
00:21:12,000 --> 00:21:15,000
jonka tavoitteena oli jälleen vaihtaa arvon täällä ja täällä

391
00:21:15,000 --> 00:21:17,000
siten, että tämä tapahtuu?

392
00:21:17,000 --> 00:21:20,000
Tämä ei oikeastaan ​​toimi. Miksi?

393
00:21:20,000 --> 00:21:22,000
Joo.

394
00:21:22,000 --> 00:21:28,000
[Äänetön-opiskelija]

395
00:21:28,000 --> 00:21:31,000
Aivan, selitystä tälle bugginess

396
00:21:31,000 --> 00:21:34,000
yksinkertaisesti ollut, koska kun soitat toiminnot C

397
00:21:34,000 --> 00:21:38,000
ja nämä funktiot argumentteja, kuten ja b täällä,

398
00:21:38,000 --> 00:21:42,000
olet ohimennen kopioita arvosta riippumatta olet tarjoamalla tälle tehtävälle.

399
00:21:42,000 --> 00:21:46,000
Et ole tarjota alkuperäiset arvot itse,

400
00:21:46,000 --> 00:21:49,000
joten näimme tämän yhteydessä buggyc,

401
00:21:49,000 --> 00:21:52,000
buggy3.c, joka näytti vähän jotain tällaista.

402
00:21:52,000 --> 00:21:57,000
>> Muistaa, että meillä oli x-ja y-alustetaan 1 ja 2, vastaavasti.

403
00:21:57,000 --> 00:21:59,000
Sitten tulostaa mitä ne olivat.

404
00:21:59,000 --> 00:22:03,000
Sitten väitti että olin vaihtamalla niitä soittamalla swap x, y.

405
00:22:03,000 --> 00:22:06,000
Mutta ongelma oli, että vaihtava toimi,

406
00:22:06,000 --> 00:22:10,000
mutta vain soveltamisalaan Swap-toiminto itse.

407
00:22:10,000 --> 00:22:13,000
Heti kun osuimme line 40 ne vaihtoivat arvot

408
00:22:13,000 --> 00:22:16,000
heitettiin pois, ja niin mikään

409
00:22:16,000 --> 00:22:21,000
Alkuperäisen funktion tärkeimmät todella muuttunut lainkaan,

410
00:22:21,000 --> 00:22:26,000
joten jos ajattelet tuolloin, mitä tämä näyttää kannalta meidän muisti

411
00:22:26,000 --> 00:22:29,000
jos tämä vasemmalla puolella Hallitus edustaa-

412
00:22:29,000 --> 00:22:33,000
ja minä teen parhaani kaikkien nähdä tämä, jos tämä vasemmalla puolella hallituksen

413
00:22:33,000 --> 00:22:37,000
edustaa, eli muistin, ja pino tulee kasvamaan edelleen aina tällä tavalla,

414
00:22:37,000 --> 00:22:43,000
ja me kutsumme toiminto, kuten pää-, ja pääasialliset on 2 paikallisia muuttujia, x ja y,

415
00:22:43,000 --> 00:22:48,000
mennään kuvaamaan niitä kuin x täällä, ja mennään kuvaamaan näitä kuin y täällä,

416
00:22:48,000 --> 00:22:55,000
ja mennään laittaa arvot 1 ja 2, joten tämä tässä on tärkein,

417
00:22:55,000 --> 00:22:58,000
ja kun tärkeimmät kutsuu swap toiminto käyttöjärjestelmä

418
00:22:58,000 --> 00:23:02,000
antaa swap toiminnon oman väylä muistia pinon,

419
00:23:02,000 --> 00:23:04,000
oman runko pinoon, niin sanotusti.

420
00:23:04,000 --> 00:23:08,000
Se myös allokoi 32 bittiä näistä ints.

421
00:23:08,000 --> 00:23:11,000
Se tapahtuu soittaa heille ja b, mutta se on täysin mielivaltainen.

422
00:23:11,000 --> 00:23:13,000
Se olisi voinut kutsua heitä mitä haluaa, mutta mitä tapahtuu, kun pääasiallinen

423
00:23:13,000 --> 00:23:19,000
kehottaa swap se vie tämän 1, laittaa kopio siellä laittaa kopio sinne.

424
00:23:19,000 --> 00:23:23,000
>> On 1 muu paikallinen muuttuja swap kuitenkin nimeltään mitä? >> Tmp.

425
00:23:23,000 --> 00:23:27,000
Tmp, joten annan itselleni toisen 32 bittiä täällä,

426
00:23:27,000 --> 00:23:29,000
ja mitä minä tein tämän toiminnon?

427
00:23:29,000 --> 00:23:34,000
Sanoin int tmp saa, joten on 1, joten tein tämän, kun olemme viimeksi toistettu tämän esimerkin.

428
00:23:34,000 --> 00:23:39,000
Sitten saa b, niin b on 2, joten nyt tämä tulee 2,

429
00:23:39,000 --> 00:23:42,000
ja nyt b saa lämpötila, joten lämpötila on 1,

430
00:23:42,000 --> 00:23:44,000
joten nyt B tulee tämän.

431
00:23:44,000 --> 00:23:46,000
Se on hienoa. Se toimi.

432
00:23:46,000 --> 00:23:49,000
Mutta sitten heti kun funktio palauttaa

433
00:23:49,000 --> 00:23:52,000
Vaihdetaan muistiin tehokkaasti katoaa, niin että sitä voidaan käyttää uudelleen

434
00:23:52,000 --> 00:23:58,000
jokin muu toiminto tulevaisuudessa, ja tärkein on tietenkin täysin ennallaan.

435
00:23:58,000 --> 00:24:00,000
Tarvitsemme tapa pohjimmiltaan ratkaista tämän ongelman,

436
00:24:00,000 --> 00:24:03,000
ja tänään me viimein tapa tehdä tämä, jossa

437
00:24:03,000 --> 00:24:06,000
voimme esitellä jotain kutsutaan osoittimen.

438
00:24:06,000 --> 00:24:09,000
On käynyt ilmi, että voimme ratkaista tämän ongelman

439
00:24:09,000 --> 00:24:12,000
ei ohimennen kopioita x ja y

440
00:24:12,000 --> 00:24:18,000
vaan läpäisemällä mitä, luuletko, että swap-toiminto?

441
00:24:18,000 --> 00:24:20,000
Joo, entä osoitteen?

442
00:24:20,000 --> 00:24:22,000
Emme ole puhuneet osoitteita paljon yksityiskohtia,

443
00:24:22,000 --> 00:24:25,000
mutta jos tämä liitutaulu edustaa tietokoneeni muistiin

444
00:24:25,000 --> 00:24:28,000
Voisimme varmasti aloittaa numerointi tavua minun RAM

445
00:24:28,000 --> 00:24:31,000
ja sanoa, tavu # 1, tämä on tavu # 2, tavu # 3,

446
00:24:31,000 --> 00:24:35,000
tavu # 4, tavu # ... 2000000000 jos minulla on 2 gigatavua RAM-

447
00:24:35,000 --> 00:24:38,000
jotta voisimme varmasti keksiä jokin mielivaltainen numerointi

448
00:24:38,000 --> 00:24:41,000
Kaikkien yksittäisten tavujen tietokoneen muistiin.

449
00:24:41,000 --> 00:24:43,000
>> Mitä jos sen sijaan kun soitan swap

450
00:24:43,000 --> 00:24:47,000
eikä kulkea kopiot x ja y

451
00:24:47,000 --> 00:24:51,000
miksi en vaan kulkea osoitteen x täällä,

452
00:24:51,000 --> 00:24:55,000
osoite y täällä, lähinnä postiosoite

453
00:24:55,000 --> 00:24:59,000
x ja y koska silloin vaihtaa, jos hän ilmoitti

454
00:24:59,000 --> 00:25:01,000
osoitteen muistiin x: n ja y,

455
00:25:01,000 --> 00:25:04,000
sitten vaihtaa, jos koulutettu häntä hieman,

456
00:25:04,000 --> 00:25:07,000
hän voisi mahdollisesti ajaa kyseiseen osoitteeseen, niin sanotusti,

457
00:25:07,000 --> 00:25:11,000
x, ja vaihda numero siellä sitten ajaa osoitteeseen y,

458
00:25:11,000 --> 00:25:16,000
Muuta numero siellä, vaikka ei oikeastaan ​​saada jäljennökset näistä arvoista itsensä,

459
00:25:16,000 --> 00:25:19,000
joten vaikka puhuimme tästä olevan tärkein muistia

460
00:25:19,000 --> 00:25:23,000
ja tämä on swap muistin voimakas ja vaarallinen osa C

461
00:25:23,000 --> 00:25:28,000
on se, että mikä tahansa toiminto voi koskettaa muistia missä tahansa tietokoneessa,

462
00:25:28,000 --> 00:25:32,000
ja tämä on voimakas, että voit tehdä hyvin fancy asioita tietokoneohjelmien C.

463
00:25:32,000 --> 00:25:36,000
Tämä on vaarallista, koska voit myös tyriä helposti.

464
00:25:36,000 --> 00:25:39,000
Itse asiassa yksi yleisimmistä tavoista ohjelmia nykyään voidaan hyödyntää

465
00:25:39,000 --> 00:25:42,000
vielä on ohjelmoija ei ymmärrä

466
00:25:42,000 --> 00:25:45,000
että hän sallii data

467
00:25:45,000 --> 00:25:49,000
kirjoitetaan paikkaan muistissa, joka ei ollut tarkoitettu.

468
00:25:49,000 --> 00:25:51,000
>> Esimerkiksi, hän ilmoittaa joukko koko 10

469
00:25:51,000 --> 00:25:56,000
mutta sitten vahingossa yrittää sijoittaa 11 tavua, että joukko muistia,

470
00:25:56,000 --> 00:25:59,000
ja aloitat koskettaa osia muistin jotka eivät ole enää voimassa.

471
00:25:59,000 --> 00:26:02,000
Vain asiayhteyteen tähän, jotkut teistä ehkä tietävät, että

472
00:26:02,000 --> 00:26:06,000
ohjelmiston usein kysyy sarjanumeroita tai rekisteröinti avaimet,

473
00:26:06,000 --> 00:26:08,000
Photoshop ja Word ja ohjelmat, kuten tämä.

474
00:26:08,000 --> 00:26:12,000
On olemassa halkeamia, kuten jotkut teistä tietävät, verkossa, jossa voit ajaa pieni ohjelma,

475
00:26:12,000 --> 00:26:14,000
ja voila, enää pyyntöä sarjanumero.

476
00:26:14,000 --> 00:26:16,000
Miten se toimii?

477
00:26:16,000 --> 00:26:21,000
Monissa tapauksissa nämä asiat ovat yksinkertaisesti toteamus tietokoneet

478
00:26:21,000 --> 00:26:24,000
Tekstin segmentit tietokoneen todellinen nollia ja ykkösiä

479
00:26:24,000 --> 00:26:28,000
missä on se toiminto, jossa sarjanumero pyydetään,

480
00:26:28,000 --> 00:26:31,000
ja te korvata tähän tilaan, tai kun ohjelma on käynnissä

481
00:26:31,000 --> 00:26:33,000
voit selvittää missä avain on tosiasiallisesti varastoitu

482
00:26:33,000 --> 00:26:37,000
käyttämällä jotain kutsutaan debuggeri, ja voit crack-ohjelmiston tavoin.

483
00:26:37,000 --> 00:26:40,000
Tämä ei tarkoita sitä, että tämä on meidän tavoite lähipäivinä,

484
00:26:40,000 --> 00:26:42,000
mutta se on hyvin reaalimaailman seurauksia.

485
00:26:42,000 --> 00:26:45,000
Tämä sattuu ottamaan varkaus ohjelmisto,

486
00:26:45,000 --> 00:26:47,000
mutta siellä on myös kompromissi koko koneita.

487
00:26:47,000 --> 00:26:50,000
>> Itse asiassa, kun sivustot näinä päivinä hyödynnetään

488
00:26:50,000 --> 00:26:53,000
ja heikentynyt ja tietojen on vuotanut ja salasanoja on varastettu

489
00:26:53,000 --> 00:26:58,000
Tämän hyvin usein liittyy huono hallinta oman muistin

490
00:26:58,000 --> 00:27:01,000
tai, jos kyseessä on tietokantoja, ettei ennakoida

491
00:27:01,000 --> 00:27:03,000
kontradiktorista tulo, niin lisää, että tulevina viikkoina,

492
00:27:03,000 --> 00:27:07,000
mutta nyt vain esimakua sellainen vahinko, että voit tehdä

493
00:27:07,000 --> 00:27:11,000
se ei aivan ymmärtää miten asiat toimivat alla huppu.

494
00:27:11,000 --> 00:27:14,000
Mennään siitä ymmärtää, miksi tämä on rikki

495
00:27:14,000 --> 00:27:17,000
työkalulla, joka tulee enemmän ja enemmän hyötyä

496
00:27:17,000 --> 00:27:19,000
koska ohjelmamme saavat monimutkaisempi.

497
00:27:19,000 --> 00:27:21,000
Toistaiseksi kun olet ollut bugi ohjelma

498
00:27:21,000 --> 00:27:23,000
miten olet mennyt noin debuggaamista?

499
00:27:23,000 --> 00:27:25,000
Mitkä ovat sinun tekniikoita olleet tähän mennessä, joko opettanut teidän TF

500
00:27:25,000 --> 00:27:27,000
tai vain itseoppinut?

501
00:27:27,000 --> 00:27:29,000
[Student] printf.

502
00:27:29,000 --> 00:27:31,000
Printf, joten printf on luultavasti ollut ystäväsi, että jos haluat nähdä

503
00:27:31,000 --> 00:27:33,000
mitä tapahtuu sisällä ohjelman

504
00:27:33,000 --> 00:27:36,000
vain laittaa printf tänne, printf täällä, printf täällä.

505
00:27:36,000 --> 00:27:38,000
Sitten voit käyttää sitä, ja saat koko joukko tavaraa ruudulla

506
00:27:38,000 --> 00:27:43,000
että voit sitten päätellä, mitä todella vialla ohjelman.

507
00:27:43,000 --> 00:27:45,000
>> Printf taipumus olla hyvin voimakas asia,

508
00:27:45,000 --> 00:27:47,000
mutta se on hyvin manuaalinen prosessi.

509
00:27:47,000 --> 00:27:49,000
Sinun täytyy laittaa printf täällä, printf täällä,

510
00:27:49,000 --> 00:27:51,000
ja jos laitat sen sisällä silmukan saatat saada 100 riviä

511
00:27:51,000 --> 00:27:53,000
tuotannon että sinulla on sitten käydä läpi.

512
00:27:53,000 --> 00:27:58,000
Se ei ole kovin käyttäjäystävällinen tai vuorovaikutteinen mekanismi Ohjelmointivirheiden,

513
00:27:58,000 --> 00:28:00,000
mutta onneksi on olemassa vaihtoehtoja.

514
00:28:00,000 --> 00:28:03,000
Siellä on ohjelma, esimerkiksi, nimeltään GDB, GNU Debugger,

515
00:28:03,000 --> 00:28:06,000
joka on hieman mystistä, miten käytät sitä.

516
00:28:06,000 --> 00:28:08,000
Se on vähän monimutkaista, mutta suoraan sanottuna,

517
00:28:08,000 --> 00:28:11,000
Tämä on yksi niistä asioista, joissa jos laitat tällä ja ensi viikolla

518
00:28:11,000 --> 00:28:14,000
ylimääräinen tunti ymmärtää jotain GDB

519
00:28:14,000 --> 00:28:18,000
se säästää luultavasti kymmeniä tunteja pitkällä aikavälillä,

520
00:28:18,000 --> 00:28:21,000
Niin, että, minä annan sinulle teaser, miten tämä asia toimii.

521
00:28:21,000 --> 00:28:23,000
>> Olen minun pääteikkunassa.

522
00:28:23,000 --> 00:28:26,000
Anna minun mennä eteenpäin ja kääntää tämän ohjelman buggy3.

523
00:28:26,000 --> 00:28:28,000
Se on jo ajan tasalla.

524
00:28:28,000 --> 00:28:31,000
Saanen käyttää sitä aivan kuten teimme taas takaisin, ja todellakin, se on rikki.

525
00:28:31,000 --> 00:28:34,000
Mutta miksi tämä on? Ehkä mokasin swap-toiminto.

526
00:28:34,000 --> 00:28:37,000
Ehkä se on ja b. En ole aivan siirtämällä niitä oikein.

527
00:28:37,000 --> 00:28:39,000
Anna minun mennä eteenpäin ja tehdä tätä.

528
00:28:39,000 --> 00:28:43,000
Sen sijaan vain ajaa buggy3 anna minun sijasta suorittaa tämän ohjelman GDB,

529
00:28:43,000 --> 00:28:48,000
ja aion kertoa sen toimimaan buggy3,

530
00:28:48,000 --> 00:28:52,000
ja aion sisällyttää komentorivin argumentti,-TUI-

531
00:28:52,000 --> 00:28:55,000
ja laitamme tätä tulevaisuudessa ongelmat spec muistuttaa.

532
00:28:55,000 --> 00:28:57,000
Ja nyt tämä mustavalkoinen käyttöliittymä piipahti jopa, että jälleen kerran,

533
00:28:57,000 --> 00:28:59,000
on hieman ylivoimainen aluksi, koska siellä on kaikkea tätä

534
00:28:59,000 --> 00:29:02,000
takuutietoja tänne, mutta ainakin siellä on jotain tuttua.

535
00:29:02,000 --> 00:29:04,000
Vuonna ikkunan yläosassa on minun todellista koodia

536
00:29:04,000 --> 00:29:08,000
ja jos minä siirry tänne haluan siirtyä hyvin alkuun minun tiedoston,

537
00:29:08,000 --> 00:29:11,000
ja todellakin, siellä buggy3.c, ja ilmoitus alareunassa tämän ikkunan

538
00:29:11,000 --> 00:29:13,000
Minulla on tämä GDB nopeasti.

539
00:29:13,000 --> 00:29:16,000
>> Tämä ei ole sama kuin minun normaali John Harvardin nopeasti.

540
00:29:16,000 --> 00:29:19,000
Tämä on nopea että menee saanen ohjata GDB.

541
00:29:19,000 --> 00:29:21,000
GDB on debuggeri.

542
00:29:21,000 --> 00:29:24,000
Debuggeri on ohjelma, jonka avulla voit kävellä läpi

543
00:29:24,000 --> 00:29:27,000
toteuttaminen ohjelmasi rivi rivi riviltä,

544
00:29:27,000 --> 00:29:30,000
matkan varrella tehdä mitä haluat ohjelman

545
00:29:30,000 --> 00:29:33,000
jopa soittaa toimintoja tai etsivät vielä tärkeämpää,

546
00:29:33,000 --> 00:29:35,000
eri muuttujan arvoja.

547
00:29:35,000 --> 00:29:37,000
Mennään eteenpäin ja tehdä tämän.

548
00:29:37,000 --> 00:29:40,000
Aion mennä eteenpäin ja kirjoita run GDB: n kehotteeseen

549
00:29:40,000 --> 00:29:43,000
niin huomaa alareunassa näytön vasemmassa olen kirjoittanut juosta,

550
00:29:43,000 --> 00:29:45,000
ja olen Enter, ja mitä se tekee?

551
00:29:45,000 --> 00:29:50,000
Se kirjaimellisesti juoksi minun ohjelma, mutta en oikeastaan ​​näe paljon mennä tänne

552
00:29:50,000 --> 00:29:55,000
koska en ole oikeastaan ​​kertonut debuggeri

553
00:29:55,000 --> 00:29:57,000
keskeyttää tietyllä hetkellä.

554
00:29:57,000 --> 00:29:59,000
Kirjoittamalla run käynnistää ohjelman.

555
00:29:59,000 --> 00:30:01,000
En oikeastaan ​​näe mitään. En voi manipuloida sitä.

556
00:30:01,000 --> 00:30:03,000
>> Sen sijaan haluan tehdä tämän.

557
00:30:03,000 --> 00:30:08,000
Tällä GDB kehotteeseen haluan vaan kirjoittaa tauko, kirjoita.

558
00:30:08,000 --> 00:30:10,000
Se ei ole mitä aioin kirjoittaa.

559
00:30:10,000 --> 00:30:13,000
Mennään vaan kirjoita tauko tärkein.

560
00:30:13,000 --> 00:30:15,000
Toisin sanoen, en halua asettaa jotain kutsutaan keskeytyskohdan,

561
00:30:15,000 --> 00:30:18,000
joka on osuvasti nimetty, koska se rikkoo tai keskeyttää

562
00:30:18,000 --> 00:30:21,000
toteuttaminen ohjelman tuohon tiettyyn paikkaan.

563
00:30:21,000 --> 00:30:23,000
Tärkein on nimi minun tehtävä.

564
00:30:23,000 --> 00:30:25,000
Huomaa, että GDB on aika fiksu.

565
00:30:25,000 --> 00:30:28,000
Se tajunnut että tärkeimmät sattuu aloittaa noin rivillä 18

566
00:30:28,000 --> 00:30:32,000
sekä buggy3.c, ja sitten huomaa täällä ylhäällä vasemmalla

567
00:30:32,000 --> 00:30:34,000
b + on aivan linjan 18.

568
00:30:34,000 --> 00:30:38,000
Se on muistuttaa minua siitä, että olen asettanut keskeytyskohdan linjan 18.

569
00:30:38,000 --> 00:30:42,000
Tällä kertaa kun kirjoitan aikavälillä, aion ajaa minun ohjelma

570
00:30:42,000 --> 00:30:45,000
kunnes se osuu että murtuessa,

571
00:30:45,000 --> 00:30:48,000
niin ohjelma pysähtyy minulle rivillä 18.

572
00:30:48,000 --> 00:30:50,000
Täällä mennään, juosta.

573
00:30:50,000 --> 00:30:53,000
Mikään ei näytä tapahtuneen, mutta ilmoituksen alareunassa jäljellä

574
00:30:53,000 --> 00:30:58,000
alkaen ohjelma, buggy3, keskeytyskohta 1 Tärkeimpien klo buggy3.c linjan 18.

575
00:30:58,000 --> 00:31:00,000
Mitä voin tehdä nyt?

576
00:31:00,000 --> 00:31:03,000
>> Ilmoitus voin alkaa kirjoittaa asioita, kuten tulostus,

577
00:31:03,000 --> 00:31:08,000
ei printf, print x, ja nyt se on outoa.

578
00:31:08,000 --> 00:31:11,000
$ 1 on vain uteliaisuus, kuten näemme

579
00:31:11,000 --> 00:31:14,000
joka kerta, kun painan jotain saat uuden $ arvo.

580
00:31:14,000 --> 00:31:18,000
Se on niin, että voit palata edelliseen arvoja vain siinä tapauksessa,

581
00:31:18,000 --> 00:31:21,000
mutta nyt mitä tulosta kertoo minulle, että arvo x tässä vaiheessa tarina

582
00:31:21,000 --> 00:31:26,000
on ilmeisesti 134514032.

583
00:31:26,000 --> 00:31:29,000
Mitä? Mistä tuo edes tulevat?

584
00:31:29,000 --> 00:31:31,000
[Äänetön-opiskelija]

585
00:31:31,000 --> 00:31:34,000
Itse asiassa tämä on mitä me kutsumme roskat arvo, ja olemme ole puhunut tästä vielä,

586
00:31:34,000 --> 00:31:37,000
mutta syy, että olet alustaa muuttujat

587
00:31:37,000 --> 00:31:40,000
On ilmeisesti niin, että heillä on jonkinlaista arvoa, että haluat heidän olla.

588
00:31:40,000 --> 00:31:44,000
Mutta saalis on muistaa, että voit julistaa muuttujia

589
00:31:44,000 --> 00:31:46,000
kuten tein hetki sitten minun sigma esimerkissä

590
00:31:46,000 --> 00:31:48,000
ilman todella heille arvoa.

591
00:31:48,000 --> 00:31:50,000
Recall mitä tein täällä Sigma.

592
00:31:50,000 --> 00:31:52,000
Olen ilmoittanut n, mutta mikä arvo annoin sen?

593
00:31:52,000 --> 00:31:56,000
Ei ole, koska tiesin, että muutaman seuraavan linjat

594
00:31:56,000 --> 00:31:59,000
GetInt hoitaisi ongelman laittamalla arvon sisällä n..

595
00:31:59,000 --> 00:32:02,000
>> Mutta tässä vaiheessa tarina linjan 11

596
00:32:02,000 --> 00:32:05,000
ja linja 12 ja linja 13 sekä linja 14

597
00:32:05,000 --> 00:32:08,000
kauttaaltaan näiden useita rivejä, mikä on n: n arvo?

598
00:32:08,000 --> 00:32:10,000
C et vain tiedä.

599
00:32:10,000 --> 00:32:14,000
Se on yleensä joitakin roskat arvo, jotkut täysin satunnaisluku

600
00:32:14,000 --> 00:32:17,000
on jäljellä yli lähinnä joidenkin aiempien toiminto

601
00:32:17,000 --> 00:32:21,000
jotka on ajaa, niin ohjelma toimii

602
00:32:21,000 --> 00:32:24,000
Muistutan, että funktio saa funktio, toiminto, funktio.

603
00:32:24,000 --> 00:32:27,000
Kaikki nämä kehykset saada laittaa muistiin, ja sitten ne toiminnot paluuta,

604
00:32:27,000 --> 00:32:31,000
ja aivan kuten ehdotin kanssa pyyhekumia niiden muisti on lopulta uudelleen.

605
00:32:31,000 --> 00:32:37,000
No, se vain on niin, että tämä muuttuja x tähän ohjelmaan

606
00:32:37,000 --> 00:32:41,000
näyttää sisälsi joitakin roskaa arvo kuin 134514032

607
00:32:41,000 --> 00:32:44,000
Joidenkin edelliseen toimintoon, ei yksi, että olen kirjoittanut.

608
00:32:44,000 --> 00:32:47,000
Se voisi olla jotain, joka tulee tehokkaasti käyttöjärjestelmä,

609
00:32:47,000 --> 00:32:49,000
jokin funktio alla huppu.

610
00:32:49,000 --> 00:32:52,000
>> Okei, se on hienoa, mutta katsotaanpa nyt edetä seuraavalle riville.

611
00:32:52,000 --> 00:32:55,000
Jos kirjoitan "seuraava" minun GDB nopeaa ja osuin enter

612
00:32:55,000 --> 00:32:58,000
huomaa, että korostus siirtyy alas linja 19,

613
00:32:58,000 --> 00:33:01,000
mutta looginen seuraus on, että linja 18

614
00:33:01,000 --> 00:33:06,000
on nyt päättynyt täytäntöönpanovaltiossa, joten jos en kerran kirjoitat "print x"

615
00:33:06,000 --> 00:33:10,000
Minun pitäisi nyt nähdä 1, ja todellakin, en.

616
00:33:10,000 --> 00:33:14,000
Jälleen $ tavaraa on tapa GDB muistuttaa sinua

617
00:33:14,000 --> 00:33:17,000
mitä historia tulosteita ovat, että olet tehnyt.

618
00:33:17,000 --> 00:33:21,000
Nyt haluan mennä eteenpäin ja tulostaa y ja todellakin, y on joitakin hulluja arvo samoin,

619
00:33:21,000 --> 00:33:24,000
mutta no big deal, koska budjettikohtaan 19 aiomme antaa sen

620
00:33:24,000 --> 00:33:27,000
arvo 2, joten haluan kirjoittaa "Seuraava" uudelleen.

621
00:33:27,000 --> 00:33:29,000
Ja nyt me olemme printf rivillä.

622
00:33:29,000 --> 00:33:31,000
Anna minun tehdä tulosta x.

623
00:33:31,000 --> 00:33:34,000
Anna minun tehdä tulosta y. Rehellisesti, Saan hieman kyllästynyt tulostaa tästä.

624
00:33:34,000 --> 00:33:38,000
Saanen sen sijaan kirjoittaa "näyttö x" ja "näyttö Y"

625
00:33:38,000 --> 00:33:41,000
ja nyt joka kerta kun kirjoitat komennon tulevaisuudessa

626
00:33:41,000 --> 00:33:45,000
Aion muistutetaan mitä x ja y, mitä x ja y, mitä x ja y.

627
00:33:45,000 --> 00:33:48,000
>> Voin myös sivuhuomautuksena, kirjoita "info paikallisia."

628
00:33:48,000 --> 00:33:50,000
Info on erityinen komento.

629
00:33:50,000 --> 00:33:52,000
Paikalliset tarkoittaa se näyttää minulle paikallisia muuttujia.

630
00:33:52,000 --> 00:33:55,000
Vain jos unohdan tai tämä on hullu, monimutkainen toiminto

631
00:33:55,000 --> 00:33:57,000
että minä tai joku muu kirjoitti info paikalliset kertovat

632
00:33:57,000 --> 00:34:00,000
mitkä ovat kaikki paikalliset muuttujat sisälle paikalliseen toiminto

633
00:34:00,000 --> 00:34:03,000
että saatat välität jos haluat penkoa.

634
00:34:03,000 --> 00:34:07,000
Nyt printf on aikeissa toteuttaa, joten anna minun mennä eteenpäin ja kirjoita "Seuraava".

635
00:34:07,000 --> 00:34:10,000
Koska olemme tässä ympäristössä emme oikeastaan ​​näe sitä

636
00:34:10,000 --> 00:34:14,000
suorittaa täällä, mutta huomaa se alkaa hieman sekavaa täällä.

637
00:34:14,000 --> 00:34:17,000
Mutta huomaa se ohittaa ruudun siellä,

638
00:34:17,000 --> 00:34:21,000
joten se ei ole täydellinen ohjelma täällä, mutta se on okei, koska en voi aina penkoa

639
00:34:21,000 --> 00:34:23,000
tulostusmateriaalien jos haluan.

640
00:34:23,000 --> 00:34:26,000
>> Saanen kirjoittaa ensi kerran, ja nyt täällä on mielenkiintoinen osa.

641
00:34:26,000 --> 00:34:29,000
Tässä vaiheessa tarina y on 2, ja x on 1,

642
00:34:29,000 --> 00:34:32,000
ehdottivat täällä, ja taas,

643
00:34:32,000 --> 00:34:35,000
Syy tähän on automaattisesti näyttää nyt, koska käytin komento

644
00:34:35,000 --> 00:34:40,000
näyttö x ja näytön y, joten tällä hetkellä en kirjoita seuraava

645
00:34:40,000 --> 00:34:43,000
teoriassa x ja y tulisi vaihtaa.

646
00:34:43,000 --> 00:34:45,000
Nyt tiedämme jo, että ei aio olla,

647
00:34:45,000 --> 00:34:49,000
mutta näemme hetken miten voimme sukeltaa syvemmälle selvittää, miksi se on totta.

648
00:34:49,000 --> 00:34:54,000
Seuraavaksi, ja valitettavasti, y on edelleen 2 ja x on edelleen 1, ja voin vahvistaa niin paljon.

649
00:34:54,000 --> 00:34:56,000
Tulosta x, tulostaa y.

650
00:34:56,000 --> 00:34:59,000
Itse asiassa ei vaihtamalla on todella tapahtunut, joten aloitetaan tämän yli.

651
00:34:59,000 --> 00:35:01,000
Selvästi swap on rikki.

652
00:35:01,000 --> 00:35:04,000
Mennään vaan kirjoita "run" uudelleen.

653
00:35:04,000 --> 00:35:07,000
Sanon kyllä, haluan käynnistää sen alusta, kirjoita.

654
00:35:07,000 --> 00:35:09,000
>> Nyt olen takaisin ylös rivillä 18.

655
00:35:09,000 --> 00:35:11,000
Nyt huomaa x ja y ovat roskaa arvot uudelleen.

656
00:35:11,000 --> 00:35:15,000
Seuraavaksi, seuraavaksi, seuraavaksi, seuraavaksi.

657
00:35:15,000 --> 00:35:17,000
Jos minä kyllästy voin myös kirjoittaa n. ensi.

658
00:35:17,000 --> 00:35:21,000
Voit lyhentää sen lyhin mahdollinen merkkijono.

659
00:35:21,000 --> 00:35:23,000
Swap on nyt rikki.

660
00:35:23,000 --> 00:35:25,000
Mennään sukellus, joten kirjoittamisen sijaan ensi-

661
00:35:25,000 --> 00:35:30,000
nyt aion kirjoittaa askel niin että olen tehostaminen sisällä tätä toimintoa

662
00:35:30,000 --> 00:35:33,000
niin että voin kävellä sen läpi, joten osuin askeleen ja kirjoita.

663
00:35:33,000 --> 00:35:37,000
Huomaa, että esiin hyppää alas alempi minun ohjelma linjaa 36.

664
00:35:37,000 --> 00:35:39,000
Nyt mitä paikallisia muuttujia?

665
00:35:39,000 --> 00:35:41,000
Info paikalliset.

666
00:35:41,000 --> 00:35:43,000
Mikään aivan vielä, koska olemme ei mennyt että linja,

667
00:35:43,000 --> 00:35:47,000
joten mennään eteenpäin ja sanoa "seuraava".

668
00:35:47,000 --> 00:35:50,000
Nyt näyttää olevan tmp, tulostaa tmp.

669
00:35:50,000 --> 00:35:52,000
Garbage arvo, eikö? Luulen niin.

670
00:35:52,000 --> 00:35:55,000
Miten tulostaa, tulostaa b, 1 ja 2?

671
00:35:55,000 --> 00:35:58,000
Hetken kun kirjoitan ensi kerran

672
00:35:58,000 --> 00:36:02,000
tmp vie on arvo 1, toivottavasti

673
00:36:02,000 --> 00:36:05,000
koska tmp aiotaan saama arvo.

674
00:36:05,000 --> 00:36:08,000
>> Nyt ei tulostu, tulosta b,

675
00:36:08,000 --> 00:36:11,000
mutta nyt tulostaa tmp, ja se on todellakin 1.

676
00:36:11,000 --> 00:36:14,000
Anna minun tehdä seuraavaksi. Anna minun tehdä seuraavaksi.

677
00:36:14,000 --> 00:36:16,000
Olen valmis swap-toiminto.

678
00:36:16,000 --> 00:36:19,000
Olen silti sisällä sen linjan 40, joten haluan tulostaa,

679
00:36:19,000 --> 00:36:22,000
Print b, enkä välitä mitä tmp on.

680
00:36:22,000 --> 00:36:27,000
Se näyttää swap on oikea, kun se tulee vaihtava ja b.

681
00:36:27,000 --> 00:36:31,000
Mutta jos minä nyt kirjoittaa seuraavaksi, hyppään takaisin linja 25,

682
00:36:31,000 --> 00:36:34,000
ja tietysti, jos en kirjoita x ja tulostaa y

683
00:36:34,000 --> 00:36:38,000
he silti ennallaan, joten emme ole korjannut ongelman.

684
00:36:38,000 --> 00:36:41,000
Mutta diagnostisesti nyt ehkä tähän GDB ohjelmaan

685
00:36:41,000 --> 00:36:44,000
olemme ainakin saaneet askeleen lähempänä ymmärrystä

686
00:36:44,000 --> 00:36:47,000
Mikä vialla ilman pentueen meidän koodia laittamalla printf täällä,

687
00:36:47,000 --> 00:36:50,000
printf täällä, printf täällä ja sitten käynnissä sen uudestaan ​​ja uudestaan

688
00:36:50,000 --> 00:36:52,000
yrittää selvittää, mitä tapahtuu pieleen.

689
00:36:52,000 --> 00:36:55,000
>> Aion mennä eteenpäin ja lopettaa pois tästä kokonaan pois sulkea.

690
00:36:55,000 --> 00:36:57,000
Se tulee sitten sanoa, "Lopeta kummiskin?" Kyllä.

691
00:36:57,000 --> 00:37:00,000
Nyt olen takaisin minun normaali nopeaa, ja olen tehnyt käyttäen GDB.

692
00:37:00,000 --> 00:37:03,000
Sivuhuomautuksena, sinun ei tarvitse käyttää tätä-TUI lippua.

693
00:37:03,000 --> 00:37:07,000
Itse asiassa, jos jätät sen saat lähinnä alaosassa näytön.

694
00:37:07,000 --> 00:37:11,000
Jos minä kirjoita taukoa tärkein ja suorita sitten

695
00:37:11,000 --> 00:37:15,000
Voin silti ajaa minun ohjelma, mutta mitä se tekee on enemmän sanallisesti

696
00:37:15,000 --> 00:37:18,000
vain näytä olevan rivin kerrallaan.

697
00:37:18,000 --> 00:37:21,000
-TUI, tekstuaalisen käyttöliittymä,

698
00:37:21,000 --> 00:37:25,000
vain näyttää enemmän ohjelman kerralla, mikä on todennäköisesti hieman käsitteellisesti helpompaa.

699
00:37:25,000 --> 00:37:27,000
Mutta todellakin, voin vain tehdä seuraavaksi, seuraavaksi, seuraavaksi,

700
00:37:27,000 --> 00:37:30,000
ja aion nähdä yksi rivi kerrallaan, ja jos haluan todella nähdä mitä tapahtuu

701
00:37:30,000 --> 00:37:35,000
Voin kirjoittaa listan ja nähdä koko joukko naapurimaiden linjat.

702
00:37:35,000 --> 00:37:39,000
>> On video, että olemme pyytäneet, että te katsella ongelma asettaa 3

703
00:37:39,000 --> 00:37:43,000
jossa Nate kattaa joitakin koukerot GDB,

704
00:37:43,000 --> 00:37:46,000
ja tämä on yksi niistä asioista, rehellisesti, jos joitakin ei-triviaaleja osuus sinua

705
00:37:46,000 --> 00:37:49,000
koskaan kosketa GDB, ja se tulee olemaan huono asia

706
00:37:49,000 --> 00:37:53,000
koska kirjaimellisesti voit päätyä menoja enemmän aikaa myöhemmin tänä lukukautena

707
00:37:53,000 --> 00:37:56,000
jahtaavat alas bugeja niin voisitte jos laitat että puoli tuntia / tunti

708
00:37:56,000 --> 00:38:00,000
tällä ja ensi viikolla oppimisen totutella GDB.

709
00:38:00,000 --> 00:38:02,000
Printf oli ystäväsi.

710
00:38:02,000 --> 00:38:05,000
GDB pitäisi nyt olla ystäväsi.

711
00:38:05,000 --> 00:38:08,000
>> Kysyttävää GDB?

712
00:38:08,000 --> 00:38:12,000
Ja tässä on nopea lista joistakin tehokkain ja hyödyllisiä komentoja.

713
00:38:12,000 --> 00:38:15,000
Joo. >> Voitko tulostaa merkkijonon?

714
00:38:15,000 --> 00:38:17,000
Voitko tulostaa merkkijonon? Ehdottomasti.

715
00:38:17,000 --> 00:38:19,000
Se ei tarvitse vain olla kokonaislukuja.

716
00:38:19,000 --> 00:38:22,000
Jos muuttuja s on merkkijono kirjoita vain tulostaa s.

717
00:38:22,000 --> 00:38:24,000
Se näyttää, mitä se merkkijono muuttuja on.

718
00:38:24,000 --> 00:38:26,000
[Äänetön-opiskelija]

719
00:38:26,000 --> 00:38:28,000
Se antaa sinulle osoitteen ja merkkijono itse.

720
00:38:28,000 --> 00:38:32,000
Se näyttää teille molemmille.

721
00:38:32,000 --> 00:38:34,000
Ja viimeinen asia, vain koska ne ovat hyvä tietää liikaa.

722
00:38:34,000 --> 00:38:37,000
Backtrace ja runko, haluan sukeltaa tämän viimeisen kerran,

723
00:38:37,000 --> 00:38:39,000
täsmälleen sama ohjelma GDB.

724
00:38:39,000 --> 00:38:44,000
Anna minun mennä eteenpäin ja ajaa tekstuaalinen käyttöliittymän versio,

725
00:38:44,000 --> 00:38:46,000
rikkoa tärkein.

726
00:38:46,000 --> 00:38:49,000
Anna minun mennä eteenpäin ja ajaa uudestaan. Tässä olen.

727
00:38:49,000 --> 00:38:55,000
Nyt haluaisin mennä seuraavaksi, seuraavaksi, seuraavaksi, seuraavaksi, seuraavaksi, askel, kirjoita.

728
00:38:55,000 --> 00:39:00,000
>> Ja nyt kai olen nyt swap tarkoituksella, mutta minä olen kuin "Hitto, mikä oli arvo x?"

729
00:39:00,000 --> 00:39:02,000
En voi tehdä x enää.

730
00:39:02,000 --> 00:39:05,000
En voi tehdä y koska he eivät laajuudeltaan.

731
00:39:05,000 --> 00:39:07,000
He eivät yhteydessä, mutta ei ole ongelma.

732
00:39:07,000 --> 00:39:09,000
Voin kirjoittaa backtrace.

733
00:39:09,000 --> 00:39:13,000
Se näyttää minulle kaikki toiminnot, jotka ovat toteuttaneet jopa tässä vaiheessa.

734
00:39:13,000 --> 00:39:16,000
Huomaa, että yksi pohjassa, pääasiassa linjojen kanssa tärkeimpien

735
00:39:16,000 --> 00:39:18,000
ollessa pohjassa meidän kuva täällä.

736
00:39:18,000 --> 00:39:22,000
Se, että swap on sen yläpuolella linjojen kanssa swap on sen yläpuolella muistiin tänne,

737
00:39:22,000 --> 00:39:26,000
ja jos haluan päästä takaisin päävalikkoon tilapäisesti voin sanoa "runko".

738
00:39:26,000 --> 00:39:30,000
Mikä numero? Tärkein on kehyksen # 1.

739
00:39:30,000 --> 00:39:32,000
Aion mennä eteenpäin ja sanoa "runko 1."

740
00:39:32,000 --> 00:39:36,000
>> Nyt olen takaisin tärkein, ja voin tulostaa x, ja voin tulostaa y,

741
00:39:36,000 --> 00:39:40,000
mutta en voi tulostaa tai b.

742
00:39:40,000 --> 00:39:43,000
Mutta voin jos sanon, "Okei, odota hetki. Missä oli swap?"

743
00:39:43,000 --> 00:39:46,000
Anna minun mennä eteenpäin ja sanoa "frame 0".

744
00:39:46,000 --> 00:39:48,000
Nyt olen takaisin minne haluan olla, ja sivuun,

745
00:39:48,000 --> 00:39:52,000
olemassa muita komentoja minäkin jos olet todella saada kyllästynyt kirjoittamalla seuraava, seuraava, seuraava, seuraava,

746
00:39:52,000 --> 00:39:56,000
voit yleensä sanoa asioita, kuten "seuraava 10" ja joka selata seuraavan 10 riviä.

747
00:39:56,000 --> 00:39:59,000
Voit myös kirjoittaa "jatka", kun todella kyllästyä tehostamalla sen läpi.

748
00:39:59,000 --> 00:40:05,000
Jatka ajaa ohjelman keskeytyksettä, kunnes se osuu toiseen murtuessa,

749
00:40:05,000 --> 00:40:07,000
onko silmukka tai laske alas teidän ohjelmassa.

750
00:40:07,000 --> 00:40:11,000
>> Tässä tapauksessa jatkoimme loppuun, ja ohjelma poistui normaalisti.

751
00:40:11,000 --> 00:40:13,000
Tämä on hieno tapa, huonompi prosessi.

752
00:40:13,000 --> 00:40:16,000
Vain ohjelman lähtenyt normaalisti.

753
00:40:16,000 --> 00:40:24,000
Lisää, että video ja virheenkorjaus istunnoissa tulla.

754
00:40:24,000 --> 00:40:26,000
Se oli paljon.

755
00:40:26,000 --> 00:40:35,000
Otetaan meidän 5 minuutin tauko täällä, ja me palata tietueet ja tiedostot.

756
00:40:35,000 --> 00:40:38,000
>> Jos olet sukeltanut tämän viikon PSET jo

757
00:40:38,000 --> 00:40:41,000
tiedät että käytämme jakelu koodin,

758
00:40:41,000 --> 00:40:45,000
lähdekoodi, että voimme tarjota sinulle lähtökohta, joitakin uusia tekniikoita.

759
00:40:45,000 --> 00:40:50,000
Erityisesti toimme uuden avainsanan nimeltään struct, rakenteelle,

760
00:40:50,000 --> 00:40:53,000
jotta voimme luoda mukautettuja muuttujia tapaisena.

761
00:40:53,000 --> 00:40:57,000
Olemme myös käyttöön käsite tiedoston I / O, tiedosto tulo ja lähtö,

762
00:40:57,000 --> 00:41:00,000
ja tämä on niin, että voimme pelastaa tilan

763
00:41:00,000 --> 00:41:03,000
oman Scramble aluksella tiedoston levylle

764
00:41:03,000 --> 00:41:06,000
niin että opetus kaverit ja voin ymmärtää

765
00:41:06,000 --> 00:41:09,000
mitä tapahtuu sisällä ohjelman ilman käsin pelata

766
00:41:09,000 --> 00:41:11,000
kymmeniä pelejä Scramble.

767
00:41:11,000 --> 00:41:13,000
Voimme tehdä tämän enemmän automatedly.

768
00:41:13,000 --> 00:41:18,000
>> Tämä ajatus struct ratkaisee melko vakuuttava ongelma.

769
00:41:18,000 --> 00:41:21,000
Oletetaan, että haluamme toteuttaa joitakin ohjelmaan

770
00:41:21,000 --> 00:41:25,000
että jotenkin pitää kirjaa tietoa opiskelijoiden,

771
00:41:25,000 --> 00:41:28,000
ja opiskelijoiden voi olla, esimerkiksi, ID, nimi

772
00:41:28,000 --> 00:41:31,000
ja talo paikassa kuten Harvard, joten nämä ovat 3 paloja tiedot

773
00:41:31,000 --> 00:41:34,000
haluamme pitää sen, niin haluan mennä eteenpäin ja alkaa kirjoittaa pieni ohjelma täällä,

774
00:41:34,000 --> 00:41:38,000
kuuluu stdio.h.

775
00:41:38,000 --> 00:41:42,000
Anna minun tehdä sisältyy cs50.h.

776
00:41:42,000 --> 00:41:44,000
Ja sitten alkaa minun tärkein tehtävä.

777
00:41:44,000 --> 00:41:46,000
En viitsi mitään komentoriviargumentteja,

778
00:41:46,000 --> 00:41:49,000
ja tässä haluan olla opiskelija, joten aion sanoa

779
00:41:49,000 --> 00:41:54,000
Opiskelijan on nimi, joten aion sanoa "merkkijonon nimi."

780
00:41:54,000 --> 00:41:59,000
Sitten aion sanoa Opiskelijalla on tunnus, joten int id,

781
00:41:59,000 --> 00:42:03,000
ja opiskelija on talossa, joten olen myös menossa sanoa "merkkijono talo."

782
00:42:03,000 --> 00:42:06,000
Sitten minä tilata hieman puhtaammin kuin tämä.

783
00:42:06,000 --> 00:42:11,000
Okei, nyt minulla on 3 muuttujien joka edustaa opiskelija, joten "opiskelija".

784
00:42:11,000 --> 00:42:15,000
>> Ja nyt haluan asuttamaan näitä arvoja, joten anna minun mennä eteenpäin ja sanoa jotain

785
00:42:15,000 --> 00:42:18,000
"Id = 123".

786
00:42:18,000 --> 00:42:21,000
Nimi on menossa David.

787
00:42:21,000 --> 00:42:24,000
Sanotaan talo menossa Mather,

788
00:42:24,000 --> 00:42:31,000
ja sitten aion tehdä jotain mielivaltaisesti kuten printf ("% s,

789
00:42:31,000 --> 00:42:37,000
jonka tunnus on% d, asuu% s.

790
00:42:37,000 --> 00:42:41,000
Ja nyt, mitä haluan kytkeä täällä, yksi toisensa jälkeen?

791
00:42:41,000 --> 00:42:47,000
Nimi, id, house, return 0.

792
00:42:47,000 --> 00:42:50,000
Okei, ellei Mokasin jossain täällä

793
00:42:50,000 --> 00:42:54,000
Mielestäni meillä on aika hyvä ohjelma, joka tallentaa yksi opiskelija.

794
00:42:54,000 --> 00:42:57,000
Tietenkin, tämä ei ole kovin kiinnostava. Mitä jos haluan olla 2 opiskelijaa?

795
00:42:57,000 --> 00:42:59,000
Se ei ole iso juttu. Voin tukea 2 henkilöä.

796
00:42:59,000 --> 00:43:03,000
Anna minun mennä eteenpäin ja korostaa tätä ja mennä tänne,

797
00:43:03,000 --> 00:43:09,000
ja voin sanoa "id = 456" kaltaiselleni Rob asuva Kirkland.

798
00:43:09,000 --> 00:43:12,000
>> Okei, odota, mutta en voi kutsua näitä sama asia,

799
00:43:12,000 --> 00:43:15,000
ja se näyttää aion pitää kopioida tämän,

800
00:43:15,000 --> 00:43:19,000
niin haluaisin sanoa, että nämä ovat Daavidin muuttujia,

801
00:43:19,000 --> 00:43:23,000
ja haluaisin saada kopioita näistä Rob.

802
00:43:23,000 --> 00:43:27,000
Me kutsumme näitä Rob, mutta tämä ei tule toimimaan nyt

803
00:43:27,000 --> 00:43:33,000
koska olen-odottaa, katsotaanpa muuttaa minua ID1, NAME1 ja house1.

804
00:43:33,000 --> 00:43:35,000
Rob on 2, 2.

805
00:43:35,000 --> 00:43:42,000
Minun täytyy muuttaa tänne, täällä, täällä, täällä, täällä, täällä.

806
00:43:42,000 --> 00:43:45,000
Odota, entä Tommy? Tehdään tämä uudestaan.

807
00:43:45,000 --> 00:43:49,000
Ilmeisesti jos olet edelleen sitä mieltä tämä on hyvä tapa tehdä tämä, se ei ole,

808
00:43:49,000 --> 00:43:52,000
niin kopioi / liitä huono.

809
00:43:52,000 --> 00:43:55,000
Mutta me ratkaisi viikko sitten.

810
00:43:55,000 --> 00:43:59,000
>> Mikä oli meidän ratkaisu, kun halusimme olla useita esiintymiä samaa tietotyyppiä?

811
00:43:59,000 --> 00:44:01,000
[Opiskelijat] array.

812
00:44:01,000 --> 00:44:03,000
Array, joten haluaisin yrittää puhdistaa tämän.

813
00:44:03,000 --> 00:44:07,000
Haluan tehdä jonkin verran itse yläreunassa, ja haluan sen sijaan tehdä tätä täällä.

814
00:44:07,000 --> 00:44:12,000
Me kutsumme näitä ihmisiä, vaan aion sanoa "int tunnukset"

815
00:44:12,000 --> 00:44:14,000
ja aion tukea 3 meistä nyt.

816
00:44:14,000 --> 00:44:18,000
Aion sanoa "merkkijonoa" ja minä tukea 3 meistä,

817
00:44:18,000 --> 00:44:22,000
ja sitten aion sanoa "string taloja" ja aion tukea 3 meistä.

818
00:44:22,000 --> 00:44:26,000
Nyt täällä Daavidin sijaan saada oman paikallisia muuttujia

819
00:44:26,000 --> 00:44:28,000
voimme päästä eroon näistä.

820
00:44:28,000 --> 00:44:30,000
Se tuntuu hyvältä, että olemme puhdistamista tähän asti.

821
00:44:30,000 --> 00:44:35,000
Voin sanoa sitten David tulee olemaan [0] ja nimet [0]

822
00:44:35,000 --> 00:44:38,000
ja talot [0].

823
00:44:38,000 --> 00:44:41,000
Ja sitten Rob voimme samalla pelastaa tämän.

824
00:44:41,000 --> 00:44:46,000
Laitetaan tähän täällä, joten hän tulee mielivaltaisesti ids [1].

825
00:44:46,000 --> 00:44:50,000
Hän tulee olemaan nimet [1],

826
00:44:50,000 --> 00:44:53,000
ja sitten lopuksi, talot [1].

827
00:44:53,000 --> 00:44:57,000
>> Vielä vähän tylsiä, ja nyt minun täytyy miettiä tätä,

828
00:44:57,000 --> 00:45:03,000
niin sanotaan "nimet [0], id [0], talot [0]

829
00:45:03,000 --> 00:45:06,000
ja katsotaanpa pluralize tätä.

830
00:45:06,000 --> 00:45:09,000
Ids, ids, ids.

831
00:45:09,000 --> 00:45:12,000
Ja vielä, minä teen sen, niin taas, olen jo turvautua kopioi / liitä uudelleen,

832
00:45:12,000 --> 00:45:14,000
joten kertoimet ovat olemassa toinen ratkaisu täällä.

833
00:45:14,000 --> 00:45:18,000
Voin ehkä puhdistaa tähän asti pidemmälle silmukka tai jotain,

834
00:45:18,000 --> 00:45:21,000
niin lyhyt, se on vähän parempi, mutta silti tuntuu

835
00:45:21,000 --> 00:45:24,000
Olen turvautuminen kopioi / liitä, mutta tämäkin, väitän,

836
00:45:24,000 --> 00:45:27,000
ei oikeastaan ​​pohjimmiltaan oikea ratkaisu, koska

837
00:45:27,000 --> 00:45:29,000
Mitä jos joskus päätämme tiedätkö mitä?

838
00:45:29,000 --> 00:45:32,000
Meidän olisi todellakin pitänyt varastointia sähköpostiosoitteet David ja Rob

839
00:45:32,000 --> 00:45:34,000
ja kaikki muut tässä ohjelmassa.

840
00:45:34,000 --> 00:45:36,000
Meidän pitäisi myös tallentaa puhelinnumeroita.

841
00:45:36,000 --> 00:45:39,000
Meidän pitäisi myös tallentaa hätätilanteessa numerot.

842
00:45:39,000 --> 00:45:41,000
Meillä on kaikki nämä palaset tietojen haluamme tallentaa,

843
00:45:41,000 --> 00:45:43,000
joten miten edetä tee sitä?

844
00:45:43,000 --> 00:45:46,000
>> Voit ilmoittaa toisen array yläreunassa, ja sitten manuaalisesti lisätä

845
00:45:46,000 --> 00:45:49,000
sähköpostiosoite [0], sähköpostiosoite [1]

846
00:45:49,000 --> 00:45:51,000
David ja Rob ja niin edelleen.

847
00:45:51,000 --> 00:45:56,000
Mutta on oikeastaan ​​vain oletus taustalla tämä malli

848
00:45:56,000 --> 00:45:59,000
että olen käyttäen kunnia järjestelmä tietää, että

849
00:45:59,000 --> 00:46:03,000
[I] kussakin useita matriiseja

850
00:46:03,000 --> 00:46:06,000
sattuu viittaamaan samalle henkilölle,

851
00:46:06,000 --> 00:46:10,000
joten [0] IDS on numero 123,

852
00:46:10,000 --> 00:46:13,000
ja aion olettaa, että nimet [0]

853
00:46:13,000 --> 00:46:16,000
on sama henkilön nimi ja talot [0]

854
00:46:16,000 --> 00:46:21,000
on sama henkilö taloon ja niin edelleen kaikille eri matriisit luon.

855
00:46:21,000 --> 00:46:24,000
Mutta huomaa, että ei ole perustavanlaatuisia yhteys

856
00:46:24,000 --> 00:46:27,000
joukossa 3 kpl tiedon, id, nimi ja talon,

857
00:46:27,000 --> 00:46:32,000
vaikka yhteisö yritämme mallia tässä ohjelmassa ei ole taulukoita.

858
00:46:32,000 --> 00:46:35,000
Paneelit ovat vain tällä ohjelmallinen tapa tehdä tämä.

859
00:46:35,000 --> 00:46:38,000
Mitä todella haluamme mallintaa meidän ohjelma on henkilö

860
00:46:38,000 --> 00:46:41,000
kuten David, henkilö kuten Rob jonka sisällä

861
00:46:41,000 --> 00:46:46,000
tai kapselointi on nimi ja tunnus sekä talon.

862
00:46:46,000 --> 00:46:49,000
>> Voimmeko jotenkin ilmaista tätä ajatusta kapselointi

863
00:46:49,000 --> 00:46:52,000
jolloin henkilö on tunnus, nimi ja talon

864
00:46:52,000 --> 00:46:55,000
eikä turvautua todella tätä hakata jonka me juuri

865
00:46:55,000 --> 00:46:58,000
luottaa kiinnike jotain

866
00:46:58,000 --> 00:47:02,000
viittaa samaan ihmisen yksikön kussakin näiden eri matriiseja?

867
00:47:02,000 --> 00:47:04,000
Voimme todella tehdä tämän.

868
00:47:04,000 --> 00:47:08,000
Anna minun mennä yli tärkein nyt, ja haluan luoda oman tietotyypin

869
00:47:08,000 --> 00:47:10,000
varten todella ensimmäistä kertaa.

870
00:47:10,000 --> 00:47:14,000
Käytimme tätä tekniikkaa Scramble,

871
00:47:14,000 --> 00:47:17,000
mutta täällä aion mennä eteenpäin ja luoda tietotyyppi,

872
00:47:17,000 --> 00:47:19,000
ja tiedätkö mitä, aion kutsua sitä opiskelija tai henkilö,

873
00:47:19,000 --> 00:47:23,000
ja aion käyttää typedef varten määritellä tyyppiä.

874
00:47:23,000 --> 00:47:25,000
Aion sanoa, että tämä on rakenne,

875
00:47:25,000 --> 00:47:29,000
ja sitten tämä rakenne tulee olla tyyppiä opiskelija, me sanoa,

876
00:47:29,000 --> 00:47:31,000
vaikka se hieman päivätty nyt minulle.

877
00:47:31,000 --> 00:47:33,000
Me sanomme "int id."

878
00:47:33,000 --> 00:47:35,000
Me sanomme "merkkijonon nimi."

879
00:47:35,000 --> 00:47:37,000
Sitten me sanomme "string talo"

880
00:47:37,000 --> 00:47:40,000
joten nyt loppuun mennessä näiden muutaman rivin koodia

881
00:47:40,000 --> 00:47:45,000
Olen juuri opettanut clang että on olemassa

882
00:47:45,000 --> 00:47:49,000
tietotyyppi lisäksi ints lisäksi jouset, paitsi tuplaa lisäksi kellukkeet.

883
00:47:49,000 --> 00:47:54,000
>> Koska tätä hetkeä rivillä 11, on nyt uusi tietotyyppi nimeltään opiskelijoita,

884
00:47:54,000 --> 00:47:58,000
ja nyt voin julistaa opiskelija muuttuja mihin haluan,

885
00:47:58,000 --> 00:48:01,000
joten haluan selaa tänne ihmisiä.

886
00:48:01,000 --> 00:48:05,000
Nyt voin päästä eroon tästä, ja voin mennä takaisin alas David täällä

887
00:48:05,000 --> 00:48:10,000
ja David voin todella sanoa, että David,

888
00:48:10,000 --> 00:48:13,000
voimme kirjaimellisesti nimetä muuttuja itsestäni,

889
00:48:13,000 --> 00:48:16,000
tulee olla tyyppiä opiskelija.

890
00:48:16,000 --> 00:48:18,000
Tämä saattaa näyttää hieman oudolta, mutta tämä ei ole kaikki, että eri

891
00:48:18,000 --> 00:48:22,000
ilmoittamasta niinkin int tai merkkijono tai float.

892
00:48:22,000 --> 00:48:24,000
Sattui vain niin kutsua opiskelija nyt,

893
00:48:24,000 --> 00:48:28,000
ja jos haluan laittaa jotain sisällä tämän rakenteen

894
00:48:28,000 --> 00:48:31,000
Olen nyt käyttää uutta pala syntaksin, mutta se on melko yksinkertainen,

895
00:48:31,000 --> 00:48:39,000
david.id = 123, david.name = "David" pääoman D,

896
00:48:39,000 --> 00:48:42,000
ja david.house = "Mather,"

897
00:48:42,000 --> 00:48:46,000
ja nyt voin päästä eroon tästä kamaa täällä.

898
00:48:46,000 --> 00:48:51,000
Ilmoituksessa olemme nyt uudistaneet ohjelma todella paljon parempi tapa

899
00:48:51,000 --> 00:48:54,000
että nyt meidän ohjelma heijastaa reaalimaailman.

900
00:48:54,000 --> 00:48:57,000
>> Siellä reaalimaailman käsitteestä henkilö tai opiskelija.

901
00:48:57,000 --> 00:49:02,000
Täällä meillä on nyt C-version henkilön tai tarkemmin opiskelija.

902
00:49:02,000 --> 00:49:05,000
Inside tämän henkilön nämä asiaankuuluvat ominaisuudet,

903
00:49:05,000 --> 00:49:10,000
Tunnus, nimi ja talon, joten Rob olennaisesti muuttuu samaa täällä,

904
00:49:10,000 --> 00:49:14,000
niin opiskelija rob, ja nyt rob.id = 456,

905
00:49:14,000 --> 00:49:17,000
rob.name = "Rob."

906
00:49:17,000 --> 00:49:20,000
Se, että muuttuja on nimeltään Rob on tavallaan merkityksetön.

907
00:49:20,000 --> 00:49:22,000
Olisimme voineet kutsuneet sitä x tai y tai z.

908
00:49:22,000 --> 00:49:25,000
Me vain nimesi sen Rob on semanttisesti johdonmukaisia,

909
00:49:25,000 --> 00:49:28,000
mutta oikeastaan ​​nimi on sisällä että alan itse

910
00:49:28,000 --> 00:49:30,000
joten nyt olen tässä.

911
00:49:30,000 --> 00:49:33,000
Myöskään tämä ei tunnu parasta suunnittelua että olen kova koodattu David.

912
00:49:33,000 --> 00:49:35,000
Olen kova koodattu Rob.

913
00:49:35,000 --> 00:49:39,000
Ja minulla on vielä turvautumaan joitakin kopioida ja liittää aina kun haluan uusia muuttujia.

914
00:49:39,000 --> 00:49:43,000
Lisäksi minulla on ilmeisesti antaa jokaiselle näistä muuttujista nimi,

915
00:49:43,000 --> 00:49:46,000
vaikka olisin paljon mieluummin kuvata näitä muuttujia

916
00:49:46,000 --> 00:49:48,000
 lisää yleisesti opiskelijat.

917
00:49:48,000 --> 00:49:52,000
>> Nyt voimme yhdistää ajatuksia, jotka ovat työskennelleet hyvin meille

918
00:49:52,000 --> 00:49:56,000
ja sen sijaan sanovat, "Tiedätkö mitä, anna minulle muuttuja nimeltä opiskelijoita,

919
00:49:56,000 --> 00:50:01,000
ja Katsotaan se olla kooltaan 3 ", joten nyt voin tarkentaa tätä vielä,

920
00:50:01,000 --> 00:50:04,000
päästä eroon käsin julisti David,

921
00:50:04,000 --> 00:50:08,000
ja voin sen sijaan sanoa jotain opiskelijoita [0] täällä.

922
00:50:08,000 --> 00:50:11,000
Voin sitten sanoa opiskelijat [0] täällä,

923
00:50:11,000 --> 00:50:14,000
opiskelijat [0] täällä, ja niin edelleen, ja voin mennä noin

924
00:50:14,000 --> 00:50:16,000
ja siivota Rob.

925
00:50:16,000 --> 00:50:19,000
Voisin myös mennä nyt ehkä lisäämällä silmukan

926
00:50:19,000 --> 00:50:23,000
ja käyttämällä GetString ja GetInt todella saada nämä arvot käyttäjältä.

927
00:50:23,000 --> 00:50:27,000
Voisin mennä lisäämällä vakio, koska tämä on yleensä huono käytäntö

928
00:50:27,000 --> 00:50:29,000
koviin koodi jotkut mielivaltaisen määrän kuin 3 täällä

929
00:50:29,000 --> 00:50:33,000
ja sitten vain muistaa, että sinun pitäisi laittaa enintään 3 opiskelijaa siinä.

930
00:50:33,000 --> 00:50:36,000
Se olisi todennäköisesti parempi käyttää # define yläreunassa minun tiedosto

931
00:50:36,000 --> 00:50:40,000
ja kerroin että ulos, niin todellakin haluan mennä eteenpäin ja yleistää tätä.

932
00:50:40,000 --> 00:50:43,000
>> Saanen avata esimerkki, joka on kesken päivän

933
00:50:43,000 --> 00:50:46,000
esimerkkejä etukäteen, structs1.

934
00:50:46,000 --> 00:50:49,000
Tämä on enemmän täydellinen ohjelma joka käyttää # define täällä

935
00:50:49,000 --> 00:50:51,000
ja sanoo aiomme olla 3 opiskelijaa oletuksena.

936
00:50:51,000 --> 00:50:54,000
Täällä olen julistamisesta luokan verran opiskelijoita,

937
00:50:54,000 --> 00:50:57,000
niin luokkahuoneessa opiskelijoita, ja nyt olen käyttäen silmukka

938
00:50:57,000 --> 00:51:00,000
vain tehdä koodia hieman tyylikäs, kansoittavat luokka

939
00:51:00,000 --> 00:51:05,000
käyttäjän panosta, joten iteroida alkaen i = 0 asti opiskelijoita, mikä on 3.

940
00:51:05,000 --> 00:51:07,000
Ja sitten minä pyytää käyttäjältä tämän version

941
00:51:07,000 --> 00:51:10,000
 mitä opiskelijan tunnus, ja saan sen GetInt.

942
00:51:10,000 --> 00:51:13,000
Mikä opiskelijan nimi, ja sitten saan sen GetString.

943
00:51:13,000 --> 00:51:15,000
Mikä opiskelijan talossa? Saan sitä GetString.

944
00:51:15,000 --> 00:51:19,000
Ja sitten alaosassa täällä olen vain päättänyt vaihtaa

945
00:51:19,000 --> 00:51:22,000
miten olen tulostamista nämä ulos ja itse käyttää silmukka,

946
00:51:22,000 --> 00:51:24,000
ja kuka olen tulostamista?

947
00:51:24,000 --> 00:51:27,000
Mukaan kommentin olen tulostamista ketään Mather,

948
00:51:27,000 --> 00:51:30,000
ja se on siinä niin Rob ja Tommy jne.-itse Tommy on Mather.

949
00:51:30,000 --> 00:51:34,000
Tommy ja David olisi painettu tässä tapauksessa, mutta miten tämä toimii?

950
00:51:34,000 --> 00:51:40,000
Emme ole nähneet tätä toimintoa ennen, mutta arvata, mitä tämä tekee.

951
00:51:40,000 --> 00:51:42,000
Vertaa merkkijonoja.

952
00:51:42,000 --> 00:51:45,000
>> Se on vähän kuin selvää, miten se vertaa merkkijonoja koska se kääntyy pois

953
00:51:45,000 --> 00:51:49,000
jos se palauttaa 0, joka tarkoittaa jouset ovat yhtä.

954
00:51:49,000 --> 00:51:53,000
Jos se palauttaa -1, joka tarkoittaa yhtä tulee aakkosjärjestyksessä ennen toista,

955
00:51:53,000 --> 00:51:57,000
ja jos se palaa +1 joka tarkoittaa toinen sana tulee aakkosjärjestyksessä

956
00:51:57,000 --> 00:52:00,000
ennen muita, ja voit katsoa verkossa tai man-sivu

957
00:52:00,000 --> 00:52:04,000
nähdä tarkalleen mihin suuntaan on joka, mutta kaikki tämä on nyt tekemässä se sanoo

958
00:52:04,000 --> 00:52:09,000
jos [i]. talo on yhtä "Mather"

959
00:52:09,000 --> 00:52:13,000
sitten mennä eteenpäin ja tulostaa niin ja niin on Mather.

960
00:52:13,000 --> 00:52:16,000
Mutta tässä on jotain emme ole ennen nähneet, ja me palaamme tähän.

961
00:52:16,000 --> 00:52:21,000
En muista koskaan tarvitse tehdä missään minun ohjelmia.

962
00:52:21,000 --> 00:52:24,000
Ilmainen on ilmeisesti viittaa muistiin, mikä vapauttaa muistia,

963
00:52:24,000 --> 00:52:31,000
mutta muisti olen ilmeisesti vapauttaa tämän silmukka alareunassa tämän ohjelman?

964
00:52:31,000 --> 00:52:34,000
Näyttää siltä, ​​olen vapauttaa henkilön nimi

965
00:52:34,000 --> 00:52:37,000
ja henkilön luona, mutta miksi?

966
00:52:37,000 --> 00:52:41,000
>> On käynyt ilmi, kaikki nämä viikkoja, että olet käyttänyt GetString

967
00:52:41,000 --> 00:52:45,000
olemme tavallaan ottaneet käyttöön bugi osaksi jokaisen ohjelmia.

968
00:52:45,000 --> 00:52:51,000
GetString suunnittelun varaa muistia, jotta se voi palata sinulle merkkijono,

969
00:52:51,000 --> 00:52:55,000
kuten David, tai Rob ja voit tehdä mitä haluat

970
00:52:55,000 --> 00:52:59,000
kanssa merkkijono ohjelman, koska olemme varattu muisti sinulle.

971
00:52:59,000 --> 00:53:02,000
Ongelmana on koko ajan aina soittaa GetString

972
00:53:02,000 --> 00:53:05,000
me, laatijat GetString, ovat kyselleet käyttöjärjestelmä

973
00:53:05,000 --> 00:53:07,000
antaa meille vähän RAM tätä merkkijono.

974
00:53:07,000 --> 00:53:09,000
Antakaa meille vähän muistia tähän ensi merkkijono.

975
00:53:09,000 --> 00:53:11,000
Antakaa meille vähän lisää muistia tähän ensi merkkijono.

976
00:53:11,000 --> 00:53:13,000
Mitä sinä, ohjelmoija, ole koskaan tehneet

977
00:53:13,000 --> 00:53:15,000
antaa meille, että muisti takaisin,

978
00:53:15,000 --> 00:53:17,000
joten nämä useita viikkoja kaikki ohjelmat olet kirjoittanut

979
00:53:17,000 --> 00:53:20,000
on ollut mitä kutsutaan muistin harppaus jossa ne pitää käyttää

980
00:53:20,000 --> 00:53:24,000
enemmän ja enemmän muistia aina soittaa GetString, ja se on hienoa.

981
00:53:24,000 --> 00:53:27,000
Olemme tietoisesti tehdä sen ensimmäisen viikon, koska se ei ole niin kiinnostavaa

982
00:53:27,000 --> 00:53:29,000
on huolehtia siitä, missä merkkijono on peräisin.

983
00:53:29,000 --> 00:53:34,000
Kaikki haluamasi on sana Rob palata kun käyttäjä sitä sisään

984
00:53:34,000 --> 00:53:38,000
>> Mutta eteenpäin meidän on nyt alkaa saada enemmän kehittyneempiä tästä.

985
00:53:38,000 --> 00:53:42,000
Aina me varata muistia olemme parempia lopulta luovuttaa sitä takaisin.

986
00:53:42,000 --> 00:53:45,000
Muuten reaalimaailmassa Macin tai PC saatat olla joskus kokeneet

987
00:53:45,000 --> 00:53:50,000
oireita jos tietokone on pysähtymässä lopulta

988
00:53:50,000 --> 00:53:54,000
tai tyhmä spinning rantapallo on vain miehittää tietokoneen

989
00:53:54,000 --> 00:53:56,000
koko huomiota ja et voi tehdä asioita.

990
00:53:56,000 --> 00:54:00,000
Tämä voidaan selittää minkä tahansa määrän bugeja, mutta joukossa mahdolliset bugit

991
00:54:00,000 --> 00:54:03,000
ovat asioita kutsutaan muistivuotoja jossa joku kirjoitti, että ohjelmisto

992
00:54:03,000 --> 00:54:07,000
käytät ei muistanut vapaata muistia

993
00:54:07,000 --> 00:54:10,000
että hän kysyi käyttöjärjestelmä,

994
00:54:10,000 --> 00:54:14,000
ei käytössä GetString, koska se CS50 juttu, mutta käyttäen samankaltaisia ​​tehtäviä

995
00:54:14,000 --> 00:54:16,000
että kysy käyttöjärjestelmän muistin.

996
00:54:16,000 --> 00:54:19,000
Jos sinä tai he tyriä ja koskaan palaa, että muisti

997
00:54:19,000 --> 00:54:24,000
oire, joka voi olla se, että ohjelma hidastuu ja hidastuu ja hidastaa

998
00:54:24,000 --> 00:54:26,000
jos muistat soittaa ilmaiseksi.

999
00:54:26,000 --> 00:54:28,000
>> Tulemme takaisin milloin ja miksi te soittaa ilmaiseksi,

1000
00:54:28,000 --> 00:54:32,000
mutta mennään eteenpäin vain hyvä toimenpide ja kokeile käynnissä kyseistä ohjelmaa.

1001
00:54:32,000 --> 00:54:35,000
Tätä kutsuttiin structs1, kirjoita.

1002
00:54:35,000 --> 00:54:40,000
Anna minun mennä eteenpäin ja ajaa structs1, 123, David Mather,

1003
00:54:40,000 --> 00:54:47,000
456, Rob Kirkland, 789,

1004
00:54:47,000 --> 00:54:50,000
Tommy Mather, ja näemme Davidin kaupungista Mather, Tommy on Mather.

1005
00:54:50,000 --> 00:54:53,000
Tämä on vain pieni järki tarkistaa, että ohjelma toimii.

1006
00:54:53,000 --> 00:54:56,000
Nyt valitettavasti tämä ohjelma on hieman turhauttavaa, että

1007
00:54:56,000 --> 00:55:00,000
En kaiken työn, olen kirjoittanut 9 eri jouset, enteriä,

1008
00:55:00,000 --> 00:55:04,000
kerrottiin joka oli Mather, mutta ilmeisesti tiesin kuka oli Mather jo, koska olen kirjoittanut sen.

1009
00:55:04,000 --> 00:55:07,000
Olisi ainakin mukavaa, jos tämä ohjelma on enemmän kuin tietokanta

1010
00:55:07,000 --> 00:55:10,000
ja se todella muistaa mitä olen kirjoittanut

1011
00:55:10,000 --> 00:55:12,000
joten en koskaan enää tarvitse syöttää nämä elevbokföring.

1012
00:55:12,000 --> 00:55:15,000
Ehkä se on kuin registrarial järjestelmä.

1013
00:55:15,000 --> 00:55:21,000
>> Voimme tehdä tämän käyttämällä tätä tekniikkaa kutsutaan tiedoston I / O, tiedosto tulo ja lähtö,

1014
00:55:21,000 --> 00:55:24,000
hyvin yleinen tapa sanoa milloin haluat lukea tiedostoja tai kirjoittaa tiedostoja

1015
00:55:24,000 --> 00:55:26,000
Voit tehdä tämän tietty joukko toimintoja.

1016
00:55:26,000 --> 00:55:29,000
Anna minun mennä eteenpäin ja avata tässä esimerkissä structs2.c,

1017
00:55:29,000 --> 00:55:33,000
joka on lähes identtinen, mutta katsotaanpa mitä se nyt tekee.

1018
00:55:33,000 --> 00:55:36,000
Ylimpänä tiedoston julistan opiskelijaryhmiä.

1019
00:55:36,000 --> 00:55:38,000
Sitten kansoittavat luokassa käyttäjän panos,

1020
00:55:38,000 --> 00:55:41,000
joten ne koodiriviä ovat juuri ennen.

1021
00:55:41,000 --> 00:55:45,000
Sitten jos selaa täällä voin tulostaa kaikille on Mather mielivaltaisesti kuten ennen,

1022
00:55:45,000 --> 00:55:47,000
mutta tämä on mielenkiintoinen uusi ominaisuus.

1023
00:55:47,000 --> 00:55:51,000
Nämä koodiriviä ovat uusia, ja ne otetaan käyttöön jotain,

1024
00:55:51,000 --> 00:55:55,000
KUVA, kaikki lippikset, ja se on * täällä samoin.

1025
00:55:55,000 --> 00:55:58,000
Jatkan tätä tänne, * täällä samoin.

1026
00:55:58,000 --> 00:56:00,000
>> Tämä toiminto emme ole ennen nähneet, fopen,

1027
00:56:00,000 --> 00:56:03,000
mutta se tarkoittaa tiedostoa auki, joten katsotaanpa lukaista läpi nämä,

1028
00:56:03,000 --> 00:56:05,000
ja tämä on jotain tulemme takaisin tulevaisuudessa psets,

1029
00:56:05,000 --> 00:56:10,000
mutta tämä linja tässä pohjimmiltaan avaa tiedosto nimeltä tietokanta,

1030
00:56:10,000 --> 00:56:13,000
ja se koskee erityisesti avaa sen siten, että se voi tehdä mitä se?

1031
00:56:13,000 --> 00:56:15,000
[Äänetön-opiskelija]

1032
00:56:15,000 --> 00:56:19,000
Oikea, joten "w" vain tarkoittaa se kertoo käyttöjärjestelmä

1033
00:56:19,000 --> 00:56:21,000
avaa tämä tiedosto niin, että voin kirjoittaa sitä.

1034
00:56:21,000 --> 00:56:23,000
En halua lukea sitä. En halua vain katsoa sitä.

1035
00:56:23,000 --> 00:56:26,000
Haluan muuttaa ja lisätä tavaraa mahdollisesti siihen,

1036
00:56:26,000 --> 00:56:28,000
ja tiedosto on menossa kutsutaan tietokantaan.

1037
00:56:28,000 --> 00:56:30,000
Tätä voitaisiin kutsua mitään.

1038
00:56:30,000 --> 00:56:32,000
Tämä voisi olla database.txt. Tämä voisi olla. Db.

1039
00:56:32,000 --> 00:56:37,000
Tämä voisi olla sana kuten foo, mutta mielivaltaisesti päätti nimetä tiedosto tietokantaan.

1040
00:56:37,000 --> 00:56:42,000
Tämä on pieni järki tarkistaa, että tulemme takaisin hyvin yksityiskohtaisesti ajan,

1041
00:56:42,000 --> 00:56:47,000
jos fp, tiedostojen osoitin, ei ole sama NULL se tarkoittaa, että kaikki on hyvin.

1042
00:56:47,000 --> 00:56:51,000
>> Pitkä tarina lyhyt, toimii kuin fopen joskus epäonnistua.

1043
00:56:51,000 --> 00:56:53,000
Ehkä tiedostoa ei ole olemassa. Ehkä olet poissa levytilaa.

1044
00:56:53,000 --> 00:56:55,000
Ehkä sinulla ei ole oikeuksia kansion,

1045
00:56:55,000 --> 00:56:58,000
joten jos fopen palauttaa null jotain pahaa tapahtui.

1046
00:56:58,000 --> 00:57:02,000
Toisaalta, jos fopen ei palauta null kaikki on hyvin

1047
00:57:02,000 --> 00:57:04,000
ja voin alkaa kirjoittaa tähän tiedostoon.

1048
00:57:04,000 --> 00:57:06,000
Tässä uusi temppu.

1049
00:57:06,000 --> 00:57:08,000
Tämä on for-silmukka, joka on iteroimalla yli jokaisen oppilaani

1050
00:57:08,000 --> 00:57:10,000
ja tämä näyttää niin samankaltaisia, mitä olemme tehneet aiemmin,

1051
00:57:10,000 --> 00:57:15,000
mutta tämä toiminto on serkku printf vaati fprintf tiedostojen printf,

1052
00:57:15,000 --> 00:57:18,000
ja huomaa se on erilainen vain 2 tapaa.

1053
00:57:18,000 --> 00:57:20,000
Yksi, se alkaa f sijasta p,

1054
00:57:20,000 --> 00:57:23,000
mutta sen ensimmäinen väite on ilmeisesti mitä?

1055
00:57:23,000 --> 00:57:25,000
[Opiskelijat] Tiedosto. >> Se tiedostoa.

1056
00:57:25,000 --> 00:57:30,000
Tämä juttu nimeltä fp, jonka me lopulta erottaa toisistaan, mikä tiedoston osoitin on,

1057
00:57:30,000 --> 00:57:35,000
mutta nyt FP yksinkertaisesti edustaa tiedosto olen avannut,

1058
00:57:35,000 --> 00:57:41,000
joten fprintf tässä sanoo tulostaa tämän käyttäjän ID tiedoston, eikä näyttöön.

1059
00:57:41,000 --> 00:57:44,000
Tulosta käyttäjän nimen tiedoston, eikä näyttöön,

1060
00:57:44,000 --> 00:57:47,000
talon tiedostoa, ei näytön, ja sitten tänne, tietenkin,

1061
00:57:47,000 --> 00:57:50,000
sulje tiedosto, ja sitten täällä vapaata muistia.

1062
00:57:50,000 --> 00:57:53,000
>> Ainoa ero tässä versio 2 ja versio 1

1063
00:57:53,000 --> 00:57:58,000
on käyttöönotto fopen ja tämän tiedoston *

1064
00:57:58,000 --> 00:58:01,000
ja tämä käsite fprintf, joten katsotaanpa mitä lopputulos on.

1065
00:58:01,000 --> 00:58:03,000
Anna minun mennä minun pääteikkuna.

1066
00:58:03,000 --> 00:58:06,000
Saanen juosta structs2, kirjoita.

1067
00:58:06,000 --> 00:58:09,000
Näyttää kaikki on hyvin. Katsotaanpa uusintana structs2.

1068
00:58:09,000 --> 00:58:15,000
123, David Mather, 456, Rob Kirkland,

1069
00:58:15,000 --> 00:58:19,000
789, Tommy Mather, kirjoita.

1070
00:58:19,000 --> 00:58:23,000
Näyttää se käyttäytyi samalla, mutta jos en nyt tee ls

1071
00:58:23,000 --> 00:58:28,000
huomaa, mitä tiedosto on täällä kaikkien minun koodi, tietokanta,

1072
00:58:28,000 --> 00:58:32,000
joten katsotaanpa avaa, gedit tietokannan, ja katso sitä.

1073
00:58:32,000 --> 00:58:34,000
Se ei ole seksikkäin tiedostomuotoja.

1074
00:58:34,000 --> 00:58:38,000
Se on todellakin yksi kappale datajohdin rivillä kohti,

1075
00:58:38,000 --> 00:58:42,000
mutta ne teistä, jotka käyttävät Excel tai CSV-tiedostoja, pilkulla erotetut arvot,

1076
00:58:42,000 --> 00:58:47,000
Voisin varmasti käyttää fprintf sen sijaan ehkä tehdä jotain tällaista

1077
00:58:47,000 --> 00:58:50,000
niin että voisin itse luoda vastaava Excel-tiedoston

1078
00:58:50,000 --> 00:58:53,000
erottamalla asiat pilkuilla, ei vain uusia linjoja.

1079
00:58:53,000 --> 00:58:56,000
>> Tässä tapauksessa, jos olisin sen sijaan käyttää pilkkuja sijaan uusien linjojen

1080
00:58:56,000 --> 00:59:01,000
Voisin kirjaimellisesti avata tietokantatiedoston Excelissä jos olen sen sijaan tehnyt näyttää tältä.

1081
00:59:01,000 --> 00:59:03,000
Lyhyesti sanottuna, nyt meillä on valta kirjoittaa tiedostoja

1082
00:59:03,000 --> 00:59:07,000
voimme nyt aloittaa jatkuva tiedon, pitää se noin levyllä

1083
00:59:07,000 --> 00:59:10,000
jotta voimme pitää tietoa ympäri uudestaan ​​ja uudestaan.

1084
00:59:10,000 --> 00:59:14,000
Ilmoitus pari muuta asiaa, jotka ovat nyt hieman tutumpi.

1085
00:59:14,000 --> 00:59:16,000
Ylimpänä tämän C tiedoston meillä typedef

1086
00:59:16,000 --> 00:59:21,000
koska halusimme luoda tietotyyppi edustaa sana,

1087
00:59:21,000 --> 00:59:25,000
joten tämä tyyppiä kutsutaan sana, ja sisällä tämän rakenteen

1088
00:59:25,000 --> 00:59:27,000
se on vähän harrastaja nyt.

1089
00:59:27,000 --> 00:59:30,000
Miksi sana koostuu ilmeisesti array?

1090
00:59:30,000 --> 00:59:33,000
Mikä on sana vain intuitiivisesti?

1091
00:59:33,000 --> 00:59:35,000
>> Se on erilaisia ​​merkkejä.

1092
00:59:35,000 --> 00:59:37,000
Se on merkkijono takaisin takaisin takaisin.

1093
00:59:37,000 --> 00:59:41,000
Isot kirjaimet sattuu olemaan meidän mielivaltaisesti sanoa maksimipituus

1094
00:59:41,000 --> 00:59:44,000
tahansa sana sanakirjasta että käytämme varten Scramble.

1095
00:59:44,000 --> 00:59:46,000
Miksi minulla on +1?

1096
00:59:46,000 --> 00:59:48,000
Nollamerkki.

1097
00:59:48,000 --> 00:59:51,000
Recall kun teimme Bananagrams esimerkki tarvitsimme erityinen arvo

1098
00:59:51,000 --> 00:59:55,000
lopussa sanan jotta seurata

1099
00:59:55,000 --> 00:59:59,000
, missä sanat tosiasiallisesti päättynyt, ja koska ongelmana asetettu spesifikaatio sanoo

1100
00:59:59,000 --> 01:00:03,000
täällä me liitytään tiettyä sanaa boolean arvo,

1101
01:00:03,000 --> 01:00:05,000
lippu, niin sanoakseni, tosi tai epätosi.

1102
01:00:05,000 --> 01:00:09,000
Oletko löytänyt tämän sanan jo, koska ymmärrämme,

1103
01:00:09,000 --> 01:00:13,000
me todella tarvitsemme tapa muistaa paitsi mitä sana on Scramble

1104
01:00:13,000 --> 01:00:15,000
mutta vai et, ihmisen, löytäneet sen

1105
01:00:15,000 --> 01:00:20,000
joten jos et löydä sanaa "" ei voi vain kirjoittaa, kirjoita,, anna, antamalla

1106
01:00:20,000 --> 01:00:23,000
ja saada 3 pistettä, 3 pistettä, 3 pistettä, 3 pistettä.

1107
01:00:23,000 --> 01:00:26,000
Haluamme pystyä mustalle listalle, että sana asettamalla bool

1108
01:00:26,000 --> 01:00:29,000
true jos olet jo löytänyt sitä, joten siksi olemme

1109
01:00:29,000 --> 01:00:31,000
kapseloitu se tässä rakenteessa.

1110
01:00:31,000 --> 01:00:35,000
>> Nyt täällä on Scramble on tämä muu struct nimeltään sanakirja.

1111
01:00:35,000 --> 01:00:39,000
Absent tässä on sana typedef koska tässä tapauksessa

1112
01:00:39,000 --> 01:00:43,000
meidän piti kiteyttää ajatukseen sanakirja,

1113
01:00:43,000 --> 01:00:46,000
ja sanakirja sisältää koko joukko sanoja,

1114
01:00:46,000 --> 01:00:49,000
koska ymmärtää tämä jono, ja kuinka moni noista sanoista ovat siellä?

1115
01:00:49,000 --> 01:00:51,000
No, mitä tämä muuttuja nimeltä kokoa sanoo.

1116
01:00:51,000 --> 01:00:53,000
Mutta meidän on vain sanakirja.

1117
01:00:53,000 --> 01:00:55,000
Emme tarvitse tietotyyppiä kutsutaan sanakirja.

1118
01:00:55,000 --> 01:00:58,000
Meidän täytyy vain yksi niistä, niin se kääntyy pois C

1119
01:00:58,000 --> 01:01:03,000
että jos et sano typedef, sanoit struct, niin sisällä aaltosulkeita

1120
01:01:03,000 --> 01:01:05,000
laitat muuttujia, niin laitat nimen.

1121
01:01:05,000 --> 01:01:09,000
Tämä on julistaa yhden muuttujan nimeltään sanakirja

1122
01:01:09,000 --> 01:01:11,000
joka näyttää tältä.

1123
01:01:11,000 --> 01:01:16,000
Sen sijaan nämä linjat luovat uudelleen tietorakenne kutsutaan sana

1124
01:01:16,000 --> 01:01:19,000
että voit luoda useita kopioita, aivan kuten olemme luoneet

1125
01:01:19,000 --> 01:01:22,000
useita kopioita opiskelijoille.

1126
01:01:22,000 --> 01:01:24,000
>> Mitä tämä lopulta antaa meille mahdollisuuden tehdä?

1127
01:01:24,000 --> 01:01:30,000
Anna minun mennä takaisin, sanokaamme, yksinkertaisempi esimerkki yksinkertaisempaa kertaa,

1128
01:01:30,000 --> 01:01:34,000
ja anna minun avata, sanotaanko, compare1.c.

1129
01:01:34,000 --> 01:01:38,000
Ongelmana tässä käsillä on todella Taitat

1130
01:01:38,000 --> 01:01:41,000
kerros merkkijonon ja aloitat pois näistä apupyörät

1131
01:01:41,000 --> 01:01:44,000
koska osoittautuu, että merkkijono koko tämän ajan

1132
01:01:44,000 --> 01:01:47,000
on kuten lupasimme viikolla 1 oikeastaan ​​vain lempinimi,

1133
01:01:47,000 --> 01:01:51,000
synonyymi alkaen CS50 kirjastosta jotain, joka näyttää hieman arvoituksellisesti,

1134
01:01:51,000 --> 01:01:53,000
char *, ja olemme nähneet tämän tähden ennen.

1135
01:01:53,000 --> 01:01:55,000
Näimme sen yhteydessä tiedostoista.

1136
01:01:55,000 --> 01:01:59,000
>> Katsotaanpa nyt, miksi olemme olleet piilossa tähän yksityiskohtaisesti jo jonkin aikaa.

1137
01:01:59,000 --> 01:02:02,000
Täällä on tiedosto nimeltä compare1.c,

1138
01:02:02,000 --> 01:02:07,000
ja se ilmeisesti pyytää käyttäjältä 2 jouset, s ja t,

1139
01:02:07,000 --> 01:02:11,000
ja sitten se yrittää verrata näitä Kielet tasa rivi 26,

1140
01:02:11,000 --> 01:02:14,000
ja jos he yhtä sanotaan, "Kirjoitit sama asia"

1141
01:02:14,000 --> 01:02:17,000
ja jos he eivät yhtä se sanoo, "Kirjoitit eri asioita."

1142
01:02:17,000 --> 01:02:19,000
Anna minun mennä eteenpäin ja suorita tämä ohjelma.

1143
01:02:19,000 --> 01:02:23,000
Anna minun mennä minun lähde hakemistoon, tee compare1. Se laaditaan okei.

1144
01:02:23,000 --> 01:02:25,000
Saanen juosta compare1.

1145
01:02:25,000 --> 01:02:27,000
Minä zoomata, kirjoita.

1146
01:02:27,000 --> 01:02:29,000
Sano jotain. HELLO.

1147
01:02:29,000 --> 01:02:32,000
Sanon jotain uudestaan. HELLO.

1148
01:02:32,000 --> 01:02:34,000
En todellakaan ole kirjoittaa eri asioita.

1149
01:02:34,000 --> 01:02:37,000
>> Yritän tässä uudelleen. BYE BYE.

1150
01:02:37,000 --> 01:02:40,000
Ehdottomasti ei eri, niin mitä täällä tapahtuu?

1151
01:02:40,000 --> 01:02:44,000
No, mitä todella verrataan linjassa 26?

1152
01:02:44,000 --> 01:02:46,000
[Äänetön-opiskelija]

1153
01:02:46,000 --> 01:02:49,000
Kyllä, niin se kääntyy pois että merkkijono, tietotyyppi, on eräänlainen valkoinen valhe.

1154
01:02:49,000 --> 01:02:53,000
Merkkijono on char *, mutta mikä on char *?

1155
01:02:53,000 --> 01:02:56,000
Char *, kuten sanotaan, on osoitin,

1156
01:02:56,000 --> 01:03:00,000
ja osoitin on tehokkaasti osoite,

1157
01:03:00,000 --> 01:03:05,000
summa sijainti muistissa, ja jos sinulla sattuu olemaan kirjoitettu sana kuten HELLO,

1158
01:03:05,000 --> 01:03:08,000
muistuttaa aiemmista keskusteluista merkkijonoja

1159
01:03:08,000 --> 01:03:16,000
Tämä on kuin sana HELLO.

1160
01:03:16,000 --> 01:03:19,000
Muista, että sanan HELLO voidaan esittää

1161
01:03:19,000 --> 01:03:22,000
kuten erilaisia ​​merkkejä kuten tämä

1162
01:03:22,000 --> 01:03:25,000
ja sitten erikoismerkki lopussa kutsutaan nollamerkki,

1163
01:03:25,000 --> 01:03:27,000
kuten \ tarkoittaa.

1164
01:03:27,000 --> 01:03:29,000
Mikä on oikeastaan ​​merkkijono?

1165
01:03:29,000 --> 01:03:32,000
Huomaa, että tämä on useita paloina muistia,

1166
01:03:32,000 --> 01:03:36,000
ja itse asiassa pää on tiedossa vasta kun näytät läpi koko merkkijono

1167
01:03:36,000 --> 01:03:38,000
etsivät erityistä nollamerkki.

1168
01:03:38,000 --> 01:03:41,000
Mutta jos tämä on kimpale muisti tietokoneen muistista,

1169
01:03:41,000 --> 01:03:44,000
Oletetaan mielivaltaisesti sanoa, että tämä jono vain onnekas,

1170
01:03:44,000 --> 01:03:47,000
ja se sai sijoitettu alusta tietokoneeni RAM.

1171
01:03:47,000 --> 01:03:54,000
Tämä on tavu 0, 1, 2, 3, 4, 5, 6 ...

1172
01:03:54,000 --> 01:04:02,000
>> Kun sanon jotain GetString ja minä string s = GetString

1173
01:04:02,000 --> 01:04:04,000
mitä oikeastaan ​​palautetaan?

1174
01:04:04,000 --> 01:04:08,000
Näiden viime viikkojen mitä todella on tallennettu s

1175
01:04:08,000 --> 01:04:13,000
ei tämä merkkijono sinänsä, mutta tässä tapauksessa, mitä on tallennettu on

1176
01:04:13,000 --> 01:04:18,000
numero 0, koska mitä GetString oikeastaan ​​tekee

1177
01:04:18,000 --> 01:04:20,000
ei se ole fyysisesti palauttaa merkkijonon.

1178
01:04:20,000 --> 01:04:22,000
Se ei edes oikeastaan ​​tee käsitteellistä järkeä.

1179
01:04:22,000 --> 01:04:24,000
Mitä se tekee paluun numero.

1180
01:04:24,000 --> 01:04:28,000
Tämä numero on osoite HELLO muistiin,

1181
01:04:28,000 --> 01:04:32,000
ja merkkijono s sitten, jos kuori takaisin tämän kerroksen merkkijono ei todellisuudessa ole olemassa.

1182
01:04:32,000 --> 01:04:35,000
Se on vain yksinkertaistaa CS50 kirjastossa.

1183
01:04:35,000 --> 01:04:38,000
>> Tämä todellakin on jotain kutsutaan char *.

1184
01:04:38,000 --> 01:04:41,000
Char järkevää, koska mikä sana, kuten HELLO?

1185
01:04:41,000 --> 01:04:44,000
No, se on sarja merkkiä, useita merkkejä.

1186
01:04:44,000 --> 01:04:47,000
Char * tarkoittaa osoitteen luonne,

1187
01:04:47,000 --> 01:04:50,000
niin mitä se tarkoittaa palauttaa merkkijonon?

1188
01:04:50,000 --> 01:04:53,000
Kiva, yksinkertainen tapa palauttaa merkkijonon

1189
01:04:53,000 --> 01:04:57,000
on pikemminkin kuin yrittää selvittää, miten palata 5 tai 6 eri tavua

1190
01:04:57,000 --> 01:05:01,000
Saanen palata osoite, joka tavun?

1191
01:05:01,000 --> 01:05:03,000
Ensimmäinen.

1192
01:05:03,000 --> 01:05:06,000
Toisin sanoen, minä annan sinulle osoitteen merkin muistiin.

1193
01:05:06,000 --> 01:05:10,000
Sitähän char * edustaa, osoite yhden merkin muistiin.

1194
01:05:10,000 --> 01:05:12,000
Soita se muuttuja s.

1195
01:05:12,000 --> 01:05:15,000
Säilytä s kyseisen osoite, jota mielivaltaisesti sanonut on 0,

1196
01:05:15,000 --> 01:05:19,000
vain pitää asiat yksinkertaisina, mutta todellisuudessa se on yleensä isompi numero.

1197
01:05:19,000 --> 01:05:21,000
>> Hetkinen.

1198
01:05:21,000 --> 01:05:23,000
Jos olet vain antaa minulle osoitteen ensimmäisen merkin, mistä tiedän, mikä osoite on

1199
01:05:23,000 --> 01:05:25,000
toinen merkki, kolmas, neljäs ja viides?

1200
01:05:25,000 --> 01:05:27,000
[Äänetön-opiskelija]

1201
01:05:27,000 --> 01:05:31,000
Et vain tiedä missä merkkijonon lopussa on tapa tämän kätevä temppu,

1202
01:05:31,000 --> 01:05:35,000
joten kun käytät jotain printf, mitä printf kirjaimellisesti tekee sen väitteen,

1203
01:05:35,000 --> 01:05:39,000
muistuttaa, että käytämme tätä% s paikkamerkkiä, ja sitten kulkea

1204
01:05:39,000 --> 01:05:41,000
muuttuja, joka on varastointi merkkijono.

1205
01:05:41,000 --> 01:05:47,000
Mitä olet todella kulkee on osoite ensimmäinen merkki merkkijonon.

1206
01:05:47,000 --> 01:05:50,000
Printf sitten käyttää for-silmukka tai kun silmukka saatuaan että osoite,

1207
01:05:50,000 --> 01:05:53,000
Esimerkiksi, 0, joten haluan tehdä sen nyt,

1208
01:05:53,000 --> 01:06:02,000
printf ("% s \ n" s);

1209
01:06:02,000 --> 01:06:07,000
Kun Kutsun printf ("% s \ n" s), mitä olen todella antaa printf kanssa

1210
01:06:07,000 --> 01:06:13,000
on osoite ensimmäisen merkin s, joka tässä mielivaltaisesti tapauksessa on H.

1211
01:06:13,000 --> 01:06:16,000
>> Miten printf tietävät mitä näyttää ruudulla?

1212
01:06:16,000 --> 01:06:19,000
Henkilö, joka toteutettiin printf toteutetaan while-silmukka tai for-silmukka

1213
01:06:19,000 --> 01:06:23,000
joka sanoo tämä merkki yhtä erityistä nollamerkki?

1214
01:06:23,000 --> 01:06:25,000
Jos ei, tulostaa sen. Entäs tämä?

1215
01:06:25,000 --> 01:06:28,000
Jos ei tulosta se, tulosta se, tulosta se, tulostaa sen.

1216
01:06:28,000 --> 01:06:32,000
Voi, tämä on erikoinen. Pysäytä tulostus ja palaa käyttäjälle.

1217
01:06:32,000 --> 01:06:35,000
Ja se on kirjaimellisesti kaikki on tapahtunut alla huppu,

1218
01:06:35,000 --> 01:06:38,000
ja että on paljon sulattaa ensimmäisenä päivänä luokan,

1219
01:06:38,000 --> 01:06:43,000
mutta nyt se on todella rakennuspalikka ymmärryksen kaikesta

1220
01:06:43,000 --> 01:06:46,000
joka on jatkunut sisällä meidän tietokoneen muistiin,

1221
01:06:46,000 --> 01:06:49,000
ja lopulta me kiusata tätä erilleen hieman apua

1222
01:06:49,000 --> 01:06:51,000
yhdeltä ystävämme Stanfordissa.

1223
01:06:51,000 --> 01:06:56,000
>> Professori Nick Parlante Stanfordin on tehnyt tämän ihanan videon järjestyksessä

1224
01:06:56,000 --> 01:06:58,000
alkaen kaikenlaisia ​​eri kieliä käyttöön

1225
01:06:58,000 --> 01:07:00,000
tämä pieni claymation merkin Binky.

1226
01:07:00,000 --> 01:07:03,000
Ääni olet aikeissa kuulla vain muutaman sekunnin ennakkoesitys

1227
01:07:03,000 --> 01:07:05,000
on, että Stanfordin professori, ja saat

1228
01:07:05,000 --> 01:07:07,000
vain 5 tai 6 sekuntia tämän juuri nyt,

1229
01:07:07,000 --> 01:07:09,000
mutta tämä on huomautus, joka me tehdä tänään

1230
01:07:09,000 --> 01:07:11,000
ja alkavat keskiviikkona.

1231
01:07:11,000 --> 01:07:15,000
Annan teille Pointer Fun with Binky, esikatselu.

1232
01:07:15,000 --> 01:07:18,000
[♪ Music ♪] [Professori Parlante] Hei, Binky.

1233
01:07:18,000 --> 01:07:21,000
Herää. On aika osoittimen hauskaa.

1234
01:07:21,000 --> 01:07:24,000
[Binky] Mikä tuo on? Lisätietoja viitteitä?

1235
01:07:24,000 --> 01:07:26,000
Voi goody!

1236
01:07:26,000 --> 01:07:29,000
>> Tulemme näkemään sinut keskiviikkona.

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]