1
00:00:00,000 --> 00:00:02,270
[Powered by Google Translate] [Vecka 2, Fortsättning]

2
00:00:02,270 --> 00:00:04,220
[David J. Malan, Harvard University]

3
00:00:04,220 --> 00:00:06,880
[Detta är CS50. - CS50.TV]

4
00:00:06,880 --> 00:00:10,990
Okej. Detta är CS50, och detta är slutet på vecka 2.

5
00:00:10,990 --> 00:00:14,410
Om du räknar med att vara hungrig vid den här tiden i morgon,

6
00:00:14,410 --> 00:00:18,620
vet att vi kommer att sammankalla en liten grupp i morgon, torsdag, 1:15 PM.

7
00:00:18,620 --> 00:00:21,360
Det är denna URL här om du vill RSVP.

8
00:00:21,360 --> 00:00:26,740
Utrymmet är begränsat, så förlåt om formuläret har fyllts upp med den tid du fylla i det här.

9
00:00:26,740 --> 00:00:29,300
En annan webbadress, men som kan vara av intresse är det.

10
00:00:29,300 --> 00:00:32,369
I nästan en månad, kursen kommer att göras tillgänglig

11
00:00:32,369 --> 00:00:36,890
allt bredare via EDX, via vilken folk på Internet kommer att kunna följa med,

12
00:00:36,890 --> 00:00:39,380
delta i kursen helt aktivt, faktiskt.

13
00:00:39,380 --> 00:00:42,270
De kommer att använda CS50 Appliance och CS50 Diskutera

14
00:00:42,270 --> 00:00:45,490
och de flesta av de olika mjukvaruverktyg som vi redan har använt den här terminen.

15
00:00:45,490 --> 00:00:48,710
Och en av de initiativ som vi vill ta på som ett experiment i år

16
00:00:48,710 --> 00:00:51,930
är att se hur mycket innehåll som vi kan översätta

17
00:00:51,930 --> 00:00:53,960
i andra talade och skrivna språk.

18
00:00:53,960 --> 00:00:57,500
Så om du kan ha ett intresse av att delta i projektet

19
00:00:57,500 --> 00:01:02,270
där vi kommer att ge engelska avskrifter och undertexter för kursens föreläsningar

20
00:01:02,270 --> 00:01:05,450
och shorts och seminarier och sektioner och liknande,

21
00:01:05,450 --> 00:01:08,200
om du talar flytande eller skriva flytande ett annat språk,

22
00:01:08,200 --> 00:01:12,290
Vi skulle älska att engagera dig i detta projekt där du tar på en eller flera av de videor,

23
00:01:12,290 --> 00:01:15,200
översätta dem till ett språk du känner ganska väl.

24
00:01:15,200 --> 00:01:18,700
>> För att ge dig en känsla av gränssnittet, det är det här webbaserade användargränssnitt

25
00:01:18,700 --> 00:01:22,090
att vi kommer att använda som kommer att skapa i huvudsak en UI som denna.

26
00:01:22,090 --> 00:01:24,290
Detta var jag undervisade lite Halloween sedan,

27
00:01:24,290 --> 00:01:27,390
och på den högra sidan där i svart bredvid dessa tidsstämplar,

28
00:01:27,390 --> 00:01:31,210
ser du de olika saker som kom ur min mun den dagen,

29
00:01:31,210 --> 00:01:34,850
och sedan under det du kommer att kunna översätta till andra språk

30
00:01:34,850 --> 00:01:38,690
exakt vad mappningen mellan, i detta fall, engelska och, säg, spanska.

31
00:01:38,690 --> 00:01:40,440
Så det är faktiskt en mycket användarvänligt verktyg.

32
00:01:40,440 --> 00:01:43,370
Du kan spola tillbaka och snabbspola mycket lätt med kortkommandon.

33
00:01:43,370 --> 00:01:47,490
Så om du vill delta i detta experiment och har dina ord sett och läst

34
00:01:47,490 --> 00:01:51,850
genom potentiellt tusentals människor där ute, jag är du välkommen att delta.

35
00:01:51,850 --> 00:01:54,350
Ett ord om kattunge från måndag.

36
00:01:54,350 --> 00:02:00,350
Så att vi har skickat en alltför skrämmande budskap, inser att som kontorstid tyder

37
00:02:00,350 --> 00:02:03,300
och som sektioner antyder, är utformningen av kursen mycket

38
00:02:03,300 --> 00:02:07,360
att eleverna samarbetar och pratar att arbeta igenom problemet set

39
00:02:07,360 --> 00:02:11,260
och problem tillsammans, och verkligen linjen bara handlar om,

40
00:02:11,260 --> 00:02:16,010
igen bör det arbete du i slutändan skicka vara din egen.

41
00:02:16,010 --> 00:02:18,860
Och så helt ärligt, i kontorstid det är helt normalt,

42
00:02:18,860 --> 00:02:22,240
det är helt att vänta med, att chatta med någon kompis bredvid dig.

43
00:02:22,240 --> 00:02:24,370
>> Om han eller hon kämpar med något ämne och du är som,

44
00:02:24,370 --> 00:02:27,940
"Åh, ja, låt mig ge er en glimt av några kodrad som jag skrev," det är bra,

45
00:02:27,940 --> 00:02:31,250
det händer, och det är mycket gynnsam, tror jag, med processen för lärande.

46
00:02:31,250 --> 00:02:36,750
När linjen blir korsade är när huvudet är typ av lutas hit alldeles för många sekunder

47
00:02:36,750 --> 00:02:41,160
eller minuter som verkligen bara varit en frigörande möjlighet för din vän,

48
00:02:41,160 --> 00:02:44,160
och säkerligen när det blir utbyts via e-post och Dropbox och liknande,

49
00:02:44,160 --> 00:02:45,640
Det är också den linje.

50
00:02:45,640 --> 00:02:48,620
Så med alla medel trivs och känner sig uppmuntrade att chatta med vänner

51
00:02:48,620 --> 00:02:52,810
och klasskamrater om psets och fler och bara inse att det du i slutändan skicka

52
00:02:52,810 --> 00:02:57,340
borde verkligen vara en produkt av din skapelse och inte någon annan.

53
00:02:57,340 --> 00:03:00,490
Och så en av de domänspecifika problem för pset2,

54
00:03:00,490 --> 00:03:04,740
som kommer att komma ut sent i morgon kväll, är att dyka in i världen av kryptografi,

55
00:03:04,740 --> 00:03:08,970
vilket är konsten att kryptera eller förvränga information,

56
00:03:08,970 --> 00:03:12,600
och detta gäller i slutändan till en värld av säkerheten.

57
00:03:12,600 --> 00:03:16,560
Nu kommer säkerheten för de flesta av oss i form av tämligen vardagliga mekanismer.

58
00:03:16,560 --> 00:03:19,050
Alla av oss har användarnamn och lösenord,

59
00:03:19,050 --> 00:03:23,450
och alla av oss har mycket dåliga användarnamn och lösenord, troligen.

60
00:03:23,450 --> 00:03:28,240
>> Om ditt lösenord är samma på flera webbplatser, det är förmodligen inte den bästa idén,

61
00:03:28,240 --> 00:03:30,070
som vi kommer att diskutera mot termin slut.

62
00:03:30,070 --> 00:03:34,720
Om ditt lösenord är skriven på en klisterlapp - inget skämt - på bildskärmen,

63
00:03:34,720 --> 00:03:38,350
som är för inte nödvändigtvis den bästa designen men ganska vanligt fenomen.

64
00:03:38,350 --> 00:03:42,470
Och om du inte använder kryptering för att kryptera dina lösenord,

65
00:03:42,470 --> 00:03:44,210
de är särskilt sårbara.

66
00:03:44,210 --> 00:03:47,270
Så om du tror att du är super smart genom att ha en dold Word-dokument

67
00:03:47,270 --> 00:03:49,910
någonstans på din hårddisk som har alla dina lösenord

68
00:03:49,910 --> 00:03:53,670
men det är i en mapp som ingen kommer att titta i, det är inte heller en mycket säker mekanism.

69
00:03:53,670 --> 00:03:56,990
Och så vad pset2 kommer att införa är denna konst av kryptografi

70
00:03:56,990 --> 00:04:02,010
och förvränga information så att saker som lösenord är allt säkrare.

71
00:04:02,010 --> 00:04:05,790
Sammanhanget här är att med osäkra uppgifter

72
00:04:05,790 --> 00:04:07,930
kommer en möjlighet att kryptera det och att förvränga den.

73
00:04:07,930 --> 00:04:11,470
Och så detta, till exempel, är ett exempel på ett krypterat meddelande.

74
00:04:11,470 --> 00:04:14,700
Detta säger faktiskt något på engelska, men det är uppenbarligen inte helt uppenbart.

75
00:04:14,700 --> 00:04:18,279
Och vi kommer full cirkel idag att retas isär vad detta hemligt meddelande här är.

76
00:04:18,279 --> 00:04:23,490
Men i den verkliga världen av datorer, saker och ting inte ens ser ut som de kan vara engelska fraser.

77
00:04:23,490 --> 00:04:28,430
Till exempel, det är vad du kan hitta på en vanlig Linux-eller Mac eller UNIX-dator

78
00:04:28,430 --> 00:04:32,070
i en fil som var en gång i tiden kallades lösenord filen.

79
00:04:32,070 --> 00:04:34,200
>> Numera har flyttats till andra platser.

80
00:04:34,200 --> 00:04:39,210
Men om man tittar på rätt plats på ett system, ser du inte bara ditt användarnamn

81
00:04:39,210 --> 00:04:43,400
eller för andra människor på systemet, men du kommer att se en krypterad version av sitt lösenord.

82
00:04:43,400 --> 00:04:47,980
I själva verket antyder ordet kryptan där att följande saker är krypterad,

83
00:04:47,980 --> 00:04:52,680
och denna serie av till synes slumpmässiga bokstäver och tecken och siffror och så vidare

84
00:04:52,680 --> 00:04:56,480
kan dekrypteras endast genom allmänt veta någon hemlighet -

85
00:04:56,480 --> 00:04:58,840
ett hemligt ord, ett hemligt nummer -

86
00:04:58,840 --> 00:05:03,160
och så faktiskt, till konsten att kryptografi slutligen handlar om förtroende av något slag

87
00:05:03,160 --> 00:05:05,650
och veta något som någon annan inte gör det.

88
00:05:05,650 --> 00:05:10,090
Så vi kommer att utforska detta i lite mer detalj i dag och i pset framöver.

89
00:05:10,090 --> 00:05:12,200
Och nu några ord om Pass / Fail.

90
00:05:12,200 --> 00:05:15,360
Särskilt som vissa av er har dykt in pset1, apparaten,

91
00:05:15,360 --> 00:05:19,080
och en mycket ny värld för dig själv, inse att frustration och förvirring

92
00:05:19,080 --> 00:05:21,700
och bara tekniska svårigheter är ganska att vänta,

93
00:05:21,700 --> 00:05:24,180
särskilt med den första pset, där det finns bara så mycket nytt,

94
00:05:24,180 --> 00:05:27,730
bara få känna ls och cd och alla dessa mystiska kommandon

95
00:05:27,730 --> 00:05:33,050
och en ny miljö, och det är separat från själva materialet och programmering själv.

96
00:05:33,050 --> 00:05:36,940
Så inser också att det finns säkert kontorstid som finns som en stödstruktur.

97
00:05:36,940 --> 00:05:38,880
>> Avsnitt börjar denna kommande söndag.

98
00:05:38,880 --> 00:05:42,960
Men viktigast av allt, om du känner bara att det inte är hela världen för dig,

99
00:05:42,960 --> 00:05:44,710
inse att det egentligen bara tar tid.

100
00:05:44,710 --> 00:05:48,600
Och om det inte vore för denna möjlighet år sedan för mig att ta en klass godkänd / underkänd,

101
00:05:48,600 --> 00:05:50,990
ärligt talat, jag skulle aldrig ens satt sin fot i klassrummet.

102
00:05:50,990 --> 00:05:53,690
Och du kan ändra detta fram, säger den femte måndagen i kursen,

103
00:05:53,690 --> 00:05:58,280
så om du är på kanten nu inse att i stället huvudet i vissa andra vatten helt och hållet,

104
00:05:58,280 --> 00:06:01,260
anser visserligen bara byta till godkänd / underkänd.

105
00:06:01,260 --> 00:06:04,570
Återigen, det är inte riktigt denna kultur här på Harvard för att ta saker godkänd / underkänd

106
00:06:04,570 --> 00:06:08,670
eftersom alla vill verkligen uppnå eller överträffa,

107
00:06:08,670 --> 00:06:11,130
men ärligt talat, det är ett underbart sätt att försöka något

108
00:06:11,130 --> 00:06:16,720
som kanske inte bekant för dig, och du kommer att sluta göra, i de flesta fall ganska bra,

109
00:06:16,720 --> 00:06:18,210
kanske mycket till din förvåning.

110
00:06:18,210 --> 00:06:20,980
Och i mer konkreta termer, vad jag tycker godkänd / underkänd i allmänhet gör,

111
00:06:20,980 --> 00:06:22,940
särskilt som du kanske har upplevt med pset0,

112
00:06:22,940 --> 00:06:26,560
Om du sätter i 10 timmar, 15 timmar, 25 timmar i någon pset

113
00:06:26,560 --> 00:06:29,920
och du bara banka huvudet mot väggen och det börjar bli super sent på natten

114
00:06:29,920 --> 00:06:33,950
men du har tagit pset 90% av vägen och du bara inte kan lista ut en sak,

115
00:06:33,950 --> 00:06:36,520
godkänd / underkänd verkligen tar udden av en klass som denna,

116
00:06:36,520 --> 00:06:39,100
där du kan sortera på glatt säga: "Okej, jag vet att det inte är perfekt,

117
00:06:39,100 --> 00:06:42,350
men jag jobbade häcken av mig på detta, jag är ganska nöjd med var den hamnade, "

118
00:06:42,350 --> 00:06:44,850
och som kommer att uppfylla de förväntningar på godkänt / underkänt.

119
00:06:44,850 --> 00:06:47,540
Så ha det i åtanke. Okej.

120
00:06:47,540 --> 00:06:50,520
>> Så de av er som har kämpat för att använda Harvard University Wi-Fi,

121
00:06:50,520 --> 00:06:54,780
vet att det finns en CS50 SSID, en Wi-Fi-anslutning, flyter runt

122
00:06:54,780 --> 00:06:56,490
som du kan ha bättre tur för.

123
00:06:56,490 --> 00:07:00,130
Det är lite ironiskt att lösenordet för detta, om du vill försöka ansluta till denna

124
00:07:00,130 --> 00:07:08,350
för bättre hastigheter - och låt oss veta om det är inte bättre - är 12345, hela vägen upp till 8

125
00:07:08,350 --> 00:07:10,910
eftersom 8 är säkrare än 5.

126
00:07:10,910 --> 00:07:16,910
Så om du behöver Wi-Fi-lösenord, anslut till CS50 trådlöst här, 12345678,

127
00:07:16,910 --> 00:07:20,380
och inlägg på CS50 Diskutera om du fortfarande har återkommande anslutningsproblem,

128
00:07:20,380 --> 00:07:25,420
och vi låter de befogenheter som ska veta detta utrymme. Okej.

129
00:07:25,420 --> 00:07:32,230
Så en snabb teaser, särskilt för dem av er som är fan pojkar eller flickor i alla saker Apple.

130
00:07:32,230 --> 00:07:37,460
Vad jag grävde upp från ett par år tillbaka var här filen här, iUnlock.c,

131
00:07:37,460 --> 00:07:39,930
bara för att typ av göra mer konkret och mer komplexa

132
00:07:39,930 --> 00:07:42,560
några av de mer grundläggande C-program som vi har skrivit.

133
00:07:42,560 --> 00:07:46,910
Så jag öppnade filen, iUnlock.c. Den finns på föreläsningar sidan för idag.

134
00:07:46,910 --> 00:07:49,810
På vänster sida ser du en lång lista med funktioner.

135
00:07:49,810 --> 00:07:53,230
Så kolleger som skrev detta skrev upp en massa funktioner, mer än bara stora.

136
00:07:53,230 --> 00:07:57,340
Han använde en massa bibliotek här, och om vi börjar rulla genom,

137
00:07:57,340 --> 00:08:04,890
vad detta egentligen är är den allra första, tror jag, spricka för den ursprungliga iPhone.

138
00:08:04,890 --> 00:08:09,830
>> När du ville jailbreaka den ursprungliga iPhone, vilket innebär untether den från AT & T

