1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Sezione 4] [meno confortevole]

2
00:00:02,000 --> 00:00:04,000
[Nate Hardison] [Harvard University]

3
00:00:04,000 --> 00:00:07,000
[Questo è CS50.] [CS50.TV]

4
00:00:07,000 --> 00:00:10,000
>> Va bene, bentornato alla sezione.

5
00:00:10,000 --> 00:00:13,000
Nella sezione di questa settimana andremo a fare un paio di cose.

6
00:00:13,000 --> 00:00:17,000
Stiamo per primo Set problema recap 2,

7
00:00:17,000 --> 00:00:20,000
che è il problema Cesare e Vigenère set.

8
00:00:20,000 --> 00:00:23,000
E poi andiamo a tuffarsi recensione Quiz 0

9
00:00:23,000 --> 00:00:26,000
e trascorrere un po 'di tempo ricapitolando ciò di cui abbiamo parlato

10
00:00:26,000 --> 00:00:30,000
in ciascuna delle lezioni fino ad ora, e faremo anche fare qualche problema

11
00:00:30,000 --> 00:00:32,000
da quiz dell'anno precedente.

12
00:00:32,000 --> 00:00:36,000
In questo modo voi ragazzi avete un buon modo per prepararsi a questo.

13
00:00:36,000 --> 00:00:40,000
>> Per iniziare, ho avviato un paio di buone soluzioni

14
00:00:40,000 --> 00:00:45,000
per il set precedente problema, Problemi Set 2, in questo spazio.

15
00:00:45,000 --> 00:00:48,000
Se voi ragazzi ha colpito questo link,

16
00:00:48,000 --> 00:00:53,000
e se si fa clic su il mio nome e cliccate su il mio prima revisione

17
00:00:53,000 --> 00:00:56,000
vedrai caesar.c, che è esattamente quello che sto guardando.

18
00:00:56,000 --> 00:01:00,000
Parliamo di questo molto velocemente.

19
00:01:00,000 --> 00:01:02,000
Questo è solo una soluzione campione.

20
00:01:02,000 --> 00:01:05,000
Questo non è necessariamente la soluzione perfetta.

21
00:01:05,000 --> 00:01:08,000
Ci sono molti modi diversi per scrivere questo,

22
00:01:08,000 --> 00:01:10,000
ma ci sono un paio di cose che volevo mettere in evidenza

23
00:01:10,000 --> 00:01:13,000
che ho visto come mi è stato di classificazione, gli errori più comuni che penso

24
00:01:13,000 --> 00:01:18,000
questa soluzione fa un ottimo lavoro di manipolazione.

25
00:01:18,000 --> 00:01:22,000
>> La prima è avere una sorta di commento di intestazione in alto.

26
00:01:22,000 --> 00:01:25,000
Sulle linee da 1 a 7 si vedono i dettagli,

27
00:01:25,000 --> 00:01:28,000
che cosa è esattamente questo programma sta facendo.

28
00:01:28,000 --> 00:01:32,000
Una buona pratica standard quando si sta scrivendo codice C

29
00:01:32,000 --> 00:01:35,000
indipendentemente se il programma è contenuto all'interno di un singolo file o

30
00:01:35,000 --> 00:01:38,000
se è suddiviso su più file è quello di avere una sorta di

31
00:01:38,000 --> 00:01:40,000
orientando commento in cima.

32
00:01:40,000 --> 00:01:43,000
Questo è anche per le persone che escono e scrivere il codice nel mondo reale.

33
00:01:43,000 --> 00:01:47,000
Questo è dove metterò le informazioni sul copyright.

34
00:01:47,000 --> 00:01:50,000
Qui sotto trovi gli # include.

35
00:01:50,000 --> 00:01:55,000
Sulla linea 16 c'è questa # define, che torneremo a tra poco.

36
00:01:55,000 --> 00:01:59,000
E poi una volta che la funzione avvia, si avvia una volta i principali,

37
00:01:59,000 --> 00:02:03,000
perché questo programma è tutto contenuto in una singola funzione

38
00:02:03,000 --> 00:02:09,000
la prima cosa che accade, e questo è molto idiomatico e tipico di un programma C

39
00:02:09,000 --> 00:02:14,000
che accoglie gli argomenti della riga di comando, è che si verifica immediatamente

40
00:02:14,000 --> 00:02:18,000
>> per il numero di argomenti, argc.

41
00:02:18,000 --> 00:02:24,000
Proprio qui si vede che il programma si aspetta esattamente 2 argomenti.

42
00:02:24,000 --> 00:02:27,000
Ricordate che ci sono che il primo argomento che è la speciale

43
00:02:27,000 --> 00:02:29,000
che è sempre il nome del programma che è in esecuzione,

44
00:02:29,000 --> 00:02:31,000
il nome del file eseguibile.

45
00:02:31,000 --> 00:02:36,000
E così ciò che questo non fa altro che impedisce all'utente di eseguire il programma

46
00:02:36,000 --> 00:02:42,000
con argomenti più o meno.

47
00:02:42,000 --> 00:02:44,000
La ragione per cui si vuole verificare la presenza di questo subito è dovuto al fatto

48
00:02:44,000 --> 00:02:52,000
non si può effettivamente accedere a questo array argv qui affidabile

49
00:02:52,000 --> 00:02:55,000
fino a quando abbiamo controllato per vedere quanto è grande.

50
00:02:55,000 --> 00:02:58,000
>> Uno degli errori più comuni che ho visto è stata la gente subito andare in

51
00:02:58,000 --> 00:03:01,000
e afferrare argv [1].

52
00:03:01,000 --> 00:03:06,000
Avevano afferrare l'argomento chiave dalla matrice e le differenze tra la a per controllare i su di esso,

53
00:03:06,000 --> 00:03:11,000
e poi che avrebbero fatto il test per argc e il prossimo test,

54
00:03:11,000 --> 00:03:16,000
se il primo argomento era effettivamente un intero al tempo stesso,

55
00:03:16,000 --> 00:03:20,000
e che non funziona perché nel caso in cui non ci sono argomenti forniti

56
00:03:20,000 --> 00:03:26,000
ti verrà afferrando un argomento che non c'è o il tentativo di afferrare quello che non c'è.

57
00:03:26,000 --> 00:03:29,000
>> L'altra cosa importante che si deve notare è che

58
00:03:29,000 --> 00:03:32,000
hai sempre voglia di stampare una sorta di messaggio di errore utile

59
00:03:32,000 --> 00:03:34,000
per l'utente di orientarli.

60
00:03:34,000 --> 00:03:37,000
Sono sicuro che hai tutti i programmi in esecuzione, dove tutto ad un tratto si blocca,

61
00:03:37,000 --> 00:03:41,000
e si ottiene questa finestra di dialogo po 'ridicolo che si apre e dice:

62
00:03:41,000 --> 00:03:44,000
qualcosa di terribilmente criptico e magari ti dà un codice di errore o qualcosa di simile

63
00:03:44,000 --> 00:03:47,000
che non ha senso.

64
00:03:47,000 --> 00:03:50,000
Questo è dove si vuole veramente offrire qualcosa di utile

65
00:03:50,000 --> 00:03:54,000
e mirate per l'utente in modo che quando si esegue vanno "Oh," faccia di palma.

66
00:03:54,000 --> 00:03:58,000
"So esattamente cosa fare. So come risolvere questo problema."

67
00:03:58,000 --> 00:04:01,000
>> Se non si stampa un messaggio, poi si finisce in realtà

68
00:04:01,000 --> 00:04:04,000
lasciando all'utente di andare a esaminare il codice sorgente

69
00:04:04,000 --> 00:04:07,000
per capire cosa è andato storto.

70
00:04:07,000 --> 00:04:11,000
Ci sono anche alcune volte che si usano diversi codici di errore.

71
00:04:11,000 --> 00:04:14,000
Qui abbiamo usato solo uno a dire che c'era un errore,

72
00:04:14,000 --> 00:04:16,000
c'è stato un errore, c'è stato un errore.

73
00:04:16,000 --> 00:04:20,000
Più grandi programmi, spesso i programmi che vengono richiamati da altri programmi,

74
00:04:20,000 --> 00:04:25,000
restituisce una sorta di codici di errore speciali in diversi scenari

75
00:04:25,000 --> 00:04:28,000
per comunicare di programmazione quello che sarebbe altrimenti

76
00:04:28,000 --> 00:04:32,000
basta usare un bel messaggio inglese per.

77
00:04:32,000 --> 00:04:35,000
Cool.

78
00:04:35,000 --> 00:04:37,000
Mentre lavoriamo in basso, si può vedere tiriamo fuori la chiave.

79
00:04:37,000 --> 00:04:40,000
Ci prova per vedere se la chiave adatta.

80
00:04:40,000 --> 00:04:42,000
Abbiamo un messaggio da parte dell'utente.

81
00:04:42,000 --> 00:04:46,000
Il motivo per cui lo facciamo in questa do while, e questo è qualcosa che ci occuperemo

82
00:04:46,000 --> 00:04:50,000
in un po ', ma si scopre che se si digita il controllo D

83
00:04:50,000 --> 00:04:54,000
quando si ottiene che GetString prompt del terminale

84
00:04:54,000 --> 00:04:59,000
quello che in realtà è esso invia un carattere speciale

85
00:04:59,000 --> 00:05:01,000
al programma.

86
00:05:01,000 --> 00:05:05,000
Si chiama ELF o il carattere di fine file.

87
00:05:05,000 --> 00:05:08,000
E in quel caso, la nostra stringa di messaggio sarà nullo,

88
00:05:08,000 --> 00:05:14,000
quindi questo non era qualcosa che abbiamo controllato per il problema posto stesso.

89
00:05:14,000 --> 00:05:17,000
>> Ma andiamo avanti, ora che abbiamo cominciato a parlare di puntatori

90
00:05:17,000 --> 00:05:21,000
e l'allocazione dinamica della memoria sul mucchio,

91
00:05:21,000 --> 00:05:25,000
controllo per nulla ogni volta che si dispone di una funzione che potrebbe

92
00:05:25,000 --> 00:05:30,000
ritorna null come valore è qualcosa che si vorrà prendere l'abitudine di fare.

93
00:05:30,000 --> 00:05:33,000
Questo è qui principalmente per illustrazione.

94
00:05:33,000 --> 00:05:36,000
Ma quando si fa vedere GetString in futuro,

95
00:05:36,000 --> 00:05:41,000
così da Problema Set 4 in poi, ti consigliamo di tenere questo in mente.

96
00:05:41,000 --> 00:05:44,000
Ancora una volta, questo non è un problema per problema Set 3 o dato che non l'aveva ancora coperto.

97
00:05:44,000 --> 00:05:53,000
Infine, si arriva a questa parte, dove si arriva al ciclo di crittografia principale,

98
00:05:53,000 --> 00:05:57,000
e ci sono un paio di cose che accadono qui.

99
00:05:57,000 --> 00:06:02,000
In primo luogo, scorrere la stringa intero messaggio stesso.

100
00:06:02,000 --> 00:06:07,000
Qui abbiamo mantenuto la strlen chiamata nella condizione,

101
00:06:07,000 --> 00:06:12,000
che molti di voi hanno sottolineato non è un ottimo modo per andare.

102
00:06:12,000 --> 00:06:15,000
Si scopre in questo caso non è anche un ottimo,

103
00:06:15,000 --> 00:06:20,000
in parte perché stiamo modificando il contenuto del messaggio stesso

104
00:06:20,000 --> 00:06:27,000
all'interno del ciclo for, quindi se abbiamo un messaggio che è 10 caratteri,

105
00:06:27,000 --> 00:06:32,000
la prima volta che si parte per il ciclo strlen tornerà cosa?

106
00:06:32,000 --> 00:06:35,000
10.

107
00:06:35,000 --> 00:06:40,000
>> Ma se quindi modificare il messaggio, dire che modificare il suo carattere 5th,

108
00:06:40,000 --> 00:06:46,000
e ci buttiamo in un carattere \ 0 in 5 ° posizione,

109
00:06:46,000 --> 00:06:49,000
su una iterazione successiva strlen (messaggio) non restituirà quello che ha fatto

110
00:06:49,000 --> 00:06:52,000
la prima volta abbiamo iterato,

111
00:06:52,000 --> 00:06:56,000
ma sarà invece restituisce 5 perché abbiamo buttato in quel terminatore null,

112
00:06:56,000 --> 00:06:59,000
e la lunghezza della stringa è definita

113
00:06:59,000 --> 00:07:03,000
dalla posizione che \ 0.

114
00:07:03,000 --> 00:07:09,000
In questo caso, questo è un ottimo modo per andare, perché lo stiamo modificando in posizione.

115
00:07:09,000 --> 00:07:13,000
Ma si nota che questo è in realtà sorprendentemente semplice per crittografare

116
00:07:13,000 --> 00:07:16,000
se è possibile ottenere la matematica corretta.

117
00:07:16,000 --> 00:07:19,000
Tutto ciò che è richiesto è quello di verificare se la lettera che si sta guardando

118
00:07:19,000 --> 00:07:21,000
è maiuscolo o minuscolo.

119
00:07:21,000 --> 00:07:24,000
>> La ragione per cui non ci resta che verificare la presenza di questo e non si deve controllare da

120
00:07:24,000 --> 00:07:27,000
è il caso alfa è perché

121
00:07:27,000 --> 00:07:30,000
se un personaggio è maiuscola o se è minuscolo

122
00:07:30,000 --> 00:07:33,000
allora è sicuramente un carattere alfabetico,

123
00:07:33,000 --> 00:07:38,000
perché non abbiamo cifre maiuscole e minuscole.

124
00:07:38,000 --> 00:07:41,000
L'altra cosa che facciamo, e questo è un po 'difficile,

125
00:07:41,000 --> 00:07:45,000
è che abbiamo modificato la norma cifrario di Cesare formula

126
00:07:45,000 --> 00:07:49,000
che abbiamo dato nella specifica set problema.

127
00:07:49,000 --> 00:07:52,000
Cosa c'è di diverso è che abbiamo sottratto

128
00:07:52,000 --> 00:07:58,000
nella capitale caso A maiuscola, e poi abbiamo aggiunto maiuscola

129
00:07:58,000 --> 00:08:02,000
eseguire in alla fine.

130
00:08:02,000 --> 00:08:05,000
>> So che alcuni di voi hanno fatto questo nel codice.

131
00:08:05,000 --> 00:08:09,000
Forse qualcuno di voi fare questo nelle vostre osservazioni?

132
00:08:09,000 --> 00:08:13,000
Sei stato tu. Ci può spiegare cosa fa, SAHB?

133
00:08:13,000 --> 00:08:18,000
Sottraendo fuori, perché hai fatto un mod a destra dopo,

134
00:08:18,000 --> 00:08:21,000
si deve prendere fuori, in modo che modo si ottiene [tosse] posizione.

135
00:08:21,000 --> 00:08:25,000
E poi con l'aggiunta di nuovo in seguito si spostò su quello che si voleva.

136
00:08:25,000 --> 00:08:27,000
Sì, esattamente.

137
00:08:27,000 --> 00:08:32,000
Che SAHB detto è che quando vogliamo aggiungere

