1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Suriin] [Quiz 0]

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

3
00:00:05,000 --> 00:00:08,000
>> [Ito ay CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Uy, lahat.

5
00:00:10,000 --> 00:00:15,000
Maligayang pagdating sa pagsusuri session para sa Quiz 0, na kung saan ay nagaganap ito Miyerkules.

6
00:00:15,000 --> 00:00:19,000
Ano kami ay pagpunta sa gawin ngayong gabi, ako ay may 3 iba pang mga TFs,

7
00:00:19,000 --> 00:00:24,000
at sama-sama namin ay pagpunta sa pumunta sa pamamagitan ng pagsusuri ng kung ano ang ginawa namin sa kurso sa ngayon.

8
00:00:24,000 --> 00:00:27,000
Hindi ito 100% komprehensibong, ngunit dapat itong bigyan ka ng isang mas mahusay na ideya

9
00:00:27,000 --> 00:00:31,000
ng kung ano ang mayroon ka nang down at kung ano ang kailangan mo pa rin upang pag-aralan bago Miyerkules.

10
00:00:31,000 --> 00:00:34,000
At huwag mag-atubiling upang taasan ang iyong kamay sa mga tanong namin ay pagpunta sa kahabaan,

11
00:00:34,000 --> 00:00:38,000
ngunit tandaan na gagamitin din namin ng kaunting panahon sa dulo-

12
00:00:38,000 --> 00:00:41,000
kung makuha namin sa pamamagitan ng ilang minuto upang ekstrang-upang gawin ang mga pangkalahatang mga katanungan,

13
00:00:41,000 --> 00:00:47,000
kaya panatilihin na sa isip, at kaya kami ay pagpunta sa magsimula sa na nagsisimula sa Linggo 0.

14
00:00:47,000 --> 00:00:50,000
>> [Pagsusulit 0 Review!] [Bahagi 0] [Lexi Ross] Ngunit bago ang ginagawa namin na natin pag-usapan ang

15
00:00:50,000 --> 00:00:53,000
ang logistik ng pagsusulit.

16
00:00:53,000 --> 00:00:55,000
>> [Logistics] [Quiz ay tumatagal ng lugar sa Miyerkules 10/10 sa halip ng panayam]

17
00:00:55,000 --> 00:00:57,000
>> [(Tingnan ang http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf para sa mga detalye)] sa Miyerkules, Oktubre ika-10.

18
00:00:57,000 --> 00:01:00,000
>> Na ito Miyerkules, at kung pumunta ka sa URL na ito dito,

19
00:01:00,000 --> 00:01:03,000
na ring ma-access mula CS50.net-may ni isang link papunta dito

20
00:01:03,000 --> 00:01:06,000
maaari mong makita ang impormasyon tungkol sa kung saan pumunta batay sa

21
00:01:06,000 --> 00:01:10,000
ang iyong huling pangalan o kaugnayan sa paaralan pati na rin

22
00:01:10,000 --> 00:01:14,000
ito ay nagsasabi sa tungkol sa kung ano mismo ang pagsusulit ay masaklawan at ang mga uri ng mga katanungan na kayo ay pagpunta upang makakuha ng.

23
00:01:14,000 --> 00:01:19,000
Isaisip na ang makikita mo ring magkaroon ng isang pagkakataon upang suriin para sa pagsusulit sa seksyon,

24
00:01:19,000 --> 00:01:21,000
sa gayon ang iyong mga TFs dapat pagpunta sa paglipas ng ilang mga problema ng kasanayan,

25
00:01:21,000 --> 00:01:29,000
at ang isa pang magandang pagkakataon upang makita kung saan kailangan mo pa ring mag-aral up para sa pagsusulit.

26
00:01:29,000 --> 00:01:32,000
Simulan natin sa simula may Bits 'n' Bytes.

27
00:01:32,000 --> 00:01:35,000
Alalahanin isang bit lamang ng 0 o 1,

28
00:01:35,000 --> 00:01:38,000
at isang byte ay isang koleksyon ng 8 ng mga bits.

29
00:01:38,000 --> 00:01:42,000
Tingnan natin sa koleksyon na ito ng mga bits dito mismo.

30
00:01:42,000 --> 00:01:44,000
Dapat namin upang malaman kung gaano karaming mga bits may.

31
00:01:44,000 --> 00:01:48,000
Saan umaasa kami lang 8 sa kanila, walong 0 o 1 yunit ng.

32
00:01:48,000 --> 00:01:51,000
At dahil may 8 bits, na 1 byte,

33
00:01:51,000 --> 00:01:53,000
at sabihin convert ito sa hexadecimal.

34
00:01:53,000 --> 00:01:58,000
Hexadecimal ay base 16, at ito ay medyo madaling i-convert

35
00:01:58,000 --> 00:02:01,000
isang numero sa binary, na kung ano iyon ay, sa isang numero sa hexadecimal.

36
00:02:01,000 --> 00:02:04,000
Ang ginagawa namin ay tinitingnan namin ang mga grupo ng 4,

37
00:02:04,000 --> 00:02:07,000
at convert namin ang mga ito sa naaangkop na digit na hexadecimal.

38
00:02:07,000 --> 00:02:11,000
Simulan namin ang i-right-pinaka-grupo ng 4, kaya 0011.

39
00:02:11,000 --> 00:02:16,000
Na pagpunta sa isang 1 at isang 2, kaya sama-sama na ginagawang 3.

40
00:02:16,000 --> 00:02:19,000
At pagkatapos ay tingnan natin sa iba pang mga bloke ng 4.

41
00:02:19,000 --> 00:02:24,000
1101. Na isa 1, isang 4, at isang 8.

42
00:02:24,000 --> 00:02:28,000
Sama-sama na pagpunta sa 13, na ginagawang D.

43
00:02:28,000 --> 00:02:32,000
At kami na tandaan na sa hexadecimal hindi namin pumunta lamang 0 hanggang 9.

44
00:02:32,000 --> 00:02:36,000
Pumunta kami 0 sa pamamagitan ng F, kaya pagkatapos ng 9, 10 ay tumutugon sa A,

45
00:02:36,000 --> 00:02:40,000
11 sa B, at iba pa na kung saan ang F ay 15.

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

47
00:02:44,000 --> 00:02:49,000
kaya i-convert ito sa decimal ang ginagawa namin ay namin ang aktwal na

48
00:02:49,000 --> 00:02:52,000
tinatrato ang bawat posisyon bilang isang kapangyarihan ng 2.

49
00:02:52,000 --> 00:02:58,000
Iyon ay isang 1, isang 2, zero 4s, zero 8s, isang 16, at iba pa,

50
00:02:58,000 --> 00:03:03,000
at ito ay isang maliit na mahirap upang makalkula sa iyong ulo, ngunit kung pumunta kami sa susunod na slide

51
00:03:03,000 --> 00:03:05,000
maaari naming makita ang mga sagot na iyon.

52
00:03:05,000 --> 00:03:09,000
>> Mahalaga kami ng balagtas mula kanan pabalik sa kaliwa,

53
00:03:09,000 --> 00:03:14,000
at kami ay multiply bawat digit ng kaukulang kapangyarihan ng 2.

54
00:03:14,000 --> 00:03:19,000
At tandaan, para sa hexadecimal magpakilala namin ang mga numerong ito may 0x sa simula

55
00:03:19,000 --> 00:03:23,000
kaya hindi namin lituhin ang mga ito na may isang decimal na numero.

56
00:03:23,000 --> 00:03:29,000
Patuloy sa, ito ay isang ASCII Table,

57
00:03:29,000 --> 00:03:35,000
at kung ano ang ginagamit namin ASCII para sa ay upang i-map mula sa mga character sa numerical na halaga.

58
00:03:35,000 --> 00:03:39,000
Tandaan sa pset cryptography ginawa namin ang malawak na paggamit ng ASCII Table

59
00:03:39,000 --> 00:03:43,000
upang gamitin ang iba't ibang mga pamamaraan ng cryptography,

60
00:03:43,000 --> 00:03:47,000
ang Caesar at ang Vigenère cipher, i-convert ang iba't ibang mga titik

61
00:03:47,000 --> 00:03:52,000
sa isang string na ayon sa ang susi na ibinigay ng user.

62
00:03:52,000 --> 00:03:56,000
Tingnan natin ng kaunting ASCII matematika.

63
00:03:56,000 --> 00:04:02,000
Pagtingin sa 'P' + 1, sa character na form na Q,

64
00:04:02,000 --> 00:04:07,000
at tandaan na '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
At kung paano eksaktong-convert namin sa pagitan ng mga 2 form?

66
00:04:10,000 --> 00:04:13,000
Ito ay hindi tunay na masyadong matigas.

67
00:04:13,000 --> 00:04:16,000
Upang makakuha ng 5 ibabawas namin ang '0 '

68
00:04:16,000 --> 00:04:20,000
dahil may 5 lugar sa pagitan ng mga '0 'at ang '5.'

69
00:04:20,000 --> 00:04:23,000
Upang pumunta sa iba pang mga paraan naming idagdag lamang ang 0,

70
00:04:23,000 --> 00:04:25,000
kaya ito ay uri ng tulad ng sa regular na pang-aritmetika.

71
00:04:25,000 --> 00:04:29,000
Tandaan lamang na kapag ang isang bagay ay may mga panipi sa paligid nito ng character

72
00:04:29,000 --> 00:04:37,000
at samakatuwid ay kumakatawan sa isang halaga sa ASCII table.

73
00:04:37,000 --> 00:04:40,000
Paglipat sa higit pang mga pangkalahatang paksa computer science.

74
00:04:40,000 --> 00:04:43,000
Natutunan namin kung ano ang algorithm ng at kung paano namin ginagamit mga programa

75
00:04:43,000 --> 00:04:45,000
ipatupad algorithm.

76
00:04:45,000 --> 00:04:48,000
Ang ilang mga halimbawa ng mga algorithm ng isang bagay na talagang simple tulad ng

77
00:04:48,000 --> 00:04:51,000
pagsuri kung ang isang numero ay kahit o kakaibang.

78
00:04:51,000 --> 00:04:54,000
Para na tandaan namin mod ang numero sa pamamagitan ng 2 at suriin kung ang resulta ay 0.

79
00:04:54,000 --> 00:04:57,000
Kung gayon, kahit. Kung hindi, kakaiba.

80
00:04:57,000 --> 00:04:59,000
At na ang isang halimbawa ng isang talagang pangunahing algorithm.

81
00:04:59,000 --> 00:05:02,000
>> Isang kaunti ng isang mas kasangkot isa ay binary paghahanap,

82
00:05:02,000 --> 00:05:05,000
na ipagpapatuloy namin sa paglipas mamaya sa session ng pagsusuri.

83
00:05:05,000 --> 00:05:09,000
At programming ay ang termino na ginagamit namin para sa pagkuha ng isang algorithm

84
00:05:09,000 --> 00:05:15,000
at nagko-convert ito sa code sa computer ay maaaring basahin.

85
00:05:15,000 --> 00:05:20,000
2 halimbawa ng programming simula,

86
00:05:20,000 --> 00:05:22,000
na kung ano ang ginawa namin sa Linggo 0.

87
00:05:22,000 --> 00:05:25,000
Kahit na hindi namin aktwal type ang code ito ay isang paraan ng pagpapatupad

88
00:05:25,000 --> 00:05:29,000
ito algorithm, na kung saan ay pag-print ang mga numero 1-10,

89
00:05:29,000 --> 00:05:32,000
dito gawin namin ang pareho sa C programming wika.

90
00:05:32,000 --> 00:05:41,000
Ito ay katumbas pagtakbo, lamang ng nakasulat sa iba't ibang wika o syntax.

91
00:05:41,000 --> 00:05:44,000
Pagkatapos namin natutunan tungkol sa boolean expression,

92
00:05:44,000 --> 00:05:48,000
at ang boolean ng isang halaga na maaaring totoo o hindi,

93
00:05:48,000 --> 00:05:51,000
at dito malimit boolean expression

94
00:05:51,000 --> 00:05:55,000
pumunta sa loob ng mga kundisyon, kaya kung (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
mahusay, namin x = 5, kaya kondisyon na upang pag-aralan sa true.

96
00:06:00,000 --> 00:06:03,000
At kung ito ay totoo, anumang code ay sa ilalim ng mga kundisyon

97
00:06:03,000 --> 00:06:08,000
ay pagpunta sa nasuri ng computer, kaya ang string na ay pagpunta sa ipi-print

98
00:06:08,000 --> 00:06:12,000
sa standard na output, at ang terminong kundisyon

99
00:06:12,000 --> 00:06:16,000
ay tumutukoy sa anumang sa loob ng panaklong ng kung pahayag.

100
00:06:16,000 --> 00:06:20,000
Tandaan ang lahat ng mga operator.

101
00:06:20,000 --> 00:06:26,000
Tandaan ito ay && at | | kapag sinusubukan naming pagsamahin 2 o higit pang mga kundisyon,

102
00:06:26,000 --> 00:06:30,000
== Hindi = upang suriin kung ang 2 bagay ay pantay-pantay.

103
00:06:30,000 --> 00:06:36,000
Tandaan na = para sa pagtatalaga samantalang == ay isang boolean operator.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ at pagkatapos ay ang panghuling 2 ay maliwanag.

105
00:06:41,000 --> 00:06:45,000
Isang pangkalahatang pagsusuri ng boolean logic dito.

106
00:06:45,000 --> 00:06:48,000
At boolean expression ay mahalaga din sa loop,

107
00:06:48,000 --> 00:06:50,000
na ipagpapatuloy namin sa paglipas ngayon.

108
00:06:50,000 --> 00:06:56,000
Namin natutunan ang tungkol sa 3 uri ng mga loop sa ngayon sa CS50,, habang, at gawin habang.

109
00:06:56,000 --> 00:06:59,000
At ito ay mahalagang malaman na habang para sa karamihan ng mga layunin ng

110
00:06:59,000 --> 00:07:02,000
maaari naming aktwal na gamitin ang anumang uri ng loop sa pangkalahatan

111
00:07:02,000 --> 00:07:06,000
may ilang mga uri ng mga layunin o mga karaniwang pattern

112
00:07:06,000 --> 00:07:09,000
programming na partikular na tumawag para sa isa ng mga loop

113
00:07:09,000 --> 00:07:13,000
na gawin itong ang pinaka-mahusay o eleganteng code na ito sa paraan na.

114
00:07:13,000 --> 00:07:18,000
Natin pumunta sa kung ano ang bawat isa sa mga loop ay may kaugaliang upang gamitin para sa madalas.

115
00:07:18,000 --> 00:07:21,000
>> Sa isang para sa loop namin sa pangkalahatan na malaman kung gaano karaming beses ang nais namin upang umulit.

116
00:07:21,000 --> 00:07:24,000
Iyon ay kung ano ang inilalagay namin sa kundisyon.

117
00:07:24,000 --> 00:07:28,000
Para sa, i = 0, i <10, halimbawa.

118
00:07:28,000 --> 00:07:31,000
Na namin alam na gusto naming gawin ang isang bagay na 10 beses.

119
00:07:31,000 --> 00:07:34,000
Ngayon, para sa isang habang loop, pangkalahatan, hindi namin kinakailangang

120
00:07:34,000 --> 00:07:36,000
malaman kung gaano karaming beses ang gusto naming loop na tumakbo.

121
00:07:36,000 --> 00:07:39,000
Ngunit ginagawa namin malaman ang ilang mga uri ng mga kondisyon na gusto namin ito

122
00:07:39,000 --> 00:07:41,000
palaging totoo o palaging maling.

123
00:07:41,000 --> 00:07:44,000
Halimbawa, habang naka-set.

124
00:07:44,000 --> 00:07:46,000
Sabihin natin na ang isang boolean variable.

125
00:07:46,000 --> 00:07:48,000
Habang na ang tunay na gusto naming code upang pag-aralan,

126
00:07:48,000 --> 00:07:52,000
kaya ng kaunti mas extensible, isang kaunti mas pangkalahatang kaysa sa isang loop,

127
00:07:52,000 --> 00:07:55,000
subalit ang anumang para sa loop ay maaari ring ma-convert sa isang loop habang.

128
00:07:55,000 --> 00:08:00,000
Panghuli, gawin habang loop, na maaaring maging trickiest naiintindihan kaagad,

129
00:08:00,000 --> 00:08:04,000
ay madalas na ginagamit kapag gusto namin upang pag-aralan muna ang code

130
00:08:04,000 --> 00:08:06,000
bago ang unang pagkakataon namin suriin ang kalagayan.

131
00:08:06,000 --> 00:08:09,000
Ang isang karaniwang kaso ng paggamit para sa isang gawin habang loop

132
00:08:09,000 --> 00:08:12,000
kapag gusto mo upang makuha ang input ng user, at alam mo na nais mong hilingin sa user

133
00:08:12,000 --> 00:08:15,000
para sa input ng hindi bababa sa isang beses, ngunit kung hindi sila magbibigay sa iyo ng magandang input kaagad

134
00:08:15,000 --> 00:08:18,000
Nais mo bang panatilihin ang pagtatanong sa kanila hanggang sila ay magbibigay sa iyo ng mahusay na input.

135
00:08:18,000 --> 00:08:21,000
Iyon ay ang pinaka-karaniwang paggamit ng isang habang loop,

136
00:08:21,000 --> 00:08:23,000
at tingnan natin sa aktwal na istraktura ng mga loop.

137
00:08:23,000 --> 00:08:27,000
Sila ay karaniwang palaging ay may posibilidad upang sundin ang mga pattern.

138
00:08:27,000 --> 00:08:30,000
>> Sa para sa loop sa loob mayroon kang 3 bahagi:

139
00:08:30,000 --> 00:08:35,000
Pinasimulan, karaniwang isang bagay tulad ng int i = 0 kung saan ay i counter,

140
00:08:35,000 --> 00:08:40,000
kondisyon, kung saan nais naming sabihin patakbuhin ang para sa loop hangga't bilang kundisyon hold pa rin ito,

141
00:08:40,000 --> 00:08:44,000
tulad ng i <10, at pagkatapos ay sa wakas, i-update, na kung saan ay kung paano namin dagdagan

142
00:08:44,000 --> 00:08:47,000
ang counter variable sa bawat punto sa loop.

143
00:08:47,000 --> 00:08:50,000
Ang isang karaniwang bagay upang makita doon ay i + +,

144
00:08:50,000 --> 00:08:52,000
na nangangahulugan na i dagdagan sa pamamagitan ng 1 sa bawat oras.

145
00:08:52,000 --> 00:08:55,000
Maaari mo ring gawin ang isang bagay tulad ng i + = 2,

146
00:08:55,000 --> 00:08:58,000
na nangangahulugan na magdagdag ng 2 sa i bawat oras na pumunta ka sa pamamagitan ng loop.

147
00:08:58,000 --> 00:09:03,000
At pagkatapos ay gawin ito lamang ay tumutukoy sa anumang code na aktwal na tumatakbo bilang bahagi ng loop.

148
00:09:03,000 --> 00:09:09,000
At para sa isang habang loop, oras na ito namin aktwal ay ang Pinasimulan sa labas ng loop,

149
00:09:09,000 --> 00:09:12,000
kaya halimbawa, sabihin nating sinusubukan naming gawin ang parehong uri ng loop bilang ko na inilarawan.

150
00:09:12,000 --> 00:09:16,000
Gusto namin sabihin int i = 0 bago loop nagsisimula.

151
00:09:16,000 --> 00:09:20,000
Pagkatapos ay maaari naming sabihin habang i <10 gawin ito,

152
00:09:20,000 --> 00:09:22,000
kaya ang parehong bloke ng code tulad ng dati,

153
00:09:22,000 --> 00:09:26,000
at oras na ito ang bahagi ng update ng code, halimbawa, i + +,

154
00:09:26,000 --> 00:09:29,000
aktwal na napupunta sa loob ng loop.

155
00:09:29,000 --> 00:09:33,000
At sa wakas, para sa isang gawin habang, katulad sa loop habang,

156
00:09:33,000 --> 00:09:36,000
ngunit mayroon kaming tandaan na ang code ay suriin sabay-sabay

157
00:09:36,000 --> 00:09:40,000
bago ang kundisyon ay naka-check, kaya gumagawa ng maraming higit pang mga kahulugan

158
00:09:40,000 --> 00:09:44,000
kung tiningnan mo ang mga ito sa pagkakasunud-sunod ng sa itaas hanggang sa ibaba.

159
00:09:44,000 --> 00:09:49,000
Sa isang gawin habang loop code ng sinusuri bago mo ring tingnan ang kundisyon ng habang,

160
00:09:49,000 --> 00:09:55,000
kung saan isang habang loop, sumusuri unang.

161
00:09:55,000 --> 00:09:59,000
Pahayag at variable.

162
00:09:59,000 --> 00:10:04,000
Kapag gusto naming upang lumikha ng isang bagong variable gusto muna namin ang pagsisimula ito.

163
00:10:04,000 --> 00:10:07,000
>> Halimbawa, int na bar initializes ang variable bar,

164
00:10:07,000 --> 00:10:10,000
ngunit hindi ito bigyan ito ng isang halaga, kaya kung ano ang bar ng halaga ngayon?

165
00:10:10,000 --> 00:10:12,000
Hindi namin alam.

166
00:10:12,000 --> 00:10:14,000
Ito ay maaaring maging ng ilang mga halaga ng basura na ay dati nang naka-imbak sa memorya doon,

167
00:10:14,000 --> 00:10:16,000
at hindi namin gusto mong gamitin na variable

168
00:10:16,000 --> 00:10:19,000
hanggang sa aktwal na namin bigyan ito ng isang halaga,

169
00:10:19,000 --> 00:10:21,000
kaya ipinapahayag namin ito dito.

170
00:10:21,000 --> 00:10:24,000
Pagkatapos naming nakapagsimula ito sa 42 sa ibaba.

171
00:10:24,000 --> 00:10:28,000
Ngayon, siyempre, alam namin na ito ay maaaring gawin sa isang linya, int bar = 42.

172
00:10:28,000 --> 00:10:30,000
Ngunit lamang na i-clear ang maraming mga hakbang na nangyayari sa,

173
00:10:30,000 --> 00:10:34,000
ang deklarasyon at ang Pinasimulan nangyayari hiwalay dito.

174
00:10:34,000 --> 00:10:38,000
Ito ay nangyayari sa isang hakbang, at sa susunod, int baz = bar + 1,

175
00:10:38,000 --> 00:10:44,000
ang pahayag na ito sa ibaba, na palugit baz, kaya sa dulo ng block ng code na ito

176
00:10:44,000 --> 00:10:48,000
kung kami ay upang i-print ang halaga ng baz ito ng 44

177
00:10:48,000 --> 00:10:52,000
dahil ipinapahayag namin at initialize ito sa 1> bar,

178
00:10:52,000 --> 00:10:58,000
at pagkatapos naming dagdagan ang mga ito nang isa pang beses sa + +.

179
00:10:58,000 --> 00:11:02,000
Nagpunta kami sa paglipas itong maganda panandaliang, ngunit ito ay mahusay na upang magkaroon ng isang pangkalahatang

180
00:11:02,000 --> 00:11:04,000
pag-unawa kung ano ang mga thread at kaganapan.

181
00:11:04,000 --> 00:11:06,000
Pangunahing ginawa namin ito sa simula,

182
00:11:06,000 --> 00:11:09,000
sa gayon ay maaari mong isipin ng mga thread sa bilang ng maramihang mga pagkakasunud-sunod ng code

183
00:11:09,000 --> 00:11:11,000
na tumatakbo sa parehong oras.

184
00:11:11,000 --> 00:11:14,000
Sa katunayan, marahil ito ay hindi tumatakbo sa parehong panahon,

185
00:11:14,000 --> 00:11:17,000
ngunit uri ng abstractly maaari naming tingin ito sa paraan na.

186
00:11:17,000 --> 00:11:20,000
>> Sa simula, halimbawa, nagkaroon kami ng maramihang mga sprites.

187
00:11:20,000 --> 00:11:22,000
Maaaring execute ang ibang code sa parehong oras.

188
00:11:22,000 --> 00:11:26,000
Maaaring isa-maigsing habang ang iba pa ay sinasabi ng isang bagay

189
00:11:26,000 --> 00:11:29,000
sa isang iba't ibang mga bahagi ng screen.

190
00:11:29,000 --> 00:11:34,000
Kaganapan ay isa pang paraan ng paghihiwalay ng ang logic

191
00:11:34,000 --> 00:11:37,000
sa pagitan ng mga iba't ibang mga elemento ng iyong code,

192
00:11:37,000 --> 00:11:40,000
at sa simula kami ay upang gayahin ang mga kaganapan sa gamit ang Broadcast,

193
00:11:40,000 --> 00:11:43,000
at na aktwal Kapag Tumanggap ko, hindi Kapag Pakinggan ko,

194
00:11:43,000 --> 00:11:47,000
ngunit mahalagang ito ay isang paraan upang magpadala ng impormasyon

195
00:11:47,000 --> 00:11:49,000
mula sa isang engkanto sa ibang.

196
00:11:49,000 --> 00:11:52,000
Halimbawa, maaaring gusto mong magpadala laro sa paglipas ng,

197
00:11:52,000 --> 00:11:56,000
at kapag ang isa pang engkanto na natatanggap ng laro sa paglipas ng,

198
00:11:56,000 --> 00:11:58,000
tumugon sa isang tiyak na paraan.

199
00:11:58,000 --> 00:12:03,000
Ito ay isang mahalagang modelo upang maunawaan para sa programming.

200
00:12:03,000 --> 00:12:07,000
Lamang upang pumunta sa ibabaw ng pangunahing Linggo 0, kung ano ang namin ang nawala sa paglipas ng sa ngayon,

201
00:12:07,000 --> 00:12:10,000
tingnan natin ito simpleng programa C.

202
00:12:10,000 --> 00:12:14,000
Teksto ay maaaring kaunti na maliit mula dito, ngunit ko pumunta sa paglipas ng ito talagang mabilis.

203
00:12:14,000 --> 00:12:20,000
Kami ay kabilang ang 2 file ng header sa tuktok, cs50.h at stdio.h.

204
00:12:20,000 --> 00:12:23,000
Kami ng pagtukoy sa isang pare-pareho na tinatawag na limitasyon na 100.

205
00:12:23,000 --> 00:12:26,000
Kami ay pagpapatupad ng aming pangunahing function na.

206
00:12:26,000 --> 00:12:29,000
Dahil hindi namin gamitin ang mga argumento sa command line dito kailangan namin upang ilagay ang walang bisa

207
00:12:29,000 --> 00:12:32,000
bilang ng mga argumento para sa pangunahing.

208
00:12:32,000 --> 00:12:38,000
Nakikita namin int itaas pangunahing. Iyon ang return uri, samakatuwid bumalik 0 sa ibaba.

209
00:12:38,000 --> 00:12:41,000
At ginagamit namin CS50 library function na makakuha int

210
00:12:41,000 --> 00:12:45,000
tanungin ang user para sa input, at hindi namin iimbak ito sa ito variable x,

211
00:12:45,000 --> 00:12:51,000
kaya namin idedeklara x sa itaas, at initialize namin ito may x = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> Pagkatapos namin suriin upang makita kung ang user ay nagbigay sa amin ng magandang input.

213
00:12:53,000 --> 00:12:59,000
Kung ≥ LIMIT gusto naming ibalik ng isang error code na 1 at i-print ang isang mensahe ng error.

214
00:12:59,000 --> 00:13:02,000
At sa wakas, kung ang gumagamit ay nagbigay sa amin ng mahusay na input

215
00:13:02,000 --> 00:13:08,000
kami ay parisukat ang numero at i-print na resulta.

216
00:13:08,000 --> 00:13:11,000
Lamang upang matiyak na ang mga lahat ng tahanan hit

217
00:13:11,000 --> 00:13:17,000
maaari mong makita ang mga label ng mga iba't ibang mga bahagi ng code dito.

218
00:13:17,000 --> 00:13:19,000
Nabanggit ko pare-pareho, header file.

219
00:13:19,000 --> 00:13:21,000
Oh, int x. Tiyakin na tandaan na ang isang lokal na variable.

220
00:13:21,000 --> 00:13:24,000
Na contrasts ito mula sa isang global na variable, kung saan ipapakita namin makipag-usap tungkol sa

221
00:13:24,000 --> 00:13:27,000
kaunti mamaya sa pagsusuri ng session,

222
00:13:27,000 --> 00:13:30,000
at kami ay pagtawag sa library function na printf,

223
00:13:30,000 --> 00:13:34,000
kaya kung hindi namin kasama ang stdio.h file ng header

224
00:13:34,000 --> 00:13:37,000
hindi namin magagawang tawagan printf.

225
00:13:37,000 --> 00:13:42,000
At naniniwala ko ang arrow na Nakakuha putol dito ay tumuturo sa d%,

226
00:13:42,000 --> 00:13:45,000
na-format na string sa printf.

227
00:13:45,000 --> 00:13:52,000
Sabi ni i-print ang variable na ito bilang isang numero,% d.

228
00:13:52,000 --> 00:13:58,000
At na ito para sa Linggo 0.

229
00:13:58,000 --> 00:14:06,000
Ngayon Lucas ay pagpunta upang magpatuloy.

230
00:14:06,000 --> 00:14:08,000
Hey, guys. Ang pangalan ko ay Lucas.

231
00:14:08,000 --> 00:14:10,000
Ako isang sopomor sa pinakamahusay na bahay sa campus, Mather,

232
00:14:10,000 --> 00:14:14,000
at ako makipag-usap ng kaunti tungkol sa Linggo 1 at 2.1.

233
00:14:14,000 --> 00:14:16,000
[Linggo 1 at 2.1!] [Lucas Freitas]

234
00:14:16,000 --> 00:14:19,000
Bilang Lexi ay sinasabi, kapag nagsimula kaming pagsalin ng iyong code mula sa simula sa C

235
00:14:19,000 --> 00:14:23,000
isa ng mga bagay na napansin namin na maaari mong hindi lamang

236
00:14:23,000 --> 00:14:26,000
isulat ang iyong code at patakbuhin ang mga ito gamit ang isang berdeng bandila ito.

237
00:14:26,000 --> 00:14:30,000
Aktwal na, mayroon kang upang gamitin ang ilang mga hakbang upang gawin ang iyong programa sa C

238
00:14:30,000 --> 00:14:33,000
maging isang executable file.

239
00:14:33,000 --> 00:14:36,000
Talaga kung ano ang ginagawa mo kapag sumusulat ka ng isang program na

240
00:14:36,000 --> 00:14:40,000
mong isalin ang iyong ideya sa isang wika na maunawaan na ang tagatala ng,

241
00:14:40,000 --> 00:14:44,000
kaya kapag sumusulat ka ng isang programa sa C

242
00:14:44,000 --> 00:14:47,000
kung ano ang iyong ginagawa ay aktwal na pagsusulat ng isang bagay na ang iyong tagatala ay upang maunawaan,

243
00:14:47,000 --> 00:14:50,000
at pagkatapos tagatala ay pagpunta sa isalin ang code na iyon

244
00:14:50,000 --> 00:14:53,000
sa isang bagay na ang iyong computer ay maunawaan.

245
00:14:53,000 --> 00:14:55,000
>> At bagay, ang iyong computer ay talagang napaka pipi.

246
00:14:55,000 --> 00:14:57,000
Iyong computer ay maaari lamang maunawaan 0s at 1s,

247
00:14:57,000 --> 00:15:01,000
kaya aktwal na sa unang computer mga tao na karaniwang program

248
00:15:01,000 --> 00:15:04,000
paggamit ng 0s at 1s, ngunit hindi ito, salamat sa Diyos.

249
00:15:04,000 --> 00:15:07,000
Hindi namin kabisaduhin ang mga pagkakasunud-sunod para 0s at 1s

250
00:15:07,000 --> 00:15:10,000
para sa isang para sa loop o para sa isang habang loop at iba pa.

251
00:15:10,000 --> 00:15:13,000
Iyon ay kung bakit mayroon kaming isang tagatala.

252
00:15:13,000 --> 00:15:17,000
Ano tagatala ng nagagawa ng isang ito talaga isinasalin ang C code,

253
00:15:17,000 --> 00:15:21,000
sa aming kaso, sa isang wika na ang iyong computer ay maunawaan,

254
00:15:21,000 --> 00:15:25,000
na ang bagay na code, at ang tagatala na ginagamit namin

255
00:15:25,000 --> 00:15:30,000
ay tinatawag na kumalatong, kaya ito ay talagang ang simbolo para sa kumalatong.

256
00:15:30,000 --> 00:15:33,000
Kapag mayroon ka ng iyong programa, mayroon kang gawin ang 2 bagay.

257
00:15:33,000 --> 00:15:37,000
Una, mayroon kang upang ipunin ang iyong programa, at pagkatapos ka upang patakbuhin ang iyong programa.

258
00:15:37,000 --> 00:15:41,000
Upang ipunin ang iyong programa mayroon kang maraming mga pagpipilian upang gawin ito.

259
00:15:41,000 --> 00:15:44,000
Ang unang isa ay upang gawin kumalatong program.c

260
00:15:44,000 --> 00:15:47,000
kung saan ang programa ay ang pangalan ng iyong programa.

261
00:15:47,000 --> 00:15:51,000
Sa kasong ito, maaari mong makita lamang ang sinasabi nila "Uy, makatipon ang aking programa."

262
00:15:51,000 --> 00:15:56,000
Hindi mo sinasabi na "Gusto ko ang pangalan na ito para sa aking programa" o anumang.

263
00:15:56,000 --> 00:15:58,000
>> Ang ikalawang opsyon ay pagbibigay ng pangalan sa iyong programa.

264
00:15:58,000 --> 00:16:02,000
Maaari mong sabihin kumalatong-o at pagkatapos ay ang pangalan na gusto mo

265
00:16:02,000 --> 00:16:06,000
executable file na pinangalanang bilang at pagkatapos program.c.

266
00:16:06,000 --> 00:16:11,000
At maaari ka ring gumawa ng programa, at makita kung paano sa unang 2 kaso

267
00:16:11,000 --> 00:16:15,000
Ko bang ilagay. C, at sa ikatlong isa ko lang ng mga programa?

268
00:16:15,000 --> 00:16:18,000
Oo, aktwal mo ay hindi dapat ilagay. C kapag gumamit ka ng gumawa.

269
00:16:18,000 --> 00:16:22,000
Kung hindi man ang tagatala ay talagang pagpunta sa sumigaw sa iyo.

270
00:16:22,000 --> 00:16:24,000
At din, hindi ko alam kung ikaw guys tandaan,

271
00:16:24,000 --> 00:16:29,000
ngunit maraming ng beses na namin ginagamit din-lcs50 o-lm.

272
00:16:29,000 --> 00:16:31,000
Na tinatawag na pagli-link.

273
00:16:31,000 --> 00:16:35,000
Ito lamang ay nagsasabi sa ang tagatala na gagamitin mo sa mga aklatan doon,

274
00:16:35,000 --> 00:16:39,000
kaya kung gusto mong gamitin ang cs50.h iyong aktwal na i-type ang

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

276
00:16:43,000 --> 00:16:45,000
Kung hindi mo gawin iyon, ang tagatala ay hindi malaman

277
00:16:45,000 --> 00:16:50,000
na gumagamit ka ng mga function sa cs50.h.

278
00:16:50,000 --> 00:16:52,000
At kapag gusto mong patakbuhin ang iyong programa Mayroon kang 2 pagpipilian.

279
00:16:52,000 --> 00:16:57,000
Kung ginawa mo kumalatong program.c hindi mo magbigay ng pangalan sa iyong programa.

280
00:16:57,000 --> 00:17:01,000
Mayroon kang upang patakbuhin ito gamit. / A.out.

281
00:17:01,000 --> 00:17:06,000
Ang A.out ay isang karaniwang pangalan na kumalatong ay nagbibigay ng iyong programa kung hindi mo bigyan ito ng isang pangalan.

282
00:17:06,000 --> 00:17:11,000
Kung hindi ka pagpunta sa gawin. / Programa kung ikaw ay nagbigay ng pangalan sa iyong programa,

283
00:17:11,000 --> 00:17:15,000
at din kung ang programa ang pangalan na programa ng upang makakuha ng

284
00:17:15,000 --> 00:17:23,000
na na program ang parehong pangalan tulad ng file c.

285
00:17:23,000 --> 00:17:26,000
Pagkatapos usapan natin ang tungkol sa mga uri ng data at ang data.

286
00:17:26,000 --> 00:17:31,000
>> Isa lamang uri ng data ay ang mga parehong bagay bilang maliit na kahon ginagamit nila

287
00:17:31,000 --> 00:17:35,000
upang mag-imbak ng mga halaga, kaya ang mga uri ng data ay talagang tulad ng Pokémons.

288
00:17:35,000 --> 00:17:39,000
Mga ito sa lahat ng mga laki at uri.

289
00:17:39,000 --> 00:17:43,000
Hindi ko alam kung ang pagkakatulad na saysay.

290
00:17:43,000 --> 00:17:46,000
Ang laki ng data sa aktwal ay depende sa architecture machine.

291
00:17:46,000 --> 00:17:49,000
Ang lahat ng data laki na ako pagpunta upang ipakita dito

292
00:17:49,000 --> 00:17:53,000
ay talagang para sa isang 32-bit na machine, na kung saan ay ang kaso ng aming appliance,

293
00:17:53,000 --> 00:17:56,000
ngunit kung aktwal mong coding sa iyong Mac o sa isang Windows din

294
00:17:56,000 --> 00:17:59,000
marahil ka upang magkaroon ng isang 64-bit na machine,

295
00:17:59,000 --> 00:18:03,000
kaya tandaan na ang laki ng data na ako pupunta upang ipakita dito

296
00:18:03,000 --> 00:18:06,000
para sa 32-bit na machine.

297
00:18:06,000 --> 00:18:08,000
Ang unang isa na nakita natin ay isang int,

298
00:18:08,000 --> 00:18:10,000
na medyo direkta.

299
00:18:10,000 --> 00:18:13,000
Gumamit ka ng int upang mag-imbak ng isang integer.

300
00:18:13,000 --> 00:18:16,000
Din kami nakakita ng character, ang pansamantalang trabaho.

301
00:18:16,000 --> 00:18:20,000
Kung nais mong gumamit ng isang titik o isang maliit na simbolo marahil ka na gumamit ng isang pansamantalang trabaho.

302
00:18:20,000 --> 00:18:26,000
Magpasinda A ay 1 byte, na nangangahulugan ng 8 bits, tulad Lexi sinabi.

303
00:18:26,000 --> 00:18:31,000
Talaga mayroon kaming isang ASCII Table na may 256

304
00:18:31,000 --> 00:18:34,000
posibleng mga kumbinasyon ng 0s at 1s,

305
00:18:34,000 --> 00:18:37,000
at pagkatapos ay kapag nag-type ka ng isang pansamantalang trabaho ito upang isalin ang

306
00:18:37,000 --> 00:18:44,000
karakter ang na input sa iyo ng isang numero na mayroon ka sa ASCII table, tulad Lexi sinabi.

307
00:18:44,000 --> 00:18:48,000
Mayroon din kaming Float, na ginagamit namin upang mag-imbak ng mga numero ng decimal.

308
00:18:48,000 --> 00:18:53,000
Kung nais mong pumili ng 3.14, halimbawa, ikaw ay pagpunta sa gumamit ng Float

309
00:18:53,000 --> 00:18:55,000
o isang double na may higit pang katumpakan.

310
00:18:55,000 --> 00:18:57,000
Float A ay may 4 bytes.

311
00:18:57,000 --> 00:19:01,000
Double A ay may 8 bytes, kaya ang pagkakaiba lamang ay ang katumpakan.

312
00:19:01,000 --> 00:19:04,000
Mayroon din kaming isang mahabang na ginagamit para sa mga integer,

313
00:19:04,000 --> 00:19:09,000
at maaari mong makita para sa isang 32-bit na machine isang int at isang mahabang may parehong laki,

314
00:19:09,000 --> 00:19:13,000
kaya hindi ito ay talagang magkaroon ng kahulugan na gumamit ng isang mahaba sa 32-bit na machine.

315
00:19:13,000 --> 00:19:17,000
>> Ngunit kung gumagamit ka ng Mac at 64-bit na machine, talagang isang mahabang laki 8,

316
00:19:17,000 --> 00:19:19,000
kaya talagang depende sa architecture.

317
00:19:19,000 --> 00:19:22,000
Para sa 32-bit na machine hindi ito gumawa ng kahulugan upang gumamit ng isang mahabang talagang.

318
00:19:22,000 --> 00:19:25,000
At pagkatapos ng isang mahabang mahabang, sa kabilang banda, ay may 8 bytes,

319
00:19:25,000 --> 00:19:30,000
kaya ito ay isang magandang kung nais mong magkaroon ng isang na integer.

320
00:19:30,000 --> 00:19:34,000
At panghuli, mayroon kaming string, na kung saan ay talagang isang pansamantalang trabaho *,

321
00:19:34,000 --> 00:19:37,000
na isang pointer sa isang pansamantalang trabaho.

322
00:19:37,000 --> 00:19:40,000
Napakadaling mag-isip na ang laki ng string ay magiging tulad ng

323
00:19:40,000 --> 00:19:42,000
ang bilang ng mga character na mayroon ka doon,

324
00:19:42,000 --> 00:19:45,000
pero sa totoo magpasinda * mismo

325
00:19:45,000 --> 00:19:49,000
ay ang laki ng isang pointer sa isang pansamantalang trabaho, na 4 bytes.

326
00:19:49,000 --> 00:19:52,000
Ang laki ng isang pansamantalang trabaho * 4 bytes.

327
00:19:52,000 --> 00:19:56,000
Hindi mahalaga kung mayroon kang isang maliit na salita o ng sulat o anumang.

328
00:19:56,000 --> 00:19:58,000
Ito ay pagpunta sa 4 bytes.

329
00:19:58,000 --> 00:20:01,000
Din namin natutunan ng kaunti tungkol sa Casting,

330
00:20:01,000 --> 00:20:04,000
sa gayon ay maaari mong makita, kung mayroon kang, halimbawa, isang programa na nagsasabing

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

332
00:20:08,000 --> 00:20:12,000
ka guys malaman kung ano ang pagpunta sa i-print sa screen?

333
00:20:12,000 --> 00:20:14,000
>> May? >> [Mga mag-aaral] 2.

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

335
00:20:16,000 --> 00:20:20,000
Kapag ginawa mo 3/2 ito upang makakuha ng 1.5,

336
00:20:20,000 --> 00:20:24,000
ngunit dahil kami ay gumagamit ng isang integer ito upang balewalain ang decimal bahagi,

337
00:20:24,000 --> 00:20:26,000
at ikaw ay pagpunta sa may 1.

338
00:20:26,000 --> 00:20:29,000
Kung hindi mo nais na mangyari kung ano ang maaari mong gawin, halimbawa,

339
00:20:29,000 --> 00:20:33,000
ay ipinapahayag ng Float y = x.

340
00:20:33,000 --> 00:20:40,000
Pagkatapos x na ginamit na 3 na ngayon na 3.000 sa y.

341
00:20:40,000 --> 00:20:44,000
At pagkatapos ay maaari mong i-print ang y / 2.

342
00:20:44,000 --> 00:20:50,000
Aktwal na, ang dapat kong magkaroon ng 2. doon.

343
00:20:50,000 --> 00:20:55,000
Ito ay pagpunta sa gawin 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
at ikaw ay pagpunta upang makakuha ng 1.5.

345
00:20:58,000 --> 00:21:06,000
At mayroon kaming ito .2 f lamang humingi para sa 2 decimal unit sa decimal bahagi.

346
00:21:06,000 --> 00:21:12,000
Kung mayroon kang 0.3 f ito pagpunta sa aktwal na magkaroon ng 1.500.

347
00:21:12,000 --> 00:21:16,000
Kung ito ay 2 ng pagpunta sa 1.50.

348
00:21:16,000 --> 00:21:18,000
Mayroon din kaming kasong ito dito.

349
00:21:18,000 --> 00:21:22,000
Kung gagawin mo Float x = 3.14 at pagkatapos mo printf x

350
00:21:22,000 --> 00:21:24,000
ka pagpunta upang makakuha ng 3.14.

351
00:21:24,000 --> 00:21:29,000
At kung gagawin mo x = ang int ng x,

352
00:21:29,000 --> 00:21:34,000
na nangangahulugan na ituturing ng x bilang isang int at i-print mo x ngayon

353
00:21:34,000 --> 00:21:36,000
ka pagpunta sa 3.00.

354
00:21:36,000 --> 00:21:38,000
Ba na magkaroon ng kahulugan?

355
00:21:38,000 --> 00:21:41,000
Dahil unang ka pagpapagamot ng x bilang isang integer, kaya ka pagbalewala sa decimal bahagi,

356
00:21:41,000 --> 00:21:45,000
at pagkatapos ka pag-print x.

357
00:21:45,000 --> 00:21:47,000
At sa wakas, maaari mo ring gawin ito,

358
00:21:47,000 --> 00:21:52,000
int x = 65, at pagkatapos ay ipinapahayag ng isang pansamantalang trabaho c = x,

359
00:21:52,000 --> 00:21:56,000
at pagkatapos ay kung-print ang c aktwal ka upang makakuha ng

360
00:21:56,000 --> 00:21:59,000
A, kaya talaga kung ano ang ginagawa mo dito

361
00:21:59,000 --> 00:22:02,000
ay nagta-translate ang integer sa ng character,

362
00:22:02,000 --> 00:22:05,000
lamang tulad ng ASCII Table ginagawa.

363
00:22:05,000 --> 00:22:08,000
Uusapang din kami tungkol sa mga operator matematika.

364
00:22:08,000 --> 00:22:14,000
Karamihan sa kanila ay medyo direkta, kaya +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
at din usapan natin ang tungkol sa mod, kung saan ay ang natitira sa isang sangay ng 2 numero.

366
00:22:20,000 --> 00:22:23,000
Kung mayroon kang 10% 3, halimbawa,

367
00:22:23,000 --> 00:22:27,000
ibig sabihin nito ay hatiin ang 10 sa pamamagitan ng 3, at kung ano ang natitira?

368
00:22:27,000 --> 00:22:30,000
Ito ay pagpunta sa 1, kaya ito ay aktwal na lubhang kapaki-pakinabang para sa maraming mga programa.

369
00:22:30,000 --> 00:22:38,000
Para Vigenère at Caesar ako ay medyo sigurado na lahat ng ka guys ginamit mod.

370
00:22:38,000 --> 00:22:43,000
Tungkol sa operator sa matematika, maging maingat kapag pinagsasama-sama ng * at /.

371
00:22:43,000 --> 00:22:48,000
>> Halimbawa, kung gagawin mo (3/2) * 2 kung ano ang iyong pagpunta upang makakuha ng?

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

373
00:22:50,000 --> 00:22:54,000
Oo, 2, dahil 3/2 pagpunta sa 1.5,

374
00:22:54,000 --> 00:22:57,000
ngunit dahil ikaw ay gumagawa ng mga operasyon sa pagitan ng 2 integer

375
00:22:57,000 --> 00:22:59,000
tunay ka lamang na isaalang-alang ang 1,

376
00:22:59,000 --> 00:23:03,000
at pagkatapos ay ang 1 * 2 na 2, kaya maging napaka, napaka-ingat

377
00:23:03,000 --> 00:23:07,000
kapag ginagawa ng aritmetika may integer dahil

378
00:23:07,000 --> 00:23:12,000
maaari kang makakuha na 2 = 3, sa kasong iyon.

379
00:23:12,000 --> 00:23:14,000
At ring maging maingat tungkol sa mangingibabaw.

380
00:23:14,000 --> 00:23:21,000
Dapat na karaniwan mong gamitin mga panaklong upang matiyak na alam mo kung ano ang iyong ginagawa.

381
00:23:21,000 --> 00:23:27,000
Ilang kapaki-pakinabang na mga shortcut, siyempre, isa i + + o i + = 1

382
00:23:27,000 --> 00:23:30,000
o paggamit + =.

383
00:23:30,000 --> 00:23:34,000
Na ang parehong bagay bilang paggawa i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Maaari mo ring gawin i - o i - = 1,

385
00:23:39,000 --> 00:23:42,000
kung saan ay ang parehong bagay bilang i = i -1,

386
00:23:42,000 --> 00:23:46,000
isang bagay ka guys ay gumagamit ng maraming sa para sa mga loop, hindi bababa sa.

387
00:23:46,000 --> 00:23:52,000
Gayundin, *, kung gumamit ka ng * = at kung gagawin mo ito, halimbawa,

388
00:23:52,000 --> 00:23:57,000
i * = 2 ay ang parehong bagay bilang sinasabi i = i * 2,

389
00:23:57,000 --> 00:23:59,000
at ang parehong bagay para sa division.

390
00:23:59,000 --> 00:24:08,000
Kung gagawin mo ang i / = 2 ang parehong bagay bilang i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Ngayon tungkol sa mga function.

392
00:24:10,000 --> 00:24:13,000
Mong natutunan ang mga guys na function ay isang napakagandang diskarte upang i-save ang code

393
00:24:13,000 --> 00:24:16,000
habang naka-programa, kaya kung gusto mong gawin ang parehong gawain

394
00:24:16,000 --> 00:24:20,000
sa code sa muli at muli, marahil nais mong gamitin ang isang function

395
00:24:20,000 --> 00:24:25,000
lang kaya hindi mo na kailangang kopyahin at i-paste ang code nang paulit-ulit.

396
00:24:25,000 --> 00:24:28,000
Aktwal na, ang pangunahing ay isang function, at kapag ipakita ko sa iyo ang format ng isang function

397
00:24:28,000 --> 00:24:32,000
ka pagpunta upang makita na na medyo halata.

398
00:24:32,000 --> 00:24:35,000
Rin naming gamitin ang mga function mula sa ilang mga aklatan,

399
00:24:35,000 --> 00:24:39,000
halimbawa, printf, GetIn, na mula sa library ng CS50,

400
00:24:39,000 --> 00:24:43,000
at iba pang mga function tulad toupper.

401
00:24:43,000 --> 00:24:46,000
Ang lahat ng mga function ay talagang ipinapatupad sa iba pang mga aklatan,

402
00:24:46,000 --> 00:24:49,000
at kapag inilagay mo ang mga file na iyon ng ma-tether sa simula ng iyong programa

403
00:24:49,000 --> 00:24:53,000
ka sinasabi Maaari ninyo bang bigyan ako ang code para sa mga function

404
00:24:53,000 --> 00:24:57,000
kaya hindi ko ipatupad ang mga ito sa pamamagitan ng aking sarili?

405
00:24:57,000 --> 00:25:00,000
At maaari mo ring isulat ang iyong sariling mga function, kaya kapag sinimulan mo ang programming

406
00:25:00,000 --> 00:25:04,000
Napagtanto mo na aklatan ay hindi ang lahat ng mga function na kailangan mo.

407
00:25:04,000 --> 00:25:10,000
Para sa huling pset, halimbawa, sinulat ni namin gumuhit, mang-uayabit, at paghahanap,

408
00:25:10,000 --> 00:25:13,000
at ito ay napaka, napakahalaga na magsulat function

409
00:25:13,000 --> 00:25:17,000
dahil ang mga ito ay kapaki-pakinabang, at ginagamit namin ang mga ito ang lahat ng oras sa programming,

410
00:25:17,000 --> 00:25:19,000
at sine-save ng maraming ng code.

411
00:25:19,000 --> 00:25:21,000
Ang format ng isang function ng isang ito.

412
00:25:21,000 --> 00:25:24,000
Mayroon kaming ang uri ng return sa simula. Ano ang uri ng return?

413
00:25:24,000 --> 00:25:27,000
Lang kapag ang iyong function ay upang bumalik.

414
00:25:27,000 --> 00:25:29,000
Kung mayroon kang isang function, halimbawa, factorial,

415
00:25:29,000 --> 00:25:31,000
na upang kalkulahin ang factorial ng isang integer,

416
00:25:31,000 --> 00:25:34,000
marahil ito upang bumalik din ang isang integer.

417
00:25:34,000 --> 00:25:37,000
Pagkatapos ay ang uri ng return ay pagpunta sa int.

418
00:25:37,000 --> 00:25:41,000
Printf aktwal ay isang uri ng return void

419
00:25:41,000 --> 00:25:43,000
dahil hindi ka bumabalik kahit ano.

420
00:25:43,000 --> 00:25:45,000
Ka pag-print ng mga bagay sa screen

421
00:25:45,000 --> 00:25:48,000
at sa pagtigil sa pag-andar pagkatapos.

422
00:25:48,000 --> 00:25:51,000
Pagkatapos mayroon kang ang pangalan ng function na maaari mong piliin.

423
00:25:51,000 --> 00:25:55,000
Dapat kang maging isang maliit na makatwirang, tulad ng hindi pumili ng isang pangalan tulad ng xyz

424
00:25:55,000 --> 00:25:58,000
o tulad ng x2f.

425
00:25:58,000 --> 00:26:02,000
Subukang gumawa ng isang pangalan na saysay.

426
00:26:02,000 --> 00:26:04,000
>> Halimbawa, kung ito ang factorial, sabihin factorial.

427
00:26:04,000 --> 00:26:08,000
Kung ito ay isang function na ay pagpunta sa gumuhit ng isang bagay, pangalanan ito gumuhit.

428
00:26:08,000 --> 00:26:11,000
At pagkatapos ay mayroon namin ang mga parameter, na tinatawag din na argumento,

429
00:26:11,000 --> 00:26:14,000
na tulad ng mga mapagkukunan na ang iyong function na nangangailangan ng

430
00:26:14,000 --> 00:26:17,000
mula sa iyong code upang isagawa ang gawain.

431
00:26:17,000 --> 00:26:20,000
Kung nais mong upang makalkula ang factorial ng isang numero

432
00:26:20,000 --> 00:26:23,000
malamang na kailangan mong magkaroon ng isang numero upang kalkulahin ang factorial.

433
00:26:23,000 --> 00:26:27,000
Isa ng argumento na kayo ay pagpunta sa may ang bilang mismo.

434
00:26:27,000 --> 00:26:31,000
At pagkatapos ito ay pagpunta sa gawin ang isang bagay at ibalik ang halaga sa dulo

435
00:26:31,000 --> 00:26:35,000
maliban kung ito ay isang walang bisa function na.

436
00:26:35,000 --> 00:26:37,000
Natin makita ang isang halimbawa.

437
00:26:37,000 --> 00:26:40,000
Kung gusto ko upang magsulat ng isang function na sums ang lahat ng mga numero sa isang array ng mga integer,

438
00:26:40,000 --> 00:26:43,000
una sa lahat, ang uri ng return ay pagpunta sa int

439
00:26:43,000 --> 00:26:46,000
dahil mayroon akong isang array ng mga integer.

440
00:26:46,000 --> 00:26:51,000
At pagkatapos ay ako pagpunta sa function na pangalan tulad ng sumArray,

441
00:26:51,000 --> 00:26:54,000
at pagkatapos ito ang array mismo, sa int nums,

442
00:26:54,000 --> 00:26:58,000
at pagkatapos ay ang haba ng array upang malaman ko kung gaano karaming mga numero na mayroon akong sabihin sa ilang.

443
00:26:58,000 --> 00:27:02,000
Pagkatapos Mayroon akong upang simulan ang isang variable na tinatawag kabuuan, halimbawa, sa 0,

444
00:27:02,000 --> 00:27:08,000
at sa bawat oras na makita ko ang isang elemento sa array ang dapat kong idagdag ito sa kabuuan, kaya ginawa ko para sa loop.

445
00:27:08,000 --> 00:27:15,000
Lamang tulad ng sinabi Lexi, gawin mo int i = 0, i <haba at i + +.

446
00:27:15,000 --> 00:27:20,000
At para sa bawat elemento sa array na aking ginawa sum + = nums [i],

447
00:27:20,000 --> 00:27:24,000
at pagkatapos ay ibinalik ko ang kabuuan, kaya ito ay napaka-simpleng, at sine-save ng maraming ng code

448
00:27:24,000 --> 00:27:28,000
kung ginagamit mo ang function na ito ng maraming beses.

449
00:27:28,000 --> 00:27:32,000
Pagkatapos namin kinuha ng pagtingin sa mga kundisyon.

450
00:27:32,000 --> 00:27:38,000
Mayroon kaming kung, tao, at iba pa kung.

451
00:27:38,000 --> 00:27:42,000
Natin makita kung ano ang pagkakaiba sa pagitan ng mga.

452
00:27:42,000 --> 00:27:45,000
Tingnan sa mga 2 code. Ano ang pagkakaiba sa pagitan ng mga ito?

453
00:27:45,000 --> 00:27:49,000
Ang unang-isa lamang ang code na nais mong sabihin sa

454
00:27:49,000 --> 00:27:51,000
kung ang numero ng +, -, o 0.

455
00:27:51,000 --> 00:27:55,000
Ang unang isa sabi kung> 0 pagkatapos ito ay positibong.

456
00:27:55,000 --> 00:28:00,000
Kung = sa 0 pagkatapos ito ay 0, at kung ito <0 ito negatibong.

457
00:28:00,000 --> 00:28:04,000
>> At ang iba pang isa ay kung, tao kung, iba pa.

458
00:28:04,000 --> 00:28:07,000
Ang pagkakaiba sa pagitan ng dalawang na ito ay aktwal na pagpunta sa

459
00:28:07,000 --> 00:28:13,000
suriin kung> 0, <0 o = 0 ng tatlong beses,

460
00:28:13,000 --> 00:28:17,000
kaya kung mayroon kang ang bilang 2, halimbawa, ito ay pagpunta sa dumating dito at sabihin

461
00:28:17,000 --> 00:28:21,000
kung (x> 0), at ito ay pagpunta sa sabihin ninyo ang oo, kaya-print ko positibong.

462
00:28:21,000 --> 00:28:25,000
Ngunit kahit alam ko na ito> 0 at hindi ito magiging 0 o <0

463
00:28:25,000 --> 00:28:29,000
Pa rin ako pagpunta sa gawin ito 0, ito <0,

464
00:28:29,000 --> 00:28:33,000
kaya tunay ako pagpunta sa loob ng ifs na hindi ako mag-

465
00:28:33,000 --> 00:28:38,000
dahil alam ko na na hindi ito masunod ang anumang ng mga kondisyon.

466
00:28:38,000 --> 00:28:41,000
Maaari ko bang gamitin ang kung, tao kung, tao pahayag.

467
00:28:41,000 --> 00:28:45,000
Ito talaga sabi kung x = 0-print ko ang positibong.

468
00:28:45,000 --> 00:28:48,000
Kung ito ay hindi, ako pagpunta sa ring subukan ang.

469
00:28:48,000 --> 00:28:51,000
Kung ito ay 2 hindi ako pagpunta sa gawin ito.

470
00:28:51,000 --> 00:28:54,000
Talaga kung ako ay may x = 2 gusto mong sabihin

471
00:28:54,000 --> 00:28:57,000
kung (x> 0), oo, kaya i-print ito.

472
00:28:57,000 --> 00:29:00,000
Ngayon na alam ko na ito> 0 at na nasiyahan sa unang kung

473
00:29:00,000 --> 00:29:02,000
Hindi ako pagpunta upang patakbuhin ang code na ito.

474
00:29:02,000 --> 00:29:09,000
Code ay nagpapatakbo ng mas mabilis, aktwal na, 3 beses nang mas mabilis kung gagamitin mo ito.

475
00:29:09,000 --> 00:29:11,000
Natutunan din kami tungkol sa at o.

476
00:29:11,000 --> 00:29:15,000
Hindi ako pagpunta upang pumunta sa pamamagitan na ito dahil Lexi na uusapang tungkol sa mga ito.

477
00:29:15,000 --> 00:29:17,000
Lang ang && at | | operator.

478
00:29:17,000 --> 00:29:21,000
>> Ang tanging bagay na Sasabihin kong maging maingat kapag mayroon kang 3 kundisyon.

479
00:29:21,000 --> 00:29:24,000
Gamitin ang mga panaklong dahil napaka-nakalilito kapag mayroon kang isang kundisyon

480
00:29:24,000 --> 00:29:27,000
at isa pa o isa pa.

481
00:29:27,000 --> 00:29:30,000
Gamitin ang mga panaklong lamang upang siguraduhin na ang iyong mga kondisyon kabuluhan

482
00:29:30,000 --> 00:29:34,000
dahil sa kasong iyon, halimbawa, maaari mong isipin na ang

483
00:29:34,000 --> 00:29:38,000
maaaring ito ay ang unang kondisyon at isa o ang iba

484
00:29:38,000 --> 00:29:41,000
o ang 2 mga kondisyon na pinagsama sa isang at

485
00:29:41,000 --> 00:29:45,000
o sa ikatlong isa, kaya maging maingat lamang.

486
00:29:45,000 --> 00:29:48,000
At sa wakas, usapan natin ang tungkol sa mga switch.

487
00:29:48,000 --> 00:29:53,000
Lumipat ay lubos na kapaki-pakinabang kapag mayroon kang isang variable.

488
00:29:53,000 --> 00:29:55,000
Sabihin natin na mayroon kang isang variable tulad n

489
00:29:55,000 --> 00:29:59,000
na maaaring maging 0, 1, o 2, at para sa bawat isa sa mga kasong iyon

490
00:29:59,000 --> 00:30:01,000
ka upang magsagawa ng gawain.

491
00:30:01,000 --> 00:30:04,000
Maaari mong sabihin ilipat ang variable, at ito ay nagpapahiwatig na ang

492
00:30:04,000 --> 00:30:08,000
ang halaga pagkatapos ay tulad ng VALUE1 ako pagpunta sa gawin ito,

493
00:30:08,000 --> 00:30:12,000
at pagkatapos ko masira, na nangangahulugan na hindi ako pagpunta sa tumingin sa anumang ng iba pang mga kaso

494
00:30:12,000 --> 00:30:15,000
sapagkat hindi namin na nasiyahan kaso na

495
00:30:15,000 --> 00:30:20,000
at pagkatapos VALUE2 at iba pa, at ako din ay maaaring magkaroon ng isang default na lumipat.

496
00:30:20,000 --> 00:30:24,000
Iyon ay nangangahulugang kung hindi ito masunod ang anumang ng mga kaso na ako ay may

497
00:30:24,000 --> 00:30:29,000
na ako pagpunta sa gawin ang iba pa, ngunit na opsyonal.

498
00:30:29,000 --> 00:30:36,000
Na ang lahat para sa akin. Ngayon sabihin mayroon Tommy.

499
00:30:36,000 --> 00:30:41,000
Lahat ng karapatan, ito ay pagpunta sa Linggo 3-ish.

500
00:30:41,000 --> 00:30:45,000
Ito ang ilang ng paksa namin na sumasaklaw, crypto, saklaw, array, at iba pa.

501
00:30:45,000 --> 00:30:49,000
Lamang ng isang mabilis na salita sa crypto. Hindi namin ay pagpunta sa martilyo ito sa bahay.

502
00:30:49,000 --> 00:30:52,000
>> Ginawa namin ito sa pset 2, ngunit para sa pagsusulit tiyakin na alam mo ang pagkakaiba

503
00:30:52,000 --> 00:30:54,000
sa pagitan ng Caesar cipher at sa Vigenère cipher,

504
00:30:54,000 --> 00:30:57,000
kung paano parehong ng mga trabaho ciphers at kung ano ito ay tulad ng upang i-encrypt

505
00:30:57,000 --> 00:30:59,000
at i-decrypt teksto gamit ang mga 2 ciphers.

506
00:30:59,000 --> 00:31:03,000
Tandaan, ang Caesar cipher lamang umiikot sa bawat character ng parehong halaga,

507
00:31:03,000 --> 00:31:06,000
siguraduhin mo mod sa pamamagitan ng bilang ng mga titik sa alpabeto.

508
00:31:06,000 --> 00:31:09,000
At ang Vigenère cipher, sa kabilang banda, umiikot sa bawat karakter

509
00:31:09,000 --> 00:31:12,000
ng isang iba't ibang mga halaga, kaya sa halip na sinasabi

510
00:31:12,000 --> 00:31:15,000
bawat pinihit ng character sa pamamagitan ng 3 Vigenère ikutin bawat karakter

511
00:31:15,000 --> 00:31:17,000
ng isang iba't ibang mga halaga depende sa ilang mga keyword

512
00:31:17,000 --> 00:31:20,000
kung saan ang bawat titik sa keyword kumakatawan sa ilang ibang halaga

513
00:31:20,000 --> 00:31:26,000
ikutin ang malinaw na teksto sa pamamagitan ng.

514
00:31:26,000 --> 00:31:28,000
Natin ang unang usapan variable na saklaw.

515
00:31:28,000 --> 00:31:30,000
May 2 iba't ibang mga uri ng variable.

516
00:31:30,000 --> 00:31:33,000
Mayroon kaming mga lokal na variable, at ang mga ito ay pagpunta sa ay tinukoy

517
00:31:33,000 --> 00:31:36,000
sa labas ng pangunahing o sa labas ng anumang function na o bloke,

518
00:31:36,000 --> 00:31:39,000
at ang mga ito ay maa-access kahit saan sa iyong programa.

519
00:31:39,000 --> 00:31:41,000
Kung mayroon kang isang function at sa na function na ay isang habang loop

520
00:31:41,000 --> 00:31:44,000
ang malaking pandaigdigang variable ay naa-access sa lahat ng dako.

521
00:31:44,000 --> 00:31:48,000
Ang isang lokal na variable, sa kabilang banda, ay scoped sa lugar na kung saan ito ay tinukoy.

522
00:31:48,000 --> 00:31:53,000
>> Kung mayroon kang isang function dito, halimbawa, mayroon kaming g ang pagpapaganang ito,

523
00:31:53,000 --> 00:31:56,000
at sa loob ng g may isang variable na dito tinatawag y,

524
00:31:56,000 --> 00:31:58,000
at na nangangahulugan na ito ay isang lokal na variable.

525
00:31:58,000 --> 00:32:00,000
Kahit na ang variable na ito ay tinatawag na y

526
00:32:00,000 --> 00:32:03,000
at ang variable na ito ay tinatawag na y mga 2-andar

527
00:32:03,000 --> 00:32:06,000
walang ideya kung ano ang bawat isa lokal na variable.

528
00:32:06,000 --> 00:32:10,000
Sa kabilang banda, hanggang dito sinasabi namin int x = 5,

529
00:32:10,000 --> 00:32:12,000
at ito ay sa labas ng saklaw ng anumang function na.

530
00:32:12,000 --> 00:32:16,000
Ito ay sa labas ng saklaw ng pangunahing, kaya ito ay isang pandaigdigang variable.

531
00:32:16,000 --> 00:32:20,000
Nangangahulugan iyon sa loob ng mga 2-andar kapag sinasabi ko x - o x + +

532
00:32:20,000 --> 00:32:26,000
Ako-access ang parehong x kung saan ito y at ito y iba't ibang mga variable.

533
00:32:26,000 --> 00:32:30,000
Na ang pagkakaiba sa pagitan ng isang global variable at isang lokal na variable.

534
00:32:30,000 --> 00:32:33,000
Bilang malayo bilang disenyo ay nababahala, minsan ito ay maaring isang mas mahusay na ideya

535
00:32:33,000 --> 00:32:37,000
upang panatilihin ang mga variable lokal tuwing maaari mo posibleng

536
00:32:37,000 --> 00:32:39,000
dahil pagkakaroon ng grupo ng mga global variable ay maaaring makakuha ng talagang nakakalito.

537
00:32:39,000 --> 00:32:42,000
Kung mayroon kang isang bungkos ng mga function lahat ng mga pagbabago ng parehong bagay

538
00:32:42,000 --> 00:32:45,000
baka nakalimutan mo kung ano ang kung ang function na ito aksidenteng binabago ito global,

539
00:32:45,000 --> 00:32:47,000
at iba pang mga function na ito ay hindi alam tungkol dito,

540
00:32:47,000 --> 00:32:50,000
at ito ay makakuha ng medyo nakakalito makakakuha ka ng higit pang mga code.

541
00:32:50,000 --> 00:32:53,000
Pagpapanatiling variable lokal tuwing maaari mo posibleng

542
00:32:53,000 --> 00:32:56,000
ay lamang magandang disenyo.

543
00:32:56,000 --> 00:33:00,000
Array, Tandaan, simpleng listahan ng mga elemento ng parehong uri.

544
00:33:00,000 --> 00:33:04,000
Loob ng CI ay hindi maaaring magkaroon ng isang listahan tulad ng 1, 2.0, kumusta.

545
00:33:04,000 --> 00:33:06,000
Lamang namin ay hindi maaaring gawin iyon.

546
00:33:06,000 --> 00:33:11,000
>> Kapag idedeklara namin ang isang array sa C ang lahat ng mga elemento ng parehong uri.

547
00:33:11,000 --> 00:33:14,000
Narito Mayroon akong isang array ng 3 integer.

548
00:33:14,000 --> 00:33:18,000
Narito ko ang haba ng array, ngunit kung ako deklarasyon ito sa ang syntax na ito

549
00:33:18,000 --> 00:33:21,000
kung saan ko tukuyin kung ano ang lahat ng mga elemento ay hindi ko technically kailangan ang 3.

550
00:33:21,000 --> 00:33:25,000
Tagatala na smart sapat upang malaman kung gaano kalaki ang array ay dapat na.

551
00:33:25,000 --> 00:33:28,000
Ngayon kapag gusto ko upang makakuha o itakda ang halaga ng isang array

552
00:33:28,000 --> 00:33:30,000
ito ang syntax upang gawin iyon.

553
00:33:30,000 --> 00:33:33,000
Ito ay aktwal na baguhin ang pangalawang elemento ng array dahil, tandaan,

554
00:33:33,000 --> 00:33:36,000
pagnunumero nagsisimula sa 0, hindi sa 1.

555
00:33:36,000 --> 00:33:42,000
Kung gusto kong basahin na halaga ang maaari kong sabihin na ang isang bagay tulad ng int x = array [1].

556
00:33:42,000 --> 00:33:44,000
O kung gusto kong mag-set na halaga, tulad ng ako ginagawa dito,

557
00:33:44,000 --> 00:33:47,000
Maaari kong sabihin array [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Oras na iyon sa pag-access ng mga elemento sa pamamagitan ng kanilang index

559
00:33:50,000 --> 00:33:52,000
o kanilang mga posisyon o kung saan ang mga ito sa array,

560
00:33:52,000 --> 00:33:57,000
at ang listahan na nagsisimula sa 0.

561
00:33:57,000 --> 00:34:00,000
Mayroon din kaming ang mga array ng array,

562
00:34:00,000 --> 00:34:03,000
at ito ay tinatawag na isang multi-dimensional array.

563
00:34:03,000 --> 00:34:05,000
Kapag kami ay may isang multi-dimensional array

564
00:34:05,000 --> 00:34:07,000
na nangangahulugan na maaari naming magkaroon ng isang bagay tulad ng mga hanay at haligi,

565
00:34:07,000 --> 00:34:11,000
at ito ay isang paraan lamang ng pagtingin sa ito o pag-iisip tungkol dito.

566
00:34:11,000 --> 00:34:14,000
Kapag mayroon akong isang multi-dimensional array na ay nangangahulugan na ang ako pagpunta upang simulan ang nangangailangan

567
00:34:14,000 --> 00:34:17,000
higit sa 1 index dahil kung mayroon akong isang grid

568
00:34:17,000 --> 00:34:19,000
lang na nagsasabi kung ano ang hilera ikaw ay nasa ay hindi nagbibigay sa amin ng isang numero.

569
00:34:19,000 --> 00:34:22,000
Na talagang lamang upang bigyan kami ng isang listahan ng mga numero.

570
00:34:22,000 --> 00:34:25,000
Ipagpalagay natin na mayroon akong dito ang array na ito.

571
00:34:25,000 --> 00:34:30,000
Mayroon akong isang array na tinatawag na grid, at ako sinasabi ito ng 2 mga hilera at 3 haligi,

572
00:34:30,000 --> 00:34:32,000
at kaya ito ay isang paraan ng pagtingin sa ito.

573
00:34:32,000 --> 00:34:37,000
Kapag sinabi ko na gusto kong makuha ang elemento sa [1] [2]

574
00:34:37,000 --> 00:34:41,000
na nangangahulugan na dahil ito ay hilera muna at pagkatapos haligi

575
00:34:41,000 --> 00:34:44,000
Ako pagpunta sa tumalon sa hilera ng 1 dahil sinabi ko 1.

576
00:34:44,000 --> 00:34:49,000
>> Pagkatapos ako pagpunta sa darating sa paglipas dito sa haligi 2, at ako pagpunta upang makuha ang halaga 6.

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

578
00:34:51,000 --> 00:34:55,000
Multi-dimensional array, Tandaan, technically lamang ng isang hanay ng mga array.

579
00:34:55,000 --> 00:34:57,000
Maaari kaming magkaroon ng mga array ng mga array ng mga array.

580
00:34:57,000 --> 00:35:00,000
Namin ang pagpunta, ngunit talagang isang paraan upang isipin ang tungkol

581
00:35:00,000 --> 00:35:03,000
kung paano ito ay inilatag at kung anong nangyayari sa ay upang mailarawan ito

582
00:35:03,000 --> 00:35:09,000
sa isang grid tulad nito.

583
00:35:09,000 --> 00:35:12,000
Kapag pumasa namin array sa function, sila ay pagpunta sa kumilos

584
00:35:12,000 --> 00:35:16,000
Medyo naiiba kaysa sa kapag pumasa kami ng mga regular na variable sa function

585
00:35:16,000 --> 00:35:18,000
tulad ng pagpasa sa isang int o isang Float.

586
00:35:18,000 --> 00:35:21,000
Kapag pumasa kami sa isang int o pansamantalang trabaho o anumang ng iba pang mga data na uri

587
00:35:21,000 --> 00:35:24,000
lang namin kinuha ng isang pagtingin sa kung binabago ang function na

588
00:35:24,000 --> 00:35:28,000
ang halaga ng variable na ang pagbabagong iyon ay hindi upang palaganapin up

589
00:35:28,000 --> 00:35:32,000
sa pagtawag sa function na.

590
00:35:32,000 --> 00:35:35,000
Sa pamamagitan ng isang array, sa kabilang banda, na ang mangyayari.

591
00:35:35,000 --> 00:35:39,000
Kung pumasa ako sa isang array sa ilang function na at ang function na nagbabago ang ilan sa mga elemento,

592
00:35:39,000 --> 00:35:43,000
kapag dumating ako pabalik sa function na tinatawag na ito

593
00:35:43,000 --> 00:35:47,000
aking array ay pagpunta sa iba, at ang bokabularyo para sa

594
00:35:47,000 --> 00:35:50,000
ay array ay naipasa sa pamamagitan ng reference, dahil kakailanganin namin makita mamaya.

595
00:35:50,000 --> 00:35:53,000
Ito ay may kaugnayan sa kung paano payo ng trabaho, kung saan ang mga pangunahing uri ng data,

596
00:35:53,000 --> 00:35:55,000
sa kabilang banda, ay naipasa sa pamamagitan ng halaga.

597
00:35:55,000 --> 00:35:59,000
>> Maaari naming isipin na bilang ng paggawa ng isang kopya ng ilang mga variable at pagkatapos pagpasa sa kopya.

598
00:35:59,000 --> 00:36:01,000
Hindi mahalaga kung ano ang ginagawa namin sa na variable.

599
00:36:01,000 --> 00:36:06,000
Ang pagtawag sa function na ay hindi magkaroon ng kamalayan na ito ay binago.

600
00:36:06,000 --> 00:36:10,000
Array ay lamang ng kaunti ibang sa na-alang.

601
00:36:10,000 --> 00:36:13,000
Halimbawa, bilang lamang namin nakita, pangunahing ay lamang ng isang function

602
00:36:13,000 --> 00:36:15,000
na maaaring tumagal ng sa 2 argumento.

603
00:36:15,000 --> 00:36:20,000
Ang unang argumento sa pangunahing function na ay argc, o ang dami ng mga argument,

604
00:36:20,000 --> 00:36:23,000
at ang pangalawang argumento ay tinatawag na argv,

605
00:36:23,000 --> 00:36:27,000
at ang mga ay ang aktwal na halaga ng mga argumento.

606
00:36:27,000 --> 00:36:30,000
Ipagpalagay natin na mayroon akong isang programa na tinatawag na this.c,

607
00:36:30,000 --> 00:36:34,000
at sinasabi ko ito, at ako pagpunta upang patakbuhin ito sa command line.

608
00:36:34,000 --> 00:36:38,000
Ngayon upang pumasa sa ilang mga argumento sa aking programa na tinatawag na ito,

609
00:36:38,000 --> 00:36:42,000
Maaari kong sabihin ang isang bagay tulad ng. / Ito ay cs 50.

610
00:36:42,000 --> 00:36:45,000
Ito ay kung ano ang namin isipin ang David na gawin ang araw-araw sa terminal.

611
00:36:45,000 --> 00:36:48,000
Ngunit ngayon ang pangunahing function na sa loob ng programang iyon

612
00:36:48,000 --> 00:36:52,000
may mga halagang ito, kaya argc ay 4.

613
00:36:52,000 --> 00:36:56,000
Maaaring maging isang maliit na nakakalito dahil talagang lamang kami ng pagpasa ay cs 50.

614
00:36:56,000 --> 00:36:58,000
Iyon lamang 3.

615
00:36:58,000 --> 00:37:02,000
Ngunit tandaan na sa unang elemento ng argv o ang unang argumento

616
00:37:02,000 --> 00:37:05,000
ang pangalan ng function na mismo.

617
00:37:05,000 --> 00:37:07,190
Sa gayon ay nangangahulugan na mayroon kaming 4 na bagay dito,

618
00:37:07,190 --> 00:37:10,530
at ang unang elemento ay pagpunta sa. / ito.

619
00:37:10,530 --> 00:37:12,970
At ito ay kinakatawan bilang isang string.

620
00:37:12,970 --> 00:37:18,590
Pagkatapos ang mga natitirang mga elemento ay kung ano ang aming nai-type sa pagkatapos ng pangalan ng programa.

621
00:37:18,590 --> 00:37:22,720
Kaya tulad ng bukod, bilang namin marahil nakita sa pset 2,

622
00:37:22,720 --> 00:37:28,780
tandaan na ang string 50 ≠ ang integer 50.

623
00:37:28,780 --> 00:37:32,520
Kaya hindi namin maaaring sabihin na ang isang bagay tulad ng, 'int x = 3 argv.'

624
00:37:32,520 --> 00:37:36,470
>> Na lang hindi kabuluhan, dahil ito ay isang string, at ito ay isang integer.

625
00:37:36,470 --> 00:37:38,510
Kaya kung nais mong i-convert sa pagitan ng 2, Tandaan, kami ay pagpunta sa

626
00:37:38,510 --> 00:37:40,810
ito magic function na tinatawag na atoi.

627
00:37:40,810 --> 00:37:46,270
Na tumatagal ng isang string at nagbalik ang integer na kinakatawan sa loob ng na string.

628
00:37:46,270 --> 00:37:48,360
Kaya na ang isang madaling pagkakamali upang gumawa sa pagsusulit,

629
00:37:48,360 --> 00:37:51,590
lamang ang pag-iisip na ito ay awtomatikong ang tamang uri ng.

630
00:37:51,590 --> 00:37:53,860
Ngunit lamang malaman na ang mga ito ay palaging magiging string

631
00:37:53,860 --> 00:38:00,920
kahit na kung string ay naglalaman lamang ng isang integer o isang character o isang Float.

632
00:38:00,920 --> 00:38:03,380
Kaya ngayon sabihin makipag-usap tungkol sa pagpapatakbo ng oras.

633
00:38:03,380 --> 00:38:06,700
Kapag mayroon kaming ang lahat ng mga algorithm na gawin sa lahat ng mga nakatutuwang mga bagay,

634
00:38:06,700 --> 00:38:11,580
ito ay magiging talagang kapaki-pakinabang upang tanungin ang tanong, "Gaano katagal ang kanilang tumagal?"

635
00:38:11,580 --> 00:38:15,500
Kumakatawan namin na may isang bagay na tinatawag na asymptotic pagtatanda.

636
00:38:15,500 --> 00:38:18,430
Kaya ito ay nangangahulugan na - mahusay, sabihin nating naming bigyan ang aming algorithm

637
00:38:18,430 --> 00:38:20,840
ilang talaga, talagang, talagang malaking input.

638
00:38:20,840 --> 00:38:23,840
Gusto naming hilingin sa tanong, "Gaano katagal ito pagpunta sa tumagal?

639
00:38:23,840 --> 00:38:26,370
Gaano karaming mga hakbang na ito ay tumagal ng aming algorithm upang tumakbo

640
00:38:26,370 --> 00:38:29,980
bilang isang katangian ng laki ng input? "

641
00:38:29,980 --> 00:38:33,080
Kaya ang unang paraan maaari naming ilarawan ang magpatakbo ng oras ay may malaking O.

642
00:38:33,080 --> 00:38:35,380
At ito ay aming pinakamasama-case tumatakbo oras.

643
00:38:35,380 --> 00:38:38,590
Kaya kung nais namin upang pag-uri-uriin ang isang array, at naming bigyan ang aming mga algorithm sa isang array

644
00:38:38,590 --> 00:38:41,000
na sa pababang ayos kapag ito ay dapat sa pataas-sunod,

645
00:38:41,000 --> 00:38:43,130
na ang pinakamasama kaso.

646
00:38:43,130 --> 00:38:49,800
Ito ang aming itaas na sumunod sa maximum na haba ng oras na aming algorithm ay magdadala.

647
00:38:49,800 --> 00:38:54,740
Sa kabilang banda, ito Ω upang ilarawan ang pinakamahusay na-case tumatakbo oras.

648
00:38:54,740 --> 00:38:58,210
Kaya kung bigyan kami ng isang array na pinagsunod-sunod sa isang pag-uuri algorithm,

649
00:38:58,210 --> 00:39:00,940
kung gaano katagal ang aabutin upang pag-uri-uriin ito?

650
00:39:00,940 --> 00:39:06,610
At ito, pagkatapos, ay naglalarawan ng isang mas mababang bound sa tumatakbo oras.

651
00:39:06,610 --> 00:39:10,980
Kaya narito ang ilang mga salita na naglalarawan ng ilang mga karaniwang panahon ng pagtakbo.

652
00:39:10,980 --> 00:39:13,120
Mga ito sa pataas na pagkakasunod-sunod.

653
00:39:13,120 --> 00:39:16,060
Ang pinakamabilis na tumatakbo ang oras na mayroon kami ay tinatawag na pare-pareho.

654
00:39:16,060 --> 00:39:19,800
>> Nangangahulugan iyon na hindi mahalaga kung gaano karaming mga elemento bigyan namin ang aming mga algorithm,

655
00:39:19,800 --> 00:39:22,280
kahit gaano kalaki ang aming array, pag-uuri-uri ito

656
00:39:22,280 --> 00:39:26,510
o paggawa ng kahit anong ginagawa namin sa array ay palaging gawin ang parehong halaga ng oras.

657
00:39:26,510 --> 00:39:30,270
Upang maaari naming kumatawan na lang na may 1, na kung saan ay patuloy na.

658
00:39:30,270 --> 00:39:32,410
Tumingin din kami sa logarithmic run oras.

659
00:39:32,410 --> 00:39:34,800
Kaya ang isang bagay tulad ng binary paghahanap ay logarithmic,

660
00:39:34,800 --> 00:39:37,140
kung saan namin kunin ang mga problema sa kalahati sa bawat oras

661
00:39:37,140 --> 00:39:40,970
at pagkatapos ay bagay lamang makakuha ng mas mataas na mula doon.

662
00:39:40,970 --> 00:39:43,580
At kung sakaling sumusulat ka ng O ng anumang factorial algorithm,

663
00:39:43,580 --> 00:39:47,850
marahil ay hindi dapat isaalang-alang ito bilang iyong araw ng trabaho.

664
00:39:47,850 --> 00:39:53,910
Kapag ihambing namin ang mga panahon ng pagtakbo mahalaga upang tandaan ang mga bagay na ito.

665
00:39:53,910 --> 00:39:57,760
Kaya kung mayroon akong isang algorithm na ang O (n), at iba pang tao

666
00:39:57,760 --> 00:40:03,590
ay isang algorithm ng O (2n) mga ito ay aktwal asymptotically katumbas.

667
00:40:03,590 --> 00:40:06,590
Kaya kung namin isipin n isang malaking bilang tulad eleventy bilyong:

668
00:40:06,590 --> 00:40:13,090
kaya kapag kami ay naghahambing eleventy bilyon sa isang bagay tulad ng eleventy bilyong + 3,

669
00:40:13,090 --> 00:40:17,640
biglang +3 na hindi talaga gumawa ng isang malaking pagkakaiba ito.

670
00:40:17,640 --> 00:40:20,980
Iyon ay kung bakit kami ay pagpunta upang simulan ang isinasaalang-alang ang mga bagay na ito upang maging katumbas.

671
00:40:20,980 --> 00:40:24,220
Kaya sa mga bagay tulad ng mga constants dito, 2 x na ito, o pagdaragdag ng isang 3,

672
00:40:24,220 --> 00:40:27,180
ito lamang ang constants, at ito ay pagpunta sa drop up.

673
00:40:27,180 --> 00:40:32,480
Kaya na ang dahilan kung bakit ang lahat ng 3 ng mga oras na ito na pinapatakbo ang parehong bilang na nagsasabi sila O (n).

674
00:40:32,480 --> 00:40:37,490
Katulad nito, kung kami ay may 2 iba pang mga beses sa run, sabihin nating O (n ³ + 2n ²), maaari naming magdagdag

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, at pagkatapos kami ay may isa pang run oras na lang O (n ³).

676
00:40:42,070 --> 00:40:46,290
muli, ito ay ang parehong bagay dahil ang mga - ito ay hindi ang parehong.

677
00:40:46,290 --> 00:40:49,840
Ito ay ang parehong mga bagay, paumanhin. Kaya ito ay ang parehong dahil

678
00:40:49,840 --> 00:40:53,090
ito n ³ ay upang dominahin ito 2n ².

679
00:40:53,090 --> 00:40:59,130
>> Ano ang hindi ang parehong bagay ay kung tumakbo kami ng mga oras tulad ng O (n ³) at O ​​(n ²)

680
00:40:59,130 --> 00:41:02,820
dahil ito n ³ ay mas malaki kaysa ito n ².

681
00:41:02,820 --> 00:41:05,470
Kaya kung kami ay may exponents, biglang ito ay nagsisimula sa mahalaga,

682
00:41:05,470 --> 00:41:08,280
ngunit kapag lamang namin ang pagharap sa mga kadahilanan habang kami dito,

683
00:41:08,280 --> 00:41:12,810
hindi ito mahalaga dahil lamang sila ay pagpunta sa drop out.

684
00:41:12,810 --> 00:41:16,760
Natin tumagal ng isang pagtingin sa nasaksihan namin sa ngayon ang ilan sa mga algorithm

685
00:41:16,760 --> 00:41:19,260
at makipag-usap tungkol sa kanilang mga oras ng run.

686
00:41:19,260 --> 00:41:23,850
Ang unang paraan ng naghahanap para sa isang bilang sa isang listahan, na nakita natin, linear paghahanap.

687
00:41:23,850 --> 00:41:26,950
At ang pagpapatupad ng linear paghahanap sobrang direkta.

688
00:41:26,950 --> 00:41:30,490
Lang namin ay may isang listahan, at kami ay pagpunta upang tumingin sa bawat solong elemento sa listahan

689
00:41:30,490 --> 00:41:34,260
hanggang sa nakita namin ang bilang namin na iyong hinahanap.

690
00:41:34,260 --> 00:41:38,370
Sa gayon ay nangangahulugan na sa pinakamasama kaso, ito O (n).

691
00:41:38,370 --> 00:41:40,860
At ang pinakamasama kaso dito kung ang elemento ay

692
00:41:40,860 --> 00:41:45,710
ang huling elemento, pagkatapos gamit ang linear paghahanap namin upang tumingin sa bawat solong elemento

693
00:41:45,710 --> 00:41:50,180
hanggang namin makuha ang huling isa upang malaman na ito ay aktwal na sa listahan.

694
00:41:50,180 --> 00:41:52,910
Hindi lamang namin magbigay ng kalahating at sabihin, "Ito ay malamang na hindi doon."

695
00:41:52,910 --> 00:41:55,980
Sa linear paghahanap namin upang tingnan ang buong bagay.

696
00:41:55,980 --> 00:41:59,090
Ang pinakamahusay na tumatakbo sa oras ng kaso, sa kabilang banda, ay pare-pareho

697
00:41:59,090 --> 00:42:04,200
dahil sa ang pinakamahusay na kaso ang elemento kaming naghahanap ng mga lamang ang unang isa sa listahan.

698
00:42:04,200 --> 00:42:08,930
Kaya pagpunta sa amin eksakto 1 hakbang, hindi mahalaga kung gaano kalaki ang listahan

699
00:42:08,930 --> 00:42:12,140
kung kaming naghahanap ng para sa unang elemento sa bawat oras.

700
00:42:12,140 --> 00:42:15,390
>> Kaya kapag hinanap mo, tandaan, hindi ito nangangailangan pinagsunod-sunod na ang aming listahan.

701
00:42:15,390 --> 00:42:19,430
Dahil lamang namin ay pagpunta upang tumingin sa bawat solong elemento, at hindi ito ay talagang mahalaga

702
00:42:19,430 --> 00:42:23,560
anong pagkakasunud-sunod ang mga elementong iyon.

703
00:42:23,560 --> 00:42:28,110
Mas intelligent na algorithm sa paghahanap ng isang bagay tulad ng binary paghahanap.

704
00:42:28,110 --> 00:42:31,500
Tandaan, ang pagpapatupad ng binary paghahanap ay kapag ikaw ay pagpunta sa

705
00:42:31,500 --> 00:42:34,320
panatilihin ang hinahanap sa gitna ng listahan.

706
00:42:34,320 --> 00:42:38,000
At dahil naghahanap kami sa gitna, kinakailangan namin na listahan ay pinagsunod-sunod

707
00:42:38,000 --> 00:42:40,580
o kung hindi namin alam kung saan ay ang gitna, at kailangan namin upang tumingin sa paglipas ng

708
00:42:40,580 --> 00:42:44,480
ang buong listahan upang hanapin ito, at pagkatapos ay sa puntong iyon kami ay aksaya ng panahon.

709
00:42:44,480 --> 00:42:48,480
Kaya kung kami ay may isang pinagsunod-sunod na listahan at nakita namin sa gitna, kami ay upang ihambing sa gitna

710
00:42:48,480 --> 00:42:51,590
sa elemento na namin na iyong hinahanap.

711
00:42:51,590 --> 00:42:54,640
Kung ito ay masyadong mataas, maaari naming kalimutan ang kanang kalahati

712
00:42:54,640 --> 00:42:57,810
dahil alam namin na kung ang aming elemento ay masyadong mataas

713
00:42:57,810 --> 00:43:01,080
at lahat sa kanan ng elemento na ito ay mas mataas,

714
00:43:01,080 --> 00:43:02,760
hindi namin kailangan upang tumingin doon ngayon.

715
00:43:02,760 --> 00:43:05,430
Saan sa kabilang banda, kung ang aming elemento ay masyadong mababa,

716
00:43:05,430 --> 00:43:08,700
Alam namin din ang lahat sa kaliwa ng na elemento ay masyadong mababa,

717
00:43:08,700 --> 00:43:11,390
kaya hindi ito ay talagang magkaroon ng kahulugan upang tumingin doon, alinman.

718
00:43:11,390 --> 00:43:15,760
Sa ganitong paraan, sa bawat hakbang at tuwing hahanapin namin sa Gitnang ng listahan,

719
00:43:15,760 --> 00:43:19,060
kami ay upang kunin ang aming problema sa kalahati dahil biglang alam namin

720
00:43:19,060 --> 00:43:23,040
buong bungkos ng mga numero na hindi kaming naghahanap ng mga.

721
00:43:23,040 --> 00:43:26,950
>> Pseudocode ito ang magiging hitsura ng isang bagay tulad nito,

722
00:43:26,950 --> 00:43:30,990
at dahil kami ay paggupit ang listahan sa kalahati bawat solong oras,

723
00:43:30,990 --> 00:43:34,920
aming pinakamasama-case run oras jumps mula sa linear sa logarithmic.

724
00:43:34,920 --> 00:43:39,260
Kaya biglang mayroon kaming-log-in hakbang upang mahanap ang isang elemento sa isang listahan.

725
00:43:39,260 --> 00:43:42,460
Ang pinakamahusay na tumatakbo sa oras ng kaso, bagaman, pa rin ang pare-pareho

726
00:43:42,460 --> 00:43:45,180
dahil ngayon, sabihin lamang sabihin na ang elemento kaming naghahanap ng mga

727
00:43:45,180 --> 00:43:48,380
laging ang eksaktong gitna ng orihinal na listahan.

728
00:43:48,380 --> 00:43:52,080
Upang maaari naming palaguin ang aming listahan bilang malaking bilang gusto namin, ngunit kung ang elemento kaming naghahanap ng mga sa gitna,

729
00:43:52,080 --> 00:43:54,910
pagkatapos lamang ito pagpunta sa tumagal kami ng 1 hakbang.

730
00:43:54,910 --> 00:44:00,920
Kaya na ang dahilan kung bakit hindi namin O (log n) at Ω (1) o pare-pareho.

731
00:44:00,920 --> 00:44:04,510
Natin ang aktwal na patakbuhin ang binary paghahanap sa listahang ito.

732
00:44:04,510 --> 00:44:08,020
Kaya sabihin nating na kaming naghahanap ng mga elemento 164.

733
00:44:08,020 --> 00:44:11,650
Ang unang bagay na kami ay pagpunta sa gawin ay hanapin ang Gitnang ng listahang ito.

734
00:44:11,650 --> 00:44:15,060
Lang kaya ang mangyayari na ang Gitnang ang pagpunta sa mahulog sa pagitan ng mga 2 numero,

735
00:44:15,060 --> 00:44:18,960
kaya sabihin lang mang sabihin, sa tuwing Gitnang Nabibilang ang pagitan ng 2 numero,

736
00:44:18,960 --> 00:44:21,150
sabihin paglilikom lang.

737
00:44:21,150 --> 00:44:24,330
Kailangan lang namin upang matiyak na gawin namin ito sa bawat hakbang ng paraan.

738
00:44:24,330 --> 00:44:29,040
Kaya kami ay upang tipunin, at kami ay sabihin na 161 sa gitna ng aming listahan.

739
00:44:29,040 --> 00:44:34,640
Kaya 161 <164, at ang bawat elemento sa kaliwa ng 161

740
00:44:34,640 --> 00:44:39,120
din <164, kaya alam namin na hindi ito upang makatulong sa amin sa lahat

741
00:44:39,120 --> 00:44:42,690
upang simulan ang naghahanap sa paglipas dito dahil ang elemento namin ang iyong hinahanap ay hindi maaaring may.

742
00:44:42,690 --> 00:44:47,060
Kaya kung ano ang maaari naming gawin ay maaari naming lamang kalimutan tungkol na buong kaliwang kalahati ng listahan,

743
00:44:47,060 --> 00:44:51,700
at ngayon ay isinasaalang-alang lamang mula sa kanan ng 161 pasulong.

744
00:44:51,700 --> 00:44:54,050
>> Kaya muli, ito ay sa Gitnang; sabihin paglilikom lang.

745
00:44:54,050 --> 00:44:56,260
Ngayon 175 ay masyadong malaki.

746
00:44:56,260 --> 00:44:59,180
Kaya alam naming hindi ito upang matulungan kaming naghahanap dito o dito,

747
00:44:59,180 --> 00:45:06,610
upang maaari naming lamang magtapon na ang layo, at kalaunan namin pindutin ang 164.

748
00:45:06,610 --> 00:45:10,560
Anumang mga katanungan sa binary paghahanap?

749
00:45:10,560 --> 00:45:14,180
Sabihin lumipat sa mula sa paghahanap sa pamamagitan ng na-pinagsunod-sunod na listahan

750
00:45:14,180 --> 00:45:17,660
sa aktwal na pagkuha ng isang listahan ng mga numero sa anumang pagkakasunud-sunod

751
00:45:17,660 --> 00:45:20,960
at paggawa na listahan sa pataas na pagkakasunod-sunod.

752
00:45:20,960 --> 00:45:24,060
Ang unang algorithm na itinuturing namin ang tinatawag na bubble-uuri.

753
00:45:24,060 --> 00:45:27,300
At ito ay simple ng algorithm na namin nakita.

754
00:45:27,300 --> 00:45:32,970
Bubble-uuri ay sinasabi na kapag ang anumang 2 elemento sa loob ng listahan ng lugar,

755
00:45:32,970 --> 00:45:36,500
ibig sabihin may isang mas mataas na numero sa kaliwa ng isang mas mababang numero,

756
00:45:36,500 --> 00:45:40,190
pagkatapos kami ay pagpunta sa swap sa kanila, dahil nangangahulugan iyon na listahan ay

757
00:45:40,190 --> 00:45:42,860
"Higit pinagsunod-sunod" kaysa ito ay bago.

758
00:45:42,860 --> 00:45:45,180
At kami ay muling ipagpatuloy ang prosesong ito at muli at muli

759
00:45:45,180 --> 00:45:52,100
hanggang sa kalaunan ang mga elemento ng uri ng bubble sa kanilang wastong lokasyon at kami ay may pinagsunod-sunod listahan.

760
00:45:52,100 --> 00:45:57,230
>> Ang run oras ng ito ay pagpunta sa O (n ²). Bakit?

761
00:45:57,230 --> 00:46:00,370
Well, dahil sa ang pinakamasama kaso, kami ay pagpunta sa tumagal ng bawat elemento, at

762
00:46:00,370 --> 00:46:04,570
kami ay pagpunta sa paghahambing nito sa bawat iba pang mga elemento sa listahan.

763
00:46:04,570 --> 00:46:08,030
Ngunit sa ang pinakamahusay na kaso, mayroon kaming isang na pinagsunod-sunod sa listahan, bubble-uuri ng

764
00:46:08,030 --> 00:46:12,230
lamang upang pumunta sa pamamagitan ng sabay-sabay, sabihin ang "Nope hindi ako gumawa ng anumang mga swaps, kaya tapos ako na."

765
00:46:12,230 --> 00:46:17,410
Kaya mayroon kami ng pinakamahusay na-case na oras ng paggana ng Ω (n).

766
00:46:17,410 --> 00:46:20,680
Natin patakbuhin ang bubble uri sa isang listahan.

767
00:46:20,680 --> 00:46:23,560
O unang, sabihin lamang tumingin sa ilang pseudocode talagang mabilis.

768
00:46:23,560 --> 00:46:28,160
Gusto naming sabihin gusto naming subaybayan ang mga, sa bawat pag-ulit ng loop,

769
00:46:28,160 --> 00:46:32,190
subaybayan man o hindi ay nagbago namin ang anumang elemento.

770
00:46:32,190 --> 00:46:37,610
Kaya ang mga dahilan para sa na, kami ay pagpunta upang itigil kapag hindi namin swapped anumang mga elemento.

771
00:46:37,610 --> 00:46:41,980
Kaya sa simula ng aming loop hindi namin swapped anumang, kaya makikita namin sabihin na maling.

772
00:46:41,980 --> 00:46:47,170
Ngayon, kami ay pagpunta sa pumunta sa pamamagitan ng listahan at ihambing ang elemento i elemento ng i + 1

773
00:46:47,170 --> 00:46:50,310
at kung ito ay ang kaso na may mas malaking numero sa kaliwa ng isang mas maliit na bilang,

774
00:46:50,310 --> 00:46:52,310
pagkatapos lamang namin ay pagpunta sa swap sa kanila.

775
00:46:52,310 --> 00:46:54,490
>> At pagkatapos kami ay tandaan na namin swapped isang elemento.

776
00:46:54,490 --> 00:46:58,900
Iyon ay nangangahulugan na kailangan namin upang pumunta sa pamamagitan ng listahan ng hindi bababa sa 1 pang oras

777
00:46:58,900 --> 00:47:02,160
dahil ang kundisyon kung saan kami huminto kapag ang buong listahan pinagsunod-sunod,

778
00:47:02,160 --> 00:47:04,890
ibig sabihin hindi kami gumawa ng anumang mga swaps.

779
00:47:04,890 --> 00:47:09,960
Kaya na ang dahilan kung bakit ang aming kundisyon pababa dito ay 'habang ang ilang mga elemento ay swapped.'

780
00:47:09,960 --> 00:47:13,720
Kaya ngayon sabihin lang tumingin sa ito tumatakbo sa isang listahan.

781
00:47:13,720 --> 00:47:16,640
Mayroon akong listahan 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Bubble-uuri upang simulan ang lahat ng mga paraan sa kaliwa, at upang ihambing

783
00:47:19,850 --> 00:47:24,700
ang i elemento, kaya 0 sa i + 1, na elemento 1.

784
00:47:24,700 --> 00:47:29,020
Ito ay pagpunta sa sabihin, na rin 5> 0, ngunit ngayon 5 sa kaliwa,

785
00:47:29,020 --> 00:47:32,500
kaya kailangan kong i-swap ang 5 at ang 0.

786
00:47:32,500 --> 00:47:35,470
Kapag swap ko ang mga ito, biglang ako makakakuha ng ibang listahan na ito.

787
00:47:35,470 --> 00:47:38,260
Ngayon 5> 1, kaya kami ay pagpunta sa swap sa kanila.

788
00:47:38,260 --> 00:47:42,160
5 ay hindi> 6, kaya hindi namin kailangang gawin dito.

789
00:47:42,160 --> 00:47:46,690
Ngunit 6> 4, kaya kailangan namin upang magpalitan.

790
00:47:46,690 --> 00:47:49,740
Muli, kailangan namin upang tumakbo sa pamamagitan ng buong listahan sa kalaunan matuklasan

791
00:47:49,740 --> 00:47:52,330
na ang mga ito ay sira; swap namin sa kanila,

792
00:47:52,330 --> 00:47:57,120
at sa puntong ito kailangan namin upang tumakbo sa pamamagitan ng listahan 1 mas maraming oras

793
00:47:57,120 --> 00:48:05,390
upang tiyakin na ang lahat ay sa order, at sa puntong ito-uri-uriin ng bubble tapos.

794
00:48:05,390 --> 00:48:10,720
Ang isang iba't ibang mga algorithm para sa pagkuha ng ilang mga elemento at pag-uuri-uri ang mga ito ay pagpili-uuri.

795
00:48:10,720 --> 00:48:15,740
Ang ideya sa likod ng pagpili-uuri ay na kami ay pagpunta upang bumuo ng pinagsunod-sunod bahagi ng listahan

796
00:48:15,740 --> 00:48:18,150
1 elemento sa isang pagkakataon.

797
00:48:18,150 --> 00:48:23,170
>> At ang paraan na kami ay pagpunta upang gawin iyon ay sa pamamagitan ng pagbuo ng hanggang sa kaliwa segment ng listahan.

798
00:48:23,170 --> 00:48:27,510
At isa lamang, ang bawat - sa bawat hakbang, kami ay ang pinakamaliit na elemento na namin ang natitira

799
00:48:27,510 --> 00:48:32,310
na hindi pa na pinagsunod-sunod, at kami ay pagpunta upang ilipat ito sa na pinagsunod-sunod na segment.

800
00:48:32,310 --> 00:48:35,850
Nangangahulugan iyon na kailangan namin upang patuloy na hanapin ang minimum unsorted elemento

801
00:48:35,850 --> 00:48:40,720
at pagkatapos ay dadalhin na minimum na elemento at magpalitan ang mga ito sa anumang

802
00:48:40,720 --> 00:48:45,090
kaliwa-pinaka-elemento na hindi nakaayos.

803
00:48:45,090 --> 00:48:50,890
Ang patakbuhin ang oras ng ito ay pagpunta sa O (n ²) dahil sa ang pinakamasama kaso

804
00:48:50,890 --> 00:48:55,070
kailangan namin upang ihambing ang bawat solong elemento sa bawat iba pang mga elemento.

805
00:48:55,070 --> 00:48:59,250
Dahil kami ay nagsasabi na kung sinimulan namin sa kaliwang kalahati ng listahan, kailangan namin

806
00:48:59,250 --> 00:49:02,970
upang pumunta sa pamamagitan ng buong karapatan segment upang mahanap ang pinakamaliit na elemento.

807
00:49:02,970 --> 00:49:05,430
At pagkatapos, muli, kailangan namin upang pumunta sa buong kanan segment at

808
00:49:05,430 --> 00:49:08,210
panatilihin ang pagpunta sa paglipas na muli nang paulit-ulit at mahigit.

809
00:49:08,210 --> 00:49:11,350
Na n ². Kami ay pagpunta sa kailangan para sa loob ng loop ng isa pa para sa loop

810
00:49:11,350 --> 00:49:13,350
na nagmumungkahi n ².

811
00:49:13,350 --> 00:49:16,530
Ang pinakamahusay na pag-iisip ng kaso, sabihin nating namin bigyan ito ng isang na pinagsunod-sunod sa listahan;

812
00:49:16,530 --> 00:49:19,270
namin ang aktwal na hindi gawin anumang mas mahusay kaysa sa n ².

813
00:49:19,270 --> 00:49:21,730
Dahil ang pagpili-uuri ay walang paraan ng alam na

814
00:49:21,730 --> 00:49:25,540
ang minimum na elemento ay mangyari ko sa pagtingin sa.

815
00:49:25,540 --> 00:49:28,970
Pa rin ito ay kinakailangan upang matiyak na ito ay talagang ang minimum.

816
00:49:28,970 --> 00:49:31,670
>> At ang tanging paraan upang matiyak na ang minimum, gamit ang algorithm,

817
00:49:31,670 --> 00:49:34,640
upang tumingin muli sa bawat solong elemento.

818
00:49:34,640 --> 00:49:38,420
Kaya talaga, kung ikaw ay bigyan ito - kung magbibigay sa iyo ng pagpili-uuri ng na pinagsunod-sunod sa listahan,

819
00:49:38,420 --> 00:49:42,720
hindi ito gawin ang anumang mas mahusay kaysa sa na nagbibigay sa ito sa isang listahan na hindi pa nakaayos.

820
00:49:42,720 --> 00:49:46,320
Sa pamamagitan ng paraan, kung ito ang mangyayari ang kaso na ang isang bagay ay O (isang bagay)

821
00:49:46,320 --> 00:49:50,640
at ang wakas ng isang bagay, maaari naming lamang sabihin mas succinctly na θ ng isang bagay.

822
00:49:50,640 --> 00:49:52,760
Kaya kung nakita mo na makabuo kahit saan, na sa kung ano ay nangangahulugan lamang na.

823
00:49:52,760 --> 00:49:57,580
>> Kung may isang bagay theta ng n ², ito ay parehong malaki O (n ²) at Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Kaya ang pinakamahusay na kaso at ang pinakamasama kaso, hindi ito gumawa ng isang pagkakaiba,

825
00:49:59,790 --> 00:50:04,400
algorithm ay pagpunta sa gawin ang parehong bagay sa bawat oras.

826
00:50:04,400 --> 00:50:06,610
Kaya ito ay kung ano ang pseudocode para sa pagpili-uuri ay maaaring magmukhang.

827
00:50:06,610 --> 00:50:10,630
Talaga namin ay upang sabihin na gusto ko upang umulit sa listahan

828
00:50:10,630 --> 00:50:15,180
mula kaliwa sa kanan, at sa bawat pag-ulit ng loop, ako pagpunta sa ilipat

829
00:50:15,180 --> 00:50:19,780
ang minimum na elemento sa ito pinagsunod-sunod na bahagi ng listahan.

830
00:50:19,780 --> 00:50:23,260
At sa sandaling ko bang ilipat ang isang bagay doon, hindi ko kailangan upang tumingin muli sa na elemento.

831
00:50:23,260 --> 00:50:28,600
Dahil sa lalong madaling swap ko ang isang elemento sa sa kaliwa segment ng listahan, pinagsunod-sunod

832
00:50:28,600 --> 00:50:32,600
dahil ginagawa namin ang lahat sa pataas na pagkakasunod-sunod sa pamamagitan ng paggamit ng mga minimum.

833
00:50:32,600 --> 00:50:38,740
Kaya't sinabi namin, okay, hindi namin sa posisyon i, at kailangan namin upang tumingin sa lahat ng mga elemento

834
00:50:38,740 --> 00:50:42,260
sa kanan ng i upang hanapin ang minimum.

835
00:50:42,260 --> 00:50:46,150
Sa gayon ay nangangahulugan na gusto naming tingnan mula sa i + 1 sa dulo ng listahan.

836
00:50:46,150 --> 00:50:51,610
At ngayon, kung ang elemento na kasalukuyan kaming naghahanap sa ay mas mababa kaysa sa aming minimum na sa ngayon,

837
00:50:51,610 --> 00:50:54,190
kung saan, Tandaan, kami ay simulan ang minimum off lamang na

838
00:50:54,190 --> 00:50:57,020
anumang elemento na hindi namin kasalukuyang sa, kukunin ko na ipinapalagay na ang minimum.

839
00:50:57,020 --> 00:51:00,270
Kung nakita ko ang isang elemento na mas maliit kaysa sa, pagkatapos ay ako pagpunta sa sabihin, okay,

840
00:51:00,270 --> 00:51:02,700
maayos, Nakakita ako ng isang bagong minimum.

841
00:51:02,700 --> 00:51:06,080
Ako pagpunta sa tandaan kung saan ay ang minimum na.

842
00:51:06,080 --> 00:51:09,560
>> Kaya ngayon, kapag nawala ko na sa pamamagitan ng na karapatan unsorted segment,

843
00:51:09,560 --> 00:51:16,690
Maaari kong sabihin ako pagpunta sa swap ang minimum na elemento sa mga elemento na sa posisyon i.

844
00:51:16,690 --> 00:51:21,100
Na upang bumuo ng aking listahan, aking pinagsunod-sunod na bahagi ng listahan mula kaliwa hanggang kanang,

845
00:51:21,100 --> 00:51:25,190
at hindi namin kailangan upang tumingin muli sa isang elemento sa sandaling ito ay sa na bahagi.

846
00:51:25,190 --> 00:51:27,930
Kapag kami swapped ito.

847
00:51:27,930 --> 00:51:30,260
Kaya natin patakbuhin ang pagpili ng uri sa listahang ito.

848
00:51:30,260 --> 00:51:38,220
Ang bughaw na elemento dito ay pagpunta sa i, at ang pulang elemento ay ang minimum na elemento.

849
00:51:38,220 --> 00:51:41,570
Kaya i nagsisimula ang lahat ng mga paraan sa kaliwa ng listahan, kaya sa 5.

850
00:51:41,570 --> 00:51:44,610
Ngayon kailangan namin upang mahanap ang minimum unsorted elemento.

851
00:51:44,610 --> 00:51:49,480
Kaya sinasabi namin 0 <5, kaya 0 ang aking bagong minimum.

852
00:51:49,480 --> 00:51:53,820
>> Ngunit hindi ko maaaring tumigil doon, dahil kahit na maaari naming nakikilala na 0 ang pinakamaliit,

853
00:51:53,820 --> 00:51:59,390
kailangan namin upang tumakbo sa pamamagitan ng bawat iba pang mga elemento ng listahan upang matiyak na.

854
00:51:59,390 --> 00:52:01,760
Kaya 1 ay mas malaki, 6 ay mas malaki, 4 ay mas malaki.

855
00:52:01,760 --> 00:52:05,850
Iyon ay nangangahulugan na pagkatapos ng pagtingin sa lahat ng mga sangkap na ito, Napag-alaman ko 0 ang pinakamaliit.

856
00:52:05,850 --> 00:52:09,800
Kaya ako pagpunta sa swap ang 5 at ang 0.

857
00:52:09,800 --> 00:52:15,480
Kapag swap ko na, ako pagpunta upang makakuha ng isang bagong listahan, at alam ko na hindi ko kailangan upang tumingin muli sa na 0

858
00:52:15,480 --> 00:52:19,380
dahil sabay-sabay ko na swapped ito, ko na pinagsunod-sunod ito at tapos na kami.

859
00:52:19,380 --> 00:52:22,730
Ngayon lang ito kaya mangyayari na ang mga asul na elemento ay muli ang 5,

860
00:52:22,730 --> 00:52:26,030
at kailangan namin upang tumingin sa 1, ang 6 at ang 4 upang matukoy na 1

861
00:52:26,030 --> 00:52:31,520
ay ang pinakamaliit na elemento ng minimum, kaya namin swap sa 1 at ang 5.

862
00:52:31,520 --> 00:52:36,890
Muli, kailangan namin upang tumingin sa - ihambing ang 5 sa 6 at ang 4,

863
00:52:36,890 --> 00:52:39,830
at kami ay pagpunta sa swap sa 4 at ang 5, at sa wakas, ihambing

864
00:52:39,830 --> 00:52:45,740
mga 2 numero at swap sa kanila hanggang sa makuha namin ang aming pinagsunod-sunod listahan.

865
00:52:45,740 --> 00:52:49,730
Anumang mga katanungan sa pagpili-uuri?

866
00:52:49,730 --> 00:52:56,420
Okay. Natin lumipat sa huling paksa dito, at na recursion.

867
00:52:56,420 --> 00:52:59,810
>> Recursion, Tandaan, ito talagang bagay meta kung saan ang isang function

868
00:52:59,810 --> 00:53:02,740
paulit-ulit na mga tawag mismo.

869
00:53:02,740 --> 00:53:05,620
Kaya sa isang punto, habang ang aming fuction ay paulit-ulit na pagtawag mismo,

870
00:53:05,620 --> 00:53:10,100
kailangang ilang mga punto kung saan itigil namin ang pagtawag sa ating sarili.

871
00:53:10,100 --> 00:53:13,670
Dahil kung hindi namin gawin iyon, pagkatapos lamang kami ay pagpunta sa patuloy na gawin ito magpakailanman,

872
00:53:13,670 --> 00:53:16,660
at ang aming programa ay hindi pagpunta sa wakasan.

873
00:53:16,660 --> 00:53:19,200
Tinatawag namin itong kundisyon base kaso.

874
00:53:19,200 --> 00:53:22,570
At ang pangunahing kaso sabi, kaysa sa pagtawag muli ang isang function,

875
00:53:22,570 --> 00:53:25,330
Lamang ako pagpunta sa ibalik ang ilang mga halaga.

876
00:53:25,330 --> 00:53:28,080
Kaya kapag ibinalik namin na ang halaga, itinigil namin ang pagtawag sa ating sarili,

877
00:53:28,080 --> 00:53:32,550
at ang lahat ng mga tawag na ginawa naming sa ngayon ay maaari ring ibalik.

878
00:53:32,550 --> 00:53:36,050
Ang tapat ng kaso ng base ang recursive kaso.

879
00:53:36,050 --> 00:53:39,050
At ito ay kapag gusto naming gumawa ng isa pang tawag sa function na hindi namin kasalukuyan.

880
00:53:39,050 --> 00:53:44,690
At hindi na namin marahil, bagaman hindi laging, nais na gumamit ng iba't ibang mga argumento.

881
00:53:44,690 --> 00:53:48,940
>> Kaya kung kami ay may isang function na tinatawag na f, at lamang na tinatawag na f 1 argumento,

882
00:53:48,940 --> 00:53:52,010
at panatilihin namin lamang pagtawag sa f (1), f (1), f (1), at ito lamang ang kaya mangyayari na

883
00:53:52,010 --> 00:53:56,510
argument 1 Nabibilang ang sa recursive kaso, pa namin ay hindi kailanman upang ihinto.

884
00:53:56,510 --> 00:54:01,620
Kahit na mayroon kami ng base kaso, kailangan namin upang matiyak na kalaunan namin ay pagpunta sa hit na base kaso.

885
00:54:01,620 --> 00:54:04,250
Hindi namin lamang panatilihin ang naglalagi sa kasong ito recursive.

886
00:54:04,250 --> 00:54:09,870
Sa pangkalahatan, kapag tinatawag naming ating sarili, marahil kami ay pagpunta sa ng ibang argumento sa bawat oras.

887
00:54:09,870 --> 00:54:12,700
Narito ang isang talagang simpleng recursive function na.

888
00:54:12,700 --> 00:54:15,090
Kaya ito ay kino-compute ang factorial ng isang numero.

889
00:54:15,090 --> 00:54:17,790
Up itaas dito namin ang aming base kaso.

890
00:54:17,790 --> 00:54:22,330
Sa kaso na n ≤ 1, hindi namin ay pagpunta sa tumawag muli ang factorial.

891
00:54:22,330 --> 00:54:26,490
Kami ay pagpunta sa itigil; lang kami upang ibalik ang ilang mga halaga.

892
00:54:26,490 --> 00:54:30,170
Kung ito ay hindi totoo, at pagkatapos namin ay pagpunta upang maabot ang aming recursive kaso.

893
00:54:30,170 --> 00:54:33,550
Mapansin dito na hindi namin lamang pagtawag factorial (n), dahil hindi kapaki-pakinabang.

894
00:54:33,550 --> 00:54:36,810
Kami ay pagpunta sa tumawag factorial ng iba pa.

895
00:54:36,810 --> 00:54:40,850
>> At sa gayon ay maaari mong makita, kalaunan kung pumasa kami ng factorial (5) o isang bagay,

896
00:54:40,850 --> 00:54:45,900
kami ay pagpunta sa tumawag factorial (4) at iba pa, at kalaunan namin upang maabot ang na base kaso.

897
00:54:45,900 --> 00:54:51,730
Kaya ito mukhang mahusay. Natin makita kung ano ang mangyayari kapag aktwal namin patakbuhin ang.

898
00:54:51,730 --> 00:54:57,840
Ito ay ang stack, at sabihin natin na ang pangunahing ay upang tawagan ang function na ito na may isang argumento (4).

899
00:54:57,840 --> 00:55:02,200
Kaya sabay-sabay factorial nakikita at = 4, factorial ay tumawag mismo.

900
00:55:02,200 --> 00:55:05,010
Ngayon, biglang, mayroon kaming factorial (3).

901
00:55:05,010 --> 00:55:10,780
Kaya ang mga function na ito ay pagpunta upang panatilihin ang lumalaking hanggang kalaunan namin pindutin ang aming base kaso.

902
00:55:10,780 --> 00:55:17,830
Sa puntong ito, ang return halaga ng return (nx return halaga ng),

903
00:55:17,830 --> 00:55:21,290
ang return halaga ng nx ang return halaga ng.

904
00:55:21,290 --> 00:55:23,290
Sa paglaon kailangan namin upang maabot ang ilang mga numero.

905
00:55:23,290 --> 00:55:26,560
Sa tuktok dito, sinasabi namin return 1.

906
00:55:26,560 --> 00:55:30,650
Iyon ay nangangahulugan na ang sabay-sabay naming ibalik na numero, maaari naming pop ito off ng stack.

907
00:55:30,650 --> 00:55:36,570
Kaya ito factorial (1) tapos na.

908
00:55:36,570 --> 00:55:41,190
Kapag 1 babalik, ito factorial (1) return, ang return na ito sa 1.

909
00:55:41,190 --> 00:55:46,910
Ang return halaga ng mga ito, Tandaan, ay nx ang return halaga ng mga ito.

910
00:55:46,910 --> 00:55:50,720
Kaya biglang, ang tao na ito ay alam na gusto ko upang bumalik 2.

911
00:55:50,720 --> 00:55:55,910
>> Kaya tandaan, bumalik halaga ng mga ito lamang nx return halaga dito.

912
00:55:55,910 --> 00:56:01,160
Kaya ngayon maaari naming sabihin 3 x 2, at sa wakas, narito maaari naming sabihin

913
00:56:01,160 --> 00:56:04,010
ito ay 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
At sa sandaling ito babalik, namin pababa ng isang integer sa loob ng pangunahing.

915
00:56:09,570 --> 00:56:15,460
Anumang mga katanungan sa recursion?

916
00:56:15,460 --> 00:56:17,090
Ayos lang. Kaya mas maraming oras para sa mga tanong sa dulo,

917
00:56:17,090 --> 00:56:23,360
ngunit ngayon Joseph ay masaklawan ang natitirang mga paksa.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] Lahat ng karapatan. Kaya ngayon na kami uusapang tungkol recursions,

919
00:56:25,590 --> 00:56:27,840
sabihin makipag-usap ng kaunti tungkol sa kung ano ang bumaybay-uuri ay.

920
00:56:27,840 --> 00:56:31,740
Pagsamahin-uuri ay isa lamang ng isa pang paraan ng pag-uuri-uri ng isang listahan ng mga numero.

921
00:56:31,740 --> 00:56:36,430
At kung paano ito gumagana ay, sa pagsasama-uuri mayroon kang isang listahan, at ano ang ginagawa namin ay

922
00:56:36,430 --> 00:56:39,120
sabihin namin, sabihin hatiin ito sa 2 halves.

923
00:56:39,120 --> 00:56:42,750
Ipapakita muna namin patakbuhin sumanib-uuri muli sa kaliwang kalahati,

924
00:56:42,750 --> 00:56:45,040
magpapadala kami magpatakbo sumanib uri sa kanang kalahati,

925
00:56:45,040 --> 00:56:50,240
at na nagbibigay sa amin ngayon 2 halves na pinagsunod-sunod, at ngayon kami ay upang pagsamahin ang mga halves.

926
00:56:50,240 --> 00:56:55,010
Ng kaunti mahirap upang makita nang walang isang halimbawa, kaya kami sa pamamagitan ng mga galaw at makita kung ano ang mangyayari.

927
00:56:55,010 --> 00:56:59,590
Kaya simulan mo sa listahang ito, hatiin namin ito sa 2 halves.

928
00:56:59,590 --> 00:57:02,300
Nagpapatakbo kami sumanib uri sa kaliwang kalahati muna.

929
00:57:02,300 --> 00:57:06,660
Kaya na ang kaliwang kalahati, at ngayon namin patakbuhin ang mga ito muli sa pamamagitan ng listahang ito

930
00:57:06,660 --> 00:57:09,800
na maipo pumasa sa sa pagsasama-uuri, at pagkatapos ay tinitingnan namin, muli,

931
00:57:09,800 --> 00:57:13,270
sa kaliwang bahagi ng listahan na ito at magpatakbo namin sumanib ang uri dito.

932
00:57:13,270 --> 00:57:15,880
Ngayon, makuha namin pababa sa isang listahan ng mga 2 numero,

933
00:57:15,880 --> 00:57:19,010
at ngayon ang kaliwang kalahati 1 elemento lamang mahaba, at hindi namin maaari

934
00:57:19,010 --> 00:57:23,380
hatiin ang isang listahan na lamang ang 1 elemento sa kalahati, kaya lang namin sabihin, sa sandaling kami ay may 50,

935
00:57:23,380 --> 00:57:26,400
na lamang ang 1 elemento, na ito pinagsunod-sunod.

936
00:57:26,400 --> 00:57:29,860
>> Sandaling namin tapos ka na, maaari naming makita na aming makakaya

937
00:57:29,860 --> 00:57:32,230
lumipat sa kanang kalahati ng listahang ito,

938
00:57:32,230 --> 00:57:36,480
at 3 din ang pinagsunod-sunod, at kaya ngayon na ang parehong halves ng listahang ito ay pinagsunod-sunod

939
00:57:36,480 --> 00:57:39,080
maaari naming sumali ang mga numerong ito pabalik sama-sama.

940
00:57:39,080 --> 00:57:45,320
Kaya tinitingnan namin sa 50 at 3; 3 ay mas maliit sa 50, kaya ito napupunta sa unang at pagkatapos ay 50 ay.

941
00:57:45,320 --> 00:57:49,340
Ngayon, na nagawa, pumunta namin pabalik hanggang sa na listahan at-uri-uriin kanang kalahati.

942
00:57:49,340 --> 00:57:52,440
42 ito ng sariling numero, kaya na ito pinagsunod-sunod.

943
00:57:52,440 --> 00:57:57,850
Kaya ngayon namin ihambing ang mga 2 at 3 ay mas maliit kaysa sa 42, kaya na ay makakakuha ng ilagay sa unang,

944
00:57:57,850 --> 00:58:02,340
ngayon 42 ay makakakuha ng ilagay sa, at 50 ay makakakuha ng ilagay.

945
00:58:02,340 --> 00:58:07,220
Ngayon, na pinagsunod-sunod, pumunta namin ang lahat ng mga paraan pabalik sa tuktok, 1337 at 15.

946
00:58:07,220 --> 00:58:14,560
Well, ngayon namin tumingin sa kaliwang kalahati ng listahang ito, 1337 ay sa pamamagitan ng mismo kaya pinagsunod-sunod at parehong may 15.

947
00:58:14,560 --> 00:58:19,020
Kaya ngayon naming pagsamahin ang 2 numero upang pag-uri-uriin na ang orihinal na listahan, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
kaya pupunta sa unang, pagkatapos 1337 pupunta.

949
00:58:23,060 --> 00:58:26,640
At ngayon, pinagsunod-sunod namin parehong halves ng orihinal na listahan up tuktok.

950
00:58:26,640 --> 00:58:30,440
At lahat kami ay may sa gawin ay pagsamahin ang mga.

951
00:58:30,440 --> 00:58:36,890
Inaasahan naming sa unang 2 numero ng listahang ito, 3 <15, kaya pupunta sa array-uuri sa unang.

952
00:58:36,890 --> 00:58:44,460
15 <42, kaya mangyaring in Ngayon, 42 <1337, na naging.

953
00:58:44,460 --> 00:58:51,010
50 <1337, kaya pupunta. At mapansin na lang namin kinuha 2 numero ng listahang ito.

954
00:58:51,010 --> 00:58:53,640
Kaya hindi namin ka lamang alternating sa pagitan ng 2 listahan.

955
00:58:53,640 --> 00:58:56,050
Kami ay naghahanap sa simula, at namin ang paglalaan ng elemento

956
00:58:56,050 --> 00:59:00,270
na mas maliit at pagkatapos ng paglalagay ito sa aming array.

957
00:59:00,270 --> 00:59:04,080
Ngayon Pinagsama namin ang lahat ng mga halves at tapos na kami.

958
00:59:04,080 --> 00:59:07,780
>> Anumang mga katanungan tungkol bumaybay-uuri? Oo?

959
00:59:07,780 --> 00:59:14,190
[Mag-aaral] Kung ito ang paghahati ng pang sa iba't ibang mga, bakit hindi nila lang hatiin ito sa sandaling

960
00:59:14,190 --> 00:59:19,970
at mayroon kang 3 at 2 sa isang grupo? [Rest ng tanong hindi maunawaan]

961
00:59:19,970 --> 00:59:24,940
Ang dahilan - kaya tanong ay, kung bakit hindi lang namin pagsamahin ang mga ito na unang hakbang pagkatapos mayroon kaming ang mga ito?

962
00:59:24,940 --> 00:59:29,530
Ang dahilan kung bakit maaari naming gawin ito, simulan sa kaliwang pinaka elemento ng magkabilang panig,

963
00:59:29,530 --> 00:59:33,040
at pagkatapos ay gawin ang mga mas maliit na isa at ilagay ito sa, na alam namin na ang mga

964
00:59:33,040 --> 00:59:35,290
indibidwal na listahan ay pinagsunod-sunod order.

965
00:59:35,290 --> 00:59:37,290
Kaya kung Naghahanap ako sa kaliwang pinakamaraming mga elemento ng parehong halves,

966
00:59:37,290 --> 00:59:40,490
Alam ko sila na ang pinakamaliit na elemento ng mga listahan.

967
00:59:40,490 --> 00:59:43,930
Sa gayon ay maaari ko bang ilagay ang mga ito sa pinakamaliit na spot ng elemento ng ang malaking listahan.

968
00:59:43,930 --> 00:59:47,810
Sa kabilang banda, kung tiningnan ko sa mga 2 listahan sa ikalawang antas banda roon,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 at 15, ang mga ay hindi pinagsunod-sunod.

970
00:59:51,640 --> 00:59:55,770
Kaya't kung tiningnan ko sa 50 at 1337, ako pagpunta upang ilagay ang 50 sa aking listahan sa unang.

971
00:59:55,770 --> 01:00:00,130
Ngunit iyon ay hindi talagang magkaroon ng kahulugan, dahil 3 ay ang pinakamaliit na elemento out sa lahat ng mga.

972
01:00:00,130 --> 01:00:04,390
Kaya ang tanging dahilan maaari naming gawin ito hakbang ng pagsasama-sama ay dahil ang aming mga listahan ay pinagsunod-sunod.

973
01:00:04,390 --> 01:00:07,010
Alin ang kung bakit mayroon kaming upang makakuha ng down ang lahat ng mga paraan sa ibaba

974
01:00:07,010 --> 01:00:09,800
dahil kapag mayroon kami ng isang numero, alam mo na ang isang solong numero

975
01:00:09,800 --> 01:00:14,120
sa loob at ng sarili nito ay pinagsunod-sunod listahan.

976
01:00:14,120 --> 01:00:19,360
>> Anumang mga katanungan? Hindi?

977
01:00:19,360 --> 01:00:24,260
Pagiging kumplikado? Well, maaari mong makita na sa bawat hakbang may pagtatapos numero,

978
01:00:24,260 --> 01:00:27,590
at maaari naming hatiin ang isang listahan sa kalahati log n beses,

979
01:00:27,590 --> 01:00:31,700
na kung saan nakukuha namin ito log n x n kumplikado.

980
01:00:31,700 --> 01:00:34,940
At makikita mo ang pinakamahusay na kaso para sa pagsasama-uuri n log n, at ito lamang kaya ang mangyayari

981
01:00:34,940 --> 01:00:39,340
na ang pinakamasama kaso, o Ω banda roon, ay din n log n.

982
01:00:39,340 --> 01:00:42,480
Isang bagay na dapat tandaan.

983
01:00:42,480 --> 01:00:45,750
Paglipat sa, sabihin pumunta sa ilang mga sobrang pangunahing file ako / O.

984
01:00:45,750 --> 01:00:48,830
Kung tumingin ka sa mang-uayabit, mapapansin mo nagkaroon kami ng ilang mga uri ng sistema

985
01:00:48,830 --> 01:00:51,270
kung saan maaari kang sumulat sa isang file ng log kung mong basahin sa pamamagitan ng code.

986
01:00:51,270 --> 01:00:53,730
Natin makita kung paano mo maaaring gawin na.

987
01:00:53,730 --> 01:00:57,450
Well, mayroon kaming fprintf, na maaari mong isipin ng bilang lamang printf,

988
01:00:57,450 --> 01:01:01,720
ngunit lamang ang pag-print sa isang file sa halip, at samakatuwid ay ibinigay ang f sa simula.

989
01:01:01,720 --> 01:01:07,570
Ang ganitong uri ng code hanggang dito, kung ano ang ginagawa nito, bilang na nakita mo sa mang-uayabit,

990
01:01:07,570 --> 01:01:12,310
napupunta sa pamamagitan ng iyong pag-print sa 2-dimensional array out hilera sa pamamagitan ng hilera kung ano ang mga numero ay.

991
01:01:12,310 --> 01:01:17,850
Sa kasong ito, printf mga Kopya sa iyong terminal o kung ano ang tinatawag naming ang standard na output ng seksyon.

992
01:01:17,850 --> 01:01:22,170
>> At ngayon, sa kasong ito, lahat kami ay may sa gawin ay palitan printf may fprintf,

993
01:01:22,170 --> 01:01:26,770
sabihin dito kung ano ang file na nais mong i-print, at sa kasong ito lamang ito ng mga Kopya ito sa file na iyon

994
01:01:26,770 --> 01:01:32,230
sa halip ng pag-print ito sa iyong terminal.

995
01:01:32,230 --> 01:01:36,500
Well, pagkatapos na begs ang tanong: Saan kami makakuha ng ganitong uri ng file mula sa, i-right?

996
01:01:36,500 --> 01:01:39,840
Ipinasa namin mag-log in sa ito fprintf fuction ngunit kami ay walang ideya na kung saan ito ay nagmula sa.

997
01:01:39,840 --> 01:01:43,980
Well, maagang sa code, ano nagkaroon kami ito tipak ng code sa paglipas dito,

998
01:01:43,980 --> 01:01:48,340
na talaga sabi na bukas ang file tawag log.txt.

999
01:01:48,340 --> 01:01:53,220
Ano ang ginagawa namin matapos na namin upang matiyak na ang file ay talagang binuksan matagumpay.

1000
01:01:53,220 --> 01:01:57,070
Kaya maaaring ito mabibigo para sa maraming mga kadahilanan, wala kang sapat na espasyo sa iyong computer, halimbawa.

1001
01:01:57,070 --> 01:01:59,790
Kaya laging mahalaga bago mo ito gawin ang anumang mga pagpapatakbo sa mga file

1002
01:01:59,790 --> 01:02:03,300
na namin suriin kung ang file na ay matagumpay na binuksan.

1003
01:02:03,300 --> 01:02:09,330
Kaya kung ano na ang, na ang isang argumento sa fopen, maayos, maaari naming buksan ang isang file sa maraming paraan.

1004
01:02:09,330 --> 01:02:13,510
Ano ang maaari naming gawin ay, maaari naming ipasa ito w, na nangangahulugan na-override ang file kung ito labasan na,

1005
01:02:13,510 --> 01:02:18,070
Maaari naming makapasa ng isang, na ikabit ang sila sa dulo ng file sa halip ng override ito,

1006
01:02:18,070 --> 01:02:22,730
o maaari naming tukuyin ang r, na nangangahulugan na, sabihin buksan ang file bilang read-only.

1007
01:02:22,730 --> 01:02:24,890
Kaya kung ang programa ay sinusubukan upang gumawa ng anumang mga pagbabago sa file,

1008
01:02:24,890 --> 01:02:30,140
sumigaw sa kanila at huwag hayaan silang gawin ito.

1009
01:02:30,140 --> 01:02:33,320
Sa wakas, sa sandaling kami ay tapos ka na sa ang file, tapos ginagawa pagpapatakbo dito,

1010
01:02:33,320 --> 01:02:35,860
kailangan namin upang matiyak na naming isara ang file.

1011
01:02:35,860 --> 01:02:38,830
At kaya sa dulo ng iyong programa, ikaw ay ipasa ang mga ito muli

1012
01:02:38,830 --> 01:02:42,120
ang file na ito na binuksan mo, at isara ito.

1013
01:02:42,120 --> 01:02:44,650
Kaya ito ay isang bagay na mahalaga na mayroon kang upang tiyakin na gagawin mo.

1014
01:02:44,650 --> 01:02:47,180
Kaya tandaan maaari mong buksan ang isang file, pagkatapos ay maaari kang sumulat sa file,

1015
01:02:47,180 --> 01:02:51,270
gawin ang mga pagpapatakbo sa file, ngunit mayroon kang upang isara ang file sa dulo.

1016
01:02:51,270 --> 01:02:53,270
>> Anumang mga katanungan sa pangunahing file I / O? Oo?

1017
01:02:53,270 --> 01:02:58,050
[Estudyante tanong, hindi maintindihan]

1018
01:02:58,050 --> 01:03:02,480
Dito mismo. Ang tanong ay, kung saan ito log.txt file?

1019
01:03:02,480 --> 01:03:07,890
Well, kung mo lamang bigyan ito ng log.txt, lumilikha ito ng ito sa parehong directory bilang executable.

1020
01:03:07,890 --> 01:03:10,500
Kaya kung you're - >> [Estudyante tanong, hindi maintindihan]

1021
01:03:10,500 --> 01:03:18,830
Oo. Sa parehong folder, o sa parehong directory, na tawagan ka.

1022
01:03:18,830 --> 01:03:21,400
Ngayon memory, stack, at magbunton.

1023
01:03:21,400 --> 01:03:23,400
Kaya kung paano ay memory inilatag sa computer?

1024
01:03:23,400 --> 01:03:26,270
Well, maaari mong isipin ang memory bilang uri ng sa block na ito dito.

1025
01:03:26,270 --> 01:03:30,260
At sa memory mayroon kaming kung ano ang tinatawag na ang magbunton natigil banda roon, at ang stack na pababa doon.

1026
01:03:30,260 --> 01:03:34,480
At magbunton lumalaki ang pababang at stack ang lumalaki paitaas.

1027
01:03:34,480 --> 01:03:38,620
Kaya bilang Tommy nabanggit - oh, mahusay, at kami ay may iba pang mga 4 segment na ako makakakuha ng sa isang segundo -

1028
01:03:38,620 --> 01:03:42,890
Bilang Tommy sinabi mas maaga, alam mo kung paano ang kanyang mga function tumawag sa kanilang sarili at tumawag sa bawat isa?

1029
01:03:42,890 --> 01:03:44,930
Bumuo sila ang ganitong uri ng stack na frame.

1030
01:03:44,930 --> 01:03:47,360
Well, kung pangunahing tawag foo, foo ay makakakuha ng ilagay sa stack.

1031
01:03:47,360 --> 01:03:52,430
Foo tawag bar, bar makakuha ng ilalagay sa stack, at na maipo ilagay sa stack pagkatapos.

1032
01:03:52,430 --> 01:03:57,040
At bilang bumalik sila, sila bawat makapag kinuha off ang stack ang.

1033
01:03:57,040 --> 01:04:00,140
Ano ang bawat isa sa mga lokasyon na ito at memory pindutin nang matagal?

1034
01:04:00,140 --> 01:04:03,110
Well, sa tuktok, na kung saan ay ang teksto ng segment, naglalaman sa programa mismo.

1035
01:04:03,110 --> 01:04:06,390
Kaya ang machine code, na doon, sa sandaling ipunin ang iyong programa.

1036
01:04:06,390 --> 01:04:08,520
Susunod, anumang nasimulan pangkalahatang variable.

1037
01:04:08,520 --> 01:04:12,660
>> Kaya mayroon ka ng mga global variable sa iyong programa, at sabihin tulad, isang = 5,

1038
01:04:12,660 --> 01:04:15,260
na ay makakakuha ng ilagay sa segment na iyon, at kanang ilalim na,

1039
01:04:15,260 --> 01:04:18,990
mayroon kang anumang uninitialized global data, na lang int ng,

1040
01:04:18,990 --> 01:04:20,990
ngunit hindi mo sabihin ito ay katumbas sa anumang bagay.

1041
01:04:20,990 --> 01:04:23,870
Napagtanto mga ito ay mga pangkalahatang variable, kaya sila sa labas ng pangunahing.

1042
01:04:23,870 --> 01:04:28,560
Kaya ito ay nangangahulugan na ang anumang mga pangkalahatang variable na ipinahayag ngunit hindi nasimulan.

1043
01:04:28,560 --> 01:04:32,310
Kaya kung ano ang sa magbunton? Memory inilalaan gamit ang malloc, na magpapadala kami makakuha ng sa ilang sandali.

1044
01:04:32,310 --> 01:04:35,990
At sa wakas, na may stack mayroon kang anumang mga lokal na variable

1045
01:04:35,990 --> 01:04:39,950
at anumang function maaari kang tumawag sa anumang ng kanilang mga parameter.

1046
01:04:39,950 --> 01:04:43,720
Ang huling bagay, hindi mo talaga malaman kung ano ang kapaligiran variable gawin,

1047
01:04:43,720 --> 01:04:46,700
ngunit kapag nagpatakbo ka ng programa, may isang bagay na nauugnay, tulad ng

1048
01:04:46,700 --> 01:04:49,550
ito ay ang username ng tao na tumakbo sa programa.

1049
01:04:49,550 --> 01:04:51,550
At na uri ng sa ibaba.

1050
01:04:51,550 --> 01:04:54,540
Sa mga tuntunin ng mga address ng memorya, na hexadecimal halaga,

1051
01:04:54,540 --> 01:04:58,170
ang mga halaga sa tuktok simula sa 0, at sila ay pumunta sa lahat ng mga paraan pababa sa ilalim.

1052
01:04:58,170 --> 01:05:00,440
Sa kasong ito, kung ikaw ay sa 32-bit na sistema,

1053
01:05:00,440 --> 01:05:05,390
ang address sa ibaba ay magiging 0x, sinusundan ng af, dahil na 32 bit,

1054
01:05:05,390 --> 01:05:10,890
na 8 bytes, at sa kasong ito 8 bytes tumutugma sa 8 digit hexadecimal.

1055
01:05:10,890 --> 01:05:20,110
Kaya down na dito ka na magkaroon, i, 0xffffff, at hanggang doon ka pagpunta sa mayroon kang 0.

1056
01:05:20,110 --> 01:05:23,660
Kaya ano ang payo? Ang ilan sa inyo ay maaaring sakop ito sa seksyon bago.

1057
01:05:23,660 --> 01:05:26,660
ngunit kami ay pumunta sa paglipas ng ito sa panayam, kaya isang pointer ay isang uri ng data

1058
01:05:26,660 --> 01:05:34,030
kung aling mga tindahan, sa halip ng ilang mga uri ng halaga tulad ng 50, nag-iimbak ang address ng ilang mga lokasyon sa memorya.

1059
01:05:34,030 --> 01:05:36,020
Tulad na memory [hindi maintindihan].

1060
01:05:36,020 --> 01:05:41,120
Kaya sa kasong ito, kung ano ang namin ay, mayroon kaming isang pointer sa isang integer o isang int *,

1061
01:05:41,120 --> 01:05:46,210
at naglalaman ito hexadecimal address ng 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Kaya kung ano ang mayroon kami, ngayon, ang mga ito ng mga puntos ng pointer sa ilang mga lokasyon sa memorya,

1063
01:05:50,880 --> 01:05:56,020
at na lamang, ang halaga 50 ay sa lokasyon na ito ng memorya.

1064
01:05:56,020 --> 01:06:01,810
Sa ilang mga 32-bit na system, sa lahat ng 32-bit system, payo tumagal ng hanggang 32 bit o 4 bytes.

1065
01:06:01,810 --> 01:06:06,020
Ngunit, halimbawa, sa isang 64-bit na sistema, mga payo 64 bit.

1066
01:06:06,020 --> 01:06:08,040
Kaya, na ang isang bagay na nanaisin mong tandaan.

1067
01:06:08,040 --> 01:06:12,310
Kaya sa isang end-bit na sistema, ang pointer ng pagtatapos bit mahaba.

1068
01:06:12,310 --> 01:06:17,320
Payo uri ng mahirap digest nang walang dagdag na mga bagay,

1069
01:06:17,320 --> 01:06:20,300
kaya sabihin pumunta sa pamamagitan ng isang halimbawa ng dynamic na paglalaan ng memory.

1070
01:06:20,300 --> 01:06:25,130
Ano dynamic na paglalaan ng memory ang para sa iyo, o kung ano ang tinatawag naming malloc,

1071
01:06:25,130 --> 01:06:29,280
ito ay nagbibigay-daan sa iyo upang magtalaga ng ilang mga uri ng data sa labas ng hanay.

1072
01:06:29,280 --> 01:06:31,830
Kaya ang data na ito ay uri ng mas permanenteng para sa tagal ng programa.

1073
01:06:31,830 --> 01:06:36,430
Dahil bilang alam mo, kung ikaw ay ipinapahayag ng mga x sa loob ng isang function, at ang function na babalik,

1074
01:06:36,430 --> 01:06:40,910
hindi ka na magkakaroon ng access sa data na naka-imbak sa x.

1075
01:06:40,910 --> 01:06:44,420
Ang payo ipaalam gawin sa amin ay ipaalam sa amin nila iimbak ang halaga ng memorya o tindahan

1076
01:06:44,420 --> 01:06:46,840
sa isang iba't ibang mga segment ng memory, lalo na ang magbunton.

1077
01:06:46,840 --> 01:06:49,340
Ngayon sabay-sabay namin bumalik ng function na, hangga't mayroon kami ng pointer

1078
01:06:49,340 --> 01:06:54,960
na lokasyon sa memorya, pagkatapos ay kung ano ang maaari naming gawin ay maaari naming lamang tingnan ang mga halaga sa doon.

1079
01:06:54,960 --> 01:06:58,020
Tingnan natin ang isang halimbawa: Ito ang aming memory layout muli.

1080
01:06:58,020 --> 01:07:00,050
At mayroon kaming ang function na ito, pangunahing.

1081
01:07:00,050 --> 01:07:06,870
Ano ang ginagawa nito - okay, kaya simpleng, i-right -? Int x = 5, na lamang sa isang variable sa stack sa pangunahing.

1082
01:07:06,870 --> 01:07:12,450
>> Sa kabilang banda, ngayon namin ipinapahayag ng pointer na tawag sa mga giveMeThreeInts function na.

1083
01:07:12,450 --> 01:07:16,800
At kaya namin ngayon pumunta sa function na ito at lumikha kami ng bagong stack frame para dito.

1084
01:07:16,800 --> 01:07:20,440
Gayunpaman, sa stack frame na ito, idedeklara namin int * Temp,

1085
01:07:20,440 --> 01:07:23,210
na mallocs 3 integer para sa amin.

1086
01:07:23,210 --> 01:07:25,880
Kaya ang laki ng int ay magbibigay sa amin kung gaano karaming mga byte int ito,

1087
01:07:25,880 --> 01:07:29,620
at nagbibigay sa amin ng malloc na maraming byte ng espasyo sa magbunton.

1088
01:07:29,620 --> 01:07:32,890
Kaya sa kasong ito, lumikha kami ng sapat na espasyo para sa 3 integer,

1089
01:07:32,890 --> 01:07:36,830
at magbunton ay paraan up doon, na kung bakit ko na iginuhit ito nang mas mataas na hanggang.

1090
01:07:36,830 --> 01:07:42,900
Sa sandaling tapos na kami, dumating kami back up dito, kailangan mo lamang 3 ints ibinalik,

1091
01:07:42,900 --> 01:07:47,000
at ito ay magbabalik ng mga address, sa kasong ito sa kung saan na ang memory.

1092
01:07:47,000 --> 01:07:51,250
At kami ng pointer = lumipat, at hanggang doon kami ay may isa lamang pointer.

1093
01:07:51,250 --> 01:07:54,550
Ngunit ano na ang mga function na babalik ay isinalansan dito at mawala.

1094
01:07:54,550 --> 01:07:59,250
Kaya Temp mawala, ngunit pinapanatili pa rin namin ang address kung saan

1095
01:07:59,250 --> 01:08:01,850
3 integer na iyon sa loob ng mains.

1096
01:08:01,850 --> 01:08:06,180
Kaya sa set na ito, ang mga payo scoped lokal para sa nakasalansan na frame,

1097
01:08:06,180 --> 01:08:09,860
ngunit ang memorya kung saan tumutukoy ang mga iyon sa magbunton.

1098
01:08:09,860 --> 01:08:12,190
>> Ba na magkaroon ng kahulugan?

1099
01:08:12,190 --> 01:08:14,960
[Mag-aaral] Puwede mong ulitin na? >> [Joseph] Oo.

1100
01:08:14,960 --> 01:08:20,270
Kaya kung pumunta ako pabalik ng kaunti lamang, makikita mo na ang Temp inilalaan

1101
01:08:20,270 --> 01:08:23,500
ilang memory sa magbunton doon.

1102
01:08:23,500 --> 01:08:28,680
Kaya kapag ang function na ito, giveMeThreeInts babalik, ito stack dito ay pagpunta sa mawala.

1103
01:08:28,680 --> 01:08:35,819
At sa ito sa anumang ng mga variable, sa kasong ito, ang pointer na inilalaan sa nakasalansan frame.

1104
01:08:35,819 --> 01:08:39,649
Na ay pagpunta sa mawala, ngunit dahil ibinalik namin Temp

1105
01:08:39,649 --> 01:08:46,330
at kami ng pointer = Temp, pointer sa ngayon upang ituro ang parehong memorya ng lokasyon bilang Temp ay.

1106
01:08:46,330 --> 01:08:50,370
Kaya ngayon, kahit na mawala namin ang Temp, na lokal na pointer,

1107
01:08:50,370 --> 01:08:59,109
mapanatili pa rin namin ang memory address ng kung ano ito ay nagtuturo sa loob ng pointer na variable.

1108
01:08:59,109 --> 01:09:03,740
Mga tanong? Na uri ng isang nakalilito paksa kung hindi mo pa nawala sa paglipas ng ito sa seksyon.

1109
01:09:03,740 --> 01:09:09,240
Maaari naming, ang iyong tf talagang pumunta sa paglipas ng ito at siyempre maaari naming sagutin ang mga katanungan

1110
01:09:09,240 --> 01:09:11,500
sa dulo ng review session para sa.

1111
01:09:11,500 --> 01:09:14,220
Ngunit ito ay uri ng isang kumplikadong paksa, at mayroon akong higit pang mga halimbawa na upang ipakita up

1112
01:09:14,220 --> 01:09:18,790
na makakatulong sa linawin kung ano ang mga payo aktwal ay.

1113
01:09:18,790 --> 01:09:22,500
>> Sa kasong ito, ang mga payo ay katumbas ng array,

1114
01:09:22,500 --> 01:09:25,229
sa gayon ay maaari ko lang gamitin ang pointer na ito bilang ang parehong bagay bilang isang int array.

1115
01:09:25,229 --> 01:09:29,840
Kaya ako pag-i-index sa 0, at pagbabago sa unang integer sa 1,

1116
01:09:29,840 --> 01:09:39,689
pagbabago ng pangalawang integer sa 2, at ang 3rd integer sa 3.

1117
01:09:39,689 --> 01:09:44,210
Kaya higit pa sa mga payo. Well, isipin ang Binky.

1118
01:09:44,210 --> 01:09:48,319
Sa kasong ito na inilalaan namin pointer ng, o ipinahayag namin ng pointer,

1119
01:09:48,319 --> 01:09:52,760
ngunit simula, kapag ko lang ipinahayag ng pointer, hindi ito na tumuturo sa kahit saan sa memorya.

1120
01:09:52,760 --> 01:09:54,930
Ito ay basura lamang ang mga halaga sa loob nito.

1121
01:09:54,930 --> 01:09:56,470
Kaya Mayroon akong walang ideya kung saan ang pointer ito ay tumuturo sa.

1122
01:09:56,470 --> 01:10:01,630
Ito ay may isang address na lang puno ng 0 at 1 kung saan simula ito ay ipinahayag.

1123
01:10:01,630 --> 01:10:04,810
Hindi ko maaaring gawin na ito hanggang tumawag ako malloc dito

1124
01:10:04,810 --> 01:10:08,390
at pagkatapos ay nagbibigay sa akin ang maliit na puwang sa magbunton kung saan Maaari ko bang ilagay ang halaga sa loob.

1125
01:10:08,390 --> 01:10:11,980
Pagkatapos muli, hindi ko alam kung ano ang sa loob ng memory na ito.

1126
01:10:11,980 --> 01:10:16,780
Kaya ang unang bagay na kailangan kong gawin ay suriin kung ang sistema ang may sapat na memorya

1127
01:10:16,780 --> 01:10:20,850
upang bigyan ako ng 1 integer sa unang lugar, na kung saan ay kung bakit ako ginagawa ito suriin.

1128
01:10:20,850 --> 01:10:25,020
Kung ang pointer ay null, na nangangahulugan na hindi ito sapat na espasyo o ilang iba pang mga naganap na error,

1129
01:10:25,020 --> 01:10:26,320
kaya dapat kong lumabas ng aking programa.

1130
01:10:26,320 --> 01:10:29,400
 Ngunit kung ito ay ginawa magtagumpay, ngayon ko gamitin na pointer

1131
01:10:29,400 --> 01:10:35,020
at kung ano ang * pointer ginagawa ito ay sumusunod kung saan ay ang address

1132
01:10:35,020 --> 01:10:38,480
sa kung saan ang halaga na hindi, at nagtatakda katumbas ng 1.

1133
01:10:38,480 --> 01:10:41,850
Kaya sa paglipas dito, Sinusuri namin kung ang memory na umiral.

1134
01:10:41,850 --> 01:10:45,380
>> Sandaling alam mo na umiiral na ito, maaari mong ilagay ito

1135
01:10:45,380 --> 01:10:50,460
kung ano ang halaga na nais mong ilagay ito, sa kasong ito 1.

1136
01:10:50,460 --> 01:10:53,060
Sa sandaling tapos na kami dito, kailangan mo upang magbakante na pointer

1137
01:10:53,060 --> 01:10:57,160
dahil kailangan namin upang makakuha muli ng system na memory na iyong hiniling para sa unang lugar.

1138
01:10:57,160 --> 01:10:59,690
Dahil ang computer ay hindi alam kapag tapos na kami dito.

1139
01:10:59,690 --> 01:11:02,510
Sa kasong ito tahasang sinasabi kami ay sa ito, okay, kami ay tapos na na memory.

1140
01:11:02,510 --> 01:11:10,780
Kung ang ilang iba pang mga proseso ay kailangang ito, ang ilang iba pang mga programa ay kailangang ito, huwag mag-atubiling upang magpatuloy at dalhin ito.

1141
01:11:10,780 --> 01:11:15,110
Ano ang maaari rin naming gawin ay maaari naming makuha ang address ng lokal na mga variable sa set.

1142
01:11:15,110 --> 01:11:19,080
Kaya int x sa loob ng nakasalansan frame ng pangunahing.

1143
01:11:19,080 --> 01:11:23,060
At kapag ginagamit namin ito ampersand, ito at operator, kung ano ang ginagawa nito ay

1144
01:11:23,060 --> 01:11:27,310
ito ay tumatagal ng x, at x lamang ang ilang mga data sa memory, ngunit ito ay may isang address.

1145
01:11:27,310 --> 01:11:33,790
Ito ay matatagpuan sa isang lugar. Ito sa pamamagitan ng pagtawag at x, kung ano ang ginagawa ng ito ay nagbibigay sa amin ang address ng x.

1146
01:11:33,790 --> 01:11:38,430
Sa pamamagitan ng paggawa nito, ginagawa namin pointer punto sa kung saan ang x ay sa memorya.

1147
01:11:38,430 --> 01:11:41,710
Ngayon lang namin ang isang bagay tulad ng * x, kami ay upang makakuha ng 5 likod.

1148
01:11:41,710 --> 01:11:43,820
Bituin ay tinatawag na dereferencing ito.

1149
01:11:43,820 --> 01:11:46,640
Sundin mo ang address at makakakuha ka ng ang halaga nito na nakaimbak doon.

1150
01:11:51,000 --> 01:11:53,310
>> Anumang mga katanungan? Oo?

1151
01:11:53,310 --> 01:11:56,500
[Mag-aaral] Kung hindi mo gawin ang 3-tulis na bagay, ay pa rin ito makatipon?

1152
01:11:56,500 --> 01:11:59,490
Oo. Kung hindi mo gawin ang 3-pointer bagay, pa rin ito upang makatipon,

1153
01:11:59,490 --> 01:12:02,720
ngunit kukunin ko na ipakita sa iyo kung ano ang mangyayari sa isang segundo, at nang hindi ginagawa na,

1154
01:12:02,720 --> 01:12:04,860
na kung ano ang tinatawag naming isang memory mahayag. Hindi mo pagbibigay ng system

1155
01:12:04,860 --> 01:12:07,850
-back ang memory nito, kaya matapos ang isang habang ang programa upang makaipon ng

1156
01:12:07,850 --> 01:12:10,940
memorya na hindi ito ginagamit, at walang sinuman ang maaaring gamitin ito.

1157
01:12:10,940 --> 01:12:15,750
Kung nakita mo ang Firefox na may 1.5 milyong kilobytes sa iyong computer,

1158
01:12:15,750 --> 01:12:17,840
sa tagapamahala ng gawain, na kung anong nangyayari sa.

1159
01:12:17,840 --> 01:12:20,760
Mayroon kang isang memory mahayag sa programa na hindi sila paghawak.

1160
01:12:23,080 --> 01:12:26,240
Kaya kung paano gumagana ang pointer ng aritmetika trabaho?

1161
01:12:26,240 --> 01:12:29,480
Well, aritmetika ng pointer ay uri ng tulad ng pag-i-index sa isang array.

1162
01:12:29,480 --> 01:12:36,370
Sa kasong ito, mayroon akong pointer, at kung ano ang gagawin ko ako makagawa ng pointer punto sa unang elemento

1163
01:12:36,370 --> 01:12:42,100
ng ang array na ito ng 3 integer na aking inilalaan.

1164
01:12:42,100 --> 01:12:46,670
Kaya ngayon kung ano ang gagawin ko, star pointer lang nagbabago sa unang elemento sa listahan.

1165
01:12:46,670 --> 01:12:49,140
Star pointer +1 puntos sa paglipas dito.

1166
01:12:49,140 --> 01:12:53,140
Kaya ang pointer ay sa paglipas dito, pointer +1 ay higit sa dito, pointer +2 sa paglipas dito.

1167
01:12:53,140 --> 01:12:56,610
>> Kaya lamang pagdaragdag ng 1 ay ang parehong bagay bilang gumagalaw sa kahabaan ng array na ito.

1168
01:12:56,610 --> 01:12:59,880
Ano ang ginagawa namin ay, kapag ginagawa namin pointer +1 sa makuha mo ang address sa paglipas dito,

1169
01:12:59,880 --> 01:13:04,180
at upang makuha ang halaga in dito, kang maglagay ng star sa mula sa buong expression

1170
01:13:04,180 --> 01:13:05,990
dereference ito.

1171
01:13:05,990 --> 01:13:09,940
Kaya, sa kasong ito, ako pagtatakda ng unang lokasyon sa array na ito sa 1,

1172
01:13:09,940 --> 01:13:13,970
pangalawang lokasyon sa 2, at ikatlong lokasyon sa 3.

1173
01:13:13,970 --> 01:13:18,180
Pagkatapos kung ano ang ako ginagawa sa paglipas dito ay ako ang pag-print ng aming pointer +1,

1174
01:13:18,180 --> 01:13:19,970
na nagbibigay sa akin lang 2.

1175
01:13:19,970 --> 01:13:23,650
Ngayon ako incrementing pointer, kaya pointer katumbas pointer +1,

1176
01:13:23,650 --> 01:13:26,780
na gumagalaw ito pasulong.

1177
01:13:26,780 --> 01:13:30,810
At kaya ngayon kung-print ko pointer +1, pointer +1 na ngayon ang 3,

1178
01:13:30,810 --> 01:13:33,990
kung saan sa kasong ito mga Kopya ang 3.

1179
01:13:33,990 --> 01:13:36,560
At upang libreng isang bagay, ang pointer na bigyan ko ito

1180
01:13:36,560 --> 01:13:40,540
ay dapat na tumuturo sa simula ng array na Nakatanggap ako mula sa malloc.

1181
01:13:40,540 --> 01:13:43,430
Kaya, sa kasong ito, kung ako ay upang tawagan ang 3 dito mismo, hindi ito magiging karapatan,

1182
01:13:43,430 --> 01:13:45,070
dahil ito sa gitna ng array.

1183
01:13:45,070 --> 01:13:48,820
Ko bang ibawas upang makakuha ng sa orihinal na lokasyon

1184
01:13:48,820 --> 01:13:50,420
paunang unang puwesto bago ko magbakante ito.

1185
01:13:56,300 --> 01:13:58,450
Kaya, narito ang isang mas kasangkot halimbawa.

1186
01:13:58,450 --> 01:14:03,360
Sa kasong ito, kami ay paglaan ng 7 character sa isang array ng character.

1187
01:14:03,360 --> 01:14:06,480
>> At sa kasong ito kung anong ginagawa namin ay namin ang looping sa ibabaw ng unang 6 sa kanila,

1188
01:14:06,480 --> 01:14:09,900
at kami ay pagtatakda ng mga ito sa Z.

1189
01:14:09,900 --> 01:14:13,350
Kaya, para sa int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Kaya, pointer + ay i lamang bigyan kami ng, sa kasong ito,

1191
01:14:16,220 --> 01:14:20,860
pointer, pointer +1, pointer +2, pointer +3, at iba pa at iba pa sa loop.

1192
01:14:20,860 --> 01:14:24,040
Ano ito gawin ay nakakakuha ng address na iyon, dereferences ito upang makuha ang halaga,

1193
01:14:24,040 --> 01:14:27,440
at mga pagbabago na halaga sa isang Z.

1194
01:14:27,440 --> 01:14:30,350
Pagkatapos sa dulo tandaan na ito ay isang string, i-right?

1195
01:14:30,350 --> 01:14:33,560
Ang lahat ng mga string ay may magtapos sa null pagwawakas ng character.

1196
01:14:33,560 --> 01:14:38,620
Kaya, kung ano ang gagawin ko sa pointer 6 ko bang ilagay ang null Terminator karakter.

1197
01:14:38,620 --> 01:14:43,980
At ngayon kung ano talaga ako ginagawa sa paglipas dito ay pagpapatupad ng printf para sa isang string, i-right?

1198
01:14:43,980 --> 01:14:46,190
>> Kaya, kapag ang printf ngayon kapag ito ay naabot ang dulo ng isang string?

1199
01:14:46,190 --> 01:14:48,230
Kapag pinindot niya ang null pagwawakas ng character.

1200
01:14:48,230 --> 01:14:52,030
Kaya, sa kasong ito, ang aking orihinal na pointer mga puntos sa simula ng array na ito.

1201
01:14:52,030 --> 01:14:56,410
-Print ko ang unang character out. Ilipat ko ito sa paglipas ng isa.

1202
01:14:56,410 --> 01:14:58,420
-Print ko na karakter out. Ko ilipat ito sa paglipas ng.

1203
01:14:58,420 --> 01:15:02,180
At patuloy ko ginagawa ito hanggang maabot ko ang katapusan.

1204
01:15:02,180 --> 01:15:07,750
At ngayon sa dulo ng pointer * dereference ito at makakuha null pagwawakas ng character.

1205
01:15:07,750 --> 01:15:11,780
At sa gayon ang aking loop habang tumatakbo lamang kapag ang halaga na hindi null pagwawakas ng character.

1206
01:15:11,780 --> 01:15:13,770
Kaya, ngayon ko lumabas sa labas ng loop na ito.

1207
01:15:18,780 --> 01:15:21,180
At kaya kung ko ibawas 6 mula sa pointer,

1208
01:15:21,180 --> 01:15:22,860
Pumunta ko bumalik ang lahat ng mga paraan sa simula.

1209
01:15:22,860 --> 01:15:27,880
Tandaan, ako ginagawa ito dahil mayroon akong pumunta sa simula upang magbakante ito.

1210
01:15:27,880 --> 01:15:30,270
>> Kaya, alam ko na ng maraming. Mayroon bang anumang mga katanungan?

1211
01:15:30,270 --> 01:15:31,870
Mangyaring, yes?

1212
01:15:31,870 --> 01:15:36,610
[Tanong hindi maunawaan Estudyante]

1213
01:15:36,610 --> 01:15:38,190
Maaari mong sabihin na louder? Sorry.

1214
01:15:38,190 --> 01:15:44,140
[Mag-aaral] Sa huling slide kanan bago napalaya mo ang pointer,

1215
01:15:44,140 --> 01:15:47,300
kung saan ang iyong aktwal na pagbabago sa halaga ng pointer?

1216
01:15:47,300 --> 01:15:50,370
[Joseph] Kaya, dito mismo. >> [Mag-aaral] Oh, okay.

1217
01:15:50,370 --> 01:15:51,890
[Joseph] Kaya, mayroon akong isang pointer minus minus, kanan,

1218
01:15:51,890 --> 01:15:54,140
na gumagalaw ang mga bagay sa likod ng isa, at pagkatapos magbakante ko ito,

1219
01:15:54,140 --> 01:15:57,000
dahil ang pointer na ito ay may tulis sa simula ng array.

1220
01:15:57,000 --> 01:16:00,420
[Mag-aaral] Ngunit iyon ay hindi na kailanganin ay huminto ka pagkatapos na linya.

1221
01:16:00,420 --> 01:16:03,130
[Joseph] Kaya, kung huminto ako pagkatapos nito, ito ay itinuturing na isang memory mahayag,

1222
01:16:03,130 --> 01:16:04,810
dahil hindi ko patakbuhin ang libreng.

1223
01:16:04,810 --> 01:16:11,290
[Mag-aaral] ko [hindi maintindihan] pagkatapos ng unang tatlong linya na kung saan mayroon kang ang pointer +1 [hindi maintindihan].

1224
01:16:11,290 --> 01:16:13,140
[Joseph] Uh-huh. Kaya, ano ang pinag-uusapan doon?

1225
01:16:13,140 --> 01:16:14,780
Sorry. Hindi, hindi. Pumunta, pumunta, mangyaring.

1226
01:16:14,780 --> 01:16:16,870
[Mag-aaral] Kaya, hindi mo binabago ang halaga ng mga payo.

1227
01:16:16,870 --> 01:16:19,130
Hindi mo ay nagkaroon upang gawin ang pointer minus minus.

1228
01:16:19,130 --> 01:16:19,730
[Joseph] Oo, eksakto.

1229
01:16:19,730 --> 01:16:21,890
Kaya, kapag gagawin ko ang pointer +1 at pointer +2,

1230
01:16:21,890 --> 01:16:24,410
Hindi ako ginagawa pointer katumbas pointer +1.

1231
01:16:24,410 --> 01:16:27,260
Kaya, ang pointer lamang ang pananatili na tumuturo sa simula ng array.

1232
01:16:27,260 --> 01:16:31,460
Lamang ito kapag gagawin ko plus plus na ito ay nagtatakda ng halaga pabalik sa loob ng pointer,

1233
01:16:31,460 --> 01:16:33,550
na ito ay aktwal na gumagalaw ito sa kahabaan ng.

1234
01:16:36,860 --> 01:16:37,780
Ayos lang.

1235
01:16:40,550 --> 01:16:42,030
Higit pang mga tanong?

1236
01:16:44,680 --> 01:16:47,790
>> Muli, kung ito ay uri ng napakatinding, ito ay sakop sa session.

1237
01:16:47,790 --> 01:16:50,710
Tanungin ang iyong kapwa ng pagtuturo tungkol dito, at maaari naming sagutin ang mga tanong sa dulo.

1238
01:16:53,510 --> 01:16:56,600
At karaniwang hindi namin bang gawin ito minus bagay.

1239
01:16:56,600 --> 01:16:59,760
Na ito ay nangangailangan sa akin pagpapanatiling track kung magkano ko na offset sa array.

1240
01:16:59,760 --> 01:17:04,520
Kaya, sa pangkalahatan, ito ay lamang sa kung paano gumagana ang pointer aritmetika.

1241
01:17:04,520 --> 01:17:07,970
Ngunit kung ano ang gusto namin karaniwang gawin ay gusto namin upang lumikha ng isang kopya ng pointer,

1242
01:17:07,970 --> 01:17:11,640
at pagkatapos ay gagamitin namin na kopya kapag kami ay gumagalaw sa paligid sa string.

1243
01:17:11,640 --> 01:17:14,660
Kaya, sa mga kaso gumamit ka ng kopya upang i-print ang buong string,

1244
01:17:14,660 --> 01:17:19,040
ngunit hindi namin na gawin tulad ng pointer minus 6 o subaybayan kung magkano namin inilipat sa,

1245
01:17:19,040 --> 01:17:22,700
dahil lang alam namin na ang aming orihinal na punto ay pa rin tulis sa simula ng listahan

1246
01:17:22,700 --> 01:17:25,340
at ang lahat na namin binago ang kopya na ito.

1247
01:17:25,340 --> 01:17:28,250
Kaya, sa pangkalahatan, baguhin ang mga kopya ng iyong orihinal na pointer.

1248
01:17:28,250 --> 01:17:32,350
Huwag subukan upang pag-uri-uriin ng tulad - don't baguhin ang orihinal na kopya.

1249
01:17:32,350 --> 01:17:35,290
Sinusubukang upang baguhin lamang ang mga kopya ng iyong orihinal na.

1250
01:17:41,540 --> 01:17:44,870
Kaya, napansin mo kapag pumasa namin ang string sa printf

1251
01:17:44,870 --> 01:17:48,990
hindi mo na kailangang maglagay ng star sa harap ng mga ito tulad ng ginawa namin sa lahat ng iba pang dereferences, i-right?

1252
01:17:48,990 --> 01:17:54,180
Kaya, kung print ka buong string% s inaasahan ng isang address,

1253
01:17:54,180 --> 01:17:57,610
at sa kasong ito ng isang pointer o sa kasong ito tulad ng isang array ng mga character.

1254
01:17:57,610 --> 01:18:00,330
>> Character, magpasinda * s, at array ay ang parehong bagay.

1255
01:18:00,330 --> 01:18:03,690
Pointer ay ang mga character, at character na array ang mga parehong bagay.

1256
01:18:03,690 --> 01:18:05,720
At iba pa, ang lahat kami ay may sa gawin ay pumasa sa pointer.

1257
01:18:05,720 --> 01:18:08,150
Hindi namin upang pumasa sa tulad ng * pointer o anumang bagay tulad na.

1258
01:18:13,110 --> 01:18:14,930
Kaya, ang mga array at pointer ang mga parehong bagay.

1259
01:18:14,930 --> 01:18:19,160
Kapag ikaw ay paggawa ng isang bagay tulad ng x [y] sa paglipas dito para sa isang array,

1260
01:18:19,160 --> 01:18:21,960
kung ano ang ginagawa sa ilalim ng hood ito sinasabi, okay, ito ay isang character array,

1261
01:18:21,960 --> 01:18:23,690
kaya ang isang pointer.

1262
01:18:23,690 --> 01:18:26,510
At kaya x ang mga parehong bagay,

1263
01:18:26,510 --> 01:18:28,650
at kaya kung ano ang ginagawa nito ay nagdadagdag ito y sa x,

1264
01:18:28,650 --> 01:18:31,820
kung saan ay ang parehong bagay bilang sumusulong sa memory na mas.

1265
01:18:31,820 --> 01:18:34,930
At ngayon x + y ay nagbibigay sa amin ng ilang mga uri ng address,

1266
01:18:34,930 --> 01:18:37,570
at dereference namin ang address o sundin ang mga arrow

1267
01:18:37,570 --> 01:18:41,640
kung saan na lokasyon sa memorya at makuha namin ang halaga ng na lokasyon sa memorya.

1268
01:18:41,640 --> 01:18:43,720
Kaya, kaya dalawang mga eksaktong parehong bagay.

1269
01:18:43,720 --> 01:18:45,840
Lamang sintaktik asukal.

1270
01:18:45,840 --> 01:18:48,090
Ginagawa nila ang parehong bagay. Lang nila ibang syntactics para sa bawat isa.

1271
01:18:51,500 --> 01:18:57,590
>> Kaya, kung ano ang maaaring magkamali sa mga payo? Tulad, ng maraming. Okay. Kaya, ang masamang bagay.

1272
01:18:57,590 --> 01:19:02,410
Ang ilang mga masamang mga bagay na maaari mong gawin ay hindi-check kung ang iyong malloc tawag nagbabalik null, i-right?

1273
01:19:02,410 --> 01:19:06,560
Sa kasong ito, ako na humihiling ang sistema upang bigyan ako - kung ano ang number na?

1274
01:19:06,560 --> 01:19:11,200
Tulad 2 bilyong beses 4, dahil ang laki ng isang integer 4 bytes.

1275
01:19:11,200 --> 01:19:13,810
Ako humihingi ang mga ito para sa tulad ng 8 bilyong bytes.

1276
01:19:13,810 --> 01:19:17,270
Siyempre ang aking computer ay hindi ninyo ako na magkano likod ng memory.

1277
01:19:17,270 --> 01:19:20,960
At hindi namin ginawa suriin kung ito ay null, kaya kapag sinubukan namin sa dereference ito banda roon -

1278
01:19:20,960 --> 01:19:24,270
sundin ang mga arrow sa kung saan ito ay pagpunta sa - hindi namin na memorya.

1279
01:19:24,270 --> 01:19:27,150
Ito ay kung ano ang tinatawag naming dereferencing null pointer.

1280
01:19:27,150 --> 01:19:29,710
At ito nagiging sanhi ng mahalagang mong segfault.

1281
01:19:29,710 --> 01:19:31,790
Ito ay isa sa mga paraan na maaari mong segfault.

1282
01:19:34,090 --> 01:19:38,090
Iba pang masamang mga bagay na maaari mong gawin - oh din.

1283
01:19:38,090 --> 01:19:40,650
Na dereferencing null pointer. Okay.

1284
01:19:40,650 --> 01:19:45,160
Iba pang mga masamang - na rin, upang ayusin mo lamang maglagay ng check doon

1285
01:19:45,160 --> 01:19:46,980
na sumusuri kung ang pointer sa ay null

1286
01:19:46,980 --> 01:19:51,000
at lumabas ng programa kung ito ang mangyayari malloc na nagbabalik ng isang null pointer.

1287
01:19:55,110 --> 01:19:59,850
Iyon ang xkcd comic. Mga tao na maunawaan ito ngayon. -Uri-uriin ng.

1288
01:20:06,120 --> 01:20:09,350
>> Kaya, memory. At nagpunta ako sa paglipas ng ito.

1289
01:20:09,350 --> 01:20:12,000
Pagtawag malloc kami sa isang loop, ngunit ang bawat oras na tinatawag naming malloc

1290
01:20:12,000 --> 01:20:14,370
namin ay mawala ang track kung saan ang pointer ito ay tumuturo sa,

1291
01:20:14,370 --> 01:20:15,750
dahil kami ay clobbering ito.

1292
01:20:15,750 --> 01:20:18,410
Kaya, ang unang tawag sa malloc ay nagbibigay sa akin memory sa paglipas dito.

1293
01:20:18,410 --> 01:20:19,990
Aking pointer pointer na ito.

1294
01:20:19,990 --> 01:20:23,020
Ngayon, hindi ko magbakante ito, kaya ngayon Tinatawag kong malloc muli.

1295
01:20:23,020 --> 01:20:26,070
Ngayon ito POINTS sa paglipas dito. Ngayon ang aking memorya ay pagturo sa paglipas dito.

1296
01:20:26,070 --> 01:20:27,640
Pagturo sa paglipas dito. Pagturo sa paglipas dito.

1297
01:20:27,640 --> 01:20:31,820
Ngunit nawala ko ang track ng address ng lahat ng memory sa dito na ko inilalaan.

1298
01:20:31,820 --> 01:20:35,100
At ito ngayon hindi ko kailangang anumang reference sa kanila na ito.

1299
01:20:35,100 --> 01:20:37,230
Kaya, hindi ko magbakante mga ito sa labas ng loop na ito.

1300
01:20:37,230 --> 01:20:39,390
At iba pa upang ayusin ang isang bagay tulad nito,

1301
01:20:39,390 --> 01:20:42,250
kung nakalimutan mo ang libreng memorya at makakakuha ka ng memory mahayag na ito,

1302
01:20:42,250 --> 01:20:45,810
Mayroon kang upang magbakante ang memory sa loob ng loop na ito sa sandaling tapos ka na dito.

1303
01:20:45,810 --> 01:20:51,400
Well, ito ay kung ano ang mangyayari. Alam ko maraming mo mapoot ito.

1304
01:20:51,400 --> 01:20:55,270
Ngunit ngayon - Yay! Nakukuha mong tulad ng 44,000 kilobytes.

1305
01:20:55,270 --> 01:20:57,110
Kaya, magbakante mo ito sa dulo ng loop,

1306
01:20:57,110 --> 01:20:59,770
at na magbakante lang ang memory sa bawat oras.

1307
01:20:59,770 --> 01:21:03,620
Mahalaga, ang iyong programa ay hindi magkaroon ng isang memory mahayag ito.

1308
01:21:03,620 --> 01:21:08,150
>> At ngayon ibang bagay na maaari mong gawin ay magbakante ilang memory na hiniling mo para sa dalawang beses.

1309
01:21:08,150 --> 01:21:11,060
Sa kasong ito, malloc isang bagay, baguhin mo ang halaga nito.

1310
01:21:11,060 --> 01:21:13,140
Magbakante mong ito sabay-sabay dahil sinabi mo ikaw ay tapos na gamit ito.

1311
01:21:13,140 --> 01:21:14,940
Ngunit pagkatapos namin napalaya itong muli.

1312
01:21:14,940 --> 01:21:16,730
Ito ay isang bagay na medyo masamang.

1313
01:21:16,730 --> 01:21:18,820
Hindi ito simula segfault,

1314
01:21:18,820 --> 01:21:23,350
ngunit matapos ang isang habang kung ano ito ay ay double pagbabakante ito corrupts iyong magbunton istraktura,

1315
01:21:23,350 --> 01:21:27,200
at matutunan mo ng kaunti ang nalalaman tungkol sa kung pinili mo ang isang klase tulad ng CS61.

1316
01:21:27,200 --> 01:21:30,000
Ngunit mahalagang matapos ang isang habang ang iyong computer ay pagpunta upang nalilito

1317
01:21:30,000 --> 01:21:33,010
tungkol sa kung ano ang memory lokasyon kung saan at kung saan naka-imbak ito -

1318
01:21:33,010 --> 01:21:34,800
kung saan ang data ay naka-imbak sa memorya.

1319
01:21:34,800 --> 01:21:38,080
At kaya pagbabakante isang pointer nang dalawang beses ay isang masamang bagay na hindi mo nais na gawin.

1320
01:21:38,080 --> 01:21:41,600
>> Iba pang mga bagay na maaaring magkamali ay hindi gumagamit ng sizeof.

1321
01:21:41,600 --> 01:21:44,460
Kaya, sa kasong ito malloc kang 8 bytes,

1322
01:21:44,460 --> 01:21:46,700
at na ang parehong bagay bilang dalawang integer, i-right?

1323
01:21:46,700 --> 01:21:49,580
Kaya, perpektong ligtas, ngunit ito?

1324
01:21:49,580 --> 01:21:52,160
Well, bilang Lucas uusapang tungkol sa iba't ibang mga architectures,

1325
01:21:52,160 --> 01:21:54,220
integer ay ng iba't-ibang haba.

1326
01:21:54,220 --> 01:21:57,970
Kaya, sa appliance na ginagamit mo, integer 4 bytes,

1327
01:21:57,970 --> 01:22:02,370
ngunit sa ilang iba pang mga system sila na 8 bytes o maaaring sila ay 16 bytes.

1328
01:22:02,370 --> 01:22:05,680
Kaya, kung ko lang gamitin ang numerong ito sa paglipas dito,

1329
01:22:05,680 --> 01:22:07,310
Ang program na ito ay maaaring gumana sa appliance,

1330
01:22:07,310 --> 01:22:10,360
ngunit hindi ito upang maglaan ng sapat na memorya sa ilang iba pang mga sistema.

1331
01:22:10,360 --> 01:22:14,020
Sa kasong ito, ito ay kung ano ang sizeof operator ay ginagamit para sa.

1332
01:22:14,020 --> 01:22:16,880
Kapag tinatawag naming sizeof (int), kung ano ang ginagawa ay

1333
01:22:16,880 --> 01:22:21,910
 ito ay nagbibigay sa amin ang laki ng isang integer sa system na programa ay tumatakbo.

1334
01:22:21,910 --> 01:22:25,490
Kaya, sa kasong ito, sizeof (int) ay magbabalik 4 sa isang bagay tulad ng appliance,

1335
01:22:25,490 --> 01:22:29,980
at ngayon ito kalooban 4 * 2, na kung saan ay 8,

1336
01:22:29,980 --> 01:22:32,330
na ang halaga ng puwang na kinakailangan para sa dalawang integer.

1337
01:22:32,330 --> 01:22:36,710
Sa ibang system, kung ang isang int tulad ng 16 bytes o 8 bytes,

1338
01:22:36,710 --> 01:22:39,380
lamang ito upang bumalik sapat byte-imbak na halaga.

1339
01:22:41,830 --> 01:22:45,310
>> At sa wakas, structs.

1340
01:22:45,310 --> 01:22:48,340
Kaya, kung gusto mo upang mag-imbak ng sudoku board sa memory, kung paano namin gawin ito?

1341
01:22:48,340 --> 01:22:51,570
Maaari mong isipin na tulad ng isang variable para sa unang bagay na,

1342
01:22:51,570 --> 01:22:53,820
isang variable para sa ikalawang bagay, sa isang variable para sa ikatlong bagay,

1343
01:22:53,820 --> 01:22:56,420
isang variable para sa ika-apat na bagay - masamang, i-right?

1344
01:22:56,420 --> 01:23:00,750
Kaya, ang isang pagpapabuti na maaari kang magsagawa ng sa itaas ng ay upang makagawa ng isang 9 x 9 array.

1345
01:23:00,750 --> 01:23:04,480
Iyon ay pinong, ngunit kung ano kung nais mong iugnay ang iba pang mga bagay sa sudoku board

1346
01:23:04,480 --> 01:23:06,490
bang kung ano ang kahirapan ng board,

1347
01:23:06,490 --> 01:23:11,740
o, halimbawa, kung ano ang iyong iskor ay, o kung gaano karaming oras na ito kinuha sa iyo upang malutas ang board na ito?

1348
01:23:11,740 --> 01:23:14,970
Well, kung ano ang maaari mong gawin ay maaari kang lumikha ng isang struct.

1349
01:23:14,970 --> 01:23:18,910
Ano talaga ako sinasabi ng pagtukoy ako istrakturang ito sa paglipas dito,

1350
01:23:18,910 --> 01:23:23,230
at ako ng pagtukoy sa isang sudoku board na binubuo ng isang board na 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> At kung ano ang mayroon itong mga ito ay may mga payo sa pangalan ng antas.

1352
01:23:26,650 --> 01:23:30,730
Mayroon din itong x at y, kung saan ang mga coordinate kung nasaan ako ngayon.

1353
01:23:30,730 --> 01:23:35,980
Din ito ay oras na ginugol [hindi maintindihan], at ito ay ang kabuuang bilang ng mga gumagalaw na ko na inputted sa ngayon.

1354
01:23:35,980 --> 01:23:40,010
At kaya sa kasong ito, maaari ko grupo ng isang buong grupo ng mga data sa isang istraktura lamang

1355
01:23:40,010 --> 01:23:42,790
sa halip ng pagkakaroon ng ito tulad ng lumilipad sa paligid tulad ng ibang mga variable

1356
01:23:42,790 --> 01:23:44,540
na hindi talaga ako makapag-subaybayan ng.

1357
01:23:44,540 --> 01:23:49,720
At ito ay nagbibigay-daan sa amin lang magaling syntax para sa uri ng tumutukoy sa iba't ibang bagay sa loob ng struct na ito.

1358
01:23:49,720 --> 01:23:53,430
Maaari ko lamang gawin board.board, at nakukuha ko ang sudoku board sa likod.

1359
01:23:53,430 --> 01:23:56,320
Board.level, nakukuha ko kung paano matigas ito ay.

1360
01:23:56,320 --> 01:24:00,540
Board.x at board.y magbigay sa akin ang mga coordinate ng kung saan maaari ko sa board.

1361
01:24:00,540 --> 01:24:04,730
At kaya ako-access sa kung ano ang tinatawag naming mga patlang sa struct.

1362
01:24:04,730 --> 01:24:08,840
Ito ay tumutukoy sudokuBoard, na kung saan ay isang uri na mayroon akong.

1363
01:24:08,840 --> 01:24:14,800
At ngayon kami dito. Mayroon akong isang variable na tinatawag na "board" ng uri sudokuBoard.

1364
01:24:14,800 --> 01:24:18,820
At kaya ngayon ko ma-access ang lahat ng mga field na bumubuo istrakturang ito sa paglipas dito.

1365
01:24:20,830 --> 01:24:22,450
>> Anumang mga katanungan tungkol sa mga structs? Oo?

1366
01:24:22,450 --> 01:24:25,890
[Mag-aaral] Para sa int x, y, ipinahayag mo pareho sa isang linya? >> [Joseph] Uh-huh.

1367
01:24:25,890 --> 01:24:27,400
[Mag-aaral] Kaya, maaari mo lamang gawin iyon sa lahat ng mga ito?

1368
01:24:27,400 --> 01:24:31,200
Gusto sa x, y mga kuwit beses na kabuuang?

1369
01:24:31,200 --> 01:24:34,460
[Joseph] Oo, maaari mong tiyak gawin iyon, ngunit ang dahilan ko bang ilagay x at y sa parehong linya -

1370
01:24:34,460 --> 01:24:36,330
at ang tanong ay kung bakit maaari naming lamang gawin ito sa parehong linya?

1371
01:24:36,330 --> 01:24:38,600
Bakit hindi namin lamang ilagay ang lahat ng mga ito sa parehong linya ay

1372
01:24:38,600 --> 01:24:42,090
x at y ay may kaugnayan sa bawat isa,

1373
01:24:42,090 --> 01:24:44,780
at ito lamang ang stylistically mas tama, sa isang kahulugan,

1374
01:24:44,780 --> 01:24:46,600
dahil ito pagpangkat dalawang bagay sa parehong linya

1375
01:24:46,600 --> 01:24:49,340
na tulad ng uri ng nauugnay sa parehong bagay.

1376
01:24:49,340 --> 01:24:51,440
At ko lang hatiin ang mga bukod. Ito ay lamang ng isang bagay ng estilo.

1377
01:24:51,440 --> 01:24:53,720
Mayroon pagtakbo ay hindi gumagawa ng mga pagkakaiba sa kung ano pa man.

1378
01:24:58,150 --> 01:24:59,270
Anumang iba pang mga tanong sa mga structs?

1379
01:25:03,030 --> 01:25:06,620
Maaari mong tukuyin ang isang Pokédex na may struct.

1380
01:25:06,620 --> 01:25:11,720
Isang Pokémon ay may numero at ito ay isang sulat, isang may-ari, isang uri.

1381
01:25:11,720 --> 01:25:16,990
At pagkatapos ay kung mayroon kang isang array ng Pokémon, maaari kang gumawa ng isang Pokédex, i-right?

1382
01:25:16,990 --> 01:25:20,810
Okay, cool. Kaya, ang mga tanong sa mga structs. Yaong ay may kaugnayan sa structs.

1383
01:25:20,810 --> 01:25:25,270
>> Panghuli, GDB. Ano ang ginagawa ng ng GDB hayaan mong gawin? Ay nagbibigay-daan sa iyo upang i-debug ang iyong programa.

1384
01:25:25,270 --> 01:25:27,650
At kung hindi mo pa ginagamit GDB, Gusto ko inirerekomenda nanonood ng maikling

1385
01:25:27,650 --> 01:25:31,250
at pagpunta sa kung ano ang GDB ay, kung paano gumagana ang dito, kung paano mo maaaring gamitin ito,

1386
01:25:31,250 --> 01:25:32,900
at subukan ito sa isang programa.

1387
01:25:32,900 --> 01:25:37,400
At kaya kung ano ang GDB ay nagbibigay-daan sa gawin mo ito ay nagbibigay-daan sa i-pause ang [hindi maintindihan] up sa programa ng iyong

1388
01:25:37,400 --> 01:25:38,920
at praktikal na linya.

1389
01:25:38,920 --> 01:25:42,600
Halimbawa, gusto kong i-pause ang pagpapatupad sa tulad ng linya 3 ng aking mga programa,

1390
01:25:42,600 --> 01:25:46,010
at habang ako sa linya 3 ang maaari kong i-print ang lahat ng mga halaga na doon.

1391
01:25:46,010 --> 01:25:49,710
At kaya kung ano ang tinatawag naming tulad ng pag-pause sa isang linya

1392
01:25:49,710 --> 01:25:52,350
ay namin tumawag ito ng paglalagay ng breakpoint sa linya na

1393
01:25:52,350 --> 01:25:55,920
at pagkatapos ay maaari naming i-print ang mga variable sa estado ng programa sa oras na iyon.

1394
01:25:55,920 --> 01:25:58,990
>> Maaari naming pagkatapos ay mula doon hakbang sa pamamagitan ng programa ng line-by-line.

1395
01:25:58,990 --> 01:26:03,200
At pagkatapos ay maaari naming tingnan ang estado ng stack sa oras.

1396
01:26:03,200 --> 01:26:08,600
At ito upang gamitin ang GDB, ano ang ginagawa namin kami tatawag kumalatong sa file C,

1397
01:26:08,600 --> 01:26:11,290
ngunit mayroon kaming upang pumasa ito sa-ggdb bandila.

1398
01:26:11,290 --> 01:26:15,850
At sa sandaling tapos na kami na namin lamang patakbuhin ang gdb sa resultang output file.

1399
01:26:15,850 --> 01:26:18,810
At kaya makakakuha ka ng ilang mga tulad ng masa ng teksto tulad nito,

1400
01:26:18,810 --> 01:26:21,990
ngunit talagang lahat ng kailangan mong gawin ay i-type sa mga utos sa simula.

1401
01:26:21,990 --> 01:26:24,250
Masira pangunahing naglalagay ng breakpoint sa pangunahing.

1402
01:26:24,250 --> 01:26:28,470
Listahan ng 400 ay naglilista ng mga linya ng code sa buong line 400.

1403
01:26:28,470 --> 01:26:31,410
At kaya sa kasong ito ay maaaring mo lamang tumingin sa paligid at sabihin, oh,

1404
01:26:31,410 --> 01:26:34,360
Gusto kong mag-set ng breakpoint sa linya 397, na ang linyang ito,

1405
01:26:34,360 --> 01:26:37,170
at pagkatapos ay tumatakbo ang iyong programa sa hakbang na iyon at ito ay pagpunta sa masira.

1406
01:26:37,170 --> 01:26:41,120
Ito ay pagpunta sa i-pause doon, at maaari mong i-print, halimbawa, ang halaga ng mababa o mataas.

1407
01:26:41,120 --> 01:26:46,410
At kaya may mga ng grupo ng mga utos na kailangan mong malaman,

1408
01:26:46,410 --> 01:26:48,660
at ang slideshow na ito ay pumunta sa website,

1409
01:26:48,660 --> 01:26:54,000
kaya kung gusto mo lang na banggitin ang mga ito o bang ilagay ang mga ito sa iyong mga impostor sheet, huwag mag-atubiling.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. Na Quiz Suriin ang 0, at kami na dumikit sa paligid kung mayroon kang anumang mga katanungan.

1411
01:27:00,650 --> 01:27:03,850
Ayos lang.

1412
01:27:03,850 --> 01:27:09,030
>>  [Palakpakan]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]