139
00:08:09,830 --> 00:08:13,710
och faktiskt installera särskild programvara på den och göra saker som Apple inte vill att folk ska göra,

140
00:08:13,710 --> 00:08:18,480
någon tog sig tid att räkna ut exakt hur de kunde utnyttja programvara brister,

141
00:08:18,480 --> 00:08:22,690
misstag, buggar, i Apple-program, och därmed föddes iUnlock.c--

142
00:08:22,690 --> 00:08:26,760
att om du sammanställt den på din dator och installerat den på en iPhone

143
00:08:26,760 --> 00:08:29,430
som var ansluten till din dator via exempelvis en USB-kabel,

144
00:08:29,430 --> 00:08:32,450
Detta skulle ge dig administrativa eller rotbehörighet på din iPhone

145
00:08:32,450 --> 00:08:34,620
och låter dig göra ganska mycket vad du vill.

146
00:08:34,620 --> 00:08:36,400
Och så det har varit denna fascinerande katt-och råttalek

147
00:08:36,400 --> 00:08:39,340
mellan Apple och resten av världen, särskilt som de, liksom många företag,

148
00:08:39,340 --> 00:08:43,350
Försök att låsa sina grejer ner så att du bara kan göra med den vad de tänker.

149
00:08:43,350 --> 00:08:47,360
Men tack vare personer gillar detta och förståelsen av lågaktivt detaljer -

150
00:08:47,360 --> 00:08:50,830
och i detta fall C-programmering - och en hel del av de välkända konstruktioner

151
00:08:50,830 --> 00:08:55,280
att vi har börjat spela med, kan du verkligen utnyttja hårdvaran

152
00:08:55,280 --> 00:08:59,250
på ett sätt som du tycker passar och inte nödvändigtvis några företagsenhet.

153
00:08:59,250 --> 00:09:01,600
Så till exempel, har jag ingen aning om vad allt detta gör,

154
00:09:01,600 --> 00:09:03,580
men getVersion låter ganska enkelt,

155
00:09:03,580 --> 00:09:05,710
och det ser ut så här är en funktion som denna person skrev.

156
00:09:05,710 --> 00:09:09,250
Det tar någon form av heltal som argument, inte återvänder något,

157
00:09:09,250 --> 00:09:13,710
men verkar slinga med en for-slinga här och en om tillstånd, om tillstånd paus,

158
00:09:13,710 --> 00:09:16,770
och på något sätt avser versionsnummer om vi rulla ner,

159
00:09:16,770 --> 00:09:19,650
även om många av dessa sökord kommer att vara nya.

160
00:09:19,650 --> 00:09:22,590
Och det finns en hel del funktioner i här vi har aldrig sett och kanske inte någonsin se

161
00:09:22,590 --> 00:09:24,350
under loppet av terminen.

162
00:09:24,350 --> 00:09:29,160
>> I slutet av dagen, följer samma regler och logik som vi har spelat med hittills.

163
00:09:29,160 --> 00:09:34,340
Så detta är alldeles för gammal för att knäcka din iPhone 3s eller 4s eller snart 5s dessa dagar,

164
00:09:34,340 --> 00:09:38,830
men vet att det är alla mycket härrör från denna värld som vi har dök in.

165
00:09:38,830 --> 00:09:42,280
Låt oss ta en titt på lite mer enkelt exempel:

166
00:09:42,280 --> 00:09:46,260
här, bara för att få värmas upp med lite syntax och även några andra datatyp

167
00:09:46,260 --> 00:09:48,910
att vi har pratat om, men har inte riktigt sett i C.

168
00:09:48,910 --> 00:09:53,670
Detta är en fil som heter positive1.c, och per kommentarerna överst,

169
00:09:53,670 --> 00:09:56,070
detta kräver bara att användaren ger ett positivt tal.

170
00:09:56,070 --> 00:09:59,910
Så det är ett exempel på en gör-while-slinga, vilket är trevligt för användaren interaktiva program

171
00:09:59,910 --> 00:10:02,070
där du måste tala om för användaren att göra något,

172
00:10:02,070 --> 00:10:05,530
och om de inte samarbetar du skriker åt dem eller förkasta deras input.

173
00:10:05,530 --> 00:10:10,480
Ett typexempel: Jag kommer att göra linjerna 19 till 24

174
00:10:10,480 --> 00:10:14,620
så länge användaren inte har gett mig ett positivt tal.

175
00:10:14,620 --> 00:10:21,340
Denna detalj här på linje 18, varför jag förklarar N över hela denna looping konstruera

176
00:10:21,340 --> 00:10:26,870
i motsats till höger bredvid rad 22 där jag faktiskt bryr få n? Ja.

177
00:10:26,870 --> 00:10:29,330
[Elev] Scope. >> Ja, så det här numret av omfattning.

178
00:10:29,330 --> 00:10:31,770
Och i lekmannaspråk, vad räckvidd hänvisar till?

179
00:10:34,880 --> 00:10:41,560
Ja. >> [Ohörbart elev svar] >> Kan du prata lite högre?

180
00:10:41,560 --> 00:10:45,440
[Elev] Om du kan komma åt den variabeln. >> Perfekt.

181
00:10:45,440 --> 00:10:47,610
Där du kan komma en viss variabel.

182
00:10:47,610 --> 00:10:50,990
Och generellt tumregeln hittills varit att omfattningen av vissa rörliga

183
00:10:50,990 --> 00:10:56,140
definieras av de senaste klammerparenteser som du har sett.

184
00:10:56,140 --> 00:11:03,070
>> Och så i det här fallet, om jag gjorde misstaget att förklara n på linjen 22, skulle den linjen fungerar.

185
00:11:03,070 --> 00:11:10,840
Jag skulle få en int, och jag skulle sätta den i den variabeln n i linje 22,

186
00:11:10,840 --> 00:11:17,060
men som kodrad skulle nu ha någon aning om vad jag pratar om? >> [Elev] 25.

187
00:11:17,060 --> 00:11:23,840
[Malan] 25, och det visar sig 24 och eftersom det i detta fall faller utanför de klammerparenteser.

188
00:11:23,840 --> 00:11:28,550
Så bara en liten bit av en olägenhet men mycket enkelt lösas genom att helt enkelt förklara variabeln

189
00:11:28,550 --> 00:11:30,700
utanför själva funktionen.

190
00:11:30,700 --> 00:11:32,760
Vi får se senare idag kan du gå ett steg längre

191
00:11:32,760 --> 00:11:34,940
och du kan även få lite lat.

192
00:11:34,940 --> 00:11:39,660
Och det är inte att rekommendera i allmänhet, men du kan även få lata

193
00:11:39,660 --> 00:11:44,150
och sätta en variabel globalt, så att säga, inte inne i en funktion, inte inne i en slinga,

194
00:11:44,150 --> 00:11:49,800
men i själva filen, utanför alla funktioner du har skrivit, som jag gjorde här på rad 15.

195
00:11:49,800 --> 00:11:55,220
Detta är vanligtvis ogillande, men inser att detta är en lösning ibland till andra problem,

196
00:11:55,220 --> 00:11:56,910
som vi så småningom se.

197
00:11:56,910 --> 00:11:59,500
Så nu ska vi lämna det så här, men låt oss se om vi kan skriva om detta

198
00:11:59,500 --> 00:12:02,360
bara att börja uttrycka oss lite annorlunda.

199
00:12:02,360 --> 00:12:05,550
Detta program, bara för att vara tydlig, är positive1.

200
00:12:05,550 --> 00:12:11,980
Låt mig gå vidare här och i min terminalfönster göra positive1, Enter.

201
00:12:11,980 --> 00:12:15,080
Sammanställer okej. Jag ska köra positive1, tryck Enter.

202
00:12:15,080 --> 00:12:19,250
Jag kräver att du ger mig ett positivt heltal. Jag ska säga -1. Det fungerade inte.

203
00:12:19,250 --> 00:12:22,340
0, 99. Det verkar fungera.

204
00:12:22,340 --> 00:12:25,310
Kanske inte den mest rigorösa testet, men åtminstone det är en trevlig sanity check

205
00:12:25,310 --> 00:12:27,100
att vi är på rätt väg.

206
00:12:27,100 --> 00:12:29,570
>> Så nu låt mig gå vidare och öppna version 2 av detta,

207
00:12:29,570 --> 00:12:32,800
och vad är annorlunda redan?

208
00:12:32,800 --> 00:12:39,030
Det genomför samma sak, men vad hoppa ut så klart annorlunda den här gången?

209
00:12:40,790 --> 00:12:47,090
Detta bool i grönt. Den lyser grönt, detta sökord som kallas bool, som är en datatyp.

210
00:12:47,090 --> 00:12:50,510
Det kommer inte inbyggd i alla versioner av C.

211
00:12:50,510 --> 00:12:52,650
Du måste inkludera en viss bibliotek.

212
00:12:52,650 --> 00:12:56,460
I vårt fall ingår jag CS50 biblioteket så att vi har tillgång till bool.

213
00:12:56,460 --> 00:12:59,860
Men i linje 18, verkar vi ha ett booleskt värde här kallas tacksam.

214
00:12:59,860 --> 00:13:02,190
Jag kunde ha kallat denna något, men jag kallade det tacksam

215
00:13:02,190 --> 00:13:04,750
bara för att typ av förmedla några semantisk innebörd.

216
00:13:04,750 --> 00:13:07,700
Så först på linjen 18, jag tydligen inte tacksam

217
00:13:07,700 --> 00:13:12,230
eftersom det booleska värdet tacksam initieras till false i linje 18.

218
00:13:12,230 --> 00:13:16,500
Och då verkar det som jag har gjort här i ledningarna 21 till 23

219
00:13:16,500 --> 00:13:19,200
är jag bara lite omskriven min logik.

220
00:13:19,200 --> 00:13:26,100
Så ingen funktionellt olika, men i linje 22 nu jag kontrollera om det int användaren har gett

221
00:13:26,100 --> 00:13:31,360
är större än 0, så ändrar jag bara värdet av tacksamma till true.

222
00:13:31,360 --> 00:13:35,590
Och varför gör jag det? Eftersom i linje 25, tydligen ska jag kolla ett villkor.

223
00:13:35,590 --> 00:13:39,760
Gör denna slinga medan tacksam är falskt.

224
00:13:39,760 --> 00:13:42,960
Så jag föreslog detta som ett alternativ till version 1

225
00:13:42,960 --> 00:13:47,050
eftersom det är åtminstone lite mer intuitiv kanske är det lite mer grundad på engelska.

226
00:13:47,050 --> 00:13:51,980
Så gör du följande när du inte är tacksam eller när tacksamma är falskt.

227
00:13:51,980 --> 00:13:56,220
Och den här gången för jag tydligen bryr inte komma ihåg vad användaren skrivit in

228
00:13:56,220 --> 00:14:00,050
eftersom varsel finns det ingen variabel n, så egentligen, en liten vit lögn där.

229
00:14:00,050 --> 00:14:03,290
>> Funktionellt är programmet lite annorlunda när vi kommer till botten med det

230
00:14:03,290 --> 00:14:04,960
eftersom jag inte ihåg vad n är.

231
00:14:04,960 --> 00:14:09,120
Men jag ville visa även här att även om vi har sett getInt

232
00:14:09,120 --> 00:14:13,780
och GetString som används på den högra sidan av ett likhetstecken hittills

233
00:14:13,780 --> 00:14:17,310
så att vi kommer ihåg värdet, tekniskt, det är inte absolut nödvändigt.

234
00:14:17,310 --> 00:14:20,290
Om du av någon anledning bara inte lust att spara värdet,

235
00:14:20,290 --> 00:14:25,540
du bara vill kontrollera värdet, märker att vi helt enkelt kan skriva detta som getInt,

236
00:14:25,540 --> 00:14:27,320
öppna paren, nära parentes.

237
00:14:27,320 --> 00:14:30,570
Denna funktion kommer att returnera ett värde, som vi har sagt.

238
00:14:30,570 --> 00:14:32,220
Det kommer att ge dig tillbaka en int.

239
00:14:32,220 --> 00:14:34,460
Och så om du tror mentalt att detta ska hända,

240
00:14:34,460 --> 00:14:38,190
När jag skriver in 99, återvänder getInt numret 99,

241
00:14:38,190 --> 00:14:41,840
och så begreppsmässigt, är det som om min kod var faktiskt här.

242
00:14:41,840 --> 00:14:45,950
Så om 99 verkligen är större än 0, så tacksam blir sann,

243
00:14:45,950 --> 00:14:50,810
sedan linje 25 inser ooh, vi gjort eftersom jag nu tacksam,

244
00:14:50,810 --> 00:14:53,970
och i linje 26, säger vi helt enkelt "Tack för den positiva heltal!"

245
00:14:53,970 --> 00:14:55,960
vad det råkade vara.

246
00:14:55,960 --> 00:14:59,140
Nu ska vi göra något syntaktisk socker här, så att säga.

247
00:14:59,140 --> 00:15:04,670
Låt oss se om vi kan städa upp denna linje 25 med denna tredje och sista varianten i positive3.

248
00:15:04,670 --> 00:15:13,600
>> Lägg märke till den enda skillnaden nu är vad kodrad? >> [Elev] 25. >> [Malan] Ja, 25.

249
00:15:13,600 --> 00:15:17,680
Och vi har inte har verkligen sett detta trick ännu, men vi såg utropstecken på måndag,

250
00:15:17,680 --> 00:15:21,070
som betecknar vad? >> [Elev] inte. >> Ej eller förnekande.

251
00:15:21,070 --> 00:15:23,510
Så ta ett booleskt värde och vända dess värde.

252
00:15:23,510 --> 00:15:25,810
True blir falskt, blir falskt sant.

253
00:15:25,810 --> 00:15:30,420
Så det här, jag skulle föreslå, är ännu lite mer intuitivt sätt att skriva koden

254
00:15:30,420 --> 00:15:33,430
eftersom jag fortfarande initiera tacksam till false, gör jag fortfarande följande,

255
00:15:33,430 --> 00:15:36,010
Jag satt tacksam till true när det är dags,

256
00:15:36,010 --> 00:15:40,880
men nu kan du egentligen bara översätta denna kod muntligen vänster till höger,

257
00:15:40,880 --> 00:15:45,630
medan (tacksam!), därför Bang eller utropstecken anger begreppet inte,

258
00:15:45,630 --> 00:15:47,580
så även om de inte tacksam.

259
00:15:47,580 --> 00:15:49,900
Så återigen, har vi infört några nya begrepp i sig.

260
00:15:49,900 --> 00:15:53,730
Vi pratade om Booleans tillbaka när vi spelade med Scratch,

261
00:15:53,730 --> 00:15:56,720
men nu inser vi bara kan börja skriva vår kod på många olika sätt.

262
00:15:56,720 --> 00:16:01,060
Så speciellt i pset1 om du typ av kämpar för att räkna ut sätt att skriva något program,

263
00:16:01,060 --> 00:16:04,340
oddsen är du tur eftersom det kan finnas ett obegränsat antal lösningar

264
00:16:04,340 --> 00:16:06,110
som du kan hända på.

265
00:16:06,110 --> 00:16:10,500
Till exempel, är detta bara 3 för även de enklaste av programmen. Okej.

266
00:16:10,500 --> 00:16:14,200
Och nu minns på måndag vi kvar på denna not med returvärden.

267
00:16:14,200 --> 00:16:18,450
Så för första gången skrev vi ett program som inte bara har stora;

268
00:16:18,450 --> 00:16:22,550
Det har också sin egen anpassad funktion som jag skrev här.

269
00:16:22,550 --> 00:16:26,810
Så i linje 31 till 34 har jag genomfört en kub funktion.

270
00:16:26,810 --> 00:16:30,240
Det är inte komplicerat. Det är bara en * a * a i detta fall.

271
00:16:30,240 --> 00:16:34,750
Men vad som är viktigt om det är att jag tar in i form av en

272
00:16:34,750 --> 00:16:39,180
och jag tillbaka ut i form av en * a * a.

273
00:16:39,180 --> 00:16:43,560
Så nu har jag möjlighet, ungefär som jag brukade med prinf ensam,

274
00:16:43,560 --> 00:16:47,240
att kalla denna funktion genom att ringa kuben funktionen.

275
00:16:47,240 --> 00:16:51,970
>> Och kuben funktionen tar lite input och kuben returnerar någon utgång.

276
00:16:51,970 --> 00:16:56,960
Däremot gjorde printf bara något.