138
00:08:32,000 --> 00:08:36,000
il nostro messaggio e la nostra chiave insieme

139
00:08:36,000 --> 00:08:42,000
e poi mod che, mod tale da NUM_LETTERS,

140
00:08:42,000 --> 00:08:50,000
se non si scala il nostro messaggio negli appositi 0-25 primo intervallo,

141
00:08:50,000 --> 00:08:54,000
allora potremmo finire per ottenere un numero davvero strano

142
00:08:54,000 --> 00:08:59,000
perché i valori che stiamo guardando quando guardiamo messaggio [i],

143
00:08:59,000 --> 00:09:03,000
quando si guarda il carattere i-esimo del nostro testo normale messaggio,

144
00:09:03,000 --> 00:09:08,000
è un valore compreso in questo intervallo 65-122

145
00:09:08,000 --> 00:09:13,000
in base ai valori ASCII per maiuscola attraverso z minuscola.

146
00:09:13,000 --> 00:09:18,000
E così quando la mod da 26 o da NUM_LETTERS,

147
00:09:18,000 --> 00:09:23,000
dato che era il nostro # define in alto a destra qui,

148
00:09:23,000 --> 00:09:28,000
che sta per darci un valore che è nel campo da 0 a 25,

149
00:09:28,000 --> 00:09:30,000
e abbiamo bisogno di un modo per ridimensionare allora che il backup

150
00:09:30,000 --> 00:09:32,000
e lo fanno nel range appropriato ASCII.

151
00:09:32,000 --> 00:09:36,000
Il modo più semplice per farlo è quello di scalare solo tutto giù

152
00:09:36,000 --> 00:09:39,000
nel campo da 0 a 25 per cominciare,

153
00:09:39,000 --> 00:09:43,000
e poi passare tutto torna alla fine.

154
00:09:43,000 --> 00:09:46,000
>> Un altro errore comune che ho visto la gente correre in è che

155
00:09:46,000 --> 00:09:50,000
se non effettivamente fare questo ridimensionamento subito

156
00:09:50,000 --> 00:09:53,000
e si aggiunge il messaggio e la chiave insieme e li aggiungi, ad esempio,

157
00:09:53,000 --> 00:09:58,000
in una variabile char, il problema con questo

158
00:09:58,000 --> 00:10:01,000
è dal messaggio [i] è un numero relativamente grande per cominciare-

159
00:10:01,000 --> 00:10:05,000
ricordatevi che è almeno il 65 se si tratta di un carattere maiuscolo-

160
00:10:05,000 --> 00:10:09,000
se si dispone di una grossa chiave, ad esempio, qualcosa come 100,

161
00:10:09,000 --> 00:10:13,000
e si aggiunge quei 2 insieme in un signed char che si vuole ottenere un overflow.

162
00:10:13,000 --> 00:10:17,000
Hai intenzione di ottenere un valore che è più grande di 127,

163
00:10:17,000 --> 00:10:22,000
che è il valore più grande che una variabile char può contenere.

164
00:10:22,000 --> 00:10:26,000
Anche in questo caso, è per questo che ci si vuole fare una cosa del genere per cominciare.

165
00:10:26,000 --> 00:10:29,000
Alcuni hanno intorno a quel caso per fare un if else e collaudo

166
00:10:29,000 --> 00:10:33,000
per vedere se sarebbe troppo pieno prima di farlo,

167
00:10:33,000 --> 00:10:36,000
ma in questo modo diventa intorno a quella.

168
00:10:36,000 --> 00:10:40,000
E poi in questa soluzione abbiamo stampato l'intera stringa alla fine.

169
00:10:40,000 --> 00:10:45,000
Altre persone stampato un carattere per volta. Entrambi sono impressionanti.

170
00:10:45,000 --> 00:10:51,000
A questo punto, voi ragazzi avete domande, commenti su questo?

171
00:10:51,000 --> 00:10:56,000
Cose che ti piacciono, le cose che non ti piacciono?

172
00:10:56,000 --> 00:10:58,000
>> Avevo una domanda.

173
00:10:58,000 --> 00:11:01,000
Forse ho perso durante la spiegazione, ma come fa questo programma

174
00:11:01,000 --> 00:11:07,000
saltare gli spazi per collegare la chiave per la lunghezza del testo?

175
00:11:07,000 --> 00:11:10,000
Questo è solo cifrario di Cesare. >> Oh, scusa, si '.

176
00:11:10,000 --> 00:11:13,000
Gia ', vedremo che.

177
00:11:13,000 --> 00:11:16,000
Nel cifrario di Cesare abbiamo ottenuto intorno che, a causa

178
00:11:16,000 --> 00:11:18,000
abbiamo solo girato caratteri.

179
00:11:18,000 --> 00:11:27,000
Abbiamo solo loro ruotate se fossero lettere maiuscole o minuscole.

180
00:11:27,000 --> 00:11:32,000
Voi ragazzi sentirsi abbastanza bene su questo?

181
00:11:32,000 --> 00:11:34,000
Sentitevi liberi di copiare questa casa, la prenda,

182
00:11:34,000 --> 00:11:37,000
confrontarlo con quello che voi scritto.

183
00:11:37,000 --> 00:11:42,000
Sicuramente non esitate a inviare domande su di esso troppo.

184
00:11:42,000 --> 00:11:46,000
E ancora, si rendono conto che l'obiettivo qui con il vostro problema imposta

185
00:11:46,000 --> 00:11:50,000
non è quello di ottenere voi per scrivere il codice perfetto per i vostri set di problemi.

186
00:11:50,000 --> 00:11:57,000
E 'una esperienza di apprendimento. Gia '.

187
00:11:57,000 --> 00:12:01,000
>> Torna alla do while, se è uguale a zero,

188
00:12:01,000 --> 00:12:06,000
quindi nullo significa proprio niente, hanno solo premere invio?

189
00:12:06,000 --> 00:12:12,000
Null è un valore speciale puntatore,

190
00:12:12,000 --> 00:12:17,000
e usiamo nullo quando vogliamo dire

191
00:12:17,000 --> 00:12:23,000
abbiamo una variabile puntatore che punta a nulla.

192
00:12:23,000 --> 00:12:28,000
E così di solito vuol dire che questa variabile, la variabile messaggio

193
00:12:28,000 --> 00:12:35,000
è vuota, e qui, perché stiamo usando il CS50 particolare tipo di stringa,

194
00:12:35,000 --> 00:12:37,000
qual è il tipo di stringa CS50?

195
00:12:37,000 --> 00:12:42,000
Hai visto quello che è quando David tirò indietro il cappuccio in conferenza?

196
00:12:42,000 --> 00:12:44,000
Si tratta di un funky-è un puntatore, giusto?

197
00:12:44,000 --> 00:12:48,000
Ok, si '. >> E' un char *.

198
00:12:48,000 --> 00:12:52,000
E così davvero si potrebbe sostituire questo

199
00:12:52,000 --> 00:12:56,000
proprio qui, con messaggio char *,

200
00:12:56,000 --> 00:13:04,000
e quindi la funzione GetString, se non correttamente ottenere una stringa dall'utente,

201
00:13:04,000 --> 00:13:08,000
non è possibile analizzare una stringa, e un caso in cui non si può analizzare una stringa

202
00:13:08,000 --> 00:13:11,000
è se l'utente digita il carattere di fine file, il controllo D,

203
00:13:11,000 --> 00:13:17,000
che non è qualcosa che di solito fare, ma se ciò accade

204
00:13:17,000 --> 00:13:20,000
allora la funzione restituisce il valore null come un modo di dire

205
00:13:20,000 --> 00:13:23,000
"Ehi, non ho avuto una stringa."

206
00:13:23,000 --> 00:13:27,000
Che cosa accadrebbe se non mettiamo messaggio = null,

207
00:13:27,000 --> 00:13:30,000
che è qualcosa che non abbiamo fatto ancora?

208
00:13:30,000 --> 00:13:32,000
Perchè dovrebbe essere un problema?

209
00:13:32,000 --> 00:13:38,000
Perché so che abbiamo parlato un po 'in conferenza sulle perdite di memoria.

210
00:13:38,000 --> 00:13:42,000
Si ', facciamolo, e vediamo cosa succede.

211
00:13:42,000 --> 00:13:44,000
>> Domanda Basilio era cosa succede se in realtà non hanno

212
00:13:44,000 --> 00:13:48,000
questo messaggio di prova = null?

213
00:13:48,000 --> 00:13:51,000
Facciamo scorrere fino alla cima.

214
00:13:51,000 --> 00:13:53,000
Voi ragazzi potete commentare questo fuori.

215
00:13:53,000 --> 00:13:55,000
A dire il vero, io lo salvo in una revisione.

216
00:13:55,000 --> 00:13:58,000
Questo sarà revisione 3.

217
00:13:58,000 --> 00:14:02,000
Quello che dovrete fare per eseguire questo programma è che dovrete fare clic su questa icona ingranaggio qui,

218
00:14:02,000 --> 00:14:04,000
e si dovrà aggiungere un argomento ad esso.

219
00:14:04,000 --> 00:14:10,000
Dovrete dare l'argomento chiave dal momento che desidera passare un argomento della riga di comando.

220
00:14:10,000 --> 00:14:13,000
Qui ho intenzione di dare il numero 3. Mi piace 3.

221
00:14:13,000 --> 00:14:19,000
Ora lo zoom indietro, l'esecuzione del programma.

222
00:14:19,000 --> 00:14:24,000
E 'in esecuzione, la compilazione, la costruzione.

223
00:14:24,000 --> 00:14:27,000
Ci siamo. E 'in attesa di essere richiesto.

224
00:14:27,000 --> 00:14:33,000
Se digito qualcosa come ciao, dove e 'andata?

225
00:14:33,000 --> 00:14:38,000
Oh, il mio programma ha impiegato troppo tempo per l'esecuzione. Ero jawing per troppo tempo.

226
00:14:38,000 --> 00:14:40,000
Qui si va.

227
00:14:40,000 --> 00:14:43,000
Ora digitare ciao.

228
00:14:43,000 --> 00:14:46,000
Vediamo che esegue la crittografia in modo appropriato.

229
00:14:46,000 --> 00:14:52,000
Ora, cosa succede se facciamo GetString richiesta di restituire null?

230
00:14:52,000 --> 00:14:57,000
Ricordate, ho detto che abbiamo fatto che premendo il controllo D, allo stesso tempo.

231
00:14:57,000 --> 00:14:59,000
Io scorrere verso l'alto qui. Ci funzionare ancora.

232
00:14:59,000 --> 00:15:01,000
Edificio. Ci va.

233
00:15:01,000 --> 00:15:04,000
Ora, quando ho colpito il controllo D

234
00:15:04,000 --> 00:15:12,000
Ho ottenuto questa linea che dice opt/sandbox50/bin/run.sh, Segmentation fault.

235
00:15:12,000 --> 00:15:15,000
Avete visto prima?

236
00:15:15,000 --> 00:15:17,000
>> [Studente] Perché non c'è nessuno >> Scusa?

237
00:15:17,000 --> 00:15:20,000
[Studente] Perché non c'è nessuna core dump in questo caso?

238
00:15:20,000 --> 00:15:26,000
Il core dump è la domanda è:-perché non c'è core dump qui?

239
00:15:26,000 --> 00:15:29,000
Il problema è che ci possono essere, ma il core dump è un file

240
00:15:29,000 --> 00:15:31,000
che viene memorizzato sul disco rigido.

241
00:15:31,000 --> 00:15:34,000
In questo caso abbiamo disattivato i core dump

242
00:15:34,000 --> 00:15:37,000
sul server di esecuzione in modo che non ci sono persone che ha provocato l'errore seg

243
00:15:37,000 --> 00:15:40,000
e costruire tonnellate di core dump.

244
00:15:40,000 --> 00:15:46,000
Ma si può ottenere uno.

245
00:15:46,000 --> 00:15:48,000
I core dump sono il genere di cose che spesso è possibile disabilitare,

246
00:15:48,000 --> 00:15:52,000
e qualche volta si fa.

247
00:15:52,000 --> 00:15:55,000
L'errore di segmentazione, per rispondere alla tua domanda, Basilico,

248
00:15:55,000 --> 00:16:00,000
sta dicendo che abbiamo cercato di accedere a un puntatore

249
00:16:00,000 --> 00:16:05,000
che non è stato impostato per puntare a qualcosa.

250
00:16:05,000 --> 00:16:09,000
Ricorda Binky nel video, quando cerca di Binky

251
00:16:09,000 --> 00:16:12,000
vai accedere a un puntatore che non sta puntando a qualcosa?

252
00:16:12,000 --> 00:16:16,000
In questo caso credo che tecnicamente il puntatore punta a qualcosa.

253
00:16:16,000 --> 00:16:20,000
Si punta a nulla, che è tecnicamente 0,

254
00:16:20,000 --> 00:16:25,000
ma che è definito per essere in un segmento che non è accessibile

255
00:16:25,000 --> 00:16:28,000
dal programma, in modo da ottenere un errore di segmentazione

256
00:16:28,000 --> 00:16:31,000
perché non stai accedendo alla memoria che è in un segmento valido

257
00:16:31,000 --> 00:16:38,000
come il segmento cumulo o segmento di stack o il segmento di dati.

258
00:16:38,000 --> 00:16:40,000
Cool.

259
00:16:40,000 --> 00:16:48,000
Altre domande su Cesare?

260
00:16:48,000 --> 00:16:51,000
>> Andiamo avanti. Diamo un'occhiata a revisione 2 molto velocemente.

261
00:16:51,000 --> 00:17:00,000
Questo è Vigenère.

262
00:17:00,000 --> 00:17:04,000
Qui in Vigenère

263
00:17:04,000 --> 00:17:06,000
faremo a piedi attraverso questo abbastanza in fretta perché, ancora una volta,

264
00:17:06,000 --> 00:17:10,000
Vigenère e Cesare sono molto simili.

265
00:17:10,000 --> 00:17:12,000
Commento Header è prima,

266
00:17:12,000 --> 00:17:17,000
# Define è prima di evitare l'uso di questi numeri magici.

267
00:17:17,000 --> 00:17:21,000
La cosa bella è dire che volevamo passare a

268
00:17:21,000 --> 00:17:23,000
un alfabeto diverso o qualcosa di simile.

269
00:17:23,000 --> 00:17:26,000
Anziché dover modificare manualmente tutti i 26 nel codice

270
00:17:26,000 --> 00:17:30,000
si potrebbe cambiare questo a 27 o cadere verso il basso

271
00:17:30,000 --> 00:17:34,000
se stessimo utilizzando alfabeti diversi, lingue diverse.

272
00:17:34,000 --> 00:17:38,000
Ancora una volta, abbiamo questo controllo del numero di argomenti,

273
00:17:38,000 --> 00:17:42,000
e davvero si può quasi prendere questo come un modello.

274
00:17:42,000 --> 00:17:46,000
Praticamente tutti i programmi che scrivi dovrebbe avere-

275
00:17:46,000 --> 00:17:50,000
se ci vogliono gli argomenti della riga di comando-una sequenza di linee

276
00:17:50,000 --> 00:17:55,000
che si legge come questo all'inizio.

