1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [Secțiunea 6] [mai confortabil]

2
00:00:01,000 --> 00:00:04,000
[Rob Bowden] [Universitatea Harvard]

3
00:00:04,000 --> 00:00:09,000
[Acest lucru este CS50.] [CS50.TV]

4
00:00:09,000 --> 00:00:11,000
>> Putem merge la sectiunea noastra de intrebari.

5
00:00:11,000 --> 00:00:17,000
I-am trimis URL-ul pentru spațiu înainte.

6
00:00:17,000 --> 00:00:22,000
Începutul secțiunii de întrebări spun-

7
00:00:22,000 --> 00:00:26,000
se pare că nu sunt în totalitate unsick-este o întrebare foarte ușor

8
00:00:26,000 --> 00:00:28,000
de doar ceea ce se Valgrind?

9
00:00:28,000 --> 00:00:30,000
Ce face Valgrind face?

10
00:00:30,000 --> 00:00:34,000
Oricine vrea să spun ce Valgrind face?

11
00:00:34,000 --> 00:00:36,000
[Student] Verificări de memorie scurgeri.

12
00:00:36,000 --> 00:00:41,000
Da, Valgrind este un verificator de memorie generală.

13
00:00:41,000 --> 00:00:44,000
Aceasta, în final, vă spune dacă ai pierderi de memorie,

14
00:00:44,000 --> 00:00:49,000
care este cea mai mare parte ceea ce-l utilizați pentru că, dacă doriți să

15
00:00:49,000 --> 00:00:54,000
face bine în set de probleme sau dacă doriți să

16
00:00:54,000 --> 00:00:59,000
ajunge pe bord mare, trebuie să aveți nici un fel de pierderi de memorie,

17
00:00:59,000 --> 00:01:01,000
și, în cazul în care aveți o scurgere de memorie care nu le puteți găsi,

18
00:01:01,000 --> 00:01:04,000
De asemenea, ține cont de faptul că de fiecare dată când deschideți un fișier

19
00:01:04,000 --> 00:01:07,000
și dacă nu-l închide, că este o scurgere de memorie.

20
00:01:07,000 --> 00:01:10,000
>> O mulțime de oameni sunt în căutarea pentru unele nod pe care ei nu sunt eliberându

21
00:01:10,000 --> 00:01:15,000
când, de fapt, acestea nu au aproape dicționarul în chiar primul pas.

22
00:01:15,000 --> 00:01:19,000
De asemenea, vă spune dacă aveți orice invalidă citește sau scrie,

23
00:01:19,000 --> 00:01:22,000
ceea ce înseamnă că, dacă ați încerca și să stabilească o valoare

24
00:01:22,000 --> 00:01:26,000
care e dincolo de sfârșitul heap și nu se întâmplă să vină seg

25
00:01:26,000 --> 00:01:30,000
dar Valgrind-l prinde, ca nu ar trebui să fie, de fapt scris acolo,

26
00:01:30,000 --> 00:01:33,000
și deci cu siguranta nu ar trebui să aibă oricare dintre cele fie.

27
00:01:33,000 --> 00:01:38,000
Cum să utilizați Valgrind?

28
00:01:38,000 --> 00:01:42,000
Cum să utilizați Valgrind?

29
00:01:42,000 --> 00:01:45,000
>> E o problemă generală de

30
00:01:45,000 --> 00:01:49,000
un fel de a rula si uita-te la ieșire.

31
00:01:49,000 --> 00:01:51,000
De ieșire este copleșitoare de multe ori.

32
00:01:51,000 --> 00:01:54,000
Există, de asemenea, în cazul în care erorile de distracție, dacă aveți ceva teribil de greșit

33
00:01:54,000 --> 00:01:59,000
se întâmplă într-o buclă, atunci se va spune în cele din urmă, "Calea erori prea multe.

34
00:01:59,000 --> 00:02:03,000
Am de gând să se oprească de numărare acum. "

35
00:02:03,000 --> 00:02:08,000
E practic de ieșire sub formă de text pe care trebuie să analizăm.

36
00:02:08,000 --> 00:02:13,000
În final, el vă va spune orice pierderi de memorie pe care le au,

37
00:02:13,000 --> 00:02:16,000
cât de multe blocuri, care poate fi folositoare, deoarece

38
00:02:16,000 --> 00:02:20,000
în cazul în care ea este una unfreed bloc, atunci este, de obicei, mai ușor de găsit

39
00:02:20,000 --> 00:02:23,000
peste 1.000 de blocuri unfreed.

40
00:02:23,000 --> 00:02:26,000
1000 blocuri unfreed, probabil, înseamnă că nu ești eliberându

41
00:02:26,000 --> 00:02:30,000
Lista de preturi dumneavoastră legate corespunzător sau ceva de genul.

42
00:02:30,000 --> 00:02:32,000
Asta e Valgrind.

43
00:02:32,000 --> 00:02:35,000
>> Acum avem sectiunea noastra de intrebari,

44
00:02:35,000 --> 00:02:38,000
care nu aveți nevoie pentru a descărca.

45
00:02:38,000 --> 00:02:41,000
Aveți posibilitatea să faceți clic pe numele meu și trageți-le în sus în spațiu.

46
00:02:41,000 --> 00:02:44,000
Acum, faceți clic pe mine.

47
00:02:44,000 --> 00:02:46,000
Revizia 1 va fi stivă, pe care facem primul.

48
00:02:46,000 --> 00:02:55,000
Revizia 2 va fi coadă, și Revizie 3 va fi legat lista individual.

49
00:02:55,000 --> 00:02:58,000
Incepand off cu stack nostru.

50
00:02:58,000 --> 00:03:02,000
Așa cum se spune aici, un teanc este una dintre cele mai de bază,

51
00:03:02,000 --> 00:03:07,000
structuri de date fundamentale ale informaticii.

52
00:03:07,000 --> 00:03:11,000
Exemplu foarte prototipic este

53
00:03:11,000 --> 00:03:13,000
stiva de tăvi în sala de mese.

54
00:03:13,000 --> 00:03:16,000
E practic ori de câte ori sunt introduse într-o stivă,

55
00:03:16,000 --> 00:03:20,000
cineva va spune, "Oh, ca un teanc de tăvi."

56
00:03:20,000 --> 00:03:22,000
Tu stivă tăvile în sus.

57
00:03:22,000 --> 00:03:24,000
Apoi, când te duci pentru a trage o tavă,

58
00:03:24,000 --> 00:03:31,000
tava primul care a tras este obtinerea ultima care a fost pus pe stiva.

59
00:03:31,000 --> 00:03:34,000
Stivă, de asemenea, ca-l spune aici-

60
00:03:34,000 --> 00:03:37,000
avem segmentul de memorie numită stivă.

61
00:03:37,000 --> 00:03:40,000
Și de ce este numit stiva?

62
00:03:40,000 --> 00:03:42,000
>> Pentru că la fel ca o stivă structura de date,

63
00:03:42,000 --> 00:03:46,000
l împinge și apare cadre coșul de fum pe stivă,

64
00:03:46,000 --> 00:03:53,000
în cazul în care cadrele stack sunt ca un apel specific al unei funcții.

65
00:03:53,000 --> 00:03:57,000
Și ca o stivă, veți avea întotdeauna să se întoarcă

66
00:03:57,000 --> 00:04:03,000
de la un apel de funcție înainte de a putea ajunge în jos, în cadre stack mai mici din nou.

67
00:04:03,000 --> 00:04:08,000
Nu puteți avea principal de bara de apel foo apel și a reveni la bar direct principal.

68
00:04:08,000 --> 00:04:14,000
Este întotdeauna trebuie să urmeze stiva corect împingându-și popping.

69
00:04:14,000 --> 00:04:18,000
Cele două operațiuni, cum am spus, sunt de împingere și pop.

70
00:04:18,000 --> 00:04:20,000
Acestea sunt termeni universale.

71
00:04:20,000 --> 00:04:26,000
Tu ar trebui să știi PUSH și POP, în ceea ce privește stive indiferent ce.

72
00:04:26,000 --> 00:04:28,000
Vom vedea cozile sunt un fel de diferite.

73
00:04:28,000 --> 00:04:32,000
Ea nu are într-adevăr un termen universal, dar PUSH și POP sunt universale pentru stack-uri.

74
00:04:32,000 --> 00:04:34,000
Push este doar pus pe stiva.

75
00:04:34,000 --> 00:04:37,000
Pop este scoate stivă.

76
00:04:37,000 --> 00:04:43,000
Și vom vedea aici, avem topul nostru typedef struct,

77
00:04:43,000 --> 00:04:46,000
așa că avem siruri de caractere char **.

78
00:04:46,000 --> 00:04:51,000
Nu te sperie de orice **.

79
00:04:51,000 --> 00:04:54,000
Acest lucru se va sfârși prin a fi o serie de siruri de caractere

80
00:04:54,000 --> 00:04:58,000
sau o matrice de pointeri la caractere, în cazul în care

81
00:04:58,000 --> 00:05:00,000
pointeri la caractere tind să fie siruri de caractere.

82
00:05:00,000 --> 00:05:05,000
Aceasta nu trebuie sa fie siruri de caractere, dar aici, ei vor fi siruri de caractere.

83
00:05:05,000 --> 00:05:08,000
>> Avem o serie de siruri de caractere.

84
00:05:08,000 --> 00:05:14,000
Avem o dimensiune, care reprezintă câte elemente sunt în prezent în stivă,

85
00:05:14,000 --> 00:05:19,000
și apoi avem capacitatea, care este cât de multe elemente poate fi pe stiva.

86
00:05:19,000 --> 00:05:22,000
Capacitatea ar trebui să înceapă off ca ceva mai mare decât 1,

87
00:05:22,000 --> 00:05:27,000
dar dimensiunea este de gând să încep cu 0.

88
00:05:27,000 --> 00:05:36,000
Acum, există, în principiu trei moduri diferite de care vă puteți gândi o stivă.

89
00:05:36,000 --> 00:05:39,000
Ei bine, există probabil mai multe, dar cele două modalități principale sunt

90
00:05:39,000 --> 00:05:43,000
puteți să-l pună în aplicare cu ajutorul unei matrice, sau puteți să-l pună în aplicare folosind o listă de legate.

91
00:05:43,000 --> 00:05:48,000
Lista de preturi legate sunt un fel de banale pentru a face stive de la.

92
00:05:48,000 --> 00:05:51,000
Este foarte ușor de a face un stack folosind liste legate,

93
00:05:51,000 --> 00:05:55,000
Deci, aici, vom face o stivă folosind tablouri,

94
00:05:55,000 --> 00:05:59,000
si apoi folosind tablouri, există, de asemenea, două moduri în care se poate gândi despre asta.

95
00:05:59,000 --> 00:06:01,000
Înainte, când am spus că avem o capacitate de stivă,

96
00:06:01,000 --> 00:06:04,000
astfel încât să putem potrivi un element pe stivă.

