1
00:00:00,000 --> 00:00:02,270
[Powered by Google Translate] [Settimana 2, Continua]

2
00:00:02,270 --> 00:00:04,220
[David J. Malan, Harvard University]

3
00:00:04,220 --> 00:00:06,880
[Questo è CS50. - CS50.TV]

4
00:00:06,880 --> 00:00:10,990
Bene. Questo è CS50, e questa è la fine della settimana 2.

5
00:00:10,990 --> 00:00:14,410
Se vi aspettate di avere fame in questo periodo di domani,

6
00:00:14,410 --> 00:00:18,620
So che stiamo andando a convocare un piccolo gruppo domani, Giovedi, 13:15.

7
00:00:18,620 --> 00:00:21,360
C'è questo URL qui se vuoi RSVP.

8
00:00:21,360 --> 00:00:26,740
Lo spazio è limitato, quindi ti prego di perdonare se il modulo è riempito nel momento in cui compili questo.

9
00:00:26,740 --> 00:00:29,300
Un altro URL, però, che potrebbe essere di interesse è questo.

10
00:00:29,300 --> 00:00:32,369
In quasi un mese di tempo, il corso sta per essere messa a disposizione

11
00:00:32,369 --> 00:00:36,890
tanto più in generale tramite edx, attraverso la quale la gente su Internet sarà in grado di seguire,

12
00:00:36,890 --> 00:00:39,380
impegnarsi nel corso abbastanza attivamente, in effetti.

13
00:00:39,380 --> 00:00:42,270
Saranno utilizzando il CS50 Appliance e CS50 Discuti

14
00:00:42,270 --> 00:00:45,490
e la maggior parte degli strumenti software diversi che già hanno utilizzato questo semestre.

15
00:00:45,490 --> 00:00:48,710
E una delle iniziative vorremmo assumere come un esperimento di quest'anno

16
00:00:48,710 --> 00:00:51,930
è quello di vedere quanto siamo in grado di tradurre i contenuti

17
00:00:51,930 --> 00:00:53,960
in altre lingue parlate e scritte.

18
00:00:53,960 --> 00:00:57,500
Quindi, se si potrebbe avere un interesse a partecipare a questo progetto

19
00:00:57,500 --> 00:01:02,270
in base al quale ci fornirà trascrizioni inglese e sottotitoli per le lezioni del corso

20
00:01:02,270 --> 00:01:05,450
e pantaloncini e seminari e sezioni e simili,

21
00:01:05,450 --> 00:01:08,200
se si parla fluentemente o scrivere correntemente un'altra lingua,

22
00:01:08,200 --> 00:01:12,290
ci piacerebbe coinvolgere in questo progetto in base al quale si prende su uno o più dei video,

23
00:01:12,290 --> 00:01:15,200
traducendoli in una lingua che si conosce abbastanza bene.

24
00:01:15,200 --> 00:01:18,700
>> Per dare un senso di interfaccia, c'è questo web-based interfaccia utente

25
00:01:18,700 --> 00:01:22,090
che useremo che creerà essenzialmente un utente come questo.

26
00:01:22,090 --> 00:01:24,290
Questo mi stava insegnando un po 'di Halloween fa,

27
00:01:24,290 --> 00:01:27,390
e sulla destra c'è in nero accanto a queste timestamp,

28
00:01:27,390 --> 00:01:31,210
vedrai le varie cose che sono uscite dalla mia bocca in quel giorno,

29
00:01:31,210 --> 00:01:34,850
e poi sotto di esso sarete in grado di tradurre in qualche altra lingua

30
00:01:34,850 --> 00:01:38,690
esattamente ciò che il mapping è tra, in questo caso, l'inglese e, per esempio, Spagnolo.

31
00:01:38,690 --> 00:01:40,440
Quindi è in realtà una molto user-friendly strumento.

32
00:01:40,440 --> 00:01:43,370
È possibile riavvolgere e far avanzare rapidamente molto rapidamente con le scorciatoie da tastiera.

33
00:01:43,370 --> 00:01:47,490
Quindi, se volete prendere parte a questo esperimento e hanno le tue parole visto e letto

34
00:01:47,490 --> 00:01:51,850
da potenzialmente migliaia di persone là fuori, per favore sentitevi liberi di partecipare.

35
00:01:51,850 --> 00:01:54,350
Una parola circa il gattino da Lunedi.

36
00:01:54,350 --> 00:02:00,350
Per non abbiamo inviato un messaggio di troppo spaventoso, si rendono conto che, come orario di ufficio suggeriscono

37
00:02:00,350 --> 00:02:03,300
e come sezioni suggeriscono, la progettazione del corso è molto

38
00:02:03,300 --> 00:02:07,360
di aver studenti collaborare e parlare a lavorare attraverso insiemi di problemi

39
00:02:07,360 --> 00:02:11,260
e problemi insieme, e in realtà la linea arriva in fondo a,

40
00:02:11,260 --> 00:02:16,010
ancora una volta, il lavoro che in ultima analisi, ritiene debbano essere il tuo.

41
00:02:16,010 --> 00:02:18,860
E così in tutta onestà, in orario di ufficio è del tutto normale,

42
00:02:18,860 --> 00:02:22,240
è del tutto prevedibile, anche, di essere in chat con qualche amico accanto a te.

43
00:02:22,240 --> 00:02:24,370
>> Se lui o lei è alle prese con un argomento e siete come,

44
00:02:24,370 --> 00:02:27,940
"Oh, beh, mi permetta di darle un assaggio di qualche linea di codice che ho scritto," va bene,

45
00:02:27,940 --> 00:02:31,250
ciò che accade, e questo è molto favorevole, credo che, con il processo di apprendimento.

46
00:02:31,250 --> 00:02:36,750
Se la linea viene attraversata è quando la testa è una sorta di inclinata qui per i secondi troppi

47
00:02:36,750 --> 00:02:41,160
o minuti che in realtà di essere stato solo l'occasione di sblocco per il tuo amico,

48
00:02:41,160 --> 00:02:44,160
e sicuramente quando le cose si scambiate via e-mail e Dropbox e simili,

49
00:02:44,160 --> 00:02:45,640
vi è anche la linea.

50
00:02:45,640 --> 00:02:48,620
Quindi, con tutti i mezzi sentirsi a proprio agio e si sentono incoraggiati a chattare con gli amici

51
00:02:48,620 --> 00:02:52,810
compagni di classe e circa pset e molto altro ancora e solo rendersi conto che ciò che si presenta alla fine

52
00:02:52,810 --> 00:02:57,340
in realtà dovrebbe essere il prodotto della vostra creazione e non qualcun altro.

53
00:02:57,340 --> 00:03:00,490
E così uno dei problemi specifici del dominio per pset2,

54
00:03:00,490 --> 00:03:04,740
che uscirà domani sera tardi, è quello di tuffarsi nel mondo della crittografia,

55
00:03:04,740 --> 00:03:08,970
che è l'arte di crittografia o cifratura dei dati,

56
00:03:08,970 --> 00:03:12,600
e questo si riferisce infine al mondo della sicurezza.

57
00:03:12,600 --> 00:03:16,560
Ora, la sicurezza per la maggior parte di noi si presenta sotto forma di meccanismi piuttosto banali.

58
00:03:16,560 --> 00:03:19,050
Tutti noi abbiamo nomi utente e password,

59
00:03:19,050 --> 00:03:23,450
e tutti noi abbiamo nomi utente e le password molto male, molto probabilmente.

60
00:03:23,450 --> 00:03:28,240
>> Se la password è la stessa su più siti web, che probabilmente non è l'idea migliore,

61
00:03:28,240 --> 00:03:30,070
come vedremo verso la fine del semestre.

62
00:03:30,070 --> 00:03:34,720
Se la password è scritto su un post-it - non è uno scherzo - sul monitor,

63
00:03:34,720 --> 00:03:38,350
anche questo non è necessariamente il miglior design, ma un fenomeno piuttosto comune.

64
00:03:38,350 --> 00:03:42,470
E se non si sta usando la crittografia per crittografare le password,

65
00:03:42,470 --> 00:03:44,210
sono particolarmente vulnerabili.

66
00:03:44,210 --> 00:03:47,270
Quindi, se pensi di essere super intelligente da avere un documento di Word nascosta

67
00:03:47,270 --> 00:03:49,910
da qualche parte sul vostro disco rigido che ha tutte le password

68
00:03:49,910 --> 00:03:53,670
ma è in una cartella che non si sta andando a guardare dentro, anche questo non è un meccanismo molto sicuro.

69
00:03:53,670 --> 00:03:56,990
E allora cosa pset2 introdurrà è questa arte della crittografia

70
00:03:56,990 --> 00:04:02,010
scrambling e informazioni in modo che cose come le password sono ancora più sicuro.

71
00:04:02,010 --> 00:04:05,790
Il contesto è che con i dati insicuri

72
00:04:05,790 --> 00:04:07,930
è la possibilità di cifrare e ad esso scramble.

73
00:04:07,930 --> 00:04:11,470
E così questo, per esempio, è un esempio di un messaggio crittografato.

74
00:04:11,470 --> 00:04:14,700
Questo in realtà dice qualcosa in inglese, ma non è chiaramente del tutto evidente.

75
00:04:14,700 --> 00:04:18,279
E torneremo al punto di oggi a prendere in giro a parte ciò che questo messaggio segreto è qui.

76
00:04:18,279 --> 00:04:23,490
Ma nel mondo reale dei computer, le cose non sembra nemmeno che potrebbero essere frasi in inglese.

77
00:04:23,490 --> 00:04:28,430
Per esempio, questo è quello che si potrebbe trovare in un standard di Linux o Mac o UNIX del computer

78
00:04:28,430 --> 00:04:32,070
in un file che una volta era un tempo chiamato il file delle password.

79
00:04:32,070 --> 00:04:34,200
>> Al giorno d'oggi è stata spostata in altri luoghi.

80
00:04:34,200 --> 00:04:39,210
Ma se si guarda al posto giusto su un sistema, si vedrà non solo il tuo nome utente

81
00:04:39,210 --> 00:04:43,400
o quella di altre persone nel sistema, ma vedrete una versione crittografata della password.

82
00:04:43,400 --> 00:04:47,980
In effetti, la cripta parola ci suggerisce che la roba che segue è crittografato,

83
00:04:47,980 --> 00:04:52,680
e questa serie di lettere apparentemente casuali e caratteri e numeri e così via

84
00:04:52,680 --> 00:04:56,480
possono essere decifrati solo generalmente conoscendo un segreto -

85
00:04:56,480 --> 00:04:58,840
una parola segreta, un numero segreto -

86
00:04:58,840 --> 00:05:03,160
e infatti, l'arte della crittografia in ultima analisi si riduce a fidarsi di qualche tipo

87
00:05:03,160 --> 00:05:05,650
e conoscere qualcosa che qualcun altro non lo fa.

88
00:05:05,650 --> 00:05:10,090
Quindi dovremo esplorare questo in dettaglio un po 'di più oggi e in pset a venire.

89
00:05:10,090 --> 00:05:12,200
Ed ora una parola sul passaggio / sicuro.

90
00:05:12,200 --> 00:05:15,360
Tanto più che alcuni di voi hanno tuffò pset1, Appliance,

91
00:05:15,360 --> 00:05:19,080
e un mondo nuovo per lei, si rende conto che le frustrazioni e la confusione

92
00:05:19,080 --> 00:05:21,700
e solo difficoltà tecniche sono abbastanza prevedibile,

93
00:05:21,700 --> 00:05:24,180
soprattutto con il pset prima, dove c'è solo così tanto nuovo,

94
00:05:24,180 --> 00:05:27,730
solo familiarizzare con ls e cd e tutti questi comandi arcani

95
00:05:27,730 --> 00:05:33,050
e un nuovo ambiente, ed è separato dal materiale reale e la programmazione stessa.

96
00:05:33,050 --> 00:05:36,940
Così conto troppo che ci sono certamente ore di ufficio che esistono come una struttura di supporto.

97
00:05:36,940 --> 00:05:38,880
>> Sezioni iniziare il prossimo Domenica.

98
00:05:38,880 --> 00:05:42,960
Ma la cosa più importante, se ti senti solo che questo non è il mondo per voi,

99
00:05:42,960 --> 00:05:44,710
rendersi conto che in realtà si limita a prendere tempo.

100
00:05:44,710 --> 00:05:48,600
E se non fosse per l'occasione anni fa per me di prendere un passaggio di classe / fail,

101
00:05:48,600 --> 00:05:50,990
onestamente, non avrei mai nemmeno messo piede in classe.

102
00:05:50,990 --> 00:05:53,690
E si può cambiare questo fino, diciamo, il Lunedi quinta del corso,

103
00:05:53,690 --> 00:05:58,280
quindi se siete al limite ora, si rendono conto che invece di testa in alcune altre acque del tutto,

104
00:05:58,280 --> 00:06:01,260
non certamente in considerazione il solo cambio di pass / fail.

105
00:06:01,260 --> 00:06:04,570
Anche in questo caso, non c'è davvero questa cultura qui a Harvard di prendere le cose pass / fail

106
00:06:04,570 --> 00:06:08,670
dal momento che tutti vuole davvero raggiungere o otterrebbe,

107
00:06:08,670 --> 00:06:11,130
ma, francamente, questo è un modo meraviglioso di provare qualcosa

108
00:06:11,130 --> 00:06:16,720
che potrebbe non essere familiare a voi, e vi ritroverete a fare, nella maggior parte dei casi, abbastanza bene,

109
00:06:16,720 --> 00:06:18,210
forse molto con vostra sorpresa.

110
00:06:18,210 --> 00:06:20,980
E in termini più concreti, quello che penso pass / fail generalmente fa,

111
00:06:20,980 --> 00:06:22,940
tanto più che si potrebbe avere sperimentato con pset0,

112
00:06:22,940 --> 00:06:26,560
se si mette in 10 ore, 15 ore, 25 ore in alcuni pset

113
00:06:26,560 --> 00:06:29,920
e sei solo sbattere la testa contro il muro e si sta facendo super-a tarda notte

114
00:06:29,920 --> 00:06:33,950
ma hai preso la pset il 90% della strada e proprio non riesco a capire una cosa,

115
00:06:33,950 --> 00:06:36,520
pass / fail prende davvero il bordo al largo di una classe come questa,

116
00:06:36,520 --> 00:06:39,100
dove si può ordinare di felicemente dire: "Va bene, lo so che non è perfetto,

117
00:06:39,100 --> 00:06:42,350
ma ho lavorato il culo su questo, sono abbastanza contento di dove è finito, "

118
00:06:42,350 --> 00:06:44,850
e in grado di soddisfare le aspettative di pass / fail.

119
00:06:44,850 --> 00:06:47,540
Quindi non tenere a mente. Bene.

120
00:06:47,540 --> 00:06:50,520
>> Così quelli di voi che hanno lottato per utilizzare la Harvard University Wi-Fi,

121
00:06:50,520 --> 00:06:54,780
so che c'è un CS50 SSID, una connessione Wi-Fi, galleggianti intorno

122
00:06:54,780 --> 00:06:56,490
che si potrebbe avere più fortuna per.

123
00:06:56,490 --> 00:07:00,130
E 'un po' ironico che la password per questo, se si vuole provare a connettersi a questo

124
00:07:00,130 --> 00:07:08,350
per una migliore velocità - e di farci sapere se si tratta di niente di meglio - è 12345, tutta la strada fino a 8

125
00:07:08,350 --> 00:07:10,910
perché 8 è più sicuro di 5.

126
00:07:10,910 --> 00:07:16,910
Quindi, se avete bisogno di password Wi-Fi, la connessione a CS50 wireless qui, 12345678,

127
00:07:16,910 --> 00:07:20,380
e post su CS50 Discutere se avete ancora problemi di connettività intermittente,

128
00:07:20,380 --> 00:07:25,420
e ti faremo i poteri che sanno essere per questo spazio. Bene.

129
00:07:25,420 --> 00:07:32,230
Quindi un teaser rapida, soprattutto per quelli di voi che sono ragazzi o ragazze fan di tutte le cose di Apple.

130
00:07:32,230 --> 00:07:37,460
Quello che ho riesumato da qualche anno fa era il file qui, iUnlock.c,

131
00:07:37,460 --> 00:07:39,930
solo per fare i tipi di più concreto e più complesso

132
00:07:39,930 --> 00:07:42,560
alcuni dei programmi più basilari C Abbiamo scritto.

133
00:07:42,560 --> 00:07:46,910
Così ho aperto questo file, iUnlock.c. E 'disponibile nella pagina lezioni per oggi.

134
00:07:46,910 --> 00:07:49,810
Sulla sinistra si vede un lungo elenco di funzioni.

135
00:07:49,810 --> 00:07:53,230
Quindi il tizio che ha scritto questo ha scritto un sacco di funzioni, più che principale.

136
00:07:53,230 --> 00:07:57,340
Ha usato un sacco di librerie di qui, e se cominciamo a scorrere,

137
00:07:57,340 --> 00:08:04,890
ciò che questo è in realtà è il primo, credo, crack per l'iPhone originale.

138
00:08:04,890 --> 00:08:09,830
>> Quando si voleva per il jailbreak di iPhone originale, il che significa untether da AT & T

