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

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

3
00:00:05,000 --> 00:00:08,000
>> [Hierdie is CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Hey, almal.

5
00:00:10,000 --> 00:00:15,000
Welkom by die hersiening sessie vir Quiz 0, wat sal plaasvind hierdie Woensdag.

6
00:00:15,000 --> 00:00:19,000
Wat gaan ons doen vanaand, ek is met 3 ander TFS,

7
00:00:19,000 --> 00:00:24,000
en saam gaan ons om te gaan deur 'n oorsig van wat ons gedoen het tot dusver in die kursus.

8
00:00:24,000 --> 00:00:27,000
Dit gaan nie om te wees 100% omvattende, maar dit moet gee jou 'n beter idee

9
00:00:27,000 --> 00:00:31,000
van wat jy reeds het en wat jy nog nodig het om te studeer voor Woensdag.

10
00:00:31,000 --> 00:00:34,000
En voel vry om jou hand op te steek met vrae as ons gaan saam,

11
00:00:34,000 --> 00:00:38,000
maar hou in gedagte dat ons ook sal moet 'n bietjie van die tyd aan die einde-

12
00:00:38,000 --> 00:00:41,000
as ons deur 'n paar minute te spaar op algemene vrae doen,

13
00:00:41,000 --> 00:00:47,000
so hou dit in gedagte, en so gaan ons begin by die begin met Week 0.

14
00:00:47,000 --> 00:00:50,000
>> [Quiz 0 Review!] [Deel 0] [Lexi Ross] Maar voordat ons dit doen Kom ons praat oor

15
00:00:50,000 --> 00:00:53,000
die logistiek van die quiz.

16
00:00:53,000 --> 00:00:55,000
>> [Logistiek] [Quiz vind plaas in plaas van die lesing op Woensdag 10/10]

17
00:00:55,000 --> 00:00:57,000
>> [(Sien http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf vir besonderhede)] Dit is op Woensdag, Oktober 10.

18
00:00:57,000 --> 00:01:00,000
>> Dit is hierdie Woensdag, en as jy gaan na hierdie URL,

19
00:01:00,000 --> 00:01:03,000
wat ook toeganklik vanaf CS50.net-daar 's 'n skakel om dit te

20
00:01:03,000 --> 00:01:06,000
inligting oor waar om te gaan op grond van wat jy kan sien

21
00:01:06,000 --> 00:01:10,000
jou laaste naam of skool affiliasie sowel as

22
00:01:10,000 --> 00:01:14,000
dit vertel oor wat presies die quiz sal dek en die tipe vrae wat jy gaan kry.

23
00:01:14,000 --> 00:01:19,000
Hou in gedagte dat jy ook sal 'n kans om te hersien vir die quiz artikel,

24
00:01:19,000 --> 00:01:21,000
sodat jou TFS moet gaan oor 'n paar praktyk probleme,

25
00:01:21,000 --> 00:01:29,000
en dit is nog 'n goeie kans om te sien waar jy nog steeds nodig om te studeer vir die quiz.

26
00:01:29,000 --> 00:01:32,000
Kom ons begin by die begin met Bits 'n 'Bytes.

27
00:01:32,000 --> 00:01:35,000
Onthou om 'n bietjie is net 'n 0 of 'n 1,

28
00:01:35,000 --> 00:01:38,000
en 'n greep is 'n versameling van 8 van daardie stukkies.

29
00:01:38,000 --> 00:01:42,000
Kom ons kyk na hierdie versameling van stukkies reg hier.

30
00:01:42,000 --> 00:01:44,000
Ons moet in staat wees om uit te vind hoeveel stukkies daar is.

31
00:01:44,000 --> 00:01:48,000
Waar ons reken daar is net 8 van hulle, agt 0 of 1 eenhede.

32
00:01:48,000 --> 00:01:51,000
En aangesien daar is 8 bisse, wat is 1 byte,

33
00:01:51,000 --> 00:01:53,000
en laat ons skakel dit om na heksadesimaal.

34
00:01:53,000 --> 00:01:58,000
Heksadesimale is base 16, en dit is redelik maklik om te sit

35
00:01:58,000 --> 00:02:01,000
'n nommer in die binêre, wat is wat dit is, 'n aantal in heksadesimaal.

36
00:02:01,000 --> 00:02:04,000
Alles wat ons doen, is ons kyk na die groepe van 4,

37
00:02:04,000 --> 00:02:07,000
en ons sit hulle aan die toepaslike heksadesimale syfer.

38
00:02:07,000 --> 00:02:11,000
Ons begin met die mees regse groep van 4, so 0011.

39
00:02:11,000 --> 00:02:16,000
Dit gaan om een ​​te wees 1 en een 2, so saam wat maak 3.

40
00:02:16,000 --> 00:02:19,000
En dan laat ons kyk na die ander blok van 4.

41
00:02:19,000 --> 00:02:24,000
1101. Wat gaan een 1, een 4, en 'n 8.

42
00:02:24,000 --> 00:02:28,000
Saam dat gaan wees 13, wat maak D.

43
00:02:28,000 --> 00:02:32,000
En ons sal onthou dat ons in heksadesimaal gaan net nie 0 tot 9.

44
00:02:32,000 --> 00:02:36,000
Ons gaan 0 tot F, so na 9, 10 ooreenstem met 'n,

45
00:02:36,000 --> 00:02:40,000
11 B, ensovoorts waar F 15.

46
00:02:40,000 --> 00:02:44,000
Hier 13 is 'n D,

47
00:02:44,000 --> 00:02:49,000
so te skakel dit om na desimale alles wat ons doen is ons eintlik

48
00:02:49,000 --> 00:02:52,000
Behandel elke posisie as 'n krag van 2.

49
00:02:52,000 --> 00:02:58,000
Dit is een 1, een 2, nul 4s, nul 8s, 16, ensovoorts,

50
00:02:58,000 --> 00:03:03,000
en dit is 'n bietjie moeilik om te bereken in jou kop, maar as ons na die volgende skyfie

51
00:03:03,000 --> 00:03:05,000
Ons kan die antwoord sien.

52
00:03:05,000 --> 00:03:09,000
>> In wese gaan ons oor van regs terug na links,

53
00:03:09,000 --> 00:03:14,000
en ons is elke syfer vermenigvuldig deur die ooreenstemmende krag van 2.

54
00:03:14,000 --> 00:03:19,000
En onthou, heksadesimaal ons dui hierdie getalle aan die begin met 0x

55
00:03:19,000 --> 00:03:23,000
sodat ons nie verwar dit met 'n desimale getal.

56
00:03:23,000 --> 00:03:29,000
Voortgesette op, dit is 'n ASCII-tabel,

57
00:03:29,000 --> 00:03:35,000
en wat ons gebruik ASCII vir kaart van karakters numeriese waardes.

58
00:03:35,000 --> 00:03:39,000
Onthou in die kriptografie pset ons het uitgebreide gebruik van die ASCII-tabel

59
00:03:39,000 --> 00:03:43,000
ten einde verskillende metodes om kriptografie te gebruik,

60
00:03:43,000 --> 00:03:47,000
die keiser en die Vigenère cipher, verskillende letters te omskep

61
00:03:47,000 --> 00:03:52,000
in 'n string wat volgens die sleutel wat deur die gebruiker.

62
00:03:52,000 --> 00:03:56,000
Kom ons kyk 'n bietjie van ASCII wiskunde.

63
00:03:56,000 --> 00:04:02,000
Op soek na 'P' + 1, in karakter vorm wat sou wees Q,

64
00:04:02,000 --> 00:04:07,000
en onthou dat '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
En presies hoe sou ons skakel tussen die 2 vorms?

66
00:04:10,000 --> 00:04:13,000
Dit is eintlik nie te moeilik.

67
00:04:13,000 --> 00:04:16,000
Ten einde 5 kry ons aftrek '0 '

68
00:04:16,000 --> 00:04:20,000
want daar is 5 plekke tussen die '0 'en die '5. "

69
00:04:20,000 --> 00:04:23,000
Ten einde die ander manier om te gaan ons net die 0 voeg,

70
00:04:23,000 --> 00:04:25,000
so dit is soort van soos 'n gereelde rekenkunde.

71
00:04:25,000 --> 00:04:29,000
Net onthou dat wanneer iets aanhalings rondom dit, dit is 'n karakter

72
00:04:29,000 --> 00:04:37,000
en stem dus ooreen met 'n waarde in die ASCII-tabel.

73
00:04:37,000 --> 00:04:40,000
Moving into meer algemene rekenaar wetenskap onderwerpe.

74
00:04:40,000 --> 00:04:43,000
Ons het geleer wat 'n algoritme is en hoe ons dit gebruik programmering

75
00:04:43,000 --> 00:04:45,000
algoritmes te implementeer.

76
00:04:45,000 --> 00:04:48,000
'N paar voorbeelde van algoritmes is iets regtig eenvoudig soos

77
00:04:48,000 --> 00:04:51,000
kontroleer of 'n getal ewe of onewe.

78
00:04:51,000 --> 00:04:54,000
Vir daardie onthou ons mod die getal met 2 en kyk of die resultaat is 0.

79
00:04:54,000 --> 00:04:57,000
As dit so is, is dit nog. Indien nie, is dit vreemd.

80
00:04:57,000 --> 00:04:59,000
En dit is 'n voorbeeld van 'n baie basiese algoritme.

81
00:04:59,000 --> 00:05:02,000
>> 'N bietjie van 'n meer betrokke te raak 1 is 'n binêre soek,

82
00:05:02,000 --> 00:05:05,000
wat ons gaan later in die hersiening sessie.

83
00:05:05,000 --> 00:05:09,000
En programmering is die term wat ons gebruik vir die neem van 'n algoritme

84
00:05:09,000 --> 00:05:15,000
en die omskakeling van die rekenaar kode kan lees.

85
00:05:15,000 --> 00:05:20,000
2 voorbeelde van programmering is kras,

86
00:05:20,000 --> 00:05:22,000
en dit is wat ons gedoen het in Week 0.

87
00:05:22,000 --> 00:05:25,000
Selfs al is ons nie eintlik nie tik die kode, dit is 'n manier van die uitvoering van

88
00:05:25,000 --> 00:05:29,000
hierdie algoritme, wat die druk van die syfers 1-10,

89
00:05:29,000 --> 00:05:32,000
en hier is ons dieselfde doen in die C-programmeertaal.

90
00:05:32,000 --> 00:05:41,000
Dit is funksioneel ekwivalent, net in verskillende tale of sintaksis.

91
00:05:41,000 --> 00:05:44,000
Ons het toe geleer het oor Boolse uitdrukkings,

92
00:05:44,000 --> 00:05:48,000
en 'n boolean is 'n waarde wat waar of vals is,

93
00:05:48,000 --> 00:05:51,000
en hier is dikwels Boolse uitdrukkings

94
00:05:51,000 --> 00:05:55,000
binnekant van voorwaardes, so as (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
Wel, ons het reeds x = 5, so dat die toestand is gaan te evalueer waar.

96
00:06:00,000 --> 00:06:03,000
En as dit waar is, alles kode is onder die voorwaarde

97
00:06:03,000 --> 00:06:08,000
gaan word geëvalueer deur die rekenaar, sodat string gaan om gedruk te word

98
00:06:08,000 --> 00:06:12,000
standaard uitvoer, en die term toestand

99
00:06:12,000 --> 00:06:16,000
verwys na alles wat binne die hakies van die IF-stelling.

100
00:06:16,000 --> 00:06:20,000
Onthou al die operateurs.

101
00:06:20,000 --> 00:06:26,000
Onthou dit && | | wanneer ons probeer om te kombineer 2 of meer voorwaardes,

102
00:06:26,000 --> 00:06:30,000
== Nie = om te kontroleer of 2 dinge gelyk is.

103
00:06:30,000 --> 00:06:36,000
Onthou dat = opdrag terwyl == is 'n booleaanse operator.

104
00:06:36,000 --> 00:06:41,000
≤ ≥ en dan die finale 2 is selfverduidelikend.

105
00:06:41,000 --> 00:06:45,000
'N algemene oorsig van Boole-logika hier.

106
00:06:45,000 --> 00:06:48,000
En Boolse uitdrukkings is ook belangrik in loops,

107
00:06:48,000 --> 00:06:50,000
wat ons gaan nou verby.

108
00:06:50,000 --> 00:06:56,000
Ons het geleer ongeveer 3 tipes lusse tot dusver in CS50, terwyl en doen terwyl.

109
00:06:56,000 --> 00:06:59,000
En dit is belangrik om te weet dat terwyl dit vir die meeste doeleindes

110
00:06:59,000 --> 00:07:02,000
ons kan eintlik gebruik van enige tipe van die lus in die algemeen

111
00:07:02,000 --> 00:07:06,000
daar is sekere tipes doeleindes of gemeenskaplike patrone

112
00:07:06,000 --> 00:07:09,000
programmering wat spesifiek roep vir een van hierdie loops

113
00:07:09,000 --> 00:07:13,000
wat maak dit die mees doeltreffende of elegante dit op dié manier te kodeer.

114
00:07:13,000 --> 00:07:18,000
Kom ons gaan oor wat elk van hierdie loops is geneig om te word wat gebruik word vir die meeste.

115
00:07:18,000 --> 00:07:21,000
>> In 'n for-lus ons oor die algemeen reeds weet hoeveel keer wil ons itereer.

116
00:07:21,000 --> 00:07:24,000
Dit is wat ons in die toestand.

117
00:07:24,000 --> 00:07:28,000
Want i = 0, i <10, byvoorbeeld.

118
00:07:28,000 --> 00:07:31,000
Ons weet reeds dat ons wil iets 10 keer te doen.

119
00:07:31,000 --> 00:07:34,000
Nou, vir 'n while lus, oor die algemeen ons nie noodwendig

120
00:07:34,000 --> 00:07:36,000
weet hoeveel keer wil ons die lus om te hardloop.

121
00:07:36,000 --> 00:07:39,000
Maar ons weet nie 'n soort van toestand dat ons dit wil

122
00:07:39,000 --> 00:07:41,000
altyd waar of altyd vals.

123
00:07:41,000 --> 00:07:44,000
Byvoorbeeld, terwyl stel.

124
00:07:44,000 --> 00:07:46,000
Kom ons sê dit is 'n boolean veranderlike.

125
00:07:46,000 --> 00:07:48,000
Terwyl dit is waar ons wil hê om die kode te evalueer,

126
00:07:48,000 --> 00:07:52,000
so 'n bietjie meer te brei, 'n bietjie meer algemeen as 'n lus

127
00:07:52,000 --> 00:07:55,000
maar 'n for-lus kan ook omgeskakel word na 'n while lus.

128
00:07:55,000 --> 00:08:00,000
Ten slotte, doen terwyl loops, wat kan wees die moeilijkste na regs weg te verstaan,

129
00:08:00,000 --> 00:08:04,000
word dikwels gebruik wanneer ons wil die kode om eers te evalueer

130
00:08:04,000 --> 00:08:06,000
voor die eerste keer het ons die toestand.

131
00:08:06,000 --> 00:08:09,000
'N algemene gebruik geval vir 'n while lus

132
00:08:09,000 --> 00:08:12,000
wanneer jy wil toevoer van die gebruiker te kry, en jy weet jy wil die gebruiker te vra

133
00:08:12,000 --> 00:08:15,000
vir insette ten minste een keer, maar as hulle gee jou nie goeie insette dadelik

134
00:08:15,000 --> 00:08:18,000
jy wil aanhou vra totdat hulle gee jou die goeie insette.

135
00:08:18,000 --> 00:08:21,000
Dit is die mees algemene gebruik van 'n while lus,

136
00:08:21,000 --> 00:08:23,000
en laat ons kyk na die werklike struktuur van hierdie loops.

137
00:08:23,000 --> 00:08:27,000
Hulle gewoonlik altyd geneig om hierdie patrone te volg.

138
00:08:27,000 --> 00:08:30,000
>> Op die for-lus binne 3 komponente:

139
00:08:30,000 --> 00:08:35,000
inisialisering, gewoonlik iets soos int i = 0 waar ek die toonbank,

140
00:08:35,000 --> 00:08:40,000
toestand, waar ons wil sê dit hardloop vir loop so lank as hierdie toestand nog hou,

141
00:08:40,000 --> 00:08:44,000
soos ek <10, en dan uiteindelik, update, wat is hoe ons inkrementeer

142
00:08:44,000 --> 00:08:47,000
die toonbank veranderlike by elke punt in die lus.

143
00:08:47,000 --> 00:08:50,000
'N algemene ding daar te sien is net i + +,

144
00:08:50,000 --> 00:08:52,000
wat beteken inkrementeer i 1 elke keer.

145
00:08:52,000 --> 00:08:55,000
Jy kan ook iets doen soos ek + = 2,

146
00:08:55,000 --> 00:08:58,000
wat beteken dat voeg 2 i elke keer as jy gaan deur die lus.

147
00:08:58,000 --> 00:09:03,000
En dan die doen dit verwys net 'n kode wat eintlik loop as deel van die lus.

148
00:09:03,000 --> 00:09:09,000
En vir 'n rukkie loop, hierdie keer het ons eintlik die inisialisering buite die lus,

149
00:09:09,000 --> 00:09:12,000
So byvoorbeeld, laat ons sê dat ons probeer om die dieselfde tipe van die lus om te doen soos ek nou net beskryf.

150
00:09:12,000 --> 00:09:16,000
Ons sou sê int i = 0 voordat die lus begin.

151
00:09:16,000 --> 00:09:20,000
Dan kan ons sê terwyl ek <10 doen dit,

152
00:09:20,000 --> 00:09:22,000
so dieselfde blok van die kode as voorheen,

153
00:09:22,000 --> 00:09:26,000
en hierdie keer het die update deel van die kode, byvoorbeeld, i + +,

154
00:09:26,000 --> 00:09:29,000
eintlik gaan binnekant van die lus.

155
00:09:29,000 --> 00:09:33,000
En ten slotte, vir 'n doen terwyl dit is soortgelyk aan die while lus,

156
00:09:33,000 --> 00:09:36,000
maar ons moet onthou dat die kode sal evalueer

157
00:09:36,000 --> 00:09:40,000
voor die aangesig van die toestand is nagegaan, sodat dit 'n baie meer sin maak

158
00:09:40,000 --> 00:09:44,000
as jy kyk na dit in volgorde van bo na onder.

159
00:09:44,000 --> 00:09:49,000
In 'n doen terwyl loop die kode evalueer voordat jy selfs kyk na die tyd toestand,

160
00:09:49,000 --> 00:09:55,000
terwyl 'n while lus, dit kontroleer of dit eerste.

161
00:09:55,000 --> 00:09:59,000
State en veranderlikes.

162
00:09:59,000 --> 00:10:04,000
Wanneer ons wil 'n nuwe veranderlike te skep wil ons eers om dit te inisialiseer.

163
00:10:04,000 --> 00:10:07,000
>> Byvoorbeeld, int bar initialisatie van die veranderlike bar,

164
00:10:07,000 --> 00:10:10,000
maar dit beteken nie dit gee 'n waarde, so wat is bar se waarde nou?

165
00:10:10,000 --> 00:10:12,000
Ons weet nie.

166
00:10:12,000 --> 00:10:14,000
Dit kan 'n gemors waarde wat voorheen in die geheue gestoor daar wees,

167
00:10:14,000 --> 00:10:16,000
en ons wil nie dat die veranderlike te gebruik

168
00:10:16,000 --> 00:10:19,000
totdat ons eintlik gee dit 'n waarde,

169
00:10:19,000 --> 00:10:21,000
so verklaar ons dit hier.

170
00:10:21,000 --> 00:10:24,000
Dan sal ons inisialiseer 42 hieronder.

171
00:10:24,000 --> 00:10:28,000
Nou, natuurlik, ons weet dit kan gedoen word op een lyn, int bar = 42.

172
00:10:28,000 --> 00:10:30,000
Maar net om duidelik die verskeie stappe wat gaan op,

173
00:10:30,000 --> 00:10:34,000
die verklaring en die inisialisering word afsonderlik hier gebeur.

174
00:10:34,000 --> 00:10:38,000
Dit gebeur op 'n stap, en die volgende een, int Baz = bar + 1,

175
00:10:38,000 --> 00:10:44,000
hierdie stelling hieronder, wat inkremente Baz, so aan die einde van hierdie kode blok

176
00:10:44,000 --> 00:10:48,000
as ons die waarde van Baz te druk, dit sou wees 44

177
00:10:48,000 --> 00:10:52,000
omdat ons verklaar en inisialiseer 1> bar wees nie,

178
00:10:52,000 --> 00:10:58,000
en dan het ons inkrementeer dit weer met die + +.

179
00:10:58,000 --> 00:11:02,000
Ons het oor hierdie mooi kortliks, maar dit is goed om te hê 'n algemene

180
00:11:02,000 --> 00:11:04,000
begrip van wat drade en gebeure is.

181
00:11:04,000 --> 00:11:06,000
Ons veral het dit gedoen Scratch

182
00:11:06,000 --> 00:11:09,000
sodat jy kan dink van die drade as verskeie rye van die kode

183
00:11:09,000 --> 00:11:11,000
loop op dieselfde tyd.

184
00:11:11,000 --> 00:11:14,000
In werklikheid, is dit waarskynlik nie loop op dieselfde tyd,

185
00:11:14,000 --> 00:11:17,000
maar soort van abstrak kan ons dink dat dit op daardie manier.

186
00:11:17,000 --> 00:11:20,000
>> Scratch, byvoorbeeld, het ons die verskeie sprites.

187
00:11:20,000 --> 00:11:22,000
Dit kan die uitvoering van verskillende-kode op dieselfde tyd.

188
00:11:22,000 --> 00:11:26,000
Mens kon loop terwyl die ander iets te sê

189
00:11:26,000 --> 00:11:29,000
in 'n ander deel van die skerm.

190
00:11:29,000 --> 00:11:34,000
Gebeure is nog 'n manier van die skeiding van die logika

191
00:11:34,000 --> 00:11:37,000
tussen die verskillende elemente van die kode,

192
00:11:37,000 --> 00:11:40,000
en in Scratch ons in staat was om gebeure te simuleer met behulp van die uitsending,

193
00:11:40,000 --> 00:11:43,000
en dit is eintlik wanneer ek nie wanneer ek dit hoor,

194
00:11:43,000 --> 00:11:47,000
maar in wese is dit 'n manier om inligting oor te dra

195
00:11:47,000 --> 00:11:49,000
van een na 'n ander sprite.

196
00:11:49,000 --> 00:11:52,000
Byvoorbeeld, kan jy spel oor te stuur,

197
00:11:52,000 --> 00:11:56,000
en wanneer ander sprite ontvang spel oor,

198
00:11:56,000 --> 00:11:58,000
dit in 'n sekere manier reageer.

199
00:11:58,000 --> 00:12:03,000
Dit is 'n belangrike model in programmering te verstaan.

200
00:12:03,000 --> 00:12:07,000
Net om te gaan oor die basiese Week 0, wat ons het so ver gegaan oor,

201
00:12:07,000 --> 00:12:10,000
laat ons kyk na hierdie eenvoudige C program.

202
00:12:10,000 --> 00:12:14,000
Die teks kan 'n klein bietjie van hier te wees, maar ek sal dit werklik gaan oor vinnige.

203
00:12:14,000 --> 00:12:20,000
Ons insluitend 2 header lêers aan die bokant, cs50.h en stdio.h.

204
00:12:20,000 --> 00:12:23,000
Ons is dan die definisie van 'n konstante genoem limiet te wees 100.

205
00:12:23,000 --> 00:12:26,000
Ons is dan die uitvoering van ons hooffunksie.

206
00:12:26,000 --> 00:12:29,000
Aangesien ons nie command line argumente gebruik hier moet ons nietig te sit

207
00:12:29,000 --> 00:12:32,000
as die argumente vir die hoof.

208
00:12:32,000 --> 00:12:38,000
Ons sien int bostaande hoofdoelwitte. Dit is die terugkeer tipe, vandaar terug 0 aan die onderkant.

209
00:12:38,000 --> 00:12:41,000
En ons gebruik CS50 biblioteek funksie kry int

210
00:12:41,000 --> 00:12:45,000
die gebruiker om insette te vra, en ons bêre dit in hierdie veranderlike x,

211
00:12:45,000 --> 00:12:51,000
sodat ons verklaar x hierbo, en ons inisialiseer met x = getint.

212
00:12:51,000 --> 00:12:53,000
>> Ons dan kyk om te sien as die gebruiker het ons goeie insette.

213
00:12:53,000 --> 00:12:59,000
As dit is ≥ LIMIT wil ons 'n fout kode van 1 om terug te keer en 'n fout boodskap print.

214
00:12:59,000 --> 00:13:02,000
En laastens, as die gebruiker aan ons gegee het goeie insette

215
00:13:02,000 --> 00:13:08,000
ons gaan om die getal te kwadreer en druk wat die resultaat.

216
00:13:08,000 --> 00:13:11,000
Net om seker te maak dat diegene wat al treffer huis

217
00:13:11,000 --> 00:13:17,000
jy kan sien die etikette van die verskillende dele van die kode hier.

218
00:13:17,000 --> 00:13:19,000
Ek genoem konstante, header lêers.

219
00:13:19,000 --> 00:13:21,000
O, int x. Maak seker om te onthou wat 'n plaaslike veranderlike is.

220
00:13:21,000 --> 00:13:24,000
Dit kontrasteer dit van 'n globale veranderlike, wat ons sal praat oor

221
00:13:24,000 --> 00:13:27,000
'n bietjie later in die hersiening sessie,

222
00:13:27,000 --> 00:13:30,000
en ons vra die biblioteek funksie printf,

223
00:13:30,000 --> 00:13:34,000
so as ons het nie die stdio.h header-lêer

224
00:13:34,000 --> 00:13:37,000
sou ons nie in staat wees om te printf noem.

225
00:13:37,000 --> 00:13:42,000
En ek glo dat die pyl wat hier het afgesny word verwys na die% d,

226
00:13:42,000 --> 00:13:45,000
wat is 'n opmaak string in printf.

227
00:13:45,000 --> 00:13:52,000
Dit sê Druk hierdie veranderlike as 'n getal,% d.

228
00:13:52,000 --> 00:13:58,000
En dit is dit vir Week 0.

229
00:13:58,000 --> 00:14:06,000
Lucas word nou gaan om voort te gaan.

230
00:14:06,000 --> 00:14:08,000
Hey, ouens. My naam is Lucas.

231
00:14:08,000 --> 00:14:10,000
Ek is 'n stage in die beste huis op kampus, Mather,

232
00:14:10,000 --> 00:14:14,000
en ek gaan 'n bietjie om te praat oor Week 1 en 2,1.

233
00:14:14,000 --> 00:14:16,000
[Week 1 en 2,1] [Lucas Freitas]

234
00:14:16,000 --> 00:14:19,000
As Lexi het gesê, toe ons begin met die vertaling van jou kode van nuuts af aan C

235
00:14:19,000 --> 00:14:23,000
een van die dinge wat ons opgemerk is dat jy kan nie net

236
00:14:23,000 --> 00:14:26,000
skryf jou kode en voer dit met behulp van 'n groen vlag nie.

237
00:14:26,000 --> 00:14:30,000
Eintlik, jy het 'n paar stappe om te gebruik om jou C-program te maak

238
00:14:30,000 --> 00:14:33,000
word 'n uitvoerbare lêer.

239
00:14:33,000 --> 00:14:36,000
Basies wat jy doen wanneer jy 'n program te skryf is dat

240
00:14:36,000 --> 00:14:40,000
jy vertaal jou idee in 'n taal wat 'n vertaler kan verstaan,

241
00:14:40,000 --> 00:14:44,000
So wanneer jy 'n program te skryf in C

242
00:14:44,000 --> 00:14:47,000
wat jy doen is eintlik iets te skryf wat jou samesteller is gaan om te verstaan,

243
00:14:47,000 --> 00:14:50,000
en dan die vertaler gaan daardie kode te vertaal

244
00:14:50,000 --> 00:14:53,000
in iets wat jou rekenaar sal verstaan.

245
00:14:53,000 --> 00:14:55,000
>> En die ding is, jou rekenaar is eintlik baie dom.

246
00:14:55,000 --> 00:14:57,000
Jou rekenaar kan slegs verstaan ​​0'e en 1s,

247
00:14:57,000 --> 00:15:01,000
so eintlik in die eerste rekenaars mense gewoonlik geprogrammeer

248
00:15:01,000 --> 00:15:04,000
deur gebruik te maak van 0'e en 1s, maar nie meer nie, dank God.

249
00:15:04,000 --> 00:15:07,000
Ons het nie die rye vir 0'e en 1s te memoriseer

250
00:15:07,000 --> 00:15:10,000
vir 'n for-lus of vir 'n while lus en so aan.

251
00:15:10,000 --> 00:15:13,000
Dit is waarom ons 'n vertaler.

252
00:15:13,000 --> 00:15:17,000
Wat 'n vertaler nie, is dit basies vertaal die C-kode,

253
00:15:17,000 --> 00:15:21,000
in ons geval, 'n taal wat jou rekenaar sal verstaan,

254
00:15:21,000 --> 00:15:25,000
wat is die object code, en die samesteller wat ons gebruik

255
00:15:25,000 --> 00:15:30,000
genoem word klang, so dit is eintlik die simbool vir die geratel.

256
00:15:30,000 --> 00:15:33,000
Wanneer jy jou program, moet jy 2 dinge te doen.

257
00:15:33,000 --> 00:15:37,000
Eerstens, jy het jou program saam te stel, en dan is jy gaan om jou program uit te voer.

258
00:15:37,000 --> 00:15:41,000
Jou program saam te stel, jy het 'n baie van die opsies om dit te doen.

259
00:15:41,000 --> 00:15:44,000
Die eerste een is kletteren program.c te doen

260
00:15:44,000 --> 00:15:47,000
wat die program is die naam van jou program.

261
00:15:47,000 --> 00:15:51,000
In hierdie geval kan jy sien hulle net sê "Hey, my program saamstel."

262
00:15:51,000 --> 00:15:56,000
Jy nie sê: "Ek wil hê dat hierdie naam vir my program" of iets.

263
00:15:56,000 --> 00:15:58,000
>> Die tweede opsie is om 'n naam te gee jou program.

264
00:15:58,000 --> 00:16:02,000
Jy kan sê klang-o en dan die naam wat jy wil

265
00:16:02,000 --> 00:16:06,000
die uitvoerbare lêer en dan program.c genoem word.

266
00:16:06,000 --> 00:16:11,000
En jy kan dit ook doen maak program, en sien hoe in die eerste 2 gevalle

267
00:16:11,000 --> 00:16:15,000
Ek het c, en in die derde een het ek net 'programme?

268
00:16:15,000 --> 00:16:18,000
Ja, jy eintlik moet nie sit c wanneer jy gebruik maak.

269
00:16:18,000 --> 00:16:22,000
Anders is die samesteller is eintlik van plan om op jou te skree.

270
00:16:22,000 --> 00:16:24,000
En ook, ek weet nie as julle onthou,

271
00:16:24,000 --> 00:16:29,000
maar 'n baie tye wat ons ook gebruik lcs50 of lm.

272
00:16:29,000 --> 00:16:31,000
Wat genoem word koppel.

273
00:16:31,000 --> 00:16:35,000
Dit vertel net die samesteller dat jy die biblioteke sal reg daar te gebruik,

274
00:16:35,000 --> 00:16:39,000
so as jy wil cs50.h te gebruik wat jy eintlik te tik

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

276
00:16:43,000 --> 00:16:45,000
As jy nie doen nie, is die vertaler nie weet

277
00:16:45,000 --> 00:16:50,000
dat jy met behulp van die funksies in cs50.h.

278
00:16:50,000 --> 00:16:52,000
En wanneer jy wil om jou program uit te voer jy het 2 opsies.

279
00:16:52,000 --> 00:16:57,000
As jy het geratel program.c jy het nie 'n naam aan jou program.

280
00:16:57,000 --> 00:17:01,000
Jy het om dit uit te voer met behulp van / a.out..

281
00:17:01,000 --> 00:17:06,000
A.out is 'n standaard naam wat kletteren gee jou program as jy dit nie 'n naam.

282
00:17:06,000 --> 00:17:11,000
Anders gaan jy / program. Te doen as jy 'n naam gegee het aan jou program,

283
00:17:11,000 --> 00:17:15,000
en ook as jy maak program die naam wat 'n program gaan kry

284
00:17:15,000 --> 00:17:23,000
is reeds gaan word geprogrammeer met dieselfde naam as die c-lêer.

285
00:17:23,000 --> 00:17:26,000
Dan het ons gepraat oor die datatipes en data.

286
00:17:26,000 --> 00:17:31,000
>> Basies data tipes is dieselfde ding as boksies wat hulle gebruik

287
00:17:31,000 --> 00:17:35,000
waardes op te slaan, sodat datatipes is eintlik net soos pokemons.

288
00:17:35,000 --> 00:17:39,000
Hulle kom in alle groottes en tipes.

289
00:17:39,000 --> 00:17:43,000
Ek weet nie indien daardie analogie sin maak.

290
00:17:43,000 --> 00:17:46,000
Die data grootte hang eintlik op die masjien argitektuur.

291
00:17:46,000 --> 00:17:49,000
Al die data groottes dat ek gaan om hier te wys

292
00:17:49,000 --> 00:17:53,000
is eintlik vir 'n 32-bis masjien, wat is die geval van ons toestel,

293
00:17:53,000 --> 00:17:56,000
maar as jy eintlik die kodering van jou Mac of in 'n Windows ook

294
00:17:56,000 --> 00:17:59,000
jy waarskynlik gaan 'n 64-bis masjien te hê,

295
00:17:59,000 --> 00:18:03,000
so onthou dat die data groottes wat ek gaan hier om te wys

296
00:18:03,000 --> 00:18:06,000
is vir die 32-bis masjien.

297
00:18:06,000 --> 00:18:08,000
Die eerste een wat ons gesien het was 'n int,

298
00:18:08,000 --> 00:18:10,000
wat is redelik eenvoudig.

299
00:18:10,000 --> 00:18:13,000
Jy gebruik int 'n heelgetal te stoor.

300
00:18:13,000 --> 00:18:16,000
Ons het ook die karakter, die char.

301
00:18:16,000 --> 00:18:20,000
As jy wil 'n brief of 'n simbool te gebruik wat jy waarskynlik gaan 'n kar om te gebruik.

302
00:18:20,000 --> 00:18:26,000
'N char het 1 byte, wat beteken 8 stukkies, soos Lexi gesê.

303
00:18:26,000 --> 00:18:31,000
Basies het ons 'n ASCII tabel wat 256

304
00:18:31,000 --> 00:18:34,000
moontlike kombinasies van 0'e en 1s,

305
00:18:34,000 --> 00:18:37,000
en dan wanneer jy 'n kar dit gaan om te vertaal

306
00:18:37,000 --> 00:18:44,000
die karakter wat insette jy 'n nommer wat jy het in die ASCII-tabel, soos Lexi gesê.

307
00:18:44,000 --> 00:18:48,000
Ons het ook die float wat ons gebruik om desimale getalle te stoor.

308
00:18:48,000 --> 00:18:53,000
As jy wil om te kies 3,14, byvoorbeeld, jy gaan 'n float te gebruik

309
00:18:53,000 --> 00:18:55,000
of 'n dubbel wat meer akkuraatheid.

310
00:18:55,000 --> 00:18:57,000
'N float het 4 grepe.

311
00:18:57,000 --> 00:19:01,000
'N dubbel 8 grepe, so die enigste verskil is die presisie.

312
00:19:01,000 --> 00:19:04,000
Ons het ook 'n lang wat gebruik word vir heelgetalle,

313
00:19:04,000 --> 00:19:09,000
en jy kan sien vir 'n 32-bis masjien 'n int en 'n lang dieselfde grootte,

314
00:19:09,000 --> 00:19:13,000
so dit maak nie regtig sin maak 'n lang om te gebruik in 'n 32-bis masjien.

315
00:19:13,000 --> 00:19:17,000
>> Maar as jy die gebruik van 'n Mac en 64-bis masjien, eintlik 'n lang grootte 8,

316
00:19:17,000 --> 00:19:19,000
so dit hang af van die argitektuur.

317
00:19:19,000 --> 00:19:22,000
Vir die 32-bis masjien dit nie sin maak nie 'n lang om werklik te gebruik.

318
00:19:22,000 --> 00:19:25,000
En dan 'n lang lang, aan die ander kant, het 8 grepe,

319
00:19:25,000 --> 00:19:30,000
so dit is baie goed as jy wil 'n langer heelgetal te hê.

320
00:19:30,000 --> 00:19:34,000
En laastens, ons het string, wat eintlik 'n char *

321
00:19:34,000 --> 00:19:37,000
wat is 'n verwysing na 'n char.

322
00:19:37,000 --> 00:19:40,000
Dit is baie maklik om te dink dat die grootte van die tou gaan wees soos

323
00:19:40,000 --> 00:19:42,000
die aantal karakters wat jy daar,

324
00:19:42,000 --> 00:19:45,000
maar eintlik is die char * self

325
00:19:45,000 --> 00:19:49,000
het die grootte van 'n wyser na 'n char wat is 4 grepe.

326
00:19:49,000 --> 00:19:52,000
Die grootte van 'n char * is 4 grepe.

327
00:19:52,000 --> 00:19:56,000
Dit maak nie saak as jy 'n klein woord of 'n brief of iets.

328
00:19:56,000 --> 00:19:58,000
Dit gaan wees 4 grepe.

329
00:19:58,000 --> 00:20:01,000
Ons het ook geleer 'n bietjie oor die beslissende,

330
00:20:01,000 --> 00:20:04,000
so soos jy kan sien, as jy, byvoorbeeld, 'n program wat sê

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

332
00:20:08,000 --> 00:20:12,000
julle weet wat dit gaan om op die skerm te druk?

333
00:20:12,000 --> 00:20:14,000
>> Iemand >> [Studente] 2.

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

335
00:20:16,000 --> 00:20:20,000
As jy dit doen 3/2 gaan om 1,5 te kry,

336
00:20:20,000 --> 00:20:24,000
maar aangesien ons met behulp van 'n heelgetal dit gaan die desimale deel te ignoreer,

337
00:20:24,000 --> 00:20:26,000
en jy gaan te hê 1.

338
00:20:26,000 --> 00:20:29,000
As jy nie wil hê dat dit gebeur wat jy kan doen, byvoorbeeld,

339
00:20:29,000 --> 00:20:33,000
is 'n float verklaar y = x.

340
00:20:33,000 --> 00:20:40,000
Dan is x wat gebruik word om 3 gaan nou 3,000 in y.

341
00:20:40,000 --> 00:20:44,000
En dan kan jy druk die y / 2.

342
00:20:44,000 --> 00:20:50,000
Eintlik, moet ek 'n 2. daar.

343
00:20:50,000 --> 00:20:55,000
Dit gaan 3.00/2.00 te doen,

344
00:20:55,000 --> 00:20:58,000
en jy gaan te kry 1,5.

345
00:20:58,000 --> 00:21:06,000
En ons het hierdie 0,2 f net te vra vir 2 desimale eenhede in die desimale deel.

346
00:21:06,000 --> 00:21:12,000
As jy het 0,3 f dit gaan eintlik het 1,500.

347
00:21:12,000 --> 00:21:16,000
As dit is 2 gaan dit wees 1,50.

348
00:21:16,000 --> 00:21:18,000
Ons het ook hierdie geval hier.

349
00:21:18,000 --> 00:21:22,000
As jy dit doen float x = 3,14 en dan kan jy printf x

350
00:21:22,000 --> 00:21:24,000
jy gaan te kry 3,14.

351
00:21:24,000 --> 00:21:29,000
En as jy dit doen x = int van x,

352
00:21:29,000 --> 00:21:34,000
wat beteken behandel x as 'n int, en jy druk x nou

353
00:21:34,000 --> 00:21:36,000
jy gaan te hê 3,00.

354
00:21:36,000 --> 00:21:38,000
Maak dit sin?

355
00:21:38,000 --> 00:21:41,000
Omdat jy eerste X te behandel as 'n heelgetal, sodat jy ignoreer die desimale deel,

356
00:21:41,000 --> 00:21:45,000
en dan is jy die druk van x.

357
00:21:45,000 --> 00:21:47,000
En laastens, kan jy dit ook doen,

358
00:21:47,000 --> 00:21:52,000
int x = 65, en dan verklaar 'n char c = x,

359
00:21:52,000 --> 00:21:56,000
en dan as jy die druk van die c wat jy eintlik gaan om te kry

360
00:21:56,000 --> 00:21:59,000
A, so basies wat jy hier doen,

361
00:21:59,000 --> 00:22:02,000
die vertaling van die heelgetal in die karakter,

362
00:22:02,000 --> 00:22:05,000
net soos die ASCII-tabel nie.

363
00:22:05,000 --> 00:22:08,000
Ons het ook gepraat oor die wiskunde operateurs.

364
00:22:08,000 --> 00:22:14,000
Die meeste van hulle is redelik eenvoudig, so +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
en ook het ons gepraat oor die mod, wat is die res van 'n afdeling van 2 getalle.

366
00:22:20,000 --> 00:22:23,000
As jy 10% 3, byvoorbeeld,

367
00:22:23,000 --> 00:22:27,000
beteken dit verdeel 10 deur 3, en wat is die res?

368
00:22:27,000 --> 00:22:30,000
Dit gaan wees 1, so dit is eintlik baie nuttig vir 'n baie van die programme.

369
00:22:30,000 --> 00:22:38,000
Vir Vigenère en Caesar Ek is redelik seker dat almal van julle ouens gebruik mod.

370
00:22:38,000 --> 00:22:43,000
Oor wiskunde operateurs, baie versigtig wees wanneer die kombinasie van * en /.

371
00:22:43,000 --> 00:22:48,000
>> Byvoorbeeld, as jy dit doen (3/2) * 2 wat jy gaan kry?

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

373
00:22:50,000 --> 00:22:54,000
Ja, 2, want 3/2 gaan wees 1,5,

374
00:22:54,000 --> 00:22:57,000
maar aangesien jy doen bewerkings tussen 2 heelgetalle

375
00:22:57,000 --> 00:22:59,000
jy eintlik net gaan om te oorweeg 1,

376
00:22:59,000 --> 00:23:03,000
en dan 1 * 2 gaan wees 2, so baie, baie versigtig wees

377
00:23:03,000 --> 00:23:07,000
wanneer om rekenkunde met heelgetalle te doen, want

378
00:23:07,000 --> 00:23:12,000
wat jy kan kry dat 2 = 3, in daardie geval.

379
00:23:12,000 --> 00:23:14,000
En ook baie versigtig wees oor voorrang.

380
00:23:14,000 --> 00:23:21,000
Jy moet gewoonlik hakies gebruik om seker te wees dat jy weet wat jy doen.

381
00:23:21,000 --> 00:23:27,000
'N paar nuttige kortpaaie, natuurlik, die een is i + + of i + = 1

382
00:23:27,000 --> 00:23:30,000
of die gebruik van + =.

383
00:23:30,000 --> 00:23:34,000
Dit is dieselfde ding as i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Jy kan dit ook doen - of i - = 1,

385
00:23:39,000 --> 00:23:42,000
wat is die dieselfde ding as i = i -1,

386
00:23:42,000 --> 00:23:46,000
iets wat jy ouens gebruik 'n lot in vir loops, ten minste.

387
00:23:46,000 --> 00:23:52,000
Ook, vir *, as jy gebruik * = en as jy dit doen, byvoorbeeld,

388
00:23:52,000 --> 00:23:57,000
i * = 2 is dieselfde ding gesê i = i * 2,

389
00:23:57,000 --> 00:23:59,000
en dieselfde ding vir die afdeling.

390
00:23:59,000 --> 00:24:08,000
As jy dit doen ek / = 2 dit is die dieselfde ding as i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Nou oor funksies.

392
00:24:10,000 --> 00:24:13,000
Julle ouens het geleer dat funksies is 'n baie goeie strategie om die kode te red

393
00:24:13,000 --> 00:24:16,000
terwyl jy programmering, so as jy wil om dieselfde taak te verrig

394
00:24:16,000 --> 00:24:20,000
in die kode weer en weer, het jy waarskynlik wil 'n funksie te gebruik

395
00:24:20,000 --> 00:24:25,000
net sodat jy hoef nie te kopieer en plak die kode oor en oor weer.

396
00:24:25,000 --> 00:24:28,000
Eintlik, hoof is 'n funksie, en wanneer ek wys jou die formaat van 'n funksie

397
00:24:28,000 --> 00:24:32,000
jy gaan om te sien dat dit redelik voor die hand liggend.

398
00:24:32,000 --> 00:24:35,000
Ons gebruik ook funksies van sommige biblioteke,

399
00:24:35,000 --> 00:24:39,000
byvoorbeeld, printf, getin, wat uit die CS50 biblioteek,

400
00:24:39,000 --> 00:24:43,000
en ander funksies soos toupper.

401
00:24:43,000 --> 00:24:46,000
Al daardie funksies is eintlik in ander biblioteke geïmplementeer,

402
00:24:46,000 --> 00:24:49,000
en wanneer jy daardie ketting lêers in die begin van jou program

403
00:24:49,000 --> 00:24:53,000
jy sê kan jy gee my asseblief die kode vir daardie funksies

404
00:24:53,000 --> 00:24:57,000
so ek het nie om dit te implementeer deur myself?

405
00:24:57,000 --> 00:25:00,000
En jy kan ook skryf jou eie funksies, so wanneer jy begin programmering

406
00:25:00,000 --> 00:25:04,000
jy besef dat biblioteke nie al die funksies wat jy nodig het.

407
00:25:04,000 --> 00:25:10,000
Vir die laaste pset, byvoorbeeld, het ons geskryf het trek, scramble en soek,

408
00:25:10,000 --> 00:25:13,000
en dit is baie, baie belangrik om in staat te wees om funksies uit te skryf

409
00:25:13,000 --> 00:25:17,000
want hulle is nuttig, en ons gebruik dit al die tyd in die programmering,

410
00:25:17,000 --> 00:25:19,000
en dit slaan 'n klomp van die kode.

411
00:25:19,000 --> 00:25:21,000
Die formaat van 'n funksie is hierdie een.

412
00:25:21,000 --> 00:25:24,000
Ons het terugkeer soort in die begin. Wat is die terugkeer tipe?

413
00:25:24,000 --> 00:25:27,000
Dis net wanneer jou funksie gaan om terug te keer.

414
00:25:27,000 --> 00:25:29,000
As jy 'n funksie, byvoorbeeld, faktoriaal,

415
00:25:29,000 --> 00:25:31,000
wat gaan om 'n produk van 'n heelgetal te bereken,

416
00:25:31,000 --> 00:25:34,000
seker dit gaan 'n heelgetal ook terugkeer.

417
00:25:34,000 --> 00:25:37,000
Dan die opbrengs soort gaan wees int.

418
00:25:37,000 --> 00:25:41,000
Printf het eintlik 'n terugkeer tipe leemte

419
00:25:41,000 --> 00:25:43,000
omdat jy nie terugkeer enigiets.

420
00:25:43,000 --> 00:25:45,000
Jy net die druk van dinge op die skerm

421
00:25:45,000 --> 00:25:48,000
en ophou die funksie daarna.

422
00:25:48,000 --> 00:25:51,000
Dan moet jy die naam van die funksie wat jy kan kies.

423
00:25:51,000 --> 00:25:55,000
Jy moet 'n bietjie redelike, soos nie kies 'n naam soos xyz

424
00:25:55,000 --> 00:25:58,000
of soos x2f.

425
00:25:58,000 --> 00:26:02,000
Probeer om te maak 'n naam wat sin maak.

426
00:26:02,000 --> 00:26:04,000
>> Byvoorbeeld, as dit is faktoriaal, sê faktoriaal.

427
00:26:04,000 --> 00:26:08,000
As dit is 'n funksie wat gaan om iets te skep, noem dit trek.

428
00:26:08,000 --> 00:26:11,000
En dan het ons die parameters, wat ook genoem argumente,

429
00:26:11,000 --> 00:26:14,000
wat is soos die hulpbronne wat u funksie behoeftes

430
00:26:14,000 --> 00:26:17,000
van jou kode om sy taak uit te voer.

431
00:26:17,000 --> 00:26:20,000
As jy wil die faktore van 'n getal te bereken

432
00:26:20,000 --> 00:26:23,000
waarskynlik wat jy nodig het om 'n nommer te hê om 'n faktoriale te bereken.

433
00:26:23,000 --> 00:26:27,000
Een van die argumente wat jy gaan te hê is die getal self.

434
00:26:27,000 --> 00:26:31,000
En dan is dit gaan om iets te doen en die waarde aan die einde terugkeer

435
00:26:31,000 --> 00:26:35,000
tensy dit is 'n leemte funksie.

436
00:26:35,000 --> 00:26:37,000
Kom ons kyk 'n voorbeeld.

437
00:26:37,000 --> 00:26:40,000
As ek wil 'n funksie te skryf wat al die getalle in 'n verskeidenheid van heelgetalle som,

438
00:26:40,000 --> 00:26:43,000
Eerste van alles, is die terugkeer soort gaan wees int

439
00:26:43,000 --> 00:26:46,000
want ek het 'n skikking van heelgetalle.

440
00:26:46,000 --> 00:26:51,000
En dan gaan ek die funksie naam soos sumArray te hê,

441
00:26:51,000 --> 00:26:54,000
en dan is dit gaan die skikking self te neem, tot int nume,

442
00:26:54,000 --> 00:26:58,000
en dan is die lengte van die skikking, sodat ek weet hoeveel nommers Ek het op te som.

443
00:26:58,000 --> 00:27:02,000
Dan het ek 'n veranderlike genoem som, byvoorbeeld, om 0 te inisialiseer,

444
00:27:02,000 --> 00:27:08,000
en elke keer as ek sien 'n element in die skikking wat ek moet byvoeg om dit te som, so ek het 'n for-lus.

445
00:27:08,000 --> 00:27:15,000
Net soos Lexi gesê het, jy doen int i = 0, i <lengte en i + +.

446
00:27:15,000 --> 00:27:20,000
En vir elke element in die skikking het ek som + = nume [i],

447
00:27:20,000 --> 00:27:24,000
en dan het ek die bedrag terug, so dit is baie eenvoudig, en dit spaar 'n baie van die kode

448
00:27:24,000 --> 00:27:28,000
as jy die gebruik van hierdie funksie 'n baie van die tye.

449
00:27:28,000 --> 00:27:32,000
Dan het ons 'n blik op die voorwaardes.

450
00:27:32,000 --> 00:27:38,000
Ons het as anders, en anders as.

451
00:27:38,000 --> 00:27:42,000
Kom ons kyk wat is die verskil tussen daardie.

452
00:27:42,000 --> 00:27:45,000
Neem 'n blik op hierdie 2 kodes. Wat is die verskil tussen hulle?

453
00:27:45,000 --> 00:27:49,000
Die eerste een is basies die kodes wil jou vertel

454
00:27:49,000 --> 00:27:51,000
indien 'n nommer +, -, of 0.

455
00:27:51,000 --> 00:27:55,000
Die eerste een sê as dit is> 0 dan is dit positief.

456
00:27:55,000 --> 00:28:00,000
As dit is = tot 0, dan is dit is 0, en as dit is <0, dan is dit negatief.

457
00:28:00,000 --> 00:28:04,000
>> En die ander een doen indien anders as anders.

458
00:28:04,000 --> 00:28:07,000
Die verskil tussen die twee is dat hierdie een eintlik gaan

459
00:28:07,000 --> 00:28:13,000
kyk of> 0 <0 of = 0 drie keer,

460
00:28:13,000 --> 00:28:17,000
so as jy die getal 2, byvoorbeeld, is dit gaan om hier te kom en sê

461
00:28:17,000 --> 00:28:21,000
if (x> 0), en dit gaan om te sê ja, so ek druk positief.

462
00:28:21,000 --> 00:28:25,000
Maar alhoewel ek weet dat dit is> 0 en dit gaan nie wees 0 of <0

463
00:28:25,000 --> 00:28:29,000
Ek nog steeds gaan om dit te doen is dit 0, is dit <0,

464
00:28:29,000 --> 00:28:33,000
so ek is eintlik gaan binnekant van ifs dat ek nie hoef te

465
00:28:33,000 --> 00:28:38,000
omdat ek reeds weet dat dit nie gaan om enige van hierdie voorwaardes te voldoen.

466
00:28:38,000 --> 00:28:41,000
Ek kan gebruik om die as, anders as, anders verklaring.

467
00:28:41,000 --> 00:28:45,000
Dit sê basies as x = 0 Ek druk die positiewe.

468
00:28:45,000 --> 00:28:48,000
As dit is nie, ek gaan ook toets.

469
00:28:48,000 --> 00:28:51,000
As dit is 2 nie ek gaan om dit te doen.

470
00:28:51,000 --> 00:28:54,000
Basies as ek het x = 2 sou jy sê

471
00:28:54,000 --> 00:28:57,000
if (x> 0), ja, so print hierdie.

472
00:28:57,000 --> 00:29:00,000
Nou dat ek weet dat dit is> 0 en dat dit voldoen aan die eerste as

473
00:29:00,000 --> 00:29:02,000
Ek is nie eens gaan hierdie kode uit te voer.

474
00:29:02,000 --> 00:29:09,000
Die kode loop vinniger, eintlik, 3 keer vinniger as jy dit gebruik.

475
00:29:09,000 --> 00:29:11,000
Ons het ook geleer het oor en of.

476
00:29:11,000 --> 00:29:15,000
Ek gaan nie om te gaan deur middel van hierdie, want Lexi het reeds gepraat oor hulle.

477
00:29:15,000 --> 00:29:17,000
Dit is net die && | | operateur.

478
00:29:17,000 --> 00:29:21,000
>> Die enigste ding wat ek sal sê, is versigtig wees wanneer jy het 3 voorwaardes.

479
00:29:21,000 --> 00:29:24,000
Gebruik hakies, want dit is baie verwarrend wanneer jy 'n toestand

480
00:29:24,000 --> 00:29:27,000
en 'n ander een of die ander een.

481
00:29:27,000 --> 00:29:30,000
Gebruik hakies net om seker te wees dat jou omstandighede sin maak

482
00:29:30,000 --> 00:29:34,000
want in daardie geval, byvoorbeeld, kan jy dink dat

483
00:29:34,000 --> 00:29:38,000
dit kan die eerste toestand en die een of ander

484
00:29:38,000 --> 00:29:41,000
of die 2 voorwaardes gekombineer in 'n

485
00:29:41,000 --> 00:29:45,000
of die derde een, so wees versigtig.

486
00:29:45,000 --> 00:29:48,000
En laastens, het ons gepraat oor die skakelaars.

487
00:29:48,000 --> 00:29:53,000
'N skakelaar is baie nuttig wanneer jy 'n veranderlike.

488
00:29:53,000 --> 00:29:55,000
Kom ons sê dat jy het 'n veranderlike soos n

489
00:29:55,000 --> 00:29:59,000
wat kan wees 0, 1 of 2, en vir elkeen van daardie gevalle

490
00:29:59,000 --> 00:30:01,000
jy gaan om 'n taak uit te voer.

491
00:30:01,000 --> 00:30:04,000
Jy kan sê skakel die veranderlike, en dit dui daarop dat

492
00:30:04,000 --> 00:30:08,000
die waarde is dan soos waarde1 ek gaan om dit te doen,

493
00:30:08,000 --> 00:30:12,000
en dan het ek breek, wat beteken ek gaan nie om te kyk na enige van die ander gevalle

494
00:30:12,000 --> 00:30:15,000
omdat ons reeds tevrede is dat

495
00:30:15,000 --> 00:30:20,000
en dan waarde2 en so aan, en ek kan ook 'n standaard skakel.

496
00:30:20,000 --> 00:30:24,000
Dit beteken dat as dit nie enige van die gevalle wat ek moes voldoen

497
00:30:24,000 --> 00:30:29,000
dat ek gaan om iets anders te doen, maar dit is opsioneel.

498
00:30:29,000 --> 00:30:36,000
Dit is al wat vir my. Nou laat ons Tommy.

499
00:30:36,000 --> 00:30:41,000
Alle reg, dit gaan Week 3-ish.

500
00:30:41,000 --> 00:30:45,000
Dit is 'n paar van die onderwerpe wat ons sal bedek word, crypto, omvang, skikkings, ensovoorts.

501
00:30:45,000 --> 00:30:49,000
Net 'n vinnige woord op crypto. Ons gaan nie hierdie huis te hamer.

502
00:30:49,000 --> 00:30:52,000
>> Ons het dit in pset 2, maar vir die quiz maak seker dat jy weet wat die verskil

503
00:30:52,000 --> 00:30:54,000
tussen die keiser cipher en die Vigenère cipher,

504
00:30:54,000 --> 00:30:57,000
hoe beide van diegene getalle werk en wat dit is soos om te enkripteer

505
00:30:57,000 --> 00:30:59,000
en dekripteer teks met behulp van dié 2 getalle.

506
00:30:59,000 --> 00:31:03,000
Onthou, die keiser cipher draai net elke karakter met dieselfde bedrag,

507
00:31:03,000 --> 00:31:06,000
maak seker dat jy mod deur die aantal letters in die alfabet.

508
00:31:06,000 --> 00:31:09,000
En die Vigenère cipher, aan die ander kant, roteer elke karakter

509
00:31:09,000 --> 00:31:12,000
deur 'n ander bedrag, so eerder as om te sê

510
00:31:12,000 --> 00:31:15,000
elke karakter geroteer deur 3 Vigenère sal roteer elke karakter

511
00:31:15,000 --> 00:31:17,000
deur 'n ander bedrag afhangend op 'n aantal navraag

512
00:31:17,000 --> 00:31:20,000
waar elke letter in die sleutelwoord paar verskillende bedrag

513
00:31:20,000 --> 00:31:26,000
die duidelike teks te draai.

514
00:31:26,000 --> 00:31:28,000
Laat ons eers praat oor die veranderlike omvang.

515
00:31:28,000 --> 00:31:30,000
Daar is 2 verskillende tipes van veranderlikes.

516
00:31:30,000 --> 00:31:33,000
Ons plaaslike veranderlikes, en hierdie gaan word gedefinieer

517
00:31:33,000 --> 00:31:36,000
buite van die hoof of buite enige funksie of blok,

518
00:31:36,000 --> 00:31:39,000
en dit sal toeganklik wees op enige plek in jou program.

519
00:31:39,000 --> 00:31:41,000
As jy 'n funksie en in daardie funksie is 'n while lus

520
00:31:41,000 --> 00:31:44,000
die groot globale veranderlike toeganklik is oral.

521
00:31:44,000 --> 00:31:48,000
'N plaaslike veranderlike, aan die ander kant, is scoped na die plek waar dit word gedefinieer.

522
00:31:48,000 --> 00:31:53,000
>> As jy 'n funksie hier, byvoorbeeld, ons het hierdie funksie g,

523
00:31:53,000 --> 00:31:56,000
en binnekant van g is daar is 'n veranderlike wat hier genoem y,

524
00:31:56,000 --> 00:31:58,000
en dit beteken dat dit is 'n plaaslike veranderlike.

525
00:31:58,000 --> 00:32:00,000
Selfs al is hierdie veranderlike genoem word y

526
00:32:00,000 --> 00:32:03,000
en hierdie veranderlike is y van hierdie 2 funksies genoem

527
00:32:03,000 --> 00:32:06,000
het geen idee wat mekaar se plaaslike veranderlikes is.

528
00:32:06,000 --> 00:32:10,000
Aan die ander kant, hier is ons sê int x = 5,

529
00:32:10,000 --> 00:32:12,000
en dit is buite die bestek van enige funksie.

530
00:32:12,000 --> 00:32:16,000
Dit is buite die bestek van die belangrikste, so dit is 'n globale veranderlike.

531
00:32:16,000 --> 00:32:20,000
Dit beteken dat die binnekant van hierdie 2 funksies toe ek sê x - of x + +

532
00:32:20,000 --> 00:32:26,000
Ek toegang tot dieselfde x waardeur hierdie y en y is verskillende veranderlikes.

533
00:32:26,000 --> 00:32:30,000
Dit is die verskil tussen 'n globale veranderlike en 'n plaaslike veranderlike.

534
00:32:30,000 --> 00:32:33,000
So ver as wat ontwerp betref, soms is dit waarskynlik 'n beter idee

535
00:32:33,000 --> 00:32:37,000
te hou veranderlikes plaaslike wanneer jy moontlik kan

536
00:32:37,000 --> 00:32:39,000
sedert met 'n klomp van die globale veranderlikes kan kry regtig verwarrend.

537
00:32:39,000 --> 00:32:42,000
As jy 'n klomp van die funksies die wysiging van die dieselfde ding

538
00:32:42,000 --> 00:32:45,000
jy dalk vergeet wat as hierdie funksie per ongeluk verander hierdie globale,

539
00:32:45,000 --> 00:32:47,000
en hierdie ander funksie nie weet nie,

540
00:32:47,000 --> 00:32:50,000
en dit het 'n bietjie verwarrend as jy meer kode.

541
00:32:50,000 --> 00:32:53,000
Hou veranderlikes plaaslike wanneer jy moontlik kan

542
00:32:53,000 --> 00:32:56,000
is net goeie ontwerp.

543
00:32:56,000 --> 00:33:00,000
Skikkings, onthou, is eenvoudig lyste van die elemente van dieselfde tipe.

544
00:33:00,000 --> 00:33:04,000
Binnekant van CI kan nie 'n lys soos 1, 2,0, hello.

545
00:33:04,000 --> 00:33:06,000
Ons kan net nie doen nie.

546
00:33:06,000 --> 00:33:11,000
>> Wanneer ons 'n skikking in C verklaar al die elemente van dieselfde soort te wees.

547
00:33:11,000 --> 00:33:14,000
Hier het ek het 'n skikking van 3 heelgetalle.

548
00:33:14,000 --> 00:33:18,000
Hier het ek die lengte van die skikking, maar as ek net verklaar dat dit in hierdie sintaksis

549
00:33:18,000 --> 00:33:21,000
waar ek spesifiseer wat al die elemente is ek tegnies hoef nie hierdie 3.

550
00:33:21,000 --> 00:33:25,000
Die samesteller is slim genoeg om uit te vind hoe groot die skikking moet wees.

551
00:33:25,000 --> 00:33:28,000
Nou wanneer ek wil kry of die waarde van 'n skikking

552
00:33:28,000 --> 00:33:30,000
dit is die sintaksis om dit te doen.

553
00:33:30,000 --> 00:33:33,000
Dit sal eintlik die tweede element van die skikking te verander, want, onthou,

554
00:33:33,000 --> 00:33:36,000
nommering begin by 0, nie op 1.

555
00:33:36,000 --> 00:33:42,000
As Ek wil hê dat die waarde te lees, ek kan iets sê soos: int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Of as ek wil hê dat die waarde te stel, soos ek hier doen,

557
00:33:44,000 --> 00:33:47,000
Ek kan sê array [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Daardie tyd toegang tot die elemente deur die indeks

559
00:33:50,000 --> 00:33:52,000
of hul posisie of waar hulle is in die skikking,

560
00:33:52,000 --> 00:33:57,000
en dat die lys begin by 0.

561
00:33:57,000 --> 00:34:00,000
Ons kan ook 'n skikkings van skikkings,

562
00:34:00,000 --> 00:34:03,000
en dit is 'n multi-dimensionele skikking genoem.

563
00:34:03,000 --> 00:34:05,000
Wanneer ons 'n multi-dimensionele skikking

564
00:34:05,000 --> 00:34:07,000
wat beteken dat ons kan iets soos rye en kolomme,

565
00:34:07,000 --> 00:34:11,000
en dit is net een manier van visualisering van hierdie of te dink oor dit.

566
00:34:11,000 --> 00:34:14,000
As ek 'n multi-dimensionele skikking wat beteken dat ek gaan om te begin nodig

567
00:34:14,000 --> 00:34:17,000
meer as 1 indeks want as ek het 'n rooster

568
00:34:17,000 --> 00:34:19,000
sê maar net wat ry jy in gee ons nie 'n nommer.

569
00:34:19,000 --> 00:34:22,000
Dit is net regtig gaan om te gee vir ons 'n lys van getalle.

570
00:34:22,000 --> 00:34:25,000
Kom ons sê ek het hierdie skikking hier.

571
00:34:25,000 --> 00:34:30,000
Ek het 'n skikking met die naam rooster, en ek sê dit is 2 rye en 3 kolomme,

572
00:34:30,000 --> 00:34:32,000
en so dit is een manier om dit te visualiseer.

573
00:34:32,000 --> 00:34:37,000
As ek sê ek wil hê dat die element te kry by [1] [2]

574
00:34:37,000 --> 00:34:41,000
wat beteken dat omdat hierdie rye eerste en dan kolomme

575
00:34:41,000 --> 00:34:44,000
Ek gaan om te spring 1 te roei, want ek het gesê 1.

576
00:34:44,000 --> 00:34:49,000
>> Dan gaan ek om te kom oor hier om te kolom 2, en ek gaan na die waarde 6.

577
00:34:49,000 --> 00:34:51,000
Sin maak?

578
00:34:51,000 --> 00:34:55,000
Multi-dimensionele skikkings, onthou, is tegnies net 'n verskeidenheid van skikkings.

579
00:34:55,000 --> 00:34:57,000
Ons kan skikkings van skikkings van skikkings.

580
00:34:57,000 --> 00:35:00,000
Ons kan hou, maar regtig 'n manier om te dink oor

581
00:35:00,000 --> 00:35:03,000
hoe dit word uitgelê en wat aangaan, is om dit te visualiseer

582
00:35:03,000 --> 00:35:09,000
in 'n rooster soos hierdie.

583
00:35:09,000 --> 00:35:12,000
Wanneer ons skikkings funksies slaag, gaan hulle om op te tree

584
00:35:12,000 --> 00:35:16,000
'n bietjie anders as ons slaag van gereelde veranderlikes funksies

585
00:35:16,000 --> 00:35:18,000
soos om 'n int of 'n float.

586
00:35:18,000 --> 00:35:21,000
Wanneer ons in 'n int of char of enige van hierdie ander data tipes slaag

587
00:35:21,000 --> 00:35:24,000
ons het net 'n blik op as die funksie verander

588
00:35:24,000 --> 00:35:28,000
die waarde van die veranderlike wat verandering gaan nie te propageer

589
00:35:28,000 --> 00:35:32,000
aan die roeping funksie.

590
00:35:32,000 --> 00:35:35,000
Met 'n skikking, aan die ander kant, dit sal gebeur nie.

591
00:35:35,000 --> 00:35:39,000
As ek in 'n skikking na 'n funksie en daardie funksie verander sommige van die elemente,

592
00:35:39,000 --> 00:35:43,000
wanneer ek terug kom na die funksie wat dit genoem

593
00:35:43,000 --> 00:35:47,000
my skikking nou gaan om anders te wees, en die woordeskat vir

594
00:35:47,000 --> 00:35:50,000
is skikkings deur verwysing geslaag, soos ons later sal sien.

595
00:35:50,000 --> 00:35:53,000
Dit is verwant aan hoe wysers werk, waar hierdie basiese datatipes,

596
00:35:53,000 --> 00:35:55,000
aan die ander kant, word geslaag deur waarde.

597
00:35:55,000 --> 00:35:59,000
>> Ons kan dink dat as die maak van 'n afskrif van 'n paar veranderlike en dan wat in die kopie.

598
00:35:59,000 --> 00:36:01,000
Dit maak nie saak wat ons doen met daardie veranderlike.

599
00:36:01,000 --> 00:36:06,000
Die roeping funksie sal nie bewus daarvan dat dit verander.

600
00:36:06,000 --> 00:36:10,000
Skikkings is net 'n bietjie anders in dié verband.

601
00:36:10,000 --> 00:36:13,000
Byvoorbeeld, as ons nou net gesien het, die vernaamste is eenvoudig 'n funksie

602
00:36:13,000 --> 00:36:15,000
wat kan in 2 argumente.

603
00:36:15,000 --> 00:36:20,000
Die eerste argument aan die hoofprogram is argc of die getal van argumente,

604
00:36:20,000 --> 00:36:23,000
en die tweede argument genoem bevat SPASIES,

605
00:36:23,000 --> 00:36:27,000
en dit is die werklike waardes van daardie argumente.

606
00:36:27,000 --> 00:36:30,000
Kom ons sê ek het 'n program genaamd this.c,

607
00:36:30,000 --> 00:36:34,000
en ek sê maak dit, en ek gaan om dit uit te voer op die command line.

608
00:36:34,000 --> 00:36:38,000
Nou te slaag in sommige argumente na my program noem dit,

609
00:36:38,000 --> 00:36:42,000
Ek kon iets sê / dit is cs 50.

610
00:36:42,000 --> 00:36:45,000
Dit is wat ons dink om Dawid te doen elke dag by die terminale.

611
00:36:45,000 --> 00:36:48,000
Maar nou is die hooffunksie binnekant van daardie program

612
00:36:48,000 --> 00:36:52,000
het hierdie waardes, so argc is 4.

613
00:36:52,000 --> 00:36:56,000
Dit kan 'n bietjie verwarrend, want regtig ons net verby is cs 50.

614
00:36:56,000 --> 00:36:58,000
Dit is slegs 3.

615
00:36:58,000 --> 00:37:02,000
Maar onthou dat die eerste element van bevat SPASIES of die eerste argument

616
00:37:02,000 --> 00:37:05,000
is die naam van die funksie self.

617
00:37:05,000 --> 00:37:07,190
So dit beteken dat ons het 4 dinge hier,

618
00:37:07,190 --> 00:37:10,530
en die eerste element gaan wees /..

619
00:37:10,530 --> 00:37:12,970
En dit sal verteenwoordig word as 'n string.

620
00:37:12,970 --> 00:37:18,590
Toe het die oorblywende elemente is wat ons na die naam van die program getik in.

621
00:37:18,590 --> 00:37:22,720
Dus, net soos 'n eenkant, as ons waarskynlik het in pset 2,

622
00:37:22,720 --> 00:37:28,780
onthou dat die string 50 integer 50 ≠.

623
00:37:28,780 --> 00:37:32,520
Ons kan dus nie sê iets soos, 'int x = bevat SPASIES 3. "

624
00:37:32,520 --> 00:37:36,470
>> Dit is nie net gaan om sin te maak, want dit is 'n string, en dit is 'n heelgetal.

625
00:37:36,470 --> 00:37:38,510
So as jy wil om te skakel tussen die 2, onthou, ons gaan

626
00:37:38,510 --> 00:37:40,810
het hierdie magic funksie genoem atoi.

627
00:37:40,810 --> 00:37:46,270
Wat 'n string en gee die heelgetal verteenwoordig binnekant van die string.

628
00:37:46,270 --> 00:37:48,360
So dit is 'n maklike fout om te maak op die quiz,

629
00:37:48,360 --> 00:37:51,590
net te dink wat hierdie sal automaties die korrekte tipe.

630
00:37:51,590 --> 00:37:53,860
Maar net weet dat dit altyd sal wees snare

631
00:37:53,860 --> 00:38:00,920
selfs indien die string bevat slegs 'n heelgetal of 'n karakter of 'n float.

632
00:38:00,920 --> 00:38:03,380
So nou, laat ons praat oor die loop van tyd.

633
00:38:03,380 --> 00:38:06,700
Wanneer ons al hierdie algoritmes wat al hierdie mal dinge doen nie,

634
00:38:06,700 --> 00:38:11,580
is dit werklik nuttig om die vraag te vra: "Hoe lank neem hulle?"

635
00:38:11,580 --> 00:38:15,500
Ons verklaar dat met iets genoem asimptotiese notasie.

636
00:38:15,500 --> 00:38:18,430
So dit beteken dat - wel, laat ons sê dat ons gee ons algoritme

637
00:38:18,430 --> 00:38:20,840
regtig, regtig, werklik 'n groot inset.

638
00:38:20,840 --> 00:38:23,840
Ons wil die vraag te vra, "Hoe lank gaan dit neem?

639
00:38:23,840 --> 00:38:26,370
Hoeveel stappe sal dit neem ons algoritme uit te voer

640
00:38:26,370 --> 00:38:29,980
as 'n funksie van die grootte van die invoer? "

641
00:38:29,980 --> 00:38:33,080
Dus is die eerste manier waarop ons kan hardloop tyd beskryf is met 'n groot O.

642
00:38:33,080 --> 00:38:35,380
En dit is ons ergste-geval looptyd.

643
00:38:35,380 --> 00:38:38,590
So as ons wil hê om 'n skikking te sorteer, en ons gee ons algoritme om 'n skikking

644
00:38:38,590 --> 00:38:41,000
dit is in dalende volgorde wanneer dit moet in stygende volgorde,

645
00:38:41,000 --> 00:38:43,130
wat gaan die ergste geval.

646
00:38:43,130 --> 00:38:49,800
Dit is ons bogrens in die maksimum lengte van tyd om ons algoritme sal neem.

647
00:38:49,800 --> 00:38:54,740
Aan die ander kant, is dit Ω gaan die beste geval looptyd te beskryf.

648
00:38:54,740 --> 00:38:58,210
So as ons 'n reeds gesorteer skikking te sorteer algoritme,

649
00:38:58,210 --> 00:39:00,940
hoe lank sal dit neem om dit uit te sorteer?

650
00:39:00,940 --> 00:39:06,610
En dit, dan, beskryf 'n ondergrens op loop.

651
00:39:06,610 --> 00:39:10,980
So hier is net 'n paar woorde wat beskryf 'n paar algemene loop tye.

652
00:39:10,980 --> 00:39:13,120
Dit is in stygende orde.

653
00:39:13,120 --> 00:39:16,060
Die vinnigste hardloop tyd het ons genoem word konstant.

654
00:39:16,060 --> 00:39:19,800
>> Dit beteken dat maak nie saak hoe baie elemente wat ons gee ons algoritme,

655
00:39:19,800 --> 00:39:22,280
maak nie saak hoe groot ons verskeidenheid, sorteer dit

656
00:39:22,280 --> 00:39:26,510
of doen wat ons doen om die skikking sal altyd dieselfde bedrag van die tyd.

657
00:39:26,510 --> 00:39:30,270
Sodat ons kan verklaar dat net met 'n 1, wat 'n konstante is.

658
00:39:30,270 --> 00:39:32,410
Ons het ook gekyk na logaritmiese run tyd.

659
00:39:32,410 --> 00:39:34,800
So iets soos binêre soek is in werklikheid logaritmies,

660
00:39:34,800 --> 00:39:37,140
waar ons die probleem in die helfte van elke keer sny

661
00:39:37,140 --> 00:39:40,970
en dan dinge net hoër kry van daar af.

662
00:39:40,970 --> 00:39:43,580
En as jy ooit die skryf van 'n O van enige faktoriaal algoritme,

663
00:39:43,580 --> 00:39:47,850
jy waarskynlik moet nie beskou dit as jou dag werk.

664
00:39:47,850 --> 00:39:53,910
Wanneer ons hardloop tye is dit belangrik om in gedagte te hou hierdie dinge.

665
00:39:53,910 --> 00:39:57,760
So as ek 'n algoritme wat is O (n), en iemand anders

666
00:39:57,760 --> 00:40:03,590
het 'n algoritme O (2n) is dit eintlik asimptoties ekwivalent.

667
00:40:03,590 --> 00:40:06,590
So as ons dink 'n groot aantal soos eleventy miljard N:

668
00:40:06,590 --> 00:40:13,090
so wanneer ons vergelyk eleventy miljard tot iets soos eleventy miljard + 3,

669
00:40:13,090 --> 00:40:17,640
skielik dat 3 het nie regtig 'n groot verskil maak nie.

670
00:40:17,640 --> 00:40:20,980
Dit is hoekom ons gaan om te begin met die oorweging van hierdie dinge as gelykwaardig.

671
00:40:20,980 --> 00:40:24,220
So dinge soos hierdie konstantes hier, daar is 2 x hierdie, of die toevoeging van 'n 3,

672
00:40:24,220 --> 00:40:27,180
dit is net konstantes, en dit gaan te laat val.

673
00:40:27,180 --> 00:40:32,480
So dit is waarom alle 3 van hierdie duur tye is dieselfde as om te sê hulle is O (n).

674
00:40:32,480 --> 00:40:37,490
Net so, as ons het 2 ander duur tye, laat ons sê O (n + 2n ² ³), ons kan byvoeg

675
00:40:37,490 --> 00:40:42,070
+ N + 7, en dan het ons nog 'n kans wat net O (n ³).

676
00:40:42,070 --> 00:40:46,290
weer, dit is dieselfde ding, omdat dit - dit is nie dieselfde nie.

677
00:40:46,290 --> 00:40:49,840
Dit is dieselfde dinge nie, jammer. So dit is dieselfde, want

678
00:40:49,840 --> 00:40:53,090
hierdie n ³ gaan hierdie 2n ² te oorheers.

679
00:40:53,090 --> 00:40:59,130
>> Wat is nie dieselfde ding is as ons loop tye soos O (n ³) en O (n ²)

680
00:40:59,130 --> 00:41:02,820
omdat dit n ³ is veel groter as hierdie n ².

681
00:41:02,820 --> 00:41:05,470
So as ons eksponente, skielik begin hierdie saak,

682
00:41:05,470 --> 00:41:08,280
maar wanneer ons net doen het met faktore soos ons is hier,

683
00:41:08,280 --> 00:41:12,810
dan is dit gaan nie saak nie, want hulle is net gaan om uit te sak.

684
00:41:12,810 --> 00:41:16,760
Kom ons neem 'n blik op sommige van die algoritmes wat ons tot dusver gesien het

685
00:41:16,760 --> 00:41:19,260
en praat oor hul duur tyd.

686
00:41:19,260 --> 00:41:23,850
Die eerste manier van soek na 'n nommer in 'n lys, wat ons gesien het, was 'n lineêre soektog.

687
00:41:23,850 --> 00:41:26,950
En die implementering van lineêre soek is super eenvoudige.

688
00:41:26,950 --> 00:41:30,490
Ons het net 'n lys, en ons gaan om te kyk na elke enkele element in die lys

689
00:41:30,490 --> 00:41:34,260
totdat vind ons die getal wat ons soek.

690
00:41:34,260 --> 00:41:38,370
So dit beteken dat in die ergste geval, O (n).

691
00:41:38,370 --> 00:41:40,860
En die ergste geval hier kan wees indien die element

692
00:41:40,860 --> 00:41:45,710
die laaste element, dan met behulp van lineêre soek ons ​​het om te kyk na elke enkele element

693
00:41:45,710 --> 00:41:50,180
totdat ons by die laaste een om te weet dat dit eintlik in die lys.

694
00:41:50,180 --> 00:41:52,910
Ons kan nie net gee halfpad en sê, "Dit is waarskynlik nie daar nie."

695
00:41:52,910 --> 00:41:55,980
Met lineêre soek ons ​​het om te kyk na die hele ding.

696
00:41:55,980 --> 00:41:59,090
Die beste geval loop tyd, aan die ander kant, is konstant

697
00:41:59,090 --> 00:42:04,200
want in die beste geval die element wat ons soek, is net die eerste een in die lys.

698
00:42:04,200 --> 00:42:08,930
So dit gaan ons presies 1 stap, maak nie saak hoe groot die lys is te neem

699
00:42:08,930 --> 00:42:12,140
as ons is op soek vir die eerste element elke keer.

700
00:42:12,140 --> 00:42:15,390
>> So wanneer jy soek, onthou, is dit nie nodig dat ons lys gesorteer word.

701
00:42:15,390 --> 00:42:19,430
Omdat ons net gaan om te kyk oor elke enkele element, en dit maak nie regtig saak

702
00:42:19,430 --> 00:42:23,560
watter volgorde hierdie elemente is.

703
00:42:23,560 --> 00:42:28,110
'N meer intelligente soek algoritme is iets soos binêre soek.

704
00:42:28,110 --> 00:42:31,500
Onthou, die implementering van binêre soek is wanneer jy gaan

705
00:42:31,500 --> 00:42:34,320
hou op soek na die middel van die lys.

706
00:42:34,320 --> 00:42:38,000
En omdat ons is op soek na die middel, vereis ons dat die lys is gesorteer

707
00:42:38,000 --> 00:42:40,580
of anders weet ons nie waar die middel is, en ons het om te kyk oor

708
00:42:40,580 --> 00:42:44,480
die hele lys om dit te vind, en dan op daardie punt het ons is net tyd mors.

709
00:42:44,480 --> 00:42:48,480
So as ons 'n gesorteerde lys en ons vind die middel, ons gaan om die middel te vergelyk

710
00:42:48,480 --> 00:42:51,590
die element wat ons soek.

711
00:42:51,590 --> 00:42:54,640
As dit is te hoog is, dan kan ons vergeet om die regte helfte

712
00:42:54,640 --> 00:42:57,810
omdat ons weet dat as ons element is reeds te hoog

713
00:42:57,810 --> 00:43:01,080
en alles wat aan die regterkant van hierdie element is selfs hoër,

714
00:43:01,080 --> 00:43:02,760
dan moet ons nie om daar te kyk nie.

715
00:43:02,760 --> 00:43:05,430
Waar op die ander kant, as ons element te laag is,

716
00:43:05,430 --> 00:43:08,700
ons weet alles aan die linkerkant van daardie element is ook te laag is,

717
00:43:08,700 --> 00:43:11,390
so dit maak nie regtig sin maak om daar te kyk, óf.

718
00:43:11,390 --> 00:43:15,760
Op hierdie manier, met elke stap en elke keer as ons kyk na die middelpunt van die lys,

719
00:43:15,760 --> 00:43:19,060
ons gaan om ons probleem op te sny in die helfte, want skielik ons ​​weet

720
00:43:19,060 --> 00:43:23,040
'n hele klomp van die nommers wat nie kan die een wat ons soek.

721
00:43:23,040 --> 00:43:26,950
>> In pseudokode sou dit lyk iets soos hierdie,

722
00:43:26,950 --> 00:43:30,990
en omdat ons die lys te sny in die helfte van elke enkele tyd,

723
00:43:30,990 --> 00:43:34,920
ons ergste geval run tyd spronge van lynvormig tot logaritmiese.

724
00:43:34,920 --> 00:43:39,260
So skielik het ons log-in stappe in om 'n element in 'n lys te vind.

725
00:43:39,260 --> 00:43:42,460
Die beste geval loop die tyd, al is, is steeds konstant

726
00:43:42,460 --> 00:43:45,180
want nou, laat ons net sê dat die element wat ons is op soek na

727
00:43:45,180 --> 00:43:48,380
altyd die presiese middel van die oorspronklike lys.

728
00:43:48,380 --> 00:43:52,080
Sodat ons kan ons lys groei so groot soos ons wil, maar as die element wat ons soek is op die middel,

729
00:43:52,080 --> 00:43:54,910
dan is dit net gaan ons 1 stap te neem.

730
00:43:54,910 --> 00:44:00,920
So dit is waarom ons O (log n) en Ω (1) of konstant.

731
00:44:00,920 --> 00:44:04,510
Laat eintlik loop binêre soek op hierdie lys.

732
00:44:04,510 --> 00:44:08,020
So laat ons sê dat ons is op soek vir die element 164.

733
00:44:08,020 --> 00:44:11,650
Die eerste ding wat ons gaan doen is om die middelpunt van hierdie lys.

734
00:44:11,650 --> 00:44:15,060
Dit gebeur net so dat die middelpunt is gaan om te val in tussen dié 2 getalle,

735
00:44:15,060 --> 00:44:18,960
so laat ons net arbitrêr sê, elke keer as die middelpunt tussen 2 nommers val,

736
00:44:18,960 --> 00:44:21,150
laat ons net rond.

737
00:44:21,150 --> 00:44:24,330
Ons het net nodig het om seker te maak ons ​​doen dit elke stap van die pad.

738
00:44:24,330 --> 00:44:29,040
So ons gaan te rond, en ons gaan om te sê dat 161 is die middel van ons lys.

739
00:44:29,040 --> 00:44:34,640
So 161 <164, en elke element aan die linkerkant van 161

740
00:44:34,640 --> 00:44:39,120
is ook <164, sodat ons weet dat dit nie gaan ons almal help

741
00:44:39,120 --> 00:44:42,690
om te begin soek hier omdat die element wat ons soek kan nie daar wees nie.

742
00:44:42,690 --> 00:44:47,060
So wat ons kan doen, is ons net kan vergeet dat die hele linker helfte van die lys,

743
00:44:47,060 --> 00:44:51,700
en nou net van die reg van die 161 verder oorweeg.

744
00:44:51,700 --> 00:44:54,050
>> So weer, dit is die middelpunt, laat ons net rond.

745
00:44:54,050 --> 00:44:56,260
Nou 175 is te groot.

746
00:44:56,260 --> 00:44:59,180
So ons weet dat dit nie gaan om ons te help soek hier of hier,

747
00:44:59,180 --> 00:45:06,610
sodat ons kan net gooi dit weg, en uiteindelik sal ons druk op die 164.

748
00:45:06,610 --> 00:45:10,560
Enige vrae oor binêre soek?

749
00:45:10,560 --> 00:45:14,180
Kom ons gaan soek deur middel van 'n reeds-gesorteerde lys

750
00:45:14,180 --> 00:45:17,660
om werklik die neem van 'n lys van die nommers in enige volgorde

751
00:45:17,660 --> 00:45:20,960
en die maak van die lys in stygende orde.

752
00:45:20,960 --> 00:45:24,060
Die eerste algoritme het ons gekyk na borrel soort genoem.

753
00:45:24,060 --> 00:45:27,300
En dit sou makliker wees van die algoritmes wat ons gesien het.

754
00:45:27,300 --> 00:45:32,970
Bubble soort sê dat wanneer enige 2 elemente binne-in die lys is uit plek,

755
00:45:32,970 --> 00:45:36,500
wat beteken daar is 'n hoër getal aan die linkerkant van 'n laer getal,

756
00:45:36,500 --> 00:45:40,190
dan moet ons gaan om dit te ruil, want dit beteken dat die lys sal wees

757
00:45:40,190 --> 00:45:42,860
"Meer gesorteer" as wat dit was voor.

758
00:45:42,860 --> 00:45:45,180
En ons net gaan hierdie proses weer voortgaan en weer en weer

759
00:45:45,180 --> 00:45:52,100
totdat uiteindelik die elemente soort van borrel aan hulle regte plek en ons het 'n gesorteerde lys.

760
00:45:52,100 --> 00:45:57,230
>> Die aanloop tyd van hierdie gaan wees O (n ²). Hoekom?

761
00:45:57,230 --> 00:46:00,370
Goed, want in die ergste geval, ons gaan elke element te neem, en

762
00:46:00,370 --> 00:46:04,570
ons gaan aan die einde dit te vergelyk met elke ander element in die lys.

763
00:46:04,570 --> 00:46:08,030
Maar in die beste geval, ons het 'n reeds gesorteerde lys, borrel soort

764
00:46:08,030 --> 00:46:12,230
net gaan om te gaan deur middel van 'n keer, sê: "Nee, ek het nie enige swaps, so ek gedoen het."

765
00:46:12,230 --> 00:46:17,410
So ons het 'n beste-geval looptyd van Ω (n).

766
00:46:17,410 --> 00:46:20,680
Kom ons loop borrel soort op 'n lys.

767
00:46:20,680 --> 00:46:23,560
Of die eerste, laat ons net kyk na sommige pseudokode regtig vinnig.

768
00:46:23,560 --> 00:46:28,160
Ons wil sê ons wil dop te hou, in elke iterasie van die lus,

769
00:46:28,160 --> 00:46:32,190
hou of ons nie enige elemente verander.

770
00:46:32,190 --> 00:46:37,610
Dus is die rede hiervoor is dat, ons gaan om te stop as ons nie enige elemente verruil.

771
00:46:37,610 --> 00:46:41,980
So aan die begin van ons loop ons nie omgeruil enigiets, so ons sal sê dit is vals.

772
00:46:41,980 --> 00:46:47,170
Nou, ons gaan om te gaan deur die lys en element vergelyk i element i + 1

773
00:46:47,170 --> 00:46:50,310
en indien dit die geval is dat daar 'n groter getal aan die linkerkant van 'n kleiner getal,

774
00:46:50,310 --> 00:46:52,310
dan is ons net gaan om dit te ruil.

775
00:46:52,310 --> 00:46:54,490
>> En dan gaan ons om te onthou dat ons 'n element verruil.

776
00:46:54,490 --> 00:46:58,900
Dit beteken dat ons ten minste 1 meer tyd nodig het om te gaan deur die lys

777
00:46:58,900 --> 00:47:02,160
want die toestand waarin ons gestop is wanneer die hele lys is reeds gesorteer is,

778
00:47:02,160 --> 00:47:04,890
wat beteken dat ons nie gemaak het nie enige swaps.

779
00:47:04,890 --> 00:47:09,960
So dit is waarom ons toestand hier onder is 'terwyl sommige elemente is omgeruil. "

780
00:47:09,960 --> 00:47:13,720
So nou, laat ons net kyk na hierdie op 'n lys.

781
00:47:13,720 --> 00:47:16,640
Ek het die lys 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Bubble soort gaan al die pad aan die linkerkant om te begin, en dit gaan om te vergelyk

783
00:47:19,850 --> 00:47:24,700
die i-elemente, so 0 i + 1, wat is element 1.

784
00:47:24,700 --> 00:47:29,020
Dit gaan om te sê, goed 5> 0, maar nou 5 is aan die linkerkant,

785
00:47:29,020 --> 00:47:32,500
so ek moet die 5 en die 0 om te ruil.

786
00:47:32,500 --> 00:47:35,470
Toe ek ruil hulle, skielik kry ek hierdie ander lys.

787
00:47:35,470 --> 00:47:38,260
Nou 5> 1, dus gaan ons hulle te ruil.

788
00:47:38,260 --> 00:47:42,160
5 is nie> 6, sodat ons nie nodig om iets hier te doen.

789
00:47:42,160 --> 00:47:46,690
Maar 6> 4, sodat ons nodig het om te ruil.

790
00:47:46,690 --> 00:47:49,740
Weereens, ons nodig het om te loop deur die hele lys om uiteindelik ontdek

791
00:47:49,740 --> 00:47:52,330
dat dit buite werking is, ruil ons hulle,

792
00:47:52,330 --> 00:47:57,120
en op hierdie punt het ons nodig het om te loop deur die lys 1 meer tyd

793
00:47:57,120 --> 00:48:05,390
om seker te maak dat alles in sy einde, en op hierdie punt borrel soort klaar.

794
00:48:05,390 --> 00:48:10,720
'N ander algoritme vir die neem van 'n paar elemente en sorteer hulle is seleksie soort.

795
00:48:10,720 --> 00:48:15,740
Die idee agter die seleksie soort is dat ons gaan om te bou aan 'n gesorteer gedeelte van die lys

796
00:48:15,740 --> 00:48:18,150
1 element op 'n slag.

797
00:48:18,150 --> 00:48:23,170
>> En die manier waarop ons gaan om dit te doen is deur die opbou van die linker-segment van die lys.

798
00:48:23,170 --> 00:48:27,510
En basies, almal op elke stap, ons gaan die kleinste element te neem, ons het alles verlaat

799
00:48:27,510 --> 00:48:32,310
wat nie is nie gesorteer, en ons gaan om dit te skuif in daardie gesorteer segment.

800
00:48:32,310 --> 00:48:35,850
Dit beteken dat ons nodig het om voortdurend te vind van die minimum ongesorteerde element

801
00:48:35,850 --> 00:48:40,720
en dan neem dat die minimum element en ruil dit met alles wat

802
00:48:40,720 --> 00:48:45,090
mees linkse element wat nie gesorteer.

803
00:48:45,090 --> 00:48:50,890
Die loop van hierdie gaan wees O (n ²) want in die ergste geval

804
00:48:50,890 --> 00:48:55,070
ons nodig het om elke enkele element te vergelyk met elke ander element.

805
00:48:55,070 --> 00:48:59,250
Omdat ons sê dat as ons begin by die linker helfte van die lys, moet ons

806
00:48:59,250 --> 00:49:02,970
om te gaan deur die hele reg segment die kleinste element te vind.

807
00:49:02,970 --> 00:49:05,430
En dan, weer, het ons nodig het om te gaan oor die hele regte segment en

808
00:49:05,430 --> 00:49:08,210
hou gaan oor wat oor en oor en oor weer.

809
00:49:08,210 --> 00:49:11,350
Dit gaan n ². Ons gaan 'n nodig vir lus binnekant van 'n ander vir die lus

810
00:49:11,350 --> 00:49:13,350
wat daarop dui dat n ².

811
00:49:13,350 --> 00:49:16,530
In die beste geval gedagte, laat ons sê ons gee dit 'n reeds gesorteerde lys;

812
00:49:16,530 --> 00:49:19,270
ons eintlik doen nie enige beter as n ².

813
00:49:19,270 --> 00:49:21,730
Omdat seleksie soort het geen manier om te weet dat

814
00:49:21,730 --> 00:49:25,540
die minimum element is net die een wat ek toevallig om te kyk na.

815
00:49:25,540 --> 00:49:28,970
Dit moet nog om seker te maak dat dit eintlik die minimum.

816
00:49:28,970 --> 00:49:31,670
>> En die enigste manier om seker te maak dat dit die minimum, die gebruik van hierdie algoritme,

817
00:49:31,670 --> 00:49:34,640
is om te kyk na elke enkele element weer.

818
00:49:34,640 --> 00:49:38,420
So regtig, as jy dit as jy gee seleksie soort 'n reeds gesorteerde lys,

819
00:49:38,420 --> 00:49:42,720
dit is nie van plan om 'n beter doen as gee dit 'n lys wat nie nog gesorteer.

820
00:49:42,720 --> 00:49:46,320
By the way, as dit gebeur om die geval te wees dat daar iets is O (iets)

821
00:49:46,320 --> 00:49:50,640
en die omega van iets, kan ons net meer bondig dat dit is θ van iets sê.

822
00:49:50,640 --> 00:49:52,760
So as jy sien wat kom nêrens, dit is wat dit beteken net.

823
00:49:52,760 --> 00:49:57,580
>> As daar iets is theta van n ², dit is beide groot O (n ²) en Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
So die beste geval en die ergste geval, is dit nie 'n verskil maak,

825
00:49:59,790 --> 00:50:04,400
die algoritme gaan om dieselfde ding te doen elke keer.

826
00:50:04,400 --> 00:50:06,610
So dit is wat pseudokode vir die seleksie soort kan lyk.

827
00:50:06,610 --> 00:50:10,630
Ons is basies gaan om te sê wat ek wil om die lys te itereer

828
00:50:10,630 --> 00:50:15,180
van links na regs, en by elke iterasie van die lus, ek gaan om te beweeg

829
00:50:15,180 --> 00:50:19,780
die minimum element in hierdie gesorteer gedeelte van die lys.

830
00:50:19,780 --> 00:50:23,260
En nadat ek daar iets beweeg, ek het nooit nodig het om te kyk weer op daardie element.

831
00:50:23,260 --> 00:50:28,600
Omdat so gou as ek ruil 'n element in die linker-segment van die lys, is dit gesorteer

832
00:50:28,600 --> 00:50:32,600
want ons doen alles in stygende orde deur gebruik te maak van minimums.

833
00:50:32,600 --> 00:50:38,740
Daarom het ons gesê, okay, ons is by posisie i, en wat ons nodig het om te kyk al die elemente

834
00:50:38,740 --> 00:50:42,260
aan die regterkant van i ten einde die minimum te vind.

835
00:50:42,260 --> 00:50:46,150
Dus beteken dit dat ons wil om te kyk vanaf i + 1 aan die einde van die lys.

836
00:50:46,150 --> 00:50:51,610
En nou, as die element wat ons tans is op soek na minder is as ons minimum wat tot dusver,

837
00:50:51,610 --> 00:50:54,190
wat, onthou, ons die begin van die minimum af om net te wees

838
00:50:54,190 --> 00:50:57,020
element wat ons is tans op, Ek sal aanvaar wat is die minimum.

839
00:50:57,020 --> 00:51:00,270
As ek 'n element wat is kleiner as dié, dan ek gaan om te sê, okay,

840
00:51:00,270 --> 00:51:02,700
Wel, ek het 'n nuwe minimum.

841
00:51:02,700 --> 00:51:06,080
Ek gaan om te onthou waar dat die minimum was.

842
00:51:06,080 --> 00:51:09,560
>> So nou, nadat ek gegaan het deur daardie regte ongesorteerde segment,

843
00:51:09,560 --> 00:51:16,690
Ek kan sê ek gaan die minimum element te ruil met die element wat in posisie i.

844
00:51:16,690 --> 00:51:21,100
Dit gaan my lys te bou, my gesorteer gedeelte van die lys van links na regs,

845
00:51:21,100 --> 00:51:25,190
en ons nooit nodig het om te kyk na 'n element weer dit is in daardie gedeelte.

846
00:51:25,190 --> 00:51:27,930
Sodra ons het dit omgeruil.

847
00:51:27,930 --> 00:51:30,260
So laat loop seleksie soort op hierdie lys.

848
00:51:30,260 --> 00:51:38,220
Die blou element hier is gaan na die i te wees, en die rooi element gaan aan die minimum element.

849
00:51:38,220 --> 00:51:41,570
, Sodat ek al die pad begin aan die linkerkant van die lys, so op 5.

850
00:51:41,570 --> 00:51:44,610
Nou moet ons die minimum ongesorteerde element te vind.

851
00:51:44,610 --> 00:51:49,480
So sê ons 0 <5 so, 0 is my nuwe minimum.

852
00:51:49,480 --> 00:51:53,820
>> Maar ek kan nie daar stop nie, want selfs al het ons kan erken dat 0 is die kleinste,

853
00:51:53,820 --> 00:51:59,390
ons nodig het om te loop deur elke ander element van die lys om seker te maak.

854
00:51:59,390 --> 00:52:01,760
So 1 is groter, 6 is groter, 4 is groter.

855
00:52:01,760 --> 00:52:05,850
Dit beteken dat, ek het na te kyk na al hierdie elemente bepaal 0 is die kleinste.

856
00:52:05,850 --> 00:52:09,800
So ek gaan die 5 en die 0 om te ruil.

857
00:52:09,800 --> 00:52:15,480
Sodra ek ruil dat ek gaan 'n nuwe lys te kry, en ek weet dat ek nooit nodig het om te kyk weer op dat 0

858
00:52:15,480 --> 00:52:19,380
want as ek verruil dit, het ek gesorteer en wat ons gedoen het.

859
00:52:19,380 --> 00:52:22,730
Nou is dit net so gebeur dat die blou element weer is die 5,

860
00:52:22,730 --> 00:52:26,030
en ons moet kyk na die 1, 6 en die 4 om te bepaal dat 1

861
00:52:26,030 --> 00:52:31,520
is die kleinste minimum element, so ons sal ruil die 1 en die 5.

862
00:52:31,520 --> 00:52:36,890
Weereens, ons nodig het om na te kyk - vergelyk die 5 tot die 6 en die 4,

863
00:52:36,890 --> 00:52:39,830
en ons gaan 4 en 5 ruil, en uiteindelik, vergelyk

864
00:52:39,830 --> 00:52:45,740
dié 2 getalle en ruil hulle totdat ons kry ons gesorteerde lys.

865
00:52:45,740 --> 00:52:49,730
Enige vrae oor die seleksie soort?

866
00:52:49,730 --> 00:52:56,420
Okay. Kom ons beweeg na die laaste onderwerp hier, en dit is rekursie.

867
00:52:56,420 --> 00:52:59,810
>> Rekursie, onthou, is dit regtig meta ding waar 'n funksie

868
00:52:59,810 --> 00:53:02,740
herhaaldelik oproepe self.

869
00:53:02,740 --> 00:53:05,620
So op 'n sekere punt, terwyl ons fuction herhaaldelik roep self,

870
00:53:05,620 --> 00:53:10,100
daar moet na 'n punt waar ons ophou vra onsself te wees.

871
00:53:10,100 --> 00:53:13,670
Want as ons dit nie doen nie, dan is ons net gaan om voort te gaan om vir ewig te doen,

872
00:53:13,670 --> 00:53:16,660
en ons program is nie net gaan om te beëindig.

873
00:53:16,660 --> 00:53:19,200
Ons noem hierdie toestand die basis geval.

874
00:53:19,200 --> 00:53:22,570
En die basis geval sê, eerder as die roep van 'n funksie weer,

875
00:53:22,570 --> 00:53:25,330
Ek gaan net 'n bietjie waarde om terug te keer.

876
00:53:25,330 --> 00:53:28,080
So wanneer ons 'n waarde het teruggekeer, het ons gestop roeping onsself,

877
00:53:28,080 --> 00:53:32,550
en die res van die oproepe wat ons tot dusver gedoen kan ook terugkeer.

878
00:53:32,550 --> 00:53:36,050
Die teenoorgestelde van die basis-geval is die rekursiewe geval.

879
00:53:36,050 --> 00:53:39,050
En dit is wanneer ons wil nog 'n oproep te maak na die funksie wat ons tans is.

880
00:53:39,050 --> 00:53:44,690
En ons waarskynlik, maar nie altyd nie, wil verskillende argumente te gebruik.

881
00:53:44,690 --> 00:53:48,940
>> So as ons 'n funksie genoem f en f genoem 1 argument,

882
00:53:48,940 --> 00:53:52,010
en ons hou net roep f (1), f (1), f (1), en dit net so gebeur dat

883
00:53:52,010 --> 00:53:56,510
val die argument 1 in rekursiewe geval, ons nog nooit gaan om te stop.

884
00:53:56,510 --> 00:54:01,620
Selfs as ons het 'n basis geval, ons nodig het om seker te maak dat ons uiteindelik gaan daardie basis geval te tref.

885
00:54:01,620 --> 00:54:04,250
Ons nie net hou verblyf in hierdie rekursiewe geval.

886
00:54:04,250 --> 00:54:09,870
In die algemeen, wanneer ons noem onsself, ons waarskynlik gaan om elke keer 'n ander argument.

887
00:54:09,870 --> 00:54:12,700
Hier is 'n baie eenvoudige rekursiewe funksie.

888
00:54:12,700 --> 00:54:15,090
So dit sal bereken die faktore van 'n getal.

889
00:54:15,090 --> 00:54:17,790
Tot bo ons het ons basis geval.

890
00:54:17,790 --> 00:54:22,330
In die geval dat n ≤ 1, het ons nie gaan om te bel faktoriaal weer.

891
00:54:22,330 --> 00:54:26,490
Ons gaan om te stop, ons gaan net 'n bietjie waarde om terug te keer.

892
00:54:26,490 --> 00:54:30,170
As dit nie waar is nie, dan is ons gaan ons rekursiewe saak te tref.

893
00:54:30,170 --> 00:54:33,550
Kennisgewing hier dat ons net nie bel faktoriaal (n), want dit sou nie baie nuttig wees.

894
00:54:33,550 --> 00:54:36,810
Ons gaan faktoriaal van iets anders om te bel.

895
00:54:36,810 --> 00:54:40,850
>> En sodat jy kan sien, uiteindelik as ons verby 'n faktoriaal (5) of iets,

896
00:54:40,850 --> 00:54:45,900
ons gaan om te bel faktoriaal (4) en so aan, en uiteindelik het ons gaan hierdie basis saak te tref.

897
00:54:45,900 --> 00:54:51,730
So, dit lyk goed. Kom ons kyk wat gebeur wanneer ons werklik hierdie hardloop.

898
00:54:51,730 --> 00:54:57,840
Dit is die stapel, en laat ons sê dat die hoof gaan om hierdie funksie te roep met 'n argument (4).

899
00:54:57,840 --> 00:55:02,200
So een keer faktoriaal sien en = 4, faktoriaal self sal roep.

900
00:55:02,200 --> 00:55:05,010
Nou, skielik, het ons faktoriaal (3).

901
00:55:05,010 --> 00:55:10,780
So hierdie funksies gaan om aan te hou groei totdat ons uiteindelik ons ​​basis geval getref.

902
00:55:10,780 --> 00:55:17,830
Op hierdie punt, die terugkeer waarde van hierdie is die terugkeer (NX die terugkeer waarde van hierdie),

903
00:55:17,830 --> 00:55:21,290
die terugkeer waarde van hierdie is nx die terugkeer waarde van hierdie.

904
00:55:21,290 --> 00:55:23,290
Uiteindelik moet ons n nommer om te tref.

905
00:55:23,290 --> 00:55:26,560
Op die top hier, sê ons terugkeer 1.

906
00:55:26,560 --> 00:55:30,650
Dit beteken dat wanneer ons terugkeer dat die getal, ons kan pop van die stapel af.

907
00:55:30,650 --> 00:55:36,570
So hierdie faktoriaal (1) gedoen word.

908
00:55:36,570 --> 00:55:41,190
Wanneer 1 opgawes, faktoriaal (1) opgawes, hierdie terugkeer na 1.

909
00:55:41,190 --> 00:55:46,910
Die opbrengs waarde van hierdie, onthou, was nx die terugkeer waarde van hierdie.

910
00:55:46,910 --> 00:55:50,720
So skielik, hierdie ou weet wat ek wil om terug te keer 2.

911
00:55:50,720 --> 00:55:55,910
>> So onthou, terugkeer waarde van hierdie is net nx die terugkeer waarde hier.

912
00:55:55,910 --> 00:56:01,160
So ons kan nou sê 3 x 2, en uiteindelik, hier kan ons sê

913
00:56:01,160 --> 00:56:04,010
dit is net gaan wees 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
En sodra hierdie opbrengste, kry ons af na 'n heelgetal binnekant van die belangrikste.

915
00:56:09,570 --> 00:56:15,460
Enige vrae oor die rekursie?

916
00:56:15,460 --> 00:56:17,090
Alles reg. So daar is meer tyd vir vrae aan die einde,

917
00:56:17,090 --> 00:56:23,360
maar nou Josef gaan die oorblywende onderwerpe dek.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] Alle regte. So nou dat ons het gepraat oor recursions,

919
00:56:25,590 --> 00:56:27,840
Kom ons praat 'n bietjie oor wat saamsmelt soort is.

920
00:56:27,840 --> 00:56:31,740
Merge soort is basies 'n ander manier om 'n lys van getalle te sorteer.

921
00:56:31,740 --> 00:56:36,430
En hoe dit werk is, met merge soort het jy 'n lys, en wat ons doen is

922
00:56:36,430 --> 00:56:39,120
ons sê, laat ons verdeel dit in 2 helftes.

923
00:56:39,120 --> 00:56:42,750
Ons sal eers hardloop saamsmelt soort weer op die linker helfte,

924
00:56:42,750 --> 00:56:45,040
dan sal ons hardloop saam te smelt soort op die regter helfte,

925
00:56:45,040 --> 00:56:50,240
en dit gee ons nou 2 helftes wat gesorteer word, en nou is ons gaan die helftes aan mekaar te kombineer.

926
00:56:50,240 --> 00:56:55,010
Dit is 'n bietjie moeilik om te sien sonder 'n voorbeeld, so ons sal gaan deur die mosies en kyk wat gebeur.

927
00:56:55,010 --> 00:56:59,590
So jy begin met hierdie lys, ons verdeel dit in 2 helftes.

928
00:56:59,590 --> 00:57:02,300
Ons loop saamsmelt soort op die linker helfte.

929
00:57:02,300 --> 00:57:06,660
So dit is die linker helfte, en nou hardloop hulle weer deur hierdie lys

930
00:57:06,660 --> 00:57:09,800
wat geslaag het in merge soort kry, en dan kyk ons ​​weer,

931
00:57:09,800 --> 00:57:13,270
aan die linkerkant van hierdie lys en ons hardloop saamsmelt soort op dit.

932
00:57:13,270 --> 00:57:15,880
Nou, kry ons af na 'n lys van 2 getalle,

933
00:57:15,880 --> 00:57:19,010
en nou die linker helfte is net 1 element lank, en ons kan nie

934
00:57:19,010 --> 00:57:23,380
verdeel 'n lys is net 1 element in die helfte, sodat ons net sê, wanneer ons 50,

935
00:57:23,380 --> 00:57:26,400
wat is net 1 element, is dit reeds gesorteer.

936
00:57:26,400 --> 00:57:29,860
>> Sodra ons klaar is met dit, kan ons sien wat ons kan

937
00:57:29,860 --> 00:57:32,230
skuif op na die regter helfte van hierdie lys,

938
00:57:32,230 --> 00:57:36,480
en 3 is ook gesorteer, en so nou dat beide helftes van hierdie lys is gesorteer

939
00:57:36,480 --> 00:57:39,080
kan ons aansluit by hierdie getalle weer saam.

940
00:57:39,080 --> 00:57:45,320
So ons sien op 50 en 3; 3 is kleiner as 50, so gaan dit in die eerste en dan 50 kom.

941
00:57:45,320 --> 00:57:49,340
Nou, dit gedoen, ons gaan terug na die lys en sorteer dit reg is 1/2.

942
00:57:49,340 --> 00:57:52,440
42 is se eie nommer, so dit is reeds gesorteer.

943
00:57:52,440 --> 00:57:57,850
So nou het ons vergelyk hierdie 2 en 3 is kleiner as 42, so wat kry in die eerste,

944
00:57:57,850 --> 00:58:02,340
nou 42 kry in, en 50 kry sit.

945
00:58:02,340 --> 00:58:07,220
Nou, dit is gesorteer, ons gaan al die pad terug na die top, 1337 en 15.

946
00:58:07,220 --> 00:58:14,560
Wel, ons nou kyk na die linker helfte van hierdie lys, 1337 is op sigself so dit is gesorteer en dieselfde met 15.

947
00:58:14,560 --> 00:58:19,020
So nou het ons kombineer hierdie 2 nommers dat die oorspronklike lys, 15 <1337 te sorteer,

948
00:58:19,020 --> 00:58:23,060
so gaan dit in die eerste, dan 1337 gaan.

949
00:58:23,060 --> 00:58:26,640
En nou het ons beide helftes van die oorspronklike lys gesorteer tot bo.

950
00:58:26,640 --> 00:58:30,440
En al wat ons hoef te doen is kombineer.

951
00:58:30,440 --> 00:58:36,890
Ons kyk na die eerste 2 nommers van hierdie lys, 3 <15, so gaan dit maar eers in die soort skikking.

952
00:58:36,890 --> 00:58:44,460
15 <42, so dit gaan. Nou, 42 <1337, wat gaan.

953
00:58:44,460 --> 00:58:51,010
50 <1337, so dit gaan. En let dat ons net het 2 nommers van hierdie lys af.

954
00:58:51,010 --> 00:58:53,640
Sodat ons nie net afwisselend tussen die 2 lyste.

955
00:58:53,640 --> 00:58:56,050
Ons is net op soek aan die begin, en ons neem die element

956
00:58:56,050 --> 00:59:00,270
dit is kleiner en dan om dit in ons verskeidenheid.

957
00:59:00,270 --> 00:59:04,080
Nou het ons al die helftes saamgevoeg en wat ons gedoen het.

958
00:59:04,080 --> 00:59:07,780
>> Enige vrae oor saamsmelt soort? Ja?

959
00:59:07,780 --> 00:59:14,190
[Studente] As dit is te verdeel in verskillende groepe, hoekom doen hulle nie net verdeel dit weer

960
00:59:14,190 --> 00:59:19,970
en jy het 3 en 2 in 'n groep? [Res van die vraag onverstaanbaar]

961
00:59:19,970 --> 00:59:24,940
Die rede - so die vraag is, waarom kan ons nie net saam te smelt hulle op daardie eerste stap nadat ons hulle?

962
00:59:24,940 --> 00:59:29,530
Die rede waarom ons dit kan doen, begin by die mees linkse elemente van beide kante,

963
00:59:29,530 --> 00:59:33,040
en dan die kleiner een en sit dit in, is dat ons weet dat hierdie

964
00:59:33,040 --> 00:59:35,290
individuele lyste is in gesorteer bestellings.

965
00:59:35,290 --> 00:59:37,290
So as ek is op soek na die mees linkse elemente van beide helftes,

966
00:59:37,290 --> 00:59:40,490
Ek weet hulle gaan wees die kleinste elemente van die lyste.

967
00:59:40,490 --> 00:59:43,930
Sodat ek kan sit dit in die kleinste element plekke van hierdie groot lys.

968
00:59:43,930 --> 00:59:47,810
Aan die ander kant, as ek kyk na die 2 lyste in die tweede vlak daar,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 en 15, word diegene wat nie gesorteer.

970
00:59:51,640 --> 00:59:55,770
So as ek kyk, ek gaan op 50 en 1337 50 in my lys te sit.

971
00:59:55,770 --> 01:00:00,130
Maar dit beteken nie regtig sin maak nie, want 3 is die kleinste element uit van al diegene.

972
01:00:00,130 --> 01:00:04,390
Dus is die enigste rede waarom ons kan dit kombineer stap doen, is omdat ons lyste is reeds gesorteer.

973
01:00:04,390 --> 01:00:07,010
Wat is die rede waarom ons het al die pad om te kry af na die bodem

974
01:00:07,010 --> 01:00:09,800
want as ons het net 'n enkele getal, jy weet dat 'n aantal

975
01:00:09,800 --> 01:00:14,120
in en van die self is reeds 'n gesorteerde lys.

976
01:00:14,120 --> 01:00:19,360
>> Enige vrae? Nie?

977
01:00:19,360 --> 01:00:24,260
Complexity? Wel, kan jy sien dat daar by elke stap is einde getalle,

978
01:00:24,260 --> 01:00:27,590
en ons kan 'n lys in die helfte log n keer verdeel,

979
01:00:27,590 --> 01:00:31,700
wat is waar ons hierdie n x log n kompleksiteit.

980
01:00:31,700 --> 01:00:34,940
En jy sal sien die beste geval vir merge soort is n log n, en dit net so gebeur

981
01:00:34,940 --> 01:00:39,340
dat die ergste geval, of die Ω daar is ook 'n teken n.

982
01:00:39,340 --> 01:00:42,480
Iets om in gedagte te hou.

983
01:00:42,480 --> 01:00:45,750
Beweeg op, laat ons gaan op 'n paar super basiese lêer I / O.

984
01:00:45,750 --> 01:00:48,830
As jy kyk na Scramble, sal jy sien ons het 'n soort van die stelsel

985
01:00:48,830 --> 01:00:51,270
waar jy kan skryf aan 'n log-lêer as jy lees deur middel van die kode.

986
01:00:51,270 --> 01:00:53,730
Kom ons kyk hoe jy kan doen.

987
01:00:53,730 --> 01:00:57,450
Wel, ons het fprintf, wat jy kan dink net so printf,

988
01:00:57,450 --> 01:01:01,720
maar net die druk na 'n lêer plaas en vandaar die f aan die begin.

989
01:01:01,720 --> 01:01:07,570
Hierdie soort van die kode hier, wat dit doen is, as jy dalk gesien het in Scramble,

990
01:01:07,570 --> 01:01:12,310
dit gaan deur jou 2-dimensionele skikking druk uit ry deur ry wat die getalle is.

991
01:01:12,310 --> 01:01:17,850
In hierdie geval, druk printf uit na jou terminale of wat ons noem die standaard uitset van artikel.

992
01:01:17,850 --> 01:01:22,170
>> En nou, in hierdie geval, al wat ons hoef te doen is vervang printf met fprintf,

993
01:01:22,170 --> 01:01:26,770
vertel watter lêer wat jy wil uit te druk, en in hierdie geval is dit net hou dit uit na daardie lêer

994
01:01:26,770 --> 01:01:32,230
in plaas van druk dit uit na jou terminale.

995
01:01:32,230 --> 01:01:36,500
Wel, dan is dit lei tot die vraag: Waar kry ons hierdie soort van die lêer uit, reg?

996
01:01:36,500 --> 01:01:39,840
Ons geslaag Teken in op hierdie fprintf fuction, maar ons het geen idee waar dit vandaan kom.

997
01:01:39,840 --> 01:01:43,980
Wel, vroeg in die kode, wat ons gehad het, was hierdie stuk van die kode hier,

998
01:01:43,980 --> 01:01:48,340
wat sê basies dat open die lêer noem log.txt.

999
01:01:48,340 --> 01:01:53,220
Wat ons doen, na wat ons het om seker te maak dat die lêer is eintlik suksesvol oopgemaak.

1000
01:01:53,220 --> 01:01:57,070
Sodat dit dalk nie vir verskeie redes, jy het nie genoeg spasie op jou rekenaar, byvoorbeeld.

1001
01:01:57,070 --> 01:01:59,790
So dit is altyd belangrik om voordat jy enige bewerkings met die lêer

1002
01:01:59,790 --> 01:02:03,300
dat ons kontroleer of dat die lêer is suksesvol oopgemaak.

1003
01:02:03,300 --> 01:02:09,330
So, wat dat 'n, dit is 'n argument te fopen, goed, kan ons 'n lêer oopmaak in baie maniere.

1004
01:02:09,330 --> 01:02:13,510
Wat is ons kan doen, kan ons dit slaag w, wat beteken ignoreer die lêer as dit uitgaan reeds,

1005
01:02:13,510 --> 01:02:18,070
Ons kan 'n 'n slaag, wat hulle voeg aan die einde van die lêer in plaas van groot,

1006
01:02:18,070 --> 01:02:22,730
of ons kan spesifiseer r, wat beteken, laat ons die lêer as lees-alleen oop.

1007
01:02:22,730 --> 01:02:24,890
Dus, as die program probeer om enige veranderinge aan te bring na die lêer,

1008
01:02:24,890 --> 01:02:30,140
skreeu hulle en moenie toelaat dat hulle dit doen.

1009
01:02:30,140 --> 01:02:33,320
Ten slotte, wanneer ons klaar is met die lêer gedoen doen bedrywighede op dit,

1010
01:02:33,320 --> 01:02:35,860
ons nodig het om seker te maak ons ​​maak die lêer.

1011
01:02:35,860 --> 01:02:38,830
En so aan die einde van jou program, jy gaan hulle weer slaag

1012
01:02:38,830 --> 01:02:42,120
hierdie lêer wat jy oopgemaak het, en sluit dit net.

1013
01:02:42,120 --> 01:02:44,650
Sodat dit is iets belangrik wat jy het om seker te maak jy doen.

1014
01:02:44,650 --> 01:02:47,180
Onthou So kan jy 'n lêer oop te maak, dan kan jy skryf na die lêer,

1015
01:02:47,180 --> 01:02:51,270
bedrywighede in die lêer doen, maar dan moet jy die lêer te sluit aan die einde.

1016
01:02:51,270 --> 01:02:53,270
>> Enige vrae oor die basiese lêer I / O? Ja?

1017
01:02:53,270 --> 01:02:58,050
[Student vraag, onverstaanbaar]

1018
01:02:58,050 --> 01:03:02,480
Reg hier. Die vraag is, waar hierdie log.txt lêer verskyn?

1019
01:03:02,480 --> 01:03:07,890
Wel, as jy net gee dit log.txt, dit skep dit in dieselfde gids as die uitvoer.

1020
01:03:07,890 --> 01:03:10,500
So as jy's - >> [Student vraag, onverstaanbaar]

1021
01:03:10,500 --> 01:03:18,830
Ja. In dieselfde lêergids, of in dieselfde gids, soos jy dit noem.

1022
01:03:18,830 --> 01:03:21,400
Nou geheue, stapel, en hoop.

1023
01:03:21,400 --> 01:03:23,400
So hoe is geheue uitgelê in die rekenaar?

1024
01:03:23,400 --> 01:03:26,270
Wel, kan jy jou indink geheue as 'n soort van die blok hier.

1025
01:03:26,270 --> 01:03:30,260
En ons het in die geheue wat die hoop vas daar, en die stapel wat daar genoem word.

1026
01:03:30,260 --> 01:03:34,480
En die hoop groei afwaarts en die stapel groei opwaarts.

1027
01:03:34,480 --> 01:03:38,620
So as Tommy genoem - O, goed, en ons het die ander 4 segmente wat ek sal kry om in 'n tweede -

1028
01:03:38,620 --> 01:03:42,890
Soos Tommy vroeër gesê het, jy weet hoe om sy werksaamhede noem hulself en noem mekaar?

1029
01:03:42,890 --> 01:03:44,930
Hulle bou hierdie soort van stapel.

1030
01:03:44,930 --> 01:03:47,360
Wel, as hoof oproepe cat, cat kry op die stapel geplaas.

1031
01:03:47,360 --> 01:03:52,430
Foo noem bar, bar kry ons sit op die stapel, en wat kry op die stapel geplaas nadat.

1032
01:03:52,430 --> 01:03:57,040
En as hulle terugkeer, het hulle elke geneem kry die stapel af.

1033
01:03:57,040 --> 01:04:00,140
Wat hou elkeen van hierdie plekke en geheue?

1034
01:04:00,140 --> 01:04:03,110
Wel, die top, wat is die teks segment, bevat die program self.

1035
01:04:03,110 --> 01:04:06,390
Sodat die masjien kode, wat is daar, wanneer jy jou program saamstel.

1036
01:04:06,390 --> 01:04:08,520
Volgende, 'n globale veranderlikes geïnisialiseer.

1037
01:04:08,520 --> 01:04:12,660
>> So jy het globale veranderlikes in jou program, en jy sê soos, a = 5,

1038
01:04:12,660 --> 01:04:15,260
wat kry in daardie segment, en reg onder,

1039
01:04:15,260 --> 01:04:18,990
u enige geïnitialiseerd globale data, wat net 'n int,

1040
01:04:18,990 --> 01:04:20,990
maar jy sê nie dit is gelyk aan enigiets nie.

1041
01:04:20,990 --> 01:04:23,870
Besef dat hierdie globale veranderlikes, sodat hulle is buite van die belangrikste.

1042
01:04:23,870 --> 01:04:28,560
Dus beteken dit 'n globale veranderlikes wat verklaar word, maar is nie geïnisialiseer nie.

1043
01:04:28,560 --> 01:04:32,310
So, wat is in die hoop? Geheue geallokeer deur malloc, wat ons sal kry in 'n bietjie.

1044
01:04:32,310 --> 01:04:35,990
En uiteindelik, met die stapel moet jy 'n plaaslike veranderlikes

1045
01:04:35,990 --> 01:04:39,950
en enige funksies wat jy kan noem in enige van hul parameters.

1046
01:04:39,950 --> 01:04:43,720
Die laaste ding wat jy nie regtig het om te weet wat die omgewing veranderlikes doen,

1047
01:04:43,720 --> 01:04:46,700
maar wanneer jy hardloop program, daar is iets wat verband hou, soos

1048
01:04:46,700 --> 01:04:49,550
dit is die gebruikersnaam van die persoon wat die program hardloop.

1049
01:04:49,550 --> 01:04:51,550
En wat gaan soort van aan die onderkant.

1050
01:04:51,550 --> 01:04:54,540
In terme van die geheue adresse, wat is hexadecimale waardes,

1051
01:04:54,540 --> 01:04:58,170
die waardes op die top begin by 0, en hulle gaan al die pad af na die bodem.

1052
01:04:58,170 --> 01:05:00,440
In hierdie geval, as jy op die 32-bis-stelsel,

1053
01:05:00,440 --> 01:05:05,390
die adres op die bodem gaan wees 0x, gevolg deur af, want dit is 32 stukkies,

1054
01:05:05,390 --> 01:05:10,890
wat is 8 grepe, en in hierdie geval 8 bytes ooreenstem met 8 hexadecimalen.

1055
01:05:10,890 --> 01:05:20,110
So af hier jy gaan hê, wil, 0xffffff, en daar het jy gaan om 0 te hê.

1056
01:05:20,110 --> 01:05:23,660
So, wat is verwysings? Sommige van julle mag nie gedek het hierdie artikel voor.

1057
01:05:23,660 --> 01:05:26,660
maar ons het gaan oor dit in die lesing, so 'n wyser is net 'n datatipe

1058
01:05:26,660 --> 01:05:34,030
watter winkels, in plaas van 'n soort van waarde soos 50, is dit die adres van n plek in die geheue stoor.

1059
01:05:34,030 --> 01:05:36,020
Soos dat "memory" [onverstaanbaar].

1060
01:05:36,020 --> 01:05:41,120
Dus, in hierdie geval, wat ons is, ons het 'n wyser na 'n heelgetal of 'n int *,

1061
01:05:41,120 --> 01:05:46,210
en dit bevat hierdie heksadesimale adres van 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> So, wat ons het is nou, wyser punte op 'n sekere plek in die geheue,

1063
01:05:50,880 --> 01:05:56,020
en dat net 'n, die waarde 50 is op hierdie geheue plek.

1064
01:05:56,020 --> 01:06:01,810
Op sommige 32-bits stelsels, op alle 32-bis-stelsels, wysers neem 32 stukkies of 4 grepe.

1065
01:06:01,810 --> 01:06:06,020
Maar, byvoorbeeld, op 'n 64-bis-stelsel, wysers is 64 bisse.

1066
01:06:06,020 --> 01:06:08,040
So dit is iets wat jy sal wil hê om in gedagte te hou.

1067
01:06:08,040 --> 01:06:12,310
So op 'n end-bis-stelsel, 'n wyser is einde stukkies lank.

1068
01:06:12,310 --> 01:06:17,320
Pointers is soort van moeilik om te verteer sonder ekstra dinge,

1069
01:06:17,320 --> 01:06:20,300
so laat ons gaan deur middel van 'n voorbeeld van dinamiese geheuetoekenning.

1070
01:06:20,300 --> 01:06:25,130
Wat dinamiese geheuetoekenning vir jou doen, of wat ons noem malloc,

1071
01:06:25,130 --> 01:06:29,280
dit kan jy 'n soort van data buite die stel ken.

1072
01:06:29,280 --> 01:06:31,830
So hierdie data is 'n soort van meer permanente werk vir die duur van die program.

1073
01:06:31,830 --> 01:06:36,430
Want soos jy weet, as jy verklaar x binnekant van 'n funksie, en dat die funksie opbrengste,

1074
01:06:36,430 --> 01:06:40,910
hoef jy nie meer toegang tot die data wat wat in x gestoor is.

1075
01:06:40,910 --> 01:06:44,420
Wat pointers laat ons doen, is hulle laat ons geheue of winkel waardes stoor

1076
01:06:44,420 --> 01:06:46,840
in 'n ander segment van die geheue, naamlik die hoop.

1077
01:06:46,840 --> 01:06:49,340
Nou wanneer ons terugkom van die funksie, so lank as wat ons 'n wyser

1078
01:06:49,340 --> 01:06:54,960
na die plek in die geheue, dan is wat ons kan doen is kan ons net kyk na die waardes daar.

1079
01:06:54,960 --> 01:06:58,020
Kom ons kyk na 'n voorbeeld: Dit is ons geheue uitleg weer.

1080
01:06:58,020 --> 01:07:00,050
En ons het hierdie funksie, hoof.

1081
01:07:00,050 --> 01:07:06,870
Wat beteken dit is okay, so eenvoudig, reg? Int x = 5, dit is net 'n veranderlike op die stapel in die hoof.

1082
01:07:06,870 --> 01:07:12,450
>> Aan die ander kant, nou het ons 'n wyser wat noem die funksie giveMeThreeInts verklaar.

1083
01:07:12,450 --> 01:07:16,800
En so nou gaan ons in hierdie funksie en skep ons 'n nuwe stapel raam vir dit.

1084
01:07:16,800 --> 01:07:20,440
Maar, in hierdie stapel raam, verklaar ons int * temp,

1085
01:07:20,440 --> 01:07:23,210
wat in mallocs 3 heelgetalle vir ons.

1086
01:07:23,210 --> 01:07:25,880
So grootte van int sal ons hoeveel bytes hierdie int is,

1087
01:07:25,880 --> 01:07:29,620
en malloc gee ons dat baie grepe van die ruimte op die hoop.

1088
01:07:29,620 --> 01:07:32,890
Dus, in hierdie geval, het ons genoeg ruimte vir 3 heelgetalle,

1089
01:07:32,890 --> 01:07:36,830
en die hoop is daar, wat is die rede waarom ek geteken het dit hoër op.

1090
01:07:36,830 --> 01:07:42,900
Sodra ons gedoen het, is ons terug kom hier, jy hoef net 3 ints teruggekeer,

1091
01:07:42,900 --> 01:07:47,000
en dit gee die adres, in hierdie geval oor waar daardie geheue is.

1092
01:07:47,000 --> 01:07:51,250
En ons het pointer = skakelaar, en daar het ons net nog wyser.

1093
01:07:51,250 --> 01:07:54,550
Maar wat daardie funksie opbrengste is hier gestapel en verdwyn.

1094
01:07:54,550 --> 01:07:59,250
So temp verdwyn, maar ons het nog steeds die adres van waar

1095
01:07:59,250 --> 01:08:01,850
daardie 3 heelgetalle is binnekant van die hoofleiding.

1096
01:08:01,850 --> 01:08:06,180
So in hierdie reeks, die wysers scoped plaaslik vir die gestapel raam,

1097
01:08:06,180 --> 01:08:09,860
maar die geheue waarop dit betrekking het, is in die hoop.

1098
01:08:09,860 --> 01:08:12,190
>> Maak dit sin?

1099
01:08:12,190 --> 01:08:14,960
[Studente] Kan jy dit herhaal? >> [Joseph] Ja.

1100
01:08:14,960 --> 01:08:20,270
So as ek net 'n bietjie terug gaan, sien jy dat temp toegeken

1101
01:08:20,270 --> 01:08:23,500
n geheue op die hoop daar.

1102
01:08:23,500 --> 01:08:28,680
So wanneer hierdie funksie, giveMeThreeInts opbrengste, hierdie stapel hier gaan om te verdwyn.

1103
01:08:28,680 --> 01:08:35,819
En met dit enige van die veranderlikes, in hierdie geval, is dit wyser wat in gestapel raam toegeken is.

1104
01:08:35,819 --> 01:08:39,649
Wat gaan verdwyn nie, maar omdat ons teruggekeer temp

1105
01:08:39,649 --> 01:08:46,330
en ons wyser = temp, pointer nou gaan dieselfde geheue van die plek as die temp was om te wys.

1106
01:08:46,330 --> 01:08:50,370
So nou, selfs al het ons verloor temp, dat die plaaslike pointer,

1107
01:08:50,370 --> 01:08:59,109
ons nog steeds die geheue adres van die wat dit wys na die binnekant van daardie veranderlike wyser.

1108
01:08:59,109 --> 01:09:03,740
Vrae? Dit soort van 'n verwarrende onderwerp kan wees as julle nie gegaan het oor dit in artikel.

1109
01:09:03,740 --> 01:09:09,240
Ons kan jou TF, sal beslis gaan oor dit en natuurlik het ons vrae kan beantwoord

1110
01:09:09,240 --> 01:09:11,500
aan die einde van die hersiening sessie vir hierdie.

1111
01:09:11,500 --> 01:09:14,220
Maar dit is 'n soort van 'n komplekse onderwerp, en ek het meer voorbeelde wat gaan om te wys

1112
01:09:14,220 --> 01:09:18,790
wat jou sal help om te verduidelik wat pointers eintlik.

1113
01:09:18,790 --> 01:09:22,500
>> In hierdie geval, wysers is gelykstaande aan skikkings,

1114
01:09:22,500 --> 01:09:25,229
so ek kan net gebruik om die wyser as die dieselfde ding as 'n int skikking.

1115
01:09:25,229 --> 01:09:29,840
So ek kruip in 0, en die verandering van die eerste heelgetal 1,

1116
01:09:29,840 --> 01:09:39,689
die verandering van die tweede heelgetal 2, en die 3de heelgetal tot 3.

1117
01:09:39,689 --> 01:09:44,210
Sodat meer wenke. Wel, Binky onthou.

1118
01:09:44,210 --> 01:09:48,319
In hierdie geval het ons 'n wyser toegeken, of ons 'n wyser verklaar,

1119
01:09:48,319 --> 01:09:52,760
maar aanvanklik, toe ek net 'n wyser verklaar, is dit nie verwys na enige plek in die geheue.

1120
01:09:52,760 --> 01:09:54,930
Dis net vullis waardes binnekant van dit.

1121
01:09:54,930 --> 01:09:56,470
So ek het geen idee waar die wyser wys.

1122
01:09:56,470 --> 01:10:01,630
Dit het 'n adres wat net gevul met 0 en 1 se waar dit aanvanklik verklaar.

1123
01:10:01,630 --> 01:10:04,810
Ek kan niks doen met hierdie totdat ek noem malloc op dit

1124
01:10:04,810 --> 01:10:08,390
en dan gee dit vir my 'n bietjie ruimte op die hoop waar ek kan sit waardes binne.

1125
01:10:08,390 --> 01:10:11,980
Dan weer, ek weet nie wat is binnekant van die geheue.

1126
01:10:11,980 --> 01:10:16,780
Dus is die eerste ding wat ek hoef te doen, is kontroleer of die stelsel het genoeg geheue

1127
01:10:16,780 --> 01:10:20,850
gee my terug 1 heelgetal in die eerste plek, wat is die rede waarom ek om dit te doen gaan.

1128
01:10:20,850 --> 01:10:25,020
As wyser is van nul, wat beteken dat dit nie genoeg spasie of 'n ander fout het voorgekom,

1129
01:10:25,020 --> 01:10:26,320
so ek moet uitgang uit my program.

1130
01:10:26,320 --> 01:10:29,400
 Maar as dit onsuksesvol was, nou kan ek gebruik dat wyser

1131
01:10:29,400 --> 01:10:35,020
en wat * pointer doen is dit volg waar die adres is

1132
01:10:35,020 --> 01:10:38,480
waar daardie waarde is, en dit stel dit gelyk aan 1.

1133
01:10:38,480 --> 01:10:41,850
So hier is ons nagaan indien daardie geheue bestaan.

1134
01:10:41,850 --> 01:10:45,380
>> Sodra jy weet dit bestaan, kan jy sit in dit

1135
01:10:45,380 --> 01:10:50,460
watter waarde wat jy wil om dit te sit in, in hierdie geval 1.

1136
01:10:50,460 --> 01:10:53,060
Sodra ons klaar is met dit wat jy nodig het dat pointer te bevry

1137
01:10:53,060 --> 01:10:57,160
want ons moet terug te kry om die stelsel wat die geheue wat jy in die eerste plek gevra vir.

1138
01:10:57,160 --> 01:10:59,690
Omdat die rekenaar weet nie wanneer ons klaar is met dit.

1139
01:10:59,690 --> 01:11:02,510
In hierdie geval het ons dit uitdruklik sê, okay, ons is gedoen met daardie geheue.

1140
01:11:02,510 --> 01:11:10,780
Indien 'n ander proses moet dit 'n ander program dit nodig het, voel vry om voort te gaan en neem dit.

1141
01:11:10,780 --> 01:11:15,110
Wat kan ons ook doen, ons kan net die adres van die plaaslike veranderlikes op die stel.

1142
01:11:15,110 --> 01:11:19,080
So int x is die binnekant van die gestapel raam van die belangrikste.

1143
01:11:19,080 --> 01:11:23,060
En wanneer ons hierdie ampersand, en operateur, wat dit doen, is

1144
01:11:23,060 --> 01:11:27,310
dit neem x en x is net 'n paar data in die geheue, maar dit het 'n adres.

1145
01:11:27,310 --> 01:11:33,790
Dit is iewers geleë is. So deur te bel & x, wat dit doen, is dit gee ons die adres van x.

1146
01:11:33,790 --> 01:11:38,430
Deur dit te doen, is ons wyser punt waar x is in die geheue.

1147
01:11:38,430 --> 01:11:41,710
Nou het ons net nie iets soos * x, ons gaan 5 terug te kry.

1148
01:11:41,710 --> 01:11:43,820
Die ster word genoem ontwysing dit.

1149
01:11:43,820 --> 01:11:46,640
Jy volg die adres en jy kry die waarde van dit wat daar gestoor word.

1150
01:11:51,000 --> 01:11:53,310
>> Enige vrae? Ja?

1151
01:11:53,310 --> 01:11:56,500
[Studente] As jy nie die 3-puntige ding doen, dit maak nog steeds stel?

1152
01:11:56,500 --> 01:11:59,490
Ja. As jy nie die 3-pointer ding doen, dit is nog steeds gaan om te stel,

1153
01:11:59,490 --> 01:12:02,720
maar Ek sal julle wys wat gebeur in 'n tweede, en sonder om dit te doen,

1154
01:12:02,720 --> 01:12:04,860
Dit is wat ons noem 'n geheugenlek. Jy nie die stelsel

1155
01:12:04,860 --> 01:12:07,850
terug sy geheue, so na 'n ruk die program gaan ophoop

1156
01:12:07,850 --> 01:12:10,940
geheue wat dit nie gebruik, en niks anders kan dit gebruik.

1157
01:12:10,940 --> 01:12:15,750
As jy al ooit gesien Firefox met 1,5 miljoen kilogrepe op jou rekenaar,

1158
01:12:15,750 --> 01:12:17,840
in die 'task manager, dit is wat gaan aan.

1159
01:12:17,840 --> 01:12:20,760
Jy het 'n geheugenlek in die program dat hulle nie die hantering van.

1160
01:12:23,080 --> 01:12:26,240
So hoe wyser rekenkundige werk?

1161
01:12:26,240 --> 01:12:29,480
Wel, pointer rekenkunde is soort van soos kruip in 'n skikking.

1162
01:12:29,480 --> 01:12:36,370
In hierdie geval, ek het 'n wyser, en wat ek doen is ek maak wyser punt na die eerste element

1163
01:12:36,370 --> 01:12:42,100
van hierdie verskeidenheid van 3 heelgetalle wat ek toegeken.

1164
01:12:42,100 --> 01:12:46,670
So nou wat ek doen, ster wyser verander net die eerste element in die lys.

1165
01:12:46,670 --> 01:12:49,140
Star pointer 1 punte hier.

1166
01:12:49,140 --> 01:12:53,140
So wyser is hier, pointer 1 is hier, pointer 2 is hier.

1167
01:12:53,140 --> 01:12:56,610
>> So voeg net 1 is dieselfde ding as die beweeg langs hierdie skikking.

1168
01:12:56,610 --> 01:12:59,880
Wat ons doen is, wanneer ons wyser 1 doen jy kry die adres hier,

1169
01:12:59,880 --> 01:13:04,180
en ten einde die waarde in hier te kry, moet jy 'n ster van die hele uitdrukking

1170
01:13:04,180 --> 01:13:05,990
om dit te dereference.

1171
01:13:05,990 --> 01:13:09,940
Dus, in hierdie geval, ek die opstel van die eerste plek in die skikking 1,

1172
01:13:09,940 --> 01:13:13,970
tweede plek 2 en derde plek tot 3.

1173
01:13:13,970 --> 01:13:18,180
Dan wat ek doen hier, is ek ons ​​wyser 1 is druk,

1174
01:13:18,180 --> 01:13:19,970
wat gee my net 2.

1175
01:13:19,970 --> 01:13:23,650
Nou is ek verhoog van pointer, so wyser gelyk aan pointer 1,

1176
01:13:23,650 --> 01:13:26,780
wat beweeg dit vorentoe.

1177
01:13:26,780 --> 01:13:30,810
En so nou as ek druk pointer 1, pointer 1 is nou 3,

1178
01:13:30,810 --> 01:13:33,990
wat in hierdie geval druk uit 3.

1179
01:13:33,990 --> 01:13:36,560
En om te vry iets, die wyser dat ek dit gee

1180
01:13:36,560 --> 01:13:40,540
moet dui op die begin van die skikking wat ek terug gekom van malloc.

1181
01:13:40,540 --> 01:13:43,430
So, in hierdie geval, as ek was 3 hier noem, sou dit nie reg wees,

1182
01:13:43,430 --> 01:13:45,070
want dit is in die middel van die skikking.

1183
01:13:45,070 --> 01:13:48,820
Ek het af te trek om te kry na die oorspronklike plek

1184
01:13:48,820 --> 01:13:50,420
die aanvanklike eerste plek voor ek dit kan bevry.

1185
01:13:56,300 --> 01:13:58,450
So, hier is 'n meer betrokke voorbeeld.

1186
01:13:58,450 --> 01:14:03,360
In hierdie geval, is ons die toekenning van 7 karakters in 'n karakter skikking.

1187
01:14:03,360 --> 01:14:06,480
>> En in hierdie geval wat ons doen is ons herhaling oor die eerste 6 van hulle,

1188
01:14:06,480 --> 01:14:09,900
en ons hulle tot Z.

1189
01:14:09,900 --> 01:14:13,350
So, int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
So, pointer + ek sal net gee ons, in hierdie geval,

1191
01:14:16,220 --> 01:14:20,860
pointer pointer 1, pointer 2 3 pointer, en so aan en so voort in die lus.

1192
01:14:20,860 --> 01:14:24,040
Hoe dit gaan om te doen, is dit kry die adres, dereferences dit die waarde te kry,

1193
01:14:24,040 --> 01:14:27,440
en veranderings wat waarde tot 'n Z.

1194
01:14:27,440 --> 01:14:30,350
Dan aan die einde onthou dit is 'n string, reg?

1195
01:14:30,350 --> 01:14:33,560
Alle stringe om te eindig met die null beëindiging van karakter.

1196
01:14:33,560 --> 01:14:38,620
So, wat ek doen is in pointer 6 Ek het die null-terminator karakter.

1197
01:14:38,620 --> 01:14:43,980
En nou wat ek basies is besig hier printf implementering vir 'n string, reg?

1198
01:14:43,980 --> 01:14:46,190
>> So, printf toe nou dat dit die einde van 'n string bereik?

1199
01:14:46,190 --> 01:14:48,230
Wanneer dit treffers die null beëindiging karakter.

1200
01:14:48,230 --> 01:14:52,030
So, in hierdie geval, my oorspronklike wyser punte aan die begin van hierdie verskeidenheid.

1201
01:14:52,030 --> 01:14:56,410
Druk ek die eerste karakter uit. Ek beweeg dit oor een.

1202
01:14:56,410 --> 01:14:58,420
Ek druk die karakter uit. Ek skuif dit oor.

1203
01:14:58,420 --> 01:15:02,180
En ek hou om dit te doen totdat ek die einde bereik.

1204
01:15:02,180 --> 01:15:07,750
En nou sal die einde * wyser dereference en terug kry die null beëindiging van karakter.

1205
01:15:07,750 --> 01:15:11,780
En so het my while lus loop slegs wanneer daardie waarde is nie die null beëindiging van karakter.

1206
01:15:11,780 --> 01:15:13,770
So, nou het ek uitgang uit van die lus.

1207
01:15:18,780 --> 01:15:21,180
En so, as ek aftrek 6 van hierdie pointer,

1208
01:15:21,180 --> 01:15:22,860
Ek gaan al die pad na die begin terug.

1209
01:15:22,860 --> 01:15:27,880
Onthou, ek is om dit te doen, want ek het om te gaan na die begin om dit te bevry.

1210
01:15:27,880 --> 01:15:30,270
>> So, ek weet dit was 'n baie. Is daar enige vrae?

1211
01:15:30,270 --> 01:15:31,870
Asseblief, ja?

1212
01:15:31,870 --> 01:15:36,610
[Student vraag onverstaanbaar]

1213
01:15:36,610 --> 01:15:38,190
Kan jy sê dat harder? Jammer.

1214
01:15:38,190 --> 01:15:44,140
[Studente] Op die laaste slide reg voordat jy die wyser bevry,

1215
01:15:44,140 --> 01:15:47,300
waar jy was eintlik die verandering van die waarde van die wyser?

1216
01:15:47,300 --> 01:15:50,370
[Joseph] So, net hier. >> [Studente] O, okay.

1217
01:15:50,370 --> 01:15:51,890
[Josef] Dus, het ek 'n wyser minus minus, reg,

1218
01:15:51,890 --> 01:15:54,140
wat die ding terug een beweeg, en dan sal ek vry om dit,

1219
01:15:54,140 --> 01:15:57,000
omdat hierdie wyser gewys moet word aan die begin van die skikking.

1220
01:15:57,000 --> 01:16:00,420
[Studente] Maar dit sal nie nodig wees het jy gestop na daardie lyn.

1221
01:16:00,420 --> 01:16:03,130
[Joseph] Dus, as ek opgehou het na hierdie, sou dit oorweeg word om 'n geheugenlek,

1222
01:16:03,130 --> 01:16:04,810
want ek het nie die vrye loop.

1223
01:16:04,810 --> 01:16:11,290
[Studente] I [onverstaanbaar] na die eerste drie reëls waar jy moes pointer 1 [onverstaanbaar].

1224
01:16:11,290 --> 01:16:13,140
[Josef] Uh-huh. So, wat is die vraag daar?

1225
01:16:13,140 --> 01:16:14,780
Jammer. Nee, nee. Gaan, gaan, asseblief.

1226
01:16:14,780 --> 01:16:16,870
[Studente] So, is jy nie die verandering van die waarde van wysers.

1227
01:16:16,870 --> 01:16:19,130
Jy nie sou gehad het nie pointer minus minus te doen.

1228
01:16:19,130 --> 01:16:19,730
[Joseph] Ja, presies.

1229
01:16:19,730 --> 01:16:21,890
So, wanneer ek dit doen pointer 1 en 2 pointer,

1230
01:16:21,890 --> 01:16:24,410
Ek doen wyser gelyk aan pointer 1.

1231
01:16:24,410 --> 01:16:27,260
So, die wyser is net bly dui op die begin van die skikking.

1232
01:16:27,260 --> 01:16:31,460
Dit is eers wanneer ek doen plus plus dat dit stel die waarde terug binne-in die wyser,

1233
01:16:31,460 --> 01:16:33,550
dat dit beweeg eintlik dit saam.

1234
01:16:36,860 --> 01:16:37,780
Alles reg.

1235
01:16:40,550 --> 01:16:42,030
Nog vrae?

1236
01:16:44,680 --> 01:16:47,790
>> Weereens, as dit is 'n soort van die oorweldigende, sal hierdie gedek word in die sessie.

1237
01:16:47,790 --> 01:16:50,710
Vra jou onderrig mede oor dit, en ons vrae kan beantwoord aan die einde.

1238
01:16:53,510 --> 01:16:56,600
En gewoonlik ons ​​nie hou nie hierdie minus ding om te doen.

1239
01:16:56,600 --> 01:16:59,760
Dit het my voor om te vereis dat die dop van hoe baie ek het in die skikking geneutraliseer.

1240
01:16:59,760 --> 01:17:04,520
So, in die algemeen, is dit net om hoe wyser rekenkundige werk te verduidelik.

1241
01:17:04,520 --> 01:17:07,970
Maar wat ons gewoonlik nie hou om dit te doen, is ons graag 'n afskrif van die wyser te skep,

1242
01:17:07,970 --> 01:17:11,640
en dan sal ons daardie afskrif gebruik wanneer ons rond te beweeg in die tou.

1243
01:17:11,640 --> 01:17:14,660
So, in hierdie geval gebruik jy die kopie die hele string te druk,

1244
01:17:14,660 --> 01:17:19,040
maar ons het nie te doen soos wyser minus 6 of hou van hoeveel het ons verhuis in hierdie,

1245
01:17:19,040 --> 01:17:22,700
net omdat ons weet dat ons oorspronklike punt is nog steeds wys na die begin van die lys

1246
01:17:22,700 --> 01:17:25,340
en alles wat ons verander het, was hierdie kopie.

1247
01:17:25,340 --> 01:17:28,250
So, in die algemeen, te verander afskrifte van jou oorspronklike wyser.

1248
01:17:28,250 --> 01:17:32,350
Moenie probeer om soort van soos - moenie verander oorspronklike kopieë.

1249
01:17:32,350 --> 01:17:35,290
Probeer net afskrifte van jou oorspronklike te verander.

1250
01:17:41,540 --> 01:17:44,870
So, jy sien wanneer ons slaag die tou in printf

1251
01:17:44,870 --> 01:17:48,990
jy hoef nie 'n ster te sit in die voorkant van dit, soos ons gedoen het met al die ander dereferences, reg?

1252
01:17:48,990 --> 01:17:54,180
Dus, as jy druk die hele string% s verwag is 'n adres,

1253
01:17:54,180 --> 01:17:57,610
en in hierdie geval 'n wyser of in hierdie geval soos 'n verskeidenheid van die karakters.

1254
01:17:57,610 --> 01:18:00,330
>> Karakters, char * s, en skikkings is dieselfde ding.

1255
01:18:00,330 --> 01:18:03,690
Pointer is om karakters, en karakter skikkings is dieselfde ding.

1256
01:18:03,690 --> 01:18:05,720
En so, is al wat ons het om te doen slaag in die wyser.

1257
01:18:05,720 --> 01:18:08,150
Ons hoef nie te slaag soos * wyser of iets soos dit.

1258
01:18:13,110 --> 01:18:14,930
So, skikkings en wysers is dieselfde ding.

1259
01:18:14,930 --> 01:18:19,160
Wanneer jy iets doen soos x [y] hier vir 'n skikking,

1260
01:18:19,160 --> 01:18:21,960
wat dit doen onder die enjinkap is dit sê, goed, dit is 'n karakter skikking,

1261
01:18:21,960 --> 01:18:23,690
dit is so 'n wyser.

1262
01:18:23,690 --> 01:18:26,510
En so x is dieselfde ding,

1263
01:18:26,510 --> 01:18:28,650
en so wat dit doen nie, is dit voeg y x,

1264
01:18:28,650 --> 01:18:31,820
wat is die dieselfde ding as om vorentoe te beweeg in die geheue dat daar nog baie.

1265
01:18:31,820 --> 01:18:34,930
En nou x + y gee ons 'n soort van adres,

1266
01:18:34,930 --> 01:18:37,570
en ons dereference die adres of volg die pyl

1267
01:18:37,570 --> 01:18:41,640
na die plek waar daardie plek in die geheue is en ons kry die waarde van daardie plek in die geheue.

1268
01:18:41,640 --> 01:18:43,720
So, so die twee is presies dieselfde ding.

1269
01:18:43,720 --> 01:18:45,840
Dit is net 'n sintaktiese suiker.

1270
01:18:45,840 --> 01:18:48,090
Hulle doen dieselfde ding. Hulle is net verskillende syntactics vir mekaar.

1271
01:18:51,500 --> 01:18:57,590
>> So, wat kan verkeerd gaan met verwysings? Soos, 'n lot. Okay. So, slegte dinge.

1272
01:18:57,590 --> 01:19:02,410
'N paar slegte dinge wat jy kan doen nie kontroleer as jou malloc oproep terug null, reg?

1273
01:19:02,410 --> 01:19:06,560
In hierdie geval, ek vra die stelsel om my te gee - Wat is die getal?

1274
01:19:06,560 --> 01:19:11,200
Soos 2 miljard keer 4, omdat die grootte van 'n heelgetal is 4 grepe.

1275
01:19:11,200 --> 01:19:13,810
Ek vra dit vir soos 8 miljard grepe.

1276
01:19:13,810 --> 01:19:17,270
Natuurlik my rekenaar is nie van plan om in staat wees om te gee vir my dat 'n groot geheue terug.

1277
01:19:17,270 --> 01:19:20,960
En ons het nie kontroleer of dit is van nul, so wanneer ons probeer om dit daar te dereference -

1278
01:19:20,960 --> 01:19:24,270
volg die pyl na die plek waar dit gaan - ons het nie dat die geheue.

1279
01:19:24,270 --> 01:19:27,150
Dit is wat ons noem ontwysing 'n null-aanwijzer.

1280
01:19:27,150 --> 01:19:29,710
En dit veroorsaak hoofsaaklik om jou te segfault.

1281
01:19:29,710 --> 01:19:31,790
Dit is een van die maniere waarop jy kan segfault.

1282
01:19:34,090 --> 01:19:38,090
Ander slegte dinge wat jy kan doen - oh well.

1283
01:19:38,090 --> 01:19:40,650
Null pointer is ontwysing. Okay.

1284
01:19:40,650 --> 01:19:45,160
Ander slegte dinge - goed, op te los dat jy net 'n tjek daar

1285
01:19:45,160 --> 01:19:46,980
wat nagaan of die wyser is null

1286
01:19:46,980 --> 01:19:51,000
en uitgang uit die program as dit gebeur dat malloc terugkeer 'n null pointer.

1287
01:19:55,110 --> 01:19:59,850
Dit is die Kletskerk komiese. Mense verstaan ​​dit nou. Soort van.

1288
01:20:06,120 --> 01:20:09,350
>> So, geheue. En ek het oor hierdie.

1289
01:20:09,350 --> 01:20:12,000
Ons vra malloc in 'n lus, maar elke keer as ons 'n beroep malloc

1290
01:20:12,000 --> 01:20:14,370
ons verloor spoor van waar die wyser wys,

1291
01:20:14,370 --> 01:20:15,750
omdat ons beuken.

1292
01:20:15,750 --> 01:20:18,410
So, die aanvanklike oproep tot malloc gee my geheue hier.

1293
01:20:18,410 --> 01:20:19,990
My wyser verwysings na hierdie.

1294
01:20:19,990 --> 01:20:23,020
Nou, ek is nie vry om dit, so nou kan ek noem malloc weer.

1295
01:20:23,020 --> 01:20:26,070
Nou is dit wys hier. Nou is my geheue wys hier.

1296
01:20:26,070 --> 01:20:27,640
Wys oor hier. Wys oor hier.

1297
01:20:27,640 --> 01:20:31,820
Maar ek het verlore spoor van die adresse van al die geheue hier dat ek toegeken.

1298
01:20:31,820 --> 01:20:35,100
En so nou Ek het nie enige verwysing na hulle nie.

1299
01:20:35,100 --> 01:20:37,230
So, ek kan nie bevry buite van hierdie lus.

1300
01:20:37,230 --> 01:20:39,390
En so om iets soos hierdie op te los,

1301
01:20:39,390 --> 01:20:42,250
As jy vergeet om te vry geheue en jy kry hierdie geheugenlek,

1302
01:20:42,250 --> 01:20:45,810
Jy het die geheue te bevry binnekant van hierdie lus sodra jy klaar is met dit.

1303
01:20:45,810 --> 01:20:51,400
Wel, dit is wat gebeur. Ek weet baie van julle haat dit.

1304
01:20:51,400 --> 01:20:55,270
Maar nou - yay! Jy kry soos 44.000 kilogrepe.

1305
01:20:55,270 --> 01:20:57,110
So, jy vry om dit aan die einde van die lus,

1306
01:20:57,110 --> 01:20:59,770
en dit is om net te gaan bevry die geheue elke keer.

1307
01:20:59,770 --> 01:21:03,620
Wese, jou program nie 'n geheugenlek nie.

1308
01:21:03,620 --> 01:21:08,150
>> En nou iets anders wat jy kan doen, is om 'n paar geheue wat jy het gevra vir twee bevry.

1309
01:21:08,150 --> 01:21:11,060
In hierdie geval, jy malloc iets, jy die waarde daarvan verander.

1310
01:21:11,060 --> 01:21:13,140
Jy vry om dit een keer, want jy het gesê jy gedoen het met dit.

1311
01:21:13,140 --> 01:21:14,940
Maar dan moet ons bevry dit weer.

1312
01:21:14,940 --> 01:21:16,730
Dit is iets wat baie sleg is.

1313
01:21:16,730 --> 01:21:18,820
Dit gaan nie om aanvanklik segfault,

1314
01:21:18,820 --> 01:21:23,350
maar na 'n rukkie wat dit dubbel is bevry hierdie bederf jou hoop struktuur,

1315
01:21:23,350 --> 01:21:27,200
en jy sal 'n bietjie meer te leer oor dit as jy kies om 'n klas te neem soos CS61.

1316
01:21:27,200 --> 01:21:30,000
Maar in wese na 'n ruk jou rekenaar gaan om te verwar

1317
01:21:30,000 --> 01:21:33,010
oor watter geheue plekke is waar en waar dit gestoor -

1318
01:21:33,010 --> 01:21:34,800
waar die data gestoor in die geheue.

1319
01:21:34,800 --> 01:21:38,080
En so bevry 'n pointer twee keer 'n slegte ding wat jy nie wil hê om dit te doen.

1320
01:21:38,080 --> 01:21:41,600
>> Ander dinge wat kan verkeerd gaan nie met behulp van sizeof.

1321
01:21:41,600 --> 01:21:44,460
So, in hierdie geval jy malloc 8 grepe,

1322
01:21:44,460 --> 01:21:46,700
en dit is die dieselfde ding as twee heelgetalle, reg?

1323
01:21:46,700 --> 01:21:49,580
So, dit is heeltemal veilig, maar is dit?

1324
01:21:49,580 --> 01:21:52,160
Wel, as Lucas gepraat oor op verskillende platforms,

1325
01:21:52,160 --> 01:21:54,220
heelgetalle is van verskillende lengtes.

1326
01:21:54,220 --> 01:21:57,970
So, op die toestel wat jy gebruik, heelgetalle is ongeveer 4 bytes,

1327
01:21:57,970 --> 01:22:02,370
maar op 'n ander stelsel wat hulle kan wees 8 bytes of hulle kan 16 grepe.

1328
01:22:02,370 --> 01:22:05,680
So, as ek net gebruik om hierdie getal hier,

1329
01:22:05,680 --> 01:22:07,310
hierdie program kan werk op die toestel,

1330
01:22:07,310 --> 01:22:10,360
maar dit is nie genoeg geheue om te wys op 'n ander stelsel.

1331
01:22:10,360 --> 01:22:14,020
In hierdie geval, dit is wat die sizeof operator word gebruik vir.

1332
01:22:14,020 --> 01:22:16,880
Wanneer ons sizeof (int), Wat dit beteken is

1333
01:22:16,880 --> 01:22:21,910
 dit gee ons die grootte van 'n heelgetal op die stelsel dat die program word uitgevoer.

1334
01:22:21,910 --> 01:22:25,490
Dus, in hierdie geval, sal sizeof (int) terugkeer 4 op iets soos die toestel,

1335
01:22:25,490 --> 01:22:29,980
en nou wil 4 * 2, wat 8,

1336
01:22:29,980 --> 01:22:32,330
wat net die bedrag van die ruimte wat nodig is vir twee heelgetalle.

1337
01:22:32,330 --> 01:22:36,710
Op 'n ander stelsel, as 'n int is soos 16 bytes of 8 grepe,

1338
01:22:36,710 --> 01:22:39,380
dit is net genoeg bytes om terug te keer daardie bedrag te stoor.

1339
01:22:41,830 --> 01:22:45,310
>> En laastens, structs.

1340
01:22:45,310 --> 01:22:48,340
Dus, as jy wou 'n sudoku-raad in geheue te stoor, kan hoe ons dit doen?

1341
01:22:48,340 --> 01:22:51,570
Jy mag dalk dink soos 'n veranderlike vir die eerste ding,

1342
01:22:51,570 --> 01:22:53,820
'n veranderlike vir die tweede ding, 'n veranderlike vir die derde ding,

1343
01:22:53,820 --> 01:22:56,420
'n veranderlike vir die vierde ding - sleg, reg?

1344
01:22:56,420 --> 01:23:00,750
So, 'n verbetering wat jy kan maak op die top van hierdie is 'n 9 x 9 skikking te maak.

1345
01:23:00,750 --> 01:23:04,480
Dit is goed, maar wat as jy wil ander dinge om te assosieer met die sudoku raad

1346
01:23:04,480 --> 01:23:06,490
soos wat die probleme van die raad is,

1347
01:23:06,490 --> 01:23:11,740
of, byvoorbeeld, wat jou telling is, of hoe lank dit geneem u hierdie bord op te los?

1348
01:23:11,740 --> 01:23:14,970
Wel, wat jy kan doen is kan jy 'n struct skep.

1349
01:23:14,970 --> 01:23:18,910
Wat ek basies sê is ek is die definisie van hierdie struktuur hier,

1350
01:23:18,910 --> 01:23:23,230
en ek is die definisie van 'n sudoku raad wat bestaan ​​uit 'n raad wat is 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> En wat dit het verwysings na die naam van die vlak.

1352
01:23:26,650 --> 01:23:30,730
Dit het ook x en y, wat die koördinate van waar ek nou is.

1353
01:23:30,730 --> 01:23:35,980
Dit het ook tyd bestee [onverstaanbaar], en dit het die totale getal van beweeg wat ek tot dusver ingevoer.

1354
01:23:35,980 --> 01:23:40,010
En so in hierdie geval, kan ek 'n hele klomp van die data groep in net een struktuur

1355
01:23:40,010 --> 01:23:42,790
in plaas van om dit soos vlieg rond soos verskillende veranderlikes

1356
01:23:42,790 --> 01:23:44,540
dat ek kan regtig nie hou.

1357
01:23:44,540 --> 01:23:49,720
En dit kan ons het net mooi sintaksis vir soort verwysingsmetode verskillende dinge binnekant van hierdie struct.

1358
01:23:49,720 --> 01:23:53,430
Ek kan net doen board.board, en ek kry die sudoku raad terug.

1359
01:23:53,430 --> 01:23:56,320
Board.level, kry ek hoe moeilik dit is.

1360
01:23:56,320 --> 01:24:00,540
Board.x en board.y gee my die koördinate van waar ek kan wees in die raad.

1361
01:24:00,540 --> 01:24:04,730
En so het ek toegang tot wat ons noem die velde in die struct.

1362
01:24:04,730 --> 01:24:08,840
Dit definieer sudokuBoard, wat is 'n tipe wat ek het.

1363
01:24:08,840 --> 01:24:14,800
En nou is ons hier. Ek het 'n veranderlike genaamd "raad" van die tipe sudokuBoard.

1364
01:24:14,800 --> 01:24:18,820
En so nou kan ek toegang tot al die velde wat hierdie struktuur hier.

1365
01:24:20,830 --> 01:24:22,450
>> Enige vrae oor structs? Ja?

1366
01:24:22,450 --> 01:24:25,890
[Studente] Vir int x, y, verklaar jy beide op een lyn? >> [Josef] Uh-huh.

1367
01:24:25,890 --> 01:24:27,400
[Studente] So, jy kan net doen wat met almal van hulle?

1368
01:24:27,400 --> 01:24:31,200
Soos in x, y komma keer dat die totale?

1369
01:24:31,200 --> 01:24:34,460
[Joseph] Ja, jy kan beslis doen wat nie, maar die rede waarom ek op dieselfde lyn x en y -

1370
01:24:34,460 --> 01:24:36,330
en die vraag is hoekom ons kan net doen dit op dieselfde lyn?

1371
01:24:36,330 --> 01:24:38,600
Waarom ons nie net sit al hierdie dinge op dieselfde lyn is

1372
01:24:38,600 --> 01:24:42,090
x en y is verwant aan mekaar,

1373
01:24:42,090 --> 01:24:44,780
en dit is net stilisties meer korrek, in 'n sekere sin,

1374
01:24:44,780 --> 01:24:46,600
want dit is die groepering van twee dinge op dieselfde lyn

1375
01:24:46,600 --> 01:24:49,340
dat net soos soort van dieselfde ding.

1376
01:24:49,340 --> 01:24:51,440
En ek het net verdeel hierdie uitmekaar. Dit is net 'n styl ding.

1377
01:24:51,440 --> 01:24:53,720
Dit maak funksioneel geen verskil hoegenaamd.

1378
01:24:58,150 --> 01:24:59,270
Enige ander vrae op structs?

1379
01:25:03,030 --> 01:25:06,620
Jy kan 'n Pokédex definieer met 'n struct.

1380
01:25:06,620 --> 01:25:11,720
'N Pokémon het 'n nommer en dit het 'n brief, 'n eienaar, 'n soort.

1381
01:25:11,720 --> 01:25:16,990
En dan as jy het 'n verskeidenheid van Pokémon, kan jy maak 'n Pokédex, reg?

1382
01:25:16,990 --> 01:25:20,810
Okay, cool. So, vrae op structs. Dit is verwant aan structs.

1383
01:25:20,810 --> 01:25:25,270
>> Ten slotte, GDB. Wat beteken GDB laat jy dit doen? Dit kan jy jou program te ontfout.

1384
01:25:25,270 --> 01:25:27,650
En as jy nie GDB gebruik, sou ek aanbeveel kyk na die kort

1385
01:25:27,650 --> 01:25:31,250
en net gaan oor wat GDB is, hoe jy werk met dit, hoe jy dit kan gebruik,

1386
01:25:31,250 --> 01:25:32,900
en toets dit op 'n program.

1387
01:25:32,900 --> 01:25:37,400
En wat GDB kan jy doen is dit kan breek die [onverstaanbaar] jou program

1388
01:25:37,400 --> 01:25:38,920
en 'n praktiese reël.

1389
01:25:38,920 --> 01:25:42,600
Byvoorbeeld, ek wil breek uitvoering soos lyn 3 van my program,

1390
01:25:42,600 --> 01:25:46,010
en terwyl ek by lyn 3 Ek kan druk uit al die waardes wat daar is.

1391
01:25:46,010 --> 01:25:49,710
En so wat ons noem soos om in 'n lyn

1392
01:25:49,710 --> 01:25:52,350
is ons noem dit om 'n breekpunt op daardie lyn

1393
01:25:52,350 --> 01:25:55,920
en dan kan ons die druk van die veranderlikes in die staat van die program op daardie tydstip.

1394
01:25:55,920 --> 01:25:58,990
>> Ons kan uit dan is daar stap deur die program lyn-vir-lyn.

1395
01:25:58,990 --> 01:26:03,200
En dan kan ons kyk na die toestand van die stapel op die oomblik.

1396
01:26:03,200 --> 01:26:08,600
En so om te gebruik GDB, wat ons doen is noem ons kletteren op die C-lêer,

1397
01:26:08,600 --> 01:26:11,290
maar ons het dit die ggdb vlag te slaag.

1398
01:26:11,290 --> 01:26:15,850
En sodra ons klaar is met wat ons loop net gdb op die gevolglike uitvoer lêer.

1399
01:26:15,850 --> 01:26:18,810
En so kry jy 'n paar soos massa van die teks soos hierdie,

1400
01:26:18,810 --> 01:26:21,990
maar eintlik al wat jy hoef te doen is tik in die opdragte aan die begin.

1401
01:26:21,990 --> 01:26:24,250
Breek hoof sit 'n breekpunt by die hoof.

1402
01:26:24,250 --> 01:26:28,470
Lys 400 bevat 'n lys van die reëls van die kode rondom line 400.

1403
01:26:28,470 --> 01:26:31,410
En so in hierdie geval jy kan net rond te kyk en sê, oh,

1404
01:26:31,410 --> 01:26:34,360
Ek wil 'n breekpunt op line 397, wat is hierdie lyn te stel,

1405
01:26:34,360 --> 01:26:37,170
en dan jou program loop in daardie stap en dit gaan om te breek.

1406
01:26:37,170 --> 01:26:41,120
Dit gaan om te breek daar, en jy kan druk, byvoorbeeld, die waarde van lae of hoë.

1407
01:26:41,120 --> 01:26:46,410
En so is daar 'n klomp van die opdragte wat jy nodig het om te weet,

1408
01:26:46,410 --> 01:26:48,660
en hierdie skyfievertoning gaan op die webwerf,

1409
01:26:48,660 --> 01:26:54,000
so as jy net wil om dit te verwys of wil sit hulle op jou cheat sheets, voel vry.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. Dit was Quiz Review 0, en ons sal hou om indien u enige vrae het.

1411
01:27:00,650 --> 01:27:03,850
Alles reg.

1412
01:27:03,850 --> 01:27:09,030
>>  [Applous]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]