277
00:16:56,960 --> 00:17:00,840
Det tog inte tillbaka någonting som vi brydde sig om, även om som en undan det gör returnera ett värde;

278
00:17:00,840 --> 00:17:03,110
du bara allmänt ignorera det.

279
00:17:03,110 --> 00:17:06,510
Printf bara gjorde något. Den hade en bieffekt av att skriva ut på skärmen.

280
00:17:06,510 --> 00:17:11,770
Däremot här har vi kuben funktionen, som faktiskt återvänder något.

281
00:17:11,770 --> 00:17:15,520
Så för dem som känner till detta, det är en ganska enkel idé.

282
00:17:15,520 --> 00:17:19,640
Men för de mindre bekant med denna idé om att passera i ingångar och komma tillbaka utgångar,

283
00:17:19,640 --> 00:17:21,950
låt oss försöka bara något super enkelt.

284
00:17:21,950 --> 00:17:25,490
Är det någon bekväm kommer upp på scenen en kort stund?

285
00:17:25,490 --> 00:17:28,040
Du måste vara bekväm med en kamera på dig också. Ja? Okej.

286
00:17:28,040 --> 00:17:31,240
Vad heter du? >> [Studenten] Ken. >> Ken. Okej. Ken, kom upp.

287
00:17:31,240 --> 00:17:35,050
Ken kommer att vara en funktion av slag här.

288
00:17:35,050 --> 00:17:38,720
Låt oss gå vidare och göra det. Låt oss få lite fantasi.

289
00:17:38,720 --> 00:17:42,260
TREVLIGT ATT TRÄFFAS. Välkommen till centrum. Okej.

290
00:17:42,260 --> 00:17:46,640
Låt oss slå den här knappen här. Okej.

291
00:17:46,640 --> 00:17:49,820
Så här har du en modern svarta tavlan,

292
00:17:49,820 --> 00:17:53,470
och vad jag är den viktigaste funktionen, till exempel,

293
00:17:53,470 --> 00:17:56,460
och jag har inte en iPad i min hand.

294
00:17:56,460 --> 00:17:59,710
>> Jag förstår inte riktigt ihåg hur man - Tja, jag kan inte säga det.

295
00:17:59,710 --> 00:18:02,480
Jag har inte riktigt bra handstil,

296
00:18:02,480 --> 00:18:05,520
och så därför vill jag att du skriver ut något på skärmen för mig.

297
00:18:05,520 --> 00:18:12,040
Jag är huvudprogrammet, och jag kommer att få dig att säga det här

298
00:18:12,040 --> 00:18:16,720
genom att skriva det i min kyckling repa och sedan passerar du en ingång.

299
00:18:16,720 --> 00:18:20,400
Så dumt men denna övning är, begreppet funktioner och kräver en funktion

300
00:18:20,400 --> 00:18:22,400
och returnera en funktion verkligen kokar ner till detta.

301
00:18:22,400 --> 00:18:26,260
Jag är viktigaste, har jag skrivit bara printf, citat-unquote något på skärmen,

302
00:18:26,260 --> 00:18:29,110
Jag kör det här programmet, och så fort printf anropas,

303
00:18:29,110 --> 00:18:32,880
det tar ett argument eller en parameter ibland mellan citationstecken.

304
00:18:32,880 --> 00:18:35,880
Här är det argumentet. Jag passerar den till Ken.

305
00:18:35,880 --> 00:18:39,020
Han är en svart låda skrivit ett visst antal år sedan

306
00:18:39,020 --> 00:18:41,510
som uppenbarligen bara vet hur man skriver ut saker på skärmen.

307
00:18:41,510 --> 00:18:43,150
Så exekvera.

308
00:18:49,280 --> 00:18:51,280
Det är inte illa. Mycket bra.

309
00:18:51,280 --> 00:18:55,510
Så nu Ken görs köra. Behöver han att lämna mig någonting tillbaka?

310
00:18:55,510 --> 00:18:57,470
Inte för att vi har sett hittills.

311
00:18:57,470 --> 00:19:00,460
Återigen, inte printf faktiskt returnera ett tal, men vi kommer att ignorera det för nu

312
00:19:00,460 --> 00:19:03,470
eftersom vi aldrig har använt den. Så det är det för Ken.

313
00:19:03,470 --> 00:19:08,580
Och så nu viktigaste tar över kontrollen av programmet igen

314
00:19:08,580 --> 00:19:11,060
eftersom det kodrad, printf, görs köra.

315
00:19:11,060 --> 00:19:14,050
Och vi går om vår väg, köra oavsett andra linjer finns.

316
00:19:14,050 --> 00:19:17,320
Så nu ska vi prova en lite annorlunda exempel.

317
00:19:17,320 --> 00:19:24,940
Den här gången låter här första rensa skärmen, och den här gången ska vi göra cubing funktion,

318
00:19:24,940 --> 00:19:27,080
men den här gången, jag förväntar mig ett produktionsvärde.

319
00:19:27,080 --> 00:19:29,180
>> Så låt oss gå vidare och göra det.

320
00:19:29,180 --> 00:19:35,790
Nu har jag en kodrad som säger X får kub av X.

321
00:19:41,370 --> 00:19:46,370
Kodraden, minns, ser ut så här: x = cube (x);

322
00:19:46,370 --> 00:19:50,930
Så hur kommer detta att fungera? Låt oss gå vidare och ge dig en vit skärm igen.

323
00:19:50,930 --> 00:19:54,070
Jag kommer att skriva ner nu värdet av x,

324
00:19:54,070 --> 00:20:01,400
som vid denna tidpunkt råkar vara, låt oss säga, 2 för att hålla det enkelt.

325
00:20:01,400 --> 00:20:06,150
Jag har skrivit ner på ett papper värdet 2, vilket är mitt värde x.

326
00:20:06,150 --> 00:20:10,920
Jag lämna det till Ken. >> Och jag skriver bara svaret? >> Ja, låt oss bara skriva svaret.

327
00:20:12,760 --> 00:20:18,940
Okej. Och nu måste han återvända mig något. Perfekt. Trevlig Segue.

328
00:20:18,940 --> 00:20:23,120
Så nu har han överlämnar mig tillbaka värdet 8 i detta fall, och vad gör jag med den?

329
00:20:23,120 --> 00:20:28,250
Faktiskt - låt oss se, få denna rätt. Vad ska jag göra med den?

330
00:20:28,250 --> 00:20:33,440
Nu ska jag ta detta värde och faktiskt lagra den i samma bitar i minnet.

331
00:20:33,440 --> 00:20:35,170
Men märker jag är typ att kämpa här.

332
00:20:35,170 --> 00:20:38,210
Jag är lite förvirrad eftersom där kan jag faktiskt skriva värdet för x,

333
00:20:38,210 --> 00:20:43,150
för det jag har just gjort är fysiskt handen Ken ett papper som hade värdet 2,

334
00:20:43,150 --> 00:20:46,590
som var X, och faktiskt, det är precis vad som hände.

335
00:20:46,590 --> 00:20:50,210
Så det visar sig att när du ringer funktionen och du passerar på ett argument

336
00:20:50,210 --> 00:20:53,290
Liksom hej, värld eller om du passerar i ett argument som 2,

337
00:20:53,290 --> 00:20:57,110
allmänhet, du passerar i en kopia av detta argument.

338
00:20:57,110 --> 00:21:00,730
Och så precis som jag skrev ner numret 2 här och gav den till Ken,

339
00:21:00,730 --> 00:21:04,720
det måste betyda att jag fortfarande har en kopia av värdet 2 någonstans

340
00:21:04,720 --> 00:21:08,890
eftersom faktiskt, nu när jag har fått tillbaka värdet 8, måste jag gå tillbaka i RAM

341
00:21:08,890 --> 00:21:12,130
och faktiskt skriva ner 8 där jag en gång hade numret 2.

342
00:21:12,130 --> 00:21:16,950
Så visuellt, kom ihåg detta begrepp att passera i, bokstavligen, en kopia av värdet.

343
00:21:16,950 --> 00:21:20,780
>> Ken gör sin grej, händer mig något - i det här fallet ett värde som 8 -

344
00:21:20,780 --> 00:21:24,980
och då måste jag göra något med det värdet om jag vill hålla det runt.

345
00:21:24,980 --> 00:21:29,650
Så allt detta kommer att komma tillbaka för att vara alltför bekant kort.

346
00:21:29,650 --> 00:21:34,920
Tack så mycket för denna demo här, Ken. [Applåder]

347
00:21:34,920 --> 00:21:36,920
Mycket bra gjort.

348
00:21:36,920 --> 00:21:42,690
Låt oss se hur det i slutändan rör en del av den funktion kräver att vi har gjort här.

349
00:21:42,690 --> 00:21:47,910
Låt mig gå vidare och föra oss tillbaka till cubing exempel.

350
00:21:47,910 --> 00:21:53,300
Observera att om vi vill faktiskt börjar ta detta ytterligare,

351
00:21:53,300 --> 00:21:57,570
vi kommer att vara uppmärksam på det faktum att antalet X som är passeras här

352
00:21:57,570 --> 00:22:01,530
skiljer sig från vad som faktiskt skickas in till funktionen.

353
00:22:01,530 --> 00:22:05,880
Så återigen, är detta pass med kopia kommer att bli ganska relevant på bara ett ögonblick.

354
00:22:05,880 --> 00:22:09,580
Låt oss ta en titt på något som inte riktigt fungerar rätt ännu.

355
00:22:09,580 --> 00:22:13,250
Jag ska gå vidare och öppna tredjedel buggy exempel som felaktig av naturen,

356
00:22:13,250 --> 00:22:18,550
och det kallas buggy3 och genomför en swapping funktion.

357
00:22:18,550 --> 00:22:25,110
Här har vi en huvudfunktion som x och y godtyckligt initieras till 1 respektive 2.

358
00:22:25,110 --> 00:22:27,700
Vi skulle kunna använda getInt, men vi behöver bara en enkel övning,

359
00:22:27,700 --> 00:22:30,170
så det är hårdkodad som 1 och 2.

360
00:22:30,170 --> 00:22:35,340
I linjerna 21 och 22, ut vi tydligen ut x och y, 1 per rad.

361
00:22:35,340 --> 00:22:39,720
Sedan på rad 23, hävdar jag jag byta dessa värden, punkt, punkt, punkt.

362
00:22:39,720 --> 00:22:44,170
Jag kallar tydligen en funktion i linje 24 kallas swap som tar 2 argument.

363
00:22:44,170 --> 00:22:48,300
Det är helt legit för funktioner för att ta 2 argument. Vi har sett printf gör det redan.

364
00:22:48,300 --> 00:22:51,830
>> Så swap tar tydligen x och y, och som namnet antyder,

365
00:22:51,830 --> 00:22:54,670
Jag hoppas att det kommer att byta dessa 2 värden.

366
00:22:54,670 --> 00:23:00,090
Så då jag hävdar på rad 25 "Swappat!" och jag nytryck x och y

367
00:23:00,090 --> 00:23:03,070
under antagandet att de verkligen har bytts.

368
00:23:03,070 --> 00:23:06,080
Men om jag faktiskt köra programmet - låt mig öppna upp ett terminalfönster,

369
00:23:06,080 --> 00:23:09,860
Låt mig göra buggy3 - som namnet antyder, detta kommer inte att sluta bra

370
00:23:09,860 --> 00:23:15,770
för när jag trycker på Retur, märker att x är 1, y 2,

371
00:23:15,770 --> 00:23:19,420
och ändå vid slutet av programmet, är de fortfarande i själva verket densamma.

372
00:23:19,420 --> 00:23:22,960
Så baserad på visad just nu med Ken, vad egentligen som händer?

373
00:23:22,960 --> 00:23:28,710
Låt oss dyka in i denna swap funktion. Det är super kort. Det är bara några få rader kod lång.

374
00:23:28,710 --> 00:23:34,520
Men vad är det grundläggande problemet baseras på den enkla berättelse här uppe med Ken?

375
00:23:34,520 --> 00:23:36,670
Varför swap bruten?

376
00:23:36,670 --> 00:23:39,660
[Elev] Du lagrar en kopia, inte variabeln.

377
00:23:39,660 --> 00:23:43,980
Exakt. Vi lagrar en kopia, inte variabeln själv.

378
00:23:43,980 --> 00:23:47,170
Med andra ord tar swap tydligen 2 argument en int,

379
00:23:47,170 --> 00:23:49,370
och det godtyckligt kallas a och b,

380
00:23:49,370 --> 00:23:54,420
och här uppe har jag gått i x-och y som är respektive 1 och 2,

381
00:23:54,420 --> 00:23:58,770
men jag inte bokstavligen är passerar i X, jag är inte bokstavligen passerar i år,

382
00:23:58,770 --> 00:24:01,450
Jag passerar en kopia av x och en kopia av y..

383
00:24:01,450 --> 00:24:04,510
Det är nästan som om du kopieras och klistras in swap

384
00:24:04,510 --> 00:24:07,810
de värden som du vill att det ska faktiskt manipulera.

385
00:24:07,810 --> 00:24:14,480
Så om så är fallet, när jag programstart utför linje 35 sedan 36,

386
00:24:14,480 --> 00:24:18,650
när jag kommer till linjen 37, vid denna punkt i berättelsen, är det värdet av en?

387
00:24:21,040 --> 00:24:25,050
Vid denna punkt i berättelsen, linje 37, vad är värdet av en vid det här laget? >> [Elev] 1.

388
00:24:25,050 --> 00:24:29,280
[Malan] Det bör bara vara 1, höger, eftersom x passerades i det första argumentet,

389
00:24:29,280 --> 00:24:33,080
och denna funktion bara godtyckligt ringer sitt första argument en.

390
00:24:33,080 --> 00:24:38,200
Likaså är y det andra argumentet och det är bara godtyckligt ringer det andra argumentet miljarder.

391
00:24:38,200 --> 00:24:40,990
>> Denna dikotomi är faktiskt ganska enkelt förklaras. Tänk på det.

392
00:24:40,990 --> 00:24:43,320
Ingen av oss har träffat den person som skrev printf,

393
00:24:43,320 --> 00:24:50,770
så väl, har han eller hon ingen aning om vad våra variabler 30 år senare kommer att kallas.

394
00:24:50,770 --> 00:24:56,650
Så det måste finnas en skillnad mellan vad du kallar variabler i funktioner du skriver

395
00:24:56,650 --> 00:25:02,080
och vad du kallar variabler i funktioner du ringer eller använder.

396
00:25:02,080 --> 00:25:05,340
Så med andra ord, har jag skrivit mina variabler som x och y,

397
00:25:05,340 --> 00:25:08,890
men om någon annan hade skrivit swap-funktionen, han eller hon absolut inte skulle veta

398
00:25:08,890 --> 00:25:10,690
vad mina variabler kommer att kallas,

399
00:25:10,690 --> 00:25:13,830
så inser att det är därför du har denna dualism av namn.

400
00:25:13,830 --> 00:25:16,750
Tekniskt skulle jag göra det av en tillfällighet,

401
00:25:16,750 --> 00:25:20,080
men de skulle ändå föras in som kopior.

402
00:25:20,080 --> 00:25:23,650
Det skulle bara vara en ren tillfällighet estetiskt om personen som skrev swap

403
00:25:23,650 --> 00:25:26,150
hade använt samma namn.

404
00:25:26,150 --> 00:25:32,370
Så på denna punkt i berättelsen, linje 37, är en 1, b är 2, och nu har jag fortsätter att byta dem.

405
00:25:32,370 --> 00:25:34,900
Först av allt, låt mig faktiskt göra det mycket enklare.

406
00:25:34,900 --> 00:25:36,690
Jag vet inte vad de 3 rader kod gjorde.

407
00:25:36,690 --> 00:25:41,210
Låt mig bara göra detta: b = a, a = b; gjort.

408
00:25:41,210 --> 00:25:44,690
Varför är denna trasig, logiskt?

409
00:25:46,490 --> 00:25:48,900
Det är typ av intuitiva sak, eller hur?

410
00:25:48,900 --> 00:25:52,560
Så en blir b och b blir,

411
00:25:52,560 --> 00:25:57,730
men problemet är att så snart som linjen 37 utför, vad är värdet av a och b?

412
00:25:57,730 --> 00:26:03,410
Detsamma, 1, eftersom du har clobbered, så att säga, du har ändrat b för lika en.

413
00:26:03,410 --> 00:26:08,890
Så när linjen 37 har utförts, det är bra, har du nu 2 kopior av nummer 1