139
00:08:09,830 --> 00:08:13,710
e in realtà installare un software speciale su di esso e fare cose che Apple non voleva che la gente a fare,

140
00:08:13,710 --> 00:08:18,480
qualcuno ha avuto il tempo di capire esattamente come si potrebbe sfruttare falle di software,

141
00:08:18,480 --> 00:08:22,690
errori, bug nel software di Apple, e quindi è nato iUnlock.c--

142
00:08:22,690 --> 00:08:26,760
che se è stato compilato il computer e installato su un iPhone

143
00:08:26,760 --> 00:08:29,430
che era collegato al computer tramite, per esempio, un cavo USB,

144
00:08:29,430 --> 00:08:32,450
questo darebbe privilegi di amministratore o di root sul vostro iPhone

145
00:08:32,450 --> 00:08:34,620
e consentono di fare più o meno quello che vuoi.

146
00:08:34,620 --> 00:08:36,400
E così c'è stato questo gatto affascinante e topo

147
00:08:36,400 --> 00:08:39,340
tra Apple e il resto del mondo, in particolare in quanto, come molte aziende,

148
00:08:39,340 --> 00:08:43,350
cercano di bloccare le loro cose in modo che si può fare solo con essa ciò che intendono.

149
00:08:43,350 --> 00:08:47,360
Ma grazie a gente come questa e la comprensione dei dettagli di basso livello -

150
00:08:47,360 --> 00:08:50,830
e in questo caso C programmazione - e molti dei costrutti familiari

151
00:08:50,830 --> 00:08:55,280
che abbiamo iniziato a giocare con, si è in grado di sfruttare realmente l'hardware

152
00:08:55,280 --> 00:08:59,250
in un modo si vede in forma e non necessariamente una qualche entità aziendale.

153
00:08:59,250 --> 00:09:01,600
Così, per esempio, non ho idea di che cosa tutto questo sta facendo,

154
00:09:01,600 --> 00:09:03,580
ma GetVersion sembra piuttosto semplice,

155
00:09:03,580 --> 00:09:05,710
e sembra che si tratta di una funzione che questa persona ha scritto.

156
00:09:05,710 --> 00:09:09,250
Ci vuole una specie di numero intero come argomento, non restituisce nulla,

157
00:09:09,250 --> 00:09:13,710
ma sembra loop con un ciclo for qui e una condizione if, se rottura condizione,

158
00:09:13,710 --> 00:09:16,770
e si riferisce in qualche modo i numeri di versione, se scorrere verso il basso,

159
00:09:16,770 --> 00:09:19,650
anche se molte di queste parole chiave stanno per essere nuovo.

160
00:09:19,650 --> 00:09:22,590
E ci sono un sacco di funzioni in qui non abbiamo mai visto e forse non mai vedere

161
00:09:22,590 --> 00:09:24,350
nel corso del semestre.

162
00:09:24,350 --> 00:09:29,160
>> Alla fine della giornata, segue le stesse regole e la logica che abbiamo giocato con finora.

163
00:09:29,160 --> 00:09:34,340
Quindi questo è di gran lunga troppo vecchio per risolvere i vostri iPhone o 3s 4s 5s o poco in questi giorni,

164
00:09:34,340 --> 00:09:38,830
ma so che è tutto molto derivato da questo mondo che abbiamo tuffò.

165
00:09:38,830 --> 00:09:42,280
Diamo uno sguardo a un piccolo esempio più semplice:

166
00:09:42,280 --> 00:09:46,260
questo, solo per ottenere riscaldato con qualche sintassi e anche qualche altro tipo di dati

167
00:09:46,260 --> 00:09:48,910
che abbiamo parlato, ma non hanno in realtà visto in C.

168
00:09:48,910 --> 00:09:53,670
Si tratta di un file chiamato positive1.c, e per i commenti in alto,

169
00:09:53,670 --> 00:09:56,070
ciò richiede solo che un utente di fornire un numero positivo.

170
00:09:56,070 --> 00:09:59,910
Quindi è un esempio di un ciclo do-while, che è bello per i programmi utente interattivi

171
00:09:59,910 --> 00:10:02,070
in cui è necessario indicare all'utente di fare qualcosa,

172
00:10:02,070 --> 00:10:05,530
e se non collaborano si urlare contro di loro o rifiutare il loro ingresso.

173
00:10:05,530 --> 00:10:10,480
Caso in questione: ho intenzione di fare le linee 19 a 24

174
00:10:10,480 --> 00:10:14,620
fino a quando l'utente non mi ha dato un numero positivo.

175
00:10:14,620 --> 00:10:21,340
Questo dettaglio qui sulla linea 18, perché dichiaro n di sopra di questo ciclo intero costrutto

176
00:10:21,340 --> 00:10:26,870
al contrario di proprio accanto alla linea 22 dove ho fatto la cura per ottenere n? Gia '.

177
00:10:26,870 --> 00:10:29,330
[Studente] Ambito di applicazione. >> Si ', per cui la questione del campo di applicazione.

178
00:10:29,330 --> 00:10:31,770
E in parole povere, che cosa fare riferimento alla portata?

179
00:10:34,880 --> 00:10:41,560
Gia '. >> [Risposta degli studenti incomprensibile] >> Si può parlare un po 'più forte?

180
00:10:41,560 --> 00:10:45,440
[Studente] Dove è possibile accedere a tale variabile. Perfetto >>.

181
00:10:45,440 --> 00:10:47,610
Dove è possibile accedere a una particolare variabile.

182
00:10:47,610 --> 00:10:50,990
E, in generale, la regola pratica finora è stato che la portata di alcune variabili

183
00:10:50,990 --> 00:10:56,140
è definita dalle parentesi graffe più recenti che avete visto.

184
00:10:56,140 --> 00:11:03,070
>> E così, in questo caso, se ho fatto l'errore di dichiarare n sulla linea 22, la linea avrebbe funzionato.

185
00:11:03,070 --> 00:11:10,840
Vorrei avere un int, e io la metterei in quella variabile n in linea 22,

186
00:11:10,840 --> 00:11:17,060
ma che riga di codice che ora non hanno alcuna idea di cosa sto parlando? >> [Studente] 25.

187
00:11:17,060 --> 00:11:23,840
[Malan] 25, e si scopre che 24 come bene perché in questo caso non rientra le parentesi graffe.

188
00:11:23,840 --> 00:11:28,550
Quindi, solo un po 'di una seccatura, ma molto facilmente risolto semplicemente dichiarando la variabile

189
00:11:28,550 --> 00:11:30,700
fuori della funzione stessa.

190
00:11:30,700 --> 00:11:32,760
Vedremo nel corso della giornata è possibile fare un ulteriore passo avanti

191
00:11:32,760 --> 00:11:34,940
e si potrebbe anche ottenere un po 'pigro.

192
00:11:34,940 --> 00:11:39,660
E questo non è da raccomandare in generale, ma si potrebbe anche ottenere pigri

193
00:11:39,660 --> 00:11:44,150
e mettere una variabile globale, per così dire, non all'interno di una funzione, non all'interno di un ciclo,

194
00:11:44,150 --> 00:11:49,800
ma nel file stesso, al di fuori di tutte le funzioni che hai scritto, come ho fatto qui sulla linea 15.

195
00:11:49,800 --> 00:11:55,220
Questo è generalmente visto di buon occhio, ma mi rendo conto questa è una soluzione a volte per altri problemi,

196
00:11:55,220 --> 00:11:56,910
come vedremo finalmente vedere.

197
00:11:56,910 --> 00:11:59,500
Quindi per ora ci lasciamo così, ma vediamo se siamo in grado di riscrivere il

198
00:11:59,500 --> 00:12:02,360
tanto per cominciare esprimere noi stessi un po 'diverso.

199
00:12:02,360 --> 00:12:05,550
Questo programma, tanto per essere chiari, è positive1.

200
00:12:05,550 --> 00:12:11,980
Lasciami andare avanti qui e nella mia finestra di terminale fare positive1, Invio.

201
00:12:11,980 --> 00:12:15,080
Compila bene. Io vado a correre positive1, premete Invio.

202
00:12:15,080 --> 00:12:19,250
Esigo che tu mi dia un numero intero positivo. Dirò -1. Non ha funzionato.

203
00:12:19,250 --> 00:12:22,340
0, 99. Questo sembra funzionare.

204
00:12:22,340 --> 00:12:25,310
Forse non la prova più rigorosa, ma almeno è un controllo di integrità bella

205
00:12:25,310 --> 00:12:27,100
che siamo sulla strada giusta.

206
00:12:27,100 --> 00:12:29,570
>> Così ora lasciami andare avanti e aprire la versione 2 di questo,

207
00:12:29,570 --> 00:12:32,800
e ciò che è già diverso?

208
00:12:32,800 --> 00:12:39,030
Essa attua la stessa cosa, ma ciò che salta fuori il più chiaramente diverso questa volta?

209
00:12:40,790 --> 00:12:47,090
Questo bool in verde. Si è evidenziato in verde, questa parola chiave conosciuto come bool, che è un tipo di dati.

210
00:12:47,090 --> 00:12:50,510
Non viene integrato in tutte le versioni di C.

211
00:12:50,510 --> 00:12:52,650
È necessario includere una libreria specifica.

212
00:12:52,650 --> 00:12:56,460
Nel nostro caso, ho inserito il CS50 biblioteca in modo da avere accesso a bool.

213
00:12:56,460 --> 00:12:59,860
Ma in linea 18, ci sembra di avere un valore booleano che qui chiamano grati.

214
00:12:59,860 --> 00:13:02,190
Avrei potuto chiamare questo niente, ma ho chiamato grato

215
00:13:02,190 --> 00:13:04,750
solo per trasmettere qualche tipo di significato semantico.

216
00:13:04,750 --> 00:13:07,700
Quindi inizialmente sulla linea 18, non sono evidentemente grato

217
00:13:07,700 --> 00:13:12,230
perché il valore booleano grato è inizializzato a false nella riga 18.

218
00:13:12,230 --> 00:13:16,500
E poi sembra che quello che ho fatto nelle linee 21 e 23

219
00:13:16,500 --> 00:13:19,200
è che ho solo un po 'riscritto la mia logica.

220
00:13:19,200 --> 00:13:26,100
Quindi no funzionalmente diverse, ma in linea 22 ora verificare se l'int l'utente ha fornito

221
00:13:26,100 --> 00:13:31,360
è maggiore di 0, quindi ho semplicemente cambiare il valore di grato su true.

222
00:13:31,360 --> 00:13:35,590
E perché dovrei farlo? Perché in linea 25, a quanto pare ho intenzione di verificare una condizione.

223
00:13:35,590 --> 00:13:39,760
Fate questo ciclo while è falsa grati.

224
00:13:39,760 --> 00:13:42,960
Così ho proposto come alternativa alla versione 1

225
00:13:42,960 --> 00:13:47,050
perché è almeno un po 'più intuitivo, forse, è un po' più a terra in lingua inglese.

226
00:13:47,050 --> 00:13:51,980
Quindi, effettuare le seguenti operazioni, mentre non sei grato o mentre grato è falso.

227
00:13:51,980 --> 00:13:56,220
E anche questa volta mi pare non mi interessa ricordare ciò che l'utente ha digitato

228
00:13:56,220 --> 00:14:00,050
perché non c'è nessun avviso n variabile, quindi in realtà, una piccola bugia bianca lì.

229
00:14:00,050 --> 00:14:03,290
>> Punto di vista funzionale, il programma è un po 'diversa una volta che andare a fondo di esso

230
00:14:03,290 --> 00:14:04,960
perché io non mi ricordo che cosa è n.

231
00:14:04,960 --> 00:14:09,120
Ma ho voluto dimostrare anche qui che, anche se abbiamo visto GetInt

232
00:14:09,120 --> 00:14:13,780
e GetString utilizzato sul lato destro di un segno di uguale finora

233
00:14:13,780 --> 00:14:17,310
in modo da ricordare il valore, tecnicamente, non è strettamente necessario.

234
00:14:17,310 --> 00:14:20,290
Se per qualsiasi motivo non solo la cura per salvare il valore,

235
00:14:20,290 --> 00:14:25,540
si vuole solo controllare il valore, si noti che possiamo semplicemente scrivere questo come GetInt,

236
00:14:25,540 --> 00:14:27,320
aperta parentesi, parentesi vicino.

237
00:14:27,320 --> 00:14:30,570
Tale funzione sta per restituire un valore, come abbiamo detto.

238
00:14:30,570 --> 00:14:32,220
E 'intenzione di dare indietro un int.

239
00:14:32,220 --> 00:14:34,460
E quindi se mentalmente pensa che ciò accada,

240
00:14:34,460 --> 00:14:38,190
quando digito nel 99, GetInt restituisce il numero 99,

241
00:14:38,190 --> 00:14:41,840
e così concettualmente, è come se il mio codice erano in realtà questo.

242
00:14:41,840 --> 00:14:45,950
Quindi, se il 99 è effettivamente maggiore di 0, quindi grato diventa vero,

243
00:14:45,950 --> 00:14:50,810
poi linea 25 si rende conto ooh, abbiamo finito, perché ora sono grato,

244
00:14:50,810 --> 00:14:53,970
e in linea 26, diciamo semplicemente: "Grazie per l'intero positivo!"

245
00:14:53,970 --> 00:14:55,960
qualunque cosa è successo di essere.

246
00:14:55,960 --> 00:14:59,140
Ora facciamo una leggera zucchero sintattico qui, per così dire.

247
00:14:59,140 --> 00:15:04,670
Vediamo se riusciamo a ripulire questa linea 25 con questa variante terzo e ultimo positive3.

248
00:15:04,670 --> 00:15:13,600
>> Si noti la differenza solo ora è quello che riga di codice? >> [Studente] 25. >> [Malan] Si ', 25.

249
00:15:13,600 --> 00:15:17,680
E non abbiamo veramente visto questo trucco appena ancora, ma abbiamo fatto vedere il punto esclamativo il Lunedi,

250
00:15:17,680 --> 00:15:21,070
che indica che cosa? >> [Studente] Non. Non >> o negazione.

251
00:15:21,070 --> 00:15:23,510
Così ha un valore booleano e capovolgere il suo valore.

252
00:15:23,510 --> 00:15:25,810
Vero diventa falso, falso diventa vero.

253
00:15:25,810 --> 00:15:30,420
Quindi questo, vorrei proporre, è anche un po 'più intuitivo il modo di scrivere il codice

254
00:15:30,420 --> 00:15:33,430
perché ancora inizializzare grato a false, ho ancora effettuare le seguenti operazioni,

255
00:15:33,430 --> 00:15:36,010
Ho impostato grato a true quando sarà il momento,

256
00:15:36,010 --> 00:15:40,880
ma ora si può davvero solo tradurre questo codice verbalmente da sinistra a destra,

257
00:15:40,880 --> 00:15:45,630
while (grati!) perché il punto esclamativo indica botto o la nozione di non,

258
00:15:45,630 --> 00:15:47,580
così, mentre non grata.

259
00:15:47,580 --> 00:15:49,900
Quindi, di nuovo, non abbiamo introdotto nuovi concetti di per sé.

260
00:15:49,900 --> 00:15:53,730
Abbiamo parlato di valori booleani indietro quando abbiamo giocato con Scratch,

261
00:15:53,730 --> 00:15:56,720
ma rendersi conto ora possiamo iniziare a scrivere il nostro codice in molti modi diversi.

262
00:15:56,720 --> 00:16:01,060
Quindi, soprattutto in pset1 se siete una sorta di fatica a capire il modo di scrivere qualche programma,

263
00:16:01,060 --> 00:16:04,340
probabilità sono che siete fortunati perché non ci può essere un qualsiasi numero di soluzioni

264
00:16:04,340 --> 00:16:06,110
che può accadere al momento.

265
00:16:06,110 --> 00:16:10,500
Per esempio, questo è solo per 3 anche il più semplice dei programmi. Bene.

266
00:16:10,500 --> 00:16:14,200
E ora ricordo il Lunedi abbiamo lasciato su questa nota con valori di ritorno.

267
00:16:14,200 --> 00:16:18,450
Così, per la prima volta abbiamo scritto un programma che non solo principale;

268
00:16:18,450 --> 00:16:22,550
ma ha anche una sua funzione personalizzata che ho scritto qui.

269
00:16:22,550 --> 00:16:26,810
Quindi, in linea 31 a 34 ho implementato una funzione cubo.

270
00:16:26,810 --> 00:16:30,240
Non è complessa. E 'solo un * a * a in questo caso.

271
00:16:30,240 --> 00:16:34,750
Ma ciò che è importante a questo proposito è che sto prendendo l'input sotto forma di un

272
00:16:34,750 --> 00:16:39,180
e sto tornando in uscita sotto forma di un * a * a.

273
00:16:39,180 --> 00:16:43,560
Così ora ho la possibilità, proprio come facevo con prinf da solo,

274
00:16:43,560 --> 00:16:47,240
per chiamare questa funzione chiamando la funzione cubo.

275
00:16:47,240 --> 00:16:51,970
>> E la funzione cubo richiede un po 'di input, e la funzione cubo restituisce un output.

276
00:16:51,970 --> 00:16:56,960
Al contrario, printf appena fatto qualcosa.