277
00:17:55,000 --> 00:17:59,000
Questo è uno dei test di integrità prima che si desidera fare.

278
00:17:59,000 --> 00:18:03,000
>> Ecco quello che abbiamo fatto è stato che abbiamo fatto in modo che

279
00:18:03,000 --> 00:18:06,000
la parola chiave è valida, e che è stato il secondo controllo che abbiamo fatto.

280
00:18:06,000 --> 00:18:11,000
Si noti ancora una volta che ci siamo separati da questo argc e 2.

281
00:18:11,000 --> 00:18:14,000
Si noti che in questo caso una cosa che abbiamo dovuto fare è stato invece

282
00:18:14,000 --> 00:18:18,000
di utilizzare una per i abbiamo voluto convalidare l'intera stringa,

283
00:18:18,000 --> 00:18:21,000
e per fare che in realtà andare carattere per carattere

284
00:18:21,000 --> 00:18:23,000
sopra la corda.

285
00:18:23,000 --> 00:18:29,000
Non c'è buon modo per chiamare qualcosa su di esso

286
00:18:29,000 --> 00:18:31,000
perché anche, per esempio, da A a I restituirà 0

287
00:18:31,000 --> 00:18:37,000
se non in grado di analizzare un numero intero, in modo che non funziona nemmeno.

288
00:18:37,000 --> 00:18:42,000
Anche in questo caso, bel messaggio che dice all'utente esattamente quello che è successo.

289
00:18:42,000 --> 00:18:45,000
Poi qui, ancora una volta, abbiamo anche gestire il caso in cui

290
00:18:45,000 --> 00:18:50,000
l'utente digita in un carattere di controllo D casuale.

291
00:18:50,000 --> 00:18:54,000
>> E poi Charlotte aveva una domanda in precedenza su come riusciamo a saltare gli spazi

292
00:18:54,000 --> 00:18:57,000
nella nostra stringa qui.

293
00:18:57,000 --> 00:19:00,000
Questo era un po 'simile a quello che abbiamo fatto con il programma di Myspace

294
00:19:00,000 --> 00:19:04,000
che abbiamo fatto in sezione, e il modo in cui questo ha funzionato

295
00:19:04,000 --> 00:19:08,000
è che abbiamo rintracciato il numero di lettere che avevamo visto.

296
00:19:08,000 --> 00:19:13,000
Mentre camminavamo sulla stringa del messaggio, come abbiamo attraversato carattere per carattere,

297
00:19:13,000 --> 00:19:16,000
abbiamo seguito l'indice come parte del nostro ciclo for, e poi abbiamo anche rintracciato

298
00:19:16,000 --> 00:19:21,000
il numero di lettere, in modo da non caratteri speciali, non-cifre, non bianco spazio

299
00:19:21,000 --> 00:19:27,000
che avevamo visto nella variabile separata.

300
00:19:27,000 --> 00:19:33,000
E poi questa soluzione modifica la chiave

301
00:19:33,000 --> 00:19:41,000
per ottenere un numero intero effettivo della chiave, e lo fa al volo,

302
00:19:41,000 --> 00:19:47,000
destra prima che vada poi per crittografare il carattere effettivo del messaggio.

303
00:19:47,000 --> 00:19:50,000
Ci sono alcune soluzioni che erano perfettamente troppo grande

304
00:19:50,000 --> 00:19:58,000
che modificare la chiave quando il test per la validità della chiave.

305
00:19:58,000 --> 00:20:01,000
Oltre a fare in modo che il carattere e la parola chiave

306
00:20:01,000 --> 00:20:05,000
è stato un carattere alfabetico che è anche trasformato in un numero intero

307
00:20:05,000 --> 00:20:13,000
nel campo da 0 a 25 a saltare poi dover fare avanti in questo ciclo for.

308
00:20:13,000 --> 00:20:18,000
Anche in questo caso, che vedete qui questo è davvero il codice esattamente lo stesso

309
00:20:18,000 --> 00:20:22,000
che abbiamo usato in Cesare, a questo punto.

310
00:20:22,000 --> 00:20:25,000
Stai facendo la stessa cosa, in modo che il vero trucco è capire

311
00:20:25,000 --> 00:20:30,000
come trasformare la parola chiave in un numero intero.

312
00:20:30,000 --> 00:20:35,000
>> Una cosa che abbiamo fatto qui che è un po 'denso

313
00:20:35,000 --> 00:20:39,000
è abbiamo ripetuto questa frase, penso che si potrebbe chiamare,

314
00:20:39,000 --> 00:20:45,000
3 volte separate linee 58, 59, e 61.

315
00:20:45,000 --> 00:20:52,000
Qualcuno può spiegare che cosa è esattamente questa frase fa?

316
00:20:52,000 --> 00:20:55,000
E 'l'accesso a un personaggio, come hai detto tu.

317
00:20:55,000 --> 00:20:59,000
Si ', e' [incomprensibile] un personaggio la parola chiave,

318
00:20:59,000 --> 00:21:04,000
e quindi è il numero di lettere visto perché si sta solo muovendo

319
00:21:04,000 --> 00:21:06,000
la parola chiave una volta che hai visto la lettera,

320
00:21:06,000 --> 00:21:10,000
modo che sta per saltare in modo efficace gli spazi e cose del genere.

321
00:21:10,000 --> 00:21:12,000
Sì, esattamente.

322
00:21:12,000 --> 00:21:16,000
E poi una volta che hai visto la vuota parola chiave che avete appena mod in modo da tornare indietro in giro.

323
00:21:16,000 --> 00:21:18,000
Esattamente. Questa è una spiegazione perfetta.

324
00:21:18,000 --> 00:21:23,000
Che cosa ha detto Kevin è che vogliamo per indicizzare la parola chiave.

325
00:21:23,000 --> 00:21:28,000
Vogliamo ottenere il carattere num_letters_seen, se si vuole,

326
00:21:28,000 --> 00:21:32,000
ma se num_letters_seen supera la lunghezza della parola chiave,

327
00:21:32,000 --> 00:21:37,000
il nostro modo di tornare in campo appropriato è usiamo l'operatore mod

328
00:21:37,000 --> 00:21:40,000
per avvolgere in modo efficace in giro.

329
00:21:40,000 --> 00:21:43,000
Ad esempio, come nel breve, la nostra parola chiave è pancetta,

330
00:21:43,000 --> 00:21:46,000
ed è lunga 5 lettere.

331
00:21:46,000 --> 00:21:50,000
Ma abbiamo visto 6 lettere nel nostro testo in chiaro, a questo punto

332
00:21:50,000 --> 00:21:52,000
e criptato 6.

333
00:21:52,000 --> 00:21:57,000
Si finirà per l'accesso alla num_letters_seen,

334
00:21:57,000 --> 00:22:00,000
che è 6, mod la lunghezza della parola chiave, 5,

335
00:22:00,000 --> 00:22:04,000
e così avremo 1, e così quello che faremo è faremo

336
00:22:04,000 --> 00:22:14,000
accedere all'interno del primo carattere della nostra parola chiave in quel punto.

337
00:22:14,000 --> 00:22:21,000
>> Va bene, tutte le questioni sui Vigenère

338
00:22:21,000 --> 00:22:26,000
prima di andare avanti?

339
00:22:26,000 --> 00:22:31,000
Voi ragazzi sentirsi abbastanza bene su questo?

340
00:22:31,000 --> 00:22:35,000
Cool, grande.

341
00:22:35,000 --> 00:22:38,000
Voglio fare in modo che voi ragazzi sono sempre la possibilità di vedere il codice

342
00:22:38,000 --> 00:22:48,000
che noi pensiamo sembra buono e hanno la possibilità di imparare da esso.

343
00:22:48,000 --> 00:22:53,000
Questo sarà l'ultimo che useremo gli spazi per il momento,

344
00:22:53,000 --> 00:22:59,000
e abbiamo intenzione di transizione adesso, e ho intenzione di andare a cs50.net/lectures

345
00:22:59,000 --> 00:23:06,000
in modo che possiamo fare un po 'di revisione quiz.

346
00:23:06,000 --> 00:23:10,000
Il modo migliore penso di iniziare a fare quiz recensione

347
00:23:10,000 --> 00:23:15,000
è quello di venire in questa pagina Lectures, cs50.net/lectures,

348
00:23:15,000 --> 00:23:20,000
e sotto ciascuna delle rubriche settimana, quindi se guardo qui alla settimana 0,

349
00:23:20,000 --> 00:23:27,000
Vedo che abbiamo un elenco di argomenti che abbiamo trattato nella Settimana 0.

350
00:23:27,000 --> 00:23:31,000
>> Se uno qualsiasi di questi argomenti sembra sconosciuto a voi

351
00:23:31,000 --> 00:23:34,000
avrete sicuramente voglia di tornare indietro e setacciare gli appunti delle lezioni e, eventualmente,

352
00:23:34,000 --> 00:23:39,000
anche sfogliare le lezioni, li guarda ancora una volta, se si desidera

353
00:23:39,000 --> 00:23:44,000
per avere un'idea di quello che sta succedendo con ciascuno di questi argomenti.

354
00:23:44,000 --> 00:23:49,000
Devo dire inoltre questo un anno di risorse fresche che abbiamo ottenuto

355
00:23:49,000 --> 00:23:55,000
Sono questi i pantaloncini che abbiamo creato, e se si guarda alla settimana 0,

356
00:23:55,000 --> 00:24:00,000
non abbiamo tutti gli argomenti trattati, ma abbiamo un bel po 'di loro,

357
00:24:00,000 --> 00:24:03,000
alcuni di quelli più ingannevoli, così guardando questi pantaloncini nuovo

358
00:24:03,000 --> 00:24:08,000
è un buon modo per arrivare fino a velocità.

359
00:24:08,000 --> 00:24:15,000
In particolare, ho intenzione di mettere in una presa per il 3 sul fondo, da quando ho fatto quelle.

360
00:24:15,000 --> 00:24:20,000
Ma se siete alle prese con binario, bit, esagonali, quel genere di cose,

361
00:24:20,000 --> 00:24:22,000
binario è un ottimo punto di partenza.

362
00:24:22,000 --> 00:24:25,000
ASCII è un altro questo è un bene per vedere troppo.

363
00:24:25,000 --> 00:24:31,000
È anche possibile guardare me a velocità 1,5 x se sto andando troppo lento per voi.

364
00:24:31,000 --> 00:24:35,000
Dal momento che è recensione, non esitate a farlo.

365
00:24:35,000 --> 00:24:40,000
>> Tanto per iniziare molto velocemente, stiamo per passare attraverso un paio di questi problemi quiz

366
00:24:40,000 --> 00:24:44,000
solo per sfornare velocemente attraverso questi.

367
00:24:44,000 --> 00:24:50,000
Per esempio, diamo un'occhiata a un problema 16 che ho proprio qui sul tavolo.

368
00:24:50,000 --> 00:24:54,000
Abbiamo questa seguente calcolo in binario,

369
00:24:54,000 --> 00:24:56,000
e vogliamo mostrare qualsiasi lavoro.

370
00:24:56,000 --> 00:24:59,000
Va bene, ho intenzione di dare a questo un colpo.

371
00:24:59,000 --> 00:25:01,000
Voi ragazzi dovrebbero seguire con la carta,

372
00:25:01,000 --> 00:25:04,000
e lo faremo molto velocemente.

373
00:25:04,000 --> 00:25:06,000
Vogliamo eseguire il seguente calcolo in binario.

374
00:25:06,000 --> 00:25:16,000
Ho 00110010.

375
00:25:16,000 --> 00:25:27,000
E ho intenzione di aggiungere ad essa 00110010.

376
00:25:27,000 --> 00:25:30,000
Per la matematica geni segue lungo a casa,

377
00:25:30,000 --> 00:25:35,000
questo è effettivamente moltiplicare per 2.

378
00:25:35,000 --> 00:25:37,000
Cominciamo.

379
00:25:37,000 --> 00:25:39,000
Stiamo per seguire lo stesso algoritmo inoltre che facciamo

380
00:25:39,000 --> 00:25:43,000
quando aggiungiamo i numeri decimali insieme.

381
00:25:43,000 --> 00:25:46,000
In realtà l'unica differenza è che noi loop back intorno

382
00:25:46,000 --> 00:25:51,000
una volta che abbiamo 1 + 1 invece di una volta si arriva a 10.

383
00:25:51,000 --> 00:25:53,000
>> Se si parte da destra, molto rapidamente, qual è la prima cifra?

384
00:25:53,000 --> 00:25:55,000
[Studente] 0. >> [Nate H] 0.

385
00:25:55,000 --> 00:25:58,000
Grande, la seconda cifra?

386
00:25:58,000 --> 00:26:00,000
[Studente] 1.

387
00:26:00,000 --> 00:26:02,000
[Nate H] E 'un 1? 1 + 1 è?

388
00:26:02,000 --> 00:26:04,000
[Studente] 10.

389
00:26:04,000 --> 00:26:08,000
[Nate H.] Esattamente, quindi qual è la cifra che scrivo proprio sotto le 2 quelli aggiunti insieme?

390
00:26:08,000 --> 00:26:11,000
[Studente] 1, 0, o 0 e poi portare la 1.

391
00:26:11,000 --> 00:26:15,000
[Nate H] 0 e portare a 1, esattamente.

392
00:26:15,000 --> 00:26:18,000
Next up uno, Basil, tocca a te.

393
00:26:18,000 --> 00:26:20,000
Qual è il terzo? >> [Basilio] 1.

394
00:26:20,000 --> 00:26:23,000
[Nate H.] 1, perfetto. Kevin?

395
00:26:23,000 --> 00:26:27,000
[Kevin] 0. >> [Nate H] 0, Charlotte?

396
00:26:27,000 --> 00:26:30,000
[Charlotte] 0. >> [Nate H] Si ', e cosa devo fare?

397
00:26:30,000 --> 00:26:32,000
[Studente] Il 1.

398
00:26:32,000 --> 00:26:34,000
[Nate H] E cosa devo fare? E poi portare la 1.

399
00:26:34,000 --> 00:26:36,000
Perfetto, SAHB? >> [SAHB] Ora avete 1.

400
00:26:36,000 --> 00:26:40,000
[Nate H] E devo fare qualcosa qui?

401
00:26:40,000 --> 00:26:43,000
[SAHB] Allora per il prossimo si dispone di 1 perché riportati 1.

402
00:26:43,000 --> 00:26:49,000
[Nate H.] Grande, ecco che possiamo finire.

403
00:26:49,000 --> 00:26:51,000
Cool.

404
00:26:51,000 --> 00:26:54,000
[Studente] Fa 0 + 0 = 0?

405
00:26:54,000 --> 00:26:56,000
0 + 0 = 0.

406
00:26:56,000 --> 00:27:01,000
1 + 1, come hai detto tu, è di 10, o 1, 0, piuttosto.

407
00:27:01,000 --> 00:27:07,000
10 è un termine improprio, perché per me 10 significa il numero 10,

408
00:27:07,000 --> 00:27:12,000
ed è il capriccio di come lo stiamo rappresentando quando stiamo scrivendo.