414
00:26:08,890 --> 00:26:13,350
insidan av denna funktion, så då när du säger i linje 38 a = b,

415
00:26:13,350 --> 00:26:17,640
du typ av skruvade eftersom du bara tilldela 1 till 1.

416
00:26:17,640 --> 00:26:20,580
Du har typ av förlorat det värde som du brydde dig om.

417
00:26:20,580 --> 00:26:23,220
Så i den ursprungliga versionen av detta, märker vad jag gjorde.

418
00:26:23,220 --> 00:26:26,850
Jag hade i stället tredjedel kodrad som såg ut så här.

419
00:26:26,850 --> 00:26:28,580
Jag förklarar en temporär variabel.

420
00:26:28,580 --> 00:26:32,170
>> Tmp är en mycket vanlig namn för en temporär variabel, och det är en int

421
00:26:32,170 --> 00:26:34,580
eftersom det har att matcha vad jag vill göra en kopia av.

422
00:26:34,580 --> 00:26:39,770
Jag lagrar kopia av en insida av TMP, så när linjen 37 har utförts,

423
00:26:39,770 --> 00:26:45,860
Värdet på a är - snabb sanity kontroll - 1, är värdet av b 2,

424
00:26:45,860 --> 00:26:48,970
och värdet av TMP är också 1.

425
00:26:48,970 --> 00:26:52,060
Så nu har jag köra linje 38.

426
00:26:52,060 --> 00:27:00,540
När linjen 38 utför, tar på värdet av b. Och b var 2, så en är nu 2.

427
00:27:00,540 --> 00:27:05,210
Så vid denna punkt i berättelsen, är en 2, b är 2, och tmp är 1,

428
00:27:05,210 --> 00:27:11,060
så nu logiskt kan vi bara plopp tmp värde i b och vi är klara.

429
00:27:11,060 --> 00:27:12,800
Så vi har löst problemet.

430
00:27:12,800 --> 00:27:17,720
Tyvärr, när jag kör det här programmet i denna form, inte egentligen byta några värden.

431
00:27:17,720 --> 00:27:20,100
Men för att vara tydlig, varför?

432
00:27:23,660 --> 00:27:26,450
Jag fixade den logiska problemet från bara en liten stund sedan,

433
00:27:26,450 --> 00:27:31,020
men återigen, om jag kör det här programmet, x och y är oförändrade

434
00:27:31,020 --> 00:27:33,310
i slutet av programmets genomförande.

435
00:27:33,310 --> 00:27:37,220
[Ohörbart elev kommentar] >> Vi har inte återvänt någonting, så det är sant.

436
00:27:37,220 --> 00:27:39,670
Men det visar sig att det är lite av ett problem här eftersom hittills,

437
00:27:39,670 --> 00:27:44,170
det enda vi har kunnat återvända är en sak, och det är en begränsning av C.

438
00:27:44,170 --> 00:27:49,070
Du kan bara returnera verkligen ett värde, i vilket fall är jag typ av fastnat här

439
00:27:49,070 --> 00:27:53,310
eftersom jag kunde återvända det nya värdet på x eller jag kunde återvända det nya värdet på y,

440
00:27:53,310 --> 00:27:55,190
men jag vill båda tillbaka.

441
00:27:55,190 --> 00:27:58,650
Så återvänder inte den enkla lösningen här.

442
00:27:58,650 --> 00:28:01,710
Men problemet är i grunden varför? Vad har vi bytte egentligen?

443
00:28:01,710 --> 00:28:04,190
[Eleven] a och b. >> A och b.

444
00:28:04,190 --> 00:28:08,230
Men a och b är kopior av x och y, vilket innebär att vi bara gjorde allt detta arbete,

445
00:28:08,230 --> 00:28:11,650
Vi tillbringade bara 3 minuter talar om swap funktion och alla 3 av dessa variabler,

446
00:28:11,650 --> 00:28:15,420
och det är bra, helt rätt för sig,

447
00:28:15,420 --> 00:28:20,740
men a och b omfattning är bara i dessa rader här.

448
00:28:20,740 --> 00:28:24,790
>> Så precis som en for-slinga, om du deklarerar ett heltal i innanför for-slingan,

449
00:28:24,790 --> 00:28:28,760
Likaså om du förklara a och b inuti en funktion som du har skrivit,

450
00:28:28,760 --> 00:28:33,320
de är endast giltiga insidan av den funktionen, vilket innebär så snart swap görs utför

451
00:28:33,320 --> 00:28:38,470
och vi går från rad 24 till rad 25, har x och y inte ändrats alls.

452
00:28:38,470 --> 00:28:42,790
Du slösat bara en massa tid att byta kopior av variabler.

453
00:28:42,790 --> 00:28:47,010
Så det visar sig att lösningen på detta är faktiskt inte självklart.

454
00:28:47,010 --> 00:28:50,670
Det är inte riktigt tillräckligt för att returnera värden eftersom vi bara kan returnera 1 värde,

455
00:28:50,670 --> 00:28:53,470
och jag vill verkligen byta både x och y samtidigt,

456
00:28:53,470 --> 00:28:55,210
så vi kommer att behöva komma tillbaka till detta.

457
00:28:55,210 --> 00:29:01,020
Men nu inser att frågan i grunden härstammar från det faktum att a och b är kopior

458
00:29:01,020 --> 00:29:03,630
och de är i sin egen räckvidd.

459
00:29:03,630 --> 00:29:05,050
Låt oss försöka lösa detta på något sätt.

460
00:29:05,050 --> 00:29:11,250
Låt mig faktiskt rulla tillbaka hit och öppna upp, låt oss säga, en fjärde variant av detta, buggy4.

461
00:29:11,250 --> 00:29:13,370
Vad sägs om det här?

462
00:29:13,370 --> 00:29:17,810
Detta är en liknande men enklare problem att titta på innan vi tar ett hugg på att lösa det.

463
00:29:17,810 --> 00:29:24,190
Detta program kallas steg, och det tydligen initierar en x heltal till 1 i linje 18.

464
00:29:24,190 --> 00:29:28,150
Jag sedan hävdar x är 1, hävdar jag då "uppräkning ..."

465
00:29:28,150 --> 00:29:33,730
Jag kallar då steg, men då i ledningarna 22 och 23, jag hävdar att det är ökats,

466
00:29:33,730 --> 00:29:40,220
Jag hävdar x är nu vad det är - 2, förmodligen - men det här programmet är buggigt.

467
00:29:40,220 --> 00:29:42,610
Vad är problemet?

468
00:29:43,440 --> 00:29:50,160
Ja. >> [Ohörbart elev svar] >> Exakt.

469
00:29:50,160 --> 00:29:52,490
SO x har försatts naturligtvis på linje 18.

470
00:29:52,490 --> 00:29:54,700
Det är inne i centrala s klammerparenteser.

471
00:29:54,700 --> 00:29:58,440
Så det enkla svaret här är att medan X finns här,

472
00:29:58,440 --> 00:30:03,930
Det finns inte i linje 32, så detta program faktiskt inte ens kommer att sammanställa.

473
00:30:03,930 --> 00:30:07,940
Kompilatorn när jag försöker kompilera koden kommer att skrika på mig

474
00:30:07,940 --> 00:30:14,100
om några odeklarerat identifierare eller något om detta. I själva verket, låt oss försöka.

475
00:30:14,100 --> 00:30:18,470
Det är att buggy4. Där är det.

476
00:30:18,470 --> 00:30:22,110
Användning av odeklarerat identifierare "x" i linje 32.

477
00:30:22,110 --> 00:30:25,580
Och faktiskt, låt oss vara tydligare här i dag, så att det är användbart

478
00:30:25,580 --> 00:30:27,580
i kontorstid och hemma.

479
00:30:27,580 --> 00:30:29,300
>> Observera att det är lite kryptiskt skrivet.

480
00:30:29,300 --> 00:30:37,270
Men det faktum att clang har yelled på oss, säger buggy4.c: 32:5, är faktiskt bra.

481
00:30:37,270 --> 00:30:42,050
Det betyder att felet är på linje 32 vid teckenposition 5.

482
00:30:42,050 --> 00:30:46,700
Så 1, 2, 3, 4, 5. Det är i själva verket där problemet är.

483
00:30:46,700 --> 00:30:49,790
Och även också tänka på kontorstid och hemma, jag är lycklig här.

484
00:30:49,790 --> 00:30:52,990
Jag har en misstag. Det kommer att vara relativt lätt att åtgärda.

485
00:30:52,990 --> 00:30:55,990
Men om du får en hel skärm full med överväldigande felmeddelanden,

486
00:30:55,990 --> 00:31:00,330
återigen inse att den nedersta en bara kan vara ett tecken på den översta en.

487
00:31:00,330 --> 00:31:03,450
Så alltid jaga ner dina fel uppifrån och ned

488
00:31:03,450 --> 00:31:05,820
eftersom det kan bara vara en kedjekoppling effekt

489
00:31:05,820 --> 00:31:09,240
som föreslår att du har sätt fler problem än vad du faktiskt gör.

490
00:31:09,240 --> 00:31:15,150
Så hur kan vi fixa detta om mitt mål är att öka x? >> [Elev] Gör X globalt.

491
00:31:15,150 --> 00:31:17,060
Okej, så vi kan göra X globala.

492
00:31:17,060 --> 00:31:20,480
Låt oss ta en genväg som jag varnade tidigare, men heck, vi behöver bara en snabb lösning,

493
00:31:20,480 --> 00:31:25,730
så låt oss bara säga int x upp här. Det gör X global.

494
00:31:25,730 --> 00:31:31,800
Så nu viktigaste har tillgång till den och steg har tillgång till det,

495
00:31:31,800 --> 00:31:34,110
och så låt mig gå vidare och sammanställa detta nu.

496
00:31:34,110 --> 00:31:37,630
Gör buggy4, Enter. Verkar kompilera nu.

497
00:31:37,630 --> 00:31:41,230
Låt oss köra buggy4. Och det verkar faktiskt fungera.

498
00:31:41,230 --> 00:31:45,150
Detta är en av dessa saker som är gör som jag säger, inte som jag gör,

499
00:31:45,150 --> 00:31:47,010
som jag bara har gjort här, för i allmänhet,

500
00:31:47,010 --> 00:31:50,440
våra program kommer att få mycket mer intressant och mycket längre än så här,

501
00:31:50,440 --> 00:31:56,390
och om din lösning på livets problem är bara sätta alla variabler på toppen av din fil,

502
00:31:56,390 --> 00:31:59,690
mycket snabbt får program får fasansfullt svårt att hantera.

503
00:31:59,690 --> 00:32:02,190
Det blir svårare att komma på nya variabelnamn,

504
00:32:02,190 --> 00:32:05,240
det blir svårare att förstå vad variabeln gör vad,

505
00:32:05,240 --> 00:32:08,460
och så i allmänhet är detta inte en bra lösning.

506
00:32:08,460 --> 00:32:10,030
Så låt oss göra det här bättre.

507
00:32:10,030 --> 00:32:12,160
Vi vill inte använda en global variabel här.

508
00:32:12,160 --> 00:32:16,240
>> Jag vill öka X, så jag kunde naturligtvis -

509
00:32:16,240 --> 00:32:18,670
i slutet av dagen, är denna typ av en dum historia eftersom vi bara gör det -

510
00:32:18,670 --> 00:32:24,450
men om jag inte visste om det operatören eller jag fick inte ändra det i huvud själv,

511
00:32:24,450 --> 00:32:30,730
Hur skulle jag genomföra Ken hit den här gången inte kub utan att öka?

512
00:32:31,380 --> 00:32:33,190
Hur ändrar jag det här här? Ja.

513
00:32:33,190 --> 00:32:38,480
[Elev] Pass i x och sedan återvända [ohörbart] >> Okej, bra.

514
00:32:38,480 --> 00:32:41,900
Så varför inte jag gå i x och sedan i stället tillbaka den,

515
00:32:41,900 --> 00:32:44,870
varför inte jag bara inte tillbaka x + 1.

516
00:32:44,870 --> 00:32:47,710
Ett par fler saker måste förändras här. Jag är på rätt spår.

517
00:32:47,710 --> 00:32:49,770
Vad behöver jag för att justera? Någon annan. Ja.

518
00:32:49,770 --> 00:32:51,740
[Ohörbart elev svar]

519
00:32:51,740 --> 00:32:54,730
Jag behöver ändra tillbaka typ av steg eftersom det inte är ogiltig.

520
00:32:54,730 --> 00:32:57,780
Void betyder ingenting skickas tillbaka, men uppenbarligen nu är det,

521
00:32:57,780 --> 00:32:59,830
så detta måste ändras till - >> [elev] int.

522
00:32:59,830 --> 00:33:02,740
int vara förenlig med vad jag faktiskt tillbaka.

523
00:33:02,740 --> 00:33:05,180
Nu något annat är fortfarande buggigt här. Ja.

524
00:33:05,180 --> 00:33:08,400
[Ohörbart elev svar] >> [Malan] Så jag måste öka x?

525
00:33:08,400 --> 00:33:12,080
[Ohörbart elev svar] >> [Malan] Ah, så jag måste gå x.

526
00:33:12,080 --> 00:33:16,660
Så jag behöver göra det här. >> [Ohörbart elev kommentar]

527
00:33:16,660 --> 00:33:20,050
[Malan] Så prototypen, jag måste ändra detta här.

528
00:33:20,050 --> 00:33:22,930
Så detta måste bli en int, måste detta bli -

529
00:33:22,930 --> 00:33:25,620
hmm, jag har faktiskt en bugg här nere. Låt oss fixa detta först.

530
00:33:25,620 --> 00:33:29,590
Vad ska det vara egentligen? Det måste vara en int något.

531
00:33:29,590 --> 00:33:32,700
Det kan vara X, men ärligt talat, om du börjar ringa alla dina variabler x,

532
00:33:32,700 --> 00:33:35,390
det kommer att bli mindre och mindre tydlig vilken som är vilken.

533
00:33:35,390 --> 00:33:39,560
>> Så låt oss bara godtyckligt välja en annan namnkonvention för mina hjälpfunktioner,

534
00:33:39,560 --> 00:33:41,940
funktioner jag skriver. Vi kallar det en, eller vi kan kalla det -

535
00:33:41,940 --> 00:33:45,010
Låt oss kalla det nummer för att bli ännu tydligare.

536
00:33:45,010 --> 00:33:47,560
Så då måste jag återvända oavsett antalet är plus 1,

537
00:33:47,560 --> 00:33:50,740
och nu har jag ändra 1 sak upp här och en annan sak här.

538
00:33:50,740 --> 00:33:54,350
Vad ska jag byta på linje 21 först? >> [Ohörbart elev svar]

539
00:33:54,350 --> 00:33:57,610
[Malan] Jag måste tilldela den till x. Jag kan inte bara ringa ökning (x).

540
00:33:57,610 --> 00:34:01,960
Jag behöver komma ihåg svaret genom att ändra värdet på x på vänster sida.

541
00:34:01,960 --> 00:34:04,680
Och även om x är nu på vänster och höger, det är helt bra

542
00:34:04,680 --> 00:34:08,860
eftersom den högra sidan blir utförs först sedan får plopped in vänster sak -

543
00:34:08,860 --> 00:34:10,600
X i detta fall.

544
00:34:10,600 --> 00:34:12,159
Och då slutligen, är detta en enkel fix nu.

545
00:34:12,159 --> 00:34:17,230
Detta bör bara matcha vad nere, int antal.

546
00:34:17,230 --> 00:34:20,570
Så en hel massa förändringar för en riktigt dum funktion

547
00:34:20,570 --> 00:34:24,420
men representativ för saker som vi alltmer kommer att vilja göra.

548
00:34:24,420 --> 00:34:27,090
Så gör buggy4. Jag har skruvat upp någonstans.

549
00:34:27,090 --> 00:34:30,139
Herregud. Fem misstag i en 6-line-programmet.

550
00:34:30,139 --> 00:34:35,690
Så vad är det för fel på rad 18, 5 tecken?

551
00:34:35,690 --> 00:34:39,610
Så jag måste förklara detta, int.

552
00:34:39,610 --> 00:34:41,920
Låt oss se. Det finns en hel massa andra fel.

553
00:34:41,920 --> 00:34:47,010
Herregud - 19, 18, 21 - men återigen, låt oss bara rensa skärmen, Control L här,

554
00:34:47,010 --> 00:34:49,380
och kör klang.

555
00:34:49,380 --> 00:34:51,340
Så 5 problem är faktiskt bara att 1.