277
00:16:56,960 --> 00:17:00,840
Essa non ha restituito tutto ciò che abbiamo a cuore, anche se, come nota a margine che non restituisce un valore;

278
00:17:00,840 --> 00:17:03,110
basta generalmente ignorarlo.

279
00:17:03,110 --> 00:17:06,510
Printf appena fatto qualcosa. Esso aveva un effetto collaterale di stampa sulla schermata.

280
00:17:06,510 --> 00:17:11,770
Al contrario qui, abbiamo la funzione di cubo, che restituisce effettivamente qualcosa.

281
00:17:11,770 --> 00:17:15,520
Quindi, per chi ha familiarità con questo, è una idea abbastanza semplice.

282
00:17:15,520 --> 00:17:19,640
Ma per coloro che hanno meno familiarità con l'idea di passare in input e tornare uscite,

283
00:17:19,640 --> 00:17:21,950
proviamo solo semplice qualcosa di super.

284
00:17:21,950 --> 00:17:25,490
C'è qualcuno che sta comodo in arrivo sul palco per breve tempo?

285
00:17:25,490 --> 00:17:28,040
Devi stare bene con una macchina fotografica su di voi pure. Si '? Va bene.

286
00:17:28,040 --> 00:17:31,240
Qual è il tuo nome? >> [Studente] Ken. Ken >>. Bene. Ken, vieni su.

287
00:17:31,240 --> 00:17:35,050
Ken sarà una funzione della specie qui.

288
00:17:35,050 --> 00:17:38,720
Andiamo avanti e farlo. Prendiamo un po 'di fantasia.

289
00:17:38,720 --> 00:17:42,260
Lieto di vederla. Benvenuti al centro della scena. Bene.

290
00:17:42,260 --> 00:17:46,640
Che ha colpito questo pulsante qui. Bene.

291
00:17:46,640 --> 00:17:49,820
Così qui avete una lavagna moderna,

292
00:17:49,820 --> 00:17:53,470
e quello che sono è la funzione principale, per esempio,

293
00:17:53,470 --> 00:17:56,460
e non ho un iPad in mano.

294
00:17:56,460 --> 00:17:59,710
>> Non mi ricordo come - Beh, non posso dire che.

295
00:17:59,710 --> 00:18:02,480
Io in realtà non hanno una buona grafia,

296
00:18:02,480 --> 00:18:05,520
e così quindi voglio di stampare qualcosa sullo schermo per me.

297
00:18:05,520 --> 00:18:12,040
Sto è il programma principale, e ho intenzione di averti dire questo

298
00:18:12,040 --> 00:18:16,720
scrivendo nel mio graffi pollo e poi passando voi un ingresso.

299
00:18:16,720 --> 00:18:20,400
Così stupido se questo esercizio è, il concetto di funzioni e chiamare una funzione

300
00:18:20,400 --> 00:18:22,400
e il ritorno di una funzione davvero si riduce a questo.

301
00:18:22,400 --> 00:18:26,260
Sono principale, ho appena scritto printf, quote-unquote qualcosa sullo schermo,

302
00:18:26,260 --> 00:18:29,110
Sono in esecuzione di questo programma, e non appena printf viene chiamato,

303
00:18:29,110 --> 00:18:32,880
ci vuole un argomento o un parametro, talvolta, tra doppi apici.

304
00:18:32,880 --> 00:18:35,880
Ecco questo argomento. Lo sto passando a Ken.

305
00:18:35,880 --> 00:18:39,020
E 'una scatola nera scritto un certo numero di anni fa

306
00:18:39,020 --> 00:18:41,510
che a quanto pare conosce solo come stampare le cose sullo schermo.

307
00:18:41,510 --> 00:18:43,150
Quindi eseguire.

308
00:18:49,280 --> 00:18:51,280
Non è male. Molto buono.

309
00:18:51,280 --> 00:18:55,510
Così ora Ken è fatto in esecuzione. Ha bisogno di darmi nulla in cambio?

310
00:18:55,510 --> 00:18:57,470
Non che abbiamo visto finora.

311
00:18:57,470 --> 00:19:00,460
Anche in questo caso, printf in effetti restituisce un numero, ma abbiamo intenzione di ignorare che per ora

312
00:19:00,460 --> 00:19:03,470
perché non abbiamo mai usato. Ecco, questo è esso per Ken.

313
00:19:03,470 --> 00:19:08,580
E così ora principale assume il controllo del programma di nuovo

314
00:19:08,580 --> 00:19:11,060
perché quella riga di codice, printf, è fatto in esecuzione.

315
00:19:11,060 --> 00:19:14,050
E si va la nostra strada, l'esecuzione di qualunque altre linee ci sono.

316
00:19:14,050 --> 00:19:17,320
Ora proviamo un esempio leggermente diverso.

317
00:19:17,320 --> 00:19:24,940
Questa volta qui si deve prima cancellare lo schermo, e questa volta faremo la funzione di cubatura,

318
00:19:24,940 --> 00:19:27,080
ma questa volta, mi aspetto un valore di uscita.

319
00:19:27,080 --> 00:19:29,180
>> Quindi cerchiamo di andare avanti e farlo.

320
00:19:29,180 --> 00:19:35,790
Ora ho una riga di codice che dice che x diventa cubo di x.

321
00:19:41,370 --> 00:19:46,370
La riga di codice, richiamo, assomiglia a questo: x = cube (x);

322
00:19:46,370 --> 00:19:50,930
Così come è questo di andare a lavorare? Andiamo avanti e dare uno schermo bianco di nuovo.

323
00:19:50,930 --> 00:19:54,070
Ho intenzione di scrivere ora il valore di x,

324
00:19:54,070 --> 00:20:01,400
che in questo momento sembra essere, diciamo, 2 per mantenere le cose semplici.

325
00:20:01,400 --> 00:20:06,150
Ho scritto su un pezzo di carta del valore di 2, che è il mio valore x.

326
00:20:06,150 --> 00:20:10,920
L'ho mano a Ken. >> E ho appena scrivere la risposta? >> Si ', diciamo solo scrivere la risposta.

327
00:20:12,760 --> 00:20:18,940
Va bene. E ora deve restituire qualcosa. Perfetto. Segue Nizza.

328
00:20:18,940 --> 00:20:23,120
Così ora mi porge nuovamente il valore di 8 in questo caso, e cosa devo fare?

329
00:20:23,120 --> 00:20:28,250
In realtà - vediamo, ottenere questo diritto. Cosa devo fare con esso?

330
00:20:28,250 --> 00:20:33,440
Ora sto andando a prendere questo valore e in realtà conservare in quegli stessi bit in memoria.

331
00:20:33,440 --> 00:20:35,170
Ma bando Sono un po 'di lottare qui.

332
00:20:35,170 --> 00:20:38,210
Sono un po 'confuso perché dove ho effettivamente scrivere il valore di x,

333
00:20:38,210 --> 00:20:43,150
perché quello che ho appena fatto è fisicamente Ken mano un pezzo di carta che aveva il valore 2,

334
00:20:43,150 --> 00:20:46,590
che era x, e in effetti, è proprio quello che è successo.

335
00:20:46,590 --> 00:20:50,210
Così si scopre che quando si chiama la funzione e si passa in una discussione

336
00:20:50,210 --> 00:20:53,290
come ciao, mondo o si passa in una discussione come 2,

337
00:20:53,290 --> 00:20:57,110
in generale, si sta passando a una copia di tale argomento.

338
00:20:57,110 --> 00:21:00,730
E così come ho scritto il numero 2 qui e lo porse a Ken,

339
00:21:00,730 --> 00:21:04,720
che deve dire che ho ancora una copia del valore 2 da qualche parte

340
00:21:04,720 --> 00:21:08,890
perché in effetti, ora che ho ottenuto di nuovo il valore 8, ho bisogno di tornare indietro nella RAM

341
00:21:08,890 --> 00:21:12,130
e in realtà scrivere 8, dove una volta ho avuto il numero 2.

342
00:21:12,130 --> 00:21:16,950
Quindi visivamente, ricorda questa nozione di passare a, letteralmente, una copia del valore.

343
00:21:16,950 --> 00:21:20,780
>> Ken fa la sua cosa, mi dà indietro qualcosa - in questo caso un valore come 8 -

344
00:21:20,780 --> 00:21:24,980
e poi devo fare qualcosa con quel valore se voglio tenerlo in giro.

345
00:21:24,980 --> 00:21:29,650
Quindi, tutto questo tornerà a essere fin troppo bene in breve tempo.

346
00:21:29,650 --> 00:21:34,920
Grazie mille per questa demo qui, Ken. [Applausi]

347
00:21:34,920 --> 00:21:36,920
Molto ben fatto.

348
00:21:36,920 --> 00:21:42,690
Vediamo come in ultima analisi, che si riferisce ad alcune delle funzione chiamante che stiamo facendo qui.

349
00:21:42,690 --> 00:21:47,910
Lasciatemi andare avanti e ci riportano alla cubatura esempio qui.

350
00:21:47,910 --> 00:21:53,300
Si noti che se vogliamo iniziare effettivamente l'assunzione di questo ulteriore,

351
00:21:53,300 --> 00:21:57,570
stiamo andando ad avere per essere consapevoli del fatto che il numero x che viene passato qui

352
00:21:57,570 --> 00:22:01,530
è diverso da ciò che è effettivamente essere passato alla funzione.

353
00:22:01,530 --> 00:22:05,880
Quindi, di nuovo, questo passaggio per copia sta per diventare molto germano in un attimo.

354
00:22:05,880 --> 00:22:09,580
Diamo uno sguardo a qualcosa che non tutto funziona bene ancora.

355
00:22:09,580 --> 00:22:13,250
Ho intenzione di andare avanti e aprire un terzo esempio buggy, che è viziata dalla natura,

356
00:22:13,250 --> 00:22:18,550
e si chiama buggy3 e implementa una funzione di scambio.

357
00:22:18,550 --> 00:22:25,110
Qui abbiamo una funzione principale che ha x ed y arbitrariamente inizializzato a 1 e 2, rispettivamente.

358
00:22:25,110 --> 00:22:27,700
Potremmo usare GetInt, ma abbiamo solo bisogno di un semplice esercizio,

359
00:22:27,700 --> 00:22:30,170
quindi è hardcoded come 1 e 2.

360
00:22:30,170 --> 00:22:35,340
In linee 21 e 22, che apparentemente stampare x ed y, 1 per riga.

361
00:22:35,340 --> 00:22:39,720
Poi sulla linea 23, rivendico sto scambiando questi valori, punto, punto, punto.

362
00:22:39,720 --> 00:22:44,170
Mi pare chiamare una funzione alla riga 24 di swap cd che prende 2 argomenti.

363
00:22:44,170 --> 00:22:48,300
E 'del tutto legit per le funzioni di prendere 2 argomenti. Abbiamo visto printf lo fanno già.

364
00:22:48,300 --> 00:22:51,830
>> Quindi scambio prende apparentemente x e y, e come suggerisce il nome,

365
00:22:51,830 --> 00:22:54,670
Mi auguro che sta andando a scambiare questi 2 valori.

366
00:22:54,670 --> 00:23:00,090
Allora io sostengo sulla linea 25 "scambiati!" e io ristampare x e y

367
00:23:00,090 --> 00:23:03,070
sotto l'ipotesi che hanno effettivamente state scambiate.

368
00:23:03,070 --> 00:23:06,080
Ma se io in realtà esegue questo programma - lasciatemi aprire una finestra di terminale,

369
00:23:06,080 --> 00:23:09,860
permettetemi di fare buggy3 - come suggerisce il nome, questo non sta andando a finire bene

370
00:23:09,860 --> 00:23:15,770
perché quando ho premere Invio, si noti che x è 1, y è 2,

371
00:23:15,770 --> 00:23:19,420
e ancora alla fine del programma, sono ancora, infatti, lo stesso.

372
00:23:19,420 --> 00:23:22,960
Quindi, basata sulla dimostrazione poco fa con Ken, cosa sta realmente succedendo?

373
00:23:22,960 --> 00:23:28,710
Tuffiamoci in questa funzione di scambio. E 'super breve. Sono solo poche righe di codice lungo.

374
00:23:28,710 --> 00:23:34,520
Ma qual è il problema fondamentale basato sulla storia semplice che racconta qui con Ken?

375
00:23:34,520 --> 00:23:36,670
Perché è rotto di swap?

376
00:23:36,670 --> 00:23:39,660
[Studente] Ecco la memorizzazione su una copia non, la variabile.

377
00:23:39,660 --> 00:23:43,980
Esattamente. Siamo la memorizzazione su una copia non, la variabile stessa.

378
00:23:43,980 --> 00:23:47,170
In altre parole, scambio prende 2 argomenti a quanto pare, un int,

379
00:23:47,170 --> 00:23:49,370
ed è arbitrariamente chiamati A e B,

380
00:23:49,370 --> 00:23:54,420
e qui ho passato in x ed y, che sono rispettivamente 1 e 2,

381
00:23:54,420 --> 00:23:58,770
ma io non sono letteralmente passando x, non sto letteralmente passando y,

382
00:23:58,770 --> 00:24:01,450
Sto passando una copia di x e una copia di y.

383
00:24:01,450 --> 00:24:04,510
E 'quasi come se è stato copiato e incollato in swap

384
00:24:04,510 --> 00:24:07,810
i valori che si desidera per manipolare effettivamente.

385
00:24:07,810 --> 00:24:14,480
Quindi, se questo è il caso, quando l'avvio del programma di esecuzione linea 35 poi 36,

386
00:24:14,480 --> 00:24:18,650
quando arrivo a riga 37, a questo punto della storia, qual è il valore di un?

387
00:24:21,040 --> 00:24:25,050
A questo punto della storia, riga 37, che è il valore di a questo punto? >> [Studente] 1.

388
00:24:25,050 --> 00:24:29,280
[Malan] Dovrebbe essere solo 1, a destra, in quanto x è stato passato come primo argomento,

389
00:24:29,280 --> 00:24:33,080
e questa funzione è sufficiente arbitrariamente sta chiamando il suo primo argomento a.

390
00:24:33,080 --> 00:24:38,200
Allo stesso modo è Y il secondo argomento, ed è solo arbitrariamente chiamando il b secondo argomento.

391
00:24:38,200 --> 00:24:40,990
>> Questa dicotomia è in realtà abbastanza semplice spiegato. Pensateci.

392
00:24:40,990 --> 00:24:43,320
Nessuno di noi ha incontrato la persona che ha scritto printf,

393
00:24:43,320 --> 00:24:50,770
quindi sicuramente, lui o lei non ha idea di quello che le nostre variabili 30 anni dopo stanno per essere chiamati.

394
00:24:50,770 --> 00:24:56,650
Quindi ci deve essere una distinzione tra ciò che voi chiamate variabili in funzioni che stai scrivendo

395
00:24:56,650 --> 00:25:02,080
e ciò che chiamate variabili in funzioni che si sta chiamando o usando.

396
00:25:02,080 --> 00:25:05,340
In altre parole, ho scritto le mie variabili come x e y,

397
00:25:05,340 --> 00:25:08,890
ma se qualcun altro aveva scritto la funzione di scambio, lui o lei di certo non avrebbe saputo

398
00:25:08,890 --> 00:25:10,690
quello che i miei variabili stanno per essere chiamato,

399
00:25:10,690 --> 00:25:13,830
in modo da rendersi conto che questo è il motivo che ha questa dualità di nomi.

400
00:25:13,830 --> 00:25:16,750
Tecnicamente, potrei fare questo per caso,

401
00:25:16,750 --> 00:25:20,080
ma sarebbe ancora passata in tante copie.

402
00:25:20,080 --> 00:25:23,650
Sarebbe solo una pura coincidenza esteticamente se la persona che ha scritto di swap

403
00:25:23,650 --> 00:25:26,150
aveva usato gli stessi nomi.

404
00:25:26,150 --> 00:25:32,370
Quindi, a questo punto della storia, la linea 37, a è 1, b è 2, e ora procedo per scambiarle.

405
00:25:32,370 --> 00:25:34,900
Prima di tutto, vorrei effettivamente fare questo molto più semplicemente.

406
00:25:34,900 --> 00:25:36,690
Non so che cosa quelle 3 righe di codice sono state facendo.

407
00:25:36,690 --> 00:25:41,210
Vorrei solo fare questo: b = a, a = b; fatto.

408
00:25:41,210 --> 00:25:44,690
Perché è rotto, logico?

409
00:25:46,490 --> 00:25:48,900
È un po 'la cosa intuitiva, giusto?

410
00:25:48,900 --> 00:25:52,560
Così un b and b diventa diventa,

411
00:25:52,560 --> 00:25:57,730
ma il problema è che non appena la linea 37 esegue, qual è il valore di A e B?

412
00:25:57,730 --> 00:26:03,410
Lo stesso, 1, perché hai rovinati, per così dire, hai cambiato b corrisponderanno a.

413
00:26:03,410 --> 00:26:08,890
Quindi una volta che la linea 37 ha eseguito, che è grande, ora avete 2 copie del numero 1

414
00:26:08,890 --> 00:26:13,350
all'interno di questa funzione, così poi quando si dice in linea 38 a = b,

415
00:26:13,350 --> 00:26:17,640
sei tipo di naso, perché si sta solo assegnando 1 a 1.

416
00:26:17,640 --> 00:26:20,580
Hai perso il tipo di valore che si interessava.