409
00:27:12,000 --> 00:27:20,000
Abbiamo rappresentano il numero 2 di 1, 0, e il numero 10 è leggermente diverso.

410
00:27:20,000 --> 00:27:23,000
>> Che tipo di bello di binario è che in realtà non sono che molti

411
00:27:23,000 --> 00:27:25,000
casi che dovete imparare.

412
00:27:25,000 --> 00:27:30,000
Ci sono 0 + 0 = 0, 0 + 1 = 1,

413
00:27:30,000 --> 00:27:34,000
1 + 1 è 0, e poi portare a 1,

414
00:27:34,000 --> 00:27:37,000
e poi si può vedere qui sulla terza colonna da destra

415
00:27:37,000 --> 00:27:40,000
abbiamo avuto questa 1, 1, e 1.

416
00:27:40,000 --> 00:27:43,000
E 1 + 1 + 1 è un 1,

417
00:27:43,000 --> 00:27:45,000
e di portare un altro 1.

418
00:27:45,000 --> 00:27:48,000
Quando si sta facendo somma binaria, piuttosto semplice.

419
00:27:48,000 --> 00:27:51,000
Mi piacerebbe fare un altro paio di questi per voi stessi verificare sanità mentale

420
00:27:51,000 --> 00:27:54,000
prima di andare in, perché questo è

421
00:27:54,000 --> 00:28:00,000
probabilmente qualcosa che vedremo sul quiz.

422
00:28:00,000 --> 00:28:03,000
Ora facciamo questo anche il prossimo.

423
00:28:03,000 --> 00:28:06,000
Facciamo problema 17.

424
00:28:06,000 --> 00:28:12,000
Abbiamo intenzione di convertire il numero binario in decimale.

425
00:28:12,000 --> 00:28:28,000
Ho 10100111001.

426
00:28:28,000 --> 00:28:33,000
Ricordate nel video binario che ho fatto

427
00:28:33,000 --> 00:28:36,000
Ho camminato attraverso un paio di esempi, e mi ha fatto vedere come

428
00:28:36,000 --> 00:28:41,000
tutto funziona quando si sta facendo in decimale.

429
00:28:41,000 --> 00:28:45,000
Quando si lavora in rappresentazione decimale penso che siamo

430
00:28:45,000 --> 00:28:48,000
a questo punto della nostra vita in modo fluente in esso che

431
00:28:48,000 --> 00:28:53,000
è abbastanza facile a sorvolare il meccanismo di come funziona realmente.

432
00:28:53,000 --> 00:28:59,000
>> Ma per fare un breve riepilogo, se ho il numero 137

433
00:28:59,000 --> 00:29:06,000
questo significa-e davvero di nuovo, questo è in rappresentazione decimale-

434
00:29:06,000 --> 00:29:19,000
il numero 137 in decimale significa che ho 1 x 100 + 3 x 10 + 7 x 1.

435
00:29:19,000 --> 00:29:22,000
Questo è tutto rimanendo sullo schermo.

436
00:29:22,000 --> 00:29:29,000
E poi se si guarda a questi numeri proprio qui,

437
00:29:29,000 --> 00:29:34,000
100, 10 e 1, si vede che sono in realtà tutte le potenze di 10.

438
00:29:34,000 --> 00:29:43,000
Ho 10 ², 10 ¹, e 10 al punto zero.

439
00:29:43,000 --> 00:29:48,000
Abbiamo una sorta di cosa simile in binario,

440
00:29:48,000 --> 00:29:55,000
eccezione del fatto che la nostra base, come lo chiamiamo noi, è di 2 invece di 10.

441
00:29:55,000 --> 00:29:58,000
Questi 10s che ho scritto qui in basso,

442
00:29:58,000 --> 00:30:02,000
questo 10 ², 10 ¹, 10 allo zero, il 10 è la nostra base,

443
00:30:02,000 --> 00:30:08,000
e l'esponente, 0, 1, o 2,

444
00:30:08,000 --> 00:30:14,000
è implicito nella posizione della cifra del numero che scrivere.

445
00:30:14,000 --> 00:30:21,000
1, se lo guardiamo, questo 1 è in 2 ° posizione.

446
00:30:21,000 --> 00:30:27,000
Il 3 è in posizione di prima, e il 7 è nella posizione di indice 0.

447
00:30:27,000 --> 00:30:35,000
È così che si ottengono i vari esponenti di seguito per le nostre basi.

448
00:30:35,000 --> 00:30:40,000
>> A seguito di tutto questo venite-in realtà, sai una cosa?

449
00:30:40,000 --> 00:30:43,000
Faremo, dove ha fatto il mio pulsante Annulla andare?

450
00:30:43,000 --> 00:30:45,000
Ci va.

451
00:30:45,000 --> 00:30:47,000
Amo questo annulla cosa.

452
00:30:47,000 --> 00:30:51,000
A seguito di questo credo che per me almeno

453
00:30:51,000 --> 00:30:54,000
il modo più semplice per avviare la conversione di un numero binario

454
00:30:54,000 --> 00:30:57,000
o un numero esadecimale in cui la base è 16

455
00:30:57,000 --> 00:31:02,000
e non 10 o 2 è di andare avanti e scrivere

456
00:31:02,000 --> 00:31:09,000
le basi e gli esponenti di tutti i numeri nel mio numero binario in alto.

457
00:31:09,000 --> 00:31:14,000
Se si parte da sinistra a destra di nuovo,

458
00:31:14,000 --> 00:31:17,000
che è una specie di contro-intuitivo,

459
00:31:17,000 --> 00:31:23,000
Io tornare in nero qui, abbiamo il 2 alla posizione 0,

460
00:31:23,000 --> 00:31:27,000
e poi abbiamo 2 ¹, 2 ²,

461
00:31:27,000 --> 00:31:33,000
e poi 2 alla 3, 2 alla 4, 2 alla 5, 6,

462
00:31:33,000 --> 00:31:39,000
7, 8, 9, e 10.

463
00:31:39,000 --> 00:31:41,000
Questi numeri che ho scritto su tutti gli esponenti.

464
00:31:41,000 --> 00:31:48,000
Ho solo scritto le basi qui in primi 3 solo per lo spazio.

465
00:31:48,000 --> 00:31:50,000
>> A questo punto ho intenzione di andare avanti e sto andando a cancellare

466
00:31:50,000 --> 00:31:53,000
le cose che abbiamo fatto in decimale, se va bene.

467
00:31:53,000 --> 00:31:57,000
Hai capito tutto.

468
00:31:57,000 --> 00:32:05,000
Quelli di voi la visione di Sono sicuro che sarà in grado di riavvolgere me se vuoi.

469
00:32:05,000 --> 00:32:07,000
Ritornando alla penna.

470
00:32:07,000 --> 00:32:12,000
Ora, ciò che possiamo fare, se voi ragazzi non sono del tutto fino a velocità sulle potenze di 2,

471
00:32:12,000 --> 00:32:15,000
che è assolutamente cool.

472
00:32:15,000 --> 00:32:18,000
Succede. Capisco.

473
00:32:18,000 --> 00:32:23,000
Una volta ho avuto un colloquio di lavoro in cui mi è stato detto che dovrei conoscere tutte potenze di 2

474
00:32:23,000 --> 00:32:26,000
fino a 2 per il 30.

475
00:32:26,000 --> 00:32:29,000
Non è stato un lavoro che ho ottenuto.

476
00:32:29,000 --> 00:32:32,000
Ad ogni modo, voi potete andare avanti e fare la matematica qui,

477
00:32:32,000 --> 00:32:35,000
ma con binario in realtà non ha senso,

478
00:32:35,000 --> 00:32:38,000
e non ha senso con decimale o esadecimale o,

479
00:32:38,000 --> 00:32:43,000
per fare i calcoli su cui si dispone zeri.

480
00:32:43,000 --> 00:32:49,000
Potete vedere che ho 0 per questo, qui a 0, 0 qui, 0 qui, 0 qui, 0 qui.

481
00:32:49,000 --> 00:32:52,000
Perché non potrebbe avere senso fare i calcoli reale

482
00:32:52,000 --> 00:32:56,000
per calcolare la potenza appropriata di 2 per quella posizione?

483
00:32:56,000 --> 00:32:59,000
Esattamente, come Charlotte ha detto, sarà 0.

484
00:32:59,000 --> 00:33:05,000
Tanto vale risparmiare il tempo se il calcolo potenze di 2 non è il tuo forte.

485
00:33:05,000 --> 00:33:10,000
In questo caso abbiamo solo bisogno di calcolarlo per 2 a 0 che è-?

486
00:33:10,000 --> 00:33:12,000
[Studente] 1.

487
00:33:12,000 --> 00:33:14,000
[Nate H.] 1, 2 alla 3 che è-?

488
00:33:14,000 --> 00:33:16,000
[Studente] 8. >> [Nate H] 8.

489
00:33:16,000 --> 00:33:18,000
2 alla 4?

490
00:33:18,000 --> 00:33:21,000
[Studente] 2. Mi dispiace, 1.

491
00:33:21,000 --> 00:33:26,000
[Nate H] 2 ​​al 4 è 16, esattamente.

492
00:33:26,000 --> 00:33:28,000
2 alla 5, Kevin? >> 32.

493
00:33:28,000 --> 00:33:32,000
[Nate H.] 32, 2 alla 8?

494
00:33:32,000 --> 00:33:38,000
[Studente] 32 x 8, 256.

495
00:33:38,000 --> 00:33:41,000
[Nate H] Perfetto.

496
00:33:41,000 --> 00:33:43,000
E 2 al 10?

497
00:33:43,000 --> 00:33:45,000
[Studente] 1024.

498
00:33:45,000 --> 00:33:49,000
[Nate H.] Si ', 1024.

499
00:33:49,000 --> 00:33:57,000
>> Una volta che abbiamo questi numeri si possono sintetizzare tutti in su.

500
00:33:57,000 --> 00:34:01,000
Ed è qui che è davvero importante per fare un paio di cose.

501
00:34:01,000 --> 00:34:07,000
Uno è andare piano e controllare il vostro lavoro.

502
00:34:07,000 --> 00:34:10,000
Si può dire che c'è un 1 alla fine di questo numero,

503
00:34:10,000 --> 00:34:15,000
quindi dovrei sicuramente ottenere un numero dispari come il mio risultato,

504
00:34:15,000 --> 00:34:18,000
perché tutti gli altri stanno per essere numeri pari

505
00:34:18,000 --> 00:34:21,000
dato che si tratta di un numero binario.

506
00:34:21,000 --> 00:34:24,000
L'altra cosa da fare è se si arriva a questo punto della prova

507
00:34:24,000 --> 00:34:27,000
e tu l'hai scritto fino a questo punto

508
00:34:27,000 --> 00:34:30,000
e sei a corto di tempo

509
00:34:30,000 --> 00:34:33,000
guardare il numero di punti che questo problema vale.

510
00:34:33,000 --> 00:34:40,000
Questo problema, come potete vedere, se mi capovolgere di nuovo al mio computer portatile molto velocemente-

511
00:34:40,000 --> 00:34:44,000
questo problema vale 2 punti, quindi questo non è il tipo di aggiunta

512
00:34:44,000 --> 00:34:47,000
si dovrebbe passare attraverso se siete veramente a corto di tempo.

513
00:34:47,000 --> 00:34:52,000
Ma noi tornare alla iPad, e andremo attraverso di essa molto velocemente.

514
00:34:52,000 --> 00:34:54,000
>> Mi piace fare i numeri prima i più piccoli

515
00:34:54,000 --> 00:34:56,000
perché trovo che facile.

516
00:34:56,000 --> 00:35:00,000
Mi piace 32 e 8, in quanto vanno insieme abbastanza facilmente, e si ottiene 50.

517
00:35:00,000 --> 00:35:03,000
16 e 1 diventa 17.

518
00:35:03,000 --> 00:35:05,000
Ci si ottiene 57,

519
00:35:05,000 --> 00:35:14,000
e poi possiamo fare il resto di questo, in modo che possiamo fare 57, 156.

520
00:35:14,000 --> 00:35:16,000
Andiamo.

521
00:35:16,000 --> 00:35:19,000
L'uomo, beh, vediamo.

522
00:35:19,000 --> 00:35:27,000
Abbiamo avuto l '57, 256, e 1024.

523
00:35:27,000 --> 00:35:31,000
A questo punto, preferisco solo passare attraverso.

524
00:35:31,000 --> 00:35:35,000
Non ho nessuna idea. Ho chiaramente bisogno di leggere su questo.

525
00:35:35,000 --> 00:35:40,000
7, 6, e 4, si ottiene 17.

526
00:35:40,000 --> 00:35:42,000
1, 5, 5, 2, 13.

527
00:35:42,000 --> 00:35:45,000
Allora otteniamo 3, quindi si ottiene 1.

528
00:35:45,000 --> 00:35:52,000
1337.

529
00:35:52,000 --> 00:35:55,000
Uovo di Pasqua, nessuno?

530
00:35:55,000 --> 00:35:59,000
Chiunque riconosce questo numero?

531
00:35:59,000 --> 00:36:02,000
Chris riconosce il numero. Che cosa significa, Chris?

532
00:36:02,000 --> 00:36:04,000
[Chris] Leet.

533
00:36:04,000 --> 00:36:11,000
Leet, quindi se si guarda a questo, sembra che leet.

534
00:36:11,000 --> 00:36:15,000
Hacker roba. Attenzione per questo genere di cose sul medio termine o il quiz, piuttosto.

535
00:36:15,000 --> 00:36:19,000
Se vedi che tipo di roba e ti stai chiedendo "Eh,"

536
00:36:19,000 --> 00:36:22,000
che potrebbe effettivamente significare qualcosa.

537
00:36:22,000 --> 00:36:24,000
Non lo so. David ama mettendo trovi

538
00:36:24,000 --> 00:36:26,000
E 'un buon modo per verificarlo sanità mentale.

539
00:36:26,000 --> 00:36:30,000
Come va bene, riesco a vedere cosa sta succedendo.

540
00:36:30,000 --> 00:36:34,000
>> E 'Settimana 0/Week 1 roba.

541
00:36:34,000 --> 00:36:39,000
Se si passa di nuovo al nostro computer portatile ora,

542
00:36:39,000 --> 00:36:46,000
zoom out, e un paio di altre cose.

543
00:36:46,000 --> 00:36:50,000
Ci sono ASCII, che abbiamo fatto un sacco di problemi con il set.

544
00:36:50,000 --> 00:36:55,000
Questa nozione di capitale A. Che cosa è davvero?

545
00:36:55,000 --> 00:36:57,000
Sapendo che è il numero intero decimale.

546
00:36:57,000 --> 00:37:00,000
65 è quello che è mappato nella tabella ASCII,

547
00:37:00,000 --> 00:37:03,000
ed è, quindi, come il computer scrive,

548
00:37:03,000 --> 00:37:06,000
ed è così che abbiamo ricevuto via nella scrittura

549
00:37:06,000 --> 00:37:09,000
la capitale carattere A e il carattere minuscolo una

550
00:37:09,000 --> 00:37:14,000
in alcune di queste soluzioni e set di problemi che hai fatto.

