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

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

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

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

5
00:00:10,000 --> 00:00:15,000
Welkom bij de herziening sessie voor Quiz 0, die plaatsvindt deze woensdag.

6
00:00:15,000 --> 00:00:19,000
Wat we gaan doen vanavond, ik ben met 3 andere TFS,

7
00:00:19,000 --> 00:00:24,000
en samen gaan we om te gaan door middel van een overzicht van wat we hebben gedaan in de loop tot nu toe.

8
00:00:24,000 --> 00:00:27,000
Het gaat niet om 100% volledig, maar het geeft je een beter idee

9
00:00:27,000 --> 00:00:31,000
van wat je al hebt naar beneden en wat je nog moet studeren voor woensdag.

10
00:00:31,000 --> 00:00:34,000
En voel je vrij om je hand op te steken met vragen als we gaan mee,

11
00:00:34,000 --> 00:00:38,000
maar houd in gedachten dat we ook een beetje van de tijd aan het eind-

12
00:00:38,000 --> 00:00:41,000
als we door met een paar minuten te reserveonderdelen op algemene vragen te doen,

13
00:00:41,000 --> 00:00:47,000
dus hou dat in gedachten, en dus gaan we beginnen bij het begin met Week 0.

14
00:00:47,000 --> 00:00:50,000
>> [Quiz 0 Review!] [Deel 0] [Lexi Ross] Maar voordat we dat doen laten we het eens hebben over

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

16
00:00:53,000 --> 00:00:55,000
>> [Logistiek] [Quiz vindt plaats op woensdag 10/10 in plaats van lezing]

17
00:00:55,000 --> 00:00:57,000
>> [(Zie http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf voor details)] Het is op woensdag 10 oktober.

18
00:00:57,000 --> 00:01:00,000
>> Dat is deze woensdag, en als je naar deze URL hier,

19
00:01:00,000 --> 00:01:03,000
dat is ook toegankelijk vanuit CS50.net-er is een link naar het-

20
00:01:03,000 --> 00:01:06,000
U kunt informatie over waar te gaan op basis van

21
00:01:06,000 --> 00:01:10,000
uw achternaam of school affiliatie en

22
00:01:10,000 --> 00:01:14,000
hij vertelt over wat de quiz worden opgenomen en de aard van de vragen die je gaat krijgen.

23
00:01:14,000 --> 00:01:19,000
Houd er rekening mee dat u ook zult de kans om voor de quiz herzien doorsnede te hebben,

24
00:01:19,000 --> 00:01:21,000
zodat uw TFs zou moeten gaan over een aantal praktijk problemen,

25
00:01:21,000 --> 00:01:29,000
en dat is een goede kans om te zien waar je moet nog steeds te studeren voor de quiz.

26
00:01:29,000 --> 00:01:32,000
Laten we beginnen bij het begin met Bits 'n' Bytes.

27
00:01:32,000 --> 00:01:35,000
Vergeet niet een beetje is gewoon een 0 of een 1,

28
00:01:35,000 --> 00:01:38,000
en een byte is een verzameling 8 van die bits.

29
00:01:38,000 --> 00:01:42,000
Laten we eens kijken naar deze collectie stukjes hier.

30
00:01:42,000 --> 00:01:44,000
We moeten in staat zijn om erachter te komen hoeveel bits er zijn.

31
00:01:44,000 --> 00:01:48,000
Waar rekenen we er slechts 8 van hen, acht 0 of 1 stuks.

32
00:01:48,000 --> 00:01:51,000
En aangezien er 8 bits, dat is 1 byte,

33
00:01:51,000 --> 00:01:53,000
en laten we het te converteren naar hexadecimaal.

34
00:01:53,000 --> 00:01:58,000
Hexadecimaal is basis 16, en het is vrij gemakkelijk om te zetten in

35
00:01:58,000 --> 00:02:01,000
een getal in binaire, wat dat wil zeggen een in hexadecimale.

36
00:02:01,000 --> 00:02:04,000
Alles wat we doen is dat we kijken naar groepen van 4,

37
00:02:04,000 --> 00:02:07,000
en we ze converteren naar de juiste hexadecimaal getal.

38
00:02:07,000 --> 00:02:11,000
We beginnen met de meest rechtse groep 4, dus 0011.

39
00:02:11,000 --> 00:02:16,000
Dat gaat als een 1 en een 2, dus samen dat maakt 3.

40
00:02:16,000 --> 00:02:19,000
En dan laten we eens kijken naar de andere blok van 4.

41
00:02:19,000 --> 00:02:24,000
1101. Dat gaat als een 1, een 4 en een 8.

42
00:02:24,000 --> 00:02:28,000
Samen is dat gaat worden 13, waardoor D.

43
00:02:28,000 --> 00:02:32,000
En we herinneren dat in hexadecimale we niet alleen 0 gaan en met 9.

44
00:02:32,000 --> 00:02:36,000
We gaan 0 tot en met F, dus na 9, 10 komt overeen met A,

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

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

47
00:02:44,000 --> 00:02:49,000
dus om het te converteren naar decimaal alles wat we doen is dat we eigenlijk

48
00:02:49,000 --> 00:02:52,000
behandelen elke positie een macht van 2.

49
00:02:52,000 --> 00:02:58,000
Dat is een 1, een 2, nul 4s, nul 8s, een 16, et cetera,

50
00:02:58,000 --> 00:03:03,000
en het is een beetje moeilijk te berekenen in je hoofd, maar als we naar de volgende dia

51
00:03:03,000 --> 00:03:05,000
zien we het antwoord op die.

52
00:03:05,000 --> 00:03:09,000
>> In wezen gaan we aan de overkant van rechts naar links,

53
00:03:09,000 --> 00:03:14,000
en we vermenigvuldigen elk cijfer door de overeenkomstige macht van 2.

54
00:03:14,000 --> 00:03:19,000
En vergeet niet, voor hexadecimale noteren we deze getallen met 0x aan het begin

55
00:03:19,000 --> 00:03:23,000
zodat we niet verwarren met een decimaal getal.

56
00:03:23,000 --> 00:03:29,000
Verdergaand is dit een ASCII tabel,

57
00:03:29,000 --> 00:03:35,000
en wat wij ASCII te gebruiken voor het in kaart brengen van de personages om numerieke waarden.

58
00:03:35,000 --> 00:03:39,000
Vergeet niet in de cryptografie PSET maakten we veelvuldig gebruik van de ASCII-tabel

59
00:03:39,000 --> 00:03:43,000
om verschillende methoden cryptografie,

60
00:03:43,000 --> 00:03:47,000
de Caesar en de Vigenère cipher, om verschillende letters om te zetten

61
00:03:47,000 --> 00:03:52,000
in een string volgens de sleutel die door de gebruiker.

62
00:03:52,000 --> 00:03:56,000
Laten we eens kijken een beetje ASCII wiskunde.

63
00:03:56,000 --> 00:04:02,000
Naar 'P' + 1, in karaktervorm dat zou Q,

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

65
00:04:07,000 --> 00:04:10,000
En hoe precies zou zetten we tussen die 2 vormen?

66
00:04:10,000 --> 00:04:13,000
Het is eigenlijk niet te hard.

67
00:04:13,000 --> 00:04:16,000
Om 5 te trekken we '0 '

68
00:04:16,000 --> 00:04:20,000
want er zijn 5 plaatsen tussen de '0 'en de '5'.

69
00:04:20,000 --> 00:04:23,000
Met het oog op de andere manier waarop we gewoon toe te voegen op de 0 te gaan,

70
00:04:23,000 --> 00:04:25,000
dus het is een beetje als gewone rekenkunde.

71
00:04:25,000 --> 00:04:29,000
Vergeet niet dat als er iets quotes heeft er omheen is het een teken

72
00:04:29,000 --> 00:04:37,000
, hetgeen overeenkomt met een waarde in de ASCII-tabel.

73
00:04:37,000 --> 00:04:40,000
Verhuizen naar meer algemene informatica onderwerpen.

74
00:04:40,000 --> 00:04:43,000
We hebben geleerd wat een algoritme is en hoe we het programmeren

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

76
00:04:45,000 --> 00:04:48,000
Enkele voorbeelden van algoritmen zijn iets heel simpels als

77
00:04:48,000 --> 00:04:51,000
controleren of een getal even of oneven is.

78
00:04:51,000 --> 00:04:54,000
Voor dat vergeet niet dat we het getal mod door 2 en controleer of het resultaat 0.

79
00:04:54,000 --> 00:04:57,000
Als dat zo is, is het zelfs. Zo niet, het is vreemd.

80
00:04:57,000 --> 00:04:59,000
En dat is een voorbeeld van een heel basic algoritme.

81
00:04:59,000 --> 00:05:02,000
>> Een beetje een meer betrokken men is binair zoeken,

82
00:05:02,000 --> 00:05:05,000
die we later gaan over in de review-sessie.

83
00:05:05,000 --> 00:05:09,000
En de programmering is de term die we gebruiken voor het nemen van een algoritme

84
00:05:09,000 --> 00:05:15,000
en om te zetten naar de computer code kan lezen.

85
00:05:15,000 --> 00:05:20,000
2 voorbeelden van de programmering is Scratch,

86
00:05:20,000 --> 00:05:22,000
en dat is wat we gedaan hebben in week 0.

87
00:05:22,000 --> 00:05:25,000
Hoewel we niet echt typ de code het is een manier van de uitvoering van

88
00:05:25,000 --> 00:05:29,000
Dit algoritme dat wordt afgedrukt getallen 1-10,

89
00:05:29,000 --> 00:05:32,000
en hier zijn we hetzelfde doen in de C programmeertaal.

90
00:05:32,000 --> 00:05:41,000
Dit zijn functioneel gelijkwaardig, maar geschreven in verschillende talen of syntaxis.

91
00:05:41,000 --> 00:05:44,000
Vervolgens hebben we geleerd over booleaanse uitdrukkingen,

92
00:05:44,000 --> 00:05:48,000
en een boolean is een waarde die is waar of onwaar,

93
00:05:48,000 --> 00:05:51,000
en hier vaak Booleaanse uitdrukkingen