417
00:26:20,580 --> 00:26:23,220
Quindi, nella versione originale di questo, nota quello che ho fatto.

418
00:26:23,220 --> 00:26:26,850
Ho invece avuto una terza riga di codice che si presentava così.

419
00:26:26,850 --> 00:26:28,580
Dichiaro una variabile temporanea.

420
00:26:28,580 --> 00:26:32,170
>> Tmp è un nome molto comune per una variabile temporanea, ed è un int

421
00:26:32,170 --> 00:26:34,580
perché deve rispondere a quello che voglio fare una copia di.

422
00:26:34,580 --> 00:26:39,770
Devo conservare copia di un interno di tmp, quindi una volta che la linea 37 è stato eseguito,

423
00:26:39,770 --> 00:26:45,860
il valore di a è - rapido controllo sanity - 1, il valore di b è 2,

424
00:26:45,860 --> 00:26:48,970
e il valore di tmp è anche 1.

425
00:26:48,970 --> 00:26:52,060
Così ora eseguo linea 38.

426
00:26:52,060 --> 00:27:00,540
Una volta eseguita la linea 38, assume un valore di b. E b è stato di 2, quindi un ora 2.

427
00:27:00,540 --> 00:27:05,210
Quindi, a questo punto della storia, a è 2, b è 2, e tmp è 1,

428
00:27:05,210 --> 00:27:11,060
così ora logicamente, possiamo solo valore di tmp plop in b e abbiamo finito.

429
00:27:11,060 --> 00:27:12,800
Così abbiamo risolto il problema.

430
00:27:12,800 --> 00:27:17,720
Purtroppo, quando si esegue il programma in questa forma, in realtà non scambiare i valori.

431
00:27:17,720 --> 00:27:20,100
Ma per essere chiari, perché?

432
00:27:23,660 --> 00:27:26,450
Ho risolto il problema logico da appena un momento fa,

433
00:27:26,450 --> 00:27:31,020
ma ancora una volta, se si esegue il programma, x e y restano invariati

434
00:27:31,020 --> 00:27:33,310
alla fine dell'esecuzione del programma.

435
00:27:33,310 --> 00:27:37,220
[Commento studente incomprensibile] >> Non ci siamo tornati niente, quindi è vero.

436
00:27:37,220 --> 00:27:39,670
Ma si scopre c'è un po 'un problema qui, perché fino ad ora,

437
00:27:39,670 --> 00:27:44,170
l'unica cosa che siamo stati in grado di tornare è una cosa, e questa è una limitazione di C.

438
00:27:44,170 --> 00:27:49,070
È possibile tornare veramente un valore, nel qual caso sono un po 'bloccato qui

439
00:27:49,070 --> 00:27:53,310
perché ho potuto restituire il nuovo valore di x oppure avrei potuto restituire il nuovo valore di y,

440
00:27:53,310 --> 00:27:55,190
ma voglio sia indietro.

441
00:27:55,190 --> 00:27:58,650
Quindi ritorno non è la soluzione più semplice qui.

442
00:27:58,650 --> 00:28:01,710
Ma il problema è fondamentalmente il motivo? Cosa abbiamo scambiato?

443
00:28:01,710 --> 00:28:04,190
[Studente] a e b. >> A e b.

444
00:28:04,190 --> 00:28:08,230
Ma a e b sono copie di x e y, il che significa che abbiamo appena fatto tutto questo lavoro,

445
00:28:08,230 --> 00:28:11,650
abbiamo appena trascorso 3 minuti a parlare sulla funzione swap e tutti e 3 di queste variabili,

446
00:28:11,650 --> 00:28:15,420
e questo è grande, perfettamente corretto in isolamento,

447
00:28:15,420 --> 00:28:20,740
ma una portata e b è solo in queste righe qui.

448
00:28:20,740 --> 00:28:24,790
>> Quindi, proprio come un ciclo for, se si dichiara un intero i all'interno del ciclo for,

449
00:28:24,790 --> 00:28:28,760
Allo stesso modo, se si sta dentro dichiara a e b di una funzione che hai scritto,

450
00:28:28,760 --> 00:28:33,320
sono validi solo all'interno di tale funzione, il che significa che non appena swap è fatto in esecuzione

451
00:28:33,320 --> 00:28:38,470
e si va da riga 24 alla riga 25, x e y non sono stati cambiati per niente.

452
00:28:38,470 --> 00:28:42,790
Hai appena sprecato un sacco di tempo scambiare copie di variabili.

453
00:28:42,790 --> 00:28:47,010
Così si scopre che la soluzione a questo è in realtà non ovvio.

454
00:28:47,010 --> 00:28:50,670
Non è del tutto sufficiente per restituire i valori, perché siamo in grado di restituire solo 1 valore,

455
00:28:50,670 --> 00:28:53,470
e mi voglio scambiare sia x e y, allo stesso tempo,

456
00:28:53,470 --> 00:28:55,210
quindi stiamo andando ad avere per tornare a questo.

457
00:28:55,210 --> 00:29:01,020
Ma per ora conto che il problema fondamentale deriva dal fatto che A e B sono copie

458
00:29:01,020 --> 00:29:03,630
e sono nel loro spazio proprio.

459
00:29:03,630 --> 00:29:05,050
Cerchiamo di risolvere questo problema in qualche modo.

460
00:29:05,050 --> 00:29:11,250
Vorrei in realtà scorrere di nuovo qui e di aprire, diciamo, una quarta variante di questo, buggy4.

461
00:29:11,250 --> 00:29:13,370
Che dire di questo?

462
00:29:13,370 --> 00:29:17,810
Si tratta di un problema simile ma più semplice da guardare prima di prendere una pugnalata a risolverlo.

463
00:29:17,810 --> 00:29:24,190
Questo programma si chiama incremento, e inizializza apparentemente un numero intero x a 1 in linea 18.

464
00:29:24,190 --> 00:29:28,150
Ho poi rivendicazione x è 1, io poi affermare "Incremento ..."

465
00:29:28,150 --> 00:29:33,730
Ho quindi chiamare incremento, ma poi nelle linee 22 e 23, io sostengo che è stato incrementato,

466
00:29:33,730 --> 00:29:40,220
Io sostengo x ora è quello che è - 2, presumibilmente - ma questo programma è bacato.

467
00:29:40,220 --> 00:29:42,610
Qual è il problema?

468
00:29:43,440 --> 00:29:50,160
Gia '. >> [Risposta degli studenti incomprensibile] >> Esattamente.

469
00:29:50,160 --> 00:29:52,490
Quindi x è stata dichiarata, ovviamente, sulla linea 18.

470
00:29:52,490 --> 00:29:54,700
Questo è all'interno delle parentesi graffe principale.

471
00:29:54,700 --> 00:29:58,440
Quindi la risposta semplice è che mentre x esiste qui,

472
00:29:58,440 --> 00:30:03,930
non esiste in linea 32, quindi questo programma effettivamente non anche compilare.

473
00:30:03,930 --> 00:30:07,940
Il compilatore quando provo a compilare questo codice sta per urlare contro di me

474
00:30:07,940 --> 00:30:14,100
su alcuni identificatore non dichiarato o qualcosa in tal senso. Infatti, proviamo.

475
00:30:14,100 --> 00:30:18,470
Questo è fare buggy4. Eccolo.

476
00:30:18,470 --> 00:30:22,110
L'uso di 'x' identificatore non dichiarato in linea 32.

477
00:30:22,110 --> 00:30:25,580
E in realtà, cerchiamo di essere più esplicito qui oggi, in modo che questo sia utile

478
00:30:25,580 --> 00:30:27,580
in orario di ufficio e in casa.

479
00:30:27,580 --> 00:30:29,300
>> Si noti che è un po 'criptico scritto.

480
00:30:29,300 --> 00:30:37,270
Ma il fatto che Clang ha urlato contro di noi, dicendo buggy4.c: 32:5, è effettivamente utile.

481
00:30:37,270 --> 00:30:42,050
Significa che l'errore è sulla linea 32 alla posizione del carattere 5.

482
00:30:42,050 --> 00:30:46,700
Quindi 1, 2, 3, 4, 5. Questo è, infatti, dove il problema è.

483
00:30:46,700 --> 00:30:49,790
E poi, anche, tenere a mente in orario d'ufficio, a casa, sono fortunato qui.

484
00:30:49,790 --> 00:30:52,990
Ho un errore. E 'intenzione di essere relativamente facile da risolvere.

485
00:30:52,990 --> 00:30:55,990
Ma se si ottiene uno schermo pieno di messaggi di errore travolgente,

486
00:30:55,990 --> 00:31:00,330
ancora una volta si rendono conto che quello in basso potrebbe essere solo sintomatico di quello più in alto.

487
00:31:00,330 --> 00:31:03,450
Quindi, sempre inseguire i bug dall'alto verso il basso

488
00:31:03,450 --> 00:31:05,820
perché ci potrebbe essere solo un effetto a catena

489
00:31:05,820 --> 00:31:09,240
che suggerisce di avere problemi più di quanto effettivamente fare.

490
00:31:09,240 --> 00:31:15,150
Quindi, come possiamo risolvere questo problema se il mio obiettivo è quello di incrementare x? >> [Studente] Fai x globale.

491
00:31:15,150 --> 00:31:17,060
Ok, allora possiamo fare x globale.

492
00:31:17,060 --> 00:31:20,480
Prendiamo la scorciatoia che ho avvertito in precedenza, ma diamine, abbiamo solo bisogno di una soluzione rapida,

493
00:31:20,480 --> 00:31:25,730
quindi diciamo solo che x int qui. Che fa x globale.

494
00:31:25,730 --> 00:31:31,800
Così ora principale ha accesso ad esso e incremento ha accesso ad esso,

495
00:31:31,800 --> 00:31:34,110
e così mi permetta di andare avanti e compilare questo ora.

496
00:31:34,110 --> 00:31:37,630
Fai buggy4, Invio. Sembra da compilare al momento.

497
00:31:37,630 --> 00:31:41,230
Corriamo buggy4. E sembra funzionare davvero.

498
00:31:41,230 --> 00:31:45,150
Questa è una di quelle cose che è fare come dico, non come faccio io,

499
00:31:45,150 --> 00:31:47,010
come ho appena fatto qui, perché in generale,

500
00:31:47,010 --> 00:31:50,440
i nostri programmi si sta per ottenere molto più interessante e molto più di questo,

501
00:31:50,440 --> 00:31:56,390
e se la soluzione ai problemi della vita è solo mettere tutte le variabili nella parte superiore del file,

502
00:31:56,390 --> 00:31:59,690
molto velocemente programmi si ottiene terribilmente difficile da gestire.

503
00:31:59,690 --> 00:32:02,190
Diventa sempre più difficile pensare a nuovi nomi delle variabili,

504
00:32:02,190 --> 00:32:05,240
diventa più difficile capire quale variabile sta facendo che cosa,

505
00:32:05,240 --> 00:32:08,460
e quindi, in generale, questa non è una buona soluzione.

506
00:32:08,460 --> 00:32:10,030
Quindi cerchiamo di farlo meglio.

507
00:32:10,030 --> 00:32:12,160
Non vogliamo usare una variabile globale qui.

508
00:32:12,160 --> 00:32:16,240
>> Voglio incrementare x, così ho potuto ovviamente -

509
00:32:16,240 --> 00:32:18,670
alla fine della giornata, questo è una specie di sciocca storia perché solo fare questo -

510
00:32:18,670 --> 00:32:24,450
ma se io non lo sapevo che l'operatore o non mi era permesso di cambiare in principale in sé,

511
00:32:24,450 --> 00:32:30,730
in quale altro modo avrei potuto implementare Ken qui questa volta non per cubo, ma per incrementare?

512
00:32:31,380 --> 00:32:33,190
Come faccio a cambiare questa cosa qui? Gia '.

513
00:32:33,190 --> 00:32:38,480
[Studente] Passa x e poi tornare [incomprensibile] >> Ok, bene.

514
00:32:38,480 --> 00:32:41,900
Allora perché non mi passa in x e allora piuttosto che restituirlo,

515
00:32:41,900 --> 00:32:44,870
perchè non ho riesci a tornare x + 1.

516
00:32:44,870 --> 00:32:47,710
Un altro paio di cose devono cambiare qui. Sono sulla strada giusta.

517
00:32:47,710 --> 00:32:49,770
Che altro ho bisogno di modificare? Qualcun altro. Gia '.

518
00:32:49,770 --> 00:32:51,740
[Risposta degli studenti incomprensibile]

519
00:32:51,740 --> 00:32:54,730
Ho bisogno di cambiare il tipo di ritorno di incremento perché non è nulla.

520
00:32:54,730 --> 00:32:57,780
Significa che non viene restituito Void, ma chiaramente ora è,

521
00:32:57,780 --> 00:32:59,830
così questo deve cambiare - >> [studente] int.

522
00:32:59,830 --> 00:33:02,740
int per essere coerente con quello che sto effettivamente tornando.

523
00:33:02,740 --> 00:33:05,180
Ora ci sia ancora qualcosa buggy qui. Gia '.

524
00:33:05,180 --> 00:33:08,400
[Risposta degli studenti incomprensibile] >> [Malan] Così ho bisogno di incrementare x?

525
00:33:08,400 --> 00:33:12,080
[Risposta degli studenti incomprensibile] >> [Malan] Ah, quindi ho bisogno di passare x.

526
00:33:12,080 --> 00:33:16,660
Quindi ho bisogno di fare questo qui. >> [Commento studente incomprensibile]

527
00:33:16,660 --> 00:33:20,050
[Malan] Il prototipo, devo cambiare questo qui.

528
00:33:20,050 --> 00:33:22,930
Quindi questo deve diventare un int, questo deve diventare -

529
00:33:22,930 --> 00:33:25,620
hmm, io in realtà sono un bug qui. Si può correggere prima.

530
00:33:25,620 --> 00:33:29,590
Che cosa avrebbe dovuto in realtà essere? E 'ottenuto di essere un qualcosa di int.

531
00:33:29,590 --> 00:33:32,700
Potrebbe essere x, ma, francamente, se si inizia a chiamare tutti i tuoi x variabili,

532
00:33:32,700 --> 00:33:35,390
sta andando per ottenere sempre meno chiaro che cosa si tratta.

533
00:33:35,390 --> 00:33:39,560
>> Così facciamo solo arbitrariamente scegliere una diversa convenzione di denominazione per le mie funzioni di supporto,

534
00:33:39,560 --> 00:33:41,940
le funzioni che sto scrivendo. Ci chiamano una, o potremmo chiamarla -

535
00:33:41,940 --> 00:33:45,010
Chiamiamolo il numero per essere ancora più esplicito.

536
00:33:45,010 --> 00:33:47,560
Allora devo restituire ciò che il numero è più 1,

537
00:33:47,560 --> 00:33:50,740
e ora devo cambiare 1 altra cosa qua e un'altra cosa qui.

538
00:33:50,740 --> 00:33:54,350
Che cosa devo cambiare sulla linea 21 prima? >> [Risposta degli studenti incomprensibile]

539
00:33:54,350 --> 00:33:57,610
[Malan] devo assegnarlo a x. Non posso chiamare incremento (x).

540
00:33:57,610 --> 00:34:01,960
Ho bisogno di ricordare la risposta modificando il valore di x sulla sinistra.

541
00:34:01,960 --> 00:34:04,680
E anche se x ora è a sinistra e la destra, questo è tutto bene

542
00:34:04,680 --> 00:34:08,860
perché il lato destro viene eseguito in primo luogo allora si lasciò cadere nella mano sinistra cosa -

543
00:34:08,860 --> 00:34:10,600
x in questo caso.

544
00:34:10,600 --> 00:34:12,159
E poi, infine, si tratta di una soluzione semplice ora.

545
00:34:12,159 --> 00:34:17,230
Questo dovrebbe corrispondere solo ciò che è in basso, il numero int.

546
00:34:17,230 --> 00:34:20,570
Quindi un sacco di cambiamenti per una funzione davvero stupido

547
00:34:20,570 --> 00:34:24,420
ma rappresentativo delle cose che sempre più ci vogliamo fare.

548
00:34:24,420 --> 00:34:27,090
Quindi, fare buggy4. Ho fatto un casino da qualche parte.

549
00:34:27,090 --> 00:34:30,139
Oh, mio ​​Dio.. Cinque errori in 6 linee di programma.

550
00:34:30,139 --> 00:34:35,690
Allora, cosa c'è che non va sulla linea 18, il carattere 5?

551
00:34:35,690 --> 00:34:39,610
Quindi devo dichiarare questo, int.

552
00:34:39,610 --> 00:34:41,920
Vediamo un po '. Ci sono un sacco di altri errori.

553
00:34:41,920 --> 00:34:47,010
Oh, mio ​​Dio - 19, 18, 21 - ma ancora una volta, facciamo solo cancellare lo schermo, L di controllo qui,

554
00:34:47,010 --> 00:34:49,380
ed eseguire nuovamente Clang.

555
00:34:49,380 --> 00:34:51,340
Così cinque problemi è in realtà solo che 1.

556
00:34:51,340 --> 00:34:57,520
Così ora corriamo buggy4, Invio. Accidenti, x è stato incrementato correttamente.