551
00:37:14,000 --> 00:37:16,000
Un paio di altre cose.

552
00:37:16,000 --> 00:37:25,000
Abbiamo istruzioni, le espressioni booleane, condizioni, cicli, variabili e fili.

553
00:37:25,000 --> 00:37:29,000
>> Quelli che tutti sembrano avere un senso per la maggior parte?

554
00:37:29,000 --> 00:37:35,000
Alcune di questa terminologia è un po 'funky, a volte.

555
00:37:35,000 --> 00:37:46,000
Mi piace pensare di una dichiarazione come per la maggior parte qualcosa che termina con un punto e virgola.

556
00:37:46,000 --> 00:37:51,000
Affermazioni come x = 7, che definisce una variabile,

557
00:37:51,000 --> 00:37:54,000
presumibilmente chiamato x = 7.

558
00:37:54,000 --> 00:38:01,000
Presumibilmente x è anche un tipo in grado di memorizzare il numero 7,

559
00:38:01,000 --> 00:38:05,000
quindi è un int o, eventualmente, di un galleggiante o di un breve o un char,

560
00:38:05,000 --> 00:38:07,000
qualcosa del genere.

561
00:38:07,000 --> 00:38:12,000
Un'espressione booleana utilizza questi doppio uguale

562
00:38:12,000 --> 00:38:17,000
e il bang uguale o non uguale, inferiore, superiore,

563
00:38:17,000 --> 00:38:22,000
inferiore o uguale a, tutto quel genere di cose.

564
00:38:22,000 --> 00:38:28,000
Condizioni quindi sono dichiarazioni if ​​else.

565
00:38:28,000 --> 00:38:32,000
Vorrei ricordare che non si può avere un altro senza un corrispondente se.

566
00:38:32,000 --> 00:38:37,000
Allo stesso modo, non si può avere un altro se senza un corrispondente se.

567
00:38:37,000 --> 00:38:40,000
Loops, ricordano i 3 tipi di loop siamo stati martellare dentro di te

568
00:38:40,000 --> 00:38:43,000
per l'ultimo paio di sezioni e set problema.

569
00:38:43,000 --> 00:38:46,000
Uso della funzione mentre quando stai ricevendo l'input dell'utente,

570
00:38:46,000 --> 00:38:51,000
Uso dei cicli while fino a quando una determinata condizione è vera,

571
00:38:51,000 --> 00:38:56,000
e quindi utilizzando i cicli for, se avete bisogno di

572
00:38:56,000 --> 00:39:01,000
sapere quale iterazione del ciclo Attualmente sei su è come ci penso.

573
00:39:01,000 --> 00:39:07,000
Oppure, se si sta facendo una per ogni carattere in una stringa che voglio fare qualcosa,

574
00:39:07,000 --> 00:39:15,000
per ogni elemento in una matrice che voglio fare qualcosa per tale elemento.

575
00:39:15,000 --> 00:39:18,000
>> Discussioni ed eventi.

576
00:39:18,000 --> 00:39:21,000
Questi non abbiamo trattato in modo così esplicito in C,

577
00:39:21,000 --> 00:39:23,000
ma ricordate che questo da zero.

578
00:39:23,000 --> 00:39:26,000
Questa è l'idea di avere diversi script.

579
00:39:26,000 --> 00:39:32,000
Questo è anche questa idea di trasmettere un evento.

580
00:39:32,000 --> 00:39:37,000
Alcune persone non si utilizza la trasmissione nei loro progetti inizialmente,

581
00:39:37,000 --> 00:39:40,000
che è assolutamente cool,

582
00:39:40,000 --> 00:39:46,000
ma questi sono 2 modi diversi di affrontare il problema più grande chiamato concorrenza,

583
00:39:46,000 --> 00:39:49,000
che è come si fa a ottenere i programmi da eseguire

584
00:39:49,000 --> 00:39:54,000
o apparentemente eseguire allo stesso tempo?

585
00:39:54,000 --> 00:39:59,000
Vari task in esecuzione, mentre altre attività sono in corso anche.

586
00:39:59,000 --> 00:40:01,000
Ecco come il sistema operativo sembra funzionare.

587
00:40:01,000 --> 00:40:04,000
Ecco perché, anche se, per esempio,

588
00:40:04,000 --> 00:40:10,000
Ho ottenuto il mio browser in esecuzione, posso anche attivare Spotify e suonare una canzone.

589
00:40:10,000 --> 00:40:14,000
Questo è più di una cosa concettuale da capire.

590
00:40:14,000 --> 00:40:17,000
Vorrei dare un'occhiata a dei fili corti

591
00:40:17,000 --> 00:40:21,000
se volete saperne di più su questo.

592
00:40:21,000 --> 00:40:26,000
>> Vediamo un po ', credo che ci sarebbe stato

593
00:40:26,000 --> 00:40:31,000
un problema su questo in uno di questi.

594
00:40:31,000 --> 00:40:35,000
Anche in questo caso, credo che le discussioni e gli eventi non sono qualcosa che tratteremo in C

595
00:40:35,000 --> 00:40:41,000
solo perché è molto più difficile che in Scratch.

596
00:40:41,000 --> 00:40:44,000
Non si deve preoccupare lì, ma sicuramente capire i concetti,

597
00:40:44,000 --> 00:40:47,000
capire cosa sta succedendo.

598
00:40:47,000 --> 00:40:52,000
Prima di andare avanti, di chiarimenti in merito Settimana 0 materiali?

599
00:40:52,000 --> 00:40:55,000
Ognuno sente abbastanza bene?

600
00:40:55,000 --> 00:41:03,000
Capire le variabili e ciò che è una variabile?

601
00:41:03,000 --> 00:41:08,000
>> Passando. Settimana 1.

602
00:41:08,000 --> 00:41:12,000
Un paio di cose qui che non erano particolarmente coperti

603
00:41:12,000 --> 00:41:21,000
nella revisione quiz necessariamente e sono anche cose più concettuali a cui pensare.

604
00:41:21,000 --> 00:41:30,000
La prima è questa nozione di ciò che del codice sorgente, compilatori e il codice oggetto sono.

605
00:41:30,000 --> 00:41:32,000
Nessuno? Basil.

606
00:41:32,000 --> 00:41:37,000
E 'di codice oggetto, voglio dire il codice sorgente è ciò che si mette in clang,

607
00:41:37,000 --> 00:41:42,000
e il codice oggetto è ciò che clang mette in modo che il computer in grado di leggere il programma.

608
00:41:42,000 --> 00:41:44,000
Esattamente.

609
00:41:44,000 --> 00:41:47,000
Il codice sorgente è il codice C che effettivamente digitare fino.

610
00:41:47,000 --> 00:41:50,000
Il codice oggetto è quello che si ottiene fuori clang.

611
00:41:50,000 --> 00:41:54,000
E 'il 0 e 1 in quel formato binario.

612
00:41:54,000 --> 00:41:59,000
Allora che cosa succede quando si ha un gruppo di file oggetto,

613
00:41:59,000 --> 00:42:04,000
dire che sta compilando un progetto o di un programma che utilizza più file di codice sorgente,

614
00:42:04,000 --> 00:42:09,000
che, per convenzione viene data la estensione di file. c.

615
00:42:09,000 --> 00:42:13,000
Questo è il motivo per cui abbiamo caesar.c, vigenère.c.

616
00:42:13,000 --> 00:42:18,000
Se state scrivendo programmi Java si dà loro l'estensione. Java.

617
00:42:18,000 --> 00:42:24,000
Programmi Python hanno l'estensione. Py spesso.

618
00:42:24,000 --> 00:42:26,000
>> Una volta che si dispone di più. File c, averli compilati.

619
00:42:26,000 --> 00:42:29,000
Clang sputa fuori tutta questa spazzatura binario.

620
00:42:29,000 --> 00:42:33,000
Allora perché si vuole solo 1 programma

621
00:42:33,000 --> 00:42:37,000
avete il link linker tutti questi oggetti file insieme

622
00:42:37,000 --> 00:42:40,000
in 1 file eseguibile.

623
00:42:40,000 --> 00:42:45,000
Questo è anche ciò che accade quando si utilizza la libreria CS50, per esempio.

624
00:42:45,000 --> 00:42:50,000
La biblioteca CS50 è sia quello. File di intestazione h

625
00:42:50,000 --> 00:42:53,000
di leggere, che # includecs50.h.

626
00:42:53,000 --> 00:42:58,000
E poi è anche uno speciale file di libreria binario

627
00:42:58,000 --> 00:43:02,000
che è stato compilato che è 0 e 1,

628
00:43:02,000 --> 00:43:08,000
e che-l, quindi se torniamo ai nostri spazi e non vediamo molto velocemente

629
00:43:08,000 --> 00:43:11,000
a quello che sta succedendo qui quando guardiamo al nostro comando clang,

630
00:43:11,000 --> 00:43:15,000
quello che abbiamo è questo è il nostro file di codice sorgente qui.

631
00:43:15,000 --> 00:43:18,000
Si tratta di un gruppo di flag di compilazione.

632
00:43:18,000 --> 00:43:22,000
E poi alla fine, questi-l collegamento bandiere

633
00:43:22,000 --> 00:43:30,000
i file binari effettivi per questi 2 biblioteche, la CS50 biblioteca e poi la libreria matematica.

634
00:43:30,000 --> 00:43:35,000
>> Comprendere ogni tipo di oggetto file '

635
00:43:35,000 --> 00:43:38,000
nel processo di compilazione è qualcosa che si desidera essere in grado di

636
00:43:38,000 --> 00:43:43,000
dare almeno una panoramica di alto livello di.

637
00:43:43,000 --> 00:43:46,000
Il codice sorgente entra in codice oggetto viene fuori.

638
00:43:46,000 --> 00:43:53,000
File di codice oggetto collegare tra loro, e si ottiene una bella, file eseguibile.

639
00:43:53,000 --> 00:43:55,000
Cool.

640
00:43:55,000 --> 00:43:58,000
Questo è anche il luogo dove è possibile ottenere gli errori in più punti

641
00:43:58,000 --> 00:44:00,000
nel processo di compilazione.

642
00:44:00,000 --> 00:44:04,000
E 'qui che, ad esempio, se si prende questo flag di collegamento,

643
00:44:04,000 --> 00:44:10,000
il CS50 bandiera, e si omette in spazi o quando si esegue il codice,

644
00:44:10,000 --> 00:44:13,000
questo è dove si ottiene un errore in fase di collegamento,

645
00:44:13,000 --> 00:44:18,000
e il linker dirà: "Ehi, hai chiamato una funzione GetString

646
00:44:18,000 --> 00:44:20,000
che è nella libreria CS50. "

647
00:44:20,000 --> 00:44:25,000
"Mi hai detto che era nella biblioteca CS50, e non riesco a trovare il codice per questo."

648
00:44:25,000 --> 00:44:28,000
È lì che si deve collegare in, e questo è separato

649
00:44:28,000 --> 00:44:33,000
da un errore di compilazione, perché il compilatore sta guardando sintassi e questo genere di cose.

650
00:44:33,000 --> 00:44:38,000
E 'bene sapere cosa sta succedendo quando.

651
00:44:38,000 --> 00:44:42,000
>> Altre cose da sapere.

652
00:44:42,000 --> 00:44:49,000
Direi che è sicuramente desidera dare un'occhiata al corto di fusione di caratteri fatto da Jordan

653
00:44:49,000 --> 00:44:55,000
di capire quali interi sono sotto il cofano,

654
00:44:55,000 --> 00:44:58,000
quali caratteri sono sotto il cofano.

655
00:44:58,000 --> 00:45:02,000
Quando si parla di ASCII e in realtà abbiamo guardare la tabella ASCII,

656
00:45:02,000 --> 00:45:07,000
quello che sta facendo ci sta dando una sotto lo sguardo cofano

657
00:45:07,000 --> 00:45:13,000
il modo in cui il computer rappresenta in realtà maiuscola e la cifra 7

658
00:45:13,000 --> 00:45:17,000
e una virgola e un punto interrogativo.

659
00:45:17,000 --> 00:45:20,000
Il computer ha anche modi speciali per rappresentare

660
00:45:20,000 --> 00:45:23,000
il numero 7 come numero intero.

661
00:45:23,000 --> 00:45:27,000
Ha un modo speciale per rappresentare il numero 7 come numero in virgola mobile,

662
00:45:27,000 --> 00:45:29,000
e questi sono molto diversi.

663
00:45:29,000 --> 00:45:32,000
Typecasting è il modo per dire al computer "Ehi, voglio di convertire

664
00:45:32,000 --> 00:45:37,000
da una rappresentazione ad un'altra rappresentazione. "

665
00:45:37,000 --> 00:45:40,000
Perché non dare un'occhiata a questo.

666
00:45:40,000 --> 00:45:44,000
>> Vorrei anche dare un'occhiata al breve sulle biblioteche e il corto di compilatori.

667
00:45:44,000 --> 00:45:47,000
Quelli parlare del processo di compilazione,

668
00:45:47,000 --> 00:45:53,000
ciò che una biblioteca è, e andare oltre alcune di queste domande che si potrebbe ottenere chiesto.

669
00:45:53,000 --> 00:45:55,000
Domande sulla Settimana 1 materiale?

670
00:45:55,000 --> 00:46:03,000
Ci sono argomenti di qui che sembrano scoraggiante vorresti coprire?

671
00:46:03,000 --> 00:46:07,000
Sto cercando di saltare attraverso la maggior parte di questi argomenti precedenti in modo che si possa arrivare a

672
00:46:07,000 --> 00:46:13,000
puntatori e fare un po 'di ricorsione.

673
00:46:13,000 --> 00:46:15,000
Pensieri?

674
00:46:15,000 --> 00:46:19,000
Qualcosa da coprire?

675
00:46:19,000 --> 00:46:21,000
Tempo per un po 'di cioccolata, magari?

676
00:46:21,000 --> 00:46:23,000
Voi ragazzi stanno lavorando attraverso di essa.

677
00:46:23,000 --> 00:46:26,000
Ho intenzione di continuare sorseggiando il mio caffè.

678
00:46:26,000 --> 00:46:31,000
Settimana 2.

679
00:46:31,000 --> 00:46:34,000
Buona idea, buona chiamata.

680
00:46:34,000 --> 00:46:38,000
In settimana 2 abbiamo parlato un po 'di più sulle funzioni.

681
00:46:38,000 --> 00:46:43,000
>> Nel primo set qualche problema non abbiamo davvero scrivere tutte le funzioni a tutti

682
00:46:43,000 --> 00:46:45,000
, anche se tale funzione?

683
00:46:45,000 --> 00:46:47,000
[Studente] principale. >> Principale, esattamente.

684
00:46:47,000 --> 00:46:51,000
E così abbiamo visto i diversi costumi che indossa principale.

685
00:46:51,000 --> 00:46:54,000
C'è quello in cui essa non accetta argomenti,

686
00:46:54,000 --> 00:46:58,000
e ci limitiamo a dire nulla tra le parentesi,

687
00:46:58,000 --> 00:47:01,000
e poi c'è l'altro dove si vuole prendere gli argomenti della riga di comando,