97
00:06:04,000 --> 00:06:09,000
>> Fel se-ar putea întâmpla este la fel de îndată ce te-a lovit 10 elemente, atunci ați terminat.

98
00:06:09,000 --> 00:06:13,000
S-ar putea ști că există o limită superioară de 10 lucruri din lume

99
00:06:13,000 --> 00:06:16,000
că nu vei avea mai mult de 10 lucruri pe stack-ul tău,

100
00:06:16,000 --> 00:06:20,000
caz în care puteți avea o limită superioară de mărimea stack-ul tău.

101
00:06:20,000 --> 00:06:23,000
Sau ai putea avea stack-ul trebuie nelimitat,

102
00:06:23,000 --> 00:06:27,000
dar dacă faci o matrice, ceea ce înseamnă că de fiecare dată te-a lovit 10 elemente,

103
00:06:27,000 --> 00:06:29,000
atunci ai de gând să trebuie să crească la 20 de elemente, și atunci când te-a lovit 20 de elemente,

104
00:06:29,000 --> 00:06:33,000
ai de gând să trebuie să crească la 30 de matrice dvs. de elemente sau 40 de elemente.

105
00:06:33,000 --> 00:06:37,000
Ai de gând să nevoie pentru a crește capacitatea, care este ceea ce am de gând să fac aici.

106
00:06:37,000 --> 00:06:40,000
De fiecare data cand vom ajunge la dimensiunea maximă a stivei noastre,

107
00:06:40,000 --> 00:06:46,000
când ne împinge altceva, ne-am de gând să nevoie pentru a crește capacitatea.

108
00:06:46,000 --> 00:06:50,000
Aici, ne-am împinge declarat ca împingere bool (char * str).

109
00:06:50,000 --> 00:06:54,000
Str. char * sir este ca suntem împingând pe stivă,

110
00:06:54,000 --> 00:06:58,000
și bool spune doar dacă am reușit sau nu.

111
00:06:58,000 --> 00:07:00,000
>> Cum putem eșua?

112
00:07:00,000 --> 00:07:04,000
Care este singura circumstanță pe care vă puteți gândi de

113
00:07:04,000 --> 00:07:07,000
în cazul în care am avea nevoie pentru a reveni fals?

114
00:07:07,000 --> 00:07:09,000
Da.

115
00:07:09,000 --> 00:07:12,000
[Student] Dacă e plin și suntem folosind o implementare mărginită.

116
00:07:12,000 --> 00:07:17,000
Da, așa cum ne definim-a răspuns el

117
00:07:17,000 --> 00:07:23,000
dacă e plin și suntem folosind o implementare mărginită.

118
00:07:23,000 --> 00:07:26,000
Apoi, vom reveni cu siguranta fals.

119
00:07:26,000 --> 00:07:31,000
De îndată ce ne-am lovit 10 lucruri pe care în matrice, nu putem potrivi 11, deci ne întoarcem fals.

120
00:07:31,000 --> 00:07:32,000
Ce se întâmplă dacă aceasta este nemarginita? Da.

121
00:07:32,000 --> 00:07:38,000
Dacă nu puteți extinde gama pentru un motiv oarecare.

122
00:07:38,000 --> 00:07:43,000
Da, deci memoria este o resursă limitată,

123
00:07:43,000 --> 00:07:51,000
și în cele din urmă, dacă păstrăm lucrurile împingând pe stiva de peste si peste, din nou,

124
00:07:51,000 --> 00:07:54,000
vom încerca să aloce o matrice mai mare pentru a se potrivi

125
00:07:54,000 --> 00:07:59,000
capacitate mai mare, și malloc sau orice ne utilizați este de gând să se întoarcă fals.

126
00:07:59,000 --> 00:08:02,000
Ei bine, malloc se va intoarce null.

127
00:08:02,000 --> 00:08:05,000
>> Amintiți-vă, de fiecare data cand suna vreodată malloc, ar trebui să fie de verificare pentru a vedea dacă acesta

128
00:08:05,000 --> 00:08:12,000
returnează null sau altceva, care este o deducere corectitudinea.

129
00:08:12,000 --> 00:08:17,000
Deoarece dorim să avem o stivă nelimitat,

130
00:08:17,000 --> 00:08:21,000
singurul caz vom fi returnarea fals este dacă vom încerca să

131
00:08:21,000 --> 00:08:26,000
creșterea capacității și malloc sau orice returneaza false.

132
00:08:26,000 --> 00:08:30,000
Apoi, pop nu ia argumente,

133
00:08:30,000 --> 00:08:37,000
și returnează șir care este pe partea de sus a stivei.

134
00:08:37,000 --> 00:08:41,000
Oricare ar fi fost cel mai recent împins pe stiva este ceea ce se întoarce pop,

135
00:08:41,000 --> 00:08:44,000
și-l elimină, de asemenea, că din stivă.

136
00:08:44,000 --> 00:08:50,000
Și observați că returnează null daca nu este nimic pe stiva.

137
00:08:50,000 --> 00:08:53,000
Este întotdeauna posibil ca stiva este gol.

138
00:08:53,000 --> 00:08:55,000
În Java, daca esti obisnuit cu asta, sau alte limbi,

139
00:08:55,000 --> 00:09:01,000
încercând să pop de la o stivă goală ar putea provoca o excepție sau ceva.

140
00:09:01,000 --> 00:09:09,000
>> Dar în C, nul este un fel de o mulțime de cazuri cum ne ocupăm de aceste probleme.

141
00:09:09,000 --> 00:09:13,000
Revenind nul este cum vom semnifica faptul că stiva era gol.

142
00:09:13,000 --> 00:09:16,000
Am furnizat un cod care va testa funcționalitatea stack-ului,

143
00:09:16,000 --> 00:09:19,000
punerea în aplicare a împinge și pop.

144
00:09:19,000 --> 00:09:23,000
Acest lucru nu va fi o mulțime de cod.

145
00:09:23,000 --> 00:09:40,000
Voi-de fapt, inainte de a face asta, aluzie, aluzie-

146
00:09:40,000 --> 00:09:44,000
în cazul în care nu ați văzut-o, malloc nu este singura funcție

147
00:09:44,000 --> 00:09:47,000
care alocă memorie pe heap pentru tine.

148
00:09:47,000 --> 00:09:51,000
Există o familie de funcții alloc.

149
00:09:51,000 --> 00:09:53,000
Primul este malloc, pe care ești obișnuit.

150
00:09:53,000 --> 00:09:56,000
Apoi, există calloc, care face același lucru ca și malloc,

151
00:09:56,000 --> 00:09:59,000
dar va zero, totul pentru tine.

152
00:09:59,000 --> 00:10:04,000
Dacă v-ați dorit vreodată pentru a seta totul la zero, după mallocing ceva

153
00:10:04,000 --> 00:10:06,000
ar fi trebuit sa folosit doar calloc în primul rând în loc de a scrie

154
00:10:06,000 --> 00:10:09,000
o buclă de la zero afară întregului bloc de memorie.

155
00:10:09,000 --> 00:10:15,000
>> Realloc este ca malloc si are o multime de cazuri speciale,

156
00:10:15,000 --> 00:10:19,000
dar în esență ceea ce face este realloc

157
00:10:19,000 --> 00:10:24,000
este nevoie de un pointer care au fost deja alocate.

158
00:10:24,000 --> 00:10:27,000
Realloc este funcția pe care doriți să fie atent la aici.

159
00:10:27,000 --> 00:10:31,000
Este nevoie de un pointer care au fost deja restituite de la malloc.

160
00:10:31,000 --> 00:10:35,000
Să spunem că ai solicita de la malloc un pointer de 10 octeți.

161
00:10:35,000 --> 00:10:38,000
Apoi, mai târziu îți dai seama că vrei 20 bytes,

162
00:10:38,000 --> 00:10:42,000
deci te sun realloc pe care indicatorul cu 20 de octeți,

163
00:10:42,000 --> 00:10:47,000
și realloc va copia în mod automat peste tot pentru tine.

164
00:10:47,000 --> 00:10:51,000
Dacă ați sunat doar malloc din nou, ca și cum am avea un bloc de 10 octeți.

165
00:10:51,000 --> 00:10:53,000
Acum am nevoie de un bloc de 20 de octeți,

166
00:10:53,000 --> 00:10:58,000
deci, dacă am malloc 20 bytes, atunci am să copiați manual peste 10 octeți de la primul lucru

167
00:10:58,000 --> 00:11:01,000
în al doilea lucru și apoi gratuit primul lucru.

168
00:11:01,000 --> 00:11:04,000
Realloc se va ocupa de asta pentru tine.

169
00:11:04,000 --> 00:11:11,000
>> Observați semnătura va fi void *,

170
00:11:11,000 --> 00:11:15,000
care se întoarce doar un pointer la blocul de memorie,

171
00:11:15,000 --> 00:11:17,000
apoi anulate * ptr.

172
00:11:17,000 --> 00:11:22,000
Vă puteți gândi la void * ca un pointer generic.

173
00:11:22,000 --> 00:11:27,000
În general, n-ai face cu void *,

174
00:11:27,000 --> 00:11:30,000
dar malloc se întoarce un void *, iar apoi este folosit doar ca

175
00:11:30,000 --> 00:11:34,000
acest lucru este, de fapt va fi un char *.

176
00:11:34,000 --> 00:11:37,000
* Nule anterior, care au fost returnate de către malloc

177
00:11:37,000 --> 00:11:41,000
este acum va fi trecut la realloc, și apoi mărimea

178
00:11:41,000 --> 00:11:49,000
este noul număr de octeți pe care doriți să le aloce, asa capacitatea de noua ta.

179
00:11:49,000 --> 00:11:57,000
Îți dau câteva minute, și fă-o în spațiul nostru.

180
00:11:57,000 --> 00:12:02,000
Începeți cu Revizia 1.

181
00:12:16,000 --> 00:12:21,000
Te voi opri după ce sperăm despre timp suficient pentru a pune în aplicare împingere,

182
00:12:21,000 --> 00:12:24,000
și apoi mă voi da o altă pauză pentru a face pop.

183
00:12:24,000 --> 00:12:27,000
Dar de fapt nu este acest cod de mult la toate.

184
00:12:27,000 --> 00:12:35,000
Codul este, probabil, cel mai chestii extinderea, extinderea capacității.

185
00:12:35,000 --> 00:12:39,000
Bine, nici o presiune pentru a fi complet făcut,

186
00:12:39,000 --> 00:12:47,000
dar atâta timp cât te simți ca și cum ești pe drumul cel bun, asta e bine.

187
00:12:47,000 --> 00:12:53,000
>> Are cineva orice cod se simt confortabil cu mine trăgând în sus?

188
00:12:53,000 --> 00:12:59,000
Da, voi face, dar nimeni nu are nici un cod pot trage în sus?

189
00:12:59,000 --> 00:13:05,000
Bine, poți începe, salvați-l, oricare ar fi ea?