557
00:34:57,520 --> 00:35:02,720
Bene. Hai domande su come incrementare i numeri? Gia '.

558
00:35:02,720 --> 00:35:09,870
[Domanda studente incomprensibile] >> Buona domanda.

559
00:35:09,870 --> 00:35:14,220
Come è possibile che io possa cambiare solo x al numero e il programma saprà immediatamente?

560
00:35:14,220 --> 00:35:16,200
>> Anche in questo caso, pensare ad esso come questa astrazione.

561
00:35:16,200 --> 00:35:21,600
Quindi, se ho am main e Ken è incremento, francamente, non mi interessa quello che Ken chiama il suo iPad.

562
00:35:21,600 --> 00:35:26,570
Non mi interessa quello che lui chiama tutto ciò che ha a che fare con la sua applicazione di questa funzionalità.

563
00:35:26,570 --> 00:35:33,340
Si tratta di un dettaglio di implementazione che io, principale, non c'è bisogno di preoccuparsi.

564
00:35:33,340 --> 00:35:38,250
E così semplicemente cambiando costantemente all'interno della funzione - numero qui e numero qui -

565
00:35:38,250 --> 00:35:40,960
è tutto quello che vuole tanto tempo come ho ricompilare.

566
00:35:40,960 --> 00:35:44,180
E 'un po' come se si pensa che molti di noi, quelli di voi con patenti di guida

567
00:35:44,180 --> 00:35:46,770
che hanno guidato o se hai anche guidato in una macchina,

568
00:35:46,770 --> 00:35:50,950
la maggior parte di noi non hanno idea di come funziona una macchina sotto la cappa.

569
00:35:50,950 --> 00:35:54,970
E letteralmente, se si apre il cofano, la maggior parte di noi - me compreso -

570
00:35:54,970 --> 00:35:56,940
non stanno andando per sapere esattamente cosa stiamo guardando,

571
00:35:56,940 --> 00:35:59,220
un po 'come si potrebbe sentire con roba come questo adesso.

572
00:35:59,220 --> 00:36:01,480
Ma in realtà non hanno di prendersi cura come la macchina funziona,

573
00:36:01,480 --> 00:36:05,970
non abbiamo a importa di quello che tutte le canne e pistoni e cavi all'interno della vettura

574
00:36:05,970 --> 00:36:08,160
sono in realtà facendo.

575
00:36:08,160 --> 00:36:12,770
Quindi, qualcosa di simile a quello che voi chiamate il pistone non ha importanza qui in questo caso. Stessa idea.

576
00:36:12,770 --> 00:36:25,300
Gia '. >> [Domanda studente incomprensibile]

577
00:36:25,300 --> 00:36:29,180
Se ci sono più usi del momento variabile xa fa,

578
00:36:29,180 --> 00:36:32,150
si, il programmatore, dovrebbe cambiare ovunque.

579
00:36:32,150 --> 00:36:36,600
Oppure si potrebbe letteralmente fare file, Menu, quindi Trova, Sostituisci - qualcosa del genere -

580
00:36:36,600 --> 00:36:39,170
ma si sta andando ad avere per fare le modifiche da soli.

581
00:36:39,170 --> 00:36:47,450
Bisogna essere coerenti. >> [Studente] Se non ci sono più variabili [incomprensibile]

582
00:36:47,450 --> 00:36:53,100
Un ordine particolare come qui, se questo fosse int un altro numero? >> [Studente] Esatto.

583
00:36:53,100 --> 00:36:56,590
[Malan] Si '. Ordina che conta quando si chiama la funzione.

584
00:36:56,590 --> 00:37:00,050
>> Quindi, se fossi chiamato Rilancio qui con qualcosa qualcosa di virgola,

585
00:37:00,050 --> 00:37:01,680
c'è una corrispondenza diretta.

586
00:37:01,680 --> 00:37:05,690
La prima variabile, come si chiama, è una copia del primo argomento qui.

587
00:37:05,690 --> 00:37:07,760
Scusi. Questo non dovrebbe essere una parentesi.

588
00:37:07,760 --> 00:37:11,490
Le linee argomento secondo fino con il secondo. Quindi l'ordine, sì, le cose. Bene.

589
00:37:11,490 --> 00:37:17,020
Scusi. Ho preso la strada più lunga per arrivarci. Altre domande? Bene.

590
00:37:17,020 --> 00:37:20,610
Quindi cerchiamo di vedere se non si può dipingere un quadro di ciò che sta realmente accadendo qui

591
00:37:20,610 --> 00:37:23,090
sotto la cappa, per così dire.

592
00:37:23,090 --> 00:37:26,640
Si tratta di un rettangolo che potrebbe rappresentare la memoria del computer.

593
00:37:26,640 --> 00:37:30,970
Anche se non avete idea di come funziona la memoria RAM o come funziona,

594
00:37:30,970 --> 00:37:33,940
almeno si supponga di avere grappoli di esso in questi giorni.

595
00:37:33,940 --> 00:37:36,280
Hai megabyte di esso, hai gigabyte di esso,

596
00:37:36,280 --> 00:37:40,870
e sappiamo da settimana 0 che un byte è proprio quello? >> [Studente] 8 bit.

597
00:37:40,870 --> 00:37:42,950
8 bit, giusto? Quindi 8 zeri e 1.

598
00:37:42,950 --> 00:37:45,880
Quindi, se il vostro computer dispone di un giga di RAM, 2 GB di RAM in questi giorni,

599
00:37:45,880 --> 00:37:55,030
si dispone di un miliardo o 2 miliardi di byte di memoria o di circa 8 miliardi o 16 miliardi di bit

600
00:37:55,030 --> 00:37:56,890
all'interno del computer.

601
00:37:56,890 --> 00:38:00,590
A differenza del piccolo esempio Wooly Willy, non è in genere più particelle magnetiche.

602
00:38:00,590 --> 00:38:04,450
Sempre più spesso - nei computer portatili, almeno - è unità a stato solido, SSD,

603
00:38:04,450 --> 00:38:08,580
che proprio non hanno parti in movimento. E 'tutto elettronico. E 'tutta l'energia elettrica-based.

604
00:38:08,580 --> 00:38:14,060
Quindi, pensare a questo come solo rettangolo che rappresenta i 1 o 2 gigabyte di memoria che avete.

605
00:38:14,060 --> 00:38:16,020
>> Quindi è un pezzo di memoria.

606
00:38:16,020 --> 00:38:19,830
Il mondo dell'informatica è sorta di partizionato

607
00:38:19,830 --> 00:38:22,950
blocchi di memoria per fare cose diverse.

608
00:38:22,950 --> 00:38:27,190
Per esempio, se questa è la RAM del computer, come suggerito dal rettangolo lì,

609
00:38:27,190 --> 00:38:31,130
risulta che per convenzione, nella parte superiore della RAM, per così dire,

610
00:38:31,130 --> 00:38:33,660
è in genere quello che si chiama un segmento di testo.

611
00:38:33,660 --> 00:38:36,740
Questi sono i 0 e 1 che sono stati compilati.

612
00:38:36,740 --> 00:38:39,020
Così, quando abbiamo guardato sotto il cofano a ciò che è a.out,

613
00:38:39,020 --> 00:38:41,980
tutti questi 0 e 1, quando si esegue un programma,

614
00:38:41,980 --> 00:38:46,290
quelli 0 e 1 vengono caricati dal disco rigido in qualcosa chiamato RAM,

615
00:38:46,290 --> 00:38:49,320
e nella RAM vengono messe in alto.

616
00:38:49,320 --> 00:38:52,770
Nel frattempo, si dispone di altre cose: inizializzare i dati, annullare l'inizializzazione dei dati.

617
00:38:52,770 --> 00:38:57,510
Quei 2 andane di memoria fare riferimento a variabili globali, che non si usano spesso

618
00:38:57,510 --> 00:39:00,760
ma a volte se lo fai, finiscono anche lassù.

619
00:39:00,760 --> 00:39:04,260
Poi ci sono alcune altre cose: variabili d'ambiente, che non passerà molto tempo,

620
00:39:04,260 --> 00:39:06,860
ma poi 2 cose importanti che tornerà tutto il semestre,

621
00:39:06,860 --> 00:39:08,550
stack e heap.

622
00:39:08,550 --> 00:39:12,210
Così la maggior parte della memoria del computer è riservato durante l'esecuzione di un programma

623
00:39:12,210 --> 00:39:15,370
per qualcosa chiamato la pila e qualcosa chiamato l'heap.

624
00:39:15,370 --> 00:39:18,840
Non abbiamo intenzione di parlare del mucchio oggi, ma parleremo lo stack.

625
00:39:18,840 --> 00:39:24,600
La pila è destinata a evocare la visuale dei vassoi pasto in sala da pranzo Mather Casa

626
00:39:24,600 --> 00:39:28,110
o dovunque vi capita di essere in cui il personale di sala da pranzo pulirli ogni giorno,

627
00:39:28,110 --> 00:39:30,180
li pila di sopra del piano in su,

628
00:39:30,180 --> 00:39:34,550
e allo stesso modo, nella memoria, c'è questa idea di mettere qualcosa su una pila,

629
00:39:34,550 --> 00:39:36,860
mettere qualcosa su una pila, mettere qualcosa su una pila.

630
00:39:36,860 --> 00:39:38,240
E che cosa si intende con questo?

631
00:39:38,240 --> 00:39:41,860
>> Facciamo zoom solo sulla metà inferiore di questo quadro, la RAM del computer,

632
00:39:41,860 --> 00:39:44,330
di proporre quanto segue.

633
00:39:44,330 --> 00:39:48,170
Si scopre che quando si esegue un programma come a.out o ciao -

634
00:39:48,170 --> 00:39:50,100
qualunque sia il programma che hai scritto -

635
00:39:50,100 --> 00:39:54,020
ancora una volta, quelli che 0 e 1 sono caricati dal disco rigido, che è stoccaggio a lungo termine,

636
00:39:54,020 --> 00:39:57,230
vi rimane anche quando si tira la spina, caricato nella RAM.

637
00:39:57,230 --> 00:40:00,610
RAM è più veloce di hard disk - è più piccolo hard disk -

638
00:40:00,610 --> 00:40:03,300
ma è dove programmi in diretta mentre li stai eseguendo.

639
00:40:03,300 --> 00:40:08,230
Così si fa doppio clic su un programma su un Mac o PC, è caricato dal disco rigido nella RAM.

640
00:40:08,230 --> 00:40:11,520
Non appena viene caricata in RAM, il go 0 e 1 in alto modo,

641
00:40:11,520 --> 00:40:16,610
il cosiddetto segmento di testo, ma poi non appena il programma viene avviato effettivamente in esecuzione,

642
00:40:16,610 --> 00:40:21,360
la funzione principale si chiama, e principale, come abbiamo visto, ha spesso variabili locali,

643
00:40:21,360 --> 00:40:24,870
e ha interi e stringhe e caratteri e simili.

644
00:40:24,870 --> 00:40:29,180
Così, se il programma che hai scritto o il programma che avete fatto doppio clic

645
00:40:29,180 --> 00:40:32,970
utilizzato alcune variabili all'interno del principale,

646
00:40:32,970 --> 00:40:37,240
finiscono nella parte inferiore del tuo stack di memoria, per così dire.

647
00:40:37,240 --> 00:40:39,410
Più concretamente, cosa significa questo in realtà significa?

648
00:40:39,410 --> 00:40:48,450
Questo significa solo che se stavamo per numero i byte di RAM nel computer,

649
00:40:48,450 --> 00:40:55,750
notare che questo potrebbe essere il numero di byte 0, questo potrebbe essere il numero di byte 1, 2, 3, 4, 5, 6,

650
00:40:55,750 --> 00:41:01,480
tutta la strada fino a 2 miliardi sarebbe fin lassù in cima.

651
00:41:01,480 --> 00:41:05,880
In altre parole, quando si parla di RAM o memoria in termini di byte,

652
00:41:05,880 --> 00:41:11,500
significa solo che qualcuno ha deciso che a contare ciascuno di questi pezzi di memoria.

653
00:41:11,500 --> 00:41:16,650
Così, quando avete bisogno di 32 bit per un int o avete bisogno di 8 bit per un char,

654
00:41:16,650 --> 00:41:18,840
dove vanno a finire nella memoria?

655
00:41:18,840 --> 00:41:22,350
>> Concettualmente, hanno appena finiscono in fondo a questa cosa chiamata stack.

656
00:41:22,350 --> 00:41:25,870
Ma ciò che è interessante ora è quando principale chiama una funzione -

657
00:41:25,870 --> 00:41:28,750
supponiamo che una funzione chiamata foo, solo un nome arbitrario -

658
00:41:28,750 --> 00:41:32,330
ciò che accade è principale è in fondo a questa pila di memoria;

659
00:41:32,330 --> 00:41:35,680
pippo ora è messo in cima principale in memoria.

660
00:41:35,680 --> 00:41:40,990
Quindi tutte le variabili locali che pippo ha finiscono sorta di concettualmente superiori a quelli in main.

661
00:41:40,990 --> 00:41:47,070
Se foo chiama un'altra funzione chiamata bar, le variabili finiscono qui.

662
00:41:47,070 --> 00:41:50,120
Se la barra chiama qualcosa d'altro, qui, qui, qui.

663
00:41:50,120 --> 00:41:53,830
Così che cosa è interessante l'esecuzione di un programma è che, come si chiamano funzioni

664
00:41:53,830 --> 00:41:57,750
e come tali funzioni chiamare le funzioni e come tali funzioni chiamare funzioni,

665
00:41:57,750 --> 00:42:01,470
si costruisce questa pila di funzioni in memoria.

666
00:42:01,470 --> 00:42:06,890
E solo una volta restituisce una funzione si fa a iniziare a ricevere che la memoria indietro.

667
00:42:06,890 --> 00:42:10,860
Quindi, uno dei modi più semplici per l'esecuzione di memoria in un programma per computer

668
00:42:10,860 --> 00:42:14,360
è quello di scrivere funzioni che non restituiscono.

669
00:42:14,360 --> 00:42:18,900
Così, per esempio, cerchiamo di dimostrare tanto con un programma creato appositamente per buggy.

670
00:42:18,900 --> 00:42:22,230
Lasciatemi andare avanti e non # include,

671
00:42:22,230 --> 00:42:25,000
int main (),

672
00:42:25,000 --> 00:42:32,940
e ho intenzione di fare, mentre (2> 1), che probabilmente non cambierà mai su di noi,

673
00:42:32,940 --> 00:42:37,560
e lasciami andare avanti ora e fare printf.

674
00:42:37,560 --> 00:42:40,700
A dire il vero, che sta per essere meno visivamente interessante. Facciamolo.

675
00:42:40,700 --> 00:42:50,240
Per int i = 0; i> 0 - facciamo questo errore - i + +.

676
00:42:50,240 --> 00:42:52,720
E non printf qui. Vediamo in pratica quello che predicava.

677
00:42:52,720 --> 00:43:00,190
Facciamo un metodo qui, coro vuoto, e diremo int i,

678
00:43:00,190 --> 00:43:06,830
e poi ho intenzione di dire printf - no, facciamo questo più interessante.

679
00:43:06,830 --> 00:43:15,790
Facciamo in realtà non stampa nulla. Diciamo solo fare questo: coro (i).

680
00:43:15,790 --> 00:43:20,390
Bene. Quindi questo è bacato perché perché?

681
00:43:20,390 --> 00:43:23,380
Sto facendo questo come vado perché il programma non fa niente di interesse.

682
00:43:23,380 --> 00:43:25,320
>> Ma questo non è l'obiettivo.

683
00:43:25,320 --> 00:43:29,630
L'obiettivo è quello di scrivere un programma la cui funzione principale fa che cosa, a quanto pare?

684
00:43:30,720 --> 00:43:32,860
Chiama se stessa. E in realtà, non abbiamo bisogno del ciclo.

685
00:43:32,860 --> 00:43:37,200
Facciamo anche semplificare questo proprio per non perdere di vista proprio il bug fondamentale.

686
00:43:37,200 --> 00:43:39,640
Chiamate principali coro a cantare qualche coro,

687
00:43:39,640 --> 00:43:41,440
poi ho fatto qualcosa di stupido e avevo chiamata coro coro

688
00:43:41,440 --> 00:43:43,760
perché davo per scontato un altro stava per attuarlo forse,

689
00:43:43,760 --> 00:43:47,210
e ora questo non ha intenzione di compilare ancora. Ho bisogno di fare ciò?

690
00:43:47,210 --> 00:43:49,970
Ho bisogno del prototipo, ricorda.

691
00:43:49,970 --> 00:43:56,110
Quindi ho bisogno di avere qui coro void (int i);

692
00:43:56,110 --> 00:43:59,210
Così ora se vado qui - in realtà, cerchiamo di utilizzare la finestra più grande.

693
00:43:59,210 --> 00:44:01,980
Andiamo avanti e fare coro.

694
00:44:01,980 --> 00:44:06,490
Andiamo avanti e fare coro.

695
00:44:06,490 --> 00:44:08,370
L'uso di identificatore non dichiarato i.

696
00:44:08,370 --> 00:44:12,500
Oh, che era stupido. Non abbiamo bisogno l'argomento. Diciamo solo fare questo.