556
00:34:51,340 --> 00:34:57,520
Så nu ska vi köra buggy4, Enter. Puh, har X ökats korrekt.

557
00:34:57,520 --> 00:35:02,720
Okej. Har du frågor om hur man öka siffror? Ja.

558
00:35:02,720 --> 00:35:09,870
[Ohörbart elev fråga] >> Bra fråga.

559
00:35:09,870 --> 00:35:14,220
Hur kommer det sig att jag bara kan byta x till antalet och programmet kommer att veta direkt?

560
00:35:14,220 --> 00:35:16,200
>> Återigen, tänk på det som denna abstraktion.

561
00:35:16,200 --> 00:35:21,600
Så om jag är huvud och Ken är inkrement, ärligt talat, jag bryr mig inte vad Ken kallar sin iPad.

562
00:35:21,600 --> 00:35:26,570
Jag bryr mig inte vad han kallar allt som har att göra med hans genomföra denna funktionalitet.

563
00:35:26,570 --> 00:35:33,340
Detta är en implementering detalj som jag, huvud, inte behöver bry sig om.

564
00:35:33,340 --> 00:35:38,250
Och så helt enkelt byta det konsekvent inuti funktionen - nummer här och nummer här -

565
00:35:38,250 --> 00:35:40,960
är allt som behövs så länge jag kompilera.

566
00:35:40,960 --> 00:35:44,180
Det är ungefär som om du tycker om många av oss, de av er med körkort

567
00:35:44,180 --> 00:35:46,770
som har drivit eller om du ens kört i en bil,

568
00:35:46,770 --> 00:35:50,950
de flesta av oss har ingen aning om hur en bil fungerar under huven.

569
00:35:50,950 --> 00:35:54,970
Och bokstavligen, om du öppnar upp huven, de flesta av oss - däribland jag själv -

570
00:35:54,970 --> 00:35:56,940
kommer inte att verkligen veta vad vi tittar på,

571
00:35:56,940 --> 00:35:59,220
ungefär som du kan känna med sånt här just nu.

572
00:35:59,220 --> 00:36:01,480
Men vi har egentligen inte bry hur bilen fungerar,

573
00:36:01,480 --> 00:36:05,970
Vi behöver inte bry sig om vad alla stavar och kolvar och kablar inne i bilen

574
00:36:05,970 --> 00:36:08,160
faktiskt gör.

575
00:36:08,160 --> 00:36:12,770
Så något liknande vad du kallar kolven spelar ingen roll här i detta fall. Samma idé.

576
00:36:12,770 --> 00:36:25,300
Ja. >> [Ohörbart elev fråga]

577
00:36:25,300 --> 00:36:29,180
Om det finns fler användningsområden för den variabla xa stund sedan,

578
00:36:29,180 --> 00:36:32,150
du, programmerare, skulle behöva ändra dem överallt.

579
00:36:32,150 --> 00:36:36,600
Eller så kan du bokstavligen göra Fil, Meny och sedan Sök, Ersätt - något liknande -

580
00:36:36,600 --> 00:36:39,170
men du kommer att behöva göra dessa ändringar själv.

581
00:36:39,170 --> 00:36:47,450
Du måste vara konsekvent. >> [Elev] Om det finns flera variabler [ohörbart]

582
00:36:47,450 --> 00:36:53,100
En särskild ordning som här, om detta var int annat nummer? >> [Elev] Korrekt.

583
00:36:53,100 --> 00:36:56,590
[Malan] Ja. Beställ frågor när du ringer funktionen.

584
00:36:56,590 --> 00:37:00,050
>> Så om jag ringer inkrement här med något kommatecken något,

585
00:37:00,050 --> 00:37:01,680
Det finns en direkt mappning.

586
00:37:01,680 --> 00:37:05,690
Den första variabeln, vad det heter, görs en kopia av det första argumentet hit.

587
00:37:05,690 --> 00:37:07,760
Ursäkta. Detta bör inte vara en parentes.

588
00:37:07,760 --> 00:37:11,490
Det andra argumentet ställer upp med den andra. Så att, ja, frågor. Okej.

589
00:37:11,490 --> 00:37:17,020
Ursäkta. Jag tog den långa vägen dit. Övriga frågor? Okej.

590
00:37:17,020 --> 00:37:20,610
Så låt oss se om vi inte kan måla en bild av vad som faktiskt händer här

591
00:37:20,610 --> 00:37:23,090
under huven, så att säga.

592
00:37:23,090 --> 00:37:26,640
Detta är en rektangel som kan representera datorns minne.

593
00:37:26,640 --> 00:37:30,970
Även om du har ingen aning om hur minnet fungerar eller hur RAM fungerar,

594
00:37:30,970 --> 00:37:33,940
åtminstone förutsätter att du har klasar av det dessa dagar.

595
00:37:33,940 --> 00:37:36,280
Du har megabyte av det, har du gigabyte den,

596
00:37:36,280 --> 00:37:40,870
och vi vet från vecka 0 att en byte är precis vad? >> [Studerande] 8 bitar.

597
00:37:40,870 --> 00:37:42,950
8 bitar, eller hur? Så 8 nollor och 1.

598
00:37:42,950 --> 00:37:45,880
Så om din dator har en spelning RAM, 2 gig RAM dessa dagar,

599
00:37:45,880 --> 00:37:55,030
du har en miljard eller 2 miljarder byte minne eller ungefär 8 miljarder eller 16 miljarder bitar

600
00:37:55,030 --> 00:37:56,890
insidan av din dator.

601
00:37:56,890 --> 00:38:00,590
Till skillnad från den lilla Wooly Willy exempel, det är inte magnetiska partiklar vanligtvis längre.

602
00:38:00,590 --> 00:38:04,450
Alltmer - i bärbara datorer minst - det är Solid State Drives, SSD,

603
00:38:04,450 --> 00:38:08,580
som bara har några rörliga delar. Det är alla elektroniska. Det är all el-baserade.

604
00:38:08,580 --> 00:38:14,060
Så tänk på detta rektangel som bara representerar 1 eller 2 gigabyte minne som du har.

605
00:38:14,060 --> 00:38:16,020
>> Så det är en bit av minne.

606
00:38:16,020 --> 00:38:19,830
I världen av datavetenskap har slags avskiljas

607
00:38:19,830 --> 00:38:22,950
bitar av minne för att göra olika saker.

608
00:38:22,950 --> 00:38:27,190
Till exempel, om detta är datorns RAM-minne, som föreslagits av rektangeln där,

609
00:38:27,190 --> 00:38:31,130
det visar sig att enligt praxis, på toppen av ditt RAM, så att säga,

610
00:38:31,130 --> 00:38:33,660
är i allmänhet vad som kallas en text segment.

611
00:38:33,660 --> 00:38:36,740
De är 0 och 1 som du har sammanställt.

612
00:38:36,740 --> 00:38:39,020
Så när vi har tittat under huven på vad a.out är,

613
00:38:39,020 --> 00:38:41,980
alla dessa 0 och 1, när du kör ett program,

614
00:38:41,980 --> 00:38:46,290
de 0s och 1s laddas från hårddisken till något som kallas RAM,

615
00:38:46,290 --> 00:38:49,320
och i RAM de är lagt på toppen.

616
00:38:49,320 --> 00:38:52,770
Samtidigt har du andra saker: initiera data avinitiera data.

617
00:38:52,770 --> 00:38:57,510
De 2 stråk av minne hänvisar till globala variabler, som du inte använder ofta

618
00:38:57,510 --> 00:39:00,760
men ibland om du gör, hamnar de upp där också.

619
00:39:00,760 --> 00:39:04,260
Sedan finns några andra saker: miljövariabler, som vi inte kommer att spendera mycket tid på,

620
00:39:04,260 --> 00:39:06,860
men sedan 2 viktiga saker som kommer tillbaka hela terminen,

621
00:39:06,860 --> 00:39:08,550
stacken och heap.

622
00:39:08,550 --> 00:39:12,210
Så de flesta av datorns minne är reserverat när man kör ett program

623
00:39:12,210 --> 00:39:15,370
för något som kallas stapeln och något som kallas högen.

624
00:39:15,370 --> 00:39:18,840
Vi kommer inte att tala om högen idag, men vi kommer att tala om stacken.

625
00:39:18,840 --> 00:39:24,600
Stacken är avsedd att trolla fram den visuella av måltiden dining hall brickor i Mather House

626
00:39:24,600 --> 00:39:28,110
eller var du råkar vara där matsalen personalen rengöra dem varje dag,

627
00:39:28,110 --> 00:39:30,180
de stack upp dem från golvet på upp,

628
00:39:30,180 --> 00:39:34,550
och på samma sätt, i minnet, det är denna idé om att sätta något på en bunt,

629
00:39:34,550 --> 00:39:36,860
sätta något på en bunt, sätta något på en stack.

630
00:39:36,860 --> 00:39:38,240
Och vad menar vi med det?

631
00:39:38,240 --> 00:39:41,860
>> Låt oss zooma in på just den nedre halvan av bilden, datorns RAM-minne,

632
00:39:41,860 --> 00:39:44,330
att föreslå följande.

633
00:39:44,330 --> 00:39:48,170
Det visar sig att när du kör ett program som a.out eller hej -

634
00:39:48,170 --> 00:39:50,100
vad programmet är att du har skrivit -

635
00:39:50,100 --> 00:39:54,020
igen, 0 och 1 som laddas från hårddisken, vilket är långtidslagring,

636
00:39:54,020 --> 00:39:57,230
stannar där även när du dra ur kontakten, laddas till RAM.

637
00:39:57,230 --> 00:40:00,610
RAM är snabbare än hårddiskar - det är mindre än hårddiskar -

638
00:40:00,610 --> 00:40:03,300
men det är där program bor när du kör dem.

639
00:40:03,300 --> 00:40:08,230
Så du dubbelklickar på ett program på en Mac eller PC, det laddas från hårddisken till RAM-minnet.

640
00:40:08,230 --> 00:40:11,520
Så snart det är laddat i RAM, den 0 och 1 gå på vägen upp,

641
00:40:11,520 --> 00:40:16,610
den så kallade textsegment, men sedan så fort ditt program faktiskt startar,

642
00:40:16,610 --> 00:40:21,360
huvudsakliga funktionen kallas, och viktigaste, som vi har sett, ofta lokala variabler,

643
00:40:21,360 --> 00:40:24,870
och det har Ints och strängar samt tecken och liknande.

644
00:40:24,870 --> 00:40:29,180
Så om ditt program som du har skrivit eller det program som du dubbelklickar har klickat

645
00:40:29,180 --> 00:40:32,970
använt några variabler inuti huvud,

646
00:40:32,970 --> 00:40:37,240
de hamnar på botten av din stack minne, så att säga.

647
00:40:37,240 --> 00:40:39,410
Mer konkret vad innebär egentligen?

648
00:40:39,410 --> 00:40:48,450
Det betyder bara att om vi skulle numrera byte RAM i datorn,

649
00:40:48,450 --> 00:40:55,750
märker att detta kan vara byte nummer 0, kan detta vara byte nummer 1, 2, 3, 4, 5, 6,

650
00:40:55,750 --> 00:41:01,480
hela vägen upp till 2 miljarder skulle vara hela vägen upp där i toppen.

651
00:41:01,480 --> 00:41:05,880
Så med andra ord, när vi talar om RAM eller minne i form av byte,

652
00:41:05,880 --> 00:41:11,500
Det betyder bara att någon har bestämt vad som numrera varje av dessa bitar av minnet.

653
00:41:11,500 --> 00:41:16,650
Så när du behöver 32 bitar för en int eller om du behöver 8 bitar för en röding,

654
00:41:16,650 --> 00:41:18,840
där slutar de upp i minnet?

655
00:41:18,840 --> 00:41:22,350
>> Begreppsmässigt hamnar de bara upp på botten av denna sak som kallas stapeln.

656
00:41:22,350 --> 00:41:25,870
Men vad som är intressant nu är när stora anropar en funktion -

657
00:41:25,870 --> 00:41:28,750
Anta att en funktion som kallas foo, bara ett godtyckligt namn -

658
00:41:28,750 --> 00:41:32,330
vad som händer är viktigaste är längst ned i denna stack minne,

659
00:41:32,330 --> 00:41:35,680
foo nu läggs ovanpå viktigaste i minnet.

660
00:41:35,680 --> 00:41:40,990
Så några lokala variabler som foo har hamnar slags konceptuellt högre än i main.

661
00:41:40,990 --> 00:41:47,070
Om foo kallar en annan funktion som heter bar, dessa variabler hamna här.

662
00:41:47,070 --> 00:41:50,120
Om spärra samtal något annat, här, här, här.

663
00:41:50,120 --> 00:41:53,830
Så vad är intressant om hur du kör ett program är att när du ringer funktioner

664
00:41:53,830 --> 00:41:57,750
och eftersom dessa funktioner kräver funktioner och eftersom dessa funktioner kräver funktioner,

665
00:41:57,750 --> 00:42:01,470
du bygga upp denna trave funktioner i minnet.

666
00:42:01,470 --> 00:42:06,890
Och bara en gång en funktion returnerar börjar man få att minnet tillbaka.

667
00:42:06,890 --> 00:42:10,860
Så en av de enklaste sätten att få slut på minne i ett datorprogram

668
00:42:10,860 --> 00:42:14,360
är att skriva funktioner som aldrig återvända.

669
00:42:14,360 --> 00:42:18,900
Så till exempel, låt oss visa så mycket med ett avsiktligt buggy program.

670
00:42:18,900 --> 00:42:22,230
Låt mig gå vidare och göra # include <stdio.h>,

671
00:42:22,230 --> 00:42:25,000
int main (void),

672
00:42:25,000 --> 00:42:32,940
och jag ska göra medan (2> 1), som troligen inte kommer någonsin ändra på oss,

673
00:42:32,940 --> 00:42:37,560
och låt mig gå vidare nu och göra printf.

674
00:42:37,560 --> 00:42:40,700
Egentligen är det kommer att bli mindre visuellt intressant. Låt oss göra detta.

675
00:42:40,700 --> 00:42:50,240
För int i = 0; i> 0 - låt oss göra detta misstag - i + +.

676
00:42:50,240 --> 00:42:52,720
Och låt oss inte printf här. Låt oss leva som jag predikade.

677
00:42:52,720 --> 00:43:00,190
Låt oss ha en metod här, ogiltig kör, och vi kommer att säga int i,

678
00:43:00,190 --> 00:43:06,830
och då ska jag säga printf - nej, låt oss göra det mer intressant.

679
00:43:06,830 --> 00:43:15,790
Låt oss faktiskt inte ut något alls. Låt oss bara göra detta: kör (i).

680
00:43:15,790 --> 00:43:20,390
Okej. Så detta är buggig eftersom varför?

681
00:43:20,390 --> 00:43:23,380
Jag gör detta som jag går eftersom programmet inte egentligen göra någonting av intresse.

682
00:43:23,380 --> 00:43:25,320
>> Men det är inte målet.

683
00:43:25,320 --> 00:43:29,630
Målet är att skriva ett program vars huvudfunktion gör vad, tydligen?

684
00:43:30,720 --> 00:43:32,860
Kalla sig. Och faktiskt, vi behöver inte slingan.

685
00:43:32,860 --> 00:43:37,200
Låt oss förenkla även detta bara för att inte glömma verkligen grundläggande felet.

686
00:43:37,200 --> 00:43:39,640
Huvudsakliga samtal refräng att sjunga lite kör,

687
00:43:39,640 --> 00:43:41,440
då jag gjorde något dumt och jag hade kör kör samtal

688
00:43:41,440 --> 00:43:43,760
eftersom jag antar att någon annan skulle genomföra det kanske,

689
00:43:43,760 --> 00:43:47,210
och nu detta inte kommer att sammanställa ännu. Jag behöver göra det?

690
00:43:47,210 --> 00:43:49,970
Jag behöver prototypen, minns.

691
00:43:49,970 --> 00:43:56,110
Så jag måste ha här uppe void kör (int i);

692
00:43:56,110 --> 00:43:59,210
Så nu om jag går ner här - faktiskt, låt oss använda den större fönstret.

693
00:43:59,210 --> 00:44:01,980
Låt oss gå vidare och göra kör.

694
00:44:01,980 --> 00:44:06,490
Låt oss gå vidare och göra kör.

695
00:44:06,490 --> 00:44:08,370
Användning av odeklarerat identifierare i..

696
00:44:08,370 --> 00:44:12,500
Åh, det var dumt. Vi behöver inte argumentet. Låt oss bara göra detta.