190
00:13:05,000 --> 00:13:09,000
Mereu uit acel pas.

191
00:13:09,000 --> 00:13:15,000
Bine, se uită la apăsare,

192
00:13:15,000 --> 00:13:18,000
vrei să explice codul?

193
00:13:18,000 --> 00:13:24,000
[Student] În primul rând, am crescut marimea.

194
00:13:24,000 --> 00:13:28,000
Cred poate că ar trebui să aibă ca-oricum, am crescut marimea,

195
00:13:28,000 --> 00:13:31,000
și văd dacă e mai mică decât capacitatea.

196
00:13:31,000 --> 00:13:36,000
Și dacă e mai mică decât capacitatea, am adăuga la matrice pe care o avem deja.

197
00:13:36,000 --> 00:13:42,000
Și dacă nu e, am înmulțiți capacitatea de 2,

198
00:13:42,000 --> 00:13:50,000
și am realoca matrice siruri de la ceva, cu o dimensiune mai mare capacitate de acum.

199
00:13:50,000 --> 00:13:55,000
Și apoi, dacă aceasta nu reușește, eu spun de utilizator și a reveni fals,

200
00:13:55,000 --> 00:14:04,000
și, dacă e în regulă, apoi am pus șir în fața noului.

201
00:14:04,000 --> 00:14:07,000
>> [Rob B.] De asemenea, observați că am folosit un operator de frumos aici la nivel de bit

202
00:14:07,000 --> 00:14:09,000
să se înmulțească cu 2.

203
00:14:09,000 --> 00:14:11,000
Amintiți-vă, deviere la stânga este întotdeauna o să fie înmulțită cu 2.

204
00:14:11,000 --> 00:14:15,000
Shift dreapta este împărțit la 2, atâta timp cât vă amintiți că acesta înseamnă

205
00:14:15,000 --> 00:14:18,000
diviza de 2 ca într-un întreg împărțit la 2.

206
00:14:18,000 --> 00:14:20,000
S-ar putea trunchia un 1 aici sau acolo.

207
00:14:20,000 --> 00:14:26,000
Dar, schimbare lăsată de 1 este întotdeauna o să fie înmulțit cu 2,

208
00:14:26,000 --> 00:14:32,000
dacă nu se reverse în limitele întreg, și atunci nu va fi.

209
00:14:32,000 --> 00:14:34,000
Un comentariu parte.

210
00:14:34,000 --> 00:14:39,000
Îmi place să fac, acest lucru nu se va schimba de codificare nici un fel,

211
00:14:39,000 --> 00:14:48,000
dar îmi place să fac ceva de genul asta.

212
00:14:48,000 --> 00:14:51,000
Este de fapt este de gând să facă ceva mai lung.

213
00:15:04,000 --> 00:15:08,000
Poate că acest lucru nu este cazul perfect pentru a arăta acest lucru,

214
00:15:08,000 --> 00:15:14,000
dar îmi place să-l în segmentul de aceste blocuri de-

215
00:15:14,000 --> 00:15:17,000
regulă, în cazul în care acest lucru se întâmplă în cazul în care, apoi am de gând să fac ceva,

216
00:15:17,000 --> 00:15:19,000
și apoi funcția se face.

217
00:15:19,000 --> 00:15:22,000
Nu am nevoie să defilați, apoi ochii mei tot drumul în jos funcția

218
00:15:22,000 --> 00:15:25,000
pentru a vedea ce se întâmplă după altceva.

219
00:15:25,000 --> 00:15:27,000
E în cazul în care acest lucru se întâmplă în cazul în care, atunci mă întorc pur și simplu.

220
00:15:27,000 --> 00:15:30,000
Ea are, de asemenea, avantajul frumos adăugată de tot dincolo de acest

221
00:15:30,000 --> 00:15:33,000
este acum mutat părăsit o dată.

222
00:15:33,000 --> 00:15:40,000
Nu mai am nevoie să-dacă vreodată în apropierea liniilor de ridicol de lungi,

223
00:15:40,000 --> 00:15:45,000
atunci acele 4 octeți poate ajuta, de asemenea, și ceva mai mult stânga este,

224
00:15:45,000 --> 00:15:48,000
mai puțin copleșit-ai simți dacă doriți-bine, am să-mi amintesc

225
00:15:48,000 --> 00:15:53,000
Eu sunt în prezent într-o buclă în timp ce în interiorul unui alt interior de o bucla for.

226
00:15:53,000 --> 00:15:58,000
Oriunde puteți face acest lucru imediat întoarcere, am facut un fel de ca.

227
00:15:58,000 --> 00:16:05,000
E complet opțional și nu este de așteptat în nici un fel.

228
00:16:05,000 --> 00:16:12,000
>> [Student] Ar trebui să existe o dimensiune - în stare eșuează?

229
00:16:12,000 --> 00:16:19,000
Stare de respingere este aici nu am reușit să realloc, asa da.

230
00:16:19,000 --> 00:16:22,000
Observați cum în stare eșuează, probabil,

231
00:16:22,000 --> 00:16:26,000
dacă nu vom chestii gratuit mai târziu, suntem mereu de gând să eșueze

232
00:16:26,000 --> 00:16:29,000
indiferent de câte ori vom încerca să împingă ceva.

233
00:16:29,000 --> 00:16:32,000
Dacă ținem împingerea, ne păstrăm dimensiunea incrementare,

234
00:16:32,000 --> 00:16:36,000
chiar dacă noi nu se pune nimic pe stiva.

235
00:16:36,000 --> 00:16:39,000
De obicei, noi nu incrementați dimensiunea până la

236
00:16:39,000 --> 00:16:43,000
după ce ne-am pus cu succes pe stivă.

237
00:16:43,000 --> 00:16:50,000
Ne-ar face, să zicem, fie aici și aici.

238
00:16:50,000 --> 00:16:56,000
Și atunci în loc de a spune s.size ≤ capacitate, e mai puțin decât capacitatea,

239
00:16:56,000 --> 00:17:01,000
doar pentru că ne-am mutat în cazul în care totul a fost.

240
00:17:01,000 --> 00:17:07,000
>> Și ține minte, singurul loc care ne-ar putea reveni, eventual, fals

241
00:17:07,000 --> 00:17:14,000
este aici, în cazul în care realloc întors nul,

242
00:17:14,000 --> 00:17:19,000
și dacă se întâmplă să vă amintiți eroarea standard,

243
00:17:19,000 --> 00:17:22,000
Poate că s-ar putea lua în considerare acest caz o în cazul în care doriți să imprimați o eroare standard,

244
00:17:22,000 --> 00:17:26,000
stderr, astfel fprintf în loc de doar imprimarea direct în standard.

245
00:17:26,000 --> 00:17:31,000
Din nou, asta nu e o așteptare, dar dacă e vreo eroare,

246
00:17:31,000 --> 00:17:41,000
tastați printf, atunci este posibil să doriți să-l imprimați să eroarea standard în loc de afară standard.

247
00:17:41,000 --> 00:17:44,000
>> Oricine are ceva de remarcat? Da.

248
00:17:44,000 --> 00:17:47,000
[Student] Poti sa te duci peste [neauzit]?

249
00:17:47,000 --> 00:17:55,000
[Rob B.] Da, binariness reală de ea sau pur și simplu ceea ce este?

250
00:17:55,000 --> 00:17:57,000
[Student] Deci ai înmulți cu 2?

251
00:17:57,000 --> 00:17:59,000
[Rob B.] Da, de fapt.

252
00:17:59,000 --> 00:18:11,000
În țara binar, avem întotdeauna setul nostru de cifre.

253
00:18:11,000 --> 00:18:22,000
Deplasarea acest stânga până la 1 Practic introduce aici, la dreapta.

254
00:18:22,000 --> 00:18:25,000
Înapoi la acest lucru, amintindu-doar că totul în binar

255
00:18:25,000 --> 00:18:28,000
este o putere a lui 2, astfel încât aceasta reprezintă 2 la 0,

256
00:18:28,000 --> 00:18:30,000
2 la acest 1, 2 la această 2.

257
00:18:30,000 --> 00:18:33,000
Prin introducerea unei 0 la dreapta acum, trecem totul peste.

258
00:18:33,000 --> 00:18:38,000
Ceea ce folosit pentru a fi de 2 la 0 este acum 2 la 1, este 2 la 2.

259
00:18:38,000 --> 00:18:41,000
Partea dreaptă pe care am inserat

260
00:18:41,000 --> 00:18:44,000
este în mod necesar va fi 0,

261
00:18:44,000 --> 00:18:46,000
ceea ce face sens.

262
00:18:46,000 --> 00:18:49,000
Dacă ați înmulțiți vreodată un număr de 2, aceasta nu se va termina ciudat,

263
00:18:49,000 --> 00:18:54,000
astfel încât 2 la locul de 0 ar trebui să fie 0,

264
00:18:54,000 --> 00:18:59,000
și acest lucru este ceea ce am avertizat despre jumătate înainte de a se dacă nu se întâmplă să schimbe

265
00:18:59,000 --> 00:19:01,000
dincolo de numărul de biți într-un număr întreg,

266
00:19:01,000 --> 00:19:04,000
atunci acest 1 se va termina prin a merge off.

267
00:19:04,000 --> 00:19:10,000
Asta e doar vă faceți griji dacă se întâmplă să fie într-adevăr de-a face cu capacități mari.

268
00:19:10,000 --> 00:19:15,000
Dar, la acel moment, atunci ai de-a face cu o serie de miliarde de lucruri,

269
00:19:15,000 --> 00:19:25,000
care nu s-ar potrivi în memorie, oricum.

270
00:19:25,000 --> 00:19:31,000
>> Acum putem ajunge la pop, care este chiar mai ușor.

271
00:19:31,000 --> 00:19:36,000
Ai putea-ți place, dacă se întâmplă să pop o grămadă,

272
00:19:36,000 --> 00:19:38,000
și acum ești la jumătate de capacitate din nou.

273
00:19:38,000 --> 00:19:42,000
Ai putea realloc pentru a micsora cantitatea de memorie aveți,

274
00:19:42,000 --> 00:19:47,000
dar nu trebuie să vă faceți griji cu privire la faptul că, așa cazul realloc doar va fi

275
00:19:47,000 --> 00:19:50,000
în creștere de memorie, nu în scădere de memorie,

276
00:19:50,000 --> 00:19:59,000
care se va face super-pop usoara.

277
00:19:59,000 --> 00:20:02,000
Acum cozi, care urmează să fie ca stive,

278
00:20:02,000 --> 00:20:06,000
dar ordinea în care luați lucrurile se inversează.

279
00:20:06,000 --> 00:20:10,000
Exemplu prototipic al unei cozi este o linie,

280
00:20:10,000 --> 00:20:12,000
deci cred ca daca ai fi limba engleză, mi-ar fi spus

281
00:20:12,000 --> 00:20:17,000
un exemplu prototipic al unei cozi este o listă de așteptare.