697
00:44:12,500 --> 00:44:16,370
Vorrei che aveva iniziato in questo modo. Sarebbe stato un programma molto più facile da scrivere.

698
00:44:16,370 --> 00:44:25,590
Ecco. Ora andiamo verso la mia finestra di terminale, eseguire nuovamente Clang, e ci siamo.

699
00:44:25,590 --> 00:44:28,460
E 'stato veramente veloce.

700
00:44:28,460 --> 00:44:31,150
Che cosa realmente è successo, però?

701
00:44:31,150 --> 00:44:33,730
Bene, ora mi aggiungere la riga di stampa in modo che possiamo vedere.

702
00:44:33,730 --> 00:44:43,490
Lasciatemi dire printf ("Io sono qui") - nessuna variabile. Lasceremo così.

703
00:44:43,490 --> 00:44:47,480
Permettetemi di fare eseguire nuovamente. Vorrei eseguire di nuovo coro.

704
00:44:47,480 --> 00:44:57,380
E ... andiamo. Continua ad andare.

705
00:44:57,380 --> 00:44:59,930
Per inciso, perché non è ancora caduto?

706
00:44:59,930 --> 00:45:02,080
L'errore di segmentazione successo super veloce prima.

707
00:45:02,080 --> 00:45:06,570
[Risposta degli studenti incomprensibile] >> Esattamente. Quindi, ci vuole tempo per la stampa, giusto?

708
00:45:06,570 --> 00:45:08,610
Ci vuole solo più lavoro da parte del computer.

709
00:45:08,610 --> 00:45:10,620
Ed eccolo lì: Segmentation fault.

710
00:45:10,620 --> 00:45:12,340
>> Quindi, notare quanto i programmi veloci correre.

711
00:45:12,340 --> 00:45:14,130
Se non si sta stampando nulla, super veloce.

712
00:45:14,130 --> 00:45:18,770
Ma abbiamo ancora ottenuto questo errore di segmentazione, perché quello che stava accadendo?

713
00:45:18,770 --> 00:45:21,210
Se si pensa a come la memoria del computer è disposto,

714
00:45:21,210 --> 00:45:28,740
questo sembra essere principale, ma qui facciamo solo chiamare questo coro, e chiama questo coro.

715
00:45:28,740 --> 00:45:34,550
E ora se lo faccio mia estetica a destra, questo è solo andare a dire coro, coro, coro,

716
00:45:34,550 --> 00:45:40,550
coro, coro, coro, coro, fino alla nausea, e alla fine, che cosa succederà?

717
00:45:40,550 --> 00:45:45,630
Se l'immagine grande, letteralmente, è questo, quello che succede solo concettualmente?

718
00:45:46,520 --> 00:45:48,630
I sovraccarichi di stack del mucchio.

719
00:45:48,630 --> 00:45:51,940
O, peggio, basta invaso tutto, compreso il segmento di testo,

720
00:45:51,940 --> 00:45:54,590
che è il 0 e 1 che rappresentano il vostro programma.

721
00:45:54,590 --> 00:45:57,080
In breve, questo è solo super, male super.

722
00:45:57,080 --> 00:45:58,830
Il vostro programma è fuori controllo.

723
00:45:58,830 --> 00:46:01,220
Stai usando la memoria modo più di quanto previsto

724
00:46:01,220 --> 00:46:03,960
tutto a causa di un errore stupido in questo caso,

725
00:46:03,960 --> 00:46:08,040
o in questo caso una funzione molto deliberatamente fatto stesso chiamante.

726
00:46:08,040 --> 00:46:09,500
Ora, questo non è affatto male.

727
00:46:09,500 --> 00:46:13,800
Le funzioni che si definiscono in realtà ha un grande potere quando lo si utilizza correttamente.

728
00:46:13,800 --> 00:46:15,800
Non l'ho usato correttamente qui.

729
00:46:15,800 --> 00:46:19,780
Quindi questo non è affatto male, ma il fatto che non ho mai veramente trattenermi chiamare

730
00:46:19,780 --> 00:46:23,520
è una debolezza fondamentale di questo programma qui.

731
00:46:23,520 --> 00:46:26,400
Allora, dove stiamo andando con tutto questo? Che cosa sta realmente accadendo?

732
00:46:26,400 --> 00:46:30,340
Quando chiamo la funzione di incremento, come stavamo facendo in questi esempi,

733
00:46:30,340 --> 00:46:33,420
Ho un valore come 1 che mi passa trovi

734
00:46:33,420 --> 00:46:37,570
Passo in una copia del numero 1, quindi si verifica quanto segue.

735
00:46:37,570 --> 00:46:44,240
Andiamo in esempio incremento, questo ragazzo proprio qui.

736
00:46:44,240 --> 00:46:46,870
Ecco quello che succede.

737
00:46:46,870 --> 00:46:53,400
Quando chiamo incremento e passare x, pittoricamente, quello che sta succedendo qui è questo.

738
00:46:53,400 --> 00:46:59,520
>> Se ho il valore di 1 memorizzati qui e io in realtà chiamare incremento,

739
00:46:59,520 --> 00:47:04,330
che ora è chiamato coro - l'iPad mi sta gettando via qui.

740
00:47:04,330 --> 00:47:09,760
Chiamiamo questo incremento, e non sappiamo che cosa questa funzione successiva sarà.

741
00:47:09,760 --> 00:47:14,840
Quindi, quello che succede è qui da qualche parte nel principale che ho un pezzo di memoria

742
00:47:14,840 --> 00:47:17,000
che memorizza il numero 1.

743
00:47:17,000 --> 00:47:19,380
Quando chiamo incremento, sto utilizzando un altro pezzo di memoria,

744
00:47:19,380 --> 00:47:21,230
ma ora ho la copia del 1.

745
00:47:21,230 --> 00:47:26,660
Quando ho incrementare tale valore, questo diventa 2,

746
00:47:26,660 --> 00:47:30,560
ma poi cosa succede appena torna incremento?

747
00:47:30,560 --> 00:47:33,630
Questa memoria appena viene restituito al sistema operativo,

748
00:47:33,630 --> 00:47:37,450
il che significa che tutto quello che hai fatto è nulla di utile.

749
00:47:37,450 --> 00:47:43,120
Il 1 che è stato originariamente contenuta nel principale è ancora effettivamente.

750
00:47:43,120 --> 00:47:44,890
Allora, dove stiamo andando con questo?

751
00:47:44,890 --> 00:47:49,770
Si scopre che nella memoria si dispone di questo back-to-back sequenza di byte

752
00:47:49,770 --> 00:47:53,050
che si può mettere roba, e si scopre che abbiamo già visto qualcosa

753
00:47:53,050 --> 00:47:55,390
che coinvolge mettendo le cose back to back to back to back.

754
00:47:55,390 --> 00:47:59,860
Che cosa è una stringa in base a settimana 1 settimana 2 e adesso?

755
00:48:00,020 --> 00:48:01,980
E 'solo un insieme di caratteri.

756
00:48:01,980 --> 00:48:04,310
Così si scopre come si può mettere i numeri in memoria,

757
00:48:04,310 --> 00:48:06,990
Allo stesso modo si può mettere i caratteri in memoria.

758
00:48:06,990 --> 00:48:10,530
E una volta che si inizia personaggi mettendo in memoria back to back to back to back,

759
00:48:10,530 --> 00:48:13,620
si scopre che con la più semplice delle cose come un ciclo for o un ciclo while,

760
00:48:13,620 --> 00:48:17,170
siamo in grado di scorrere da sinistra a destra sopra i caratteri di una stringa

761
00:48:17,170 --> 00:48:20,600
e iniziare a massaggiare in caratteri completamente diversi -

762
00:48:20,600 --> 00:48:23,370
potrebbe diventare un b, b potrebbe diventare c -

763
00:48:23,370 --> 00:48:27,780
in modo che alla fine, siamo in grado di prendere una frase in inglese che rende effettivamente senso

764
00:48:27,780 --> 00:48:30,310
e convertire ciascuna di tali lettere una alla volta

765
00:48:30,310 --> 00:48:34,400
a piedi attraverso la memoria del nostro computer da sinistra a destra per crittografare in realtà.

766
00:48:34,400 --> 00:48:35,810
Quindi cerchiamo di prendere la nostra pausa di cinque minuti qui,

767
00:48:35,810 --> 00:48:40,730
e quando torneremo, inizieremo questo processo di scrambling informazioni.

768
00:48:42,020 --> 00:48:43,520
>> Bene.

769
00:48:43,520 --> 00:48:48,070
Prima di immergersi in un po 'di queste cose e crittografico chiamato array,

770
00:48:48,070 --> 00:48:51,470
fatemi pausa per tutte le domande, perché mi sento come se davvero specie di confusa

771
00:48:51,470 --> 00:48:54,080
alcuni di questi argomenti. Quindi cerchiamo di correggerla se possiamo.

772
00:48:54,080 --> 00:48:58,700
Abbiamo appena parlato di valori di ritorno, abbiamo parlato di argomenti,

773
00:48:58,700 --> 00:49:03,250
e abbiamo parlato di questo concetto, che vedremo tornare nelle settimane a venire,

774
00:49:03,250 --> 00:49:08,720
visualizzazione di memoria come un insieme di questi vassoi sovrapposti, per così dire,

775
00:49:08,720 --> 00:49:12,660
dal basso in alto, in modo tale che ogni vassoio che viene messo in pila

776
00:49:12,660 --> 00:49:16,530
rappresenta una funzione che è attualmente in fase di chiamata.

777
00:49:17,900 --> 00:49:20,260
Hai ancora domande?

778
00:49:20,260 --> 00:49:22,640
Vorrei fare una domanda qui.

779
00:49:22,640 --> 00:49:27,890
Vorrei semplificare questo torna a quello che era prima che alcuni dei nostri precedenti Q & A.

780
00:49:27,890 --> 00:49:35,570
Il fatto che l'incremento ha parentesi aperta, il numero int, chiusa parentesi -

781
00:49:35,570 --> 00:49:39,110
cosa numero int rappresenta?

782
00:49:39,110 --> 00:49:42,790
[Studente] Un argomento. Un argomento >>. Va bene. Ma che cosa è un argomento?

783
00:49:42,790 --> 00:49:46,370
[Risposta degli studenti incomprensibile] >> Che cos'è? >> [Studente] Qualcosa che si passa trovi

784
00:49:46,370 --> 00:49:49,940
Ok, quindi qualcosa che si passa in E, più in generale, è solo l'ingresso.

785
00:49:49,940 --> 00:49:52,450
Se si dovesse scrivere una funzione e lo scopo che la funzione nella vita

786
00:49:52,450 --> 00:49:55,770
è quello di fare qualcosa di diverso ogni volta che lo si utilizza,

787
00:49:55,770 --> 00:50:00,110
allora l'unico modo perché ciò avvenga davvero sembrerebbe essere quello di fornire con ingresso

788
00:50:00,110 --> 00:50:03,510
in modo che possa fare qualcosa di diverso con il medesimo ogni volta.

789
00:50:03,510 --> 00:50:06,650
>> Quindi è necessario specificare due cose quando una funzione riceve l'input.

790
00:50:06,650 --> 00:50:09,590
È necessario specificare il nome che si vuole dare a quella di ingresso

791
00:50:09,590 --> 00:50:12,700
esclusivamente per la vostra convenienza in modo che si può fare riferimento ad essa

792
00:50:12,700 --> 00:50:16,540
nella funzione che ti sta scrivendo, come ho fatto qui in linea 32.

793
00:50:16,540 --> 00:50:20,800
Ma è anche necessario specificarne il tipo, perché C è un linguaggio di programmazione

794
00:50:20,800 --> 00:50:25,940
che richiede solo che se si vuole una variabile, è necessario dire al computer che tipo di dati si tratta,

795
00:50:25,940 --> 00:50:30,200
in gran parte in modo che sappia quanti bit assegnare per tale variabile

796
00:50:30,200 --> 00:50:33,020
perché potrebbe essere di 6 - mi dispiace, non sarà 6.

797
00:50:33,020 --> 00:50:37,080
Esso può essere di 16, può essere 8, può essere 32, anche 64,

798
00:50:37,080 --> 00:50:39,130
ma il computer ha bisogno di sapere.

799
00:50:39,130 --> 00:50:43,180
Ora, l'int sulla sinistra rappresenta ciò, invece?

800
00:50:46,350 --> 00:50:48,850
[Risposta degli studenti incomprensibile] >> Che cos'è? >> [Studente] Tipo di funzione.

801
00:50:48,850 --> 00:50:53,610
Il tipo di una funzione e, più in particolare, il tipo di sua produzione. Giusto.

802
00:50:53,610 --> 00:50:57,380
Così che la cosa in parentesi rappresenta il suo ingresso, eventualmente,

803
00:50:57,380 --> 00:50:59,660
la cosa a sinistra rappresenta la sua uscita.

804
00:50:59,660 --> 00:51:03,530
E in questo caso, a quanto pare incremento restituisce un int,

805
00:51:03,530 --> 00:51:07,690
e così int è il tipo restituito da questa funzione.

806
00:51:07,690 --> 00:51:09,340
Che cosa significa per il ritorno?

807
00:51:09,340 --> 00:51:15,090
Letteralmente, si utilizza la parola chiave return e poi se quello che stanno tornando

808
00:51:15,090 --> 00:51:18,600
alla destra della parola chiave è un numero intero,

809
00:51:18,600 --> 00:51:21,660
allora quello è effettivamente coerente con ciò che abbiamo promesso.

810
00:51:21,660 --> 00:51:26,410
Non si poteva fare qualcosa di simile - ciao, mondo - perché questa è una stringa.

811
00:51:26,410 --> 00:51:28,860
>> Ovviamente, non è un numero intero.

812
00:51:28,860 --> 00:51:33,140
Così, in breve, il peso è davvero su di noi, il programmatore, per essere precisi

813
00:51:33,140 --> 00:51:37,770
da quello che stiamo tornando e poi effettivamente fare per restituirlo.

814
00:51:37,770 --> 00:51:43,440
Il contesto qui è ora che la memoria del computer è un gigabyte, 2 gigabyte -

815
00:51:43,440 --> 00:51:45,920
qualunque cosa - forse è più, forse è meno,

816
00:51:45,920 --> 00:51:49,050
ma il computer lo vede come aventi diverse sezioni.

817
00:51:49,050 --> 00:51:51,200
Qualcosa va laggiù, qualcosa va lassù,

818
00:51:51,200 --> 00:51:54,290
cose diverse va nel mezzo, e oggi abbiamo appena inizia a raccontare la storia,

819
00:51:54,290 --> 00:51:56,340
ma torneremo a questo nel corso del tempo.

820
00:51:56,340 --> 00:51:59,980
Per ora, l'unico pezzo di memoria che veramente interessa è il segmento di testo

821
00:51:59,980 --> 00:52:03,360
perché questo rappresenta solo il 0 e 1 che ha emesso Clang.

822
00:52:03,360 --> 00:52:06,050
Così, quando si esegue un comando a tastiera come a.out

823
00:52:06,050 --> 00:52:09,110
o con un doppio clic su un'icona in Mac OS o Windows,

824
00:52:09,110 --> 00:52:11,880
il programma viene caricato dal disco rigido nella RAM

825
00:52:11,880 --> 00:52:16,330
e si lasciò cadere nella parte superiore della RAM del computer, per così dire.

826
00:52:16,330 --> 00:52:20,450
Nel frattempo, mentre il programma si avvia e principale viene chiamato

827
00:52:20,450 --> 00:52:23,640
nel programma che hai scritto o il programma di Microsoft o Apple ha scritto,

828
00:52:23,640 --> 00:52:27,860
una delle sue variabili locali finiscono laggiù in fondo alla memoria del computer.

829
00:52:27,860 --> 00:52:33,230
Ma se le chiamate principali un'altra funzione che si ha variabili o argomenti, finiscono sopra di esso.

830
00:52:33,230 --> 00:52:36,680
E se tale funzione chiama qualcosa, finiscono sopra, al di sopra, al di sopra di esso.

831
00:52:36,680 --> 00:52:41,460
>> E solo una volta una funzione di esecuzione si è fatto la pila di vassoi, per così dire,

832
00:52:41,460 --> 00:52:43,240
cominciano a farsi sempre più in basso.

833
00:52:43,240 --> 00:52:48,250
E questo è quello che poi, in poche parole, spiega perché quando si chiama cubo

834
00:52:48,250 --> 00:52:51,550
o si chiama incremento, si sta passando a una copia del valore.

835
00:52:51,550 --> 00:52:55,520
E che cosa significa pittoricamente è che si sta letteralmente scrivendo il numero 1

836
00:52:55,520 --> 00:53:00,460
in un'altra parte della memoria, che cambia 1 a 2 in caso di incremento

837
00:53:00,460 --> 00:53:04,820
o ad un 8 nel caso di cubo e poi gettare via che la memoria

838
00:53:04,820 --> 00:53:09,140
appena l'incremento o il ritorno del cubo di funzione. Domanda.

839
00:53:09,140 --> 00:53:12,900
[Studente] dove memorizzate le variabili globali?

840
00:53:12,900 --> 00:53:18,100
Le variabili globali sono memorizzate in quello che è attualmente chiamato i dati inizializzati o dati non inizializzati,

841
00:53:18,100 --> 00:53:21,920
la differenza è se si dispone di una variabile globale e si assegna immediatamente un valore

