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

2
00:00:03,000 --> 00:00:05,000
>> [Lexi Ross, Tommy MacWilliam, Lucas Freitas, Jāzeps Ong] [Hārvarda]

3
00:00:05,000 --> 00:00:08,000
>> [Tas ir CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Hei, visi.

5
00:00:10,000 --> 00:00:15,000
Laipni uz pārskata sesiju 0 viktorīnā, kas notiek šo trešdien.

6
00:00:15,000 --> 00:00:19,000
Ko mēs darīsim šovakar, es esmu ar 3 citiem TFS,

7
00:00:19,000 --> 00:00:24,000
un kopā mēs gatavojamies iet cauri pārskatu par to, ko mēs esam darījuši gaitā līdz šim.

8
00:00:24,000 --> 00:00:27,000
Tas nav būs 100% pilnīgs, bet tas būtu jums labāku priekšstatu

9
00:00:27,000 --> 00:00:31,000
ko jums jau ir uz leju, un to, kas jums joprojām ir nepieciešams mācīties, pirms trešdien.

10
00:00:31,000 --> 00:00:34,000
Un justies brīvi, lai palielinātu savu roku ar jautājumiem, kā mēs ejam kopā,

11
00:00:34,000 --> 00:00:38,000
bet paturiet prātā, ka mums būs arī mazliet laika beigās-

12
00:00:38,000 --> 00:00:41,000
ja mēs pārdzīvosim ar dažām minūtēm, lai rezerves, lai do vispārīgus jautājumus,

13
00:00:41,000 --> 00:00:47,000
lai saglabātu, ka prātā, un tāpēc mēs esam gatavojas sākt sākumā ar 0 Week.

14
00:00:47,000 --> 00:00:50,000
>> [Viktorīna 0 Review!] [Daļa 0] [Lexi Ross] Taču, pirms mēs, pieņemsim runāt par

15
00:00:50,000 --> 00:00:53,000
loģistiku viktorīnas.

16
00:00:53,000 --> 00:00:55,000
>> [Loģistika] [Viktorīna notiek trešdien 10/10 vietā lekciju]

17
00:00:55,000 --> 00:00:57,000
>> [(Skatīt http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf sīkāku informāciju)] Tas ir par trešdiena 10 oktobris.

18
00:00:57,000 --> 00:01:00,000
>> Tas ir šo trešdien, un, ja jūs iet uz šo URL šeit,

19
00:01:00,000 --> 00:01:03,000
kas ir pieejams arī no CS50.net-tur ir saite uz to,

20
00:01:03,000 --> 00:01:06,000
Jūs varat redzēt informāciju par to, kur doties, pamatojoties uz

21
00:01:06,000 --> 00:01:10,000
Jūsu uzvārds vai skolas piederībai, kā arī

22
00:01:10,000 --> 00:01:14,000
tā stāsta par to, kādi viktorīna segs un par jautājumiem, veidiem, ka jūs gatavojas saņemt.

23
00:01:14,000 --> 00:01:19,000
Paturiet prātā, ka jums ir arī iespēja pārskatīt uz viktorīnu sadaļā,

24
00:01:19,000 --> 00:01:21,000
lai jūsu TFS būtu iet pa dažiem prakses problēmām,

25
00:01:21,000 --> 00:01:29,000
un tas ir vēl viens labs iespēja redzēt, kur jums joprojām ir nepieciešams mācīties izveidota viktorīnas.

26
00:01:29,000 --> 00:01:32,000
Sāksim sākumā ar biti 'n' baitiem.

27
00:01:32,000 --> 00:01:35,000
Atcerieties bits ir tikai 0 vai 1,

28
00:01:35,000 --> 00:01:38,000
un baits ir kolekcija 8 no šiem bitiem.

29
00:01:38,000 --> 00:01:42,000
Apskatīsim šo kolekciju bitiem šeit.

30
00:01:42,000 --> 00:01:44,000
Mums jāspēj izrēķināt, cik bitus tur ir.

31
00:01:44,000 --> 00:01:48,000
Kur mēs paļaujamies tur ir tikai 8 no tiem, astoņas 0 vai 1 vienības.

32
00:01:48,000 --> 00:01:51,000
Un tā kā tur ir 8 biti, kas ir 1 baits,

33
00:01:51,000 --> 00:01:53,000
un pieņemsim pārvērst to heksadecimālo.

34
00:01:53,000 --> 00:01:58,000
Heksadecimālais ir bāze 16, un tas ir diezgan viegli pārveidot

35
00:01:58,000 --> 00:02:01,000
binārā skaits, kas ir tas, kas ir uz vairākiem heksadecimālā.

36
00:02:01,000 --> 00:02:04,000
Viss, kas mums jādara, ir aplūkojam grupām 4,

37
00:02:04,000 --> 00:02:07,000
un mēs pārvērst tos uz atbilstošu heksadecimālo cipara.

38
00:02:07,000 --> 00:02:11,000
Mēs sākam ar labo visvairāk grupā 4, tāpēc 0011.

39
00:02:11,000 --> 00:02:16,000
Tas būs viens 1 un vienu 2, lai kopā, kas padara 3.

40
00:02:16,000 --> 00:02:19,000
Un tad pieņemsim apskatīt citu bloku gada 4.

41
00:02:19,000 --> 00:02:24,000
1101. Tas būs viens 1, viena 4, un viens 8.

42
00:02:24,000 --> 00:02:28,000
Kopā, ka būs 13, kas padara D.

43
00:02:28,000 --> 00:02:32,000
Un mēs atcerēties, ka heksadecimālā mēs ne tikai iet no 0 līdz 9.

44
00:02:32,000 --> 00:02:36,000
Mēs iet no 0 līdz F, lai pēc 9, 10, atbilst,

45
00:02:36,000 --> 00:02:40,000
11 B, uc kur F ir 15.

46
00:02:40,000 --> 00:02:44,000
Šeit 13 ir D,

47
00:02:44,000 --> 00:02:49,000
tāpēc, lai pārvērstu to par decimālu visi mēs darām, ir mēs patiesībā

48
00:02:49,000 --> 00:02:52,000
ārstēt katru pozīciju jauda 2.

49
00:02:52,000 --> 00:02:58,000
Tas ir viens 1, vienu 2, nulle 4s, nulle 8s, viens 16, un tā tālāk,

50
00:02:58,000 --> 00:03:03,000
un tas ir mazliet grūti aprēķināt jūsu galvas, bet, ja mēs ejam uz nākamo slaidu

51
00:03:03,000 --> 00:03:05,000
mēs varam redzēt atbildi uz to.

52
00:03:05,000 --> 00:03:09,000
>> Būtībā mēs ejam pretī tiesības atpakaļ uz kreiso,

53
00:03:09,000 --> 00:03:14,000
un mēs reizinot katra cipara ar attiecīgo jaudu gada 2.

54
00:03:14,000 --> 00:03:19,000
Un atcerieties, lai heksadecimālā mēs apzīmētu šos skaitļus ar 0x sākumā

55
00:03:19,000 --> 00:03:23,000
tāpēc mēs nejauciet to ar decimālskaitlis.

56
00:03:23,000 --> 00:03:29,000
Turpinot par, tas ir ASCII tabulā,

57
00:03:29,000 --> 00:03:35,000
un ko mēs izmantojam ASCII lai ir kartēt no burtiem, lai skaitliskās vērtības.

58
00:03:35,000 --> 00:03:39,000
Atceros kriptogrāfijas PSET mēs plaši izmanto ASCII tabulā

59
00:03:39,000 --> 00:03:43,000
Lai izmantotu dažādas metodes kriptogrāfija,

60
00:03:43,000 --> 00:03:47,000
Cēzars un Vigenère šifra, lai pārvērstu dažādus burtus

61
00:03:47,000 --> 00:03:52,000
virknē Saskaņā ar atslēgu, ko lietotājs.

62
00:03:52,000 --> 00:03:56,000
Apskatīsim mazliet ASCII math.

63
00:03:56,000 --> 00:04:02,000
Aplūkojot "P" + 1, jo raksturs formā, kas būtu Q,

64
00:04:02,000 --> 00:04:07,000
un atcerēties, ka 5 "≠ 5.

65
00:04:07,000 --> 00:04:10,000
Un kā tieši tas mums konvertēt starp šiem 2 veidu?

66
00:04:10,000 --> 00:04:13,000
Tas nav reāli pārāk grūti.

67
00:04:13,000 --> 00:04:16,000
Lai iegūtu 5 mēs atņemt '0 '

68
00:04:16,000 --> 00:04:20,000
jo ir 5 vietas starp šobrīd '0 'un '5. "

69
00:04:20,000 --> 00:04:23,000
Lai iet citu ceļu, mēs vienkārši pievienojiet 0,

70
00:04:23,000 --> 00:04:25,000
tāpēc tas ir sava veida, piemēram regulāri aritmētisko.

71
00:04:25,000 --> 00:04:29,000
Tikai atceraties, ka tad, kad kaut kas ir pēdiņas ap to, tas ir raksturs

72
00:04:29,000 --> 00:04:37,000
un tādējādi atbilst vērtību ASCII tabulu.

73
00:04:37,000 --> 00:04:40,000
Pārcelšanās uz vispārīgākiem datorzinātņu tēmām.

74
00:04:40,000 --> 00:04:43,000
Mēs uzzinājām kāda algoritms ir un kā mēs izmantojam programmēšana

75
00:04:43,000 --> 00:04:45,000
lai īstenotu algoritmiem.

76
00:04:45,000 --> 00:04:48,000
Daži algoritmu piemēri ir kaut kas patiešām vienkāršs, piemēram,

77
00:04:48,000 --> 00:04:51,000
pārbaudīt, vai skaitlis ir pāra vai nepāra.

78
00:04:51,000 --> 00:04:54,000
Par to atceros, mēs mod skaitu ar 2 un pārbaudīt, ja rezultāts ir 0.

79
00:04:54,000 --> 00:04:57,000
Ja tā, tas ir pat. Ja tā nav, tas ir dīvaini.

80
00:04:57,000 --> 00:04:59,000
Un tas ir piemērs patiešām pamata algoritms.

81
00:04:59,000 --> 00:05:02,000
>> Mazliet vairāk iesaistīts viens ir binārs meklēt,

82
00:05:02,000 --> 00:05:05,000
kas mēs iet pār vēlāk pārskatīšanas sesijā.

83
00:05:05,000 --> 00:05:09,000
Un programmēšana ir termins, mēs izmantojam, lai veiktu algoritmu

84
00:05:09,000 --> 00:05:15,000
un pārveidojot to kodu datoru var lasīt.

85
00:05:15,000 --> 00:05:20,000
2 piemēri par plānošanas Scratch,

86
00:05:20,000 --> 00:05:22,000
kas ir tas, ko mēs darījām 0 nedēļa.

87
00:05:22,000 --> 00:05:25,000
Pat ja mums nav reāli tipa no kodu tas veids, kā īstenot

88
00:05:25,000 --> 00:05:29,000
Šis algoritms, kas drukāšanas skaitļi 1-10,

89
00:05:29,000 --> 00:05:32,000
un šeit mēs to pašu C programmēšanas valodu.

90
00:05:32,000 --> 00:05:41,000
Tie ir funkcionāli līdzvērtīgi, vienkārši rakstīts dažādās valodās vai sintakse.

91
00:05:41,000 --> 00:05:44,000
Mēs tad uzzināja par boolean izteiksmes,

92
00:05:44,000 --> 00:05:48,000
un Būla ir vērtība, kas ir vai nu patiess vai nepatiess,

93
00:05:48,000 --> 00:05:51,000
un šeit nereti Būla izteiksmes

94
00:05:51,000 --> 00:05:55,000
iet iekšā nosacījumu, tādēļ, ja (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
labi, mēs jau noteikti x = 5, tāpēc šis nosacījums ir gatavojas novērtēt taisnība.

96
00:06:00,000 --> 00:06:03,000
Un, ja tā ir taisnība, neatkarīgi kods ir zem nosacījuma

97
00:06:03,000 --> 00:06:08,000
būs jānovērtē ar datoru, lai virkne būs jādrukā

98
00:06:08,000 --> 00:06:12,000
standarta produkciju, un termiņu stāvokli

99
00:06:12,000 --> 00:06:16,000
attiecas uz visu, kas iekšpusē no IF iekavās.

100
00:06:16,000 --> 00:06:20,000
Atcerēties visus uzņēmējus.

101
00:06:20,000 --> 00:06:26,000
Atcerieties, tas ir && un | | kad mēs cenšamies apvienot 2 vai vairāk nosacījumus,

102
00:06:26,000 --> 00:06:30,000
== Nevis = pārbaudīt, vai 2 lietas ir vienādi.

103
00:06:30,000 --> 00:06:36,000
Atcerieties, ka = ir ieskaitīšanai tā == ir Būla operators.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ un tad gala 2 ir pašsaprotami.

105
00:06:41,000 --> 00:06:45,000
Vispārējs pārskats par Būla loģika šeit.

106
00:06:45,000 --> 00:06:48,000
Un Būla izteiksmes ir svarīgi arī cilpas,

107
00:06:48,000 --> 00:06:50,000
kas mēs iet pār tagad.

108
00:06:50,000 --> 00:06:56,000
Mēs mācījāmies par 3 veidu cilpas līdz šim CS50, lai, savukārt, un darīt savukārt.

109
00:06:56,000 --> 00:06:59,000
Un tas ir svarīgi zināt, ka, kamēr vairumam vajadzībām

110
00:06:59,000 --> 00:07:02,000
mēs faktiski var izmantot jebkura veida cilpas kopumā

111
00:07:02,000 --> 00:07:06,000
ir daži veidi, mērķiem vai kopējām tendencēm

112
00:07:06,000 --> 00:07:09,000
programmēšanā, kas īpaši aicinām uz vienu no šiem cilpas

113
00:07:09,000 --> 00:07:13,000
kas padara to par visefektīvāko vai elegants ar kodu tieši tā.

114
00:07:13,000 --> 00:07:18,000
Iesim pa to, ko katrs no šiem cilpas mēdz izmantot visbiežāk.

115
00:07:18,000 --> 00:07:21,000
>> Jo lai cilpa mēs parasti jau zinām, cik reizes mēs vēlamies atkārtot.

116
00:07:21,000 --> 00:07:24,000
Tas, ko mēs ieliekam stāvoklī.

117
00:07:24,000 --> 00:07:28,000
Jo, i = 0, i <10, piemēram.

118
00:07:28,000 --> 00:07:31,000
Mēs jau zinām, ka mēs vēlamies kaut ko darīt 10 reizes.

119
00:07:31,000 --> 00:07:34,000
Tagad, par kamēr cilpa, parasti mēs ne vienmēr

120
00:07:34,000 --> 00:07:36,000
zināt, cik reizes mēs vēlamies cilpa palaist.

121
00:07:36,000 --> 00:07:39,000
Bet mēs zinām kaut kādas nosacījumu, ka mēs gribam, lai

122
00:07:39,000 --> 00:07:41,000
vienmēr būs taisnība, vai vienmēr būt nepatiesa.

123
00:07:41,000 --> 00:07:44,000
Piemēram, lai gan ir noteikts.

124
00:07:44,000 --> 00:07:46,000
Pieņemsim, ka ir Būla mainīgs.

125
00:07:46,000 --> 00:07:48,000
Bet tā ir taisnība, mēs vēlamies kodu novērtēt,

126
00:07:48,000 --> 00:07:52,000
tāpēc mazliet vairāk paplašināmas, nedaudz plašāks nekā uz cilpas,

127
00:07:52,000 --> 00:07:55,000
bet jebkura cilpa var arī pārvērst par kamēr cilpa.

128
00:07:55,000 --> 00:08:00,000
Visbeidzot, darīt, kamēr cilpas, kas var būt visgrūtākais, lai saprastu uzreiz,

129
00:08:00,000 --> 00:08:04,000
bieži lieto, ja mēs gribam, lai novērtētu kodu Pirmkārt

130
00:08:04,000 --> 00:08:06,000
Pirms pirmo reizi mēs pārbaudīt stāvokli.

131
00:08:06,000 --> 00:08:09,000
Kopējā izmantošanas gadījumā darīt, kamēr cilpa

132
00:08:09,000 --> 00:08:12,000
ir, kad jūs vēlaties, lai saņemtu lietotāja ievadi, un jūs zināt, ko vēlaties uzdot lietotājam

133
00:08:12,000 --> 00:08:15,000
par ieguldījumu vismaz vienu reizi, bet, ja tie nav sniegt jums labu ieguldījumu uzreiz

134
00:08:15,000 --> 00:08:18,000
Jūs vēlaties, lai saglabātu lūdzot tos, līdz tie dod jums labu ievadi.

135
00:08:18,000 --> 00:08:21,000
Tas ir visbiežāk izmanto do kamēr cilpa,

136
00:08:21,000 --> 00:08:23,000
un pieņemsim apskatīt faktisko struktūru šo cilpas.

137
00:08:23,000 --> 00:08:27,000
Viņi parasti vienmēr ir tendence sekot šiem modeļiem.

138
00:08:27,000 --> 00:08:30,000
>> Par priekšlikumu cilpa iekšā jums ir 3 sastāvdaļas:

139
00:08:30,000 --> 00:08:35,000
inicializācijas, parasti kaut kā int i = 0, ja i ir skaitītājs,

140
00:08:35,000 --> 00:08:40,000
nosacījumu, ja mēs vēlamies pateikt palaist šo par cilpa, kamēr šis nosacījums joprojām pieder,

141
00:08:40,000 --> 00:08:44,000
Tāpat kā es <10, un tad beidzot, atjauninājumu, kas ir kā mēs pieauguma

142
00:08:44,000 --> 00:08:47,000
skaitītājs mainīgais katrā brīdī cilpa.

143
00:08:47,000 --> 00:08:50,000
Kopīga lieta, lai redzētu, ka ir tikai i + +,

144
00:08:50,000 --> 00:08:52,000
kas nozīmē pieauguma i 1 katru reizi.

145
00:08:52,000 --> 00:08:55,000
Jūs arī varētu darīt kaut kas līdzīgs i + = 2,

146
00:08:55,000 --> 00:08:58,000
kas nozīmē pievieno 2 līdz i katru reizi, kad iet caur cilpu.

147
00:08:58,000 --> 00:09:03,000
Un tad izdarīt tikai attiecas uz jebkuru kodu, kas faktiski darbojas kā daļa no cilpas.

148
00:09:03,000 --> 00:09:09,000
Un, kamēr cilpa, šoreiz mums tiešām ir inicializācijas ārpus cilpas,

149
00:09:09,000 --> 00:09:12,000
tā, piemēram, teiksim, mēs cenšamies darīt to pašu veida cilpas, kā es tikko aprakstīts.

150
00:09:12,000 --> 00:09:16,000
Mēs varētu teikt int i = 0 līdz cilpa sākuma.

151
00:09:16,000 --> 00:09:20,000
Tad mēs varētu teikt, bet es <10 darīt,

152
00:09:20,000 --> 00:09:22,000
tā pati bloku kods kā līdz šim,

153
00:09:22,000 --> 00:09:26,000
un šoreiz atjauninājums daļa no koda, piemēram, i + +,

154
00:09:26,000 --> 00:09:29,000
faktiski iet iekšā no cilpas.

155
00:09:29,000 --> 00:09:33,000
Un visbeidzot, lai darīt, bet, tas ir līdzīgs kamēr cilpa,

156
00:09:33,000 --> 00:09:36,000
bet mums ir jāatceras, ka kods būs novērtēt, kad

157
00:09:36,000 --> 00:09:40,000
pirms stāvoklis tiek pārbaudīts, tāpēc tas padara daudz nozīmē

158
00:09:40,000 --> 00:09:44,000
ja paskatās uz to, lai no augšas uz apakšu.

159
00:09:44,000 --> 00:09:49,000
Jo darīt, kamēr cilpa kodu izvērtē pirms Jūs pat apskatīt kamēr stāvoklī,

160
00:09:49,000 --> 00:09:55,000
tā kā kamēr cilpa, tā pārbauda pirmais.

161
00:09:55,000 --> 00:09:59,000
Paziņojumus un mainīgie.

162
00:09:59,000 --> 00:10:04,000
Ja mēs vēlamies, lai izveidotu jaunu mainīgo mēs vispirms vēlamies, lai sāktu to.

163
00:10:04,000 --> 00:10:07,000
>> Piemēram, int bārs inicializē mainīgo joslu,

164
00:10:07,000 --> 00:10:10,000
bet tas nav arī tā vērtību, lai kāda ir bāra vērtība tagad?

165
00:10:10,000 --> 00:10:12,000
Mēs nezinām.

166
00:10:12,000 --> 00:10:14,000
Tas varētu būt daži atkritumu vērtība, kas bija agrāk glabā atmiņā tur,

167
00:10:14,000 --> 00:10:16,000
un mēs negribam, lai izmantotu šo mainīgo

168
00:10:16,000 --> 00:10:19,000
kamēr mēs patiesībā arī tā vērtību,

169
00:10:19,000 --> 00:10:21,000
tāpēc mēs paziņojam to šeit.

170
00:10:21,000 --> 00:10:24,000
Tad mēs sāktu, lai to tālāk norādīto 42.

171
00:10:24,000 --> 00:10:28,000
Tagad, protams, mēs zinām to var izdarīt vienā rindā, int bārs = 42.

172
00:10:28,000 --> 00:10:30,000
Bet tikai, lai nodzēstu vairākas darbības, kas notiek,

173
00:10:30,000 --> 00:10:34,000
deklarācija un inicializācijas ir notiek atsevišķi šeit.

174
00:10:34,000 --> 00:10:38,000
Tas notiek uz vienu soli, un nākamais, int baz = bar + 1,

175
00:10:38,000 --> 00:10:44,000
Šis apgalvojums zemāk, ka pieaugumu baz, tāpēc beigās šo kodu bloku

176
00:10:44,000 --> 00:10:48,000
ja mēs drukāt vērtību Baz tas bija 44

177
00:10:48,000 --> 00:10:52,000
jo mēs atzīt un sāktu to par 1> bārs,

178
00:10:52,000 --> 00:10:58,000
un tad mēs pieauguma to vēlreiz ar + +.

179
00:10:58,000 --> 00:11:02,000
Mēs devāmies pār šo diezgan īsi, bet tas ir labi, ka vispārējā

180
00:11:02,000 --> 00:11:04,000
izpratne par to, ko diegi un notikumi ir.

181
00:11:04,000 --> 00:11:06,000
Mēs galvenokārt darīja to nulles,

182
00:11:06,000 --> 00:11:09,000
lai jūs varētu domāt par diegiem kā daudzas sekvences kodu

183
00:11:09,000 --> 00:11:11,000
darbojas tajā pašā laikā.

184
00:11:11,000 --> 00:11:14,000
In aktualitāte, tas, iespējams, nedarbojas tajā pašā laikā,

185
00:11:14,000 --> 00:11:17,000
bet veida abstrakti mēs varam domāt par to šādā veidā.

186
00:11:17,000 --> 00:11:20,000
>> Nokasāmajās Piemēram, mums bija vairākas sprites.

187
00:11:20,000 --> 00:11:22,000
Tas varētu būt izpildes citu kodu tajā pašā laikā.

188
00:11:22,000 --> 00:11:26,000
Varētu būt iešana, bet otrs saka kaut

189
00:11:26,000 --> 00:11:29,000
citā daļā no ekrāna.

190
00:11:29,000 --> 00:11:34,000
Notikumi ir vēl viens veids, nošķirot to loģiku

191
00:11:34,000 --> 00:11:37,000
dažādo elementu savu kodu,

192
00:11:37,000 --> 00:11:40,000
un nulles, mēs varējām simulēt notikumus, izmantojot raidījuma

193
00:11:40,000 --> 00:11:43,000
un tas ir patiesībā, kad es saņemšu, nevis tad, kad es dzirdēt,

194
00:11:43,000 --> 00:11:47,000
bet būtībā tas ir veids, lai pārraidītu informāciju

195
00:11:47,000 --> 00:11:49,000
no vienas Sprite uz otru.

196
00:11:49,000 --> 00:11:52,000
Piemēram, jūs varat nosūtīt spēli vairāk,

197
00:11:52,000 --> 00:11:56,000
un kad cits elfa saņem spēli vairāk,

198
00:11:56,000 --> 00:11:58,000
tas reaģē noteiktā veidā.

199
00:11:58,000 --> 00:12:03,000
Tas svarīgi modeli, lai saprastu par programmēšanu.

200
00:12:03,000 --> 00:12:07,000
Tikai iet pār pamata nedēļā 0, ko mēs esam izgājuši vairāk nekā līdz šim,

201
00:12:07,000 --> 00:12:10,000
aplūkosim šo vienkāršo C programmu.

202
00:12:10,000 --> 00:12:14,000
Teksts var būt mazliet maza no šejienes, bet es iešu pār to tiešām ātri.

203
00:12:14,000 --> 00:12:20,000
Mēs esam skaitā 2 header failus augšā, cs50.h un stdio.h.

204
00:12:20,000 --> 00:12:23,000
Mēs tad nosakot konstantu sauc robežu, ir 100.

205
00:12:23,000 --> 00:12:26,000
Mēs esam tam īstenotu mūsu galveno funkciju.

206
00:12:26,000 --> 00:12:29,000
Tā kā mēs neizmantojam komandrindas argumentus šeit mums ir nepieciešams īstenot tukšumu

207
00:12:29,000 --> 00:12:32,000
kā par galveno argumentu.

208
00:12:32,000 --> 00:12:38,000
Mēs redzam int iepriekš galvenais. Tas ir atgriešanās tips, tātad atgriezties 0 apakšā.

209
00:12:38,000 --> 00:12:41,000
Un mēs esam izmantojot CS50 bibliotēkas funkciju iegūt int

210
00:12:41,000 --> 00:12:45,000
pieprasīt no lietotāja ievadi, un mēs saglabājam to šajā mainīgā x,

211
00:12:45,000 --> 00:12:51,000
tāpēc mēs paziņojam x iepriekš, un mēs sāktu to ar x = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> Mēs pēc tam pārbaudiet, ja lietotājs deva mums labu ieguldījumu.

213
00:12:53,000 --> 00:12:59,000
Ja tas ir ≥ LIMIT mēs vēlamies atgriezties kļūdas kodu 1 un izdrukāt kļūdas ziņojumu.

214
00:12:59,000 --> 00:13:02,000
Un, visbeidzot, ja lietotājs ir devis mums labs ieguldījums

215
00:13:02,000 --> 00:13:08,000
mēs ejam uz kvadrātveida numuru un izdrukāt šo rezultātu.

216
00:13:08,000 --> 00:13:11,000
Tikai, lai pārliecinātos, ka tie visi hit mājās

217
00:13:11,000 --> 00:13:17,000
Jūs varat redzēt etiķetes dažādām kodu šeit.

218
00:13:17,000 --> 00:13:19,000
Es teicu konstante, header failus.

219
00:13:19,000 --> 00:13:21,000
Ak, int x. Pārliecinieties atcerēties, ka ir vietējais mainīgs.

220
00:13:21,000 --> 00:13:24,000
Kas kontrastē no globālā mainīgā, ko mēs runājam par

221
00:13:24,000 --> 00:13:27,000
nedaudz vēlāk pārskata sesijā,

222
00:13:27,000 --> 00:13:30,000
un mēs aicinām bibliotēkas funkciju printf,

223
00:13:30,000 --> 00:13:34,000
tāpēc, ja mēs nebūtu iekļauta stdio.h header failu

224
00:13:34,000 --> 00:13:37,000
mēs nevarētu zvanīt printf.

225
00:13:37,000 --> 00:13:42,000
Un es uzskatu, ka bulta, kas ieguva nogrieza šeit ir vērsta uz% d,

226
00:13:42,000 --> 00:13:45,000
kas ir formatēšanas virknes printf.

227
00:13:45,000 --> 00:13:52,000
Tajā teikts izdrukāt šo mainīgo kā numuru,% d.

228
00:13:52,000 --> 00:13:58,000
Un tas ir tas par 0 Week.

229
00:13:58,000 --> 00:14:06,000
Tagad Lucas gatavojas turpināt.

230
00:14:06,000 --> 00:14:08,000
Hei, puiši. Mans vārds ir Lucas.

231
00:14:08,000 --> 00:14:10,000
Es esmu sophomore kas vislabāk māja Campus, Mather,

232
00:14:10,000 --> 00:14:14,000
un es esmu gatavojas runāt mazliet par Nedēļu 1 līdz 2,1.

233
00:14:14,000 --> 00:14:16,000
[Nedēļu 1 un 2.1!] [Lucas Freitas]

234
00:14:16,000 --> 00:14:19,000
Kā Lexi teica, kad mēs sākām tulkojot savu kodu no nulles līdz C

235
00:14:19,000 --> 00:14:23,000
viena no lietām, ko mēs pamanījuši, ka jūs varat ne tikai

236
00:14:23,000 --> 00:14:26,000
rakstīt savu kodu un palaist to, izmantojot zaļo karogu vairs.

237
00:14:26,000 --> 00:14:30,000
Patiesībā, jums ir izmantot dažus pasākumus, lai padarītu jūsu C programmu

238
00:14:30,000 --> 00:14:33,000
kļūt izpildāmo failu.

239
00:14:33,000 --> 00:14:36,000
Būtībā tas, ko jūs darāt, kad jūs esat rakstiski programma ir, ka

240
00:14:36,000 --> 00:14:40,000
Jums tulkot savu ideju valodā ka kompilators var saprast,

241
00:14:40,000 --> 00:14:44,000
tāpēc, ja jūs esat rakstiski programmu C

242
00:14:44,000 --> 00:14:47,000
ko jūs darāt, ir faktiski rakstot kaut kas jūsu kompilators gatavojas saprast,

243
00:14:47,000 --> 00:14:50,000
un tad kompilators gatavojas tulkot šo kodu

244
00:14:50,000 --> 00:14:53,000
kaut ka jūsu dators sapratīs.

245
00:14:53,000 --> 00:14:55,000
>> Un lieta ir, dators ir tiešām ļoti muļķīgi.

246
00:14:55,000 --> 00:14:57,000
Dators var tikai saprast 0s un 1s,

247
00:14:57,000 --> 00:15:01,000
tāpēc faktiski pirmo datoru cilvēki parasti ieprogrammēta

248
00:15:01,000 --> 00:15:04,000
izmantojot 0s un 1s, bet ne vairs, paldies Dievam.

249
00:15:04,000 --> 00:15:07,000
Mums nav nepieciešams iegaumēt secību par 0s un 1s

250
00:15:07,000 --> 00:15:10,000
par cilpa vai par kamēr cilpa un tā tālāk.

251
00:15:10,000 --> 00:15:13,000
Tieši tāpēc mums ir kompilatoru.

252
00:15:13,000 --> 00:15:17,000
Kas kompilators tas ir tas būtībā pārveido C kodu,

253
00:15:17,000 --> 00:15:21,000
mūsu gadījumā, uz valodu, ka jūsu dators sapratīs,

254
00:15:21,000 --> 00:15:25,000
kas ir objekta kodu, un kompilators ka mēs esam izmantojot

255
00:15:25,000 --> 00:15:30,000
sauc šķindoņa, tāpēc tas ir faktiski simbols šķindēt.

256
00:15:30,000 --> 00:15:33,000
Ja jums ir jūsu programma, kas Jums jādara 2 lietas.

257
00:15:33,000 --> 00:15:37,000
Pirmkārt, jums ir apkopot savu programmu, un tad jūs gatavojas palaist savu programmu.

258
00:15:37,000 --> 00:15:41,000
Sastādīt savu programmu jums ir daudz iespējas to darīt.

259
00:15:41,000 --> 00:15:44,000
Pirmais ir jādara šķindēt program.c

260
00:15:44,000 --> 00:15:47,000
kurā programma ir nosaukums jūsu programmā.

261
00:15:47,000 --> 00:15:51,000
Šajā gadījumā jūs varat redzēt, ka viņi vienkārši pasakot "Hei, sastādīt savu programmu."

262
00:15:51,000 --> 00:15:56,000
Tu neesi sakot: "Es vēlos šo nosaukumu manā programmā" vai neko.

263
00:15:56,000 --> 00:15:58,000
>> Otrais variants dod nosaukumu ar savu programmu.

264
00:15:58,000 --> 00:16:02,000
Jūs varat teikt šķindoņa-o un tad vārds, kas jūs vēlaties

265
00:16:02,000 --> 00:16:06,000
izpildāmo failu, kas nosaukts kā un pēc tam program.c.

266
00:16:06,000 --> 00:16:11,000
Un jūs varat arī darīt veikt programmu, un redzēt, kā pirmajās 2 gadījumos

267
00:16:11,000 --> 00:16:15,000
Man C,. Un trešais man ir tikai programmas?

268
00:16:15,000 --> 00:16:18,000
Jā, jūs faktiski nav jākļūst c kad lietojat darīt..

269
00:16:18,000 --> 00:16:22,000
Citādi kompilators ir faktiski gatavojas kliegt pie jums.

270
00:16:22,000 --> 00:16:24,000
Un arī, es nezinu, ja jūs guys atcerēties,

271
00:16:24,000 --> 00:16:29,000
bet daudz reižu mēs arī izmanto-lcs50 vai-LM.

272
00:16:29,000 --> 00:16:31,000
Ka sauc savieno.

273
00:16:31,000 --> 00:16:35,000
Tas tikai stāsta kompilators, ka jūs izmantot šīs bibliotēkas labi tur,

274
00:16:35,000 --> 00:16:39,000
tādēļ, ja jūs vēlaties izmantot cs50.h jūs faktiski ir rakstīt

275
00:16:39,000 --> 00:16:43,000
šķindoņa program.c-lcs50.

276
00:16:43,000 --> 00:16:45,000
Ja jums nav darīt, kompilators nav gatavojas zināt

277
00:16:45,000 --> 00:16:50,000
ka jūs izmantojat šos funkcijas cs50.h.

278
00:16:50,000 --> 00:16:52,000
Un, kad jūs vēlaties, lai palaistu savu programmu, jums ir 2 iespējas.

279
00:16:52,000 --> 00:16:57,000
Ja jūs šķindēt program.c jums nav dot nosaukumu ar savu programmu.

280
00:16:57,000 --> 00:17:01,000
Jums ir palaist to izmantojot. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out ir standarta vārds, kas šķindēt dod savu programmu, ja jums nav arī tā nosaukumu.

282
00:17:06,000 --> 00:17:11,000
Pretējā gadījumā jūs gatavojas darīt. / Programmu, ja jums deva vārdu ar savu programmu,

283
00:17:11,000 --> 00:17:15,000
un arī tad, ja jūs padarīt programmas nosaukumu, programma ir gatavojas iegūt

284
00:17:15,000 --> 00:17:23,000
jau būs ieprogrammēts tāds pats nosaukums kā C failu.

285
00:17:23,000 --> 00:17:26,000
Tad mēs runājām par datu tipiem un datu.

286
00:17:26,000 --> 00:17:31,000
>> Būtībā datu veidi ir tas pats, kas maz kastes viņi izmanto

287
00:17:31,000 --> 00:17:35,000
uzglabāt vērtības, tāpēc datu tipi ir faktiski tāpat kā Pokémons.

288
00:17:35,000 --> 00:17:39,000
Tās ir visās izmēru un veidu.

289
00:17:39,000 --> 00:17:43,000
Es nezinu, ja tas analoģija ir jēga.

290
00:17:43,000 --> 00:17:46,000
Datu apjoms faktiski ir atkarīga no mašīnas arhitektūru.

291
00:17:46,000 --> 00:17:49,000
Visi dati izmēri, ka es esmu gatavojas parādīs šeit

292
00:17:49,000 --> 00:17:53,000
ir faktiski par 32 bitu mašīna, kas ir gadījums mūsu ierīces,

293
00:17:53,000 --> 00:17:56,000
bet, ja jūs faktiski kodēšanas jūsu Mac vai Windows arī

294
00:17:56,000 --> 00:17:59,000
iespējams, jums nāksies 64 bitu mašīna,

295
00:17:59,000 --> 00:18:03,000
tāpēc atcerieties, ka datu izmēri, ka es esmu gatavojas parādīs šeit

296
00:18:03,000 --> 00:18:06,000
ir par 32-bitu mašīna.

297
00:18:06,000 --> 00:18:08,000
Pirmais, ko mēs redzējām, bija int,

298
00:18:08,000 --> 00:18:10,000
kas ir diezgan vienkārši.

299
00:18:10,000 --> 00:18:13,000
Jūs varat izmantot int uzglabāt skaitlim.

300
00:18:13,000 --> 00:18:16,000
Mēs redzējām arī raksturs, tad char.

301
00:18:16,000 --> 00:18:20,000
Ja jūs vēlaties izmantot burtu vai maz simbolu jūs, iespējams, gatavojas izmantot char.

302
00:18:20,000 --> 00:18:26,000
CHAR ir 1 baits, kas nozīmē 8 bitiem, piemēram, Lexi teica.

303
00:18:26,000 --> 00:18:31,000
Būtībā mums ir ASCII tabula, kas ir 256

304
00:18:31,000 --> 00:18:34,000
iespējamās kombinācijas 0s un 1s,

305
00:18:34,000 --> 00:18:37,000
un tad, kad jūs tipa char tas notiek tulkot

306
00:18:37,000 --> 00:18:44,000
raksturu, kas ieejas jūs skaitlis, kas jums ir ASCII tabulā, tāpat Lexi teica.

307
00:18:44,000 --> 00:18:48,000
Mums ir arī peldēt, ko mēs izmantojam, lai uzglabātu decimāldaļu skaitu.

308
00:18:48,000 --> 00:18:53,000
Ja jūs vēlaties, lai izvēlētos 3,14, piemēram, jūs gatavojas izmantot, apgrozāmos

309
00:18:53,000 --> 00:18:55,000
vai dubultā, kas ir lielāka precizitāte.

310
00:18:55,000 --> 00:18:57,000
Pludiņš ir 4 baiti.

311
00:18:57,000 --> 00:19:01,000
Dubultā ir 8 baiti, tāpēc vienīgā atšķirība ir precizitāte.

312
00:19:01,000 --> 00:19:04,000
Mums ir arī sen, kas tiek izmantots skaitļu,

313
00:19:04,000 --> 00:19:09,000
un jūs varat redzēt uz 32-bitu mašīna int un sen ir vienāda izmēra,

314
00:19:09,000 --> 00:19:13,000
tāpēc nav īsti jēgas lietot ilgi 32-bitu mašīna.

315
00:19:13,000 --> 00:19:17,000
>> Bet, ja jūs izmantojat Mac un 64 bitu mašīna, faktiski sen ir izmērs 8,

316
00:19:17,000 --> 00:19:19,000
tā tas tiešām ir atkarīgs no arhitektūru.

317
00:19:19,000 --> 00:19:22,000
Par 32-bitu mašīna tā nav jēgas lietot ilgi tiešām.

318
00:19:22,000 --> 00:19:25,000
Un tad ilgi ilgi, no otras puses, ir 8 baiti,

319
00:19:25,000 --> 00:19:30,000
tāpēc ir ļoti labi, ja jūs vēlaties, lai ir garāks skaitlim.

320
00:19:30,000 --> 00:19:34,000
Un visbeidzot, mums ir virkne, kas ir faktiski char *,

321
00:19:34,000 --> 00:19:37,000
kas ir rādītājs uz char.

322
00:19:37,000 --> 00:19:40,000
Tas ir ļoti viegli domāt, ka virknes lielums būs līdzīgi

323
00:19:40,000 --> 00:19:42,000
rakstzīmju skaitu, kas jums ir tur,

324
00:19:42,000 --> 00:19:45,000
bet patiesībā char * pati

325
00:19:45,000 --> 00:19:49,000
ir lielums rādītājs uz char, kas ir 4 baiti.

326
00:19:49,000 --> 00:19:52,000
No char * izmērs ir 4 baiti.

327
00:19:52,000 --> 00:19:56,000
Tas nav svarīgi, ja jums ir neliela vārdu vai vēstuli vai neko.

328
00:19:56,000 --> 00:19:58,000
Tas būs 4 baiti.

329
00:19:58,000 --> 00:20:01,000
Mēs arī iemācījušies mazliet par liešana,

330
00:20:01,000 --> 00:20:04,000
lai jūs varētu redzēt, ja jums ir, piemēram, programma, kas saka

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

332
00:20:08,000 --> 00:20:12,000
Vai jūs guys zināt, kas tas notiek, lai drukātu uz ekrāna?

333
00:20:12,000 --> 00:20:14,000
>> Kāds >> [Studentiem] 2?.

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

335
00:20:16,000 --> 00:20:20,000
Kad jūs darīt 3/2 tas notiek, lai saņemtu 1,5,

336
00:20:20,000 --> 00:20:24,000
bet kopš mēs esam izmantojot skaitlim tas notiek, lai ignorēt decimālā daļa,

337
00:20:24,000 --> 00:20:26,000
un jūs gatavojas ir 1.

338
00:20:26,000 --> 00:20:29,000
Ja jūs nevēlaties, ka, lai notiktu tas, ko jūs varat darīt, piemēram,

339
00:20:29,000 --> 00:20:33,000
ir atzīt, apgrozāmos y = x.

340
00:20:33,000 --> 00:20:40,000
Tad x, kas kādreiz bija 3 tagad būs 3,000 y.

341
00:20:40,000 --> 00:20:44,000
Un tad jūs varat izdrukāt y / 2.

342
00:20:44,000 --> 00:20:50,000
Patiesībā, es būtu 2. tur.

343
00:20:50,000 --> 00:20:55,000
Tā gatavojas darīt 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
un jūs gatavojas saņemt 1.5.

345
00:20:58,000 --> 00:21:06,000
Un mums ir šī .2 f vienkārši lūgt 2 zīmes aiz vienību decimālo daļu.

346
00:21:06,000 --> 00:21:12,000
Ja jums ir 0,3 f tas notiek, lai būtu reāli 1,500.

347
00:21:12,000 --> 00:21:16,000
Ja tas ir 2 tas būs 1,50.

348
00:21:16,000 --> 00:21:18,000
Mums arī ir šī lieta šeit.

349
00:21:18,000 --> 00:21:22,000
Ja jūs float x = 3.14, un tad jūs printf x

350
00:21:22,000 --> 00:21:24,000
jūs gatavojas saņemt 3.14.

351
00:21:24,000 --> 00:21:29,000
Un, ja jūs x = int x,

352
00:21:29,000 --> 00:21:34,000
kas nozīmē ārstēt X kā int, un jūs drukāt x tagad

353
00:21:34,000 --> 00:21:36,000
Jums nāksies 3.00.

354
00:21:36,000 --> 00:21:38,000
Vai ir jēga?

355
00:21:38,000 --> 00:21:41,000
Jo jūs pirmo apstrādājot X kā veselums, tāpēc jūs ignorējot decimālā daļa,

356
00:21:41,000 --> 00:21:45,000
un tad jūs drukāšanas x.

357
00:21:45,000 --> 00:21:47,000
Un visbeidzot, jūs varat arī darīt,

358
00:21:47,000 --> 00:21:52,000
int x = 65, un tad jums paziņot CHAR c = x,

359
00:21:52,000 --> 00:21:56,000
un tad, ja jūs drukāt c jūs tiešām gatavojas saņemt

360
00:21:56,000 --> 00:21:59,000
, Tāpēc būtībā, ko jūs šeit darāt

361
00:21:59,000 --> 00:22:02,000
ir tulkojot skaitlim vērā raksturu,

362
00:22:02,000 --> 00:22:05,000
tāpat ASCII tabulā dara.

363
00:22:05,000 --> 00:22:08,000
Mēs arī runājām par math operatoriem.

364
00:22:08,000 --> 00:22:14,000
Lielākā daļa no tām ir diezgan vienkārši, tāpēc +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
un arī mēs runājām par mod, kas ir atlikusī sadalīšanu 2 numuriem.

366
00:22:20,000 --> 00:22:23,000
Ja jums ir 10% 3, piemēram,

367
00:22:23,000 --> 00:22:27,000
tas nozīmē sadalīt 10 ar 3, un kāda ir atlikusī?

368
00:22:27,000 --> 00:22:30,000
Tas būs 1, tāpēc tas ir tiešām ļoti noderīgs par daudz programmu.

369
00:22:30,000 --> 00:22:38,000
Par Vigenère un Cēzara es esmu diezgan pārliecināts, ka visi no jums, puiši izmanto mod.

370
00:22:38,000 --> 00:22:43,000
Par matemātikas operatoriem, jābūt ļoti uzmanīgiem, apvienojot * un /.

371
00:22:43,000 --> 00:22:48,000
>> Piemēram, ja jūs (3/2) * 2, ko jūs gatavojas saņemt?

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

373
00:22:50,000 --> 00:22:54,000
Jā, 2, jo 3/2 būs 1,5,

374
00:22:54,000 --> 00:22:57,000
bet tā kā jūs darāt operācijas starp 2 integers

375
00:22:57,000 --> 00:22:59,000
jūs faktiski tikai gatavojas apsvērt 1,

376
00:22:59,000 --> 00:23:03,000
un tad 1 * 2 būs 2, tāpēc jābūt ļoti, ļoti uzmanīgiem

377
00:23:03,000 --> 00:23:07,000
veicot aritmētiskās ar veseliem skaitļiem, jo

378
00:23:07,000 --> 00:23:12,000
Jūs varētu saņemt, ka 2 = 3, šajā gadījumā.

379
00:23:12,000 --> 00:23:14,000
Un arī jābūt ļoti uzmanīgiem par prioritāti.

380
00:23:14,000 --> 00:23:21,000
Jums vajadzētu parasti izmantot iekavas, lai pārliecinātos, ka jūs zināt, ko jūs darāt.

381
00:23:21,000 --> 00:23:27,000
Daži noderīgi īsceļi, protams, viens ir man + + vai i + = 1

382
00:23:27,000 --> 00:23:30,000
vai izmantojot + =.

383
00:23:30,000 --> 00:23:34,000
Tas ir tas pats, kas dara i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Jūs varat arī man ir - vai man - = 1,

385
00:23:39,000 --> 00:23:42,000
kas ir tas pats, kas i = i -1,

386
00:23:42,000 --> 00:23:46,000
Kaut kas jums guys izmantot daudz uz cilpas, vismaz.

387
00:23:46,000 --> 00:23:52,000
Arī, *, ja jūs izmantojat * = un, ja jūs, piemēram,

388
00:23:52,000 --> 00:23:57,000
i * = 2 ir tas pats, kas sakot i = i * 2,

389
00:23:57,000 --> 00:23:59,000
un pats par sadalīšanu.

390
00:23:59,000 --> 00:24:08,000
Ja jums i / = 2 tas ir tas pats, kas i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Tagad par funkcijām.

392
00:24:10,000 --> 00:24:13,000
Jūs puiši uzzināja, ka funkcijas ir ļoti laba stratēģija, lai saglabātu kodu

393
00:24:13,000 --> 00:24:16,000
kamēr jūs programmēšana, tādēļ, ja jūs vēlaties, lai veiktu to pašu uzdevumu

394
00:24:16,000 --> 00:24:20,000
kodā atkal un atkal, iespējams, jūs vēlaties izmantot funkciju

395
00:24:20,000 --> 00:24:25,000
tikai tāpēc jums nav kopēt un ielīmēt kodu atkal un atkal.

396
00:24:25,000 --> 00:24:28,000
Patiesībā, galvenais ir funkcija, un, kad es parādīs formātu funkciju

397
00:24:28,000 --> 00:24:32,000
jūs gatavojas redzēt, ka tas ir diezgan skaidrs.

398
00:24:32,000 --> 00:24:35,000
Mēs arī izmantot funkcijas no dažām bibliotēkām,

399
00:24:35,000 --> 00:24:39,000
Piemēram, printf, getin, kas ir no CS50 bibliotēkas,

400
00:24:39,000 --> 00:24:43,000
un citas funkcijas, piemēram, toupper.

401
00:24:43,000 --> 00:24:46,000
Visas šīs funkcijas ir faktiski īstenoti citās bibliotēkās,

402
00:24:46,000 --> 00:24:49,000
un kad jūs nodot šos piesiet failus sākumā savu programmu

403
00:24:49,000 --> 00:24:53,000
Jūs sakāt, jūs varat lūdzu man kodu šīm funkcijām

404
00:24:53,000 --> 00:24:57,000
tāpēc man nav, lai tos īstenot ar sevi?

405
00:24:57,000 --> 00:25:00,000
Un jūs varat arī rakstīt savas funkcijas, tad, kad jūs sākat plānošanu

406
00:25:00,000 --> 00:25:04,000
tu saproti, ka bibliotēkas nav visas funkcijas, kas jums nepieciešams.

407
00:25:04,000 --> 00:25:10,000
Par pēdējo PSET, piemēram, mēs rakstīja izdarīt, motokross, un lookup,

408
00:25:10,000 --> 00:25:13,000
un tas ir ļoti, ļoti svarīgi, lai varētu rakstīt funkcijas

409
00:25:13,000 --> 00:25:17,000
jo tie ir noderīgi, un mēs tos izmantot visu laiku programmēšanas,

410
00:25:17,000 --> 00:25:19,000
un tas ietaupa daudz kodu.

411
00:25:19,000 --> 00:25:21,000
Par funkcija formāts tas ir viens.

412
00:25:21,000 --> 00:25:24,000
Mums ir atgriešanās veidu sākumā. Kāda ir atgriešanās tips?

413
00:25:24,000 --> 00:25:27,000
Tas ir tikai tad, kad jūsu funkcija ir gatavojas atgriezties.

414
00:25:27,000 --> 00:25:29,000
Ja jums ir funkcija, piemēram, faktoru,

415
00:25:29,000 --> 00:25:31,000
kas notiek, lai aprēķinātu faktoriālu veselam skaitlim,

416
00:25:31,000 --> 00:25:34,000
Iespējams, tas notiek, lai atgrieztos skaitlim arī.

417
00:25:34,000 --> 00:25:37,000
Tad atgriešanās tips būs int.

418
00:25:37,000 --> 00:25:41,000
Printf faktiski ir atgriešanās tipa tukšumu

419
00:25:41,000 --> 00:25:43,000
jo jūs neesat atgriežas neko.

420
00:25:43,000 --> 00:25:45,000
Tu esi vienkārši izdrukāt lietas uz ekrāna

421
00:25:45,000 --> 00:25:48,000
un atmest šo funkciju vēlāk.

422
00:25:48,000 --> 00:25:51,000
Tad jums ir nosaukumu funkciju, ka jūs varat izvēlēties.

423
00:25:51,000 --> 00:25:55,000
Jums vajadzētu būt mazliet saprātīgs, tāpat nav jāizvēlas vārds, piemēram, XYZ

424
00:25:55,000 --> 00:25:58,000
vai līdzīgi x2f.

425
00:25:58,000 --> 00:26:02,000
Mēģiniet veido vārdu, kas ir jēga.

426
00:26:02,000 --> 00:26:04,000
>> Piemēram, ja tas ir faktoru, teiksim faktori.

427
00:26:04,000 --> 00:26:08,000
Ja tas ir funkcija, kas gatavojas izdarīt kaut ko, nosaukt to izdarīt.

428
00:26:08,000 --> 00:26:11,000
Un tad mums ir parametrus, kas ir arī sauc argumenti,

429
00:26:11,000 --> 00:26:14,000
kas ir līdzīgi resursiem ka jūsu funkcija ir

430
00:26:14,000 --> 00:26:17,000
no savu kodu, lai veiktu savu uzdevumu.

431
00:26:17,000 --> 00:26:20,000
Ja jūs vēlaties, lai aprēķinātu skaitļa faktoriālu

432
00:26:20,000 --> 00:26:23,000
iespējams, jums ir nepieciešams, lai ir vairāki aprēķināt faktori.

433
00:26:23,000 --> 00:26:27,000
Viens no argumentiem, kas jums nāksies ir numurs pati.

434
00:26:27,000 --> 00:26:31,000
Un tad tas notiek, lai kaut ko darīt, un jāatgriež vērtība gada beigās

435
00:26:31,000 --> 00:26:35,000
ja vien tas nav spēkā funkcija.

436
00:26:35,000 --> 00:26:37,000
Pieņemsim redzēt piemēru.

437
00:26:37,000 --> 00:26:40,000
Ja es gribu uzrakstīt funkciju, kas summēts visus numurus masīvs integers,

438
00:26:40,000 --> 00:26:43,000
pirmkārt, atgriešanās tips būs int

439
00:26:43,000 --> 00:26:46,000
jo man ir masīvs integers.

440
00:26:46,000 --> 00:26:51,000
Un tad es esmu nāksies funkcijas nosaukumu, piemēram sumArray,

441
00:26:51,000 --> 00:26:54,000
un tad tas notiek, lai masīvs pati, lai int nums,

442
00:26:54,000 --> 00:26:58,000
un tad garums masīva, lai es zinu, cik skaitļu man summa.

443
00:26:58,000 --> 00:27:02,000
Tad man ir inicializēt mainīgo sauc summu, piemēram, uz 0,

444
00:27:02,000 --> 00:27:08,000
un katru reizi, kad es redzu elementu masīvu man vajadzētu pievienot to summu, tāpēc es tomēr par cilpu.

445
00:27:08,000 --> 00:27:15,000
Tāpat kā Lexi teica, jūs int i = 0, i <garumu un i + +.

446
00:27:15,000 --> 00:27:20,000
Un par katru elementu masīvu I did summa + = nums [i],

447
00:27:20,000 --> 00:27:24,000
un tad es atpakaļ summu, tāpēc tas ir ļoti vienkārši, un tas ietaupa daudz kodu

448
00:27:24,000 --> 00:27:28,000
ja jūs izmantojat šī funkcija daudz reižu.

449
00:27:28,000 --> 00:27:32,000
Tad mēs ņēmām apskatīt apstākļos.

450
00:27:32,000 --> 00:27:38,000
Mums ir, ja cits, un cits ja.

451
00:27:38,000 --> 00:27:42,000
Paskatīsimies, kāda ir atšķirība starp tiem.

452
00:27:42,000 --> 00:27:45,000
Veikt apskatīt šiem 2 kodiem. Kāda ir atšķirība starp tiem?

453
00:27:45,000 --> 00:27:49,000
Pirmais ir, būtībā kodi gribu jums pateikt

454
00:27:49,000 --> 00:27:51,000
ja skaitlis ir +, -, 0 vai.

455
00:27:51,000 --> 00:27:55,000
Pirmais saka: ja tas ir> 0, tad tas ir pozitīvi.

456
00:27:55,000 --> 00:28:00,000
Ja tas ir = ar 0, tad tas ir 0, un, ja tas ir <0, tad tas ir negatīvs.

457
00:28:00,000 --> 00:28:04,000
>> Un otrs dara, ja cits, ja cits.

458
00:28:04,000 --> 00:28:07,000
Starp abiem atšķirība ir tā, ka šī ir patiešām gatavojas

459
00:28:07,000 --> 00:28:13,000
pārbaudītu, vai> 0, <0 vai = 0 trīs reizes,

460
00:28:13,000 --> 00:28:17,000
tādēļ, ja jums ir numurs 2, piemēram, tas notiek, lai nāk šeit un teikt

461
00:28:17,000 --> 00:28:21,000
ja (x> 0), un tas notiek, lai teikt, jā, tāpēc es drukāt pozitīvi.

462
00:28:21,000 --> 00:28:25,000
Bet pat ja es zinu, ka tas ir> 0 un tas nav būs 0 0 vai <

463
00:28:25,000 --> 00:28:29,000
Es joprojām gatavojas darīt, ir tas 0, tas ir <0,

464
00:28:29,000 --> 00:28:33,000
tāpēc es esmu tiešām iet iekšā IF ka man nebija

465
00:28:33,000 --> 00:28:38,000
jo es jau zinu, ka tas nav gatavojas, lai apmierinātu kādu no šiem nosacījumiem.

466
00:28:38,000 --> 00:28:41,000
Es varu izmantot, ja cits, ja cits paziņojums.

467
00:28:41,000 --> 00:28:45,000
Tā būtībā saka, ja x = 0 Es izdrukāt pozitīvs.

468
00:28:45,000 --> 00:28:48,000
Ja tā nav, es esmu gatavojas pārbaudīt arī šo.

469
00:28:48,000 --> 00:28:51,000
Ja tas ir 2 ne es esmu gatavojas darīt.

470
00:28:51,000 --> 00:28:54,000
Būtībā, ja man bija x = 2 tu teiktu

471
00:28:54,000 --> 00:28:57,000
ja (x> 0), jā, tā drukāt šo.

472
00:28:57,000 --> 00:29:00,000
Tagad, kad es zinu, ka tas ir> 0 un ka tā atbilst pirmā, ja

473
00:29:00,000 --> 00:29:02,000
Es neesmu pat gatavojas palaist šo kodu.

474
00:29:02,000 --> 00:29:09,000
Kods darbojas ātrāk, patiesībā, 3 reizes ātrāk, ja jūs izmantot šo.

475
00:29:09,000 --> 00:29:11,000
Mēs arī uzzināja par un un vai.

476
00:29:11,000 --> 00:29:15,000
Es neesmu gatavojas iet cauri, jo Lexi jau runāja par viņiem.

477
00:29:15,000 --> 00:29:17,000
Tas ir tikai && un | | operatoru.

478
00:29:17,000 --> 00:29:21,000
>> Vienīgais, ko es saku, ir jābūt uzmanīgiem, kad jums ir 3 nosacījumi.

479
00:29:21,000 --> 00:29:24,000
Izmantot iekavas, jo tas ir ļoti mulsinoši, kad jums ir nosacījums

480
00:29:24,000 --> 00:29:27,000
un vēl viens vai otrs.

481
00:29:27,000 --> 00:29:30,000
Izmantot iekavas tikai, lai pārliecinātos, ka jūsu apstākļi jēgas

482
00:29:30,000 --> 00:29:34,000
jo šajā gadījumā, piemēram, jūs varat iedomāties, ka

483
00:29:34,000 --> 00:29:38,000
tas varētu būt pirmais nosacījums un vienu vai otru

484
00:29:38,000 --> 00:29:41,000
vai 2 nosacījumi apvienoti un

485
00:29:41,000 --> 00:29:45,000
vai trešais, tā vienkārši jābūt uzmanīgiem.

486
00:29:45,000 --> 00:29:48,000
Un visbeidzot, mēs runājām par slēdžiem.

487
00:29:48,000 --> 00:29:53,000
Slēdzis ir ļoti noderīgi, ja jums ir mainīgs.

488
00:29:53,000 --> 00:29:55,000
Pieņemsim, ka jums ir mainīgs, piemēram, n

489
00:29:55,000 --> 00:29:59,000
kas var būt 0, 1, 2 vai, un par katru no šiem gadījumiem

490
00:29:59,000 --> 00:30:01,000
jūs gatavojas veikt uzdevumu.

491
00:30:01,000 --> 00:30:04,000
Jūs varat teikt pārslēgties mainīgais, un tas liecina, ka

492
00:30:04,000 --> 00:30:08,000
vērtība, tad ir kā vērtība1 es esmu gatavojas darīt,

493
00:30:08,000 --> 00:30:12,000
un tad es pauze, kas nozīmē, es neesmu gatavojas apskatīt kādu citu gadījumu

494
00:30:12,000 --> 00:30:15,000
jo mēs jau apmierināti, ka lietu

495
00:30:15,000 --> 00:30:20,000
un tad vērtība2 un tā tālāk, un es arī varētu būt noklusējuma slēdzi.

496
00:30:20,000 --> 00:30:24,000
Tas nozīmē, ja tas neatbilst kādam no gadījumiem, kas man bija

497
00:30:24,000 --> 00:30:29,000
ka es esmu gatavojas darīt kaut ko citu, bet tas ir obligāti.

498
00:30:29,000 --> 00:30:36,000
Tas ir viss, par mani. Tagad pieņemsim ir Tomiju.

499
00:30:36,000 --> 00:30:41,000
Labi, tas būs nedēļa 3-ish.

500
00:30:41,000 --> 00:30:45,000
Šie ir daži no jautājumiem, mēs būsim aptver, Kripto, apjomu, masīvus, uc.

501
00:30:45,000 --> 00:30:49,000
Tikai ātri vārdu par crypto. Mēs nebrauksim, lai āmurs šīs mājas.

502
00:30:49,000 --> 00:30:52,000
>> Mēs to darījām 2 PSET, bet viktorīnas pārliecinieties jūs zināt starpību

503
00:30:52,000 --> 00:30:54,000
starp Cēzara šifra un Vigenère šifrētus,

504
00:30:54,000 --> 00:30:57,000
kā gan no tiem cipariem darbu un to, ko tas ir tāpat kā šifrētu

505
00:30:57,000 --> 00:30:59,000
un atšifrēt tekstu, izmantojot tās 2 šifriem.

506
00:30:59,000 --> 00:31:03,000
Atcerieties, Cēzara šifra vienkārši rotē katru rakstzīmi par tādu pašu summu,

507
00:31:03,000 --> 00:31:06,000
pārliecinoties, ka jums mod ar numuru burtiem alfabēta.

508
00:31:06,000 --> 00:31:09,000
Un Vigenère šifra, no otras puses, rotē katru rakstzīmi

509
00:31:09,000 --> 00:31:12,000
ar citu summu, lai nevis pasakot

510
00:31:12,000 --> 00:31:15,000
Katram varonim pagriezts par 3 Vigenère rotēs katru rakstzīmi

511
00:31:15,000 --> 00:31:17,000
ar citu summu atkarībā no dažiem atslēgvārdiem

512
00:31:17,000 --> 00:31:20,000
kur katrs atslēgvārdu vēstule pārstāv kādu citu summu

513
00:31:20,000 --> 00:31:26,000
lai pagrieztu skaidru tekstu,.

514
00:31:26,000 --> 00:31:28,000
Pieņemsim vispirms runāt par mainīgo jomu.

515
00:31:28,000 --> 00:31:30,000
Ir 2 dažādi veidi mainīgajiem.

516
00:31:30,000 --> 00:31:33,000
Mums ir vietējo mainīgie, un tie būs jānosaka

517
00:31:33,000 --> 00:31:36,000
ārpus galvenās vai ārpus jebkuras funkcijas vai bloku,

518
00:31:36,000 --> 00:31:39,000
un tie būs pieejami jebkur jūsu programmā.

519
00:31:39,000 --> 00:31:41,000
Ja jums ir funkcija un šāds statuss ir, bet cilpa

520
00:31:41,000 --> 00:31:44,000
liels globāls mainīgais ir pieejama visur.

521
00:31:44,000 --> 00:31:48,000
Vietējā mainīga, no otras puses, ir scoped uz vietu, kur tas tiek definēts.

522
00:31:48,000 --> 00:31:53,000
>> Ja jums ir funkcija šeit, piemēram, mums ir šī funkcija g,

523
00:31:53,000 --> 00:31:56,000
un iekšpusē g ir mainīgs šeit sauc y,

524
00:31:56,000 --> 00:31:58,000
un tas nozīmē, ka šis ir vietējais mainīgs.

525
00:31:58,000 --> 00:32:00,000
Pat ja šis mainīgais sauc y

526
00:32:00,000 --> 00:32:03,000
un šis mainīgais sauc y šos 2 funkcijas

527
00:32:03,000 --> 00:32:06,000
nav ne jausmas, ko viens otra vietējās mainīgie.

528
00:32:06,000 --> 00:32:10,000
No otras puses, šeit mēs sakām int x = 5,

529
00:32:10,000 --> 00:32:12,000
un tas ir ārpus jebkuras funkcijas.

530
00:32:12,000 --> 00:32:16,000
Tas ir ārpus galvenā, tāpēc šis ir globāls mainīgais.

531
00:32:16,000 --> 00:32:20,000
Tas nozīmē, ka iekšā no šiem 2 funkcijas, kad es saku x - vai x + +

532
00:32:20,000 --> 00:32:26,000
Es esmu piekļūstot pašu x turklāt šis y un tas y ir dažādi mainīgie.

533
00:32:26,000 --> 00:32:30,000
Tas ir starp pasaules mainīgo un vietējo mainīgajiem starpība.

534
00:32:30,000 --> 00:32:33,000
Ciktāl dizains ir bažas, dažreiz tas ir iespējams, labāka ideja

535
00:32:33,000 --> 00:32:37,000
saglabāt mainīgie vietējiem kad vien iespējams, var

536
00:32:37,000 --> 00:32:39,000
jo ar globālo mainīgo ķekars var iegūt tiešām mulsinoši.

537
00:32:39,000 --> 00:32:42,000
Ja jums ir ķekars funkcijas visu pārveidojot to pašu

538
00:32:42,000 --> 00:32:45,000
jūs varētu aizmirst to, ko tad, ja šī funkcija nejauši izmaina šī globālā,

539
00:32:45,000 --> 00:32:47,000
un tas citas funkcijas nezina par to,

540
00:32:47,000 --> 00:32:50,000
un tas get diezgan mulsinoši, kā jūs iegūtu vairāk kodu.

541
00:32:50,000 --> 00:32:53,000
Turot mainīgie vietējā kad vien iespējams, var

542
00:32:53,000 --> 00:32:56,000
ir tikai labs dizains.

543
00:32:56,000 --> 00:33:00,000
Bloki, atcerieties, ir vienkārši saraksti elementu paša tipa.

544
00:33:00,000 --> 00:33:04,000
Iekšā KI nevar būt sarakstu, piemēram, 1, 2,0, sveiki.

545
00:33:04,000 --> 00:33:06,000
Mēs vienkārši nevaram darīt.

546
00:33:06,000 --> 00:33:11,000
>> Kad mēs deklarēt masīvu C visi elementi jābūt tā paša tipa.

547
00:33:11,000 --> 00:33:14,000
Šeit man ir masīvs 3 integers.

548
00:33:14,000 --> 00:33:18,000
Šeit es esmu garums masīva, bet, ja es esmu tikai deklarējot to šajā sintaksi

549
00:33:18,000 --> 00:33:21,000
kur es jānorāda, kāda visi elementi man nav tehniski nepieciešams šo 3.

550
00:33:21,000 --> 00:33:25,000
Kompilators ir pietiekami gudrs, lai saprastu, cik liels masīvs jābūt.

551
00:33:25,000 --> 00:33:28,000
Tagad, kad es vēlos, lai saņemtu vai noteikt vērtību masīva

552
00:33:28,000 --> 00:33:30,000
Tas ir sintakse, lai to izdarītu.

553
00:33:30,000 --> 00:33:33,000
Tas būs tiešām mainīt otro elementu masīva, jo, atcerieties,

554
00:33:33,000 --> 00:33:36,000
numerācija sākas ar 0, nevis 1.

555
00:33:36,000 --> 00:33:42,000
Ja es gribu, lai lasītu šo vērtību es varu teikt kaut ko līdzīgu int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Vai, ja es gribu, lai noteiktu šo vērtību, piemēram, es esmu šeit darām,

557
00:33:44,000 --> 00:33:47,000
Es varu teikt Array [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Tas laiks piekļuvei elementus ar to indekss

559
00:33:50,000 --> 00:33:52,000
vai viņu stāvokli, vai ja tie ir masīvs,

560
00:33:52,000 --> 00:33:57,000
un ka saraksts sākas ar 0.

561
00:33:57,000 --> 00:34:00,000
Mēs varam būt arī masīvus masīvi,

562
00:34:00,000 --> 00:34:03,000
un to sauc par daudzdimensiju masīvu.

563
00:34:03,000 --> 00:34:05,000
Kad mums ir daudzpusīga masīvs

564
00:34:05,000 --> 00:34:07,000
tas nozīmē, ka mēs varam būt kaut kas līdzīgs rindām un kolonnām,

565
00:34:07,000 --> 00:34:11,000
un tas ir tikai viens veids, kā vizualizēt šīs vai domā par to.

566
00:34:11,000 --> 00:34:14,000
Kad man ir daudzdimensiju masīvu, kas nozīmē, ka es esmu gatavojas sākt nepieciešams

567
00:34:14,000 --> 00:34:17,000
vairāk nekā 1 indeksa, jo, ja man ir režģi

568
00:34:17,000 --> 00:34:19,000
vienkārši sakot ko rinda tu esi mums nedod numuru.

569
00:34:19,000 --> 00:34:22,000
Tas ir tiešām tikai gatavojas sniegt mums sarakstu numuriem.

570
00:34:22,000 --> 00:34:25,000
Pieņemsim, ka man ir šī masīva šeit.

571
00:34:25,000 --> 00:34:30,000
Man ir masīvs sauc režģis, un es saku, tas ir 2 rindas un 3 kolonnas,

572
00:34:30,000 --> 00:34:32,000
un tāpēc tas ir viens veids, kā vizualizēt to.

573
00:34:32,000 --> 00:34:37,000
Kad es saku es gribu, lai iegūtu elementu pie [1] [2]

574
00:34:37,000 --> 00:34:41,000
tas nozīmē, ka, jo tie ir rindas vispirms un tad kolonnas

575
00:34:41,000 --> 00:34:44,000
Es esmu gatavojas lēkt uz rinda 1, jo es teicu 1.

576
00:34:44,000 --> 00:34:49,000
>> Tad es esmu gatavojas nākt nekā šeit uz 2 kolonnu, un es esmu gatavojas saņemt vērtība 6.

577
00:34:49,000 --> 00:34:51,000
Jēga?

578
00:34:51,000 --> 00:34:55,000
Daudzdimensiju masīvus, atceries, ir tehniski tikai masīvs masīvi.

579
00:34:55,000 --> 00:34:57,000
Mēs varam būt masīvus bloki bloki.

580
00:34:57,000 --> 00:35:00,000
Mēs varam glabāt notiek, bet tiešām viens veids, kā domāt par

581
00:35:00,000 --> 00:35:03,000
Kā tas tiek izklāstīts un to, kas notiek, ir vizualizēt

582
00:35:03,000 --> 00:35:09,000
režģī kā šis.

583
00:35:09,000 --> 00:35:12,000
Kad mēs iet masīvus pēc funkcijām, viņi dodas uz uzvesties

584
00:35:12,000 --> 00:35:16,000
mazliet savādāk, nekā tad, kad mēs iet regulāri mainīgie funkcijām

585
00:35:16,000 --> 00:35:18,000
kā iet int vai peldēt.

586
00:35:18,000 --> 00:35:21,000
Kad mēs iet uz int vai char vai kāds no šiem citiem datu tipiem

587
00:35:21,000 --> 00:35:24,000
mēs vienkārši ņēma apskatīt, ja funkcija izmaina

588
00:35:24,000 --> 00:35:28,000
vērtība no mainīgā ka izmaiņas nav gatavojas izplatīt augšu

589
00:35:28,000 --> 00:35:32,000
uz izsaucēja funkcijas.

590
00:35:32,000 --> 00:35:35,000
Ar masīvu, no otras puses, kas notiks.

591
00:35:35,000 --> 00:35:39,000
Ja es iet masīvā uz kādu funkciju un šo funkciju mainās daži no elementiem,

592
00:35:39,000 --> 00:35:43,000
kad es atgriezīšos līdz funkcijai, kas sauc to

593
00:35:43,000 --> 00:35:47,000
mans masīvs tagad būs atšķirīgs, un par to vārdnīca

594
00:35:47,000 --> 00:35:50,000
ir masīvi ir pagājis, atsaucoties, kā mēs redzēsim vēlāk.

595
00:35:50,000 --> 00:35:53,000
Tas ir saistīts ar to, kā palīglīdzekļi darbu, ja šajās pamata datu veidiem,

596
00:35:53,000 --> 00:35:55,000
no otras puses, ir pagājis pēc vērtības.

597
00:35:55,000 --> 00:35:59,000
>> Mēs varam iedomāties, kas kā kopēšana dažu mainīgo un tad iet kopijā.

598
00:35:59,000 --> 00:36:01,000
Tas nav svarīgi, ko mēs darām ar šo mainīgo.

599
00:36:01,000 --> 00:36:06,000
Zvana funkcija nebūs zināms, ka tas tika mainīts.

600
00:36:06,000 --> 00:36:10,000
Masīvi ir tikai nedaudz atšķirīgs šajā sakarā.

601
00:36:10,000 --> 00:36:13,000
Piemēram, kā mēs tikko redzējām, galvenais ir vienkārši funkcija

602
00:36:13,000 --> 00:36:15,000
kas var veikt 2 argumentiem.

603
00:36:15,000 --> 00:36:20,000
Pirmais arguments, lai galvenā funkcija ir argc, vai vairākus argumentus,

604
00:36:20,000 --> 00:36:23,000
un otrais arguments sauc argv,

605
00:36:23,000 --> 00:36:27,000
un tie ir faktiskie vērtības šiem argumentiem.

606
00:36:27,000 --> 00:36:30,000
Pieņemsim, ka man ir programmu, ko sauc this.c,

607
00:36:30,000 --> 00:36:34,000
un es saku padara šo, un es esmu gatavojas palaist šo pie komandrindas.

608
00:36:34,000 --> 00:36:38,000
Tagad iet dažās argumentus manā programmā sauc šo,

609
00:36:38,000 --> 00:36:42,000
Es varētu teikt kaut ko līdzīgu / šis ir cs. 50.

610
00:36:42,000 --> 00:36:45,000
Tas ir tas, ko mēs iedomāties Deivids darīt katru dienu pie termināla.

611
00:36:45,000 --> 00:36:48,000
Bet tagad galvenais uzdevums iekšpusē šīs programmas

612
00:36:48,000 --> 00:36:52,000
ir šīs vērtības, tāpēc argc ir 4.

613
00:36:52,000 --> 00:36:56,000
Tas varētu būt nedaudz mulsinoši, jo tiešām mēs esam tikai brauc, ir cs 50.

614
00:36:56,000 --> 00:36:58,000
Tas ir tikai 3.

615
00:36:58,000 --> 00:37:02,000
Bet atcerieties, ka pirmā no argv elements vai pirmais arguments

616
00:37:02,000 --> 00:37:05,000
ir nosaukums funkcijas pati.

617
00:37:05,000 --> 00:37:07,190
Tātad tas nozīmē, ka mums ir 4 lietas šeit,

618
00:37:07,190 --> 00:37:10,530
un pirmais elements būs. / šis.

619
00:37:10,530 --> 00:37:12,970
Un tas tiks attēlots kā string.

620
00:37:12,970 --> 00:37:18,590
Tad pārējie elementi ir tas, ko mēs drukāti pēc programmas nosaukumu.

621
00:37:18,590 --> 00:37:22,720
Tā tāpat kā malā, kā mēs, iespējams, redzēja 2 PSET,

622
00:37:22,720 --> 00:37:28,780
atcerieties, ka virkne 50 tiek ≠ skaitlim 50.

623
00:37:28,780 --> 00:37:32,520
Tātad mēs nevaram teikt kaut ko līdzīgu, "int x = 3 argv."

624
00:37:32,520 --> 00:37:36,470
>> Tas ir tikai nav gatavojas jēgas, jo tas ir virkne, un tas ir skaitlis.

625
00:37:36,470 --> 00:37:38,510
Tātad, ja jūs vēlaties, lai pārvērstu starp 2, atceries, mēs spēsim

626
00:37:38,510 --> 00:37:40,810
ir šī burvju funkciju sauc atoi.

627
00:37:40,810 --> 00:37:46,270
Kas ņem stīgu un atgriež skaitlim pārstāv iekšpusē šajā virknē.

628
00:37:46,270 --> 00:37:48,360
Tātad tas ir viegli kļūda izteikt uz viktorīnu,

629
00:37:48,360 --> 00:37:51,590
tikai domāju, ka tas tiks automātiski pareizs veids.

630
00:37:51,590 --> 00:37:53,860
Bet tikai zinu, ka tie vienmēr būs stīgas

631
00:37:53,860 --> 00:38:00,920
pat ja virkne satur tikai skaitlim vai rakstzīmi vai peldēt.

632
00:38:00,920 --> 00:38:03,380
Tāpēc tagad parunāsim par braukšanas laiku.

633
00:38:03,380 --> 00:38:06,700
Kad mums ir visi šie algoritmi, kas darīt visas šīs trakas lietas,

634
00:38:06,700 --> 00:38:11,580
tā kļūst patiešām lietderīgi uzdot jautājumu: "Cik ilgi viņi veic?"

635
00:38:11,580 --> 00:38:15,500
Mēs pārstāvam ka ar kaut ko sauc par asimptotiskās notācija.

636
00:38:15,500 --> 00:38:18,430
Tas nozīmē, ka - labi, pieņemsim, ka mēs dodam mūsu algoritms

637
00:38:18,430 --> 00:38:20,840
daži tiešām, tiešām, tiešām liels ieguldījums.

638
00:38:20,840 --> 00:38:23,840
Mēs vēlamies uzdot jautājumu: "Cik ilgi tas ir gatavojas veikt?

639
00:38:23,840 --> 00:38:26,370
Cik soļus paies mūsu algoritmu, lai palaistu

640
00:38:26,370 --> 00:38:29,980
atkarībā no lieluma ieejas? "

641
00:38:29,980 --> 00:38:33,080
Tātad pirmais veids, kā mēs varam aprakstīt palaist laiku ir ar lielu O.

642
00:38:33,080 --> 00:38:35,380
Un tas ir mūsu sliktāko darba laika.

643
00:38:35,380 --> 00:38:38,590
Tātad, ja mēs gribam sakārtot masīvu, un mēs dodam mūsu algoritmu masīvs

644
00:38:38,590 --> 00:38:41,000
tas dilstošā secībā, ja tas būtu augošā secībā,

645
00:38:41,000 --> 00:38:43,130
kas būs sliktākais gadījums.

646
00:38:43,130 --> 00:38:49,800
Šī ir mūsu augšējā robeža ir maksimālais laika mūsu algoritms būs.

647
00:38:49,800 --> 00:38:54,740
No otras puses, šī Ω gatavojas aprakstīt labākajā gadījumā darba laika.

648
00:38:54,740 --> 00:38:58,210
Tātad, ja mēs dodam jau ir sakārtoti masīvs šķirošanas algoritmu,

649
00:38:58,210 --> 00:39:00,940
cik ilgs laiks būs vajadzīgs, lai sakārtotu to?

650
00:39:00,940 --> 00:39:06,610
Un tas, pēc tam, apraksta zemākā darba laika.

651
00:39:06,610 --> 00:39:10,980
Tāpēc šeit ir tikai daži vārdi, kas raksturo dažas kopējas darbības laiku.

652
00:39:10,980 --> 00:39:13,120
Tie ir augošā secībā.

653
00:39:13,120 --> 00:39:16,060
Ātrākais darbības laiks mums ir sauc nemainīgs.

654
00:39:16,060 --> 00:39:19,800
>> Tas nozīmē, ka nav svarīgi, cik daudz elementu mēs dodam mūsu algoritms,

655
00:39:19,800 --> 00:39:22,280
Nav svarīgi, cik liels mūsu masīvs, šķirošanu to

656
00:39:22,280 --> 00:39:26,510
vai darot neatkarīgi mēs darām ar masīvu vienmēr būs tikpat daudz laika.

657
00:39:26,510 --> 00:39:30,270
Tātad, mēs varam apliecināt, ka tikai ar 1, kas ir nemainīgs.

658
00:39:30,270 --> 00:39:32,410
Mēs arī paskatījās logaritmisko palaist laikā.

659
00:39:32,410 --> 00:39:34,800
Tātad kaut kas līdzīgs binārā meklēšana ir logaritmiska,

660
00:39:34,800 --> 00:39:37,140
kur mēs samazināt problēmu ilgāks eliminācijas katru reizi

661
00:39:37,140 --> 00:39:40,970
un tad lietas tikai iegūt augstāku no turienes.

662
00:39:40,970 --> 00:39:43,580
Un, ja jūs esat kādreiz rakstot O jebkura faktoriālo algoritmu,

663
00:39:43,580 --> 00:39:47,850
jūs, iespējams, nevajadzētu uzskatīt to par savu dienas darbu.

664
00:39:47,850 --> 00:39:53,910
Ja mēs salīdzinām skriešanas reizes tas ir svarīgi paturēt prātā šīs lietas.

665
00:39:53,910 --> 00:39:57,760
Tātad, ja man ir algoritms, kas ir O (N), un kāds cits

666
00:39:57,760 --> 00:40:03,590
ir O algoritms (2n) tie ir faktiski asimptotiski līdzvērtīgi.

667
00:40:03,590 --> 00:40:06,590
Tātad, ja mēs iedomājamies n būt liels skaits piemēram miljardi eleventy:

668
00:40:06,590 --> 00:40:13,090
tad, kad mēs esam salīdzinot eleventy miljardus kaut ko līdzīgu miljardiem eleventy +3,

669
00:40:13,090 --> 00:40:17,640
pēkšņi, ka 3 nav īsti liela atšķirība vairs.

670
00:40:17,640 --> 00:40:20,980
Tieši tāpēc mēs esam gatavojas sākt apsvērt šīs lietas ir līdzvērtīgas.

671
00:40:20,980 --> 00:40:24,220
Tātad lietas, piemēram, šīm konstantēm šeit, tur ir 2 x šo, vai pievienojot 3,

672
00:40:24,220 --> 00:40:27,180
šie ir tikai konstantes, un tie gatavojas piliens uz augšu.

673
00:40:27,180 --> 00:40:32,480
Tātad, tāpēc visi šie jaunākas reizes 3 ir tāds pats, kā saka viņi O (N).

674
00:40:32,480 --> 00:40:37,490
Tāpat, ja mums ir 2 citas palaist reizes, teiksim O (n ³ + 2n ²), mēs varam pievienot

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, un tad mums ir cita darbības laiku, kas ir tikai O (n ³).

676
00:40:42,070 --> 00:40:46,290
atkal, tie ir tas pats, jo tie - tie nav vienādi.

677
00:40:46,290 --> 00:40:49,840
Tās ir tās pašas lietas, piedodiet. Tātad tas ir tas pats, jo

678
00:40:49,840 --> 00:40:53,090
this n ³ gatavojas dominēt šajā 2n ².

679
00:40:53,090 --> 00:40:59,130
>> Kas nav tā pati lieta ir, ja mēs esam palaist reizes, piemēram, O (n ³) un O (N ²)

680
00:40:59,130 --> 00:41:02,820
jo tas n ³ ir daudz lielāks nekā šo n ².

681
00:41:02,820 --> 00:41:05,470
Tātad, ja mums ir exponents, pēkšņi tas sāk jautājums,

682
00:41:05,470 --> 00:41:08,280
bet, kad mēs esam tikai nodarbojas ar faktoriem, jo ​​mēs esam šeit,

683
00:41:08,280 --> 00:41:12,810
tad tas nav dodas uz jautājumu, jo tie ir tikai gatavojas pamest.

684
00:41:12,810 --> 00:41:16,760
Pieņemsim to apskatīt dažas no algoritmiem, mēs esam redzējuši līdz šim

685
00:41:16,760 --> 00:41:19,260
un runāt par savu darbības laiku.

686
00:41:19,260 --> 00:41:23,850
Pirmais veids meklē numuru sarakstā, ko mēs redzējām, bija lineāra meklēt.

687
00:41:23,850 --> 00:41:26,950
Un lineārās meklēšanas īstenošana ir super vienkārša.

688
00:41:26,950 --> 00:41:30,490
Mums vienkārši ir saraksts, un mēs ejam apskatīt katru elementu sarakstā

689
00:41:30,490 --> 00:41:34,260
kamēr mēs atrastu numuru mēs meklējam.

690
00:41:34,260 --> 00:41:38,370
Tātad tas nozīmē, ka sliktākajā gadījumā, tas O (N).

691
00:41:38,370 --> 00:41:40,860
Un sliktākais gadījums varētu būt, ja elements ir

692
00:41:40,860 --> 00:41:45,710
pēdējais elements, tad, izmantojot lineāro meklēšanu mums ir jāskatās uz katru elementu

693
00:41:45,710 --> 00:41:50,180
kamēr mēs to pēdējais, lai zinām, ka faktiski tas bija sarakstā.

694
00:41:50,180 --> 00:41:52,910
Mēs nevaram vienkārši atmest pusceļā un saka: "Tas droši vien nav tur."

695
00:41:52,910 --> 00:41:55,980
Ar lineāro meklēšanu mums ir jāskatās uz visu lieta.

696
00:41:55,980 --> 00:41:59,090
Labākajā gadījumā piestrādes laiks, no otras puses, ir nemainīga

697
00:41:59,090 --> 00:42:04,200
jo labākajā gadījumā elements mēs meklējam, ir tikai pirmais sarakstā.

698
00:42:04,200 --> 00:42:08,930
Tātad tas ir gatavojas veikt mums tieši 1 solis, lai cik liels šis saraksts ir

699
00:42:08,930 --> 00:42:12,140
ja mēs meklējam pirmo elementu katru reizi.

700
00:42:12,140 --> 00:42:15,390
>> Tātad, ja jūs meklēt, atcerieties, tas nenozīmē, ka mūsu saraksts tiks sakārtots.

701
00:42:15,390 --> 00:42:19,430
Jo mēs vienkārši dodas meklēt pa katru elementu, un tas nav īsti jautājums

702
00:42:19,430 --> 00:42:23,560
ko lai šie elementi ir iekšā

703
00:42:23,560 --> 00:42:28,110
Vairāk viedo meklēšanas algoritms ir kaut kas līdzīgs bināro meklēšanu.

704
00:42:28,110 --> 00:42:31,500
Atcerieties, ka bināro meklēšanas ieviešana ir, kad jūs gatavojas

705
00:42:31,500 --> 00:42:34,320
glabāt meklējat pie vidū sarakstā.

706
00:42:34,320 --> 00:42:38,000
Un tāpēc mēs meklējam vidū, mēs pieprasām, lai saraksts ir sakārtots

707
00:42:38,000 --> 00:42:40,580
vai arī mēs nezinām, kur pa vidu ir, un mums ir jāskatās pāri

708
00:42:40,580 --> 00:42:44,480
viss saraksts, lai atrastu to, un tad tajā brīdī mēs esam tikai tērēt laiku.

709
00:42:44,480 --> 00:42:48,480
Tātad, ja mums ir sakārtoti sarakstu, un mēs atrast vidū, mēs ejam, lai salīdzinātu vidū

710
00:42:48,480 --> 00:42:51,590
līdz elementam mēs meklējam.

711
00:42:51,590 --> 00:42:54,640
Ja tas ir pārāk augsts, tad mēs varam aizmirst labajā pusē

712
00:42:54,640 --> 00:42:57,810
jo mēs zinām, ka, ja mūsu elements ir jau pārāk liels

713
00:42:57,810 --> 00:43:01,080
un viss pa labi no šā elementa ir vēl lielāks,

714
00:43:01,080 --> 00:43:02,760
tad mums nav nepieciešams meklēt tur vairs.

715
00:43:02,760 --> 00:43:05,430
Kur no otras puses, ja mūsu elements ir pārāk mazs,

716
00:43:05,430 --> 00:43:08,700
mēs zinām viss pa kreisi no šī elementa ir pārāk zems,

717
00:43:08,700 --> 00:43:11,390
tāpēc nav īsti jēgas meklēt tur, vai nu.

718
00:43:11,390 --> 00:43:15,760
Tādā veidā, ar katru soli un katru reizi mēs skatāmies viduspunktā saraksta,

719
00:43:15,760 --> 00:43:19,060
mēs spēsim samazināt mūsu problēmas uz pusi, jo pēkšņi mēs zinām

720
00:43:19,060 --> 00:43:23,040
viss ķekars numuriem, kas var nebūt viens mēs meklējam.

721
00:43:23,040 --> 00:43:26,950
>> Jo pseudocode tas varētu izskatīties kaut kas līdzīgs šim,

722
00:43:26,950 --> 00:43:30,990
un tāpēc mēs esam griešana sarakstu uz pusi katru reizi,

723
00:43:30,990 --> 00:43:34,920
Mūsu sliktākajā gadījumā Run laiks lec no lineārs logaritmiska.

724
00:43:34,920 --> 00:43:39,260
Tik pēkšņi mums ir pieteikšanās posmos, lai atrastu elementu sarakstā.

725
00:43:39,260 --> 00:43:42,460
Labākajā gadījumā piestrādes laiku, lai gan, joprojām ir nemainīgs

726
00:43:42,460 --> 00:43:45,180
jo tagad, pieņemsim tikai teikt, ka elements mēs meklējam, ir

727
00:43:45,180 --> 00:43:48,380
vienmēr precīzs vidū sākotnējā sarakstā.

728
00:43:48,380 --> 00:43:52,080
Tātad mēs varam augt mūsu sarakstā tik lielas kā mēs vēlamies, bet, ja šis elements mēs meklējam, ir pa vidu,

729
00:43:52,080 --> 00:43:54,910
tad tas ir tikai gatavojas veikt mums 1 soli.

730
00:43:54,910 --> 00:44:00,920
Tātad, tāpēc mēs esam O (log n) un Ω (1) vai pastāvīga.

731
00:44:00,920 --> 00:44:04,510
Pieņemsim kursēt bināro meklēšanu šajā sarakstā.

732
00:44:04,510 --> 00:44:08,020
Tāpēc pieņemsim, ka mēs meklējam elementa 164.

733
00:44:08,020 --> 00:44:11,650
Pirmā lieta, mēs gatavojamies darīt, ir atrast viduspunktā šajā sarakstā.

734
00:44:11,650 --> 00:44:15,060
Tas tikai tā notiek, ka viduspunktā gatavojas krist starp šiem 2 numuriem,

735
00:44:15,060 --> 00:44:18,960
tāpēc pieņemsim tikai patvaļīgi teikt, katru reizi, viduspunktā iekrīt starp 2 numuriem,

736
00:44:18,960 --> 00:44:21,150
pieņemsim tikai noapaļot uz augšu.

737
00:44:21,150 --> 00:44:24,330
Mums vienkārši nepieciešams, lai pārliecinātos, ka mēs to izdarīt ik solis ceļu.

738
00:44:24,330 --> 00:44:29,040
Tāpēc mēs esam gatavojas noapaļot uz augšu, un mēs esam gatavojas teikt, ka 161 ir vidū mūsu sarakstā.

739
00:44:29,040 --> 00:44:34,640
So 161 <164, un katrs elements pa kreisi 161

740
00:44:34,640 --> 00:44:39,120
Ir arī <164, lai mēs zinām, ka tas nav dodas, lai palīdzētu mums visiem

741
00:44:39,120 --> 00:44:42,690
lai sāktu meklēt nekā šeit, jo elements mēs meklējam nevar būt tur.

742
00:44:42,690 --> 00:44:47,060
Tātad, ko mēs varam darīt, ir, mēs varam tikai aizmirst par to, ka visa kreisā puse sarakstā,

743
00:44:47,060 --> 00:44:51,700
un tagad tikai apsvērt no tiesībām 161 vēlāk.

744
00:44:51,700 --> 00:44:54,050
>> Tātad vēlreiz, tas ir viduspunktā; pieņemsim tikai noapaļot uz augšu.

745
00:44:54,050 --> 00:44:56,260
Tagad 175 ir pārāk liels.

746
00:44:56,260 --> 00:44:59,180
Tātad mēs zinām, tas nav dodas, lai palīdzētu mums meklē šeit vai šeit,

747
00:44:59,180 --> 00:45:06,610
tāpēc mēs varam tikai mest, ka prom, un galu galā mēs hit 164.

748
00:45:06,610 --> 00:45:10,560
Visus jautājumus par bināro meklēšanu?

749
00:45:10,560 --> 00:45:14,180
Pāriesim no meklējot izmantojot jau sakārtoti sarakstā

750
00:45:14,180 --> 00:45:17,660
faktiski ņemot sarakstu numurus jebkurā secībā

751
00:45:17,660 --> 00:45:20,960
un padarot šo sarakstu augošā secībā.

752
00:45:20,960 --> 00:45:24,060
Pirmais algoritms mēs paskatījās sauca burbulis šķirot.

753
00:45:24,060 --> 00:45:27,300
Un tas būtu vienkāršāka algoritmiem mēs redzējām.

754
00:45:27,300 --> 00:45:32,970
Burbulis šķirot saka, ka tad, kad visi 2 elementi iekšā sarakstā ir nevietā,

755
00:45:32,970 --> 00:45:36,500
nozīmē, ka ir lielāks skaits pa kreisi uz mazāku skaitu,

756
00:45:36,500 --> 00:45:40,190
tad mēs ejam, lai mijmaiņas tiem, jo ​​tas nozīmē, ka saraksts būs

757
00:45:40,190 --> 00:45:42,860
"Vairāk sakārtoti", nekā tas bija pirms tam.

758
00:45:42,860 --> 00:45:45,180
Un mēs esam tikai gatavojas turpināt šo procesu atkal un atkal un atkal

759
00:45:45,180 --> 00:45:52,100
līdz beidzot elementi burbulis to pareizajā vietā, un tam mums ir sakārtoti sarakstu.

760
00:45:52,100 --> 00:45:57,230
>> Norises laiks tas būs O (N ²). Kāpēc?

761
00:45:57,230 --> 00:46:00,370
Nu, jo sliktākajā gadījumā mēs spēsim veikt katru elementu, un

762
00:46:00,370 --> 00:46:04,570
mēs spēsim nonākt salīdzinot to ar jebkuru citu elementu sarakstā.

763
00:46:04,570 --> 00:46:08,030
Bet labākajā gadījumā, mums ir jau sakārtoti sarakstu, burbulis kārtot s

764
00:46:08,030 --> 00:46:12,230
tikai gatavojas iet cauri vienreiz, saka "Nē. Man nebija nekādas mijmaiņa, tāpēc es esmu darīts."

765
00:46:12,230 --> 00:46:17,410
Tātad mums ir labākā lieta darbības laiku Ω (n).

766
00:46:17,410 --> 00:46:20,680
Pieņemsim palaist burbulis šķirot sarakstā.

767
00:46:20,680 --> 00:46:23,560
Vai pirmais, pieņemsim tikai apskatīt dažus pseudocode tiešām ātri.

768
00:46:23,560 --> 00:46:28,160
Mēs vēlamies pateikt, ka mēs vēlamies, lai sekotu, katrā atkārtojuma no cilpas,

769
00:46:28,160 --> 00:46:32,190
izsekot, vai mēs mainīt nekādus elementus.

770
00:46:32,190 --> 00:46:37,610
So iemeslu tas ir, mēs spēsim apturēt, ja mēs esam nav iesaistīts mijmaiņas nekādus elementus.

771
00:46:37,610 --> 00:46:41,980
Darbības sākumā mūsu Loop mēs esam nav iesaistīts mijmaiņas neko, tāpēc mēs sakām, ka ir nepatiesa.

772
00:46:41,980 --> 00:46:47,170
Tagad mēs esam gatavojas iet cauri sarakstam un salīdzināt elements I elements i + 1

773
00:46:47,170 --> 00:46:50,310
un, ja tas ir gadījumā, ka ir lielāks skaits pa kreisi uz mazāku skaitu,

774
00:46:50,310 --> 00:46:52,310
tad mēs esam tikai gatavojas, lai mijmaiņas tiem.

775
00:46:52,310 --> 00:46:54,490
>> Un tad mēs esam gatavojas atcerēties, ka mēs mijmaina elementu.

776
00:46:54,490 --> 00:46:58,900
Tas nozīmē, ka mums ir jāiet cauri sarakstam vismaz vēl 1 reizi

777
00:46:58,900 --> 00:47:02,160
jo stāvoklis, kurā mēs apstājāmies ir tad, kad viss saraksts ir jau sakārtots,

778
00:47:02,160 --> 00:47:04,890
kas nozīmē, mēs esam nav veicis nekādus mijmaiņas darījumus.

779
00:47:04,890 --> 00:47:09,960
Tātad, tāpēc mūsu nosacījums paredz šeit ir ", bet daži elementi ir samainīti."

780
00:47:09,960 --> 00:47:13,720
Tāpēc tagad pieņemsim tikai paskaties darbojas sarakstā.

781
00:47:13,720 --> 00:47:16,640
Man ir saraksts 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Burbulis kārtot gatavojas sākt visu ceļu pa kreisi, un tas notiek, lai salīdzinātu

783
00:47:19,850 --> 00:47:24,700
Arī I elementiem, tāpēc 0 līdz i + 1, kas ir elements 1.

784
00:47:24,700 --> 00:47:29,020
Tas notiek, lai teikt, labi 5> 0, bet tagad 5 ir pa kreisi,

785
00:47:29,020 --> 00:47:32,500
tāpēc man ir nepieciešams, lai apmainītu 5, 0.

786
00:47:32,500 --> 00:47:35,470
Kad es mijmaiņas tiem, pēkšņi man šis citu sarakstu.

787
00:47:35,470 --> 00:47:38,260
Tagad 5> 1, tāpēc mēs ejam, lai mijmaiņas tiem.

788
00:47:38,260 --> 00:47:42,160
5 nav> 6, tāpēc mums nav nepieciešams neko darīt šeit.

789
00:47:42,160 --> 00:47:46,690
Bet 6> 4, tāpēc mums ir nepieciešams, lai mijmaiņas.

790
00:47:46,690 --> 00:47:49,740
Atkal, mums ir nepieciešams, lai palaistu cauri visam sarakstam beidzot atklāt

791
00:47:49,740 --> 00:47:52,330
ka tie nav pareizā secībā, mēs mijmaiņas tiem,

792
00:47:52,330 --> 00:47:57,120
un šajā brīdī mums ir nepieciešams, lai palaistu cauri sarakstam 1 vairāk laika

793
00:47:57,120 --> 00:48:05,390
lai pārliecinātos, ka viss ir savā kārtībā, un šajā brīdī burbulis veida ir pabeigta.

794
00:48:05,390 --> 00:48:10,720
Atšķirīgs algoritms veikt dažus elementus un šķirošanu, ir izvēle veida.

795
00:48:10,720 --> 00:48:15,740
Aiz atlases veida ideja ir tāda, ka mēs spēsim veidot sakārtoti daļu saraksta

796
00:48:15,740 --> 00:48:18,150
1 elements vienlaikus.

797
00:48:18,150 --> 00:48:23,170
>> Un kā mēs gatavojamies darīt, ir, izveidojot kreiso segmentu sarakstā.

798
00:48:23,170 --> 00:48:27,510
Un būtībā, katrs - par katru soli, mēs spēsim veikt mazāko elementu esam kreisi

799
00:48:27,510 --> 00:48:32,310
kas nav sakārtoti vēl, un mēs ejam, lai pārvietotu to vērā, ka šķiroto segmentā.

800
00:48:32,310 --> 00:48:35,850
Tas nozīmē, ka mums ir nepieciešams, lai pastāvīgi atrast minimālo nešķirotu elements

801
00:48:35,850 --> 00:48:40,720
un tad šo minimālo elementu un mijmaiņas to ar kāda

802
00:48:40,720 --> 00:48:45,090
kreisās visvairāk elements, nav sakārtots.

803
00:48:45,090 --> 00:48:50,890
Palaist laikā šī būs O (n ²), jo sliktākajā gadījumā

804
00:48:50,890 --> 00:48:55,070
Mums nepieciešams, lai salīdzinātu katru elementu katram citu elementu.

805
00:48:55,070 --> 00:48:59,250
Jo mēs esam sakot, ka, ja mēs sāktu kreisajā pusē sarakstā, mums ir nepieciešams

806
00:48:59,250 --> 00:49:02,970
iet cauri visai labo segmentā atrast mazāko elementu.

807
00:49:02,970 --> 00:49:05,430
Un tad atkal, mums ir nepieciešams, lai iet pa visu labo segmentu un

808
00:49:05,430 --> 00:49:08,210
glabāt iet pāri, ka atkal un atkal un atkal.

809
00:49:08,210 --> 00:49:11,350
Kas notiek, lai ar n ². Mēs ejam, lai vajag cilpa iekšpusē citu cilpa

810
00:49:11,350 --> 00:49:13,350
kas liecina n ².

811
00:49:13,350 --> 00:49:16,530
Labākajā gadījumā domu, pieņemsim, ka mēs arī tā jau sakārtoti sarakstu;

812
00:49:16,530 --> 00:49:19,270
mēs faktiski nav darīt jebkurā labāk nekā n ².

813
00:49:19,270 --> 00:49:21,730
Jo izvēle veida ir nekādi nevar zināt, ka

814
00:49:21,730 --> 00:49:25,540
minimālais elements ir tikai viens es gadās būt meklē.

815
00:49:25,540 --> 00:49:28,970
Tā joprojām ir jāpārliecinās, ka tas ir faktiski minimums.

816
00:49:28,970 --> 00:49:31,670
>> Un vienīgais veids, kā pārliecināties, ka tas ir minimālais, izmantojot šo algoritmu,

817
00:49:31,670 --> 00:49:34,640
ir apskatīt katru elementu vēlreiz.

818
00:49:34,640 --> 00:49:38,420
Tik tiešām, ja jūs arī tā - ja jūs sniegtu atlase kārtot jau sakārtoti sarakstu,

819
00:49:38,420 --> 00:49:42,720
tas nav gatavojas darīt jebkurā labāk nekā piešķirot tai sarakstu, kas nav sakārtots vēl.

820
00:49:42,720 --> 00:49:46,320
Starp citu, ja tas notiek, ir gadījums, ka kaut kas ir O (kaut)

821
00:49:46,320 --> 00:49:50,640
un kaut Omega, mēs varam tikai teikt kodolīgāk, ka tas ir θ par kaut ko.

822
00:49:50,640 --> 00:49:52,760
Tātad, ja jūs redzat, ka nākt klajā visur, tas ir tas, ko tas nozīmē tikai to.

823
00:49:52,760 --> 00:49:57,580
>> Ja kaut kas ir Theta n ², tas ir gan liels O (n ²) un Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Lai vislabāk lietu un sliktākajā gadījumā, tas nav kaut ko mainīt,

825
00:49:59,790 --> 00:50:04,400
algoritms ir gatavojas darīt to pašu katru reizi.

826
00:50:04,400 --> 00:50:06,610
Tātad tas ir tas, ko pseudocode par atlases veida varētu izskatīties.

827
00:50:06,610 --> 00:50:10,630
Mēs būtībā gatavojas teikt, ka es gribu atkārtot pa sarakstu

828
00:50:10,630 --> 00:50:15,180
no kreisās uz labo, un katrā atkārtojuma no cilpas, es esmu gatavojas pārvietot

829
00:50:15,180 --> 00:50:19,780
minimālais elements šajā sakārtoti daļu sarakstu.

830
00:50:19,780 --> 00:50:23,260
Un, kad es pārvietot kaut ko tur, es nekad nepieciešams apskatīt šo elementu vēlreiz.

831
00:50:23,260 --> 00:50:28,600
Jo tiklīdz es swap elements, lai kreisajā segmentā sarakstā, tas ir sakārtoti

832
00:50:28,600 --> 00:50:32,600
jo mēs darām visu, kas ir augošā secībā, izmantojot minimums.

833
00:50:32,600 --> 00:50:38,740
Tāpēc mēs teicām, labi, mēs esam pie stāvoklī man, un mums ir jāskatās uz visu elementu

834
00:50:38,740 --> 00:50:42,260
tiesībām uz i, lai atrastu minimumu.

835
00:50:42,260 --> 00:50:46,150
Tātad tas nozīmē, ka mēs gribam izskatīties no i + 1 līdz saraksta beigām.

836
00:50:46,150 --> 00:50:51,610
Un tagad, ja elements, ka mēs pašlaik meklē ir mazāka nekā mūsu minimumu līdz šim,

837
00:50:51,610 --> 00:50:54,190
kas, atcerieties, mēs sākam minimālo off vienkārši būt

838
00:50:54,190 --> 00:50:57,020
neatkarīgi elements mēs šobrīd, es pieņemu, ka ir minimums.

839
00:50:57,020 --> 00:51:00,270
Ja es atrastu elementu, kas ir mazāks nekā, tad es esmu gatavojas teikt, labi,

840
00:51:00,270 --> 00:51:02,700
labi, man ir atraduši jaunu minimumu.

841
00:51:02,700 --> 00:51:06,080
Es esmu gatavojas atcerēties, kur tas minimums bija.

842
00:51:06,080 --> 00:51:09,560
>> Tāpēc tagad, kad esmu gājusi caur šo labo nešķirotu segmentā,

843
00:51:09,560 --> 00:51:16,690
Es varu teikt, es esmu gatavojas apmainīt minimālo elementu ar elementu, kas ir stāvoklī man.

844
00:51:16,690 --> 00:51:21,100
Kas notiek, lai izveidotu savu sarakstu, mans sakārtoti daļa saraksta, no kreisās uz labo pusi,

845
00:51:21,100 --> 00:51:25,190
un mums nav kādreiz nepieciešams apskatīt elementu atkal reiz tas ir tā daļa.

846
00:51:25,190 --> 00:51:27,930
Tiklīdz mēs esam aizstāja to.

847
00:51:27,930 --> 00:51:30,260
Tāpēc pieņemsim darboties atlases veida šajā sarakstā.

848
00:51:30,260 --> 00:51:38,220
Zils elements šeit būs man, un sarkanā elements būs minimālais elements.

849
00:51:38,220 --> 00:51:41,570
Tāpēc es sāk visu ceļu pa kreisi no saraksta, lai pie 5.

850
00:51:41,570 --> 00:51:44,610
Tagad mums ir nepieciešams, lai atrastu minimālo nešķirotu elementu.

851
00:51:44,610 --> 00:51:49,480
Tātad mēs teiksim 0 <5, tāpēc 0 ir mans jaunais minimums.

852
00:51:49,480 --> 00:51:53,820
>> Bet es nevaru apstāties tur, jo, pat ja mēs varam atzīt, ka 0 ir mazākais,

853
00:51:53,820 --> 00:51:59,390
Mums ir nepieciešams, lai palaistu cauri jebkuru citu elementu sarakstu, lai pārliecinātos.

854
00:51:59,390 --> 00:52:01,760
Lai 1 ir lielāks, 6 ir lielāks, 4 ir lielāks.

855
00:52:01,760 --> 00:52:05,850
Tas nozīmē, ka pēc apskatot visus šos elementus, es esmu nosaka 0 ir mazākais.

856
00:52:05,850 --> 00:52:09,800
Tāpēc es esmu gatavojas swap 5, 0.

857
00:52:09,800 --> 00:52:15,480
Kad man swap, ka es esmu gatavojas saņemt jaunu sarakstu, un es zinu, ka man nekad nav nepieciešams apskatīt 0, kas atkal

858
00:52:15,480 --> 00:52:19,380
jo kad es esmu nomainīju, es esam sakārtoti, un mēs esam darīts.

859
00:52:19,380 --> 00:52:22,730
Tagad tas tikai tā notiek, ka zilā elements ir atkal 5,

860
00:52:22,730 --> 00:52:26,030
un mums ir jāskatās uz 1, 6 un 4 noteikt, ka 1

861
00:52:26,030 --> 00:52:31,520
ir mazākā minimālā elements, tāpēc mēs swap 1 un 5.

862
00:52:31,520 --> 00:52:36,890
Atkal, mums ir jāskatās uz - salīdzināt 5 augstāks 6, 4,

863
00:52:36,890 --> 00:52:39,830
un mēs esam gatavojas swap 4, 5, un, visbeidzot, salīdzināt

864
00:52:39,830 --> 00:52:45,740
šie 2 numuri un mijmaiņas tiem līdz mēs saņemt mūsu sakārtoti sarakstu.

865
00:52:45,740 --> 00:52:49,730
Visus jautājumus par atlases veida?

866
00:52:49,730 --> 00:52:56,420
Labi. Pieņemsim pāriet uz pēdējo tēmu šeit, un tas ir rekursija.

867
00:52:56,420 --> 00:52:59,810
>> Rekursija, atcerieties, tas ir patiešām meta lieta, ja funkcija

868
00:52:59,810 --> 00:53:02,740
atkārtoti aicina sevi.

869
00:53:02,740 --> 00:53:05,620
Tāpēc pie kādā brīdī, bet mūsu fuction ir vairākkārt zvana pats,

870
00:53:05,620 --> 00:53:10,100
tur, jāatrod punkts, kurā mēs pārtraukt zvana sevi.

871
00:53:10,100 --> 00:53:13,670
Jo, ja mēs nedarām, tad mēs esam tikai gatavojas turpināt to darīt mūžīgi,

872
00:53:13,670 --> 00:53:16,660
un mūsu programma ir vienkārši nav gatavojas pārtraukt.

873
00:53:16,660 --> 00:53:19,200
Mēs saucam šo nosacījumu gadījumu.

874
00:53:19,200 --> 00:53:22,570
Un bāzes scenārijs saka, nevis zvana funkciju atkal,

875
00:53:22,570 --> 00:53:25,330
Es esmu tikai gatavojas atgriezties kādu vērtību.

876
00:53:25,330 --> 00:53:28,080
Tātad, kad mēs esam atgriezušies vērtību, esam pārtraukuši zvanot sevi,

877
00:53:28,080 --> 00:53:32,550
un zvaniem mēs esam padarījuši tik tālu atpūtas var arī atgriezties.

878
00:53:32,550 --> 00:53:36,050
Bāzes lietas pretī ir rekursīvs gadījums.

879
00:53:36,050 --> 00:53:39,050
Un tas ir, kad mēs vēlamies veikt citu zvanu funkciju, ka mēs pašlaik iekšā

880
00:53:39,050 --> 00:53:44,690
Un mēs, iespējams, kaut arī ne vienmēr, vēlas izmantot dažādus argumentus.

881
00:53:44,690 --> 00:53:48,940
>> Tātad, ja mums ir funkciju sauc f, un f tikai sauc ņem 1 argumentu,

882
00:53:48,940 --> 00:53:52,010
un mēs tikai glabāt zvanot f (1), f (1), f (1), un tas tikai tā notiek, ka

883
00:53:52,010 --> 00:53:56,510
arguments 1 iekrīt rekursīvo gadījumā mēs vēl nekad gatavojas pārtraukt.

884
00:53:56,510 --> 00:54:01,620
Pat ja mums ir bāzes scenārijs, mums ir nepieciešams, lai pārliecinātos, ka galu galā mēs ejam, lai sasniegtu šo gadījumu.

885
00:54:01,620 --> 00:54:04,250
Mēs ne tikai glabāt uzturas šajā rekursīvs gadījumā.

886
00:54:04,250 --> 00:54:09,870
Parasti, kad mēs saucam sevi, mēs, iespējams, nāksies atšķirīgu argumentu katru reizi.

887
00:54:09,870 --> 00:54:12,700
Te ir ļoti vienkāršs rekursīvas funkcijas.

888
00:54:12,700 --> 00:54:15,090
Tāpēc šī būs compute faktoriālu numuru.

889
00:54:15,090 --> 00:54:17,790
Līdz top šeit mums ir mūsu gadījumu.

890
00:54:17,790 --> 00:54:22,330
Gadījumā, n ≤ 1, mēs nebrauksim, lai izsauktu faktoriāls vēlreiz.

891
00:54:22,330 --> 00:54:26,490
Mēs ejam, lai apturētu, mēs esam tikai gatavojas atgriezties kādu vērtību.

892
00:54:26,490 --> 00:54:30,170
Ja tas tā nav taisnība, tad mēs ejam, lai sasniegtu mūsu rekursīvas lietu.

893
00:54:30,170 --> 00:54:33,550
Ievērojiet, ka mēs esam ne tikai zvanot faktoriāls (n), jo tas nebūtu ļoti noderīga.

894
00:54:33,550 --> 00:54:36,810
Mēs ejam, lai izsauktu faktoriālu kaut kas cits.

895
00:54:36,810 --> 00:54:40,850
>> Un lai jūs varētu redzēt, galu galā, ja mēs iet faktoriālo (5) vai kaut ko,

896
00:54:40,850 --> 00:54:45,900
mēs spēsim zvanīt faktoriāls (4) un tā tālāk, un galu galā mēs esam gatavojas skārusi šo gadījumu.

897
00:54:45,900 --> 00:54:51,730
Tāpēc tas izskatās labi. Paskatīsimies, kas notiek, kad mēs faktiski palaist to.

898
00:54:51,730 --> 00:54:57,840
Šis ir kaudze, un pieņemsim, ka galvenais ir gatavojas nosaukt šo funkciju ar argumentu (4).

899
00:54:57,840 --> 00:55:02,200
Lai vienreiz faktoriālo redz un = 4, faktoru aicinās pati.

900
00:55:02,200 --> 00:55:05,010
Tagad pēkšņi, mums ir faktoriālu (3).

901
00:55:05,010 --> 00:55:10,780
Tāpēc šie funkcijas gatavojas glabāt pieaug līdz beidzot mēs hit mūsu gadījumu.

902
00:55:10,780 --> 00:55:17,830
Šajā brīdī, atgriešanās vērtību šī ir atgriešanās (NX atgriešanās vērtību šo),

903
00:55:17,830 --> 00:55:21,290
atgriešanās vērtību tas ir NX atgriešanās vērtību to.

904
00:55:21,290 --> 00:55:23,290
Galu galā mums ir nepieciešams, lai sasniegtu dažas vairākus.

905
00:55:23,290 --> 00:55:26,560
Augšā šeit, mēs sakām atpakaļ 1.

906
00:55:26,560 --> 00:55:30,650
Tas nozīmē, ka, tiklīdz mēs atgriežamies šo numuru, mēs varam pop šis pie skursteņa.

907
00:55:30,650 --> 00:55:36,570
Tātad šī faktoriāls (1) tiek darīts.

908
00:55:36,570 --> 00:55:41,190
Kad 1 atgriež, šis faktoriālās (1) deklarācijas, šī atgriešanās pret 1.

909
00:55:41,190 --> 00:55:46,910
Atgriešanās vērtību ar to, atceries, bija NX atgriešanās vērtību to.

910
00:55:46,910 --> 00:55:50,720
Tik pēkšņi, tas puisis zina, ka es gribu atgriezties 2.

911
00:55:50,720 --> 00:55:55,910
>> Līdz ar to atcerēties, atgriešanās vērtība tas ir tikai NX atgriešanās vērtība šeit.

912
00:55:55,910 --> 00:56:01,160
Tāpēc tagad mēs varam teikt 3 x 2, un visbeidzot, šeit mēs varam teikt

913
00:56:01,160 --> 00:56:04,010
tas ir tikai būs 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
Un, kad tas atgriežas, mēs nokļūt uz leju, lai vienu skaitlim iekšpusē galvenais.

915
00:56:09,570 --> 00:56:15,460
Kādi jautājumi par recursion?

916
00:56:15,460 --> 00:56:17,090
Labi. Tāpēc tur vairāk laika jautājumiem beigās,

917
00:56:17,090 --> 00:56:23,360
bet tagad Jāzeps būs segtu atlikušās tēmām.

918
00:56:23,360 --> 00:56:25,590
>> [Džozefs Ong] Nu labi. Tāpēc tagad, ka mēs esam runājuši par recursions,

919
00:56:25,590 --> 00:56:27,840
parunāsim mazliet par to, ko apvienot kārtošanas ir.

920
00:56:27,840 --> 00:56:31,740
Sapludināt kārtošanas ir pamatā citu veids šķirošanas sarakstu numuriem.

921
00:56:31,740 --> 00:56:36,430
Un kā tā darbojas, ir, ar sapludināšanas veida jums ir saraksts, un ko mēs darām, ir

922
00:56:36,430 --> 00:56:39,120
mēs sakām, pieņemsim sadalīt šo par 2 daļās.

923
00:56:39,120 --> 00:56:42,750
Mēs vispirms palaist apvienoties kārtot atkal kreisajā pusē,

924
00:56:42,750 --> 00:56:45,040
tad mēs rādīsim apvienot kārtot labajā pusē,

925
00:56:45,040 --> 00:56:50,240
un tas dod mums tagad 2 pusītes, kas ir sakārtoti, un tagad mēs esam gatavojas apvienot šos pusītes kopā.

926
00:56:50,240 --> 00:56:55,010
Tas mazliet grūti redzēt bez Piemēram, tāpēc mēs iet caur priekšlikumus un redzēt, kas notiek.

927
00:56:55,010 --> 00:56:59,590
Tātad jūs sākat ar šo sarakstu, mēs sadalīt to 2 daļās.

928
00:56:59,590 --> 00:57:02,300
Mēs palaist apvienot kārtot uz kreisajā pusē pirmais.

929
00:57:02,300 --> 00:57:06,660
Tātad, tas ir kreisajā pusē, un tagad mēs palaist tos caur šo sarakstu vēlreiz

930
00:57:06,660 --> 00:57:09,800
kas izpaužas nonākt sapludināšanas kārtot, un tad mēs skatāmies, atkal,

931
00:57:09,800 --> 00:57:13,270
kreisajā pusē šī saraksta, un mēs palaist apvienot šķirot par to.

932
00:57:13,270 --> 00:57:15,880
Tagad mēs uz leju, lai sarakstu 2 numuriem,

933
00:57:15,880 --> 00:57:19,010
un tagad kreisā puse ir tikai 1 elements garš, un mēs nevaram

934
00:57:19,010 --> 00:57:23,380
sadalīt sarakstu, kas ir tikai 1 elements uz pusi, tāpēc mēs tikai teikt, kad mums ir 50,

935
00:57:23,380 --> 00:57:26,400
kas ir tikai 1 elements, tas jau ir sakārtoti.

936
00:57:26,400 --> 00:57:29,860
>> Kad mēs esam darīts ar to, ka mēs varam redzēt, ka mēs varam

937
00:57:29,860 --> 00:57:32,230
pāriet uz labo pusi no šā saraksta,

938
00:57:32,230 --> 00:57:36,480
un 3 ir arī sakārtots, un tāpēc tagad, ka abi šīs saraksta pusītes ir sakārtoti

939
00:57:36,480 --> 00:57:39,080
mēs varam pievienoties šos skaitļus atpakaļ kopā.

940
00:57:39,080 --> 00:57:45,320
Lai mēs skatāmies uz 50 līdz 3; 3 ir mazāks par 50, tāpēc tas iet vispirms un tad 50 nāk iekšā

941
00:57:45,320 --> 00:57:49,340
Tagad, kas ir izdarīts, mēs ejam atpakaļ uz augšu uz šo sarakstu un kārtot tas ir labajā pusē.

942
00:57:49,340 --> 00:57:52,440
42 ir tā paša skaits, tāpēc tas jau ir sakārtoti.

943
00:57:52,440 --> 00:57:57,850
Tātad tagad mēs salīdzinām šos 2 un 3 ir mazāks par 42, lai izpaužas likts pirmajā,

944
00:57:57,850 --> 00:58:02,340
šobrīd 42 izpaužas nodot, un 50 izpaužas likts iekšā

945
00:58:02,340 --> 00:58:07,220
Tagad, kas ir sakārtoti, mēs ejam visu ceļu atpakaļ uz augšu, 1337 un 15.

946
00:58:07,220 --> 00:58:14,560
Nu, mēs tagad apskatīt kreisajā pusē šajā sarakstā; 1337 ir pats par sevi, lai tas ir sakārtoti un pats ar 15.

947
00:58:14,560 --> 00:58:19,020
Tātad tagad mēs apvienojam šos 2 numurus sakārtotu šo sākotnējo sarakstu, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
tāpēc tas iet pa priekšu, tad 1337 iet iekšā

949
00:58:23,060 --> 00:58:26,640
Un tagad mēs sakārtoti abas pusītes sākotnējā sarakstā līdz top.

950
00:58:26,640 --> 00:58:30,440
Un viss, kas mums jādara, ir apvienot šos.

951
00:58:30,440 --> 00:58:36,890
Mēs skatāmies uz pirmajām 2 numuriem šajā sarakstā, 3 <15, tāpēc tas nonāk kārtošanas masīva pirmās.

952
00:58:36,890 --> 00:58:44,460
15 <42, tāpēc tas iet iekšā Tagad, 42 <1337, kas iet iekšā

953
00:58:44,460 --> 00:58:51,010
50 <1337, tāpēc tas iet iekšā un paziņo, ka mēs vienkārši bija 2 skaitļus pie šī saraksta.

954
00:58:51,010 --> 00:58:53,640
Tāpēc mēs esam ne tikai pārmaiņus starp 2 sarakstiem.

955
00:58:53,640 --> 00:58:56,050
Mēs esam tikai meklē sākumā, un mēs esam ņemot elements

956
00:58:56,050 --> 00:59:00,270
tas ir mazāks, un tad nodot to mūsu masīvs.

957
00:59:00,270 --> 00:59:04,080
Tagad mēs esam apvienoti visi pusītes, un mēs esam darīts.

958
00:59:04,080 --> 00:59:07,780
>> Kādi jautājumi par apvienoties šķirot? Jā?

959
00:59:07,780 --> 00:59:14,190
[Studentu] Ja tas ir sadalīšana dažādās grupās, kāpēc ne viņi vienkārši sadalīt to vienu reizi

960
00:59:14,190 --> 00:59:19,970
un jums ir 3 un 2 grupā? [Pārējā jautājums nesaprotams]

961
00:59:19,970 --> 00:59:24,940
Iemesls - tāpēc jautājums ir, kāpēc mēs nevaram vienkārši apvienot tos tajā pirmo soli, kad mēs tos?

962
00:59:24,940 --> 00:59:29,530
Iemesls, kāpēc mēs varam darīt, sāciet pie kreisās visvairāk elementiem abās pusēs,

963
00:59:29,530 --> 00:59:33,040
un tad uz mazāku vienu un nodot to, ka mēs zinām, ka šie

964
00:59:33,040 --> 00:59:35,290
individuālie saraksti ir sakārtoti pasūtījumiem.

965
00:59:35,290 --> 00:59:37,290
Tātad, ja es esmu meklē kreisās visvairāk elementiem abās pusēs,

966
00:59:37,290 --> 00:59:40,490
Es zinu, viņi būs mazākais elementi šajos sarakstos.

967
00:59:40,490 --> 00:59:43,930
Lai es varētu nodot tos mazākajiem elementu plankumi šo lielo sarakstu.

968
00:59:43,930 --> 00:59:47,810
No otras puses, ja es paskatos šiem 2 sarakstiem otrā līmeņa tur,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 un 15, tie netiek šķiroti.

970
00:59:51,640 --> 00:59:55,770
Tātad, ja es paskatos 50 un 1337, es esmu gatavojas īstenot 50 manā sarakstā pirmais.

971
00:59:55,770 --> 01:00:00,130
Bet tas nav īsti jēgas, jo 3 ir mazākais elements no visiem no tiem.

972
01:00:00,130 --> 01:00:04,390
Tāpēc vienīgais iemesls, kāpēc mēs varam darīt šo apvieno soli ir tāpēc, ka mūsu saraksti jau ir sakārtots.

973
01:00:04,390 --> 01:00:07,010
Kurš ir iemesls, kāpēc mums ir jāķeras visu ceļu uz leju

974
01:00:07,010 --> 01:00:09,800
jo, ja mums ir tikai viens numurs, jūs zināt, ka viens numurs

975
01:00:09,800 --> 01:00:14,120
un pats par sevi jau ir sakārtoti sarakstā.

976
01:00:14,120 --> 01:00:19,360
>> Kādi jautājumi? Nē?

977
01:00:19,360 --> 01:00:24,260
Sarežģītību? Nu, jūs varat redzēt, ka katrā solī tur gala skaitļi,

978
01:00:24,260 --> 01:00:27,590
un mēs varam sadalīt sarakstu puslogaritmiskiem n reizes,

979
01:00:27,590 --> 01:00:31,700
kas ir, ja mēs šo n x log n sarežģītību.

980
01:00:31,700 --> 01:00:34,940
Un jūs redzēsiet labākajā gadījumā uz merge veida ir n log n, un tas tikai tā notiek

981
01:00:34,940 --> 01:00:39,340
ka sliktākajā gadījumā, vai arī tur Ω, ir arī n log n.

982
01:00:39,340 --> 01:00:42,480
Kaut kas jāpatur prātā.

983
01:00:42,480 --> 01:00:45,750
Attīstība, iesim uz kādu super pamata failu I / O.

984
01:00:45,750 --> 01:00:48,830
Ja jūs paskatījās motokross, jūs pamanīsiet mums bija kaut kādas sistēmas

985
01:00:48,830 --> 01:00:51,270
kur jūs varētu rakstīt log failu, ja jūs lasīt, izmantojot kodu.

986
01:00:51,270 --> 01:00:53,730
Let 's redzēt, kā jūs varētu darīt.

987
01:00:53,730 --> 01:00:57,450
Nu, mums ir fprintf, ko jūs varat iedomāties, kā tikai printf,

988
01:00:57,450 --> 01:01:01,720
bet tikai drukāšanas failā, nevis, un līdz ar to f sākumā.

989
01:01:01,720 --> 01:01:07,570
Šāda veida koda šeit, ko tā dara, ir, kā jūs varētu būt redzams motokross,

990
01:01:07,570 --> 01:01:12,310
tā iet caur jūsu 2-dimensiju masīvu izdrukāt rindu pa rindai, ko numuri.

991
01:01:12,310 --> 01:01:17,850
Šajā gadījumā, printf izdrukā jūsu terminālu vai to, ko mēs saucam standarta produkciju sadaļā.

992
01:01:17,850 --> 01:01:22,170
>> Un tagad, šajā gadījumā, viss, kas mums ir jādara, ir aizstāt printf ar fprintf,

993
01:01:22,170 --> 01:01:26,770
pateikt to, ko failu jūs vēlaties drukāt, un šajā gadījumā tā tikai izdrukas to, lai šo failu

994
01:01:26,770 --> 01:01:32,230
vietā izdrukāt to, lai jūsu terminālu.

995
01:01:32,230 --> 01:01:36,500
Nu, tad tas rodas jautājums: Kur mēs iegūt šāda veida failu no, labi?

996
01:01:36,500 --> 01:01:39,840
Mēs nodots pieteikties uz šo fprintf fuction bet mums nebija ne jausmas, no kurienes tas nācis.

997
01:01:39,840 --> 01:01:43,980
Nu, sākumā kodu, kas mums bija bija šī rieciens koda nekā šeit,

998
01:01:43,980 --> 01:01:48,340
kas būtībā saka, ka atvērts fails aicina log.txt.

999
01:01:48,340 --> 01:01:53,220
Ko mēs darām pēc tam ir mums ir jāpārliecinās, ka fails ir faktiski atvērts veiksmīgi.

1000
01:01:53,220 --> 01:01:57,070
Tātad tas varētu neizdoties vairāku iemeslu dēļ, jums nav pietiekami daudz vietas uz jūsu datora, piemēram.

1001
01:01:57,070 --> 01:01:59,790
Tātad, tas vienmēr ir svarīgi, pirms jūs darīt nekādas darbības ar failu

1002
01:01:59,790 --> 01:02:03,300
mēs pārbaudītu, vai šī lieta tika atklāta veiksmīgi.

1003
01:02:03,300 --> 01:02:09,330
Tātad, kādi ka, tas ir arguments, fopen, labi, mēs varam atvērt failu daudzos veidos.

1004
01:02:09,330 --> 01:02:13,510
Ko mēs varam darīt, ir, mēs varam nodot to w, kas nozīmē ignorēt failu, ja tas izejām jau,

1005
01:02:13,510 --> 01:02:18,070
Mēs varam iet A, ko viņi pievienot uz beigām failu, nevis svarīgas to,

1006
01:02:18,070 --> 01:02:22,730
vai mēs varam norādīt r, kas nozīmē, pieņemsim atvērt failu kā tikai lasāmu.

1007
01:02:22,730 --> 01:02:24,890
Tātad, ja programma mēģina veikt izmaiņas failā,

1008
01:02:24,890 --> 01:02:30,140
bļaut pie viņiem, un neļaujiet viņiem to darīt.

1009
01:02:30,140 --> 01:02:33,320
Visbeidzot, kad mēs pabeigsim ar failu, beidzis darot operācijas par to,

1010
01:02:33,320 --> 01:02:35,860
Mums ir nepieciešams, lai pārliecinātos, ka mēs aizveriet failu.

1011
01:02:35,860 --> 01:02:38,830
Un tā beigās savu programmu, jūs gatavojas nodot tos atkal

1012
01:02:38,830 --> 01:02:42,120
Šis fails, kuru atklāja, un tikai aizveriet to.

1013
01:02:42,120 --> 01:02:44,650
Tātad tas ir kaut kas svarīgs, ka jums ir, lai pārliecinātos, jums.

1014
01:02:44,650 --> 01:02:47,180
Līdz ar to atcerēties jūs varat atvērt failu, tad jūs varat rakstīt uz failu,

1015
01:02:47,180 --> 01:02:51,270
darīt operācijas failā, bet tad jums ir slēgt lietu beigās.

1016
01:02:51,270 --> 01:02:53,270
>> Visus jautājumus par pamata failu I / O? Jā?

1017
01:02:53,270 --> 01:02:58,050
[Studentu jautājums, nesaprotami]

1018
01:02:58,050 --> 01:03:02,480
Tieši šeit. Jautājums ir, ja tas log.txt fails parādās?

1019
01:03:02,480 --> 01:03:07,890
Nu, ja jūs Dāvini log.txt, tas rada to pašā direktorijā, kā izpildāmā.

1020
01:03:07,890 --> 01:03:10,500
Tātad, ja jūs esat nokļuvis - >> [Studentu jautājums, nesaprotami]

1021
01:03:10,500 --> 01:03:18,830
Jā. Tajā pašā mapē, vai tajā pašā direktorijā, kā jūs to saucat.

1022
01:03:18,830 --> 01:03:21,400
Tagad atmiņas, kaudze, un kaudze.

1023
01:03:21,400 --> 01:03:23,400
Tātad, kā ir atmiņa, kas veic ar datoru?

1024
01:03:23,400 --> 01:03:26,270
Nu, jūs varat iedomāties, atmiņas kā sava veida šajā blokā šeit.

1025
01:03:26,270 --> 01:03:30,260
Un atmiņā mums ir ko sauc kaudze iestrēdzis tur, un kaudze, kas ir tur lejā.

1026
01:03:30,260 --> 01:03:34,480
Un kaudze aug lejup un kaudze aug uz augšu.

1027
01:03:34,480 --> 01:03:38,620
Tā kā Tomijs minēts - ak, labi, un mums ir šie citi 4 segmenti, ko es nopirkšu uz otro -

1028
01:03:38,620 --> 01:03:42,890
Kā Tommy teica agrāk, jūs zināt, cik viņa funkcijas sevi sauc un sauc viens otru?

1029
01:03:42,890 --> 01:03:44,930
Viņi veidot šāda veida kaudze rāmi.

1030
01:03:44,930 --> 01:03:47,360
Nu, ja galvenie zvani foo, foo izpaužas likts uz skursteņa.

1031
01:03:47,360 --> 01:03:52,430
Foo aicina, bārs iegūt s likts uz skursteņa, un kas izpaužas likts uz skursteņa pēc.

1032
01:03:52,430 --> 01:03:57,040
Un kā viņi atgriezīsies, viņi katrs saņem pacēlies kaudzīti.

1033
01:03:57,040 --> 01:04:00,140
Ko katrs no šīm vietām un atmiņas turēt?

1034
01:04:00,140 --> 01:04:03,110
Nu, top, kas ir teksta segments, satur pati programma.

1035
01:04:03,110 --> 01:04:06,390
Tāpēc mašīnu kodu, kas ir tur, kad jūs sastādīt savu programmu.

1036
01:04:06,390 --> 01:04:08,520
Nākamais, kāds inicializēts pasaules mainīgie.

1037
01:04:08,520 --> 01:04:12,660
>> Tātad jums ir globālas mainīgos savā programmā, un jūs sakāt, piemēram, a = 5,

1038
01:04:12,660 --> 01:04:15,260
kas izpaužas likts šajā segmentā, un tiesības saskaņā ar to,

1039
01:04:15,260 --> 01:04:18,990
Jums ir kādi neinicializēts globālu datu, kas ir tikai Int,

1040
01:04:18,990 --> 01:04:20,990
bet jums nav teikt, tas ir vienāds ar neko.

1041
01:04:20,990 --> 01:04:23,870
Realizēt tie ir globālie mainīgie, lai viņi ārpus galvenā.

1042
01:04:23,870 --> 01:04:28,560
Tātad tas nozīmē, kādi pasaules mainīgie, kas ir deklarējušas, bet netiek inicializēts.

1043
01:04:28,560 --> 01:04:32,310
Tātad, kas ir kaudzes? Atmiņas piešķirti izmantojot malloc, ko mēs sāksim ar mazliet.

1044
01:04:32,310 --> 01:04:35,990
Un visbeidzot, ar kaudze jums ir kādi vietējo mainīgie

1045
01:04:35,990 --> 01:04:39,950
un visas funkcijas jūs varētu zvanīt jebkurā no saviem parametriem.

1046
01:04:39,950 --> 01:04:43,720
Pēdējā lieta, jums nav īsti ir jāzina, ko vides mainīgie darīt,

1047
01:04:43,720 --> 01:04:46,700
bet kad tu palaist programmu, ir saistīts kaut kas, piemēram,

1048
01:04:46,700 --> 01:04:49,550
tas ir lietotājvārds personai, kas vadīja programmu.

1049
01:04:49,550 --> 01:04:51,550
Un tas būs sava veida apakšā.

1050
01:04:51,550 --> 01:04:54,540
Runājot par atmiņas adreses, kas ir heksadecimālo vērtību,

1051
01:04:54,540 --> 01:04:58,170
Augšdaļā sākas ar 0 vērtības, un viņi iet visu ceļu uz leju, lai apakšā.

1052
01:04:58,170 --> 01:05:00,440
Šajā gadījumā, ja jūs esat par 32 bitu sistēmā,

1053
01:05:00,440 --> 01:05:05,390
apakšā adrese būs 0x, kam seko AF, jo tas ir 32 bitu,

1054
01:05:05,390 --> 01:05:10,890
kas ir 8 baiti, un šajā gadījumā 8 biti atbilst 8 heksadecimālo cipariem.

1055
01:05:10,890 --> 01:05:20,110
Tātad noteikti šeit jūs gatavojas ir, piemēram, 0xffffff, un tur jūs nāksies 0.

1056
01:05:20,110 --> 01:05:23,660
Tātad, kādi ir norādes? Daži no jums, iespējams, nav ietverti šajā sadaļā iepriekš.

1057
01:05:23,660 --> 01:05:26,660
bet mēs iet pār to lekciju, tāpēc rādītājs ir tikai datu tips

1058
01:05:26,660 --> 01:05:34,030
kas veikalos, nevis kaut kādu vērtību, piemēram, 50, tas saglabā adresi kādu vietu atmiņā.

1059
01:05:34,030 --> 01:05:36,020
Tāpat kā šīs atmiņas [nesaprotams].

1060
01:05:36,020 --> 01:05:41,120
Tātad šajā gadījumā, ko mēs esam, ir, mums ir rādītāju līdz veselam skaitlim vai int *,

1061
01:05:41,120 --> 01:05:46,210
un tā satur šo heksadecimālo adresi 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Tātad, kas mums ir, tagad, šis rādītājs norāda uz kādu vietu atmiņā,

1063
01:05:50,880 --> 01:05:56,020
un tas ir tikai, vērtība 50 ir šajā atmiņas vietā.

1064
01:05:56,020 --> 01:06:01,810
Par dažiem 32-bitu sistēmas, uz visiem 32-bitu sistēmas, norādes aizņem 32 bitus vai 4 baiti.

1065
01:06:01,810 --> 01:06:06,020
Bet, piemēram, uz 64-bitu sistēmas, norādes ir 64 biti.

1066
01:06:06,020 --> 01:06:08,040
Tā ka ir kaut kas jūs vēlaties paturēt prātā.

1067
01:06:08,040 --> 01:06:12,310
Tātad uz gala-bitu sistēmas, rādītājs ir beigas bitus garš.

1068
01:06:12,310 --> 01:06:17,320
Norādes ir sava veida grūti sagremot bez papildus lietām,

1069
01:06:17,320 --> 01:06:20,300
tāpēc pieņemsim iet caur piemēru par dinamisku atmiņas sadalījumu.

1070
01:06:20,300 --> 01:06:25,130
Kas dinamiskā atmiņas sadale tas jums, vai to, ko mēs saucam malloc,

1071
01:06:25,130 --> 01:06:29,280
tas ļauj piešķirt kaut kādus datus ārpus komplekta.

1072
01:06:29,280 --> 01:06:31,830
Tātad šie dati ir sava veida vairāk pastāvīgo uz programmas darbības laiku.

1073
01:06:31,830 --> 01:06:36,430
Jo, kā jūs zināt, ja jūs atzīt x iekšpusē funkciju, un ka funkcija atgriež,

1074
01:06:36,430 --> 01:06:40,910
jums vairs nav piekļuves datiem, kas tika glabāti x.

1075
01:06:40,910 --> 01:06:44,420
Kas norādes ļaujiet mums darīt, ir tie ļauj mums saglabāt atmiņas vai veikala vērtības

1076
01:06:44,420 --> 01:06:46,840
citā segmentā atmiņu, proti, kaudze.

1077
01:06:46,840 --> 01:06:49,340
Tagad, kad mēs atgriežamies no funkciju, kamēr mums ir rādītāju

1078
01:06:49,340 --> 01:06:54,960
uz šo vietu atmiņā, tad ko mēs varam darīt, ir, mēs varam tikai apskatīt vērtībām tur.

1079
01:06:54,960 --> 01:06:58,020
Apskatīsim piemēru: Tas ir mūsu atmiņa izkārtojums atkal.

1080
01:06:58,020 --> 01:07:00,050
Un mums ir šī funkcija, galvenais.

1081
01:07:00,050 --> 01:07:06,870
Kas tas ir - labi, tik vienkārši, vai ne? - Int x = 5, tas ir tikai mainīgo uz skursteņa, kas galvenais.

1082
01:07:06,870 --> 01:07:12,450
>> No otras puses, tagad mēs paziņojam rādītāju, kas izsauc funkciju giveMeThreeInts.

1083
01:07:12,450 --> 01:07:16,800
Un tāpēc tagad mēs iedziļināties šīs funkcijas, un mēs izveidot jaunu kaudze rāmi par to.

1084
01:07:16,800 --> 01:07:20,440
Tomēr šajā kaudze rāmi, mēs paziņojam int * temp,

1085
01:07:20,440 --> 01:07:23,210
kas 3 mallocs integers mums.

1086
01:07:23,210 --> 01:07:25,880
Tātad lielums int dos mums cik daudz baitu tas int ir,

1087
01:07:25,880 --> 01:07:29,620
un malloc dod mums, ka daudzi baiti vietas uz kaudzes.

1088
01:07:29,620 --> 01:07:32,890
Tātad šajā gadījumā, mēs esam radījuši pietiekami daudz vietas uz 3 integers,

1089
01:07:32,890 --> 01:07:36,830
un kaudze ir veids tur, kas ir iemesls, kāpēc es esmu sastādīts to augstāk.

1090
01:07:36,830 --> 01:07:42,900
Kad mēs esam darīts, mēs atkal šeit, vajag tikai 3 Ints atgriezās,

1091
01:07:42,900 --> 01:07:47,000
un tas atgriež adresi, šajā gadījumā vairāk nekā ja šī atmiņa ir.

1092
01:07:47,000 --> 01:07:51,250
Un mēs noteikti rādītājs = slēdzi, un tur mums ir tikai viens rādītājs.

1093
01:07:51,250 --> 01:07:54,550
Bet ko tas funkcija atgriež ir stacked šeit un pazūd.

1094
01:07:54,550 --> 01:07:59,250
Tātad temperatūra pazūd, bet mēs joprojām saglabā adresi, kur

1095
01:07:59,250 --> 01:08:01,850
šos 3 integers ir iekšā elektrotīkla.

1096
01:08:01,850 --> 01:08:06,180
Tātad šo kopumu, tad norādes ir scoped lokāli uz sakrautas rāmi,

1097
01:08:06,180 --> 01:08:09,860
bet atmiņas, uz kuru tie atsaucas, ir kaudzes.

1098
01:08:09,860 --> 01:08:12,190
>> Vai ir jēga?

1099
01:08:12,190 --> 01:08:14,960
[Studentu] Vai jūs varētu atkārtot, ka? >> [Džozefs] Jā.

1100
01:08:14,960 --> 01:08:20,270
Tātad, ja es iet atpakaļ tikai mazliet, jūs redzēsiet, ka temp piešķirti

1101
01:08:20,270 --> 01:08:23,500
dažas atmiņas par sakraut tur.

1102
01:08:23,500 --> 01:08:28,680
Tātad, ja šī funkcija, giveMeThreeInts nopelnīt, šī kaudze šeit ir izzudīs.

1103
01:08:28,680 --> 01:08:35,819
Un līdz ar to kādu no mainīgajiem, kas šajā gadījumā, šis rādītājs, kas tika piešķirti sakrautas rāmī.

1104
01:08:35,819 --> 01:08:39,649
Kas notiek, izzudīs, bet kopš mēs atgriezāmies temp

1105
01:08:39,649 --> 01:08:46,330
un mēs noteikti rādītāju = temperatūra, rādītājs ir tagad gatavojas atzīmēt pašu atmiņas par atrašanās vietu, kā temp bija.

1106
01:08:46,330 --> 01:08:50,370
Tāpēc tagad, lai gan mēs zaudējam temp, ka vietējās rādītājs,

1107
01:08:50,370 --> 01:08:59,109
mēs joprojām saglabā atmiņas adresi, ko tā bija vērsta uz iekšpusi šo mainīgo rādītāju.

1108
01:08:59,109 --> 01:09:03,740
Jautājumi? Tas var būt sava veida mulsinoši tēmu, ja jums nav aizgājuši pār to sadaļā.

1109
01:09:03,740 --> 01:09:09,240
Mēs varam, jūsu TF noteikti iet pār to un, protams, mēs varam atbildēt uz jautājumiem

1110
01:09:09,240 --> 01:09:11,500
beigās pārskata sesijā šo.

1111
01:09:11,500 --> 01:09:14,220
Bet tas ir sava veida sarežģīts jautājums, un man ir vairāk piemēru, kas gatavojas parādās

1112
01:09:14,220 --> 01:09:18,790
kas palīdzēs noskaidrot, ko norādes patiesībā ir.

1113
01:09:18,790 --> 01:09:22,500
>> Šajā gadījumā, norādes ir līdzvērtīgi masīvi,

1114
01:09:22,500 --> 01:09:25,229
tāpēc es varu tikai izmantot šo rādītāju kā pats kā int masīvu.

1115
01:09:25,229 --> 01:09:29,840
Tāpēc es esmu indeksāciju uz 0, un mainot pirmo skaitlim 1,

1116
01:09:29,840 --> 01:09:39,689
mainot otro skaitlim līdz 2, un arī 3 skaitlim līdz 3.

1117
01:09:39,689 --> 01:09:44,210
Tā vairāk uz norādes. Nu, atgādināt Binky.

1118
01:09:44,210 --> 01:09:48,319
Šajā gadījumā mēs esam piešķirts rādītāju, vai mēs paziņoja rādītāju,

1119
01:09:48,319 --> 01:09:52,760
bet sākotnēji, kad es tikko paziņoja rādītāju, tas nav norādot uz jebkur atmiņā.

1120
01:09:52,760 --> 01:09:54,930
Tas ir tikai atkritumu vērtības iekšpusē no tā.

1121
01:09:54,930 --> 01:09:56,470
Tāpēc man nav ne jausmas, kur šis rādītājs ir vērsta uz.

1122
01:09:56,470 --> 01:10:01,630
Tā ir adrese, kas ir tikai piepildīta ar 0 un 1, kur tas sākotnēji tika atzīts.

1123
01:10:01,630 --> 01:10:04,810
Es nevaru darīt kaut ko ar šo kamēr es aicinu malloc par to

1124
01:10:04,810 --> 01:10:08,390
un tad tas dod man maz vietas uz kaudzes, kur es varētu likt vērtības iekšā.

1125
01:10:08,390 --> 01:10:11,980
Tad atkal, es nezinu, kas ir iekšā šīs atmiņas.

1126
01:10:11,980 --> 01:10:16,780
Tātad pirmā lieta man ir jādara, ir pārbaudīt, vai sistēma bija pietiekami daudz atmiņas

1127
01:10:16,780 --> 01:10:20,850
sniegt man atpakaļ 1 skaitlim ir pirmajā vietā, tāpēc es esmu to izdarīt pārbaudi.

1128
01:10:20,850 --> 01:10:25,020
Ja rādītājs ir nulle, kas nozīmē, ka tai nav pietiekami daudz vietas, vai kādu citu kļūda,

1129
01:10:25,020 --> 01:10:26,320
tāpēc es izietu no manas programmas.

1130
01:10:26,320 --> 01:10:29,400
 Bet, ja tas izdosies, tagad es varu izmantot šo rādītāju

1131
01:10:29,400 --> 01:10:35,020
un ko * rādītājs tas ir tas izriet kur adrese ir

1132
01:10:35,020 --> 01:10:38,480
kur šī vērtība ir, un tas nosaka, ka vienāda ar 1.

1133
01:10:38,480 --> 01:10:41,850
Tātad vairāk nekā šeit, mēs pārbaudītu, ja tas atmiņa pastāvēja.

1134
01:10:41,850 --> 01:10:45,380
>> Tiklīdz jūs zināt, tas ir, jūs varat nodot to

1135
01:10:45,380 --> 01:10:50,460
kāda vērtība jūs vēlaties nodot to, šajā gadījumā 1.

1136
01:10:50,460 --> 01:10:53,060
Kad mēs esam darīts ar to, jums ir nepieciešams, lai atbrīvotu šo rādītāju

1137
01:10:53,060 --> 01:10:57,160
jo mums ir nepieciešams, lai saņemtu atpakaļ uz sistēmu, ka atmiņas, kas jums lūdza pirmajā vietā.

1138
01:10:57,160 --> 01:10:59,690
Jo dators nav zināms, kad mēs esam darīts ar to.

1139
01:10:59,690 --> 01:11:02,510
Šajā gadījumā mēs skaidri stāsta to, labi, mēs esam darīts ar šo atmiņu.

1140
01:11:02,510 --> 01:11:10,780
Ja daži citi procesa vajadzībām tā, kāda cita programma ir vajadzīga, justies brīvi iet uz priekšu un ņemt to.

1141
01:11:10,780 --> 01:11:15,110
Ko mēs varam darīt, ir, mēs varam tikai iegūt adresi vietējās mainīgie par komplektu.

1142
01:11:15,110 --> 01:11:19,080
Tātad int x ir iekšpusē sakrautas rāmja galvenais.

1143
01:11:19,080 --> 01:11:23,060
Un, kad mēs izmantojam šī zīme, šo un operators, ko tas ir

1144
01:11:23,060 --> 01:11:27,310
tas aizņem x, un x ir tikai daži dati atmiņā, bet tā ir adrese.

1145
01:11:27,310 --> 01:11:33,790
Tas atrodas kaut kur. Tātad, aicinot un x, ko tas dara, ir tas dod mums adresi x.

1146
01:11:33,790 --> 01:11:38,430
To darot, mēs nesam rādītājs punktu kur x ir atmiņā.

1147
01:11:38,430 --> 01:11:41,710
Tagad mēs vienkārši kaut kas līdzīgs * x, mēs esam gatavojas saņemt 5 atpakaļ.

1148
01:11:41,710 --> 01:11:43,820
Zvaigzne sauc dereferencing to.

1149
01:11:43,820 --> 01:11:46,640
Jūs sekot adresi un jums par to vērtību uzglabā tur.

1150
01:11:51,000 --> 01:11:53,310
>> Kādi jautājumi? Jā?

1151
01:11:53,310 --> 01:11:56,500
[Studentu] Ja jums nav darīt to 3-smailo lieta, tas joprojām apkopotu?

1152
01:11:56,500 --> 01:11:59,490
Jā. Ja jums nav darīt to 3-rādītāju lieta, tas joprojām gatavojas apkopot,

1153
01:11:59,490 --> 01:12:02,720
bet es jums parādīs, kas notiek otrā, un bez to dara,

1154
01:12:02,720 --> 01:12:04,860
tas, ko mēs saucam atmiņas noplūde. Tu neesi un sistēma

1155
01:12:04,860 --> 01:12:07,850
atpakaļ savu atmiņu, lai pēc kāda laika programma ir gatavojas uzkrāt

1156
01:12:07,850 --> 01:12:10,940
Atmiņas ka tas nav, izmantojot, un nekas cits nevar izmantot.

1157
01:12:10,940 --> 01:12:15,750
Ja esat kādreiz redzējuši Firefox ar 1,5 miljoniem kilobaitu datorā,

1158
01:12:15,750 --> 01:12:17,840
uzdevumu pārvaldnieks, tas, kas notiek.

1159
01:12:17,840 --> 01:12:20,760
Jums ir atmiņas noplūde programmā ka viņi nav apstrādes.

1160
01:12:23,080 --> 01:12:26,240
Tātad, kā tas rādītājs aritmētika darbojas?

1161
01:12:26,240 --> 01:12:29,480
Nu, rādītājs aritmētiskais ir veida, piemēram indeksāciju masīvs.

1162
01:12:29,480 --> 01:12:36,370
Šajā gadījumā, man ir rādītāju, un to, ko es daru, ir man darīt rādītāja līdz pirmajam elementam

1163
01:12:36,370 --> 01:12:42,100
Šīs masīva 3 integers, ka es esmu piešķirto.

1164
01:12:42,100 --> 01:12:46,670
Tātad, tagad to, ko es daru, zvaigzne rādītājs vienkārši maina pirmo elementu sarakstā.

1165
01:12:46,670 --> 01:12:49,140
Star rādītājs 1 punktiem vairāk nekā šeit.

1166
01:12:49,140 --> 01:12:53,140
Tātad rādītājs ir vairāk nekā šeit, +1 rādītājs ir vairāk nekā šeit, rādītājs +2 ir vairāk nekā šeit.

1167
01:12:53,140 --> 01:12:56,610
>> Tik vienkārši pievienojot 1 ir tas pats, kas pārvietojas pa šo masīvu.

1168
01:12:56,610 --> 01:12:59,880
Ko mēs darām, ir, kad mēs rādītāju +1, jūs saņemsiet adresi nekā šeit,

1169
01:12:59,880 --> 01:13:04,180
un lai iegūtu vērtību šeit, jūs varat ievietot zvaigzne no visas izteiksmes

1170
01:13:04,180 --> 01:13:05,990
līdz dereference to.

1171
01:13:05,990 --> 01:13:09,940
Tātad, šajā gadījumā, es esmu nosakot pirmo vietu šajā masīvā ar 1,

1172
01:13:09,940 --> 01:13:13,970
Otro vietu līdz 2, un trešā vieta līdz 3.

1173
01:13:13,970 --> 01:13:18,180
Tad ko es daru vairāk nekā šeit ir es esmu izdrukāt mūsu rādītāju +1,

1174
01:13:18,180 --> 01:13:19,970
kas tikai dod man 2.

1175
01:13:19,970 --> 01:13:23,650
Tagad es esmu palielināšanai rādītāju, lai rādītājs ir vienāds rādītājs 1,

1176
01:13:23,650 --> 01:13:26,780
kas kustas uz priekšu.

1177
01:13:26,780 --> 01:13:30,810
Un tāpēc tagad, ja es izdrukāt rādītāju 1, rādītājs 1 tagad ir 3,

1178
01:13:30,810 --> 01:13:33,990
kas šajā gadījumā izdrukā 3.

1179
01:13:33,990 --> 01:13:36,560
Un, lai atbrīvotu kaut ko, šautriņu ka es arī tā

1180
01:13:36,560 --> 01:13:40,540
jābūt norādot sākumā masīva ko es saņēmu atpakaļ no malloc.

1181
01:13:40,540 --> 01:13:43,430
Tātad, šajā gadījumā, ja man bija, lai izsauktu 3 tieši šeit, tas nebūtu pareizi,

1182
01:13:43,430 --> 01:13:45,070
jo tas ir vidū masīva.

1183
01:13:45,070 --> 01:13:48,820
Man ir, lai atņemtu nokļūt uz sākotnējo atrašanās vietu

1184
01:13:48,820 --> 01:13:50,420
Sākotnējais pirmā vieta, pirms es varētu atbrīvot to.

1185
01:13:56,300 --> 01:13:58,450
Tātad, šeit ir vairāk jāiesaistās piemērs.

1186
01:13:58,450 --> 01:14:03,360
Šajā gadījumā, mēs esam piešķirot 7 rakstzīmes rakstzīmju masīvs.

1187
01:14:03,360 --> 01:14:06,480
>> Un šajā gadījumā tas, ko mēs darām, ir mēs looping pa pirmo 6 no tiem,

1188
01:14:06,480 --> 01:14:09,900
un mēs esam nosakot tos līdz Z.

1189
01:14:09,900 --> 01:14:13,350
Tātad, lai int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Tātad, rādītājs + es tikai dod mums, šajā gadījumā,

1191
01:14:16,220 --> 01:14:20,860
rādītājs, rādītājs +1, rādītājs +2 rādītājs +3, un tā tālāk un tā tālāk ar cilpu.

1192
01:14:20,860 --> 01:14:24,040
Ko tā gatavojas darīt, ir tas izpaužas ka adrese, dereferences tā, lai iegūtu vērtību,

1193
01:14:24,040 --> 01:14:27,440
un izmaiņas šī vērtība uz Z.

1194
01:14:27,440 --> 01:14:30,350
Tad beigās atcerieties, tas ir virkne, labi?

1195
01:14:30,350 --> 01:14:33,560
Visi virknes ir, lai izbeigtu ar nulles izbeidz raksturs.

1196
01:14:33,560 --> 01:14:38,620
Tātad, ko es daru, ir 6 rādītājs man likt null terminatora raksturs collas

1197
01:14:38,620 --> 01:14:43,980
Un tagad ko es esmu būtībā dara nekā šeit īsteno printf uz virkni, labi?

1198
01:14:43,980 --> 01:14:46,190
>> Tātad, ja tas printf tagad, kad tas ir sasnieguši virknes?

1199
01:14:46,190 --> 01:14:48,230
Kad tas hits null izbeidz raksturs.

1200
01:14:48,230 --> 01:14:52,030
Tātad, šajā gadījumā, mana sākotnējā rādītāja norāda uz sākuma šo masīva.

1201
01:14:52,030 --> 01:14:56,410
Es izdrukāt pirmo rakstzīmi. Es pārvietot to uz vienu.

1202
01:14:56,410 --> 01:14:58,420
Es izdrukāt šo rakstzīmi. Es pārvietot to pa.

1203
01:14:58,420 --> 01:15:02,180
Un es glabāt darot kamēr es beigs.

1204
01:15:02,180 --> 01:15:07,750
Un tagad beigas * rādītājs būs dereference šo un saņemt null izbeidz raksturs atpakaļ.

1205
01:15:07,750 --> 01:15:11,780
Un tāpēc mans kamēr cilpa iet tikai tad, kad šī vērtība nav Null izbeidz raksturs.

1206
01:15:11,780 --> 01:15:13,770
Tātad, tagad es izietu no šīs cilpas.

1207
01:15:18,780 --> 01:15:21,180
Un tāpēc, ja es atņemtu 6 no šīs rādītājs,

1208
01:15:21,180 --> 01:15:22,860
Es iet atpakaļ visu ceļu uz sākumu.

1209
01:15:22,860 --> 01:15:27,880
Atcerieties, es esmu to izdarīt, jo man jādodas uz sākumu, lai atbrīvotu to.

1210
01:15:27,880 --> 01:15:30,270
>> Tātad, es zinu, ka bija daudz. Vai ir kādi jautājumi?

1211
01:15:30,270 --> 01:15:31,870
Lūdzu, jā?

1212
01:15:31,870 --> 01:15:36,610
[Studentu jautājums nesaprotams]

1213
01:15:36,610 --> 01:15:38,190
Vai varat teikt, ka skaļāk? Žēl.

1214
01:15:38,190 --> 01:15:44,140
[Studentu] No pēdējā slaida labi, pirms jūs atbrīvojušies rādītāju,

1215
01:15:44,140 --> 01:15:47,300
Kur jūs bijāt tiešām maina vērtību rādītāja?

1216
01:15:47,300 --> 01:15:50,370
[Džozefs] Tātad, šeit. >> [Studentu] Ak, labi.

1217
01:15:50,370 --> 01:15:51,890
[Džozefs] Tātad, man ir rādītāju mīnus mīnus, labi,

1218
01:15:51,890 --> 01:15:54,140
kas pārvietojas lieta atpakaļ vienu, un tad es to atbrīvotu,

1219
01:15:54,140 --> 01:15:57,000
jo šis rādītājs ir jānorāda uz sākumu masīva.

1220
01:15:57,000 --> 01:16:00,420
[Studentu] Bet tas nav vajadzīgs bija jums apstājās pēc šīs līnijas.

1221
01:16:00,420 --> 01:16:03,130
[Džozefs] Tātad, ja man bija apturēta pēc tam, tas būtu uzskatāms atmiņas noplūde,

1222
01:16:03,130 --> 01:16:04,810
jo man nav palaist bezmaksas.

1223
01:16:04,810 --> 01:16:11,290
[Studentu] Es [nesaprotams] pēc pirmajiem trim līnijām, kur jums bija rādītāju 1 [nesaprotams].

1224
01:16:11,290 --> 01:16:13,140
[Džozefs] Uh-Huh. Tātad, kāda ir jautājums tur?

1225
01:16:13,140 --> 01:16:14,780
Žēl. Nē, nē. Go, go, lūdzu.

1226
01:16:14,780 --> 01:16:16,870
[Studentu] Tātad, jūs ne mainot vērtību norādes.

1227
01:16:16,870 --> 01:16:19,130
Jums nebūtu bijis jādara rādītāju mīnus mīnuss.

1228
01:16:19,130 --> 01:16:19,730
[Džozefs] Jā, tieši tā.

1229
01:16:19,730 --> 01:16:21,890
Tātad, kad man rādītāju +1 un rādītāju +2,

1230
01:16:21,890 --> 01:16:24,410
Es nedaru rādītāju vienāds rādītāju +1.

1231
01:16:24,410 --> 01:16:27,260
Tātad, rādītājs vienkārši paliek norādot sākumā masīva.

1232
01:16:27,260 --> 01:16:31,460
Tas ir tikai tad, kad man plus plus tas, ka tā vērtība atpakaļ iekšā rādītāja,

1233
01:16:31,460 --> 01:16:33,550
ka tas faktiski pārceļas šo kopā.

1234
01:16:36,860 --> 01:16:37,780
Labi.

1235
01:16:40,550 --> 01:16:42,030
Vēl jautājumi?

1236
01:16:44,680 --> 01:16:47,790
>> Atkal, ja tas ir sava veida milzīgs, tas tiks iekļauti sesijā.

1237
01:16:47,790 --> 01:16:50,710
Uzdod savu mācību kolēģiem par to, un mēs varam atbildēt uz jautājumiem beigās.

1238
01:16:53,510 --> 01:16:56,600
Un parasti mums nepatīk to darīt mīnus lieta.

1239
01:16:56,600 --> 01:16:59,760
Tas ir prasīt man sekot tam, cik daudz es esmu kompensēt masīvā.

1240
01:16:59,760 --> 01:17:04,520
Tātad, kopumā, tas ir tikai, lai izskaidrotu, kā rādītāju aritmētisko darbi.

1241
01:17:04,520 --> 01:17:07,970
Bet tas, ko mēs parasti patīk darīt, ir mums patīk izveidot kopiju rādītāja,

1242
01:17:07,970 --> 01:17:11,640
un tad mēs izmantot šo kopiju, kad mēs esam pārvietojas virknē.

1243
01:17:11,640 --> 01:17:14,660
Tātad, šajos gadījumos jūs izmantojat kopiju drukāt virtenei,

1244
01:17:14,660 --> 01:17:19,040
bet mums nav jādara, piemēram, rādītāju mīnus 6 vai sekot līdzi, cik daudz mēs pārcēlās šajā,

1245
01:17:19,040 --> 01:17:22,700
tikai tāpēc, ka mēs zinām, ka mūsu sākotnējais punkts ir joprojām norādīja uz saraksta sākumā

1246
01:17:22,700 --> 01:17:25,340
un viss, ko mēs mainīts bija šī kopija.

1247
01:17:25,340 --> 01:17:28,250
Tātad, kopumā, mainīt kopijas savu sākotnējo rādītāju.

1248
01:17:28,250 --> 01:17:32,350
Vai nav mēģināt kārtot līdzīgu - Don 't mainīt oriģinālu kopijas.

1249
01:17:32,350 --> 01:17:35,290
Mēģinot mainīt tikai kopijas oriģinālu.

1250
01:17:41,540 --> 01:17:44,870
Tātad, jūs ievērosiet, kad mēs iet virkni vērā printf

1251
01:17:44,870 --> 01:17:48,990
Jums nav likt zvaigzne priekšā no tā, kā mēs to darījām ar visām citām dereferences, labi?

1252
01:17:48,990 --> 01:17:54,180
Tātad, ja jūs izdrukāt visu stīgu% s sagaida ir adrese,

1253
01:17:54,180 --> 01:17:57,610
un šajā gadījumā šautriņu vai šajā gadījumā, piemēram masīvu rakstzīmes.

1254
01:17:57,610 --> 01:18:00,330
>> Blondīne, char * s, un masīvi ir tas pats.

1255
01:18:00,330 --> 01:18:03,690
Rādītājs ir rakstzīmes, un raksturs bloki ir tas pats.

1256
01:18:03,690 --> 01:18:05,720
Un tā, viss, kas mums ir jādara, ir caurlaide rādītājs.

1257
01:18:05,720 --> 01:18:08,150
Mums nav iet līdzīgi * rādītājs vai kaut kā tā.

1258
01:18:13,110 --> 01:18:14,930
Tātad, masīvi un norādes ir pats.

1259
01:18:14,930 --> 01:18:19,160
Kad jūs darāt kaut ko līdzīgu x [y] nekā šeit masīva,

1260
01:18:19,160 --> 01:18:21,960
ko tas dara ar kapuci, ir tas saka, labi, tas ir raksturs masīvs,

1261
01:18:21,960 --> 01:18:23,690
tāpēc tas ir rādītājs.

1262
01:18:23,690 --> 01:18:26,510
Un tā x ir tas pats,

1263
01:18:26,510 --> 01:18:28,650
un lai ko tas ir tas piebilst y x,

1264
01:18:28,650 --> 01:18:31,820
kas ir tas pats, kas virzās uz priekšu, atmiņas, ka daudz.

1265
01:18:31,820 --> 01:18:34,930
Un tagad x + y dod mums kaut kādas adreses,

1266
01:18:34,930 --> 01:18:37,570
un mēs dereference adresi vai sekot bultiņas

1267
01:18:37,570 --> 01:18:41,640
kur tas atmiņā vieta ir, un mēs iegūtu vērtību no šīs vietas atmiņā.

1268
01:18:41,640 --> 01:18:43,720
Tātad, tāpēc šie divi ir tieši tas pats.

1269
01:18:43,720 --> 01:18:45,840
Tas ir tikai sintaktisko cukura.

1270
01:18:45,840 --> 01:18:48,090
Viņi to pašu. Viņi tikai dažādu syntactics par otru.

1271
01:18:51,500 --> 01:18:57,590
>> Tātad, ko var noiet greizi ar norādes? Piemēram, partiju. Labi. Tātad, sliktas lietas.

1272
01:18:57,590 --> 01:19:02,410
Daži slikti lietas, varat darīt nav pārbaudīt, vai jūsu malloc zvans atgriež null, labi?

1273
01:19:02,410 --> 01:19:06,560
Šajā gadījumā, es esmu lūdzot sistēmu, lai dotu man - kas tas ir skaitlis?

1274
01:19:06,560 --> 01:19:11,200
Līdzīgi kā 2 miljardu reižu 4, jo veselam skaitlim izmērs ir 4 baiti.

1275
01:19:11,200 --> 01:19:13,810
Es esmu lūdzot sniegt, piemēram, 8 miljards baitu.

1276
01:19:13,810 --> 01:19:17,270
Protams mans dators nav gatavojas, lai varētu sniegt man, ka daudz atmiņas atpakaļ.

1277
01:19:17,270 --> 01:19:20,960
Un mums nav pārbaudīt, vai tas ir nulle, tad, kad mēs cenšamies dereference to vairāk tur -

1278
01:19:20,960 --> 01:19:24,270
sekot bultiņas, kur tas notiek, lai - mums nav šo atmiņu.

1279
01:19:24,270 --> 01:19:27,150
Tas ir tas, ko mēs saucam dereferencing ar null rādītāju.

1280
01:19:27,150 --> 01:19:29,710
Un tas būtībā liek jums segfault.

1281
01:19:29,710 --> 01:19:31,790
Tas ir viens no veidiem, kā jūs varat segfault.

1282
01:19:34,090 --> 01:19:38,090
Citas sliktas lietas jūs varat darīt - oh labi.

1283
01:19:38,090 --> 01:19:40,650
Tas bija dereferencing ar null rādītāju. Labi.

1284
01:19:40,650 --> 01:19:45,160
Citas sliktas lietas - labi, noteikt, ka jūs vienkārši ievietot pārbaudi tur

1285
01:19:45,160 --> 01:19:46,980
kas pārbauda, ​​vai rādītājs ir nulle

1286
01:19:46,980 --> 01:19:51,000
un izietu no programmas, ja tas notiek, ka malloc atgriež null rādītāju.

1287
01:19:55,110 --> 01:19:59,850
Tas ir xkcd komiksu. Cilvēki saprot to tagad. Veida.

1288
01:20:06,120 --> 01:20:09,350
>> Tātad, atmiņas. Un es devos pār to.

1289
01:20:09,350 --> 01:20:12,000
Mēs esam aicinot malloc cilpā, bet katru reizi, kad mēs saucam malloc

1290
01:20:12,000 --> 01:20:14,370
mēs zaudēt dziesmu par to, kur šis rādītājs ir vērsta uz,

1291
01:20:14,370 --> 01:20:15,750
jo mēs esam clobbering to.

1292
01:20:15,750 --> 01:20:18,410
Tātad, sākotnējais aicinājums malloc dod man atmiņā vairāk nekā šeit.

1293
01:20:18,410 --> 01:20:19,990
Mani rādītājs norādes uz to.

1294
01:20:19,990 --> 01:20:23,020
Tagad, man nav to atbrīvotu, tāpēc tagad es aicinu malloc vēlreiz.

1295
01:20:23,020 --> 01:20:26,070
Tagad tas norāda vairāk nekā šeit. Tagad mana atmiņa ir vērsta vairāk nekā šeit.

1296
01:20:26,070 --> 01:20:27,640
Norādot vairāk nekā šeit. Norādot vairāk nekā šeit.

1297
01:20:27,640 --> 01:20:31,820
Bet es esmu zaudējis dziesmu no visu atmiņu nekā šeit, ka man piešķirta adresēm.

1298
01:20:31,820 --> 01:20:35,100
Un tāpēc tagad man nav nekādas atsauces uz tiem vairs.

1299
01:20:35,100 --> 01:20:37,230
Tātad, es nevaru bez viņiem ārpus šīs cilpas.

1300
01:20:37,230 --> 01:20:39,390
Un tāpēc, lai noteiktu kaut ko tādu,

1301
01:20:39,390 --> 01:20:42,250
ja esat aizmirsis, lai atbrīvotu atmiņu, un jūs saņemsiet šo atmiņas noplūde,

1302
01:20:42,250 --> 01:20:45,810
Jums ir, lai atbrīvotu atmiņu iekšā šīs cilpas, kad esat pabeidzis ar to.

1303
01:20:45,810 --> 01:20:51,400
Nu, tas ir tas, kas notiek. Es zinu daudz no jums ienīstu šo.

1304
01:20:51,400 --> 01:20:55,270
Bet tagad - Yay! Jūs saņemsiet kā 44.000 kilobaiti.

1305
01:20:55,270 --> 01:20:57,110
Tātad, jūs atbrīvot to beigās cilpa,

1306
01:20:57,110 --> 01:20:59,770
un kas notiek, lai tikai atbrīvotu atmiņā katru reizi.

1307
01:20:59,770 --> 01:21:03,620
Būtībā, jūsu programma nav atmiņas noplūdi vairs.

1308
01:21:03,620 --> 01:21:08,150
>> Un tagad kaut kas cits jūs varat darīt, ir atbrīvotu atmiņu, ka esat lūdza divreiz.

1309
01:21:08,150 --> 01:21:11,060
Šajā gadījumā jums malloc kaut, jūs maināt savu vērtību.

1310
01:21:11,060 --> 01:21:13,140
Jūs atbrīvot to reizi, jo jūs teicāt, tika darīts ar to.

1311
01:21:13,140 --> 01:21:14,940
Bet tad mēs atbrīvojušies to vēlreiz.

1312
01:21:14,940 --> 01:21:16,730
Tas ir kaut kas ir diezgan slikti.

1313
01:21:16,730 --> 01:21:18,820
Tas nav gatavojas sākotnēji segfault,

1314
01:21:18,820 --> 01:21:23,350
bet pēc kāda laika, ko tas ir dubultā atbrīvojot Šis samaitā jūsu kaudze struktūru,

1315
01:21:23,350 --> 01:21:27,200
un jūs varēsiet uzzināt nedaudz vairāk par to, ja jūs izvēlaties veikt klases, piemēram CS61.

1316
01:21:27,200 --> 01:21:30,000
Bet būtībā pēc kamēr jūsu dators ir gatavojas saņemt sajaukt

1317
01:21:30,000 --> 01:21:33,010
par to, ko atmiņas vietas ir, kur un kad tas ir saglabāts -

1318
01:21:33,010 --> 01:21:34,800
kur dati tiek glabāti atmiņā.

1319
01:21:34,800 --> 01:21:38,080
Un tā atbrīvojot rādītāju divreiz ir slikta lieta, ka jūs nevēlaties to darīt.

1320
01:21:38,080 --> 01:21:41,600
>> Citas lietas, kas var noiet greizi neizmanto sizeof.

1321
01:21:41,600 --> 01:21:44,460
Tātad, šajā gadījumā jums malloc 8 baiti,

1322
01:21:44,460 --> 01:21:46,700
un tas ir pats par diviem veseliem skaitļiem, labi?

1323
01:21:46,700 --> 01:21:49,580
Tātad, tas ir pilnīgi droši, bet tas ir?

1324
01:21:49,580 --> 01:21:52,160
Nu, kā Lucas runāja par dažādām arhitektūrām,

1325
01:21:52,160 --> 01:21:54,220
integers ir dažāda garuma.

1326
01:21:54,220 --> 01:21:57,970
Tātad, uz ierīces, kas jūs izmantojat, veseli skaitļi ir aptuveni 4 baiti,

1327
01:21:57,970 --> 01:22:02,370
bet uz kādu citu sistēmu tie varētu būt 8 biti vai tie varētu būt 16 baiti.

1328
01:22:02,370 --> 01:22:05,680
Tātad, ja es tikai izmantot šo numuru nekā šeit,

1329
01:22:05,680 --> 01:22:07,310
Šī programma varētu strādāt uz ierīces,

1330
01:22:07,310 --> 01:22:10,360
bet tas nav gatavojas piešķirt pietiekami daudz atmiņas uz kādu citu sistēmu.

1331
01:22:10,360 --> 01:22:14,020
Šajā gadījumā, tas ir tas, ko sizeof operators izmanto.

1332
01:22:14,020 --> 01:22:16,880
Kad mēs saucam sizeof (int), ko tas dara, ir

1333
01:22:16,880 --> 01:22:21,910
 tas dod mums lielumu skaitlim par sistēmu, ka programma darbojas.

1334
01:22:21,910 --> 01:22:25,490
Tātad, šajā gadījumā, sizeof (int) atgriezīsies 4 par kaut ko līdzīgu ierīci,

1335
01:22:25,490 --> 01:22:29,980
un tagad šī griba 4 * 2, kas ir 8,

1336
01:22:29,980 --> 01:22:32,330
kas ir tikai daudz vietas nepieciešams divu veselu skaitļu.

1337
01:22:32,330 --> 01:22:36,710
Par citu sistēmu, ja int ir kā 16 baiti vai 8 baiti,

1338
01:22:36,710 --> 01:22:39,380
tas ir tikai gatavojas atgriezties pietiekami bytes uzglabāt šo summu.

1339
01:22:41,830 --> 01:22:45,310
>> Un visbeidzot, structs.

1340
01:22:45,310 --> 01:22:48,340
Tātad, ja jūs vēlaties, lai saglabātu sudoku kuģa atmiņā, kā varētu mēs to darām?

1341
01:22:48,340 --> 01:22:51,570
Jūs varētu domāt par, piemēram, mainīgais pirmā lieta,

1342
01:22:51,570 --> 01:22:53,820
mainīgo par otro lieta, mainīgais Trešā lieta,

1343
01:22:53,820 --> 01:22:56,420
mainīgo par ceturto lieta - slikti, vai ne?

1344
01:22:56,420 --> 01:23:00,750
Tātad, viens uzlabojums jūs varat veikt uz augšu, ir padarīt 9 x 9 masīvs.

1345
01:23:00,750 --> 01:23:04,480
Tas ir labi, bet kas notiks, ja jūs vēlētos saistīt citas lietas ar sudoku kuģa

1346
01:23:04,480 --> 01:23:06,490
patīk tas, ko no kuģa grūtības,

1347
01:23:06,490 --> 01:23:11,740
vai, piemēram, kādas ir jūsu rezultāts ir, vai cik daudz laika tas ir pieņemts jums atrisināt šo kuģa?

1348
01:23:11,740 --> 01:23:14,970
Nu, ko jūs varat darīt, ir iespējams izveidot struct.

1349
01:23:14,970 --> 01:23:18,910
Ko es esmu būtībā sakot, ir es esmu definējot šo struktūru nekā šeit,

1350
01:23:18,910 --> 01:23:23,230
un es esmu nosakot sudoku valde, kas sastāv no kuģa, kas ir 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> Un ko tas ir tā norādes uz vārdu līmenī.

1352
01:23:26,650 --> 01:23:30,730
Tas arī ir x un y, kas ir koordinātes, kur es esmu šobrīd.

1353
01:23:30,730 --> 01:23:35,980
Tas arī ir laiks [nesaprotami], un tas ir kopējais skaits kustas es esmu ievadījis līdz šim.

1354
01:23:35,980 --> 01:23:40,010
Un tāpēc šajā gadījumā, es varētu grupēt visu ķekars datu par vienu struktūru

1355
01:23:40,010 --> 01:23:42,790
vietā, tā kā peld apkārt līdzīgi dažādiem mainīgajiem

1356
01:23:42,790 --> 01:23:44,540
ka es nevaru īsti izsekot.

1357
01:23:44,540 --> 01:23:49,720
Un tas ļauj mums būt tikai jauka sintakse veida norādes dažādas lietas iekšpuses šo struct.

1358
01:23:49,720 --> 01:23:53,430
Es varu tikai darīt board.board, un man sudoku valde atpakaļ.

1359
01:23:53,430 --> 01:23:56,320
Board.level, man, cik grūts tas ir.

1360
01:23:56,320 --> 01:24:00,540
Board.x un board.y man koordinātes, kur es varētu būt valdē.

1361
01:24:00,540 --> 01:24:04,730
Un tāpēc es esmu piekļuvei, ko mēs saucam lauki struct.

1362
01:24:04,730 --> 01:24:08,840
Tas nosaka sudokuBoard, kas ir veids, kas man ir.

1363
01:24:08,840 --> 01:24:14,800
Un tagad mēs esam šeit. Man ir mainīgo sauc "valde" tipa sudokuBoard.

1364
01:24:14,800 --> 01:24:18,820
Un tāpēc tagad es varētu piekļūt visi lauki, kas veido šo struktūru nekā šeit.

1365
01:24:20,830 --> 01:24:22,450
>> Kādi jautājumi par structs? Jā?

1366
01:24:22,450 --> 01:24:25,890
[Studentu] Par int x, y, tu paziņoja abi vienā rindā? >> [Džozefs] Uh-Huh.

1367
01:24:25,890 --> 01:24:27,400
[Studentu] Tātad, jūs varētu vienkārši darīt ar tiem visiem?

1368
01:24:27,400 --> 01:24:31,200
Tāpat kā X, Y komatu reizes kopējais?

1369
01:24:31,200 --> 01:24:34,460
[Džozefs] Jā, jūs varētu noteikti darīt, bet iemesls man x un y uz vienas līnijas -

1370
01:24:34,460 --> 01:24:36,330
un jautājums ir, kāpēc mēs varam vienkārši izdarīt uz vienas līnijas?

1371
01:24:36,330 --> 01:24:38,600
Kāpēc ne mēs tikai visus šos uz vienas līnijas ir

1372
01:24:38,600 --> 01:24:42,090
x un y ir saistīti viens ar otru,

1373
01:24:42,090 --> 01:24:44,780
un tas ir tikai stilistiski pareizi, kas nozīmē,

1374
01:24:44,780 --> 01:24:46,600
jo tas grupējot divas lietas vienā rindā

1375
01:24:46,600 --> 01:24:49,340
ka, piemēram, sava veida attiecas uz to pašu.

1376
01:24:49,340 --> 01:24:51,440
Un es vienkārši sadalīt šos intervālu. Tas ir tikai stils lieta.

1377
01:24:51,440 --> 01:24:53,720
Tā funkcionāli nekādas starpības whatsoever.

1378
01:24:58,150 --> 01:24:59,270
Jebkādi citi jautājumi par structs?

1379
01:25:03,030 --> 01:25:06,620
Jūs varat definēt Pokédex ar struct.

1380
01:25:06,620 --> 01:25:11,720
Pokmon ir vairākas, un tas ir vēstule, īpašnieks, tipa.

1381
01:25:11,720 --> 01:25:16,990
Un tad, ja jums ir masīvs Pokemon, jūs varat veido Pokédex, labi?

1382
01:25:16,990 --> 01:25:20,810
Labi, atdzesē. Tātad, jautājumi par structs. Tie ir saistīti ar structs.

1383
01:25:20,810 --> 01:25:25,270
>> Visbeidzot, GDB. Kāda Gdb jums darīt? Tas ļauj jums atkļūdot savu programmu.

1384
01:25:25,270 --> 01:25:27,650
Un, ja jūs neesat izmantojis GDB, es ieteicams skatīties īstermiņa

1385
01:25:27,650 --> 01:25:31,250
un tikai iet pār to Gdb ir, kā jūs strādājat ar to, kā jūs varētu to izmantot,

1386
01:25:31,250 --> 01:25:32,900
un pārbaudīt to uz programmu.

1387
01:25:32,900 --> 01:25:37,400
Un lai ko Gdb ļauj jums jādara, ir tas ļauj pauzes [nesaprotams] Līdz jūsu programmā

1388
01:25:37,400 --> 01:25:38,920
un praktisku līniju.

1389
01:25:38,920 --> 01:25:42,600
Piemēram, es gribu, lai apturētu izpildi pēc kā mana programmas 3 līniju,

1390
01:25:42,600 --> 01:25:46,010
un kamēr es esmu pie 3 līniju es varētu izdrukāt visas vērtības, kas ir tur.

1391
01:25:46,010 --> 01:25:49,710
Un tā, ko mēs saucam kā pauzēm rindā

1392
01:25:49,710 --> 01:25:52,350
ir mēs saucam liekot pārtraukumpunkts šajā līnijā

1393
01:25:52,350 --> 01:25:55,920
un tad mēs varam izdrukāt mainīgie pie valsts programmas šajā laikā.

1394
01:25:55,920 --> 01:25:58,990
>> Mēs varam tad no turienes soli pa programmu rindu pa līniju.

1395
01:25:58,990 --> 01:26:03,200
Un tad mēs varam apskatīt stāvokli skursteņa laikā.

1396
01:26:03,200 --> 01:26:08,600
Un tāpēc, lai izmantotu GDB, ko mēs darām, ir mēs aicinām šķindēt par C failu,

1397
01:26:08,600 --> 01:26:11,290
bet mums ir jāiet tā-ggdb karogu.

1398
01:26:11,290 --> 01:26:15,850
Un, kad mēs esam darīts ar to mēs vienkārši palaist gdb uz iegūtajā failā.

1399
01:26:15,850 --> 01:26:18,810
Un tā jums dažas, piemēram, masu teksta, piemēram, tas,

1400
01:26:18,810 --> 01:26:21,990
bet tiešām viss, kas jums jādara, ir rakstīt komandas sākumā.

1401
01:26:21,990 --> 01:26:24,250
Break galvenais liek pārtraukumpunkts pie galvenā.

1402
01:26:24,250 --> 01:26:28,470
Sarakstā 400 uzskaitīti rindas koda aptuveni 400 līniju.

1403
01:26:28,470 --> 01:26:31,410
Un tāpēc šajā gadījumā jūs varat vienkārši paskatīties un teikt, ak,

1404
01:26:31,410 --> 01:26:34,360
Es gribu, lai noteikt pārtraukumpunkts pie 397 līniju, kas ir šī pozīcija,

1405
01:26:34,360 --> 01:26:37,170
un tad jūsu programma darbojas uz šo soli, un tas notiek, lai izjauktu.

1406
01:26:37,170 --> 01:26:41,120
Tas notiek, lai apturētu tur, un jūs varat izdrukāt, piemēram, vērtību zems vai augsts.

1407
01:26:41,120 --> 01:26:46,410
Un tāpēc ir komandu, kas jums jāzina ķekars,

1408
01:26:46,410 --> 01:26:48,660
un tas slaidrādi iet līdzi mājas lapā,

1409
01:26:48,660 --> 01:26:54,000
tādēļ, ja jūs vienkārši vēlaties, lai norādītu tos vai patīk viņus uz jūsu apkrāptu loksnes, justies brīvi.

1410
01:26:54,000 --> 01:27:00,650
>> Atdzist. Tas bija viktorīna Review 0, un mēs stick apkārt, ja jums ir kādi jautājumi.

1411
01:27:00,650 --> 01:27:03,850
Labi.

1412
01:27:03,850 --> 01:27:09,030
>>  [Aplausi]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]