282
00:20:17,000 --> 00:20:22,000
Deci, ca o linie, daca esti prima persoana în linie,

283
00:20:22,000 --> 00:20:24,000
vă așteptați să fie prima persoană din linie.

284
00:20:24,000 --> 00:20:31,000
Dacă ești ultima persoană în linie, aveți de gând să fie ultima persoană de service.

285
00:20:31,000 --> 00:20:35,000
Noi numim acel model FIFO, LIFO întrucât stiva a fost model.

286
00:20:35,000 --> 00:20:40,000
Aceste cuvinte sunt destul de universale.

287
00:20:40,000 --> 00:20:46,000
>> Ca stive și, spre deosebire de tablouri, cozile de obicei, nu permit accesul la elemente în mijloc.

288
00:20:46,000 --> 00:20:50,000
Aici, o stivă, avem de împingere și pop.

289
00:20:50,000 --> 00:20:54,000
Aici, se întâmplă să am numit-le Puneți în coadă și dequeue.

290
00:20:54,000 --> 00:20:58,000
De asemenea, am auzit i-a chemat schimbare și unshift.

291
00:20:58,000 --> 00:21:02,000
Am auzit oameni spun PUSH și POP să se aplice, de asemenea, la cozi.

292
00:21:02,000 --> 00:21:05,000
Am auzit insera, elimina,

293
00:21:05,000 --> 00:21:11,000
astfel PUSH și POP, dacă este vorba despre stive, sunteți împingându-și popping.

294
00:21:11,000 --> 00:21:16,000
Dacă vorbești despre cozile, ai putea alege cuvintele pe care doriți să le utilizați

295
00:21:16,000 --> 00:21:23,000
pentru introducerea și îndepărtarea, și nu există un consens asupra a ceea ce ar trebui să fie numit.

296
00:21:23,000 --> 00:21:27,000
Dar aici, avem Puneți în coadă și dequeue.

297
00:21:27,000 --> 00:21:37,000
Acum, struct arata aproape identic cu struct stiva.

298
00:21:37,000 --> 00:21:40,000
Dar noi trebuie să țină evidența cap.

299
00:21:40,000 --> 00:21:44,000
Cred că se spune aici, dar de ce avem nevoie de cap?

300
00:21:53,000 --> 00:21:57,000
Prototipurile sunt, practic, identice pentru a împinge și pop.

301
00:21:57,000 --> 00:21:59,000
Vă puteți gândi la ea ca PUSH și POP.

302
00:21:59,000 --> 00:22:08,000
Singura diferență este pop se întoarce în loc de-trecut, se întoarce prima.

303
00:22:08,000 --> 00:22:12,000
2, 1, 3, 4, sau ceva de genul.

304
00:22:12,000 --> 00:22:14,000
Și aici e începutul.

305
00:22:14,000 --> 00:22:17,000
Coada noastra este complet plin, asa ca nu e patru elemente în ea.

306
00:22:17,000 --> 00:22:21,000
Sfârșitul coada noastră este în prezent 2,

307
00:22:21,000 --> 00:22:24,000
iar acum mergem pentru a introduce altceva.

308
00:22:24,000 --> 00:22:29,000
>> Când vrem să inserați acel altceva, ceea ce am făcut pentru versiunea stivei

309
00:22:29,000 --> 00:22:36,000
ne-am extins este blocul nostru de memorie.

310
00:22:36,000 --> 00:22:40,000
Care este problema cu asta?

311
00:22:40,000 --> 00:22:45,000
[Student] Vă mutați 2.

312
00:22:45,000 --> 00:22:51,000
Ceea ce am spus mai devreme despre sfârșitul cozii de așteptare,

313
00:22:51,000 --> 00:22:57,000
acest lucru nu are sens să începem la 1,

314
00:22:57,000 --> 00:23:01,000
Apoi vrem să dequeue 1, apoi dequeue 3, apoi dequeue 4,

315
00:23:01,000 --> 00:23:05,000
apoi dequeue 2, dequeue atunci aceasta.

316
00:23:05,000 --> 00:23:08,000
Noi nu putem folosi realloc acum,

317
00:23:08,000 --> 00:23:11,000
sau cel puțin foarte, va trebui să utilizați realloc într-un mod diferit.

318
00:23:11,000 --> 00:23:15,000
Dar tu, probabil, nu ar trebui să folosească doar realloc.

319
00:23:15,000 --> 00:23:18,000
Ai de gând să aibă de a copia manual de memorie.

320
00:23:18,000 --> 00:23:21,000
>> Există două funcții de memorie pentru a copia.

321
00:23:21,000 --> 00:23:25,000
Nu e memcopy și memmove.

322
00:23:25,000 --> 00:23:29,000
Citesc în prezent, paginile man pentru a vedea care dintre ai de gând să doriți să o utilizați.

323
00:23:29,000 --> 00:23:35,000
Bine, memcopy, diferența este

324
00:23:35,000 --> 00:23:38,000
că memcopy și memmove, o tratează în mod corect cazul

325
00:23:38,000 --> 00:23:41,000
în cazul în care sunteți copierea într-o regiune care se întâmplă să se suprapună regiune

326
00:23:41,000 --> 00:23:46,000
te de la copierea.

327
00:23:46,000 --> 00:23:50,000
Memcopy nu-l ocupe. Memmove face.

328
00:23:50,000 --> 00:23:59,000
Vă puteți gândi la problema ca-

329
00:23:59,000 --> 00:24:09,000
Să zicem că vreau să copiați acest tip,

330
00:24:09,000 --> 00:24:13,000
aceste patru la acest tip de peste.

331
00:24:13,000 --> 00:24:16,000
În cele din urmă, ceea ce ar trebui să arate ca matricea

332
00:24:16,000 --> 00:24:26,000
după copiere este 2, 1, 2, 1, 3, 4, iar apoi unele chestii la sfârșitul anului.

333
00:24:26,000 --> 00:24:29,000
Dar acest lucru depinde de ordinea în care le copia, de fapt,

334
00:24:29,000 --> 00:24:32,000
deoarece, dacă nu considerăm faptul că regiunea suntem copierea în

335
00:24:32,000 --> 00:24:35,000
suprapune o suntem copiere de la,

336
00:24:35,000 --> 00:24:46,000
atunci am putea face ca început aici, copiați 2 în locul vrem să mergem,

337
00:24:46,000 --> 00:24:52,000
apoi mutați indicii noastre înainte.

338
00:24:52,000 --> 00:24:56,000
>> Acum vom fi aici și aici, și acum vrem să copiați

339
00:24:56,000 --> 00:25:04,000
acest tip de peste tipul ăsta și pentru a muta pointeri noastre mai departe.

340
00:25:04,000 --> 00:25:07,000
Ceea ce am de gând să sfârșesc prin obtinerea este de 2, 1, 2, 1, 2, 1

341
00:25:07,000 --> 00:25:10,000
în loc de caz 2, 1, 2, 1, 3, 4, deoarece

342
00:25:10,000 --> 00:25:15,000
2, 1 anulate originalul 3, 4.

343
00:25:15,000 --> 00:25:19,000
Memmove se ocupă de asta în mod corect.

344
00:25:19,000 --> 00:25:23,000
În acest caz, practic doar folosiți întotdeauna memmove

345
00:25:23,000 --> 00:25:26,000
pentru că se ocupă în mod corect.

346
00:25:26,000 --> 00:25:29,000
În general nu efectua orice rău.

347
00:25:29,000 --> 00:25:32,000
Ideea este loc de a porni de la început și copiere în acest fel

348
00:25:32,000 --> 00:25:35,000
așa cum am făcut aici, se pornește de la capăt și copiaza in,

349
00:25:35,000 --> 00:25:38,000
și, în acest caz, nu poți avea o problemă.

350
00:25:38,000 --> 00:25:40,000
Nu este nici o performanță pierdut.

351
00:25:40,000 --> 00:25:47,000
Folosiți întotdeauna memmove. Nu vă faceți griji cu privire la memcopy.

352
00:25:47,000 --> 00:25:51,000
Și asta e în cazul în care ai de gând să aibă de a memmove separat

353
00:25:51,000 --> 00:26:01,000
porțiunea înfășurat în jurul valorii de-a lista de așteptare.

354
00:26:01,000 --> 00:26:04,000
Nu vă faceți griji dacă nu este complet terminat.

355
00:26:04,000 --> 00:26:10,000
Acest lucru este mult mai dificil decât stivă, împinge, și pop.

356
00:26:10,000 --> 00:26:15,000
>> Oricine are orice cod am putea lucra cu?

357
00:26:15,000 --> 00:26:21,000
Chiar dacă complet incomplet?

358
00:26:21,000 --> 00:26:23,000
[Student] Da, e complet incomplet, totuși.

359
00:26:23,000 --> 00:26:27,000
Complet incompletă este bine, atâta timp cât ne-nu te poate salva de revizuire?

360
00:26:27,000 --> 00:26:32,000
Am uitat că de fiecare dată singur.

361
00:26:32,000 --> 00:26:39,000
Bine, ignorând ceea ce se întâmplă atunci când avem nevoie pentru a redimensiona lucrurile.

362
00:26:39,000 --> 00:26:42,000
Ignora complet redimensionare.

363
00:26:42,000 --> 00:26:49,000
Explică acest cod.

364
00:26:49,000 --> 00:26:54,000
Mă verificare în primul rând, dacă dimensiunea este mai mică decât prima copie a tuturor

365
00:26:54,000 --> 00:27:01,000
și apoi după aceea, am insera-am lua capul + dimensiune,

366
00:27:01,000 --> 00:27:05,000
și am asigurați-vă că se încadrează în jurul valorii de capacitatea de matrice,

367
00:27:05,000 --> 00:27:08,000
și am insera șir nou în această poziție.

368
00:27:08,000 --> 00:27:12,000
Apoi am crește dimensiunea și să se întoarcă adevărat.

369
00:27:12,000 --> 00:27:22,000
>> [Rob B.] Acest lucru este cu siguranta una dintre acele cazuri în care ai de gând să doriți să fie folosind Mod.

370
00:27:22,000 --> 00:27:25,000
Orice fel de caz unde ați ambalaj în jurul valorii de, dacă crezi în jurul valorii de ambalaj,

371
00:27:25,000 --> 00:27:29,000
gândul imediat ar trebui să fie Mod.

372
00:27:29,000 --> 00:27:36,000
Ca o optimizare rapida / a vă face o linie mai scurtă codul,

373
00:27:36,000 --> 00:27:42,000
observați că linia imediat după aceasta

374
00:27:42,000 --> 00:27:53,000
este doar marimea + +, astfel încât să îmbinați că în această linie, dimensiune + +.

375
00:27:53,000 --> 00:27:58,000
Acum aici, avem cazul

376
00:27:58,000 --> 00:28:01,000
în cazul în care nu avem suficientă memorie,

377
00:28:01,000 --> 00:28:05,000
așa că sunt în creștere capacitatea noastră de 2.