697
00:44:12,500 --> 00:44:16,370
Jag önskar att vi hade börjat på detta sätt. Det skulle ha varit en mycket enklare program för att skriva.

698
00:44:16,370 --> 00:44:25,590
Där. Nu ska vi gå över till min terminalfönster, kör klang, och här kör vi.

699
00:44:25,590 --> 00:44:28,460
Det var verkligen snabbt.

700
00:44:28,460 --> 00:44:31,150
Vad som egentligen hände, men?

701
00:44:31,150 --> 00:44:33,730
Nåväl, nu ska jag lägga den tryckta linjen så vi kan se.

702
00:44:33,730 --> 00:44:43,490
Låt mig säga printf ("Jag är här") - inga variabler. Vi lämnar det så.

703
00:44:43,490 --> 00:44:47,480
Låt mig köra göra. Låt mig köra kör.

704
00:44:47,480 --> 00:44:57,380
Och ... kom igen. Fortsätt.

705
00:44:57,380 --> 00:44:59,930
Som en sidoreplik, varför har det kraschade inte ännu?

706
00:44:59,930 --> 00:45:02,080
Den segmenteringsfel hände supersnabb tidigare.

707
00:45:02,080 --> 00:45:06,570
[Ohörbart elev svar] >> Exakt. Så det tar tid att skriva ut, eller hur?

708
00:45:06,570 --> 00:45:08,610
Det tar bara mer arbete på datorns sida.

709
00:45:08,610 --> 00:45:10,620
Och det är det: segmenteringsfel.

710
00:45:10,620 --> 00:45:12,340
>> Så märker hur snabbt program körs.

711
00:45:12,340 --> 00:45:14,130
Om du inte skriver något, supersnabb.

712
00:45:14,130 --> 00:45:18,770
Men vi fick ändå denna segmentering fel eftersom vad som hände?

713
00:45:18,770 --> 00:45:21,210
Om du tänker på hur datorns minne är anlagd,

714
00:45:21,210 --> 00:45:28,740
Detta råkar vara huvud, men här vi bara kalla denna kör, och låt oss kalla denna kör.

715
00:45:28,740 --> 00:45:34,550
Och nu om jag gör mitt estetik rätt, kommer detta bara säga kör, kör, kör,

716
00:45:34,550 --> 00:45:40,550
kör, kör, kör, kör, ad nauseum, och så småningom, vad som kommer att hända?

717
00:45:40,550 --> 00:45:45,630
Om helheten, bokstavligen, är det, vad händer just begreppsmässigt?

718
00:45:46,520 --> 00:45:48,630
Bunten överskridanden högen.

719
00:45:48,630 --> 00:45:51,940
Eller ännu värre, överskridande du bara allt, inklusive texten segmentet,

720
00:45:51,940 --> 00:45:54,590
som är den 0 och 1 som representerar ditt program.

721
00:45:54,590 --> 00:45:57,080
Kort sagt, detta är bara super, super dåligt.

722
00:45:57,080 --> 00:45:58,830
Ditt program har spiraled utom kontroll.

723
00:45:58,830 --> 00:46:01,220
Du använder mycket mer minne än du tänkt

724
00:46:01,220 --> 00:46:03,960
allt på grund av ett dumt misstag i detta fall,

725
00:46:03,960 --> 00:46:08,040
eller i detta fall en mycket medvetet gjort funktion kallar sig.

726
00:46:08,040 --> 00:46:09,500
Nu är detta inte dåligt.

727
00:46:09,500 --> 00:46:13,800
Funktioner som kallar sig har faktiskt stor makt när du använder den på rätt sätt.

728
00:46:13,800 --> 00:46:15,800
Jag har inte använt det på rätt här.

729
00:46:15,800 --> 00:46:19,780
Så detta är inte allt dåligt, men det faktum att jag aldrig sluta kalla mig själv

730
00:46:19,780 --> 00:46:23,520
är en grundläggande svaghet här i detta program.

731
00:46:23,520 --> 00:46:26,400
Så vart är vi på väg med allt detta? Vad som verkligen händer?

732
00:46:26,400 --> 00:46:30,340
När jag ringer ökningen funktion som vi gjorde i dessa exempel,

733
00:46:30,340 --> 00:46:33,420
Jag har ett värde som 1 som jag passerar i.

734
00:46:33,420 --> 00:46:37,570
Jag passerar i en kopia av siffran 1, så följande händer.

735
00:46:37,570 --> 00:46:44,240
Låt oss gå in i steg exempel den här killen här borta.

736
00:46:44,240 --> 00:46:46,870
Här är vad som faktiskt händer.

737
00:46:46,870 --> 00:46:53,400
När jag ringer ökning och jag passerar i x, bildmässigt, vad som händer här är det.

738
00:46:53,400 --> 00:46:59,520
>> Om jag har värdet 1 sparas här och jag faktiskt kallar steg,

739
00:46:59,520 --> 00:47:04,330
som nu kallas refrängen - iPad kastar mig här.

740
00:47:04,330 --> 00:47:09,760
Låt oss kalla detta steg, och vi vet inte vad det nästa funktion kommer att bli.

741
00:47:09,760 --> 00:47:14,840
Så vad som faktiskt händer här någonstans i huvud har jag en bit av minne

742
00:47:14,840 --> 00:47:17,000
som lagrar numret 1.

743
00:47:17,000 --> 00:47:19,380
När jag ringer steg, jag använder en annan bit av minnet,

744
00:47:19,380 --> 00:47:21,230
men nu har jag en kopia av 1.

745
00:47:21,230 --> 00:47:26,660
När jag öka detta värde blir detta 2,

746
00:47:26,660 --> 00:47:30,560
men vad händer när inkrement återvänder?

747
00:47:30,560 --> 00:47:33,630
Detta minne blir bara lämnas tillbaka till operativsystemet,

748
00:47:33,630 --> 00:47:37,450
vilket innebär att alla du har gjort är inget användbart.

749
00:47:37,450 --> 00:47:43,120
Den 1 som ursprungligen ingick i huvud är fortfarande faktiskt det.

750
00:47:43,120 --> 00:47:44,890
Så vart är vi på väg med detta?

751
00:47:44,890 --> 00:47:49,770
Det visar sig att i minnet du har denna back-to-back sekvens av byte

752
00:47:49,770 --> 00:47:53,050
som du kan sätta saker i, och det visar sig att vi redan har sett något

753
00:47:53,050 --> 00:47:55,390
som innebär att sätta saker rygg mot rygg mot rygg mot rygg.

754
00:47:55,390 --> 00:47:59,860
Vad är en sträng baserad på vecka 1 och vecka nu 2?

755
00:48:00,020 --> 00:48:01,980
Det är bara en samling av tecken.

756
00:48:01,980 --> 00:48:04,310
Så det visar sig precis som du kan sätta siffror i minnet,

757
00:48:04,310 --> 00:48:06,990
liknande kan du sätta tecken i minnet.

758
00:48:06,990 --> 00:48:10,530
Och när vi börjar sätta tecken i minnet tillbaka till tillbaka till rygg mot rygg,

759
00:48:10,530 --> 00:48:13,620
det visar sig att använda den enklaste av saker som en for-slinga eller en while-slinga,

760
00:48:13,620 --> 00:48:17,170
Vi kan iterera från vänster till höger över tecknen i en sträng

761
00:48:17,170 --> 00:48:20,600
och börja massera dem i olika karaktärer helt -

762
00:48:20,600 --> 00:48:23,370
en kan bli b, kunde B bli c -

763
00:48:23,370 --> 00:48:27,780
så att i slutändan, kan vi ta en engelsk mening som faktiskt är vettigt

764
00:48:27,780 --> 00:48:30,310
och omvandla var och en av dessa bokstäver en åt gången

765
00:48:30,310 --> 00:48:34,400
genom att gå igenom vår dators minne från vänster till höger för att verkligen kryptera.

766
00:48:34,400 --> 00:48:35,810
Så låt oss ta vår fem-minuters paus här,

767
00:48:35,810 --> 00:48:40,730
och när vi kommer tillbaka, börjar vi processen att förvränga information.

768
00:48:42,020 --> 00:48:43,520
>> Okej.

769
00:48:43,520 --> 00:48:48,070
Innan vi dyka in några krypto och dessa saker som kallas matriser,

770
00:48:48,070 --> 00:48:51,470
Låt mig stanna upp några frågor eftersom jag känner att jag verkligen slags rörig

771
00:48:51,470 --> 00:48:54,080
vissa av dessa ämnen. Så låt oss fixa nu om vi kan.

772
00:48:54,080 --> 00:48:58,700
Vi bara pratade om returvärden, talade vi om argument,

773
00:48:58,700 --> 00:49:03,250
och vi pratade om detta begrepp, som vi ska återkomma till i de kommande veckorna,

774
00:49:03,250 --> 00:49:08,720
att betrakta minnet som en massa av dessa staplade brickor, så att säga,

775
00:49:08,720 --> 00:49:12,660
från botten på upp, så att varje fack som får sätta på stacken

776
00:49:12,660 --> 00:49:16,530
representerar en funktion som för närvarande är som anropas.

777
00:49:17,900 --> 00:49:20,260
Några frågor?

778
00:49:20,260 --> 00:49:22,640
Låt mig ställa en fråga här.

779
00:49:22,640 --> 00:49:27,890
Låt mig förenkla tillbaka till vad det var innan några av våra tidigare Q & A.

780
00:49:27,890 --> 00:49:35,570
Det faktum att ökningen har öppen parentes, int antal, stängd parentes -

781
00:49:35,570 --> 00:49:39,110
Vad utgör int nummer?

782
00:49:39,110 --> 00:49:42,790
[Eleven] Ett argument. >> Ett argument. Okej. Men vad är ett argument?

783
00:49:42,790 --> 00:49:46,370
[Ohörbart elev svar] >> Vad är det? >> [Elev] Något som du skickar in

784
00:49:46,370 --> 00:49:49,940
Okej, så något som du passerar i. Och mer allmänt, det är bara ingången.

785
00:49:49,940 --> 00:49:52,450
Om du skriver en funktion och att funktionens syfte i livet

786
00:49:52,450 --> 00:49:55,770
är att göra något lite annorlunda varje gång du använder det,

787
00:49:55,770 --> 00:50:00,110
då det enda sättet för att det ska hända verkligen tycks vara att förse den med ingång

788
00:50:00,110 --> 00:50:03,510
så att den kan göra något annorlunda med den ingången varje gång.

789
00:50:03,510 --> 00:50:06,650
>> Så du måste ange två saker när en funktion tar in.

790
00:50:06,650 --> 00:50:09,590
Du måste ange det namn som du vill ge till denna ingång

791
00:50:09,590 --> 00:50:12,700
enbart för din egen bekvämlighet så att du kan hänvisa till den

792
00:50:12,700 --> 00:50:16,540
i den funktion som du själv skriver, som jag gjorde här i linje 32.

793
00:50:16,540 --> 00:50:20,800
Men du måste också ange dess typ eftersom C är ett programmeringsspråk

794
00:50:20,800 --> 00:50:25,940
som kräver bara att om du vill ha en variabel, måste du tala om för datorn vad datatyp det är,

795
00:50:25,940 --> 00:50:30,200
till stor del så att den vet hur många bitar att fördela för den variabeln

796
00:50:30,200 --> 00:50:33,020
eftersom det kan vara 6 - förlåt, kommer det inte 6.

797
00:50:33,020 --> 00:50:37,080
Det kan vara 16, kan det vara 8, kan det vara 32, även 64,

798
00:50:37,080 --> 00:50:39,130
men datorn behöver veta.

799
00:50:39,130 --> 00:50:43,180
Nu representerar int på den vänstra sidan vad däremot?

800
00:50:46,350 --> 00:50:48,850
[Ohörbart elev svar] >> Vad är det? >> [Elev] Typ av funktion.

801
00:50:48,850 --> 00:50:53,610
Typen av en funktion och, mer specifikt, den typ av produktionen. Rätt.

802
00:50:53,610 --> 00:50:57,380
Så medan sak i parentes representerar dess ingång, om någon,

803
00:50:57,380 --> 00:50:59,660
sak till vänster representerar dess utgång.

804
00:50:59,660 --> 00:51:03,530
Och i det här fallet returnerar steg tydligen en int,

805
00:51:03,530 --> 00:51:07,690
och så int är returtyp av denna funktion.

806
00:51:07,690 --> 00:51:09,340
Vad innebär det att återvända?

807
00:51:09,340 --> 00:51:15,090
Bokstavligen, använder du nyckelordet tillbaka och sedan om vad du återvänder

808
00:51:15,090 --> 00:51:18,600
till höger om sökordet är ett heltal,

809
00:51:18,600 --> 00:51:21,660
då verkligen överensstämmer med vad vi har lovat.

810
00:51:21,660 --> 00:51:26,410
Du kunde inte göra något liknande - hej, värld - för det är en sträng.

811
00:51:26,410 --> 00:51:28,860
>> Uppenbarligen är det inte ett heltal.

812
00:51:28,860 --> 00:51:33,140
Så kort sagt, är bördan verkligen på oss, programmeraren, att vara specifik

813
00:51:33,140 --> 00:51:37,770
vad vi tillbaka och sedan faktiskt gå tillbaka det.

814
00:51:37,770 --> 00:51:43,440
Sammanhanget här är nu att datorns minne är en gigabyte, 2 gigabyte -

815
00:51:43,440 --> 00:51:45,920
vad - kanske är det mer, kanske är det mindre,

816
00:51:45,920 --> 00:51:49,050
men datorn ser det som att ha olika sektioner.

817
00:51:49,050 --> 00:51:51,200
Något går ner dit, går något annat där uppe,

818
00:51:51,200 --> 00:51:54,290
olika saker går i mitten, och idag har vi bara börja berätta historien,

819
00:51:54,290 --> 00:51:56,340
men vi ska återkomma till detta med tiden.

820
00:51:56,340 --> 00:51:59,980
För nu, är det enda minne vi verkligen bryr oss om texten segmentet

821
00:51:59,980 --> 00:52:03,360
eftersom det bara är den 0 och 1 som klang har matas ut.

822
00:52:03,360 --> 00:52:06,050
Så när du kör ett kommando på tangentbordet som a.out

823
00:52:06,050 --> 00:52:09,110
eller du dubbelklicka på en ikon i Mac OS eller Windows,

824
00:52:09,110 --> 00:52:11,880
ditt program laddas från hårddisken till RAM

825
00:52:11,880 --> 00:52:16,330
och det är plopped på toppen av datorns RAM-minne, så att säga.

826
00:52:16,330 --> 00:52:20,450
Samtidigt som programmet startar och viktigaste anropas

827
00:52:20,450 --> 00:52:23,640
i det program som du skrev eller programmet Microsoft eller Apple skrev,

828
00:52:23,640 --> 00:52:27,860
någon av dess lokala variabler hamnar nere på botten av din dators minne.

829
00:52:27,860 --> 00:52:33,230
Men om stora samtal en annan funktion som själv har variabler eller argument hamnar de ovanför.

830
00:52:33,230 --> 00:52:36,680
Och om den funktionen kallar någonting, hamnar de ovanför, ovanför, ovanför den.

831
00:52:36,680 --> 00:52:41,460
>> Och endast en gång en funktion görs verkställande inte stapeln av brickor, så att säga,

832
00:52:41,460 --> 00:52:43,240
börjar bli lägre och lägre.

833
00:52:43,240 --> 00:52:48,250
Och detta är vad då, i ett nötskal, förklarar varför när du ringer kub

834
00:52:48,250 --> 00:52:51,550
eller du kallar steg, du passerar i en kopia av värdet.

835
00:52:51,550 --> 00:52:55,520
Och vad det betyder bildmässigt är att du bokstavligen skriver siffran 1

836
00:52:55,520 --> 00:53:00,460
i en annan del av minnet, förändras att 1 till 2 i fallet med inkrementet

837
00:53:00,460 --> 00:53:04,820
eller till en 8 vid kuben och sedan kasta att minnet bort

838
00:53:04,820 --> 00:53:09,140
så snart inkrement eller kuben återgår funktionen. Fråga.

839
00:53:09,140 --> 00:53:12,900
[Elev] Var är globala variabler lagras?

840
00:53:12,900 --> 00:53:18,100
Globala variabler lagras i vad som för närvarande kallas initierade data eller oinitierade data,

841
00:53:18,100 --> 00:53:21,920
Skillnaden är om du har en global variabel och tilldelar den omedelbart ett värde

842
00:53:21,920 --> 00:53:24,640
med likhetstecknet, slutar upp i toppen där,

