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

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

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

4
00:00:08,000 --> 00:00:10,000
>> Hei, toată lumea.

5
00:00:10,000 --> 00:00:15,000
Bine ați venit la sesiunea de reexaminare pentru Quiz 0, care are loc miercurea aceasta.

6
00:00:15,000 --> 00:00:19,000
Ceea ce am de gând să faci în seara asta, eu sunt cu 3 TFS alte,

7
00:00:19,000 --> 00:00:24,000
și împreună vom merge printr-o revizuire a ceea ce am făcut în cursul până în prezent.

8
00:00:24,000 --> 00:00:27,000
Acesta nu va fi de 100% complete, dar ar trebui să vă dau o idee mai bună

9
00:00:27,000 --> 00:00:31,000
de ceea ce ai deja în jos și ceea ce aveți nevoie în continuare pentru a studia inainte de miercuri.

10
00:00:31,000 --> 00:00:34,000
Și nu ezitați să ridice mâna cu întrebări ca mergem de-a lungul,

11
00:00:34,000 --> 00:00:38,000
dar păstrează în minte faptul că vom avea, de asemenea, un pic de timp de la sfârșitul anului

12
00:00:38,000 --> 00:00:41,000
în cazul în care vom obține prin intermediul cu câteva minute pentru a de rezervă, pentru a face întrebări generale,

13
00:00:41,000 --> 00:00:47,000
deci rețineți că, în minte, și așa am de gând să înceapă de la început cu săptămâna 0.

14
00:00:47,000 --> 00:00:50,000
>> [Quiz 0 opinie!] [Partea 0] [Lexi Ross] Dar, inainte de a face asta haideți să vorbim despre

15
00:00:50,000 --> 00:00:53,000
logistica de test.

16
00:00:53,000 --> 00:00:55,000
>> [Logistica] [Chestionar are loc miercuri, 10/10 în loc de curs]

17
00:00:55,000 --> 00:00:57,000
>> [(A se vedea pentru detalii http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf)], este miercuri, 10 octombrie.

18
00:00:57,000 --> 00:01:00,000
>> Asta e miercurea aceasta, și dacă te duci la această adresă URL aici,

19
00:01:00,000 --> 00:01:03,000
care este, de asemenea, accesibil din CS50.net-acolo e un link către aceasta,

20
00:01:03,000 --> 00:01:06,000
puteți vedea informații despre unde să mergeți pe baza

21
00:01:06,000 --> 00:01:10,000
Numele dvs. de familie sau de afiliere față de școală, precum și

22
00:01:10,000 --> 00:01:14,000
se spune despre exact ceea ce testul va acoperi și tipurile de întrebări pe care ai de gând să obțineți.

23
00:01:14,000 --> 00:01:19,000
Țineți cont de faptul că veți avea, de asemenea, o șansă de a revizui pentru test în secțiune,

24
00:01:19,000 --> 00:01:21,000
astfel TFS dvs. ar trebui să fie trecând peste unele probleme de practică,

25
00:01:21,000 --> 00:01:29,000
și asta este o altă șansă bună de a vedea în cazul în care aveți în continuare nevoie pentru a studia pentru test.

26
00:01:29,000 --> 00:01:32,000
Să începem de la început cu Bytes 'n' biți.

27
00:01:32,000 --> 00:01:35,000
Amintiți-vă un pic este doar un 0 sau un 1,

28
00:01:35,000 --> 00:01:38,000
și un octet este o colecție de 8 biți a acestor.

29
00:01:38,000 --> 00:01:42,000
Să ne uităm la această colecție de biți chiar aici.

30
00:01:42,000 --> 00:01:44,000
Noi ar trebui să fie în măsură să dau seama cum de multe biți sunt.

31
00:01:44,000 --> 00:01:48,000
În cazul în care ne bazăm nu e doar 8 dintre ei, cu opt unități de 0 sau 1.

32
00:01:48,000 --> 00:01:51,000
Și din moment ce există 8 biți, care e un octet,

33
00:01:51,000 --> 00:01:53,000
și să-l transforme în hexazecimal.

34
00:01:53,000 --> 00:01:58,000
Hexazecimal este baza 16, și este destul de ușor pentru a converti

35
00:01:58,000 --> 00:02:01,000
un număr în binar, care este ceea ce este faptul că, la un număr în hexazecimal.

36
00:02:01,000 --> 00:02:04,000
Tot ce facem este ne uitam la grupuri de 4,

37
00:02:04,000 --> 00:02:07,000
și le converti în cifre hexazecimale corespunzătoare.

38
00:02:07,000 --> 00:02:11,000
Vom începe cu drept de grup-cea mai mare de 4, așa 0011.

39
00:02:11,000 --> 00:02:16,000
Asta va fi un 1 și un 2, astfel încât împreună face 3.

40
00:02:16,000 --> 00:02:19,000
Și atunci să ne uităm la blocul celălalt de 4.

41
00:02:19,000 --> 00:02:24,000
1101. Asta va fi un 1, un 4, și un 8.

42
00:02:24,000 --> 00:02:28,000
Împreună, care va fi 13, care face D.

43
00:02:28,000 --> 00:02:32,000
Și ne vom aminti că, în hexazecimal noi nu mergem la 0 la 9.

44
00:02:32,000 --> 00:02:36,000
Noi mergem la 0 la F, dupa 9, 10 corespunde unei,

45
00:02:36,000 --> 00:02:40,000
11 B, et cetera unde F este de 15.

46
00:02:40,000 --> 00:02:44,000
Aici este un D 13,

47
00:02:44,000 --> 00:02:49,000
astfel încât să converti în zecimal tot ceea ce facem este că, de fapt

48
00:02:49,000 --> 00:02:52,000
trateze fiecare poziție ca o putere a lui 2.

49
00:02:52,000 --> 00:02:58,000
Asta e un 1, o 2, la zero 4s, zero 8s, o 16, et cetera,

50
00:02:58,000 --> 00:03:03,000
și e un pic cam greu pentru a calcula în capul tău, dar dacă mergem la urmatorul slide

51
00:03:03,000 --> 00:03:05,000
putem vedea răspunsul la asta.

52
00:03:05,000 --> 00:03:09,000
>> În esență, mergem peste drum de dreapta spate la stânga,

53
00:03:09,000 --> 00:03:14,000
și suntem înmulțirea fiecărei cifre de puterea corespunzătoare de 2.

54
00:03:14,000 --> 00:03:19,000
Și amintiți-vă, pentru hexazecimal notăm aceste numere cu 0x la început

55
00:03:19,000 --> 00:03:23,000
așa că nu-l confunda cu un număr zecimal.

56
00:03:23,000 --> 00:03:29,000
Continuând pe, acesta este un tabel ASCII,

57
00:03:29,000 --> 00:03:35,000
și ceea ce vom folosi ASCII pentru este de a mapa de caractere la valori numerice.

58
00:03:35,000 --> 00:03:39,000
Amintiți-vă, în PSET criptografie am folosit pe scară largă a Tabelul ASCII

59
00:03:39,000 --> 00:03:43,000
, în scopul de a utiliza diverse metode de criptografie,

60
00:03:43,000 --> 00:03:47,000
Cezar și cifrul Vigenere, pentru a converti litere diferite

61
00:03:47,000 --> 00:03:52,000
într-un șir în conformitate cu cheia dată de utilizator.

62
00:03:52,000 --> 00:03:56,000
Să ne uităm la un pic de matematica ASCII.

63
00:03:56,000 --> 00:04:02,000
Privind la "P" + 1, în formă de caractere care ar fi Q,

64
00:04:02,000 --> 00:04:07,000
și amintiți-vă că "'5 ≠ 5.

65
00:04:07,000 --> 00:04:10,000
Și cum mai exact ne-ar converti între aceste 2 forme?

66
00:04:10,000 --> 00:04:13,000
Nu e de fapt prea greu.

67
00:04:13,000 --> 00:04:16,000
În scopul de a obține 5 scădem '0 '

68
00:04:16,000 --> 00:04:20,000
deoarece sunt 5 locuri între '0 'și '5. "

69
00:04:20,000 --> 00:04:23,000
În scopul de a merge în altă parte vom adăuga doar 0,

70
00:04:23,000 --> 00:04:25,000
deci e un fel de aritmetică regulate.

71
00:04:25,000 --> 00:04:29,000
Doar amintiți-vă că atunci când ceva are citate în jurul valorii de ea e un personaj

72
00:04:29,000 --> 00:04:37,000
și, astfel, corespunde o valoare în tabelul ASCII.

73
00:04:37,000 --> 00:04:40,000
Mutarea în mai multe teme generale de informatică.

74
00:04:40,000 --> 00:04:43,000
Am învățat ce un algoritm este și modul în care ne folosim de programare

75
00:04:43,000 --> 00:04:45,000
să pună în aplicare algoritmi.

76
00:04:45,000 --> 00:04:48,000
Câteva exemple de algoritmi sunt ceva foarte simplu ca

77
00:04:48,000 --> 00:04:51,000
a verifica dacă un număr este par sau impar.

78
00:04:51,000 --> 00:04:54,000
Pentru că ne amintim modez numărul de 2 și verificați dacă rezultatul este 0.

79
00:04:54,000 --> 00:04:57,000
Dacă este așa, e chiar. Dacă nu, e ciudat.

80
00:04:57,000 --> 00:04:59,000
Si asta e un exemplu de algoritm foarte de bază.

81
00:04:59,000 --> 00:05:02,000
>> Un pic de una mult mai implicat este căutare binară,

82
00:05:02,000 --> 00:05:05,000
care vom trece peste mai târziu, în sesiunea de reexaminare.

83
00:05:05,000 --> 00:05:09,000
Și de programare este termenul vom folosi pentru a lua un algoritm

84
00:05:09,000 --> 00:05:15,000
și transformând-o pentru a coda calculatorul poate citi.

85
00:05:15,000 --> 00:05:20,000
2 exemple de programare este Scratch,

86
00:05:20,000 --> 00:05:22,000
care este ceea ce am făcut în săptămâna 0.

87
00:05:22,000 --> 00:05:25,000
Chiar dacă nu ne tastați codul efectiv este o modalitate de punere în aplicare

88
00:05:25,000 --> 00:05:29,000
acest algoritm, care se imprimă numerele 1-10,

89
00:05:29,000 --> 00:05:32,000
și aici facem același lucru în limbajul de programare C.

90
00:05:32,000 --> 00:05:41,000
Acestea sunt echivalente funcțional, doar scrise în limbi diferite sau de sintaxă.

91
00:05:41,000 --> 00:05:44,000
Apoi am învățat despre expresii booleene,

92
00:05:44,000 --> 00:05:48,000
și un boolean este o valoare care este adevărat sau fals,

93
00:05:48,000 --> 00:05:51,000
și de multe ori expresii booleene aici