378
00:28:05,000 --> 00:28:09,000
Cred că ai putea avea aceeași problemă aici, dar o putem ignora acum,

379
00:28:09,000 --> 00:28:13,000
în cazul în care, dacă nu ați reușit să crească capacitatea dumneavoastră,

380
00:28:13,000 --> 00:28:18,000
atunci ai de gând să doriți să scadă capacitatea dvs. de 2 din nou.

381
00:28:18,000 --> 00:28:24,000
O altă notă scurtă este la fel ca poti sa faci + =,

382
00:28:24,000 --> 00:28:30,000
puteți face, de asemenea, << =.

383
00:28:30,000 --> 00:28:43,000
Aproape orice poate merge înainte egal, + =, | =, & =, << =.

384
00:28:43,000 --> 00:28:52,000
Char * bloc nou este noul nostru de memorie.

385
00:28:52,000 --> 00:28:55,000
Oh, aici.

386
00:28:55,000 --> 00:29:02,000
>> Ce cred oamenii despre tipul de blocul nostru nou de memorie?

387
00:29:02,000 --> 00:29:06,000
[Student] ar trebui să fie char **.

388
00:29:06,000 --> 00:29:12,000
Gândindu-mă la struct noastră până aici,

389
00:29:12,000 --> 00:29:14,000
siruri de caractere este ceea ce suntem realocare.

390
00:29:14,000 --> 00:29:21,000
Facem un întreg nou de stocare dinamic pentru elementele din coada de așteptare.

391
00:29:21,000 --> 00:29:25,000
Ceea ce am de gând să fie atribuirea siruri de caractere dvs. este ceea ce noi te mallocing acum,

392
00:29:25,000 --> 00:29:30,000
și atât de nou va fi un char **.

393
00:29:30,000 --> 00:29:34,000
O să fie o matrice de siruri de caractere.

394
00:29:34,000 --> 00:29:38,000
Atunci ceea ce este cazul în care ne vom întoarce false?

395
00:29:38,000 --> 00:29:41,000
[Student] ar trebui să facem char *?

396
00:29:41,000 --> 00:29:44,000
[Rob B.] Da, apel bună.

397
00:29:44,000 --> 00:29:46,000
[Student] Ce-a fost asta?

398
00:29:46,000 --> 00:29:49,000
[Rob B.] Am vrut sa facem dimensiunea char *, deoarece nu mai suntem-

399
00:29:49,000 --> 00:29:53,000
aceasta ar fi de fapt o problemă foarte mare pentru că sizeof (char) ar fi de 1.

400
00:29:53,000 --> 00:29:55,000
Sizeof * char va fi 4,

401
00:29:55,000 --> 00:29:58,000
astfel încât de multe ori atunci când ai de a face cu Ints,

402
00:29:58,000 --> 00:30:01,000
aveți tendința să scape cu ea, deoarece mărimea și dimensiunea int * int

403
00:30:01,000 --> 00:30:04,000
pe un sistem pe 32 de biți vor fi același lucru.

404
00:30:04,000 --> 00:30:09,000
Dar aici, sizeof (char) si sizeof (char *) sunt acum de gând să fie același lucru.

405
00:30:09,000 --> 00:30:15,000
>> Care este împrejurarea în care ne întoarcem fals?

406
00:30:15,000 --> 00:30:17,000
[Student] Nou este nulă.

407
00:30:17,000 --> 00:30:23,000
Da, în cazul în care noul este nul, ne întoarcem fals,

408
00:30:23,000 --> 00:30:34,000
și am de gând să arunce aici-

409
00:30:34,000 --> 00:30:37,000
[Student] [neauzit]

410
00:30:37,000 --> 00:30:39,000
[Rob B.] Da, acest lucru este bine.

411
00:30:39,000 --> 00:30:46,000
Ai putea face, fie de 2 ori capacitatea de schimbare sau de capacitatea de 1 și apoi doar stabilit aici, sau orice altceva.

412
00:30:46,000 --> 00:30:52,000
Vom face așa cum l-am avut.

413
00:30:52,000 --> 00:30:56,000
Capacitatea >> = 1.

414
00:30:56,000 --> 00:31:08,000
Și nu sunteți niciodată de gând să trebuie să vă faceți griji cu privire la pierderea locului lui 1

415
00:31:08,000 --> 00:31:12,000
pentru că te-a părăsit decalate cu 1, deci locul lui 1 este în mod necesar un 0,

416
00:31:12,000 --> 00:31:16,000
astfel dreptul de deplasare de 1, sunteți încă de gând să fie bine.

417
00:31:16,000 --> 00:31:19,000
[Student] Ai nevoie să faci asta înainte de retur?

418
00:31:19,000 --> 00:31:29,000
[Rob B.] Da, acest lucru absolut nici un sens.

419
00:31:29,000 --> 00:31:36,000
>> Acum presupunem vom ajunge revenirea adevărat până la capăt.

420
00:31:36,000 --> 00:31:39,000
Modul în care ne vom face aceste memmoves,

421
00:31:39,000 --> 00:31:45,000
trebuie să fim atenți cu modul în care noi le facem.

422
00:31:45,000 --> 00:31:50,000
Are cineva orice sugestii despre cum le facem?

423
00:32:17,000 --> 00:32:21,000
Iată începutul nostru.

424
00:32:21,000 --> 00:32:28,000
În mod inevitabil, vrem să pornim de la început din nou

425
00:32:28,000 --> 00:32:35,000
și lucruri de copiere de acolo, în 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
Cum faci asta?

427
00:32:41,000 --> 00:32:52,000
În primul rând, trebuie să se uite la pagina de manual pentru memmove din nou.

428
00:32:52,000 --> 00:32:57,000
Memmove, ordinea de argumente este întotdeauna importantă.

429
00:32:57,000 --> 00:33:01,000
Ne dorim ca destinație primul, al doilea sursă, a treia dimensiune.

430
00:33:01,000 --> 00:33:06,000
Există o mulțime de funcții care inversare sursă și destinație.

431
00:33:06,000 --> 00:33:11,000
Destinație, sursă tinde să fie în concordanță oarecum.

432
00:33:17,000 --> 00:33:21,000
Mutare, pentru ce se întoarce?

433
00:33:21,000 --> 00:33:27,000
Aceasta returneaza un pointer la destinație, indiferent de motiv ați putea dori asta.

434
00:33:27,000 --> 00:33:32,000
Eu pot citi imaginea, dar vrem să se mute în destinația noastră.

435
00:33:32,000 --> 00:33:35,000
>> Ceea ce este destinația noastră va fi?

436
00:33:35,000 --> 00:33:37,000
[Student] Nou.

437
00:33:37,000 --> 00:33:39,000
[Rob B.] Da, și unde ne copierea de la?

438
00:33:39,000 --> 00:33:43,000
Primul lucru pe care se copiază este acest lucru 1, 3, 4.

439
00:33:43,000 --> 00:33:50,000
Ce este aceasta-1, 3, 4.

440
00:33:50,000 --> 00:33:55,000
Care este adresa acestei 1?

441
00:33:55,000 --> 00:33:58,000
Care este adresa pe care 1?

442
00:33:58,000 --> 00:34:01,000
[Student] [neauzit]

443
00:34:01,000 --> 00:34:03,000
[Rob B.] Meciuri + adresa primului element.

444
00:34:03,000 --> 00:34:05,000
Cum ajungem primul element din matrice?

445
00:34:05,000 --> 00:34:10,000
[Student] coadă.

446
00:34:10,000 --> 00:34:15,000
[Rob B.] Da, q.strings.

447
00:34:15,000 --> 00:34:20,000
Amintiți-vă, aici, capul nostru este 1.

448
00:34:20,000 --> 00:34:24,000
Darn-l. Cred că e magic-

449
00:34:24,000 --> 00:34:29,000
Aici, capul nostru este 1. Am de gând să schimbe culoarea mea.

450
00:34:29,000 --> 00:34:36,000
Și aici este siruri de caractere.

451
00:34:36,000 --> 00:34:41,000
Acest lucru, putem scrie, fie că așa cum am făcut aici

452
00:34:41,000 --> 00:34:43,000
cu capete + q.strings.

453
00:34:43,000 --> 00:34:51,000
O mulțime de oameni a scrie, de asemenea, IT & q.strings [cap].

454
00:34:51,000 --> 00:34:55,000
Acest lucru nu este adevărat nici mai puțin eficientă.

455
00:34:55,000 --> 00:34:58,000
S-ar putea gândi la ea ca dacă îl dereferencing si apoi obtinerea adresa,

456
00:34:58,000 --> 00:35:04,000
dar compilator este de gând să-l traduce ceea ce am avut înainte, oricum, q.strings + cap.

457
00:35:04,000 --> 00:35:06,000
Fie modul în care doriți să se gândească la asta.

458
00:35:06,000 --> 00:35:11,000
>> Și cum de multe bytes vrem să copiați?

459
00:35:11,000 --> 00:35:15,000
[Student] Capacitate - cap.

460
00:35:15,000 --> 00:35:18,000
Capacitate - cap.

461
00:35:18,000 --> 00:35:21,000
Și apoi ai putea scrie întotdeauna un exemplu

462
00:35:21,000 --> 00:35:23,000
să dau seama dacă e bine.

463
00:35:23,000 --> 00:35:26,000
[Student] Acesta trebuie să fie împărțit la 2, apoi.

464
00:35:26,000 --> 00:35:30,000
Da, așa cred am putea folosi dimensiunea.

465
00:35:30,000 --> 00:35:35,000
Avem încă dimensiunea fiind-

466
00:35:35,000 --> 00:35:39,000
folosind dimensiunea, avem dimensiune egală cu 4.

467
00:35:39,000 --> 00:35:42,000
Dimensiunea noastra este 4. Capul nostru este de 1.

468
00:35:42,000 --> 00:35:46,000
Dorim să copiați aceste 3 elemente.

469
00:35:46,000 --> 00:35:54,000
Asta e bun-simț verifica marimea - capul este corect 3.

470
00:35:54,000 --> 00:35:58,000
Și venind înapoi aici, așa cum am spus mai înainte,

471
00:35:58,000 --> 00:36:00,000
în cazul în care am folosit capacitatea, atunci vom avea de a diviza la 2

472
00:36:00,000 --> 00:36:04,000
pentru ca ne-am dezvoltat deja capacitatea noastră, astfel încât în ​​loc, vom folosi dimensiune.

473
00:36:11,000 --> 00:36:13,000
Că copii care porțiilor.

474
00:36:13,000 --> 00:36:18,000
Acum, avem nevoie pentru a copia cealaltă porțiune, partea care a mai rămas din start.

475
00:36:18,000 --> 00:36:28,000
>> Asta o să memmove în ce poziție?

476
00:36:28,000 --> 00:36:32,000
[Student] Dimensiune Plus - cap.

477
00:36:32,000 --> 00:36:38,000
Da, așa că am deja copiat in marime - octeți cap,

