1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Săptămâna 4]

2
00:00:03,000 --> 00:00:05,000
[David J. Malan] [Universitatea Harvard]

3
00:00:05,000 --> 00:00:08,000
[Acest lucru este CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> Bine, asta este CS50, iar acest lucru este începutul săptămânii 4,

5
00:00:12,000 --> 00:00:16,000
și acesta este unul dintre algoritmii de sortare cel mai lent posibil.

6
00:00:16,000 --> 00:00:19,000
Care dintre fost că ne-am privit acolo?

7
00:00:19,000 --> 00:00:24,000
Asta a fost un fel balon, în scopul de Big O (n ^ 2) + suma,

8
00:00:24,000 --> 00:00:28,000
și într-adevăr, nu suntem singurii în această lume pentru a par să știe

9
00:00:28,000 --> 00:00:30,000
ce fel bubble este sau timpul său de funcționare.

10
00:00:30,000 --> 00:00:33,000
Într-adevăr, aceasta a fost un interviu cu Eric Schmidt de la Google

11
00:00:33,000 --> 00:00:45,000
si fostul senator american Barack Obama la doar câțiva ani în urmă.

12
00:00:45,000 --> 00:00:48,000
>> Acum, senatorul, ești aici de la Google,

13
00:00:48,000 --> 00:00:54,000
și îmi place să mă gândesc la președinția ca un interviu de angajare.

14
00:00:54,000 --> 00:00:58,000
Acum, e greu pentru a obține un loc de muncă în calitate de președinte, și tu te duci prin rigorile acum.

15
00:00:58,000 --> 00:01:00,000
Este, de asemenea, greu pentru a obține un loc de muncă la Google.

16
00:01:00,000 --> 00:01:05,000
Avem întrebări, și ne pune întrebări candidaților noștri,

17
00:01:05,000 --> 00:01:10,000
si aceasta este de la Larry Schwimmer.

18
00:01:10,000 --> 00:01:14,000
Voi credeți că glumesc? E chiar aici.

19
00:01:14,000 --> 00:01:18,000
Care este cel mai eficient mod de a sorta un milion de numere întregi pe 32 de biți?

20
00:01:18,000 --> 00:01:21,000
[Râsete]

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

22
00:01:24,000 --> 00:01:26,000
Îmi pare rău >> Nu, nu, nu, nu..

23
00:01:26,000 --> 00:01:34,000
Cred ca ar fi un fel bula mod greșit de a merge.

24
00:01:34,000 --> 00:01:39,000
>> Haide, care ia spus asta?

25
00:01:39,000 --> 00:01:43,000
Săptămâna trecută, amintesc am luat o pauza de la cod, cel puțin pentru o zi,

26
00:01:43,000 --> 00:01:46,000
și a început concentrându-se pe unele idei de nivel superior și de rezolvare a problemelor, în general, mai mult

27
00:01:46,000 --> 00:01:49,000
în contextul căutare și sortare,

28
00:01:49,000 --> 00:01:53,000
și am introdus ceva ce nu am palmă acest nume pe săptămâna trecută,

29
00:01:53,000 --> 00:01:56,000
dar notația asimptotică, Big O, Omega Big,

30
00:01:56,000 --> 00:02:00,000
și, uneori, Big notația Theta, și acestea au fost pur și simplu moduri

31
00:02:00,000 --> 00:02:02,000
de a descrie timpul de rulare al algoritmilor,

32
00:02:02,000 --> 00:02:05,000
cât de mult timp este nevoie pentru a rula un algoritm.

33
00:02:05,000 --> 00:02:08,000
>> Și poate vă amintiți că ați vorbit despre timpul de execuție în ceea ce privește dimensiunea

34
00:02:08,000 --> 00:02:11,000
de intrare, pe care noi o numim, în general, n, oricare ar fi problema poate fi,

35
00:02:11,000 --> 00:02:13,000
unde n este numărul de persoane în cameră,

36
00:02:13,000 --> 00:02:17,000
numărul de pagini dintr-o carte de telefon, și am început să scrie lucruri

37
00:02:17,000 --> 00:02:21,000
cum ar fi O (n ^ 2) sau O (n) sau O (n log n),

38
00:02:21,000 --> 00:02:24,000
și chiar și atunci când matematica nu a mers prea bine atât de perfect

39
00:02:24,000 --> 00:02:28,000
și a fost n ² - n / 2 sau ceva de genul asta

40
00:02:28,000 --> 00:02:31,000
în schimb ne-ar arunca pur și simplu o parte din termenii de ordine inferioare,

41
00:02:31,000 --> 00:02:34,000
și motivația nu este ca ne dorim cu adevarat o

42
00:02:34,000 --> 00:02:37,000
un fel de mod obiectiv de evaluare

43
00:02:37,000 --> 00:02:39,000
performanța programelor sau performanța algoritmilor

44
00:02:39,000 --> 00:02:42,000
faptul că, la sfârșitul zilei nu are nimic de a face, de exemplu,

45
00:02:42,000 --> 00:02:45,000
cu viteza de computer de astăzi.

46
00:02:45,000 --> 00:02:47,000
>> De exemplu, dacă ați pune în aplicare sortare cu bule,

47
00:02:47,000 --> 00:02:50,000
sau te pună în aplicare îmbinarea sortare sau o selecție sortare pe calculatorul de astăzi,

48
00:02:50,000 --> 00:02:53,000
un calculator 2 GHz, și tu-l executați,

49
00:02:53,000 --> 00:02:56,000
și este nevoie de un numar de secunde, anul viitor e un GHz 3

50
00:02:56,000 --> 00:02:59,000
sau un 4 GHz calculator, și s-ar putea pretinde apoi că "Wow, mi algoritm

51
00:02:59,000 --> 00:03:03,000
este acum de două ori mai repede, "atunci când, în realitate, că nu e în mod evident cazul.

52
00:03:03,000 --> 00:03:06,000
E doar hardware-ul a devenit mai rapid, dar computerului

53
00:03:06,000 --> 00:03:10,000
a nu, și așa dorim cu adevărat să arunce lucruri, cum ar fi

54
00:03:10,000 --> 00:03:13,000
multipli de 2 sau multiplu de 3 atunci când vine vorba de a descrie

55
00:03:13,000 --> 00:03:17,000
cât de repede sau cât de încet un algoritm este și într-adevăr să se concentreze doar

56
00:03:17,000 --> 00:03:20,000
pe n sau un factor al acestuia,

57
00:03:20,000 --> 00:03:24,000
o anumită putere a acestora, în cazul felul de săptămâna trecută.

58
00:03:24,000 --> 00:03:27,000
Și reamintească faptul că, cu ajutorul fel de fuziune

59
00:03:27,000 --> 00:03:31,000
noi am fost capabil sa faca acest lucru mult mai bine decât sortare cu bule și sortare selecție

60
00:03:31,000 --> 00:03:33,000
și chiar și inserarea de sortare.

61
00:03:33,000 --> 00:03:36,000
>> Am ajuns la n log n, și, din nou,

62
00:03:36,000 --> 00:03:39,000
Reamintim că log n general, se referă la ceva care creste

63
00:03:39,000 --> 00:03:43,000
mai lent, apoi n, deci n log n până acum a fost bun

64
00:03:43,000 --> 00:03:45,000
pentru că a fost mai puțin ² n.

65
00:03:45,000 --> 00:03:47,000
Dar pentru a realiza n log n cu un fel de îmbinare

66
00:03:47,000 --> 00:03:51,000
ceea ce a fost germenul de bază a unei idei pe care am avut să impulsioneze

67
00:03:51,000 --> 00:03:54,000
că am, de asemenea, extinse la nivel înapoi în săptămâna 0?

68
00:03:54,000 --> 00:03:58,000
Cum am aborda problema de sortare ingenios cu un fel de îmbinare?

69
00:03:58,000 --> 00:04:04,000
Care a fost cheia înțelegere, poate?

70
00:04:04,000 --> 00:04:07,000
Oricine deloc.

71
00:04:07,000 --> 00:04:09,000
Bine, hai să facem un pas înapoi.

72
00:04:09,000 --> 00:04:11,000
Descrieți îmbinare de sortare în propriile tale cuvinte.

73
00:04:11,000 --> 00:04:15,000
Cum a mers?

74
00:04:15,000 --> 00:04:17,000
Bine, ne vom rândul inapoi la 0 săptămână.

75
00:04:17,000 --> 00:04:19,000
Bine, da.

76
00:04:19,000 --> 00:04:22,000
[Imperceptibil-elev]

77
00:04:22,000 --> 00:04:26,000
Bine, bine, așa că am împărțit matrice de numere în 2 bucăți.

78
00:04:26,000 --> 00:04:29,000
Am sortat fiecare dintre aceste piese, iar apoi le-am fuzionat,

79
00:04:29,000 --> 00:04:33,000
și am văzut această idee înainte de a lua o problemă care este atât de mare

80
00:04:33,000 --> 00:04:36,000
și tocare-l într-o problemă care este atât de mare sau atât de mare.

81
00:04:36,000 --> 00:04:38,000
>> Amintiți-exemplu cartea de telefon.

82
00:04:38,000 --> 00:04:42,000
Amintiți-algoritm de auto-numărare de săptămâni în urmă,

83
00:04:42,000 --> 00:04:45,000
sortare, astfel îmbinare a fost rezumată de acest pseudocod aici.

84
00:04:45,000 --> 00:04:48,000
Când ești dat n elemente, în primul rând a fost bun-simț verifica.

85
00:04:48,000 --> 00:04:51,000
Dacă n <2, atunci nu faci nimic, la toate

86
00:04:51,000 --> 00:04:55,000
pentru că dacă n <2, atunci n este, evident, 0 sau 1,

87
00:04:55,000 --> 00:04:57,000
și, deci, dacă e 0 sau 1 nu e nimic pentru a sorta.

88
00:04:57,000 --> 00:04:59,000
Ai terminat.

89
00:04:59,000 --> 00:05:01,000
Lista dvs. este deja sortat trivial.

90
00:05:01,000 --> 00:05:04,000
Dar altfel, dacă ai 2 sau mai multe elemente mergeți mai departe și împărțiți-le

91
00:05:04,000 --> 00:05:06,000
in 2 jumatati, la stânga și la dreapta.

92
00:05:06,000 --> 00:05:09,000
Sorteaza fiecare dintre aceste jumatati, iar apoi îmbinați jumatati sortate.

93
00:05:09,000 --> 00:05:13,000
Dar problema aici este faptul că, la prima vedere, acest lucru se simte ca și cum suntem punting.

94
00:05:13,000 --> 00:05:17,000
Aceasta este o definiție circulară în care, dacă v-am rugat a sorta aceste elemente n

95
00:05:17,000 --> 00:05:22,000
și tu îmi spui "Bine, bine, vom sorta aceste elemente n / 2 și cele N / 2,"

96
00:05:22,000 --> 00:05:27,000
atunci urmatoarea mea intrebare va fi "Bine, cum vrei să sortați n / 2 elemente?"

97
00:05:27,000 --> 00:05:30,000
>> Dar, din cauza structurii acestui program,

98
00:05:30,000 --> 00:05:33,000
pentru că nu există acest caz de bază, ca să spunem așa,

99
00:05:33,000 --> 00:05:39,000
acest caz special care spune că, dacă n este <o anumită valoare fixă ​​ca 2 retur imediat.

100
00:05:39,000 --> 00:05:42,000
Nu răspund cu aceeași circulară raspuns.

101
00:05:42,000 --> 00:05:46,000
Acest proces, acest ciclicitate se va încheia în cele din urmă.

102
00:05:46,000 --> 00:05:50,000
Dacă te întreb "după aceste elemente n", și spui, "Bine, sorta aceste N / 2,"

103
00:05:50,000 --> 00:05:53,000
atunci spui, "un fel Fine, acestea n / 4, n / 8, n/16,"

104
00:05:53,000 --> 00:05:56,000
în cele din urmă veți împărți de un număr suficient de mare

105
00:05:56,000 --> 00:05:59,000
că veți avea doar 1 element de stânga, moment în care se poate spune,

106
00:05:59,000 --> 00:06:02,000
"Aici, aici este un element de sortat singur."

107
00:06:02,000 --> 00:06:06,000
Apoi strălucirea acestui algoritm aici este de a obține de la faptul

108
00:06:06,000 --> 00:06:09,000
că, odată ce ai toate aceste liste sortate în mod individual,

109
00:06:09,000 --> 00:06:12,000
toate care sunt de dimensiune 1, care pare a fi inutil,

110
00:06:12,000 --> 00:06:15,000
odată ce începe fuziunea acestora și fuzionarea acestora

111
00:06:15,000 --> 00:06:19,000
ai construi în cele din urmă ca Rob a făcut într-o listă de filme în cele din urmă sortate.

112
00:06:19,000 --> 00:06:22,000
>> Dar această idee se extinde mult dincolo de sortare.

113
00:06:22,000 --> 00:06:26,000
Există această idee inglobate in acest program cunoscut sub numele de recursivitate,

114
00:06:26,000 --> 00:06:29,000
Ideea prin care sunteți un program,

115
00:06:29,000 --> 00:06:32,000
și pentru a rezolva unele probleme te sun,

116
00:06:32,000 --> 00:06:36,000
sau puse în contextul limbajelor de programare sunteți o funcție,

117
00:06:36,000 --> 00:06:39,000
și în scopul de a rezolva o problemă, te funcția de tine suna

118
00:06:39,000 --> 00:06:42,000
din nou și din nou și din nou, dar tu funcția

119
00:06:42,000 --> 00:06:44,000
nu se poate numi te ori infinit de multe.

120
00:06:44,000 --> 00:06:47,000
În cele din urmă va trebui să scadă, ca să spunem așa,

121
00:06:47,000 --> 00:06:49,000
și de a avea starea hard-coded de bază care spune

122
00:06:49,000 --> 00:06:53,000
în acest moment nu mai sunat-te, astfel încât întregul proces de

123
00:06:53,000 --> 00:06:56,000
în cele din urmă se opri în fapt.

124
00:06:56,000 --> 00:06:58,000
Ce înseamnă aceasta cu adevărat, să recurse?

125
00:06:58,000 --> 00:07:01,000
>> Să vedem, daca putem face un exemplu simplu, banal cu, să zicem,

126
00:07:01,000 --> 00:07:03,000
3 persoane cu mine până aici pe scenă, în cazul în care cineva este confortabil.

127
00:07:03,000 --> 00:07:06,000
1, vino sus, 2 și 3.

128
00:07:06,000 --> 00:07:09,000
Dacă vă doriți 3 să vină aici.

129
00:07:09,000 --> 00:07:12,000
Dacă vrei să stai lângă mine aici, într-o linie, să presupunem că problema de la mână

130
00:07:12,000 --> 00:07:15,000
este foarte trivial conta numărul de oameni care sunt aici.

131
00:07:15,000 --> 00:07:18,000
Dar sincer, eu sunt obosit de toate aceste exemple de numărare a voturilor.

132
00:07:18,000 --> 00:07:21,000
Acest lucru este de gând să ia ceva timp, 1, 2, si punct, punct, punct.

133
00:07:21,000 --> 00:07:23,000
O să dureze o eternitate.

134
00:07:23,000 --> 00:07:25,000
Aș prefera barca tocmai această problemă cu totul, cu ajutorul-care e numele tău?

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

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

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

138
00:07:31,000 --> 00:07:34,000
Chiar acum am fost întrebat de cineva

139
00:07:34,000 --> 00:07:37,000
cât de mulți oameni sunt pe această scenă, și nu am nici o idee.

140
00:07:37,000 --> 00:07:40,000
Aceasta este o listă foarte lungă, și astfel în loc să am de gând să fac acest truc.

141
00:07:40,000 --> 00:07:43,000
Mă duc să întreb persoana de lângă mine să fac cea mai mare parte de lucru,

142
00:07:43,000 --> 00:07:46,000
și o dată ea se face face de cele mai multe de lucru

143
00:07:46,000 --> 00:07:49,000
Am de gând să fac cel puțin suma de munca este posibil și se adaugă la doar 1

144
00:07:49,000 --> 00:07:51,000
la orice răspunsul ei este, așa că aici vom merge.

145
00:07:51,000 --> 00:07:54,000
Am fost întrebat câți oameni sunt pe scena.

146
00:07:54,000 --> 00:07:57,000
Câți oameni sunt pe scenă la stânga de tine?

147
00:07:57,000 --> 00:08:00,000
Stânga de mine >> Ok?, Dar nu ieftin.

148
00:08:00,000 --> 00:08:04,000
Asta e bine, e corect, dar dacă vrem să continuăm această logică

149
00:08:04,000 --> 00:08:08,000
Să presupunem că vă doriți să similar punt această problemă la stânga de tine,

150
00:08:08,000 --> 00:08:11,000
Deci, mai degrabă decât răspunsul merge direct mai departe și să treacă doar dolar.

151
00:08:11,000 --> 00:08:14,000
Oh, cât de mulți oameni sunt la stânga de mine?

152
00:08:14,000 --> 00:08:16,000
Cât de mulți oameni sunt la stânga?

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

154
00:08:18,000 --> 00:08:27,000
[Râsete]

155
00:08:27,000 --> 00:08:30,000
Ok, deci 0, deci ceea ce a făcut acum Willy

156
00:08:30,000 --> 00:08:33,000
te-ai întors răspunsul această direcție spunând 0.

157
00:08:33,000 --> 00:08:36,000
Acum, ce ar trebui să faci? >> 1.

158
00:08:36,000 --> 00:08:39,000
Bine, deci tu ești 1, asa ai spus, "Bine, am de gând să adăugați 1

159
00:08:39,000 --> 00:08:41,000
la orice număr Willy a fost, "așa 1 + 0.

160
00:08:41,000 --> 00:08:43,000
Ești acum 1 atât de răspunsul dumneavoastră la dreapta este acum-

161
00:08:43,000 --> 00:08:45,000
1. >> Si a mea ar fi 2.

162
00:08:45,000 --> 00:08:48,000
Bine, deci tu iei răspunsul anterior de 1,

163
00:08:48,000 --> 00:08:51,000
adăugând cantitatea minimă de muncă vrei să faci, ceea ce este un.

164
00:08:51,000 --> 00:08:55,000
Aveți acum 2, și tu dai apoi mi care valoarea?

165
00:08:55,000 --> 00:08:57,000
3, vreau să spun, îmi pare rău, 2.

166
00:08:57,000 --> 00:08:59,000
Bine.

167
00:08:59,000 --> 00:09:02,000
>> Ei bine, am avut de la 0 la stânga.

168
00:09:02,000 --> 00:09:05,000
Apoi am avut 1, iar apoi adăugăm 2,

169
00:09:05,000 --> 00:09:07,000
si acum esti predarea-mi numărul 2,

170
00:09:07,000 --> 00:09:10,000
și așa spun, bine, +1, 3.

171
00:09:10,000 --> 00:09:13,000
E într-adevăr, 3 persoane în picioare lângă mine pe această scenă,

172
00:09:13,000 --> 00:09:16,000
asa ca am fi putut face, evident, acest lucru foarte liniar,

173
00:09:16,000 --> 00:09:19,000
foarte mult în modă evident, dar ceea ce am făcut cu adevărat?

174
00:09:19,000 --> 00:09:21,000
Am luat o problemă de dimensiune 3 inițial.

175
00:09:21,000 --> 00:09:24,000
Noi l-am rupt în jos într-o problemă de dimensiune 2,

176
00:09:24,000 --> 00:09:27,000
apoi o problema de dimensiune 1, și apoi în cele din urmă scenariul de bază

177
00:09:27,000 --> 00:09:29,000
a fost într-adevăr, oh, nu e nimeni acolo,

178
00:09:29,000 --> 00:09:33,000
moment în care a revenit în mod eficient Willy un răspuns hard-coded de cateva ori,

179
00:09:33,000 --> 00:09:36,000
iar al doilea a fost apoi barbotat sus, bule de aer în sus, barbotat sus,

180
00:09:36,000 --> 00:09:39,000
și apoi, prin adaugarea in aceasta suplimentară 1

181
00:09:39,000 --> 00:09:41,000
am implementat această idee de bază a recursivitate.

182
00:09:41,000 --> 00:09:44,000
>> Acum, în acest caz nu a rezolvat într-adevăr o problemă

183
00:09:44,000 --> 00:09:46,000
mai eficient, atunci l-am văzut până acum.

184
00:09:46,000 --> 00:09:48,000
Dar gândește-te la algoritmii care le-am făcut pe scenă până acum.

185
00:09:48,000 --> 00:09:51,000
Am avut 8 bucăți de hârtie pe tablă,

186
00:09:51,000 --> 00:09:55,000
pe video atunci când Sean a fost în căutarea pentru numărul 7, și ce a făcut el chiar nu?

187
00:09:55,000 --> 00:09:58,000
Ei bine, el nu a făcut nici un fel de divide et impera.

188
00:09:58,000 --> 00:10:01,000
El nu a făcut nici un fel de recursivitate.

189
00:10:01,000 --> 00:10:03,000
Mai degrabă el a făcut doar acest algoritm liniar.

190
00:10:03,000 --> 00:10:07,000
Dar când am introdus ideea de numere sunt sortate pe scenă trăiesc săptămâna trecută

191
00:10:07,000 --> 00:10:09,000
atunci am avut acest instinct de a merge la mijloc,

192
00:10:09,000 --> 00:10:13,000
moment în care am avut o listă mai mică de mărimea 4 sau o altă listă de marimea 4,

193
00:10:13,000 --> 00:10:17,000
și apoi am avut exact aceeași problemă, așa că am repetat, repetat, repetat.

194
00:10:17,000 --> 00:10:19,000
Cu alte cuvinte, ne recursed.

195
00:10:19,000 --> 00:10:24,000
Vă mulțumesc foarte mult pentru cele 3 voluntari aici pentru a demonstra recursivitate cu noi.

196
00:10:24,000 --> 00:10:28,000
>> Să vedem dacă nu putem face asta acum concret un pic mai mult,

197
00:10:28,000 --> 00:10:30,000
rezolvarea unei probleme pe care din nou, am putea face destul de ușor,

198
00:10:30,000 --> 00:10:34,000
dar ne vom folosi ca o piatră de temelie pentru punerea în aplicare a acestei idei de bază.

199
00:10:34,000 --> 00:10:37,000
Dacă vreau să calculeze însumarea o grămadă de numere,

200
00:10:37,000 --> 00:10:39,000
de exemplu, dacă treci în numărul 3,

201
00:10:39,000 --> 00:10:42,000
Vreau să vă dau valoarea sigma 3,

202
00:10:42,000 --> 00:10:46,000
astfel încât suma de 3 + 2 + 1 + 0.

203
00:10:46,000 --> 00:10:48,000
Vreau să mă întorc răspunsul 6,

204
00:10:48,000 --> 00:10:51,000
așa că vom pune în aplicare această funcție Sigma, această funcție însumării

205
00:10:51,000 --> 00:10:54,000
că, din nou, ia în intrare, iar apoi returnează însumarea

206
00:10:54,000 --> 00:10:57,000
din acest număr tot drumul până la 0.

207
00:10:57,000 --> 00:10:59,000
Am putea face acest lucru destul de simplu, nu?

208
00:10:59,000 --> 00:11:01,000
Am putea face acest lucru cu un fel de structură looping,

209
00:11:01,000 --> 00:11:04,000
asa ca lasa-ma sa plec mai departe și a obține acest început.

210
00:11:04,000 --> 00:11:07,000
>> Include stdio.h.

211
00:11:07,000 --> 00:11:09,000
Lasă-mă să mă ajunge în principal pentru a lucra cu aici.

212
00:11:09,000 --> 00:11:12,000
Să salvăm acest lucru ca sigma.c.

213
00:11:12,000 --> 00:11:14,000
Apoi, am de gând să merg aici, și am de gând să o declare un int n,

214
00:11:14,000 --> 00:11:18,000
și am de gând să fac următoarele în timp ce utilizatorul nu cooperează.

215
00:11:18,000 --> 00:11:22,000
În timp ce utilizatorul nu mi-a dat un număr pozitiv

216
00:11:22,000 --> 00:11:26,000
lasă-mă să merg mai departe și cere-le pentru n = GetInt,

217
00:11:26,000 --> 00:11:28,000
și lasă-mă să le dau niște instrucțiuni cu privire la ce să fac,

218
00:11:28,000 --> 00:11:33,000
astfel încât printf ("număr întreg pozitiv vă rugăm").

219
00:11:33,000 --> 00:11:39,000
Doar ceva relativ simplu, așa astfel încât, până când am lovit linia 14

220
00:11:39,000 --> 00:11:42,000
acum avem un număr întreg pozitiv, probabil, în nr.

221
00:11:42,000 --> 00:11:44,000
>> Acum, hai să facem ceva cu ea.

222
00:11:44,000 --> 00:11:50,000
Lasă-mă să merg mai departe și calcula însumarea, astfel încât suma intre int = sigma (n).

223
00:11:50,000 --> 00:11:54,000
Sigma este doar însumarea, așa că eu sunt doar scris, în mod crescator.

224
00:11:54,000 --> 00:11:56,000
Vom numi doar sigma acolo.

225
00:11:56,000 --> 00:11:58,000
Asta e suma, iar acum am de gând să imprima rezultatul,

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

227
00:12:08,000 --> 00:12:11,000
Și apoi voi întoarce 0 pentru o bună măsură.

228
00:12:11,000 --> 00:12:15,000
Am făcut tot ceea ce presupune acest program, cu excepția partea interesantă,

229
00:12:15,000 --> 00:12:18,000
care este de a pune în aplicare, de fapt funcția sigma.

230
00:12:18,000 --> 00:12:22,000
>> Lasă-mă să merg aici la partea de jos, și lasă-mă să declare funcția sigma.

231
00:12:22,000 --> 00:12:26,000
Trebuie sa ia o variabilă care este de tip întreg,

232
00:12:26,000 --> 00:12:30,000
și ce tip de date vreau să se întoarcă probabil de la Sigma?

233
00:12:30,000 --> 00:12:34,000
Int, pentru că vreau să se potrivească așteptărilor mele pe linia 15.

234
00:12:34,000 --> 00:12:37,000
În aici, lasă-mă să merg mai departe și punerea în aplicare a prezentei

235
00:12:37,000 --> 00:12:41,000
într-un mod destul de simplu.

236
00:12:41,000 --> 00:12:45,000
>> Să mergem mai departe și să spunem suma intre int = 0,

237
00:12:45,000 --> 00:12:47,000
și acum am de gând să merg avea un pic de buclă aici

238
00:12:47,000 --> 00:12:50,000
care va spune ceva de genul asta,

239
00:12:50,000 --> 00:13:01,000
pentru (int i = 0; i <= număr; i + +) + = i suma intre.

240
00:13:01,000 --> 00:13:05,000
Și apoi am de gând să se întoarcă suma intre.

241
00:13:05,000 --> 00:13:07,000
Am fi putut puse în aplicare acest lucru în orice număr de moduri.

242
00:13:07,000 --> 00:13:09,000
Am fi putut folosi o buclă în timp ce.

243
00:13:09,000 --> 00:13:11,000
Aș fi putut să omit folosind variabila suma în cazul în care am vrut să,

244
00:13:11,000 --> 00:13:15,000
dar pe scurt, avem doar o funcție care, dacă nu am făcut-Cea mai mare greseala declară suma intre este 0.

245
00:13:15,000 --> 00:13:18,000
Apoi, iterează la 0 pe sus, prin numărul,

246
00:13:18,000 --> 00:13:23,000
și pe fiecare iterație se adaugă faptul că valoarea actuală a sumei și apoi returnează suma intre.

247
00:13:23,000 --> 00:13:25,000
>> Acum, există o optimizare ușoară aici.

248
00:13:25,000 --> 00:13:29,000
Acesta este, probabil, un pas pierdut, dar așa să fie. Asta e bine pentru moment.

249
00:13:29,000 --> 00:13:32,000
Suntem cel puțin a fi aprofundată și merge 0 tot drumul pe sus.

250
00:13:32,000 --> 00:13:34,000
Nu este foarte greu și destul de simplă,

251
00:13:34,000 --> 00:13:37,000
dar se pare că, odată cu funcția de sigma avem aceeași oportunitate

252
00:13:37,000 --> 00:13:39,000
așa cum am făcut-o aici, pe scenă.

253
00:13:39,000 --> 00:13:42,000
Pe scenă ne-am numărat câți oameni au fost alături de mine,

254
00:13:42,000 --> 00:13:47,000
dar în schimb, dacă ne-am dorit pentru a contoriza numărul 3 + 2 + 1

255
00:13:47,000 --> 00:13:51,000
privind în jos la 0 am putut în mod similar barca la o funcție

256
00:13:51,000 --> 00:13:55,000
pe care o voi descrie în loc ca fiind recursivă.

257
00:13:55,000 --> 00:13:57,000
Aici sa facem o verificare rapidă bun-simț și asigurați-vă că nu am făcut-o prost.

258
00:13:57,000 --> 00:14:00,000
>> Știu că e cel puțin un lucru în acest program pe care eu am făcut greșit.

259
00:14:00,000 --> 00:14:04,000
Când m-am lovit introduceți am de gând pentru a obține orice fel de țipi la mine?

260
00:14:04,000 --> 00:14:06,000
Ceea ce am de gând să fie strigat la aproximativ?

261
00:14:06,000 --> 00:14:11,000
Da, am uitat prototipul, asa ca am folosind o functie numita Sigma pe linia 15,

262
00:14:11,000 --> 00:14:16,000
dar nu este declarată până la linia 22, așa că am cel mai bun mod proactiv merge aici

263
00:14:16,000 --> 00:14:22,000
și declară un prototip, iar eu voi spune int Sigma (int numar), și asta e tot.

264
00:14:22,000 --> 00:14:24,000
Este implementat la partea de jos.

265
00:14:24,000 --> 00:14:27,000
>> Sau un alt modul în care am putea rezolva acest lucru,

266
00:14:27,000 --> 00:14:30,000
Aș putea muta funcția de acolo, ceea ce nu este rău,

267
00:14:30,000 --> 00:14:32,000
dar cel puțin atunci când programele încep pentru a obține lung, sincer,

268
00:14:32,000 --> 00:14:35,000
Cred că e ceva în valoare de având în principal întotdeauna în partea de sus

269
00:14:35,000 --> 00:14:38,000
astfel încât să în cititorul poate deschide fișierul și apoi să vedem imediat

270
00:14:38,000 --> 00:14:40,000
ceea ce face programul, fără a fi nevoie să căutați prin ea

271
00:14:40,000 --> 00:14:42,000
In cautare de faptul că funcția principală.

272
00:14:42,000 --> 00:14:49,000
Să mergem la fereastră terminal mea aici, încercați să fac Sigma Sigma,

273
00:14:49,000 --> 00:14:51,000
si am dat-on bară aici.

274
00:14:51,000 --> 00:14:55,000
Declarația implicită a funcției GetInt înseamnă că am uitat să fac ce altceva?

275
00:14:55,000 --> 00:14:57,000
[Imperceptibil-elev]

276
00:14:57,000 --> 00:15:00,000
Bine, deci se pare o greșeală comună, asa ca hai sa pun asta aici,

277
00:15:00,000 --> 00:15:04,000
cs50.h, și acum să ne întoarcem la fereastra terminalul meu.

278
00:15:04,000 --> 00:15:08,000
>> Voi goli ecranul, iar eu voi face reluare sigma.

279
00:15:08,000 --> 00:15:11,000
Se pare că s-au compilat. Lasă-mă să fugi acum sigma.

280
00:15:11,000 --> 00:15:15,000
Voi tastați în numărul 3, și eu am primit 6, deci nu un cec riguros,

281
00:15:15,000 --> 00:15:18,000
dar cel puțin se pare a fi de lucru la prima vedere, dar acum hai sa-l rupe în afară,

282
00:15:18,000 --> 00:15:21,000
și să pârghie de fapt, ideea de recursivitate, din nou,

283
00:15:21,000 --> 00:15:24,000
într-un context foarte simplu, astfel încât, în câteva săptămâni "

284
00:15:24,000 --> 00:15:27,000
atunci când vom începe explorarea structurilor de date mai frumoase decât matrice

285
00:15:27,000 --> 00:15:30,000
avem un alt instrument în set de instrumente cu care să

286
00:15:30,000 --> 00:15:33,000
manipula aceste structuri de date așa cum vom vedea.

287
00:15:33,000 --> 00:15:36,000
Aceasta este abordarea iterativă, abordarea bazată pe bucla.

288
00:15:36,000 --> 00:15:39,000
>> Lasă-mă în loc să fac asta acum.

289
00:15:39,000 --> 00:15:44,000
Permiteți-mi să spun că în loc însumarea numărului

290
00:15:44,000 --> 00:15:48,000
privind în jos la 0 este într-adevăr același lucru ca și

291
00:15:48,000 --> 00:15:53,000
Numărul + Sigma (număr - 1).

292
00:15:53,000 --> 00:15:57,000
Cu alte cuvinte, la fel ca și pe scenă am degajată la fiecare dintre oamenii de lângă mine,

293
00:15:57,000 --> 00:16:00,000
și aceștia, la rândul păstrat punting până când vom în cele din urmă durat până la Willy,

294
00:16:00,000 --> 00:16:03,000
care a trebuit să se întoarcă un răspuns hard-coded ca 0.

295
00:16:03,000 --> 00:16:07,000
Aici, acum suntem la fel punting la Sigma

296
00:16:07,000 --> 00:16:10,000
aceeași funcție ca și a fost inițial numit, dar perspectiva cheie aici

297
00:16:10,000 --> 00:16:12,000
este faptul că nu suntem de asteptare sigma identic.

298
00:16:12,000 --> 00:16:14,000
Noi nu suntem în trecere nr.

299
00:16:14,000 --> 00:16:17,000
Suntem în mod clar trecerea la număr - 1,

300
00:16:17,000 --> 00:16:20,000
astfel încât o problemă puțin mai mic, puțin mai mică problemă.

301
00:16:20,000 --> 00:16:23,000
>> Din păcate, acest lucru nu este destul de o soluție încă, și înainte de a ne repara

302
00:16:23,000 --> 00:16:26,000
ceea ce ar putea fi sărind ca evident, la unii dintre voi

303
00:16:26,000 --> 00:16:28,000
lasă-mă să merg mai departe și reluare a face.

304
00:16:28,000 --> 00:16:30,000
Se pare că pentru a compila bine.

305
00:16:30,000 --> 00:16:32,000
Lasă-mă să rulați din nou cu 6 sigma.

306
00:16:32,000 --> 00:16:37,000
Hopa, lasă-mă să rulați din nou cu 6 sigma.

307
00:16:37,000 --> 00:16:42,000
Am văzut acest lucru înainte, deși timpul accidental trecut.

308
00:16:42,000 --> 00:16:48,000
De ce am primit această eroare de segmentare criptic? Da.

309
00:16:48,000 --> 00:16:50,000
[Imperceptibil-elev]

310
00:16:50,000 --> 00:16:53,000
Nu e nici un caz de bază, și, mai precis, ceea ce probabil sa întâmplat?

311
00:16:53,000 --> 00:16:58,000
Acesta este un simptom a ceea ce comportament?

312
00:16:58,000 --> 00:17:00,000
Spune-o un pic mai tare.

313
00:17:00,000 --> 00:17:02,000
[Imperceptibil-elev]

314
00:17:02,000 --> 00:17:05,000
E o buclă infinită în mod eficient, iar problema cu bucle infinite

315
00:17:05,000 --> 00:17:08,000
atunci când acestea implică recursivitate în acest caz, o funcție în sine de asteptare,

316
00:17:08,000 --> 00:17:10,000
ceea ce se întâmplă de fiecare dată când apelați o funcție?

317
00:17:10,000 --> 00:17:13,000
Ei bine, cred că înapoi la modul în care am pus afară de memorie într-un computer.

318
00:17:13,000 --> 00:17:16,000
Am spus că există această bucată de memorie numit stiva care este în partea de jos,

319
00:17:16,000 --> 00:17:19,000
și de fiecare dată când apelați o funcție de memorie un pic mai mult se pune

320
00:17:19,000 --> 00:17:24,000
pe această stivă așa-numitul conține variabile care functioneaza despre locale sau parametri,

321
00:17:24,000 --> 00:17:27,000
așa că, dacă sigma sigma sigma Apeluri solicită sigma

322
00:17:27,000 --> 00:17:29,000
 solicită, în cazul în care se sigma acest scop poveste?

323
00:17:29,000 --> 00:17:31,000
>> Ei bine, în cele din urmă depășiri suma totală

324
00:17:31,000 --> 00:17:33,000
de memorie pe care le au la dispoziție la computer.

325
00:17:33,000 --> 00:17:37,000
Ai depășit segmentul pe care tu ar trebui să rămână în cadrul,

326
00:17:37,000 --> 00:17:40,000
și veți obține acest defect segmentare, miez fac obiectul unui dumping,

327
00:17:40,000 --> 00:17:43,000
și ce înseamnă de bază fac obiectul unui dumping este că am acum un fișier numit miez

328
00:17:43,000 --> 00:17:46,000
care este un fișier care conține zerouri și cele

329
00:17:46,000 --> 00:17:49,000
că, de fapt, în viitor, va fi folositoare pentru diagnostic.

330
00:17:49,000 --> 00:17:52,000
Dacă nu e evident pentru tine în cazul în care bug-ul dvs. este

331
00:17:52,000 --> 00:17:54,000
puteți face de fapt, un pic de analiza medico-legală, ca să spunem așa,

332
00:17:54,000 --> 00:17:58,000
în acest dosar benă de bază, care, din nou, este doar o grămadă de zerouri și cele

333
00:17:58,000 --> 00:18:02,000
care reprezintă în esență, starea programului în memorie

334
00:18:02,000 --> 00:18:05,000
momentul în care sa prăbușit în acest fel.

335
00:18:05,000 --> 00:18:11,000
>> Fix aici este că nu putem pur și simplu întoarce orbește sigma,

336
00:18:11,000 --> 00:18:14,000
numărul + sigma de o problemă puțin mai mică.

337
00:18:14,000 --> 00:18:16,000
Avem nevoie de a avea un fel de scenariul de bază aici,

338
00:18:16,000 --> 00:18:19,000
și ceea ce ar trebui să fie, probabil, cazul de bază?

339
00:18:19,000 --> 00:18:22,000
[Imperceptibil-elev]

340
00:18:22,000 --> 00:18:25,000
Bine, atâta timp cât numărul este pozitiv ar trebui să ne întoarcă de fapt acest lucru,

341
00:18:25,000 --> 00:18:29,000
sau, altfel spus, dacă numărul este, să spunem, <= cu 0

342
00:18:29,000 --> 00:18:32,000
Știi ce, voi merge mai departe și să se întoarcă 0,

343
00:18:32,000 --> 00:18:36,000
la fel ca Willy făcut, și altceva, am de gând să merg mai departe

344
00:18:36,000 --> 00:18:41,000
și să se întoarcă acest lucru, așa că nu e mult mai scurtă

345
00:18:41,000 --> 00:18:44,000
decât versiunea iterativ care am incitat folosind mai întâi un pentru buclă,

346
00:18:44,000 --> 00:18:48,000
dar observați că există acest tip de eleganță să-l.

347
00:18:48,000 --> 00:18:51,000
În loc de a se întoarce un numar si efectuarea toate astea matematica

348
00:18:51,000 --> 00:18:54,000
și adăugarea de lucrurile cu variabilele locale

349
00:18:54,000 --> 00:18:57,000
tu spui în loc "Bine, dacă aceasta este o problemă foarte ușor,

350
00:18:57,000 --> 00:19:01,000
ca numărul este <0, permiteți-mi să se întoarcă imediat 0. "

351
00:19:01,000 --> 00:19:03,000
>> Noi nu suntem de gând să deranjez numere de sprijin negative,

352
00:19:03,000 --> 00:19:05,000
așa că am de gând să codul de greu valoarea 0.

353
00:19:05,000 --> 00:19:08,000
Dar altfel, să pună în aplicare această idee de însumând

354
00:19:08,000 --> 00:19:11,000
toate aceste numere împreună puteți face în mod eficient o muscatura mic

355
00:19:11,000 --> 00:19:14,000
din problema, la fel ca am facut aici pe scenă,

356
00:19:14,000 --> 00:19:18,000
apoi punt restul de problema următoarea persoană,

357
00:19:18,000 --> 00:19:20,000
dar, în acest caz, următoarea persoană este singur.

358
00:19:20,000 --> 00:19:22,000
Este o funcție identic pe nume.

359
00:19:22,000 --> 00:19:25,000
Doar treci o problemă mai mică și mai mică și mai mică de fiecare dată,

360
00:19:25,000 --> 00:19:28,000
și chiar dacă nu avem lucruri destul de formalizate în codul aici

361
00:19:28,000 --> 00:19:33,000
acest lucru este exact ceea ce se întâmplă în săptămâna 0, cu cartea de telefon.

362
00:19:33,000 --> 00:19:36,000
Acest lucru este exact ceea ce se întâmplă în ultimele săptămâni cu Sean

363
00:19:36,000 --> 00:19:39,000
și cu demonstrații noastre de căutare pentru numere.

364
00:19:39,000 --> 00:19:42,000
Este de a lua o problemă și împărțind-o din nou și din nou.

365
00:19:42,000 --> 00:19:44,000
>> Cu alte cuvinte, există o modalitate de a traduce acum

366
00:19:44,000 --> 00:19:47,000
acest construct lumea reală, această construcție nivel superior

367
00:19:47,000 --> 00:19:51,000
de dezbina si cucereste și de a face ceva nou și din nou

368
00:19:51,000 --> 00:19:56,000
în cod, astfel încât aceasta este ceva ce se va vedea din nou-a lungul timpului.

369
00:19:56,000 --> 00:20:00,000
Acum, ca o paranteză, dacă sunteți nou la recursia ar trebui să înțeleagă cel puțin acum

370
00:20:00,000 --> 00:20:02,000
de ce acest lucru este amuzant.

371
00:20:02,000 --> 00:20:05,000
Am de gând să merg la google.com,

372
00:20:05,000 --> 00:20:17,000
și am de gând pentru a căuta câteva sfaturi și trucuri despre recursivitate, introduceți.

373
00:20:17,000 --> 00:20:21,000
Spune-i persoanei de lângă tine, dacă acestea nu au fost doar râd acum.

374
00:20:21,000 --> 00:20:23,000
Ați vrut să spuneți recursivitate?

375
00:20:23,000 --> 00:20:25,000
Ați vrut să spuneți-ah, acolo mergem.

376
00:20:25,000 --> 00:20:28,000
Ok, acum că e restul de toată lumea.

377
00:20:28,000 --> 00:20:30,000
Un pic de ou de Paști inglobate undeva acolo în Google.

378
00:20:30,000 --> 00:20:33,000
Ca o paranteza, unul dintre link-urile de pe site-ul am pus cursului

379
00:20:33,000 --> 00:20:36,000
pentru ziua de azi este doar această grilă de algoritmi de sortare diferite,

380
00:20:36,000 --> 00:20:39,000
dintre care unele ne-am uitat la saptamana trecuta, dar ce e frumos despre această vizualizare

381
00:20:39,000 --> 00:20:43,000
în timp ce încerca să-și încheie în jurul valorii de mintea ta diverse lucruri legate de algoritmi

382
00:20:43,000 --> 00:20:46,000
știți că puteți foarte ușor începe acum, cu diferite tipuri de intrări.

383
00:20:46,000 --> 00:20:50,000
Intrarile toate inversat, cea mai mare parte a intrărilor sortate, intrările aleatoare și așa mai departe.

384
00:20:50,000 --> 00:20:53,000
În timp ce încerca să, din nou, distinge aceste lucruri în mintea ta

385
00:20:53,000 --> 00:20:57,000
dau seama că acest URL pe site-ul cursului pe pagina Prelegeri

386
00:20:57,000 --> 00:21:00,000
s-ar putea ajuta să vă motiv, prin unele dintre cele.

387
00:21:00,000 --> 00:21:05,000
>> Astăzi vom ajunge în cele din urmă pentru a rezolva această problemă dintr-o înapoi în timp,

388
00:21:05,000 --> 00:21:08,000
care a fost faptul că această funcție de swap pur si simplu nu au de lucru,

389
00:21:08,000 --> 00:21:12,000
și ceea ce a fost problema fundamentală cu acest swap funcție,

390
00:21:12,000 --> 00:21:15,000
scopul care a fost, din nou, să facă schimb de o valoare aici si aici

391
00:21:15,000 --> 00:21:17,000
astfel că se întâmplă acest lucru?

392
00:21:17,000 --> 00:21:20,000
Acest lucru nu lucrează efectiv. De ce?

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

394
00:21:22,000 --> 00:21:28,000
[Imperceptibil-elev]

395
00:21:28,000 --> 00:21:31,000
Exact, explicația pentru acest bugginess

396
00:21:31,000 --> 00:21:34,000
pur și simplu pentru că a fost atunci când apelați funcții în C

397
00:21:34,000 --> 00:21:38,000
și funcțiile respective să ia argumente, ca a si b aici,

398
00:21:38,000 --> 00:21:42,000
te trec în copiile, indiferent de valoarea pe care o oferi la această funcție.

399
00:21:42,000 --> 00:21:46,000
Tu nu sunt furnizarea de valorile inițiale s-au,

400
00:21:46,000 --> 00:21:49,000
așa că am văzut acest lucru în contextul buggyc,

401
00:21:49,000 --> 00:21:52,000
buggy3.c, care a analizat ceva de genul asta.

402
00:21:52,000 --> 00:21:57,000
>> Amintiți-vă că am avut x și y inițializat la 1 și 2, respectiv.

403
00:21:57,000 --> 00:21:59,000
Apoi am imprimat ceea ce au fost.

404
00:21:59,000 --> 00:22:03,000
Apoi am susținut că am fost le-swapping sunand de swap x, y.

405
00:22:03,000 --> 00:22:06,000
Dar problema era că schimbarea a lucrat,

406
00:22:06,000 --> 00:22:10,000
dar numai în domeniul de aplicare al swap-sine funcționa.

407
00:22:10,000 --> 00:22:13,000
De îndată ce ne-am lovit linia 40 aceste valori schimbate

408
00:22:13,000 --> 00:22:16,000
s-au aruncat, și așa mai nimic

409
00:22:16,000 --> 00:22:21,000
în funcția originală principal a fost schimbat de fapt, la toate,

410
00:22:21,000 --> 00:22:26,000
așa că, dacă vă gândiți la ceea ce atunci, ca acest lucru arata ca in ceea ce priveste memoria noastră

411
00:22:26,000 --> 00:22:29,000
în cazul în care această partea stângă a consiliului reprezintă,

412
00:22:29,000 --> 00:22:33,000
și voi face meu cel mai bun pentru toată lumea să vadă acest-ar fi dacă această partea stângă a plăcii

413
00:22:33,000 --> 00:22:37,000
reprezintă, să zicem, RAM-ul, iar stiva este de gând să crească pe sus în acest fel,

414
00:22:37,000 --> 00:22:43,000
și am apela o funcție cum ar fi principal, și principalele are 2 variabile locale, x și y,

415
00:22:43,000 --> 00:22:48,000
Să descrie pe cei ca x aici, și să descrie aceste ca y aici,

416
00:22:48,000 --> 00:22:55,000
și să punem în valorile pe 1 și 2, astfel încât acesta este principalul aici,

417
00:22:55,000 --> 00:22:58,000
și atunci când solicită principal funcția de swap sistemul de operare

418
00:22:58,000 --> 00:23:02,000
dă funcția de swap cărare proprie de memorie pe stiva,

419
00:23:02,000 --> 00:23:04,000
rama proprie pe stiva, ca să spunem așa.

420
00:23:04,000 --> 00:23:08,000
Se alocă, de asemenea, 32 de biți pentru aceste Ints.

421
00:23:08,000 --> 00:23:11,000
Se întâmplă să le numim A și B, dar asta e cu totul arbitrar.

422
00:23:11,000 --> 00:23:13,000
Le-ar fi numit orice ar vrea, dar ce se întâmplă atunci când principalul

423
00:23:13,000 --> 00:23:19,000
de swap solicită este nevoie de acest lucru 1, pune o copie acolo, pune o copie acolo.

424
00:23:19,000 --> 00:23:23,000
>> Există 1 altor variabile locale în schimb, deși, numit ce? Tmp >>.

425
00:23:23,000 --> 00:23:27,000
Tmp, asa ca lasa-ma da eu încă 32 de biți de aici,

426
00:23:27,000 --> 00:23:29,000
și ceea ce am făcut în această funcție?

427
00:23:29,000 --> 00:23:34,000
I-am spus tmp int devine o, astfel încât o are 1, așa că am făcut acest lucru când am jucat cu ultima acest exemplu.

428
00:23:34,000 --> 00:23:39,000
Atunci devine b, deci b este 2, așa că acum aceasta devine 2,

429
00:23:39,000 --> 00:23:42,000
și acum B devine temperatură, deci temperatura este de 1,

430
00:23:42,000 --> 00:23:44,000
deci acum B devine asta.

431
00:23:44,000 --> 00:23:46,000
Asta-i grozav. Ea a lucrat.

432
00:23:46,000 --> 00:23:49,000
Dar apoi, de îndată ce se întoarce funcția

433
00:23:49,000 --> 00:23:52,000
Memoria de swap în mod eficient dispare, astfel încât să poată fi reutilizate

434
00:23:52,000 --> 00:23:58,000
printr-o altă funcție, în viitor, și, evident, principalul este complet neschimbat.

435
00:23:58,000 --> 00:24:00,000
Avem nevoie de o modalitate de rezolvare a acestei probleme fundamental,

436
00:24:00,000 --> 00:24:03,000
iar astăzi vom avea în sfârșit o modalitate de a face acest lucru, prin care

437
00:24:03,000 --> 00:24:06,000
putem introduce ceva numit un pointer.

438
00:24:06,000 --> 00:24:09,000
Se pare că putem rezolva această problemă

439
00:24:09,000 --> 00:24:12,000
nu prin trecerea în copii ale lui x și y

440
00:24:12,000 --> 00:24:18,000
ci prin trecerea in ceea ce, crezi că, la funcția de swap?

441
00:24:18,000 --> 00:24:20,000
Da, ceea ce despre adresa?

442
00:24:20,000 --> 00:24:22,000
Noi nu prea am vorbit despre adresele de mai multe detalii,

443
00:24:22,000 --> 00:24:25,000
dar dacă această tablă reprezintă memoria computerului meu

444
00:24:25,000 --> 00:24:28,000
am putea începe cu siguranță, numerotarea octeți în memoria RAM mea

445
00:24:28,000 --> 00:24:31,000
și spun acest lucru este octet # 1, acesta este octetul # 2, # 3 Octet,

446
00:24:31,000 --> 00:24:35,000
octet # 4, # Octet ... 2 miliarde EUR dacă am 2 GB de RAM,

447
00:24:35,000 --> 00:24:38,000
asa ca am putea veni cu siguranta cu o schema de numerotare arbitrare

448
00:24:38,000 --> 00:24:41,000
pentru toți octeții individuale în memoria computerului meu.

449
00:24:41,000 --> 00:24:43,000
>> Ce se întâmplă dacă în schimb când eu numesc de swap

450
00:24:43,000 --> 00:24:47,000
mai degrabă decât trecere în copii ale lui x și y

451
00:24:47,000 --> 00:24:51,000
de ce nu trec în locul în adresa lui x aici,

452
00:24:51,000 --> 00:24:55,000
adresa lui y aici, în esență, adresa poștală

453
00:24:55,000 --> 00:24:59,000
lui x și y, deoarece swap, în cazul în care el este informat

454
00:24:59,000 --> 00:25:01,000
a adresa în memoria lui x și y,

455
00:25:01,000 --> 00:25:04,000
apoi schimba, dacă ne-am antrenat-l un pic,

456
00:25:04,000 --> 00:25:07,000
el ar putea conduce, potențial, la acea adresă, ca să spunem așa,

457
00:25:07,000 --> 00:25:11,000
x, și de a schimba numărul de acolo, conduce apoi la adresa de Y,

458
00:25:11,000 --> 00:25:16,000
modifica numărul de acolo, chiar și atunci când nu primesc de fapt, copii ale acestor valori el însuși,

459
00:25:16,000 --> 00:25:19,000
Deci, chiar daca am vorbit despre acest lucru ca fiind memoria principală a lui

460
00:25:19,000 --> 00:25:23,000
și acest swap ca fiind memoria puternic și partea periculoasă a C

461
00:25:23,000 --> 00:25:28,000
este că orice funcție poate atinge memoria oriunde în calculator,

462
00:25:28,000 --> 00:25:32,000
și acest lucru este puternic, în care poți face lucruri foarte fancy, cu programe de calculator în C.

463
00:25:32,000 --> 00:25:36,000
Acest lucru este periculos deoarece puteți bară de asemenea, foarte usor.

464
00:25:36,000 --> 00:25:39,000
De fapt, una dintre cele mai comune modalități de programe în aceste zile pentru a fi exploatate

465
00:25:39,000 --> 00:25:42,000
încă este pentru un programator, nu pentru a realiza

466
00:25:42,000 --> 00:25:45,000
că el sau ea este de a permite o serie de date

467
00:25:45,000 --> 00:25:49,000
să fie scrise într-o locație de memorie, în care nu a fost destinat.

468
00:25:49,000 --> 00:25:51,000
>> De exemplu, el sau ea declară o matrice de dimensiune 10

469
00:25:51,000 --> 00:25:56,000
dar apoi accidental încearcă să afișezi 11 octeți în faptul că matrice de memorie,

470
00:25:56,000 --> 00:25:59,000
și de a începe să atingeți părți ale memoriei care nu mai sunt valabile.

471
00:25:59,000 --> 00:26:02,000
Doar pentru a contextuale acest lucru, unii dintre voi s-ar putea știți că

472
00:26:02,000 --> 00:26:06,000
software-ul de multe ori vă solicită pentru numere de serie sau chei de înregistrare,

473
00:26:06,000 --> 00:26:08,000
Photoshop și Word și programe de acest gen.

474
00:26:08,000 --> 00:26:12,000
Există fisuri, așa cum unii dintre voi știți, online, unde puteți rula un mic program,

475
00:26:12,000 --> 00:26:14,000
și voila, nici o cerere mai mare pentru un număr de serie.

476
00:26:14,000 --> 00:26:16,000
Cum este că funcționează?

477
00:26:16,000 --> 00:26:21,000
În multe cazuri, aceste lucruri sunt pur și simplu găsirea în calculatoarele

478
00:26:21,000 --> 00:26:24,000
segmente de text în zerouri calculatorului reale și cele

479
00:26:24,000 --> 00:26:28,000
în cazul în care este această funcție în cazul în care numărul de serie se solicită,

480
00:26:28,000 --> 00:26:31,000
și vă suprascrie acel spatiu, sau în timp ce programul se execută

481
00:26:31,000 --> 00:26:33,000
vă puteți da seama de unde cheia este de fapt stocat

482
00:26:33,000 --> 00:26:37,000
folosind ceva numit un debugger, și puteți sparge software-ul în acest fel.

483
00:26:37,000 --> 00:26:40,000
Acest lucru nu este să spun că acest lucru este obiectivul nostru pentru urmatoarele doua zile,

484
00:26:40,000 --> 00:26:42,000
dar are foarte reale ramificații.

485
00:26:42,000 --> 00:26:45,000
Asta se întâmplă să implice furtul de software,

486
00:26:45,000 --> 00:26:47,000
dar există, de asemenea, compromis de mașini întregi.

487
00:26:47,000 --> 00:26:50,000
>> De fapt, atunci când site-uri web în aceste zile sunt exploatate

488
00:26:50,000 --> 00:26:53,000
și compromise și de date este scurgeri si parole sunt furate

489
00:26:53,000 --> 00:26:58,000
acest lucru foarte des se referă la gestionarea proastă a memoriei cuiva,

490
00:26:58,000 --> 00:27:01,000
sau, în cazul bazelor de date, incapacitatea de a anticipa

491
00:27:01,000 --> 00:27:03,000
intrare contradictorie, astfel mai mult pe faptul că, în următoarele săptămâni să vină,

492
00:27:03,000 --> 00:27:07,000
dar pentru moment doar o previzualizare a fel de daune pe care le puteți face

493
00:27:07,000 --> 00:27:11,000
prin faptul că nu înțelege destul de cum merg lucrurile sub capota.

494
00:27:11,000 --> 00:27:14,000
Să mergem despre a intelege de ce acest lucru este rupt

495
00:27:14,000 --> 00:27:17,000
cu un instrument care va deveni mai mult și mai util

496
00:27:17,000 --> 00:27:19,000
ca programele noastre devin mai complexe.

497
00:27:19,000 --> 00:27:21,000
Astfel, de departe atunci când ai avut un bug în program

498
00:27:21,000 --> 00:27:23,000
cum te-ai dus despre depanarea asta?

499
00:27:23,000 --> 00:27:25,000
Care au fost tehnicile de până acum, indiferent dacă predate de TF dvs.

500
00:27:25,000 --> 00:27:27,000
sau pur si simplu autodidact?

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

502
00:27:29,000 --> 00:27:31,000
Printf, deci printf a fost, probabil, prietenul tău în care, dacă doriți să vedeți

503
00:27:31,000 --> 00:27:33,000
ce se întâmplă în interiorul programului

504
00:27:33,000 --> 00:27:36,000
tocmai l-ați pus printf aici, printf aici, printf aici.

505
00:27:36,000 --> 00:27:38,000
Atunci când îl rulați, și veți obține o grămadă de chestii pe ecran

506
00:27:38,000 --> 00:27:43,000
pe care le puteți utiliza pentru a deduce, atunci ceea ce se întâmplă de fapt greșit în programul tău.

507
00:27:43,000 --> 00:27:45,000
>> Printf tinde să fie un lucru foarte puternic,

508
00:27:45,000 --> 00:27:47,000
dar este un proces foarte manual.

509
00:27:47,000 --> 00:27:49,000
Trebuie sa pui un printf aici, o printf aici,

510
00:27:49,000 --> 00:27:51,000
si daca o pui in interiorul unei bucle s-ar putea obține 100 de linii

511
00:27:51,000 --> 00:27:53,000
de ieșire pe care trebuie sa te cerne prin intermediul.

512
00:27:53,000 --> 00:27:58,000
Nu e un mecanism foarte user-friendly sau interactiv pentru programe de depanare,

513
00:27:58,000 --> 00:28:00,000
dar din fericire există alternative.

514
00:28:00,000 --> 00:28:03,000
Există un program, de exemplu, numit GDB, Debugger GNU,

515
00:28:03,000 --> 00:28:06,000
care este un pic obscură în modul în care îl utilizați.

516
00:28:06,000 --> 00:28:08,000
E un complex pic, dar, sincer,

517
00:28:08,000 --> 00:28:11,000
acesta este unul dintre acele lucruri pe care, dacă ați pus în această săptămână și viitoare

518
00:28:11,000 --> 00:28:14,000
ora in plus de a înțelege ceva de genul GDB

519
00:28:14,000 --> 00:28:18,000
acesta va salva, probabil, zeci de ore pe termen lung,

520
00:28:18,000 --> 00:28:21,000
Și cu asta, permiteți-mi să vă dau un teaser a modului în care acest lucru functioneaza.

521
00:28:21,000 --> 00:28:23,000
>> Sunt într-o fereastră terminalul meu.

522
00:28:23,000 --> 00:28:26,000
Lasă-mă să merg mai departe și compila acest program, buggy3.

523
00:28:26,000 --> 00:28:28,000
E deja până la data de.

524
00:28:28,000 --> 00:28:31,000
Lasă-mă să-l rulați la fel cum am facut-o înapoi în timp, și într-adevăr, e rupt.

525
00:28:31,000 --> 00:28:34,000
Dar de ce este acest lucru? Poate am greșit funcția de swap.

526
00:28:34,000 --> 00:28:37,000
Poate e un și b. Eu nu sunt destul de ei se deplasează în jurul valorii de corect.

527
00:28:37,000 --> 00:28:39,000
Lasă-mă să mergeți mai departe și de a face acest lucru.

528
00:28:39,000 --> 00:28:43,000
Mai degrabă decât doar să rulați buggy3 lasă-mă să ruleze în locul acestui program de GDB,

529
00:28:43,000 --> 00:28:48,000
și am de gând să-l spun pentru a rula buggy3,

530
00:28:48,000 --> 00:28:52,000
și am de gând să includă un argument linie de comandă, TUI-,

531
00:28:52,000 --> 00:28:55,000
și vom pune acest lucru în probleme viitoare la spec. să amintesc.

532
00:28:55,000 --> 00:28:57,000
Și acum această interfață în alb și negru a apărut, încă o dată,

533
00:28:57,000 --> 00:28:59,000
este un pic copleșitoare la început, deoarece există toate astea

534
00:28:59,000 --> 00:29:02,000
Informații garanție aici, dar cel puțin e ceva familiar.

535
00:29:02,000 --> 00:29:04,000
În partea de sus a ferestrei este codul meu real,

536
00:29:04,000 --> 00:29:08,000
și dacă am derula aici lasă-mă să derulați până la foarte de sus a dosarul meu,

537
00:29:08,000 --> 00:29:11,000
și într-adevăr, nu e buggy3.c, și observați în partea de jos a acestei ferestre

538
00:29:11,000 --> 00:29:13,000
Am acest prompt GDB.

539
00:29:13,000 --> 00:29:16,000
>> Acest lucru nu este același ca și meu obișnuit John Harvard promptă.

540
00:29:16,000 --> 00:29:19,000
Acesta este un prompt care va permite-mi să controleze GDB.

541
00:29:19,000 --> 00:29:21,000
GDB este un program de depanare.

542
00:29:21,000 --> 00:29:24,000
Un debugger este un program care vă permite să se plimbe prin

543
00:29:24,000 --> 00:29:27,000
executarea de linie programul de linie cu linie,

544
00:29:27,000 --> 00:29:30,000
de-a lungul modul în care faci tot ce vrei să programului,

545
00:29:30,000 --> 00:29:33,000
de asteptare chiar funcții, sau caută, mai important,

546
00:29:33,000 --> 00:29:35,000
la valori variabile diferite lui.

547
00:29:35,000 --> 00:29:37,000
Să mergem mai departe și de a face acest lucru.

548
00:29:37,000 --> 00:29:40,000
Am de gând să merg mai departe și tastați în termen de la promptul de GDB lui,

549
00:29:40,000 --> 00:29:43,000
astfel observa la partea din stânga jos a ecranului am tastat alerga,

550
00:29:43,000 --> 00:29:45,000
și am lovit intra, și ce a făcut asta?

551
00:29:45,000 --> 00:29:50,000
Ea a fugit literalmente programul meu, dar nu am vedea de fapt mult mai merge pe aici

552
00:29:50,000 --> 00:29:55,000
pentru că nu am spus de fapt, depanatorul

553
00:29:55,000 --> 00:29:57,000
pentru a întrerupe la un moment dat în timp.

554
00:29:57,000 --> 00:29:59,000
Tastarea doar pe termen ruleaza programul.

555
00:29:59,000 --> 00:30:01,000
Nu văd de fapt nimic. Eu nu pot manipula.

556
00:30:01,000 --> 00:30:03,000
>> În schimb lasă-mă să fac asta.

557
00:30:03,000 --> 00:30:08,000
La acest prompt GDB permiteți-mi să tastați în schimb pauză, introduceți.

558
00:30:08,000 --> 00:30:10,000
Asta nu e ceea ce am vrut să tastați.

559
00:30:10,000 --> 00:30:13,000
Să tastați în schimb pauză principal.

560
00:30:13,000 --> 00:30:15,000
Cu alte cuvinte, vreau să setați un punct de întrerupere ceva numit,

561
00:30:15,000 --> 00:30:18,000
care este pe bună dreptate numit, deoarece ea va rupe sau întrerupe

562
00:30:18,000 --> 00:30:21,000
executarea de programul tau la locul respectiv.

563
00:30:21,000 --> 00:30:23,000
Principal este numele de funcția mea.

564
00:30:23,000 --> 00:30:25,000
Observați că GDB este destul de inteligent.

565
00:30:25,000 --> 00:30:28,000
A dat seama că se întâmplă principal pentru a porni de la aproximativ linia 18

566
00:30:28,000 --> 00:30:32,000
de buggy3.c, și observați apoi aici, la stânga-sus

567
00:30:32,000 --> 00:30:34,000
b + este chiar lângă linia de 18.

568
00:30:34,000 --> 00:30:38,000
Asta amintindu-mi că am stabilit un punct de control la linia 18.

569
00:30:38,000 --> 00:30:42,000
De data aceasta, când am tip alerga, am de gând să ruleze programul meu

570
00:30:42,000 --> 00:30:45,000
până când se atinge breakpoint că,

571
00:30:45,000 --> 00:30:48,000
astfel încât programul se va opri pentru mine la linia 18.

572
00:30:48,000 --> 00:30:50,000
Aici vom merge, alerga.

573
00:30:50,000 --> 00:30:53,000
Nimic nu pare să se fi întâmplat, dar atenție la partea din stânga jos

574
00:30:53,000 --> 00:30:58,000
Programul de pornire, buggy3, breakpoint 1 în principal la linia buggy3.c 18.

575
00:30:58,000 --> 00:31:00,000
Ce pot să fac acum?

576
00:31:00,000 --> 00:31:03,000
>> Observați că pot începe tastarea lucruri, cum ar fi imprimare,

577
00:31:03,000 --> 00:31:08,000
Nu printf, x imprimare, și acum, că e ciudat.

578
00:31:08,000 --> 00:31:11,000
$ 1 este doar o curiozitate, așa cum vom vedea

579
00:31:11,000 --> 00:31:14,000
de fiecare dată când imprimați ceva ce obține o nouă valoare $.

580
00:31:14,000 --> 00:31:18,000
Asta e, astfel încât să vă puteți referi înapoi la valorile anterioare doar în cazul,

581
00:31:18,000 --> 00:31:21,000
dar de acum ceea ce mi-a spus de imprimare este este faptul că valoarea lui x, la acest moment, în povestea

582
00:31:21,000 --> 00:31:26,000
este aparent 134514032.

583
00:31:26,000 --> 00:31:29,000
Ce? În cazul în care a făcut asta, chiar provin de la?

584
00:31:29,000 --> 00:31:31,000
[Imperceptibil-elev]

585
00:31:31,000 --> 00:31:34,000
Într-adevăr, aceasta este ceea ce vom numi o valoare de gunoi, și nu ne-am vorbit despre asta încă,

586
00:31:34,000 --> 00:31:37,000
dar motivul pentru care ați inițializa variabilele

587
00:31:37,000 --> 00:31:40,000
este, evident, astfel încât acestea să aibă o anumită valoare pe care doriți să le aibă.

588
00:31:40,000 --> 00:31:44,000
Dar captura este reamintesc că puteți declara variabile

589
00:31:44,000 --> 00:31:46,000
cum am făcut-o clipă în urmă, în exemplul meu sigma

590
00:31:46,000 --> 00:31:48,000
fără de fapt, oferindu-le o valoare.

591
00:31:48,000 --> 00:31:50,000
Amintesc ce am făcut aici, în Sigma.

592
00:31:50,000 --> 00:31:52,000
Eu n declarat, dar ce valoare l-am dat?

593
00:31:52,000 --> 00:31:56,000
Nici una, pentru că știam că, în următoarele câteva linii

594
00:31:56,000 --> 00:31:59,000
GetInt va avea grijă de problema de a pune o valoare a lui n interiorul.

595
00:31:59,000 --> 00:32:02,000
>> Dar, în acest moment, în povestea line 11

596
00:32:02,000 --> 00:32:05,000
și 12 linie și linia 13 și linia 14

597
00:32:05,000 --> 00:32:08,000
de-a lungul acestor linii de mai multe ceea ce este valoarea lui n?

598
00:32:08,000 --> 00:32:10,000
În C pur si simplu nu stiu.

599
00:32:10,000 --> 00:32:14,000
E, în general, o valoare gunoi, un numar complet aleatoare

600
00:32:14,000 --> 00:32:17,000
care a rămas în esență, din peste o funcție anterioară

601
00:32:17,000 --> 00:32:21,000
au fost executați, în așa fel încât programul se execută

602
00:32:21,000 --> 00:32:24,000
Reamintim că funcția devine funcție, funcția, funcția.

603
00:32:24,000 --> 00:32:27,000
Toate aceste cadre se pune pe memorie, iar apoi cei retur funcții,

604
00:32:27,000 --> 00:32:31,000
și așa cum am sugerat, cu radiera memoria lor este în cele din urmă reutilizate.

605
00:32:31,000 --> 00:32:37,000
Ei bine, ea doar se întâmplă, astfel încât aceasta variabila x în acest program

606
00:32:37,000 --> 00:32:41,000
pare să fi conținut o valoare gunoi ca 134514032

607
00:32:41,000 --> 00:32:44,000
de la unele funcția anterioară, nu una pe care am scris-o.

608
00:32:44,000 --> 00:32:47,000
Ar putea fi ceva care vine în mod eficient cu sistemul de operare,

609
00:32:47,000 --> 00:32:49,000
o anumită funcție de sub capota.

610
00:32:49,000 --> 00:32:52,000
>> Bine, asta e bine, dar hai acum trece la următoarea linie.

611
00:32:52,000 --> 00:32:55,000
Dacă aș tip "next" la GDB promptă meu și l-am lovit intra,

612
00:32:55,000 --> 00:32:58,000
observați că se mută în jos pentru a evidenția linia 19,

613
00:32:58,000 --> 00:33:01,000
dar implicație logică este că linia 18

614
00:33:01,000 --> 00:33:06,000
acum a terminat de executare, astfel încât, dacă tip I din nou "print x"

615
00:33:06,000 --> 00:33:10,000
Ar trebui să vedeți acum 1, și într-adevăr, să fac.

616
00:33:10,000 --> 00:33:14,000
Din nou, lucrurile $ este o modalitate de a GDB, amintindu-vă

617
00:33:14,000 --> 00:33:17,000
ceea ce istoria de printuri sunt pe care le-ați făcut.

618
00:33:17,000 --> 00:33:21,000
Acum, lasă-mă să merg mai departe și tipări y, și într-adevăr, y este o anumită valoare, precum și nebun,

619
00:33:21,000 --> 00:33:24,000
dar nu e mare lucru, deoarece, în linia 19 suntem pe cale să le atribuie

620
00:33:24,000 --> 00:33:27,000
valoarea 2, asa ca lasa-ma tastați "Next" din nou.

621
00:33:27,000 --> 00:33:29,000
Și acum suntem pe linia printf.

622
00:33:29,000 --> 00:33:31,000
Lasă-mă să fac x imprimare.

623
00:33:31,000 --> 00:33:34,000
Lasă-mă să fac y imprimare. Sincer, eu sunt un pic cam obosit de imprimare asta.

624
00:33:34,000 --> 00:33:38,000
Lasă-mă să tastați în loc "afișare x" și "y ecran,"

625
00:33:38,000 --> 00:33:41,000
si acum de fiecare dată când tastați o comandă în viitor

626
00:33:41,000 --> 00:33:45,000
Eu voi fi amintit de ceea ce este x și y, ceea ce este x și y, ceea ce este x și y.

627
00:33:45,000 --> 00:33:48,000
>> Eu pot, de asemenea, ca o parte, de tip în "localnici info."

628
00:33:48,000 --> 00:33:50,000
Info este o comandă specială.

629
00:33:50,000 --> 00:33:52,000
Localnicii înseamnă că-mi arată variabilele locale.

630
00:33:52,000 --> 00:33:55,000
Doar în cazul în care mi-am uitat sau aceasta este o funcție nebun, complicat

631
00:33:55,000 --> 00:33:57,000
că am sau altcineva a scris localnici informatiile vă va spune

632
00:33:57,000 --> 00:34:00,000
Care sunt toate variabilele locale din interiorul această funcție locală

633
00:34:00,000 --> 00:34:03,000
care v-ar pasa daca vrei sa scoti in jurul.

634
00:34:03,000 --> 00:34:07,000
Acum, printf este pe cale să execute, deci lasă-mă să merg mai departe și doar tipul "Next".

635
00:34:07,000 --> 00:34:10,000
Pentru că suntem în acest mediu nu suntem de fapt, să-l văd

636
00:34:10,000 --> 00:34:14,000
executa aici, dar observați că acesta e un pic cam mangled aici.

637
00:34:14,000 --> 00:34:17,000
Dar observați că acesta este imperative ecran acolo,

638
00:34:17,000 --> 00:34:21,000
deci nu e un program perfect aici, dar asta e bine pentru că eu pot băga mereu în jurul valorii de

639
00:34:21,000 --> 00:34:23,000
utilizarea de imprimare dacă vreau.

640
00:34:23,000 --> 00:34:26,000
>> Lasă-mă să tastați Next din nou, iar acum aici e partea interesanta.

641
00:34:26,000 --> 00:34:29,000
În acest moment, în povestea y este 2, iar x este 1,

642
00:34:29,000 --> 00:34:32,000
cum sa sugerat aici, și, din nou,

643
00:34:32,000 --> 00:34:35,000
motivul pentru care acest este automat afișarea acum este pentru că am folosit comanda

644
00:34:35,000 --> 00:34:40,000
afișare x și y ecran, astfel încât momentul în care am introduce următoarea

645
00:34:40,000 --> 00:34:43,000
în teorie x și y ar trebui să devină schimbate.

646
00:34:43,000 --> 00:34:45,000
Acum, știm deja că nu va fi cazul,

647
00:34:45,000 --> 00:34:49,000
dar vom vedea într-un moment cum putem scufunda mai adânc pentru a afla de ce e adevărat.

648
00:34:49,000 --> 00:34:54,000
În continuare, și, din păcate, este încă y 2 și x este încă 1, și pot să confirm la fel de mult.

649
00:34:54,000 --> 00:34:56,000
Imprimare x, y imprimare.

650
00:34:56,000 --> 00:34:59,000
Într-adevăr, nici schimbarea sa întâmplat de fapt, așa că hai să înceapă peste asta.

651
00:34:59,000 --> 00:35:01,000
În mod clar de swap este rupt.

652
00:35:01,000 --> 00:35:04,000
Să tastați loc "Run" din nou.

653
00:35:04,000 --> 00:35:07,000
Permiteți-mi să spun da, vreau să-l reporniți de la început, introduceți.

654
00:35:07,000 --> 00:35:09,000
>> Acum m-am întors până la linia de 18.

655
00:35:09,000 --> 00:35:11,000
Acum observați x și y sunt valori de gunoi din nou.

656
00:35:11,000 --> 00:35:15,000
Următor, în continuare, în continuare, următoarea.

657
00:35:15,000 --> 00:35:17,000
Dacă m-am plictisit eu pot, de asemenea, să tastați n pentru viitor.

658
00:35:17,000 --> 00:35:21,000
Puteți să-l abrevierea pentru secventa mai scurt posibil de caractere.

659
00:35:21,000 --> 00:35:23,000
Swap este acum rupt.

660
00:35:23,000 --> 00:35:25,000
Haideti sa patrundem in, astfel încât în ​​loc să tastați următoarea,

661
00:35:25,000 --> 00:35:30,000
acum am de gând să tastați pas, astfel că am pășit în interiorul acestei funcții

662
00:35:30,000 --> 00:35:33,000
astfel încât să pot merge prin ea, asa ca am lovit pas și apoi introduceți.

663
00:35:33,000 --> 00:35:37,000
Observați că sare în jos evidențiază mai mică în programul meu pentru linia 36.

664
00:35:37,000 --> 00:35:39,000
Acum, ce sunt variabilele locale?

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

666
00:35:41,000 --> 00:35:43,000
Nimic încă pentru că nu am ajuns la acea linie,

667
00:35:43,000 --> 00:35:47,000
așa că hai să mergem mai departe și spun "Next".

668
00:35:47,000 --> 00:35:50,000
Acum, se pare că avem tmp, tmp de imprimare.

669
00:35:50,000 --> 00:35:52,000
Valoarea gunoi, nu? Așa cred.

670
00:35:52,000 --> 00:35:55,000
Cum imprima despre o, imprimare b, 1 și 2?

671
00:35:55,000 --> 00:35:58,000
Într-un moment, de îndată ce am Următorul tip nou

672
00:35:58,000 --> 00:36:02,000
tmp este de gând să ia o valoare de 1, sperăm,

673
00:36:02,000 --> 00:36:05,000
deoarece tmp va fi atribuit valoarea unei.

674
00:36:05,000 --> 00:36:08,000
>> Acum, haideți să nu imprimați o, b imprimare,

675
00:36:08,000 --> 00:36:11,000
dar imprima acum tmp, și este, într-adevăr 1.

676
00:36:11,000 --> 00:36:14,000
Lasă-mă să fac în continuare. Lasă-mă să fac în continuare.

677
00:36:14,000 --> 00:36:16,000
Am terminat funcția de swap.

678
00:36:16,000 --> 00:36:19,000
Sunt încă în interiorul ei, în linia 40, asa ca lasa-ma imprima o,

679
00:36:19,000 --> 00:36:22,000
b imprimare, și nu-mi pasă ce tmp este.

680
00:36:22,000 --> 00:36:27,000
Se pare ca de swap este corectă atunci când vine vorba de pompare a și b.

681
00:36:27,000 --> 00:36:31,000
Dar dacă aș scrie acum următoare, am sări înapoi la linia 25,

682
00:36:31,000 --> 00:36:34,000
și, bineînțeles, dacă am tip în x și y imprimare

683
00:36:34,000 --> 00:36:38,000
ei sunt încă neschimbate, deci nu am rezolvat problema.

684
00:36:38,000 --> 00:36:41,000
Dar acum, probabil diagnostic cu acest program GDB

685
00:36:41,000 --> 00:36:44,000
am primit cel puțin un pas mai aproape de intelegerea

686
00:36:44,000 --> 00:36:47,000
ceea ce se întâmplă rău, fără a fi nevoie să așternut codul nostru de a pune o printf aici,

687
00:36:47,000 --> 00:36:50,000
printf aici, aici și printf apoi difuzate din nou și din nou

688
00:36:50,000 --> 00:36:52,000
încercând să dau seama ce se întâmplă greșit.

689
00:36:52,000 --> 00:36:55,000
>> Am de gând să mergeți mai departe și din acest renunta cu totul cu demisia.

690
00:36:55,000 --> 00:36:57,000
Se va spune, atunci, "Quit oricum?" Da.

691
00:36:57,000 --> 00:37:00,000
Acum m-am intors de la promptul meu normal, si am terminat cu ajutorul GDB.

692
00:37:00,000 --> 00:37:03,000
Ca o paranteza, nu aveți nevoie pentru a utiliza aceasta-tui pavilion.

693
00:37:03,000 --> 00:37:07,000
De fapt, dacă o veți obține în esență, omite jumătatea de jos a ecranului.

694
00:37:07,000 --> 00:37:11,000
Dacă aș apoi tastați pauza principal și apoi executați

695
00:37:11,000 --> 00:37:15,000
Eu pot rula în continuare programul meu, dar ceea ce va face este mai mult textual

696
00:37:15,000 --> 00:37:18,000
Doar arată-mi o linie curentă la un moment dat.

697
00:37:18,000 --> 00:37:21,000
TUI-, interfața cu utilizatorul textuală,

698
00:37:21,000 --> 00:37:25,000
doar vă arată mai mult a programului dintr-o dată, ceea ce este, probabil, un pic mai ușor conceptual.

699
00:37:25,000 --> 00:37:27,000
Dar, într-adevăr, pot face chiar lângă, în continuare, în continuare,

700
00:37:27,000 --> 00:37:30,000
și am de gând să văd o linie la un moment dat, și dacă chiar vreau să văd ce se întâmplă

701
00:37:30,000 --> 00:37:35,000
Am posibilitatea să tastați listă și a vedea o grămadă de linii vecine.

702
00:37:35,000 --> 00:37:39,000
>> E un film care le-am cerut să te uiți pentru problema seturi 3

703
00:37:39,000 --> 00:37:43,000
în care Nate se referă la unele dintre complicațiile GDB,

704
00:37:43,000 --> 00:37:46,000
iar acesta este unul dintre acele lucruri, sincer, în cazul în care un anumit procentaj non-triviale de tine

705
00:37:46,000 --> 00:37:49,000
niciodată nu va atinge GDB, și că va fi un lucru rău

706
00:37:49,000 --> 00:37:53,000
deoarece literalmente vei sfârși prin a petrece mai mult timp în cursul acestui semestru

707
00:37:53,000 --> 00:37:56,000
alungare jos bug-uri, atunci ar fi dacă ați pus în jumătate de oră / oră

708
00:37:56,000 --> 00:38:00,000
în această săptămână și de învățare următoare pentru a obține confortabil cu GDB.

709
00:38:00,000 --> 00:38:02,000
Printf a fost prietenul tău.

710
00:38:02,000 --> 00:38:05,000
GDB ar trebui sa fie acum prietenul tău.

711
00:38:05,000 --> 00:38:08,000
>> Orice întrebări cu privire la GDB?

712
00:38:08,000 --> 00:38:12,000
Și aici o listă scurtă a unora dintre comenzile cele mai puternice si folositoare.

713
00:38:12,000 --> 00:38:15,000
Da. >> Se poate imprima un șir?

714
00:38:15,000 --> 00:38:17,000
Poți să imprimați un șir? Absolut.

715
00:38:17,000 --> 00:38:19,000
Aceasta nu trebuie să fie doar întregi.

716
00:38:19,000 --> 00:38:22,000
În cazul în care o variabila este un șir de tip doar în s. imprimare.

717
00:38:22,000 --> 00:38:24,000
Acesta vă va arăta ce variabila șir este.

718
00:38:24,000 --> 00:38:26,000
[Imperceptibil-elev]

719
00:38:26,000 --> 00:38:28,000
Acesta vă va oferi adresa și șirul în sine.

720
00:38:28,000 --> 00:38:32,000
Acesta va arăta pe amândoi.

721
00:38:32,000 --> 00:38:34,000
Si inca un lucru trecut, doar pentru că acestea sunt bine de știut prea.

722
00:38:34,000 --> 00:38:37,000
Backtrace și cadru, lasă-mă să se arunca cu capul în acest moment ultima,

723
00:38:37,000 --> 00:38:39,000
Programul exact aceeasi cu GDB.

724
00:38:39,000 --> 00:38:44,000
Lasă-mă să mergeți mai departe și a alerga textuală versiunea interfața cu utilizatorul,

725
00:38:44,000 --> 00:38:46,000
rupe principal.

726
00:38:46,000 --> 00:38:49,000
Lasă-mă să mergeți mai departe și a alerga din nou. Iată-mă.

727
00:38:49,000 --> 00:38:55,000
Acum, lasă-mă să mergem, în continuare, în continuare, următoarea, în continuare, pas, introduceți.

728
00:38:55,000 --> 00:39:00,000
>> Și acum să presupunem că eu sunt acum în mod deliberat de swap, dar eu zic "La naiba, ce a fost valoarea lui x?"

729
00:39:00,000 --> 00:39:02,000
Eu nu pot face x mai.

730
00:39:02,000 --> 00:39:05,000
Eu nu pot face y, deoarece acestea nu sunt în sfera de aplicare.

731
00:39:05,000 --> 00:39:07,000
Ei nu sunt în context, dar nici o problema.

732
00:39:07,000 --> 00:39:09,000
Pot tip backtrace.

733
00:39:09,000 --> 00:39:13,000
Asta imi arata toate funcțiile de care s-au executate până la acest moment.

734
00:39:13,000 --> 00:39:16,000
Observați că una pe partea de jos, principal, se aliniază cu principal

735
00:39:16,000 --> 00:39:18,000
fiind la partea de jos a imaginii noastre de aici.

736
00:39:18,000 --> 00:39:22,000
Faptul că swap este deasupra ei linii de swap cu a fi mai sus, în memoria aici,

737
00:39:22,000 --> 00:39:26,000
și dacă vreau să mă întorc la principala temporar pot sa spun "cadru".

738
00:39:26,000 --> 00:39:30,000
Ce numar? Principal este cadru # 1.

739
00:39:30,000 --> 00:39:32,000
Am de gând să merg mai departe și spun "cadru 1."

740
00:39:32,000 --> 00:39:36,000
>> Acum m-am întors în principal, și eu pot imprima x, si pot imprima y,

741
00:39:36,000 --> 00:39:40,000
dar nu pot imprima pe a sau b.

742
00:39:40,000 --> 00:39:43,000
Dar eu pot, dacă spun, "Bine, stai un minut În cazul în care a fost de swap?".

743
00:39:43,000 --> 00:39:46,000
Lasă-mă să mergeți mai departe și spun "0 cadru."

744
00:39:46,000 --> 00:39:48,000
Acum m-am întors de unde vreau sa fie, si ca o paranteza,

745
00:39:48,000 --> 00:39:52,000
există alte comenzi prea, cum ar fi dacă într-adevăr vei primi dactilografiere plictisesc următoare, în continuare, în continuare, următoarea,

746
00:39:52,000 --> 00:39:56,000
vă pot spune, în general, lucruri de genul "urmatoarele 10," și că va parcurge următoarele 10 de linii.

747
00:39:56,000 --> 00:39:59,000
Puteți scrie, de asemenea, "continua" atunci când vei ajunge într-adevăr hrănite cu intensificarea prin ea.

748
00:39:59,000 --> 00:40:05,000
Continua programul va rula fără întrerupere până când lovește un alt punct de întrerupere,

749
00:40:05,000 --> 00:40:07,000
dacă într-o buclă sau scădea în programul tău.

750
00:40:07,000 --> 00:40:11,000
>> În acest caz, am continuat până la capăt, iar programul a ieșit în mod normal.

751
00:40:11,000 --> 00:40:13,000
Acesta este un mod fantezist, procesul inferior.

752
00:40:13,000 --> 00:40:16,000
Doar programul ieșit în mod normal.

753
00:40:16,000 --> 00:40:24,000
Mai mult pe faptul că, în video și sesiuni de depanare în a veni.

754
00:40:24,000 --> 00:40:26,000
Asta a fost o foarte mult.

755
00:40:26,000 --> 00:40:35,000
Să luăm de 5 minute de pauză aici, iar noi vom reveni cu struct și fișiere.

756
00:40:35,000 --> 00:40:38,000
>> Dacă ați plonjat în PSET această săptămână deja

757
00:40:38,000 --> 00:40:41,000
veți ști pe care le folosim în codul de distribuție,

758
00:40:41,000 --> 00:40:45,000
codul sursă pe care vi le oferim ca un punct de plecare, unele tehnici noi.

759
00:40:45,000 --> 00:40:50,000
În special, am introdus acest cuvânt cheie nou numit struct, pentru structura,

760
00:40:50,000 --> 00:40:53,000
astfel încât să putem crea variabile personalizate de soiuri.

761
00:40:53,000 --> 00:40:57,000
Am introdus, de asemenea, noțiunea de intrare fișier fișier I / O, și de ieșire,

762
00:40:57,000 --> 00:41:00,000
și acest lucru este astfel încât să putem salva de stat

763
00:41:00,000 --> 00:41:03,000
de bord Scramble într-un fișier pe disc

764
00:41:03,000 --> 00:41:06,000
astfel încât colegii de predare și pot să înțeleg

765
00:41:06,000 --> 00:41:09,000
ce se întâmplă în interiorul programului, fără a fi nevoie să joace manual

766
00:41:09,000 --> 00:41:11,000
zeci de jocuri de Scramble.

767
00:41:11,000 --> 00:41:13,000
Putem face acest lucru mai automatedly.

768
00:41:13,000 --> 00:41:18,000
>> Această idee a unei structuri rezolvă o problemă destul de convingătoare.

769
00:41:18,000 --> 00:41:21,000
Să presupunem că dorim să pună în aplicare programul de unele

770
00:41:21,000 --> 00:41:25,000
care ține evidența într-un fel de informații cu privire la elevi,

771
00:41:25,000 --> 00:41:28,000
și studenții ar putea avea, de exemplu, un ID, un nume

772
00:41:28,000 --> 00:41:31,000
și o casă într-un loc ca la Harvard, astfel încât acestea sunt de 3 bucăți de informații

773
00:41:31,000 --> 00:41:34,000
vrem să păstreze în jurul valorii de, asa ca lasa-ma sa plec mai departe și începe să scrie un mic program aici,

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

775
00:41:38,000 --> 00:41:42,000
Lasă-mă să fac includ cs50.h.

776
00:41:42,000 --> 00:41:44,000
Și apoi începe funcția mea principală.

777
00:41:44,000 --> 00:41:46,000
Nu voi deranja cu orice argumente de linie de comandă,

778
00:41:46,000 --> 00:41:49,000
și aici vreau să am un student, așa că am de gând să spun

779
00:41:49,000 --> 00:41:54,000
un student are un nume, așa că am de gând să spun "nume șir."

780
00:41:54,000 --> 00:41:59,000
Apoi, am de gând să spun un student are, de asemenea, un act de identitate, codul de identificare astfel int,

781
00:41:59,000 --> 00:42:03,000
și un student are o casă, așa că am de gând să spun, de asemenea, "casa șir."

782
00:42:03,000 --> 00:42:06,000
Atunci voi comanda aceste pic mai curat-o ca asta.

783
00:42:06,000 --> 00:42:11,000
Ok, acum am 3 variabile cu care să reprezintă un student, deci "un student."

784
00:42:11,000 --> 00:42:15,000
>> Și acum vreau să populeze aceste valori, asa ca lasa-ma sa plec mai departe și spune ceva de genul

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

786
00:42:18,000 --> 00:42:21,000
Numele este mergi la a lua pe David.

787
00:42:21,000 --> 00:42:24,000
Să spunem casa este mergi la a lua Mather,

788
00:42:24,000 --> 00:42:31,000
și apoi am de gând să fac ceva arbitrar ca printf ("% s,

789
00:42:31,000 --> 00:42:37,000
a cărui identitate este% d, locuiește în s.%.

790
00:42:37,000 --> 00:42:41,000
Și acum, ce vreau să conectați aici, unul după altul?

791
00:42:41,000 --> 00:42:47,000
Nume, id, casa; return 0.

792
00:42:47,000 --> 00:42:50,000
Bine, dacă nu am greșit undeva aici

793
00:42:50,000 --> 00:42:54,000
Cred că avem un program destul de bun care stochează un elev.

794
00:42:54,000 --> 00:42:57,000
Desigur, asta nu este tot ceea ce interesant. Ce se întâmplă dacă doriți să aveți 2 studenți?

795
00:42:57,000 --> 00:42:59,000
Asta nu e mare lucru. Eu pot sprijini 2 persoane.

796
00:42:59,000 --> 00:43:03,000
Lasă-mă să mergeți mai departe și de a evidenția acest lucru și du-te în jos aici,

797
00:43:03,000 --> 00:43:09,000
si eu pot spune "id = 456" pentru cineva ca Rob care locuieste in Kirkland.

798
00:43:09,000 --> 00:43:12,000
>> Bine, stai, dar eu nu pot apela aceste același lucru,

799
00:43:12,000 --> 00:43:15,000
si se pare ca am de gând să aibă de a copia acest lucru,

800
00:43:15,000 --> 00:43:19,000
asa ca lasa-mi să spun că acestea vor fi variabile lui David,

801
00:43:19,000 --> 00:43:23,000
și lasă-mă să iau niște copii ale acestora pentru Rob.

802
00:43:23,000 --> 00:43:27,000
Vom numi aceste lui Rob, dar acest lucru nu este de gând să lucreze acum

803
00:43:27,000 --> 00:43:33,000
deoarece am-aștept, să-mi schimbe la ID1, NAME1 și house1.

804
00:43:33,000 --> 00:43:35,000
Rob va fi de 2, 2.

805
00:43:35,000 --> 00:43:42,000
Am să schimbe acest lucru aici, aici, aici, aici, aici, aici.

806
00:43:42,000 --> 00:43:45,000
Stai, ce zici de Tommy? Hai să facem asta din nou.

807
00:43:45,000 --> 00:43:49,000
Evident, dacă încă mai cred aceasta este o modalitate buna de a face acest lucru, nu este,

808
00:43:49,000 --> 00:43:52,000
astfel copy / paste rău.

809
00:43:52,000 --> 00:43:55,000
Dar am rezolvat asta acum o săptămână.

810
00:43:55,000 --> 00:43:59,000
>> Care a fost soluția noastră atunci când ne-am dorit să avem mai multe instanțe de același tip de date?

811
00:43:59,000 --> 00:44:01,000
Elevii [] O matrice.

812
00:44:01,000 --> 00:44:03,000
O matrice, asa ca lasa-ma sa incerc sa curat asta.

813
00:44:03,000 --> 00:44:07,000
Lasă-mă să fac ceva loc pentru mine în partea de sus, și lasă-mă să fac asta în locul aici.

814
00:44:07,000 --> 00:44:12,000
Vom chema pe acești oameni, și în loc să mă duc să spun "id-uri de int,"

815
00:44:12,000 --> 00:44:14,000
și am de gând să sprijine 3 dintre noi de acum.

816
00:44:14,000 --> 00:44:18,000
Am de gând să spun "nume șir," și voi sprijini 3 din noi,

817
00:44:18,000 --> 00:44:22,000
si apoi am de gând să spun "case de coarde," și am de gând să sprijine 3 din noi.

818
00:44:22,000 --> 00:44:26,000
Acum in locul lui David, aici a obține variabilele sale locale proprii

819
00:44:26,000 --> 00:44:28,000
putem scăpa de ele.

820
00:44:28,000 --> 00:44:30,000
Asta se simte bine că suntem de curățare asta.

821
00:44:30,000 --> 00:44:35,000
Pot spune atunci David va fi [0] și numele [0]

822
00:44:35,000 --> 00:44:38,000
și case [0].

823
00:44:38,000 --> 00:44:41,000
Și apoi Rob ne poate salva în mod similar în acest sens.

824
00:44:41,000 --> 00:44:46,000
Să punem asta aici, asa ca va fi arbitrar id-uri [1].

825
00:44:46,000 --> 00:44:50,000
El va fi nume [1],

826
00:44:50,000 --> 00:44:53,000
și apoi în cele din urmă, case [1].

827
00:44:53,000 --> 00:44:57,000
>> Încă un pic plictisitoare, și acum am să dau asta,

828
00:44:57,000 --> 00:45:03,000
așa că hai să spunem "nume [0], id-ul [0], case [0],

829
00:45:03,000 --> 00:45:06,000
si sa trece la plural acest lucru.

830
00:45:06,000 --> 00:45:09,000
Id-uri de, id-uri, id-uri.

831
00:45:09,000 --> 00:45:12,000
Și din nou, eu o fac, așa că, din nou, eu sunt deja a recurge la copy / paste din nou,

832
00:45:12,000 --> 00:45:14,000
deci sansele sunt acolo e altă soluție aici.

833
00:45:14,000 --> 00:45:18,000
Eu pot curăța, probabil, asta în continuare, cu o buclă sau ceva de genul asta,

834
00:45:18,000 --> 00:45:21,000
Deci, pe scurt, e un pic mai bine, dar încă se simte ca

835
00:45:21,000 --> 00:45:24,000
Sunt recurge la copy / paste, dar chiar și acest lucru, eu susțin,

836
00:45:24,000 --> 00:45:27,000
este într-adevăr nu fundamental soluția corectă, deoarece

837
00:45:27,000 --> 00:45:29,000
Ce se întâmplă dacă cândva ne hotărâm știi ce?

838
00:45:29,000 --> 00:45:32,000
Am într-adevăr ar fi trebuit stocarea adreselor de e-mail pentru David și Rob

839
00:45:32,000 --> 00:45:34,000
și toată lumea în acest program.

840
00:45:34,000 --> 00:45:36,000
Ar trebui să stocați numere de telefon, de asemenea,.

841
00:45:36,000 --> 00:45:39,000
Noi ar trebui să stoca, de asemenea numere de urgență de contact.

842
00:45:39,000 --> 00:45:41,000
Avem toate aceste fragmente de date pe care dorim să le stoca,

843
00:45:41,000 --> 00:45:43,000
asa cum te duci despre a face asta?

844
00:45:43,000 --> 00:45:46,000
>> Ai declară un alt tablou în partea de sus, și apoi adăugați manual

845
00:45:46,000 --> 00:45:49,000
o adresă de e-mail [0], adresa de e-mail [1]

846
00:45:49,000 --> 00:45:51,000
pentru David și Rob și așa mai departe.

847
00:45:51,000 --> 00:45:56,000
Dar există cu adevărat doar o presupunere care stă la baza acestui design

848
00:45:56,000 --> 00:45:59,000
că eu sunt, folosind sistemul onoarea să știe că

849
00:45:59,000 --> 00:46:03,000
[I] în fiecare din cele tablouri mai multe

850
00:46:03,000 --> 00:46:06,000
doar așa se întâmplă să se refere la aceeași persoană,

851
00:46:06,000 --> 00:46:10,000
astfel încât [0] în actele de identitate este numărul 123,

852
00:46:10,000 --> 00:46:13,000
și am de gând să-și asume faptul că numele [0]

853
00:46:13,000 --> 00:46:16,000
este aceeași persoană numele și casele [0]

854
00:46:16,000 --> 00:46:21,000
este casa aceeași persoană și așa mai departe pentru toate tablouri diferite pe care le creează.

855
00:46:21,000 --> 00:46:24,000
Dar observați că nu există nici o legătură fundamentală

856
00:46:24,000 --> 00:46:27,000
printre cele 3 bucăți de informații, id-ul, numele și casa,

857
00:46:27,000 --> 00:46:32,000
chiar dacă entitatea noi încercăm să model în acest program nu este matrice.

858
00:46:32,000 --> 00:46:35,000
Matricile sunt doar acest mod programatic de a face acest lucru.

859
00:46:35,000 --> 00:46:38,000
Ceea ce vrem cu adevărat să modeleze în programul nostru este o persoană

860
00:46:38,000 --> 00:46:41,000
ca David, o persoana ca Rob interiorul căruia se

861
00:46:41,000 --> 00:46:46,000
sau încapsulare este un nume si ID-ul și o casă.

862
00:46:46,000 --> 00:46:49,000
>> Poate ne exprimăm într-un fel această idee de încapsulare

863
00:46:49,000 --> 00:46:52,000
prin care o persoană are o identitate, un nume și o casă

864
00:46:52,000 --> 00:46:55,000
și nu recurg la acest hack cu adevărat, prin care ne-am

865
00:46:55,000 --> 00:46:58,000
încredere că ceva suportul

866
00:46:58,000 --> 00:47:02,000
se referă la aceeași entitate umană, în fiecare din aceste tablouri disparate?

867
00:47:02,000 --> 00:47:04,000
Noi putem face de fapt acest lucru.

868
00:47:04,000 --> 00:47:08,000
Lasă-mă să merg mai sus principal de acum, și lasă-mă să creați propriul meu tip de date

869
00:47:08,000 --> 00:47:10,000
într-adevăr pentru prima dată.

870
00:47:10,000 --> 00:47:14,000
Am folosit această tehnică în Scramble,

871
00:47:14,000 --> 00:47:17,000
dar aici am de gând să merg mai departe și de a crea un tip de date,

872
00:47:17,000 --> 00:47:19,000
și știi ce, am de gând să-l sun elev sau persoană,

873
00:47:19,000 --> 00:47:23,000
și am de gând să utilizeze typedef pentru a defini un tip.

874
00:47:23,000 --> 00:47:25,000
Am de gând să spun că aceasta este o structură,

875
00:47:25,000 --> 00:47:29,000
și apoi această structură va fi de student tip, vom spune,

876
00:47:29,000 --> 00:47:31,000
chiar daca e un pic datat acum pentru mine.

877
00:47:31,000 --> 00:47:33,000
Vom spune "int id."

878
00:47:33,000 --> 00:47:35,000
Vom spune "nume șir."

879
00:47:35,000 --> 00:47:37,000
Apoi, vom spune "casa șir,"

880
00:47:37,000 --> 00:47:40,000
asa ca acum, până la sfârșitul acestor câteva linii de cod

881
00:47:40,000 --> 00:47:45,000
Am învățat doar zăngănit că există

882
00:47:45,000 --> 00:47:49,000
un tip de date în afară de Ints, pe langa siruri de caractere, în afară de dublu, în afară de flotoare.

883
00:47:49,000 --> 00:47:54,000
>> Începând din acest moment, în conformitate timp 11, există acum un nou tip de date numit studenți,

884
00:47:54,000 --> 00:47:58,000
si acum pot declara o variabila elev oriunde vreau,

885
00:47:58,000 --> 00:48:01,000
asa ca lasa-ma aici, defilați în jos la oameni.

886
00:48:01,000 --> 00:48:05,000
Acum pot scapa de acest lucru, iar eu pot merge înapoi la David aici,

887
00:48:05,000 --> 00:48:10,000
și pentru David pot spune de fapt că David,

888
00:48:10,000 --> 00:48:13,000
putem numi literalmente variabila după mine,

889
00:48:13,000 --> 00:48:16,000
va fi de student tip.

890
00:48:16,000 --> 00:48:18,000
Acest lucru ar putea arata un pic ciudat, dar asta nu este tot ceea ce diferit

891
00:48:18,000 --> 00:48:22,000
de la declararea ceva ca un int sau un șir de caractere sau un flotor.

892
00:48:22,000 --> 00:48:24,000
Doar așa se întâmplă să fie numit elev acum,

893
00:48:24,000 --> 00:48:28,000
și dacă vreau să pun ceva în interiorul acestei structuri

894
00:48:28,000 --> 00:48:31,000
Acum trebuie să utilizeze o noua piesa de sintaxă, dar e destul de simplă,

895
00:48:31,000 --> 00:48:39,000
david.id = 123, david.name = "David" în capitalul D,

896
00:48:39,000 --> 00:48:42,000
și david.house = "Mather,"

897
00:48:42,000 --> 00:48:46,000
și acum mă pot scăpa de aceste lucruri aici.

898
00:48:46,000 --> 00:48:51,000
Observați că am reproiectat acum programul nostru într-un mod într-adevăr mult mai bine

899
00:48:51,000 --> 00:48:54,000
în faptul că acum programul nostru reflectă lumea reală.

900
00:48:54,000 --> 00:48:57,000
>> E o noțiune lumea reala a unei persoane sau a unui elev.

901
00:48:57,000 --> 00:49:02,000
Aici avem acum o versiune C a unei persoane sau mai precis un student.

902
00:49:02,000 --> 00:49:05,000
În interiorul acelei persoane sunt aceste caracteristici relevante,

903
00:49:05,000 --> 00:49:10,000
ID-ul, numele și casa, așa Rob devine în esență, același lucru aici,

904
00:49:10,000 --> 00:49:14,000
asa elev jefuiască, și acum rob.id = 456,

905
00:49:14,000 --> 00:49:17,000
rob.name = "Rob".

906
00:49:17,000 --> 00:49:20,000
Faptul că variabila se numeste Rob este un fel de lipsită de sens.

907
00:49:20,000 --> 00:49:22,000
Am putut numi x sau y sau z.

908
00:49:22,000 --> 00:49:25,000
Noi doar a numit-o Rob să fie coerente semantic,

909
00:49:25,000 --> 00:49:28,000
dar de fapt numele este în interiorul acest domeniu în sine,

910
00:49:28,000 --> 00:49:30,000
asa ca acum am asta.

911
00:49:30,000 --> 00:49:33,000
Acest lucru nu prea se simt ca cel mai bun design, în care le-am codificat greu David.

912
00:49:33,000 --> 00:49:35,000
Am codificate greu Rob.

913
00:49:35,000 --> 00:49:39,000
Și eu încă mai trebuie să recurgă la unele copiați și lipiți de fiecare dată când vreau variabile noi.

914
00:49:39,000 --> 00:49:43,000
Mai mult decât atât, trebuie să dau aparent fiecare dintre aceste variabile un nume,

915
00:49:43,000 --> 00:49:46,000
chiar dacă aș mai degrabă descriu aceste variabile

916
00:49:46,000 --> 00:49:48,000
 elevii mai mult generic ca.

917
00:49:48,000 --> 00:49:52,000
>> Acum putem uni ideile care au fost de lucru bine pentru noi

918
00:49:52,000 --> 00:49:56,000
și spun în schimb, "Știi ce, dă-mi un elevilor variabilă numită,

919
00:49:56,000 --> 00:50:01,000
si hai sa l-au fi de marimea 3, "așa că acum pot rafina acest lucru în continuare,

920
00:50:01,000 --> 00:50:04,000
scăpa de David manual a declarat,

921
00:50:04,000 --> 00:50:08,000
si eu pot spune în schimb ceva de genul elevi [0] aici.

922
00:50:08,000 --> 00:50:11,000
Pot spune atunci elevii [0] aici,

923
00:50:11,000 --> 00:50:14,000
elevii [0] aici, și așa mai departe, și eu pot merge în jurul valorii de

924
00:50:14,000 --> 00:50:16,000
și curățați că pentru Rob.

925
00:50:16,000 --> 00:50:19,000
Am putea merge, de asemenea, despre adăugarea acum poate o buclă

926
00:50:19,000 --> 00:50:23,000
și utilizarea getString și GetInt pentru a obține de fapt, aceste valori de la utilizator.

927
00:50:23,000 --> 00:50:27,000
Aș putea merge despre adăugarea unei constante, deoarece acest lucru este, în general, de rău practică

928
00:50:27,000 --> 00:50:29,000
la codul de greu un numar arbitrar ca 3 chiar aici

929
00:50:29,000 --> 00:50:33,000
și apoi amintiți-vă doar că ar trebui să pună mai mult de 3 elevi în ea.

930
00:50:33,000 --> 00:50:36,000
Acesta ar fi, probabil, mai bine să folosiți # define la partea de sus a fișierului meu

931
00:50:36,000 --> 00:50:40,000
și factorul de asta, așa, într-adevăr, lasă-mă să mergeți mai departe și să generalizeze acest lucru.

932
00:50:40,000 --> 00:50:43,000
>> Lasă-mă să deschid un exemplu care e printre azi

933
00:50:43,000 --> 00:50:46,000
exemple în avans, structs1.

934
00:50:46,000 --> 00:50:49,000
Acesta este un program mai complet care foloseste # define aici

935
00:50:49,000 --> 00:50:51,000
și spune că vom avea 3 elevi în mod implicit.

936
00:50:51,000 --> 00:50:54,000
Aici am declara o valoare de clasa de elevi,

937
00:50:54,000 --> 00:50:57,000
deci o clasă de elevi, iar acum eu sunt, folosind o buclă

938
00:50:57,000 --> 00:51:00,000
doar pentru a face codul un pic mai elegant, populează clasa

939
00:51:00,000 --> 00:51:05,000
cu intrare utilizatorului, itera astfel de la i = 0, pe până la studenți, care este 3.

940
00:51:05,000 --> 00:51:07,000
Și apoi am cere utilizatorului în această versiune

941
00:51:07,000 --> 00:51:10,000
 ceea ce este ID-ul elevului, si m-am prins cu GetInt.

942
00:51:10,000 --> 00:51:13,000
Care e numele elevului, iar apoi am să-l cu getString.

943
00:51:13,000 --> 00:51:15,000
Ce e casa elevului? M-am prins cu getString.

944
00:51:15,000 --> 00:51:19,000
Și apoi în partea de jos aici, am decis să schimbe

945
00:51:19,000 --> 00:51:22,000
cum mă imprimarea pe acestea și să utilizeze o buclă de fapt,

946
00:51:22,000 --> 00:51:24,000
Și cine sunt eu de imprimare?

947
00:51:24,000 --> 00:51:27,000
Potrivit comentariul Sunt imprimarea pe nimeni în Mather,

948
00:51:27,000 --> 00:51:30,000
și că e atât de Rob și Tommy și așa mai departe, de fapt lui Tommy în Mather.

949
00:51:30,000 --> 00:51:34,000
Tommy și David ar fi tipărite în acest caz, dar cum este aceasta funcționează?

950
00:51:34,000 --> 00:51:40,000
Noi nu am văzut această funcție înainte, dar ia o presupunere cu privire la ce face asta.

951
00:51:40,000 --> 00:51:42,000
Compară siruri de caractere.

952
00:51:42,000 --> 00:51:45,000
>> E un pic non-evident cum se compară siruri de caractere, deoarece se dovedește

953
00:51:45,000 --> 00:51:49,000
în cazul în care returnează 0 înseamnă că șirurile sunt egale.

954
00:51:49,000 --> 00:51:53,000
În cazul în care returnează un -1 înseamnă că unul vine în ordine alfabetică în fața celuilalt,

955
00:51:53,000 --> 00:51:57,000
și dacă se returnează 1 înseamnă că alt cuvânt vine în ordine alfabetică

956
00:51:57,000 --> 00:52:00,000
înainte de altă parte, poti sa te uiti si on-line sau de la pagina de om

957
00:52:00,000 --> 00:52:04,000
pentru a vedea exact care este calea pe care, dar toate acest lucru este acum face este ea spune

958
00:52:04,000 --> 00:52:09,000
în cazul în care [i]. casa este egal cu "Mather"

959
00:52:09,000 --> 00:52:13,000
apoi mergeți mai departe și tipări așa și așa este în Mather.

960
00:52:13,000 --> 00:52:16,000
Dar aici e ceva ce nu am mai văzut până acum, și ne vom întoarce la asta.

961
00:52:16,000 --> 00:52:21,000
Nu-mi amintesc niciodată nevoie să faceți acest lucru în oricare dintre programele mele.

962
00:52:21,000 --> 00:52:24,000
Gratuit este aparent referindu-se la memorie, eliberarea de memorie,

963
00:52:24,000 --> 00:52:31,000
dar ceea ce caut eu de memorie aparent eliberând în această buclă, la partea de jos a acestui program?

964
00:52:31,000 --> 00:52:34,000
Se pare ca am eliberarea numele unei persoane

965
00:52:34,000 --> 00:52:37,000
și casa unei persoane, dar de ce e asta?

966
00:52:37,000 --> 00:52:41,000
>> Se pare că toate aceste săptămâni pe care le-ați folosit getString

967
00:52:41,000 --> 00:52:45,000
am fost un fel de introducere a unui bug în fiecare dintre programele dumneavoastră.

968
00:52:45,000 --> 00:52:51,000
GetString de memorie de design alocă astfel încât să poată reveni la un șir,

969
00:52:51,000 --> 00:52:55,000
ca David, sau Rob, și puteți face, atunci ce vrei

970
00:52:55,000 --> 00:52:59,000
cu faptul că șirul în programul dvs., deoarece ne-am rezervat de memorie pentru tine.

971
00:52:59,000 --> 00:53:02,000
Problema este tot acest timp de fiecare data cand suna getString

972
00:53:02,000 --> 00:53:05,000
Noi, autorii getString, au cerut sistemul de operare

973
00:53:05,000 --> 00:53:07,000
să ne dea un pic de RAM pentru acest șir.

974
00:53:07,000 --> 00:53:09,000
Dă-ne un pic de RAM pentru acest șir următoare.

975
00:53:09,000 --> 00:53:11,000
Dă-ne ceva mai mult RAM pentru acest șir următoare.

976
00:53:11,000 --> 00:53:13,000
Ce ai, programator, nu au făcut

977
00:53:13,000 --> 00:53:15,000
este oferindu-ne că înapoi de memorie,

978
00:53:15,000 --> 00:53:17,000
astfel încât pentru aceste câteva săptămâni toate programele pe care le-ați scris

979
00:53:17,000 --> 00:53:20,000
au avut ceea ce se numește un salt de memorie prin care acestea continuă să utilizeze

980
00:53:20,000 --> 00:53:24,000
mai multă memorie și mai mult de fiecare dată când suna getString, și asta e bine.

981
00:53:24,000 --> 00:53:27,000
Noi facem în mod deliberat faptul că, în primele săptămâni, pentru că nu e interesant

982
00:53:27,000 --> 00:53:29,000
să aibă de a vă faceți griji în cazul în care șirul este venind de la.

983
00:53:29,000 --> 00:53:34,000
Tot ce vreau este cuvântul Rob să vină înapoi, atunci când utilizatorul îl tipuri de inch

984
00:53:34,000 --> 00:53:38,000
>> Dar merge mai departe acum avem de a începe să obtinerea mai sofisticate despre acest lucru.

985
00:53:38,000 --> 00:53:42,000
De fiecare dată când vom aloca memorie mai bună preda în cele din urmă înapoi.

986
00:53:42,000 --> 00:53:45,000
În caz contrar, în lumea reală pe Mac sau PC-ul ar putea să aibă experiență ocazional

987
00:53:45,000 --> 00:53:50,000
în cazul în care simptomele computerul este rectificat la un popas în cele din urmă

988
00:53:50,000 --> 00:53:54,000
sau prost mingea plajă se rotește ocupă doar de calculator

989
00:53:54,000 --> 00:53:56,000
intreaga atentie si nu poti face lucruri.

990
00:53:56,000 --> 00:54:00,000
Care poate fi explicat prin orice număr de bug-uri, dar printre aceste bug-uri posibile

991
00:54:00,000 --> 00:54:03,000
sunt lucruri numite scurgeri de memorie în care cineva care a scris acea bucată de software

992
00:54:03,000 --> 00:54:07,000
pe care îl utilizați nu-mi amintesc să eliberați memorie

993
00:54:07,000 --> 00:54:10,000
că el sau ea a cerut pentru sistemul de operare,

994
00:54:10,000 --> 00:54:14,000
Nu utilizați getString, pentru că e un lucru CS50, dar folosind funcții similare

995
00:54:14,000 --> 00:54:16,000
că cere sistemul de operare pentru memorie.

996
00:54:16,000 --> 00:54:19,000
Daca tu sau ei în bară și nu se mai întorc de fapt că memoria

997
00:54:19,000 --> 00:54:24,000
un simptom de care poate fi faptul că un program de încetinește și încetinește și încetinește

998
00:54:24,000 --> 00:54:26,000
excepția cazului în care uitați să apelați gratuit.

999
00:54:26,000 --> 00:54:28,000
>> Vom reveni la când și de ce v-ar suna gratuit,

1000
00:54:28,000 --> 00:54:32,000
dar hai sa mergem mai departe doar pentru o bună măsură și încercați să rulați acest program special.

1001
00:54:32,000 --> 00:54:35,000
Acest lucru a fost numit structs1, introduceți.

1002
00:54:35,000 --> 00:54:40,000
Lasă-mă să mergeți mai departe și a alerga 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, și vom vedea David în Mather, Tommy în Mather.

1005
00:54:50,000 --> 00:54:53,000
Acesta este doar un cec bun-simț mic care programul este de lucru.

1006
00:54:53,000 --> 00:54:56,000
Acum, din păcate, acest program este un pic frustrant, în care

1007
00:54:56,000 --> 00:55:00,000
Am facut tot ce locul de muncă, am scris în 9 siruri de caractere diferite, a lovit introduceți,

1008
00:55:00,000 --> 00:55:04,000
sa spus care era în Mather, dar, evident, știam care era în Mather deja pentru că l-am scris.

1009
00:55:04,000 --> 00:55:07,000
Ar fi de cel puțin frumos dacă acest program este mai mult ca o bază de date

1010
00:55:07,000 --> 00:55:10,000
și-l amintește de fapt ceea ce am scris în

1011
00:55:10,000 --> 00:55:12,000
deci nu am avea din nou pentru a introduce aceste înregistrări elevilor.

1012
00:55:12,000 --> 00:55:15,000
Poate e ca un sistem de registrarial.

1013
00:55:15,000 --> 00:55:21,000
>> Putem face acest lucru utilizând această tehnică cunoscută sub numele de intrare fișier fișier I / O, și de ieșire,

1014
00:55:21,000 --> 00:55:24,000
un mod foarte generic de a spune orice moment doriți să citiți fișiere sau scrie fișiere

1015
00:55:24,000 --> 00:55:26,000
puteți face acest lucru cu un anumit set de funcții.

1016
00:55:26,000 --> 00:55:29,000
Lasă-mă să merg mai departe și deschide acest structs2.c exemplu,

1017
00:55:29,000 --> 00:55:33,000
care este aproape identic, dar să vedem ce se face acum.

1018
00:55:33,000 --> 00:55:36,000
În partea de sus a fișierului, declar o clasă de elevi.

1019
00:55:36,000 --> 00:55:38,000
Am popula apoi clasa cu intrarea utilizatorului,

1020
00:55:38,000 --> 00:55:41,000
astfel încât aceste linii de cod sunt exact ca înainte.

1021
00:55:41,000 --> 00:55:45,000
Apoi, dacă am derula în jos aici am tipărarea toți cei care se află în mod arbitrar Mather ca înainte,

1022
00:55:45,000 --> 00:55:47,000
dar aceasta este o caracteristica interesanta nou.

1023
00:55:47,000 --> 00:55:51,000
Aceste linii de cod sunt noi, și ei introduc ceva aici,

1024
00:55:51,000 --> 00:55:55,000
Fișier, toate capacele, și a * aici, de asemenea.

1025
00:55:55,000 --> 00:55:58,000
Lasă-mă să mut asta aici, o * pe aici, de asemenea.

1026
00:55:58,000 --> 00:56:00,000
>> Această funcție nu am văzut până acum, fopen,

1027
00:56:00,000 --> 00:56:03,000
dar aceasta înseamnă fișier deschis, așa că hai să degresat prin acestea,

1028
00:56:03,000 --> 00:56:05,000
și acest lucru este ceva ce ne vom întoarce la psets viitoare,

1029
00:56:05,000 --> 00:56:10,000
dar această linie aici se deschide în esență, un fișier numit bază de date,

1030
00:56:10,000 --> 00:56:13,000
și în mod special acesta se deschide în așa fel încât să poată face ceea ce cu ea?

1031
00:56:13,000 --> 00:56:15,000
[Imperceptibil-elev]

1032
00:56:15,000 --> 00:56:19,000
Corect, așa "w" doar înseamnă că e spune sistemul de operare

1033
00:56:19,000 --> 00:56:21,000
deschide acest fișier în așa fel încât eu pot scrie la ea.

1034
00:56:21,000 --> 00:56:23,000
Nu vreau să-l citesc. Nu vreau să se uite doar la el.

1035
00:56:23,000 --> 00:56:26,000
Vreau să-l schimbe și să adăugați lucruri potențial să-l,

1036
00:56:26,000 --> 00:56:28,000
și fișierul va fi numit de baze de date.

1037
00:56:28,000 --> 00:56:30,000
Acest lucru ar putea fi numit nimic.

1038
00:56:30,000 --> 00:56:32,000
Acest lucru ar putea fi database.txt. Acest lucru ar putea fi. DB.

1039
00:56:32,000 --> 00:56:37,000
Acest lucru ar putea fi un cuvânt ca foo, dar am ales arbitrar pentru a numi fișier bază de date.

1040
00:56:37,000 --> 00:56:42,000
Aceasta este o verificare sanatatea mic care vom reveni în detaliu mare-a lungul timpului,

1041
00:56:42,000 --> 00:56:47,000
în cazul în care fp, pentru indicatorul dosar, nu NULL egal înseamnă că totul este bine.

1042
00:56:47,000 --> 00:56:51,000
>> Pe scurt, cum ar fi funcțiile fopen nu reușesc uneori.

1043
00:56:51,000 --> 00:56:53,000
Poate că fișierul nu există. Poate ești din spațiu pe disc.

1044
00:56:53,000 --> 00:56:55,000
Poate nu aveți permisiunea de a acel folder,

1045
00:56:55,000 --> 00:56:58,000
așa că, dacă fopen returneaza null ceva rău sa întâmplat.

1046
00:56:58,000 --> 00:57:02,000
În schimb, în ​​cazul în care fopen nu intoarce null totul este bine

1047
00:57:02,000 --> 00:57:04,000
și pot începe să scrie în acest dosar.

1048
00:57:04,000 --> 00:57:06,000
Aici e un truc nou.

1049
00:57:06,000 --> 00:57:08,000
Aceasta este o buclă pentru care a iterarea peste fiecare dintre elevii mei,

1050
00:57:08,000 --> 00:57:10,000
și acest lucru pare atât de asemănătoare cu ceea ce am făcut înainte,

1051
00:57:10,000 --> 00:57:15,000
dar această funcție este un văr de printf solicitat fprintf pentru fișier printf,

1052
00:57:15,000 --> 00:57:18,000
și observați că acesta este diferit, în doar 2 moduri.

1053
00:57:18,000 --> 00:57:20,000
Unul, incepe cu f în loc de p,

1054
00:57:20,000 --> 00:57:23,000
dar apoi primul argument este aparent ce?

1055
00:57:23,000 --> 00:57:25,000
Elevii [] fișier. >> E un fișier.

1056
00:57:25,000 --> 00:57:30,000
Acest lucru numit fp, pe care în cele din urmă vom tachineze pe lângă ceea ce un pointer fisier este,

1057
00:57:30,000 --> 00:57:35,000
dar de acum FP reprezintă pur și simplu fișierul pe care l-am deschis,

1058
00:57:35,000 --> 00:57:41,000
astfel fprintf aici se spune tipărarea ID-ul acestui utilizator la dosar, nu pe ecran.

1059
00:57:41,000 --> 00:57:44,000
Imprima numele de utilizator la dosar, nu pe ecran,

1060
00:57:44,000 --> 00:57:47,000
casa la dosar, nu pe ecran, și apoi în jos aici, în mod evident,

1061
00:57:47,000 --> 00:57:50,000
închideți fișierul, apoi aici gratuit de memorie.

1062
00:57:50,000 --> 00:57:53,000
>> Singura diferență între această versiune 2 și versiunea 1

1063
00:57:53,000 --> 00:57:58,000
este introducerea fopen și acest fișier cu *

1064
00:57:58,000 --> 00:58:01,000
și această noțiune de fprintf, asa ca hai sa vedem ce rezultatul final este.

1065
00:58:01,000 --> 00:58:03,000
Lasă-mă să intru în fereastra terminalul meu.

1066
00:58:03,000 --> 00:58:06,000
Lasă-mă să rulați structs2, introduceți.

1067
00:58:06,000 --> 00:58:09,000
Se pare ca totul este bine. Să reluare 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, introduceți.

1070
00:58:19,000 --> 00:58:23,000
Se pare că s-au comportat la fel, dar daca eu fac acum ls

1071
00:58:23,000 --> 00:58:28,000
observați ce fisierul este aici, printre tot codul, baze de date,

1072
00:58:28,000 --> 00:58:32,000
așa că hai să deschizi, gedit de baze de date, si uita-te la asta.

1073
00:58:32,000 --> 00:58:34,000
Nu e cea mai sexy de formate de fișiere.

1074
00:58:34,000 --> 00:58:38,000
Este într-adevăr este una bucată de linie de date pe linie pe linie,

1075
00:58:38,000 --> 00:58:42,000
dar cei dintre voi care folosesc fisiere Excel sau CSV, valori separate prin virgulă,

1076
00:58:42,000 --> 00:58:47,000
Am fi putut cu siguranță folosit pentru a fprintf loc poate face ceva de genul asta

1077
00:58:47,000 --> 00:58:50,000
astfel încât am putut crea de fapt echivalentul unui fișier Excel

1078
00:58:50,000 --> 00:58:53,000
prin separarea lucrurile cu virgula, nu doar linii noi.

1079
00:58:53,000 --> 00:58:56,000
>> În acest caz, dacă aș fi folosit în loc virgule in loc de linii noi

1080
00:58:56,000 --> 00:59:01,000
Am putut deschide literalmente acest fișier bază de date în Excel, dacă am făcut-o în locul arate ca asta.

1081
00:59:01,000 --> 00:59:03,000
Pe scurt, acum că avem puterea de a scrie fișiere

1082
00:59:03,000 --> 00:59:07,000
putem incepe acum date persistente, menținându-l în jurul valorii de pe disc

1083
00:59:07,000 --> 00:59:10,000
astfel încât să putem păstra informațiile în jurul valorii de nou și din nou.

1084
00:59:10,000 --> 00:59:14,000
Observați o serie de alte lucruri care acum sunt un pic mai familiar.

1085
00:59:14,000 --> 00:59:16,000
În partea de sus a acestui fișier C avem un typedef

1086
00:59:16,000 --> 00:59:21,000
pentru că am vrut să creăm un tip de date care reprezintă un cuvânt,

1087
00:59:21,000 --> 00:59:25,000
astfel încât acest tip este numit cuvânt, și în interiorul acestei structuri

1088
00:59:25,000 --> 00:59:27,000
e un pic crescator acum.

1089
00:59:27,000 --> 00:59:30,000
De ce este un cuvânt compus din aparent o matrice?

1090
00:59:30,000 --> 00:59:33,000
Ce este un cuvânt pur și simplu intuitiv?

1091
00:59:33,000 --> 00:59:35,000
>> E un tablou de caractere.

1092
00:59:35,000 --> 00:59:37,000
E o secvență de caractere spate în spate în spate.

1093
00:59:37,000 --> 00:59:41,000
SCRISORI în toate capacele se întâmplă să fie arbitrar am spus lungime maxima

1094
00:59:41,000 --> 00:59:44,000
de orice cuvânt în dicționarul pe care îl utilizăm pentru Scramble.

1095
00:59:44,000 --> 00:59:46,000
De ce am un +1?

1096
00:59:46,000 --> 00:59:48,000
Nul caracter.

1097
00:59:48,000 --> 00:59:51,000
Recall atunci când am făcut exemplul Bananagrams avem nevoie de o valoare deosebită

1098
00:59:51,000 --> 00:59:55,000
la sfârșitul cuvântului, în scopul de a ține evidența

1099
00:59:55,000 --> 00:59:59,000
de unde de fapt sa încheiat cuvinte, și ca caietul de sarcini set de probleme spune

1100
00:59:59,000 --> 01:00:03,000
aici suntem asocierea cu un cuvânt dat o valoare boolean,

1101
01:00:03,000 --> 01:00:05,000
un steag, ca să spunem așa, adevărat sau fals.

1102
01:00:05,000 --> 01:00:09,000
Ați găsit deja acest cuvânt, pentru că ne dăm seama

1103
01:00:09,000 --> 01:00:13,000
avem nevoie de o modalitate de a aminti ceea ce nu doar un cuvânt este în Scramble

1104
01:00:13,000 --> 01:00:15,000
dar dacă sunteți sau nu, om, l-au găsit

1105
01:00:15,000 --> 01:00:20,000
astfel încât, dacă nu găsiți cuvântul "" nu poți chiar tip, introduceți,, introduceți,, introduceți

1106
01:00:20,000 --> 01:00:23,000
și de a lua 3 puncte, 3 puncte, 3 puncte, 3 puncte.

1107
01:00:23,000 --> 01:00:26,000
Ne dorim să fie în măsură să lista neagra acest cuvânt prin stabilirea unui bool

1108
01:00:26,000 --> 01:00:29,000
pentru adevărat dacă deja ați găsit-o, și deci de aceea am

1109
01:00:29,000 --> 01:00:31,000
încapsulate-o în această structură.

1110
01:00:31,000 --> 01:00:35,000
>> Acum, aici, în Scramble e un alt struct numit dicționar.

1111
01:00:35,000 --> 01:00:39,000
Absent aici este cuvântul typedef, deoarece, în acest caz,

1112
01:00:39,000 --> 01:00:43,000
avem nevoie pentru a îngloba ideea unui dicționar,

1113
01:00:43,000 --> 01:00:46,000
și un dicționar conține o grămadă de cuvinte,

1114
01:00:46,000 --> 01:00:49,000
cum implicate de această matrice, și cât de multe dintre aceste cuvinte sunt acolo?

1115
01:00:49,000 --> 01:00:51,000
Ei bine, indiferent de această dimensiune variabilă numită spune.

1116
01:00:51,000 --> 01:00:53,000
Dar avem nevoie doar de un dicționar.

1117
01:00:53,000 --> 01:00:55,000
Nu avem nevoie de un tip de date numit dicționar.

1118
01:00:55,000 --> 01:00:58,000
Avem nevoie doar de unul dintre ei, așa că se transformă în C

1119
01:00:58,000 --> 01:01:03,000
că, dacă nu spui typedef, vă spun doar struct, apoi în interiorul acolade

1120
01:01:03,000 --> 01:01:05,000
ai pus variabilele tale, atunci ai pus numele.

1121
01:01:05,000 --> 01:01:09,000
Acest lucru este declarat un dicționar variabilă numită

1122
01:01:09,000 --> 01:01:11,000
care arata ca acest lucru.

1123
01:01:11,000 --> 01:01:16,000
În schimb, aceste linii sunt crearea unei structuri de date reutilizabil numit cuvânt

1124
01:01:16,000 --> 01:01:19,000
pe care le pot crea mai multe copii ale, la fel cum am creat

1125
01:01:19,000 --> 01:01:22,000
copii multiple ale elevilor.

1126
01:01:22,000 --> 01:01:24,000
>> Ce înseamnă acest lucru permite în cele din urmă ne-a face?

1127
01:01:24,000 --> 01:01:30,000
Lasă-mă să merg înapoi în, să zicem, un exemplu simplu de ori mai simple,

1128
01:01:30,000 --> 01:01:34,000
și lasă-mă să deschid, să zicem, compare1.c.

1129
01:01:34,000 --> 01:01:38,000
Problema aici la mana este de fapt coaja de a întoarce

1130
01:01:38,000 --> 01:01:41,000
strat de un șir și începe să luați de pe aceste roți de formare

1131
01:01:41,000 --> 01:01:44,000
deoarece se dovedește că un șir în tot acest timp

1132
01:01:44,000 --> 01:01:47,000
Este așa cum am promis in saptamana 1 de fapt doar un pseudonim,

1133
01:01:47,000 --> 01:01:51,000
un sinonim din biblioteca CS50 pentru ceva care arată un pic mai criptic,

1134
01:01:51,000 --> 01:01:53,000
* char, și am văzut această stea înainte.

1135
01:01:53,000 --> 01:01:55,000
Am văzut-o în contextul de fișiere.

1136
01:01:55,000 --> 01:01:59,000
>> Să vedem acum de ce am fost ascuns acest detaliu pentru ceva timp acum.

1137
01:01:59,000 --> 01:02:02,000
Aici este un fișier numit compare1.c,

1138
01:02:02,000 --> 01:02:07,000
și-l întreabă aparent ghidul pentru 2 siruri de caractere, S și T,

1139
01:02:07,000 --> 01:02:11,000
și apoi încearcă să-l compara aceste siruri de caractere pentru egalitatea de șanse în linia 26,

1140
01:02:11,000 --> 01:02:14,000
și dacă ele sunt egale se spune, "Tu tastat același lucru,"

1141
01:02:14,000 --> 01:02:17,000
și dacă ei nu sunt egale se spune, "Tu tastat lucruri diferite."

1142
01:02:17,000 --> 01:02:19,000
Lasă-mă să merg mai departe și să executați acest program.

1143
01:02:19,000 --> 01:02:23,000
Lasă-mă să intru în directorul sursa mea, fac o compare1. Acesta compilat bine.

1144
01:02:23,000 --> 01:02:25,000
Lasă-mă să fugi compare1.

1145
01:02:25,000 --> 01:02:27,000
Voi mări, introduceți.

1146
01:02:27,000 --> 01:02:29,000
Spune ceva. HELLO.

1147
01:02:29,000 --> 01:02:32,000
Voi spune ceva nou. HELLO.

1148
01:02:32,000 --> 01:02:34,000
Eu cu siguranta nu am tastați lucruri diferite.

1149
01:02:34,000 --> 01:02:37,000
>> Lasă-mă să încerc din nou. BYE BYE.

1150
01:02:37,000 --> 01:02:40,000
Categoric, nu diferit, deci ce se întâmplă pe aici?

1151
01:02:40,000 --> 01:02:44,000
Ei bine, ceea ce este cu adevărat comparată, în linia 26?

1152
01:02:44,000 --> 01:02:46,000
[Imperceptibil-elev]

1153
01:02:46,000 --> 01:02:49,000
Da, așa se pare că un șir, tipul de date, este un fel de minciună albă.

1154
01:02:49,000 --> 01:02:53,000
Un sir este o char *, dar ceea ce este un char *?

1155
01:02:53,000 --> 01:02:56,000
A char *, cum se spune, este un pointer,

1156
01:02:56,000 --> 01:03:00,000
și un pointer este efectiv o adresă,

1157
01:03:00,000 --> 01:03:05,000
o locație de memorie în sumă, iar dacă se întâmplă să fi tastat într-un cuvânt cum ar fi HELLO,

1158
01:03:05,000 --> 01:03:08,000
retrag de la discuțiile anterioare ale siruri de caractere

1159
01:03:08,000 --> 01:03:16,000
acest lucru este ca și cum cuvântul HELLO.

1160
01:03:16,000 --> 01:03:19,000
Amintiți-vă că un cuvânt ca HELLO poate fi reprezentat

1161
01:03:19,000 --> 01:03:22,000
ca o matrice de caractere ca aceasta

1162
01:03:22,000 --> 01:03:25,000
și apoi cu un caracter special, la sfârșitul numit caracterul nul,

1163
01:03:25,000 --> 01:03:27,000
cum denotă \.

1164
01:03:27,000 --> 01:03:29,000
Ce este de fapt un șir?

1165
01:03:29,000 --> 01:03:32,000
Observați că acest lucru este bucati multiple de memorie,

1166
01:03:32,000 --> 01:03:36,000
și, de fapt, sfârșitul este cunoscut decât după ce te uiți prin șir întreg

1167
01:03:36,000 --> 01:03:38,000
In cautare de caracterul nul specială.

1168
01:03:38,000 --> 01:03:41,000
Dar dacă aceasta este o bucată de memorie din memoria calculatorului meu,

1169
01:03:41,000 --> 01:03:44,000
să arbitrar spun că acest șir avut noroc,

1170
01:03:44,000 --> 01:03:47,000
si a fost plasat la începutul memoria RAM a computerului meu.

1171
01:03:47,000 --> 01:03:54,000
Acest lucru este octet 0, 1, 2, 3, 4, 5, 6 ...

1172
01:03:54,000 --> 01:04:02,000
>> Când spun ceva de genul getString si eu sirul s = getString

1173
01:04:02,000 --> 01:04:04,000
ceea ce e foarte care sunt returnate?

1174
01:04:04,000 --> 01:04:08,000
Pentru aceste ultimele câteva săptămâni, ceea ce e cu adevărat a fi depozitate într s

1175
01:04:08,000 --> 01:04:13,000
nu este acest șir în sine, dar, în acest caz, ceea ce se depozitate este

1176
01:04:13,000 --> 01:04:18,000
0 Numărul că ceea ce de fapt nu getString

1177
01:04:18,000 --> 01:04:20,000
este că nu se întoarce fizic un șir.

1178
01:04:20,000 --> 01:04:22,000
Asta nu face cu adevărat nici un sens conceptual.

1179
01:04:22,000 --> 01:04:24,000
Ceea ce face revenirea este un număr.

1180
01:04:24,000 --> 01:04:28,000
Acest număr este adresa HELLO în memorie,

1181
01:04:28,000 --> 01:04:32,000
și șirul s, apoi, dacă ne coaja de spate acest strat, șir nu există cu adevărat.

1182
01:04:32,000 --> 01:04:35,000
E doar o simplificare în bibliotecă CS50.

1183
01:04:35,000 --> 01:04:38,000
>> Acest lucru este cu adevărat ceva numit char *.

1184
01:04:38,000 --> 01:04:41,000
Char are sens, deoarece ceea ce e un cuvânt, cum ar fi HELLO?

1185
01:04:41,000 --> 01:04:44,000
Ei bine, este o serie de caractere, o serie de caractere.

1186
01:04:44,000 --> 01:04:47,000
* Char înseamnă adresa unui personaj,

1187
01:04:47,000 --> 01:04:50,000
Deci, ce înseamnă să se întoarcă un șir?

1188
01:04:50,000 --> 01:04:53,000
Un mod frumos, simplu, de a se întoarce un șir

1189
01:04:53,000 --> 01:04:57,000
este, mai degrabă decât să încerce să dau seama cum să mă întorc la 5 sau 6 octeți diferite

1190
01:04:57,000 --> 01:05:01,000
permiteți-mi să se întoarcă la adresa pe care byte?

1191
01:05:01,000 --> 01:05:03,000
Primul.

1192
01:05:03,000 --> 01:05:06,000
Cu alte cuvinte, permiteți-mi să vă dau adresa unui personaj în memorie.

1193
01:05:06,000 --> 01:05:10,000
Asta e ceea ce char * reprezintă, adresa un caracter unic în memorie.

1194
01:05:10,000 --> 01:05:12,000
Numesc asta e variabila.

1195
01:05:12,000 --> 01:05:15,000
Magazin în care s anumită adresă, care am spus arbitrar este 0,

1196
01:05:15,000 --> 01:05:19,000
doar pentru a menține lucrurile simple, dar în realitate este, în general, un număr mai mare.

1197
01:05:19,000 --> 01:05:21,000
>> Stai un minut.

1198
01:05:21,000 --> 01:05:23,000
Dacă sunteți doar să-mi dea adresa primului caracter, cum știu ce adresă este

1199
01:05:23,000 --> 01:05:25,000
al doilea caracter, al treilea, al patrulea și al cincilea?

1200
01:05:25,000 --> 01:05:27,000
[Imperceptibil-elev]

1201
01:05:27,000 --> 01:05:31,000
Știi doar în cazul în care la sfârșitul string este cu titlu de acest truc la îndemână,

1202
01:05:31,000 --> 01:05:35,000
astfel încât atunci când utilizați ceva de genul printf, ceea ce printf literalmente ia ca argument,

1203
01:05:35,000 --> 01:05:39,000
Reamintim că vom folosi acest substituent% s, iar apoi treci la

1204
01:05:39,000 --> 01:05:41,000
variabila care este un șir stocarea.

1205
01:05:41,000 --> 01:05:47,000
Ceea ce într-adevăr trece este adresa primului caracter din șir.

1206
01:05:47,000 --> 01:05:50,000
Printf foloseste apoi un pentru buclă sau o buclă în timp ce la primirea acea adresă,

1207
01:05:50,000 --> 01:05:53,000
de exemplu, 0, asa ca lasa-mă să fac asta acum,

1208
01:05:53,000 --> 01:06:02,000
printf ("% s \ n", s);

1209
01:06:02,000 --> 01:06:07,000
Când m-am apel printf ("% s \ n", s); ceea ce am cu adevărat oferi printf cu

1210
01:06:07,000 --> 01:06:13,000
este adresa primului caracter din s., care în acest caz este arbitrară H.

1211
01:06:13,000 --> 01:06:16,000
>> Cum nu știe exact ce printf pentru a afișa pe ecran?

1212
01:06:16,000 --> 01:06:19,000
Persoana care a pus în aplicare în aplicare printf o buclă în timp sau o buclă pentru

1213
01:06:19,000 --> 01:06:23,000
care spune acest personaj nu egală cu caracterul nul special?

1214
01:06:23,000 --> 01:06:25,000
Dacă nu, imprima. Ce zici de asta?

1215
01:06:25,000 --> 01:06:28,000
Dacă nu-l imprimați, imprima, imprimați-l, îl imprimați.

1216
01:06:28,000 --> 01:06:32,000
Oh, asta este special. Opri imprimarea și a reveni la utilizator.

1217
01:06:32,000 --> 01:06:35,000
Și asta e tot ce literalmente sa întâmplat sub capota,

1218
01:06:35,000 --> 01:06:38,000
și că o mulțime de a digera în prima zi a unei clase,

1219
01:06:38,000 --> 01:06:43,000
dar acum este într-adevăr bloc a tot ceea ce înțelegere

1220
01:06:43,000 --> 01:06:46,000
care a fost întâmplă în interiorul memoriei calculatorului nostru,

1221
01:06:46,000 --> 01:06:49,000
și în cele din urmă vom prezenta în afară tachineze cu un pic de ajutor

1222
01:06:49,000 --> 01:06:51,000
de la unul dintre prietenii nostri de la Stanford.

1223
01:06:51,000 --> 01:06:56,000
>> Profesorul Nick Parlante de la Stanford a făcut această secvență video de minunat

1224
01:06:56,000 --> 01:06:58,000
de la tot felul de limbi diferite, care au introdus

1225
01:06:58,000 --> 01:07:00,000
acest mic personaj claymation Binky.

1226
01:07:00,000 --> 01:07:03,000
Vocea esti pe cale de a auzi în doar o previzualizare a furișăm câteva secunde

1227
01:07:03,000 --> 01:07:05,000
este cea a unui profesor de la Stanford, si vei primi

1228
01:07:05,000 --> 01:07:07,000
doar 5 sau 6 secunde de asta acum,

1229
01:07:07,000 --> 01:07:09,000
dar aceasta este nota pe care o vom încheia astăzi

1230
01:07:09,000 --> 01:07:11,000
și să înceapă miercuri.

1231
01:07:11,000 --> 01:07:15,000
Eu vă dau Fun Indicator cu Binky, previzualizare.

1232
01:07:15,000 --> 01:07:18,000
[♪ ♪ Muzică] [Profesorul Parlante] Hei, Binky.

1233
01:07:18,000 --> 01:07:21,000
Trezește-te. E timpul pentru distracție indicatorul.

1234
01:07:21,000 --> 01:07:24,000
[Binky] Ce e asta? Aflați mai multe despre indicii?

1235
01:07:24,000 --> 01:07:26,000
Ce bine!

1236
01:07:26,000 --> 01:07:29,000
>> Vă vom vedea miercuri.

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]