843
00:53:24,640 --> 00:53:29,200
och om du bara säga int x, utan värde, slutar det upp något lägre i RAM

844
00:53:29,200 --> 00:53:31,710
helt enkelt genom konventionen.

845
00:53:31,710 --> 00:53:34,940
Övriga frågor? Okej.

846
00:53:34,940 --> 00:53:37,340
Så den här bilden kommer tillbaka när vi blir mer kraftfull

847
00:53:37,340 --> 00:53:39,170
med vad vi kan göra med datorn,

848
00:53:39,170 --> 00:53:42,720
men nu ska vi ha en kort introduktion till kryptografi,

849
00:53:42,720 --> 00:53:46,080
en viss typ av kryptering som inte lösa alla världens problem

850
00:53:46,080 --> 00:53:47,720
men löser några av dem.

851
00:53:47,720 --> 00:53:51,700
I detta fallet här har vi något som kallas hemliga key kryptografi.

852
00:53:51,700 --> 00:53:56,410
Hemlig-nyckel kryptografi, som namnet antyder, får sin säkerhet från en hemlighet.

853
00:53:56,410 --> 00:54:00,690
>> Till exempel, om du var tillbaka i skolan och du passerar en liten bokstav hemliga kärlek

854
00:54:00,690 --> 00:54:04,850
till pojke eller flicka du krossa, om du ville passera denna anmärkning genom publiken,

855
00:54:04,850 --> 00:54:08,380
du förmodligen inte skulle skriva en sådan anteckning i engelska eller vad ditt modersmål är.

856
00:54:08,380 --> 00:54:13,340
Snarare kan du kryptera den eller du kanske bara skicka dem ett SMS i dessa dagar.

857
00:54:13,340 --> 00:54:15,460
Men du kan faktiskt passera dem en anteckning hela klassrummet.

858
00:54:15,460 --> 00:54:18,700
Och att göra detta säkert på ett sådant sätt att dina vänner och lärare

859
00:54:18,700 --> 00:54:22,650
vet inte vad du skriver, kan du komma med en ganska enkel algoritm,

860
00:54:22,650 --> 00:54:25,920
ung men du kan vara, bara förvränga orden.

861
00:54:25,920 --> 00:54:28,130
Så istället för att skriva en du kan skriva b,

862
00:54:28,130 --> 00:54:30,220
istället för B du kan skriva c,

863
00:54:30,220 --> 00:54:32,140
istället för c du kan skriva d, och så vidare.

864
00:54:32,140 --> 00:54:34,360
Eller så kan du komma med en mer sofistikerad översättning

865
00:54:34,360 --> 00:54:36,720
av brev till olika bokstäver.

866
00:54:36,720 --> 00:54:39,740
Men fångsten är pojke eller flicka som du ska skicka detta meddelande

867
00:54:39,740 --> 00:54:45,020
behöver veta något, vilket är vad, uppenbarligen? >> [Eleven] Vad du skickar.

868
00:54:45,020 --> 00:54:49,720
Vad din hemlighet är, liksom vad är det mappning mellan s och B: s och C: s och D: s.

869
00:54:49,720 --> 00:54:54,650
Är det att lägga bara 1 till var och en av bokstäverna för att gå från A till B, B till C?

870
00:54:54,650 --> 00:54:56,670
Är det mer komplext än så?

871
00:54:56,670 --> 00:55:01,540
>> Så du och din kärlek måste ha denna hemlig information,

872
00:55:01,540 --> 00:55:03,190
men det är lite av en fångst-22 här.

873
00:55:03,190 --> 00:55:06,830
Om detta är första gången du skickar detta kärleksbrev genom klassen,

874
00:55:06,830 --> 00:55:10,720
hur är det pojke eller flicka kommer att veta vad hemligheten med är?

875
00:55:10,720 --> 00:55:13,930
Så hemlig-nyckel krypto löser inte alla världens problem,

876
00:55:13,930 --> 00:55:16,320
och det finns faktiskt en relation här som vi ska återkomma till mot termin slut.

877
00:55:16,320 --> 00:55:25,110
Likaså gör de flesta av oss vet inte någon som fungerar, till exempel på Amazon.com,

878
00:55:25,110 --> 00:55:28,190
och ändå många av oss har säkert köpt grejer på Amazon.com,

879
00:55:28,190 --> 00:55:31,990
och vi har fått lära oss att anta att dessa e-handelstransaktioner är säkra.

880
00:55:31,990 --> 00:55:36,470
Webbadressen säger förmodligen https, det finns kanske en dum liten hänglås-ikonen någonstans,

881
00:55:36,470 --> 00:55:39,930
Det finns någon form av kryptering säkra din kreditkortsinformation

882
00:55:39,930 --> 00:55:42,160
mellan dig och Amazon.com.

883
00:55:42,160 --> 00:55:45,430
Och ändå om kryptografi innebär att veta någon hemlighet

884
00:55:45,430 --> 00:55:48,620
och ändå vet jag inte vem som helst på Amazon och jag har verkligen inte arrangerat någon form av hemlig

885
00:55:48,620 --> 00:55:52,710
med någon på Amazon, hur är min dator eller min webbläsare gör detta?

886
00:55:52,710 --> 00:55:55,720
Det visar sig att det finns andra typer av kryptografi helt att lösa det problemet.

887
00:55:55,720 --> 00:55:57,670
Men för idag, vi fokuserar på det enkla en

888
00:55:57,670 --> 00:56:00,290
där du kan ordna i förväg veta någon hemlig

889
00:56:00,290 --> 00:56:03,760
som en eller några mappning mellan A: s och B: s.

890
00:56:03,760 --> 00:56:05,840
Och processen för kryptografi involverar generellt detta.

891
00:56:05,840 --> 00:56:08,620
Du har några oformaterad text, visas här till vänster,

892
00:56:08,620 --> 00:56:12,930
du kör det genom någon form av algoritm eller förfarande för kryptering det -

893
00:56:12,930 --> 00:56:15,100
kanske det är bara en blir B, blir B C -

894
00:56:15,100 --> 00:56:17,490
och sedan sluta med chiffertext.

895
00:56:17,490 --> 00:56:20,380
Samtidigt när din kärlek får denna hemliga anmärkning,

896
00:56:20,380 --> 00:56:24,200
han eller hon har att sedan dekryptera det med allmänt motverka dessa algoritm

897
00:56:24,200 --> 00:56:27,190
så att få tillbaka oformaterad text.

898
00:56:27,190 --> 00:56:28,960
Det finns fysiska inkarnationer av detta.

899
00:56:28,960 --> 00:56:31,680
>> Till exempel är det en liten hemlighet dekoder ring,

900
00:56:31,680 --> 00:56:35,110
och detta är en ring i den meningen att det finns två rattar här.

901
00:56:35,110 --> 00:56:38,490
På utsidan periferi denna sak, det finns bokstäverna A till Z,

902
00:56:38,490 --> 00:56:40,340
även om de är i slumpmässig ordning,

903
00:56:40,340 --> 00:56:42,880
och på insidan, det finns faktiskt några siffror

904
00:56:42,880 --> 00:56:46,620
så att med denna ring kan du typ av tur utsidan men inte insidan

905
00:56:46,620 --> 00:56:49,140
För att rada upp numren med bokstäver.

906
00:56:49,140 --> 00:56:53,020
Från en film som heter A Christmas Story, ser du den lilla Ralphie

907
00:56:53,020 --> 00:56:58,000
var så ivriga att räkna ut vad Little Orphan Annie hemliga budskap var att han

908
00:56:58,000 --> 00:57:02,570
som hade meddelats, tror jag, i form av numeriska meddelanden på ett flingpaket

909
00:57:02,570 --> 00:57:07,220
och du var tvungen att samla alla de små korten som kom i flingpaket,

910
00:57:07,220 --> 00:57:09,770
du var tvungen att posta dem i, var du tvungen att få tillbaka den hemliga dekoder ringen

911
00:57:09,770 --> 00:57:13,910
så att du kan äntligen räkna ut vad mappningen mellan bokstäver och siffror

912
00:57:13,910 --> 00:57:15,550
eller bokstäver och bokstäver.

913
00:57:15,550 --> 00:57:19,520
Hur i en dator kan vi gå att genomföra eller representerar saker som detta?

914
00:57:19,520 --> 00:57:22,560
Vi behöver ett sätt att uttrycka oss själva lite mer flexibelt

915
00:57:22,560 --> 00:57:25,080
än våra variabler hittills ha tillåtit.

916
00:57:25,080 --> 00:57:29,000
Vi har haft Ints, vi har haft tecken, vi har haft flöten och dubblar och några andra,

917
00:57:29,000 --> 00:57:34,200
men de är enskilda delar av minnet som egentligen inte tillåter oss att uttrycka saker

918
00:57:34,200 --> 00:57:36,440
som ord och meningar och fraser.

919
00:57:36,440 --> 00:57:38,630
I själva verket har vi kallade dessa saker strängar,

920
00:57:38,630 --> 00:57:42,660
men vi lovar att det är egentligen bara en förenkling av CS50 biblioteket

921
00:57:42,660 --> 00:57:45,540
att vi har för avsikt att dra tillbaka.

922
00:57:45,540 --> 00:57:47,500
Och så låt oss börja att göra det här.

923
00:57:47,500 --> 00:57:49,840
Låt mig gå vidare och öppna upp en fil -

924
00:57:49,840 --> 00:57:54,100
alla dessa filer finns som vanligt på nätet - kallad array.c

925
00:57:54,100 --> 00:57:58,960
att lösa ett problem utan samband med strängar men det ger en bild här

926
00:57:58,960 --> 00:58:01,520
om hur vi kan använda något som kallas en matris.

927
00:58:01,520 --> 00:58:04,050
>> En array är en datatyp.

928
00:58:04,050 --> 00:58:10,730
Det är en typ av variabel slags som har flera mindre datatyper inuti den

929
00:58:10,730 --> 00:58:12,680
rygg mot rygg mot rygg mot rygg.

930
00:58:12,680 --> 00:58:16,980
Så till exempel, om vi ville skriva ett litet program som ger dig din frågesport genomsnitt

931
00:58:16,980 --> 00:58:19,780
för en kurs som 50 som har 2 frågesporter,

932
00:58:19,780 --> 00:58:23,450
kan du mycket enkelt skriva det här programmet bygger även på några av förra veckans material

933
00:58:23,450 --> 00:58:28,830
genom getInt och ett par variabler: int quiz1, int quiz2.

934
00:58:28,830 --> 00:58:30,550
Och det är ganska enkelt.

935
00:58:30,550 --> 00:58:33,500
Det är kanske 10, 20 rader kod Max att genomföra ett program

936
00:58:33,500 --> 00:58:38,940
som frågar användaren om 2 frågesport poäng och sedan beräknar deras genomsnittliga

937
00:58:38,940 --> 00:58:42,020
genom att lägga till dem tillsammans, dela med 2 och sedan skriva ut resultatet.

938
00:58:42,020 --> 00:58:46,400
Vi kan nog göra det ganska lätt nu efter ett antal minuter.

939
00:58:46,400 --> 00:58:49,450
Men problemet är att anta att 50 hade 3 frågesporter eller 4.

940
00:58:49,450 --> 00:58:52,830
Anta att du vill använda samma program för en klass som hade veckovis frågesporter.

941
00:58:52,830 --> 00:58:55,100
Tänk på en klass som varje vecka har frågesporter.

942
00:58:55,100 --> 00:58:58,840
Om det finns 16 eller så veckor i termin, nu har du 16 variabler:

943
00:58:58,840 --> 00:59:03,030
int quiz1, int quiz2, int quiz3, int quiz4.

944
00:59:03,030 --> 00:59:06,870
Så snart du börjar se denna redundans, detta kopiera och klistra in i kod,

945
00:59:06,870 --> 00:59:09,810
den ska börja att göra dig önskar att det fanns ett bättre sätt.

946
00:59:09,810 --> 00:59:13,610
Och tack och lov, på grund av matriser finns. Så låt oss göra det här.

947
00:59:13,610 --> 00:59:16,700
Först, låt mig presentera en mycket enkel sak att vi inte har använt hittills,

948
00:59:16,700 --> 00:59:18,820
men du kommer att se det ibland i koden.

949
00:59:18,820 --> 00:59:21,270
>> Detta är vad som allmänt kallas en konstant.

950
00:59:21,270 --> 00:59:24,410
Så det är en konstant i den meningen att detta värde inte ändras.

951
00:59:24,410 --> 00:59:26,450
Den mänskliga konvention när du skapar en konstant

952
00:59:26,450 --> 00:59:30,420
är att använda versaler bara så att det verkligen sticker ut i din kod,

953
00:59:30,420 --> 00:59:34,270
och den speciella nyckelord som du använder i C definierar #.

954
00:59:34,270 --> 00:59:39,970
Så vi säger # define då ett utrymme, så det ord du vill använda för konstanten namn

955
00:59:39,970 --> 00:59:41,730
och sedan värdet på konstanten.

956
00:59:41,730 --> 00:59:44,710
Notera att detta är annorlunda tilldela något till en variabel.

957
00:59:44,710 --> 00:59:46,430
Det finns ingen likhetstecken, det finns ingen semikolon.

958
00:59:46,430 --> 00:59:49,140
Detta är vad som allmänt är känt som en preprocessor direktiv,

959
00:59:49,140 --> 00:59:50,840
men mer om det en annan gång.

960
00:59:50,840 --> 00:59:56,350
För nu, skapar detta en oföränderlig värde kallas frågesporter

961
00:59:56,350 --> 00:59:58,290
vars faktiska numeriska värdet är 2.

962
00:59:58,290 --> 01:00:02,180
Så var du ser frågesport, frågesport, frågesporter hela filen,

963
01:00:02,180 --> 01:00:04,230
det är bara nummer 2.

964
01:00:04,230 --> 01:00:06,550
Om jag tittar på huvud nu, låt oss se hur det fungerar.

965
01:00:06,550 --> 01:00:09,770
Först ser det lite kryptiskt, men det är alla grejer från vecka 1.

966
01:00:09,770 --> 01:00:12,210
Be användaren för betyg. Hur gör vi det?

967
01:00:12,210 --> 01:00:17,350
I linje 22 - detta är verkligen den saftiga delen - Jag förklarar en flottör

968
01:00:17,350 --> 01:00:23,240
men inte en enda flottör. Jag förklarar snarare en rad flyttalsvärden.

969
01:00:23,240 --> 01:00:27,700
Den variabeln kommer att kallas kvaliteter, vilket antyds här,

970
01:00:27,700 --> 01:00:31,420
men den enda del av nya syntaxen är då dessa hakparenteser.

971
01:00:31,420 --> 01:00:37,280
Det faktum att jag har sagt float betyg och öppna sedan fäste och sedan ett antal -

972
01:00:37,280 --> 01:00:40,980
märker om det är en konstant är precis som vi gjorde detta -

973
01:00:40,980 --> 01:00:46,840
Detta innebär, "Hej dator, ge mig 2 flyter och låt oss tillsammans kalla dem betyg."

974
01:00:46,840 --> 01:00:51,780
>> Detta står i kontrast till en mycket mer mödosam process så här: float Grade1;

975
01:00:51,780 --> 01:00:54,580
float grade2, och så vidare.

976
01:00:54,580 --> 01:00:58,310
Så en array kan vi genomföra denna idé, men mycket mindre messily,

977
01:00:58,310 --> 01:01:04,560
på ett sådant sätt att vi kan skriva 1 kodrad i stället för, säg, 16 för en 16-veckors termin.

978
01:01:04,560 --> 01:01:09,060
Jag ville inte hård-kod 2 för om man tänker på det nu logiskt,

979
01:01:09,060 --> 01:01:12,560
antar nästa år CS50 ändringar 3 frågesporter istället

980
01:01:12,560 --> 01:01:15,010
och jag hade nummer 2 här, hade jag numret 2 här,

981
01:01:15,010 --> 01:01:17,210
Jag hade nummer 2 här numret 2 här.

982
01:01:17,210 --> 01:01:19,890
Det blir mycket tröttande och mycket lätt att skruva upp

983
01:01:19,890 --> 01:01:26,550
och att oavsiktligt ändra 1 värde till 3 och missa något annat värde av 2.

984
01:01:26,550 --> 01:01:30,660
Så jag ska istället abstrakta detta bort och använda denna konstant som,

985
01:01:30,660 --> 01:01:32,520
Som namnet antyder, förändras aldrig.