478
00:36:38,000 --> 00:36:43,000
și așa mai departe în cazul în care dorim să copiați bytes rămase este nou

479
00:36:43,000 --> 00:36:48,000
și apoi dimensiunea minus-bine, numărul de octeți care le-am copiat deja inch

480
00:36:48,000 --> 00:36:52,000
Si apoi de unde ne copierea de la?

481
00:36:52,000 --> 00:36:54,000
[Student] Q.strings [0].

482
00:36:54,000 --> 00:36:56,000
[Rob B.] Da, q.strings.

483
00:36:56,000 --> 00:37:02,000
Am putea face fie & q.strings [0].

484
00:37:02,000 --> 00:37:05,000
Acest lucru este semnificativ mai frecvente decât aceasta.

485
00:37:05,000 --> 00:37:14,000
Dacă este doar de gând să fie 0, atunci ai tendinta de a vedea q.strings.

486
00:37:14,000 --> 00:37:16,000
Asta e atunci când suntem la copierea.

487
00:37:16,000 --> 00:37:18,000
Câte bytes ne-au lăsat să copieze? >> [Elevului] 10.

488
00:37:18,000 --> 00:37:20,000
Corect.

489
00:37:20,000 --> 00:37:25,000
[Student] Nu trebuie să ne multiplica 5 - 10 ori mai mare de octeți sau ceva de genul?

490
00:37:25,000 --> 00:37:30,000
Da, deci acest lucru este în cazul în care-exact ceea ce ne copiere?

491
00:37:30,000 --> 00:37:32,000
[Student] [neauzit]

492
00:37:32,000 --> 00:37:34,000
Care este tipul de lucru pe care suntem copiere?

493
00:37:34,000 --> 00:37:36,000
[Student] [neauzit]

494
00:37:36,000 --> 00:37:41,000
Da, așa e char * ca suntem copierea, nu știm unde acestea sunt provin din.

495
00:37:41,000 --> 00:37:47,000
Ei bine, în cazul în care acestea sunt arătând spre, cum ar fi siruri de caractere, vom ajunge, împingându-l pe coadă

496
00:37:47,000 --> 00:37:49,000
sau enqueuing pe coada.

497
00:37:49,000 --> 00:37:51,000
În cazul în care acestea sunt provin din, nu avem nici o idee.

498
00:37:51,000 --> 00:37:56,000
Avem nevoie doar de a urmări * e char ei înșiși.

499
00:37:56,000 --> 00:38:00,000
Noi nu vrem să copiați dimensiunea - octeți cap.

500
00:38:00,000 --> 00:38:03,000
Dorim să copiați dimensiunea - cap char * s,

501
00:38:03,000 --> 00:38:11,000
deci vom multiplica acest lucru prin sizeof (char *).

502
00:38:11,000 --> 00:38:17,000
Same aici, cap de * sizeof (char *).

503
00:38:17,000 --> 00:38:24,000
>> [Student] Ce [neauzit]?

504
00:38:24,000 --> 00:38:26,000
Acest drept aici?

505
00:38:26,000 --> 00:38:28,000
[Student] Nu, mai jos, care, dimensiunea - cap.

506
00:38:28,000 --> 00:38:30,000
[Rob B.] Acest drept aici?

507
00:38:30,000 --> 00:38:32,000
Pointer aritmetică.

508
00:38:32,000 --> 00:38:35,000
Cum aritmetică indicatorul se va lucra este

509
00:38:35,000 --> 00:38:40,000
se multiplică în mod automat în funcție de mărimea tipul care am de-a face cu.

510
00:38:40,000 --> 00:38:46,000
La fel ca aici, noi + (dimensiune - cap)

511
00:38:46,000 --> 00:38:56,000
este exact echivalent cu & [size - cap] nou

512
00:38:56,000 --> 00:39:00,000
până când ne așteptăm ca să funcționeze corect,

513
00:39:00,000 --> 00:39:04,000
deoarece dacă avem de-a face cu o serie int, atunci nu ne facem indicele de int-

514
00:39:04,000 --> 00:39:07,000
sau în cazul în care este de dimensiunea de 5 și doriți elementul patra, apoi am indicele în

515
00:39:07,000 --> 00:39:10,000
int matrice [4].

516
00:39:10,000 --> 00:39:14,000
Ai tăcerea: nu-[4] Dimensiunea * de int.

517
00:39:14,000 --> 00:39:21,000
Că se ocupă în mod automat, și acest caz,

518
00:39:21,000 --> 00:39:29,000
este literalmente echivalent, astfel încât suportul sintaxa

519
00:39:29,000 --> 00:39:34,000
este doar de gând să fie convertite la acest lucru ca de îndată ce vă compilați.

520
00:39:34,000 --> 00:39:38,000
Asta e ceva ce trebuie să fie atent de faptul că

521
00:39:38,000 --> 00:39:42,000
atunci când sunt adăugați dimensiunea - cap

522
00:39:42,000 --> 00:39:45,000
adăugați nu un octet.

523
00:39:45,000 --> 00:39:53,000
Te adăugarea unei char *, care poate fi unul octeți sau orice altceva.

524
00:39:53,000 --> 00:39:56,000
>> Alte întrebări?

525
00:39:56,000 --> 00:40:04,000
Bine, dequeue va fi mai ușor.

526
00:40:04,000 --> 00:40:11,000
Îți dau un minut să pună în aplicare.

527
00:40:11,000 --> 00:40:18,000
Oh, și cred că acest lucru este în cazul în care aceeași situație

528
00:40:18,000 --> 00:40:21,000
ce caz Puneți în coadă, dacă suntem enqueuing nul,

529
00:40:21,000 --> 00:40:24,000
Poate că vrem să-l ocupe, poate că nu.

530
00:40:24,000 --> 00:40:27,000
Noi nu-l va face din nou aici, dar la fel ca stiva cazul nostru.

531
00:40:27,000 --> 00:40:34,000
Dacă ne redați nul, ne-am putea dori să-l ignore.

532
00:40:34,000 --> 00:40:40,000
Oricine are unele cod pot trage în sus?

533
00:40:40,000 --> 00:40:45,000
[Student] Am doar dequeue.

534
00:40:45,000 --> 00:40:56,000
Versiunea 2 este faptul că-în regulă.

535
00:40:56,000 --> 00:40:59,000
Vrei să explice?

536
00:40:59,000 --> 00:41:01,000
[Student] În primul rând, vă asigurați că nu e ceva în coada de așteptare

537
00:41:01,000 --> 00:41:07,000
și că dimensiunea este merge în jos de 1.

538
00:41:07,000 --> 00:41:11,000
Ai nevoie să faci asta, și apoi vă întoarceți capul

539
00:41:11,000 --> 00:41:13,000
și apoi mutați capul sus 1.

540
00:41:13,000 --> 00:41:19,000
Ok, deci nu este un caz colț trebuie să ia în considerare. Da.

541
00:41:19,000 --> 00:41:24,000
[Student] În cazul în care capul este la ultimul element,

542
00:41:24,000 --> 00:41:26,000
atunci nu vrei cap la punctul in afara de matrice.

543
00:41:26,000 --> 00:41:29,000
>> Da, deci imediat în calitate de șef ajunge la capatul gama noastră,

544
00:41:29,000 --> 00:41:35,000
când am dequeue, capul nostru ar trebui să fie modded inapoi la 0.

545
00:41:35,000 --> 00:41:40,000
Din păcate, nu putem face asta într-un singur pas.

546
00:41:40,000 --> 00:41:44,000
Cred că modul în care aș repara probabil că este

547
00:41:44,000 --> 00:41:52,000
acest lucru este mergi la a fi un char *, ceea ce ne revin,

548
00:41:52,000 --> 00:41:55,000
indiferent de numele tău este variabilă vrea să fie.

549
00:41:55,000 --> 00:42:02,000
Apoi ne-am dori sa modez cap de capacitatea noastră

550
00:42:02,000 --> 00:42:10,000
și a reveni apoi retras.

551
00:42:10,000 --> 00:42:14,000
O mulțime de oameni aici, s-ar putea do-

552
00:42:14,000 --> 00:42:19,000
acesta este cazul, veți avea văd oameni fac în cazul în cap

553
00:42:19,000 --> 00:42:29,000
este mai mare decât capacitatea, nu capul - capacitate.

554
00:42:29,000 --> 00:42:36,000
Și asta e doar de lucru în jurul valorii de ceea ce este MOD.

555
00:42:36,000 --> 00:42:41,000
Capacitatea de cap = mod este mult mai curat

556
00:42:41,000 --> 00:42:51,000
a unui ambalaj în jurul valorii de cap mai mare decât în ​​cazul în care capacitatea de cap - capacitate.

557
00:42:51,000 --> 00:42:56,000
>> Întrebări?

558
00:42:56,000 --> 00:43:02,000
Bine, ultimul lucru pe care l-am lăsat este lista noastră de legat.

559
00:43:02,000 --> 00:43:07,000
S-ar putea fi folosite la unele dintre comportament lista de legat, dacă ai făcut-o

560
00:43:07,000 --> 00:43:11,000
legat de preturi din tabele de dispersie, dacă ai făcut un tabel hash.

561
00:43:11,000 --> 00:43:15,000
Vă recomandăm cu tărie fac un tabel hash.

562
00:43:15,000 --> 00:43:17,000
Este posibil să fi făcut deja un trie,

563
00:43:17,000 --> 00:43:23,000
dar incearca sunt mult mai dificil.

564
00:43:23,000 --> 00:43:27,000
În teorie, sunt asimptotic mai bine.

565
00:43:27,000 --> 00:43:30,000
Dar uita-te doar la bord mare,

566
00:43:30,000 --> 00:43:35,000
și încearcă niciodată face mai bine, și le iau mai multa memorie.

567
00:43:35,000 --> 00:43:43,000
Totul despre Incearca sfârșește prin a fi mai rău pentru mai mult de lucru.

568
00:43:43,000 --> 00:43:49,000
E ceea ce soluție David Malan lui este întotdeauna

569
00:43:49,000 --> 00:43:56,000
este el mesaje întotdeauna soluția lui trie, și să vedem unde în prezent este.

570
00:43:56,000 --> 00:44:00,000
Ceea ce era sub, David J?

571
00:44:00,000 --> 00:44:06,000
E # 18, astfel că nu e teribil de rău,

572
00:44:06,000 --> 00:44:09,000
și că va fi una dintre cele mai bune încearcă vă puteți gândi

573
00:44:09,000 --> 00:44:17,000
sau unul din cele mai bune încearcă o trie.

574
00:44:17,000 --> 00:44:23,000
Nu este chiar soluția lui original?

575
00:44:23,000 --> 00:44:29,000
Mă simt ca soluții trie tind să fie mai mult în acest interval de utilizare RAM.

576
00:44:29,000 --> 00:44:33,000
>> Du-te la partea de sus foarte, și folosirea RAM este în cifre unice.

577
00:44:33,000 --> 00:44:36,000
Du-te jos spre partea de jos, și apoi începe să vedeți încearcă