94
00:05:51,000 --> 00:05:55,000
naar binnen gaan van de voorwaarden, dus als (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
goed, we reeds x = 5, dus aan die voorwaarde zal evalueren om waar te zijn.

96
00:06:00,000 --> 00:06:03,000
En als het waar is, wat code is onder de voorwaarde

97
00:06:03,000 --> 00:06:08,000
zal worden geëvalueerd door de computer, zo die reeks te bedrukken

98
00:06:08,000 --> 00:06:12,000
naar standaard uitvoer, en de term conditie

99
00:06:12,000 --> 00:06:16,000
verwijst naar wat er tussen de haakjes van de if-statement.

100
00:06:16,000 --> 00:06:20,000
Vergeet niet alle operatoren.

101
00:06:20,000 --> 00:06:26,000
Vergeet niet het is && en | | wanneer we proberen te combineren 2 of meer voorwaarden,

102
00:06:26,000 --> 00:06:30,000
== Niet = om te controleren of 2 dingen gelijk zijn.

103
00:06:30,000 --> 00:06:36,000
Vergeet niet dat = is voor de toewijzing terwijl == is een booleaanse operator.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ en dan de laatste 2 spreken voor zich.

105
00:06:41,000 --> 00:06:45,000
Een algemeen overzicht van de Booleaanse logica hier.

106
00:06:45,000 --> 00:06:48,000
En booleaanse uitdrukkingen zijn ook belangrijk in lussen,

107
00:06:48,000 --> 00:06:50,000
die we nu gaan voorbij.

108
00:06:50,000 --> 00:06:56,000
We leerden over 3 soorten lussen tot nu toe in CS50, for, while, en te doen terwijl.

109
00:06:56,000 --> 00:06:59,000
En het is belangrijk te weten dat, hoewel voor de meeste doeleinden

110
00:06:59,000 --> 00:07:02,000
kunnen we eigenlijk over het algemeen gebruik maken van elk type lus

111
00:07:02,000 --> 00:07:06,000
zijn er bepaalde soorten doeleinden of gemeenschappelijke patronen

112
00:07:06,000 --> 00:07:09,000
in de programmering die specifiek vragen om een ​​van deze lussen

113
00:07:09,000 --> 00:07:13,000
waardoor het de meest efficiënte of elegante om het te coderen op die manier.

114
00:07:13,000 --> 00:07:18,000
Laten we naar wat deze lussen gewoonlijk gebruikt voor het vaakst.

115
00:07:18,000 --> 00:07:21,000
>> In een lus for we over het algemeen al weten hoe vaak we willen herhalen.

116
00:07:21,000 --> 00:07:24,000
Dat is wat we in de aandoening.

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

118
00:07:28,000 --> 00:07:31,000
We weten al dat we iets willen 10 keer doen.

119
00:07:31,000 --> 00:07:34,000
Nu, voor een while-lus, over het algemeen hebben we niet per se

120
00:07:34,000 --> 00:07:36,000
weten hoe vaak we voor de lus wilt uitvoeren.

121
00:07:36,000 --> 00:07:39,000
Maar we weten wel een soort van voorwaarde dat we het willen

122
00:07:39,000 --> 00:07:41,000
altijd waar of altijd onwaar.

123
00:07:41,000 --> 00:07:44,000
Zo wordt tijdens het instellen.

124
00:07:44,000 --> 00:07:46,000
Laten we zeggen dat is een boolean variabele.

125
00:07:46,000 --> 00:07:48,000
Terwijl dat is waar we willen dat de code te evalueren,

126
00:07:48,000 --> 00:07:52,000
dus een beetje meer uitbreidbaar, een beetje meer algemeen dan een for-lus,

127
00:07:52,000 --> 00:07:55,000
maar elke for-lus kan ook worden omgezet in een while lus.

128
00:07:55,000 --> 00:08:00,000
Tot slot doen terwijl lussen, die misschien wel de lastigste om meteen te begrijpen,

129
00:08:00,000 --> 00:08:04,000
worden vaak gebruikt wanneer we de code eerst evalueren

130
00:08:04,000 --> 00:08:06,000
voor de eerste keer dat we de toestand.

131
00:08:06,000 --> 00:08:09,000
Een vaak gebruikte methode voor een doe while loop

132
00:08:09,000 --> 00:08:12,000
is wanneer u wilt input van de gebruiker te krijgen, en je weet dat je de gebruiker wilt vragen

133
00:08:12,000 --> 00:08:15,000
voor input ten minste een keer, maar als ze niet geven u goede input meteen

134
00:08:15,000 --> 00:08:18,000
je wilt blijven vragen totdat ze geven u de goede input.

135
00:08:18,000 --> 00:08:21,000
Dat is het meest voorkomende gebruik van een niet while-lus,

136
00:08:21,000 --> 00:08:23,000
en laten we kijken naar de werkelijke structuur van deze lussen.

137
00:08:23,000 --> 00:08:27,000
Ze meestal altijd de neiging om deze patronen te volgen.

138
00:08:27,000 --> 00:08:30,000
>> Op de for-lus binnen in je hebt 3 componenten:

139
00:08:30,000 --> 00:08:35,000
initialisatie, meestal iets als int i = 0 waarbij i de teller,

140
00:08:35,000 --> 00:08:40,000
staat, waar we willen zeggen dat dit draaien lus, zolang deze toestand nog steeds bekleedt,

141
00:08:40,000 --> 00:08:44,000
als i <10, en ten slotte, update, dat is hoe verhogen we

142
00:08:44,000 --> 00:08:47,000
de teller variabele op elk punt in de lus.

143
00:08:47,000 --> 00:08:50,000
Een veel voorkomende ding om daar te zien is gewoon i + +,

144
00:08:50,000 --> 00:08:52,000
wat betekent verhogen i met 1 elke keer.

145
00:08:52,000 --> 00:08:55,000
U kunt ook iets doen als ik + = 2,

146
00:08:55,000 --> 00:08:58,000
wat betekent voeg 2 tot i elke keer dat je door de lus.

147
00:08:58,000 --> 00:09:03,000
En het doen alleen verwijst naar een code daadwerkelijk wordt uitgevoerd als deel van de lus.

148
00:09:03,000 --> 00:09:09,000
En voor een while-lus, deze keer hebben we eigenlijk de initialisatie buitenkant van de lus,

149
00:09:09,000 --> 00:09:12,000
dus bijvoorbeeld, laten we zeggen dat we proberen om hetzelfde soort lus zoals ik zojuist beschreven doen.

150
00:09:12,000 --> 00:09:16,000
Wij zouden zeggen int i = 0 voor de lus begint.

151
00:09:16,000 --> 00:09:20,000
Dan zouden we kunnen zeggen, terwijl ik <10 dit doen,

152
00:09:20,000 --> 00:09:22,000
zodat dezelfde codeblok als voorheen

153
00:09:22,000 --> 00:09:26,000
en deze keer de update een deel van de code, bijvoorbeeld, i + +,

154
00:09:26,000 --> 00:09:29,000
eigenlijk gaat de binnenkant van de lus.

155
00:09:29,000 --> 00:09:33,000
En tenslotte, voor een doen, terwijl, het is vergelijkbaar met de while-lus,

156
00:09:33,000 --> 00:09:36,000
maar we moeten niet vergeten dat de code een keer zal evalueren

157
00:09:36,000 --> 00:09:40,000
voordat de conditie wordt gecontroleerd, dus het maakt veel meer zin

158
00:09:40,000 --> 00:09:44,000
als je kijkt naar het in opdracht van boven naar beneden.

159
00:09:44,000 --> 00:09:49,000
In een doe while loop van de code evalueert voordat je zelfs kijken naar de zolang voorwaarde,

160
00:09:49,000 --> 00:09:55,000
terwijl een while-lus, controleert het eerst.

161
00:09:55,000 --> 00:09:59,000
Verklaringen en variabelen.

162
00:09:59,000 --> 00:10:04,000
Als we willen een nieuwe variabele te maken willen we eerst te initialiseren.

163
00:10:04,000 --> 00:10:07,000
>> Bijvoorbeeld, int bar initialiseert de variabele bar,

164
00:10:07,000 --> 00:10:10,000
maar het is niet geef het een waarde, dus wat is nu bar waarde?

165
00:10:10,000 --> 00:10:12,000
We weten het niet.

166
00:10:12,000 --> 00:10:14,000
Het kan een aantal vuilnis waarde die eerder werd opgeslagen er in het geheugen zijn,

167
00:10:14,000 --> 00:10:16,000
en we willen niet dat de variabele gebruiken

168
00:10:16,000 --> 00:10:19,000
totdat we daadwerkelijk geven hem de waarde,

169
00:10:19,000 --> 00:10:21,000
zodat we hier verklaren.

170
00:10:21,000 --> 00:10:24,000
Dan gaan we initialiseren te zijn 42 hieronder.

171
00:10:24,000 --> 00:10:28,000
Nu, natuurlijk, we weten dat dit kan worden gedaan op een regel, int bar = 42.

172
00:10:28,000 --> 00:10:30,000
Maar gewoon om te worden duidelijk de verschillende stappen die aan de hand,

173
00:10:30,000 --> 00:10:34,000
de verklaring en de initialisatie worden afzonderlijk gebeuren hier.

174
00:10:34,000 --> 00:10:38,000
Het gebeurt op een stap, en de volgende, int baz = bar + 1,

175
00:10:38,000 --> 00:10:44,000
deze verklaring, die in stappen baz, zodat aan het eind van deze code blok

176
00:10:44,000 --> 00:10:48,000
Als we de waarde van baz drukken zou 44

177
00:10:48,000 --> 00:10:52,000
omdat we declareren en initialiseren deze in op 1> bar bedragen,

178
00:10:52,000 --> 00:10:58,000
en dan verhogen we het nog een keer met de + +.

179
00:10:58,000 --> 00:11:02,000
We gingen over dit mooie kort, maar het is goed om een ​​algemene

180
00:11:02,000 --> 00:11:04,000
begrip van wat draden en gebeurtenissen zijn.

181
00:11:04,000 --> 00:11:06,000
We hebben voornamelijk deden dit in Scratch,

182
00:11:06,000 --> 00:11:09,000
dus je kunt bedenken draden als meerdere sequenties van de code

183
00:11:09,000 --> 00:11:11,000
die op hetzelfde moment.

184
00:11:11,000 --> 00:11:14,000
In werkelijkheid is waarschijnlijk niet draait tegelijkertijd,

185
00:11:14,000 --> 00:11:17,000
maar soort van abstract kunnen we denken aan het op die manier.

186
00:11:17,000 --> 00:11:20,000
>> In Scratch, bijvoorbeeld, hadden we de meerdere sprites.

187
00:11:20,000 --> 00:11:22,000
Men kan verschillende uitvoerende code tegelijk.

188
00:11:22,000 --> 00:11:26,000
Men zou kunnen lopen, terwijl de ander zegt iets

189
00:11:26,000 --> 00:11:29,000
in een ander deel van het scherm.

190
00:11:29,000 --> 00:11:34,000
Evenementen zijn een andere manier van het scheiden van de logica

191
00:11:34,000 --> 00:11:37,000
tussen de verschillende elementen van de code,

192
00:11:37,000 --> 00:11:40,000
en in Scratch waren we in staat om gebeurtenissen te simuleren met behulp van de uitzending,

193
00:11:40,000 --> 00:11:43,000
en dat is eigenlijk wanneer ik ontvangen, niet als ik hoor,

194
00:11:43,000 --> 00:11:47,000
maar in wezen is het een manier om informatie te verzenden

195
00:11:47,000 --> 00:11:49,000
ene naar de andere sprite.

196
00:11:49,000 --> 00:11:52,000
Bijvoorbeeld, kunt u om het spel te zenden over,

197
00:11:52,000 --> 00:11:56,000
en wanneer een andere sprite ontvangt game over,

198
00:11:56,000 --> 00:11:58,000
reageert op een bepaalde manier.

199
00:11:58,000 --> 00:12:03,000
Het is een belangrijk model om te begrijpen voor de programmering.

200
00:12:03,000 --> 00:12:07,000
Gewoon te gaan over de basis Week 0, wat we gegaan tot nu toe,

201
00:12:07,000 --> 00:12:10,000
Laten we eens kijken naar dit eenvoudige C programma.

202
00:12:10,000 --> 00:12:14,000
De tekst kan een beetje klein van hier te zijn, maar ik zal gaan over het echt snel.

203
00:12:14,000 --> 00:12:20,000
We zijn met 2 header-bestanden aan de top, cs50.h en stdio.h.

204
00:12:20,000 --> 00:12:23,000
We dan het definiëren van een constante genaamd limiet op 100.

205
00:12:23,000 --> 00:12:26,000
We vervolgens de implementatie van onze belangrijkste functie.

206
00:12:26,000 --> 00:12:29,000
Aangezien we hier niet gebruiken command line argumenten moeten we leegte zetten

207
00:12:29,000 --> 00:12:32,000
als de argumenten voor de belangrijkste.

208
00:12:32,000 --> 00:12:38,000
We zien int boven hoofd. Dat is de return type, dus 0 terug aan de onderkant.

209
00:12:38,000 --> 00:12:41,000
En we gebruiken CS50 functie uit de bibliotheek te krijgen int

210
00:12:41,000 --> 00:12:45,000
aan de gebruiker om invoer te vragen, en we slaan in deze variabele x,

211
00:12:45,000 --> 00:12:51,000
dus we hierboven verklaren x, en we het initialiseren met x = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> Vervolgens kijken we om te zien of de gebruiker gaf ons goede input.

213
00:12:53,000 --> 00:12:59,000
Als het ≥ LIMIT willen we een foutcode van 1 terug te keren en er een foutbericht af te drukken.

214
00:12:59,000 --> 00:13:02,000
En tenslotte, als de gebruiker heeft ons goede input

215
00:13:02,000 --> 00:13:08,000
we gaan het getal wilt kwadrateren en af ​​te drukken die het gevolg zijn.

216
00:13:08,000 --> 00:13:11,000
Gewoon om ervoor te zorgen dat degenen die alle getroffen huis

217
00:13:11,000 --> 00:13:17,000
kunt u de labels van verschillende delen van de code hier.

218
00:13:17,000 --> 00:13:19,000
Ik noemde constante, header-bestanden.

219
00:13:19,000 --> 00:13:21,000
Oh, int x. Zorg ervoor om te onthouden is dat een lokale variabele.

220
00:13:21,000 --> 00:13:24,000
Dat contrasteert het van een globale variabele, die gaan we praten over

221
00:13:24,000 --> 00:13:27,000
een beetje later in de review-sessie,

222
00:13:27,000 --> 00:13:30,000
en wij roepen de bibliotheek functie printf,

223
00:13:30,000 --> 00:13:34,000
dus als we hadden niet het stdio.h header-bestand

224
00:13:34,000 --> 00:13:37,000
zouden we niet in staat zijn om printf bellen.

225
00:13:37,000 --> 00:13:42,000
En ik geloof dat de pijl die werd afgesneden hier af wijst naar de% d,

226
00:13:42,000 --> 00:13:45,000
dat is een opmaak tekenreeks in printf.

227
00:13:45,000 --> 00:13:52,000
Het zegt print deze variabele als een getal,% d.

228
00:13:52,000 --> 00:13:58,000
En dat is het voor Week 0.

229
00:13:58,000 --> 00:14:06,000
Nu Lucas zal blijven.

230
00:14:06,000 --> 00:14:08,000
He, jongens. Mijn naam is Lucas.

231
00:14:08,000 --> 00:14:10,000
Ik ben een tweedejaars in de beste huis op de campus, Mather,

232
00:14:10,000 --> 00:14:14,000
en ik ga een beetje vertellen over 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
Zoals Lexi zei, toen we begonnen het vertalen van uw code van Scratch naar C

235
00:14:19,000 --> 00:14:23,000
een van de dingen die we hebben gemerkt is dat je niet zomaar

236
00:14:23,000 --> 00:14:26,000
schrijf uw code en voer het uit met behulp van een groene vlag meer.

237
00:14:26,000 --> 00:14:30,000
Eigenlijk moet je een aantal stappen te gebruiken om uw C-programma te maken

238
00:14:30,000 --> 00:14:33,000
uitgegroeid tot een uitvoerbaar bestand.

239
00:14:33,000 --> 00:14:36,000
Eigenlijk wat je doet als je het schrijven van een programma is dat

240
00:14:36,000 --> 00:14:40,000
je vertaalt uw idee in een taal die een compiler kan begrijpen,

241
00:14:40,000 --> 00:14:44,000
dus als je het schrijven van een programma in C

242
00:14:44,000 --> 00:14:47,000
wat je doet is eigenlijk het schrijven van iets dat je compiler gaat begrijpen,

243
00:14:47,000 --> 00:14:50,000
en dan de compiler zal die code te vertalen

244
00:14:50,000 --> 00:14:53,000
in iets dat uw computer zal begrijpen.

245
00:14:53,000 --> 00:14:55,000
>> En het ding is, de computer is eigenlijk heel dom.

246
00:14:55,000 --> 00:14:57,000
Uw computer kan alleen begrijpen 0s en 1s,

247
00:14:57,000 --> 00:15:01,000
dus eigenlijk in de eerste computers mensen meestal geprogrammeerd

248
00:15:01,000 --> 00:15:04,000
met behulp van 0s en 1s, maar nu niet meer, God zij dank.

249
00:15:04,000 --> 00:15:07,000
We hoeven niet te de sequenties voor 0s en 1s onthouden

250
00:15:07,000 --> 00:15:10,000
een lus of een while enzovoort.

251
00:15:10,000 --> 00:15:13,000
Daarom hebben we een compiler.

252
00:15:13,000 --> 00:15:17,000
Wat een compiler doet is het in principe de C-code vertaalt,

253
00:15:17,000 --> 00:15:21,000
in ons geval, een taal die uw computer zal begrijpen,

254
00:15:21,000 --> 00:15:25,000
die het voorwerp code, en de compiler dat we met behulp van

255
00:15:25,000 --> 00:15:30,000
heet clang, dus dit is eigenlijk het symbool voor clang.

256
00:15:30,000 --> 00:15:33,000
Wanneer u uw programma hebben, dan moet je 2 dingen doen.

257
00:15:33,000 --> 00:15:37,000
Ten eerste, moet je je programma te compileren, en dan zul je je programma uit te voeren.

258
00:15:37,000 --> 00:15:41,000
Om uw programma te compileren heb je een veel opties om dat te doen.

259
00:15:41,000 --> 00:15:44,000
De eerste is om te doen clang program.c

260
00:15:44,000 --> 00:15:47,000
in welk programma is de naam van uw programma.

261
00:15:47,000 --> 00:15:51,000
In dit geval kunt u ze alleen maar te zeggen: "He, mijn programma samen te stellen."

262
00:15:51,000 --> 00:15:56,000
Je zegt niet: "Ik wil deze naam voor mijn programma" of wat dan ook.

263
00:15:56,000 --> 00:15:58,000
>> De tweede optie is het geven van een naam aan uw programma.

264
00:15:58,000 --> 00:16:02,000
Je kunt zeggen clang-o en vervolgens de naam die u wilt

265
00:16:02,000 --> 00:16:06,000
het uitvoerbare bestand om zo en dan program.c worden genoemd.

266
00:16:06,000 --> 00:16:11,000
En u kunt dit ook doen met het programma make, en zie hoe in de eerste 2 gevallen

267
00:16:11,000 --> 00:16:15,000
Ik zette. C, en in de derde Ik heb alleen programma's?

268
00:16:15,000 --> 00:16:18,000
Ja, je eigenlijk niet te zetten. C wanneer u te maken.

269
00:16:18,000 --> 00:16:22,000
Anders wordt de compiler er werkelijk gaande te schreeuwen naar je.

270
00:16:22,000 --> 00:16:24,000
En ook, ik weet niet of jullie herinneren,

271
00:16:24,000 --> 00:16:29,000
maar een heleboel keer hebben we ook gebruikt-lcs50 of-lm.

272
00:16:29,000 --> 00:16:31,000
Dat heet koppelen.

273
00:16:31,000 --> 00:16:35,000
Het vertelt alleen de compiler dat je die bibliotheken gebruiken daar,

274
00:16:35,000 --> 00:16:39,000
dus als je wilt cs50.h gebruiken je eigenlijk hoeft te typen

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

276
00:16:43,000 --> 00:16:45,000
Als je dat niet doet, is de compiler niet van plan om te weten

277
00:16:45,000 --> 00:16:50,000
dat u het gebruik van deze functies in cs50.h.

278
00:16:50,000 --> 00:16:52,000
En als u wilt uw programma uit te voeren heb je 2 opties.

279
00:16:52,000 --> 00:16:57,000
Als je dat deed clang program.c heb je een naam niet geven aan uw programma.

280
00:16:57,000 --> 00:17:01,000
Je moet het uit te voeren met behulp van. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out is een standaard naam die clang uw programma geeft als je het niet geef het een naam.

282
00:17:06,000 --> 00:17:11,000
Anders ga je. / Programma doen als je gaf een naam aan uw programma,

283
00:17:11,000 --> 00:17:15,000
en ook als je maakte het programma de naam die een programma gaat krijgen

284
00:17:15,000 --> 00:17:23,000
al zal worden geprogrammeerd dezelfde naam als het bestand c.

285
00:17:23,000 --> 00:17:26,000
Dan hebben we gesproken over data types en data.

286
00:17:26,000 --> 00:17:31,000
>> In principe gegevenstypen zijn hetzelfde als doosjes die ze gebruiken

287
00:17:31,000 --> 00:17:35,000
om waarden op te slaan, zodat datatypes zijn eigenlijk net als Pokemons.

288
00:17:35,000 --> 00:17:39,000
Ze komen in alle soorten en maten.

289
00:17:39,000 --> 00:17:43,000
Ik weet niet of die analogie is logisch.

290
00:17:43,000 --> 00:17:46,000
Het gegevensformaat hangt eigenlijk van de architectuur van de machine.

291
00:17:46,000 --> 00:17:49,000
Alle gegevens maten die ik ga hier laten zien

292
00:17:49,000 --> 00:17:53,000
eigenlijk voor een 32-bits machine, hetgeen het geval van onze apparatuur,

293
00:17:53,000 --> 00:17:56,000
maar als je echt coderen van uw Mac of in een Windows-ook

294
00:17:56,000 --> 00:17:59,000
waarschijnlijk zul je een 64-bits machine,

295
00:17:59,000 --> 00:18:03,000
dus denk eraan dat de gegevens maten die ik ga hier om te tonen

296
00:18:03,000 --> 00:18:06,000
zijn voor de 32-bit machine.

297
00:18:06,000 --> 00:18:08,000
De eerste die we zagen was een int,

298
00:18:08,000 --> 00:18:10,000
dat is vrij eenvoudig.

299
00:18:10,000 --> 00:18:13,000
U gebruikt int naar een geheel getal op te slaan.

300
00:18:13,000 --> 00:18:16,000
We zagen ook het karakter, de char.

301
00:18:16,000 --> 00:18:20,000
Als u een brief of een beetje symbool te gebruiken bent u waarschijnlijk gaat om een ​​char te gebruiken.

302
00:18:20,000 --> 00:18:26,000
Een char heeft 1 byte, waarvan 8 bits, zoals Lexi gezegd betekent.

303
00:18:26,000 --> 00:18:31,000
In principe hebben we een ASCII-tabel die 256 heeft

304
00:18:31,000 --> 00:18:34,000
mogelijke combinaties van 0s en 1s,

305
00:18:34,000 --> 00:18:37,000
en dan als je een char typ het gaat vertalen

306
00:18:37,000 --> 00:18:44,000
het teken dat ingangen die u een nummer dat u in de ASCII-tabel, zoals Lexi gezegd.

307
00:18:44,000 --> 00:18:48,000
We hebben ook de vlotter, die we gebruiken om decimale getallen op te slaan.

308
00:18:48,000 --> 00:18:53,000
Als u wilt 3,14 kiezen, bijvoorbeeld, zul je een float te gebruiken

309
00:18:53,000 --> 00:18:55,000
of een dubbele die meer precisie heeft.

310
00:18:55,000 --> 00:18:57,000
Een vlotter is 4 bytes.

311
00:18:57,000 --> 00:19:01,000
Een dubbele heeft 8 bytes, dus het enige verschil is de precisie.

312
00:19:01,000 --> 00:19:04,000
We hebben ook een lange die wordt gebruikt voor integers,

313
00:19:04,000 --> 00:19:09,000
en u kunt zien voor een 32-bit machine een int en een lange hebben dezelfde grootte,

314
00:19:09,000 --> 00:19:13,000
dus het maakt niet echt zin om een ​​lange te gebruiken in een 32-bits machine.

315
00:19:13,000 --> 00:19:17,000
>> Maar als je een Mac gebruikt en 64-bits machine, eigenlijk een lange heeft maat 8,

316
00:19:17,000 --> 00:19:19,000
dus het is echt afhankelijk van de architectuur.

317
00:19:19,000 --> 00:19:22,000
Voor de 32-bit machine heeft het geen zin om echt gebruik maken van een lange.

318
00:19:22,000 --> 00:19:25,000
En een lange lange, daarentegen, heeft 8 bytes,

319
00:19:25,000 --> 00:19:30,000
dus het is heel goed als je wilt een langere integer te hebben.

320
00:19:30,000 --> 00:19:34,000
En tot slot hebben we string, dat is eigenlijk een char *,

321
00:19:34,000 --> 00:19:37,000
Dit is een pointer naar een char.

322
00:19:37,000 --> 00:19:40,000
Het is heel makkelijk om te denken dat de grootte van de string gaat als zijn

323
00:19:40,000 --> 00:19:42,000
het aantal tekens dat je er hebt,

324
00:19:42,000 --> 00:19:45,000
maar eigenlijk de char * zelf

325
00:19:45,000 --> 00:19:49,000
heeft het formaat van een pointer naar een char, die 4 bytes.

326
00:19:49,000 --> 00:19:52,000
De grootte van een char * 4 bytes is.

327
00:19:52,000 --> 00:19:56,000
Het maakt niet uit of u een klein woord of een brief of wat dan ook.

328
00:19:56,000 --> 00:19:58,000
Het gaat worden 4 bytes.

329
00:19:58,000 --> 00:20:01,000
We hebben ook geleerd een beetje over gieten,

330
00:20:01,000 --> 00:20:04,000
zodat u kunt zien, als je bijvoorbeeld een programma dat zegt

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
Weten jullie wat het gaat om af te drukken op het scherm?

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

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

335
00:20:16,000 --> 00:20:20,000
Wanneer u 3/2 doen het gaat om 1,5 te krijgen,

336
00:20:20,000 --> 00:20:24,000
maar aangezien we met behulp van een geheel getal dat het gaat om het decimale gedeelte negeren,

337
00:20:24,000 --> 00:20:26,000
en je gaat 1 hebben.

338
00:20:26,000 --> 00:20:29,000
Als u niet wilt dat dit gebeurt wat u kunt doen, bijvoorbeeld,

339
00:20:29,000 --> 00:20:33,000
is een vlotter vast y = x.

340
00:20:33,000 --> 00:20:40,000
Vervolgens x die voorheen 3 gaat nu 3,000 in y.

341
00:20:40,000 --> 00:20:44,000
En dan kunt u afdrukken de y / 2.

342
00:20:44,000 --> 00:20:50,000
Eigenlijk zou ik een 2. daar.

343
00:20:50,000 --> 00:20:55,000
Het zal 3.00/2.00 doen,

344
00:20:55,000 --> 00:20:58,000
en je gaat naar 1,5 te krijgen.

345
00:20:58,000 --> 00:21:06,000
En we hebben dit .2 f alleen maar om te vragen voor 2 decimale eenheden in het decimale gedeelte.

346
00:21:06,000 --> 00:21:12,000
Als u .3 f het gaat om daadwerkelijk 1,500.

347
00:21:12,000 --> 00:21:16,000
Als het 2 gaat het om 1,50.

348
00:21:16,000 --> 00:21:18,000
Wij hebben ook dit geval.

349
00:21:18,000 --> 00:21:22,000
Als je float x = 3,14 en dan heb je printf x

350
00:21:22,000 --> 00:21:24,000
je gaat naar 3,14 te krijgen.

351
00:21:24,000 --> 00:21:29,000
En als je x = het int van x,

352
00:21:29,000 --> 00:21:34,000
wat betekent dat de behandeling van x als een int en u afdrukt x nu

353
00:21:34,000 --> 00:21:36,000
je gaat naar 3,00 te hebben.

354
00:21:36,000 --> 00:21:38,000
Is dat logisch?

355
00:21:38,000 --> 00:21:41,000
Omdat je het eerst behandelen x als een integer, dus je negeert het decimale gedeelte,

356
00:21:41,000 --> 00:21:45,000
en dan u afdrukt x.

357
00:21:45,000 --> 00:21:47,000
En ten slotte, kunt u dit ook doen,

358
00:21:47,000 --> 00:21:52,000
int x = 65, en dan declareer je een char c = x,

359
00:21:52,000 --> 00:21:56,000
en dan als u afdrukt de c je eigenlijk gaat krijgen

360
00:21:56,000 --> 00:21:59,000
A, dus in principe wat je hier doet

361
00:21:59,000 --> 00:22:02,000
is het vertalen van de integer in het karakter,

362
00:22:02,000 --> 00:22:05,000
net als de ASCII-tabel doet.

363
00:22:05,000 --> 00:22:08,000
We hebben ook gesproken over wiskundige operatoren.

364
00:22:08,000 --> 00:22:14,000
De meeste van hen zijn vrij eenvoudig, dus +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
en ook hebben we gesproken over mod, die de rest van een deling van 2 getallen.

366
00:22:20,000 --> 00:22:23,000
Als u 10% 3, bijvoorbeeld,

367
00:22:23,000 --> 00:22:27,000
het betekent delen 10 door 3, en wat is de rest?

368
00:22:27,000 --> 00:22:30,000
Het zal op 1, dus het is eigenlijk heel nuttig voor een groot deel van de programma's.

369
00:22:30,000 --> 00:22:38,000
Voor Vigenère en Caesar ik ben er vrij zeker van dat jullie allemaal mod gebruikt.

370
00:22:38,000 --> 00:22:43,000
Over wiskundige operatoren, heel voorzichtig zijn bij het combineren van * en /.

371
00:22:43,000 --> 00:22:48,000
>> Bijvoorbeeld, als je dat doet (3/2) * 2 wat ga je krijgen?

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

373
00:22:50,000 --> 00:22:54,000
Ja, 2, omdat 3/2 zal zijn 1,5,

374
00:22:54,000 --> 00:22:57,000
maar omdat je aan het doen bent operaties tussen 2 gehele getallen

375
00:22:57,000 --> 00:22:59,000
je eigenlijk alleen maar naar 1 te overwegen,

376
00:22:59,000 --> 00:23:03,000
en dan 1 * 2 gaat worden 2, dus heel, heel voorzichtig

377
00:23:03,000 --> 00:23:07,000
bij het doen van rekenen met gehele getallen, omdat

378
00:23:07,000 --> 00:23:12,000
je zou kunnen krijgen dat 2 = 3, in dat geval.

379
00:23:12,000 --> 00:23:14,000
En ook heel voorzichtig zijn over voorrang.

380
00:23:14,000 --> 00:23:21,000
Je moet meestal haakjes gebruiken om er zeker van dat je weet wat je doet.

381
00:23:21,000 --> 00:23:27,000
Handige sneltoetsen natuurlijk men i + + i + of = 1

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

383
00:23:30,000 --> 00:23:34,000
Dat is hetzelfde als het doen van i = i + 1.

384
00:23:34,000 --> 00:23:39,000
U kunt ook i - of i - = 1,

385
00:23:39,000 --> 00:23:42,000
die hetzelfde is als i = i -1,

386
00:23:42,000 --> 00:23:46,000
iets wat jullie gebruiken veel in voor loops, op zijn minst.

387
00:23:46,000 --> 00:23:52,000
Ook voor *, als u * = en als je dat doet, bijvoorbeeld,

388
00:23:52,000 --> 00:23:57,000
i * = 2 is hetzelfde als zeggen i = i * 2,

389
00:23:57,000 --> 00:23:59,000
en hetzelfde voor divisie.

390
00:23:59,000 --> 00:24:08,000
Als je i / = 2 is hetzelfde als i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Nu over functies.

392
00:24:10,000 --> 00:24:13,000
Jullie geleerd dat functies zijn een zeer goede strategie om code op te slaan

393
00:24:13,000 --> 00:24:16,000
terwijl je het programmeren, dus als je wilt om dezelfde taak uit te voeren

394
00:24:16,000 --> 00:24:20,000
in code opnieuw en opnieuw, waarschijnlijk u een functie wilt gebruiken

395
00:24:20,000 --> 00:24:25,000
maar dat je het niet hoeft te kopiëren en de code te plakken over en weer.

396
00:24:25,000 --> 00:24:28,000
Eigenlijk belangrijkste is een functie, en als ik u het formaat van een functie

397
00:24:28,000 --> 00:24:32,000
zul je zien dat dat is vrij duidelijk.

398
00:24:32,000 --> 00:24:35,000
We gebruiken ook functies van een aantal bibliotheken,

399
00:24:35,000 --> 00:24:39,000
bijvoorbeeld printf, GETIN, dat de CS50 bibliotheek

400
00:24:39,000 --> 00:24:43,000
en andere functies, zoals toupper.

401
00:24:43,000 --> 00:24:46,000
Al deze functies worden daadwerkelijk uitgevoerd in andere bibliotheken,

402
00:24:46,000 --> 00:24:49,000
en als je die ketting bestanden in het begin van het programma

403
00:24:49,000 --> 00:24:53,000
je zegt kunt u mij de code voor deze functies

404
00:24:53,000 --> 00:24:57,000
dus ik hoef ze niet te implementeren in mijn eentje?

405
00:24:57,000 --> 00:25:00,000
En u kunt ook uw eigen functies, dus als je programma in te gaan

406
00:25:00,000 --> 00:25:04,000
realiseer je je dat niet bibliotheken niet alle functies die je nodig hebt.

407
00:25:04,000 --> 00:25:10,000
Voor de laatste PSET, bijvoorbeeld, schreven we tekenen, door elkaar husselen en opzoeken,

408
00:25:10,000 --> 00:25:13,000
en het is heel erg belangrijk om te kunnen functies schrijven

409
00:25:13,000 --> 00:25:17,000
omdat ze nuttig zijn, en we gebruiken ze de hele tijd in de programmering,

410
00:25:17,000 --> 00:25:19,000
en het bespaart een hoop code.

411
00:25:19,000 --> 00:25:21,000
Het formaat van een functie is deze.

412
00:25:21,000 --> 00:25:24,000
We hebben return type in het begin. Wat is het rendement type?

413
00:25:24,000 --> 00:25:27,000
Het is gewoon als je de functie gaat om terug te keren.

414
00:25:27,000 --> 00:25:29,000
Als u een functie, bijvoorbeeld, faculteit,

415
00:25:29,000 --> 00:25:31,000
dat gaat een faculteit van een integer berekenen,

416
00:25:31,000 --> 00:25:34,000
waarschijnlijk dat het gaat om een ​​geheel getal ook terugkeren.

417
00:25:34,000 --> 00:25:37,000
Dan is de return type gaat worden int.

418
00:25:37,000 --> 00:25:41,000
Printf eigenlijk een terugkeer type void

419
00:25:41,000 --> 00:25:43,000
omdat je niet wat terugstuurt.

420
00:25:43,000 --> 00:25:45,000
Je bent gewoon afdrukken dingen op het scherm

421
00:25:45,000 --> 00:25:48,000
en het verlaten van de functie na afloop.

422
00:25:48,000 --> 00:25:51,000
Dan heb je de naam van de functie die u kunt kiezen.

423
00:25:51,000 --> 00:25:55,000
Je moet een beetje redelijk, zoals niet kiezen voor een naam als xyz

424
00:25:55,000 --> 00:25:58,000
of zoals x2F.

425
00:25:58,000 --> 00:26:02,000
Probeer om make-up een naam die zinvol is.

426
00:26:02,000 --> 00:26:04,000
>> Bijvoorbeeld, als het factorial we zeggen factoriële.

427
00:26:04,000 --> 00:26:08,000
Als het een functie die gaat iets te tekenen, noem maar op te tekenen.

428
00:26:08,000 --> 00:26:11,000
En dan hebben we de parameters, die ook worden genoemd argumenten,

429
00:26:11,000 --> 00:26:14,000
die net als de middelen die uw functie moet

430
00:26:14,000 --> 00:26:17,000
van uw code om zijn taak uit te voeren.

431
00:26:17,000 --> 00:26:20,000
Als u wilt dat de faculteit van een getal te berekenen

432
00:26:20,000 --> 00:26:23,000
Waarschijnlijk moet je een nummer hebben om een ​​factorieel berekenen.

433
00:26:23,000 --> 00:26:27,000
Een van de argumenten die je gaat hebben is het nummer zelf.

434
00:26:27,000 --> 00:26:31,000
En dan dat het gaat om iets te doen en de waarde op het einde

435
00:26:31,000 --> 00:26:35,000
tenzij het een leegte functie.

436
00:26:35,000 --> 00:26:37,000
Laten we eens een voorbeeld.

437
00:26:37,000 --> 00:26:40,000
Als ik wil een functie die alle getallen vat in een array van integers te schrijven,

438
00:26:40,000 --> 00:26:43,000
allereerst wordt de return type zal zijn int

439
00:26:43,000 --> 00:26:46,000
want ik heb een array van integers.

440
00:26:46,000 --> 00:26:51,000
En dan ga ik naar de functie naam zoals sumArray hebben,

441
00:26:51,000 --> 00:26:54,000
en dan is het gaat om de array zelf te nemen, om int nums,

442
00:26:54,000 --> 00:26:58,000
en vervolgens de lengte van de array, zodat ik weet hoeveel nummers ik moet samenvatten.

443
00:26:58,000 --> 00:27:02,000
Dan moet ik een variabele genaamd bedrag, bijvoorbeeld op 0 initialiseren

444
00:27:02,000 --> 00:27:08,000
en elke keer zie ik een element in de array moet ik toevoegen aan som, dus ik heb een for-lus.

445
00:27:08,000 --> 00:27:15,000
Net zoals Lexi zei, je doet int i = 0, i <lengte en i + +.

446
00:27:15,000 --> 00:27:20,000
En voor elk element in de array ik som + = nums [i],

447
00:27:20,000 --> 00:27:24,000
en dan heb ik het bedrag terug, dus het is zeer eenvoudig, en het scheelt een hoop code

448
00:27:24,000 --> 00:27:28,000
als je gebruik maakt van deze functie een heleboel keer.

449
00:27:28,000 --> 00:27:32,000
We namen een kijkje op voorwaarden.

450
00:27:32,000 --> 00:27:38,000
We hebben als, anders, en anders als.

451
00:27:38,000 --> 00:27:42,000
Laten we eens kijken wat is het verschil tussen deze.

452
00:27:42,000 --> 00:27:45,000
Neem een ​​kijkje op deze 2 codes. Wat is het verschil tussen hen?

453
00:27:45,000 --> 00:27:49,000
De eerste is-eigenlijk de codes wil dat je te vertellen

454
00:27:49,000 --> 00:27:51,000
of een getal +, -, of 0.

455
00:27:51,000 --> 00:27:55,000
De eerste zegt dat als het> 0 dan dat het positief is.

456
00:27:55,000 --> 00:28:00,000
Als het = aan 0 dan is het 0, en als het <0 dan is het negatief.

457
00:28:00,000 --> 00:28:04,000
>> En de andere aan het doen is, indien, anders als, anders.

458
00:28:04,000 --> 00:28:07,000
Het verschil tussen de twee is dat dit daadwerkelijk zal

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

460
00:28:13,000 --> 00:28:17,000
dus als je de nummer 2, bijvoorbeeld, gaat het om hier te komen en zeggen:

461
00:28:17,000 --> 00:28:21,000
if (x> 0), en het gaat om ja te zeggen, dus ik print positief.

462
00:28:21,000 --> 00:28:25,000
Maar hoewel ik weet dat het> 0 en het is niet van plan om 0 of <0

463
00:28:25,000 --> 00:28:29,000
Ik ben nog steeds ga doen is het 0, is het <0,

464
00:28:29,000 --> 00:28:33,000
dus ik ben eigenlijk naar binnen van mitsen dat ik niet hoefde te

465
00:28:33,000 --> 00:28:38,000
omdat ik al weet dat het niet gaat om een ​​van deze voorwaarden te voldoen.

466
00:28:38,000 --> 00:28:41,000
Ik kan gebruik maken van de if, else if, else statement.

467
00:28:41,000 --> 00:28:45,000
Het zegt in feite als x = 0 print ik de positieve.

468
00:28:45,000 --> 00:28:48,000
Als het niet, ik ga ook testen.

469
00:28:48,000 --> 00:28:51,000
Als het 2 niet ik ga om dit te doen.

470
00:28:51,000 --> 00:28:54,000
In principe als ik x = 2 zou je zeggen

471
00:28:54,000 --> 00:28:57,000
if (x> 0), ja, zo afdrukken.

472
00:28:57,000 --> 00:29:00,000
Nu ik weet dat het> 0 en dat het voldeed aan de eerst als

473
00:29:00,000 --> 00:29:02,000
Ik ben niet eens gaan deze code uit te voeren.

474
00:29:02,000 --> 00:29:09,000
De code loopt sneller, eigenlijk, 3 keer zo snel als u deze.

475
00:29:09,000 --> 00:29:11,000
We hebben ook geleerd over en en of.

476
00:29:11,000 --> 00:29:15,000
Ik ben niet van plan om te gaan door omdat Lexi al gesproken over hen.

477
00:29:15,000 --> 00:29:17,000
Het is gewoon de && en | | operator.

478
00:29:17,000 --> 00:29:21,000
>> Het enige wat ik zeg is voorzichtig te zijn wanneer u 3 voorwaarden.

479
00:29:21,000 --> 00:29:24,000
Gebruik haakjes want het is erg verwarrend wanneer u een aandoening heeft

480
00:29:24,000 --> 00:29:27,000
en nog een of een andere.

481
00:29:27,000 --> 00:29:30,000
Gebruik haakjes gewoon om zeker te zijn dat uw omstandigheden zinvol

482
00:29:30,000 --> 00:29:34,000
omdat in dat geval, bijvoorbeeld, kun je je voorstellen dat

483
00:29:34,000 --> 00:29:38,000
het zou de eerste toestand en een of de ander door

484
00:29:38,000 --> 00:29:41,000
of de 2 voorwaarden gecombineerd in een en

485
00:29:41,000 --> 00:29:45,000
of de derde, dus wees voorzichtig.

486
00:29:45,000 --> 00:29:48,000
En tot slot hebben we gesproken over schakelaars.

487
00:29:48,000 --> 00:29:53,000
Een switch is erg handig wanneer u een variabele.

488
00:29:53,000 --> 00:29:55,000
Laten we zeggen dat je een variabele als n hebben

489
00:29:55,000 --> 00:29:59,000
dat kan 0, 1, of 2, en voor elk van deze gevallen

490
00:29:59,000 --> 00:30:01,000
je gaat om een ​​taak uit te voeren.

491
00:30:01,000 --> 00:30:04,000
Je kunt zeggen zet de variabele, en het geeft aan dat

492
00:30:04,000 --> 00:30:08,000
de waarde is dan als waarde1 ga ik om dit te doen,

493
00:30:08,000 --> 00:30:12,000
en dan breek ik, wat betekent dat ik ben niet van plan om te kijken naar een van de andere gevallen

494
00:30:12,000 --> 00:30:15,000
omdat we al tevreden dat geval

495
00:30:15,000 --> 00:30:20,000
en dan waarde2 en ga zo maar door, en ik kan ook een standaard schakelaar.

496
00:30:20,000 --> 00:30:24,000
Dat betekent dat als het niet voldoet aan een van de gevallen die ik had

497
00:30:24,000 --> 00:30:29,000
dat ik ga iets anders doen, maar dat is optioneel.

498
00:30:29,000 --> 00:30:36,000
Dat is alles voor mij. Laten we nu eens Tommy.

499
00:30:36,000 --> 00:30:41,000
Oke, dit gaat Week 3-ish te zijn.

500
00:30:41,000 --> 00:30:45,000
Dit zijn enkele van de onderwerpen die we zullen behandelen, crypto, scope, arrays, et cetera.

501
00:30:45,000 --> 00:30:49,000
Gewoon een snelle woord over crypto. We gaan niet naar dit huis hamer.

502
00:30:49,000 --> 00:30:52,000
>> We deden dit in PSET 2, maar voor de quiz zorg ervoor dat je weet dat het verschil

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

504
00:30:54,000 --> 00:30:57,000
hoe deze beide cijfers werk en hoe het is om te coderen

505
00:30:57,000 --> 00:30:59,000
en decoderen van tekst met behulp van deze 2 cijfers.

506
00:30:59,000 --> 00:31:03,000
Vergeet niet, de Caesar cipher draait gewoon aan elk teken met hetzelfde bedrag,

507
00:31:03,000 --> 00:31:06,000
voor dat u mod door het aantal letters in het alfabet.

508
00:31:06,000 --> 00:31:09,000
En Vigenère cijfer, anderzijds, roteert elk teken

509
00:31:09,000 --> 00:31:12,000
door een ander bedrag, dus in plaats van te zeggen

510
00:31:12,000 --> 00:31:15,000
elk karakter geroteerd met 3 Vigenère draait elk karakter

511
00:31:15,000 --> 00:31:17,000
een verschillende hoeveelheid afhankelijk van een zoekwoord

512
00:31:17,000 --> 00:31:20,000
waar elke letter in het trefwoord vertegenwoordigt zo'n ander bedrag

513
00:31:20,000 --> 00:31:26,000
de duidelijke tekst draaien.

514
00:31:26,000 --> 00:31:28,000
Laten we eerst praten over variabele bereik.

515
00:31:28,000 --> 00:31:30,000
Er zijn 2 verschillende typen variabelen.

516
00:31:30,000 --> 00:31:33,000
We hebben lokale variabelen, en deze zullen worden gedefinieerd

517
00:31:33,000 --> 00:31:36,000
buiten hoofd-of buiten een functie of blok,

518
00:31:36,000 --> 00:31:39,000
en deze zullen overal toegankelijk zijn in uw programma.

519
00:31:39,000 --> 00:31:41,000
Als u een functie en in die functie is een while-lus

520
00:31:41,000 --> 00:31:44,000
de grote globale variabele is overal toegankelijk.

521
00:31:44,000 --> 00:31:48,000
Een lokale variabele, daarentegen, is binnen het bereik van de plaats waar het is gedefinieerd.

522
00:31:48,000 --> 00:31:53,000
>> Als u een functie hier, bijvoorbeeld, hebben we deze functie g,

523
00:31:53,000 --> 00:31:56,000
en binnenkant van g er variabele hier genoemd y,

524
00:31:56,000 --> 00:31:58,000
en dat betekent dat dit een lokale variabele.

525
00:31:58,000 --> 00:32:00,000
Hoewel deze variabele y heet

526
00:32:00,000 --> 00:32:03,000
en deze variabele wordt genoemd y deze 2 functies

527
00:32:03,000 --> 00:32:06,000
hebben geen idee wat elkaars lokale variabelen zijn.

528
00:32:06,000 --> 00:32:10,000
Anderzijds, hier we zeggen int x = 5,

529
00:32:10,000 --> 00:32:12,000
en dit is buiten het bereik van elke functie.

530
00:32:12,000 --> 00:32:16,000
Het is buiten het bereik van de belangrijkste, dus dit is een globale variabele.

531
00:32:16,000 --> 00:32:20,000
Dat betekent dat de binnenkant van deze 2 functies als ik zeg x - of x + +

532
00:32:20,000 --> 00:32:26,000
Ik ben toegang tot dezelfde x waarbij deze y en dit y verschillende variabelen.

533
00:32:26,000 --> 00:32:30,000
Dat is het verschil tussen een globale variabele en een lokale variabele.

534
00:32:30,000 --> 00:32:33,000
Qua vormgeving betreft, soms is het waarschijnlijk een beter idee

535
00:32:33,000 --> 00:32:37,000
te houden variabelen lokale wanneer je kan

536
00:32:37,000 --> 00:32:39,000
omdat het hebben van een bos van globale variabelen kan erg verwarrend zijn.

537
00:32:39,000 --> 00:32:42,000
Als u een aantal functies al het wijzigen van de hetzelfde

538
00:32:42,000 --> 00:32:45,000
je zou kunnen vergeten wat als deze functie per ongeluk wijzigt deze wereldwijde,

539
00:32:45,000 --> 00:32:47,000
en deze andere functie niet weten,

540
00:32:47,000 --> 00:32:50,000
en het is behoorlijk verwarrend als je meer code.

541
00:32:50,000 --> 00:32:53,000
Het houden van variabelen lokale wanneer je kan

542
00:32:53,000 --> 00:32:56,000
is alleen een goed ontwerp.

543
00:32:56,000 --> 00:33:00,000
Arrays, vergeet niet, zijn gewoon lijsten van elementen van hetzelfde type.

544
00:33:00,000 --> 00:33:04,000
Binnenkant van CI kan niet over een lijst, zoals 1, 2.0, hallo.

545
00:33:04,000 --> 00:33:06,000
We kunnen gewoon niet doen.

546
00:33:06,000 --> 00:33:11,000
>> Wanneer we een array verklaren C alle elementen moeten van hetzelfde type.

547
00:33:11,000 --> 00:33:14,000
Hier heb ik een serie van 3 gehele getallen.

548
00:33:14,000 --> 00:33:18,000
Hier heb ik de lengte van de array, maar als ik ben gewoon te verklaren het in deze syntax

549
00:33:18,000 --> 00:33:21,000
waar ik aangeven wat alle elementen zijn ik technisch niet dit 3 nodig.

550
00:33:21,000 --> 00:33:25,000
De compiler is slim genoeg om erachter te komen hoe groot de array zou moeten zijn.

551
00:33:25,000 --> 00:33:28,000
Nu wanneer ik wil krijgen of de waarde van een array

552
00:33:28,000 --> 00:33:30,000
dit is de syntax om dat te doen.

553
00:33:30,000 --> 00:33:33,000
Dit ook daadwerkelijk te wijzigen het tweede element van de array, omdat, onthoud,

554
00:33:33,000 --> 00:33:36,000
nummering begint bij 0, niet bij 1.

555
00:33:36,000 --> 00:33:42,000
Als ik wil dat afgelezen waarde ik kan zeggen iets als int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Of als ik wil dat waarde in te stellen, zoals ik hier doe,

557
00:33:44,000 --> 00:33:47,000
Ik kan zeggen array [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Die tijd toegang tot elementen door hun index

559
00:33:50,000 --> 00:33:52,000
of de positie of wanneer zij in de array,

560
00:33:52,000 --> 00:33:57,000
en die lijst begint bij 0.

561
00:33:57,000 --> 00:34:00,000
We kunnen ook arrays van arrays

562
00:34:00,000 --> 00:34:03,000
en dit wordt een meerdimensionale array.

563
00:34:03,000 --> 00:34:05,000
Wanneer we een meerdimensionale array

564
00:34:05,000 --> 00:34:07,000
dat betekent dat we kunnen hebben iets als rijen en kolommen,

565
00:34:07,000 --> 00:34:11,000
en dit is slechts een manier om te visualiseren deze of erover na te denken.

566
00:34:11,000 --> 00:34:14,000
Toen ik een multi-dimensionale array hebben dat betekent dat ik ga beginnen nodig

567
00:34:14,000 --> 00:34:17,000
meer dan 1 index, want als ik een raster

568
00:34:17,000 --> 00:34:19,000
gewoon zeggen wat rij je in geeft ons niet een nummer.

569
00:34:19,000 --> 00:34:22,000
Dat is echt alleen maar om ons een lijst met getallen.

570
00:34:22,000 --> 00:34:25,000
Laten we zeggen dat ik hier deze array.

571
00:34:25,000 --> 00:34:30,000
Ik heb een array met de naam net, en ik zeg het is 2 rijen en 3 kolommen,

572
00:34:30,000 --> 00:34:32,000
en dus dit is een manier van visualiseren.

573
00:34:32,000 --> 00:34:37,000
Als ik zeg dat ik het element wilt krijgen op [1] [2]

574
00:34:37,000 --> 00:34:41,000
dat betekent dat omdat deze rijen en vervolgens de kolommen

575
00:34:41,000 --> 00:34:44,000
Ik ga springen naar rij 1, omdat ik zei 1.

576
00:34:44,000 --> 00:34:49,000
>> Dan ga ik om hier te komen naar kolom 2, en ik ga om de waarde te krijgen 6.

577
00:34:49,000 --> 00:34:51,000
Make sense?

578
00:34:51,000 --> 00:34:55,000
Multi-dimensionale arrays, vergeet niet, zijn technisch slechts een array van arrays.

579
00:34:55,000 --> 00:34:57,000
We kunnen arrays van arrays van arrays.

580
00:34:57,000 --> 00:35:00,000
We kunnen blijven gaan, maar echt een manier om na te denken over

581
00:35:00,000 --> 00:35:03,000
hoe dit wordt aangelegd en wat er aan de hand is om te visualiseren dat

582
00:35:03,000 --> 00:35:09,000
in een raster als dit.

583
00:35:09,000 --> 00:35:12,000
Als we arrays om functies passeren, gaan ze zich gedragen

584
00:35:12,000 --> 00:35:16,000
een beetje anders dan wanneer we passeren regelmatig variabelen om functies

585
00:35:16,000 --> 00:35:18,000
zoals het passeren van een int of een float.

586
00:35:18,000 --> 00:35:21,000
Toen we langs in een int of char of een van deze andere soorten gegevens

587
00:35:21,000 --> 00:35:24,000
we namen een kijkje op als de functie wijzigt

588
00:35:24,000 --> 00:35:28,000
de waarde van die variabele die verandering is niet van plan om zich te verspreiden naar boven

589
00:35:28,000 --> 00:35:32,000
naar de aanroepfunctie.

590
00:35:32,000 --> 00:35:35,000
Met een array, daarentegen, zal gebeuren.

591
00:35:35,000 --> 00:35:39,000
Als ik pas in een array een functie en die functie tot enkele van de elementen,

592
00:35:39,000 --> 00:35:43,000
wanneer ik een back-up naar de functie die het genoemd

593
00:35:43,000 --> 00:35:47,000
mijn array gaat nu om anders te zijn, en de woordenschat van die

594
00:35:47,000 --> 00:35:50,000
is arrays worden doorgegeven door middel van verwijzing, zoals we later zullen zien.

595
00:35:50,000 --> 00:35:53,000
Dit is gerelateerd aan hoe pointers werken, waar deze fundamentele data types,

596
00:35:53,000 --> 00:35:55,000
Anderzijds zijn waarde doorgegeven.

597
00:35:55,000 --> 00:35:59,000
>> We kunnen denken aan dat als het maken van een kopie van een aantal variabele en vervolgens passeren in de kopie.

598
00:35:59,000 --> 00:36:01,000
Het maakt niet uit wat we doen met die variabele.

599
00:36:01,000 --> 00:36:06,000
De aanroepende functie zal niet van bewust dat het werd veranderd.

600
00:36:06,000 --> 00:36:10,000
Arrays zijn net een beetje anders in dat opzicht.

601
00:36:10,000 --> 00:36:13,000
Bijvoorbeeld, zoals we net zagen, de belangrijkste is gewoon een functie

602
00:36:13,000 --> 00:36:15,000
dat kan in 2 argumenten.

603
00:36:15,000 --> 00:36:20,000
Het eerste argument van de belangrijkste functie is argc, of het aantal argumenten,

604
00:36:20,000 --> 00:36:23,000
en het tweede argument wordt genoemd argv,

605
00:36:23,000 --> 00:36:27,000
en dat zijn de werkelijke waarden van deze argumenten.

606
00:36:27,000 --> 00:36:30,000
Laten we zeggen dat ik een programma genaamd this.c,

607
00:36:30,000 --> 00:36:34,000
en ik zeg maken dit, en ik ga deze draaien op de opdrachtregel.

608
00:36:34,000 --> 00:36:38,000
Nu in een aantal argumenten door te geven aan mijn programma noemde dit,

609
00:36:38,000 --> 00:36:42,000
Ik zou zoiets als zeggen. / Dit is cs 50.

610
00:36:42,000 --> 00:36:45,000
Dit is wat we ons voorstellen David te doen elke dag op de terminal.

611
00:36:45,000 --> 00:36:48,000
Maar nu de belangrijkste functie binnenkant van dat programma

612
00:36:48,000 --> 00:36:52,000
heeft deze waarden, dus argc is 4.

613
00:36:52,000 --> 00:36:56,000
Het is misschien een beetje verwarrend, want eigenlijk zijn we slechts terloops in is cs 50.

614
00:36:56,000 --> 00:36:58,000
Dat is slechts 3.

615
00:36:58,000 --> 00:37:02,000
Maar vergeet niet dat het eerste element van argv of het eerste argument

616
00:37:02,000 --> 00:37:05,000
is de naam van de functie zelf.

617
00:37:05,000 --> 00:37:07,190
Dus dat betekent dat we 4 dingen hier hebben,

618
00:37:07,190 --> 00:37:10,530
en het eerste element zal worden. / dit.

619
00:37:10,530 --> 00:37:12,970
En wordt dit weergegeven als een string.

620
00:37:12,970 --> 00:37:18,590
Vervolgens de resterende elementen zijn wat we getypt na de naam van het programma.

621
00:37:18,590 --> 00:37:22,720
Dus net als een terzijde, want we waarschijnlijk zagen in PSET 2,

622
00:37:22,720 --> 00:37:28,780
vergeet niet dat de snaar 50 wordt het gehele getal 50 ≠.

623
00:37:28,780 --> 00:37:32,520
Dus we kunnen niet iets zeggen als, 'int x = argv 3.'

624
00:37:32,520 --> 00:37:36,470
>> Dat is gewoon niet zinvol, want dit is een string, en dit is een geheel getal.

625
00:37:36,470 --> 00:37:38,510
Dus als je wilt converteren tussen de 2, vergeet niet, we gaan

626
00:37:38,510 --> 00:37:40,810
hebben deze magische functie genaamd atoi.

627
00:37:40,810 --> 00:37:46,270
Dat neemt een string en geeft het geheel getal vertegenwoordigde binnenkant van die string.

628
00:37:46,270 --> 00:37:48,360
Dus dat is een makkelijk fout te maken op de quiz,

629
00:37:48,360 --> 00:37:51,590
net te denken dat dit automatisch zal zijn van het juiste type.

630
00:37:51,590 --> 00:37:53,860
Maar weet alleen dat deze altijd zal zijn strings

631
00:37:53,860 --> 00:38:00,920
zelfs indien de string alleen een geheel getal of een teken of een float.

632
00:38:00,920 --> 00:38:03,380
Dus nu laten we praten over lopende tijd.

633
00:38:03,380 --> 00:38:06,700
Als we al deze algoritmen die al deze gekke dingen te doen,

634
00:38:06,700 --> 00:38:11,580
wordt het pas echt nuttig om de vraag te stellen: "Hoe lang duren ze? '

635
00:38:11,580 --> 00:38:15,500
Wij vertegenwoordigen dat met iets genaamd asymptotische notatie.

636
00:38:15,500 --> 00:38:18,430
Dus dit betekent dat - nou ja, laten we zeggen dat we geven ons algoritme

637
00:38:18,430 --> 00:38:20,840
sommige echt, echt, echt grote ingang.

638
00:38:20,840 --> 00:38:23,840
We willen de vraag stellen: "Hoe lang gaat dat duren?

639
00:38:23,840 --> 00:38:26,370
Hoeveel stappen duurt het ons algoritme te lopen

640
00:38:26,370 --> 00:38:29,980
als functie van de grootte van de input? "

641
00:38:29,980 --> 00:38:33,080
Dus de eerste manier waarop we kunnen draaien tijd te beschrijven is met grote O.

642
00:38:33,080 --> 00:38:35,380
En dit is onze worst-case nalooptijd.

643
00:38:35,380 --> 00:38:38,590
Dus als we een array wilt sorteren, en we geven ons algoritme een reeks

644
00:38:38,590 --> 00:38:41,000
dat is, in dalende volgorde als het zou moeten zijn in oplopende volgorde,

645
00:38:41,000 --> 00:38:43,130
dat gaat het ergste geval te zijn.

646
00:38:43,130 --> 00:38:49,800
Dit is onze bovengrens in de maximale lengte van de tijd ons algoritme zal nemen.

647
00:38:49,800 --> 00:38:54,740
Anderzijds bevindt het Ω gaat best-case looptijd beschrijven.

648
00:38:54,740 --> 00:38:58,210
Dus als we een reeds gesorteerde array naar een sorteer-algoritme,

649
00:38:58,210 --> 00:39:00,940
hoe lang zal het duren om het te sorteren?

650
00:39:00,940 --> 00:39:06,610
En dit dan beschrijft een ondergrens op looptijd.

651
00:39:06,610 --> 00:39:10,980
Dus hier zijn slechts enkele woorden die een aantal gemeenschappelijke looptijden te beschrijven.

652
00:39:10,980 --> 00:39:13,120
Deze zijn in oplopende volgorde.

653
00:39:13,120 --> 00:39:16,060
De snelste looptijd hebben we heet constant.

654
00:39:16,060 --> 00:39:19,800
>> Dat betekent dat ongeacht hoeveel elementen die we ons algoritme te geven,

655
00:39:19,800 --> 00:39:22,280
het maakt niet uit hoe groot ons aanbod is, het sorteren hiervan

656
00:39:22,280 --> 00:39:26,510
of doen wat we doen om de array zal altijd de dezelfde hoeveelheid tijd.

657
00:39:26,510 --> 00:39:30,270
Dus kan vertegenwoordigen dat alleen een 1, welke een constante.

658
00:39:30,270 --> 00:39:32,410
We hebben ook gekeken naar logaritmische runtime.

659
00:39:32,410 --> 00:39:34,800
Dus iets als binair zoeken is logaritmisch,

660
00:39:34,800 --> 00:39:37,140
waar we snijden het probleem in de helft elke keer

661
00:39:37,140 --> 00:39:40,970
en dan dingen gewoon hoger te komen van daar.

662
00:39:40,970 --> 00:39:43,580
En als je ooit het schrijven van een O van een faculteit algoritme,

663
00:39:43,580 --> 00:39:47,850
je waarschijnlijk niet overwegen dit als uw dagelijkse werk.

664
00:39:47,850 --> 00:39:53,910
Wanneer we looptijden vergelijken is het belangrijk om in gedachten te houden deze dingen.

665
00:39:53,910 --> 00:39:57,760
Dus als ik een algoritme dat is O (n), en iemand anders

666
00:39:57,760 --> 00:40:03,590
heeft een algoritme O (2n) bestaat eigenlijk asymptotisch equivalent.

667
00:40:03,590 --> 00:40:06,590
Dus als we voorstellen dat n een groot getal als eleventy miljard:

668
00:40:06,590 --> 00:40:13,090
dus als we het vergelijken eleventy miljard naar iets als eleventy miljard + 3,

669
00:40:13,090 --> 00:40:17,640
plotseling dat +3 niet echt meer een groot verschil maken.

670
00:40:17,640 --> 00:40:20,980
Daarom gaan we gaan nadenken over deze dingen gelijkwaardig te zijn.

671
00:40:20,980 --> 00:40:24,220
Dus dingen zoals deze constanten hier, er is 2 x dit, of het toevoegen van een 3,

672
00:40:24,220 --> 00:40:27,180
dit zijn slechts constanten en deze gaan dalen up.

673
00:40:27,180 --> 00:40:32,480
Dus dat is waarom al 3 van deze run tijden zijn hetzelfde als zeggen dat ze O (n).

674
00:40:32,480 --> 00:40:37,490
Evenzo, als we 2 andere looptijden, laten we zeggen dat O (n ³ + 2n ²), we kunnen toevoegen

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, en dan hebben we nog een run time dat is slechts O (n ³).

676
00:40:42,070 --> 00:40:46,290
Ook dit zijn hetzelfde omdat deze - dit zijn niet hetzelfde.

677
00:40:46,290 --> 00:40:49,840
Dit zijn dezelfde dingen, sorry. Dus deze hetzelfde omdat

678
00:40:49,840 --> 00:40:53,090
deze n ³ gaat deze 2n ² domineren.

679
00:40:53,090 --> 00:40:59,130
>> Wat is niet hetzelfde is als we geen tijden als O (n ³) en O (n ²)

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

681
00:41:02,820 --> 00:41:05,470
Dus als we exponenten, plotseling begint dit belangrijk voor,

682
00:41:05,470 --> 00:41:08,280
maar als we alleen te maken met factoren als wij zijn hier,

683
00:41:08,280 --> 00:41:12,810
dan is het niet van plan om toe omdat ze gewoon uit te vallen.

684
00:41:12,810 --> 00:41:16,760
Laten we eens een kijkje nemen op enkele van de algoritmen die we tot nu toe hebben gezien

685
00:41:16,760 --> 00:41:19,260
en praten over hun looptijd.

686
00:41:19,260 --> 00:41:23,850
De eerste manier van kijken naar een getal in een lijst, die we zagen, was lineair zoeken.

687
00:41:23,850 --> 00:41:26,950
En de implementatie van lineair zoeken is super eenvoudig.

688
00:41:26,950 --> 00:41:30,490
We hebben een lijst, en we gaan op elk afzonderlijk element kijken in de lijst

689
00:41:30,490 --> 00:41:34,260
totdat we het getal dat we op zoek zijn.

690
00:41:34,260 --> 00:41:38,370
Dat betekent dat in het slechtste geval O (n).

691
00:41:38,370 --> 00:41:40,860
En het ergste geval kan hier als het element

692
00:41:40,860 --> 00:41:45,710
het laatste element, vervolgens met behulp van lineair zoeken we kijken naar elk element

693
00:41:45,710 --> 00:41:50,180
tot we bij de laatste om te weten dat het eigenlijk in de lijst.

694
00:41:50,180 --> 00:41:52,910
We kunnen gewoon niet halverwege opgeven en zeggen: "Het is waarschijnlijk niet daar."

695
00:41:52,910 --> 00:41:55,980
Met lineair zoeken moeten we kijken naar de hele zaak.

696
00:41:55,980 --> 00:41:59,090
De best-case nalooptijd, daarentegen, is constant

697
00:41:59,090 --> 00:42:04,200
want in het beste geval het element die we zoeken is slechts de eerste in de lijst.

698
00:42:04,200 --> 00:42:08,930
Dus het gaat duren ons precies 1 stap, maakt niet uit hoe groot de lijst is

699
00:42:08,930 --> 00:42:12,140
als we op zoek naar het eerste element elke keer.

700
00:42:12,140 --> 00:42:15,390
>> Dus wanneer u zoekt, vergeet niet, is het niet nodig dat onze lijst worden gesorteerd.

701
00:42:15,390 --> 00:42:19,430
Omdat we gewoon gaan om te kijken over elk element, en het maakt eigenlijk niet uit

702
00:42:19,430 --> 00:42:23,560
welke volgorde deze elementen zijn binnen

703
00:42:23,560 --> 00:42:28,110
Een intelligenter zoekalgoritme is zoiets als binaire zoekopdracht.

704
00:42:28,110 --> 00:42:31,500
Vergeet niet dat de uitvoering van binair zoeken is wanneer je gaat

705
00:42:31,500 --> 00:42:34,320
blijven kijken het midden van de lijst.

706
00:42:34,320 --> 00:42:38,000
En omdat we kijken naar het midden, wij eisen dat de lijst is gesorteerd

707
00:42:38,000 --> 00:42:40,580
of anders weten we niet waar het midden is, en we hebben om te kijken over

708
00:42:40,580 --> 00:42:44,480
de hele lijst om het te vinden, en dan op dat moment zijn we gewoon tijd te verspillen.

709
00:42:44,480 --> 00:42:48,480
Dus als we een gesorteerde lijst en we vinden het midden, we gaan naar het midden te vergelijken

710
00:42:48,480 --> 00:42:51,590
om het element dat we op zoek zijn.

711
00:42:51,590 --> 00:42:54,640
Als het te hoog is, dan kunnen we vergeten de rechter helft

712
00:42:54,640 --> 00:42:57,810
omdat we weten dat als ons element is al te hoog

713
00:42:57,810 --> 00:43:01,080
en alles rechts van dit element nog hoger,

714
00:43:01,080 --> 00:43:02,760
dan hebben we niet nodig om er niet meer te kijken.

715
00:43:02,760 --> 00:43:05,430
Wanneer aan de andere kant, als onze element te laag is,

716
00:43:05,430 --> 00:43:08,700
we weten dat alles aan de linkerkant van dat element is ook te laag is,

717
00:43:08,700 --> 00:43:11,390
dus het maakt niet echt zin om daar te kijken, ook niet.

718
00:43:11,390 --> 00:43:15,760
Op deze manier, met elke stap en elke keer als we kijken naar het midden van de lijst,

719
00:43:15,760 --> 00:43:19,060
we gaan ons probleem gehalveerd omdat we ineens weten

720
00:43:19,060 --> 00:43:23,040
een hele hoop nummers die niet kan worden degene die we zoeken.

721
00:43:23,040 --> 00:43:26,950
>> In pseudocode zou dit er als volgt uitzien,

722
00:43:26,950 --> 00:43:30,990
en omdat we het snijden van de lijst in de helft elke keer,

723
00:43:30,990 --> 00:43:34,920
onze worst-case run time springt van lineair naar logaritmisch.

724
00:43:34,920 --> 00:43:39,260
Zo plotseling hebben we log-in stappen om een ​​element in een lijst te vinden.

725
00:43:39,260 --> 00:43:42,460
De beste geval looptijd, is echter nog steeds een constante

726
00:43:42,460 --> 00:43:45,180
want nu, laten we gewoon zeggen dat het element we zoeken is

727
00:43:45,180 --> 00:43:48,380
altijd het exacte midden van de oorspronkelijke lijst.

728
00:43:48,380 --> 00:43:52,080
Dus we kunnen groeien onze lijst zo groot als we willen, maar als het element die we zoeken is in het midden,

729
00:43:52,080 --> 00:43:54,910
dan is het alleen maar om ons 1 stap.

730
00:43:54,910 --> 00:44:00,920
Dus dat is waarom we O (log n) en Ω (1) of constant.

731
00:44:00,920 --> 00:44:04,510
Laten we eigenlijk binair zoeken op deze lijst uit te voeren.

732
00:44:04,510 --> 00:44:08,020
Dus laten we zeggen dat we zijn op zoek naar het element 164.

733
00:44:08,020 --> 00:44:11,650
Het eerste wat we gaan doen is het vinden het middelpunt van deze lijst.

734
00:44:11,650 --> 00:44:15,060
Het is gewoon zo gebeurt het dat het midden gaat in vallen tussen deze 2 nummers,

735
00:44:15,060 --> 00:44:18,960
dus laten we gewoon willekeurig zeggen, elke keer als het middelpunt valt tussen 2 nummers,

736
00:44:18,960 --> 00:44:21,150
laten we gewoon naar boven afronden.

737
00:44:21,150 --> 00:44:24,330
We moeten alleen zorgen dat we dit doen bij elke stap van de weg.

738
00:44:24,330 --> 00:44:29,040
Dus we gaan naar boven afgerond en we gaan om te zeggen dat 161 is het midden van onze lijst.

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

740
00:44:34,640 --> 00:44:39,120
is ook <164, dus we weten dat het niet gaat om ons te helpen op alle

741
00:44:39,120 --> 00:44:42,690
op zoek gaan naar hier omdat het element die we zoeken kan er niet zijn.

742
00:44:42,690 --> 00:44:47,060
Dus wat we kunnen doen is kunnen we gewoon vergeten dat hele linkerhelft van de lijst,

743
00:44:47,060 --> 00:44:51,700
en nu alleen naar het recht van de 161 verder.

744
00:44:51,700 --> 00:44:54,050
>> Dus nogmaals, dit is het middelpunt; laten we gewoon naar boven afronden.

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

746
00:44:56,260 --> 00:44:59,180
Dus we weten dat het niet gaat om ons te helpen op zoek hier of hier,

747
00:44:59,180 --> 00:45:06,610
dus we kunnen gooien dat weg, en uiteindelijk zullen we raken de 164.

748
00:45:06,610 --> 00:45:10,560
Eventuele vragen over binary search?

749
00:45:10,560 --> 00:45:14,180
Laten we verder gaan van het zoeken door middel van een reeds gesorteerde lijst

750
00:45:14,180 --> 00:45:17,660
om daadwerkelijk het nemen van een lijst met nummers in een willekeurige volgorde

751
00:45:17,660 --> 00:45:20,960
en het maken van die lijst in oplopende volgorde.

752
00:45:20,960 --> 00:45:24,060
Het eerste algoritme hebben we gekeken naar heette bubble sort.

753
00:45:24,060 --> 00:45:27,300
En dit zou eenvoudiger zijn van de algoritmen die we zagen.

754
00:45:27,300 --> 00:45:32,970
Bubble sort zegt dat wanneer een 2 elementen in de lijst zijn niet op zijn plaats,

755
00:45:32,970 --> 00:45:36,500
betekent dat er een groter aantal links van een kleiner aantal,

756
00:45:36,500 --> 00:45:40,190
dan gaan we om ze te verwisselen, want dat betekent dat de lijst zal zijn

757
00:45:40,190 --> 00:45:42,860
"Meer gesorteerd" dan voorheen.

758
00:45:42,860 --> 00:45:45,180
En we gaan gewoon om dit proces weer voort te zetten en opnieuw en opnieuw

759
00:45:45,180 --> 00:45:52,100
totdat uiteindelijk de elementen soort zeepbel op hun juiste plaats en we hebben een gesorteerde lijst.

760
00:45:52,100 --> 00:45:57,230
>> De looptijd van deze gaat worden O (n ²). Waarom?

761
00:45:57,230 --> 00:46:00,370
Wel, omdat in het ergste geval, we gaan elk element te nemen, en

762
00:46:00,370 --> 00:46:04,570
we gaan uiteindelijk te vergelijken met ieder ander element in de lijst.

763
00:46:04,570 --> 00:46:08,030
Maar in het beste geval hebben we een reeds gesorteerde lijst, bubble sort's

764
00:46:08,030 --> 00:46:12,230
gewoon om te gaan door een keer te zeggen: "Nee. Ik heb geen swaps te maken, dus ik ben klaar."

765
00:46:12,230 --> 00:46:17,410
Dus hebben we een best-case looptijd van Ω (n).

766
00:46:17,410 --> 00:46:20,680
Laten we bubble sort draaien op een lijst.

767
00:46:20,680 --> 00:46:23,560
Of, laten we gewoon kijken naar een aantal pseudo-code heel snel.

768
00:46:23,560 --> 00:46:28,160
We willen zeggen dat we willen bijhouden, in elke iteratie van de lus,

769
00:46:28,160 --> 00:46:32,190
bijhouden van al dan niet veranderden we alle elementen.

770
00:46:32,190 --> 00:46:37,610
Dus de reden daarvoor is, gaan we stoppen wanneer we nog niet verwisseld alle elementen.

771
00:46:37,610 --> 00:46:41,980
Dus op het begin van onze lus hebben we niet geruild niets, dus we zullen zeggen dat valse is.

772
00:46:41,980 --> 00:46:47,170
Nu, we gaan om te gaan door de lijst en element vergelijken i tot element i + 1

773
00:46:47,170 --> 00:46:50,310
en als het zo is dat er een groter aantal links van een kleiner aantal,

774
00:46:50,310 --> 00:46:52,310
dan kunnen we gaan gewoon om ze te verwisselen.

775
00:46:52,310 --> 00:46:54,490
>> En dan gaan we niet vergeten dat we een element verwisseld.

776
00:46:54,490 --> 00:46:58,900
Dat betekent dat we verder moeten gaan door de lijst in ieder geval nog 1 keer

777
00:46:58,900 --> 00:47:02,160
omdat de toestand waarin we gestopt wanneer de gehele lijst al gesorteerd,

778
00:47:02,160 --> 00:47:04,890
dit betekent dat we hebben geen swaps gemaakt.

779
00:47:04,890 --> 00:47:09,960
Dus dat is de reden waarom onze toestand hier beneden is 'terwijl sommige elementen zijn verwisseld.'

780
00:47:09,960 --> 00:47:13,720
Dus nu laten we gewoon kijken naar deze draait op een lijst.

781
00:47:13,720 --> 00:47:16,640
Ik heb de lijst 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Bubble sort gaat helemaal links beginnen, en het gaat om te vergelijken

783
00:47:19,850 --> 00:47:24,700
het i elementen, dus 0 tot i + 1, dat element 1.

784
00:47:24,700 --> 00:47:29,020
Het gaat om te zeggen, nou 5> 0, maar nu 5 is aan de linkerkant,

785
00:47:29,020 --> 00:47:32,500
dus ik moet de 5 en de 0 te wisselen.

786
00:47:32,500 --> 00:47:35,470
Als ik ze te verwisselen, opeens krijg ik dit andere lijst.

787
00:47:35,470 --> 00:47:38,260
Nu 5> 1, dus we gaan om ze te verwisselen.

788
00:47:38,260 --> 00:47:42,160
5 is niet> 6, dus we hoeven niet te doen hier niets.

789
00:47:42,160 --> 00:47:46,690
Maar 6> 4, dus we moeten wisselen.

790
00:47:46,690 --> 00:47:49,740
Nogmaals, we moeten lopen door de hele lijst om uiteindelijk te ontdekken

791
00:47:49,740 --> 00:47:52,330
dat deze buiten de orde, we ruilen ze,

792
00:47:52,330 --> 00:47:57,120
en op dit punt moeten we lopen door de lijst nog 1 keer

793
00:47:57,120 --> 00:48:05,390
om ervoor te zorgen dat alles in zijn beschikking, en op dit punt bubble sort is voltooid.

794
00:48:05,390 --> 00:48:10,720
Een ander algoritme voor het nemen van een aantal elementen en het sorteren ervan is selectie sorteren.

795
00:48:10,720 --> 00:48:15,740
Het idee achter selection sort is dat we gaan het opbouwen van een gesorteerd deel van de lijst

796
00:48:15,740 --> 00:48:18,150
Een element per keer.

797
00:48:18,150 --> 00:48:23,170
>> En de manier waarop we dat doen is door het opbouwen van het linker segment van de lijst.

798
00:48:23,170 --> 00:48:27,510
En eigenlijk, elke - op elke stap, we gaan naar het kleinste element die we nog hebben te nemen

799
00:48:27,510 --> 00:48:32,310
dat is nog niet gesorteerd, en we gaan om het te verplaatsen in die gesorteerd segment.

800
00:48:32,310 --> 00:48:35,850
Dat betekent dat we moeten voortdurend vinden van de minimale ongesorteerde element

801
00:48:35,850 --> 00:48:40,720
en neem dan dat minimum element en ruilen met wat

802
00:48:40,720 --> 00:48:45,090
meest linkse element dat niet is gesorteerd.

803
00:48:45,090 --> 00:48:50,890
De looptijd van deze gaat worden O (n ²), omdat in het ergste geval

804
00:48:50,890 --> 00:48:55,070
We moeten alle elementen te vergelijken elk ander element.

805
00:48:55,070 --> 00:48:59,250
Omdat we zeggen dat als we beginnen bij de linker helft van de lijst, moeten we

806
00:48:59,250 --> 00:49:02,970
om door de gehele rechter segment het kleinste element vinden.

807
00:49:02,970 --> 00:49:05,430
En dan, nogmaals, we moeten gaan over de gehele rechter segment en

808
00:49:05,430 --> 00:49:08,210
blijven gaan over die over en over en weer.

809
00:49:08,210 --> 00:49:11,350
Dat gaat n ². We gaan een behoefte aan lus binnenkant van een ander for-lus

810
00:49:11,350 --> 00:49:13,350
wat suggereert n ².

811
00:49:13,350 --> 00:49:16,530
In het beste geval denken, laten we zeggen dat we geven het een reeds gesorteerde lijst;

812
00:49:16,530 --> 00:49:19,270
we eigenlijk niet beter dan n ².

813
00:49:19,270 --> 00:49:21,730
Omdat selectie sorteren heeft geen manier om te weten dat

814
00:49:21,730 --> 00:49:25,540
de minimale element is slechts degene die ik toevallig te kijken.

815
00:49:25,540 --> 00:49:28,970
Het moet nog steeds om ervoor te zorgen dat dit eigenlijk het minimum.

816
00:49:28,970 --> 00:49:31,670
>> En de enige manier om ervoor te zorgen dat het de minimale, met behulp van dit algoritme,

817
00:49:31,670 --> 00:49:34,640
is om weer te kijken naar elk element.

818
00:49:34,640 --> 00:49:38,420
Dus echt, als je het - als je selectie sorteren een reeds gesorteerde lijst,

819
00:49:38,420 --> 00:49:42,720
het is niet van plan om beter te doen dan het geven van een lijst die nog niet is gesorteerd.

820
00:49:42,720 --> 00:49:46,320
By the way, als het gebeurt om het geval dat er iets is O (iets)

821
00:49:46,320 --> 00:49:50,640
en de omega van iets, kunnen we alleen maar zeggen meer kort en bondig dat het θ van iets.

822
00:49:50,640 --> 00:49:52,760
Dus als je ziet dat overal komen, dat is wat precies dat betekent.

823
00:49:52,760 --> 00:49:57,580
>> Als er iets is theta van n ², is het zowel grote O (n ²) en Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Zodat je best case en worst case, is het niet een verschil maken,

825
00:49:59,790 --> 00:50:04,400
het algoritme gaat om hetzelfde te doen elke keer.

826
00:50:04,400 --> 00:50:06,610
Dus dit is wat pseudocode voor selectie sorteren eruit zou kunnen zien.

827
00:50:06,610 --> 00:50:10,630
We principe gaan om te zeggen dat ik wil itereren over de lijst

828
00:50:10,630 --> 00:50:15,180
van links naar rechts, en bij elke herhaling van de lus, ik ga verhuizen

829
00:50:15,180 --> 00:50:19,780
de minimale element in deze gesorteerd deel van de lijst.

830
00:50:19,780 --> 00:50:23,260
En als ik daar te bewegen iets, ik heb nooit moeten opnieuw kijken naar dat element.

831
00:50:23,260 --> 00:50:28,600
Want zodra ik een element wisselen in het linker segment van de lijst, het is gesorteerd

832
00:50:28,600 --> 00:50:32,600
want we doen alles wat in oplopende volgorde met behulp van minima.

833
00:50:32,600 --> 00:50:38,740
Dus we zeiden, oke, we zijn op positie i, en we moeten om naar te kijken alle elementen

834
00:50:38,740 --> 00:50:42,260
rechts van i om de minimum vinden.

835
00:50:42,260 --> 00:50:46,150
Dat betekent willen we van i + 1 zien op het einde van de lijst.

836
00:50:46,150 --> 00:50:51,610
En nu, als het element dat we op dit moment op zoek bent naar minder dan het minimale tot nu toe,

837
00:50:51,610 --> 00:50:54,190
die, vergeet niet dat we het starten van de minimum uit om gewoon

838
00:50:54,190 --> 00:50:57,020
wat element zijn we momenteel op, ik ga ervan uit dat is het minimum.

839
00:50:57,020 --> 00:51:00,270
Als ik een element dat is kleiner dan dat, dan ga ik zeggen, oke,

840
00:51:00,270 --> 00:51:02,700
goed, heb ik gevonden een nieuwe minimum.

841
00:51:02,700 --> 00:51:06,080
Ik ga om te onthouden waar dat minimum was.

842
00:51:06,080 --> 00:51:09,560
>> Dus nu, nadat ik heb doorgemaakt dat recht ongesorteerd segment,

843
00:51:09,560 --> 00:51:16,690
Ik kan zeggen dat ik ga tot het minimum element te wisselen met het element dat in staat i.

844
00:51:16,690 --> 00:51:21,100
Dat gaat bouwen mijn lijst, mijn gesorteerd deel van de lijst van links naar rechts,

845
00:51:21,100 --> 00:51:25,190
en we niet ooit opnieuw te kijken naar een element wanneer het eenmaal in dat gedeelte.

846
00:51:25,190 --> 00:51:27,930
Zodra we geruild.

847
00:51:27,930 --> 00:51:30,260
Dus laten we selection sort draaien op deze lijst.

848
00:51:30,260 --> 00:51:38,220
De blauwe element hier gaat de i, en de rode element zal de minimum element.

849
00:51:38,220 --> 00:51:41,570
Dus ik begint helemaal links van de lijst zodat bij 5.

850
00:51:41,570 --> 00:51:44,610
Nu moeten we de minimale ongesorteerde element te vinden.

851
00:51:44,610 --> 00:51:49,480
Dus we zeggen 0 <5, dus 0 is mijn nieuwe minimum.

852
00:51:49,480 --> 00:51:53,820
>> Maar ik kan niet stoppen, want ook al kunnen we herkennen dat 0 is de kleinste,

853
00:51:53,820 --> 00:51:59,390
we moeten doorlopen om de andere elementen van de lijst om er zeker van.

854
00:51:59,390 --> 00:52:01,760
Dus 1 is groter, 6 is groter, 4 is groter.

855
00:52:01,760 --> 00:52:05,850
Dat betekent dat na het bekijken van al deze elementen, die ik heb bepaald 0 is de kleinste.

856
00:52:05,850 --> 00:52:09,800
Dus ik ga naar de 5 en de 0 te wisselen.

857
00:52:09,800 --> 00:52:15,480
Zodra ik dat wisselen, ga ik een nieuwe lijst te krijgen, en ik weet dat ik nooit opnieuw te kijken naar dat 0

858
00:52:15,480 --> 00:52:19,380
want zodra ik heb geruild, ik heb losten het en we zijn klaar.

859
00:52:19,380 --> 00:52:22,730
Nu is het gewoon zo gebeurt het dat de blauwe element weer is het 5,

860
00:52:22,730 --> 00:52:26,030
en we moeten kijken naar de 1, de 6 en de 4 die een vast

861
00:52:26,030 --> 00:52:31,520
is de kleinste minimale element, dus we wisselen de 1 en de 5.

862
00:52:31,520 --> 00:52:36,890
Nogmaals, we moeten kijken naar - vergelijk de 5 naar de 6 en de 4,

863
00:52:36,890 --> 00:52:39,830
en we gaan naar de 4 en de 5 te wisselen, en ten slotte, te vergelijken

864
00:52:39,830 --> 00:52:45,740
die 2 nummers en wisselen ze totdat we onze gesorteerde lijst.

865
00:52:45,740 --> 00:52:49,730
Hebt u vragen over de selectie sorteren?

866
00:52:49,730 --> 00:52:56,420
Oke. Laten we hier naar het laatste onderwerp, en dat is recursie.

867
00:52:56,420 --> 00:52:59,810
>> Recursie, onthoud, is dit echt meta ding waarin een functie

868
00:52:59,810 --> 00:53:02,740
herhaaldelijk noemt zichzelf.

869
00:53:02,740 --> 00:53:05,620
Dus op een gegeven moment, terwijl onze fuction wordt herhaaldelijk die zichzelf,

870
00:53:05,620 --> 00:53:10,100
moet er een bepaald punt waar we stoppen met bellen onszelf.

871
00:53:10,100 --> 00:53:13,670
Want als we dat niet doen, dan zijn we gaan gewoon door te gaan voor altijd doen,

872
00:53:13,670 --> 00:53:16,660
en ons programma is gewoon niet van plan om te beëindigen.

873
00:53:16,660 --> 00:53:19,200
We noemen deze toestand het nulalternatief.

874
00:53:19,200 --> 00:53:22,570
En het nulalternatief zegt, in plaats van het aanroepen van een functie weer,

875
00:53:22,570 --> 00:53:25,330
Ik ga gewoon een bepaalde waarde terug te keren.

876
00:53:25,330 --> 00:53:28,080
Dus zodra we terug een waarde, hebben we gestopt met bellen onszelf,

877
00:53:28,080 --> 00:53:32,550
en de rest van de gesprekken die we tot nu toe gemaakt kunt ook terugkeren.

878
00:53:32,550 --> 00:53:36,050
Het tegenovergestelde van het nulalternatief is de recursieve geval is.

879
00:53:36,050 --> 00:53:39,050
En dit is wanneer we willen nog een oproep te doen aan de functie die we op dit moment zijn binnen

880
00:53:39,050 --> 00:53:44,690
En we waarschijnlijk, hoewel niet altijd, wil je verschillende argumenten te gebruiken.

881
00:53:44,690 --> 00:53:48,940
>> Dus als we een functie genaamd f, en f heeft net gebeld neem 1 argument,

882
00:53:48,940 --> 00:53:52,010
en we blijven noemen f (1), f (1), f (1), en het gewoon zo gebeurt het dat

883
00:53:52,010 --> 00:53:56,510
het argument 1 valt in recursieve geval zijn we nog steeds niet van plan te stoppen.

884
00:53:56,510 --> 00:54:01,620
Zelfs als we een basisscenario, moeten we ervoor zorgen dat we uiteindelijk gaan dat base case te raken.

885
00:54:01,620 --> 00:54:04,250
We hebben niet alleen te houden een verblijf in deze recursieve geval.

886
00:54:04,250 --> 00:54:09,870
Over het algemeen, als we onszelf noemen, we waarschijnlijk gaan om een ​​ander argument hebben elke keer.

887
00:54:09,870 --> 00:54:12,700
Hier is een heel eenvoudige recursieve functie.

888
00:54:12,700 --> 00:54:15,090
Dus berekent de faculteit van een getal.

889
00:54:15,090 --> 00:54:17,790
Up Top hier hebben we ons basisscenario.

890
00:54:17,790 --> 00:54:22,330
In het geval dat n ≤ 1, we niet nog een keer te bellen faculteit.

891
00:54:22,330 --> 00:54:26,490
We gaan om te stoppen, we gaan gewoon naar een bepaalde waarde terug te keren.

892
00:54:26,490 --> 00:54:30,170
Als dit niet waar is, dan gaan we onze recursieve geval geraakt.

893
00:54:30,170 --> 00:54:33,550
Let hier op dat we niet alleen maar bellen faculteit (n), want dat zou niet erg behulpzaam.

894
00:54:33,550 --> 00:54:36,810
We gaan noemen faculteit van iets anders.

895
00:54:36,810 --> 00:54:40,850
>> En zodat u kunt zien, uiteindelijk als we een faculteit (5) of iets voorbij,

896
00:54:40,850 --> 00:54:45,900
we gaan bellen faculteit (4) en ga zo maar door, en uiteindelijk gaan we dit referentiemodel te raken.

897
00:54:45,900 --> 00:54:51,730
Dus dit ziet er goed uit. Laten we eens kijken wat er gebeurt als we daadwerkelijk uitvoeren van deze.

898
00:54:51,730 --> 00:54:57,840
Dit is de stapel, en laten we zeggen dat de belangrijkste zal deze functie aan te roepen met een argument (4).

899
00:54:57,840 --> 00:55:02,200
Dus zodra faculteit ziet en = 4, factorieel belt zelf.

900
00:55:02,200 --> 00:55:05,010
Nu, plotseling, we hebben factorial (3).

901
00:55:05,010 --> 00:55:10,780
Dus deze functies zullen blijven groeien totdat uiteindelijk raken we ons basisscenario.

902
00:55:10,780 --> 00:55:17,830
Op dit punt, de return waarde van deze is de terugkeer (nx de return waarde van deze),

903
00:55:17,830 --> 00:55:21,290
de return waarde hiervan is nx de return waarde van deze.

904
00:55:21,290 --> 00:55:23,290
Uiteindelijk moeten we een getal te raken.

905
00:55:23,290 --> 00:55:26,560
Op de top hier, zeggen we terug 1.

906
00:55:26,560 --> 00:55:30,650
Dat betekent dat als we eenmaal terug dat aantal kunnen we knallen dit uit de stapel.

907
00:55:30,650 --> 00:55:36,570
Dus factorial (1) wordt gedaan.

908
00:55:36,570 --> 00:55:41,190
Bij een rendement, dit faculteit (1) retourneert, deze terugkeer naar 1.

909
00:55:41,190 --> 00:55:46,910
De return waarde van deze, onthoud, was nx de return waarde van deze.

910
00:55:46,910 --> 00:55:50,720
Zo plotseling, deze man weet dat ik wil 2 terug te keren.

911
00:55:50,720 --> 00:55:55,910
>> Dus onthoud, return waarde van dit is gewoon nx de return waarde hier boven.

912
00:55:55,910 --> 00:56:01,160
Dus nu kunnen we zeggen 3 x 2, en tot slot, hier kunnen we zeggen

913
00:56:01,160 --> 00:56:04,010
dit is gewoon gaat worden 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
En zodra dit weer, we aan de slag om een ​​enkel geheel getal binnenkant van de belangrijkste.

915
00:56:09,570 --> 00:56:15,460
Eventuele vragen over recursie?

916
00:56:15,460 --> 00:56:17,090
Oke. Dus er is meer tijd voor vragen aan het eind,

917
00:56:17,090 --> 00:56:23,360
maar nu Jozef zal betrekking hebben op de resterende onderwerpen.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] Oke. Dus nu hebben we gesproken over recursies,

919
00:56:25,590 --> 00:56:27,840
Laten we een beetje praten over wat samenvoegen soort is.

920
00:56:27,840 --> 00:56:31,740
Samenvoegen soort is in feite een andere manier van het sorteren van een lijst met getallen.

921
00:56:31,740 --> 00:56:36,430
En hoe het werkt is, met merge sort heb je een lijst, en wat we doen is

922
00:56:36,430 --> 00:56:39,120
we zeggen, laten we deze opgesplitst in 2 helften.

923
00:56:39,120 --> 00:56:42,750
We zullen eerst rennen weer samenvoegen sorteren op de linker helft,

924
00:56:42,750 --> 00:56:45,040
dan zullen we lopen samen te voegen sorteren op de rechter helft,

925
00:56:45,040 --> 00:56:50,240
en dat geeft ons nu 2 helften die worden gesorteerd, en nu gaan we combineren deze helften.

926
00:56:50,240 --> 00:56:55,010
Het is een beetje moeilijk te zien zonder een voorbeeld, dus we gaan door de bewegingen en zie wat er gebeurt.

927
00:56:55,010 --> 00:56:59,590
Dus je begint met deze lijst, hebben we het opgesplitst in 2 helften.

928
00:56:59,590 --> 00:57:02,300
We lopen samen te voegen sorteren op de linker helft eerst.

929
00:57:02,300 --> 00:57:06,660
Dus dat is de linker helft, en nu hebben we ze nogmaals uit te voeren door middel van deze lijst

930
00:57:06,660 --> 00:57:09,800
die wordt doorgegeven in merge sort, en dan kijken we, nogmaals,

931
00:57:09,800 --> 00:57:13,270
aan de linkerkant van deze lijst en we lopen samen te voegen sorteren op.

932
00:57:13,270 --> 00:57:15,880
Nu krijgen we tot een lijst met 2 nummers,

933
00:57:15,880 --> 00:57:19,010
en nu de linkerhelft is slechts 1 element lang, en we kunnen niet

934
00:57:19,010 --> 00:57:23,380
splitsen van een lijst die is slechts 1 element in de helft, dus we zeggen, als we 50 hebben,

935
00:57:23,380 --> 00:57:26,400
Dit is slechts 1 element, het is al gesorteerd.

936
00:57:26,400 --> 00:57:29,860
>> Zodra we klaar zijn met dat, kunnen we zien dat we kunnen

937
00:57:29,860 --> 00:57:32,230
overgaan tot de rechter helft van deze lijst,

938
00:57:32,230 --> 00:57:36,480
en 3 wordt ook gesorteerd, en dus nu dat beide helften van deze lijst zijn gesorteerd

939
00:57:36,480 --> 00:57:39,080
we kunnen lid worden van deze nummers weer bij elkaar.

940
00:57:39,080 --> 00:57:45,320
Dus we kijken bij 50 en 3, 3 kleiner dan 50, zo gaat in en vervolgens 50 wordt in

941
00:57:45,320 --> 00:57:49,340
Nu, dat is gedaan, gaan we terug naar die lijst en soort het is rechter helft.

942
00:57:49,340 --> 00:57:52,440
42 is een eigen nummer, dus het is al gesorteerd.

943
00:57:52,440 --> 00:57:57,850
Dus nu vergelijken we deze 2 en 3 is kleiner dan 42, zodat wordt gezet in de eerste,

944
00:57:57,850 --> 00:58:02,340
nu 42 wordt gezet in, en 50 wordt zetten inch

945
00:58:02,340 --> 00:58:07,220
Nu, dat is gesorteerd, gaan we helemaal terug naar de top, 1337 en 15.

946
00:58:07,220 --> 00:58:14,560
Nou, we nu kijken naar de linker helft van deze lijst; 1337 is op zichzelf dus het is gesorteerd en hetzelfde met 15.

947
00:58:14,560 --> 00:58:19,020
Dus nu combineren we deze 2 nummers aan die oorspronkelijke lijst, 15 <1337 te sorteren,

948
00:58:19,020 --> 00:58:23,060
zo gaat het in de eerste, dan is 1337 gaat binnen

949
00:58:23,060 --> 00:58:26,640
En nu hebben we beide helften van de oorspronkelijke lijst gesorteerd boven.

950
00:58:26,640 --> 00:58:30,440
En alles wat we hoeven te doen is combineren.

951
00:58:30,440 --> 00:58:36,890
We kijken naar de eerste 2 nummers van deze lijst, 3 <15, dus het gaat in het soort reeks eerste.

952
00:58:36,890 --> 00:58:44,460
15 <42, dus het gaat inch Nu, 42 <1337, dat gaat binnen

953
00:58:44,460 --> 00:58:51,010
50 <1337, dus het gaat inch En merken dat we slechts 2 nummers nam af van deze lijst.

954
00:58:51,010 --> 00:58:53,640
Dus we zijn niet alleen afwisselend tussen de 2 lijsten.

955
00:58:53,640 --> 00:58:56,050
We zijn gewoon op zoek naar het begin, en we nemen het element

956
00:58:56,050 --> 00:59:00,270
dat is kleiner en dan zetten het in ons aanbod.

957
00:59:00,270 --> 00:59:04,080
Nu hebben we samengevoegd alle helften en we zijn klaar.

958
00:59:04,080 --> 00:59:07,780
>> Heeft u vragen over samenvoegen soort? Ja?

959
00:59:07,780 --> 00:59:14,190
[Student] Als het splitsen in verschillende groepen, waarom ze niet gewoon splitsen keer

960
00:59:14,190 --> 00:59:19,970
en je hebt 3 en 2 in een groep? [Rest van vraag onverstaanbaar]

961
00:59:19,970 --> 00:59:24,940
De reden - dus de vraag is, waarom kunnen we niet gewoon samen te voegen in die eerste stap nadat we ze hebben?

962
00:59:24,940 --> 00:59:29,530
De reden dat we dit kunnen doen, beginnen bij de meest linkse elementen van beide zijden,

963
00:59:29,530 --> 00:59:33,040
en neem dan de kleinere en zet het in, is dat we dat deze weten

964
00:59:33,040 --> 00:59:35,290
individuele lijsten zijn in gesorteerd orders.

965
00:59:35,290 --> 00:59:37,290
Dus als ik ben op zoek naar de meest linkse elementen van beide helften,

966
00:59:37,290 --> 00:59:40,490
Ik weet dat ze gaan de kleinste elementen van die lijsten.

967
00:59:40,490 --> 00:59:43,930
Dus ik kan ze in het kleinste element plekjes van deze grote lijst.

968
00:59:43,930 --> 00:59:47,810
Aan de andere kant, als ik kijk naar deze 2 lijsten in het tweede niveau daar,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 en 15, zijn deze niet gesorteerd.

970
00:59:51,640 --> 00:59:55,770
Dus als ik kijk naar 50 en 1337, ga ik 50 eerste in mijn lijst.

971
00:59:55,770 --> 01:00:00,130
Maar dat betekent niet echt zinvol, want 3 is het kleinste element uit al die.

972
01:00:00,130 --> 01:00:04,390
Dus de enige reden dat we dit kunnen combineren stap te doen is omdat onze lijsten al zijn gesorteerd.

973
01:00:04,390 --> 01:00:07,010
Daarom moeten we naar beneden helemaal tot op de bodem

974
01:00:07,010 --> 01:00:09,800
want als we slechts een enkel nummer hebt, weet je dat een enkel nummer

975
01:00:09,800 --> 01:00:14,120
in en van zichzelf is al een gesorteerde lijst.

976
01:00:14,120 --> 01:00:19,360
>> Nog vragen? Nee?

977
01:00:19,360 --> 01:00:24,260
Complexiteit? Nou, je kunt zien dat bij elke stap is er eind nummers,

978
01:00:24,260 --> 01:00:27,590
en we kunnen verdelen een lijst in de helft log n keer,

979
01:00:27,590 --> 01:00:31,700
dat is waar we dit n x log n complexiteit.

980
01:00:31,700 --> 01:00:34,940
En je zult zien het beste geval voor merge sort is n log n, en het gewoon zo gebeurt

981
01:00:34,940 --> 01:00:39,340
dat de slechtste of de Ω daar, ook n log n.

982
01:00:39,340 --> 01:00:42,480
Iets om in gedachten te houden.

983
01:00:42,480 --> 01:00:45,750
Moving on, laten we verder gaan met een aantal super basic file I / O.

984
01:00:45,750 --> 01:00:48,830
Als je keek naar Scramble, zult u merken dat we hadden een soort van systeem

985
01:00:48,830 --> 01:00:51,270
waar je kon schrijven naar een logbestand als je leest door de code.

986
01:00:51,270 --> 01:00:53,730
Laten we eens kijken hoe je zou kunnen doen.

987
01:00:53,730 --> 01:00:57,450
Nou, we hebben fprintf, die u kunt zien als gewoon printf,

988
01:00:57,450 --> 01:01:01,720
maar slechts afdrukken naar een bestand plaats, en daarmee de f begin.

989
01:01:01,720 --> 01:01:07,570
Dit soort code hier, wat het doet is, zoals je misschien al hebt gezien in Scramble,

990
01:01:07,570 --> 01:01:12,310
gaat het door uw 2-dimensionale array uitprinten rij voor rij wat de nummers zijn.

991
01:01:12,310 --> 01:01:17,850
In dit geval, printf drukt om uw terminal of wat wij noemen de standaard output van een hoofdstuk.

992
01:01:17,850 --> 01:01:22,170
>> En nu, in dit geval, alles wat we moeten doen is het vervangen printf met fprintf,

993
01:01:22,170 --> 01:01:26,770
vertellen wat bestand dat u wilt afdrukken, en in dit geval gewoon print deze aan dat bestand

994
01:01:26,770 --> 01:01:32,230
in plaats van deze af te drukken naar uw terminal.

995
01:01:32,230 --> 01:01:36,500
Nou, dan is dat roept de vraag op: Waar we dit soort bestand te krijgen van, toch?

996
01:01:36,500 --> 01:01:39,840
We passeerden in te loggen om deze fprintf fuction, maar we hadden geen idee waar het vandaan kwam.

997
01:01:39,840 --> 01:01:43,980
Nou, in het begin van de code, wat we hadden was dit stuk code hier,

998
01:01:43,980 --> 01:01:48,340
die in feite zegt dat open het bestand log.txt noemt.

999
01:01:48,340 --> 01:01:53,220
Wat wij doen na dat is dat we ervoor moeten zorgen dat het bestand daadwerkelijk succesvol geopend.

1000
01:01:53,220 --> 01:01:57,070
Dus het kan mislukken om verschillende redenen, je niet genoeg ruimte hebt op je computer, bijvoorbeeld.

1001
01:01:57,070 --> 01:01:59,790
Dus het is altijd belangrijk voordat u eventuele werkzaamheden met het bestand

1002
01:01:59,790 --> 01:02:03,300
dat we controleren of dat bestand met succes is geopend.

1003
01:02:03,300 --> 01:02:09,330
Dus wat dat een, dat is een argument om fopen, nou ja, kunnen we een bestand openen op vele manieren.

1004
01:02:09,330 --> 01:02:13,510
Wat we wel kunnen is doen, kunnen we doorgeven w, wat betekent overschrijven het bestand als het reeds verlaat,

1005
01:02:13,510 --> 01:02:18,070
We kunnen passeren een a, die zij toevoegen aan het einde van het bestand in plaats van het dwingende,

1006
01:02:18,070 --> 01:02:22,730
of we kunnen specificeren r, dat wil zeggen, laten we het bestand openen als alleen-lezen.

1007
01:02:22,730 --> 01:02:24,890
Dus als het programma probeert om eventuele wijzigingen aan te brengen in het bestand,

1008
01:02:24,890 --> 01:02:30,140
schreeuwen tegen hen en laat ze niet doen.

1009
01:02:30,140 --> 01:02:33,320
Ten slotte, wanneer we klaar zijn met het bestand, klaar mee operaties op het,

1010
01:02:33,320 --> 01:02:35,860
moeten we ervoor zorgen dat we het bestand sluiten.

1011
01:02:35,860 --> 01:02:38,830
En dus aan het eind van uw programma, ga je weer doorgeven

1012
01:02:38,830 --> 01:02:42,120
dit bestand die u hebt geopend, en gewoon sluiten.

1013
01:02:42,120 --> 01:02:44,650
Dus dit is iets belangrijks dat je moet zorgen dat je doet.

1014
01:02:44,650 --> 01:02:47,180
Dus onthoud u een bestand kunt openen, dan kunt u schrijven naar het bestand,

1015
01:02:47,180 --> 01:02:51,270
doen operaties in het bestand, maar dan moet je het bestand te sluiten aan het eind.

1016
01:02:51,270 --> 01:02:53,270
>> Hebt u vragen over fundamentele file I / O? Ja?

1017
01:02:53,270 --> 01:02:58,050
[Student vraag, onverstaanbaar]

1018
01:02:58,050 --> 01:03:02,480
Precies hier. De vraag is, betekent dit log.txt bestand verschijnen waar?

1019
01:03:02,480 --> 01:03:07,890
Nou, als je gewoon geven log.txt, creëert het in dezelfde map als het uitvoerbare bestand.

1020
01:03:07,890 --> 01:03:10,500
Dus als je bent - >> [Student vraag, onverstaanbaar]

1021
01:03:10,500 --> 01:03:18,830
Ja. In dezelfde map, of in dezelfde directory, zoals jij dat noemt.

1022
01:03:18,830 --> 01:03:21,400
Nu geheugen, stack en heap.

1023
01:03:21,400 --> 01:03:23,400
Dus hoe is het geheugen vastgelegd in de computer?

1024
01:03:23,400 --> 01:03:26,270
Nou, kun je je voorstellen als een soort geheugen van dit blok hier.

1025
01:03:26,270 --> 01:03:30,260
En in het geheugen hebben we wat de hoop vast daar, en de stapel dat is daar beneden geroepen.

1026
01:03:30,260 --> 01:03:34,480
En de heap groeit naar beneden en de stapel omhoog groeit.

1027
01:03:34,480 --> 01:03:38,620
Dus als Tommy genoemd - oh, goed, en we hebben die andere 4 segmenten die ik zal krijgen in een tweede -

1028
01:03:38,620 --> 01:03:42,890
Zoals Tommy al eerder zei, je weet hoe zijn functies noemen zichzelf en elkaar bellen?

1029
01:03:42,890 --> 01:03:44,930
Ze bouwen dit soort stack frame.

1030
01:03:44,930 --> 01:03:47,360
Nou, als de belangrijkste oproepen foo, foo wordt op de stapel gelegd.

1031
01:03:47,360 --> 01:03:52,430
Foo noemt, bar krijgen de op de stapel gelegd, en dat wordt op de stapel gelegd na.

1032
01:03:52,430 --> 01:03:57,040
En als ze terugkeren, ze krijgen elk genomen uit de stapel.

1033
01:03:57,040 --> 01:04:00,140
Wat moet elk van deze locaties en het geheugen te houden?

1034
01:04:00,140 --> 01:04:03,110
En de top, welke de tekst segment bevat het programma zelf.

1035
01:04:03,110 --> 01:04:06,390
Dus de machine code, dat er, zodra het samenstellen van je programma.

1036
01:04:06,390 --> 01:04:08,520
Vervolgens alle globale variabelen geïnitialiseerd.

1037
01:04:08,520 --> 01:04:12,660
>> Dus je hebt globale variabelen in je programma, en je zegt als, a = 5,

1038
01:04:12,660 --> 01:04:15,260
die wordt gezet in dat segment, en rechts onder dat,

1039
01:04:15,260 --> 01:04:18,990
u nog niet geïnitialiseerde gegevens opslaat, die net is int a,

1040
01:04:18,990 --> 01:04:20,990
maar je hoeft niet zeggen dat het gelijk is aan wat dan ook.

1041
01:04:20,990 --> 01:04:23,870
Realiseer dit zijn globale variabelen, zodat ze buiten de belangrijkste.

1042
01:04:23,870 --> 01:04:28,560
Dus dit betekent dat elke globale variabelen die worden gedeclareerd maar niet geïnitialiseerd.

1043
01:04:28,560 --> 01:04:32,310
Dus wat er in de hoop? Geheugen toegewezen met behulp van malloc, die we zullen krijgen in een beetje.

1044
01:04:32,310 --> 01:04:35,990
En ten slotte, met de stapel u lokale variabelen

1045
01:04:35,990 --> 01:04:39,950
en alle functies die u zou kunnen noemen in een van hun parameters.

1046
01:04:39,950 --> 01:04:43,720
Het laatste wat, hoef je niet echt te weten wat de omgevingsvariabelen te doen,

1047
01:04:43,720 --> 01:04:46,700
maar wanneer je programma uit te voeren, er is geassocieerd iets, zoals

1048
01:04:46,700 --> 01:04:49,550
dit is de gebruikersnaam van de persoon die liep van het programma.

1049
01:04:49,550 --> 01:04:51,550
En dat gaat om een ​​soort van op de bodem.

1050
01:04:51,550 --> 01:04:54,540
In termen van het geheugen-adressen, die zijn hexadecimale waarden,

1051
01:04:54,540 --> 01:04:58,170
de waarden aan de top beginnen bij 0, en ze gaan helemaal naar beneden naar de bodem.

1052
01:04:58,170 --> 01:05:00,440
In dit geval, als je op de 32-bits systeem,

1053
01:05:00,440 --> 01:05:05,390
het adres aan de onderkant gaat worden 0x, gevolgd door af, want dat is 32 bits,

1054
01:05:05,390 --> 01:05:10,890
dat 8 bytes, en in dit geval 8 bytes overeenkomt met 8 hexadecimale cijfers.

1055
01:05:10,890 --> 01:05:20,110
Dus hier beneden je gaat te hebben, zoals, 0xFFFFFF, en daar zul je 0.

1056
01:05:20,110 --> 01:05:23,660
Dus wat zijn pointers? Sommigen van u kunnen niet hebben behandeld in de rubriek voor.

1057
01:05:23,660 --> 01:05:26,660
maar we hebben er overheen te gaan in college, dus een pointer is gewoon een gegevenstype

1058
01:05:26,660 --> 01:05:34,030
welke winkels, in plaats van een soort van waarde zoals 50, dan het adres van een locatie in het geheugen worden opgeslagen.

1059
01:05:34,030 --> 01:05:36,020
Net als dat het geheugen [onverstaanbaar].

1060
01:05:36,020 --> 01:05:41,120
Dus in dit geval, wat wij hebben is, hebben we een pointer naar een integer of een int *,

1061
01:05:41,120 --> 01:05:46,210
en het bevat dit hexadecimale adres van 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Dus wat we hebben is, nu, deze pointer wijst naar een locatie in het geheugen,

1063
01:05:50,880 --> 01:05:56,020
en dat is nog maar een, de waarde 50 is op dit geheugenlocatie.

1064
01:05:56,020 --> 01:06:01,810
Op sommige 32-bits systemen, op alle 32-bits systemen, pointers nemen 32 bits of 4 bytes.

1065
01:06:01,810 --> 01:06:06,020
Maar bijvoorbeeld op een 64-bits systeem pointers zijn 64 bits.

1066
01:06:06,020 --> 01:06:08,040
Dus dat is iets wat je wilt in gedachten te houden.

1067
01:06:08,040 --> 01:06:12,310
Dus op een eind-bits systeem, een pointer is eind bits lang.

1068
01:06:12,310 --> 01:06:17,320
Pointers zijn een soort van moeilijk te verteren zonder extra dingen,

1069
01:06:17,320 --> 01:06:20,300
dus laten we gaan door een voorbeeld van dynamisch geheugen toewijzing.

1070
01:06:20,300 --> 01:06:25,130
Wat dynamisch geheugen toewijzing voor je doet, of wat wij noemen malloc,

1071
01:06:25,130 --> 01:06:29,280
het laat je toe te wijzen een soort van gegevens buiten de set.

1072
01:06:29,280 --> 01:06:31,830
Zodat deze gegevens soort meer permanent voor de duur van het programma.

1073
01:06:31,830 --> 01:06:36,430
Want zoals u weet, als je verklaart x binnenkant van een functie, en die functie terugkeert,

1074
01:06:36,430 --> 01:06:40,910
u niet langer toegang tot de gegevens die opgeslagen zijn in x.

1075
01:06:40,910 --> 01:06:44,420
Wat pointers laat ons doen, is ze ons laten slaan geheugen of op te slaan waarden

1076
01:06:44,420 --> 01:06:46,840
in een ander segment van het geheugen, namelijk de heap.

1077
01:06:46,840 --> 01:06:49,340
Nu als we eenmaal uit de terugkeer van functie, zolang we een pointer hebben

1078
01:06:49,340 --> 01:06:54,960
naar die locatie in het geheugen, dan wat we kunnen doen is dat we kunnen gewoon kijken naar de waarden daar.

1079
01:06:54,960 --> 01:06:58,020
Laten we eens kijken naar een voorbeeld: Dit is ons geheugen lay-out weer.

1080
01:06:58,020 --> 01:07:00,050
En we hebben deze functie, de belangrijkste.

1081
01:07:00,050 --> 01:07:06,870
Wat het doet is - oke, zo simpel, toch? - Int x = 5, dat is gewoon een variabele op de stack in de belangrijkste.

1082
01:07:06,870 --> 01:07:12,450
>> Anderzijds, nu verklaren een pointer die de functie giveMeThreeInts noemt.

1083
01:07:12,450 --> 01:07:16,800
En nu gaan we in deze functie en maken we een nieuwe stack frame voor.

1084
01:07:16,800 --> 01:07:20,440
Echter, in deze stack frame, verklaren wij int * temp,

1085
01:07:20,440 --> 01:07:23,210
die in mallocs 3 gehele getallen voor ons.

1086
01:07:23,210 --> 01:07:25,880
Dus grootte van int zal ons hoeveel bytes deze int is,

1087
01:07:25,880 --> 01:07:29,620
en malloc geeft ons dat veel bytes aan ruimte op de heap.

1088
01:07:29,620 --> 01:07:32,890
Dus in dit geval, hebben wij voldoende ruimte voor 3 integers,

1089
01:07:32,890 --> 01:07:36,830
en de hoop is weg daar, dat is waarom ik getekend heb het hoger.

1090
01:07:36,830 --> 01:07:42,900
Zodra we klaar zijn, we terug komen hier, hoeft u alleen maar 3 ints terug,

1091
01:07:42,900 --> 01:07:47,000
en geeft het adres in dat geval het waar dat geheugen.

1092
01:07:47,000 --> 01:07:51,250
En we wijzer = switch, en daar hebben we gewoon een pointer.

1093
01:07:51,250 --> 01:07:54,550
Maar wat die functie terugkeert is hier gestapeld en verdwijnt.

1094
01:07:54,550 --> 01:07:59,250
Dus temp verdwijnt, maar we hebben nog steeds het adres van waar

1095
01:07:59,250 --> 01:08:01,850
die 3 getallen bevinden zich binnenin net.

1096
01:08:01,850 --> 01:08:06,180
Dus in deze set, de pointers zijn scoped lokaal voor de gestapelde frame,

1097
01:08:06,180 --> 01:08:09,860
maar het geheugen waarnaar zij verwijzen in de heap.

1098
01:08:09,860 --> 01:08:12,190
>> Is dat logisch?

1099
01:08:12,190 --> 01:08:14,960
[Student] Kunt u dat herhalen? >> [Joseph] Ja.

1100
01:08:14,960 --> 01:08:20,270
Dus als ik terug een beetje, zie je dat temp toegewezen

1101
01:08:20,270 --> 01:08:23,500
wat geheugen op de heap daar.

1102
01:08:23,500 --> 01:08:28,680
Dus als deze functie giveMeThreeInts terug, deze stapel hier gaat verdwijnen.

1103
01:08:28,680 --> 01:08:35,819
En daarmee een van de variabelen in dit geval pointer die is toegewezen in gestapelde frame.

1104
01:08:35,819 --> 01:08:39,649
Dat gaat verdwijnen, maar sinds we terug temp

1105
01:08:39,649 --> 01:08:46,330
en we wijzer = temp, wijzer nu gaat om hetzelfde geheugen van locatie als temperatuur was wijzen.

1106
01:08:46,330 --> 01:08:50,370
Dus nu, ook al verliezen we temp, dat de lokale aanwijzer,

1107
01:08:50,370 --> 01:08:59,109
we hebben nog steeds het geheugenadres van wat het was te wijzen op de binnenkant van die variabele pointer.

1108
01:08:59,109 --> 01:09:03,740
Vragen? Dat kan een soort van een verwarrend onderwerp zijn als je dat nog niet gegaan over het in sectie.

1109
01:09:03,740 --> 01:09:09,240
Wij kunnen, zal uw TF zeker gaan erover en natuurlijk kunnen we vragen beantwoorden

1110
01:09:09,240 --> 01:09:11,500
aan het einde van het sessie voor deze.

1111
01:09:11,500 --> 01:09:14,220
Maar dit is een soort van een complex onderwerp, en ik heb meer voorbeelden die gaan verschijnen

1112
01:09:14,220 --> 01:09:18,790
dat zal duidelijker worden wat pointers eigenlijk zijn.

1113
01:09:18,790 --> 01:09:22,500
>> In dit geval pointers gelijkwaardig zijn aan arrays,

1114
01:09:22,500 --> 01:09:25,229
dus ik kan deze pointer net als hetzelfde als een int array.

1115
01:09:25,229 --> 01:09:29,840
Dus ik ben het indexeren in 0, en het veranderen van de eerste gehele getal 1,

1116
01:09:29,840 --> 01:09:39,689
veranderende tweede gehele getal 2 en de 3e gehele getal 3.

1117
01:09:39,689 --> 01:09:44,210
Dus meer op pointers. Nou, Binky te roepen.

1118
01:09:44,210 --> 01:09:48,319
In dit geval hebben we toegewezen een pointer, of we uitgeroepen tot een pointer,

1119
01:09:48,319 --> 01:09:52,760
maar in eerste instantie, toen ik net een pointer verklaard, het is niet te wijzen op ergens in het geheugen.

1120
01:09:52,760 --> 01:09:54,930
Het is gewoon vuilnis waarden binnen het.

1121
01:09:54,930 --> 01:09:56,470
Dus ik heb geen idee waar deze pointer naar wijst.

1122
01:09:56,470 --> 01:10:01,630
Het heeft een adres dat net is gevuld met 0 en 1, waar het in eerste instantie werd verklaard.

1123
01:10:01,630 --> 01:10:04,810
Ik kan niets doen met deze totdat ik noem malloc op het

1124
01:10:04,810 --> 01:10:08,390
en dan geeft me een beetje ruimte op de heap waar ik kan binnen zetten waarden.

1125
01:10:08,390 --> 01:10:11,980
Dan weer, ik weet niet wat er in dit geheugen.

1126
01:10:11,980 --> 01:10:16,780
Dus het eerste wat ik moet doen is controleren of de installatie voldoende geheugen had

1127
01:10:16,780 --> 01:10:20,850
om mij terug 1 geheel getal in de eerste plaats, dat is de reden waarom ik dit doe controleren.

1128
01:10:20,850 --> 01:10:25,020
Als wijzer nul is, dat betekent dat het niet genoeg ruimte of een andere fout is opgetreden,

1129
01:10:25,020 --> 01:10:26,320
dus ik moet af te sluiten van mijn programma.

1130
01:10:26,320 --> 01:10:29,400
 Maar als het wel lukt, nu kan ik gebruik maken van dat pointer

1131
01:10:29,400 --> 01:10:35,020
en wat * pointer doet is het volgende waar het adres is

1132
01:10:35,020 --> 01:10:38,480
waar die waarde, en stelt deze gelijk aan 1.

1133
01:10:38,480 --> 01:10:41,850
Dus hier zijn we te controleren of dat het geheugen bestaan.

1134
01:10:41,850 --> 01:10:45,380
>> Als je eenmaal weet dat het bestaat, kun je erin steekt

1135
01:10:45,380 --> 01:10:50,460
welke waarde u wilt erin steekt, in dit geval 1.

1136
01:10:50,460 --> 01:10:53,060
Zodra we klaar zijn met het, moet je die pointer bevrijden

1137
01:10:53,060 --> 01:10:57,160
want we moeten terug naar het systeem dat geheugen dat u gevraagd om in de eerste plaats.

1138
01:10:57,160 --> 01:10:59,690
Omdat de computer weet niet wanneer we klaar zijn met het.

1139
01:10:59,690 --> 01:11:02,510
In dit geval zijn we expliciet te vertellen, oke, we zijn klaar met dat geheugen.

1140
01:11:02,510 --> 01:11:10,780
Als een ander proces nodig heeft, een ander programma nodig heeft, voel je vrij om verder te gaan en mee te nemen.

1141
01:11:10,780 --> 01:11:15,110
Wat we ook kunnen doen is dat we kunnen gewoon het adres van de lokale variabelen op de set.

1142
01:11:15,110 --> 01:11:19,080
Dus int x is binnen de gestapelde frame van de belangrijkste.

1143
01:11:19,080 --> 01:11:23,060
En als we dit teken te gebruiken, dit en operator, wat het doet is

1144
01:11:23,060 --> 01:11:27,310
duurt x en x is slechts enkele gegevens in het geheugen, maar het heeft een adres.

1145
01:11:27,310 --> 01:11:33,790
Het is ergens bevindt. Dus door te bellen & x, wat dit doet is het geeft ons het adres van x.

1146
01:11:33,790 --> 01:11:38,430
Door dit te doen, maken we wijzer punt waar x is in het geheugen.

1147
01:11:38,430 --> 01:11:41,710
Nu hebben we gewoon iets als * x, we gaan naar 5 terug te krijgen.

1148
01:11:41,710 --> 01:11:43,820
De ster wordt genoemd dereferentie het.

1149
01:11:43,820 --> 01:11:46,640
Je volgt het adres en je krijgt de waarde van het daar opgeslagen.

1150
01:11:51,000 --> 01:11:53,310
>> Nog vragen? Ja?

1151
01:11:53,310 --> 01:11:56,500
[Student] Als u dit niet doet de 3-puntige ding, is het nog steeds compileren?

1152
01:11:56,500 --> 01:11:59,490
Ja. Als u dit niet doet de 3-pointer ding, het is nog steeds te compileren,

1153
01:11:59,490 --> 01:12:02,720
maar ik zal je laten zien wat er gebeurt in een tweede, en zonder dat te doen,

1154
01:12:02,720 --> 01:12:04,860
dat is wat wij noemen een geheugenlek. Je geeft het systeem

1155
01:12:04,860 --> 01:12:07,850
terug zijn geheugen, dus na een tijdje het programma gaat ophopen

1156
01:12:07,850 --> 01:12:10,940
geheugen dat het niet gebruikt, en niets anders kan gebruiken.

1157
01:12:10,940 --> 01:12:15,750
Als je ooit hebt gezien Firefox met 1,5 miljoen kilobytes op uw computer,

1158
01:12:15,750 --> 01:12:17,840
in de task manager, dat is wat er gaande is.

1159
01:12:17,840 --> 01:12:20,760
Je hebt een geheugenlek in het programma dat ze niet hanteren.

1160
01:12:23,080 --> 01:12:26,240
Dus hoe werkt pointers werk?

1161
01:12:26,240 --> 01:12:29,480
Nou, pointers is een soort van indexering in een array.

1162
01:12:29,480 --> 01:12:36,370
In dit geval, ik heb een pointer, en wat ik doe is ik maak pointer wijzen op het eerste element

1163
01:12:36,370 --> 01:12:42,100
van deze array van 3 gehele getallen die ik heb toegewezen.

1164
01:12:42,100 --> 01:12:46,670
Dus nu wat ik doe, ster aanwijzer verandert alleen het eerste element in de lijst.

1165
01:12:46,670 --> 01:12:49,140
Star aanwijzer +1 punten hier.

1166
01:12:49,140 --> 01:12:53,140
Dus aanwijzer op hier, wijzer +1 is hier voorbij, aanwijzer +2 is hier.

1167
01:12:53,140 --> 01:12:56,610
>> Dus gewoon het toevoegen van 1 is hetzelfde als het verplaatsen langs deze array.

1168
01:12:56,610 --> 01:12:59,880
Wat wij doen is, als we wijzer +1 krijgt u dan het adres hier,

1169
01:12:59,880 --> 01:13:04,180
en om de waarde in hier te komen, zet je een ster in de gehele uitdrukking

1170
01:13:04,180 --> 01:13:05,990
het dereference.

1171
01:13:05,990 --> 01:13:09,940
Dus, in dit geval, waarin ik de eerste locatie in deze array 1,

1172
01:13:09,940 --> 01:13:13,970
tweede locatie 2 en derde locatie 3.

1173
01:13:13,970 --> 01:13:18,180
Dan wat ik doe hier is dat ik onze pointer +1 afdrukken,

1174
01:13:18,180 --> 01:13:19,970
die geeft gewoon me 2.

1175
01:13:19,970 --> 01:13:23,650
Nu ben ik het verhogen pointer, zodat pointer gelijk pointer +1,

1176
01:13:23,650 --> 01:13:26,780
die beweegt deze naar voren.

1177
01:13:26,780 --> 01:13:30,810
En dus nu als ik print pointer +1, pointer +1 is nu 3,

1178
01:13:30,810 --> 01:13:33,990
in dit geval afgedrukt 3.

1179
01:13:33,990 --> 01:13:36,560
En om gratis iets, de pointer die ik geef het

1180
01:13:36,560 --> 01:13:40,540
moet wijzen op het begin van de array die terug kreeg ik van malloc.

1181
01:13:40,540 --> 01:13:43,430
Dus, in dit geval, als ik tot 3 noemen hier, zou dit niet juist zijn,

1182
01:13:43,430 --> 01:13:45,070
omdat het in het midden van de array.

1183
01:13:45,070 --> 01:13:48,820
Ik moet aftrekken om naar de oorspronkelijke locatie

1184
01:13:48,820 --> 01:13:50,420
de eerste eerste plek voordat ik het kan bevrijden.

1185
01:13:56,300 --> 01:13:58,450
Dus, hier is een meer betrokken voorbeeld.

1186
01:13:58,450 --> 01:14:03,360
In dit geval we verdeling 7 karakters in een karakter array.

1187
01:14:03,360 --> 01:14:06,480
>> En in dit geval wat we doen is dat we een lus over de eerste 6 van hen,

1188
01:14:06,480 --> 01:14:09,900
en we zijn oprichting ervan tot Z.

1189
01:14:09,900 --> 01:14:13,350
Dus voor int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Dus, pointer + zal ik geef ons, in dit geval,

1191
01:14:16,220 --> 01:14:20,860
pointer, pointer +1, pointer +2, aanwijzer +3, en zo verder en zo voort in de lus.

1192
01:14:20,860 --> 01:14:24,040
Wat het gaat doen, is het wordt dat adres, referentie aan het te krijgen van de waarde,

1193
01:14:24,040 --> 01:14:27,440
en wijzigingen die waarde een Z.

1194
01:14:27,440 --> 01:14:30,350
Dan herinner aan het einde dit is een string, toch?

1195
01:14:30,350 --> 01:14:33,560
Alle strings moeten eindigen met de nul eindigt karakter.

1196
01:14:33,560 --> 01:14:38,620
Dus, wat ik doe is in pointer 6 Ik, de null-terminator karakter zetten inch

1197
01:14:38,620 --> 01:14:43,980
En nu, wat ik eigenlijk aan het doen ben hier wordt printf tenuitvoerlegging door een string, toch?

1198
01:14:43,980 --> 01:14:46,190
>> Dus, als printf nu als het aan het einde van een string?

1199
01:14:46,190 --> 01:14:48,230
Als het de nul eindigt karakter raakt.

1200
01:14:48,230 --> 01:14:52,030
Dus, in dit geval mijn oorspronkelijke wijzer naar het begin van deze array.

1201
01:14:52,030 --> 01:14:56,410
Ik print het eerste teken uit. Ik beweeg het over een.

1202
01:14:56,410 --> 01:14:58,420
Print ik dat karakter uit. Ik beweeg het over.

1203
01:14:58,420 --> 01:15:02,180
En ik blijf dit doen tot ik het einde bereikt.

1204
01:15:02,180 --> 01:15:07,750
En nu het einde * pointer zal dereference deze en de nul eindigt karakter terug te krijgen.

1205
01:15:07,750 --> 01:15:11,780
En dus mijn while loop wordt alleen uitgevoerd wanneer die waarde niet de nul eindigt karakter.

1206
01:15:11,780 --> 01:15:13,770
Zo, nu ik uit te sluiten van deze lus.

1207
01:15:18,780 --> 01:15:21,180
En dus als ik aftrekken 6 van deze pointer,

1208
01:15:21,180 --> 01:15:22,860
Ik ga helemaal terug naar het begin.

1209
01:15:22,860 --> 01:15:27,880
Vergeet niet, ik doe dit omdat ik moet naar het begin om het te bevrijden.

1210
01:15:27,880 --> 01:15:30,270
>> Dus, ik weet dat was veel. Zijn er nog vragen?

1211
01:15:30,270 --> 01:15:31,870
Alsjeblieft, ja?

1212
01:15:31,870 --> 01:15:36,610
[Student vraag onverstaanbaar]

1213
01:15:36,610 --> 01:15:38,190
Kunt u zeggen dat harder? Sorry.

1214
01:15:38,190 --> 01:15:44,140
[Student] Op de laatste dia vlak voordat je de aanwijzer bevrijd,

1215
01:15:44,140 --> 01:15:47,300
waar was je eigenlijk het veranderen van de waarde van de pointer?

1216
01:15:47,300 --> 01:15:50,370
[Joseph] Dus, hier. >> [Student] Oh, oke.

1217
01:15:50,370 --> 01:15:51,890
[Joseph] Dus, ik heb een pointer minus minus, rechts,

1218
01:15:51,890 --> 01:15:54,140
die beweegt het ding terug een, en dan zal ik bevrijden,

1219
01:15:54,140 --> 01:15:57,000
omdat deze pointer moet worden gewezen op het begin van de array.

1220
01:15:57,000 --> 01:16:00,420
[Student] Maar dat zou niet nodig was je gestopt na die lijn.

1221
01:16:00,420 --> 01:16:03,130
[Joseph] Dus als ik was gestopt na deze, zou dit worden beschouwd als een geheugenlek,

1222
01:16:03,130 --> 01:16:04,810
omdat ik niet lopen het gratis.

1223
01:16:04,810 --> 01:16:11,290
[Student] I [onverstaanbaar] na de eerste drie regels waar je moest aanwijzer +1 [onverstaanbaar].

1224
01:16:11,290 --> 01:16:13,140
[Joseph] Uh-huh. Dus, wat is de vraag daar?

1225
01:16:13,140 --> 01:16:14,780
Sorry. Nee, nee. Ga, ga, alsjeblieft.

1226
01:16:14,780 --> 01:16:16,870
[Student] Dus, je bent niet het veranderen van de waarde van pointers.

1227
01:16:16,870 --> 01:16:19,130
Je zou het niet hebben moeten aanwijzer minus minus doen.

1228
01:16:19,130 --> 01:16:19,730
[Joseph] Ja, precies.

1229
01:16:19,730 --> 01:16:21,890
Dus, als ik wijzer +1 en +2 pointer te doen,

1230
01:16:21,890 --> 01:16:24,410
Ik doe pointer gelijk pointer +1.

1231
01:16:24,410 --> 01:16:27,260
Dus blijft de aanwijzer precies die op het begin van de array.

1232
01:16:27,260 --> 01:16:31,460
Het is pas als ik dat doe plus plus dat het zich de waarde terug in de aanwijzer,

1233
01:16:31,460 --> 01:16:33,550
dat het beweegt eigenlijk dit samen.

1234
01:16:36,860 --> 01:16:37,780
Oke.

1235
01:16:40,550 --> 01:16:42,030
Meer vragen?

1236
01:16:44,680 --> 01:16:47,790
>> Nogmaals, als dit is een soort van overweldigend, zal dit worden behandeld in sessie.

1237
01:16:47,790 --> 01:16:50,710
Vraag uw onderwijs collega over, en we kunnen vragen te beantwoorden op het einde.

1238
01:16:53,510 --> 01:16:56,600
En meestal hebben we niet graag dit minus ding te doen.

1239
01:16:56,600 --> 01:16:59,760
Dit heeft te verlangen mij het bijhouden van hoeveel ik heb gecompenseerd in de array.

1240
01:16:59,760 --> 01:17:04,520
Dus, in het algemeen, is dit gewoon uit te leggen hoe pointers werken.

1241
01:17:04,520 --> 01:17:07,970
Maar wat we meestal willen doen is dat we graag een kopie van de wijzer te maken,

1242
01:17:07,970 --> 01:17:11,640
en dan zullen we gebruik maken van die kopie als we bewegen in de string.

1243
01:17:11,640 --> 01:17:14,660
Dus, in deze het geval u gebruik maken van de kopie aan de gehele reeks af te drukken,

1244
01:17:14,660 --> 01:17:19,040
maar we hoeven niet te doen alsof wijzer min 6 of bijhouden hoeveel we verhuisden in deze,

1245
01:17:19,040 --> 01:17:22,700
alleen maar omdat we weten dat onze oorspronkelijke punt nog steeds gewezen op het begin van de lijst

1246
01:17:22,700 --> 01:17:25,340
en alles wat we veranderd was dit exemplaar.

1247
01:17:25,340 --> 01:17:28,250
Dus, in het algemeen, te wijzigen kopieën van uw originele aanwijzer.

1248
01:17:28,250 --> 01:17:32,350
Probeer niet te sorteren van soortgelijke - Doe niet wijzigen originele exemplaren.

1249
01:17:32,350 --> 01:17:35,290
Proberen om alleen kopieën van uw originele te veranderen.

1250
01:17:41,540 --> 01:17:44,870
Dus, je opvalt als we langs de string in printf

1251
01:17:44,870 --> 01:17:48,990
je hoeft niet om een ​​ster in de voorkant van het als we met alle andere referentie aan, toch?

1252
01:17:48,990 --> 01:17:54,180
Dus, als je drukt de volledige tekenreeks% s verwacht is een adres,

1253
01:17:54,180 --> 01:17:57,610
en in dit geval een pointer of in dit geval als een array van karakters.

1254
01:17:57,610 --> 01:18:00,330
>> Karakters, char * s, en arrays zijn hetzelfde.

1255
01:18:00,330 --> 01:18:03,690
Pointer is om tekens, en karakter arrays zijn hetzelfde.

1256
01:18:03,690 --> 01:18:05,720
En dus, is alles wat we moeten doen passeren in aanwijzer.

1257
01:18:05,720 --> 01:18:08,150
We hebben geen geschiedde in zoals * pointer of iets dergelijks.

1258
01:18:13,110 --> 01:18:14,930
Dus, arrays en pointers zijn hetzelfde.

1259
01:18:14,930 --> 01:18:19,160
Als je iets doet als x [y] hier voor een array,

1260
01:18:19,160 --> 01:18:21,960
wat het doet onder de motorkap is het zegt, oke, het is een karakter array,

1261
01:18:21,960 --> 01:18:23,690
dus het is een pointer.

1262
01:18:23,690 --> 01:18:26,510
En dus x zijn hetzelfde,

1263
01:18:26,510 --> 01:18:28,650
en dus wat het doet is het voegt y naar x,

1264
01:18:28,650 --> 01:18:31,820
dat is hetzelfde als vooruit in het geheugen dat veel.

1265
01:18:31,820 --> 01:18:34,930
En nu x + y geeft ons een soort van adres,

1266
01:18:34,930 --> 01:18:37,570
en we dereference het adres of volg de pijl

1267
01:18:37,570 --> 01:18:41,640
naar de plaats waar die locatie in het geheugen is en krijgen we de waarde uit die locatie in het geheugen.

1268
01:18:41,640 --> 01:18:43,720
Zo, zo deze twee zijn precies hetzelfde.

1269
01:18:43,720 --> 01:18:45,840
Het is gewoon een syntactische suiker.

1270
01:18:45,840 --> 01:18:48,090
Ze doen hetzelfde. Ze zijn gewoon anders syntactics voor elkaar.

1271
01:18:51,500 --> 01:18:57,590
>> Dus, wat kan verkeerd gaan met pointers? Zoals, heel veel. Oke. Dus, slechte dingen.

1272
01:18:57,590 --> 01:19:02,410
Sommige slechte dingen die je kunt doen is niet na te gaan of uw malloc oproep null retourneert, toch?

1273
01:19:02,410 --> 01:19:06,560
In dit geval, ik vraag het systeem voor mij te geven - wat is dat nummer?

1274
01:19:06,560 --> 01:19:11,200
Als 2 miljard keer 4, omdat de grootte van een geheel getal van 4 bytes.

1275
01:19:11,200 --> 01:19:13,810
Ik vraag het voor als 8 miljard bytes.

1276
01:19:13,810 --> 01:19:17,270
Natuurlijk is mijn computer is niet van plan te zijn in staat om mij dat veel geheugen terug.

1277
01:19:17,270 --> 01:19:20,960
En we hadden toch niet controleren of deze nul is, dus als we proberen om dereference het daar -

1278
01:19:20,960 --> 01:19:24,270
volg de pijl naar de plaats waar het gaat om - hebben we niet dat het geheugen.

1279
01:19:24,270 --> 01:19:27,150
Dit is wat we noemen dereferentie een null pointer.

1280
01:19:27,150 --> 01:19:29,710
En dit zorgt ervoor dat in wezen je segfault aan.

1281
01:19:29,710 --> 01:19:31,790
Dit is een van de manieren waarop u kunt segfault.

1282
01:19:34,090 --> 01:19:38,090
Andere slechte dingen die je kunt doen - oh well.

1283
01:19:38,090 --> 01:19:40,650
Dat was dereferentie een null pointer. Oke.

1284
01:19:40,650 --> 01:19:45,160
Andere slechte dingen - nou ja, om vast te stellen dat je gewoon een cheque in daar te zetten

1285
01:19:45,160 --> 01:19:46,980
die controleert of de aanwijzer null is

1286
01:19:46,980 --> 01:19:51,000
en uit te sluiten van het programma als het gebeurt dat malloc geeft een null pointer.

1287
01:19:55,110 --> 01:19:59,850
Dat is de xkcd comic. Mensen begrijpen het nu. Soort van.

1288
01:20:06,120 --> 01:20:09,350
>> Dus geheugen. En ik ging dit.

1289
01:20:09,350 --> 01:20:12,000
We noemen malloc in een lus, maar elke keer als we noemen malloc

1290
01:20:12,000 --> 01:20:14,370
we verliezen bij waar deze pointer wijst naar,

1291
01:20:14,370 --> 01:20:15,750
omdat we beuken het.

1292
01:20:15,750 --> 01:20:18,410
Dus, het eerste contact met malloc geeft me het geheugen hier.

1293
01:20:18,410 --> 01:20:19,990
Mijn wijzer verwijzingen naar deze.

1294
01:20:19,990 --> 01:20:23,020
Nu, ik het niet vrij, dus nu noem ik malloc weer.

1295
01:20:23,020 --> 01:20:26,070
Nu wijst hier. Nu is mijn geheugen wijst hier.

1296
01:20:26,070 --> 01:20:27,640
Wijzend hier. Wijzend hier.

1297
01:20:27,640 --> 01:20:31,820
Maar ik heb verloren spoor van de adressen van al het geheugen hier dat ik toegewezen.

1298
01:20:31,820 --> 01:20:35,100
En dus nu heb ik niet meer om het even welke verwijzing naar hen.

1299
01:20:35,100 --> 01:20:37,230
Dus ik kan niet bevrijden buiten deze lus.

1300
01:20:37,230 --> 01:20:39,390
En dus om iets als dit op te lossen,

1301
01:20:39,390 --> 01:20:42,250
als je vergeet om geheugen vrij te en je krijgt dit geheugenlek,

1302
01:20:42,250 --> 01:20:45,810
Je moet de geheugen vrij binnenkant van deze lus als je eenmaal klaar bent met het.

1303
01:20:45,810 --> 01:20:51,400
Nou, dit is wat er gebeurt. Ik weet dat velen van jullie een hekel aan.

1304
01:20:51,400 --> 01:20:55,270
Maar nu - yay! Je krijgt net als 44.000 kilobytes.

1305
01:20:55,270 --> 01:20:57,110
Dus, je bevrijden aan het einde van de lus,

1306
01:20:57,110 --> 01:20:59,770
en dat gaat gewoon vrij het geheugen elke keer.

1307
01:20:59,770 --> 01:21:03,620
In wezen gaat het programma niet meer een geheugenlek.

1308
01:21:03,620 --> 01:21:08,150
>> En nu iets anders dat je kunt doen is geheugen vrij dat u gevraagd twee keer.

1309
01:21:08,150 --> 01:21:11,060
In dit geval moet u malloc iets, u die waarde wijzigen.

1310
01:21:11,060 --> 01:21:13,140
Je bevrijden het een keer, omdat je zei dat je er klaar mee.

1311
01:21:13,140 --> 01:21:14,940
Maar dan moeten we bevrijd het weer.

1312
01:21:14,940 --> 01:21:16,730
Dit is iets dat is vrij slecht.

1313
01:21:16,730 --> 01:21:18,820
Het gaat niet in eerste instantie segfault,

1314
01:21:18,820 --> 01:21:23,350
maar na een tijdje wat dit doet is dubbel bevrijden dit corrumpeert uw hoop structuur,

1315
01:21:23,350 --> 01:21:27,200
en je krijgt een beetje meer te leren over dit als je ervoor kiest om een ​​klasse te nemen als CS61.

1316
01:21:27,200 --> 01:21:30,000
Maar in wezen na een tijdje de computer gaat in de war raken

1317
01:21:30,000 --> 01:21:33,010
over wat geheugen locaties zijn waar en waar het is opgeslagen -

1318
01:21:33,010 --> 01:21:34,800
waarin gegevens worden opgeslagen.

1319
01:21:34,800 --> 01:21:38,080
En dus het vrijmaken van een pointer twee keer is een slechte zaak dat je niet wilt doen.

1320
01:21:38,080 --> 01:21:41,600
>> Andere dingen die fout kunnen gaan is niet met behulp van sizeof.

1321
01:21:41,600 --> 01:21:44,460
Dus, in dit geval malloc 8 bytes,

1322
01:21:44,460 --> 01:21:46,700
en dat is hetzelfde als twee gehele getallen, toch?

1323
01:21:46,700 --> 01:21:49,580
Dus, dat is volkomen veilig, maar is het?

1324
01:21:49,580 --> 01:21:52,160
Nou, zoals Lucas het over op verschillende architecturen,

1325
01:21:52,160 --> 01:21:54,220
integers zijn van verschillende lengte.

1326
01:21:54,220 --> 01:21:57,970
Dus, op het apparaat dat u gebruikt, gehele getallen zijn ongeveer 4 bytes,

1327
01:21:57,970 --> 01:22:02,370
maar op een ander systeem ze ook mogen zijn 8 bytes of ze kunnen worden 16 bytes.

1328
01:22:02,370 --> 01:22:05,680
Dus, als ik gewoon dit nummer te gebruiken hier,

1329
01:22:05,680 --> 01:22:07,310
dit programma zou kunnen werken op het apparaat,

1330
01:22:07,310 --> 01:22:10,360
maar het is niet genoeg geheugen op een ander systeem toe te wijzen.

1331
01:22:10,360 --> 01:22:14,020
In dit geval is wat de sizeof operator wordt gebruikt.

1332
01:22:14,020 --> 01:22:16,880
Wanneer noemen we sizeof (int), wat dit doet is

1333
01:22:16,880 --> 01:22:21,910
 het geeft ons de grootte van een geheel getal op het systeem dat het programma wordt uitgevoerd.

1334
01:22:21,910 --> 01:22:25,490
Dus, in dit geval sizeof (int) terug 4 op zoiets als het apparaat

1335
01:22:25,490 --> 01:22:29,980
en nu dit wil 4 * 2, dat is 8,

1336
01:22:29,980 --> 01:22:32,330
die net de ruimte nodig voor twee integers.

1337
01:22:32,330 --> 01:22:36,710
Op een ander systeem, als een int is als 16 bytes of 8 bytes,

1338
01:22:36,710 --> 01:22:39,380
het is gewoon genoeg bytes terug te keren naar dat bedrag op te slaan.

1339
01:22:41,830 --> 01:22:45,310
>> En tot slot, structs.

1340
01:22:45,310 --> 01:22:48,340
Dus, als je wilde een sudoku bord op te slaan in het geheugen, hoe kunnen we dit doen?

1341
01:22:48,340 --> 01:22:51,570
Je zou kunnen denken van als een variabele voor het eerste ding,

1342
01:22:51,570 --> 01:22:53,820
een variabele voor de tweede zaak, een variabele voor de derde ding,

1343
01:22:53,820 --> 01:22:56,420
een variabele voor de vierde ding - slecht, toch?

1344
01:22:56,420 --> 01:23:00,750
Dus, een verbetering kunt u top van deze is om een ​​9 x 9 array.

1345
01:23:00,750 --> 01:23:04,480
Dat is prima, maar wat als je wilde om andere dingen te associëren met de sudoku bord

1346
01:23:04,480 --> 01:23:06,490
als wat de moeilijkheid van het bord is,

1347
01:23:06,490 --> 01:23:11,740
of, bijvoorbeeld, wat uw score is, of hoeveel tijd het is genomen om dit forum op te lossen?

1348
01:23:11,740 --> 01:23:14,970
Nou, wat je kunt doen is kunt u een struct.

1349
01:23:14,970 --> 01:23:18,910
Wat ik eigenlijk wil zeggen is dat ik deze structuur definiëren hier,

1350
01:23:18,910 --> 01:23:23,230
en ik ben het definiëren van een sudoku boord die bestaat uit een raad van bestuur die is 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> En wat het heeft het heeft verwijzingen naar de naam van het level.

1352
01:23:26,650 --> 01:23:30,730
Het heeft ook x en y, die de coördinaten van waar ik nu.

1353
01:23:30,730 --> 01:23:35,980
Het heeft ook tijd besteed [onverstaanbaar], en het heeft het totale aantal zetten ik tot nu toe ingevoerd.

1354
01:23:35,980 --> 01:23:40,010
En dus in dit geval, kan ik een hele hoop gegevens groeperen in een enkele structuur

1355
01:23:40,010 --> 01:23:42,790
in plaats van het hebben van het als vliegen rond in als verschillende variabelen

1356
01:23:42,790 --> 01:23:44,540
dat kan ik niet echt bijhouden.

1357
01:23:44,540 --> 01:23:49,720
En dit laat ons hebben gewoon leuk syntaxis voor soort verwijzen naar verschillende dingen binnenkant van dit struct.

1358
01:23:49,720 --> 01:23:53,430
Ik kan gewoon board.board, en ik krijg de sudoku bord terug.

1359
01:23:53,430 --> 01:23:56,320
Board.level, krijg ik hoe moeilijk het is.

1360
01:23:56,320 --> 01:24:00,540
Board.x en board.y geef me de coördinaten van waar ik zou kunnen zijn in het bestuur.

1361
01:24:00,540 --> 01:24:04,730
En dus ik ben toegang tot wat wij noemen velden in de struct.

1362
01:24:04,730 --> 01:24:08,840
Dit definieert sudokuBoard, dat is een soort die ik heb.

1363
01:24:08,840 --> 01:24:14,800
En nu zijn we hier. Ik heb een variabele genaamd "board" van het type sudokuBoard.

1364
01:24:14,800 --> 01:24:18,820
En dus nu kan ik toegang krijgen tot alle velden die deel uitmaken van deze structuur hier.

1365
01:24:20,830 --> 01:24:22,450
>> Heeft u vragen over structs? Ja?

1366
01:24:22,450 --> 01:24:25,890
[Student] Voor int x, y, u heeft verklaard zowel op een lijn? >> [Joseph] Uh-huh.

1367
01:24:25,890 --> 01:24:27,400
[Student] Dus, zou je dat te doen met elk van hen?

1368
01:24:27,400 --> 01:24:31,200
Net als in x, y komma keer dat de totale?

1369
01:24:31,200 --> 01:24:34,460
[Joseph] Ja, dat kan zeker doen, maar de reden dat ik x en y op dezelfde lijn -

1370
01:24:34,460 --> 01:24:36,330
en de vraag is waarom kunnen we gewoon dit doen op dezelfde lijn?

1371
01:24:36,330 --> 01:24:38,600
Waarom gaan we niet zomaar al deze op dezelfde lijn is

1372
01:24:38,600 --> 01:24:42,090
x en y zijn gerelateerd aan elkaar

1373
01:24:42,090 --> 01:24:44,780
en dit is slechts stilistisch meer correct is, in zekere zin,

1374
01:24:44,780 --> 01:24:46,600
omdat het groeperen van twee dingen op dezelfde lijn

1375
01:24:46,600 --> 01:24:49,340
dat als soort hebben betrekking op hetzelfde.

1376
01:24:49,340 --> 01:24:51,440
En ik splitsen deze uit elkaar. Het is gewoon een stijl ding.

1377
01:24:51,440 --> 01:24:53,720
Het maakt functioneel geen enkel verschil.

1378
01:24:58,150 --> 01:24:59,270
Alle andere vragen over structs?

1379
01:25:03,030 --> 01:25:06,620
U kunt een Pokedex met een struct.

1380
01:25:06,620 --> 01:25:11,720
Een Pokemon heeft een nummer en het heeft een brief, een eigenaar, een type.

1381
01:25:11,720 --> 01:25:16,990
En dan als je een array van Pokemon, kunt u een Pokedex, toch?

1382
01:25:16,990 --> 01:25:20,810
Oke, cool. Dus vragen over structs. Dat zijn gerelateerd aan structs.

1383
01:25:20,810 --> 01:25:25,270
>> Tenslotte GDB. Wat doet GDB laten doen? Het laat je debuggen uw programma.

1384
01:25:25,270 --> 01:25:27,650
En als je niet hebt gebruikt GDB, zou ik raden het kijken naar de korte

1385
01:25:27,650 --> 01:25:31,250
en gewoon gaan over wat GDB is, hoe je er mee werkt, hoe u het te gebruiken,

1386
01:25:31,250 --> 01:25:32,900
en test het op een programma.

1387
01:25:32,900 --> 01:25:37,400
En dus wat GDB kunt u doen is het laat pauzeren [onverstaanbaar]-up van uw programma

1388
01:25:37,400 --> 01:25:38,920
en een praktische lijn.

1389
01:25:38,920 --> 01:25:42,600
Bijvoorbeeld, ik wil om te pauzeren uitvoering op als lijn 3 van mijn programma,

1390
01:25:42,600 --> 01:25:46,010
en terwijl ik op regel 3 Ik kan uitprinten alle waarden die er zijn.

1391
01:25:46,010 --> 01:25:49,710
En dus wat wij noemen als het pauzeren in een lijn

1392
01:25:49,710 --> 01:25:52,350
is noemen we dit zetten een breakpoint op die lijn

1393
01:25:52,350 --> 01:25:55,920
en dan kunnen we printen de variabelen over de toestand van het programma op dat moment.

1394
01:25:55,920 --> 01:25:58,990
>> We kunnen dan van daaruit stap door het programma lijn per lijn.

1395
01:25:58,990 --> 01:26:03,200
En dan kunnen we kijken naar de staat van de stack op het moment.

1396
01:26:03,200 --> 01:26:08,600
En dus om GDB, wat we doen is dat we clang een beroep doen op de C-bestand te gebruiken,

1397
01:26:08,600 --> 01:26:11,290
maar we moeten doorgeven the-ggdb vlag.

1398
01:26:11,290 --> 01:26:15,850
En zodra we klaar zijn met dat we gewoon gdb draaien op de resulterende output file.

1399
01:26:15,850 --> 01:26:18,810
En zo krijg je een aantal achtige massa van tekst als deze,

1400
01:26:18,810 --> 01:26:21,990
maar werkelijk alles wat je hoeft te doen is typen in commando's aan het begin.

1401
01:26:21,990 --> 01:26:24,250
Breek belangrijkste zet een breakpoint op de belangrijkste.

1402
01:26:24,250 --> 01:26:28,470
Lijst 400 geeft de lijnen van de code rond regel 400.

1403
01:26:28,470 --> 01:26:31,410
En dus in dit geval kun je gewoon rondkijken en zeggen: oh,

1404
01:26:31,410 --> 01:26:34,360
Ik wil een breekpunt op lijn 397, die deze lijn in te stellen,

1405
01:26:34,360 --> 01:26:37,170
en vervolgens uw programma loopt in die stap en het zal breken.

1406
01:26:37,170 --> 01:26:41,120
Het gaat om te pauzeren daar, en u kunt afdrukken, bijvoorbeeld, de waarde van lage of hoge.

1407
01:26:41,120 --> 01:26:46,410
En zo zijn er een heleboel commando's die je moet weten,

1408
01:26:46,410 --> 01:26:48,660
en deze slideshow zal omhoog gaan op de website,

1409
01:26:48,660 --> 01:26:54,000
dus als je gewoon wilt dat deze verwijzen of zoals ze op je spiekbriefjes, voel je vrij.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. Dat was Quiz Beoordeling 0, en we zullen blijven hangen als u vragen hebt.

1411
01:27:00,650 --> 01:27:03,850
Oke.

1412
01:27:03,850 --> 01:27:09,030
>>  [Applaus]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]