842
00:53:21,920 --> 00:53:24,640
con il segno di uguale, finisce in alto là,

843
00:53:24,640 --> 00:53:29,200
e se hai appena detto x int, senza alcun valore, finisce leggermente inferiore nella RAM

844
00:53:29,200 --> 00:53:31,710
semplicemente per convenzione.

845
00:53:31,710 --> 00:53:34,940
Altre domande? Bene.

846
00:53:34,940 --> 00:53:37,340
Quindi questa immagine tornerà, come abbiamo più più potente

847
00:53:37,340 --> 00:53:39,170
con quello che si può fare con il computer,

848
00:53:39,170 --> 00:53:42,720
ma per ora, diamo una breve introduzione alla crittografia,

849
00:53:42,720 --> 00:53:46,080
un tipo specifico di crittografia che non risolve tutti i problemi del mondo

850
00:53:46,080 --> 00:53:47,720
ma risolve alcuni di essi.

851
00:53:47,720 --> 00:53:51,700
In questo caso qui, abbiamo qualcosa che si chiama crittografia a chiave segreta.

852
00:53:51,700 --> 00:53:56,410
La crittografia a chiave segreta, come suggerisce il nome, deriva la sua sicurezza da un segreto.

853
00:53:56,410 --> 00:54:00,690
>> Per esempio, se si erano di nuovo in grado di scuola e si passavano un po 'lettera d'amore segreta

854
00:54:00,690 --> 00:54:04,850
per il ragazzo o la ragazza si stava schiacciando in poi, se si vuole passare che nota tra il pubblico,

855
00:54:04,850 --> 00:54:08,380
probabilmente non avrebbe scritto una nota in inglese o qualunque sia la vostra lingua madre è.

856
00:54:08,380 --> 00:54:13,340
Piuttosto, si potrebbe criptare o si potrebbe semplicemente inviare un messaggio di testo in questi giorni.

857
00:54:13,340 --> 00:54:15,460
Ma si potrebbe effettivamente passare una nota in tutta la classe.

858
00:54:15,460 --> 00:54:18,700
E per farlo in modo sicuro, in modo che i tuoi amici e l'insegnante

859
00:54:18,700 --> 00:54:22,650
Non so quello che stai scrivendo, si potrebbe trovare con un algoritmo piuttosto semplice,

860
00:54:22,650 --> 00:54:25,920
giovane anche se si potrebbe essere, a poco rimescolare le parole.

861
00:54:25,920 --> 00:54:28,130
Così, invece di scrivere un si potrebbe scrivere b,

862
00:54:28,130 --> 00:54:30,220
invece di b si potrebbe scrivere c,

863
00:54:30,220 --> 00:54:32,140
invece di c si può scrivere d, e così via.

864
00:54:32,140 --> 00:54:34,360
Oppure si potrebbe trovare una traduzione più sofisticato

865
00:54:34,360 --> 00:54:36,720
di lettere alle lettere diverse.

866
00:54:36,720 --> 00:54:39,740
Ma il fermo è il ragazzo o la ragazza a cui si sta inviando questa nota

867
00:54:39,740 --> 00:54:45,020
ha bisogno di sapere qualcosa, che è ciò che, ovviamente? >> [Studente] Che cosa si sta inviando.

868
00:54:45,020 --> 00:54:49,720
Qual è il tuo segreto, come quello che è che la mappatura tra le b, c e d s.

869
00:54:49,720 --> 00:54:54,650
E 'solo l'aggiunta di 1 a ciascuna delle lettere per andare da A a B, da B a C?

870
00:54:54,650 --> 00:54:56,670
E 'più complesso di quello?

871
00:54:56,670 --> 00:55:01,540
>> Quindi tu e il tuo amore hanno bisogno di avere questa informazioni segrete,

872
00:55:01,540 --> 00:55:03,190
ma c'è una specie di cattura-22 qui.

873
00:55:03,190 --> 00:55:06,830
Se questa è la prima volta che si sta inviando questa lettera d'amore tramite la classe,

874
00:55:06,830 --> 00:55:10,720
come è quel ragazzo o ragazza che va di sapere quale sia il segreto è ancora?

875
00:55:10,720 --> 00:55:13,930
Così a chiave segreta di crittografia non risolve tutti i problemi del mondo,

876
00:55:13,930 --> 00:55:16,320
e c'è in realtà un rapporto di qui che torneremo a verso la fine del semestre.

877
00:55:16,320 --> 00:55:25,110
Allo stesso modo, non la maggior parte di noi conosce qualcuno che lavora, per esempio, su Amazon.com,

878
00:55:25,110 --> 00:55:28,190
eppure molti di noi hanno probabilmente comprato roba su Amazon.com,

879
00:55:28,190 --> 00:55:31,990
e ci è stato insegnato a pensare che queste transazioni e-commerce sono sicure.

880
00:55:31,990 --> 00:55:36,470
L'URL https dice probabilmente, c'è forse l'icona di un piccolo lucchetto sciocco da qualche parte,

881
00:55:36,470 --> 00:55:39,930
c'è un qualche tipo di crittografia proteggere i dati della carta di credito

882
00:55:39,930 --> 00:55:42,160
tra te e Amazon.com.

883
00:55:42,160 --> 00:55:45,430
Eppure, se la crittografia implica conoscere qualche segreto

884
00:55:45,430 --> 00:55:48,620
eppure io non conosco nessuno su Amazon e ho certamente non disposti qualsiasi tipo di segreto

885
00:55:48,620 --> 00:55:52,710
con qualcuno su Amazon, come è il mio computer o il mio browser facendo questo?

886
00:55:52,710 --> 00:55:55,720
Sembra che vi sono altri tipi di crittografia del tutto che risolvere il problema.

887
00:55:55,720 --> 00:55:57,670
Ma per oggi, ci concentreremo sulla semplice

888
00:55:57,670 --> 00:56:00,290
dove è possibile organizzare in anticipo per conoscere qualche segreto

889
00:56:00,290 --> 00:56:03,760
come +1 o un po 'di mapping tra un le b.

890
00:56:03,760 --> 00:56:05,840
E il processo di crittografia comporta generalmente questo.

891
00:56:05,840 --> 00:56:08,620
Hai un po 'di testo, illustrato qui a sinistra,

892
00:56:08,620 --> 00:56:12,930
lo si esegue attraverso un qualche tipo di algoritmo o procedura di crittografia -

893
00:56:12,930 --> 00:56:15,100
forse è solo una diventa b, b diventa c -

894
00:56:15,100 --> 00:56:17,490
e poi si finisce con testo cifrato.

895
00:56:17,490 --> 00:56:20,380
Nel frattempo, una volta che il tuo amore riceve questa nota segreta,

896
00:56:20,380 --> 00:56:24,200
lui o lei deve poi decifrare generalmente le inversioni di algoritmo

897
00:56:24,200 --> 00:56:27,190
in modo da recuperare il testo in chiaro.

898
00:56:27,190 --> 00:56:28,960
Ci sono incarnazioni fisiche di questo.

899
00:56:28,960 --> 00:56:31,680
>> Per esempio, questo è un piccolo anello decodificatore segreto,

900
00:56:31,680 --> 00:56:35,110
e questo è un anello, nel senso che ci sono due quadranti qui.

901
00:56:35,110 --> 00:56:38,490
Alla periferia al di fuori di questa cosa, ci sono le lettere dalla A alla Z,

902
00:56:38,490 --> 00:56:40,340
anche se sono in ordine casuale,

903
00:56:40,340 --> 00:56:42,880
e al suo interno, c'è in realtà alcuni numeri

904
00:56:42,880 --> 00:56:46,620
in modo tale che con questo anello è possibile tipo di trasformare l'esterno ma non l'interno

905
00:56:46,620 --> 00:56:49,140
al fine di allineare i numeri con lettere.

906
00:56:49,140 --> 00:56:53,020
Da un film intitolato Una storia di Natale, vedrai che Ralphie poco

907
00:56:53,020 --> 00:56:58,000
era così ansioso di capire quale messaggio segreto Little Orphan Annie era per lui

908
00:56:58,000 --> 00:57:02,570
che era stata comunicata, credo, sotto forma di messaggi numerici su una scatola di cereali

909
00:57:02,570 --> 00:57:07,220
e si doveva accumulare tutte le carte piccole che è venuto nella scatola di cereali,

910
00:57:07,220 --> 00:57:09,770
si doveva spedirle in, si doveva tornare sul ring segreto decoder

911
00:57:09,770 --> 00:57:13,910
in modo che si possa finalmente capire che cosa è la mappatura tra lettere e numeri

912
00:57:13,910 --> 00:57:15,550
o lettere e lettere.

913
00:57:15,550 --> 00:57:19,520
Come in un computer si può fare per l'attuazione o rappresentare le cose in questo modo?

914
00:57:19,520 --> 00:57:22,560
Abbiamo bisogno di un modo di esprimere se stessi un po 'più flessibile

915
00:57:22,560 --> 00:57:25,080
che le nostre variabili finora hanno permesso.

916
00:57:25,080 --> 00:57:29,000
Abbiamo avuto interi, abbiamo avuto caratteri, abbiamo avuto float e double e pochi altri,

917
00:57:29,000 --> 00:57:34,200
ma questi sono singoli pezzi di memoria che in realtà non ci permettono di esprimere le cose

918
00:57:34,200 --> 00:57:36,440
come le parole e le frasi e frasi.

919
00:57:36,440 --> 00:57:38,630
In effetti, abbiamo chiamato tali stringhe cose,

920
00:57:38,630 --> 00:57:42,660
ma vi promettiamo che questo è davvero solo una semplificazione nella biblioteca CS50

921
00:57:42,660 --> 00:57:45,540
che stiamo intenzione di staccare.

922
00:57:45,540 --> 00:57:47,500
E così cominciamo a farlo qui.

923
00:57:47,500 --> 00:57:49,840
Lasciatemi andare avanti e aprire un file -

924
00:57:49,840 --> 00:57:54,100
tutti questi file sono disponibili, come di consueto, online - array.c chiamato

925
00:57:54,100 --> 00:57:58,960
per risolvere un problema non correlato alle stringhe, ma che dipinge un quadro qui

926
00:57:58,960 --> 00:58:01,520
di come si può utilizzare qualcosa chiamato un array.

927
00:58:01,520 --> 00:58:04,050
>> Un array è un tipo di dati.

928
00:58:04,050 --> 00:58:10,730
E 'un tipo di variabile di sorta che dispone di più tipi di dati più piccoli all'interno di esso

929
00:58:10,730 --> 00:58:12,680
back to back to back to back.

930
00:58:12,680 --> 00:58:16,980
Così, per esempio, se volessimo scrivere un piccolo programma che ti dà la media quiz

931
00:58:16,980 --> 00:58:19,780
per un corso come 50 che ha 2 quiz,

932
00:58:19,780 --> 00:58:23,450
si potrebbe facilmente scrivere questo programma basato anche su alcuni dei materiali della scorsa settimana

933
00:58:23,450 --> 00:58:28,830
utilizzando GetInt e un paio di variabili: int quiz1, int quiz2.

934
00:58:28,830 --> 00:58:30,550
Ed è abbastanza semplice.

935
00:58:30,550 --> 00:58:33,500
E 'forse da 10, 20 righe di codice massimo di attuare un programma

936
00:58:33,500 --> 00:58:38,940
che chiede all'utente di 2 punteggi di quiz e poi calcola la loro media

937
00:58:38,940 --> 00:58:42,020
sommando insieme, dividendo per 2, e quindi la stampa dei risultati.

938
00:58:42,020 --> 00:58:46,400
Si potrebbe probabilmente fare abbastanza facilmente che ora, dopo un certo numero di minuti.

939
00:58:46,400 --> 00:58:49,450
Ma il problema è che supporre che il 50 aveva 3 o 4 quiz.

940
00:58:49,450 --> 00:58:52,830
Supponiamo di voler utilizzare lo stesso programma per una classe che aveva settimanale quiz.

941
00:58:52,830 --> 00:58:55,100
Pensate a una classe che ha quiz settimanale.

942
00:58:55,100 --> 00:58:58,840
Se ci sono 16 o in modo da settimane in un semestre, ora si dispone di 16 variabili:

943
00:58:58,840 --> 00:59:03,030
quiz1 int, int quiz2, quiz3 int, int quiz4.

944
00:59:03,030 --> 00:59:06,870
Non appena si inizia a vedere questa ridondanza, il copia e incolla del codice,

945
00:59:06,870 --> 00:59:09,810
si dovrebbe iniziare a farvi piacerebbe che ci fosse un modo migliore.

946
00:59:09,810 --> 00:59:13,610
E per fortuna, a causa delle matrici che ci sia. Allora, facciamo questo.

947
00:59:13,610 --> 00:59:16,700
In primo luogo, permettetemi di presentarvi una cosa molto semplice che non abbiamo usato finora,

948
00:59:16,700 --> 00:59:18,820
ma lo vedrete tanto in tanto nel codice.

949
00:59:18,820 --> 00:59:21,270
>> Questo è ciò che generalmente chiamato una costante.

950
00:59:21,270 --> 00:59:24,410
Quindi è una costante, nel senso che non è mai tale valore cambia.

951
00:59:24,410 --> 00:59:26,450
La convenzione umana durante la creazione di una costante

952
00:59:26,450 --> 00:59:30,420
è quello di utilizzare tutte le lettere maiuscole solo in modo che si distingue sul serio nel codice,

953
00:59:30,420 --> 00:59:34,270
e la parola chiave speciale che si utilizza è in C # define.

954
00:59:34,270 --> 00:59:39,970
Così diciamo # define, poi uno spazio, quindi la parola che si desidera utilizzare per il nome della costante di

955
00:59:39,970 --> 00:59:41,730
e quindi il valore della costante.

956
00:59:41,730 --> 00:59:44,710
Si noti che questo è diverso da assegnare qualcosa a una variabile.

957
00:59:44,710 --> 00:59:46,430
Non c'è segno di uguale, non c'è punto e virgola.

958
00:59:46,430 --> 00:59:49,140
Questo è ciò che è noto come una direttiva del preprocessore,

959
00:59:49,140 --> 00:59:50,840
ma su questo un'altra volta.

960
00:59:50,840 --> 00:59:56,350
Per ora, questo crea un valore immutabile chiamato QUIZ

961
00:59:56,350 --> 00:59:58,290
il cui valore numerico effettivo è 2.

962
00:59:58,290 --> 01:00:02,180
Quindi, ovunque compaia QUIZZES, quiz, quiz in questo file,

963
01:00:02,180 --> 01:00:04,230
questo è solo il numero 2.

964
01:00:04,230 --> 01:00:06,550
Se guardo principale ora, vediamo come funziona.

965
01:00:06,550 --> 01:00:09,770
In primo luogo sembra un po 'criptico, ma è tutta roba da settimana 1.

966
01:00:09,770 --> 01:00:12,210
Chiedi l'utente per i gradi. Come possiamo fare questo?

967
01:00:12,210 --> 01:00:17,350
In linea 22 - questo è davvero la parte succosa - dichiaro un galleggiante

968
01:00:17,350 --> 01:00:23,240
ma non solo un singolo galleggiante. Sto dichiarando, anzi, una serie di valori a virgola mobile.

969
01:00:23,240 --> 01:00:27,700
Tale variabile sta per essere chiamato gradi, come implicito qui,

970
01:00:27,700 --> 01:00:31,420
ma l'unico pezzo di nuova sintassi allora sono queste parentesi quadre.

971
01:00:31,420 --> 01:00:37,280
Il fatto che io ho detto voti float e poi parentesi aperta e poi un numero -

972
01:00:37,280 --> 01:00:40,980
notare se si tratta di una costante è proprio come abbiamo fatto questo -

973
01:00:40,980 --> 01:00:46,840
questo vuol dire, "Hey computer, dammi 2 galleggianti e andiamo insieme chiamarli gradi."

974
01:00:46,840 --> 01:00:51,780
>> Questo è in contrasto con un processo molto più noioso come questo: float grade1;

975
01:00:51,780 --> 01:00:54,580
galleggiare grade2, e così via.

976
01:00:54,580 --> 01:00:58,310
Quindi un array ci permette di attuare questa idea, ma molto meno disordinato,

977
01:00:58,310 --> 01:01:04,560
in modo tale che possiamo scrivere 1 riga di codice invece di, diciamo, 16 per un 16-settimana semestre.

978
01:01:04,560 --> 01:01:09,060
Non volevo a livello di codice 2, perché se si pensa di questo ora logicamente,

979
01:01:09,060 --> 01:01:12,560
supponiamo che il prossimo anno CS50 cambia di 3 quiz invece

980
01:01:12,560 --> 01:01:15,010
e ho avuto il numero 2 qui, ho avuto il numero 2 qui,

981
01:01:15,010 --> 01:01:17,210
Ho avuto il numero 2 qui, il numero 2 qui.

982
01:01:17,210 --> 01:01:19,890
Diventa molto noioso e molto facile da avvitare

983
01:01:19,890 --> 01:01:26,550
e per cambiare accidentalmente 1 valore a 3 e perdere un altro valore di 2.

984
01:01:26,550 --> 01:01:30,660
Quindi ho intenzione di astratto invece questa distanza e utilizzare questa costante che,