578
00:44:36,000 --> 00:44:41,000
în cazul în care veți obține utilizarea RAM absolut masiv,

579
00:44:41,000 --> 00:44:45,000
și încearcă sunt mai dificil.

580
00:44:45,000 --> 00:44:53,000
Nu în întregime în valoare de ea, ci o experiență educațională în cazul în care ai făcut-o.

581
00:44:53,000 --> 00:44:56,000
Ultimul lucru este lista noastră de legat,

582
00:44:56,000 --> 00:45:04,000
și aceste trei lucruri, stive, cozi, și liste legate,

583
00:45:04,000 --> 00:45:09,000
orice lucru viitor mai faci în informatică

584
00:45:09,000 --> 00:45:12,000
se va presupune că avea familiaritate cu aceste lucruri.

585
00:45:12,000 --> 00:45:19,000
Acestea sunt doar atât de fundamentală pentru tot.

586
00:45:19,000 --> 00:45:25,000
>> Legat de preturi, iar aici am o listă individual legat va fi punerea în aplicare noastră.

587
00:45:25,000 --> 00:45:34,000
Ce înseamnă individual legată înseamnă, spre deosebire de două ori legat? Da.

588
00:45:34,000 --> 00:45:37,000
[Student] Se indică numai indicatorul următoare, mai degrabă decât de indicii,

589
00:45:37,000 --> 00:45:39,000
ca cel ce o precede și unul după ea.

590
00:45:39,000 --> 00:45:44,000
Da, astfel încât în ​​format de imagine, ce-am făcut?

591
00:45:44,000 --> 00:45:48,000
Am două lucruri. Am imagine și imagine.

592
00:45:48,000 --> 00:45:51,000
În formatul de imagine, liste de unu noastre legate,

593
00:45:51,000 --> 00:45:57,000
în mod inevitabil, avem un fel de pointer la capul listei noastre,

594
00:45:57,000 --> 00:46:02,000
și apoi, în cadrul listei noastre, avem doar pointeri,

595
00:46:02,000 --> 00:46:05,000
și poate că acest puncte de la zero.

596
00:46:05,000 --> 00:46:08,000
O să fie desenul tipic al unei liste individual legat.

597
00:46:08,000 --> 00:46:14,000
O listă dublu legat, poti sa te duci înapoi.

598
00:46:14,000 --> 00:46:19,000
Dacă îți dau orice nod în listă, atunci puteți obține în mod necesar la

599
00:46:19,000 --> 00:46:23,000
orice alt nod în listă în cazul în care este vorba de o listă de două ori legat.

600
00:46:23,000 --> 00:46:27,000
Dar dacă am să te nodul treilea listă și este o listă legată individual,

601
00:46:27,000 --> 00:46:30,000
nici o cale de ai vreodată de gând să ajungă în prima și a doua noduri.

602
00:46:30,000 --> 00:46:34,000
Și nu există beneficii și dezavantaje, și un o evidentă

603
00:46:34,000 --> 00:46:42,000
se va duce in sus dimensiune mai, și va trebui să urmăriți în cazul în care aceste lucruri sunt orientate acum.

604
00:46:42,000 --> 00:46:49,000
Dar ne pasă doar de separat legat.

605
00:46:49,000 --> 00:46:53,000
>> Câteva lucruri pe care le vom avea să pună în aplicare.

606
00:46:53,000 --> 00:47:00,000
Nodul typedef struct, int i: struct nod * următor; nod.

607
00:47:00,000 --> 00:47:09,000
Asta ar trebui să fie arse typedef în mințile voastre.

608
00:47:09,000 --> 00:47:14,000
Test 1 ar trebui dori dea un typedef unui nod listă legată,

609
00:47:14,000 --> 00:47:18,000
și ar trebui să fie în măsură să noteaza imediat că se

610
00:47:18,000 --> 00:47:22,000
fără să se mai gândească la asta.

611
00:47:22,000 --> 00:47:27,000
Cred că cateva intrebari, de ce avem nevoie de struct aici?

612
00:47:27,000 --> 00:47:32,000
De ce nu putem spune * nod?

613
00:47:32,000 --> 00:47:35,000
[Student] [neauzit]

614
00:47:35,000 --> 00:47:38,000
Da.

615
00:47:38,000 --> 00:47:44,000
Singurul lucru care definește un nod ca un lucru

616
00:47:44,000 --> 00:47:47,000
este typedef în sine.

617
00:47:47,000 --> 00:47:55,000
Dar, ca de la acest punct, atunci când suntem un fel de parsare prin intermediul acestei definiții nod struct,

618
00:47:55,000 --> 00:48:01,000
nu ne-am terminat typedef noastră încă, deci din moment typedef nu sa terminat,

619
00:48:01,000 --> 00:48:05,000
nod nu exista.

620
00:48:05,000 --> 00:48:12,000
Dar struct nod face, iar acest nod aici,

621
00:48:12,000 --> 00:48:14,000
acest lucru ar putea fi numit, de asemenea, nimic altceva.

622
00:48:14,000 --> 00:48:16,000
Acest lucru ar putea fi numit nr.

623
00:48:16,000 --> 00:48:19,000
Ar putea fi numit nod lista de legat.

624
00:48:19,000 --> 00:48:21,000
Ar putea fi numit nimic.

625
00:48:21,000 --> 00:48:26,000
Dar acest nod struct trebuie să fie numit același lucru ca și acest nod struct.

626
00:48:26,000 --> 00:48:29,000
Ceea ce voi numiti acest lucru trebuie să fie, de asemenea, aici,

627
00:48:29,000 --> 00:48:32,000
și, de asemenea, astfel încât răspunde al doilea punct de discuție

628
00:48:32,000 --> 00:48:37,000
care este motivul pentru-o de multe ori, când veți vedea struct și typedefs de struct,

629
00:48:37,000 --> 00:48:42,000
veți vedea struct anonime în cazul în care veți vedea doar typedef struct,

630
00:48:42,000 --> 00:48:47,000
punerea în aplicare a struct, dicționar, sau orice altceva.

631
00:48:47,000 --> 00:48:51,000
>> De ce aici avem nevoie să spunem nod?

632
00:48:51,000 --> 00:48:54,000
De ce nu poate fi o struct anonim?

633
00:48:54,000 --> 00:48:56,000
Este aproape același răspuns.

634
00:48:56,000 --> 00:48:58,000
[Student] Trebuie să se refere la acesta în struct.

635
00:48:58,000 --> 00:49:04,000
Da, în cadrul struct, trebuie să se refere la struct sine.

636
00:49:04,000 --> 00:49:10,000
Dacă nu dau struct un nume, dacă e un struct anonim, nu se poate referi la ea.

637
00:49:10,000 --> 00:49:17,000
Si nu in ultimul rand, acestea nu ar trebui să fie oarecum simplă,

638
00:49:17,000 --> 00:49:20,000
și acestea ar trebui să vă ajute să realizeze daca scrii asta în jos

639
00:49:20,000 --> 00:49:24,000
că faci ceva greșit dacă aceste felul de lucruri care nu fac sens.

640
00:49:24,000 --> 00:49:28,000
Nu în ultimul rând, de ce face acest lucru trebuie să fie struct nod *?

641
00:49:28,000 --> 00:49:34,000
De ce nu poate fi struct nod doar următoare?

642
00:49:34,000 --> 00:49:37,000
[Student] Pointer la struct următoare.

643
00:49:37,000 --> 00:49:39,000
Asta e inevitabil ceea ce ne dorim.

644
00:49:39,000 --> 00:49:42,000
De ce ar putea fi niciodată nod struct viitoare?

645
00:49:42,000 --> 00:49:50,000
De ce trebuie să fie struct nod * următor? Da.

646
00:49:50,000 --> 00:49:53,000
[Student] E ca o buclă infinită.

647
00:49:53,000 --> 00:49:55,000
Da.

648
00:49:55,000 --> 00:49:57,000
[Student], ar fi totul într-o singură.

649
00:49:57,000 --> 00:50:02,000
Da, doar că de modul în care ne-ar face dimensiunea sau ceva.

650
00:50:02,000 --> 00:50:08,000
Dimensiunea unei structuri este de fapt + sau - un tipar aici sau acolo.

651
00:50:08,000 --> 00:50:15,000
Este practic va fi suma dimensiunilor de lucruri în struct.

652
00:50:15,000 --> 00:50:18,000
Acest drept aici fără a schimba ceva, este dimensiunea va fi ușor.

653
00:50:18,000 --> 00:50:24,000
Mărimea nod struct va fi dimensiunea i mărimea + de viitor.

654
00:50:24,000 --> 00:50:27,000
Dimensiunea lui i va fi 4. Dimensiunea de lângă va fi 4.

655
00:50:27,000 --> 00:50:30,000
Mărimea nod struct va fi 8.

656
00:50:30,000 --> 00:50:34,000
Dacă nu avem *, de gândire de sizeof,

657
00:50:34,000 --> 00:50:37,000
apoi sizeof (i) va fi 4.

658
00:50:37,000 --> 00:50:43,000
Mărimea nod struct următoarea va fi dimensiunea i mărimea + struct nod de lângă

659
00:50:43,000 --> 00:50:46,000
Dimensiunea + de + i dimensiunea de nod struct următoare.

660
00:50:46,000 --> 00:50:55,000
Ar fi o recursivitate infinita de noduri.

661
00:50:55,000 --> 00:51:00,000
Acesta este motivul pentru acest lucru este modul în care lucrurile trebuie să fie.

662
00:51:00,000 --> 00:51:03,000
>> Din nou, memoreze cu siguranță că,

663
00:51:03,000 --> 00:51:06,000
sau cel puțin se înțelege suficient faptul că puteți fi în măsură să

664
00:51:06,000 --> 00:51:12,000
Motivul prin ceea ce ar trebui să arate.

665
00:51:12,000 --> 00:51:14,000
Lucrurile pe care le vom dori să pună în aplicare.

666
00:51:14,000 --> 00:51:18,000
Dacă lungimea lista-

667
00:51:18,000 --> 00:51:21,000
ai putea trișa și să păstreze în jurul valorii de un

668
00:51:21,000 --> 00:51:24,000
Durata globală sau ceva, dar noi nu vom face asta.

669
00:51:24,000 --> 00:51:28,000
Vom conta lungimea listei.

670
00:51:28,000 --> 00:51:34,000
Ne-am conține, așa că e practic ca o căutare,

671
00:51:34,000 --> 00:51:41,000
așa că avem o listă legată de numere întregi pentru a vedea dacă acest întreg este în lista de legat.

672
00:51:41,000 --> 00:51:44,000
PREFIX se va insera la începutul listei.

673
00:51:44,000 --> 00:51:46,000
Append este de gând să introduceți la sfârșitul anului.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted se va insera în poziția sortate în listă.

675
00:51:53,000 --> 00:52:01,000
Un fel de Insert_sorted presupune că niciodată nu ați utilizat PREFIX sau adăugați în moduri proaste.

