1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Recenzija] [Kviz 0]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi Ross, Tommy MacWilliam, Lucas Freitas, Josip Ong] [Sveučilište Harvard]

3
00:00:05,000 --> 00:00:08,000
>> [Ovo je CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Hej, svatko.

5
00:00:10,000 --> 00:00:15,000
Dobro došli na pregled sjednice za kviz 0, koji se održava u srijedu.

6
00:00:15,000 --> 00:00:19,000
Što ćemo učiniti večeras, ja sam s tri druga TFS,

7
00:00:19,000 --> 00:00:24,000
i zajedno ćemo proći kroz pregled onoga što smo učinili u tijeku do sada.

8
00:00:24,000 --> 00:00:27,000
To neće biti 100% sveobuhvatan, ali to bi trebao dati bolju ideju

9
00:00:27,000 --> 00:00:31,000
od onoga što već imate dolje i ono što još treba proučiti prije srijede.

10
00:00:31,000 --> 00:00:34,000
I slobodno podići ruku s pitanjima kao što ćemo zajedno,

11
00:00:34,000 --> 00:00:38,000
ali imajte na umu da također ćemo imati malo vremena na kraju-

12
00:00:38,000 --> 00:00:41,000
ako prođemo s nekoliko minuta da slobodno učiniti opća pitanja,

13
00:00:41,000 --> 00:00:47,000
pa imajte to na umu, i tako ćemo početi početkom tjedna s 0.

14
00:00:47,000 --> 00:00:50,000
>> [Kviz 0 pregled!] [Dio 0] [Lexi Ross] Ali prije nego što nam je činiti da pričajmo o

15
00:00:50,000 --> 00:00:53,000
logistika u kvizu.

16
00:00:53,000 --> 00:00:55,000
>> [Logistika] [Kviz se odvija u srijedu 10/10 u zamjenu za predavanje]

17
00:00:55,000 --> 00:00:57,000
>> [(Vidi http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf za detalje)] To je na srijeda, 10. listopada.

18
00:00:57,000 --> 00:01:00,000
>> To je ove srijede, a ako idete na ovaj URL ovdje,

19
00:01:00,000 --> 00:01:03,000
koji je također dostupan s CS50.net-tu je link na njega-

20
00:01:03,000 --> 00:01:06,000
možete vidjeti informacije o tome gdje ići na temelju

21
00:01:06,000 --> 00:01:10,000
Vaše prezime ili škola pripadnosti, kao i

22
00:01:10,000 --> 00:01:14,000
to govori o točno što kviz će pokriti i vrste pitanja koja ste idući u dobiti.

23
00:01:14,000 --> 00:01:19,000
Imajte na umu da ćete također imati priliku za pregled za kviz u odjeljku,

24
00:01:19,000 --> 00:01:21,000
tako da TFS treba ide preko nekih problema praksi,

25
00:01:21,000 --> 00:01:29,000
i to je još jedna dobra prilika za vidjeti gdje se još uvijek treba učiti za kviz.

26
00:01:29,000 --> 00:01:32,000
Počnimo na početku s komadićima 'n' Bytes.

27
00:01:32,000 --> 00:01:35,000
Sjeti se malo je samo 0 ili 1,

28
00:01:35,000 --> 00:01:38,000
a bajt je skup od 8 tih bitova.

29
00:01:38,000 --> 00:01:42,000
Pogledajmo ove zbirke bitova ovdje.

30
00:01:42,000 --> 00:01:44,000
Trebali bismo biti u mogućnosti shvatiti koliko bita postoje.

31
00:01:44,000 --> 00:01:48,000
Gdje smo računati postoji samo osam od njih, osam 0 ili 1 jedinice.

32
00:01:48,000 --> 00:01:51,000
A budući da je 8 bita, to je jedan byte,

33
00:01:51,000 --> 00:01:53,000
i neka ga pretvoriti u heksadecimalni.

34
00:01:53,000 --> 00:01:58,000
Heksadecimalni je baza 16, a to je prilično lako pretvoriti

35
00:01:58,000 --> 00:02:01,000
broj u binarnom sustavu, što je što je to, na broj u heksadecimalnom.

36
00:02:01,000 --> 00:02:04,000
Sve mi je gledamo grupe 4,

37
00:02:04,000 --> 00:02:07,000
i mi smo ih pretvoriti u odgovarajući heksadecimalnom znamenkom.

38
00:02:07,000 --> 00:02:11,000
Mi smo započeli s desne najviše skupini 4, tako da 0011.

39
00:02:11,000 --> 00:02:16,000
To će biti jedan jedan i jedan dva, pa zajedno čini tri.

40
00:02:16,000 --> 00:02:19,000
A onda pogledajmo druge bloka 4.

41
00:02:19,000 --> 00:02:24,000
1101. To će biti jedan jedan, jedan 4, a jedan 8.

42
00:02:24,000 --> 00:02:28,000
Zajedno da će biti 13, što čini D.

43
00:02:28,000 --> 00:02:32,000
A mi ćemo se sjetiti da je u heksadecimalnom smo ne samo ići 0 do 9..

44
00:02:32,000 --> 00:02:36,000
Idemo 0 do F, tako da nakon 9, 10 odgovara,

45
00:02:36,000 --> 00:02:40,000
11. B, et cetera gdje je F 15.

46
00:02:40,000 --> 00:02:44,000
Ovdje 13 je D,

47
00:02:44,000 --> 00:02:49,000
tako da pretvoriti ga u decimalni sve što radimo je zapravo

48
00:02:49,000 --> 00:02:52,000
liječiti svaku poziciju kao snage 2.

49
00:02:52,000 --> 00:02:58,000
To je jedna 1, jedan dva, nula 4s, nula 8s, jedan 16, et cetera,

50
00:02:58,000 --> 00:03:03,000
i to je malo teško izračunati u glavi, ali ako ćemo ići na sljedeći slajd

51
00:03:03,000 --> 00:03:05,000
možemo vidjeti odgovor na to pitanje.

52
00:03:05,000 --> 00:03:09,000
>> U suštini idemo preko pravo vratiti na lijevoj strani,

53
00:03:09,000 --> 00:03:14,000
i mi smo množenjem svake znamenke s odgovarajućim moći dva.

54
00:03:14,000 --> 00:03:19,000
I zapamtite, za heksadecimalnom smo označavaju ove brojeve s 0x na početku

55
00:03:19,000 --> 00:03:23,000
tako da mi to ne brkati s decimalnim brojem.

56
00:03:23,000 --> 00:03:29,000
Nastavljajući dalje, to je ASCII tablica,

57
00:03:29,000 --> 00:03:35,000
i ono što ćemo koristiti ASCII je da će karta iz znakova na brojčane vrijednosti.

58
00:03:35,000 --> 00:03:39,000
Sjetite u kriptografiji pset smo napravili veliku korištenje ASCII tablici

59
00:03:39,000 --> 00:03:43,000
kako bi se koristiti različite metode kriptografije,

60
00:03:43,000 --> 00:03:47,000
Caesar i Vigenère šifra, pretvoriti različite slova

61
00:03:47,000 --> 00:03:52,000
u nizu prema ključu danom od strane korisnika.

62
00:03:52,000 --> 00:03:56,000
Pogledajmo malo ASCII matematici.

63
00:03:56,000 --> 00:04:02,000
Gledajući na 'P' + 1, u znak obliku koji će biti P,

64
00:04:02,000 --> 00:04:07,000
i sjetite se da '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
A kako bi točno smo pretvoriti između tih dvaju oblika?

66
00:04:10,000 --> 00:04:13,000
To je zapravo nije previše teško.

67
00:04:13,000 --> 00:04:16,000
Da bi dobili 5 oduzmemo '0 '

68
00:04:16,000 --> 00:04:20,000
jer postoji pet mjesta između '0 'i '5'.

69
00:04:20,000 --> 00:04:23,000
Kako bi se ići na drugi način samo smo dodali 0,

70
00:04:23,000 --> 00:04:25,000
pa to je nešto kao redoviti aritmetike.

71
00:04:25,000 --> 00:04:29,000
Samo zapamtite da kada nešto ima citati oko njega to je znak

72
00:04:29,000 --> 00:04:37,000
i tako se odnosi na vrijednost u ASCII tablice.

73
00:04:37,000 --> 00:04:40,000
Preseljenje u više opće informatike temama.

74
00:04:40,000 --> 00:04:43,000
Naučili smo što je algoritam i koliko mi koristimo programiranje

75
00:04:43,000 --> 00:04:45,000
implementirati algoritme.

76
00:04:45,000 --> 00:04:48,000
Neki primjeri algoritama su nešto stvarno jednostavan kao

77
00:04:48,000 --> 00:04:51,000
provjere da li je broj čak i čudno.

78
00:04:51,000 --> 00:04:54,000
Za to smo se sjetiti mod broj po dvije i provjerite je li rezultat je 0.

79
00:04:54,000 --> 00:04:57,000
Ako je tako, to je čak. Ako ne, to je čudno.

80
00:04:57,000 --> 00:04:59,000
I to je primjer zaista osnovni algoritam.

81
00:04:59,000 --> 00:05:02,000
>> Malo više uključeni jedan je binarno pretraživanje,

82
00:05:02,000 --> 00:05:05,000
koje ćemo ići preko kasnije u žalbenom sjednici.

83
00:05:05,000 --> 00:05:09,000
I programiranje je pojam koji koristimo za uzimanje algoritam

84
00:05:09,000 --> 00:05:15,000
i pretvoriti ga kodirati računalo može pročitati.

85
00:05:15,000 --> 00:05:20,000
2 primjeri programiranja je Scratch,

86
00:05:20,000 --> 00:05:22,000
što je ono što smo učinili u tjednu 0.

87
00:05:22,000 --> 00:05:25,000
Iako mi zapravo ne tip iz kôd je način provedbe

88
00:05:25,000 --> 00:05:29,000
ovaj algoritam, koji se ispisuje brojeve 1-10,

89
00:05:29,000 --> 00:05:32,000
i ovdje mi učiniti isto u jeziku C programiranje.

90
00:05:32,000 --> 00:05:41,000
To su funkcionalno ekvivalentne, samo napisan u različitim jezicima ili sintakse.

91
00:05:41,000 --> 00:05:44,000
Mi smo tada naučili o Boolean izraza,

92
00:05:44,000 --> 00:05:48,000
i boolean je vrijednost koja je ili istinita ili lažna,

93
00:05:48,000 --> 00:05:51,000
i ovdje često boolean izraza

94
00:05:51,000 --> 00:05:55,000
ući uvjeta, pa ako (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
dobro, već smo postavili x = 5, tako da stanje ide na procjenu da vrijedi.

96
00:06:00,000 --> 00:06:03,000
A ako je to istina, bez obzira na broj je ispod stanju

97
00:06:03,000 --> 00:06:08,000
će se vrednovati po računalu, tako da niz će se ispisati

98
00:06:08,000 --> 00:06:12,000
na standardni izlaz, i pojma stanju

99
00:06:12,000 --> 00:06:16,000
odnosi se na ono što je unutar zagrada u ako izjavi.

100
00:06:16,000 --> 00:06:20,000
Zapamtite sve operatore.

101
00:06:20,000 --> 00:06:26,000
Zapamtite da je && i | | kada pokušavamo kombinirati dva ili više uvjeta,

102
00:06:26,000 --> 00:06:30,000
== Ne = biste provjerili jesu li dvije stvari su jednake.

103
00:06:30,000 --> 00:06:36,000
Sjetite se da je = za dodjelu dok == je boolean operator.

104
00:06:36,000 --> 00:06:41,000
≤, ≥, a zatim konačnu dva su samorazumljivo.

105
00:06:41,000 --> 00:06:45,000
Opći pregled Booleova logika ovdje.

106
00:06:45,000 --> 00:06:48,000
I boolean izraza su također važni u petlji,

107
00:06:48,000 --> 00:06:50,000
koje ćemo ići preko sada.

108
00:06:50,000 --> 00:06:56,000
Naučili smo oko tri vrste petlji tako daleko u CS50, za, dok je, i to dok.

109
00:06:56,000 --> 00:06:59,000
I to je važno znati da, dok za većinu svrhe

110
00:06:59,000 --> 00:07:02,000
zapravo možemo koristiti bilo koju vrstu petlje općenito

111
00:07:02,000 --> 00:07:06,000
postoje određene vrste svrhe ili zajedničkih uzoraka

112
00:07:06,000 --> 00:07:09,000
u programiranju koji su posebno poziv za jedan od tih petlji

113
00:07:09,000 --> 00:07:13,000
da bi ga najučinkovitiji ili elegantne ga kodirati na taj način.

114
00:07:13,000 --> 00:07:18,000
Idemo na ono što svaki od tih petlji tendenciju da se koristiti za najčešće.

115
00:07:18,000 --> 00:07:21,000
>> U for petlji smo uglavnom već znate koliko puta želimo ponoviti.

116
00:07:21,000 --> 00:07:24,000
To je ono što smo stavili u stanju.

117
00:07:24,000 --> 00:07:28,000
Jer, i = 0, i <10, na primjer.

118
00:07:28,000 --> 00:07:31,000
Mi već znamo da želimo učiniti nešto 10 puta.

119
00:07:31,000 --> 00:07:34,000
Sada, za while petlje, općenito mi ne nužno

120
00:07:34,000 --> 00:07:36,000
znam koliko puta želimo se petlja pokrenuti.

121
00:07:36,000 --> 00:07:39,000
Ali znamo nekakvu uvjetom da želimo da

122
00:07:39,000 --> 00:07:41,000
uvijek biti istinita ili lažna uvijek biti.

123
00:07:41,000 --> 00:07:44,000
Na primjer, dok je postavljen.

124
00:07:44,000 --> 00:07:46,000
Recimo da je boolean varijablu.

125
00:07:46,000 --> 00:07:48,000
Iako je istina da želimo kod ocijeniti,

126
00:07:48,000 --> 00:07:52,000
pa malo više rastezljiva, malo više općenito nego za petlje,

127
00:07:52,000 --> 00:07:55,000
ali bilo za petlje također može pretvoriti u while petlji.

128
00:07:55,000 --> 00:08:00,000
Konačno, učiniti dok petlje, koja može biti najzahtjevnijim shvatiti odmah,

129
00:08:00,000 --> 00:08:04,000
često se koristi kada želimo procijeniti kôd prvi

130
00:08:04,000 --> 00:08:06,000
prije prvi put smo provjeriti stanje.

131
00:08:06,000 --> 00:08:09,000
Zajedničko korištenje slučaj za napraviti, a petlja

132
00:08:09,000 --> 00:08:12,000
kada želite dobiti korisničkog unosa, a vi znate što želite pitati korisnika

133
00:08:12,000 --> 00:08:15,000
za ulaz barem jednom, ali ako oni ne daju vam dobar ulaz odmah

134
00:08:15,000 --> 00:08:18,000
želite zadržati moleći ih dok oni vam dati dobar ulaz.

135
00:08:18,000 --> 00:08:21,000
To je najčešći korištenje ne while petlja,

136
00:08:21,000 --> 00:08:23,000
i pogledajmo stvarnoj strukturi tih petlji.

137
00:08:23,000 --> 00:08:27,000
Oni obično uvijek imaju tendenciju da slijedite ove obrasce.

138
00:08:27,000 --> 00:08:30,000
>> Na za petlju unutar imate tri komponente:

139
00:08:30,000 --> 00:08:35,000
inicijalizacija, obično nešto poput int i = 0 gdje je i brojač,

140
00:08:35,000 --> 00:08:40,000
stanje, u kojem želimo reći pokrenuti ovo za petlju dok ovo stanje još uvijek drži,

141
00:08:40,000 --> 00:08:44,000
Kao što sam <10, i onda konačno, ažuriranja, što je kako smo povećavati

142
00:08:44,000 --> 00:08:47,000
brojač varijabla u svakoj točki u petlji.

143
00:08:47,000 --> 00:08:50,000
Uobičajena stvar vidjeti postoji samo i + +,

144
00:08:50,000 --> 00:08:52,000
što znači da sam povećavati po 1 svaki put.

145
00:08:52,000 --> 00:08:55,000
Također bi mogao učiniti nešto slično i + = 2,

146
00:08:55,000 --> 00:08:58,000
što znači dodati dvije do i svaki put kada ide kroz petlju.

147
00:08:58,000 --> 00:09:03,000
I onda je to samo odnosi na bilo koda koji zapravo radi kao dio petlje.

148
00:09:03,000 --> 00:09:09,000
A za while petlji, ovaj put smo zapravo imaju inicijalizacije izvan petlje,

149
00:09:09,000 --> 00:09:12,000
tako da za primjer, recimo da mi pokušavamo učiniti istu vrstu petlje kao što sam upravo opisao.

150
00:09:12,000 --> 00:09:16,000
Mi bismo rekli int i = 0 prije petlje počinje.

151
00:09:16,000 --> 00:09:20,000
Tada bismo mogli reći dok ja <10 to učinili,

152
00:09:20,000 --> 00:09:22,000
tako da se isti blok koda kao i prije,

153
00:09:22,000 --> 00:09:26,000
i ovaj put ažuriranje dio koda, na primjer, i + +,

154
00:09:26,000 --> 00:09:29,000
zapravo ide unutar petlje.

155
00:09:29,000 --> 00:09:33,000
I na kraju, za to vrijeme, to je slično while petlje,

156
00:09:33,000 --> 00:09:36,000
ali moramo se sjetiti da je kod će ocijeniti jednom

157
00:09:36,000 --> 00:09:40,000
prije nego je uvjet provjeren, tako da to čini puno više smisla

158
00:09:40,000 --> 00:09:44,000
ako pogledate to u redu vrha do dna.

159
00:09:44,000 --> 00:09:49,000
U učiniti dok petlja kod ocjenjuje prije nego što čak i pogled na while uvjet,

160
00:09:49,000 --> 00:09:55,000
a while petlji provjerava prvi.

161
00:09:55,000 --> 00:09:59,000
Izjave i varijable.

162
00:09:59,000 --> 00:10:04,000
Kada želimo stvoriti novu varijablu smo prvi put ga želite inicijalizirati.

163
00:10:04,000 --> 00:10:07,000
>> Na primjer, int bar inicijalizira varijable bar,

164
00:10:07,000 --> 00:10:10,000
ali to ne dati mu vrijednost, tako što je bara vrijednost sada?

165
00:10:10,000 --> 00:10:12,000
Mi ne znamo.

166
00:10:12,000 --> 00:10:14,000
To bi mogao biti neki smeća vrijednost koja je prethodno pohranjen u memoriji postoji,

167
00:10:14,000 --> 00:10:16,000
i ne želimo koristiti tu varijablu

168
00:10:16,000 --> 00:10:19,000
dok mi zapravo dati mu vrijednost,

169
00:10:19,000 --> 00:10:21,000
pa smo ga proglasiti ovdje.

170
00:10:21,000 --> 00:10:24,000
Onda smo inicijalizirati da bude 42 u nastavku.

171
00:10:24,000 --> 00:10:28,000
Sada, naravno, znamo da to može biti učinjeno na jednoj liniji, int bar = 42.

172
00:10:28,000 --> 00:10:30,000
Ali samo da se jasno više koraka koji se događa,

173
00:10:30,000 --> 00:10:34,000
deklaracija i inicijalizacija se događa odvojeno ovdje.

174
00:10:34,000 --> 00:10:38,000
To se događa na jednom koraku, a sljedeći, int baz = bar + 1,

175
00:10:38,000 --> 00:10:44,000
ova izjava u nastavku, koji se povećava baz, tako da na kraju ovog bloka koda

176
00:10:44,000 --> 00:10:48,000
ako smo ispisali vrijednost Baz da će to biti 44

177
00:10:48,000 --> 00:10:52,000
jer smo proglasiti i inicijalizirati biti jedan> bara,

178
00:10:52,000 --> 00:10:58,000
i onda smo ga povećavati još jednom s + +.

179
00:10:58,000 --> 00:11:02,000
Išli smo preko ovog lijepog kratko, ali to je dobro imati opće

180
00:11:02,000 --> 00:11:04,000
razumijevanje onoga što teme i događaji su.

181
00:11:04,000 --> 00:11:06,000
Mi uglavnom je to učinio u nule,

182
00:11:06,000 --> 00:11:09,000
tako da se možete sjetiti niti kao više sekvenci koda

183
00:11:09,000 --> 00:11:11,000
prikazivati ​​u isto vrijeme.

184
00:11:11,000 --> 00:11:14,000
U stvarnosti, to vjerojatno ne radi u isto vrijeme,

185
00:11:14,000 --> 00:11:17,000
ali vrsta apstraktno možemo razmišljati o tome na taj način.

186
00:11:17,000 --> 00:11:20,000
>> U Scratch, na primjer, imali smo više sprites.

187
00:11:20,000 --> 00:11:22,000
To bi mogao biti drugačiji kod izvršenja u isto vrijeme.

188
00:11:22,000 --> 00:11:26,000
Moglo bi biti hodanje dok je drugi nešto kaže

189
00:11:26,000 --> 00:11:29,000
u drugom dijelu na zaslonu.

190
00:11:29,000 --> 00:11:34,000
Događaji su još jedan način izdvajanjem logiku

191
00:11:34,000 --> 00:11:37,000
između različitih elemenata kodu,

192
00:11:37,000 --> 00:11:40,000
i ispočetka bili smo u mogućnosti da simuliraju događaje pomoću emitiranje,

193
00:11:40,000 --> 00:11:43,000
i to je zapravo Kada sam primite, ne kad čujem,

194
00:11:43,000 --> 00:11:47,000
ali u suštini to je način za prijenos informacija

195
00:11:47,000 --> 00:11:49,000
iz jedne u drugu sprite.

196
00:11:49,000 --> 00:11:52,000
Na primjer, možda ćete htjeti prenositi utakmicu više,

197
00:11:52,000 --> 00:11:56,000
i kada je drugi vilenjak prima igra više,

198
00:11:56,000 --> 00:11:58,000
ona reagira na određeni način.

199
00:11:58,000 --> 00:12:03,000
To je važno razumjeti model za programiranje.

200
00:12:03,000 --> 00:12:07,000
Samo da ide preko osnovnog tjednu 0, što smo otišli na tako daleko,

201
00:12:07,000 --> 00:12:10,000
pogledajmo ovaj jednostavan C program.

202
00:12:10,000 --> 00:12:14,000
Tekst može biti malo mali od ovdje, ali ja ću ići preko njega jako brzo.

203
00:12:14,000 --> 00:12:20,000
Mi smo, uključujući dvije zaglavlja datoteke na vrhu, cs50.h i stdio.h.

204
00:12:20,000 --> 00:12:23,000
Mi smo tada se definiraju stalno zove ograničenje biti 100.

205
00:12:23,000 --> 00:12:26,000
Mi smo tada ste provedbi našu glavnu funkciju.

206
00:12:26,000 --> 00:12:29,000
Budući da ne koristite argumente naredbenog retka ovdje moramo staviti prazninu

207
00:12:29,000 --> 00:12:32,000
kao argumente za glavni.

208
00:12:32,000 --> 00:12:38,000
Vidimo int iznad glavni. To je povratni tip, pa se vratiti 0 na dnu.

209
00:12:38,000 --> 00:12:41,000
I mi smo pomoću CS50 knjižnice funkciju dobiti int

210
00:12:41,000 --> 00:12:45,000
pitati korisnika za ulaz, a mi smo ga spremiti u ovoj varijablu x,

211
00:12:45,000 --> 00:12:51,000
pa smo proglasiti x gore, a mi smo ga inicijalizirati sa x = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> Mi smo tada provjerite da li je korisnik dao nam dobar ulaz.

213
00:12:53,000 --> 00:12:59,000
Ako je ≥ GRANICA želimo vratiti pogreške kod jednog i ispisati poruku o pogrešci.

214
00:12:59,000 --> 00:13:02,000
I na kraju, ako korisnik nam je dao dobar ulaz

215
00:13:02,000 --> 00:13:08,000
idemo na trgu broj i ispisati taj rezultat.

216
00:13:08,000 --> 00:13:11,000
Samo kako bi bili sigurni da su oni svi pogodak dom

217
00:13:11,000 --> 00:13:17,000
možete vidjeti etikete različitih dijelova koda ovdje.

218
00:13:17,000 --> 00:13:19,000
Spomenuo sam konstantne, zaglavlje datoteke.

219
00:13:19,000 --> 00:13:21,000
Oh, int x. Pobrinite se sjetiti da je lokalna varijabla.

220
00:13:21,000 --> 00:13:24,000
To je u suprotnosti s globalnom varijablom, što ćemo govoriti o

221
00:13:24,000 --> 00:13:27,000
Malo kasnije u žalbenom sjednici,

222
00:13:27,000 --> 00:13:30,000
i mi smo pozivom knjižnice funkciju printf,

223
00:13:30,000 --> 00:13:34,000
pa ako nismo uključeni stdio.h header datoteku

224
00:13:34,000 --> 00:13:37,000
ne bismo mogli nazvati printf.

225
00:13:37,000 --> 00:13:42,000
I ja vjerujem da je strelica dobio odsječen ovdje se ukazuje na% d,

226
00:13:42,000 --> 00:13:45,000
što je oblikovanje niz u printf.

227
00:13:45,000 --> 00:13:52,000
Ona kaže isprintati ovu varijablu kao broj,% d.

228
00:13:52,000 --> 00:13:58,000
I to je to za tjedan 0.

229
00:13:58,000 --> 00:14:06,000
Sada Lucas se ide dalje.

230
00:14:06,000 --> 00:14:08,000
Hej, dečki. Moje ime je Lucas.

231
00:14:08,000 --> 00:14:10,000
Ja sam student u najboljem kući na kampusu, Mather,

232
00:14:10,000 --> 00:14:14,000
i ja ću razgovarati malo o tjednu 1 i 2,1.

233
00:14:14,000 --> 00:14:16,000
[Tjedan 1 i 2,1!] [Lucas Freitas]

234
00:14:16,000 --> 00:14:19,000
Kao Lexi je rekao, kada smo počeli prevođenju koda od nule u C

235
00:14:19,000 --> 00:14:23,000
jedna od stvari koje smo primijetili je da ne možete samo

236
00:14:23,000 --> 00:14:26,000
pisati svoj kod i pokrenuti ga koristite zelenu zastavu više.

237
00:14:26,000 --> 00:14:30,000
Zapravo, morate koristiti neke korake kako bi vaš C program

238
00:14:30,000 --> 00:14:33,000
postala izvršna datoteka.

239
00:14:33,000 --> 00:14:36,000
Uglavnom ono što učiniti kada pišete program je da

240
00:14:36,000 --> 00:14:40,000
li prevesti svoju ideju na jeziku koji kompajler može razumjeti,

241
00:14:40,000 --> 00:14:44,000
pa kad pišete program u C

242
00:14:44,000 --> 00:14:47,000
što radiš zapravo piše nešto da je vaš kompajler će razumjeti,

243
00:14:47,000 --> 00:14:50,000
i onda prevodilac će prevesti taj kod

244
00:14:50,000 --> 00:14:53,000
u nešto što će vaše računalo razumije.

245
00:14:53,000 --> 00:14:55,000
>> A stvar je, vaše računalo je zapravo vrlo glup.

246
00:14:55,000 --> 00:14:57,000
Računalo se samo mogu razumjeti 0s i 1s,

247
00:14:57,000 --> 00:15:01,000
tako da je zapravo u prvim računalima ljudi obično programiran

248
00:15:01,000 --> 00:15:04,000
pomoću 0s i 1s, ali ne više, hvala Bogu.

249
00:15:04,000 --> 00:15:07,000
Mi ne moramo pamtiti sekvence za 0S i 1S

250
00:15:07,000 --> 00:15:10,000
za for petlje ili za while petlje i tako dalje.

251
00:15:10,000 --> 00:15:13,000
To je razlog zašto smo prevodilac.

252
00:15:13,000 --> 00:15:17,000
Što prevodilac čini se da u osnovi prevodi C koda,

253
00:15:17,000 --> 00:15:21,000
u našem slučaju, na jeziku koji će vaše računalo razumije,

254
00:15:21,000 --> 00:15:25,000
koja je predmet kod, a kompajler da smo pomoću

255
00:15:25,000 --> 00:15:30,000
zove se jeka, tako da je ovo zapravo simbol za zveka.

256
00:15:30,000 --> 00:15:33,000
Kad imate svoj program, morate učiniti dvije stvari.

257
00:15:33,000 --> 00:15:37,000
Prvo, morate sastaviti svoj program, a zatim ćete pokrenuti vaš program.

258
00:15:37,000 --> 00:15:41,000
Za sastaviti svoj program imate puno mogućnosti da to učini.

259
00:15:41,000 --> 00:15:44,000
Prvi je to učiniti zveka program.c

260
00:15:44,000 --> 00:15:47,000
u kojem programu je ime svog programa.

261
00:15:47,000 --> 00:15:51,000
U tom slučaju možete vidjeti oni su samo govoreći: "Hej, sastaviti svoj program."

262
00:15:51,000 --> 00:15:56,000
Vi ne govorite "Želim taj naziv za svoj program" ili ništa.

263
00:15:56,000 --> 00:15:58,000
>> Druga opcija je davanje imena na svoj program.

264
00:15:58,000 --> 00:16:02,000
Možete reći zveka-o i onda ime koje želite

265
00:16:02,000 --> 00:16:06,000
izvršnu datoteku da se zove kao i onda program.c.

266
00:16:06,000 --> 00:16:11,000
A također možete napraviti napraviti program, i vidjeti kako je u prvih dvaju slučajeva

267
00:16:11,000 --> 00:16:15,000
Stavio sam. C, au trećem sam samo programe?

268
00:16:15,000 --> 00:16:18,000
Da, zapravo ne bi trebalo staviti. C kada koristite napraviti.

269
00:16:18,000 --> 00:16:22,000
Inače prevodilac zapravo događa vikati na tebe.

270
00:16:22,000 --> 00:16:24,000
A isto tako, ne znam, ako vi ne zaboravite,

271
00:16:24,000 --> 00:16:29,000
ali puno puta mi se također koristi-lcs50 ili-lm.

272
00:16:29,000 --> 00:16:31,000
To se zove povezivanja.

273
00:16:31,000 --> 00:16:35,000
To samo govori prevodilac koje ćete koristiti one knjižnice tamo,

274
00:16:35,000 --> 00:16:39,000
pa ako želite koristiti cs50.h zapravo morati upisati

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

276
00:16:43,000 --> 00:16:45,000
Ako to ne učinite, prevodilac se neće znati

277
00:16:45,000 --> 00:16:50,000
koristite li one funkcije u cs50.h.

278
00:16:50,000 --> 00:16:52,000
I kada želite pokrenuti vaš program imate dvije opcije.

279
00:16:52,000 --> 00:16:57,000
Ako je zveka program.c niste dati ime svom programu.

280
00:16:57,000 --> 00:17:01,000
Morate ga pokrenuti korištenjem. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out je standardni ime koje zveka daje svoj program, ako ne dati mu ime.

282
00:17:06,000 --> 00:17:11,000
Inače ćeš učiniti. / Programa ako je dao ime svom programu,

283
00:17:11,000 --> 00:17:15,000
i ako je napraviti program za ime koje program će se

284
00:17:15,000 --> 00:17:23,000
već će se programirati isto ime kao c datoteku.

285
00:17:23,000 --> 00:17:26,000
Zatim smo razgovarali o tipovima podataka i podataka.

286
00:17:26,000 --> 00:17:31,000
>> Uglavnom tipovi podataka su ista stvar kao male kutijice koje koriste

287
00:17:31,000 --> 00:17:35,000
za pohranu vrijednosti, tako da tipovi podataka su zapravo samo kao Pokemon.

288
00:17:35,000 --> 00:17:39,000
Oni dolaze u svim veličinama i vrstama.

289
00:17:39,000 --> 00:17:43,000
Ja ne znam da li analogija smisla.

290
00:17:43,000 --> 00:17:46,000
Podaci veličina zapravo ovisi o stroju arhitekture.

291
00:17:46,000 --> 00:17:49,000
Svi podaci veličine da ću pokazati ovdje

292
00:17:49,000 --> 00:17:53,000
zapravo su za 32-bitni stroj, što je slučaj našeg aparata,

293
00:17:53,000 --> 00:17:56,000
ali ako ste zapravo kodiranja svoj Mac ili u Windowsima također

294
00:17:56,000 --> 00:17:59,000
Vjerojatno ćeš imati 64-bitni stroj,

295
00:17:59,000 --> 00:18:03,000
pa ne zaboravite da su podaci veličine da ću pokazati ovdje

296
00:18:03,000 --> 00:18:06,000
su za 32-bitni stroj.

297
00:18:06,000 --> 00:18:08,000
Prvi onaj koji smo vidjeli je int,

298
00:18:08,000 --> 00:18:10,000
što je prilično jednostavan.

299
00:18:10,000 --> 00:18:13,000
Možete koristiti int pohraniti cijeli broj.

300
00:18:13,000 --> 00:18:16,000
Također smo vidjeli karakter, char.

301
00:18:16,000 --> 00:18:20,000
Ako želite koristiti slovo ili simbol malo ste vjerojatno će koristiti char.

302
00:18:20,000 --> 00:18:26,000
Char ima 1 bajt, što znači 8 bita, kao Lexi, rekao je.

303
00:18:26,000 --> 00:18:31,000
Uglavnom imamo ASCII tablicu koja ima 256

304
00:18:31,000 --> 00:18:34,000
moguće kombinacije 0S i 1s,

305
00:18:34,000 --> 00:18:37,000
i onda kad upišete char to će prevesti

306
00:18:37,000 --> 00:18:44,000
lik koji ulazi ste broj koji imate u ASCII tablici, kao Lexi, rekao je.

307
00:18:44,000 --> 00:18:48,000
Također imamo plovak, koje ćemo koristiti za pohranjivanje decimalnih brojeva.

308
00:18:48,000 --> 00:18:53,000
Ako želite izabrati 3,14, na primjer, idete na korištenje plovak

309
00:18:53,000 --> 00:18:55,000
ili dvaput da ima više preciznosti.

310
00:18:55,000 --> 00:18:57,000
Plovak ima 4 bajta.

311
00:18:57,000 --> 00:19:01,000
Bračni ima 8 bajtova, pa je jedina razlika je preciznost.

312
00:19:01,000 --> 00:19:04,000
Također smo dugo da se koristi za integers,

313
00:19:04,000 --> 00:19:09,000
i možete vidjeti za 32-bitni stroj int i dugo imati istu veličinu,

314
00:19:09,000 --> 00:19:13,000
tako da se to zapravo ne smisla koristiti dugo u 32-bitnom stroju.

315
00:19:13,000 --> 00:19:17,000
>> Ali ako koristite Mac i 64-bitni stroj, zapravo dugo je veličine 8,

316
00:19:17,000 --> 00:19:19,000
tako da stvarno ovisi o arhitekturi.

317
00:19:19,000 --> 00:19:22,000
Za 32-bitni stroj to ne bi imalo smisla koristiti dugo stvarno.

318
00:19:22,000 --> 00:19:25,000
A onda dugo dugo, s druge strane, ima 8 bajtova,

319
00:19:25,000 --> 00:19:30,000
tako da je vrlo dobra, ako želite imati više cijeli.

320
00:19:30,000 --> 00:19:34,000
I na kraju, imamo niz, što je zapravo char *,

321
00:19:34,000 --> 00:19:37,000
koji je pokazivač na char.

322
00:19:37,000 --> 00:19:40,000
To je vrlo jednostavno mislim da je veličina niza će biti poput

323
00:19:40,000 --> 00:19:42,000
broj znakova da ste tamo,

324
00:19:42,000 --> 00:19:45,000
ali zapravo char * sama

325
00:19:45,000 --> 00:19:49,000
ima veličinu od pokazivač na char, koji je 4 bajta.

326
00:19:49,000 --> 00:19:52,000
Veličina je char * je 4 bajta.

327
00:19:52,000 --> 00:19:56,000
Nije bitno ako imate malu riječ ili slovo ili ništa.

328
00:19:56,000 --> 00:19:58,000
To će biti 4 bajta.

329
00:19:58,000 --> 00:20:01,000
Također smo naučili nešto o lijevanje,

330
00:20:01,000 --> 00:20:04,000
pa kao što možete vidjeti, ako imate, na primjer, program koji kaže

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

332
00:20:08,000 --> 00:20:12,000
Imate li vi znate što će to ispisati na ekranu?

333
00:20:12,000 --> 00:20:14,000
>> Netko? >> [Studenti] 2.

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

335
00:20:16,000 --> 00:20:20,000
Kada to učinite 3/2 to će dobiti 1,5,

336
00:20:20,000 --> 00:20:24,000
ali budući da smo koristeći cijeli će to ignorirati decimalni dio,

337
00:20:24,000 --> 00:20:26,000
i ti ćeš imati jedan.

338
00:20:26,000 --> 00:20:29,000
Ako ne želite da se to dogodi što možete učiniti, primjerice,

339
00:20:29,000 --> 00:20:33,000
se proglasiti plovak y = x.

340
00:20:33,000 --> 00:20:40,000
Onda x koji se koriste da se 3 sada će biti 3,000 uy.

341
00:20:40,000 --> 00:20:44,000
I onda možete ispisati y / 2.

342
00:20:44,000 --> 00:20:50,000
Zapravo, ja bi trebao imati dva. tamo.

343
00:20:50,000 --> 00:20:55,000
To će učiniti 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
i ti si idući u dobiti 1,5.

345
00:20:58,000 --> 00:21:06,000
I mi imamo ovu 0,2 f samo pitati za dva decimalna jedinica u decimalnom dijelu.

346
00:21:06,000 --> 00:21:12,000
Ako imate 0,3 f to će imati zapravo 1,500.

347
00:21:12,000 --> 00:21:16,000
Ako je to dvoje to će biti 1,50.

348
00:21:16,000 --> 00:21:18,000
Također imamo ovaj slučaj ovdje.

349
00:21:18,000 --> 00:21:22,000
Ako to ne učinite plovak x = 3,14 i onda vi printf x

350
00:21:22,000 --> 00:21:24,000
ćete dobiti 3,14.

351
00:21:24,000 --> 00:21:29,000
A ako to ne učinite x = int X,

352
00:21:29,000 --> 00:21:34,000
što znači liječiti x kao int i ispisati x sada

353
00:21:34,000 --> 00:21:36,000
ćeš imati 3,00.

354
00:21:36,000 --> 00:21:38,000
Ima li to smisla?

355
00:21:38,000 --> 00:21:41,000
Zato vas prvi liječenju x kao cijeli broj, tako da ste ignoriranje decimalni dio,

356
00:21:41,000 --> 00:21:45,000
i onda ste tiskanje x.

357
00:21:45,000 --> 00:21:47,000
I na kraju, možete to učiniti,

358
00:21:47,000 --> 00:21:52,000
int x = 65, a zatim proglasiti char c = x,

359
00:21:52,000 --> 00:21:56,000
i onda ako ispisati c ste zapravo ide da biste dobili

360
00:21:56,000 --> 00:21:59,000
, Tako da u osnovi ono što radite ovdje

361
00:21:59,000 --> 00:22:02,000
je prevodio cijeli u karakteru,

362
00:22:02,000 --> 00:22:05,000
baš kao ASCII tablica radi.

363
00:22:05,000 --> 00:22:08,000
Također smo razgovarali o matematičkim operatorima.

364
00:22:08,000 --> 00:22:14,000
Većina od njih su prilično jednostavan, tako +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
i također smo razgovarali o mod, koji je ostatak podjele dva broja.

366
00:22:20,000 --> 00:22:23,000
Ako imate 10% 3, na primjer,

367
00:22:23,000 --> 00:22:27,000
to znači podijeliti 10 do 3, a ono što je ostatak?

368
00:22:27,000 --> 00:22:30,000
To će biti jedan, tako da je zapravo vrlo korisno za puno programa.

369
00:22:30,000 --> 00:22:38,000
Za Vigenère i Cezara sam prilično siguran da svi od vas koristi mod.

370
00:22:38,000 --> 00:22:43,000
O matematici operatorima, biti vrlo oprezni kada kombiniranjem * i /.

371
00:22:43,000 --> 00:22:48,000
>> Na primjer, ako učinite (3/2) * 2 što ćete dobiti?

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

373
00:22:50,000 --> 00:22:54,000
Da, 2, jer je 3/2 će biti 1,5,

374
00:22:54,000 --> 00:22:57,000
ali budući da radite poslovanje između dviju cjelobrojnih

375
00:22:57,000 --> 00:22:59,000
ste zapravo samo će razmotriti jedan,

376
00:22:59,000 --> 00:23:03,000
, a zatim 1 * 2 će biti 2, tako da se vrlo, vrlo oprezni

377
00:23:03,000 --> 00:23:07,000
kad radiš aritmetiku s brojeva jer

378
00:23:07,000 --> 00:23:12,000
možda ćete dobiti da 2 = 3, u tom slučaju.

379
00:23:12,000 --> 00:23:14,000
I također biti vrlo oprezni o prvenstva.

380
00:23:14,000 --> 00:23:21,000
Obično bi trebao koristiti zagrade kako bi bili sigurni da znate što radite.

381
00:23:21,000 --> 00:23:27,000
Neki korisni prečaci, naravno, jedan je ja + + ili ja + = 1

382
00:23:27,000 --> 00:23:30,000
ili pomoću + =.

383
00:23:30,000 --> 00:23:34,000
To je ista stvar kao i radiš i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Također mogu učiniti - ili ja - = 1,

385
00:23:39,000 --> 00:23:42,000
što je ista stvar kao i = i -1,

386
00:23:42,000 --> 00:23:46,000
nešto vi koristite puno u za petlje, barem.

387
00:23:46,000 --> 00:23:52,000
Također, za *, ako koristite * = a ako to ne učinite, na primjer,

388
00:23:52,000 --> 00:23:57,000
ja * = 2 je ista stvar kao govoreći i = i * 2,

389
00:23:57,000 --> 00:23:59,000
i ista stvar za podjelu.

390
00:23:59,000 --> 00:24:08,000
Ako to ne učinite i / = 2 to je ista stvar kao i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Sada o funkcijama.

392
00:24:10,000 --> 00:24:13,000
Vi saznao da su funkcije vrlo dobra strategija za spremanje koda

393
00:24:13,000 --> 00:24:16,000
dok ste programiranje, pa ako želite da obavljaju isti zadatak

394
00:24:16,000 --> 00:24:20,000
u kodu i opet, vjerojatno želite koristiti funkciju

395
00:24:20,000 --> 00:24:25,000
samo tako da ne morate kopirati i zalijepiti kôd iznova i iznova.

396
00:24:25,000 --> 00:24:28,000
Zapravo, glavna je funkcija, a kad sam vam pokazati format funkciji

397
00:24:28,000 --> 00:24:32,000
ćeš vidjeti da je to prilično očito.

398
00:24:32,000 --> 00:24:35,000
Mi također koristiti funkcije iz neke knjižnice,

399
00:24:35,000 --> 00:24:39,000
na primjer, printf, GetIn, koji je od CS50 knjižnice,

400
00:24:39,000 --> 00:24:43,000
i druge funkcije kao što su toupper.

401
00:24:43,000 --> 00:24:46,000
Sve one funkcije zapravo se provode u drugim knjižnicama,

402
00:24:46,000 --> 00:24:49,000
i kada ste stavili one tether datoteke u početku svog programa

403
00:24:49,000 --> 00:24:53,000
pričaš možete molim vas dajte mi kod za tih funkcija

404
00:24:53,000 --> 00:24:57,000
pa nemam ih provesti po sebi?

405
00:24:57,000 --> 00:25:00,000
A također možete napisati svoje vlastite funkcije, tako kada počnete programiranje

406
00:25:00,000 --> 00:25:04,000
shvatit ćete da knjižnice nemaju sve funkcije koje vam je potrebno.

407
00:25:04,000 --> 00:25:10,000
Za posljednjeg pset, na primjer, napisali smo izvući, otimati i pregledna,

408
00:25:10,000 --> 00:25:13,000
i to je vrlo, vrlo važno biti u stanju napisati funkcije

409
00:25:13,000 --> 00:25:17,000
jer oni su korisni, a mi ih koristiti sve vrijeme u programiranju,

410
00:25:17,000 --> 00:25:19,000
i to štedi puno koda.

411
00:25:19,000 --> 00:25:21,000
Oblik funkcije je ovo jedan.

412
00:25:21,000 --> 00:25:24,000
Imamo povratnu tip u početku. Što je povratni tip?

413
00:25:24,000 --> 00:25:27,000
To je samo kad je funkcija će vratiti.

414
00:25:27,000 --> 00:25:29,000
Ako imate neku funkciju, na primjer, faktorski,

415
00:25:29,000 --> 00:25:31,000
koji će se izračunati faktorijel cijeli broj,

416
00:25:31,000 --> 00:25:34,000
Vjerojatno će to vratiti integer također.

417
00:25:34,000 --> 00:25:37,000
Tada je povratni tip će biti int.

418
00:25:37,000 --> 00:25:41,000
Printf zapravo ima prazninu povratni tip

419
00:25:41,000 --> 00:25:43,000
jer niste vraća ništa.

420
00:25:43,000 --> 00:25:45,000
Vi samo tiskanje stvari na zaslonu

421
00:25:45,000 --> 00:25:48,000
i odvikavanje funkciju nakon toga.

422
00:25:48,000 --> 00:25:51,000
Tada imate naziv funkcije koje možete izabrati.

423
00:25:51,000 --> 00:25:55,000
Trebali bi biti malo razuman, kao što ne odabrati ime kao xyz

424
00:25:55,000 --> 00:25:58,000
ili kao x2f.

425
00:25:58,000 --> 00:26:02,000
Pokušajte čine ime koje ima smisla.

426
00:26:02,000 --> 00:26:04,000
>> Na primjer, ako je faktorijel, reći faktorijel.

427
00:26:04,000 --> 00:26:08,000
Ako je funkcija koja će izvući nešto, ime je privući.

428
00:26:08,000 --> 00:26:11,000
I onda imamo parametre, koji se također zove argumenti,

429
00:26:11,000 --> 00:26:14,000
koji su poput sredstava da funkcija treba

430
00:26:14,000 --> 00:26:17,000
iz kôda obavljati svoju zadaću.

431
00:26:17,000 --> 00:26:20,000
Ako želite izračunati faktorijel broja

432
00:26:20,000 --> 00:26:23,000
vjerojatno trebate imati broj izračunati faktorijel.

433
00:26:23,000 --> 00:26:27,000
Jedan od argumenata da idete da je broj sama.

434
00:26:27,000 --> 00:26:31,000
I onda se događa nešto učiniti i vratiti vrijednost na kraju

435
00:26:31,000 --> 00:26:35,000
osim ako je to praznina funkcija.

436
00:26:35,000 --> 00:26:37,000
Pogledajmo jedan primjer.

437
00:26:37,000 --> 00:26:40,000
Ako želim napisati funkciju koja sažima sve brojeve u niz brojeva,

438
00:26:40,000 --> 00:26:43,000
prije svega, povratak tip će biti int

439
00:26:43,000 --> 00:26:46,000
jer imam niz brojeva.

440
00:26:46,000 --> 00:26:51,000
I onda ću imati funkcije imena poput sumArray,

441
00:26:51,000 --> 00:26:54,000
i onda će se niz sama, na int nums,

442
00:26:54,000 --> 00:26:58,000
i onda je duljina niza tako da znam koliko brojevi moram zbrojiti.

443
00:26:58,000 --> 00:27:02,000
Onda moram inicijalizirati varijablu nazvanu iznos, na primjer, za 0,

444
00:27:02,000 --> 00:27:08,000
i svaki put vidim element u polju sam trebao dodati svemu, tako da sam učinio za petlju.

445
00:27:08,000 --> 00:27:15,000
Baš kao Lexi rekao, ti int i = 0, i <duljina i ja + +.

446
00:27:15,000 --> 00:27:20,000
A za svaki element u polju sam zbroj + = nums [i],

447
00:27:20,000 --> 00:27:24,000
i onda sam se vratio iznos, tako da je vrlo jednostavan, a to štedi puno koda

448
00:27:24,000 --> 00:27:28,000
ako koristite ovu funkciju mnogo puta.

449
00:27:28,000 --> 00:27:32,000
Tada mi je uzeo pogledati uvjetima.

450
00:27:32,000 --> 00:27:38,000
Imamo li, inače, i drugo, ako.

451
00:27:38,000 --> 00:27:42,000
Hajdemo vidjeti što je razlika između njih.

452
00:27:42,000 --> 00:27:45,000
Bacite pogled na ove dvije kodova. Koja je razlika između njih?

453
00:27:45,000 --> 00:27:49,000
Prvi je, u osnovi, šifre želim reći

454
00:27:49,000 --> 00:27:51,000
ako je broj +, -, ili 0.

455
00:27:51,000 --> 00:27:55,000
Prva kaže da ako je> 0 onda je pozitivno.

456
00:27:55,000 --> 00:28:00,000
Ako je = 0 do tada je 0, a ako je <0 tada je negativna.

457
00:28:00,000 --> 00:28:04,000
>> A drugi je taj ako, drugo ako drugdje.

458
00:28:04,000 --> 00:28:07,000
Razlika između dva je da je ovo jedan zapravo ide

459
00:28:07,000 --> 00:28:13,000
provjerite je li> 0, <0 ili = 0 tri puta,

460
00:28:13,000 --> 00:28:17,000
pa ako imate broj 2, na primjer, da će doći ovdje i reći

461
00:28:17,000 --> 00:28:21,000
if (x> 0), a to će reći da, tako sam ispisati pozitivno.

462
00:28:21,000 --> 00:28:25,000
No, iako znam da je> 0 i to ne će biti 0 ili <0

463
00:28:25,000 --> 00:28:29,000
Ja još uvijek idem napraviti je 0, to je <0,

464
00:28:29,000 --> 00:28:33,000
tako da sam zapravo idem unutar oklijevanja da nisam imao na

465
00:28:33,000 --> 00:28:38,000
jer sam već znamo da to ne ide kako bi zadovoljio bilo koji od ovih uvjeta.

466
00:28:38,000 --> 00:28:41,000
Ja mogu koristiti ako drugi ako drugi izjavu.

467
00:28:41,000 --> 00:28:45,000
To je u osnovi kaže da ako je x = 0 ja ispisali pozitivno.

468
00:28:45,000 --> 00:28:48,000
Ako to nije, ja ću također testirati.

469
00:28:48,000 --> 00:28:51,000
Ako to dvoje ne idem to učiniti.

470
00:28:51,000 --> 00:28:54,000
Uglavnom, ako sam imao x = 2 što će reći

471
00:28:54,000 --> 00:28:57,000
if (x> 0), da, tako ispiši.

472
00:28:57,000 --> 00:29:00,000
Sada znam da je> 0 i da je zadovoljan prvi ako

473
00:29:00,000 --> 00:29:02,000
Nisam čak će pokrenuti ovaj kod.

474
00:29:02,000 --> 00:29:09,000
Kod teče brže, zapravo, tri puta brže ako koristite to.

475
00:29:09,000 --> 00:29:11,000
Također smo naučili o i i ili.

476
00:29:11,000 --> 00:29:15,000
Neću ići kroz to, jer Lexi već razgovarali o njima.

477
00:29:15,000 --> 00:29:17,000
To je samo && i | | operatora.

478
00:29:17,000 --> 00:29:21,000
>> Jedino ću reći da je biti oprezan kada imate tri uvjeta.

479
00:29:21,000 --> 00:29:24,000
Koristite zagrade, jer to je vrlo zbunjujuće kada imate stanje

480
00:29:24,000 --> 00:29:27,000
i još jedan ili drugi.

481
00:29:27,000 --> 00:29:30,000
Koristite zagrade samo da bi bili sigurni da su Vaši uvjeti smisla

482
00:29:30,000 --> 00:29:34,000
jer u tom slučaju, na primjer, možete zamisliti da

483
00:29:34,000 --> 00:29:38,000
to može biti prvi uvjet i jedan ili drugi

484
00:29:38,000 --> 00:29:41,000
ili dvije uvjeti u kombinaciji i

485
00:29:41,000 --> 00:29:45,000
ili treći, pa samo budite oprezni.

486
00:29:45,000 --> 00:29:48,000
I konačno, razgovarali smo o prekidača.

487
00:29:48,000 --> 00:29:53,000
Prekidač je vrlo korisno kada imate varijablu.

488
00:29:53,000 --> 00:29:55,000
Recimo da imate varijablu kao n

489
00:29:55,000 --> 00:29:59,000
koji može biti 0, 1, ili 2, a za svaki od tih slučajeva

490
00:29:59,000 --> 00:30:01,000
ti si idući u obaviti zadatak.

491
00:30:01,000 --> 00:30:04,000
Možete reći prebaciti varijablu, a to ukazuje na to da

492
00:30:04,000 --> 00:30:08,000
vrijednost onda je kao vrijednost1 ću to učiniti,

493
00:30:08,000 --> 00:30:12,000
i onda sam razbiti, što znači da ne idem gledati na bilo koju od ostalih slučajeva

494
00:30:12,000 --> 00:30:15,000
jer smo već zadovoljni taj slučaj

495
00:30:15,000 --> 00:30:20,000
i onda vrijednost2 i tako dalje, i ja također mogu imati prekidač zadani.

496
00:30:20,000 --> 00:30:24,000
To znači da ako to ne zadovoljava bilo slučajeva da sam imao

497
00:30:24,000 --> 00:30:29,000
da ću raditi nešto drugo, ali to je opcionalno.

498
00:30:29,000 --> 00:30:36,000
To je sve za mene. Sada ćemo imati Tommy.

499
00:30:36,000 --> 00:30:41,000
U redu, ovo će biti tjedan 3-ish.

500
00:30:41,000 --> 00:30:45,000
Ovo su neke od tema koje će se pokrivaju, kripto, opseg polja, et cetera.

501
00:30:45,000 --> 00:30:49,000
Samo brzi riječ o Crypto. Nećemo čekić ovaj dom.

502
00:30:49,000 --> 00:30:52,000
>> Učinili smo to u pset dva, ali za kviz pobrinite se da znate razliku

503
00:30:52,000 --> 00:30:54,000
između Caesar šifra i Vigenère šifrirane,

504
00:30:54,000 --> 00:30:57,000
kako i od onih šifre posla i što ga je kao da šifriranje

505
00:30:57,000 --> 00:30:59,000
i dešifriranje teksta pomoću one dvije šifre.

506
00:30:59,000 --> 00:31:03,000
Podsjetimo, Cezarova šifra jednostavno rotira svaki lik za isti iznos,

507
00:31:03,000 --> 00:31:06,000
pazeći da MORH po broju slova u abecedi.

508
00:31:06,000 --> 00:31:09,000
I Vigenère šifra, s druge strane, rotira svaki lik

509
00:31:09,000 --> 00:31:12,000
različitom iznosu, pa umjesto da govori

510
00:31:12,000 --> 00:31:15,000
Svaki lik rotirati po tri Vigenère izmjenjivat će svaki lik

511
00:31:15,000 --> 00:31:17,000
različitom iznosu, ovisno o nekoj ključnoj riječi

512
00:31:17,000 --> 00:31:20,000
gdje svako slovo u ključnu riječ predstavlja neki drugi iznos

513
00:31:20,000 --> 00:31:26,000
rotirati jasan tekst.

514
00:31:26,000 --> 00:31:28,000
Idemo prvi razgovor o promjenjivom opsegu.

515
00:31:28,000 --> 00:31:30,000
Postoje dvije različite vrste varijabli.

516
00:31:30,000 --> 00:31:33,000
Imamo lokalne varijable, a to će se definirati

517
00:31:33,000 --> 00:31:36,000
izvan glavne ili izvan bilo funkciji ili bloku,

518
00:31:36,000 --> 00:31:39,000
a to će biti dostupna bilo gdje u svom programu.

519
00:31:39,000 --> 00:31:41,000
Ako imate neku funkciju, a tu funkciju je while petlja

520
00:31:41,000 --> 00:31:44,000
velika globalna varijabla je dostupna svugdje.

521
00:31:44,000 --> 00:31:48,000
Lokalna promjenljiva, s druge strane, je opfateno na mjesto gdje je definirano.

522
00:31:48,000 --> 00:31:53,000
>> Ako imate funkciju ovdje, na primjer, imamo ovu funkciju g,

523
00:31:53,000 --> 00:31:56,000
i unutar g je varijabla ovdje zove y,

524
00:31:56,000 --> 00:31:58,000
a to znači da je to lokalna varijabla.

525
00:31:58,000 --> 00:32:00,000
Iako je ova varijabla naziva y

526
00:32:00,000 --> 00:32:03,000
i to se zove varijabla y ove dvije funkcije

527
00:32:03,000 --> 00:32:06,000
nemam pojma što svaki drugi je lokalni varijable su.

528
00:32:06,000 --> 00:32:10,000
S druge strane, ovdje govorimo int x = 5,

529
00:32:10,000 --> 00:32:12,000
a to je izvan opsega bilo funkciju.

530
00:32:12,000 --> 00:32:16,000
To je izvan opsega glavna, tako da je ovo globalna varijabla.

531
00:32:16,000 --> 00:32:20,000
To znači da unutar tih dviju funkcija kad kažem x - ili x + +

532
00:32:20,000 --> 00:32:26,000
Ja sam pristupaju istom x čemu to y, a to y su različite varijable.

533
00:32:26,000 --> 00:32:30,000
To je razlika između globalne varijable i lokalne varijable.

534
00:32:30,000 --> 00:32:33,000
Što se tiče dizajna tiče, ponekad je vjerojatno bolja ideja

535
00:32:33,000 --> 00:32:37,000
držati varijable lokalne god možete eventualno

536
00:32:37,000 --> 00:32:39,000
budući da hrpa globalnih varijabli može dobiti stvarno zbunjujuće.

537
00:32:39,000 --> 00:32:42,000
Ako imate hrpu funkcija sve mijenjanja istu stvar

538
00:32:42,000 --> 00:32:45,000
možda zaboraviti što ako je ova funkcija slučajno modificira ovo globalno,

539
00:32:45,000 --> 00:32:47,000
i ovaj drugi funkcija ne znaju o tome,

540
00:32:47,000 --> 00:32:50,000
i to ne dobiti prilično zbunjujuće kao što ste dobili više koda.

541
00:32:50,000 --> 00:32:53,000
Imajući varijable lokalne god možete eventualno

542
00:32:53,000 --> 00:32:56,000
je samo dobar dizajn.

543
00:32:56,000 --> 00:33:00,000
Polja, zapamtite, jednostavno su popisi elemenata istog tipa.

544
00:33:00,000 --> 00:33:04,000
Unutar CI ne može imati popis kao jedan, 2,0, halo.

545
00:33:04,000 --> 00:33:06,000
Mi jednostavno ne možemo to učiniti.

546
00:33:06,000 --> 00:33:11,000
>> Kada smo proglasi niz u C sve elemente moraju biti istog tipa.

547
00:33:11,000 --> 00:33:14,000
Ovdje imam niz tri integers.

548
00:33:14,000 --> 00:33:18,000
Ovdje imam duljinu niza, ali ako ja sam samo to proglašenja u ovoj sintaksi

549
00:33:18,000 --> 00:33:21,000
gdje sam navesti što sve od elemenata ne tehnički je potrebna ova tri.

550
00:33:21,000 --> 00:33:25,000
Prevodilac je dovoljno pametan shvatiti koliko je velika polja bi trebala biti.

551
00:33:25,000 --> 00:33:28,000
Sada kada želim dobiti ili postavite vrijednost niz

552
00:33:28,000 --> 00:33:30,000
ovo je sintaksa za to.

553
00:33:30,000 --> 00:33:33,000
To će zapravo mijenjati drugi element niza, jer, ne zaboravite,

554
00:33:33,000 --> 00:33:36,000
Numeracija počinje na 0, a ne na jednoj.

555
00:33:36,000 --> 00:33:42,000
Ako želim čitati tu vrijednost mogu reći nešto poput int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Ili ako želim postaviti tu vrijednost, kao što radim ovdje,

557
00:33:44,000 --> 00:33:47,000
Ja mogu reći array [1] = 4.

558
00:33:47,000 --> 00:33:50,000
To vrijeme pristupa elemente svog indeksa

559
00:33:50,000 --> 00:33:52,000
ili njihov položaj ili gdje su u nizu,

560
00:33:52,000 --> 00:33:57,000
i da popis počinje na 0.

561
00:33:57,000 --> 00:34:00,000
Možemo također imaju polja od polja,

562
00:34:00,000 --> 00:34:03,000
i to se zove multi-dimenzionalni niz.

563
00:34:03,000 --> 00:34:05,000
Kada imamo multi-dimenzionalni niz

564
00:34:05,000 --> 00:34:07,000
to znači da možemo imati nešto poput redaka i stupaca,

565
00:34:07,000 --> 00:34:11,000
i to je samo jedan od načina vizualizacije ovo ili razmišljanja o tome.

566
00:34:11,000 --> 00:34:14,000
Kad imam multidimenzionalnu niz to znači da ću početi siromaštvo

567
00:34:14,000 --> 00:34:17,000
više od 1 indeks, jer ako imam mrežu

568
00:34:17,000 --> 00:34:19,000
Jednostavno govoreći ono red ste u ne daje nam broj.

569
00:34:19,000 --> 00:34:22,000
To je stvarno samo će nam dati popis brojeva.

570
00:34:22,000 --> 00:34:25,000
Recimo ja imam ovaj niz ovdje.

571
00:34:25,000 --> 00:34:30,000
Imam niz zove mrežu, a ja govorim to je dva reda i tri stupca,

572
00:34:30,000 --> 00:34:32,000
pa to je jedan od načina da ga vizualizaciju.

573
00:34:32,000 --> 00:34:37,000
Kad kažem želim da se element na [1] [2]

574
00:34:37,000 --> 00:34:41,000
to znači da, jer su redovi a zatim kolumne

575
00:34:41,000 --> 00:34:44,000
Ja ću skočiti na red jednom otkad sam rekao jednom.

576
00:34:44,000 --> 00:34:49,000
>> Onda ću doći ovamo na stupcu 2, a ja ću doći vrijednosti šest.

577
00:34:49,000 --> 00:34:51,000
Smisla?

578
00:34:51,000 --> 00:34:55,000
Multi-dimenzionalni nizovi, zapamtite, tehnički su samo niz polja.

579
00:34:55,000 --> 00:34:57,000
Mi možemo imati polja za polja u polja.

580
00:34:57,000 --> 00:35:00,000
Možemo zadržati ide, ali stvarno jedan način razmišljati o

581
00:35:00,000 --> 00:35:03,000
kako je to biti izložena i što se događa je da ga vizualizirati

582
00:35:03,000 --> 00:35:09,000
u mreži kao što je ovaj.

583
00:35:09,000 --> 00:35:12,000
Kada smo proći polja na funkcijama, oni će se ponašati

584
00:35:12,000 --> 00:35:16,000
malo drugačije nego kada smo proći redovite varijabli funkcije

585
00:35:16,000 --> 00:35:18,000
kao što prolazi jedan int ili plutaju.

586
00:35:18,000 --> 00:35:21,000
Kada smo proći u int ili char ili bilo koji od ovih drugih podataka tipova

587
00:35:21,000 --> 00:35:24,000
samo mi je uzeo pogledati ako funkcija mijenja

588
00:35:24,000 --> 00:35:28,000
Vrijednost te varijable da promjena ne ide s propagandom naših gore

589
00:35:28,000 --> 00:35:32,000
pozivatelju funkcije.

590
00:35:32,000 --> 00:35:35,000
Uz niz, s druge strane, to će se dogoditi.

591
00:35:35,000 --> 00:35:39,000
Ako sam proći u niz neke funkcije i da funkcija mijenja neki od elemenata,

592
00:35:39,000 --> 00:35:43,000
kad dođem do funkcije da ga se zove

593
00:35:43,000 --> 00:35:47,000
moja niz sada će biti drugačiji, a vokabular za to

594
00:35:47,000 --> 00:35:50,000
je nizovi su prošli pozivanjem, kao što ćemo kasnije vidjeti.

595
00:35:50,000 --> 00:35:53,000
To se odnosi na to kako pokazivače rada, gdje je ove osnovne vrste podataka,

596
00:35:53,000 --> 00:35:55,000
S druge strane, prenose po vrijednosti.

597
00:35:55,000 --> 00:35:59,000
>> Možemo misliti da je kao presnimavanje neke varijable, a zatim prolazi u kopiji.

598
00:35:59,000 --> 00:36:01,000
Nije bitno ono što radimo s tom varijablom.

599
00:36:01,000 --> 00:36:06,000
Zove funkcija neće biti svjesni da je to promijenilo.

600
00:36:06,000 --> 00:36:10,000
Nizovi su samo malo drugačiji u tom pogledu.

601
00:36:10,000 --> 00:36:13,000
Na primjer, kao što smo upravo vidjeli, glavna je jednostavno funkcija

602
00:36:13,000 --> 00:36:15,000
koji se može uzeti u dva argumenta.

603
00:36:15,000 --> 00:36:20,000
Prvi argument je glavna funkcija je argc, ili broj argumenata,

604
00:36:20,000 --> 00:36:23,000
a drugi argument je pozvao argv,

605
00:36:23,000 --> 00:36:27,000
i one su stvarne vrijednosti tih argumenata.

606
00:36:27,000 --> 00:36:30,000
Recimo imam program pod nazivom this.c,

607
00:36:30,000 --> 00:36:34,000
i ja reći da je ovo, a ja ću pokrenuti to na naredbenog retka.

608
00:36:34,000 --> 00:36:38,000
Sada da prođe u nekim argumentima da moj program se zove ovaj,

609
00:36:38,000 --> 00:36:42,000
Mogao bih reći nešto slično. / Ovo je cs 50.

610
00:36:42,000 --> 00:36:45,000
To je ono što možemo zamisliti David učiniti svaki dan na terminalu.

611
00:36:45,000 --> 00:36:48,000
No, sada je glavna funkcija unutar tog programa

612
00:36:48,000 --> 00:36:52,000
ima tih vrijednosti, pa argc je 4.

613
00:36:52,000 --> 00:36:56,000
To bi moglo biti malo zbunjujuće, jer stvarno mi samo ti prolazi u CS 50.

614
00:36:56,000 --> 00:36:58,000
To je samo tri.

615
00:36:58,000 --> 00:37:02,000
Ali zapamtite da je prvi element argv ili prvi argument

616
00:37:02,000 --> 00:37:05,000
je naziv funkcije same.

617
00:37:05,000 --> 00:37:07,190
Dakle, to znači da imamo 4 stvari ovdje,

618
00:37:07,190 --> 00:37:10,530
a prvi element će biti. / ovo.

619
00:37:10,530 --> 00:37:12,970
I to će biti predstavljeni kao niz.

620
00:37:12,970 --> 00:37:18,590
Tada su preostali elementi su ono što smo upisali u nakon naziva programa.

621
00:37:18,590 --> 00:37:22,720
Dakle, samo kao stranu, kao što smo vjerojatno vidjeli u pset 2,

622
00:37:22,720 --> 00:37:28,780
sjetite se da je string 50. ≠ se prirodni 50.

623
00:37:28,780 --> 00:37:32,520
Dakle, ne možemo reći nešto poput "int x = argv tri. '

624
00:37:32,520 --> 00:37:36,470
>> To je jednostavno ne ide smisla, jer je to niz, a to je cijeli broj.

625
00:37:36,470 --> 00:37:38,510
Dakle, ako želite pretvoriti između dva zapamtite, idemo

626
00:37:38,510 --> 00:37:40,810
imaju tu čarobnu funkciju zvanu atoi.

627
00:37:40,810 --> 00:37:46,270
To traje niz i vraća cijeli broj predstavlja unutar tog niza.

628
00:37:46,270 --> 00:37:48,360
Tako da je lako napraviti pogrešku na kvizu,

629
00:37:48,360 --> 00:37:51,590
samo razmišljam da je to automatski će biti točna vrsta.

630
00:37:51,590 --> 00:37:53,860
No, samo znam da je to uvijek će biti nizovi

631
00:37:53,860 --> 00:38:00,920
čak i ako je string sadrži samo cijeli broj ili karakter ili plutaju.

632
00:38:00,920 --> 00:38:03,380
Dakle, sada ćemo govoriti o prikazivati ​​vrijeme.

633
00:38:03,380 --> 00:38:06,700
Kada imamo sve te algoritme koji rade sve te lude stvari,

634
00:38:06,700 --> 00:38:11,580
postaje jako korisno postaviti pitanje, "Kako dugo su se?"

635
00:38:11,580 --> 00:38:15,500
Zastupnici smo da je s nečim što se zove asimptotski zapis.

636
00:38:15,500 --> 00:38:18,430
Dakle, to znači da - dobro, recimo dajemo naš algoritam

637
00:38:18,430 --> 00:38:20,840
neki stvarno, stvarno, stvarno veliki ulaz.

638
00:38:20,840 --> 00:38:23,840
Želimo postaviti pitanje: "Kako dugo će to trajati?

639
00:38:23,840 --> 00:38:26,370
Koliko koraka će ga odvesti našu algoritam za pokretanje

640
00:38:26,370 --> 00:38:29,980
kao funkcija veličine ulaza? "

641
00:38:29,980 --> 00:38:33,080
Dakle, prvi put možemo opisati pokrenuti vrijeme je sa velikim O.

642
00:38:33,080 --> 00:38:35,380
I to je naš najgori slučaj trčanje vrijeme.

643
00:38:35,380 --> 00:38:38,590
Dakle, ako želimo sortirati niz, i mi dati naš algoritam niz

644
00:38:38,590 --> 00:38:41,000
to je u silaznom redoslijedu, kada bi trebao biti u uzlaznom redoslijedu,

645
00:38:41,000 --> 00:38:43,130
to će biti najgori slučaj.

646
00:38:43,130 --> 00:38:49,800
To je naša gornja granica u maksimalnoj dužini vremena naš algoritam će se.

647
00:38:49,800 --> 00:38:54,740
S druge strane, ovo Ω će opisati najbolji slučaj, trčanje vremena.

648
00:38:54,740 --> 00:38:58,210
Dakle, ako smo dati već sortiran niz na sortiranje algoritma,

649
00:38:58,210 --> 00:39:00,940
koliko dugo će to trajati to sortirati?

650
00:39:00,940 --> 00:39:06,610
A to, onda, opisuje donju granicu prikazivati ​​vrijeme.

651
00:39:06,610 --> 00:39:10,980
Dakle, ovdje su samo neke riječi koje opisuju neke zajedničke pokrenute puta.

652
00:39:10,980 --> 00:39:13,120
To su u uzlaznom redoslijedu.

653
00:39:13,120 --> 00:39:16,060
Najbrže vrijeme rada imamo se zove konstantna.

654
00:39:16,060 --> 00:39:19,800
>> To znači da bez obzira koliko elementi dajemo naš algoritam,

655
00:39:19,800 --> 00:39:22,280
bez obzira koliko je velika naša polje je, to sortiranje

656
00:39:22,280 --> 00:39:26,510
ili što god radimo na polju uvijek će se isti iznos od vrijeme.

657
00:39:26,510 --> 00:39:30,270
Tako možemo izjavljujete da samo s jednom, što je konstanta.

658
00:39:30,270 --> 00:39:32,410
Također smo gledali logaritamske vrijeme izvođenja.

659
00:39:32,410 --> 00:39:34,800
Dakle, nešto poput binarnog pretraživanja je logaritamska,

660
00:39:34,800 --> 00:39:37,140
gdje smo smanjiti problem na pola svaki put

661
00:39:37,140 --> 00:39:40,970
i onda se stvari jednostavno dobiti veći od tamo.

662
00:39:40,970 --> 00:39:43,580
A ako ste ikada pisanju O bilo faktorijalnim algoritma,

663
00:39:43,580 --> 00:39:47,850
vjerojatno ne bi trebalo uzeti u obzir ovaj kao dan posao.

664
00:39:47,850 --> 00:39:53,910
Kad usporedimo pokrenute puta važno je imati na umu ove stvari.

665
00:39:53,910 --> 00:39:57,760
Dakle, ako sam algoritam koji je O (n), a netko drugi

666
00:39:57,760 --> 00:40:03,590
je algoritam O (2n) to su zapravo asimptotski ekvivalent.

667
00:40:03,590 --> 00:40:06,590
Dakle, ako možemo zamisliti n biti veliki broj kao eleventy milijardi:

668
00:40:06,590 --> 00:40:13,090
pa kad smo uspoređujući eleventy milijarde na nešto poput eleventy milijardi + 3,

669
00:40:13,090 --> 00:40:17,640
naglo 3 zapravo ne čine veliku razliku više.

670
00:40:17,640 --> 00:40:20,980
Zato ćemo za početak s obzirom da se ove stvari biti jednaka.

671
00:40:20,980 --> 00:40:24,220
So stvari poput tih konstanti ovdje, tamo je 2 x to, ili dodavanjem 3,

672
00:40:24,220 --> 00:40:27,180
ovo su samo konstante, a to će pasti gore.

673
00:40:27,180 --> 00:40:32,480
Dakle, to je razlog zašto sve tri od tih vožnji vremena su isti kao i govoreći da su O (n).

674
00:40:32,480 --> 00:40:37,490
Isto tako, ako imamo dvije druge run puta, recimo O (n ³ + 2n ²), možemo dodati

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, a onda imamo još jedan run vremena to je samo O (n ³).

676
00:40:42,070 --> 00:40:46,290
opet, to su ista stvar, jer to - to nisu isti.

677
00:40:46,290 --> 00:40:49,840
To su iste stvari, žao mi je. Dakle, to su isti, jer

678
00:40:49,840 --> 00:40:53,090
this n ³ će dominirati this 2n ².

679
00:40:53,090 --> 00:40:59,130
>> Ono što nije ista stvar je ako smo pokrenuti puta kao O (n ³) i O (n ²)

680
00:40:59,130 --> 00:41:02,820
jer je to n ³ je puno veći nego ove n ².

681
00:41:02,820 --> 00:41:05,470
Dakle, ako imamo eksponentima, odjednom to počne važno,

682
00:41:05,470 --> 00:41:08,280
ali kad smo tek bave čimbenicima kao što smo mi ovdje,

683
00:41:08,280 --> 00:41:12,810
onda to neće bitno jer se ide samo ispadne.

684
00:41:12,810 --> 00:41:16,760
Idemo pogledati neke od algoritama smo do sada vidjeli

685
00:41:16,760 --> 00:41:19,260
i govoriti o njihovom radnom vremenu.

686
00:41:19,260 --> 00:41:23,850
Prvi put u potrazi za brojem u popisu, koji smo vidjeli, bio linearan pretraživanje.

687
00:41:23,850 --> 00:41:26,950
A provedba linearnog potrazi je super jednostavan.

688
00:41:26,950 --> 00:41:30,490
Moramo samo popis, a mi ćemo gledati na svaki element u popisu

689
00:41:30,490 --> 00:41:34,260
dok smo pronašli broj tražimo.

690
00:41:34,260 --> 00:41:38,370
Dakle, to znači da je u najgorem slučaju, to O (n).

691
00:41:38,370 --> 00:41:40,860
A najgore ovdje slučaj mogao biti, ako je element

692
00:41:40,860 --> 00:41:45,710
zadnji element, a zatim pomoću linearne pretraživanje moramo gledati na svakog pojedinog elementa

693
00:41:45,710 --> 00:41:50,180
dok ne dođemo do posljednjeg, kako bi znali da je to zapravo u popisu.

694
00:41:50,180 --> 00:41:52,910
Ne možemo samo dati do pola puta i reći: "To je vjerojatno ne postoji."

695
00:41:52,910 --> 00:41:55,980
S linearno pretraživanje moramo gledati na cijelu stvar.

696
00:41:55,980 --> 00:41:59,090
Najbolji slučaja trčanje vrijeme, s druge strane, je konstanta

697
00:41:59,090 --> 00:42:04,200
jer u najboljem slučaju element tražimo je samo prvi na popisu.

698
00:42:04,200 --> 00:42:08,930
Dakle, to će nam trebati upravo jedan korak, bez obzira koliko je velik je popis

699
00:42:08,930 --> 00:42:12,140
ako smo u potrazi za prvi element, svaki put.

700
00:42:12,140 --> 00:42:15,390
>> Dakle, kada ste traženje zapamtite, to ne zahtijeva da naš popis biti riješeno.

701
00:42:15,390 --> 00:42:19,430
Jer mi jednostavno idemo gledati preko svakog pojedinog elementa, a to uopće nije važno

702
00:42:19,430 --> 00:42:23,560
što bi ti elementi su u.

703
00:42:23,560 --> 00:42:28,110
Više inteligentni algoritam za pretraživanje je nešto poput binarnog pretraživanja.

704
00:42:28,110 --> 00:42:31,500
Zapamtite, provedba binarnog pretraživanja je kad idete

705
00:42:31,500 --> 00:42:34,320
držati obličje na sredini popisa.

706
00:42:34,320 --> 00:42:38,000
I zato tražimo na sredini, tražimo da se popis sortira

707
00:42:38,000 --> 00:42:40,580
inače ne znamo gdje je srednji je, a mi moramo gledati preko

708
00:42:40,580 --> 00:42:44,480
cijeli popis da biste ga pronašli, a onda u tom trenutku mi smo samo gubljenje vremena.

709
00:42:44,480 --> 00:42:48,480
Dakle, ako imamo sortirani popis i mi naći sredinu, idemo usporediti sredinu

710
00:42:48,480 --> 00:42:51,590
na element tražimo.

711
00:42:51,590 --> 00:42:54,640
Ako je prevelik, onda možemo zaboraviti desnu polovicu

712
00:42:54,640 --> 00:42:57,810
jer znamo da ako je naš element je već previsoka

713
00:42:57,810 --> 00:43:01,080
i sve na desnoj strani tog elementa je čak i veći,

714
00:43:01,080 --> 00:43:02,760
onda mi ne trebamo gledati tamo više.

715
00:43:02,760 --> 00:43:05,430
Gdje s druge strane, ako je naš element je preniska,

716
00:43:05,430 --> 00:43:08,700
znamo sve na lijevoj strani tog elementa je također prenizak,

717
00:43:08,700 --> 00:43:11,390
tako da se to zapravo ne smisla gledati tamo, bilo.

718
00:43:11,390 --> 00:43:15,760
Na taj način, na svakom koraku i svaki put gledamo sredinu popisa,

719
00:43:15,760 --> 00:43:19,060
idemo smanjiti naš problem na pola jer odjednom mi znamo

720
00:43:19,060 --> 00:43:23,040
cijela hrpa brojeva koji ne može biti jedan tražimo.

721
00:43:23,040 --> 00:43:26,950
>> U pseudocode bi to izgledati nešto kao što je ovaj,

722
00:43:26,950 --> 00:43:30,990
i zato smo rezanja popisa u pola svaki put,

723
00:43:30,990 --> 00:43:34,920
naši najgorem slučaju mali vremenski skokovi iz linearno na logaritamski.

724
00:43:34,920 --> 00:43:39,260
Tako iznenada imamo log-u koracima kako bi se pronašli element u popisu.

725
00:43:39,260 --> 00:43:42,460
Najbolji-slučaj trčanje vrijeme, iako je još uvijek konstantna

726
00:43:42,460 --> 00:43:45,180
jer sada, neka je samo reći da je element tražimo je

727
00:43:45,180 --> 00:43:48,380
Uvijek je točno sredina na izvornom popisu.

728
00:43:48,380 --> 00:43:52,080
Tako možemo rasti naš popis velika kao što želimo, ali ako je element tražimo je u sredini,

729
00:43:52,080 --> 00:43:54,910
onda samo će nam trebati jedan korak.

730
00:43:54,910 --> 00:44:00,920
Tako da je razlog zašto smo O (log n) i Ω (1) ili konstanta.

731
00:44:00,920 --> 00:44:04,510
Ajmo zapravo pokrenuti binarni pretraživanje na ovom popisu.

732
00:44:04,510 --> 00:44:08,020
Pa recimo da smo u potrazi za element 164.

733
00:44:08,020 --> 00:44:11,650
Prva stvar koju ćemo učiniti je pronaći tačku ove liste.

734
00:44:11,650 --> 00:44:15,060
To samo tako dogodi da midpoint će pasti između tih dvaju brojeva,

735
00:44:15,060 --> 00:44:18,960
pa neka je samo proizvoljno reći, svaki put midpoint pada između dva broja,

736
00:44:18,960 --> 00:44:21,150
neka je samo zaokružiti.

737
00:44:21,150 --> 00:44:24,330
Trebamo samo kako bi bili sigurni smo to učinili svaki korak na putu.

738
00:44:24,330 --> 00:44:29,040
Dakle, mi ćemo zaokružiti, a mi ćemo reći da 161 je sredinom našem popisu.

739
00:44:29,040 --> 00:44:34,640
So 161 <164, i svaki element na lijevoj 161

740
00:44:34,640 --> 00:44:39,120
Također je <164, tako da znamo da to ne ide kako bi nam pomogli na sve

741
00:44:39,120 --> 00:44:42,690
za početak u potrazi ovamo jer element tražimo ne može biti tamo.

742
00:44:42,690 --> 00:44:47,060
Dakle, ono što možemo učiniti je možemo samo zaboraviti o toj cijeloj lijevoj polovici popisa,

743
00:44:47,060 --> 00:44:51,700
i sada u obzir samo iz desne strane 161 pa nadalje.

744
00:44:51,700 --> 00:44:54,050
>> Pa opet, to je srednji, neka je samo zaokružiti.

745
00:44:54,050 --> 00:44:56,260
Sada 175 je prevelika.

746
00:44:56,260 --> 00:44:59,180
Dakle, mi znamo da ne ide kako bi nam pomogli u potrazi ovdje ili ovdje,

747
00:44:59,180 --> 00:45:06,610
pa možemo samo bacanjem koje daleko, i na kraju ćemo pogoditi 164.

748
00:45:06,610 --> 00:45:10,560
Sva pitanja o binarnom traženja?

749
00:45:10,560 --> 00:45:14,180
Idemo od traženja kroz već sortirane liste

750
00:45:14,180 --> 00:45:17,660
zapravo uzimanje popis brojeva u bilo kojem redoslijedu

751
00:45:17,660 --> 00:45:20,960
i što taj popis u uzlaznom redoslijedu.

752
00:45:20,960 --> 00:45:24,060
Prvi algoritam gledali smo zvali balon vrsta.

753
00:45:24,060 --> 00:45:27,300
I to će biti jednostavnije od algoritama smo vidjeli.

754
00:45:27,300 --> 00:45:32,970
Bubble sorta kaže da kada bilo dva elementa unutar popisa su izvan mjesta,

755
00:45:32,970 --> 00:45:36,500
što znači da je veći broj na lijevoj manjim brojem,

756
00:45:36,500 --> 00:45:40,190
onda ćemo ih zamijeniti, jer to znači da će popis biti

757
00:45:40,190 --> 00:45:42,860
"Više sortiraju" nego što je bio prije.

758
00:45:42,860 --> 00:45:45,180
I mi smo samo će nastaviti taj proces opet i opet i opet

759
00:45:45,180 --> 00:45:52,100
dok na kraju elementi vrsta balona na njihovu ispravnu lokaciju i imamo sortirani popis.

760
00:45:52,100 --> 00:45:57,230
>> Run vrijeme će to biti O (n ²). Zašto?

761
00:45:57,230 --> 00:46:00,370
Pa, zato što u najgorem slučaju, idemo uzeti svaki element, a

762
00:46:00,370 --> 00:46:04,570
idemo završiti uspoređujući ga svaki drugi element u popisu.

763
00:46:04,570 --> 00:46:08,030
No, u najboljem slučaju, imamo već sortiran popis, bubble sorta je

764
00:46:08,030 --> 00:46:12,230
samo će proći kroz jednom, reći: "Ne. Nisam napravila nikakve zamjene, tako da sam učinio."

765
00:46:12,230 --> 00:46:17,410
Dakle, tu imamo najbolji slučaj, trčanje vremena Ω (n).

766
00:46:17,410 --> 00:46:20,680
Ajmo pokrenuti mjehurić vrsta na popisu.

767
00:46:20,680 --> 00:46:23,560
Ili prvi, neka je samo pogledati neke pseudocode jako brzo.

768
00:46:23,560 --> 00:46:28,160
Želimo reći želimo pratiti, u svakom iteracija petlje,

769
00:46:28,160 --> 00:46:32,190
pratiti hoće li ili ne možemo mijenjati nikakve elemente.

770
00:46:32,190 --> 00:46:37,610
Dakle razlog za to je, da ćemo prestati kad nismo zamijenili nikakve elemente.

771
00:46:37,610 --> 00:46:41,980
Tako je na početku našeg petlje nismo zamijenili ništa, pa ćemo reći da je lažna.

772
00:46:41,980 --> 00:46:47,170
Sada, idemo proći kroz popis i usporediti elemente i. elementa i + 1

773
00:46:47,170 --> 00:46:50,310
a ako je to slučaj da postoji veći broj lijevo od manjeg broja,

774
00:46:50,310 --> 00:46:52,310
onda smo tek će ih zamijeniti.

775
00:46:52,310 --> 00:46:54,490
>> A onda ćemo se sjetiti da smo zamijenili element.

776
00:46:54,490 --> 00:46:58,900
To znači da moramo proći kroz popis barem jedan više vremena

777
00:46:58,900 --> 00:47:02,160
jer stanje u kojem smo prestali kada je cijeli popis već sortiran,

778
00:47:02,160 --> 00:47:04,890
znači nismo napravili nikakve zamjene.

779
00:47:04,890 --> 00:47:09,960
Zato je naš uvjet ovdje dolje je ', dok su neki elementi su zamijenili. "

780
00:47:09,960 --> 00:47:13,720
Dakle, sada neka je samo pogledati ovo prikazivati ​​na popisu.

781
00:47:13,720 --> 00:47:16,640
Imam popis 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Bubble vrsta će početi skroz na lijevoj strani, a to će se usporediti

783
00:47:19,850 --> 00:47:24,700
I elementi, tako da od 0 do i + 1, što je element 1.

784
00:47:24,700 --> 00:47:29,020
To će reći, i 5> 0, ali sada je pet s lijeve strane,

785
00:47:29,020 --> 00:47:32,500
tako da moram zamijeniti 5 i 0.

786
00:47:32,500 --> 00:47:35,470
Kad sam ih zamijeniti, odjednom sam dobiti ovaj drugi popis.

787
00:47:35,470 --> 00:47:38,260
Sada 5> 1, pa ćemo ih zamijeniti.

788
00:47:38,260 --> 00:47:42,160
5 nije> 6, tako da ne moramo ništa učiniti ovdje.

789
00:47:42,160 --> 00:47:46,690
Ali 6> 4, tako da ćemo morati mijenjati.

790
00:47:46,690 --> 00:47:49,740
Opet, moramo pokrenuti kroz cijeli popis na kraju otkriti

791
00:47:49,740 --> 00:47:52,330
da su od reda, a mi ih zamijeniti,

792
00:47:52,330 --> 00:47:57,120
iu ovom trenutku moramo pokrenuti kroz popis 1 više vremena

793
00:47:57,120 --> 00:48:05,390
kako bi bili sigurni da je sve u svojoj redu, au ovom trenutku mjehurić kakve je završio.

794
00:48:05,390 --> 00:48:10,720
Drugačiji algoritam za uzimanje neke elemente te ih sortiranje je izbor vrsta.

795
00:48:10,720 --> 00:48:15,740
Ideja odabira vrste je da ćemo izgraditi sortirani dio popisa

796
00:48:15,740 --> 00:48:18,150
1 elementa na vrijeme.

797
00:48:18,150 --> 00:48:23,170
>> A način na koji ćemo učiniti da je izgradnjom lijevu segment popisu.

798
00:48:23,170 --> 00:48:27,510
I u osnovi, svaki - na svakom koraku, idemo uzeti najmanji element smo lijevo

799
00:48:27,510 --> 00:48:32,310
koji nije sortirani još, a mi ćemo ga premjestiti u taj poredani segmentu.

800
00:48:32,310 --> 00:48:35,850
To znači da moramo stalno pronaći minimalnu Unsorted elementa

801
00:48:35,850 --> 00:48:40,720
i onda se taj minimalni elemenat te ga zamijeniti s bilo

802
00:48:40,720 --> 00:48:45,090
lijevo-većina element koji nije riješeno.

803
00:48:45,090 --> 00:48:50,890
Run vrijeme će to biti O (n ²), jer u najgorem slučaju

804
00:48:50,890 --> 00:48:55,070
trebamo usporediti svaki jedan element koji bi svaki drugi element.

805
00:48:55,070 --> 00:48:59,250
Budući da smo rekavši da ako počnemo na lijevoj polovici liste, trebamo

806
00:48:59,250 --> 00:49:02,970
proći kroz cijelu desnu segmentu pronaći najmanji element.

807
00:49:02,970 --> 00:49:05,430
A onda, opet, trebamo ići preko cijelog pravo segment i

808
00:49:05,430 --> 00:49:08,210
zadržati ide preko toga iznova i iznova i iznova.

809
00:49:08,210 --> 00:49:11,350
To će biti n ². Mi ćemo morati za petlje unutar drugog za petlje

810
00:49:11,350 --> 00:49:13,350
što sugerira n ².

811
00:49:13,350 --> 00:49:16,530
U najboljem slučaju misli, ajmo reći da smo mu dati već sortiran popis;

812
00:49:16,530 --> 00:49:19,270
mi zapravo ne učiniti ništa bolje nego n ².

813
00:49:19,270 --> 00:49:21,730
Jer izbor vrsta nema načina znajući da

814
00:49:21,730 --> 00:49:25,540
minimalni element je samo jedan Ja se dogoditi da se gleda.

815
00:49:25,540 --> 00:49:28,970
To još uvijek treba kako bi bili sigurni da je to zapravo minimalna.

816
00:49:28,970 --> 00:49:31,670
>> A jedini način kako bi bili sigurni da je to minimum, koristeći ovaj algoritam,

817
00:49:31,670 --> 00:49:34,640
je da pogledate na svakom pojedinom elementu opet.

818
00:49:34,640 --> 00:49:38,420
Pa stvarno, ako ga dati - ako vam odabira Poredaj već sortiran popis,

819
00:49:38,420 --> 00:49:42,720
to neće učiniti bilo bolje nego dajući mu popis koji nije sortirani još.

820
00:49:42,720 --> 00:49:46,320
Usput, ako se dogodi da se u slučaju da nešto je O (nešto)

821
00:49:46,320 --> 00:49:50,640
i omega nešto, možemo samo reći više jezgrovito da je θ nečega.

822
00:49:50,640 --> 00:49:52,760
Dakle, ako vidite da se bilo gdje, to je ono što to samo znači.

823
00:49:52,760 --> 00:49:57,580
>> Ako je nešto theta n ², to je i veliki O (n ²) i Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
So najboljem slučaju i najgorem slučaju, to ne čine razliku,

825
00:49:59,790 --> 00:50:04,400
algoritam će učiniti istu stvar svaki put.

826
00:50:04,400 --> 00:50:06,610
Dakle, to je ono što pseudocode za izbor vrste mogao izgledati.

827
00:50:06,610 --> 00:50:10,630
Mi smo u osnovi ćeš reći da želim ponoviti tijekom popisa

828
00:50:10,630 --> 00:50:15,180
s lijeva na desno, a na svakoj iteraciju petlje, idem premjestiti

829
00:50:15,180 --> 00:50:19,780
minimalni elemenat u ovom sortirani dijelu liste.

830
00:50:19,780 --> 00:50:23,260
I kad sam premjestiti nešto postoji, ja nikada ne treba gledati u tom elementu opet.

831
00:50:23,260 --> 00:50:28,600
Jer čim sam zamijeniti element u na lijevom segmentu popisu, to razvrstani

832
00:50:28,600 --> 00:50:32,600
jer radimo sve što je u uzlaznom redoslijedu pomoću minimuma.

833
00:50:32,600 --> 00:50:38,740
Dakle, mi je rekao, ok, mi smo na sam položaj, a mi moramo gledati na sve elemente

834
00:50:38,740 --> 00:50:42,260
s desne strane ja kako bi se pronašli minimum.

835
00:50:42,260 --> 00:50:46,150
Dakle, to znači da želimo gledati iz I + 1 na kraju popisa.

836
00:50:46,150 --> 00:50:51,610
A sada, ako je element koji mi trenutno gledamo u manje od našeg minimum tako daleko,

837
00:50:51,610 --> 00:50:54,190
koja, zapamtite, mi smo početkom minimalnu off samo biti

838
00:50:54,190 --> 00:50:57,020
god Element smo trenutno na; ću pretpostaviti da je minimalna.

839
00:50:57,020 --> 00:51:00,270
Ako nađem element koji je manji od toga, onda ću reći, ok,

840
00:51:00,270 --> 00:51:02,700
dobro, ja sam pronašao novi minimum.

841
00:51:02,700 --> 00:51:06,080
Ja ću se sjetiti gdje je taj minimum.

842
00:51:06,080 --> 00:51:09,560
>> Tako sada, nakon što sam prošao kroz to pravo nerazvrstani segmentu,

843
00:51:09,560 --> 00:51:16,690
Ja mogu reći da ću zamijeniti minimalnu elementa s elementom koji je u sam položaju.

844
00:51:16,690 --> 00:51:21,100
To će izgraditi svoj popis, moj razvrstani dio popisa s lijeva na desno,

845
00:51:21,100 --> 00:51:25,190
a mi nikada ne trebamo gledati na elementu ponovno nakon što je u tom dijelu.

846
00:51:25,190 --> 00:51:27,930
Nakon što smo ga zamijenili.

847
00:51:27,930 --> 00:51:30,260
Tako ćemo pokrenuti izbor vrsta na ovom popisu.

848
00:51:30,260 --> 00:51:38,220
Plava je element ovdje će biti ja, a crveni element će biti minimalni element.

849
00:51:38,220 --> 00:51:41,570
Tako sam počinje skroz na lijevoj strani popisa, pa na pet.

850
00:51:41,570 --> 00:51:44,610
Sada moramo pronaći minimalnu Unsorted element.

851
00:51:44,610 --> 00:51:49,480
Dakle, mi kažu 0 <5, pa 0 je moj novi minimalna.

852
00:51:49,480 --> 00:51:53,820
>> Ali ja ne mogu zaustaviti, jer iako možemo prepoznati da 0 je najmanji,

853
00:51:53,820 --> 00:51:59,390
moramo pokrenuti kroz svaki drugi element popisa kako bi bili sigurni.

854
00:51:59,390 --> 00:52:01,760
Dakle 1 je veći, šest je veća, 4 veća.

855
00:52:01,760 --> 00:52:05,850
To znači da nakon što gleda na sve ove elemente, sam određuje 0 najmanja.

856
00:52:05,850 --> 00:52:09,800
Dakle, ja ću zamijeniti 5 i 0.

857
00:52:09,800 --> 00:52:15,480
Jednom sam zamijeniti da ću dobiti novi popis, a ja znam da ja nikada ne treba gledati u tom 0 opet

858
00:52:15,480 --> 00:52:19,380
jer jednom sam ga zamijenio, ja sam ga izdvojiti, a mi smo gotovi.

859
00:52:19,380 --> 00:52:22,730
Sada to samo tako dogodi da je plava element je opet 5,

860
00:52:22,730 --> 00:52:26,030
i trebamo gledati na 1, 6 i 4 kako bi se utvrdilo da je jedan

861
00:52:26,030 --> 00:52:31,520
je najmanji minimalni element, pa ćemo zamijeniti jedan i pet.

862
00:52:31,520 --> 00:52:36,890
Opet, moramo gledati na - usporediti 5 do 6 i 4,

863
00:52:36,890 --> 00:52:39,830
i mi ćemo zamijeniti 4 i 5, i na kraju, usporedite

864
00:52:39,830 --> 00:52:45,740
te dvije brojke i mijenjati ih dok ne dođemo našu sortirani popis.

865
00:52:45,740 --> 00:52:49,730
Sva pitanja o odabiru vrste?

866
00:52:49,730 --> 00:52:56,420
Ok. Idemo do posljednjeg temu ovdje, a to je rekurzije.

867
00:52:56,420 --> 00:52:59,810
>> Rekurzije, zapamtite, je li to doista meta stvar gdje funkcija

868
00:52:59,810 --> 00:53:02,740
puta sebe naziva.

869
00:53:02,740 --> 00:53:05,620
Dakle, u nekom trenutku, dok je naša fuction opetovano se zove,

870
00:53:05,620 --> 00:53:10,100
postoji potreba da se neke točke na kojoj smo zaustaviti se zove.

871
00:53:10,100 --> 00:53:13,670
Jer ako to ne učinimo, onda smo tek će nastaviti raditi zauvijek,

872
00:53:13,670 --> 00:53:16,660
i naš program samo ne ide prekinuti.

873
00:53:16,660 --> 00:53:19,200
Mi to nazivamo stanje baza slučaj.

874
00:53:19,200 --> 00:53:22,570
A osnovni slučaj, kaže, umjesto poziva funkciju ponovno,

875
00:53:22,570 --> 00:53:25,330
Samo ću se vratiti neku vrijednost.

876
00:53:25,330 --> 00:53:28,080
Dakle, nakon što smo se vratili vrijednost, prestali smo se zove,

877
00:53:28,080 --> 00:53:32,550
, a ostatak od poziva koje smo napravili do sada također može vratiti.

878
00:53:32,550 --> 00:53:36,050
Suprotnost osnovnom scenariju je rekurzivna slučaj.

879
00:53:36,050 --> 00:53:39,050
A to je kada želimo napraviti još jedan poziv na funkciju koju smo trenutno u.

880
00:53:39,050 --> 00:53:44,690
I mi smo vjerojatno, iako ne uvijek, želite koristiti različite argumente.

881
00:53:44,690 --> 00:53:48,940
>> Dakle, ako imamo funkciju pod nazivom f i f upravo zvao uzeti jedan argument,

882
00:53:48,940 --> 00:53:52,010
a mi samo zadržati poziv f (1), f (1), f (1), i to samo tako dogodi da

883
00:53:52,010 --> 00:53:56,510
the argument jednog pada u rekurzivni slučaju, mi smo još uvijek nikada neće prestati.

884
00:53:56,510 --> 00:54:01,620
Čak i ako imamo osnovni slučaj, moramo biti sigurni da na kraju idemo hit koji osnovnog scenarija.

885
00:54:01,620 --> 00:54:04,250
Mi ne samo zadržati ostanak u ovom slučaju rekurzivni.

886
00:54:04,250 --> 00:54:09,870
Općenito, kada smo se zovu, mi vjerojatno će imati drugačiji argument svaki put.

887
00:54:09,870 --> 00:54:12,700
Ovdje je stvarno jednostavan rekurzivna funkcija.

888
00:54:12,700 --> 00:54:15,090
Dakle, to će izračunati faktorijel broja.

889
00:54:15,090 --> 00:54:17,790
Do vrh ovdje imamo osnovni slučaj.

890
00:54:17,790 --> 00:54:22,330
U slučaju da n ≤ 1, nećemo zvati faktorijel opet.

891
00:54:22,330 --> 00:54:26,490
Idemo da se zaustavi, a mi se samo ćeš se vratiti neku vrijednost.

892
00:54:26,490 --> 00:54:30,170
Ako to nije istina, onda idemo pogoditi naše rekurzivna slučaj.

893
00:54:30,170 --> 00:54:33,550
Obavijest da se ovdje nismo samo zove faktorijel (n), jer to ne bi bilo vrlo korisno.

894
00:54:33,550 --> 00:54:36,810
Mi ćemo pozvati faktorijel nešto drugo.

895
00:54:36,810 --> 00:54:40,850
>> I tako da možete vidjeti, na kraju ako bismo proći faktorski (5) ili nešto,

896
00:54:40,850 --> 00:54:45,900
idemo zvati faktorijel (4) i tako dalje, i na kraju ćemo pogoditi ovaj osnovni slučaj.

897
00:54:45,900 --> 00:54:51,730
Dakle, ovo izgleda dobro. Idemo vidjeti što se događa kada smo zapravo pokrenuti ovo.

898
00:54:51,730 --> 00:54:57,840
Ovo je stog, a recimo da je glavni će pozvati ovu funkciju s argumentom (4).

899
00:54:57,840 --> 00:55:02,200
Tako jednom faktorijel vidi i = 4, faktorijel će se zvati.

900
00:55:02,200 --> 00:55:05,010
Sada, odjednom, imamo faktorijel (3).

901
00:55:05,010 --> 00:55:10,780
Dakle, ove funkcije će držati raste dok na kraju smo pogodak naš osnovni scenarij.

902
00:55:10,780 --> 00:55:17,830
U ovom trenutku, povratak vrijednost to je povratak (nx povratak vrijednost toga),

903
00:55:17,830 --> 00:55:21,290
povratak vrijednost je ovo nx povratak vrijednost toga.

904
00:55:21,290 --> 00:55:23,290
Na kraju moramo pogoditi neki broj.

905
00:55:23,290 --> 00:55:26,560
Na vrhu ovdje, možemo reći povratak jednog.

906
00:55:26,560 --> 00:55:30,650
To znači da nakon što smo se vratili taj broj, možemo pop ovo off stog.

907
00:55:30,650 --> 00:55:36,570
Dakle, to faktorijel (1) se obavlja.

908
00:55:36,570 --> 00:55:41,190
Kad jednom vraća, ovaj faktorijel (1) vraća, ovaj povratak na jedan.

909
00:55:41,190 --> 00:55:46,910
Povratak vrijednost toga, zapamtite, bio je nx povratak vrijednost toga.

910
00:55:46,910 --> 00:55:50,720
Dakle, odjednom, taj čovjek zna da želim vratiti dva.

911
00:55:50,720 --> 00:55:55,910
>> Tako zapamtite, vratiti vrijednost to je samo nx povratna vrijednost se ovdje.

912
00:55:55,910 --> 00:56:01,160
Tako sada možemo reći 3 x 2, i konačno, ovdje možemo reći

913
00:56:01,160 --> 00:56:04,010
to samo će biti 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
I jednom kada je taj povrat, dobili smo dolje na jednu integer unutrašnjosti glavni.

915
00:56:09,570 --> 00:56:15,460
Sva pitanja o rekurzije?

916
00:56:15,460 --> 00:56:17,090
U redu. Dakle, tu je više vremena za pitanja na kraju,

917
00:56:17,090 --> 00:56:23,360
ali sada Josip pokrit će preostale teme.

918
00:56:23,360 --> 00:56:25,590
>> [Josip Ong] U redu. Dakle, sada kada smo razgovarali o recursions,

919
00:56:25,590 --> 00:56:27,840
pričajmo malo o tome što spajanje vrsta je.

920
00:56:27,840 --> 00:56:31,740
Spoji vrsta je u osnovi još jedan način sortiranja popis brojeva.

921
00:56:31,740 --> 00:56:36,430
A kako se to radi je, uz spajanje kakve imate popis, a ono što mi radimo je

922
00:56:36,430 --> 00:56:39,120
kažemo, ajmo podijeliti to u dvije polovice.

923
00:56:39,120 --> 00:56:42,750
Mi smo prvi put će pokrenuti spajanje vrsta ponovno na lijevoj polovici,

924
00:56:42,750 --> 00:56:45,040
onda ćemo pokrenuti spajanje vrsta na desnoj polovici,

925
00:56:45,040 --> 00:56:50,240
i da nam daje sada dvije polovice koje su raspoređene, a sada ćemo kombinirati one polovice zajedno.

926
00:56:50,240 --> 00:56:55,010
To je malo teško vidjeti bez primjer, pa ćemo proći kroz prijedloge i vidjeti što se događa.

927
00:56:55,010 --> 00:56:59,590
Dakle, početi s ovog popisa, mi ga podijeliti na dva dijela.

928
00:56:59,590 --> 00:57:02,300
Mi smo mali spojiti vrsta na lijevoj polovici prvi.

929
00:57:02,300 --> 00:57:06,660
Tako da je lijeva polovica, a sada smo ih izvoditi kroz ovaj popis opet

930
00:57:06,660 --> 00:57:09,800
koji dobiva prošao u spajanje vrste, a zatim gledamo, opet,

931
00:57:09,800 --> 00:57:13,270
Na lijevoj strani tog popisa, a mi pokrenuti spajanje vrsta na njega.

932
00:57:13,270 --> 00:57:15,880
Sada smo se dolje na popisu dva broja,

933
00:57:15,880 --> 00:57:19,010
i sada lijeva polovica je samo jedan element koji dugo, a mi ne možemo

934
00:57:19,010 --> 00:57:23,380
podijeliti popis koji je samo jedan element koji u poluvremenu, tako da smo samo reći, jednom smo 50,

935
00:57:23,380 --> 00:57:26,400
što je samo jedan element, to je već riješeno.

936
00:57:26,400 --> 00:57:29,860
>> Nakon što smo učinili s tim, možemo vidjeti što možemo

937
00:57:29,860 --> 00:57:32,230
premjestiti na desnoj polovici ove liste,

938
00:57:32,230 --> 00:57:36,480
i 3 također razvrstani, i tako sada da su obje polovice ovog popisa razvrstani

939
00:57:36,480 --> 00:57:39,080
možemo pridružiti te brojeve natrag zajedno.

940
00:57:39,080 --> 00:57:45,320
Tako smo pogledati 50 i 3; 3 je manji od 50, tako to ide u prvi, a zatim 50 dolazi u.

941
00:57:45,320 --> 00:57:49,340
Sada, što je učinio, a mi se vratiti do tog popisa i vrsta To je pravo pola.

942
00:57:49,340 --> 00:57:52,440
42 je da je vlastiti broj, tako da je već riješeno.

943
00:57:52,440 --> 00:57:57,850
Dakle, sada smo usporediti ove 2 i 3 je manji od 42, tako da se stavi u prvi,

944
00:57:57,850 --> 00:58:02,340
Sada 42 dobiva staviti u, a 50 se stavi u.

945
00:58:02,340 --> 00:58:07,220
Sada, koji je sortiran, idemo sve na putu natrag do vrha, 1337 i 15.

946
00:58:07,220 --> 00:58:14,560
Pa, mi smo sada gledati na lijevoj polovici ove liste; 1337 je sama po sebi tako da je izdvojiti i isto sa 15.

947
00:58:14,560 --> 00:58:19,020
Dakle, sada smo kombinirati ove dvije brojeva sortirati to da je izvorni popis, 15 <1.337,

948
00:58:19,020 --> 00:58:23,060
tako to ide u prvi, a zatim 1337 ide u.

949
00:58:23,060 --> 00:58:26,640
I sada smo razvrstani u oba poluvremena na izvornom popisu do vrha.

950
00:58:26,640 --> 00:58:30,440
I sve što morate učiniti je kombinirati ove.

951
00:58:30,440 --> 00:58:36,890
Mi gledamo na prvih dvaju brojeva ovom popisu, 3 <15, tako to ide u sortiranja niza prvi.

952
00:58:36,890 --> 00:58:44,460
15 <42, tako to ide u. Sada, 42 <1.337, koji ide u.

953
00:58:44,460 --> 00:58:51,010
50 <1.337, tako to ide u. I primijetiti da smo upravo uzeo 2 broja s ovog popisa.

954
00:58:51,010 --> 00:58:53,640
Dakle, mi ne samo izmjenične između dva popisa.

955
00:58:53,640 --> 00:58:56,050
Mi samo tražimo na početku, a mi smo vodeći element

956
00:58:56,050 --> 00:59:00,270
to je manji, a zatim ga stavite u naš niz.

957
00:59:00,270 --> 00:59:04,080
Sada smo spojili sve poluvremena, a mi smo gotovi.

958
00:59:04,080 --> 00:59:07,780
>> Sva pitanja oko spajanja vrsta? Da?

959
00:59:07,780 --> 00:59:14,190
[Studentski] Ako je cijepanje u različite grupe, zašto jednostavno ne ga podijeliti jednom

960
00:59:14,190 --> 00:59:19,970
i imate 3 i 2 u skupini? [Ostatak pitanje nerazumljivo]

961
00:59:19,970 --> 00:59:24,940
Razlog - pa je pitanje, zašto ne možemo ih samo spojiti na tom prvom koraku nakon što smo ih imati?

962
00:59:24,940 --> 00:59:29,530
Razlog možemo to učiniti, početi na lijevom većini elemenata obje strane,

963
00:59:29,530 --> 00:59:33,040
i onda uzeti manji jedan i stavite ga u, jest da mi znamo da to

964
00:59:33,040 --> 00:59:35,290
pojedinačni popisi su u razvrstanih naloga.

965
00:59:35,290 --> 00:59:37,290
Dakle, ako sam u potrazi na lijevoj većini elemenata oba poluvremena,

966
00:59:37,290 --> 00:59:40,490
Znam da ćemo biti najmanji elementi tih popisa.

967
00:59:40,490 --> 00:59:43,930
Tako sam ih možete staviti u najmanji element spotova ovog velikog popisa.

968
00:59:43,930 --> 00:59:47,810
S druge strane, ako gledam one dvije liste u drugoj razini tamo,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 i 15, oni nisu sortirani.

970
00:59:51,640 --> 00:59:55,770
Dakle, ako sam pogled na 50 i 1337, ja ću staviti 50 u mom popisu prvi.

971
00:59:55,770 --> 01:00:00,130
No, to zapravo ne smisla, jer tri je najmanji element od svih onih.

972
01:00:00,130 --> 01:00:04,390
Dakle, jedini razlog možemo napraviti ovaj korak je kombiniranje jer su naši popisi već su razvrstani.

973
01:00:04,390 --> 01:00:07,010
Koji je razlog zašto moramo sići sve do dna

974
01:00:07,010 --> 01:00:09,800
jer kad imamo samo jedan broj, znaš da jedan broj

975
01:00:09,800 --> 01:00:14,120
i sama je već razvrstani popis.

976
01:00:14,120 --> 01:00:19,360
>> Ima li pitanja? No?

977
01:00:19,360 --> 01:00:24,260
Kompleksnost? Pa, možete vidjeti da je na svakom koraku postoji kraj brojevi,

978
01:00:24,260 --> 01:00:27,590
a možemo podijeliti popis na pola dnevnika n puta,

979
01:00:27,590 --> 01:00:31,700
što je, gdje smo dobili ovaj dnevnik n x n složenost.

980
01:00:31,700 --> 01:00:34,940
I vidjet ćete najbolji slučaj za spajanje kakve je n log n, i to samo tako dogodi

981
01:00:34,940 --> 01:00:39,340
da je najgori slučaj, ili Ω tamo, također je n prijavite n.

982
01:00:39,340 --> 01:00:42,480
Nešto treba imati na umu.

983
01:00:42,480 --> 01:00:45,750
Premještanje na, ajmo na neki super osnovnom datoteku I / O.

984
01:00:45,750 --> 01:00:48,830
Ako ste gledali na Scramble, primijetit ćete da je imao nekakvu sustava

985
01:00:48,830 --> 01:00:51,270
gdje se može pisati log datoteku, ako ste pročitali kroz koda.

986
01:00:51,270 --> 01:00:53,730
Idemo vidjeti kako biste mogli učiniti.

987
01:00:53,730 --> 01:00:57,450
Pa, imamo fprintf, koje možete misliti samo kao printf,

988
01:00:57,450 --> 01:01:01,720
ali samo ispisa u datoteku umjesto, a time i ž na početku.

989
01:01:01,720 --> 01:01:07,570
Ova vrsta koda ovdje, što to je, kao što ste mogli vidjeti u Scramble,

990
01:01:07,570 --> 01:01:12,310
to ide kroz 2-dimenzionalnog polja ispis iz red ono što su brojevi.

991
01:01:12,310 --> 01:01:17,850
U ovom slučaju, printf ispisuje na vašem terminalu ili ono što mi zovemo standardni izlaz dijelu.

992
01:01:17,850 --> 01:01:22,170
>> I sada, u ovom slučaju, sve što morate učiniti je zamijeniti printf s fprintf,

993
01:01:22,170 --> 01:01:26,770
ga reći što datoteke želite ispisati, au ovom slučaju to je samo ga ispisuje na tu datoteku

994
01:01:26,770 --> 01:01:32,230
umjesto da ga ispisuje na terminalu.

995
01:01:32,230 --> 01:01:36,500
Pa, onda postavlja pitanje: Odakle smo dobili ovu vrstu datoteke iz, zar ne?

996
01:01:36,500 --> 01:01:39,840
Mi smo prošli prijavite u ovom fprintf fuction, ali nismo imali pojma gdje je došao iz.

997
01:01:39,840 --> 01:01:43,980
Pa, rano u kodu, ono što smo imali je bio ovaj komad koda ovamo,

998
01:01:43,980 --> 01:01:48,340
koji u osnovi kaže da otvorite datoteku naziva log.txt.

999
01:01:48,340 --> 01:01:53,220
Što nam je činiti nakon toga je moramo biti sigurni da je datoteka je zapravo otvorena uspješno.

1000
01:01:53,220 --> 01:01:57,070
Dakle, to bi moglo uspjeti zbog više razloga, nemate dovoljno prostora na vašem računalu, na primjer.

1001
01:01:57,070 --> 01:01:59,790
Dakle, to je uvijek važno učiniti prije nego što sve operacije s datotekom

1002
01:01:59,790 --> 01:02:03,300
da smo provjerili da li da je datoteka otvorena uspješno.

1003
01:02:03,300 --> 01:02:09,330
Pa što da je, to je argument za fopen, dobro, možemo otvoriti datoteku na mnoge načine.

1004
01:02:09,330 --> 01:02:13,510
Ono što možemo učiniti je, možemo proći ona w, što znači nadjačati datoteku ako to već izlazi,

1005
01:02:13,510 --> 01:02:18,070
Možemo proći A, koje se dodaje na kraju datoteke, umjesto da ga preskakanja,

1006
01:02:18,070 --> 01:02:22,730
ili možemo odrediti r, što znači, ajmo otvoriti datoteku samo za čitanje.

1007
01:02:22,730 --> 01:02:24,890
Dakle, ako se program pokušava napraviti nikakve promjene u datoteci,

1008
01:02:24,890 --> 01:02:30,140
vikati na njih i ne dopustiti da ih to učiniti.

1009
01:02:30,140 --> 01:02:33,320
Konačno, nakon što smo gotovi sa spisom, učinio radi operacije na njemu,

1010
01:02:33,320 --> 01:02:35,860
trebamo kako bi bili sigurni smo zatvorite datoteku.

1011
01:02:35,860 --> 01:02:38,830
I tako je na kraju svog programa, od vas će proći ih opet

1012
01:02:38,830 --> 01:02:42,120
ovo datoteku koju ste otvorili, a samo ga zatvoriti.

1013
01:02:42,120 --> 01:02:44,650
Dakle, ovo je nešto važno da imate kako biste bili sigurni što učiniti.

1014
01:02:44,650 --> 01:02:47,180
Tako zapamtite možete otvoriti datoteku, onda možete pisati u datoteku,

1015
01:02:47,180 --> 01:02:51,270
učiniti poslovanje u spisu, ali onda morate zatvoriti datoteku na kraju.

1016
01:02:51,270 --> 01:02:53,270
>> Sva pitanja o osnovnom datoteku I / O? Da?

1017
01:02:53,270 --> 01:02:58,050
[Studentski pitanje, nerazumljivo]

1018
01:02:58,050 --> 01:03:02,480
Upravo ovdje. Pitanje je, gdje je to log.txt file pojaviti?

1019
01:03:02,480 --> 01:03:07,890
Pa, ako ste samo dati log.txt, on ga stvara u istom direktoriju kao i izvršna.

1020
01:03:07,890 --> 01:03:10,500
Dakle, ako ti si - >> [Studentski pitanje, nerazumljivo]

1021
01:03:10,500 --> 01:03:18,830
Da. U istoj mapi, ili u istom direktoriju, kao što ga zovu.

1022
01:03:18,830 --> 01:03:21,400
Sada memorije, stog i hrpa.

1023
01:03:21,400 --> 01:03:23,400
Pa kako je memorija izneseno u računalu?

1024
01:03:23,400 --> 01:03:26,270
Pa, možete zamisliti memorije kao svojevrsno ovom bloku ovdje.

1025
01:03:26,270 --> 01:03:30,260
A u sjećanju mi ​​imamo ono što se zove hrpu zapela tamo, i stog koji je tamo dolje.

1026
01:03:30,260 --> 01:03:34,480
I hrpa raste prema dolje i stog raste prema gore.

1027
01:03:34,480 --> 01:03:38,620
Dakle, kao što je spomenuto Tommy - oh, dobro, i mi imamo ove druge četiri segmenta koji ću dobiti u drugi -

1028
01:03:38,620 --> 01:03:42,890
Kao što je Tommy rekao ranije, znate kako njegovi funkcije zovu i zovu jedni druge?

1029
01:03:42,890 --> 01:03:44,930
Oni izgraditi ovu vrstu stog okvira.

1030
01:03:44,930 --> 01:03:47,360
Pa, ako je glavni pozivi foo, foo dobiva staviti na stog.

1031
01:03:47,360 --> 01:03:52,430
Foo poziva, bar bi je staviti na hrpu, i da se stavi na hrpu poslije.

1032
01:03:52,430 --> 01:03:57,040
I kao što su se vratili, oni svaki se skinut snop.

1033
01:03:57,040 --> 01:04:00,140
Što svaki od tih lokacija i memorije držite?

1034
01:04:00,140 --> 01:04:03,110
Pa, na vrhu, koji je tekst segment sadrži samog programa.

1035
01:04:03,110 --> 01:04:06,390
Dakle strojnom kodu, da je tamo, nakon što sastaviti svoj program.

1036
01:04:06,390 --> 01:04:08,520
Dalje, bilo inicijaliziran globalne varijable.

1037
01:04:08,520 --> 01:04:12,660
>> Tako ćete imati globalne varijable u svom programu, a vi kao recimo, a = 5,

1038
01:04:12,660 --> 01:04:15,260
da se stavi u tom segmentu, a odmah ispod toga,

1039
01:04:15,260 --> 01:04:18,990
imate nepokrenute globalne podatke, koje je samo int,

1040
01:04:18,990 --> 01:04:20,990
ali ne kažu da je jednaka ništa.

1041
01:04:20,990 --> 01:04:23,870
Shvatite to su globalne varijable, tako da su oni izvan glavne.

1042
01:04:23,870 --> 01:04:28,560
Dakle, to znači sve globalne varijable koje su deklarirane, ali se ne ponište.

1043
01:04:28,560 --> 01:04:32,310
Dakle, ono što je u gomili? Memorija dodijeljena koristeći malloc, što ćemo dobiti u malo.

1044
01:04:32,310 --> 01:04:35,990
I na kraju, s hrpom imate lokalne varijable

1045
01:04:35,990 --> 01:04:39,950
i sve funkcije koje bi se moglo nazvati u bilo kojem od njihovih parametara.

1046
01:04:39,950 --> 01:04:43,720
Posljednja stvar, ne stvarno morati znati što učiniti varijable okruženja,

1047
01:04:43,720 --> 01:04:46,700
ali kad god pokrenete program, postoji nešto povezana, kao što su

1048
01:04:46,700 --> 01:04:49,550
to je ime osobe koja je tekla program.

1049
01:04:49,550 --> 01:04:51,550
I to će biti vrsta na dnu.

1050
01:04:51,550 --> 01:04:54,540
U smislu memorijske adrese, koji su heksadecimalni vrijednosti,

1051
01:04:54,540 --> 01:04:58,170
vrijednosti u gornjem početka na 0, a oni idu skroz do dna.

1052
01:04:58,170 --> 01:05:00,440
U tom slučaju, ako ste na 32-bitnom sustavu,

1053
01:05:00,440 --> 01:05:05,390
Adresa na dnu će biti 0x, nakon čega slijedi af, jer to je 32 bita,

1054
01:05:05,390 --> 01:05:10,890
što je 8 bajtova, au ovom slučaju osam bajtova odgovara 8 heksadecimalni znamenki.

1055
01:05:10,890 --> 01:05:20,110
Dakle, ovdje ćete imati, kao, 0xffffff, i tamo ćeš imati 0.

1056
01:05:20,110 --> 01:05:23,660
Dakle, ono što su pokazivače? Neki od vas možda nisu obuhvaćeni to u dijelu prije.

1057
01:05:23,660 --> 01:05:26,660
ali mi nije ići preko njega u predavanju, tako da pokazivač je samo vrsta podataka

1058
01:05:26,660 --> 01:05:34,030
koji pohranjuje, umjesto nekakvoj vrijednosti kao što su 50, pohranjuje adresu nekom mjestu u memoriji.

1059
01:05:34,030 --> 01:05:36,020
Poput onog memorije [nerazumljivo].

1060
01:05:36,020 --> 01:05:41,120
Dakle, u ovom slučaju, ono što smo je, imamo pokazivač na cijeli broj ili int *,

1061
01:05:41,120 --> 01:05:46,210
i sadrži ovu heksadecimalni adresu 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Dakle, ono što imamo je, sada, ovaj pokazivač bodova na nekom mjestu u memoriji,

1063
01:05:50,880 --> 01:05:56,020
i to je samo, vrijednost 50 je u ovom memorijske lokacije.

1064
01:05:56,020 --> 01:06:01,810
Na nekim 32-bitne sustave, na svim 32-bitnim sustavima, upućuje zauzimaju 32 bita ili 4 bajta.

1065
01:06:01,810 --> 01:06:06,020
Ali, na primjer, na 64-bitni sustav, pokazivači su 64 bita.

1066
01:06:06,020 --> 01:06:08,040
Dakle, to je nešto što ćete želite imati na umu.

1067
01:06:08,040 --> 01:06:12,310
Dakle, na kraju-bitnom sustavu, pokazivač je kraj bita dugo.

1068
01:06:12,310 --> 01:06:17,320
Pokazivači su vrsta teško probaviti bez dodatne stvari,

1069
01:06:17,320 --> 01:06:20,300
pa ajmo kroz primjer dinamička dodjela memorije.

1070
01:06:20,300 --> 01:06:25,130
Što dinamička dodjela memorije radi za vas, ili ono što mi zovemo malloc,

1071
01:06:25,130 --> 01:06:29,280
to vam omogućuje da dodijeliti neku vrstu podataka izvan seta.

1072
01:06:29,280 --> 01:06:31,830
Dakle, taj podatak je svojevrsna više stalnih za vrijeme trajanja programa.

1073
01:06:31,830 --> 01:06:36,430
Jer kao što znate, ako proglasiti x unutar jedne funkcije i da funkcija vraća,

1074
01:06:36,430 --> 01:06:40,910
više nemate pristup podacima koje je pohranjenih u x.

1075
01:06:40,910 --> 01:06:44,420
Što upućuje činimo je da neka nam pohranu memorije ili pohraniti vrijednosti

1076
01:06:44,420 --> 01:06:46,840
u drugom dijelu memorije, naime hrpa.

1077
01:06:46,840 --> 01:06:49,340
Sada kada smo se vratili izvan funkcije, dok imamo pokazivač

1078
01:06:49,340 --> 01:06:54,960
na toj lokaciji u memoriji, onda ono što možemo učiniti je možemo samo gledati na vrijednosti tamo.

1079
01:06:54,960 --> 01:06:58,020
Pogledajmo primjer: Ovo je naša memorija izgleda opet.

1080
01:06:58,020 --> 01:07:00,050
I mi imamo tu funkciju, glavni.

1081
01:07:00,050 --> 01:07:06,870
Što je to ipak - ok, tako jednostavno, zar ne -? Int x = 5, to je samo varijabla na stog u glavni.

1082
01:07:06,870 --> 01:07:12,450
>> S druge strane, sada smo proglasiti pokazivač koji poziva funkcijske giveMeThreeInts.

1083
01:07:12,450 --> 01:07:16,800
I tako sada idemo u ovoj funkciji, a mi stvaramo novu stog okvir za njega.

1084
01:07:16,800 --> 01:07:20,440
Međutim, u ovom stog okvir, izjavljujemo int * temp,

1085
01:07:20,440 --> 01:07:23,210
koji je u mallocs tri integers za nas.

1086
01:07:23,210 --> 01:07:25,880
Dakle, veličina int će nam dati koliko bajtova to int je,

1087
01:07:25,880 --> 01:07:29,620
i malloc nam daje da mnogi bajtova prostora na hrpi.

1088
01:07:29,620 --> 01:07:32,890
Dakle, u ovom slučaju, stvorili smo dovoljno prostora za tri brojeva,

1089
01:07:32,890 --> 01:07:36,830
i hrpa je put do tamo, što je razlog zašto sam ga izvući više gore.

1090
01:07:36,830 --> 01:07:42,900
Nakon što smo učinili, mi vratiti ovdje, trebate samo tri Ints vratio,

1091
01:07:42,900 --> 01:07:47,000
i vraća adresu, u ovom slučaju više gdje da je memorija.

1092
01:07:47,000 --> 01:07:51,250
I mi smo postavili pokazivač = prekidač, i tamo imamo samo jedan pokazivač.

1093
01:07:51,250 --> 01:07:54,550
No, ono što je funkcija vraća se slaže ovdje i nestaje.

1094
01:07:54,550 --> 01:07:59,250
Dakle temperatura nestaje, ali mi i dalje održavati adresu gdje

1095
01:07:59,250 --> 01:08:01,850
te tri cijela broja su unutar mreže.

1096
01:08:01,850 --> 01:08:06,180
Dakle, u ovoj postavi, pokazivači su opfateno lokalno za složenom okvira,

1097
01:08:06,180 --> 01:08:09,860
ali memorije na koje se odnose je u hrpi.

1098
01:08:09,860 --> 01:08:12,190
>> Ima li to smisla?

1099
01:08:12,190 --> 01:08:14,960
[Studentski] Možete li to ponoviti? >> [Josip] Da.

1100
01:08:14,960 --> 01:08:20,270
Dakle, ako sam se vratiti samo malo, vidjet ćete da je temperatura dodijeljeno

1101
01:08:20,270 --> 01:08:23,500
dio memorije na hrpi do tamo.

1102
01:08:23,500 --> 01:08:28,680
Dakle, kada je ova funkcija, giveMeThreeInts vraća, to stog ovdje će nestati.

1103
01:08:28,680 --> 01:08:35,819
I s njim bilo od varijabli, u ovom slučaju, to pokazivač koji je dodijeljen u složenom okvira.

1104
01:08:35,819 --> 01:08:39,649
To će nestati, ali budući da smo se vratili temp

1105
01:08:39,649 --> 01:08:46,330
i mi postaviti pokazivač = temperatura, pokazivač sada će ukazati istu memoriju mjestu kao temperatura bila.

1106
01:08:46,330 --> 01:08:50,370
Tako sada, iako smo izgubili temp, da lokalna pokazivača,

1107
01:08:50,370 --> 01:08:59,109
mi još uvijek zadržati memorijsku adresu ono što je pokazujući na unutrašnjost te varijable pointer.

1108
01:08:59,109 --> 01:09:03,740
Pitanja? To može biti neka vrsta zbunjujuće temu ako niste otišli preko njega u sekciji.

1109
01:09:03,740 --> 01:09:09,240
Možemo, vaš TF definitivno će ići preko njega i naravno možemo odgovoriti na pitanja

1110
01:09:09,240 --> 01:09:11,500
na kraju pregled sjednice za to.

1111
01:09:11,500 --> 01:09:14,220
No, to je neka vrsta kompleksnu temu, i imam više primjera koje će se prikazati

1112
01:09:14,220 --> 01:09:18,790
koje će pomoći u rasvjetljavanju što upućuje zapravo jesu.

1113
01:09:18,790 --> 01:09:22,500
>> U ovom slučaju, pokazivači su ekvivalent polja,

1114
01:09:22,500 --> 01:09:25,229
tako da sam samo mogu koristiti ovaj pokazivač kao istu stvar kao int niz.

1115
01:09:25,229 --> 01:09:29,840
Tako sam indeksiranje u 0, a mijenja prvi cijeli broj 1,

1116
01:09:29,840 --> 01:09:39,689
mijenja drugi cijeli do 2, i 3. cijeli do 3.

1117
01:09:39,689 --> 01:09:44,210
Dakle, više na pokazivače. Pa, prisjetimo Binky.

1118
01:09:44,210 --> 01:09:48,319
U ovom slučaju smo dodijeljen pokazivač, ili ćemo proglašen pokazivač,

1119
01:09:48,319 --> 01:09:52,760
ali u početku, kad sam tek proglašen pokazivač, to ne ukazuje na bilo gdje u memoriji.

1120
01:09:52,760 --> 01:09:54,930
To je samo smeće vrijednosti unutar nje.

1121
01:09:54,930 --> 01:09:56,470
Dakle, ja nemam pojma gdje je to pokazivač pokazuje na.

1122
01:09:56,470 --> 01:10:01,630
To ima adresu koja je samo ispunjen 0-a i jedan je gdje je u početku bio proglašen.

1123
01:10:01,630 --> 01:10:04,810
Ja ne mogu ništa učiniti s tim dok sam nazvati malloc na njemu

1124
01:10:04,810 --> 01:10:08,390
i onda mi daje malo prostora na hrpi gdje mogu staviti vrijednosti unutra.

1125
01:10:08,390 --> 01:10:11,980
Onda opet, ne znam što je unutar ove memorije.

1126
01:10:11,980 --> 01:10:16,780
Dakle, prva stvar koju moram učiniti je provjeriti je li sustav imao dovoljno memorije

1127
01:10:16,780 --> 01:10:20,850
da mi vrati jedan cijeli na prvom mjestu, što je razlog zašto sam to provjeriti.

1128
01:10:20,850 --> 01:10:25,020
Ako pokazivač je nula, to znači da ona nije imala dovoljno prostora ili neke druge pogreške,

1129
01:10:25,020 --> 01:10:26,320
pa ja bi trebao izaći iz mog programa.

1130
01:10:26,320 --> 01:10:29,400
 Ali ako je to učinio uspjeti, sada mogu koristiti taj pokazivač

1131
01:10:29,400 --> 01:10:35,020
i ono * pokazivač ipak slijedi gdje je adresa

1132
01:10:35,020 --> 01:10:38,480
gdje ta vrijednost je, a to ga postavlja jednak 1.

1133
01:10:38,480 --> 01:10:41,850
Dakle, ovdje, mi smo provjere da li da je sjećanje postojala.

1134
01:10:41,850 --> 01:10:45,380
>> Jednom kada znate da postoji, možete staviti u nju

1135
01:10:45,380 --> 01:10:50,460
što vrijednost koju želite staviti u njega, u ovom slučaju jedan.

1136
01:10:50,460 --> 01:10:53,060
Nakon što smo učinili s njim, morate osloboditi taj pokazivač

1137
01:10:53,060 --> 01:10:57,160
jer moramo vratiti na sustav koji memorijskoj da ste pitali za na prvom mjestu.

1138
01:10:57,160 --> 01:10:59,690
Budući da računalo ne zna kad završimo s tim.

1139
01:10:59,690 --> 01:11:02,510
U ovom slučaju mi ​​smo ga izričito govori, ok, mi smo gotovi s tim memorije.

1140
01:11:02,510 --> 01:11:10,780
Ako neki drugi proces treba ga neki drugi program to treba, slobodno ići naprijed i uzeti ga.

1141
01:11:10,780 --> 01:11:15,110
Što možemo učiniti je možemo samo dobiti adresu lokalnih varijabli na setu.

1142
01:11:15,110 --> 01:11:19,080
Dakle, int x je unutar složenom okviru glavni.

1143
01:11:19,080 --> 01:11:23,060
A kad smo koristiti ovaj ampersand, to i operater, što to je

1144
01:11:23,060 --> 01:11:27,310
to traje x, a x je samo neki podaci iz memorije, ali to ima adresu.

1145
01:11:27,310 --> 01:11:33,790
Ona je smještena negdje. Tako je poziv & x, što to znači je to nam daje adresu x.

1146
01:11:33,790 --> 01:11:38,430
Na taj način, mi smo izradu pokazivač točku gdje je x u sjećanju.

1147
01:11:38,430 --> 01:11:41,710
Sada mi samo ne nešto poput * x, idemo dobiti pet leđa.

1148
01:11:41,710 --> 01:11:43,820
Zvijezda se zove to dereferencing.

1149
01:11:43,820 --> 01:11:46,640
Možete slijediti adresu i dobijete vrijednost toga tamo pohranjena.

1150
01:11:51,000 --> 01:11:53,310
>> Ima li pitanja? Da?

1151
01:11:53,310 --> 01:11:56,500
[Studentski] Ako to ne učinite 3-zašiljeni stvar, to još uvijek sastaviti?

1152
01:11:56,500 --> 01:11:59,490
Da. Ako to ne učinite 3-pointer stvar, ona i dalje će sastaviti,

1153
01:11:59,490 --> 01:12:02,720
ali ja ću vam pokazati što se događa u drugi, i bez da radi,

1154
01:12:02,720 --> 01:12:04,860
to je ono što mi zovemo otjecanje memorije. Vi ne daje sustav pri

1155
01:12:04,860 --> 01:12:07,850
natrag svoju memoriju, pa nakon nekog vremena program će se akumulirati

1156
01:12:07,850 --> 01:12:10,940
memorije da to ne koristite, i ništa drugo ne može ga koristiti.

1157
01:12:10,940 --> 01:12:15,750
Ako ste ikada vidjeli Firefox s 1,5 milijuna kilobajta na računalu,

1158
01:12:15,750 --> 01:12:17,840
u task manager, to je ono što se događa.

1159
01:12:17,840 --> 01:12:20,760
Imate memorijsku curenja u programu da se ne rješava.

1160
01:12:23,080 --> 01:12:26,240
Pa kako se kazaljka aritmetička rad?

1161
01:12:26,240 --> 01:12:29,480
Pa, pokazivač aritmetička je vrsta od poput indeksiranje u polju.

1162
01:12:29,480 --> 01:12:36,370
U ovom slučaju, imam pokazivač, i što mi je činiti je sam napraviti pokazivača točku na prvi element

1163
01:12:36,370 --> 01:12:42,100
ovog niza brojeva 3 koje sam dodijeljenih.

1164
01:12:42,100 --> 01:12:46,670
I što sad radim, zvijezda pokazivač samo mijenja prvi element u popisu.

1165
01:12:46,670 --> 01:12:49,140
Star pokazivač 1 boda više ovdje.

1166
01:12:49,140 --> 01:12:53,140
Dakle, pokazivač je ovdje, pokazivač jedan je ovdje, pokazivač 2 je ovdje.

1167
01:12:53,140 --> 01:12:56,610
>> Dakle, samo dodavanjem jedne je ista stvar kao i kretanje po ovom polju.

1168
01:12:56,610 --> 01:12:59,880
Ono što mi radimo jest, kada radimo pokazivač jednom ste dobili adresu ovamo,

1169
01:12:59,880 --> 01:13:04,180
i kako bi dobili vrijednost u ovdje, stavi zvijezdu iz cijelog izraza

1170
01:13:04,180 --> 01:13:05,990
to dereference.

1171
01:13:05,990 --> 01:13:09,940
Dakle, u ovom slučaju, ja sam postavljanje prvog mjesta u ovom polju na jednoj,

1172
01:13:09,940 --> 01:13:13,970
drugi položaj do 2, i treće mjesto na 3.

1173
01:13:13,970 --> 01:13:18,180
Onda ono što ja radim ovdje je sam ispis naš pokazivač 1,

1174
01:13:18,180 --> 01:13:19,970
koji samo mi daje dvije.

1175
01:13:19,970 --> 01:13:23,650
Sada sam povećavanjem pokazivač, tako da pokazivač jednak pokazivač 1,

1176
01:13:23,650 --> 01:13:26,780
koji ga pomiče naprijed.

1177
01:13:26,780 --> 01:13:30,810
I tako sada, ako sam isprintati pokazivač 1, pokazivač jedna je sada 3,

1178
01:13:30,810 --> 01:13:33,990
koja je u ovom slučaju ispisuje tri.

1179
01:13:33,990 --> 01:13:36,560
A kako bi slobodnom nešto, pokazivač da sam ga dati

1180
01:13:36,560 --> 01:13:40,540
mora biti ukazujući na početku niza koji sam dobio natrag iz malloc.

1181
01:13:40,540 --> 01:13:43,430
Dakle, u ovom slučaju, ako bih pozvati tri ovdje, to ne bi bilo dobro,

1182
01:13:43,430 --> 01:13:45,070
jer se nalazi u sredini polja.

1183
01:13:45,070 --> 01:13:48,820
Imam za oduzimanje doći do izvornog mjesta

1184
01:13:48,820 --> 01:13:50,420
početna prvi put ugledali prije nego što sam ga osloboditi.

1185
01:13:56,300 --> 01:13:58,450
Dakle, ovdje je više uključeni primjer.

1186
01:13:58,450 --> 01:14:03,360
U ovom slučaju, mi smo izdvajanja 7 znakove u nizu znakova.

1187
01:14:03,360 --> 01:14:06,480
>> I u ovom slučaju ono što mi radimo je da smo petlje u odnosu na prvi šest od njih,

1188
01:14:06,480 --> 01:14:09,900
i mi smo ih postavljanja do Z.

1189
01:14:09,900 --> 01:14:13,350
Dakle, za int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Dakle, pokazivač + ja samo će nam dati, u ovom slučaju,

1191
01:14:16,220 --> 01:14:20,860
pokazivač, pokazivač 1, 2 pokazivač, pokazivač 3, i tako dalje i tako dalje u petlji.

1192
01:14:20,860 --> 01:14:24,040
Što će to učiniti je da dobije tu adresu, dereferences da biste dobili vrijednost,

1193
01:14:24,040 --> 01:14:27,440
i promjene koje vrijednost za Z.

1194
01:14:27,440 --> 01:14:30,350
Tada je na kraju zapamtite ovo je string, zar ne?

1195
01:14:30,350 --> 01:14:33,560
Svi nizovi moraju završiti sa završnim null karakter.

1196
01:14:33,560 --> 01:14:38,620
Dakle, ono što mi je činiti u pokazivač 6 stavim null terminator lik u.

1197
01:14:38,620 --> 01:14:43,980
A sad ono što ja zapravo radim ovdje provodi printf za niz, zar ne?

1198
01:14:43,980 --> 01:14:46,190
>> Dakle, kada printf ne sada kada je došla do kraja niza?

1199
01:14:46,190 --> 01:14:48,230
Kada ga pogodi nulte ukida karakter.

1200
01:14:48,230 --> 01:14:52,030
Dakle, u ovom slučaju, moje izvorne pokazivač pokazuje na početku ovog niza.

1201
01:14:52,030 --> 01:14:56,410
Ja ispisati prvi lik iz. Ja ga premjestiti preko jednog.

1202
01:14:56,410 --> 01:14:58,420
Ja ispisati taj lik iz. Ja ga premjestiti.

1203
01:14:58,420 --> 01:15:02,180
I ja sam zadržati to dok sam doći do kraja.

1204
01:15:02,180 --> 01:15:07,750
A sada pokazivač kraj * će dereference to i dobiti null ukida karakter natrag.

1205
01:15:07,750 --> 01:15:11,780
I tako moj while petlja radi samo kada je vrijednost nije null završni lik.

1206
01:15:11,780 --> 01:15:13,770
Dakle, sada sam izaći iz ove petlje.

1207
01:15:18,780 --> 01:15:21,180
I tako, ako sam oduzmite 6 iz ovog pokazivača,

1208
01:15:21,180 --> 01:15:22,860
Vraćam sve do početka.

1209
01:15:22,860 --> 01:15:27,880
Zapamtite, ja sam to, jer moram ići na početak kako bi ga oslobodili.

1210
01:15:27,880 --> 01:15:30,270
>> Dakle, znam da je puno. Ima li kakvih pitanja?

1211
01:15:30,270 --> 01:15:31,870
Molim vas, da?

1212
01:15:31,870 --> 01:15:36,610
[Studentski pitanje nerazumljivo]

1213
01:15:36,610 --> 01:15:38,190
Može li se reći da je glasniji? Oprostite.

1214
01:15:38,190 --> 01:15:44,140
[Studentski] Na posljednjem slajdu neposredno prije oslobodio pokazivač,

1215
01:15:44,140 --> 01:15:47,300
gdje su ti zapravo mijenja vrijednost pokazivača?

1216
01:15:47,300 --> 01:15:50,370
[Josip] Dakle, ovdje. >> [Student] Oh, u redu.

1217
01:15:50,370 --> 01:15:51,890
[Josip] Dakle, imam pokazivač minus minus, desno,

1218
01:15:51,890 --> 01:15:54,140
koja se kreće stvar povratak, a onda sam ga oslobodi,

1219
01:15:54,140 --> 01:15:57,000
jer ovo pokazivač mora biti ukazao na početku niza.

1220
01:15:57,000 --> 01:16:00,420
[Studentski] Ali to ne bi bilo potrebno da ste prestali nakon tog liniji.

1221
01:16:00,420 --> 01:16:03,130
[Josip] Dakle, ako sam prestao nakon toga, to će se smatrati otjecanje memorije,

1222
01:16:03,130 --> 01:16:04,810
jer nisam pokrenuti besplatno.

1223
01:16:04,810 --> 01:16:11,290
[Studentski] ja [nerazumljivo] nakon prva tri linije gdje ste imali pokazivač 1 [nerazumljivo].

1224
01:16:11,290 --> 01:16:13,140
[Josip] Aha. Dakle, ono što je pitanje postoji?

1225
01:16:13,140 --> 01:16:14,780
Oprostite. Ne, ne. Idi, idi, molim te.

1226
01:16:14,780 --> 01:16:16,870
[Studentski] Dakle, niste mijenja vrijednost pokazivača.

1227
01:16:16,870 --> 01:16:19,130
Vi ne bi morao učiniti pokazivač minus minus.

1228
01:16:19,130 --> 01:16:19,730
[Josip] Da, točno.

1229
01:16:19,730 --> 01:16:21,890
Dakle, kad radim pokazivač 1 i 2 upustvo,

1230
01:16:21,890 --> 01:16:24,410
Ja ne radim pokazivač jednak pokazivač jednom.

1231
01:16:24,410 --> 01:16:27,260
Dakle, pokazivač samo ostaje ukazujući na početku niza.

1232
01:16:27,260 --> 01:16:31,460
To je samo kad radim plus plus da postavlja vrijednost natrag u pokazivač,

1233
01:16:31,460 --> 01:16:33,550
da je to zapravo kreće to zajedno.

1234
01:16:36,860 --> 01:16:37,780
U redu.

1235
01:16:40,550 --> 01:16:42,030
Više pitanja?

1236
01:16:44,680 --> 01:16:47,790
>> Opet, ako je to neka vrsta neodoljiv, to će biti pokrivena u sjednici.

1237
01:16:47,790 --> 01:16:50,710
Pitajte kolega nastave o tome, i mi možemo odgovoriti na pitanja na kraju.

1238
01:16:53,510 --> 01:16:56,600
I obično mi se ne sviđa to učiniti minus stvar.

1239
01:16:56,600 --> 01:16:59,760
To mora zahtijevati mene praćenje koliko sam pomak u polju.

1240
01:16:59,760 --> 01:17:04,520
Dakle, u cjelini, to je samo objasniti kako radi pokazivač aritmetika.

1241
01:17:04,520 --> 01:17:07,970
Ali ono što mi obično željeli učiniti je da smo željeli stvoriti kopiju pokazivačem

1242
01:17:07,970 --> 01:17:11,640
i onda ćemo koristiti taj primjerak kada smo se kreće u nizu.

1243
01:17:11,640 --> 01:17:14,660
Dakle, u tih slučaju da koristite kopija za ispis cijeli niz,

1244
01:17:14,660 --> 01:17:19,040
ali mi nemamo učiniti kao pokazivač minus šest ili pratiti koliko smo se preselili u ovo,

1245
01:17:19,040 --> 01:17:22,700
samo zato jer znamo da je naša izvorna točka i dalje je ukazao na početku popisa

1246
01:17:22,700 --> 01:17:25,340
i sve što smo promijenili je to kopija.

1247
01:17:25,340 --> 01:17:28,250
Dakle, u cjelini, mijenjati kopije originalnog pokazivača.

1248
01:17:28,250 --> 01:17:32,350
Nemojte pokušati nešto poput - nemojte mijenjati originalne kopije.

1249
01:17:32,350 --> 01:17:35,290
Pokušavajući izmijeniti samo kopija originala.

1250
01:17:41,540 --> 01:17:44,870
Dakle, možete primijetiti kada smo proći niz u printf

1251
01:17:44,870 --> 01:17:48,990
nemate staviti zvijezdu ispred njega kao što smo učinili s ostalim dereferences, zar ne?

1252
01:17:48,990 --> 01:17:54,180
Dakle, ako vam ispisati cijeli niz% s. očekuje je adresa,

1253
01:17:54,180 --> 01:17:57,610
iu tom slučaju pokazivač ili u ovom slučaju kao niz znakova.

1254
01:17:57,610 --> 01:18:00,330
>> Likovi, char * s, i polja su ista stvar.

1255
01:18:00,330 --> 01:18:03,690
Pointer je znakova, a karakter polja su ista stvar.

1256
01:18:03,690 --> 01:18:05,720
I tako, sve što morate učiniti je proći pokazivač.

1257
01:18:05,720 --> 01:18:08,150
Mi ne moramo položiti u kao * pokazivač ili nešto slično.

1258
01:18:13,110 --> 01:18:14,930
Dakle, polja i pokazivače su ista stvar.

1259
01:18:14,930 --> 01:18:19,160
Kada radite nešto poput x [y] ovdje za niz,

1260
01:18:19,160 --> 01:18:21,960
ono što radi ispod haube je to rekao, ok, to je znak polje,

1261
01:18:21,960 --> 01:18:23,690
tako da je pokazivač.

1262
01:18:23,690 --> 01:18:26,510
I tako x su ista stvar,

1263
01:18:26,510 --> 01:18:28,650
pa što je to ipak dodaje y za x,

1264
01:18:28,650 --> 01:18:31,820
što je ista stvar kao i kretanje naprijed u sjećanju da je mnogo.

1265
01:18:31,820 --> 01:18:34,930
I sad x + y daje nam nekakvu adresu,

1266
01:18:34,930 --> 01:18:37,570
i mi dereference adresu ili slijediti strelicu

1267
01:18:37,570 --> 01:18:41,640
gdje to mjesto u memoriji, a dobili smo vrijednost od tog mjesta u memoriji.

1268
01:18:41,640 --> 01:18:43,720
Dakle, kako se radi o dvije potpuno ista stvar.

1269
01:18:43,720 --> 01:18:45,840
To je samo sintaktička šećer.

1270
01:18:45,840 --> 01:18:48,090
Oni učiniti istu stvar. Oni su samo različiti syntactics za drugoga.

1271
01:18:51,500 --> 01:18:57,590
>> Dakle, ono što može poći krivo s pokazivačima? Kao, puno. Ok. Dakle, loše stvari.

1272
01:18:57,590 --> 01:19:02,410
Neke loše stvari koje možete učiniti ne provjere da li vaš poziv malloc vraća null, zar ne?

1273
01:19:02,410 --> 01:19:06,560
U tom slučaju, ja tražim da sustav mi dati - što je to broj?

1274
01:19:06,560 --> 01:19:11,200
Kao dvije milijarde puta četiri, jer je veličina cijeli broj je 4 bajta.

1275
01:19:11,200 --> 01:19:13,810
Ja sam ga tražeći poput 8000000000 bajtova.

1276
01:19:13,810 --> 01:19:17,270
Naravno moj računalo neće biti u mogućnosti dati mi toliko memorije leđa.

1277
01:19:17,270 --> 01:19:20,960
I nismo provjerili je li to nula, pa kad smo ga pokušati dereference tamo -

1278
01:19:20,960 --> 01:19:24,270
slijediti strelicu na mjesto gdje će to - mi nemamo tu memoriju.

1279
01:19:24,270 --> 01:19:27,150
To je ono što mi zovemo dereferencing null pokazivač.

1280
01:19:27,150 --> 01:19:29,710
I to u suštini uzrokuje da segfault.

1281
01:19:29,710 --> 01:19:31,790
Ovo je jedan od načina na koji možete segfault.

1282
01:19:34,090 --> 01:19:38,090
Ostali loše stvari koje možete učiniti - oh dobro.

1283
01:19:38,090 --> 01:19:40,650
To je dereferencing null pokazivač. Ok.

1284
01:19:40,650 --> 01:19:45,160
Ostali loše stvari - dobro, to popraviti samo stavi ček tamo

1285
01:19:45,160 --> 01:19:46,980
da provjerava je li pokazivač null

1286
01:19:46,980 --> 01:19:51,000
i izlaz iz programa ako se dogodi da malloc vraća null pokazivač.

1287
01:19:55,110 --> 01:19:59,850
To je xkcd strip. Ljudi ga sada razumijem. Vrsta.

1288
01:20:06,120 --> 01:20:09,350
>> Dakle, memorija. I ja sam otišao preko toga.

1289
01:20:09,350 --> 01:20:12,000
Mi pozivamo malloc u petlji, ali svaki put mi zovemo malloc

1290
01:20:12,000 --> 01:20:14,370
gubimo trag gdje se ova kazaljka pokazuje da,

1291
01:20:14,370 --> 01:20:15,750
jer smo ga clobbering.

1292
01:20:15,750 --> 01:20:18,410
Dakle, početni poziv na malloc daje mi sjećanje ovamo.

1293
01:20:18,410 --> 01:20:19,990
Moje pokazivač upućuje na to.

1294
01:20:19,990 --> 01:20:23,020
Sada, ja to ne oslobodi, tako da sada zovem malloc opet.

1295
01:20:23,020 --> 01:20:26,070
Sada to ukazuje ovamo. Sada moja memorija pokazuje ovamo.

1296
01:20:26,070 --> 01:20:27,640
Ukazujući ovamo. Ukazujući ovamo.

1297
01:20:27,640 --> 01:20:31,820
Ali ja sam izgubio trag od adrese svih memorije ovamo da bih izdvojila.

1298
01:20:31,820 --> 01:20:35,100
I tako sad ja nemam referencu na njih više.

1299
01:20:35,100 --> 01:20:37,230
Dakle, ja ne mogu osloboditi ih izvan tog kruga.

1300
01:20:37,230 --> 01:20:39,390
I tako bi se riješili ovako nešto,

1301
01:20:39,390 --> 01:20:42,250
ako ste zaboravili slobodne memorije i dobijete Osipanje memorije,

1302
01:20:42,250 --> 01:20:45,810
Morate osloboditi memoriju unutar ove petlje jednom ste učinili s njim.

1303
01:20:45,810 --> 01:20:51,400
Pa, to je ono što se događa. Znam puno vas mrzim to.

1304
01:20:51,400 --> 01:20:55,270
Ali sada - yay! Možete dobiti kao 44.000 kilobajta.

1305
01:20:55,270 --> 01:20:57,110
Dakle, vi ga osloboditi na kraju petlje,

1306
01:20:57,110 --> 01:20:59,770
i da će se samo osloboditi memoriju svaki put.

1307
01:20:59,770 --> 01:21:03,620
U osnovi, vaš program nema curenja memorije više.

1308
01:21:03,620 --> 01:21:08,150
>> A sada nešto drugo što možete učiniti je osloboditi dio memorije koji ste tražili dvaput.

1309
01:21:08,150 --> 01:21:11,060
U ovom slučaju, malloc nešto, promijenite svoju vrijednost.

1310
01:21:11,060 --> 01:21:13,140
Možete ga oslobodi jednom, jer si rekao da su učinili s njim.

1311
01:21:13,140 --> 01:21:14,940
Ali onda smo ga oslobodili opet.

1312
01:21:14,940 --> 01:21:16,730
To je nešto što je jako loše.

1313
01:21:16,730 --> 01:21:18,820
To ne ide na početku segfault,

1314
01:21:18,820 --> 01:21:23,350
ali nakon što dok to ne dvostruko oslobađajući Ova kvari svoj hrpa strukturu,

1315
01:21:23,350 --> 01:21:27,200
i da ćete naučiti nešto više o tome, ako se odlučite uzeti klasa poput CS61.

1316
01:21:27,200 --> 01:21:30,000
No, bitno je nakon nekog vremena vaše računalo će se zbuniti

1317
01:21:30,000 --> 01:21:33,010
o tome što memorijska mjesta gdje su i gdje je pohranjen -

1318
01:21:33,010 --> 01:21:34,800
gdje su podaci pohranjeni u memoriji.

1319
01:21:34,800 --> 01:21:38,080
I tako oslobađajući pokazivač dva puta je loša stvar koju ne želim učiniti.

1320
01:21:38,080 --> 01:21:41,600
>> Druge stvari koje mogu poći krivo ne koristi sizeof.

1321
01:21:41,600 --> 01:21:44,460
Dakle, u tom slučaju vam malloc 8 bajtova,

1322
01:21:44,460 --> 01:21:46,700
i to je ista stvar kao i dvije brojeva, zar ne?

1323
01:21:46,700 --> 01:21:49,580
Dakle, to je sasvim sigurno, ali je to?

1324
01:21:49,580 --> 01:21:52,160
Pa, kao Lucas govorio o na različitim arhitekturama,

1325
01:21:52,160 --> 01:21:54,220
integeri su različitih duljina.

1326
01:21:54,220 --> 01:21:57,970
Dakle, na aparatu koji ste koristili, cijeli, oko 4 bajta,

1327
01:21:57,970 --> 01:22:02,370
ali na nekom drugom sustavu mogle bi biti 8 bajtova ili bi mogli biti 16 bajtova.

1328
01:22:02,370 --> 01:22:05,680
Dakle, ako sam koristiti ovaj broj ovamo,

1329
01:22:05,680 --> 01:22:07,310
ovaj program može raditi na aparatu,

1330
01:22:07,310 --> 01:22:10,360
ali to neće dodijeliti dovoljno memorije na nekom drugom sustavu.

1331
01:22:10,360 --> 01:22:14,020
U ovom slučaju, to je ono što sizeof operator koristi za.

1332
01:22:14,020 --> 01:22:16,880
Kad mi zovemo sizeof (int), što je ovo ipak

1333
01:22:16,880 --> 01:22:21,910
 to nam daje veličinu cijeli na sustavu da je program pokrenut.

1334
01:22:21,910 --> 01:22:25,490
Dakle, u ovom slučaju, sizeof (int) će se vratiti 4 na nešto poput aparata,

1335
01:22:25,490 --> 01:22:29,980
i sada će ovo 4 * 2, što je 8,

1336
01:22:29,980 --> 01:22:32,330
što je samo iznos prostora potrebnog za dvije brojeva.

1337
01:22:32,330 --> 01:22:36,710
Na drugom sustavu, ako int je kao 16 bajtova ili 8 bajtova,

1338
01:22:36,710 --> 01:22:39,380
to je samo ide da se vrati dovoljno bajtova za pohranu taj iznos.

1339
01:22:41,830 --> 01:22:45,310
>> I na kraju, tvorevina.

1340
01:22:45,310 --> 01:22:48,340
Dakle, ako ste htjeli pohraniti sudoku ploču u znak sjećanja, kako bismo mogli to učiniti?

1341
01:22:48,340 --> 01:22:51,570
Možda misle kao varijable za prvu stvar,

1342
01:22:51,570 --> 01:22:53,820
varijabla za drugog stvar, varijabla za treći stvar,

1343
01:22:53,820 --> 01:22:56,420
varijabla za četvrti stvar - loše, zar ne?

1344
01:22:56,420 --> 01:23:00,750
Dakle, jedan poboljšanja možete napraviti na vrhu je to napraviti 9 x 9 polja.

1345
01:23:00,750 --> 01:23:04,480
To je u redu, ali što ako ste htjeli povezati druge stvari s sudoku brodu

1346
01:23:04,480 --> 01:23:06,490
sviđa ono poteškoća odbora je,

1347
01:23:06,490 --> 01:23:11,740
ili, na primjer, ono što je vaš rezultat je, ili koliko vremena to uzima li riješiti ovaj forum?

1348
01:23:11,740 --> 01:23:14,970
Pa, što možete učiniti je da možete stvoriti struct.

1349
01:23:14,970 --> 01:23:18,910
Ono što sam zapravo govorim je sam definiranja ovu strukturu ovamo,

1350
01:23:18,910 --> 01:23:23,230
i ja sam definiranje Sudoku odbora koji se sastoji od ploče koja je 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> I ono što je ona ima upućuje na ime razini.

1352
01:23:26,650 --> 01:23:30,730
Ona također ima X i Y, koji su koordinate gdje sam sada.

1353
01:23:30,730 --> 01:23:35,980
To je također vrijeme provedeno [nerazumljivo], a to je ukupan broj poteza koje sam do sada unesene.

1354
01:23:35,980 --> 01:23:40,010
I tako, u ovom slučaju, ja mogu grupirati hrpu podataka u samo jednoj strukturi

1355
01:23:40,010 --> 01:23:42,790
umjesto da ga kao leti okolo poput različitih varijabli

1356
01:23:42,790 --> 01:23:44,540
da ja stvarno ne mogu pratiti.

1357
01:23:44,540 --> 01:23:49,720
A to nam omogućuje da imaju samo lijepe sintaksu za kakve pozivom različite stvari unutar ovog struct.

1358
01:23:49,720 --> 01:23:53,430
Ja samo mogu učiniti board.board, a ja dobiti sudoku ploču natrag.

1359
01:23:53,430 --> 01:23:56,320
Board.level, sam se kako tvrd je.

1360
01:23:56,320 --> 01:24:00,540
Board.x i board.y daj mi koordinate gdje sam mogao biti na brodu.

1361
01:24:00,540 --> 01:24:04,730
I tako sam pristup ono što mi zovemo polja u struct.

1362
01:24:04,730 --> 01:24:08,840
To definira sudokuBoard, što je tip koji imam.

1363
01:24:08,840 --> 01:24:14,800
I sad smo ovdje. Imam varijablu pod nazivom "zajednica" tipa sudokuBoard.

1364
01:24:14,800 --> 01:24:18,820
I tako sada ja mogu pristupiti sva polja koja čine ovu strukturu ovamo.

1365
01:24:20,830 --> 01:24:22,450
>> Sva pitanja o tvorevina? Da?

1366
01:24:22,450 --> 01:24:25,890
[Studentski] Za int x, y, što proglašen i na jednoj liniji? >> [Josip] Aha.

1367
01:24:25,890 --> 01:24:27,400
[Studentski] Dakle, mogli ste upravo to učiniti sa svima njima?

1368
01:24:27,400 --> 01:24:31,200
Kao u X, Y zarez puta da su ukupni?

1369
01:24:31,200 --> 01:24:34,460
[Josip] Da, svakako bi mogao to učiniti, ali razlog zbog kojeg sam stavio xiy na istoj liniji -

1370
01:24:34,460 --> 01:24:36,330
i pitanje je zašto možemo samo to učiniti na istoj liniji?

1371
01:24:36,330 --> 01:24:38,600
Zašto ne bismo samo stavi sve to na istoj liniji je

1372
01:24:38,600 --> 01:24:42,090
x i y su međusobno povezani,

1373
01:24:42,090 --> 01:24:44,780
i to je samo stilski točnije, u smislu,

1374
01:24:44,780 --> 01:24:46,600
jer to je grupiranje dvije stvari na istoj liniji

1375
01:24:46,600 --> 01:24:49,340
da kao vrsta odnose na istu stvar.

1376
01:24:49,340 --> 01:24:51,440
I ja sam samo podijeliti ove apart. To je samo stil stvar.

1377
01:24:51,440 --> 01:24:53,720
To funkcionalno čini nikakve razlike.

1378
01:24:58,150 --> 01:24:59,270
Bilo koja druga pitanja o tvorevina?

1379
01:25:03,030 --> 01:25:06,620
Možete definirati Pokédex s struct.

1380
01:25:06,620 --> 01:25:11,720
Pokémon ima broj i to je pismo, vlasnik, tipa.

1381
01:25:11,720 --> 01:25:16,990
A onda, ako imate niz Pokemona, možete čine Pokédex, zar ne?

1382
01:25:16,990 --> 01:25:20,810
Ok, cool. Dakle, pitanja o tvorevina. Oni su vezane uz tvorevina.

1383
01:25:20,810 --> 01:25:25,270
>> Konačno, GDB. Što GDB neka vam je činiti? To vam omogućuje ispravljanje svoj program.

1384
01:25:25,270 --> 01:25:27,650
A ako niste koristili gdb, ja bih preporučuje gledajući kratki

1385
01:25:27,650 --> 01:25:31,250
i samo ono što ide preko GDB je, kako raditi s njim, kako bi ga koristiti,

1386
01:25:31,250 --> 01:25:32,900
i testirati ga na programu.

1387
01:25:32,900 --> 01:25:37,400
I tako ono što GDB vam omogućuje da učinite je to omogućuje stanku [nerazumljivo] Gore vaš program

1388
01:25:37,400 --> 01:25:38,920
i praktičan linija.

1389
01:25:38,920 --> 01:25:42,600
Na primjer, želim pauzu izvršenja na liniji kao tri moje programa,

1390
01:25:42,600 --> 01:25:46,010
i dok sam na liniji 3 mogu ispisati sve vrijednosti koje su tu.

1391
01:25:46,010 --> 01:25:49,710
I tako ono što mi zovemo kao pauziranje u skladu

1392
01:25:49,710 --> 01:25:52,350
je mi zovemo ovo stavljanjem točke prekida na toj liniji

1393
01:25:52,350 --> 01:25:55,920
i onda možemo ispisati varijable na državnoj programa u to vrijeme.

1394
01:25:55,920 --> 01:25:58,990
>> Mi smo tada može od tamo korak kroz program line-by-line.

1395
01:25:58,990 --> 01:26:03,200
A onda možemo pogledati stanje stog na vrijeme.

1396
01:26:03,200 --> 01:26:08,600
I tako bi se koristiti gdb, ono što mi radimo je zovemo zveka na C datoteci,

1397
01:26:08,600 --> 01:26:11,290
ali moramo proći to-ggdb zastavu.

1398
01:26:11,290 --> 01:26:15,850
A kad smo gotovi s tim smo samo pokrenuti gdb na proizašlog izlazne datoteke.

1399
01:26:15,850 --> 01:26:18,810
I tako da ćete dobiti neki kao masu teksta kao što je ovaj,

1400
01:26:18,810 --> 01:26:21,990
ali stvarno sve što morate učiniti je upisati naredbe na početku.

1401
01:26:21,990 --> 01:26:24,250
Break glavni stavlja točke prekida na glavni.

1402
01:26:24,250 --> 01:26:28,470
Popis 400 navodi linija koda oko liniji 400.

1403
01:26:28,470 --> 01:26:31,410
I tako u tom slučaju možete samo pogledati oko sebe i reći, oh,

1404
01:26:31,410 --> 01:26:34,360
Želim postaviti točke prekida na liniji 397, što je ova linija,

1405
01:26:34,360 --> 01:26:37,170
a zatim vaš program radi u tom koraku, a to će se slomiti.

1406
01:26:37,170 --> 01:26:41,120
To će pauzirati tamo, i možete ispisati, primjerice, vrijednost niska ili visoka.

1407
01:26:41,120 --> 01:26:46,410
I tako postoji hrpa naredbi koje trebate znati,

1408
01:26:46,410 --> 01:26:48,660
i to Slideshow će ići gore na web stranici,

1409
01:26:48,660 --> 01:26:54,000
pa ako baš želite referencirati ove ili vole ih staviti na svoje Šalabahteri, slobodno.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. To je kviz pregled 0, a mi ćemo držati oko, ako imate bilo kakvih pitanja.

1411
01:27:00,650 --> 01:27:03,850
U redu.

1412
01:27:03,850 --> 01:27:09,030
>>  [Pljesak]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]