688
00:47:01,000 --> 00:47:08,000
e come abbiamo visto, è lì che avete int argc e argv array di stringhe

689
00:47:08,000 --> 00:47:13,000
o ora che abbiamo effettivamente esposti stringa di essere il char * che si tratta di

690
00:47:13,000 --> 00:47:20,000
stiamo per iniziare a scrivere come char * argv e poi staffe.

691
00:47:20,000 --> 00:47:22,000
In Set Problema 3, voi ragazzi ha visto un sacco di funzioni,

692
00:47:22,000 --> 00:47:27,000
e implementato una serie di funzioni, disegnare, guardare in alto, scramble.

693
00:47:27,000 --> 00:47:31,000
I prototipi sono stati tutti scritti lì per voi.

694
00:47:31,000 --> 00:47:33,000
>> Quello che volevo parlare qui con funzioni molto rapidamente

695
00:47:33,000 --> 00:47:38,000
è che ci sono 3 parti a loro ogni volta che si scrive una funzione.

696
00:47:38,000 --> 00:47:43,000
È necessario specificare il tipo di ritorno della funzione.

697
00:47:43,000 --> 00:47:46,000
È necessario specificare un nome per la funzione e quindi è necessario specificare

698
00:47:46,000 --> 00:47:51,000
l'elenco degli argomenti o la lista dei parametri.

699
00:47:51,000 --> 00:47:57,000
Per esempio, se dovessi scrivere una funzione per riassumere un po 'di numeri interi

700
00:47:57,000 --> 00:48:03,000
e poi tornare da me la somma ciò che sarebbe stato il mio tipo di ritorno

701
00:48:03,000 --> 00:48:06,000
se volessi riassumere interi e quindi restituire la somma?

702
00:48:06,000 --> 00:48:12,000
Quindi il nome della funzione.

703
00:48:12,000 --> 00:48:27,000
Se vado avanti e scrivere in verde, questa parte è il tipo restituito.

704
00:48:27,000 --> 00:48:34,000
Questa parte è il nome.

705
00:48:34,000 --> 00:48:40,000
E poi, tra parentesi

706
00:48:40,000 --> 00:48:46,000
è dove io do gli argomenti,

707
00:48:46,000 --> 00:48:56,000
spesso abbreviato in args, a volte chiamati params per i parametri.

708
00:48:56,000 --> 00:49:00,000
E se ne avete uno, è sufficiente specificare l'uno.

709
00:49:00,000 --> 00:49:06,000
Se si dispone di più di separare ognuno con una virgola.

710
00:49:06,000 --> 00:49:13,000
E per ogni argomento si dà 2 cose che sono, Kevin?

711
00:49:13,000 --> 00:49:18,000
[Kevin] Dovete dare il tipo e poi il nome.

712
00:49:18,000 --> 00:49:21,000
E poi il nome, e il nome è il nome che avete intenzione di usare

713
00:49:21,000 --> 00:49:25,000
per fare riferimento a tale argomento all'interno della funzione somma,

714
00:49:25,000 --> 00:49:27,000
all'interno della funzione che si sta scrivendo.

715
00:49:27,000 --> 00:49:32,000
>> Non è per-ad esempio, se ho intenzione di riassumere,

716
00:49:32,000 --> 00:49:41,000
diciamo, un array di interi-we'll do array di int,

717
00:49:41,000 --> 00:49:46,000
e io mi do alcune parentesi graffe vi-

718
00:49:46,000 --> 00:49:51,000
poi quando ho passare un array alla funzione somma

719
00:49:51,000 --> 00:49:55,000
Lo passo al primo posto della lista degli argomenti.

720
00:49:55,000 --> 00:49:59,000
Ma la matrice che mi passa in non avere il nome arr.

721
00:49:59,000 --> 00:50:07,000
Arr. sta per essere come mi riferisco a tale argomento all'interno del corpo della funzione.

722
00:50:07,000 --> 00:50:10,000
L'altra cosa che abbiamo bisogno di prendere in considerazione,

723
00:50:10,000 --> 00:50:14,000
e questo è leggermente diverso dalle funzioni, ma credo che sia un punto importante,

724
00:50:14,000 --> 00:50:20,000
è che in C, quando sto scrivendo una funzione come questa

725
00:50:20,000 --> 00:50:29,000
come faccio a sapere quanti elementi sono in questo array?

726
00:50:29,000 --> 00:50:31,000
Questo è un po 'di una domanda trabocchetto.

727
00:50:31,000 --> 00:50:35,000
Ne abbiamo parlato un po 'nella sezione della scorsa settimana.

728
00:50:35,000 --> 00:50:40,000
Come faccio a sapere il numero di elementi all'interno di un array in C?

729
00:50:40,000 --> 00:50:44,000
C'è un modo?

730
00:50:44,000 --> 00:50:49,000
>> Si scopre che non c'è modo di saperlo.

731
00:50:49,000 --> 00:50:52,000
Devi passare in parte.

732
00:50:52,000 --> 00:50:55,000
C'è un trucco che si può fare

733
00:50:55,000 --> 00:51:00,000
se siete nella stessa funzione in cui l'array è stato dichiarato,

734
00:51:00,000 --> 00:51:04,000
e si sta lavorando con una matrice di stack.

735
00:51:04,000 --> 00:51:06,000
Ma questo funziona solo se siete nella stessa funzione.

736
00:51:06,000 --> 00:51:09,000
Una volta che si passa una matrice a un'altra funzione o se si è dichiarato un array

737
00:51:09,000 --> 00:51:12,000
e si mette tale matrice sul mucchio, hai utilizzato malloc

738
00:51:12,000 --> 00:51:15,000
 e questo genere di cose, tutte le scommesse sono spenti.

739
00:51:15,000 --> 00:51:18,000
Poi effettivamente passare intorno

740
00:51:18,000 --> 00:51:21,000
un argomento speciale o un altro parametro

741
00:51:21,000 --> 00:51:23,000
che ti dice quanto è grande l'array è.

742
00:51:23,000 --> 00:51:28,000
In questo caso, vorrei usare una virgola-mi dispiace, sta andando fuori dallo schermo qui-

743
00:51:28,000 --> 00:51:32,000
e mi piacerebbe passare a un altro argomento

744
00:51:32,000 --> 00:51:40,000
 e lo chiamano int len ​​per la lunghezza.

745
00:51:40,000 --> 00:51:44,000
>> Una cosa che potrebbe venire sul quiz

746
00:51:44,000 --> 00:51:49,000
vi chiede di scrivere o implementare una particolare funzione chiamata qualcosa.

747
00:51:49,000 --> 00:51:54,000
Se non vi danno il prototipo, quindi tutta questa cosa qui,

748
00:51:54,000 --> 00:51:58,000
tutto questo casino si chiama dichiarazione di funzione o il prototipo di funzione,

749
00:51:58,000 --> 00:52:01,000
questa è una delle prime cose che si vorrà inchiodare se non è dato

750
00:52:01,000 --> 00:52:03,000
a voi subito sul quiz.

751
00:52:03,000 --> 00:52:06,000
L'altro trucco che ho imparato è che

752
00:52:06,000 --> 00:52:11,000
dire che concede il prototipo di una funzione, e diciamo: "Ehi, hai avuto modo di scriverlo."

753
00:52:11,000 --> 00:52:16,000
All'interno delle parentesi graffe che avete sul quiz

754
00:52:16,000 --> 00:52:20,000
se si nota che c'è un tipo di ritorno e si nota che il tipo di ritorno

755
00:52:20,000 --> 00:52:25,000
è qualcosa di diverso da void, il che significa che la funzione non restituisce nulla,

756
00:52:25,000 --> 00:52:28,000
poi una cosa che sicuramente voglio fare è scrivere

757
00:52:28,000 --> 00:52:33,000
una sorta di return alla fine della funzione.

758
00:52:33,000 --> 00:52:40,000
Ritorno, e in questo caso, ci metterò un vuoto perché vogliamo riempire il vuoto.

759
00:52:40,000 --> 00:52:44,000
Ma questo ti fa pensare nel modo giusto su come faccio a affrontare questo problema?

760
00:52:44,000 --> 00:52:49,000
E ti ricorda che stai andando ad avere per restituire un valore

761
00:52:49,000 --> 00:52:51,000
al chiamante della funzione.

762
00:52:51,000 --> 00:52:54,000
>> Si '. >> [Studente] Ha stile si applicano quando si sta scrivendo codice sul quiz?

763
00:52:54,000 --> 00:52:58,000
Come rientro e quel genere di cose? >> [Studente] Si '.

764
00:52:58,000 --> 00:53:00,000
No, non tanto.

765
00:53:00,000 --> 00:53:09,000
Penso che un sacco di-questo è qualcosa che ci chiariscono il quiz il giorno,

766
00:53:09,000 --> 00:53:15,000
ma in genere preoccuparsi include # e questo genere di cose, è una specie di fuori.

767
00:53:15,000 --> 00:53:17,000
[Studente] Avete bisogno di commentare il codice scritto a mano?

768
00:53:17,000 --> 00:53:19,000
Avete bisogno di commentare il codice scritto a mano?

769
00:53:19,000 --> 00:53:24,000
Commentando è sempre bene, se siete preoccupati per credito parziale

770
00:53:24,000 --> 00:53:29,000
o se si vuole comunicare la vostra intenzione allo livellatrice.

771
00:53:29,000 --> 00:53:33,000
Ma, ancora una volta, chiarirà 'in quiz e il giorno quiz,

772
00:53:33,000 --> 00:53:39,000
ma io non credo che ti verrà richiesto di scrivere commenti, no.

773
00:53:39,000 --> 00:53:42,000
In genere no, ma è sicuramente il genere di cose in cui

774
00:53:42,000 --> 00:53:45,000
è possibile comunicare la vostra intenzione, come "Hey, questo è dove sto andando con esso."

775
00:53:45,000 --> 00:53:49,000
E a volte che può aiutare con il credito parziale.

776
00:53:49,000 --> 00:53:51,000
Cool.

777
00:53:51,000 --> 00:53:53,000
>> Basil.

778
00:53:53,000 --> 00:53:56,000
[Basilio] Qual è la differenza tra la dichiarazione di, diciamo, int lang

779
00:53:56,000 --> 00:54:03,000
negli argomenti o parametri rispetto dichiara una variabile all'interno della funzione?

780
00:54:03,000 --> 00:54:05,000
Wow, il caffè è andato giù per la trachea.

781
00:54:05,000 --> 00:54:07,000
[Basilio] Ti piace che le cose che vogliamo mettere in argomenti.

782
00:54:07,000 --> 00:54:09,000
Sì, è una grande domanda.

783
00:54:09,000 --> 00:54:11,000
Come si fa a scegliere ciò che le cose che si desidera mettere in argomenti

784
00:54:11,000 --> 00:54:17,000
rispetto a ciò che le cose che si dovrebbero fare all'interno della funzione?

785
00:54:17,000 --> 00:54:24,000
In questo caso abbiamo incluso entrambi come argomenti

786
00:54:24,000 --> 00:54:29,000
perché sono qualcosa che chi sta per utilizzare la funzione somma

787
00:54:29,000 --> 00:54:32,000
ha bisogno di specificare quelle cose.

788
00:54:32,000 --> 00:54:35,000
>> La funzione somma, come abbiamo detto, non ha modo di sapere

789
00:54:35,000 --> 00:54:40,000
quanto è grande l'array è ottiene dal suo chiamante o di chi sta utilizzando la funzione di somma.

790
00:54:40,000 --> 00:54:44,000
Non ha modo di sapere quanto grande è quella matrice.

791
00:54:44,000 --> 00:54:48,000
La ragione per cui si passa in questa lunghezza qui come argomento

792
00:54:48,000 --> 00:54:51,000
è dovuto al fatto che è qualcosa che stiamo praticamente dicendo che il chiamante della funzione,

793
00:54:51,000 --> 00:54:55,000
chi sta per utilizzare la funzione somma, "Ehi, non solo dovete darci una matrice

794
00:54:55,000 --> 00:54:59,000
di int, si hanno anche per dirci quanto è grande l'array che ci hai dato è. "

795
00:54:59,000 --> 00:55:03,000
[Basilio] Coloro che saranno entrambi gli argomenti della riga di comando?

796
00:55:03,000 --> 00:55:06,000
No, questi sono argomenti reali che si dovrebbe passare alla funzione.

797
00:55:06,000 --> 00:55:10,000
>> Vorrei fare una nuova pagina qui.

798
00:55:10,000 --> 00:55:13,000
[Basilio] Come nome sarebbe pass-

799
00:55:13,000 --> 00:55:24,000
[Nate H] Se ho int main (void),

800
00:55:24,000 --> 00:55:27,000
e ho intenzione di mettere nel mio 0 return qui in basso,

801
00:55:27,000 --> 00:55:31,000
e dire che voglio chiamare la funzione somma.

802
00:55:31,000 --> 00:55:42,000
Voglio dire int x = sum ();

803
00:55:42,000 --> 00:55:46,000
Per utilizzare la funzione somma che devo passare sia la matrice che voglio riassumere

804
00:55:46,000 --> 00:55:51,000
e la lunghezza della matrice, quindi questo è dove

805
00:55:51,000 --> 00:55:54,000
assumendo Ho avuto un array di interi,

806
00:55:54,000 --> 00:56:12,000
dire che ho avuto numbaz int [] = 1, 2, 3,

807
00:56:12,000 --> 00:56:16,000
tipo di utilizzo che a pezzi sintassi proprio lì,

808
00:56:16,000 --> 00:56:21,000
allora quello che vorrei fare è insomma vorrei passare

809
00:56:21,000 --> 00:56:27,000
sia numbaz e il numero 3

810
00:56:27,000 --> 00:56:30,000
a dire la funzione somma "Ok, ecco la matrice voglio che sommare."

811
00:56:30,000 --> 00:56:34,000
"Ecco le sue dimensioni."

812
00:56:34,000 --> 00:56:39,000
Ha senso? Ho risposto alla tua domanda?

813
00:56:39,000 --> 00:56:42,000
>> Per molti versi parallelo fa quello che stiamo facendo con il principale

814
00:56:42,000 --> 00:56:44,000
quando abbiamo gli argomenti della riga di comando.

815
00:56:44,000 --> 00:56:47,000
Un programma come Cesare cifra, per esempio, che aveva bisogno di

816
00:56:47,000 --> 00:56:53,000
argomenti della riga di comando non sarebbe in grado di fare qualsiasi cosa.

817
00:56:53,000 --> 00:56:57,000
Non saprei come crittografare se non indicare cosa chiave da utilizzare

818
00:56:57,000 --> 00:57:03,000
o se non lo dire cosa stringa che si vuole crittografare.

819
00:57:03,000 --> 00:57:08,000
La richiesta di input, questo è dove abbiamo ottenuto 2 diversi meccanismi

820
00:57:08,000 --> 00:57:14,000
per prendere in ingresso dall'utente, per prendere informazioni da parte dell'utente.

821
00:57:14,000 --> 00:57:19,000
Per Problema Set 1 abbiamo visto questa GetInt, GetString, modo getFloat

822
00:57:19,000 --> 00:57:26,000
di richiesta di input, e che si chiama con il flusso di input standard.