94
00:05:51,000 --> 00:05:55,000
du-te în interiorul unor condiții, astfel încât, dacă (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
ei bine, am stabilit deja x = 5, astfel încât condiție este de gând să evalueze la adevărat.

96
00:06:00,000 --> 00:06:03,000
Și dacă e adevărat, tot ce este sub cod condiție

97
00:06:03,000 --> 00:06:08,000
va fi evaluat de către calculator, astfel încât șirul va fi imprimată

98
00:06:08,000 --> 00:06:12,000
la iesirea standard, iar condiția termenul

99
00:06:12,000 --> 00:06:16,000
se referă la ceea ce este în interiorul paranteze de declarația în cazul în care.

100
00:06:16,000 --> 00:06:20,000
Amintiți-vă toți operatorii.

101
00:06:20,000 --> 00:06:26,000
Amintiți-vă && sale și | | atunci cand incercam sa combina 2 sau mai multe condiții,

102
00:06:26,000 --> 00:06:30,000
== = Nu pentru a verifica dacă 2 lucruri sunt egale.

103
00:06:30,000 --> 00:06:36,000
Amintiți-vă că = este pentru atribuirea întrucât == este un operator boolean.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ i apoi finala 2 sunt auto-explicative.

105
00:06:41,000 --> 00:06:45,000
O revizuire generală a logica booleană aici.

106
00:06:45,000 --> 00:06:48,000
Și expresii booleene sunt de asemenea importante în bucle,

107
00:06:48,000 --> 00:06:50,000
care vom trece peste acum.

108
00:06:50,000 --> 00:06:56,000
Am învățat aproximativ 3 tipuri de bucle până în prezent în CS50, pentru, în timp ce, și de a face în timp.

109
00:06:56,000 --> 00:06:59,000
Și e important să știți că în timp ce pentru cele mai multe scopuri

110
00:06:59,000 --> 00:07:02,000
putem folosi de fapt, orice tip de bucla, în general,

111
00:07:02,000 --> 00:07:06,000
există anumite tipuri de scopuri sau modele comune

112
00:07:06,000 --> 00:07:09,000
în programare care suna în mod special pentru una dintre aceste bucle

113
00:07:09,000 --> 00:07:13,000
care îl fac. cel mai eficient sau elegant să-l cod în acest fel

114
00:07:13,000 --> 00:07:18,000
Să trecem peste ceea ce fiecare dintre aceste bucle tinde să fie utilizată pentru cele mai multe ori.

115
00:07:18,000 --> 00:07:21,000
>> Într-o buclă pentru noi, în general, știm deja cum de multe ori dorim să itera.

116
00:07:21,000 --> 00:07:24,000
Asta e ceea ce am pus în stare.

117
00:07:24,000 --> 00:07:28,000
Pentru, i = 0, i <10, de exemplu.

118
00:07:28,000 --> 00:07:31,000
Știm deja că vrem să facem ceva de 10 ori.

119
00:07:31,000 --> 00:07:34,000
Acum, pentru o buclă în timp ce, în general, nu neapărat

120
00:07:34,000 --> 00:07:36,000
știu de câte ori vrem bucla pentru a rula.

121
00:07:36,000 --> 00:07:39,000
Dar stim un fel de condiții pe care vrem să-l

122
00:07:39,000 --> 00:07:41,000
întotdeauna să fie adevărat sau fals să fie întotdeauna.

123
00:07:41,000 --> 00:07:44,000
De exemplu, în timp ce este setat.

124
00:07:44,000 --> 00:07:46,000
Să spunem că e o variabilă boolean.

125
00:07:46,000 --> 00:07:48,000
În timp ce este adevărat că vrem cod pentru a evalua,

126
00:07:48,000 --> 00:07:52,000
deci un pic mai mult extensibil, un pic mai general decât o buclă pentru,

127
00:07:52,000 --> 00:07:55,000
dar orice pentru buclă poate fi, de asemenea, convertite într-o buclă în timp ce.

128
00:07:55,000 --> 00:08:00,000
În cele din urmă, în timp ce face bucle, care pot fi mai dificila de a înțelege imediat,

129
00:08:00,000 --> 00:08:04,000
sunt adesea folosite atunci când vrem să evalueze primul cod

130
00:08:04,000 --> 00:08:06,000
înainte de prima dată când am verifica starea.

131
00:08:06,000 --> 00:08:09,000
Un caz de utilizare comună pentru o face în timp ce bucla

132
00:08:09,000 --> 00:08:12,000
este atunci când doriți să obțineți date introduse de utilizator, și știi că vrei să ceară utilizatorului

133
00:08:12,000 --> 00:08:15,000
pentru intrare cel puțin o dată, dar în cazul în care nu vă dau de intrare bine imediat

134
00:08:15,000 --> 00:08:18,000
doriți să păstrați cerându-le până când îți dă de intrare bun.

135
00:08:18,000 --> 00:08:21,000
Asta e mai comună utilizare a unui buclă în timp ce-mi,

136
00:08:21,000 --> 00:08:23,000
și să ne uităm la structura efectivă a acestor bucle.

137
00:08:23,000 --> 00:08:27,000
Ele de obicei, mereu tendinta de a urma aceste modele.

138
00:08:27,000 --> 00:08:30,000
>> Pe bucla de interior ai 3 componente:

139
00:08:30,000 --> 00:08:35,000
initializare, de obicei, ceva de genul int i = 0 unde i este contra,

140
00:08:35,000 --> 00:08:40,000
condiție, în cazul în care vrem să spunem rulați acest lucru pentru bucla atât timp cât această condiție deține încă,

141
00:08:40,000 --> 00:08:44,000
ca i <10, și apoi în cele din urmă, update, care este modul în care ne incrementa

142
00:08:44,000 --> 00:08:47,000
variabila contor la fiecare punct în buclă.

143
00:08:47,000 --> 00:08:50,000
Un lucru comun pentru a vedea acolo este doar i + +,

144
00:08:50,000 --> 00:08:52,000
ceea ce înseamnă incrementa i cu 1 de fiecare dată.

145
00:08:52,000 --> 00:08:55,000
Ai putea face, de asemenea, ceva de genul i + = 2,

146
00:08:55,000 --> 00:08:58,000
ceea ce înseamnă adaugă 2 la i de fiecare dată când merge prin bucla.

147
00:08:58,000 --> 00:09:03,000
Și apoi face acest lucru doar se refera la orice cod care ruleaza de fapt, ca parte a buclei.

148
00:09:03,000 --> 00:09:09,000
Și pentru o buclă în timp ce, de data aceasta avem de fapt de initializare in afara de bucla,

149
00:09:09,000 --> 00:09:12,000
Deci, de exemplu, să spunem că încercăm să facem același tip de bucla ca tocmai am descris.

150
00:09:12,000 --> 00:09:16,000
Ne-ar spune int i = 0 înainte de a începe bucla.

151
00:09:16,000 --> 00:09:20,000
Apoi ne-am putea spune în timp ce eu <10 face acest lucru,

152
00:09:20,000 --> 00:09:22,000
astfel încât același bloc de cod ca înainte,

153
00:09:22,000 --> 00:09:26,000
și de această dată parte de actualizare a codului, de exemplu, i + +,

154
00:09:26,000 --> 00:09:29,000
de fapt, merge în interiorul buclei.

155
00:09:29,000 --> 00:09:33,000
Și, în sfârșit, pentru o faceți în timp ce, e similar cu bucla în timp ce,

156
00:09:33,000 --> 00:09:36,000
dar trebuie să ne amintim că codul va evalua o dată

157
00:09:36,000 --> 00:09:40,000
înainte de condiție se verifică, asa ca are sens mult mai mult

158
00:09:40,000 --> 00:09:44,000
daca te uiti la ea, în scopul de sus în jos.

159
00:09:44,000 --> 00:09:49,000
Într-o, în timp ce face bucla codul evaluează înainte de a te uiti chiar si la starea în timp ce

160
00:09:49,000 --> 00:09:55,000
întrucât o buclă în timp ce, se verifică mai întâi.

161
00:09:55,000 --> 00:09:59,000
Declarații și variabile.

162
00:09:59,000 --> 00:10:04,000
Atunci când dorim să creăm o nouă variabilă ne-am dori să-l inițializa.

163
00:10:04,000 --> 00:10:07,000
>> De exemplu, bara de int inițializează variabila bar,

164
00:10:07,000 --> 00:10:10,000
dar nu da o valoare, astfel încât ceea ce este valoarea barul lui acum?

165
00:10:10,000 --> 00:10:12,000
Noi nu știm.

166
00:10:12,000 --> 00:10:14,000
Ar putea fi o anumită valoare gunoi care a fost stocat anterior în memorie acolo,

167
00:10:14,000 --> 00:10:16,000
și nu doriți să utilizați ca variabilă

168
00:10:16,000 --> 00:10:19,000
până când vom da de fapt, o valoare,

169
00:10:19,000 --> 00:10:21,000
așa că am să declare aici.

170
00:10:21,000 --> 00:10:24,000
Apoi ne-am inițializa să fie 42 de mai jos.

171
00:10:24,000 --> 00:10:28,000
Acum, desigur, știm că acest lucru poate fi realizat pe o singură linie, int = 42 bar.

172
00:10:28,000 --> 00:10:30,000
Dar, doar pentru a fi clar în mai multe etape care au loc,

173
00:10:30,000 --> 00:10:34,000
declarația și inițializarea se intampla separat aici.

174
00:10:34,000 --> 00:10:38,000
Aceasta se întâmplă pe un singur pas, iar urmatorul, int Baz = bar + 1,

175
00:10:38,000 --> 00:10:44,000
această declarație de mai jos, care Baz incremente, asa ca la sfârșitul acestui bloc de cod

176
00:10:44,000 --> 00:10:48,000
dacă am pentru a imprima valoarea de baz ar fi 44

177
00:10:48,000 --> 00:10:52,000
pentru că ne pronunțăm și inițializa-l să fie de 1 bar>,

178
00:10:52,000 --> 00:10:58,000
și apoi l-am incrementa o dată mai mult cu + +.

179
00:10:58,000 --> 00:11:02,000
Ne-am dus peste acest scurt destul, dar e bine să aibă o

180
00:11:02,000 --> 00:11:04,000
înțelegerea a ceea ce fire și evenimente sunt.

181
00:11:04,000 --> 00:11:06,000
Am făcut acest lucru în principal, Scratch,

182
00:11:06,000 --> 00:11:09,000
astfel încât vă puteți gândi de fire ca mai multe secvențe de cod

183
00:11:09,000 --> 00:11:11,000
rulează în același timp.

184
00:11:11,000 --> 00:11:14,000
În realitate, probabil că nu se execută, în același timp,

185
00:11:14,000 --> 00:11:17,000
dar un fel de abstract ne putem gândi că în acest fel.

186
00:11:17,000 --> 00:11:20,000
>> În Scratch, de exemplu, am avut mai multe sprites.

187
00:11:20,000 --> 00:11:22,000
Ar putea fi de executare alt cod, în același timp.

188
00:11:22,000 --> 00:11:26,000
S-ar putea fi mersul pe jos în timp ce celălalt spune ceva

189
00:11:26,000 --> 00:11:29,000
într-o altă parte a ecranului.

190
00:11:29,000 --> 00:11:34,000
Evenimentele sunt un alt mod de a separa logica

191
00:11:34,000 --> 00:11:37,000
între diferitele elemente ale codului,

192
00:11:37,000 --> 00:11:40,000
și în Scratch am putut pentru a simula evenimente folosind Broadcast,

193
00:11:40,000 --> 00:11:43,000
și că, de fapt, atunci când primesc, nu atunci când aud,

194
00:11:43,000 --> 00:11:47,000
dar în esență, este un mod de a transmite informații

195
00:11:47,000 --> 00:11:49,000
de la un Sprite la alta.

196
00:11:49,000 --> 00:11:52,000
De exemplu, poate doriți să transmită joc de peste,

197
00:11:52,000 --> 00:11:56,000
și atunci când un alt joc de peste Sprite primește,

198
00:11:56,000 --> 00:11:58,000
acesta răspunde într-un anumit fel.

199
00:11:58,000 --> 00:12:03,000
Este un model important pentru a înțelege pentru programare.

200
00:12:03,000 --> 00:12:07,000
Doar pentru a trece peste Săptămâna de bază 0, ceea ce am trecut peste pana acum,

201
00:12:07,000 --> 00:12:10,000
să ne uităm la acest program C simplu.

202
00:12:10,000 --> 00:12:14,000
Textul poate fi un pic mic de aici, dar voi trece peste asta foarte repede.

203
00:12:14,000 --> 00:12:20,000
Suntem inclusiv 2 fisiere antet de la cs50.h de sus, și stdio.h.

204
00:12:20,000 --> 00:12:23,000
Suntem definirea apoi o limită constantă numită să fie 100.

205
00:12:23,000 --> 00:12:26,000
Suntem de punere în aplicare atunci funcția nostru principal.

206
00:12:26,000 --> 00:12:29,000
Din moment ce nu folosim argumente din linia de comandă aici avem nevoie pentru a pune anulate

207
00:12:29,000 --> 00:12:32,000
ca argumente pentru principal.

208
00:12:32,000 --> 00:12:38,000
Ne vedem mai sus int principal. Asta e tipul de retur, deci întoarce 0 la partea de jos.

209
00:12:38,000 --> 00:12:41,000
Și noi suntem folosind funcția de bibliotecă CS50 obține int

210
00:12:41,000 --> 00:12:45,000
să solicite utilizatorului pentru intrare, și l-am păstra în această variabila x,

211
00:12:45,000 --> 00:12:51,000
asa ne pronunțăm x de mai sus, și l-am inițializa cu x = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> Noi apoi atunci a verifica pentru a vedea dacă utilizatorul de intrare ne-a dat bine.

213
00:12:53,000 --> 00:12:59,000
Dacă e TERMENUL ≥ vrem să se întoarcă un cod de eroare de 1 si imprima un mesaj de eroare.

214
00:12:59,000 --> 00:13:02,000
Și, în sfârșit, în cazul în care utilizatorul ne-a dat bine de intrare

215
00:13:02,000 --> 00:13:08,000
vom pătrat numărul și imprima acest rezultat.

216
00:13:08,000 --> 00:13:11,000
Doar pentru a vă asigura că cei toate hit-acasă

217
00:13:11,000 --> 00:13:17,000
puteți vedea etichetele de diferite părți ale codului aici.

218
00:13:17,000 --> 00:13:19,000
Am menționat fișiere constante, antet.

219
00:13:19,000 --> 00:13:21,000
Oh, int x. Asigurați-vă să ne amintim că este o variabilă locală.

220
00:13:21,000 --> 00:13:24,000
Că acesta contrastează dintr-o variabilă globală, pe care vom vorbi despre

221
00:13:24,000 --> 00:13:27,000
un pic mai târziu, în sesiunea de reexaminare,

222
00:13:27,000 --> 00:13:30,000
și ne sunt de asteptare funcția de bibliotecă printf,

223
00:13:30,000 --> 00:13:34,000
așa că, dacă nu am fi inclus fisierul header stdio.h

224
00:13:34,000 --> 00:13:37,000
nu am putea să numim printf.

225
00:13:37,000 --> 00:13:42,000
Și eu cred că săgeata a fost tăiat aici se indică spre d%,

226
00:13:42,000 --> 00:13:45,000
care este un șir de formatare în printf.

227
00:13:45,000 --> 00:13:52,000
Se spune imprima această variabilă ca d% un număr,.

228
00:13:52,000 --> 00:13:58,000
Și asta este pentru săptămâna 0.

229
00:13:58,000 --> 00:14:06,000
Acum, Lucas va continua.

230
00:14:06,000 --> 00:14:08,000
Hei, băieți. Numele meu este Lucas.

231
00:14:08,000 --> 00:14:10,000
Sunt un al doilea de studentie in cea mai buna casa de pe campus, Mather,

232
00:14:10,000 --> 00:14:14,000
și am de gând să vorbesc un pic despre Săptămâna 1 și 2.1.

233
00:14:14,000 --> 00:14:16,000
[Săptămâna 1 și 2,1!] [Lucas Freitas]

234
00:14:16,000 --> 00:14:19,000
Ca Lexi spunea, atunci când am început traducerea codul de la zero la C

235
00:14:19,000 --> 00:14:23,000
unul din lucrurile pe care am observat este că poți nu doar

236
00:14:23,000 --> 00:14:26,000
scrie codul și rulați-l folosind un steag verde mai.

237
00:14:26,000 --> 00:14:30,000
De fapt, va trebui să utilizați unele măsuri pentru a face programul tău C

238
00:14:30,000 --> 00:14:33,000
deveni un fișier executabil.

239
00:14:33,000 --> 00:14:36,000
Practic ceea ce faci atunci cand scrii un program care este

240
00:14:36,000 --> 00:14:40,000
ai traduce ideea într-o limbă pe care o înțelege compilator poate,

241
00:14:40,000 --> 00:14:44,000
asa ca atunci cand scrii un program în C

242
00:14:44,000 --> 00:14:47,000
ceea ce faci este scris de fapt, ceva care compilatorul dvs. este de gând să înțeleagă,

243
00:14:47,000 --> 00:14:50,000
și apoi compilator este de gând să traducem acest cod

244
00:14:50,000 --> 00:14:53,000
în ceva care calculatorul dvs. va înțelege.

245
00:14:53,000 --> 00:14:55,000
>> Și chestia este, computerul este de fapt foarte prost.

246
00:14:55,000 --> 00:14:57,000
Computerul poate înțelege doar 0s și 1s,

247
00:14:57,000 --> 00:15:01,000
astfel încât, de fapt, în primele calculatoare, de obicei, oamenii programat

248
00:15:01,000 --> 00:15:04,000
folosind 0s și 1s, dar nu mai, mulțumesc lui Dumnezeu.

249
00:15:04,000 --> 00:15:07,000
Noi nu trebuie să memoreze secventele de 0s și 1s

250
00:15:07,000 --> 00:15:10,000
pentru o buclă pentru sau pentru o buclă în timp ce și așa mai departe.

251
00:15:10,000 --> 00:15:13,000
De aceea avem un compilator.

252
00:15:13,000 --> 00:15:17,000
Ce face un compilator este în esență traduce codul C,

253
00:15:17,000 --> 00:15:21,000
în cazul nostru, într-o limbă pe care calculatorul dvs. va înțelege,

254
00:15:21,000 --> 00:15:25,000
care este codul obiect, iar compilatorul pe care îl utilizăm

255
00:15:25,000 --> 00:15:30,000
este numit zăngănit, astfel încât acesta este de fapt simbolul pentru zăngănit.

256
00:15:30,000 --> 00:15:33,000
Când aveți programul dumneavoastră, trebuie să faci 2 lucruri.

257
00:15:33,000 --> 00:15:37,000
În primul rând, trebuie să compilați programul dumneavoastră, și apoi ai de gând să rulați programul tău.

258
00:15:37,000 --> 00:15:41,000
Pentru a compila programul dumneavoastră aveți o mulțime de opțiuni pentru a face acest lucru.

259
00:15:41,000 --> 00:15:44,000
Prima dintre ele este de a face program.c zăngănit

260
00:15:44,000 --> 00:15:47,000
în care programul este numele programului.

261
00:15:47,000 --> 00:15:51,000
În acest caz, puteți vedea că spui doar "Hei, compila programul meu."

262
00:15:51,000 --> 00:15:56,000
Tu nu spui "Vreau acest nume pentru programul meu", sau ceva de genul.

263
00:15:56,000 --> 00:15:58,000
>> A doua opțiune este da un nume pentru program.

264
00:15:58,000 --> 00:16:02,000
Se poate spune zăngănit-o și apoi numele pe care îl doriți

265
00:16:02,000 --> 00:16:06,000
fișierul executabil care urmează să fie numit ca și apoi program.c.

266
00:16:06,000 --> 00:16:11,000
Și puteți face, de asemenea, face programul, și să vedem cum, în primele 2 cazuri

267
00:16:11,000 --> 00:16:15,000
Am pus C,. Și, în al treilea am doar programe?

268
00:16:15,000 --> 00:16:18,000
Da, de fapt, nu ar trebui să pună c atunci când utilizați fac..

269
00:16:18,000 --> 00:16:22,000
În caz contrar, compilatorul este, de fapt de gând să țip la tine.

270
00:16:22,000 --> 00:16:24,000
Și, de asemenea, nu știu dacă voi aminti,

271
00:16:24,000 --> 00:16:29,000
dar de multe ori am folosit, de asemenea, lcs50-sau-LM.

272
00:16:29,000 --> 00:16:31,000
Care este numit de legătură.

273
00:16:31,000 --> 00:16:35,000
Ea spune doar compilatorul pe care le va folosi aceste biblioteci acolo,

274
00:16:35,000 --> 00:16:39,000
așa că, dacă doriți să utilizați cs50.h de fapt trebuie să tastați

275
00:16:39,000 --> 00:16:43,000
zăngănit program.c-lcs50.

276
00:16:43,000 --> 00:16:45,000
Dacă nu faci asta, compilatorul nu este de gând să știu

277
00:16:45,000 --> 00:16:50,000
pe care îl utilizați aceste funcții în cs50.h.

278
00:16:50,000 --> 00:16:52,000
Iar atunci când doriți să rulați programul tău aveți 2 opțiuni.

279
00:16:52,000 --> 00:16:57,000
Dacă ați făcut program.c zăngănit nu ai da un nume pentru program.

280
00:16:57,000 --> 00:17:01,000
Trebuie să-l rulați utilizând / a.out..

281
00:17:01,000 --> 00:17:06,000
A.out este un nume standard care ofera zăngănit programul dumneavoastră dacă nu dau un nume.

282
00:17:06,000 --> 00:17:11,000
În caz contrar, ai de gând să faci / programului., Dacă ați dat un nume la program,

283
00:17:11,000 --> 00:17:15,000
și, de asemenea, dacă ai făcut-o face programul de numele pe care un program este mergi la a lua

284
00:17:15,000 --> 00:17:23,000
este deja va fi programat același nume ca fisierul c.

285
00:17:23,000 --> 00:17:26,000
Apoi am vorbit despre tipurile de date și de date.

286
00:17:26,000 --> 00:17:31,000
>> Practic tipuri de date sunt același lucru ca și cutii mici pe care le folosesc

287
00:17:31,000 --> 00:17:35,000
pentru a stoca valori, deci tipuri de date sunt de fapt la fel ca pokemoni.

288
00:17:35,000 --> 00:17:39,000
Ei vin în toate mărimile și tipurile.

289
00:17:39,000 --> 00:17:43,000
Nu știu dacă asta are sens analogie.

290
00:17:43,000 --> 00:17:46,000
Dimensiunea de date, de fapt depinde de arhitectura mașinii.

291
00:17:46,000 --> 00:17:49,000
Toate dimensiunile de date pe care am de gând să arate aici

292
00:17:49,000 --> 00:17:53,000
sunt de fapt pentru o mașină de 32-biți, care este cazul aparatului nostru,

293
00:17:53,000 --> 00:17:56,000
dar dacă sunteți de codificare de fapt, Mac-ul sau într-un Windows, de asemenea,

294
00:17:56,000 --> 00:17:59,000
probabil ai de gând să aibă o mașină de 64-biți,

295
00:17:59,000 --> 00:18:03,000
astfel amintiți-vă că dimensiunile de date pe care am de gând să arate aici

296
00:18:03,000 --> 00:18:06,000
sunt pentru masina de 32-biți.

297
00:18:06,000 --> 00:18:08,000
Primul pe care am vazut a fost un int,

298
00:18:08,000 --> 00:18:10,000
care este destul de simplă.

299
00:18:10,000 --> 00:18:13,000
Puteți utiliza int pentru a stoca un număr întreg.

300
00:18:13,000 --> 00:18:16,000
Am văzut, de asemenea, caracterul, char.

301
00:18:16,000 --> 00:18:20,000
Dacă doriți să utilizați o literă sau un simbol mic esti, probabil, de gând să utilizeze un char.

302
00:18:20,000 --> 00:18:26,000
O char are 1 octet, ceea ce înseamnă 8 biți, cum ar fi spus Lexi.

303
00:18:26,000 --> 00:18:31,000
Practic, avem un tabel ASCII care are 256

304
00:18:31,000 --> 00:18:34,000
combinații posibile de 0s și 1s,

305
00:18:34,000 --> 00:18:37,000
și apoi când tastați un char se va traduce

306
00:18:37,000 --> 00:18:44,000
personaj care intrări un numar pe care îl au în tabelul ASCII, cum a spus Lexi.

307
00:18:44,000 --> 00:18:48,000
Avem, de asemenea, float, pe care le folosim pentru a stoca numere zecimale.

308
00:18:48,000 --> 00:18:53,000
Dacă doriți să alegeți 3.14, de exemplu, ai de gând să utilizați un flotor

309
00:18:53,000 --> 00:18:55,000
sau un dublu care are o precizie mai mult.

310
00:18:55,000 --> 00:18:57,000
Un flotor are 4 octeți.

311
00:18:57,000 --> 00:19:01,000
Un dublu are 8 octeți, astfel încât singura diferenta este de precizie.

312
00:19:01,000 --> 00:19:04,000
Avem, de asemenea, o lungă care este folosit pentru numere întregi,

313
00:19:04,000 --> 00:19:09,000
și puteți vedea pentru o mașină de 32-biți un int și un lung au aceeași dimensiune,

314
00:19:09,000 --> 00:19:13,000
așa că nu prea are sens să utilizeze un lung într-o mașină de 32-biți.

315
00:19:13,000 --> 00:19:17,000
>> Dar, dacă utilizați o mașină de Mac și 64-biți, de fapt, un lung are dimensiune 8,

316
00:19:17,000 --> 00:19:19,000
așa că într-adevăr depinde de arhitectura.

317
00:19:19,000 --> 00:19:22,000
Pentru masina de 32-bit, nu are sens să utilizeze un lung adevărat.

318
00:19:22,000 --> 00:19:25,000
Și apoi un lung timp, pe de altă parte, are 8 octeți,

319
00:19:25,000 --> 00:19:30,000
așa că este foarte bine, dacă doriți să aveți un număr întreg mai mare.

320
00:19:30,000 --> 00:19:34,000
Și, în sfârșit, avem string, care este de fapt un char *,

321
00:19:34,000 --> 00:19:37,000
care este un pointer la un char.

322
00:19:37,000 --> 00:19:40,000
Este foarte ușor să cred că mărimea șir va fi

323
00:19:40,000 --> 00:19:42,000
numărul de caractere pe care le aveți acolo,

324
00:19:42,000 --> 00:19:45,000
dar, de fapt char * sine

325
00:19:45,000 --> 00:19:49,000
are dimensiunea unui pointer la un char, care este de 4 octeți.

326
00:19:49,000 --> 00:19:52,000
Dimensiunea unui char * este de 4 octeți.

327
00:19:52,000 --> 00:19:56,000
Nu contează dacă aveți un cuvânt mic sau o scrisoare sau ceva.

328
00:19:56,000 --> 00:19:58,000
O să fie de 4 octeți.

329
00:19:58,000 --> 00:20:01,000
Am aflat, de asemenea, un pic despre turnare,

330
00:20:01,000 --> 00:20:04,000
Deci, după cum puteți vedea, dacă aveți, de exemplu, un program care spune

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

332
00:20:08,000 --> 00:20:12,000
Știți ce se întâmplă pentru a imprima pe ecran?

333
00:20:12,000 --> 00:20:14,000
>> Cineva >> [Studenții] 2?.

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

335
00:20:16,000 --> 00:20:20,000
Când faci 3/2 se va obține 1,5,

336
00:20:20,000 --> 00:20:24,000
dar din moment ce suntem folosind un întreg se va ignora partea zecimală,

337
00:20:24,000 --> 00:20:26,000
și ai de gând să aibă 1.

338
00:20:26,000 --> 00:20:29,000
Dacă nu vrea să se întâmple ceea ce se poate face, de exemplu,

339
00:20:29,000 --> 00:20:33,000
se declară un flotor y = x.

340
00:20:33,000 --> 00:20:40,000
Atunci x, care utilizate pentru a fi 3 este acum de gând să fie în y 3.000.

341
00:20:40,000 --> 00:20:44,000
Și apoi puteți imprima y / 2.

342
00:20:44,000 --> 00:20:50,000
De fapt, ar trebui să am un 2. acolo.

343
00:20:50,000 --> 00:20:55,000
Se va face 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
și vei primi 1.5.

345
00:20:58,000 --> 00:21:06,000
Și avem această f 0.2 doar pentru a cere pentru 2 unități zecimal în partea zecimală.

346
00:21:06,000 --> 00:21:12,000
Dacă aveți f 0.3 se va avea de fapt 1.500.

347
00:21:12,000 --> 00:21:16,000
Dacă e 2, aceasta va fi 1.50.

348
00:21:16,000 --> 00:21:18,000
Avem, de asemenea, acest caz aici.

349
00:21:18,000 --> 00:21:22,000
Dacă veți face float x = 3.14 si apoi x printf

350
00:21:22,000 --> 00:21:24,000
ai de gând să obțineți 3.14.

351
00:21:24,000 --> 00:21:29,000
Și dacă faci x = int de x,

352
00:21:29,000 --> 00:21:34,000
ceea ce înseamnă tratarea x ca un int și să imprimați x acum

353
00:21:34,000 --> 00:21:36,000
ai de gând să aibă 3.00.

354
00:21:36,000 --> 00:21:38,000
Are vreun sens?

355
00:21:38,000 --> 00:21:41,000
Pentru că te tratează primul x ca un întreg, astfel încât să te ignora partea zecimală,

356
00:21:41,000 --> 00:21:45,000
și apoi imprimați x.

357
00:21:45,000 --> 00:21:47,000
Și, în sfârșit, puteți face acest lucru,

358
00:21:47,000 --> 00:21:52,000
int x = 65, iar apoi să declare un char c = x,

359
00:21:52,000 --> 00:21:56,000
și apoi, dacă imprimați c tu esti de fapt mergi la a lua

360
00:21:56,000 --> 00:21:59,000
A, deci practic ce faci aici

361
00:21:59,000 --> 00:22:02,000
este traducerea în întreg caracterul,

362
00:22:02,000 --> 00:22:05,000
la fel ca tabelul ASCII face.

363
00:22:05,000 --> 00:22:08,000
Am vorbit și despre operatorii de matematica.

364
00:22:08,000 --> 00:22:14,000
Cele mai multe dintre ele sunt destul de simple, așa +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
și, de asemenea, am vorbit despre mod, care este restul de o divizie a 2 numere.

366
00:22:20,000 --> 00:22:23,000
Dacă aveți 10% 3, de exemplu,

367
00:22:23,000 --> 00:22:27,000
aceasta înseamnă împartă 10 cu 3, și ceea ce este restul?

368
00:22:27,000 --> 00:22:30,000
O să fie de 1, asa ca este de fapt foarte util pentru o multime de programe.

369
00:22:30,000 --> 00:22:38,000
Pentru Vigenere și Cezar sunt destul de sigur că voi toți băieți utilizat mod.

370
00:22:38,000 --> 00:22:43,000
Despre operatori de matematica, să fie foarte atenți atunci când combinarea * și /.

371
00:22:43,000 --> 00:22:48,000
>> De exemplu, dacă faci (3/2) * 2 Ce ai de gând să obțineți?

372
00:22:48,000 --> 00:22:50,000
[Studenții] 2.

373
00:22:50,000 --> 00:22:54,000
Da, 2, deoarece 3/2 va fi 1.5,

374
00:22:54,000 --> 00:22:57,000
dar din moment ce faci operațiuni între 2 numere întregi

375
00:22:57,000 --> 00:22:59,000
tu de fapt, doar de gând să ia în considerare 1,

376
00:22:59,000 --> 00:23:03,000
și apoi 1 * 2 va fi 2, asa ca fii foarte, foarte atent

377
00:23:03,000 --> 00:23:07,000
atunci când faci aritmetica cu numere întregi, deoarece

378
00:23:07,000 --> 00:23:12,000
s-ar putea obține că 2 = 3, în acest caz.

379
00:23:12,000 --> 00:23:14,000
Și, de asemenea, să fie foarte atent cu privire la prioritate.

380
00:23:14,000 --> 00:23:21,000
Ar trebui să utilizați, de obicei, între paranteze pentru a fi sigur că știi ce faci.

381
00:23:21,000 --> 00:23:27,000
Unele comenzi rapide utile, desigur, una este i + + sau i + = 1

382
00:23:27,000 --> 00:23:30,000
sau folosind + =.

383
00:23:30,000 --> 00:23:34,000
Acesta este același lucru ca și face i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Puteți face, de asemenea, i - sau i - = 1,

385
00:23:39,000 --> 00:23:42,000
ceea ce este același lucru ca i = i -1,

386
00:23:42,000 --> 00:23:46,000
Ceva ce voi folosi o mulțime de bucle în, cel puțin.

387
00:23:46,000 --> 00:23:52,000
De asemenea, pentru *, dacă utilizați * = și dacă ai face, de exemplu,

388
00:23:52,000 --> 00:23:57,000
i * = 2 este același lucru cu a spune i = i * 2,

389
00:23:57,000 --> 00:23:59,000
și același lucru pentru diviziune.

390
00:23:59,000 --> 00:24:08,000
Dacă veți face i / = 2 e același lucru ca i = I / 2.

391
00:24:08,000 --> 00:24:10,000
>> Acum, despre funcțiile.

392
00:24:10,000 --> 00:24:13,000
Voi aflat că funcțiile sunt o strategie foarte buna pentru a salva code

393
00:24:13,000 --> 00:24:16,000
în timp ce programarea, deci, dacă doriți să efectuați aceeași sarcină

394
00:24:16,000 --> 00:24:20,000
codul nou și din nou, probabil doriți să utilizați o funcție

395
00:24:20,000 --> 00:24:25,000
doar astfel încât să nu trebuie să copiați și să inserați codul de peste si peste din nou.

396
00:24:25,000 --> 00:24:28,000
De fapt, este o funcție principală, și când am să vă arate formatul unei funcții

397
00:24:28,000 --> 00:24:32,000
ai de gând să văd că este destul de evident.

398
00:24:32,000 --> 00:24:35,000
Noi folosim, de asemenea, funcții din unele biblioteci,

399
00:24:35,000 --> 00:24:39,000
de exemplu, printf, GetIn, care este de la bibliotecă CS50,

400
00:24:39,000 --> 00:24:43,000
și alte funcții, cum ar fi toupper.

401
00:24:43,000 --> 00:24:46,000
Toate aceste funcții sunt de fapt puse în aplicare în alte biblioteci,

402
00:24:46,000 --> 00:24:49,000
și atunci când ați pus acele fișiere lega la începutul programului dvs.

403
00:24:49,000 --> 00:24:53,000
vrei să spui că poate, te rog da-mi codul pentru aceste funcții

404
00:24:53,000 --> 00:24:57,000
așa că nu trebuie să le pună în aplicare de unul singur?

405
00:24:57,000 --> 00:25:00,000
Și puteți scrie, de asemenea, propriile funcții, astfel încât atunci când veți începe programarea

406
00:25:00,000 --> 00:25:04,000
îți dai seama că bibliotecile nu au toate funcțiile de care aveți nevoie.

407
00:25:04,000 --> 00:25:10,000
Pentru PSET ultima, de exemplu, am scris trage, goana, și de căutare,

408
00:25:10,000 --> 00:25:13,000
și e foarte, foarte important să fie în măsură să scrie funcții

409
00:25:13,000 --> 00:25:17,000
deoarece acestea sunt utile, iar noi să le utilizeze tot timpul în programare,

410
00:25:17,000 --> 00:25:19,000
și-l salvează o mulțime de cod.

411
00:25:19,000 --> 00:25:21,000
Formatul unei functii este aceasta.

412
00:25:21,000 --> 00:25:24,000
Avem de tip întoarcere la început. Care este tipul de retur?

413
00:25:24,000 --> 00:25:27,000
E doar atunci când funcția dumneavoastră este de gând să se întoarcă.

414
00:25:27,000 --> 00:25:29,000
Dacă aveți o funcție, de exemplu, factorial,

415
00:25:29,000 --> 00:25:31,000
care este de gând să calculeze un factorială a unui număr întreg,

416
00:25:31,000 --> 00:25:34,000
Probabil că va reveni, de asemenea, un număr întreg.

417
00:25:34,000 --> 00:25:37,000
Apoi, tipul de revenire va fi int.

418
00:25:37,000 --> 00:25:41,000
Printf are de fapt un gol tip de retur

419
00:25:41,000 --> 00:25:43,000
pentru că nu te întoarce nimic.

420
00:25:43,000 --> 00:25:45,000
Sunteți de imprimare doar lucrurile la ecranul

421
00:25:45,000 --> 00:25:48,000
si renunti funcția după aceea.

422
00:25:48,000 --> 00:25:51,000
Apoi, aveți numele functiei pe care le puteți alege.

423
00:25:51,000 --> 00:25:55,000
Tu ar trebui să fie un pic rezonabil, ca să nu alegi un nume ca xyz

424
00:25:55,000 --> 00:25:58,000
sau ca x2f.

425
00:25:58,000 --> 00:26:02,000
Încercați să facă un nume care are sens.

426
00:26:02,000 --> 00:26:04,000
>> De exemplu, dacă e factorială, spune factorială.

427
00:26:04,000 --> 00:26:08,000
Daca este o funcție care este de gând să atragă ceva, denumiți-l trage.

428
00:26:08,000 --> 00:26:11,000
Și apoi avem parametri, care sunt, de asemenea, numite argumente

429
00:26:11,000 --> 00:26:14,000
care sunt ca resursele de care are nevoie funcția

430
00:26:14,000 --> 00:26:17,000
din codul dvs. pentru a îndeplini sarcina.

431
00:26:17,000 --> 00:26:20,000
Dacă doriți pentru a calcula factorialul unui număr

432
00:26:20,000 --> 00:26:23,000
probabil ai nevoie de a avea un număr pentru a calcula o factorial.

433
00:26:23,000 --> 00:26:27,000
Unul dintre argumentele pe care ai de gând să aibă este numărul însuși.

434
00:26:27,000 --> 00:26:31,000
Și apoi o să facă ceva și să se întoarcă valoarea de la sfârșitul

435
00:26:31,000 --> 00:26:35,000
excepția cazului în care este o funcție de vid.

436
00:26:35,000 --> 00:26:37,000
Să vedem un exemplu.

437
00:26:37,000 --> 00:26:40,000
Dacă vreau să scrie o funcție care însumează toate numerele într-o matrice de întregi,

438
00:26:40,000 --> 00:26:43,000
în primul rând, tipul de revenire va fi int

439
00:26:43,000 --> 00:26:46,000
pentru că am un tablou de întregi.

440
00:26:46,000 --> 00:26:51,000
Și apoi am de gând să aibă numele funcției ca sumArray,

441
00:26:51,000 --> 00:26:54,000
și apoi se va lua matrice în sine, pentru a nums int,

442
00:26:54,000 --> 00:26:58,000
și apoi lungimea de matrice, așa că știu câte numere trebuie să însumați.

443
00:26:58,000 --> 00:27:02,000
Atunci am pentru a inițializa o sumă variabilă numită, de exemplu, la 0,

444
00:27:02,000 --> 00:27:08,000
și de fiecare dată când văd un element în matrice ar trebui să-l adauge la suma, așa că am făcut o buclă pentru.

445
00:27:08,000 --> 00:27:15,000
La fel ca Lexi a spus, ai făcut int i = 0, i <lungime și i + +.

446
00:27:15,000 --> 00:27:20,000
Și pentru fiecare element în matrice am facut suma intre + = nums [i],

447
00:27:20,000 --> 00:27:24,000
si apoi m-am întors suma, asa ca este foarte simplu, și-l salvează o mulțime de cod

448
00:27:24,000 --> 00:27:28,000
dacă utilizați această funcție o multime de ori.

449
00:27:28,000 --> 00:27:32,000
Apoi am luat o privire la condițiile.

450
00:27:32,000 --> 00:27:38,000
Avem în cazul în care, altfel, și în cazul în care altcineva.

451
00:27:38,000 --> 00:27:42,000
Să vedem ce este diferența dintre cele.

452
00:27:42,000 --> 00:27:45,000
Aruncati o privire la aceste 2 coduri. Care este diferența dintre ele?

453
00:27:45,000 --> 00:27:49,000
Prima a-practic codurile vreau să spun

454
00:27:49,000 --> 00:27:51,000
dacă un număr este de +, -, sau 0.

455
00:27:51,000 --> 00:27:55,000
Prima spune dacă e> 0, atunci e pozitiv.

456
00:27:55,000 --> 00:28:00,000
Dacă e = cu 0, atunci e 0, iar dacă e <0 atunci e negativ.

457
00:28:00,000 --> 00:28:04,000
>> Și cealaltă este de a face în cazul în care, în cazul în care altcineva, altceva.

458
00:28:04,000 --> 00:28:07,000
Diferența dintre cele două este că aceasta este, de fapt de gând să

459
00:28:07,000 --> 00:28:13,000
verificați dacă> 0, <0 sau = 0 de trei ori,

460
00:28:13,000 --> 00:28:17,000
așa că, dacă aveți numărul 2, de exemplu, o să vină aici și să spun

461
00:28:17,000 --> 00:28:21,000
în cazul în care (x> 0), și-l va spune da, așa că am imprima pozitiv.

462
00:28:21,000 --> 00:28:25,000
Dar, chiar dacă știu că e> 0 și nu va fi 0 sau <0

463
00:28:25,000 --> 00:28:29,000
Sunt încă de gând să faci este 0, este <0,

464
00:28:29,000 --> 00:28:33,000
așa că mă duc de fapt, în interiorul fondurilor de investiții care nu am avea de a

465
00:28:33,000 --> 00:28:38,000
pentru că deja știu că nu va satisface oricare dintre aceste condiții.

466
00:28:38,000 --> 00:28:41,000
Eu pot folosi în cazul în care, în cazul în care altcineva, altceva declarație.

467
00:28:41,000 --> 00:28:45,000
Este practic spune că dacă x = 0 I imprima pozitiv.

468
00:28:45,000 --> 00:28:48,000
Dacă nu e, am de gând pentru a testa, de asemenea, acest lucru.

469
00:28:48,000 --> 00:28:51,000
Dacă e 2 nu am de gând să fac asta.

470
00:28:51,000 --> 00:28:54,000
Practic, dacă am avut x = 2 v-ar spune

471
00:28:54,000 --> 00:28:57,000
în cazul în care (x> 0), da, așa imprimați acest lucru.

472
00:28:57,000 --> 00:29:00,000
Acum, că știu că e> 0 și că îndeplinită în cazul în care prima

473
00:29:00,000 --> 00:29:02,000
Eu nu sunt chiar de gând să rulați acest cod.

474
00:29:02,000 --> 00:29:09,000
Codul rulează mai rapid, de fapt, de 3 ori mai repede dacă folosiți asta.

475
00:29:09,000 --> 00:29:11,000
Am învățat, de asemenea, despre și i sau.

476
00:29:11,000 --> 00:29:15,000
Eu nu am de gând să treacă prin acest lucru, deoarece Lexi vorbit deja despre ele.

477
00:29:15,000 --> 00:29:17,000
E doar && si | | operatorului.

478
00:29:17,000 --> 00:29:21,000
>> Singurul lucru pe care voi spune este să fie atenți atunci când avea 3 condiții.

479
00:29:21,000 --> 00:29:24,000
Utilizați paranteze pentru că este foarte confuz atunci când aveți o afecțiune

480
00:29:24,000 --> 00:29:27,000
și un alt unul sau altul.

481
00:29:27,000 --> 00:29:30,000
Utilizați paranteze doar pentru a fi siguri că condițiilor sens

482
00:29:30,000 --> 00:29:34,000
deoarece, în acest caz, de exemplu, vă puteți imagina că

483
00:29:34,000 --> 00:29:38,000
ar putea fi prima condiție și unul sau altul

484
00:29:38,000 --> 00:29:41,000
sau cele 2 condițiile combinate într-o și

485
00:29:41,000 --> 00:29:45,000
sau o treime, astfel încât să fie doar atent.

486
00:29:45,000 --> 00:29:48,000
Și, în sfârșit, am vorbit despre switch-uri.

487
00:29:48,000 --> 00:29:53,000
Un comutator este foarte util atunci când aveți o variabilă.

488
00:29:53,000 --> 00:29:55,000
Să presupunem că aveți o variabilă ca n

489
00:29:55,000 --> 00:29:59,000
care poate fi 0, 1, sau 2, precum și pentru fiecare dintre aceste cazuri,

490
00:29:59,000 --> 00:30:01,000
ai de gând să efectuați o sarcină.

491
00:30:01,000 --> 00:30:04,000
Se poate spune comuta variabilă, și aceasta indică faptul că

492
00:30:04,000 --> 00:30:08,000
valoarea, atunci este ca și cum valoare1 am de gând să fac asta,

493
00:30:08,000 --> 00:30:12,000
si apoi m-am rupe, ceea ce înseamnă că nu am de gând să se uite la oricare dintre celelalte cazuri

494
00:30:12,000 --> 00:30:15,000
pentru că am mulțumit deja acest caz,

495
00:30:15,000 --> 00:30:20,000
și apoi valoare2 și așa mai departe, și am, de asemenea, pot avea un comutator implicit.

496
00:30:20,000 --> 00:30:24,000
Asta înseamnă că în cazul în care nu îndeplinește niciuna dintre cazurile pe care le-am avut

497
00:30:24,000 --> 00:30:29,000
că am de gând să fac altceva, dar asta e optional.

498
00:30:29,000 --> 00:30:36,000
Asta e tot pentru mine. Acum, hai să Tommy.

499
00:30:36,000 --> 00:30:41,000
Bine, asta va fi Săptămâna 3-ish.

500
00:30:41,000 --> 00:30:45,000
Acestea sunt unele dintre subiectele vom fi acoperind, cripto, domeniul de aplicare, matrice, et cetera.

501
00:30:45,000 --> 00:30:49,000
Doar un cuvânt rapid pe cripto. Noi nu suntem de gând să ciocan această casă.

502
00:30:49,000 --> 00:30:52,000
>> Am făcut acest lucru în PSET 2, dar pentru testul asigurați-vă că știți diferența

503
00:30:52,000 --> 00:30:54,000
între cifrul Cezar și cifrul Vigenere,

504
00:30:54,000 --> 00:30:57,000
cum atât de cei care lucrează cifrurilor și ceea ce e ca pentru a cripta

505
00:30:57,000 --> 00:30:59,000
și decripta text folosind cele 2 cifre.

506
00:30:59,000 --> 00:31:03,000
Amintiți-vă, cifrul lui Cezar se rotește pur și simplu, fiecare caracter cu aceeași sumă,

507
00:31:03,000 --> 00:31:06,000
asigurându-vă că Mod de numărul de litere din alfabet.

508
00:31:06,000 --> 00:31:09,000
Și cifrul Vigenere, pe de altă parte, se rotește fiecare caracter

509
00:31:09,000 --> 00:31:12,000
de o sumă diferită, astfel încât mai degrabă decât a spune

510
00:31:12,000 --> 00:31:15,000
fiecare rotit de caractere cu 3 Vigenere se vor roti fiecare caracter

511
00:31:15,000 --> 00:31:17,000
cu o sumă diferită în funcție de cuvinte cheie unele

512
00:31:17,000 --> 00:31:20,000
în cazul în care fiecare literă din cuvântul cheie reprezintă o anumită cantitate diferită

513
00:31:20,000 --> 00:31:26,000
pentru a roti textul clar de.

514
00:31:26,000 --> 00:31:28,000
Să vorbim mai întâi despre domeniul de aplicare variabilă.

515
00:31:28,000 --> 00:31:30,000
Exista 2 tipuri diferite de variabile.

516
00:31:30,000 --> 00:31:33,000
Avem variabile locale, iar acestea urmează să fie definite

517
00:31:33,000 --> 00:31:36,000
în afara de principal sau în afara orice funcție sau bloc,

518
00:31:36,000 --> 00:31:39,000
și acestea vor fi accesibile oriunde în programul tău.

519
00:31:39,000 --> 00:31:41,000
Dacă aveți o funcție și în care funcția este o buclă în timp ce

520
00:31:41,000 --> 00:31:44,000
variabila mare la nivel mondial este accesibil peste tot.

521
00:31:44,000 --> 00:31:48,000
O variabilă locală, pe de altă parte, este luneta la locul unde este definit.

522
00:31:48,000 --> 00:31:53,000
>> Dacă aveți o funcție aici, de exemplu, avem această funcție g,

523
00:31:53,000 --> 00:31:56,000
și în interiorul lui G este o variabilă numită aici y,

524
00:31:56,000 --> 00:31:58,000
și asta înseamnă că aceasta este o variabilă locală.

525
00:31:58,000 --> 00:32:00,000
Chiar dacă această variabilă se numește y

526
00:32:00,000 --> 00:32:03,000
și această variabilă este numit Y aceste 2 functii

527
00:32:03,000 --> 00:32:06,000
nu au nici o idee despre ceea ce variabile reciproc locale sunt.

528
00:32:06,000 --> 00:32:10,000
Pe de altă parte, aici ne spunem int x = 5,

529
00:32:10,000 --> 00:32:12,000
și acest lucru este în afara domeniului de aplicare a oricărei funcții.

530
00:32:12,000 --> 00:32:16,000
E în afara domeniului de aplicare al principal, astfel încât aceasta este o variabilă globală.

531
00:32:16,000 --> 00:32:20,000
Asta înseamnă că în interiorul acestor 2 funcții atunci când spun x - sau x + +

532
00:32:20,000 --> 00:32:26,000
Mă accesarea x același prin care aceasta y și y sunt variabile acest diferite.

533
00:32:26,000 --> 00:32:30,000
Asta e diferența dintre o variabilă globală și o variabilă locală.

534
00:32:30,000 --> 00:32:33,000
În ceea ce privește design-ul este în cauză, uneori este, probabil, o idee mai bună

535
00:32:33,000 --> 00:32:37,000
să păstreze variabilele locale ori de câte ori pot, eventual,

536
00:32:37,000 --> 00:32:39,000
din moment ce o gramada de variabile globale poate obține cu adevărat confuz.

537
00:32:39,000 --> 00:32:42,000
Dacă aveți o grămadă de funcții modificarea tuturor același lucru

538
00:32:42,000 --> 00:32:45,000
s-ar putea uita ceea ce în cazul în care această funcție accidental modifică acest nivel global,

539
00:32:45,000 --> 00:32:47,000
și această altă funcție nu știe despre asta,

540
00:32:47,000 --> 00:32:50,000
și se ajunge destul de confuz cum veți obține mai mult cod.

541
00:32:50,000 --> 00:32:53,000
Păstrarea variabile locale ori de câte ori pot, eventual,

542
00:32:53,000 --> 00:32:56,000
este designul doar bine.

543
00:32:56,000 --> 00:33:00,000
Matrice, amintiți-vă, sunt pur și simplu liste de elemente de același tip.

544
00:33:00,000 --> 00:33:04,000
In interiorul IC nu poate avea o listă cum ar fi 1, 2.0, salut.

545
00:33:04,000 --> 00:33:06,000
Noi chiar nu pot face asta.

546
00:33:06,000 --> 00:33:11,000
>> Când ne-am declara o matrice în C toate elementele trebuie să fie de același tip.

547
00:33:11,000 --> 00:33:14,000
Aici am o serie de 3 numere întregi.

548
00:33:14,000 --> 00:33:18,000
Aici am lungimea de matrice, dar dacă eu sunt doar de declarare în această sintaxă

549
00:33:18,000 --> 00:33:21,000
în cazul în care am specifica ce toate elementele sunt nu am nevoie de acest punct de vedere tehnic 3.

550
00:33:21,000 --> 00:33:25,000
Compilatorul este destul de inteligent să ne dăm seama cât de mare ar trebui să fie matrice.

551
00:33:25,000 --> 00:33:28,000
Acum, când vreau să obțineți sau să setați valoarea unei matrice

552
00:33:28,000 --> 00:33:30,000
aceasta este sintaxa pentru a face asta.

553
00:33:30,000 --> 00:33:33,000
Acest lucru va modifica de fapt, al doilea element al matricei, deoarece, amintiți-vă,

554
00:33:33,000 --> 00:33:36,000
Numerotarea începe de la 0, nu de la 1.

555
00:33:36,000 --> 00:33:42,000
Dacă vreau să citesc această valoare pot spune ceva de genul: int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Sau dacă vreau să setați această valoare, la fel ca fac aici,

557
00:33:44,000 --> 00:33:47,000
Eu pot să spun matrice [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Acel timp accesarea elemente de indicele lor

559
00:33:50,000 --> 00:33:52,000
sau poziția lor, sau în cazul în care acestea sunt în matrice,

560
00:33:52,000 --> 00:33:57,000
și că listarea începe de la 0.

561
00:33:57,000 --> 00:34:00,000
Putem avea, de asemenea, tablouri de matrice,

562
00:34:00,000 --> 00:34:03,000
și aceasta se numește o matrice multi-dimensional.

563
00:34:03,000 --> 00:34:05,000
Când vom avea un tablou multi-dimensional

564
00:34:05,000 --> 00:34:07,000
ceea ce înseamnă că poate avea ceva de genul rânduri și coloane,

565
00:34:07,000 --> 00:34:11,000
și aceasta este doar o modalitate de a vizualiza acest lucru sau gândire despre el.

566
00:34:11,000 --> 00:34:14,000
Când am o matrice multi-dimensional, care înseamnă am de gând să înceapă nevoie

567
00:34:14,000 --> 00:34:17,000
mai mult de 1 index, deoarece în cazul în care am o rețea

568
00:34:17,000 --> 00:34:19,000
doar că ceea ce ești în rând nu ne dea un număr.

569
00:34:19,000 --> 00:34:22,000
Asta într-adevăr doar de gând să ne dea o listă de numere.

570
00:34:22,000 --> 00:34:25,000
Să spunem că am această matrice aici.

571
00:34:25,000 --> 00:34:30,000
Am o matrice numita grilă, și vreau să spun e 2 rânduri și 3 coloane,

572
00:34:30,000 --> 00:34:32,000
și astfel aceasta este o modalitate de a vizualiza acesta.

573
00:34:32,000 --> 00:34:37,000
Când am spus că vreau să obțineți element la [1] [2]

574
00:34:37,000 --> 00:34:41,000
ceea ce înseamnă că, deoarece acestea sunt primele rânduri și apoi coloane

575
00:34:41,000 --> 00:34:44,000
Am de gând să sari la rândul 1, deoarece am spus 1.

576
00:34:44,000 --> 00:34:49,000
>> Apoi, am de gând să vin aici în coloana 2, și am de gând pentru a obține valoarea 6.

577
00:34:49,000 --> 00:34:51,000
Face sens?

578
00:34:51,000 --> 00:34:55,000
Multi-dimensionale matrice, amintește-ți, sunt punct de vedere tehnic doar o serie de tablouri.

579
00:34:55,000 --> 00:34:57,000
Putem avea tablouri de tablouri de matrice.

580
00:34:57,000 --> 00:35:00,000
Noi putem continua, dar de fapt un mod de a gândi despre

581
00:35:00,000 --> 00:35:03,000
modul în care acest lucru este prevăzut afară și ceea ce se întâmplă este să-l vizualizeze

582
00:35:03,000 --> 00:35:09,000
într-o rețea ca asta.

583
00:35:09,000 --> 00:35:12,000
Când ne-am trece la funcții de matrice, au de gând să se comporte

584
00:35:12,000 --> 00:35:16,000
un pic diferit decât atunci când vom trece variabile regulate la funcții

585
00:35:16,000 --> 00:35:18,000
ca trecerea unui int sau un flotor.

586
00:35:18,000 --> 00:35:21,000
Când ne-am trece într-un tip int sau char sau la oricare dintre aceste alte date

587
00:35:21,000 --> 00:35:24,000
am luat doar o privire la cazul în funcția modifică

588
00:35:24,000 --> 00:35:28,000
valoarea acelei variabile care schimbarea nu se va propaga în sus

589
00:35:28,000 --> 00:35:32,000
pentru funcția de asteptare.

590
00:35:32,000 --> 00:35:35,000
Cu o matrice, pe de altă parte, faptul că se va întâmpla.

591
00:35:35,000 --> 00:35:39,000
Dacă aș trece într-o matrice la unele funcții și că funcția schimbă unele din elementele,

592
00:35:39,000 --> 00:35:43,000
când am venit înapoi până la funcția pe care a numit-

593
00:35:43,000 --> 00:35:47,000
matrice mea este acum va fi diferit, și de vocabular pentru că

594
00:35:47,000 --> 00:35:50,000
matrice este sunt transmise prin referință, după cum vom vedea mai târziu.

595
00:35:50,000 --> 00:35:53,000
Acest lucru este legat de modul în care munca indicii, în cazul în care aceste tipuri de bază de date,

596
00:35:53,000 --> 00:35:55,000
pe de altă parte, sunt transmise prin valoare.

597
00:35:55,000 --> 00:35:59,000
>> Ne putem gândi că, în calitate face o copie a unor variabilă și apoi trece în copie.

598
00:35:59,000 --> 00:36:01,000
Nu contează ceea ce facem cu acea variabilă.

599
00:36:01,000 --> 00:36:06,000
Funcția de asteptare nu va fi conștienți de faptul că acesta a fost schimbat.

600
00:36:06,000 --> 00:36:10,000
Matricile sunt doar un pic diferit în această privință.

601
00:36:10,000 --> 00:36:13,000
De exemplu, după cum tocmai am văzut, principalul este pur și simplu o funcție

602
00:36:13,000 --> 00:36:15,000
care poate lua în 2 argumente.

603
00:36:15,000 --> 00:36:20,000
Primul argument pentru funcția principală este argc, sau numărul de argumente,

604
00:36:20,000 --> 00:36:23,000
și al doilea argument este numit argv,

605
00:36:23,000 --> 00:36:27,000
și acestea sunt valorile efective ale acestor argumente.

606
00:36:27,000 --> 00:36:30,000
Să spunem că am un program numit this.c,

607
00:36:30,000 --> 00:36:34,000
și spun asta fac, și am de gând să ruleze acest lucru la linia de comandă.

608
00:36:34,000 --> 00:36:38,000
Acum, pentru a trece în unele argumente pentru a programul meu numit aceasta,

609
00:36:38,000 --> 00:36:42,000
Am putea spune ceva de genul / aceasta este CS 50..

610
00:36:42,000 --> 00:36:45,000
Aceasta este ceea ce ne imaginăm pe David să facă în fiecare zi la terminal.

611
00:36:45,000 --> 00:36:48,000
Dar acum interiorul funcția principală a acestui program

612
00:36:48,000 --> 00:36:52,000
are aceste valori, deci argc este 4.

613
00:36:52,000 --> 00:36:56,000
Ar putea fi un pic confuz, deoarece într-adevăr suntem doar în trecere în cs este 50.

614
00:36:56,000 --> 00:36:58,000
Asta e doar 3.

615
00:36:58,000 --> 00:37:02,000
Dar amintiți-vă că primul element al argv sau primul argument

616
00:37:02,000 --> 00:37:05,000
este numele funcției în sine.

617
00:37:05,000 --> 00:37:07,190
Deci asta înseamnă că avem 4 lucruri aici,

618
00:37:07,190 --> 00:37:10,530
și primul element va fi / aceasta..

619
00:37:10,530 --> 00:37:12,970
Iar acest lucru va fi reprezentat ca un șir.

620
00:37:12,970 --> 00:37:18,590
Apoi, restul elementelor sunt ceea ce am tastat în după numele programului.

621
00:37:18,590 --> 00:37:22,720
Deci, la fel ca o parte, așa cum am văzut, probabil, în PSET 2,

622
00:37:22,720 --> 00:37:28,780
amintiți-vă că șirul 50 este ≠ întregul 50.

623
00:37:28,780 --> 00:37:32,520
Deci nu putem spune ceva de genul, 'int x = argv 3. "

624
00:37:32,520 --> 00:37:36,470
>> Asta nu doar va face sens, deoarece aceasta este un șir, iar acesta este un număr întreg.

625
00:37:36,470 --> 00:37:38,510
Deci, dacă doriți să faceți conversia intre cele 2, amintiți-vă, vom

626
00:37:38,510 --> 00:37:40,810
această funcție magică numită atoi.

627
00:37:40,810 --> 00:37:46,270
Care ia un șir și returnează întreg reprezentat în interiorul acelui șir.

628
00:37:46,270 --> 00:37:48,360
Deci, asta e o greșeală ușor de a face pe test,

629
00:37:48,360 --> 00:37:51,590
doar gândindu-se că aceasta va fi în mod automat tipul corect.

630
00:37:51,590 --> 00:37:53,860
Dar știu doar că acestea vor fi întotdeauna siruri de caractere

631
00:37:53,860 --> 00:38:00,920
chiar dacă șirul conține numai un număr întreg sau un caracter sau un flotor.

632
00:38:00,920 --> 00:38:03,380
Deci, acum să vorbim despre timpul de funcționare.

633
00:38:03,380 --> 00:38:06,700
Când vom avea toate aceste algoritmi care fac toate aceste lucruri nebunești,

634
00:38:06,700 --> 00:38:11,580
devine cu adevărat util să punem întrebarea: "Cât timp nu se iau?"

635
00:38:11,580 --> 00:38:15,500
Noi reprezentăm că, odată cu ceva numit notația asimptotică.

636
00:38:15,500 --> 00:38:18,430
Deci asta înseamnă că - ei bine, hai să spunem că da algoritmul nostru

637
00:38:18,430 --> 00:38:20,840
unele foarte, foarte, foarte mare de intrare.

638
00:38:20,840 --> 00:38:23,840
Dorim să punem întrebarea, "Cât timp se merge să ia?

639
00:38:23,840 --> 00:38:26,370
Câți pași va lua algoritmul nostru pentru a rula

640
00:38:26,370 --> 00:38:29,980
în funcție de mărimea de intrare? "

641
00:38:29,980 --> 00:38:33,080
Deci prima cale putem descrie timpul rula este cu mare O.

642
00:38:33,080 --> 00:38:35,380
Și acest lucru este nostru cel mai rău caz timp de funcționare.

643
00:38:35,380 --> 00:38:38,590
Deci, dacă vrem să sortați o matrice, și ne da algoritmul nostru o matrice

644
00:38:38,590 --> 00:38:41,000
asta e în ordine descrescătoare atunci când ar trebui să fie în ordine crescătoare,

645
00:38:41,000 --> 00:38:43,130
care va fi cel mai rau caz.

646
00:38:43,130 --> 00:38:49,800
Aceasta este superioară nostru legat în durata maximă a timpului algoritmului nostru va lua.

647
00:38:49,800 --> 00:38:54,740
Pe de altă parte, această Ω este de gând să descrie mai bun caz timp de funcționare.

648
00:38:54,740 --> 00:38:58,210
Deci, dacă am da-o matrice deja sortate unui algoritm de sortare,

649
00:38:58,210 --> 00:39:00,940
Cât timp va dura pentru a sorta?

650
00:39:00,940 --> 00:39:06,610
Și aceasta, apoi, descrie o limită inferioară pe timpul de funcționare.

651
00:39:06,610 --> 00:39:10,980
Deci, aici sunt doar cateva cuvinte care descriu uneori comune de funcționare.

652
00:39:10,980 --> 00:39:13,120
Acestea sunt, în ordine crescătoare.

653
00:39:13,120 --> 00:39:16,060
Cel mai rapid timp de funcționare avem este numit constantă.

654
00:39:16,060 --> 00:39:19,800
>> Asta înseamnă că indiferent de cât de multe elemente pe care le dau algoritmului nostru,

655
00:39:19,800 --> 00:39:22,280
indiferent de cât de mare este gama noastră, sortarea acestora

656
00:39:22,280 --> 00:39:26,510
sau de a face tot ce ne facem să matrice va avea întotdeauna aceeași cantitate de timp.

657
00:39:26,510 --> 00:39:30,270
Deci, putem reprezenta că doar cu un 1, care este o constantă.

658
00:39:30,270 --> 00:39:32,410
Noi, de asemenea, sa uitat la momentul execuției logaritmică.

659
00:39:32,410 --> 00:39:34,800
Deci, ceva de genul binar de căutare este logaritmică,

660
00:39:34,800 --> 00:39:37,140
în cazul în care am tăiat în jumătate problema de fiecare dată

661
00:39:37,140 --> 00:39:40,970
și apoi lucrurile devin doar mai mare de acolo.

662
00:39:40,970 --> 00:39:43,580
Și dacă sunteți scris vreodată o O, de orice algoritm factorial,

663
00:39:43,580 --> 00:39:47,850
probabil că nu ar trebui să considere acest lucru ca slujba ta zi.

664
00:39:47,850 --> 00:39:53,910
Când ne-am compara ori de funcționare este important să păstrați în minte aceste lucruri.

665
00:39:53,910 --> 00:39:57,760
Deci, dacă am un algoritm care este O (n), și altcineva

666
00:39:57,760 --> 00:40:03,590
a un algoritm O (2n), acestea sunt de fapt asimptotic echivalente.

667
00:40:03,590 --> 00:40:06,590
Deci, dacă ne imaginăm n sa fie un numar mare ca eleventy miliarde de euro:

668
00:40:06,590 --> 00:40:13,090
asa ca atunci cand suntem fata eleventy miliarde de euro la ceva de genul eleventy miliarde de euro + 3,

669
00:40:13,090 --> 00:40:17,640
dintr-o dată că trei nu face într-adevăr o mare diferență mai.

670
00:40:17,640 --> 00:40:20,980
De aceea vom începe în considerare aceste lucruri să fie echivalente.

671
00:40:20,980 --> 00:40:24,220
Deci lucrurile ca aceste constante de aici, nu e 2 x asta, sau adăugarea de un 3,

672
00:40:24,220 --> 00:40:27,180
Acestea sunt doar constante, iar acestea sunt de gând să scadă în sus.

673
00:40:27,180 --> 00:40:32,480
Deci, de aceea toate aceste 3 din timpul de functionare sunt la fel cu a spune că sunt O (n).

674
00:40:32,480 --> 00:40:37,490
În mod similar, în cazul în care avem de 2 ori de alte rulare, să zicem O (n + 2n ² ³), putem adăuga

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, și apoi avem un alt timpului de funcționare asta e doar O (n ³).

676
00:40:42,070 --> 00:40:46,290
din nou, acestea sunt același lucru, deoarece acestea - acestea nu sunt aceleași.

677
00:40:46,290 --> 00:40:49,840
Acestea sunt aceleași lucruri, îmi pare rău. Deci, acestea sunt aceleași, deoarece

678
00:40:49,840 --> 00:40:53,090
acest ³ n este de gând să domine această ² 2n.

679
00:40:53,090 --> 00:40:59,130
>> Ceea ce nu este același lucru este în cazul în care ne-am fugi de ori ca O (n ³) și O (n ²)

680
00:40:59,130 --> 00:41:02,820
deoarece acest ³ n este mult mai mare decât această ² n.

681
00:41:02,820 --> 00:41:05,470
Deci, dacă avem exponentii, brusc începe să conteze asta,

682
00:41:05,470 --> 00:41:08,280
dar atunci când suntem doar de-a face cu factori de cum suntem noi aici,

683
00:41:08,280 --> 00:41:12,810
atunci nu va conta, deoarece acestea sunt doar de gând să renunțe la.

684
00:41:12,810 --> 00:41:16,760
Să aruncăm o privire la unele dintre algoritmii care le-am vazut pana acum

685
00:41:16,760 --> 00:41:19,260
și să vorbească despre timpul de functionare a acestora.

686
00:41:19,260 --> 00:41:23,850
Primul mod de a privi pentru un număr într-o listă, pe care am văzut, era de căutare liniară.

687
00:41:23,850 --> 00:41:26,950
Și punerea în aplicare a liniară căutare este super simplu.

688
00:41:26,950 --> 00:41:30,490
Noi avem doar o listă, și ne vom uita la fiecare element din listă

689
00:41:30,490 --> 00:41:34,260
până când vom găsi numărul căutăm.

690
00:41:34,260 --> 00:41:38,370
Deci asta înseamnă că, în cel mai rău caz, acest O (n).

691
00:41:38,370 --> 00:41:40,860
Și cel mai rău caz, ar putea fi aici, în cazul în care elementul este

692
00:41:40,860 --> 00:41:45,710
ultimul element, apoi utilizând căutarea liniară trebuie să ne uităm la fiecare element

693
00:41:45,710 --> 00:41:50,180
până când vom ajunge la ultimul, în scopul de a ști că acesta a fost de fapt în listă.

694
00:41:50,180 --> 00:41:52,910
Noi nu putem oferi doar până la jumătate și spune, "Este, probabil, nu acolo."

695
00:41:52,910 --> 00:41:55,980
Cu căutare liniară trebuie sa ne uitam la toată chestia.

696
00:41:55,980 --> 00:41:59,090
Cel mai bun timp la caz funcționare, pe de altă parte, este constant

697
00:41:59,090 --> 00:42:04,200
deoarece, în cel mai bun caz elementul căutăm este doar prima din listă.

698
00:42:04,200 --> 00:42:08,930
Așa că o să ne ia exact 1 pas, indiferent cât de mare este lista

699
00:42:08,930 --> 00:42:12,140
dacă suntem în căutarea pentru primul element de fiecare dată.

700
00:42:12,140 --> 00:42:15,390
>> Astfel încât atunci când veți căuta, amintiți-vă, aceasta nu impune ca lista noastră să fie sortate.

701
00:42:15,390 --> 00:42:19,430
Pentru că suntem pur și simplu de gând să se uite peste fiecare element unic, și nu contează cu adevărat

702
00:42:19,430 --> 00:42:23,560
ce ordine aceste elemente sunt inch

703
00:42:23,560 --> 00:42:28,110
Un algoritm de căutare mai inteligent este ceva de genul căutare binară.

704
00:42:28,110 --> 00:42:31,500
Amintiți-vă, punerea în aplicare a binar de căutare este atunci când ai de gând să

705
00:42:31,500 --> 00:42:34,320
Ți privirea de la mijlocul listei.

706
00:42:34,320 --> 00:42:38,000
Și pentru că ne uităm la mijloc, avem nevoie ca lista este sortată

707
00:42:38,000 --> 00:42:40,580
sau altfel nu știm unde mijloc este, și trebuie să privim peste

708
00:42:40,580 --> 00:42:44,480
întreaga listă să-l găsească, și apoi la acel moment ne pierdem doar de timp.

709
00:42:44,480 --> 00:42:48,480
Deci, dacă avem o listă sortată și vom găsi la mijloc, vom compara mijloc

710
00:42:48,480 --> 00:42:51,590
la elementul căutăm.

711
00:42:51,590 --> 00:42:54,640
Dacă e prea mare, atunci putem uita jumătatea din dreapta

712
00:42:54,640 --> 00:42:57,810
pentru că știm că, dacă elementul nostru este deja prea mare

713
00:42:57,810 --> 00:43:01,080
și totul la dreapta acestui element este chiar mai mare,

714
00:43:01,080 --> 00:43:02,760
atunci nu avem nevoie să te uiți acolo.

715
00:43:02,760 --> 00:43:05,430
În cazul în care, pe de altă parte, în cazul în care elementul nostru este prea mic,

716
00:43:05,430 --> 00:43:08,700
știm totul la stânga acelui element este, de asemenea, prea mic,

717
00:43:08,700 --> 00:43:11,390
așa că nu prea are sens să se uite acolo, fie.

718
00:43:11,390 --> 00:43:15,760
În acest fel, cu fiecare pas și de fiecare dată când ne uităm la mijlocul listei,

719
00:43:15,760 --> 00:43:19,060
am de gând să taie în jumătate problema noastră, deoarece brusc știm

720
00:43:19,060 --> 00:43:23,040
o grămadă de numere care nu pot fi cel pe care îl căutăm.

721
00:43:23,040 --> 00:43:26,950
>> În pseudocod acest lucru ar arata ceva de genul asta,

722
00:43:26,950 --> 00:43:30,990
și pentru că suntem tăierea lista in jumatate de fiecare dată,

723
00:43:30,990 --> 00:43:34,920
noastre cel mai rău caz salturi în timp curgă de la liniar la logaritmică.

724
00:43:34,920 --> 00:43:39,260
Atât de brusc, avem log-in etape, în scopul de a găsi un element într-o listă.

725
00:43:39,260 --> 00:43:42,460
Cel mai bun timp la caz funcționare, însă, este încă constanta

726
00:43:42,460 --> 00:43:45,180
pentru că acum, hai să spunem că elementul-l căutăm este

727
00:43:45,180 --> 00:43:48,380
întotdeauna mijlocul exactă a lista inițială.

728
00:43:48,380 --> 00:43:52,080
Astfel încât să putem crește lista noastră la fel de mare ca vrem, dar dacă elementul căutăm este la mijloc,

729
00:43:52,080 --> 00:43:54,910
apoi se doar de gând să ne ia un pas.

730
00:43:54,910 --> 00:44:00,920
Deci de asta suntem O (log n) si Ω (1) sau constantă.

731
00:44:00,920 --> 00:44:04,510
Să fugi de fapt, binar de căutare pe această listă.

732
00:44:04,510 --> 00:44:08,020
Deci, haideți să spunem că suntem în căutarea pentru elementul 164.

733
00:44:08,020 --> 00:44:11,650
Primul lucru pe care o vom face este să găsească punctul de mijloc al acestei liste.

734
00:44:11,650 --> 00:44:15,060
Pur și simplu așa se întâmplă că punctul de mijloc este de gând să scadă între aceste 2 cifre,

735
00:44:15,060 --> 00:44:18,960
așa că hai să spunem doar că arbitrar, de fiecare dată punctul de mijloc se încadrează între 2 numere,

736
00:44:18,960 --> 00:44:21,150
hai rotunji doar până.

737
00:44:21,150 --> 00:44:24,330
Trebuie doar să ne asigurăm că facem asta în fiecare pas din drum.

738
00:44:24,330 --> 00:44:29,040
Așa că vom rotunji în sus, și vom spune că 161 este mijlocul listei noastre.

739
00:44:29,040 --> 00:44:34,640
So 161 <164, și fiecare element la stânga de 161

740
00:44:34,640 --> 00:44:39,120
De asemenea, este <164, astfel încât știm că nu ne va ajuta deloc

741
00:44:39,120 --> 00:44:42,690
pentru a începe căutarea aici, deoarece elementul căutăm nu poate fi acolo.

742
00:44:42,690 --> 00:44:47,060
Deci, ce putem face este că putem uita doar despre faptul că jumătate din stânga întreaga listă,

743
00:44:47,060 --> 00:44:51,700
iar acum ia în considerare numai de dreptul de departe 161.

744
00:44:51,700 --> 00:44:54,050
>> Deci, din nou, aceasta este punctul de mijloc; să rotunjească doar până.

745
00:44:54,050 --> 00:44:56,260
Acum 175 este prea mare.

746
00:44:56,260 --> 00:44:59,180
Deci știm că nu o să ne ajute în căutarea aici sau aici,

747
00:44:59,180 --> 00:45:06,610
astfel încât să putem arunca doar că distanță, și în cele din urmă vom lovi 164.

748
00:45:06,610 --> 00:45:10,560
Orice întrebări cu privire la căutare binară?

749
00:45:10,560 --> 00:45:14,180
Să trecem de la căutarea printr-o listă deja sortate

750
00:45:14,180 --> 00:45:17,660
de a lua de fapt o listă de numere în orice ordine

751
00:45:17,660 --> 00:45:20,960
și de a face această listă, în ordine crescătoare.

752
00:45:20,960 --> 00:45:24,060
Algoritmul prima ne-am uitat la a fost numit de sortare cu bule.

753
00:45:24,060 --> 00:45:27,300
Și acest lucru ar fi mai simplu de algoritmi le-am văzut.

754
00:45:27,300 --> 00:45:32,970
Sortare bubble spune că atunci când oricare 2 elemente din interiorul listă sunt din loc,

755
00:45:32,970 --> 00:45:36,500
adică există un număr mai mare în partea stângă a unui număr mai mic,

756
00:45:36,500 --> 00:45:40,190
atunci vom pentru a le schimba, pentru că înseamnă că lista va fi

757
00:45:40,190 --> 00:45:42,860
"Mai sortati" decât a fost înainte.

758
00:45:42,860 --> 00:45:45,180
Și noi suntem doar de gând să continue acest proces nou și din nou și din nou

759
00:45:45,180 --> 00:45:52,100
până când în cele din urmă un fel de elemente cu bule de locația lor corectă și avem o listă sortată.

760
00:45:52,100 --> 00:45:57,230
>> Timpul de functionare a acestei va fi O (n ²). De ce?

761
00:45:57,230 --> 00:46:00,370
Ei bine, pentru că, în cel mai rău caz, vom lua fiecare element, și

762
00:46:00,370 --> 00:46:04,570
vom ajunge comparând-o la fiecare alt element din listă.

763
00:46:04,570 --> 00:46:08,030
Dar, în cel mai bun caz, avem o listă deja sortate, cu bule de sortare's

764
00:46:08,030 --> 00:46:12,230
doar de gând să treacă prin o dată, spune "Nu. Nu am face orice swap-uri, așa că am terminat."

765
00:46:12,230 --> 00:46:17,410
Deci, avem un timp mai bun caz de funcționare a Ω (n).

766
00:46:17,410 --> 00:46:20,680
Să ruleze un fel balon pe o listă.

767
00:46:20,680 --> 00:46:23,560
Sau mai întâi, să ne uităm doar la un pseudocod foarte repede.

768
00:46:23,560 --> 00:46:28,160
Vrem să spunem că doriți să urmăriți de, în fiecare iterație a buclei,

769
00:46:28,160 --> 00:46:32,190
ține evidența dacă este sau nu ne-am schimbat elemente.

770
00:46:32,190 --> 00:46:37,610
Deci motivul pentru care este, vom opri atunci când nu ne-am schimbat elemente.

771
00:46:37,610 --> 00:46:41,980
Deci, la începutul buclei noastre nu am schimbat nimic, așa că vom spune că e fals.

772
00:46:41,980 --> 00:46:47,170
Acum, vom merge prin listă și compara elementul i pentru a elementului i + 1

773
00:46:47,170 --> 00:46:50,310
și dacă este cazul în care există un număr mai mare în partea stângă a unui număr mai mic,

774
00:46:50,310 --> 00:46:52,310
atunci suntem doar de gând să le schimba.

775
00:46:52,310 --> 00:46:54,490
>> Și apoi vom aminti că am schimbat un element.

776
00:46:54,490 --> 00:46:58,900
Asta înseamnă că trebuie să treacă prin lista de cel puțin 1 de mai mult timp

777
00:46:58,900 --> 00:47:02,160
deoarece starea în care ne-am oprit este atunci cand intreaga lista este deja sortat,

778
00:47:02,160 --> 00:47:04,890
ceea ce înseamnă că nu am făcut nici un swap.

779
00:47:04,890 --> 00:47:09,960
Deci, de aceea starea noastră aici este "în timp ce unele elemente au fost schimbate."

780
00:47:09,960 --> 00:47:13,720
Așa că haideți să ne uităm acum doar la acest rulează pe o listă.

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

782
00:47:16,640 --> 00:47:19,850
Sortare Bubble este de gând să înceapă tot drumul la stânga, și se va compara

783
00:47:19,850 --> 00:47:24,700
elementele i, astfel încât cifra 0 la i + 1, care este elementul 1.

784
00:47:24,700 --> 00:47:29,020
Se va spune, bine 5> 0, dar acum 5 este la stânga,

785
00:47:29,020 --> 00:47:32,500
așa că am nevoie pentru a schimba 5 și 0.

786
00:47:32,500 --> 00:47:35,470
Când le-am schimba, dintr-o dată I a lua această listă diferită.

787
00:47:35,470 --> 00:47:38,260
Acum 5> 1, deci vom pentru a le schimba.

788
00:47:38,260 --> 00:47:42,160
5 nu este> 6, așa că nu trebuie să facem nimic aici.

789
00:47:42,160 --> 00:47:46,690
Dar 6> 4, așa că trebuie să schimb.

790
00:47:46,690 --> 00:47:49,740
Din nou, avem nevoie pentru a rula prin intreaga lista a descoperi în cele din urmă

791
00:47:49,740 --> 00:47:52,330
că acestea sunt în afara ordinii; le schimba,

792
00:47:52,330 --> 00:47:57,120
și în acest moment avem nevoie pentru a rula prin lista de mai mult timp 1

793
00:47:57,120 --> 00:48:05,390
pentru a vă asigura că totul este în ordine său, și în acest fel bubble punct a terminat.

794
00:48:05,390 --> 00:48:10,720
Un algoritm diferit pentru a lua unele elemente și sortarea lor este un fel de selecție.

795
00:48:10,720 --> 00:48:15,740
Ideea din spatele fel de selecție este că vom construi o parte din lista de sortat

796
00:48:15,740 --> 00:48:18,150
1 element la un moment dat.

797
00:48:18,150 --> 00:48:23,170
>> Și modul în care vom face acest lucru este prin construirea segmentului stângă a listei.

798
00:48:23,170 --> 00:48:27,510
Și, practic, în fiecare - pe fiecare pas, vom lua cel mai mic element care le-am lăsat

799
00:48:27,510 --> 00:48:32,310
care nu a fost încă sortate, iar noi o să-l mute în acest segment sortate.

800
00:48:32,310 --> 00:48:35,850
Asta înseamnă că trebuie să găsim continuu elementul minim nesortate

801
00:48:35,850 --> 00:48:40,720
și să ia apoi că elementul minim și swap cu orice

802
00:48:40,720 --> 00:48:45,090
cea mai din stânga element care nu este sortat.

803
00:48:45,090 --> 00:48:50,890
Timpul a alerga de acest lucru se întâmplă pentru a fi O (n ²), deoarece, în cel mai rău caz,

804
00:48:50,890 --> 00:48:55,070
avem nevoie pentru a compara fiecare element unic pentru fiecare alt element.

805
00:48:55,070 --> 00:48:59,250
Pentru că noi spunem că, dacă începem de la jumătatea stângă a listei, avem nevoie de

806
00:48:59,250 --> 00:49:02,970
pentru a merge prin segmentul dreptul de intreaga pentru a gasi cel mai mic element.

807
00:49:02,970 --> 00:49:05,430
Și apoi, din nou, avem nevoie pentru a trece peste întregul segment drept și

808
00:49:05,430 --> 00:49:08,210
continui peste care de peste si peste si peste din nou.

809
00:49:08,210 --> 00:49:11,350
Asta va fi n ². Vom avea nevoie de o buclă de interior de un altul pentru buclă

810
00:49:11,350 --> 00:49:13,350
ceea ce sugerează ² n.

811
00:49:13,350 --> 00:49:16,530
În gândul cel mai bun caz, să spunem că da o listă deja sortate;

812
00:49:16,530 --> 00:49:19,270
de fapt, noi nu facem mai bine decât ² n.

813
00:49:19,270 --> 00:49:21,730
Pentru ca un fel de selecție nu are nici o modalitate de a ști că

814
00:49:21,730 --> 00:49:25,540
elementul minim este doar cea pe care am întâmplă să se uite la.

815
00:49:25,540 --> 00:49:28,970
Este încă nevoie să se asigure că aceasta este de fapt minim.

816
00:49:28,970 --> 00:49:31,670
>> Și singura modalitate de a vă asigura că este minim, folosind acest algoritm,

817
00:49:31,670 --> 00:49:34,640
este să se uite la fiecare element din nou.

818
00:49:34,640 --> 00:49:38,420
Deci de fapt, dacă-l dau - daca dai un fel de selecție o listă deja sortate,

819
00:49:38,420 --> 00:49:42,720
nu se va face nici mai bine decât dându-i o listă care nu este încă sortate.

820
00:49:42,720 --> 00:49:46,320
Apropo, dacă se întâmplă să fie cazul în care ceva este O (ceva)

821
00:49:46,320 --> 00:49:50,640
și omega a ceva, putem spune doar mai succint că e ceva de θ.

822
00:49:50,640 --> 00:49:52,760
Deci, dacă vedeți că veni oriunde, asta e ceea ce inseamna ca doar.

823
00:49:52,760 --> 00:49:57,580
>> Dacă ceva este teta de n ², acesta este atât de mare O (n ²) și Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Deci, cel mai bun caz și cel mai rău caz, aceasta nu face o diferență,

825
00:49:59,790 --> 00:50:04,400
algoritm este de gând să facă același lucru de fiecare dată.

826
00:50:04,400 --> 00:50:06,610
Deci, asta este ceea ce pseudocod pentru selectarea fel ar putea arăta.

827
00:50:06,610 --> 00:50:10,630
Suntem practic de gând să spun că vreau să itera peste lista

828
00:50:10,630 --> 00:50:15,180
de la stânga la dreapta, și la fiecare iterație a buclei, am de gând să se mute

829
00:50:15,180 --> 00:50:19,780
elementul minim în această parte a listei sortate.

830
00:50:19,780 --> 00:50:23,260
Și odată ce am muta ceva acolo, nu mai am nevoie să se uite la acest element din nou.

831
00:50:23,260 --> 00:50:28,600
Pentru că de îndată ce am schimba un element in pentru a segmentul stângă a listei, se sortate

832
00:50:28,600 --> 00:50:32,600
pentru că facem totul în ordine crescătoare, prin utilizarea minime.

833
00:50:32,600 --> 00:50:38,740
Așa că am zis, bine, suntem la pozitia i, și trebuie să ne uităm la toate elementele

834
00:50:38,740 --> 00:50:42,260
la dreptul de i, în scopul de a găsi minim.

835
00:50:42,260 --> 00:50:46,150
Asta înseamnă că vrem să te uiți la i + 1 la sfârșitul listei.

836
00:50:46,150 --> 00:50:51,610
Și acum, în cazul în care elementul care ne caută în prezent este mai puțin decât minimul noastre de până acum,

837
00:50:51,610 --> 00:50:54,190
care, amintiți-vă, suntem incepand off minimă să fie doar

838
00:50:54,190 --> 00:50:57,020
orice element de suntem în prezent la; Voi presupune că e minim.

839
00:50:57,020 --> 00:51:00,270
Dacă aș găsi un element care este mai mică decât asta, atunci am de gând să spun, bine,

840
00:51:00,270 --> 00:51:02,700
Ei bine, am găsit un nou minim.

841
00:51:02,700 --> 00:51:06,080
Mă duc să-mi amintesc în cazul în care a fost minimă.

842
00:51:06,080 --> 00:51:09,560
>> Așa că acum, odată ce am trecut prin acel segment nesortate drept,

843
00:51:09,560 --> 00:51:16,690
Eu pot spune că am de gând să schimb elementul minim cu elementul care este în poziția I.

844
00:51:16,690 --> 00:51:21,100
Asta se întâmplă pentru a construi lista mea, partea mea sortate din lista de la stânga la dreapta,

845
00:51:21,100 --> 00:51:25,190
si nu avem nevoie niciodată să se uite la un element nou, odată ce e în acea porțiune.

846
00:51:25,190 --> 00:51:27,930
După ce l-am schimbat.

847
00:51:27,930 --> 00:51:30,260
Deci, haideți să ruleze un fel de selecție pe această listă.

848
00:51:30,260 --> 00:51:38,220
Elementul blue aici este de gând să fi i, iar elementul roșu va fi elementul minim.

849
00:51:38,220 --> 00:51:41,570
Asa ca am incepe tot drumul din partea stângă a listei, astfel încât la 5.

850
00:51:41,570 --> 00:51:44,610
Acum, avem nevoie pentru a găsi elementul minim nesortate.

851
00:51:44,610 --> 00:51:49,480
Așa că spunem 0 <5, astfel încât cifra 0 este de minim noua mea.

852
00:51:49,480 --> 00:51:53,820
>> Dar eu nu pot opri aici, deoarece, chiar dacă putem recunoaște că 0 este cel mai mic,

853
00:51:53,820 --> 00:51:59,390
avem nevoie pentru a rula prin fiecare alt element al listei pentru a vă asigura.

854
00:51:59,390 --> 00:52:01,760
Deci, 1 este mai mare, 6 este mai mare, 4 este mai mare.

855
00:52:01,760 --> 00:52:05,850
Asta înseamnă că după ce se uită la toate aceste elemente, am determinat 0 este mai mic.

856
00:52:05,850 --> 00:52:09,800
Așa că am de gând să swap 5 și 0.

857
00:52:09,800 --> 00:52:15,480
Odata ce am schimba asta, am de gând pentru a obține o listă nouă, și știu că n-am nevoie să te uiți la asta din nou 0

858
00:52:15,480 --> 00:52:19,380
pentru că odată ce l-am schimbat, l-am sortati si am terminat.

859
00:52:19,380 --> 00:52:22,730
Acum, doar așa se întâmplă că elementul albastru este din nou 5,

860
00:52:22,730 --> 00:52:26,030
și trebuie să se uite la 1, 6 și 4 pentru a stabili că: 1

861
00:52:26,030 --> 00:52:31,520
este elementul cel mai mic minim, deci vom schimba de 1 și 5.

862
00:52:31,520 --> 00:52:36,890
Din nou, avem nevoie să se uite la - compara 5 la 6 și 4,

863
00:52:36,890 --> 00:52:39,830
și am de gând să schimb de 4 și 5, și, în final, comparati

864
00:52:39,830 --> 00:52:45,740
cele 2 numere și swap-le până când vom ajunge lista noastră de sortat.

865
00:52:45,740 --> 00:52:49,730
Orice întrebări cu privire la fel de selecție?

866
00:52:49,730 --> 00:52:56,420
Bine. Să trecem la ultimul subiect aici, și că este recursivitate.

867
00:52:56,420 --> 00:52:59,810
>> Recursivitate, amintiți-vă, este acest lucru cu adevărat meta în cazul în care o funcție

868
00:52:59,810 --> 00:53:02,740
în mod repetat se numește.

869
00:53:02,740 --> 00:53:05,620
Deci, la un moment dat, în timp ce fuction noastră este în mod repetat în sine de asteptare,

870
00:53:05,620 --> 00:53:10,100
trebuie să existe un anumit punct în care ne oprim de asteptare noi înșine.

871
00:53:10,100 --> 00:53:13,670
Pentru că dacă nu facem asta, atunci suntem doar de gând să continue să facă acest lucru pentru totdeauna,

872
00:53:13,670 --> 00:53:16,660
și programul nostru nu este doar de gând să rezilieze.

873
00:53:16,660 --> 00:53:19,200
Noi numim această condiție cazul de bază.

874
00:53:19,200 --> 00:53:22,570
Și în cazul de bază spune, mai degrabă decât o funcție de asteptare din nou,

875
00:53:22,570 --> 00:53:25,330
Sunt doar de gând să se întoarcă o valoare.

876
00:53:25,330 --> 00:53:28,080
Deci, odată ce ne-am întors o valoare, ne-am mai sunat pe noi înșine,

877
00:53:28,080 --> 00:53:32,550
și restul apelurilor care le-am făcut până acum, de asemenea, pot reveni.

878
00:53:32,550 --> 00:53:36,050
Opusul din scenariul de bază este cazul recursiv.

879
00:53:36,050 --> 00:53:39,050
Iar acest lucru este atunci când vrem să face un alt apel la funcția pe care suntem în prezent inch

880
00:53:39,050 --> 00:53:44,690
Și noi, probabil, deși nu întotdeauna, doriți să utilizați argumente diferite.

881
00:53:44,690 --> 00:53:48,940
>> Deci, dacă avem o funcție numită f, și f sunat ia 1 argument,

882
00:53:48,940 --> 00:53:52,010
și ne ține doar de asteptare f (1), f (1), f (1), și doar așa se întâmplă că

883
00:53:52,010 --> 00:53:56,510
argumentul 1 cade în caz recursiv, niciodată nu vom mai merge să se oprească.

884
00:53:56,510 --> 00:54:01,620
Chiar dacă avem un caz de bază, trebuie să ne asigurăm că în cele din urmă vom lovi acest caz de bază.

885
00:54:01,620 --> 00:54:04,250
Noi nu ține numai sejurului în acest caz recursiv.

886
00:54:04,250 --> 00:54:09,870
În general, atunci când ne numim, vom avea, probabil, un argument diferită de fiecare dată.

887
00:54:09,870 --> 00:54:12,700
Aici este o funcție foarte simplu recursivă.

888
00:54:12,700 --> 00:54:15,090
Deci, aceasta va calcula factorialul unui număr.

889
00:54:15,090 --> 00:54:17,790
Până top aici avem cazul nostru de bază.

890
00:54:17,790 --> 00:54:22,330
În cazul în care n ≤ 1, noi nu vom apela din nou factorial.

891
00:54:22,330 --> 00:54:26,490
Vom opri; suntem doar de gând să se întoarcă o valoare.

892
00:54:26,490 --> 00:54:30,170
Dacă acest lucru nu este adevărat, atunci vom lovi cazul nostru recursiv.

893
00:54:30,170 --> 00:54:33,550
Observați aici că nu suntem doar asteptare factorial (n), pentru că nu ar fi de foarte mare ajutor.

894
00:54:33,550 --> 00:54:36,810
Vom apela factorială a altceva.

895
00:54:36,810 --> 00:54:40,850
>> Și așa cum puteți vedea, în cele din urmă dacă vom trece ceva factorială (5) sau,

896
00:54:40,850 --> 00:54:45,900
vom apela factorial (4) și așa mai departe, și în cele din urmă vom lovi acest caz de bază.

897
00:54:45,900 --> 00:54:51,730
Deci, acest lucru pare bine. Să vedem ce se întâmplă atunci când vom rula de fapt acest lucru.

898
00:54:51,730 --> 00:54:57,840
Aceasta este stiva, și să spunem că principala este de gând pentru a apela această funcție cu un argument (4).

899
00:54:57,840 --> 00:55:02,200
Deci, odată ce vede și factorială = 4, factorială se va apela.

900
00:55:02,200 --> 00:55:05,010
Acum, dintr-o dată, avem factorială (3).

901
00:55:05,010 --> 00:55:10,780
Deci, aceste funcții sunt de gând să păstreze în creștere până în cele din urmă ne-am lovit cazul nostru de bază.

902
00:55:10,780 --> 00:55:17,830
În acest moment, valoarea returnata de aceasta este întoarcerea (NX valoarea returnata de aceasta),

903
00:55:17,830 --> 00:55:21,290
valoarea returnata de aceasta este nx valoarea returnata de aceasta.

904
00:55:21,290 --> 00:55:23,290
În cele din urmă, avem nevoie pentru a lovi unele număr.

905
00:55:23,290 --> 00:55:26,560
In partea de sus aici, spunem retur 1.

906
00:55:26,560 --> 00:55:30,650
Asta înseamnă că odată ce ne vom întoarce acest număr, ne putem pop de pe acest stiva.

907
00:55:30,650 --> 00:55:36,570
Deci, acest factorial (1) se face.

908
00:55:36,570 --> 00:55:41,190
Când 1 revine, acest factoriale (1) se întoarce, această întoarcere la 1.

909
00:55:41,190 --> 00:55:46,910
Valoarea returnata de aceasta, ține minte, a fost nx valoarea returnata de aceasta.

910
00:55:46,910 --> 00:55:50,720
Deci dintr-o data, tipul ăsta știe că vreau să se întoarcă 2.

911
00:55:50,720 --> 00:55:55,910
>> Deci, amintiți, returna valoarea aceasta este doar nx valoarea de returnare aici.

912
00:55:55,910 --> 00:56:01,160
Deci, acum putem spune 3 x 2, și în cele din urmă, aici, putem spune

913
00:56:01,160 --> 00:56:04,010
acest lucru este doar de gând să fie de 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
Și odată ce acest întoarce, vom ajunge până la un număr întreg interiorul unic de principal.

915
00:56:09,570 --> 00:56:15,460
Orice întrebări cu privire la recursivitate?

916
00:56:15,460 --> 00:56:17,090
Bine. Deci, nu e de mai mult timp pentru întrebări la sfârșitul anului,

917
00:56:17,090 --> 00:56:23,360
dar acum Iosif va acoperi subiecte rămase.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] În regulă. Deci, acum că ne-am vorbit despre recursions,

919
00:56:25,590 --> 00:56:27,840
hai sa vorbim un pic despre ceea ce este corespondenței fel.

920
00:56:27,840 --> 00:56:31,740
Merge fel este de fapt un alt mod de sortare o listă de numere.

921
00:56:31,740 --> 00:56:36,430
Și cum funcționează este, cu un fel de îmbinare aveți o listă, și ceea ce facem noi este

922
00:56:36,430 --> 00:56:39,120
spunem, să împărțit în 2 jumătăți acest.

923
00:56:39,120 --> 00:56:42,750
Vom rula prima îmbinare fel din nou pe jumătatea stângă,

924
00:56:42,750 --> 00:56:45,040
apoi vom rula îmbinare fel pe jumătatea din dreapta,

925
00:56:45,040 --> 00:56:50,240
și care ne dă acum 2 jumatati, care sunt sortate, iar acum vom combina aceste jumatati împreună.

926
00:56:50,240 --> 00:56:55,010
E un pic cam greu pentru a vedea fara un exemplu, așa că vom trece prin propunerilor de rezoluție și a vedea ce se întâmplă.

927
00:56:55,010 --> 00:56:59,590
Așa că începe cu această listă, l-am impartit in 2 jumatati.

928
00:56:59,590 --> 00:57:02,300
Vom rula un fel îmbinare pe jumătatea stângă prima.

929
00:57:02,300 --> 00:57:06,660
Deci, asta e jumătatea stângă, iar acum le trece prin această listă din nou

930
00:57:06,660 --> 00:57:09,800
care devine trecut în sortare îmbinare, iar apoi ne uităm, din nou,

931
00:57:09,800 --> 00:57:13,270
la partea stângă a acestei liste și vom rula îmbinare fel pe ea.

932
00:57:13,270 --> 00:57:15,880
Acum, ajungem la o listă de 2 numere,

933
00:57:15,880 --> 00:57:19,010
iar acum jumătatea stângă este de numai 1, de mult timp, și nu putem

934
00:57:19,010 --> 00:57:23,380
împărți o listă care doar 1 element în jumătate, așa că am să spun, după ce vom avea 50,

935
00:57:23,380 --> 00:57:26,400
care este doar 1 element, este deja sortate.

936
00:57:26,400 --> 00:57:29,860
>> După ce am terminat cu asta, putem vedea că putem

937
00:57:29,860 --> 00:57:32,230
trece la jumătatea dreaptă a acestei liste,

938
00:57:32,230 --> 00:57:36,480
și 3 este, de asemenea, sortate, și astfel acum că ambele jumatati ale acestei liste sunt sortate

939
00:57:36,480 --> 00:57:39,080
ne putem alătura aceste numere din nou împreună.

940
00:57:39,080 --> 00:57:45,320
Deci ne uităm la 50 și 3; 3 este mai mică de 50, așa că se duce în primul și apoi 50 inch vine

941
00:57:45,320 --> 00:57:49,340
Acum, ce sa făcut, să ne întoarcem până la această listă și sortare e pe jumătate dreptate.

942
00:57:49,340 --> 00:57:52,440
42 este numărul de propria lui, așa că deja sortate.

943
00:57:52,440 --> 00:57:57,850
Deci, acum vom compara aceste 2 și 3 este mai mic decât 42, astfel că se pune în primul rând,

944
00:57:57,850 --> 00:58:02,340
acum 42 se pune în, și 50 se pune inch

945
00:58:02,340 --> 00:58:07,220
Acum, care este sortat, vom merge tot drumul înapoi la partea de sus, 1337 și 15.

946
00:58:07,220 --> 00:58:14,560
Ei bine, acum ne uităm la jumătatea stângă a acestei liste; 1337 este, în sine, așa că sortati si aceeasi cu 15.

947
00:58:14,560 --> 00:58:19,020
Deci, acum vom combina aceste 2 numere pentru a sorta această listă inițială, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
așa că merge în primul rând, apoi merge inch 1337

949
00:58:23,060 --> 00:58:26,640
Și acum am sortat ambele jumatati ale lista inițială până sus.

950
00:58:26,640 --> 00:58:30,440
Și tot ce trebuie să faceți este să combine aceste.

951
00:58:30,440 --> 00:58:36,890
Ne uităm la primele 2 numere din această listă, 3 <15, așa că merge în matrice de sortare primul.

952
00:58:36,890 --> 00:58:44,460
15 <42, deci merge inch Acum, 42 <1337, care merge inch

953
00:58:44,460 --> 00:58:51,010
50 <1337, așa că merge inch Și observați că am luat doar 2 numere de pe această listă.

954
00:58:51,010 --> 00:58:53,640
Deci, nu suntem doar alternând între cele 2 liste.

955
00:58:53,640 --> 00:58:56,050
Căutăm doar la început, și vom lua elementul

956
00:58:56,050 --> 00:59:00,270
care este mai mic și apoi punerea în gama noastră.

957
00:59:00,270 --> 00:59:04,080
Acum, ne-am unit toate jumatati si am terminat.

958
00:59:04,080 --> 00:59:07,780
>> Orice întrebări despre fuziona fel? Da?

959
00:59:07,780 --> 00:59:14,190
[Student] Dacă e divizare în grupuri diferite, de ce nu au doar o dată împărțit

960
00:59:14,190 --> 00:59:19,970
și aveți 3 și 2 în grup? [Restul de neînțeles cauză]

961
00:59:19,970 --> 00:59:24,940
Motivul - deci intrebarea este, de ce nu putem îmbina doar le la acel prim pas după ce le avem?

962
00:59:24,940 --> 00:59:29,530
Motivul pentru care putem face acest lucru, încep de la elementele de stânga, cele mai multe de ambele părți,

963
00:59:29,530 --> 00:59:33,040
și apoi să ia cea mai mică și pune-l în, este că noi știm că aceste

964
00:59:33,040 --> 00:59:35,290
Lista de preturi individuale sunt sortate în ordine.

965
00:59:35,290 --> 00:59:37,290
Deci, dacă mă uit la elementele de cea mai din stânga ale ambelor reprize,

966
00:59:37,290 --> 00:59:40,490
Știu că o să fie cele mai mici elemente ale acestor liste.

967
00:59:40,490 --> 00:59:43,930
Deci, eu le pot pune în pete mai mic element al acestei liste mari.

968
00:59:43,930 --> 00:59:47,810
Pe de altă parte, dacă mă uit la cele 2 liste, în al doilea nivel de acolo,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 și 15, acestea nu sunt sortate.

970
00:59:51,640 --> 00:59:55,770
Deci, dacă mă uit la 50 și 1337, am de gând să afișezi 50 în lista de prima mea.

971
00:59:55,770 --> 01:00:00,130
Dar asta nu prea are sens, pentru că 3 este cel mai mic element din toate acestea.

972
01:00:00,130 --> 01:00:04,390
Deci singurul motiv pentru care putem face acest pas, deoarece este combinarea listele noastre sunt deja sortate.

973
01:00:04,390 --> 01:00:07,010
Care este motivul pentru care trebuie să te jos tot drumul la partea de jos

974
01:00:07,010 --> 01:00:09,800
pentru ca atunci cand avem doar un singur număr, știți că un număr unic

975
01:00:09,800 --> 01:00:14,120
în sine este deja o listă sortată.

976
01:00:14,120 --> 01:00:19,360
>> Alte întrebări? Nu?

977
01:00:19,360 --> 01:00:24,260
Complexitate? Ei bine, puteți vedea că, la fiecare pas exista numere finali,

978
01:00:24,260 --> 01:00:27,590
și putem împărți o listă în jurnalul de jumătate de n ori,

979
01:00:27,590 --> 01:00:31,700
care este în cazul în care vom obține acest jurnal n x n complexitate.

980
01:00:31,700 --> 01:00:34,940
Și veți vedea cel mai bun caz pentru sortare îmbinare este n log n, și doar așa se întâmplă

981
01:00:34,940 --> 01:00:39,340
că cel mai rău caz, sau Ω acolo, este, de asemenea, n log n.

982
01:00:39,340 --> 01:00:42,480
Ceva de a păstra în minte.

983
01:00:42,480 --> 01:00:45,750
Mutarea, să mergem pe la unele dosarul de bază, super-I / O.

984
01:00:45,750 --> 01:00:48,830
Dacă te-ai uitat la Scramble, veți observa am avut un fel de sistem de

985
01:00:48,830 --> 01:00:51,270
în cazul în care ați putea scrie într-un fișier jurnal, dacă ai citit prin codul.

986
01:00:51,270 --> 01:00:53,730
Să vedem cum s-ar putea face asta.

987
01:00:53,730 --> 01:00:57,450
Ei bine, avem fprintf, pe care vă puteți gândi ca doar printf,

988
01:00:57,450 --> 01:01:01,720
ci doar imprimarea într-un fișier în loc, și, prin urmare f la început.

989
01:01:01,720 --> 01:01:07,570
Acest tip de cod aici, ceea ce face este, așa cum s-ar putea fi văzut în Scramble,

990
01:01:07,570 --> 01:01:12,310
ea trece prin imprimare matrice 2-dimensional out rând cu rând ce numere sunt.

991
01:01:12,310 --> 01:01:17,850
În acest caz, printf imprimă la terminalul sau ceea ce noi numim de ieșire standard de secțiune.

992
01:01:17,850 --> 01:01:22,170
>> Și acum, în acest caz, tot ce trebuie să faceți este să înlocuiască printf cu fprintf,

993
01:01:22,170 --> 01:01:26,770
Spune-i cum fișier pe care doriți să imprimați, și, în acest caz, doar se imprimă în acest dosar

994
01:01:26,770 --> 01:01:32,230
în loc să-l imprimarea la terminalul.

995
01:01:32,230 --> 01:01:36,500
Ei bine, atunci pune întrebarea: Unde facem obține acest tip de fișier de la, dreapta?

996
01:01:36,500 --> 01:01:39,840
Am trecut conecta la acest fuction fprintf, dar am avut nici o idee de unde a venit de la.

997
01:01:39,840 --> 01:01:43,980
Ei bine, în prima parte a codului, ceea ce am avut a fost această bucată de cod pe aici,

998
01:01:43,980 --> 01:01:48,340
care, practic, spune ca se deschid fișierul solicită log.txt.

999
01:01:48,340 --> 01:01:53,220
Ce facem după aceea este că trebuie să vă asigurați că fișierul este deschis cu succes, de fapt.

1000
01:01:53,220 --> 01:01:57,070
Deci, s-ar putea eșua din mai multe motive, nu aveți spațiu suficient pe calculator, de exemplu.

1001
01:01:57,070 --> 01:01:59,790
Deci, este întotdeauna important înainte de a face orice operațiuni cu fișierul

1002
01:01:59,790 --> 01:02:03,300
pe care le verifice dacă acest dosar a fost deschis cu succes.

1003
01:02:03,300 --> 01:02:09,330
Deci, ce că o, care este un argument pentru a fopen, ei bine, putem deschide un fișier în mai multe moduri.

1004
01:02:09,330 --> 01:02:13,510
Ceea ce putem face este, putem să-l dați g, ceea ce înseamnă suprascrie fișierul, dacă acesta iese deja,

1005
01:02:13,510 --> 01:02:18,070
Putem trece un un, pe care le adăugați la sfârșitul fișierului în loc de aceasta imperative,

1006
01:02:18,070 --> 01:02:22,730
sau putem specifica R, ceea ce înseamnă, să deschideți fișierul doar în citire.

1007
01:02:22,730 --> 01:02:24,890
Deci, dacă programul încearcă să facă orice modificări la dosar,

1008
01:02:24,890 --> 01:02:30,140
tipa la ei si nu-i lasa sa-l faca.

1009
01:02:30,140 --> 01:02:33,320
În cele din urmă, odată ce am terminat cu fișierul, terminat fac operațiuni pe ea,

1010
01:02:33,320 --> 01:02:35,860
avem nevoie pentru a ne asigura închide fișierul.

1011
01:02:35,860 --> 01:02:38,830
Și astfel, la sfârșitul programului dumneavoastră, aveți de gând să-i treacă din nou

1012
01:02:38,830 --> 01:02:42,120
acest fișier pe care l-ați deschis, închideți-l și doar.

1013
01:02:42,120 --> 01:02:44,650
Deci, asta este ceva important care trebuie să vă asigurați faci.

1014
01:02:44,650 --> 01:02:47,180
Deci, amintiți puteți deschide un fișier, le puteti scrie la dosar,

1015
01:02:47,180 --> 01:02:51,270
face operațiuni în fișier, dar apoi va trebui să închideți fișierul la sfârșitul anului.

1016
01:02:51,270 --> 01:02:53,270
>> Orice întrebări cu privire la dosar de bază I / O? Da?

1017
01:02:53,270 --> 01:02:58,050
[Întrebare Student, neinteligibil]

1018
01:02:58,050 --> 01:03:02,480
Chiar aici. Întrebarea este, în cazul în care nu apare acest fișier log.txt?

1019
01:03:02,480 --> 01:03:07,890
Ei bine, daca da doar log.txt, îl creează în același director ca și executabil.

1020
01:03:07,890 --> 01:03:10,500
Deci, dacă Esti - >> [intrebare Student, neinteligibil]

1021
01:03:10,500 --> 01:03:18,830
Da. În același dosar, sau în același director, așa cum îl numesc.

1022
01:03:18,830 --> 01:03:21,400
Acum memorie, stivă, și heap.

1023
01:03:21,400 --> 01:03:23,400
Deci, cum este memoria prevăzută în calculator?

1024
01:03:23,400 --> 01:03:26,270
Ei bine, vă puteți imagina de memorie ca un fel de acest bloc aici.

1025
01:03:26,270 --> 01:03:30,260
Și în memorie, avem ceea ce se numește heap blocat acolo, iar stiva că e acolo.

1026
01:03:30,260 --> 01:03:34,480
Și heap crește în jos și în sus stiva creste.

1027
01:03:34,480 --> 01:03:38,620
Deci, ca Tommy sa menționat - Oh, ei bine, și avem aceste alte 4 segmente pe care le voi obține la un al doilea -

1028
01:03:38,620 --> 01:03:42,890
Ca Tommy spus mai devreme, știi cum funcțiile sale se numesc și apelați unul pe altul?

1029
01:03:42,890 --> 01:03:44,930
Ei construi acest tip de cadru stivă.

1030
01:03:44,930 --> 01:03:47,360
Ei bine, în cazul în care solicită principalele foo, foo este pus pe stiva.

1031
01:03:47,360 --> 01:03:52,430
Foo solicită bar, să-l punem pe stiva, și că este pus pe stivă după.

1032
01:03:52,430 --> 01:03:57,040
Și, după cum se întorc, fiecare dintre ele se iau de pe stivă.

1033
01:03:57,040 --> 01:04:00,140
Ce fiecare dintre aceste locații de memorie și mențineți?

1034
01:04:00,140 --> 01:04:03,110
Ei bine, de sus, care este segmentul de text, conține programul in sine.

1035
01:04:03,110 --> 01:04:06,390
Deci, cod mașină, că e acolo, odată ce compilați programul dumneavoastră.

1036
01:04:06,390 --> 01:04:08,520
În continuare, orice initializat variabilele globale.

1037
01:04:08,520 --> 01:04:12,660
>> Deci, aveți variabile globale în programul tău, iar tu spui ca, un 5 =,

1038
01:04:12,660 --> 01:04:15,260
care se pune în acest segment, și chiar sub care,

1039
01:04:15,260 --> 01:04:18,990
aveți orice date neinițializate globale, care este int doar o,

1040
01:04:18,990 --> 01:04:20,990
dar nu spune ca e egal cu nimic.

1041
01:04:20,990 --> 01:04:23,870
Realizati acestea sunt variabile globale, astfel încât acestea sunt în afara principal.

1042
01:04:23,870 --> 01:04:28,560
Deci, acest lucru înseamnă orice variabile globale care sunt declarate, dar nu sunt inițializate.

1043
01:04:28,560 --> 01:04:32,310
Deci, ce e în heap? De memorie alocate folosind malloc, pe care vom ajunge la un pic.

1044
01:04:32,310 --> 01:04:35,990
Și, în sfârșit, cu stiva aveți orice variabile locale

1045
01:04:35,990 --> 01:04:39,950
și orice funcții s-ar putea numi, în oricare din parametrii lor.

1046
01:04:39,950 --> 01:04:43,720
Ultimul lucru, nu aveți cu adevărat să știe ce fac variabilele de mediu,

1047
01:04:43,720 --> 01:04:46,700
dar ori de câte ori aveți o programul, nu este ceva asociat, cum ar fi

1048
01:04:46,700 --> 01:04:49,550
aceasta este numele de utilizator al persoanei care a fugit programului.

1049
01:04:49,550 --> 01:04:51,550
Și asta va fi un fel de la partea de jos.

1050
01:04:51,550 --> 01:04:54,540
În ceea ce privește adresele de memorie, care sunt valorile hexazecimale,

1051
01:04:54,540 --> 01:04:58,170
valorile de la începutul partea de sus de la 0, și care se duc tot drumul până la partea de jos.

1052
01:04:58,170 --> 01:05:00,440
În acest caz, dacă sunteți pe sistemul de 32-biți,

1053
01:05:00,440 --> 01:05:05,390
adresa la partea de jos va fi 0x, urmat de af, pentru că e de 32 de biți,

1054
01:05:05,390 --> 01:05:10,890
care este de 8 octeți, și, în acest caz, 8 octeți pentru a corespunde cifre hexazecimale 8.

1055
01:05:10,890 --> 01:05:20,110
Deci, aici ai de gând să aibă, ca, 0xFFFFFF, si acolo ai de gând să aibă 0.

1056
01:05:20,110 --> 01:05:23,660
Deci, ce sunt indicii? Unii dintre voi ar putea să nu au acoperit acest lucru în secțiune înainte.

1057
01:05:23,660 --> 01:05:26,660
dar am merge peste ea în curs, astfel încât un pointer este doar un tip de date

1058
01:05:26,660 --> 01:05:34,030
care de magazine, în loc de un fel de valoare cum ar fi 50, acesta stochează adresa o locație în memorie.

1059
01:05:34,030 --> 01:05:36,020
Ca faptul că memoria [neinteligibil].

1060
01:05:36,020 --> 01:05:41,120
Deci, în acest caz, ceea ce am este, avem un pointer la un întreg sau o int *,

1061
01:05:41,120 --> 01:05:46,210
și conține această adresă hexazecimală de 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Deci, ceea ce avem este, în prezent, această indicatorul de la o locație în memorie,

1063
01:05:50,880 --> 01:05:56,020
și că e doar o, valoarea 50 este în această locație de memorie.

1064
01:05:56,020 --> 01:06:01,810
Pe unele sisteme 32-biți, pentru toate sistemele pe 32 de biți, indicii dura până biți 32 sau 4 octeți.

1065
01:06:01,810 --> 01:06:06,020
Dar, de exemplu, pe un sistem de 64-biți, pointerii sunt pe 64 de biți.

1066
01:06:06,020 --> 01:06:08,040
Deci, asta e ceva ce veți dori să păstrați în minte.

1067
01:06:08,040 --> 01:06:12,310
Deci, pe un sistem end-biți, este un pointer biți end lung.

1068
01:06:12,310 --> 01:06:17,320
Pointeri sunt un fel de greu de digerat, fără lucruri suplimentare,

1069
01:06:17,320 --> 01:06:20,300
așa că hai să treacă printr-un exemplu de alocare dinamică a memoriei.

1070
01:06:20,300 --> 01:06:25,130
Ce alocare de memorie dinamică face pentru tine, sau ceea ce noi numim malloc,

1071
01:06:25,130 --> 01:06:29,280
vă permite să aloce un fel de date din afara setului.

1072
01:06:29,280 --> 01:06:31,830
Deci, asta este un fel de date cu caracter mai permanent pentru durata programului.

1073
01:06:31,830 --> 01:06:36,430
Pentru că după cum știți, dacă ați declara x în interiorul unei funcții, și care returnează funcția,

1074
01:06:36,430 --> 01:06:40,910
nu mai avea acces la datele care au fost stocate în x.

1075
01:06:40,910 --> 01:06:44,420
Ce indicii să facem este ca ei să ne stoca valori de memorie sau magazin

1076
01:06:44,420 --> 01:06:46,840
într-un segment diferit al memoriei, și anume heap.

1077
01:06:46,840 --> 01:06:49,340
Acum, odată ce ne vom întoarce din funcție, atâta timp cât avem un pointer

1078
01:06:49,340 --> 01:06:54,960
la acea locație în memorie, atunci ce putem face este doar să ne putem uita la valorile de acolo.

1079
01:06:54,960 --> 01:06:58,020
Să ne uităm la un exemplu: Acesta este aspectul nostru de memorie din nou.

1080
01:06:58,020 --> 01:07:00,050
Și avem această funcție, principala.

1081
01:07:00,050 --> 01:07:06,870
Ceea ce face este - în regulă, atât de simplu, nu? - Int x = 5, asta e doar o variabilă pe stivă în principal.

1082
01:07:06,870 --> 01:07:12,450
>> Pe de altă parte, acum avem declara un pointer care cheamă giveMeThreeInts funcției.

1083
01:07:12,450 --> 01:07:16,800
Și acum mergem în această funcție și vom crea un cadru nou teanc de ea.

1084
01:07:16,800 --> 01:07:20,440
Cu toate acestea, în acest cadru stivă, ne declarăm int * temp,

1085
01:07:20,440 --> 01:07:23,210
care, în mallocs 3 numere întregi pentru noi.

1086
01:07:23,210 --> 01:07:25,880
Deci, dimensiunea int ne va da cate bytes aceasta este int,

1087
01:07:25,880 --> 01:07:29,620
și malloc ne oferă ca multe bytes de spațiu de pe heap.

1088
01:07:29,620 --> 01:07:32,890
Deci, în acest caz, am creat spațiu suficient pentru 3 numere întregi,

1089
01:07:32,890 --> 01:07:36,830
și heap este drumul până acolo, motiv pentru care l-am redactat mai sus.

1090
01:07:36,830 --> 01:07:42,900
După ce am terminat, am venit înapoi aici, aveți nevoie doar de 3 Ints întors,

1091
01:07:42,900 --> 01:07:47,000
și returnează adresa, în acest caz peste în cazul în care memoria este.

1092
01:07:47,000 --> 01:07:51,250
Și ne-am stabilit indicatorul = comutator, și acolo avem doar un alt indicator.

1093
01:07:51,250 --> 01:07:54,550
Dar ceea ce revine funcției este stivuite aici și dispare.

1094
01:07:54,550 --> 01:07:59,250
Deci temp dispare, dar încă menține adresa în cazul în care

1095
01:07:59,250 --> 01:08:01,850
cele 3 numere întregi se află în interiorul rețelei de alimentare.

1096
01:08:01,850 --> 01:08:06,180
Deci, în acest set, pointerii cad pe plan local pentru cadru stivuite,

1097
01:08:06,180 --> 01:08:09,860
dar memoria la care se referă este în heap.

1098
01:08:09,860 --> 01:08:12,190
>> Are vreun sens?

1099
01:08:12,190 --> 01:08:14,960
[Student] Ai putea repeta asta? >> [Iosif] Da.

1100
01:08:14,960 --> 01:08:20,270
Așa că, dacă mă întorc doar un pic, vezi ca temp alocate

1101
01:08:20,270 --> 01:08:23,500
unele de memorie pe heap acolo.

1102
01:08:23,500 --> 01:08:28,680
Deci, atunci când această funcție, giveMeThreeInts retururi, acest teanc aici este de gând să dispară.

1103
01:08:28,680 --> 01:08:35,819
Și cu ea oricare dintre variabile, în acest caz, acest pointer care a fost alocată în cadrul stivuite.

1104
01:08:35,819 --> 01:08:39,649
Care este de gând să dispară, dar din moment ce ne-am întors temp

1105
01:08:39,649 --> 01:08:46,330
și ne-am stabilit indicatorul = temp, indicatorul se acum de gând să arate aceeași memorie de locație ca și temperatură a fost.

1106
01:08:46,330 --> 01:08:50,370
Deci, acum, chiar daca vom pierde temp, că indicatorul locală,

1107
01:08:50,370 --> 01:08:59,109
am încă mai păstrează adresa de memorie a ceea ce a fost îndreptat spre interior din variabila pointer.

1108
01:08:59,109 --> 01:09:03,740
Întrebări? Asta poate fi un fel de un subiect confuz, dacă nu au trecut peste ea în secțiunea.

1109
01:09:03,740 --> 01:09:09,240
Noi putem, TF ta va merge cu siguranta peste ea și, desigur, putem răspunde la întrebări

1110
01:09:09,240 --> 01:09:11,500
la finalul sesiunii de revizuire pentru acest lucru.

1111
01:09:11,500 --> 01:09:14,220
Dar aceasta este un fel de subiect complex, si am mai multe exemple care urmeaza sa apara

1112
01:09:14,220 --> 01:09:18,790
care va ajuta la clarificarea ce indicii sunt de fapt.

1113
01:09:18,790 --> 01:09:22,500
>> În acest caz, indicii sunt echivalente cu matrice,

1114
01:09:22,500 --> 01:09:25,229
așa că am putea folosi doar acest pointer ca același lucru ca o matrice int.

1115
01:09:25,229 --> 01:09:29,840
Deci, eu sunt în indexarea 0, se schimba întreg primul la 1,

1116
01:09:29,840 --> 01:09:39,689
schimbarea întreg secunde la 2, iar întreg treilea la 3.

1117
01:09:39,689 --> 01:09:44,210
Deci, mai mult pe pointeri. Ei bine, amintesc Binky.

1118
01:09:44,210 --> 01:09:48,319
În acest caz, am alocat un pointer, sau ne-am declarat un pointer,

1119
01:09:48,319 --> 01:09:52,760
dar inițial, când am declarat doar un pointer, nu este îndreptat oriunde în memorie.

1120
01:09:52,760 --> 01:09:54,930
E doar valori de gunoi în interiorul de ea.

1121
01:09:54,930 --> 01:09:56,470
Deci nu am nici o idee în cazul în care acest indicator este îndreptat spre.

1122
01:09:56,470 --> 01:10:01,630
Acesta are o adresă care este doar umplut cu a lui 0 și 1 în cazul în care acesta a fost declarat inițial.

1123
01:10:01,630 --> 01:10:04,810
Eu nu pot face nimic cu asta până când am apel malloc pe ea

1124
01:10:04,810 --> 01:10:08,390
și apoi dă-mi un pic de spatiu pe movila unde pot pune valori în interiorul.

1125
01:10:08,390 --> 01:10:11,980
Apoi, din nou, nu știu ce e în interiorul acestei memorii.

1126
01:10:11,980 --> 01:10:16,780
Deci, primul lucru pe care trebuie să faceți este să verificați dacă sistemul a avut suficientă memorie

1127
01:10:16,780 --> 01:10:20,850
sa-mi dea inapoi 1 întreg în primul rând, care este motivul pentru care fac asta verifica.

1128
01:10:20,850 --> 01:10:25,020
În cazul în care indicatorul este nul, ceea ce înseamnă că nu avea suficient spațiu sau o altă eroare a avut loc,

1129
01:10:25,020 --> 01:10:26,320
așa că am ar trebui să ieși din programul meu.

1130
01:10:26,320 --> 01:10:29,400
 Dar dacă a făcut-o a reuși, acum pot folosi ca indicatorul

1131
01:10:29,400 --> 01:10:35,020
și ceea ce face este pointer * rezultă în cazul în care adresa este

1132
01:10:35,020 --> 01:10:38,480
pentru a în cazul în care valoarea este, și acesta stabilește l egal cu 1.

1133
01:10:38,480 --> 01:10:41,850
Deci aici, suntem de verificare în cazul în care memoria existat.

1134
01:10:41,850 --> 01:10:45,380
>> Odată ce știi că există, puteți pune în ea

1135
01:10:45,380 --> 01:10:50,460
ce valoare doriți să puneți în ea, în acest caz 1.

1136
01:10:50,460 --> 01:10:53,060
După ce am terminat cu el, aveți nevoie pentru a elibera că indicatorul

1137
01:10:53,060 --> 01:10:57,160
pentru că avem nevoie să ne întoarcem la sistemul de ca memoria pe care ai cerut, în primul rând.

1138
01:10:57,160 --> 01:10:59,690
Deoarece calculatorul nu știu când am terminat cu el.

1139
01:10:59,690 --> 01:11:02,510
În acest caz, vom spune în mod explicit că, în regulă, am terminat cu asta de memorie.

1140
01:11:02,510 --> 01:11:10,780
În cazul în care alt proces de care are nevoie, un alt program de care are nevoie, nu ezitați să mergeți mai departe și ia-o.

1141
01:11:10,780 --> 01:11:15,110
Ce putem face, de asemenea, este, putem obține doar adresa de variabilele locale pe platourile de filmare.

1142
01:11:15,110 --> 01:11:19,080
Deci, int x este în interiorul cadrului de stivuite principal.

1143
01:11:19,080 --> 01:11:23,060
Și atunci când vom folosi acest ampersand, asta și operatorul, ceea ce face este

1144
01:11:23,060 --> 01:11:27,310
este nevoie de x, si x este doar unele date din memorie, dar are o adresă.

1145
01:11:27,310 --> 01:11:33,790
Este situat undeva. Deci, prin chemarea & x, ce face asta este ne dă adresa lui x.

1146
01:11:33,790 --> 01:11:38,430
Făcând acest lucru, vom face punctul pointer la x, unde este în memorie.

1147
01:11:38,430 --> 01:11:41,710
Acum ne-am face ceva de genul * x, vom primi înapoi 5.

1148
01:11:41,710 --> 01:11:43,820
Stele este numit dereferencing ea.

1149
01:11:43,820 --> 01:11:46,640
Să urmați adresa și veți obține o valoare de ea stocată acolo.

1150
01:11:51,000 --> 01:11:53,310
>> Alte întrebări? Da?

1151
01:11:53,310 --> 01:11:56,500
[Student] Dacă nu faci chestia 3-colturi, nu-l compilați în continuare?

1152
01:11:56,500 --> 01:11:59,490
Da. Dacă nu faci chestia 3-pointer, este încă în desfășurare pentru a compila,

1153
01:11:59,490 --> 01:12:02,720
dar vă voi arăta ce se întâmplă într-o secundă, și fără a face acest lucru,

1154
01:12:02,720 --> 01:12:04,860
asta e ceea ce noi numim o scurgere de memorie. Tu nu dai sistemul

1155
01:12:04,860 --> 01:12:07,850
copii de memoria sa, asa ca dupa un timp programul este de gând să se acumuleze

1156
01:12:07,850 --> 01:12:10,940
de memorie care nu este utilizat, și nimic altceva pot folosi.

1157
01:12:10,940 --> 01:12:15,750
Dacă ați văzut vreodată Firefox cu 1,5 milioane de kilobiți pe computer,

1158
01:12:15,750 --> 01:12:17,840
în task manager, asta e ceea ce se întâmplă.

1159
01:12:17,840 --> 01:12:20,760
Ai o scurgere de memorie în programul pe care ei nu sunt de manipulare.

1160
01:12:23,080 --> 01:12:26,240
Deci, cum face indicatorul de muncă aritmetica?

1161
01:12:26,240 --> 01:12:29,480
Ei bine, aritmetica indicatorul este un fel de indexare ca într-o matrice.

1162
01:12:29,480 --> 01:12:36,370
În acest caz, am un pointer, iar ceea ce fac este punctul fac pointer la primul element

1163
01:12:36,370 --> 01:12:42,100
din această matrice de 3 numere intregi care le-am alocate.

1164
01:12:42,100 --> 01:12:46,670
Deci, acum ce să fac, indicatorul stea schimbă doar primul element din listă.

1165
01:12:46,670 --> 01:12:49,140
Stele pointer +1 puncte peste aici.

1166
01:12:49,140 --> 01:12:53,140
Deci, indicatorul este de peste aici, indicatorul +1 este aici, indicatorul +2 este aici.

1167
01:12:53,140 --> 01:12:56,610
>> Deci, adăugând doar 1 este același lucru ca și în mișcare de-a lungul acestei matrice.

1168
01:12:56,610 --> 01:12:59,880
Ceea ce facem este, atunci când facem indicatorul 1 te adresa aici,

1169
01:12:59,880 --> 01:13:04,180
și, în scopul de a obține o valoare aici, ai pus o stea de la întreaga expresie

1170
01:13:04,180 --> 01:13:05,990
să-l dereference.

1171
01:13:05,990 --> 01:13:09,940
Deci, în acest caz, am stabilind prima locatie in aceasta matrice de 1,

1172
01:13:09,940 --> 01:13:13,970
doua locatie la 2, și a treia locație la 3.

1173
01:13:13,970 --> 01:13:18,180
Atunci ce fac eu aici este că am imprimarea indicatorul nostru +1,

1174
01:13:18,180 --> 01:13:19,970
care tocmai îmi dă 2.

1175
01:13:19,970 --> 01:13:23,650
Acum sunt incrementarea pointer, astfel încât indicatorul este egal cu indicatorul 1,

1176
01:13:23,650 --> 01:13:26,780
care se mișcă înainte.

1177
01:13:26,780 --> 01:13:30,810
Și acum, dacă am tipări indicatorul 1, indicatorul 1 este acum 3,

1178
01:13:30,810 --> 01:13:33,990
care, în acest caz, imprimă 3.

1179
01:13:33,990 --> 01:13:36,560
Și în scopul de a ceva gratuit, indicatorul pe care l-am da

1180
01:13:36,560 --> 01:13:40,540
trebuie să fie îndreptată la începutul matrice pe care m-am întors de la malloc.

1181
01:13:40,540 --> 01:13:43,430
Deci, în acest caz, dacă ar fi să sun 3 chiar aici, acest lucru nu ar fi corect,

1182
01:13:43,430 --> 01:13:45,070
pentru că este în mijlocul matrice.

1183
01:13:45,070 --> 01:13:48,820
Trebuie să scadă pentru a ajunge la locația originală

1184
01:13:48,820 --> 01:13:50,420
loc inițială înainte pot să-l elibera.

1185
01:13:56,300 --> 01:13:58,450
Deci, aici e un exemplu se implice mai mult.

1186
01:13:58,450 --> 01:14:03,360
În acest caz, vom aloca 7 caractere într-un sir de caractere.

1187
01:14:03,360 --> 01:14:06,480
>> Și în acest caz, ceea ce facem noi e ca suntem looping peste primele 6 dintre ele,

1188
01:14:06,480 --> 01:14:09,900
și suntem stabilirea lor la Z.

1189
01:14:09,900 --> 01:14:13,350
Deci, pentru int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Deci, indicatorul + i se va da doar noi, în acest caz,

1191
01:14:16,220 --> 01:14:20,860
indicatorul, indicatorul 1, indicatorul 2, indicatorul 3, și așa mai departe și așa mai departe, în buclă.

1192
01:14:20,860 --> 01:14:24,040
Ce va face este faptul că devine adresa, dereferences l pentru a obține valoarea,

1193
01:14:24,040 --> 01:14:27,440
și modificările că valoarea unei Z.

1194
01:14:27,440 --> 01:14:30,350
Apoi, la sfârșitul retineti aceasta este un șir, nu?

1195
01:14:30,350 --> 01:14:33,560
Toate siruri de caractere trebuie să se termine cu caracterul nul de încheiere.

1196
01:14:33,560 --> 01:14:38,620
Deci, ceea ce fac este în indicatorul 6 am pus nul caracterul terminator inch

1197
01:14:38,620 --> 01:14:43,980
Și acum ce fac eu practic aici este punerea în aplicare a printf pentru un șir, nu?

1198
01:14:43,980 --> 01:14:46,190
>> Deci, atunci când se printf acum, când acesta a ajuns la sfârșitul unui șir?

1199
01:14:46,190 --> 01:14:48,230
Când va atinge caracterul nul de încheiere.

1200
01:14:48,230 --> 01:14:52,030
Deci, în acest caz, punctele mele originale indicatorul la începutul acestei matrice.

1201
01:14:52,030 --> 01:14:56,410
Am imprima primul caracter afară. Am muta peste o.

1202
01:14:56,410 --> 01:14:58,420
Am imprima acel caracter afară. Am muta peste.

1203
01:14:58,420 --> 01:15:02,180
Și am face asta până când voi ajunge la final.

1204
01:15:02,180 --> 01:15:07,750
Și acum * indicatorul final va dereference acest lucru și a obține caracterul nul de încheiere înapoi.

1205
01:15:07,750 --> 01:15:11,780
Și astfel buclă în timp ce se execută meu numai atunci când acea valoare nu este caracterul nul de încheiere.

1206
01:15:11,780 --> 01:15:13,770
Deci, acum am ieși din această buclă.

1207
01:15:18,780 --> 01:15:21,180
Și deci, dacă am scădea 6 din acest pointer,

1208
01:15:21,180 --> 01:15:22,860
Mă duc înapoi tot drumul de la început.

1209
01:15:22,860 --> 01:15:27,880
Amintiți-vă, eu fac asta pentru că trebuie să mă duc la început pentru ao elibera.

1210
01:15:27,880 --> 01:15:30,270
>> Deci, eu știu că a fost o foarte mult. Există întrebări?

1211
01:15:30,270 --> 01:15:31,870
Te rog, da?

1212
01:15:31,870 --> 01:15:36,610
[Neinteligibil întrebare Student]

1213
01:15:36,610 --> 01:15:38,190
Poți să spui asta mai tare? Scuze.

1214
01:15:38,190 --> 01:15:44,140
[Student] La ultimul diapozitiv chiar înainte de a te-a eliberat indicatorul,

1215
01:15:44,140 --> 01:15:47,300
în cazul în care ați fost schimbarea de fapt, valoarea indicatorului?

1216
01:15:47,300 --> 01:15:50,370
[Joseph] Deci, chiar aici. >> [Student] Oh, bine.

1217
01:15:50,370 --> 01:15:51,890
[Joseph] Deci, am un pointer minus minus, dreapta,

1218
01:15:51,890 --> 01:15:54,140
care se mută înapoi cu un lucru, iar apoi l-am elibera,

1219
01:15:54,140 --> 01:15:57,000
deoarece acest indicator trebuie să fie arătat la începutul matrice.

1220
01:15:57,000 --> 01:16:00,420
[Student] Dar asta nu ar fi nevoie de a te-ai oprit după acea linie.

1221
01:16:00,420 --> 01:16:03,130
[Joseph] Deci, dacă aș fi oprit după aceasta, acest lucru ar fi considerat o scurgere de memorie,

1222
01:16:03,130 --> 01:16:04,810
pentru că nu am alerga liber.

1223
01:16:04,810 --> 01:16:11,290
[Student] I [neinteligibil] după primele trei linii în cazul în care le-ați avut indicatorul 1 [neinteligibil].

1224
01:16:11,290 --> 01:16:13,140
[Joseph] Uh-huh. Deci, ce e problema acolo?

1225
01:16:13,140 --> 01:16:14,780
Scuze. Nu, nu. Du-te, du-te, te rog.

1226
01:16:14,780 --> 01:16:16,870
[Student] Deci, nu te schimba valoarea de pointeri.

1227
01:16:16,870 --> 01:16:19,130
Tu nu ar fi trebuit să facă indicatorul minus minus.

1228
01:16:19,130 --> 01:16:19,730
[Joseph] Da, exact.

1229
01:16:19,730 --> 01:16:21,890
Așa că, atunci când fac indicatorul +1 și indicatorul 2,

1230
01:16:21,890 --> 01:16:24,410
Eu nu fac indicatorul este egală cu indicatorul 1.

1231
01:16:24,410 --> 01:16:27,260
Deci, indicatorul rămâne doar îndreptat la începutul matrice.

1232
01:16:27,260 --> 01:16:31,460
E doar atunci când fac, plus, plus că aceasta stabilește valoarea înapoi indicatorul,

1233
01:16:31,460 --> 01:16:33,550
că se mișcă de fapt această de-a lungul.

1234
01:16:36,860 --> 01:16:37,780
Bine.

1235
01:16:40,550 --> 01:16:42,030
Mai multe întrebări?

1236
01:16:44,680 --> 01:16:47,790
>> Din nou, în cazul în care aceasta este un fel de copleșitoare, acest lucru va fi acoperit în sesiune.

1237
01:16:47,790 --> 01:16:50,710
Adresați-vă colegii dumneavoastră de predare cu privire la aceasta, și putem răspunde la întrebările de la sfârșitul.

1238
01:16:53,510 --> 01:16:56,600
Și, de obicei, nu ne place să facem acest lucru minus.

1239
01:16:56,600 --> 01:16:59,760
Acest lucru trebuie să solicite mă ține cont de cât de mult le-am compensat în matrice.

1240
01:16:59,760 --> 01:17:04,520
Deci, în general, acest lucru este doar de a explica modul în care funcționează indicatorul aritmetice.

1241
01:17:04,520 --> 01:17:07,970
Dar, de obicei, ceea ce ne place să facem este să ne place crea o copie a indicatorului,

1242
01:17:07,970 --> 01:17:11,640
și apoi vom folosi această copie atunci când ne mișcăm în jurul valorii de în șir.

1243
01:17:11,640 --> 01:17:14,660
Deci, în aceste cazuri, utilizați pentru a imprima copia întregul șir,

1244
01:17:14,660 --> 01:17:19,040
dar noi nu trebuie să facem ca indicatorul minus 6 sau a urmări cât de mult ne-am mutat în acest sens,

1245
01:17:19,040 --> 01:17:22,700
doar pentru că știm că punctul nostru inițial este încă indicat la începutul listei

1246
01:17:22,700 --> 01:17:25,340
și tot ce am modificat a fost această copie.

1247
01:17:25,340 --> 01:17:28,250
Deci, în general, să modifice copii ale indicatorul original.

1248
01:17:28,250 --> 01:17:32,350
Nu încercați să un fel de - Nu te modifica exemplare originale.

1249
01:17:32,350 --> 01:17:35,290
Încercarea de a modifica doar copii ale originalului.

1250
01:17:41,540 --> 01:17:44,870
Deci, observați când vom trece în șir printf

1251
01:17:44,870 --> 01:17:48,990
nu trebuie să pună o stea în fața lui ca și cum am făcut-o cu toate celelalte dereferences, nu?

1252
01:17:48,990 --> 01:17:54,180
Deci, dacă vă tipăriți întregul% s sir așteaptă este o adresă,

1253
01:17:54,180 --> 01:17:57,610
și, în acest caz, un pointer sau în acest caz, ca un tablou de caractere.

1254
01:17:57,610 --> 01:18:00,330
>> Caractere, char * s, și matrice sunt același lucru.

1255
01:18:00,330 --> 01:18:03,690
Pointer este de a caracterelor, și matrice de caractere sunt același lucru.

1256
01:18:03,690 --> 01:18:05,720
Și astfel, tot ce trebuie să faceți este să treci în pointer.

1257
01:18:05,720 --> 01:18:08,150
Noi nu trebuie să treacă în aceeași pointer * sau ceva de genul asta.

1258
01:18:13,110 --> 01:18:14,930
Deci, tablouri și pointeri sunt același lucru.

1259
01:18:14,930 --> 01:18:19,160
Atunci când faci ceva de genul x [y] aici pentru o matrice,

1260
01:18:19,160 --> 01:18:21,960
ceea ce face sub capota este ea spune, bine, e un sir de caractere,

1261
01:18:21,960 --> 01:18:23,690
așa că este un pointer.

1262
01:18:23,690 --> 01:18:26,510
Și astfel x sunt același lucru,

1263
01:18:26,510 --> 01:18:28,650
și așa mai departe ceea ce face este se adaugă y la x,

1264
01:18:28,650 --> 01:18:31,820
ceea ce este același lucru ca și avansează în memorie atât de mult.

1265
01:18:31,820 --> 01:18:34,930
Și acum x + y ne dă un fel de adresă,

1266
01:18:34,930 --> 01:18:37,570
și am dereference adresa sau urmați săgeata

1267
01:18:37,570 --> 01:18:41,640
pentru a în cazul în care locația în memorie este si ajungem valoarea din acea locație în memorie.

1268
01:18:41,640 --> 01:18:43,720
Deci, astfel încât acestea două sunt exact acelasi lucru.

1269
01:18:43,720 --> 01:18:45,840
E doar un zahăr sintactică.

1270
01:18:45,840 --> 01:18:48,090
Ei fac acelasi lucru. Sunt doar syntactics diferite pentru fiecare altul.

1271
01:18:51,500 --> 01:18:57,590
>> Deci, ce se poate merge în neregulă cu pointeri? Ca, o mulțime. Bine. Deci, lucruri rele.

1272
01:18:57,590 --> 01:19:02,410
Unele lucruri rele pe care le puteți face, nu se verifica dacă apelul malloc returnează null, nu?

1273
01:19:02,410 --> 01:19:06,560
În acest caz, vă cer să-mi dea de sistem - ceea ce este că numărul?

1274
01:19:06,560 --> 01:19:11,200
Ca 2 miliarde de ori 4, deoarece dimensiunea unei întregi este de 4 octeți.

1275
01:19:11,200 --> 01:19:13,810
Eu l cer pentru ca 8 miliard de octeți.

1276
01:19:13,810 --> 01:19:17,270
Desigur, calculatorul meu nu va fi în măsură să-mi dea înapoi că multă memorie.

1277
01:19:17,270 --> 01:19:20,960
Și nu am verifica daca acest lucru este nulă, astfel încât atunci când vom încerca să-l dereference acolo -

1278
01:19:20,960 --> 01:19:24,270
urmați săgeata în cazul în care se va - nu avem acea memorie.

1279
01:19:24,270 --> 01:19:27,150
Aceasta este ceea ce noi numim un pointer nul dereferencing.

1280
01:19:27,150 --> 01:19:29,710
Și asta în esență, te face să te segfault.

1281
01:19:29,710 --> 01:19:31,790
Aceasta este una dintre modalități în care puteți segfault.

1282
01:19:34,090 --> 01:19:38,090
Alte lucruri rele pe care le puteți face - oh bine.

1283
01:19:38,090 --> 01:19:40,650
Care a fost dereferencing un pointer nul. Bine.

1284
01:19:40,650 --> 01:19:45,160
Alte lucruri rele - ei bine, să se stabilească faptul că ai pus doar un cec acolo

1285
01:19:45,160 --> 01:19:46,980
care verifică dacă indicatorul este nul

1286
01:19:46,980 --> 01:19:51,000
și ieși afară din program daca se intampla ca malloc returnează un pointer null.

1287
01:19:55,110 --> 01:19:59,850
Asta e comic xkcd. Oamenii înțeleg acum. Oarecum.

1288
01:20:06,120 --> 01:20:09,350
>> Deci, de memorie. Și m-am dus peste asta.

1289
01:20:09,350 --> 01:20:12,000
Suntem de asteptare malloc într-o buclă, dar de fiecare dată când ne numim malloc

1290
01:20:12,000 --> 01:20:14,370
vom pierde evidența în cazul în care acest indicator este orientată spre,

1291
01:20:14,370 --> 01:20:15,750
pentru că noi îl platesti.

1292
01:20:15,750 --> 01:20:18,410
Deci, apelul inițial la malloc îmi dă de memorie pe aici.

1293
01:20:18,410 --> 01:20:19,990
Pointeri mele pointer la.

1294
01:20:19,990 --> 01:20:23,020
Acum, eu nu-l eliberăm, așa că acum eu numesc malloc din nou.

1295
01:20:23,020 --> 01:20:26,070
Acum, aceasta subliniază aici. Acum, memoria mea este îndreptată peste aici.

1296
01:20:26,070 --> 01:20:27,640
Îndreptată peste aici. Îndreptată peste aici.

1297
01:20:27,640 --> 01:20:31,820
Dar am pierdut evidența adresele tuturor memorie de aici pe care am alocat.

1298
01:20:31,820 --> 01:20:35,100
Și acum nu am nici o referire la ele mai.

1299
01:20:35,100 --> 01:20:37,230
Deci, eu nu le pot elibera in afara de aceasta bucla.

1300
01:20:37,230 --> 01:20:39,390
Și astfel, în scopul de a stabili ceva de genul asta,

1301
01:20:39,390 --> 01:20:42,250
dacă vă uitați pentru a elibera memorie și veți obține acest scurgere de memorie,

1302
01:20:42,250 --> 01:20:45,810
Ai pentru a elibera memoria interiorul această buclă odată ce ai terminat cu ea.

1303
01:20:45,810 --> 01:20:51,400
Ei bine, aceasta este ceea ce se întâmplă. Știu o mulțime de urăști asta.

1304
01:20:51,400 --> 01:20:55,270
Dar acum - yay! Veți obține ca 44000 kilobytes.

1305
01:20:55,270 --> 01:20:57,110
Deci, ai elibera la sfârșitul buclei,

1306
01:20:57,110 --> 01:20:59,770
și că va elibera doar de memorie de fiecare dată.

1307
01:20:59,770 --> 01:21:03,620
În esență, programul nu are o scurgere de memorie mai.

1308
01:21:03,620 --> 01:21:08,150
>> Și acum ceva ce poți face este elibera de memorie pe care le-ați cerut de două ori.

1309
01:21:08,150 --> 01:21:11,060
În acest caz, ceva malloc, ai modifica valoarea.

1310
01:21:11,060 --> 01:21:13,140
Ai elibereze odată pentru că ai spus că s-au făcut cu ea.

1311
01:21:13,140 --> 01:21:14,940
Dar apoi l-am eliberat din nou.

1312
01:21:14,940 --> 01:21:16,730
Acest lucru este ceva care este destul de rău.

1313
01:21:16,730 --> 01:21:18,820
Acesta nu va segfault inițial,

1314
01:21:18,820 --> 01:21:23,350
dar după un timp ce acest lucru nu este dublu eliberarea acestei corupe structura heap,

1315
01:21:23,350 --> 01:21:27,200
și veți afla un pic mai mult despre acest lucru, dacă alegeți să luați o clasă ca CS61.

1316
01:21:27,200 --> 01:21:30,000
Dar, în esență, după o vreme, computerul se va obține confuz

1317
01:21:30,000 --> 01:21:33,010
despre ceea ce locațiile de memorie sunt în cazul în care și în cazul în care este stocat -

1318
01:21:33,010 --> 01:21:34,800
în cazul în care datele sunt stocate în memorie.

1319
01:21:34,800 --> 01:21:38,080
Și eliberând astfel un pointer de două ori este un lucru rău că nu vrei să faci.

1320
01:21:38,080 --> 01:21:41,600
>> Alte lucruri care pot merge prost, nu se utilizează sizeof.

1321
01:21:41,600 --> 01:21:44,460
Deci, în acest caz, vă malloc 8 octeți,

1322
01:21:44,460 --> 01:21:46,700
și că e același lucru ca două numere întregi, nu?

1323
01:21:46,700 --> 01:21:49,580
Deci, asta e perfect sigur, dar este?

1324
01:21:49,580 --> 01:21:52,160
Ei bine, după cum Lucas a vorbit despre pe alte arhitecturi diferite,

1325
01:21:52,160 --> 01:21:54,220
întregi sunt de lungimi diferite.

1326
01:21:54,220 --> 01:21:57,970
Deci, pe aparatul pe care îl utilizați, întregi sunt de aproximativ 4 octeți,

1327
01:21:57,970 --> 01:22:02,370
dar pe un alt sistem ar putea fi de 8 octeți sau s-ar putea fi de 16 bytes.

1328
01:22:02,370 --> 01:22:05,680
Deci, dacă am folosi doar acest număr aici,

1329
01:22:05,680 --> 01:22:07,310
acest program ar putea să funcționeze pe aparat,

1330
01:22:07,310 --> 01:22:10,360
dar nu se va aloca suficientă memorie pe un alt sistem.

1331
01:22:10,360 --> 01:22:14,020
În acest caz, aceasta este ceea ce operatorul sizeof este utilizat pentru.

1332
01:22:14,020 --> 01:22:16,880
Când numim sizeof (int), ce face asta este

1333
01:22:16,880 --> 01:22:21,910
 aceasta ne dă dimensiunea unui întreg sistem care pe programul se execută.

1334
01:22:21,910 --> 01:22:25,490
Deci, în acest caz, sizeof (int) va returna 4 pe ceva de genul aparatul,

1335
01:22:25,490 --> 01:22:29,980
și acum această voință 4 * 2, care este de 8,

1336
01:22:29,980 --> 01:22:32,330
care este doar cantitatea de spațiul necesar pentru două numere întregi.

1337
01:22:32,330 --> 01:22:36,710
Pe un sistem diferit, în cazul în care un int este ca 16 bytes sau 8 octeți,

1338
01:22:36,710 --> 01:22:39,380
este doar de gând să se întoarcă bytes suficiente pentru a stoca această sumă.

1339
01:22:41,830 --> 01:22:45,310
>> Și, în sfârșit, struct.

1340
01:22:45,310 --> 01:22:48,340
Deci, dacă ai vrut să stocați un consiliu de sudoku în memorie, cum am putea face acest lucru?

1341
01:22:48,340 --> 01:22:51,570
Ai putea crede ca a unei variabile pentru primul lucru,

1342
01:22:51,570 --> 01:22:53,820
o variabilă pentru al doilea lucru, o variabila pentru al treilea lucru,

1343
01:22:53,820 --> 01:22:56,420
o variabilă de lucru al patrulea - de rău, nu?

1344
01:22:56,420 --> 01:23:00,750
Deci, o îmbunătățire puteți face pe partea de sus a acestei este de a face o matrice 9 x 9.

1345
01:23:00,750 --> 01:23:04,480
Asta e bine, dar ce se întâmplă dacă ai vrut să se asocieze cu alte lucruri placa sudoku

1346
01:23:04,480 --> 01:23:06,490
ca ceea ce dificultatea de a bord este,

1347
01:23:06,490 --> 01:23:11,740
sau, de exemplu, ceea ce este scorul dvs., sau cât de mult timp mi-a luat să rezolve acest forum?

1348
01:23:11,740 --> 01:23:14,970
Ei bine, ce poti face este puteți crea un struct.

1349
01:23:14,970 --> 01:23:18,910
Ceea ce vreau să spun este practic eu definesc această structură de aici,

1350
01:23:18,910 --> 01:23:23,230
si eu o placa definirea sudoku, care constă dintr-un consiliu care este de 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> Și ce are are indicatori către numele de nivel.

1352
01:23:26,650 --> 01:23:30,730
Ea are, de asemenea, x și y, care sunt coordonatele unde sunt acum.

1353
01:23:30,730 --> 01:23:35,980
De asemenea, a petrecut timpul [neinteligibil], și are numărul total de mutãri am introduse până acum.

1354
01:23:35,980 --> 01:23:40,010
Și astfel, în acest caz, pot grupa o grămadă de date într-o singură structură

1355
01:23:40,010 --> 01:23:42,790
în loc de a avea o ca zboară în jurul valorii de la diferite variabile cum ar fi

1356
01:23:42,790 --> 01:23:44,540
că nu pot ține evidența într-adevăr.

1357
01:23:44,540 --> 01:23:49,720
Și aceasta ne permite să avem doar sintaxa frumos pentru un fel de referire la lucruri diferite interiorul acestei structuri.

1358
01:23:49,720 --> 01:23:53,430
Eu doar pot face board.board, iar eu placa sudoku înapoi.

1359
01:23:53,430 --> 01:23:56,320
Board.level, am înțeles cât de greu este.

1360
01:23:56,320 --> 01:24:00,540
Board.x și board.y da-mi coordonatele unde s-ar putea să fie în bord.

1361
01:24:00,540 --> 01:24:04,730
Și așa am accesarea ceea ce noi numim câmpurile struct.

1362
01:24:04,730 --> 01:24:08,840
Aceasta definește sudokuBoard, care este un tip de care am.

1363
01:24:08,840 --> 01:24:14,800
Și acum suntem aici. Am o variabilă numită "board" de sudokuBoard tip.

1364
01:24:14,800 --> 01:24:18,820
Și așa că acum pot accesa toate domeniile care alcătuiesc această structură aici.

1365
01:24:20,830 --> 01:24:22,450
>> Orice întrebări despre struct? Da?

1366
01:24:22,450 --> 01:24:25,890
[Student] Pentru int x, y, ai declarat amândoi pe o linie? >> [Joseph] Uh-huh.

1367
01:24:25,890 --> 01:24:27,400
[Student] Deci, ai putea sa faci doar asta, cu toate acestea?

1368
01:24:27,400 --> 01:24:31,200
Ca și în x, y ori de virgulă că totale?

1369
01:24:31,200 --> 01:24:34,460
[Joseph] Da, ai putea face cu siguranta asta, dar motivul pentru care am pus x si y pe aceeași linie -

1370
01:24:34,460 --> 01:24:36,330
și întrebarea este de ce putem face asta pe aceeași linie?

1371
01:24:36,330 --> 01:24:38,600
De ce nu ne pune toate acestea pe aceeași linie este

1372
01:24:38,600 --> 01:24:42,090
x și y sunt legate unele de altele,

1373
01:24:42,090 --> 01:24:44,780
și acesta este doar stilistic mai corect, într-un sens,

1374
01:24:44,780 --> 01:24:46,600
deoarece este gruparea două lucruri pe aceeași linie

1375
01:24:46,600 --> 01:24:49,340
acest tip de ca se referă la același lucru.

1376
01:24:49,340 --> 01:24:51,440
Și am impartit doar aceste afară. E doar o chestie de stil.

1377
01:24:51,440 --> 01:24:53,720
Se face funcțional nici o diferență fel.

1378
01:24:58,150 --> 01:24:59,270
Orice alte întrebări cu privire struct?

1379
01:25:03,030 --> 01:25:06,620
Puteți defini un Pokedex cu o struct.

1380
01:25:06,620 --> 01:25:11,720
Un Pokemon are un număr și are o scrisoare, un proprietar, un tip.

1381
01:25:11,720 --> 01:25:16,990
Și apoi, dacă aveți o serie de Pokemon, puteți face un Pokedex, nu?

1382
01:25:16,990 --> 01:25:20,810
Bine, bine. Deci, întrebările pe struct. Acestea sunt legate de struct.

1383
01:25:20,810 --> 01:25:25,270
>> În cele din urmă, GDB. Ce înseamnă GDB lasa sa faci? Acesta vă permite să depanați programul tău.

1384
01:25:25,270 --> 01:25:27,650
Și dacă nu ați utilizat GDB, mi-ar recomanda uitam scurt

1385
01:25:27,650 --> 01:25:31,250
și doar trecând peste ceea ce este GDB, modul în care lucrați cu el, cum s-ar putea folosi,

1386
01:25:31,250 --> 01:25:32,900
și-l testeze pe un program.

1387
01:25:32,900 --> 01:25:37,400
Și deci ce GDB vă permite să faceți este permite pauză [neinteligibil] sus de program

1388
01:25:37,400 --> 01:25:38,920
și o linie de practică.

1389
01:25:38,920 --> 01:25:42,600
De exemplu, vreau să executare pauză la fel ca linia 3 din programul meu,

1390
01:25:42,600 --> 01:25:46,010
și în timp ce eu sunt la linia 3 Pot imprima toate valorile care sunt acolo.

1391
01:25:46,010 --> 01:25:49,710
Și astfel ceea ce numim ca oprindu-se într-o linie

1392
01:25:49,710 --> 01:25:52,350
noi numim acest lucru se pune un punct de control la acea linie

1393
01:25:52,350 --> 01:25:55,920
și apoi putem imprima variabilele de la nivel de stat a programului, la acel moment.

1394
01:25:55,920 --> 01:25:58,990
>> Ne putem apoi de acolo pas prin programul linie cu linie.

1395
01:25:58,990 --> 01:26:03,200
Și apoi ne putem uita la starea de stivă la momentul respectiv.

1396
01:26:03,200 --> 01:26:08,600
Și astfel, în scopul de a utiliza GDB, ceea ce facem noi este o numim zăngănit pe fișierul C,

1397
01:26:08,600 --> 01:26:11,290
dar trebuie să-l dați ggdb-pavilion.

1398
01:26:11,290 --> 01:26:15,850
Și odată ce am terminat cu asta vom rula doar gdb pe fișierul de ieșire rezultat.

1399
01:26:15,850 --> 01:26:18,810
Și astfel încât să obțineți unele masă ca de text de acest fel,

1400
01:26:18,810 --> 01:26:21,990
dar de fapt tot ce trebuie să faceți este să tastați în comenzile de la început.

1401
01:26:21,990 --> 01:26:24,250
Break principal pune un punct de control la principal.

1402
01:26:24,250 --> 01:26:28,470
Lista 400 enumeră linii de cod în jurul valorii de linia 400.

1403
01:26:28,470 --> 01:26:31,410
Și astfel, în acest caz, poti sa te uiti doar în jurul și să spună, oh,

1404
01:26:31,410 --> 01:26:34,360
Vreau să se stabilească un punct de întrerupere la linia 397, care este această linie,

1405
01:26:34,360 --> 01:26:37,170
și apoi programul rulează în această etapă și se va rupe.

1406
01:26:37,170 --> 01:26:41,120
O să pauză acolo, și puteți imprima, de exemplu, valoarea scăzută sau ridicată.

1407
01:26:41,120 --> 01:26:46,410
Și astfel, există o grămadă de comenzi ce trebuie să știți,

1408
01:26:46,410 --> 01:26:48,660
și această prezentare se va merge pe site-ul web,

1409
01:26:48,660 --> 01:26:54,000
așa că, dacă doriți doar pentru a face referire acestea sau ca le-a pus pe foi de cheat dvs., nu ezitați.

1410
01:26:54,000 --> 01:27:00,650
>> Mișto. Asta a fost Quiz comentariu 0, iar noi vom lipi în jurul valorii de, dacă aveți întrebări.

1411
01:27:00,650 --> 01:27:03,850
Bine.

1412
01:27:03,850 --> 01:27:09,030
>>  [Aplauze]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]