985
01:01:30,660 --> 01:01:32,520
Come suggerisce il nome, cambia mai.

986
01:01:32,520 --> 01:01:35,870
E ora non importa se abbiamo diversi quiz quest'anno o il prossimo,

987
01:01:35,870 --> 01:01:39,380
Devo solo cambiare in un posto qui in alto.

988
01:01:39,380 --> 01:01:41,230
Ecco, questo è tutto un costante.

989
01:01:41,230 --> 01:01:47,100
Nel frattempo, la nuova funzionalità concettuale è quella di una matrice.

990
01:01:47,100 --> 01:01:55,030
Così le parentesi quadre mi danno questo molti carri allegorici e mi permette di chiamarli collettivamente gradi qui.

991
01:01:55,030 --> 01:01:56,720
Così ora vediamo che cosa ho intenzione di fare.

992
01:01:56,720 --> 01:01:59,220
Qui nella riga 24 è l'inizio di un ciclo.

993
01:01:59,220 --> 01:02:03,380
>> Questo è davvero niente di speciale. E 'solo con QUIZ invece di un hard-coded numero.

994
01:02:03,380 --> 01:02:06,740
Ma non c'è nulla di diverso ci intellettualmente dalla settimana scorsa.

995
01:02:06,740 --> 01:02:11,650
Questo è solo printf, così printf ("Quiz #% d di% d:")

996
01:02:11,650 --> 01:02:16,670
perché io voglio solo stampare darmi quiz numero 1 di 2 e poi 2 di 2.

997
01:02:16,670 --> 01:02:18,480
Quindi questa è una cosa puramente estetica.

998
01:02:18,480 --> 01:02:21,000
Ma la parte interessante è ora in linea 27.

999
01:02:21,000 --> 01:02:27,840
Al fine di compilare uno dei due segnaposto con un valore a virgola mobile,

1000
01:02:27,840 --> 01:02:29,640
di nuovo utilizzare le parentesi quadre.

1001
01:02:29,640 --> 01:02:35,170
In questo caso, sto usando io, perché questo ciclo for è iniziata con i pari che valore, a quanto pare?

1002
01:02:35,170 --> 01:02:36,670
[Studente] 0. >> [Malan] 0.

1003
01:02:36,670 --> 01:02:40,990
Quindi, alla prima iterazione di questo ciclo, è come se ho scritto questo nel codice,

1004
01:02:40,990 --> 01:02:46,310
ma sulla seconda iterazione di questo ciclo, è come se Ho scritto questo nel mio codice.

1005
01:02:46,310 --> 01:02:49,970
Ma il fatto che sto usando una variabile è perfetto, perché, come suggerisce il nome,

1006
01:02:49,970 --> 01:02:52,600
sta variando il suo valore ad ogni iterazione,

1007
01:02:52,600 --> 01:02:55,900
così sto compilando questa matrice un punto alla volta.

1008
01:02:55,900 --> 01:02:57,380
Che cosa significa questo array assomiglia?

1009
01:02:57,380 --> 01:03:01,570
La ragione per cui ho disegnato il rettangolo super semplice sullo schermo qui prima era per questo motivo.

1010
01:03:01,570 --> 01:03:05,590
Un array è solo un pezzo di memoria seguito da un altro pezzo di memoria

1011
01:03:05,590 --> 01:03:08,570
seguito da un altro pezzo di memoria e così via.

1012
01:03:08,570 --> 01:03:13,120
Quindi, se la mia matrice è di dimensione 2 in questo caso qui, tutto quello che avrebbe fatto

1013
01:03:13,120 --> 01:03:20,200
digitando il mio punteggio quiz piace qui - ho preso 100 su questo e poi ho avuto un 99 su questo -

1014
01:03:20,200 --> 01:03:24,970
allora questa memoria potrebbe anche non essere usato perché ho chiesto solo il computer

1015
01:03:24,970 --> 01:03:26,840
per una matrice di dimensione 2.

1016
01:03:26,840 --> 01:03:28,600
Queste piazze sono ancora lì, giusto?

1017
01:03:28,600 --> 01:03:32,670
Hai ancora 2 gigabyte di RAM, anche se si sta solo chiedendo 2 galleggianti.

1018
01:03:32,670 --> 01:03:36,840
Così l'idea che sta dietro gli array è che il computer richiede solo un pezzo di memoria

1019
01:03:36,840 --> 01:03:41,340
e ripartisce poi pezzi più piccoli back to back to back to back.

1020
01:03:41,340 --> 01:03:43,310
E così questo è tutto un array è.

1021
01:03:43,310 --> 01:03:47,350
>> E 'un pezzo contiguo di memoria interna di cui si possono mettere le cose.

1022
01:03:47,350 --> 01:03:50,700
Questo succede a fare allora solo alcuni aritmetica noioso.

1023
01:03:50,700 --> 01:03:54,640
Se scorrere verso il basso qui, questo è dove ho poi scorrere l'array.

1024
01:03:54,640 --> 01:03:58,020
Io vengo con la somma di tutti i valori nella matrice,

1025
01:03:58,020 --> 01:04:02,470
e poi usare la funzione da queste parti per fare realmente la somma divisa per quiz.

1026
01:04:02,470 --> 01:04:06,320
Ma permettetemi di salutare la mia mano in quella come una sorta di aritmetica sufficiente per ora.

1027
01:04:06,320 --> 01:04:08,370
Ma tutto quello che sta facendo per me, in ultima analisi, sta calcolando una media.

1028
01:04:08,370 --> 01:04:13,580
Quindi, primo quiz più quiz secondo diviso per 2 e poi stampare come un int.

1029
01:04:13,580 --> 01:04:17,280
Ma andiamo ora transizione verso un esempio diverso chiamato stringa1,

1030
01:04:17,280 --> 01:04:20,700
che dipinge un quadro simile, ma con le stringhe.

1031
01:04:20,700 --> 01:04:23,940
Lasciatemi andare avanti e semplificare questo solo per un momento.

1032
01:04:23,940 --> 01:04:27,090
Perdonate il rientro per ora.

1033
01:04:27,090 --> 01:04:30,870
Del bando nella riga 19 di questo esempio, ho una stringa dall'utente.

1034
01:04:30,870 --> 01:04:34,640
Ma notate quello che sto facendo in prossima linee 22 in poi.

1035
01:04:34,640 --> 01:04:41,250
In realtà sto iterando da i fino a - e questo è un nuovo trucco - strlen, lunghezza della stringa.

1036
01:04:41,250 --> 01:04:44,880
Questa è una funzione che viene fornito con C che, se si passa una stringa,

1037
01:04:44,880 --> 01:04:47,730
ti dice quanti caratteri sono in quella stringa. Questo è tutto.

1038
01:04:47,730 --> 01:04:51,550
E il fatto che si tratta di strlen invece di lunghezza della stringa è solo perché è più succinto.

1039
01:04:51,550 --> 01:04:55,100
Trenta anni fa, la gente amava scrivere le cose nel modo più succinto possibile,

1040
01:04:55,100 --> 01:04:57,630
così abbiamo mantenuto tale convenzione qui.

1041
01:04:57,630 --> 01:05:00,660
i + + significa solo incrementare i in ogni iterazione.

1042
01:05:00,660 --> 01:05:02,990
E ora notare questo, che è davvero interessante.

1043
01:05:02,990 --> 01:05:09,180
In linea 24, dico, "Computer, dammi un carattere, 8 bit, e lo chiamano c."

1044
01:05:09,180 --> 01:05:12,630
Ma che cosa è questo sul lato destro dicendo?

1045
01:05:13,490 --> 01:05:16,530
In inglese, che cosa rappresenta?

1046
01:05:16,530 --> 01:05:18,730
[Studente] Il primo carattere della matrice.

1047
01:05:18,730 --> 01:05:20,790
Esattamente. Dammi il primo carattere della matrice.

1048
01:05:20,790 --> 01:05:24,090
O, più in generale, mi danno il carattere i-esimo nella matrice.

1049
01:05:24,090 --> 01:05:26,100
E rendo conto che è importante ora che, come gli informatici,

1050
01:05:26,100 --> 01:05:27,890
stiamo in realtà a contare da 0.

1051
01:05:27,890 --> 01:05:29,720
>> Non hanno la facoltà ora di iniziare a fare questo.

1052
01:05:29,720 --> 01:05:34,160
Ora ti devi comportare in linea con le aspettative del computer e contare da 0

1053
01:05:34,160 --> 01:05:38,180
perché [0] sta per essere il primo carattere di una stringa,

1054
01:05:38,180 --> 01:05:42,150
[1] sarà il secondo, [2] sarà il terzo, e così via.

1055
01:05:42,150 --> 01:05:49,720
Quindi questo programma, se lo compila, questo è ancora stringa1, in modo da rendere stringa1,

1056
01:05:49,720 --> 01:05:54,670
e ora ho eseguito stringa1 nella mia finestra di terminale.

1057
01:05:54,670 --> 01:05:58,330
E 'in attesa di input, così ho intenzione di scrivere in David, Invio,

1058
01:05:58,330 --> 01:06:02,540
e ora la stampa David tutto su linee diverse, perché avviso quello che sto facendo.

1059
01:06:02,540 --> 01:06:05,820
Sto stampando un carattere alla volta.

1060
01:06:05,820 --> 01:06:10,100
Non entreremo nei dettagli oggi su questo, ma ho cancellato poco fa questo controllo qui.

1061
01:06:10,100 --> 01:06:15,480
Si scopre che se l'utente si comporta male,, contraddittorio, o semplicemente confusi

1062
01:06:15,480 --> 01:06:20,210
si può effettivamente non riescono a dare una stringa di una certa lunghezza.

1063
01:06:20,210 --> 01:06:22,860
Se si preme il tasto sbagliato sulla tastiera, si potrebbe dare nessuna stringa a tutti,

1064
01:06:22,860 --> 01:06:26,950
o se siete maligni, si potrebbe cercare di incollare merita una gigabyte di un saggio

1065
01:06:26,950 --> 01:06:29,290
per riempire questa stringa, e se il computer esaurisce la memoria,

1066
01:06:29,290 --> 01:06:32,710
si scopre che stiamo andando a recuperare questo valore speciale chiamato NULL.

1067
01:06:32,710 --> 01:06:35,580
Quindi, per ora, è sufficiente sapere che c'è questo valore speciale chiamato NULL

1068
01:06:35,580 --> 01:06:39,580
che ci permetterà di controllare quando siamo di memoria, tra le altre cose.

1069
01:06:39,580 --> 01:06:45,630
Ma se apro adesso stringa2, si noti una differenza qui.

1070
01:06:45,630 --> 01:06:48,210
Si noti una differenza qui con stringa2.

1071
01:06:48,210 --> 01:06:51,340
Con stringa2, questo ciclo for è un po 'diverso.

1072
01:06:51,340 --> 01:06:55,010
>> Mi permette di cancellare i valori null in modo che si possa parlare di quelli un'altra volta.

1073
01:06:55,010 --> 01:06:57,800
Cosa c'è di diverso il ciclo for questa volta?

1074
01:06:59,620 --> 01:07:01,670
Posso tornare all'esempio precedente.

1075
01:07:01,670 --> 01:07:08,580
Ecco, questo è la versione 2, questa è la versione 1. 1, 2.

1076
01:07:08,580 --> 01:07:11,980
1, 2.

1077
01:07:13,520 --> 01:07:16,660
La chiamata strlen è dove?

1078
01:07:16,660 --> 01:07:18,860
E 'nella prima parte del ciclo for.

1079
01:07:18,860 --> 01:07:21,830
Ogni pensiero sul motivo per cui sto facendo questo? Gia '.

1080
01:07:21,830 --> 01:07:24,560
[Studente] Quindi non si chiama la funzione ogni volta.

1081
01:07:24,560 --> 01:07:26,440
[Malan] Quindi non chiamare la funzione ogni volta. Esattamente.

1082
01:07:26,440 --> 01:07:28,300
Ricordiamo da cicli for che sono super semplice

1083
01:07:28,300 --> 01:07:31,770
una volta che si ordina di capire che questo è l'inizializzazione, la condizione, e l'aggiornamento.

1084
01:07:31,770 --> 01:07:34,750
Il problema è che la condizione si verifica su ogni iterazione del ciclo.

1085
01:07:34,750 --> 01:07:40,010
E così, in questo esempio qui, ciò che è male per il fatto che questa è la mia condizione?

1086
01:07:40,010 --> 01:07:41,830
[Studente] Tu stai chiamando strlen.

1087
01:07:41,830 --> 01:07:44,340
[Malan] Tu stai chiamando strlen ancora e ancora e ancora.

1088
01:07:44,340 --> 01:07:47,410
Ma una volta che ho scritto a David, la lunghezza di tale stringa è 5,

1089
01:07:47,410 --> 01:07:49,650
e non cambierà ad ogni iterazione del ciclo

1090
01:07:49,650 --> 01:07:51,670
poiché la stringa è ancora D-a-v-i-d.

1091
01:07:51,670 --> 01:07:55,320
Quindi questo è un accenno a quello che sta per diventare un 'idea sempre più importante

1092
01:07:55,320 --> 01:08:00,410
conosciuta come una decisione di progettazione in cui semplicemente non ha il computer a fare lavoro inutile.

1093
01:08:00,410 --> 01:08:03,920
>> Proprio come in anteprima pset2, pset2 nella versione standard

1094
01:08:03,920 --> 01:08:07,030
sta andando a sfidare di implementare effettivamente un certo numero di cifre,

1095
01:08:07,030 --> 01:08:10,410
un certo numero di algoritmi di crittografia, in modo che è possibile sia crittografare

1096
01:08:10,410 --> 01:08:13,840
e decifrare i messaggi segreti molto simile al Ralphie lì decodificato.

1097
01:08:13,840 --> 01:08:16,810
Nell'edizione hacker di pset2, abbiamo intenzione di andare un po 'oltre.

1098
01:08:16,810 --> 01:08:19,649
Stiamo andando a portata di mano è un file da un sistema informatico attuale

1099
01:08:19,649 --> 01:08:23,479
che contiene un sacco di nomi utente e password criptate reali,

1100
01:08:23,479 --> 01:08:26,939
e la sfida per l'edizione pirata sta per essere a rompere le password

1101
01:08:26,939 --> 01:08:33,200
e capire cos'è la crittografia o quale segreto è stato utilizzato per generare effettivamente le password.

1102
01:08:33,200 --> 01:08:36,109
E abbiamo intenzione di farlo utilizzando una nuova funzionalità di C

1103
01:08:36,109 --> 01:08:40,630
che io ti do solo un demo di nota come argomenti della riga di comando.

1104
01:08:40,630 --> 01:08:44,229
Si scopre, come alcuni di voi avranno visto in sezione o nei libri di testo,

1105
01:08:44,229 --> 01:08:48,260
principale non sempre deve essere vuoto tra parentesi.

1106
01:08:48,260 --> 01:08:52,430
Si scopre che principale può anche essere scritto in questo modo, con due argomenti,

1107
01:08:52,430 --> 01:08:56,870
argc e argv, dove argc è il numero di parole

1108
01:08:56,870 --> 01:09:00,020
di digitare dopo il nome del programma sulla riga di comando

1109
01:09:00,020 --> 01:09:03,420
e argv sono le parole reali.

1110
01:09:03,420 --> 01:09:07,540
E come le parentesi quadre ci suggeriscono, argv è apparentemente un array.

1111
01:09:07,540 --> 01:09:12,210
E 'intenzione di essere una stringa dopo una stringa dopo una stringa in memoria.

1112
01:09:12,210 --> 01:09:16,010
>> Quindi quello che sta andando ad essere in grado di fare a partire da pset 2 è qualcosa di simile a questo.

1113
01:09:16,010 --> 01:09:21,350
Se faccio argv1, che è un esempio torneremo a il Lunedi, ed eseguirlo,

1114
01:09:21,350 --> 01:09:23,370
notare che non sembra di fare nulla ancora.

1115
01:09:23,370 --> 01:09:25,490
Essa si limita a stampare il suo nome.

1116
01:09:25,490 --> 01:09:31,479
Ma se io dico addio di classe, si noti che il programma scorre apparentemente

1117
01:09:31,479 --> 01:09:35,479
su ciascuna delle parole che sono state digitate al prompt.

1118
01:09:35,479 --> 01:09:41,630
E i mezzi con cui si avrà accesso alle parole che l'utente ha digitato al prompt

1119
01:09:41,630 --> 01:09:49,160
è cambiando principale a partire da questo fine settimana da int main (void) a int main (argc, argv)

1120
01:09:49,160 --> 01:09:52,050
e così nascerà riga di comando argomenti.

1121
01:09:52,050 --> 01:09:57,100
E una volta che si ottiene veramente sofisticata di questo, sarete in grado di scrivere programmi molto trippy

1122
01:09:57,100 --> 01:09:59,610
come questa qui, che va al di là

1123
01:09:59,610 --> 01:10:03,940
alcune delle funzionalità che abbiamo fatto fino ad ora, ma tutti abbastanza potente.

1124
01:10:03,940 --> 01:10:08,950
>> Così lasceremo questo con questo sullo schermo, e ci vedremo il Lunedi.

1125
01:10:17,570 --> 01:10:20,000
>> [CS50.TV]