823
00:57:26,000 --> 00:57:28,000
E 'un po' diverso.

824
00:57:28,000 --> 00:57:31,000
E 'qualcosa che si può fare in una sola volta al contrario di

825
00:57:31,000 --> 00:57:35,000
quando si avvia il programma, quando si avvia il programma in esecuzione.

826
00:57:35,000 --> 00:57:41,000
Gli argomenti della riga di comando sono specificati tutti quando si avvia il funzionamento del programma.

827
00:57:41,000 --> 00:57:47,000
Abbiamo la miscelazione dei due di quelli.

828
00:57:47,000 --> 00:57:52,000
Quando si usano argomenti di una funzione, è molto simile a gli argomenti della riga di comando per principale.

829
00:57:52,000 --> 00:57:56,000
E 'quando si richiama la funzione è necessario indicare la

830
00:57:56,000 --> 00:58:05,000
che cosa ha bisogno per svolgere i propri compiti.

831
00:58:05,000 --> 00:58:08,000
Un'altra buona cosa da guardare, e ti farò vedere le cose nel tempo libero,

832
00:58:08,000 --> 00:58:11,000
ed è stato coperto nel quiz-era questa nozione di portata

833
00:58:11,000 --> 00:58:15,000
e variabili locali rispetto a variabili globali.

834
00:58:15,000 --> 00:58:18,000
Fare attenzione a questo.

835
00:58:18,000 --> 00:58:23,000
>> Ora che ci stiamo a queste altre cose,

836
00:58:23,000 --> 00:58:27,000
nella Settimana 3 abbiamo iniziato a parlare di ricerca e l'ordinamento.

837
00:58:27,000 --> 00:58:32,000
Ricerca e l'ordinamento, almeno in CS50,

838
00:58:32,000 --> 00:58:39,000
è molto un'introduzione ad alcune delle parti più teoriche di informatica.

839
00:58:39,000 --> 00:58:42,000
Il problema della ricerca, il problema di smistamento

840
00:58:42,000 --> 00:58:46,000
sono grandi, problemi canonici.

841
00:58:46,000 --> 00:58:52,000
Come si fa a trovare un determinato numero in un array di miliardi di numeri interi?

842
00:58:52,000 --> 00:58:55,000
Come si fa a trovare un particolare nome all'interno di una rubrica telefonica

843
00:58:55,000 --> 00:58:59,000
che è memorizzato su un computer portatile?

844
00:58:59,000 --> 00:59:04,000
E così si introduce la nozione di tempi di esecuzione asintotici

845
00:59:04,000 --> 00:59:11,000
per quantificare realmente quanto tempo, quanto sia difficile questo problema sono,

846
00:59:11,000 --> 00:59:14,000
quanto tempo impiegano a risolvere.

847
00:59:14,000 --> 00:59:20,000
In, credo, 2011 di quiz c'è un problema che penso meriti

848
00:59:20,000 --> 00:59:27,000
copertura molto rapidamente, che è questo, il problema 12.

849
00:59:27,000 --> 00:59:32,000
O no, è Omega.

850
00:59:32,000 --> 00:59:41,000
>> Qui stiamo parlando del tempo di esecuzione più veloce possibile

851
00:59:41,000 --> 00:59:46,000
per un particolare algoritmo e quindi il tempo di esecuzione più lento possibile.

852
00:59:46,000 --> 00:59:52,000
Questo Omega e O sono in realtà solo scorciatoie.

853
00:59:52,000 --> 00:59:55,000
Sono scorciatoie notazionali per dire

854
00:59:55,000 --> 00:59:59,000
la velocità nel caso migliore sarà il nostro algoritmo di esecuzione,

855
00:59:59,000 --> 01:00:06,000
e la lentezza nel caso peggiore sarà il nostro algoritmo di correre?

856
01:00:06,000 --> 01:00:10,000
Facciamo un paio di questi, e questi sono stati coperti

857
01:00:10,000 --> 01:00:13,000
a breve sulla notazione asintotica, che consiglio vivamente.

858
01:00:13,000 --> 01:00:17,000
Jackson ha fatto davvero un buon lavoro.

859
01:00:17,000 --> 01:00:23,000
Con la ricerca binaria, si parla di ricerca binaria come un algoritmo,

860
01:00:23,000 --> 01:00:28,000
e di solito parlarne in termini di grande O.

861
01:00:28,000 --> 01:00:30,000
Qual è la grande O?

862
01:00:30,000 --> 01:00:34,000
Qual è il tempo di esecuzione più lento possibile di ricerca binaria?

863
01:00:34,000 --> 01:00:36,000
[Studente] N ²?

864
01:00:36,000 --> 01:00:41,000
Chiudi, credo simile a quello.

865
01:00:41,000 --> 01:00:43,000
E 'molto più veloce di così.

866
01:00:43,000 --> 01:00:45,000
[Studente] binario? >> Si ', la ricerca binaria.

867
01:00:45,000 --> 01:00:47,000
[Studente] E 'log n.

868
01:00:47,000 --> 01:00:49,000
Log n, cosa fanno log n dire?

869
01:00:49,000 --> 01:00:51,000
E si dimezza ogni iterazione.

870
01:00:51,000 --> 01:00:56,000
Esattamente, quindi nel caso più lento possibile,

871
01:00:56,000 --> 01:01:00,000
dire se si dispone di un array ordinato

872
01:01:00,000 --> 01:01:08,000
di un milione di numeri interi e il numero che stai cercando

873
01:01:08,000 --> 01:01:14,000
o è il primo elemento nella matrice o l'elemento nella matrice.

874
01:01:14,000 --> 01:01:18,000
Ricordate, l'algoritmo di ricerca binaria funziona guardando l'elemento centrale,

875
01:01:18,000 --> 01:01:21,000
vedere se questa è la partita che si sta cercando.

876
01:01:21,000 --> 01:01:23,000
Se lo è, allora bene, l'hai trovato.

877
01:01:23,000 --> 01:01:27,000
>> Nel caso migliore, la velocità di esecuzione fa ricerca binaria?

878
01:01:27,000 --> 01:01:29,000
[Gli studenti] 1.

879
01:01:29,000 --> 01:01:32,000
1, è la costante di tempo, grande O di 1. Gia '.

880
01:01:32,000 --> 01:01:36,000
[Studente] Ho una domanda. Quando si dice log di n, si intende rispetto alla base 2, giusto?

881
01:01:36,000 --> 01:01:40,000
Sì, in modo che l'altra cosa.

882
01:01:40,000 --> 01:01:44,000
Diciamo n log, e credo che quando ero al liceo

883
01:01:44,000 --> 01:01:48,000
Ho sempre pensato che il log era base 10.

884
01:01:48,000 --> 01:01:57,000
Gia ', quindi sì, log 2 base è in genere ciò che usiamo.

885
01:01:57,000 --> 01:02:02,000
Anche in questo caso, tornando alla ricerca binaria, se siete alla ricerca di uno dei due

886
01:02:02,000 --> 01:02:05,000
l'elemento alla fine o l'elemento all'inizio,

887
01:02:05,000 --> 01:02:08,000
perché si inizia a metà e poi scartare

888
01:02:08,000 --> 01:02:13,000
seconda metà non è conforme ai criteri che si sta cercando,

889
01:02:13,000 --> 01:02:15,000
e si va al prossimo mezzo e la prossima metà e la metà successiva.

890
01:02:15,000 --> 01:02:19,000
Se sto cercando per il più grande elemento dell'array milioni di interi

891
01:02:19,000 --> 01:02:25,000
Ho intenzione di dimezzare lo al più log di 1 milione di volte

892
01:02:25,000 --> 01:02:28,000
prima che finalmente provare e vedere che l'elemento che sto cercando

893
01:02:28,000 --> 01:02:33,000
è il più grande o nel più alto indice della matrice,

894
01:02:33,000 --> 01:02:38,000
e che avrà log n, log di 1 milione di volte.

895
01:02:38,000 --> 01:02:40,000
>> Bubble sort.

896
01:02:40,000 --> 01:02:43,000
Voi ragazzi ricordate l'algoritmo bubble sort?

897
01:02:43,000 --> 01:02:47,000
Kevin, mi puoi dare un breve riepilogo di quello che è successo con l'algoritmo bubble sort?

898
01:02:47,000 --> 01:02:50,000
[Kevin] In sostanza si passa attraverso tutto ciò che nella lista.

899
01:02:50,000 --> 01:02:52,000
Si guarda le prime due.

900
01:02:52,000 --> 01:02:55,000
Se il primo è più grande la seconda essa le swap.

901
01:02:55,000 --> 01:02:58,000
Poi si confronta secondo e terzo, la stessa cosa, swaps,

902
01:02:58,000 --> 01:03:00,000
terzo e quarto, fino in fondo.

903
01:03:00,000 --> 01:03:03,000
Più grandi i numeri seguirà fino alla fine.

904
01:03:03,000 --> 01:03:07,000
E dopo molti cicli tuttavia il gioco è fatto.

905
01:03:07,000 --> 01:03:11,000
Esattamente, quindi ciò che ha detto è che Kevin guarderemo più grandi numeri

906
01:03:11,000 --> 01:03:15,000
bolla fino alla fine della matrice.

907
01:03:15,000 --> 01:03:19,000
Ad esempio, ti dispiace camminare attraverso questo esempio, se questa è la nostra matrice?

908
01:03:19,000 --> 01:03:21,000
[Kevin] Ti prendo 2 e 3.

909
01:03:21,000 --> 01:03:23,000
3 è più grande di 2, quindi li scambio.

910
01:03:23,000 --> 01:03:29,000
[Nate H.] Giusto, quindi ci scambiamo questi, e in modo da ottenere 2, 3, 6, 4, e 9.

911
01:03:29,000 --> 01:03:31,000
[Kevin] Allora si confronta il 3 e 6.

912
01:03:31,000 --> 01:03:33,000
3 è inferiore a 6, in modo da lasciare loro,

913
01:03:33,000 --> 01:03:37,000
e 6 e 4, che li avresti scambiare perché 4 è inferiore a 6.

914
01:03:37,000 --> 01:03:42,000
[Nate H.] destro, in modo da ottenere 2, 3, 4, 6, 9.

915
01:03:42,000 --> 01:03:46,000
[Kevin] E 9 è superiore a 6, in modo da lasciare.

916
01:03:46,000 --> 01:03:48,000
E devi andare indietro attraverso di nuovo.

917
01:03:48,000 --> 01:03:50,000
>> [Nate H] Sto fare a questo punto? >> [Kevin] No.

918
01:03:50,000 --> 01:03:52,000
E perché io non ho fatto a questo punto?

919
01:03:52,000 --> 01:03:54,000
Perché sembra che il mio array è ordinato. Mi sto guardando.

920
01:03:54,000 --> 01:03:57,000
[Kevin] Vai attraverso di essa ancora e fare in modo che non ci sono gli swap non più

921
01:03:57,000 --> 01:04:00,000
prima di poter smettere completamente.

922
01:04:00,000 --> 01:04:04,000
Esattamente, quindi è necessario per andare avanti attraverso e fare in modo che non ci siano swap

923
01:04:04,000 --> 01:04:06,000
che si può fare a questo punto.

924
01:04:06,000 --> 01:04:08,000
E 'stato davvero solo fortuna, come hai detto tu, che abbiamo finito per

925
01:04:08,000 --> 01:04:12,000
solo dover fare 1 pass through e siamo ordinati.

926
01:04:12,000 --> 01:04:16,000
Ma per fare questo nel caso generale ci troveremo a fare questo più e più volte.

927
01:04:16,000 --> 01:04:20,000
E infatti, questo era un esempio del caso migliore,

928
01:04:20,000 --> 01:04:24,000
come abbiamo visto nel problema.

929
01:04:24,000 --> 01:04:28,000
Abbiamo visto che il caso migliore è stata n.

930
01:04:28,000 --> 01:04:32,000
Siamo andati con il tempo di matrice 1.

931
01:04:32,000 --> 01:04:35,000
Qual è il caso peggiore possibile per questo algoritmo?

932
01:04:35,000 --> 01:04:37,000
[Kevin] N ².

933
01:04:37,000 --> 01:04:41,000
E che cosa piace quello sguardo? Che cosa sarebbe un look matrice del genere sarebbe voluto del tempo ² n?

934
01:04:41,000 --> 01:04:43,000
[Kevin] [incomprensibile] ordinati.

935
01:04:43,000 --> 01:04:51,000
Esattamente, quindi se avessi la matrice 9, 7, 6, 5, 2,

936
01:04:51,000 --> 01:04:54,000
prima il 9 si bolla tutto il senso fino.

937
01:04:54,000 --> 01:04:59,000
Dopo 1 iterazione avremmo 7, 6, 5, 2, 9.

938
01:04:59,000 --> 01:05:07,000
Poi il 7 sarebbe bubble up, 6, 5, 2, 7, 9, e così via e così via.

939
01:05:07,000 --> 01:05:13,000
>> Dovremmo passare attraverso l'intero array n volte,

940
01:05:13,000 --> 01:05:16,000
e si può effettivamente ottenere un po 'più precisa di questa

941
01:05:16,000 --> 01:05:23,000
perché una volta che abbiamo spostato il 9 tutta la strada fino nella sua ultima posizione possibile

942
01:05:23,000 --> 01:05:26,000
sappiamo che non dobbiamo confrontare con tale elemento nuovo.

943
01:05:26,000 --> 01:05:29,000
Una volta che si comincia a gorgogliare il 7

944
01:05:29,000 --> 01:05:35,000
sappiamo che siamo in grado di fermare una volta che il 7 è a destra prima del 9

945
01:05:35,000 --> 01:05:37,000
dal momento che già il 9 rispetto ad esso.

946
01:05:37,000 --> 01:05:46,000
Se si esegue questa operazione in modo intelligente non è vero, credo, che molto tempo.

947
01:05:46,000 --> 01:05:49,000
Tu non stai andando a confrontare tutte le possibili combinazioni di [incomprensibile]

948
01:05:49,000 --> 01:05:55,000
ogni volta che si passa attraverso ogni iterazione.

949
01:05:55,000 --> 01:05:59,000
Ma ancora, quando si parla di questo limite superiore si dice che

950
01:05:59,000 --> 01:06:04,000
siete alla ricerca di n ² confronti fino in fondo.

951
01:06:04,000 --> 01:06:12,000
>> Torniamo indietro, e dato che stiamo iniziando a diventare un po 'a corto di tempo

952
01:06:12,000 --> 01:06:15,000
Direi che si dovrebbe andare per il resto di questa tabella,

953
01:06:15,000 --> 01:06:17,000
compilare tutto.

954
01:06:17,000 --> 01:06:20,000
Pensate di esempi. Pensate di esempi concreti.

955
01:06:20,000 --> 01:06:22,000
E 'davvero comodo e utile da fare.

956
01:06:22,000 --> 01:06:25,000
Disegna fuori.

957
01:06:25,000 --> 01:06:28,000
Questo è il tipo di tabella che come si passa attraverso in informatica

958
01:06:28,000 --> 01:06:32,000
si dovrebbe davvero iniziare a conoscere questi cuore da.