986
01:01:32,520 --> 01:01:35,870
Och nu spelar ingen roll om vi har olika frågesporter i år eller nästa,

987
01:01:35,870 --> 01:01:39,380
Jag måste bara ändra det på ett ställe här uppe på toppen.

988
01:01:39,380 --> 01:01:41,230
Så det är allt en konstant är.

989
01:01:41,230 --> 01:01:47,100
Samtidigt är den nya konceptuella funktion som av en matris.

990
01:01:47,100 --> 01:01:55,030
Så hakparenteser ge mig så många flottar och låter mig kollektivt kallar dem kvaliteter här.

991
01:01:55,030 --> 01:01:56,720
Så nu ska vi se vad jag ska göra.

992
01:01:56,720 --> 01:01:59,220
Här i linje 24 är början av en for-slinga.

993
01:01:59,220 --> 01:02:03,380
>> Detta är verkligen ingenting fancy. Det är bara att använda frågesporter stället för en hårdkodad nummer.

994
01:02:03,380 --> 01:02:06,740
Men det finns inget intellektuellt annorlunda där från förra veckan.

995
01:02:06,740 --> 01:02:11,650
Detta är bara printf så printf ("Quiz #% d av% ​​d:")

996
01:02:11,650 --> 01:02:16,670
eftersom jag vill bara skriva ut mig frågesport nummer 1 av 2 och sedan 2 av 2.

997
01:02:16,670 --> 01:02:18,480
Så detta är en rent estetisk sak.

998
01:02:18,480 --> 01:02:21,000
Men det intressanta är nu i linje 27.

999
01:02:21,000 --> 01:02:27,840
För att fylla i en av de två platshållare med en floating-point värde,

1000
01:02:27,840 --> 01:02:29,640
du använda igen hakparenteser.

1001
01:02:29,640 --> 01:02:35,170
I det här fallet, jag använder jag eftersom det för slinga har börjat med i motsvarande vad värde, tydligen?

1002
01:02:35,170 --> 01:02:36,670
[Elev] 0. >> [Malan] 0.

1003
01:02:36,670 --> 01:02:40,990
Så på den första iteration av denna slinga är det som om jag skrev detta i kod,

1004
01:02:40,990 --> 01:02:46,310
men på andra iteration av denna slinga är det som om jag skrev detta i min kod.

1005
01:02:46,310 --> 01:02:49,970
Men det faktum att jag använder en variabel är perfekt eftersom, som namnet antyder,

1006
01:02:49,970 --> 01:02:52,600
det variera dess värde på varje iteration,

1007
01:02:52,600 --> 01:02:55,900
så jag fyller denna array en plats åt gången.

1008
01:02:55,900 --> 01:02:57,380
Hur ser denna array ut?

1009
01:02:57,380 --> 01:03:01,570
Anledningen till att jag drog super enkel rektangel på skärmen här var innan av detta skäl.

1010
01:03:01,570 --> 01:03:05,590
En array är bara en bit av minnet, följt av en annan bit av minnet

1011
01:03:05,590 --> 01:03:08,570
följt av en annan bit av minne och så vidare.

1012
01:03:08,570 --> 01:03:13,120
Så om min array är av storlek 2 i detta fallet här, allt jag skulle göra

1013
01:03:13,120 --> 01:03:20,200
genom att skriva i min frågesport poäng som här - jag fick 100 på detta och sedan fick jag en 99 på den här -

1014
01:03:20,200 --> 01:03:24,970
då detta minne kanske inte ens användas eftersom jag har bara frågat datorn

1015
01:03:24,970 --> 01:03:26,840
för en rad storlek 2.

1016
01:03:26,840 --> 01:03:28,600
Dessa rutor är fortfarande där, eller hur?

1017
01:03:28,600 --> 01:03:32,670
Du har fortfarande 2 gigabyte RAM-minne, även om du bara ber om 2 flyter.

1018
01:03:32,670 --> 01:03:36,840
Så tanken bakom arrayer är att datorn bara tar en bit av minne

1019
01:03:36,840 --> 01:03:41,340
och sedan fördelas proportionellt mindre bitar rygg mot rygg mot rygg mot rygg.

1020
01:03:41,340 --> 01:03:43,310
Och så är allt en array är.

1021
01:03:43,310 --> 01:03:47,350
>> Det är en sammanhängande bit av minne inuti som du kan lägga saker.

1022
01:03:47,350 --> 01:03:50,700
Det händer så gör några tråkiga aritmetik.

1023
01:03:50,700 --> 01:03:54,640
Om jag bläddra ner hit, det är här jag sedan iterera över arrayen.

1024
01:03:54,640 --> 01:03:58,020
Jag kommer upp med summan av alla värden i matrisen,

1025
01:03:58,020 --> 01:04:02,470
och då använder jag den runda funktion här att faktiskt göra det belopp dividerat med frågesporter.

1026
01:04:02,470 --> 01:04:06,320
Men låt mig våg min hand på det som en slags tillräckligt aritmetik för nu.

1027
01:04:06,320 --> 01:04:08,370
Men allt som gör för mig ytterst beräknar ett genomsnitt.

1028
01:04:08,370 --> 01:04:13,580
Så först frågesport plus 2. Frågesport delat med 2 och sedan skriva ut det som en int.

1029
01:04:13,580 --> 01:04:17,280
Men låt övergång nu till en annan exempel heter sträng1,

1030
01:04:17,280 --> 01:04:20,700
vilket ger en liknande bild, men med strängar.

1031
01:04:20,700 --> 01:04:23,940
Låt mig gå vidare och förenkla detta för ett ögonblick.

1032
01:04:23,940 --> 01:04:27,090
Förlåt indraget för nu.

1033
01:04:27,090 --> 01:04:30,870
Meddelande i linje 19 i detta exempel, får jag en sträng från användaren.

1034
01:04:30,870 --> 01:04:34,640
Men märka vad jag nästa ska göra i rader 22 och framåt.

1035
01:04:34,640 --> 01:04:41,250
Jag är faktiskt iteration från i upp till - och detta är ett nytt trick - strlen, stränglängd.

1036
01:04:41,250 --> 01:04:44,880
Detta är en funktion som kommer med C att om du ge det en sträng,

1037
01:04:44,880 --> 01:04:47,730
Det talar om för dig hur många tecken finns i den strängen. Det är allt.

1038
01:04:47,730 --> 01:04:51,550
Och det faktum att det är strlen istället för sträng längd är bara för att det är mer kortfattad.

1039
01:04:51,550 --> 01:04:55,100
För trettio år sedan, tyckte folk att skriva saker så kortfattat som möjligt,

1040
01:04:55,100 --> 01:04:57,630
så vi har hållit denna konvention här.

1041
01:04:57,630 --> 01:05:00,660
i + + betyder bara öka i i varje iteration.

1042
01:05:00,660 --> 01:05:02,990
Och nu märker detta, vilket är riktigt intressant.

1043
01:05:02,990 --> 01:05:09,180
I linje 24, säger jag, "Dator, ge mig ett tecken, 8 bitar, och kallar det c".

1044
01:05:09,180 --> 01:05:12,630
Men vad är detta på höger sida säger?

1045
01:05:13,490 --> 01:05:16,530
På engelska, vad står?

1046
01:05:16,530 --> 01:05:18,730
[Eleven] Det första tecknet i arrayen.

1047
01:05:18,730 --> 01:05:20,790
Exakt. Ge mig det första tecknet i arrayen.

1048
01:05:20,790 --> 01:05:24,090
Eller mer allmänt, ge mig den i: te tecknet i arrayen.

1049
01:05:24,090 --> 01:05:26,100
Och inse att det är nu viktigt att som datavetare,

1050
01:05:26,100 --> 01:05:27,890
vi faktiskt räknat från 0.

1051
01:05:27,890 --> 01:05:29,720
>> Du har inte utrymme för skönsmässig bedömning nu att börja göra det.

1052
01:05:29,720 --> 01:05:34,160
Nu måste du agera i enlighet med datorns förväntningar och räknar från 0

1053
01:05:34,160 --> 01:05:38,180
eftersom [0] kommer att bli det första tecknet i en sträng,

1054
01:05:38,180 --> 01:05:42,150
[1] kommer att vara den andra, [2] kommer att vara den tredje, och så vidare.

1055
01:05:42,150 --> 01:05:49,720
Så det här programmet, om jag kompilera det, är detta återigen sträng1, så sträng1,

1056
01:05:49,720 --> 01:05:54,670
och nu har jag springa sträng1 i min terminalfönster.

1057
01:05:54,670 --> 01:05:58,330
Det väntar för inmatning, så jag kommer att skriva i David, Enter,

1058
01:05:58,330 --> 01:06:02,540
och nu skriver David allt på olika linjer eftersom varsel vad jag gör.

1059
01:06:02,540 --> 01:06:05,820
Jag skriver ett tecken i taget.

1060
01:06:05,820 --> 01:06:10,100
Vi kommer inte att gå in i detalj i dag om detta, men jag raderade nyss denna kontroll här.

1061
01:06:10,100 --> 01:06:15,480
Det visar sig att om användaren missköter, kontradiktoriskt, eller bara förvirrad,

1062
01:06:15,480 --> 01:06:20,210
kan du faktiskt misslyckas med att ge en sträng av viss längd.

1063
01:06:20,210 --> 01:06:22,860
Om du trycker på fel tangent på tangentbordet, kan du ge några sträng alls,

1064
01:06:22,860 --> 01:06:26,950
eller om du är skadlig, kan du prova att klistra in en gigabyte värde av en uppsats

1065
01:06:26,950 --> 01:06:29,290
att fylla detta sträng, och om datorn får slut på minne,

1066
01:06:29,290 --> 01:06:32,710
det visar sig att vi kommer att få tillbaka denna speciella värde som kallas NULL.

1067
01:06:32,710 --> 01:06:35,580
Så för nu, bara veta att det är det här särskilt värde kallas NULL

1068
01:06:35,580 --> 01:06:39,580
som ger oss möjlighet att kontrollera när vi är ute på minne, bland annat.

1069
01:06:39,580 --> 01:06:45,630
Men om jag öppnar nu sträng2, märker en skillnad här.

1070
01:06:45,630 --> 01:06:48,210
Lägg märke till en skillnad här med sträng2.

1071
01:06:48,210 --> 01:06:51,340
Med sträng2 är detta för slinga lite annorlunda.

1072
01:06:51,340 --> 01:06:55,010
>> Låt mig ta bort nollorna så att vi kan tala om dem en annan gång.

1073
01:06:55,010 --> 01:06:57,800
Vad är annorlunda for-slingan den här gången?

1074
01:06:59,620 --> 01:07:01,670
Jag kan gå tillbaka till det tidigare exemplet.

1075
01:07:01,670 --> 01:07:08,580
Så det är version 2, är denna version 1. 1, 2.

1076
01:07:08,580 --> 01:07:11,980
1, 2.

1077
01:07:13,520 --> 01:07:16,660
Det strlen samtalet var?

1078
01:07:16,660 --> 01:07:18,860
Det är i första delen av for-slingan.

1079
01:07:18,860 --> 01:07:21,830
Några tankar om varför jag gör det här? Ja.

1080
01:07:21,830 --> 01:07:24,560
[Elev] Så du kallar inte funktionen varje gång.

1081
01:07:24,560 --> 01:07:26,440
[Malan] Så vi inte anropa funktionen varje gång. Exakt.

1082
01:07:26,440 --> 01:07:28,300
Minns från loopar att de är super enkla

1083
01:07:28,300 --> 01:07:31,770
när du typ av förstå att detta är initieringen, tillstånd och uppdateringen.

1084
01:07:31,770 --> 01:07:34,750
Problemet är att villkoret händer på varje iteration av slingan.

1085
01:07:34,750 --> 01:07:40,010
Och så i detta exempel här är vad dåligt om det faktum att detta är mitt tillstånd?

1086
01:07:40,010 --> 01:07:41,830
[Eleven] Du kallar strlen.

1087
01:07:41,830 --> 01:07:44,340
[Malan] Du kallar strlen igen och igen och igen.

1088
01:07:44,340 --> 01:07:47,410
Men när jag har skrivit i David, är längden på den strängen 5,

1089
01:07:47,410 --> 01:07:49,650
och det kommer inte att ändra på varje iteration av slingan

1090
01:07:49,650 --> 01:07:51,670
eftersom strängen fortfarande D-A-V-I-d.

1091
01:07:51,670 --> 01:07:55,320
Så detta är ett tips på vad som kommer att bli en allt viktigare idé

1092
01:07:55,320 --> 01:08:00,410
känd som en design beslut där bara inte göra datorn gör onödigt arbete.

1093
01:08:00,410 --> 01:08:03,920
>> Precis som en förhandstitt på pset2, pset2 i standardversionen

1094
01:08:03,920 --> 01:08:07,030
kommer att utmana dig att faktiskt genomföra ett visst antal chiffer,

1095
01:08:07,030 --> 01:08:10,410
ett visst antal krypteringsalgoritmer, så att du både kan kryptera

1096
01:08:10,410 --> 01:08:13,840
och dekryptera hemliga meddelanden mycket som den Ralphie där avkodas.

1097
01:08:13,840 --> 01:08:16,810
I hacker upplagan av pset2, kommer vi att gå lite längre.

1098
01:08:16,810 --> 01:08:19,649
Vi kommer att lämna dig en fil från en faktisk dator

1099
01:08:19,649 --> 01:08:23,479
som innehåller en hel massa användarnamn och faktiska krypterade lösenord,

1100
01:08:23,479 --> 01:08:26,939
och utmaningen för hacker upplagan kommer att vara att knäcka dessa lösenord

1101
01:08:26,939 --> 01:08:33,200
och räkna ut vad kryptografi eller vad hemligheten användes för att faktiskt generera dessa lösenord.

1102
01:08:33,200 --> 01:08:36,109
Och vi kommer att göra detta genom att använda en ny funktion här av C

1103
01:08:36,109 --> 01:08:40,630
att jag ska ge dig bara en demo av sk kommandoradsargument.

1104
01:08:40,630 --> 01:08:44,229
Det visar sig, som några av er kanske har sett i avsnitt eller i läroböcker,

1105
01:08:44,229 --> 01:08:48,260
viktigaste inte alltid vara ogiltig inom parentes.

1106
01:08:48,260 --> 01:08:52,430
Det visar sig att stora även kan skrivas så här, med två argument,

1107
01:08:52,430 --> 01:08:56,870
argc och argv, där argc är antalet ord

1108
01:08:56,870 --> 01:09:00,020
att du skriver efter programmets namn på kommandoraden

1109
01:09:00,020 --> 01:09:03,420
och argv är själva orden.

1110
01:09:03,420 --> 01:09:07,540
Och som hakparenteserna där antyder, är argv tydligen en matris.

1111
01:09:07,540 --> 01:09:12,210
Det kommer att vara en sträng efter en sträng efter en sträng i minnet.

1112
01:09:12,210 --> 01:09:16,010
>> Så vad vi ska kunna göra börjar med pset 2 är ungefär så här.

1113
01:09:16,010 --> 01:09:21,350
Om jag gör argv1, vilket är ett exempel som vi ska återkomma till på måndag, och kör den,

1114
01:09:21,350 --> 01:09:23,370
märker att det inte verkar göra något ännu.

1115
01:09:23,370 --> 01:09:25,490
Den skriver bara ut sitt eget namn.

1116
01:09:25,490 --> 01:09:31,479
Men om jag säger adjö klass, meddelande att detta program uppenbarligen itererar

1117
01:09:31,479 --> 01:09:35,479
över vart och ett av orden som skrivs vid prompten.

1118
01:09:35,479 --> 01:09:41,630
Och de medel genom vilka vi får tillgång till ord som användaren har skrivit vid prompten

1119
01:09:41,630 --> 01:09:49,160
är genom att ändra viktigaste utgångspunkt i helgen från int main (void) och int main (argc, argv)

1120
01:09:49,160 --> 01:09:52,050
och därmed kommer att födas kommandoradsargument.

1121
01:09:52,050 --> 01:09:57,100
Och när du får riktigt sofistikerad på detta, kommer du att kunna skriva riktigt trippy program

1122
01:09:57,100 --> 01:09:59,610
som denna här, som går utöver

1123
01:09:59,610 --> 01:10:03,940
vissa funktioner vi har gjort hittills, men alla ganska kraftfull.

1124
01:10:03,940 --> 01:10:08,950
>> Så vi lämnar detta med detta på skärmen, och vi kommer att se dig på måndag.

1125
01:10:17,570 --> 01:10:20,000
>> [CS50.TV]