676
00:52:01,000 --> 00:52:09,000
>> Insert_sorted atunci când sunteți de punere în aplicare insert_sorted-

677
00:52:09,000 --> 00:52:13,000
Să presupunem că avem lista noastră legată.

678
00:52:13,000 --> 00:52:18,000
Aceasta este ceea ce arata ca in prezent, 2, 4, 5.

679
00:52:18,000 --> 00:52:24,000
Vreau să inserați 3, atâta timp cât lista de sine este deja sortat,

680
00:52:24,000 --> 00:52:27,000
e ușor să găsiți în cazul în care face parte 3.

681
00:52:27,000 --> 00:52:29,000
Am încep de la 2.

682
00:52:29,000 --> 00:52:32,000
Bine, 3 este mai mare de 2, așa că vreau să continui.

683
00:52:32,000 --> 00:52:35,000
Oh, 4 este prea mare, așa că știu 3 este de gând să meargă în între 2 și 4,

684
00:52:35,000 --> 00:52:39,000
și trebuie să stabilească indicii și toate chestiile alea.

685
00:52:39,000 --> 00:52:43,000
Dar dacă nu ne-am folosi strict insert_sorted,

686
00:52:43,000 --> 00:52:50,000
ca să spunem doar că prefixului 6,

687
00:52:50,000 --> 00:52:55,000
apoi lista mea de legat este de gând să devină asta.

688
00:52:55,000 --> 00:53:01,000
Se face acum nici un sens, asa ca pentru insert_sorted, puteți presupune doar

689
00:53:01,000 --> 00:53:04,000
că lista este sortată, chiar dacă există operații

690
00:53:04,000 --> 00:53:09,000
care poate provoca aceasta să nu fie sortate, iar asta e tot.

691
00:53:09,000 --> 00:53:20,000
Găsiți un utill inserați-Deci, acestea sunt principalele lucruri ai de gând să trebuie să pună în aplicare.

692
00:53:20,000 --> 00:53:24,000
>> Pentru moment, să ia un minut pentru a face lungime și conține,

693
00:53:24,000 --> 00:53:30,000
și acestea ar trebui să fie relativ rapid.

694
00:53:41,000 --> 00:53:48,000
Apropie ora închiderii, astfel încât oricine are ceva de lungime sau conține?

695
00:53:48,000 --> 00:53:50,000
Ei vor să fie aproape identice.

696
00:53:50,000 --> 00:53:57,000
[Student] Lungime.

697
00:53:57,000 --> 00:54:01,000
Să vedem, revizuire.

698
00:54:01,000 --> 00:54:04,000
Bine.

699
00:54:12,000 --> 00:54:15,000
Vrei să explice?

700
00:54:15,000 --> 00:54:21,000
[Student] pot crea doar un nod pointer și inițializa-l la primul, care este variabila noastră globală,

701
00:54:21,000 --> 00:54:27,000
și apoi am verifica pentru a vedea dacă este nulă, așa că am nu primesc un defect segment și pentru a reveni 0 dacă e cazul.

702
00:54:27,000 --> 00:54:34,000
În caz contrar, am bucla prin, urmărirea în termen de număr întreg

703
00:54:34,000 --> 00:54:38,000
de câte ori am accesat urmatorul element al listei

704
00:54:38,000 --> 00:54:43,000
și în același operație incrementului accesa, de asemenea, faptul că elementul real,

705
00:54:43,000 --> 00:54:47,000
si apoi fac continuu verificare pentru a vedea dacă este nulă,

706
00:54:47,000 --> 00:54:56,000
și, dacă este nulă, atunci va abandona și returnează doar numărul de elemente le-am accesat.

707
00:54:56,000 --> 00:55:01,000
>> [Rob B.] Are cineva vreun comentariu pe nimic?

708
00:55:01,000 --> 00:55:06,000
Acest lucru arata corectitudinea bine înțelept.

709
00:55:06,000 --> 00:55:10,000
[Student] Nu cred că ai nevoie de nod == null.

710
00:55:10,000 --> 00:55:13,000
Da, așa că, dacă nodul == 0 intoarce null.

711
00:55:13,000 --> 00:55:18,000
Dar dacă nodul == null atunci acest oh-, există o problemă de corectitudine.

712
00:55:18,000 --> 00:55:23,000
A fost doar te-am întoarce, dar nu e în sfera de aplicare chiar acum.

713
00:55:23,000 --> 00:55:30,000
Ai nevoie doar de int i, deci i = 0.

714
00:55:30,000 --> 00:55:34,000
Dar dacă nodul este nul, atunci i este în continuare va fi 0,

715
00:55:34,000 --> 00:55:39,000
și am de gând să se întoarcă 0, deci acest caz este identic.

716
00:55:39,000 --> 00:55:48,000
Un alt lucru comun este de a păstra declarația

717
00:55:48,000 --> 00:55:51,000
din interiorul nod de buclă pentru.

718
00:55:51,000 --> 00:55:54,000
Ai putea spune-oh, nu.

719
00:55:54,000 --> 00:55:56,000
Să păstrați-l ca asta.

720
00:55:56,000 --> 00:55:59,000
Mi-ar pune, probabil, int i = 0 aici,

721
00:55:59,000 --> 00:56:05,000
apoi nod * nod = prima aici.

722
00:56:05,000 --> 00:56:11,000
Și acest lucru este, probabil, modul în care-a scăpa de asta acum.

723
00:56:11,000 --> 00:56:14,000
Acesta este, probabil, cum mi-ar fi scris.

724
00:56:14,000 --> 00:56:21,000
Ai putea, de asemenea, se uită la el, ca asta.

725
00:56:21,000 --> 00:56:25,000
Această structură de buclă chiar aici

726
00:56:25,000 --> 00:56:30,000
ar trebui să fie aproape la fel de natural pentru tine, ca pentru int i = 0

727
00:56:30,000 --> 00:56:33,000
i este mai mică decât lungimea de matrice i + +.

728
00:56:33,000 --> 00:56:38,000
Daca asta e modul în care repeta peste o matrice, acesta este modul în care repeta peste o listă legată.

729
00:56:38,000 --> 00:56:45,000
>> Acest lucru ar trebui să fie a doua natura la un moment dat.

730
00:56:45,000 --> 00:56:50,000
Cu asta în minte, acest lucru este mergi la a fi aproape același lucru.

731
00:56:50,000 --> 00:56:57,000
Ai de gând să doriți să itera peste o listă legat.

732
00:56:57,000 --> 00:57:02,000
Dacă nodul-am nici o idee despre ceea ce se numeste valoarea.

733
00:57:02,000 --> 00:57:04,000
Nodul i.

734
00:57:04,000 --> 00:57:15,000
În cazul în care valoarea de la acel nod = i întoarcă adevărat, și asta e tot.

735
00:57:15,000 --> 00:57:18,000
Observați că singurul mod de a reveni vreodată fals

736
00:57:18,000 --> 00:57:23,000
este, dacă am repeta peste intreaga lista legate și nu se mai întorc adevărat,

737
00:57:23,000 --> 00:57:29,000
Deci asta ce face asta.

738
00:57:29,000 --> 00:57:36,000
Ca o parte notă-ne, probabil, nu va primi să adăugați sau adauge.

739
00:57:36,000 --> 00:57:39,000
>> Rapidă ultima nota.

740
00:57:39,000 --> 00:57:52,000
Dacă vedeți cuvântul cheie static, așa că hai să spunem static int count = 0,

741
00:57:52,000 --> 00:57:56,000
atunci vom face numărătoarea + +, vă puteți gândi la ea ca practic o variabilă globală,

742
00:57:56,000 --> 00:58:00,000
chiar dacă am spus acest lucru nu este modul în care vom pune în aplicare lungime.

743
00:58:00,000 --> 00:58:06,000
Eu fac asta aici, și apoi conta + +.

744
00:58:06,000 --> 00:58:11,000
Orice fel putem introduce un nod în lista noastră de legat suntem incrementarea numărului nostru.

745
00:58:11,000 --> 00:58:15,000
Punctul de acest lucru este ceea ce înseamnă cuvântul cheie static.

746
00:58:15,000 --> 00:58:20,000
Dacă aș fi avut doar count int = 0, care ar fi o variabilă regulat vechi globale.

747
00:58:20,000 --> 00:58:25,000
Ce înseamnă static int count este că acesta este o variabilă globală pentru acest fișier.

748
00:58:25,000 --> 00:58:28,000
Este imposibil pentru un alt fișier,

749
00:58:28,000 --> 00:58:34,000
cred ca de PSET 5, în cazul în care ați început.

750
00:58:34,000 --> 00:58:39,000
Aveți atât speller.c, și aveți dictionary.c,

751
00:58:39,000 --> 00:58:42,000
și dacă declară doar o chestie la nivel mondial, apoi nimic în speller.c

752
00:58:42,000 --> 00:58:45,000
pot fi accesate în dictionary.c și vice-versa.

753
00:58:45,000 --> 00:58:48,000
Variabilele globale sunt accesibile de către orice fișier. C,

754
00:58:48,000 --> 00:58:54,000
dar variabilele statice sunt accesibile doar din interiorul fișierul propriu-zis,

755
00:58:54,000 --> 00:59:01,000
astfel încât interiorul corector ortografic sau în interiorul dictionary.c,

756
00:59:01,000 --> 00:59:06,000
acest lucru este un fel de cum mi-ar declar variabila mea pentru dimensiunea matrice meu

757
00:59:06,000 --> 00:59:10,000
sau dimensiunea de numărul meu de cuvinte în dicționar.

758
00:59:10,000 --> 00:59:15,000
Din moment ce nu vreau să declare o variabilă globală care oricine are acces la,

759
00:59:15,000 --> 00:59:18,000
Am într-adevăr numai pasă de el pentru propriile mele scopuri.

760
00:59:18,000 --> 00:59:21,000
>> Lucru bun despre acest lucru este, de asemenea, întregul coliziune chestii nume.

761
00:59:21,000 --> 00:59:27,000
În cazul în care un alt fișier încearcă să utilizeze o variabilă globală numită count, lucrurile merg foarte, foarte greșit,

762
00:59:27,000 --> 00:59:33,000
Deci, acest frumos păstrează în condiții de siguranță lucruri, și doar tu poți accesa,

763
00:59:33,000 --> 00:59:38,000
și nimeni altcineva nu poate, iar dacă altcineva declară o variabilă globală numită count,

764
00:59:38,000 --> 00:59:43,000
atunci nu va interfera cu variabila statica numita numărătoarea.

765
00:59:43,000 --> 00:59:47,000
Asta e ceea ce este static. Acesta este un fișier variabilă globală.

766
00:59:47,000 --> 00:59:52,000
>> Întrebări cu privire la ceva?

767
00:59:52,000 --> 00:59:59,000
Toate set. Pa.

768
00:59:59,000 --> 01:00:03,000
[CS50.TV]