959
01:06:32,000 --> 01:06:34,000
Questi sono i tipi di domande che si ottiene nelle interviste.

960
01:06:34,000 --> 01:06:36,000
Questi sono i tipi di cose che è bene sapere,

961
01:06:36,000 --> 01:06:41,000
e pensare a questi casi limite, in realtà per capire come pensare

962
01:06:41,000 --> 01:06:45,000
sapendo che per bolla ordinare l'array peggiore possibile

963
01:06:45,000 --> 01:06:52,000
per ordinare con questo è uno che è in ordine inverso.

964
01:06:52,000 --> 01:06:58,000
>> Puntatori. Parliamo un po 'di puntatori.

965
01:06:58,000 --> 01:07:03,000
Negli ultimi minuti abbiamo qui

966
01:07:03,000 --> 01:07:11,000
So che questa è una cosa insieme a file di I / O che è piuttosto nuovo.

967
01:07:11,000 --> 01:07:19,000
Quando si parla di puntatori il motivo per cui vogliamo parlare di puntatori

968
01:07:19,000 --> 01:07:24,000
è perché, uno, quando stiamo lavorando in C

969
01:07:24,000 --> 01:07:33,000
siamo davvero ad un livello abbastanza basso rispetto ai linguaggi di programmazione più moderni.

970
01:07:33,000 --> 01:07:38,000
Siamo effettivamente in grado di manipolare le variabili in memoria,

971
01:07:38,000 --> 01:07:43,000
capire dove stanno in realtà si trova all'interno della nostra RAM.

972
01:07:43,000 --> 01:07:46,000
Una volta che hai continuato a prendere lezioni di sistema operativo che vedrete

973
01:07:46,000 --> 01:07:48,000
che questo è, ancora una volta, una specie di astrazione.

974
01:07:48,000 --> 01:07:50,000
Questo non è davvero il caso.

975
01:07:50,000 --> 01:07:52,000
Abbiamo la memoria virtuale che si nasconde questi dettagli da noi.

976
01:07:52,000 --> 01:07:58,000
>> Ma per ora si può supporre che quando si ha un programma,

977
01:07:58,000 --> 01:08:02,000
per esempio, quando si avvia l'esecuzione del programma-cifrario di Cesare

978
01:08:02,000 --> 01:08:06,000
Io tornare al mio iPad molto velocemente-

979
01:08:06,000 --> 01:08:12,000
che proprio all'inizio del programma, se si dispone di, diciamo,

980
01:08:12,000 --> 01:08:15,000
4 gigabyte di RAM su un computer portatile,

981
01:08:15,000 --> 01:08:21,000
vieni messo da parte questo pezzo, e chiameremo questa RAM.

982
01:08:21,000 --> 01:08:25,000
E si avvia in un luogo che andremo a chiamare 0,

983
01:08:25,000 --> 01:08:30,000
e termina in un luogo che chiameremo 4 gigabyte.

984
01:08:30,000 --> 01:08:37,000
Io davvero non riesco a scrivere. L'uomo, che viene violato.

985
01:08:37,000 --> 01:08:40,000
Quando il programma viene eseguito

986
01:08:40,000 --> 01:08:44,000
il sistema operativo scolpisce la RAM,

987
01:08:44,000 --> 01:08:51,000
e specifica di segmenti diversi per le diverse parti del programma in cui vivere

988
01:08:51,000 --> 01:08:58,000
Quaggiù questa zona è una specie di terra di nessuno.

989
01:08:58,000 --> 01:09:02,000
Quando si sale un po 'più qui

990
01:09:02,000 --> 01:09:05,000
hai effettivamente il luogo in cui

991
01:09:05,000 --> 01:09:09,000
il codice per la vostra vita del programma.

992
01:09:09,000 --> 01:09:13,000
Questo codice binario vero e proprio, che in realtà file eseguibile viene caricato in memoria

993
01:09:13,000 --> 01:09:17,000
quando si esegue un programma, e vive nel segmento di codice.

994
01:09:17,000 --> 01:09:22,000
E come il programma esegue il processore in questo segmento di codice

995
01:09:22,000 --> 01:09:24,000
per capire che cosa è l'istruzione successiva?

996
01:09:24,000 --> 01:09:27,000
Qual è la prossima linea di codice che devo eseguire?

997
01:09:27,000 --> 01:09:31,000
>> C'è anche un segmento di dati, ed è qui che le costanti di stringa

998
01:09:31,000 --> 01:09:34,000
vengono memorizzati che hai usato.

999
01:09:34,000 --> 01:09:42,000
E poi, più in alto c'è questo posto chiamato l'heap.

1000
01:09:42,000 --> 01:09:46,000
Abbiamo accedere alla memoria in esso, utilizzando malloc,

1001
01:09:46,000 --> 01:09:49,000
e poi verso la cima del programma

1002
01:09:49,000 --> 01:09:52,000
c'è la pila,

1003
01:09:52,000 --> 01:09:57,000
ed è lì che abbiamo giocato per la maggior parte l'inizio.

1004
01:09:57,000 --> 01:09:59,000
Questo non è in scala o altro.

1005
01:09:59,000 --> 01:10:03,000
Molto di questo è molto dipendente dalla macchina,

1006
01:10:03,000 --> 01:10:10,000
dipende dal sistema operativo, ma questo è piuttosto il modo le cose si Chunked up.

1007
01:10:10,000 --> 01:10:17,000
Quando si esegue un programma e si dichiara una variabile chiamata x-

1008
01:10:17,000 --> 01:10:27,000
Io vado a disegnare un'altra casella in basso, e questo sarà RAM pure.

1009
01:10:27,000 --> 01:10:29,000
E sto andando a guardare.

1010
01:10:29,000 --> 01:10:34,000
Ci disegnare linee frastagliate per indicare questo è solo una piccola parte di RAM

1011
01:10:34,000 --> 01:10:38,000
e non tutti come attingiamo in alto.

1012
01:10:38,000 --> 01:10:43,000
>> Se Dichiaro una variabile intera chiamata x,

1013
01:10:43,000 --> 01:10:49,000
allora quello che è realmente ottenere una mappatura

1014
01:10:49,000 --> 01:10:54,000
memorizzato nella tabella dei simboli del mio programma

1015
01:10:54,000 --> 01:11:00,000
che collega la x nome a questa regione di memoria che ho disegnato

1016
01:11:00,000 --> 01:11:03,000
proprio qui, tra le barre verticali.

1017
01:11:03,000 --> 01:11:08,000
Se ho una riga di codice nel mio programma che dice che x = 7

1018
01:11:08,000 --> 01:11:15,000
il processore sa "Oh, va bene, lo so che la vita x in questa posizione in memoria."

1019
01:11:15,000 --> 01:11:25,000
"Ho intenzione di andare avanti e scrivere un 7 lì".

1020
01:11:25,000 --> 01:11:28,000
Come fa a sapere quale posizione questo è in memoria?

1021
01:11:28,000 --> 01:11:30,000
Beh, questo è tutto fatto al momento della compilazione.

1022
01:11:30,000 --> 01:11:34,000
Il compilatore si occupa di allocare in cui ciascuna delle variabili sta per andare

1023
01:11:34,000 --> 01:11:40,000
e creando un mapping speciale o meglio i puntini

1024
01:11:40,000 --> 01:11:43,000
tra un simbolo e dove sta andando, il nome di una variabile

1025
01:11:43,000 --> 01:11:46,000
e dove sta andando a vivere nella memoria.

1026
01:11:46,000 --> 01:11:50,000
Ma si scopre che si può effettivamente accedere ai nostri programmi pure.

1027
01:11:50,000 --> 01:11:55,000
Questo diventa importante quando si comincia a parlare di alcune delle strutture di dati,

1028
01:11:55,000 --> 01:11:58,000
che è un concetto che stiamo per introdurre in seguito.

1029
01:11:58,000 --> 01:12:09,000
>> Ma per ora, quello che si può sapere è che posso creare un puntatore a questa posizione, x.

1030
01:12:09,000 --> 01:12:12,000
Per esempio, è possibile creare una variabile puntatore.

1031
01:12:12,000 --> 01:12:16,000
Quando creiamo una variabile puntatore si usa la notazione stella.

1032
01:12:16,000 --> 01:12:21,000
In questo caso, questo dice che ho intenzione di creare un puntatore a un int.

1033
01:12:21,000 --> 01:12:24,000
E 'un tipo come tutte le altre.

1034
01:12:24,000 --> 01:12:27,000
Abbiamo dato una variabile come y,

1035
01:12:27,000 --> 01:12:32,000
e poi impostarlo uguale all'indirizzo, ad un indirizzo.

1036
01:12:32,000 --> 01:12:38,000
In questo caso, si può impostare y per puntare a x

1037
01:12:38,000 --> 01:12:43,000
prendendo l'indirizzo di x, che fare con questo e commerciale,

1038
01:12:43,000 --> 01:12:55,000
e poi abbiamo fissato y per puntare ad esso.

1039
01:12:55,000 --> 01:12:59,000
Quello che in sostanza non è se guardiamo al nostro RAM

1040
01:12:59,000 --> 01:13:02,000
questo crea una variabile separata.

1041
01:13:02,000 --> 01:13:04,000
E 'intenzione di chiamarlo y,

1042
01:13:04,000 --> 01:13:06,000
e quando questa riga di codice viene eseguito

1043
01:13:06,000 --> 01:13:13,000
sta in realtà andando a creare un puntatore poco che abbiamo di solito disegnare come una freccia,

1044
01:13:13,000 --> 01:13:15,000
e pone y per puntare a x.

1045
01:13:15,000 --> 01:13:17,000
Sì.

1046
01:13:17,000 --> 01:13:19,000
[Studente] Se x è già un puntatore, vuoi solo fare

1047
01:13:19,000 --> 01:13:22,000
int * y = x al posto di avere la e commerciale?

1048
01:13:22,000 --> 01:13:24,000
Sì.

1049
01:13:24,000 --> 01:13:27,000
Se x è già un puntatore, allora è possibile impostare 2 puntatori uguali tra loro,

1050
01:13:27,000 --> 01:13:30,000
nel qual caso y non indicavano un x,

1051
01:13:30,000 --> 01:13:34,000
ma ricorda a tutto ciò che x sta puntando.

1052
01:13:34,000 --> 01:13:37,000
Purtroppo, non siamo fuori dal tempo.

1053
01:13:37,000 --> 01:13:44,000
>> Quello che vorrei dire a questo punto, possiamo parlare di questa linea,

1054
01:13:44,000 --> 01:13:49,000
ma direi che iniziare a lavorare con questo problema, # 14.

1055
01:13:49,000 --> 01:13:53,000
Si può vedere che c'è già un po 'compilato per voi qui.

1056
01:13:53,000 --> 01:13:57,000
Si può vedere che, quando dichiariamo 2 puntatori, int * x e y *,

1057
01:13:57,000 --> 01:14:01,000
e si noti che puntando il * accanto alla variabile è qualcosa che è stato fatto l'anno scorso.

1058
01:14:01,000 --> 01:14:05,000
Si scopre che questo è simile a quello che stiamo facendo quest'anno.

1059
01:14:05,000 --> 01:14:11,000
Non importa dove si scrive il * quando si dichiara il puntatore.

1060
01:14:11,000 --> 01:14:17,000
Ma abbiamo scritto il * accanto al tipo di

1061
01:14:17,000 --> 01:14:24,000
perché questo rende molto chiaro che si sta dichiarazione di una variabile puntatore.

1062
01:14:24,000 --> 01:14:27,000
Si può vedere che dichiara i 2 puntatori ci dà 2 scatole.

1063
01:14:27,000 --> 01:14:31,000
Qui quando abbiamo fissato x uguale a malloc

1064
01:14:31,000 --> 01:14:34,000
cosa sta dicendo è mettere da parte la memoria nel mucchio.

1065
01:14:34,000 --> 01:14:41,000
Questa piccola scatola proprio qui, questo cerchio, si trova sul mucchio.

1066
01:14:41,000 --> 01:14:43,000
X è ad esso.

1067
01:14:43,000 --> 01:14:46,000
Si noti che y non è ancora punta a nulla.

1068
01:14:46,000 --> 01:14:50,000
Per memoria per memorizzare il numero 42 in x

1069
01:14:50,000 --> 01:14:55,000
useremo la notazione che cosa?

1070
01:14:55,000 --> 01:14:59,000
[Studente] * x = 42.

1071
01:14:59,000 --> 01:15:01,000
Esattamente, * x = 42.

1072
01:15:01,000 --> 01:15:06,000
Questo significa seguire la freccia e gettare 42 in là.

1073
01:15:06,000 --> 01:15:09,000
Qui è dove si imposta y e x, abbiamo y punta a x.

1074
01:15:09,000 --> 01:15:13,000
Ancora una volta, questo è proprio come quello che Kevin ha detto dove si imposta y = x.

1075
01:15:13,000 --> 01:15:15,000
Y non punta a x.

1076
01:15:15,000 --> 01:15:19,000
Piuttosto, sta puntando a ciò che x sta indicando pure.

1077
01:15:19,000 --> 01:15:24,000
>> E poi, infine, in questa ultima finestra ci sono 2 possibili cose che potremmo fare.

1078
01:15:24,000 --> 01:15:28,000
Uno è, potremmo dire * x = 13.

1079
01:15:28,000 --> 01:15:33,000
L'altra cosa è che potrebbe dire-Alex, sai cosa potremmo fare qui?

1080
01:15:33,000 --> 01:15:37,000
Si potrebbe dire che x * = 13 o-

1081
01:15:37,000 --> 01:15:41,000
[Studente] Si potrebbe dire qualunque int.

1082
01:15:41,000 --> 01:15:45,000
[Nate H] Se questo fosse indicato come una variabile int potremmo farlo.

1083
01:15:45,000 --> 01:15:49,000
Potremmo anche dire * y = 13, perché sono entrambi puntando nello stesso posto,

1084
01:15:49,000 --> 01:15:51,000
in modo da poter utilizzare sia variabile per arrivarci.

1085
01:15:51,000 --> 01:15:56,000
Si '. >> [Studente] Che cosa sarebbe simile se ci limitiamo a dire x int è 13?

1086
01:15:56,000 --> 01:16:00,000
Questo sarebbe dichiara una nuova variabile chiamata x, che non avrebbe funzionato.

1087
01:16:00,000 --> 01:16:04,000
Avremmo una collisione perché abbiamo dichiarato x essere un puntatore qui.

1088
01:16:04,000 --> 01:16:10,000
[Studente] Se abbiamo avuto solo questa affermazione di per sé ciò che potrebbe somigliare in termini di cerchio?

1089
01:16:10,000 --> 01:16:14,000
Se avessimo x = 13 allora avremmo una scatola, e piuttosto che avere una freccia

1090
01:16:14,000 --> 01:16:16,000
che esce dalla scatola l'avevamo disegnare come solo un 13.

1091
01:16:16,000 --> 01:16:19,000
[Studente] Nella finestra. Va bene.

1092
01:16:19,000 --> 01:16:24,000
>> Grazie per la visione, e buona fortuna per il Quiz 0.

1093
01:16:24,000 --> 01:16:28,000
[CS50.TV]