1
00:00:00,000 --> 00:00:02,310
[Powered by Google Translate] [Settimana 4, Continua]

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

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

4
00:00:07,290 --> 00:00:11,290
>> Questo è CS50, e questa è la fine della settimana 4.

5
00:00:11,290 --> 00:00:14,030
Quindi una buona notizia e una cattiva notizia.

6
00:00:14,030 --> 00:00:26,240
Nessuna lezione di Lunedi, nessun problema impostare la prossima settimana. [Studenti tifo]

7
00:00:26,240 --> 00:00:28,680
Non ti piacerà dove questo sta andando.

8
00:00:28,680 --> 00:00:31,590
Ma noi abbiamo questo invece Mercoledì prossimo,

9
00:00:31,590 --> 00:00:37,740
e c'è anche per la conferenza programma 1 Venerdì Venerdì prossimo in modo da poter rimanere in pista.

10
00:00:37,740 --> 00:00:40,580
Ma tutto sarà girato come al solito, quindi non preoccuparti.

11
00:00:40,580 --> 00:00:44,100
>> E per quanto riguarda i quiz 0 quello che faremo verso la fine della settimana

12
00:00:44,100 --> 00:00:47,140
è pubblicare sul cs50.net homepage del corso una spiegazione

13
00:00:47,140 --> 00:00:50,160
di che tipo di aspettative si dovrebbe avere quando si tratta il primo quiz.

14
00:00:50,160 --> 00:00:55,100
In generale, sarà a scelta multipla, vero-falso, risposte brevi, brevi problemi di codifica.

15
00:00:55,100 --> 00:00:57,360
Lei non sta andando ad essere tenuti ad attuare l'equivalente

16
00:00:57,360 --> 00:01:00,030
di un problema che si vede su un pset, per il quale si dispone di un computer

17
00:01:00,030 --> 00:01:03,240
e un debugger e simili, ma ci saranno piccoli problemi di codifica.

18
00:01:03,240 --> 00:01:06,900
>> E in effetti, la migliore guida per ottenere un senso di ciò che CS50 quiz sono come

19
00:01:06,900 --> 00:01:09,180
è andare a cs50.net, andare al Quiz link,

20
00:01:09,180 --> 00:01:11,920
e si può vedere il passato parecchi anni vale la pena di quiz.

21
00:01:11,920 --> 00:01:16,600
Basta rendersi conto che il curriculum non è sempre stata la stessa nel corso degli anni.

22
00:01:16,600 --> 00:01:18,510
A volte si aggiunge, a volte sottrarre,

23
00:01:18,510 --> 00:01:20,670
quindi se vedete qualche argomento in uno di quei vecchi quiz

24
00:01:20,670 --> 00:01:25,380
che non avete idea di cosa si sta parlando, è uno dei due che abbiamo fatto coprire

25
00:01:25,380 --> 00:01:27,210
o che non lo riguardano.

26
00:01:27,210 --> 00:01:31,110
Ma in forma di recensioni, questa Domenica, Lunedi e Martedì

27
00:01:31,110 --> 00:01:34,770
così come un corso a livello sessione di revisione nella notte di Domenica -

28
00:01:34,770 --> 00:01:37,500
ora e luogo che saranno annunciati sulla home page del corso -

29
00:01:37,500 --> 00:01:40,120
tutti hanno l'opportunità di rivedere con compagni di insegnamento del corso

30
00:01:40,120 --> 00:01:44,830
il materiale per quest'anno, sia in sezione e come classe piena,

31
00:01:44,830 --> 00:01:48,400
e quelli sarà girato come al solito pure.

32
00:01:48,400 --> 00:01:53,380
>> Bene. Quindi, senza ulteriori indugi, un commento su pass / fail e add / drop.

33
00:01:53,380 --> 00:01:57,980
Potreste aver visto le mie note la scorsa notte, e questo è davvero solo un po 'di rassicurazione ulteriore

34
00:01:57,980 --> 00:02:01,250
che se siete tra coloro particolarmente comodo o meno una via di mezzo

35
00:02:01,250 --> 00:02:04,870
e ti senti solo un po 'in sopra la vostra testa,

36
00:02:04,870 --> 00:02:08,430
si rendono conto che è davvero tutto normale, e non c'è una struttura di sostegno ampio in atto,

37
00:02:08,430 --> 00:02:13,530
uno dei quali orari di ufficio erano intenti a migliorare ancor più per la mia notte ultima e-mail,

38
00:02:13,530 --> 00:02:16,520
e realizzare anche che un'opzione come pass / fail per una classe come questa

39
00:02:16,520 --> 00:02:21,540
in realtà è inteso come un meccanismo per eliminare il bordo di un corso come questo,

40
00:02:21,540 --> 00:02:24,200
in modo che ancora una volta, se stai spendendo quei 10, 15, 20 ore

41
00:02:24,200 --> 00:02:28,160
solo cercando di ottenere qualche pset al lavoro e sai che sei il 90-95% del tragitto

42
00:02:28,160 --> 00:02:32,100
ma non riesci a trovare un po 'di bug maledetto, in un pass / fail modello che è una sorta di bene.

43
00:02:32,100 --> 00:02:36,230
>> L'idea è che con tale meccanismo si può quindi andare attenzione per i vostri pset altri

44
00:02:36,230 --> 00:02:39,530
o dormire o qualsiasi altra cosa è che si vuole mettere a fuoco.

45
00:02:39,530 --> 00:02:43,390
Così si rendono conto che avete tempo fino al il prossimo Martedì - tecnicamente il 5 Lunedi,

46
00:02:43,390 --> 00:02:50,840
ma è una vacanza, quindi il prossimo Martedì - per passare dal passo / non versa graduali o viceversa.

47
00:02:50,840 --> 00:02:54,450
E se sei davvero sull'orlo del precipizio e stanno pensando di abbandonare del tutto,

48
00:02:54,450 --> 00:02:56,440
Si prega di prendere me dopo lezione o mandami una nota.

49
00:02:56,440 --> 00:02:59,990
Ci piacerebbe almeno chiacchierata prima di addio.

50
00:02:59,990 --> 00:03:03,470
Bene. Così abbiamo iniziato a prendere le rotelle fuori l'ultima volta.

51
00:03:03,470 --> 00:03:06,030
In particolare, ci siamo concentrati sulla corda.

52
00:03:06,030 --> 00:03:09,740
String è qualcosa che è dichiarata nella libreria CS50,

53
00:03:09,740 --> 00:03:14,340
in particolare in quel file chiamato cs50.h che inizieremo a guardare questa settimana e la prossima.

54
00:03:14,340 --> 00:03:17,250
Ma stringa è in realtà solo una semplificazione di qualcosa

55
00:03:17,250 --> 00:03:20,980
che è un po 'più arcanamente descritto come char *.

56
00:03:20,980 --> 00:03:24,090
Char siamo a conoscenza. E 'solo un singolo carattere.

57
00:03:24,090 --> 00:03:28,010
Ma * a partire da Lunedi indicato che cosa? >> [Studente] Puntatore.

58
00:03:28,010 --> 00:03:31,290
Un puntatore. E che cosa è un puntatore? >> [Studente] Un indirizzo.

59
00:03:31,290 --> 00:03:33,420
>> E 'come un indirizzo, una locazione di memoria.

60
00:03:33,420 --> 00:03:35,910
Che cos'è un indirizzo o la posizione o la memoria?

61
00:03:35,910 --> 00:03:40,290
Ancora una volta, tutti noi abbiamo laptop con un concerto o 2 gigabyte di RAM molto probabilmente in questi giorni,

62
00:03:40,290 --> 00:03:44,160
e questo significa che si dispone di un miliardo o 2 miliardi di byte di memoria vale la pena.

63
00:03:44,160 --> 00:03:46,240
E non importa quello che sembra fisicamente come,

64
00:03:46,240 --> 00:03:51,220
ma prendere sulla fede che si può numerare tutti i singoli byte che il proprio computer portatile ha -

65
00:03:51,220 --> 00:03:54,580
questo è il byte 0, questo è il byte 1, questo è byte 2 miliardi di euro -

66
00:03:54,580 --> 00:03:56,100
e questo è esattamente ciò che un computer fa.

67
00:03:56,100 --> 00:04:00,030
Quando si allocare spazio per un singolo carattere, per esempio,

68
00:04:00,030 --> 00:04:02,480
che ha ovviamente a vivere da qualche parte nella memoria del computer,

69
00:04:02,480 --> 00:04:05,860
e forse è al numero di byte 12345,

70
00:04:05,860 --> 00:04:08,470
e che da qualche parte qui in memoria del computer.

71
00:04:08,470 --> 00:04:12,630
E poi l'indirizzo di quel personaggio è 12345.

72
00:04:12,630 --> 00:04:16,140
>> Ora, nella settimana da 0 a ora finora, non abbiamo veramente a cuore

73
00:04:16,140 --> 00:04:19,170
dove in memoria le cose sono memorizzati perché di solito utilizzano simboli,

74
00:04:19,170 --> 00:04:22,540
variabili e matrici per ottenere effettivamente i nostri dati.

75
00:04:22,540 --> 00:04:24,950
Ma, come di Lunedi e tanto più oggi, si sta ora andando ad avere

76
00:04:24,950 --> 00:04:27,710
tutte le funzionalità più espressivi con i programmi di scrittura

77
00:04:27,710 --> 00:04:31,330
per manipolare davvero memoria di un computer ma si vede in forma,

78
00:04:31,330 --> 00:04:33,720
sia per scopi buoni e cattivi,

79
00:04:33,720 --> 00:04:39,620
bug è un risultato molto comune a questo punto imparare questa roba.

80
00:04:39,620 --> 00:04:42,460
Ma che cosa significa realmente essere un char *?

81
00:04:42,460 --> 00:04:46,140
Andiamo avanti a indietro - e torneremo a Binky come promesso oggi.

82
00:04:46,140 --> 00:04:48,670
Andiamo in un semplice esempio qui.

83
00:04:48,670 --> 00:04:53,060
Vorrei salvare il file come compare.c, e vorrei solo avere un po 'di codice modello qui

84
00:04:53,060 --> 00:05:00,490
in modo da includere stdio.h, mi permetto anche di darmi includono cs50.h. Io zoom lassù.

85
00:05:00,490 --> 00:05:05,850
Vorrei iniziare a scrivere int main, main (), e ora voglio fare qualcosa di simile a questa:

86
00:05:05,850 --> 00:05:13,520
printf ("Dammi una stringa:") e poi userò stringa s viene GetString

87
00:05:13,520 --> 00:05:16,750
per ottenere una stringa da parte dell'utente, quindi ho intenzione di chiedere all'utente per un altro.

88
00:05:16,750 --> 00:05:21,870
("Dammi un'altra stringa:") e ho intenzione di chiedere loro tramite GetString per ottenere che.

89
00:05:21,870 --> 00:05:27,020
Io lo chiamo t t perché viene dopo s ed s è un bel nome per una stringa, se è abbastanza generico.

90
00:05:27,020 --> 00:05:30,030
Così GetString, e adesso voglio solo fare un controllo di integrità e ho intenzione di dire

91
00:05:30,030 --> 00:05:39,770
if (s == t) allora sto solo andando a informare l'utente printf ("Hai digitato la stessa cosa \ n");

92
00:05:39,770 --> 00:05:45,520
altra cosa io vado a stampare qualcosa di simile ("Hai digitato qualcosa di diverso! \ n")

93
00:05:45,520 --> 00:05:48,460
o qualsiasi altra cosa la sentenza sarà. Quindi, qualcosa di simile.

94
00:05:48,460 --> 00:05:52,200
Poi, come al solito, tornerò 0 che significava solo che nulla di male è accaduto,

95
00:05:52,200 --> 00:05:54,400
e ho intenzione di andare avanti e compilare ed eseguire il programma.

96
00:05:54,400 --> 00:05:56,540
>> Ma il Lunedi abbiamo fatto questo programma,

97
00:05:56,540 --> 00:06:00,420
e in realtà hanno detto che non è CIAO CIAO CIAO e non è un addio.

98
00:06:00,420 --> 00:06:03,140
Il comportamento che abbiamo visto era un po 'più simile a questo.

99
00:06:03,140 --> 00:06:11,450
Lasciami andare nella mia directory di origine, zoom in qui, e facciamolo fare confrontare.

100
00:06:11,450 --> 00:06:14,570
Compilato bene. Vorrei correre confrontare. Dammi una stringa: CIAO.

101
00:06:14,570 --> 00:06:16,300
Dammi un'altra stringa: CIAO.

102
00:06:16,300 --> 00:06:18,000
È stato digitato qualcosa di diverso!

103
00:06:18,000 --> 00:06:22,650
Beh, mi permetta di provare qualcosa di più semplice come 50, 50. È stato digitato qualcosa di diverso!

104
00:06:22,650 --> 00:06:25,740
hi, hi. Quindi, chiaramente, qualcosa sta succedendo qui.

105
00:06:25,740 --> 00:06:28,440
Ma qual è stata la spiegazione del perché?

106
00:06:28,440 --> 00:06:33,850
A quanto pare, la linea 12 è completamente disfunzionale.

107
00:06:34,300 --> 00:06:39,430
Qual è il problema fondamentale qui? Gia '. >> [Studente] E 'confrontando gli indirizzi.

108
00:06:39,430 --> 00:06:41,850
Sì, esattamente. In realtà confrontando gli indirizzi

109
00:06:41,850 --> 00:06:44,580
in cui CIAO CIAO e sono memorizzati.

110
00:06:44,580 --> 00:06:48,290
Non è a confronto le lettere CIAO ancora e ancora,

111
00:06:48,290 --> 00:06:52,370
perché quello che è realmente accaduto, tutto questo tempo abbiamo usato GetString -

112
00:06:52,370 --> 00:06:56,130
Questa lavagna è ancora una volta la memoria del nostro computer,

113
00:06:56,130 --> 00:07:00,100
e diciamo che io chiamo GetString dopo aver dichiarato una variabile s.

114
00:07:00,100 --> 00:07:01,930
Cosa fa la mia memoria assomiglia?

115
00:07:01,930 --> 00:07:07,070
Facciamo arbitrariamente dire che s assomiglia a questo. Si tratta di un quadrato.

116
00:07:07,070 --> 00:07:09,040
E più o meno ogni volta che ho disegnato un pezzo di memoria sullo schermo

117
00:07:09,040 --> 00:07:12,860
se è a 32 bit ho disegnare quadrati come questo perché in effetti all'interno dell'apparecchio,

118
00:07:12,860 --> 00:07:17,380
un puntatore, un indirizzo, è di 32 bit. E 'la stessa di un int.

119
00:07:17,380 --> 00:07:19,420
Che possono variare in base al sistema del computer.

120
00:07:19,420 --> 00:07:24,630
Quelli di voi che sono vagamente a conoscenza del fatto che il vostro Mac o PC è a 64 bit,

121
00:07:24,630 --> 00:07:28,120
che indica in realtà che il computer utilizza puntatori a 64 bit,

122
00:07:28,120 --> 00:07:33,730
Indirizzi a 64 bit, e tra gli aspetti positivi di questo è il vostro computer

123
00:07:33,730 --> 00:07:35,560
possono disporre di RAM molto più di un tempo.

124
00:07:35,560 --> 00:07:39,240
Per farla breve, nel giorno in cui i computer utilizzati solo 32 bit

125
00:07:39,240 --> 00:07:42,740
per rappresentare gli indirizzi, il maggior numero di byte che potrebbe rappresentare

126
00:07:42,740 --> 00:07:46,280
in questo caso era quello che se si dispone di 32 bit?

127
00:07:46,280 --> 00:07:49,590
Quindi 4 miliardi, giusto, perché da 2 a 32 è di 4 miliardi di euro.

128
00:07:49,590 --> 00:07:51,370
Questo numero è stato ricorrenti nel corso.

129
00:07:51,370 --> 00:07:55,240
>> Quindi, se avete solo 32 bit, il numero più alto si può contare fino a è di circa 4 miliardi.

130
00:07:55,240 --> 00:07:58,750
Ma quella era una limitazione fondamentale di computer fino a pochi anni fa

131
00:07:58,750 --> 00:08:01,180
perché se si può contare solo più in alto come 4 miliardi di euro,

132
00:08:01,180 --> 00:08:05,270
non importa se si acquista 8 gigabyte di RAM o anche 5 gigabyte di RAM;

133
00:08:05,270 --> 00:08:07,780
non si può contare così in alto, quindi era inutile.

134
00:08:07,780 --> 00:08:11,430
Si può accedere solo i primi 3 o 4 gigabyte di memoria del computer.

135
00:08:11,430 --> 00:08:14,410
Questo è meno di un problema ora, e si possono acquistare MacBook Pro e Dells

136
00:08:14,410 --> 00:08:17,680
con 8 gigabyte di RAM o anche di più in questi giorni.

137
00:08:17,680 --> 00:08:24,100
Ma se allocare semplicemente in questo programma un puntatore, un puntatore chiamato s,

138
00:08:24,100 --> 00:08:28,370
potrebbe apparire come questo sullo schermo perché in effetti abbiamo bisogno di togliere questo strato.

139
00:08:28,370 --> 00:08:33,520
Continuo a dire stringa, ma come di Lunedi, la stringa è davvero char *,

140
00:08:33,520 --> 00:08:35,590
l'indirizzo di qualche personaggio.

141
00:08:35,590 --> 00:08:39,280
Quindi cerchiamo di prendere la ruota formazione fuori, anche se continueremo a utilizzare GetString per ora.

142
00:08:39,280 --> 00:08:42,600
Così ho dichiarato s, e questo è un pezzo di memoria a 32 bit.

143
00:08:42,600 --> 00:08:47,370
Cosa c'è qui in memoria di default? >> [Risposta degli studenti incomprensibile]

144
00:08:47,370 --> 00:08:50,040
Che cos'è? >> [Studente] Garbage. Garbage >>. Esattamente.

145
00:08:50,040 --> 00:08:54,610
Se il programmatore non mettere un valore in una variabile, che sa che cos'è?

146
00:08:54,610 --> 00:08:57,990
A volte sei fortunato ed è 0, che è una specie di bello, valore di default pulito,

147
00:08:57,990 --> 00:09:00,310
ma come abbiamo visto Lunedi, a volte è assolutamente privi di senso,

148
00:09:00,310 --> 00:09:04,130
un numero veramente grande positivo o negativo che è venuto da dove?

149
00:09:05,350 --> 00:09:07,010
Gia '. >> [Studente] La funzione prima. Sì >>.

150
00:09:07,010 --> 00:09:10,170
>> Spesso la funzione che ha chiamato prima, perché ricordare,

151
00:09:10,170 --> 00:09:13,920
come si chiamano le funzioni in memoria, occupano sempre più spazio dal basso verso l'alto,

152
00:09:13,920 --> 00:09:17,040
e non appena la funzione ritorna, che la memoria viene riutilizzata

153
00:09:17,040 --> 00:09:20,890
per la persona accanto che viene chiamato, che utilizzano la vostra stessa porzione di memoria.

154
00:09:20,890 --> 00:09:23,450
E se hai spazzatura di sinistra, i valori precedenti,

155
00:09:23,450 --> 00:09:28,190
potremmo scambiare s come avere un certo valore, quando in realtà non abbiamo messo nulla.

156
00:09:28,190 --> 00:09:30,960
Quindi la nostra RAM, a questo punto si presenta così.

157
00:09:30,960 --> 00:09:36,030
Ora sul lato destro della linea 7 che stiamo chiamando GetString,

158
00:09:36,030 --> 00:09:40,150
che stiamo facendo da settimane, ma ciò che è GetString facendo veramente?

159
00:09:40,150 --> 00:09:43,350
GetString scritto dal personale CS50 è un po 'intelligente

160
00:09:43,350 --> 00:09:46,500
dal fatto che, non appena l'utente inizia tasti battitura e colpisce Invio,

161
00:09:46,500 --> 00:09:50,010
GetString figure quante battute ha fatto il colpo d'uso,

162
00:09:50,010 --> 00:09:53,360
il numero di caratteri devo allocata memoria RAM.

163
00:09:53,360 --> 00:09:55,660
E dove che la RAM viene, chi lo sa?

164
00:09:55,660 --> 00:09:58,930
E 'da qualche parte nel vostro computer o roba del genere 2 gigabyte di memoria.

165
00:09:58,930 --> 00:10:05,200
Ma supponiamo che il computer trovato spazio per la parola CIAO proprio qui.

166
00:10:05,200 --> 00:10:08,710
La parola che ho scritto era H-E-L-L-O.

167
00:10:08,710 --> 00:10:13,510
E se disegnare questo come una sequenza di caratteri, possiamo disegnare come questo.

168
00:10:13,510 --> 00:10:17,860
Ma ho bisogno di fare 1 cosa in più. Ciò che appartiene alla fine di una stringa in C?

169
00:10:17,860 --> 00:10:20,710
Il carattere nullo, che si scrive come \ 0.

170
00:10:20,710 --> 00:10:23,980
E 'tecnicamente il numero 0, ma il backslash rende tutto più chiaro

171
00:10:23,980 --> 00:10:28,150
che questo è letteralmente il numero 0, il numero intero 0;

172
00:10:28,150 --> 00:10:32,440
non è, ad esempio, quote-unquote 0 che è possibile digitare sulla tastiera.

173
00:10:32,440 --> 00:10:33,940
Quindi questo è CIAO.

174
00:10:33,940 --> 00:10:36,350
>> E che cosa abbiamo detto il Lunedi che una funzione come GetString

175
00:10:36,350 --> 00:10:39,580
è in realtà tornando tutte queste settimane?

176
00:10:39,580 --> 00:10:43,960
Non è restituendo una stringa di per sé in quanto che in realtà non hanno un significato

177
00:10:43,960 --> 00:10:47,710
perché le stringhe non esistono. Sono una sorta di fabbricazione nella libreria CS50.

178
00:10:47,710 --> 00:10:51,300
Quello che è veramente una stringa, più tecnicamente? >> [Studente] E 'il primo carattere.

179
00:10:51,300 --> 00:10:55,950
Esattamente. E 'semplicemente l'indirizzo del primo carattere che l'utente ha digitato trovi

180
00:10:55,950 --> 00:11:02,810
Quindi, se la mia parola CIAO finisce a 123 il numero di byte e quindi al numero di byte 124,

181
00:11:02,810 --> 00:11:08,320
125, 126, e così via, se ho solo il mio numero di byte da 0 in su,

182
00:11:08,320 --> 00:11:12,650
ciò che realmente sta tornando GetString è letteralmente il numero 123.

183
00:11:12,650 --> 00:11:19,270
Quindi, ciò che viene messo in s è il numero 123, non la lettera H, non la parola CIAO,

184
00:11:19,270 --> 00:11:23,130
semplicemente l'indirizzo al quale riesco a trovare la prima lettera di CIAO.

185
00:11:23,130 --> 00:11:26,500
Ma questo non sembra sufficiente. Ti ho chiesto per una stringa, non un carattere.

186
00:11:26,500 --> 00:11:32,970
Quindi, come possiamo o il computer sa che ELLO tipo di venire con la H?

187
00:11:35,760 --> 00:11:37,460
Qual è il tipo di accordo che abbiamo? Gia '.

188
00:11:37,460 --> 00:11:40,100
[Studente] Si continua a dire se stesso per trovare un po 'di più caratteri. >> Esattamente.

189
00:11:40,100 --> 00:11:44,570
>> C'e 'un uomo-computer convenzione per cui quando hai a che fare con le stringhe,

190
00:11:44,570 --> 00:11:49,410
altrimenti noto ora come stelle char, devi semplicemente capire

191
00:11:49,410 --> 00:11:54,350
dove alla fine di ogni stringa nella vita è in realtà solo da iterando su di esso con un ciclo for,

192
00:11:54,350 --> 00:11:57,820
un ciclo while, qualunque cosa, in modo che quando si trova alla fine della stringa

193
00:11:57,820 --> 00:12:02,160
ora si può dedurre da questo, oh, l'intera parola è stata CIAO.

194
00:12:02,160 --> 00:12:04,820
Quelli di voi con esperienza di programmazione precedente potrebbe sapere in Java

195
00:12:04,820 --> 00:12:09,880
si può chiamare. lunghezza e in altre lingue è possibile chiamare lunghezza o simili.

196
00:12:09,880 --> 00:12:14,060
Questo perché in molte lingue, in particolare cose chiamate linguaggi orientati agli oggetti,

197
00:12:14,060 --> 00:12:18,580
la lunghezza di qualcosa è una specie di incapsulato all'interno del pezzo dei dati stessi,

198
00:12:18,580 --> 00:12:24,000
un po 'come noi ID incapsulati e nomi e le case all'interno di uno studente il Lunedi.

199
00:12:24,000 --> 00:12:28,700
Ma C è di livello molto più basso. Non ci sono oggetti o classi, se hai sentito questi termini prima.

200
00:12:28,700 --> 00:12:31,490
Tutto quello che è in realtà gli indirizzi di memoria.

201
00:12:31,490 --> 00:12:35,540
Quindi questa è una sorta di vecchia maniera di rappresentare strutture di dati interessanti.

202
00:12:35,540 --> 00:12:38,760
Si dispone di un valore iniziale come l'indirizzo del primo carattere

203
00:12:38,760 --> 00:12:42,340
e poi basta un po 'di convenzione arbitraria che tutti sono d'accordo a seguire.

204
00:12:42,340 --> 00:12:46,420
Così come è la lunghezza della stringa attuato, ha proponiamo?

205
00:12:46,420 --> 00:12:51,360
Strlen, strlen, che alcuni di voi hanno utilizzato un paio di volte. E 'piuttosto semplice, no?

206
00:12:51,360 --> 00:12:53,060
E 'come 2 righe di codice.

207
00:12:53,060 --> 00:12:56,140
E 'praticamente un ciclo per di qualche tipo, magari con una variabile aggiuntiva locale.

208
00:12:56,140 --> 00:13:00,540
Ma strlen deve solo prendere un puntatore e poi iniziare a cercare \ 0.

209
00:13:00,540 --> 00:13:05,190
>> E non appena lo trova, può restituire il numero totale di passi che è preso in quella stringa.

210
00:13:05,190 --> 00:13:07,150
Quindi possiamo dedurre da questo quello che succede dopo.

211
00:13:07,150 --> 00:13:11,850
Supponiamo quindi Dichiaro t come ho fatto nella riga 10.

212
00:13:11,850 --> 00:13:14,280
Questo è un valore immondizia. Chissà in un primo momento?

213
00:13:14,280 --> 00:13:18,490
Ma sul lato destro della linea di 10 Chiamo GetString nuovo.

214
00:13:18,490 --> 00:13:20,050
Chi sa dove questo finisce?

215
00:13:20,050 --> 00:13:23,830
Facciamo arbitrariamente dire che il sistema operativo trovato spazio per essa fin qui.

216
00:13:23,830 --> 00:13:28,610
Mi è capitato di scrivere a caso H-E-L-L-O ancora,

217
00:13:28,610 --> 00:13:31,260
e così possiamo trarre lo stesso tipo di immagine.

218
00:13:31,260 --> 00:13:34,290
Ma il fatto che ho ridisegnato questa immagine è deliberata

219
00:13:34,290 --> 00:13:37,720
perché questo è un altro CIAO di questo.

220
00:13:37,720 --> 00:13:43,920
Ecco questo potrebbe essere posizione 456, questo è 457, e così via.

221
00:13:43,920 --> 00:13:47,170
Quindi, ciò che viene messo in cui il punto di domanda era una volta?

222
00:13:47,170 --> 00:13:50,190
In questo caso 456.

223
00:13:50,190 --> 00:13:53,540
Stiamo raccogliendo questi numeri arbitrariamente perché in realtà a partire da oggi

224
00:13:53,540 --> 00:13:57,110
non stiamo andando a prendersi cura così tanto su ciò che l'indirizzo di qualsiasi cosa è.

225
00:13:57,110 --> 00:14:02,690
Tutto quello che interessa è che siamo in grado di capire l'indirizzo di qualche pezzo di dati come CIAO.

226
00:14:02,690 --> 00:14:07,100
>> Quindi, in realtà ciò che la maggior parte delle persone fanno in informatica quando si parla di indirizzi di memoria

227
00:14:07,100 --> 00:14:10,210
e parlando di puntatori in particolare,

228
00:14:10,210 --> 00:14:14,220
piuttosto che preoccuparsi di capire 123 - chi se ne frega se questa roba è in realtà,

229
00:14:14,220 --> 00:14:17,440
sappiamo solo che è a un certo indirizzo numerico -

230
00:14:17,440 --> 00:14:22,180
semplifichiamo il mondo e solo dire che s punta a quel personaggio

231
00:14:22,180 --> 00:14:25,080
e t punta a quel personaggio.

232
00:14:25,080 --> 00:14:27,430
E il fatto che è una freccia è piuttosto intenzionale

233
00:14:27,430 --> 00:14:31,610
perché letteralmente ora s è puntato verso H e t è puntato verso l'altro H

234
00:14:31,610 --> 00:14:34,720
perché alla fine della giornata, non importa quanto sia l'indirizzo,

235
00:14:34,720 --> 00:14:40,240
ma è importante che abbiamo la capacità di esprimere l'indirizzo con qualche pezzo di codice.

236
00:14:40,240 --> 00:14:42,730
Non abbiamo davvero manipolato questi indirizzi appena ancora

237
00:14:42,730 --> 00:14:47,770
quindi vedremo dove possiamo intervenire con e ordinare di fare le cose con i puntatori,

238
00:14:47,770 --> 00:14:52,030
ma per ora in linea 12 letteralmente quali valori stiamo confrontando

239
00:14:52,030 --> 00:14:55,500
in base a questa storia nella riga 12?

240
00:14:56,570 --> 00:15:01,290
Stiamo dicendo che è 123 pari pari a 456? E questo non è assolutamente il caso.

241
00:15:01,290 --> 00:15:05,320
E anche concettualmente, questo puntatore non è assolutamente la stessa di questa

242
00:15:05,320 --> 00:15:09,500
perché hai chiamato GetString due volte, e GetString non cerca di essere super intelligente,

243
00:15:09,500 --> 00:15:12,470
non cercare di capire, oh, avete digitato CIAO 5 minuti fa;

244
00:15:12,470 --> 00:15:15,090
lasciate che vi dia lo stesso puntatore come ti ho dato prima,

245
00:15:15,090 --> 00:15:18,450
assegna solo una nuova porzione di memoria ogni volta che viene chiamata.

246
00:15:18,450 --> 00:15:20,350
>> Quindi, come possiamo risolvere questo problema?

247
00:15:20,350 --> 00:15:24,270
Se un livello superiore voglio confrontare le stringhe CIAO CIAO e -

248
00:15:24,270 --> 00:15:28,680
Non mi importa delle indicazioni - come posso fare per rispondere alla domanda,

249
00:15:28,680 --> 00:15:31,980
ha l'utente digita la stessa cosa? Che cosa è necessario qui? Gia '.

250
00:15:31,980 --> 00:15:35,200
[Studente] Utilizzare una funzione. >> Riesco ad usare una funzione, fuori dalla scatola.

251
00:15:35,200 --> 00:15:38,170
Riesco ad usare una funzione chiamata strcmp, s-t-r-c-m-p,

252
00:15:38,170 --> 00:15:41,190
solo la versione abbreviata di dire stringa confrontare.

253
00:15:41,190 --> 00:15:45,070
E se andiamo in, per esempio, confrontare 2, che è tra gli stampati di oggi,

254
00:15:45,070 --> 00:15:46,690
Faccio esattamente questo.

255
00:15:46,690 --> 00:15:51,750
Ho tenuto tutto il resto lo stesso dalla linea 1 in giù a 26 o giù di lì,

256
00:15:51,750 --> 00:15:54,360
e ora notate questa parte è cambiato solo un po '.

257
00:15:54,360 --> 00:15:57,690
Ignoriamo linea 28 per un momento e concentrarsi solo su questo.

258
00:15:57,690 --> 00:16:00,410
Cosa abbiamo detto Lunedi che str confronto fa?

259
00:16:00,410 --> 00:16:05,200
Gestisce il processo di prendere due puntatori, S e T in questo caso,

260
00:16:05,200 --> 00:16:08,480
sorta di quasi mettere il dito su quelle 2 lettere,

261
00:16:08,480 --> 00:16:11,530
e ciò che deve fare è qualcosa di simile a un ciclo while o un ciclo for,

262
00:16:11,530 --> 00:16:16,050
e si dice che sono questi gli stessi? In caso affermativo, si muove le dita o puntatori avanti.

263
00:16:16,050 --> 00:16:17,970
Questi sono gli stessi, questi lo stesso, questi lo stesso,

264
00:16:17,970 --> 00:16:22,710
questi lo stesso, questi lo stesso? E ooh, io sono alla fine della stringa, sia a s e t.

265
00:16:22,710 --> 00:16:26,780
Non ho trovato alcuna contraddizione. Sì, queste stringhe sono uguali.

266
00:16:26,780 --> 00:16:31,940
E che cosa str confronta ritorno, se due stringhe sono uguali, a quanto pare? Zero.

267
00:16:31,940 --> 00:16:35,900
Quindi 0 è bene in questo caso perché se restituisce -1 o +1,

268
00:16:35,900 --> 00:16:40,560
ciò significa che s succede solo a venire prima o dopo la t in ordine alfabetico t.

269
00:16:40,560 --> 00:16:43,760
E perché ciò sarebbe utile disporre di una funzione che ti dice quale stringa viene prima

270
00:16:43,760 --> 00:16:46,720
o dopo in un dizionario?

271
00:16:46,720 --> 00:16:48,740
[Studente] Ricerca. >> Ricerca e l'ordinamento.

272
00:16:48,740 --> 00:16:51,730
>> Così si può fare le cose come ricerca binaria o bubble sort e merge sort

273
00:16:51,730 --> 00:16:53,230
dove si deve confrontare cose.

274
00:16:53,230 --> 00:16:56,420
Finora abbiamo tipo di tagliare alcune curve e solo parlato di ordinamento

275
00:16:56,420 --> 00:16:59,430
nel contesto dei numeri, perché è bello e facile parlare,

276
00:16:59,430 --> 00:17:02,430
ma si può certamente confrontare le stringhe, mela e banana,

277
00:17:02,430 --> 00:17:05,349
perché se Apple è noto per venire prima banana, allo stesso modo,

278
00:17:05,349 --> 00:17:09,319
si può spostare in giro per le stringhe in memoria, proprio come ha fatto con Rob merge sort nel video

279
00:17:09,319 --> 00:17:15,880
e lo abbiamo fatto qui sul palco con selection sort, insertion sort e bubble sort.

280
00:17:15,880 --> 00:17:18,710
Allora, dove altro possiamo prendere questo? Proviamo questo.

281
00:17:18,710 --> 00:17:23,980
Facciamo una specie di lezione dimenticare che per un momento e prova adesso e copiare 1.c effettuare le seguenti operazioni.

282
00:17:23,980 --> 00:17:26,800
In linea 21 che sto dicendo qualcosa di stampa,

283
00:17:26,800 --> 00:17:28,520
allora sto diventando una stringa da parte dell'utente,

284
00:17:28,520 --> 00:17:30,690
allora sto controllando questo.

285
00:17:30,690 --> 00:17:33,620
Non abbiamo davvero ottenuto in questa abitudine ancora, ma andiamo ora fare questo.

286
00:17:33,620 --> 00:17:40,990
Facciamo in realtà togliere questo strato. Questo è veramente char *. Questo ragazzo è davvero char *.

287
00:17:40,990 --> 00:17:45,690
Che cosa vuol dire essere il controllo se s == NULL?

288
00:17:45,690 --> 00:17:48,380
Si scopre che quando si chiama una funzione come GetString

289
00:17:48,380 --> 00:17:51,540
o più in generale, basta chiedere a un computer di darvi un po 'di memoria,

290
00:17:51,540 --> 00:17:53,030
qualcosa potrebbe andare storto.

291
00:17:53,030 --> 00:17:56,630
Potresti essere pazzo e chiedere al computer per un terabyte di memoria

292
00:17:56,630 --> 00:18:01,780
con la richiesta di migliaia di miliardi di byte di memoria che proprio non esistono nel computer,

293
00:18:01,780 --> 00:18:05,130
ma le funzioni GetString e di altri bisogno di un modo di urlare contro di voi

294
00:18:05,130 --> 00:18:06,820
se hai chiesto troppo.

295
00:18:06,820 --> 00:18:10,450
E il modo GetString fa questo è che se si hanno chiesto più memoria

296
00:18:10,450 --> 00:18:14,250
che è disponibile nel computer, anche se è super, super basso probabilità

297
00:18:14,250 --> 00:18:17,730
perché nessuno di noi sta andando a digitare mille miliardi di caratteri, quindi premere Invio,

298
00:18:17,730 --> 00:18:21,980
ma bassa probabilità per quanto possa essere, ho ancora voglia di verificare la presenza di esso nel caso in cui,

299
00:18:21,980 --> 00:18:26,120
e il valore speciale che restituisce GetString, risposta, e altre funzioni

300
00:18:26,120 --> 00:18:30,630
se qualcosa è andato storto è NULL in tutte le protezioni.

301
00:18:30,630 --> 00:18:36,520
>> E che cosa è NULL? NULL così succede per rappresentare un puntatore. E 'l'indirizzo 0 della memoria.

302
00:18:36,520 --> 00:18:40,800
Il mondo ha deciso che arbitrariamente, se questa è la memoria del mio computer - sai una cosa? -

303
00:18:40,800 --> 00:18:46,260
stiamo andando a rubare solo 1 byte di memoria di ogni computer, e questa è la posizione 0.

304
00:18:46,260 --> 00:18:49,560
Stiamo per dare un soprannome di NULL, e abbiamo intenzione di promettere

305
00:18:49,560 --> 00:18:52,660
che non saremo mai effettivamente messo dati reali ci

306
00:18:52,660 --> 00:18:56,770
perché abbiamo bisogno di arbitrariamente un valore speciale, 0, NULL alias,

307
00:18:56,770 --> 00:19:00,230
in modo che possiamo urlare agli utenti se qualcosa va storto.

308
00:19:00,230 --> 00:19:03,590
In caso contrario si potrebbe non sapere è 0 significa mettere qualcosa qui

309
00:19:03,590 --> 00:19:05,490
o significa qualcosa è andato storto?

310
00:19:05,490 --> 00:19:09,190
Siamo d'accordo tutti che non significa nulla NULL è stato restituito,

311
00:19:09,190 --> 00:19:11,700
nessun indirizzo effettivo è stato restituito.

312
00:19:11,700 --> 00:19:15,210
Ora, qui sto solo adottando la mia convenzione umana di torno 1 dal principale

313
00:19:15,210 --> 00:19:17,040
se qualcosa va storto.

314
00:19:17,040 --> 00:19:20,650
Questo perché il ritorno convenzione principale è quello di restituire 0 se buona,

315
00:19:20,650 --> 00:19:22,990
1 o qualche altro valore se male.

316
00:19:22,990 --> 00:19:28,200
Ma GetString e qualsiasi funzione che si occupa di memoria ritorna NULL se qualcosa va male.

317
00:19:28,200 --> 00:19:33,480
>> Va bene. Così, purtroppo, linea 27, super semplice che sia, non riesce completamente a copiare la stringa.

318
00:19:33,480 --> 00:19:35,740
Perché? Si può vedere questo come segue.

319
00:19:35,740 --> 00:19:40,120
Sto sostenendo in linea 27 da fare una copia di s e t chiamarlo.

320
00:19:40,120 --> 00:19:45,790
Quindi non sto chiedendo all'utente per 2 stringhe di questa volta, io sto solo dicendo che il valore in s

321
00:19:45,790 --> 00:19:47,870
dovrebbe essere messo in t pure.

322
00:19:47,870 --> 00:19:52,890
Così ora solo per dimostrare come questo è rotto, in linea 29 in poi quello che sto facendo?

323
00:19:52,890 --> 00:19:56,980
Prima Sto controllando se la lunghezza di t è maggiore di 0.

324
00:19:56,980 --> 00:19:59,330
C'è qualche stringa lì. L'utente ha digitato qualcosa trovi

325
00:19:59,330 --> 00:20:03,410
Qual è la linea 32 facendo, a quanto pare?

326
00:20:03,410 --> 00:20:08,910
[Risposta incomprensibile studente] destra >>. È possibile che tipo di dedurre da ciò che ho detto che sta facendo.

327
00:20:08,910 --> 00:20:13,200
Ma tecnicamente, cosa sta facendo questo? t [0] rappresenta ciò?

328
00:20:13,200 --> 00:20:15,140
[Studente] Il carattere 0. >> [Malan] Il carattere 0.

329
00:20:15,140 --> 00:20:19,620
O, più simile a quella umana, il primo carattere in t, qualunque essa sia, H forse in questo caso.

330
00:20:19,620 --> 00:20:24,990
E toupper fa quello che dice. Essa sfrutta il carattere zero della t e lo cambia.

331
00:20:24,990 --> 00:20:28,430
Quindi questo significa prendere il carattere zero della t, rendono maiuscolo,

332
00:20:28,430 --> 00:20:30,320
e lo rimise in quella stessa posizione.

333
00:20:30,320 --> 00:20:35,540
Quindi, se scrivo ciao in caratteri minuscoli, la situazione dovrebbe cambiare la h minuscola a una maiuscola

334
00:20:35,540 --> 00:20:41,400
Ma il problema è che nelle linee 35 e 36 quello che sto per fare è stampare per noi s e t.

335
00:20:41,400 --> 00:20:43,120
E qual è la tua sensazione?

336
00:20:43,120 --> 00:20:47,250
Che cosa sono io in realtà andando a vedere se ho digitato ciao a tutto minuscolo?

337
00:20:47,250 --> 00:20:52,280
Che cosa sta per far stampare? >> [Risposta degli studenti incomprensibile] >> Che cos'è?

338
00:20:52,280 --> 00:20:58,360
[Studente] Big H e il resto piccolo. >> Il grande H e il resto piccolo per il quale, s o t?

339
00:20:58,360 --> 00:21:03,170
[Studente] Entrambi. Entrambi >>. Esattamente. Quindi cerchiamo di vedere quello che sta succedendo qui.

340
00:21:03,170 --> 00:21:08,380
>> Lasciatemi andare avanti e compilare questo. Questo è da Copia1, in modo da rendere Copia1. Bene.

341
00:21:08,380 --> 00:21:14,840
Immagine Lasciami andare avanti ed eseguire Copia1, Enter, Inserisci commento: ciao in minuscolo.

342
00:21:14,840 --> 00:21:19,570
E 'capitalizzato la copia, ma a quanto pare capitalizzato l'originale pure,

343
00:21:19,570 --> 00:21:22,070
perché ciò che accade oggi in questa storia?

344
00:21:22,070 --> 00:21:27,030
In linea 27 che in realtà non sembrano essere la copia della stringa,

345
00:21:27,030 --> 00:21:30,450
ma anche se si potrebbe avere intuitivamente sperare che sia il caso,

346
00:21:30,450 --> 00:21:33,680
se pensi di questo quadro, ciò che veramente ho fatto?

347
00:21:33,680 --> 00:21:35,410
Metà del quadro è la stessa.

348
00:21:35,410 --> 00:21:39,390
Quindi cerchiamo di rotolare indietro nel tempo in modo che t non esiste ancora nella storia.

349
00:21:39,390 --> 00:21:43,160
S può esistere nella storia, ma cerchiamo di minuscole ciao questa volta.

350
00:21:43,160 --> 00:21:46,710
Permettetemi quindi di correggere quello che ho effettivamente digitato trovi

351
00:21:46,710 --> 00:21:51,280
In questo caso qui abbiamo h-e-l-l-o.

352
00:21:51,280 --> 00:21:58,050
Noi lo disegnare come una sequenza di caratteri, mettere le mie linee di separazione qui e la mia \ 0.

353
00:21:58,050 --> 00:22:05,980
Quindi questo è dove siamo, non appena la linea da 1 a 24-ish, prendere o lasciare, hanno eseguito.

354
00:22:05,980 --> 00:22:07,800
Questo è il quadro della mia memoria.

355
00:22:07,800 --> 00:22:10,800
Quando arrivo alla riga 27, che cosa succede?

356
00:22:10,800 --> 00:22:14,730
Proprio come prima, ottengo un puntatore, che verrà disegnare come questa piazza.

357
00:22:14,730 --> 00:22:19,740
Si chiama t. E qual è il suo valore di default? Chi lo sa? Alcuni rifiuti valore.

358
00:22:19,740 --> 00:22:22,060
>> Quindi mi astratto che via come un punto interrogativo.

359
00:22:22,060 --> 00:22:27,670
E non appena il lato destro della linea 27 viene eseguito, quello che sto mettendo dentro di t?

360
00:22:27,670 --> 00:22:30,770
La stessa cosa che è in s.

361
00:22:30,770 --> 00:22:34,120
Quindi, se per un momento rimuovere questa astrazione della freccia e diciamo,

362
00:22:34,120 --> 00:22:40,330
oh, questo è un carico indirizzo di memoria 123, quando si dice t ottiene s, punto e virgola,

363
00:22:40,330 --> 00:22:42,700
si sta letteralmente mettendo 123 qui.

364
00:22:42,700 --> 00:22:45,200
Ora, se i tipi di semplificare il nostro mondo di nuovo con le immagini,

365
00:22:45,200 --> 00:22:48,750
quello che hai fatto veramente è appena aggiunto un'altra freccia al tuo mondo

366
00:22:48,750 --> 00:22:52,910
che sta puntando da t per la stessa stringa esatta.

367
00:22:52,910 --> 00:22:59,730
Così, quando in linea 31 e 32, io in realtà andare a cambiare t [0],

368
00:22:59,730 --> 00:23:05,580
ciò che è t [0] a quanto pare sinonimo di adesso? s [0]

369
00:23:05,580 --> 00:23:07,030
Ecco, questo è tutto quello che sta succedendo.

370
00:23:07,030 --> 00:23:09,900
E anche se questo tipo di livello si sente un po 'basso e arcano

371
00:23:09,900 --> 00:23:12,760
e questo tipo di sente come forse intuitivamente questo dovrebbe essere solo lavorato -

372
00:23:12,760 --> 00:23:15,410
Ho fatto copie di cose prima e solo lavorato -

373
00:23:15,410 --> 00:23:18,590
se effettivamente pensare a quello che una stringa è in realtà, è un char *.

374
00:23:18,590 --> 00:23:21,700
Beh, che cosa è questo? E 'l'indirizzo di qualche personaggio.

375
00:23:21,700 --> 00:23:24,930
Allora forse ha più senso che quando si tenta di fare qualcosa

376
00:23:24,930 --> 00:23:29,220
Super apparentemente semplice come questo, tutto quello che stai facendo è la copia di un indirizzo di memoria.

377
00:23:29,220 --> 00:23:32,530
Lei non sta effettivamente facendo qualcosa con la stringa stessa.

378
00:23:32,530 --> 00:23:37,500
Quindi, anche se non avete idea di come si potrebbe risolvere questo problema nel codice,

379
00:23:37,500 --> 00:23:45,080
alto livello, concettualmente, che cosa dobbiamo fare per rendere ta copia conforme di s, a quanto pare?

380
00:23:46,670 --> 00:23:48,820
Gia '. >> [Studente] Dare una nuova posizione? >> Esattamente.

381
00:23:48,820 --> 00:23:50,800
>> Abbiamo bisogno di dare una nuova posizione del marchio t.

382
00:23:50,800 --> 00:23:55,230
Abbiamo bisogno di creare in qualche modo un mondo in cui si ottiene un nuovo blocco di memoria,

383
00:23:55,230 --> 00:24:00,090
che solo per motivi di chiarezza io disegnare direttamente al di sotto di questo, ma non ha bisogno di essere lì.

384
00:24:00,090 --> 00:24:04,880
Ma deve avere la stessa dimensione, quindi mi disegnare queste linee verticali nello stesso luogo.

385
00:24:04,880 --> 00:24:09,720
Va bene se si tratta di tutti i rifiuti inizialmente. Chi sa che cosa c'era?

386
00:24:09,720 --> 00:24:13,850
Ma il passaggio 1 sta per essere darmi la quantità di memoria di cui ho bisogno

387
00:24:13,850 --> 00:24:18,630
di adattamento di una copia di ciao, quindi capire come copiare il h qui, l'indirizzo qui,

388
00:24:18,630 --> 00:24:20,390
L qui e così via.

389
00:24:20,390 --> 00:24:24,880
Ma questo già dovrebbe sentire un po 'ovvio, anche se alcuni dettagli sono ancora astratto.

390
00:24:24,880 --> 00:24:28,690
Per copiare questa stringa in questo, è solo un ciclo for o un ciclo while

391
00:24:28,690 --> 00:24:31,580
o qualcosa con cui sei diventato ancora più familiare.

392
00:24:31,580 --> 00:24:35,970
Quindi cerchiamo di provare questo. Lasciami andare in copy2.c.

393
00:24:35,970 --> 00:24:43,270
In copy2.c abbiamo quasi lo stesso programma, tranne per la linea 27.

394
00:24:43,270 --> 00:24:47,260
Sembra un po 'complessa, ma se lo scomporre pezzo per pezzo,

395
00:24:47,260 --> 00:24:48,950
il lato sinistro è la stessa.

396
00:24:48,950 --> 00:24:52,790
Char * t crea questa cosa nella memoria, anche se con un punto interrogativo

397
00:24:52,790 --> 00:24:54,680
perché non abbiamo idea di quello che c'è di default.

398
00:24:54,680 --> 00:24:57,920
Sul lato destro ci stiamo ora introducendo una nuova funzione, malloc,

399
00:24:57,920 --> 00:25:00,640
per la memoria allocare, dammi la memoria,

400
00:25:00,640 --> 00:25:06,900
e ci vuole a quanto pare il numero di argomenti, quante cose tra parentesi?

401
00:25:09,660 --> 00:25:12,130
Ho sentito mormorii di 1 e 2, ma è solo 1.

402
00:25:12,130 --> 00:25:15,320
Non c'è una virgola, il che significa che c'è solo 1 cosa all'interno delle parentesi.

403
00:25:15,320 --> 00:25:17,720
Anche se ci sono altre parentesi, vorrei sottolineare

404
00:25:17,720 --> 00:25:21,460
cosa c'è dentro le parentesi più esterni, ed è questa espressione:

405
00:25:21,460 --> 00:25:25,880
(Strlen (s) + 1) * sizeof (char).

406
00:25:25,880 --> 00:25:29,190
Quindi, se in realtà credo che questo attraverso, questo sta dicendo darmi la lunghezza di s.

407
00:25:29,190 --> 00:25:34,440
Perché io sono, però, aggiungere 1 sulla lunghezza? >> [Risposta degli studenti incomprensibile]

408
00:25:34,440 --> 00:25:40,200
Esattamente. Abbiamo bisogno di spazio per questo ragazzo in coda, il sesto carattere che non ha alcun significato inglese

409
00:25:40,200 --> 00:25:42,250
ma ha particolare significato programmatico.

410
00:25:42,250 --> 00:25:46,800
>> Quindi abbiamo bisogno di un + 1 per questo, perché strlen restituisce l'attesa umana di lunghezza,

411
00:25:46,800 --> 00:25:50,890
ciao o 5, non ti dà il carattere aggiuntivo nullo.

412
00:25:50,890 --> 00:25:52,980
Quindi aggiungere manualmente questo con + 1.

413
00:25:52,980 --> 00:25:56,060
E poi questo, di dimensioni * (char), non abbiamo mai visto prima.

414
00:25:56,060 --> 00:25:57,480
Questo non è tecnicamente una funzione.

415
00:25:57,480 --> 00:26:04,150
E 'una parola chiave speciale che dice solo quello che la dimensione è di un certo tipo di dati in un computer

416
00:26:04,150 --> 00:26:06,980
perché in realtà, alcuni di noi hanno computer a 32 bit.

417
00:26:06,980 --> 00:26:10,900
Ho un computer piuttosto vecchio a casa, e utilizza solo 32 bit per rappresentare i puntatori.

418
00:26:10,900 --> 00:26:13,900
E quindi se ho fatto dimensione di un tipo di dati, potrebbe essere a 32 bit.

419
00:26:13,900 --> 00:26:18,300
Ma se sto usando il mio nuovo computer fantasia, potrei tornare un valore di 64 bit

420
00:26:18,300 --> 00:26:20,510
per qualcosa come un indirizzo.

421
00:26:20,510 --> 00:26:25,400
Quindi, in questo caso, giusto per essere sicuri super, non stiamo andando a qualcosa di duro come il codice -

422
00:26:25,400 --> 00:26:28,740
bene, qual è la dimensione di un char in base a quello che abbiamo detto finora?

423
00:26:28,740 --> 00:26:34,450
Abbiamo più o meno ha detto verbalmente che è 1 byte, e questo è più o meno vero su tutta la linea.

424
00:26:34,450 --> 00:26:37,000
Ma ancora una volta, le ipotesi tendono ad essere cattivi.

425
00:26:37,000 --> 00:26:40,850
Essi conducono al software bacato se la gente usa il software in modi che non aveva l'intenzione.

426
00:26:40,850 --> 00:26:44,750
Quindi cerchiamo di astratto questa via e solo più genericamente dire

427
00:26:44,750 --> 00:26:46,830
Ho bisogno di questo molti pezzi di memoria

428
00:26:46,830 --> 00:26:50,210
e ciascun blocco di memoria dovrebbe essere equivalente alla dimensione di un carattere,

429
00:26:50,210 --> 00:26:54,870
che è infatti pari a 1 in questo caso, ma è un modo più generico di scrittura.

430
00:26:54,870 --> 00:27:00,460
Quindi, se la parola è ciao, quanti byte si malloc apparentemente allocare per ciao?

431
00:27:00,460 --> 00:27:04,980
[Studente] Six. Six >>. Esattamente come molti come abbiamo punti interrogativi sullo schermo.

432
00:27:04,980 --> 00:27:07,800
E poi prendere un indovinare ora in base alla comprensione della GetString

433
00:27:07,800 --> 00:27:12,790
cosa malloc probabilmente restituire? >> [Studente] Un indirizzo.

434
00:27:12,790 --> 00:27:17,020
Un indirizzo di che cosa? Del primo blocco di memoria.

435
00:27:17,020 --> 00:27:20,670
>> Non abbiamo idea di quello che c'è, perché qualche altra funzione

436
00:27:20,670 --> 00:27:23,010
avrebbe potuto usando questa memoria precedentemente.

437
00:27:23,010 --> 00:27:28,380
Ma malloc, come GetString, restituisce l'indirizzo del primo byte di memoria

438
00:27:28,380 --> 00:27:30,540
che ha messo da parte per te.

439
00:27:30,540 --> 00:27:38,380
Tuttavia, ciò che non fare è riempire questo vuoto con un carattere null barra rovesciata

440
00:27:38,380 --> 00:27:43,030
perché è venuto fuori è possibile utilizzare malloc per allocare tutto: int, stringhe, array,

441
00:27:43,030 --> 00:27:45,700
galleggianti, strutture studenti.

442
00:27:45,700 --> 00:27:47,750
È possibile utilizzare malloc completamente genericamente.

443
00:27:47,750 --> 00:27:51,470
Non importa o devono sapere cosa si sta per l'allocazione di memoria.

444
00:27:51,470 --> 00:27:55,810
Quindi sarebbe presuntuoso per malloc di mettere un \ 0

445
00:27:55,810 --> 00:27:58,340
alla fine di ogni blocco di memoria che sta dando

446
00:27:58,340 --> 00:28:02,620
perché questa \ 0 non è solo una convenzione per le stringhe.

447
00:28:02,620 --> 00:28:06,310
Non è utilizzato per interi, non è utilizzato per i float, non è utilizzato per gli studenti.

448
00:28:06,310 --> 00:28:11,730
E così il Gotcha con malloc è che l'onere è interamente su di voi il programmatore

449
00:28:11,730 --> 00:28:16,790
per ricordare il numero di byte che si assegnata e di non utilizzare mai un ciclo for

450
00:28:16,790 --> 00:28:21,570
o un ciclo while e andare oltre il bordo del blocco di memoria che è stata data.

451
00:28:21,570 --> 00:28:23,540
In altre parole, non appena si alloca la memoria,

452
00:28:23,540 --> 00:28:28,510
non si può chiedere al sistema operativo, oh, a proposito, come di un grande pezzo di memoria era questo?

453
00:28:28,510 --> 00:28:32,080
E 'interamente a voi di ricordare se avete bisogno di tale valore.

454
00:28:32,080 --> 00:28:34,330
>> Quindi cerchiamo di vedere come procedere ad utilizzare questa memoria.

455
00:28:34,330 --> 00:28:38,430
In linea 28 e 29 perchè sto facendo questo?

456
00:28:39,850 --> 00:28:42,260
Solo test di consistenza totale.

457
00:28:42,260 --> 00:28:45,110
Nel caso in cui qualcosa è andato storto, chiedo per una certa quantità folle di memoria

458
00:28:45,110 --> 00:28:48,690
o Ho tante cose in esecuzione sul computer che semplicemente non è sufficiente memoria,

459
00:28:48,690 --> 00:28:51,780
qualcosa del genere, io almeno voglio verificare la presenza di null.

460
00:28:51,780 --> 00:28:55,260
In realtà, la maggior parte dei computer vi darà l'illusione che ogni programma

461
00:28:55,260 --> 00:28:57,080
possono utilizzare la totalità della RAM,

462
00:28:57,080 --> 00:29:00,740
ma anche così, se l'utente digita una stringa folle lungo forse perché sono un cattivo ragazzo

463
00:29:00,740 --> 00:29:03,440
e stanno in realtà cercando di causare il crash del programma o hack in esso,

464
00:29:03,440 --> 00:29:07,300
si desidera controllare almeno il valore di ritorno di malloc e se è uguale a null.

465
00:29:07,300 --> 00:29:11,630
E se lo fa, diciamo solo uscire in questo momento perché non so cosa fare in quel caso.

466
00:29:11,630 --> 00:29:13,950
Come faccio a copiare la stringa? Ci sono alcuni modi per farlo.

467
00:29:13,950 --> 00:29:18,850
Ci sono str copia delle funzioni in C, ma è super semplice per noi per fare questo la vecchia maniera.

468
00:29:18,850 --> 00:29:23,110
>> In primo luogo vorrei capire quale sia la lunghezza di s è.

469
00:29:23,110 --> 00:29:26,930
Avrei potuto mettere questo nel ciclo, ma invece ho appena messo qui per chiarezza.

470
00:29:26,930 --> 00:29:30,610
Così n memorizza ora la lunghezza della stringa originale, che è apparentemente 5.

471
00:29:30,610 --> 00:29:35,290
Poi, nel mio loop per sto iterazione da 0 su un massimo di n,

472
00:29:35,290 --> 00:29:40,940
e su ogni iterazione sto mettendo s [i] all'interno del t [i].

473
00:29:40,940 --> 00:29:45,060
Ecco, questo è quello che ho implicita con i miei 2 dita rivolte le corde prima.

474
00:29:45,060 --> 00:29:49,260
Dato che questo ciclo for itera come questo, ho intenzione di essere la copia h in questa sede,

475
00:29:49,260 --> 00:29:52,890
e in questa sede, l in questa sede perché questo è s, questo è t.

476
00:29:52,890 --> 00:29:58,770
E poi, infine, alla riga 35 perché sto facendo questo?

477
00:29:58,770 --> 00:30:03,770
Ho bisogno di fare in modo che io la fine della stringa t.

478
00:30:03,770 --> 00:30:06,170
E l'ho fatto in questo modo per essere super esplicito.

479
00:30:06,170 --> 00:30:09,510
Ma proporre, qualcuno, se si potesse, un modo diverso di fare questo.

480
00:30:09,510 --> 00:30:13,930
Non ho davvero bisogno di linea 35. C'è un altro modo per fare questo.

481
00:30:13,930 --> 00:30:18,880
Gia '. >> [Risposta degli studenti incomprensibile] >> Dillo più forte.

482
00:30:18,880 --> 00:30:20,960
[Studente] Minore o uguale a. >> Esattamente.

483
00:30:20,960 --> 00:30:24,450
Potremmo semplicemente dire minore o uguale an, che in generale è stato male

484
00:30:24,450 --> 00:30:28,190
perché quasi sempre quando andiamo fino ad un uguale alla cosa che stiamo contando

485
00:30:28,190 --> 00:30:30,000
1 passo andiamo troppo lontano.

486
00:30:30,000 --> 00:30:32,170
Ma ricordate, quanti byte abbiamo allocare?

487
00:30:32,170 --> 00:30:37,210
Abbiamo assegnato strlen di s, quindi 5 + 1 per un totale di 6.

488
00:30:37,210 --> 00:30:39,980
Quindi, in questo caso si potrebbe fare qualcosa di simile

489
00:30:39,980 --> 00:30:46,450
in modo che si sta copiando non solo il ciao, ma anche il \ 0 alla fine.

490
00:30:46,450 --> 00:30:49,860
In alternativa, si potrebbe utilizzare una funzione chiamata str copia, strcpy,

491
00:30:49,860 --> 00:30:51,700
ma che non sarebbe stato divertente così tanto.

492
00:30:51,700 --> 00:30:54,000
Ma questo è tutto ciò che fa sotto la cappa.

493
00:30:54,000 --> 00:30:56,050
Poi infine, facciamo la stessa cosa di prima.

494
00:30:56,050 --> 00:31:01,620
I capitalizzare t e poi affermare che l'originale assomiglia a questo e la copia sembra che.

495
00:31:01,620 --> 00:31:08,570
Quindi cerchiamo di provare questo adesso. Lasciami andare qui. Fai copy2. Ci ingrandire ed eseguire copy2.

496
00:31:08,570 --> 00:31:13,840
Io vado a digitare ciao in minuscolo, e in effetti ho minuscolo ciao come l'originale

497
00:31:13,840 --> 00:31:16,930
Ciao ma il capitale per la copia.

498
00:31:16,930 --> 00:31:20,300
Ma non ho finito ancora. Ho bisogno di fare 1 ultima cosa qui.

499
00:31:20,300 --> 00:31:28,000
46 e 47 è chiaramente liberare la memoria, ma che cosa significa in realtà?

500
00:31:28,000 --> 00:31:33,250
Cosa sto facendo, pensi che, chiamando la linea 46 e linea 47?

501
00:31:33,250 --> 00:31:38,900
Che effetto ha questo? Gia '.

502
00:31:38,900 --> 00:31:43,140
[Risposta degli studenti incomprensibile] >> Esattamente.

503
00:31:43,140 --> 00:31:46,380
>> Si sta solo dicendo il sistema operativo, ehi, grazie per questa memoria.

504
00:31:46,380 --> 00:31:48,320
È ora possibile utilizzare per qualcun altro.

505
00:31:48,320 --> 00:31:50,790
Ed ecco un esempio perfetto di valori spazzatura.

506
00:31:50,790 --> 00:31:55,430
Ho appena usato questa memoria per scrivere la parola ciao in 2 posti,

507
00:31:55,430 --> 00:31:57,490
qui, qui, qui e qui.

508
00:31:57,490 --> 00:32:00,910
Quindi questo è h-e-l-l-o-\ 0.

509
00:32:00,910 --> 00:32:06,960
Ma poi io chiamo la linea 46 e linea 47, e sai cosa succede in termini di immagine?

510
00:32:06,960 --> 00:32:10,010
A dire il vero, aspetta, questa immagine è quello vecchio.

511
00:32:10,010 --> 00:32:12,550
Una volta che facciamo la copia, questo ragazzo è in realtà punta qui,

512
00:32:12,550 --> 00:32:16,110
quindi cerchiamo di rimuovere i numeri e solo astrarre come le nostre frecce di nuovo.

513
00:32:16,110 --> 00:32:19,370
Che cosa succede in questa foto quando si chiama gratis?

514
00:32:19,370 --> 00:32:22,750
[Risposta incomprensibile studente] >> Neanche.

515
00:32:22,750 --> 00:32:29,510
Se chiamo gratuito s e t - una specie di domanda trabocchetto - questa immagine non cambia niente

516
00:32:29,510 --> 00:32:33,880
perché la chiamata e la chiamata s t dice solo il sistema operativo,

517
00:32:33,880 --> 00:32:39,010
hey, è possibile utilizzare questa memoria ancora una volta, ma non cambia questo valore nullo

518
00:32:39,010 --> 00:32:41,840
o qualche carattere speciale, non cambia questo,

519
00:32:41,840 --> 00:32:47,350
non cambia l'h o l'indirizzo o il l o l o o in altro luogo a qualsiasi altra cosa.

520
00:32:47,350 --> 00:32:51,610
In termini di immagine, non appena si chiama gratis, non cambia nulla.

521
00:32:51,610 --> 00:32:56,570
E qui sta l'origine dei valori della spazzatura perché se io poi in questo programma

522
00:32:56,570 --> 00:33:01,010
chiedere al sistema operativo per più memoria con GetString o malloc o qualcosa del genere

523
00:33:01,010 --> 00:33:04,900
e il sistema operativo dice, certo, ho 12 byte di memoria appena liberati,

524
00:33:04,900 --> 00:33:08,080
utilizzare questi, che cosa hai intenzione di essere consegnato?

525
00:33:08,080 --> 00:33:10,830
Stai andando a consegnare un pezzo di memoria che in genere trarre

526
00:33:10,830 --> 00:33:13,700
con punti di domanda, ma quali sono questi punti interrogativi?

527
00:33:13,700 --> 00:33:17,000
Essi capita di essere h-e-l-l-o, h-e-l-l-o.

528
00:33:17,000 --> 00:33:20,940
Questi sono i nostri valori spazzatura nuovi non appena si liberare la memoria.

529
00:33:20,940 --> 00:33:22,750
>> C'è un mondo reale implicazione anche qui.

530
00:33:22,750 --> 00:33:24,720
Questo succede a che fare con la RAM, ma i computer

531
00:33:24,720 --> 00:33:26,720
effettivamente fare la stessa cosa con il disco.

532
00:33:26,720 --> 00:33:30,620
Parleremo di questo, in particolare, con una serie di problemi futuri che si concentra sulla forense.

533
00:33:30,620 --> 00:33:36,170
Ma ciò che effettivamente accade se hai qualche file finanziarie sensibili sul tuo desktop

534
00:33:36,170 --> 00:33:39,600
o qualche abbozzato JPEG e si trascina nel cestino,

535
00:33:39,600 --> 00:33:44,390
cosa succede quando si trascina nel cestino o nel cestino?

536
00:33:44,390 --> 00:33:47,240
Sapevi cosa stavo parlando. [Risate]

537
00:33:47,240 --> 00:33:52,370
Che cosa succede quando hai trascinato tali prove nella tua cestino o cestino?

538
00:33:52,370 --> 00:33:55,920
[Risposta degli studenti incomprensibile]

539
00:33:55,920 --> 00:33:58,000
Beh, così attento. Che cosa succede quando l'hai fatto?

540
00:33:58,000 --> 00:34:01,030
La risposta breve è niente, no?

541
00:34:01,030 --> 00:34:04,790
File di Sketchy o sensibili è ancora seduto lì da qualche parte nel disco rigido.

542
00:34:04,790 --> 00:34:07,940
La maggior parte di noi almeno hanno imparato a proprie spese che è necessario svuotare il cestino

543
00:34:07,940 --> 00:34:10,429
o il cestino per eliminare i file in realtà.

544
00:34:10,429 --> 00:34:13,440
E infatti, quando si fa clic o controllare clic sul tuo cestino

545
00:34:13,440 --> 00:34:15,580
o scegliere File, Vuota il Cestino o qualsiasi altra cosa

546
00:34:15,580 --> 00:34:21,420
e in realtà svuotare il cestino o cestino, ciò che effettivamente accade poi a questo quadro?

547
00:34:22,810 --> 00:34:25,969
Niente di più. Quindi nulla accade realmente sul disco.

548
00:34:25,969 --> 00:34:30,880
>> E se solo temporaneamente divagare e scrivere - I'Ll basta utilizzare il retro di questo.

549
00:34:30,880 --> 00:34:34,639
Così ora la storia sta cambiando da RAM, che è dove esistono programmi

550
00:34:34,639 --> 00:34:39,250
mentre li stai eseguendo, su disco, che è dove sono immagazzinati a lungo termine

551
00:34:39,250 --> 00:34:42,920
anche quando il potere esce, per ora - e ci torneremo a questo in futuro -

552
00:34:42,920 --> 00:34:46,380
facciamo solo finta che questo rappresenta la parte interna del disco rigido del computer

553
00:34:46,380 --> 00:34:50,110
perché nel giorno quelli di una volta dischi circolari, proprio come i floppy disk.

554
00:34:50,110 --> 00:34:55,130
Quindi, se si dispone di alcuni file di Excel sensibile, potrebbe prendere questo pezzo di memoria

555
00:34:55,130 --> 00:34:59,770
sul disco del computer, e sto solo disegnando stesso 1s arbitraria e 0.

556
00:34:59,770 --> 00:35:03,970
Quando si trascina il file in quel modo al vostro cestino o nel cestino,

557
00:35:03,970 --> 00:35:07,750
letteralmente nulla accade perché Apple e Microsoft hanno appena deciso

558
00:35:07,750 --> 00:35:10,450
il cestino e cestino è in realtà solo un segnaposto temporaneo.

559
00:35:10,450 --> 00:35:14,710
Forse alla fine il sistema operativo svuotarlo per voi, ma in genere, non fa nulla,

560
00:35:14,710 --> 00:35:17,090
almeno fino a quando sei veramente poco spazio.

561
00:35:17,090 --> 00:35:20,870
>> Tuttavia, quando si va al cestino vuoto o Svuota cestino,

562
00:35:20,870 --> 00:35:23,460
allo stesso modo, non succede nulla a questo quadro.

563
00:35:23,460 --> 00:35:28,590
Tutto ciò che accade è altrove nel computer, c'è una specie di tabella.

564
00:35:28,590 --> 00:35:35,400
E 'un po' come un piccolo schema riassuntivo poco che dice che, diciamo, resume.doc,

565
00:35:35,400 --> 00:35:40,920
così il vostro curriculum in un file di Microsoft Word abituati a vivere nella posizione 123 sul disco rigido,

566
00:35:40,920 --> 00:35:43,710
non in memoria e non in RAM, ma sul disco rigido,

567
00:35:43,710 --> 00:35:49,050
e le vostre vite abbozzato JPEG a 456, e il file di Excel vive a 789 o dovunque.

568
00:35:49,050 --> 00:35:53,640
Quando si eliminano i file da parte effettivamente svuotare il cestino o il cestino,

569
00:35:53,640 --> 00:35:59,530
questa immagine non cambia. La 0 e 1 sul disco rigido non andare da nessuna parte.

570
00:35:59,530 --> 00:36:03,930
Ma questa tabella, questo piccolo database di sorta, non cambia.

571
00:36:03,930 --> 00:36:08,750
Quando si elimina il tuo curriculum, è come se il file viene eliminato in un certo senso,

572
00:36:08,750 --> 00:36:12,790
ma tutto il computer non si dimentica dove quella cosa vive sul disco rigido.

573
00:36:12,790 --> 00:36:17,870
La 0 e 1 che compongono il tuo curriculum o uno qualsiasi di questi altri file sono ancora intatte.

574
00:36:17,870 --> 00:36:21,960
>> Quindi, se avete fatto questo errore, c'è ancora una probabilità diversa da zero

575
00:36:21,960 --> 00:36:25,800
che è possibile recuperare i vostri dati con Norton Utilities o alcuni software commerciali

576
00:36:25,800 --> 00:36:29,810
il cui scopo nella vita è quello di trovare 0 e 1 che sono una sorta di rimasti orfani,

577
00:36:29,810 --> 00:36:33,300
dimenticato qui, ma qui a sinistra, in modo da poter ottenere i vostri dati.

578
00:36:33,300 --> 00:36:38,410
Oppure investigatori forensi con la polizia o FBI sarebbe in realtà fare un disco rigido

579
00:36:38,410 --> 00:36:42,550
e in realtà cercare modelli di 0 e 1 che sembrano JPEG, guarda come i file di Excel,

580
00:36:42,550 --> 00:36:46,400
e recuperarli in questo modo, anche se il computer non li ha dimenticati.

581
00:36:46,400 --> 00:36:49,820
Quindi l'unico modo veramente per cancellare i dati, come vedremo in futuro,

582
00:36:49,820 --> 00:36:54,190
è quello di strofinare o cancellare il file o il disco rigido -

583
00:36:54,190 --> 00:36:56,540
Non si può davvero sbarazzarsi del 0 e 1

584
00:36:56,540 --> 00:36:59,440
perché altrimenti ci si avvia con un disco rigido gigabyte

585
00:36:59,440 --> 00:37:02,380
e che ci si finisce con un disco rigido megabyte se costantemente sono stati l'eliminazione,

586
00:37:02,380 --> 00:37:04,380
letteralmente, 0 e 1.

587
00:37:04,380 --> 00:37:06,310
Che cosa faresti se si voleva davvero per coprire le tracce

588
00:37:06,310 --> 00:37:10,510
e il problema fondamentale è che c'è ancora 0 e 1 sul disco?

589
00:37:10,510 --> 00:37:14,930
Vedo qualcuno che si gesticolando fisicamente rompere il dispositivo. Che funzionerà.

590
00:37:14,930 --> 00:37:19,600
[Risate] Ma se questo è una specie di soluzione costosa, ciò che sarebbe più ragionevole?

591
00:37:19,600 --> 00:37:23,270
Gia '. >> [Studente] Sovrascrivi loro. Loro >> Sovrascrivere con che cosa? >> [Studente] Altri dati.

592
00:37:23,270 --> 00:37:29,070
Altri dati. Si può solo sovrascrivere il disco con 0 o 1 o di tutti 0, tutti 1.

593
00:37:29,070 --> 00:37:31,230
>> E questo è proprio ciò che alcuni dei software fa.

594
00:37:31,230 --> 00:37:33,570
È possibile acquistare il software o addirittura ottenere il software libero,

595
00:37:33,570 --> 00:37:36,610
e anche integrato in Mac OS in questi giorni, meno in Windows,

596
00:37:36,610 --> 00:37:38,660
è la possibilità di cancellare in modo sicuro.

597
00:37:38,660 --> 00:37:41,960
In realtà, se si vuole tutti a casa run oggi, se hai un Mac e fare questo,

598
00:37:41,960 --> 00:37:45,740
se hai un po 'di roba nel tuo cestino, si può fare Vuota Cestino sicuro,

599
00:37:45,740 --> 00:37:47,610
che fa proprio questo.

600
00:37:47,610 --> 00:37:53,350
Piuttosto che limitarsi a cancellare i file qui, non cancella la 0 e 1 qui,

601
00:37:53,350 --> 00:38:01,240
piuttosto, cambia solo tutti loro, per esempio, a 0 e dot, dot, dot.

602
00:38:01,240 --> 00:38:05,330
Così uno dei tuoi futuri pset sarà effettivamente per recuperare i dati intenzionalmente -

603
00:38:05,330 --> 00:38:08,430
fotografie che abbiamo preso di persone, luoghi e cose del campus

604
00:38:08,430 --> 00:38:12,810
per il quale faremo una immagine forense di scheda di memoria di una fotocamera digitale,

605
00:38:12,810 --> 00:38:17,120
che è la stessa idea - e dovrete essere chiamati a trovare effettivamente

606
00:38:17,120 --> 00:38:20,160
i modelli che rappresentano JPEG sul disco rigido,

607
00:38:20,160 --> 00:38:23,610
molto simile a quella ex studente la cui e-mail ho letto un paio di settimane fa ha fatto

608
00:38:23,610 --> 00:38:25,860
per recuperare fotografie della sorella.

609
00:38:25,860 --> 00:38:30,300
Perché non facciamo una pausa di 5 minuti qui, e noi provvederemo a riorganizzarsi con più sulla memoria.

610
00:38:33,030 --> 00:38:38,610
Quindi, ecco le cose si fanno un po 'mind-bending, ma questo è un passo molto potente

611
00:38:38,610 --> 00:38:40,480
verso la comprensione di questa ancora di più.

612
00:38:40,480 --> 00:38:42,900
Ecco un programma chiamato pointers.c.

613
00:38:42,900 --> 00:38:45,430
E 'tra il codice di esempio di oggi.

614
00:38:45,430 --> 00:38:51,280
Si noti che nelle prime righe, da 19 a 22, tutto quello che stiamo facendo è qualcosa di simile GetString

615
00:38:51,280 --> 00:38:54,460
e restituendo un indirizzo, depositandolo in s.

616
00:38:54,460 --> 00:38:58,380
D'ora in poi per pset anche 3 se si vuole, ma pset 4 e su

617
00:38:58,380 --> 00:39:01,030
dove si può iniziare a prendere queste ruote di formazione fuori da soli,

618
00:39:01,030 --> 00:39:04,030
non vi è motivo di fingere che le stringhe esistono più.

619
00:39:04,030 --> 00:39:07,030
E 'sicuramente a posto per iniziare solo dicendo char *.

620
00:39:07,030 --> 00:39:12,610
>> Per inciso, di riferimenti on-line e nei libri si possono spesso vedere la stella accanto alla variabile.

621
00:39:12,610 --> 00:39:15,600
Si potrebbe anche vedere spazi intorno a entrambi i lati di esso.

622
00:39:15,600 --> 00:39:17,680
Tutti questi sono funzionalmente corretto.

623
00:39:17,680 --> 00:39:21,180
Per ora, però, ci standardizzare su questo approccio per rendere super chiaro

624
00:39:21,180 --> 00:39:24,000
che char * è come dire puntatore a carattere.

625
00:39:24,000 --> 00:39:25,680
Questo è il tipo di dati.

626
00:39:25,680 --> 00:39:28,730
E poi il nome della variabile s è in questo caso.

627
00:39:28,730 --> 00:39:31,180
Così abbiamo ottenuto una stringa e l'abbiamo chiamato s.

628
00:39:31,180 --> 00:39:35,180
E poi qui notare che sto facendo in realtà un po 'di trucco.

629
00:39:35,180 --> 00:39:39,080
Questo si chiama aritmetica dei puntatori, che è una sorta di super semplice.

630
00:39:39,080 --> 00:39:41,790
Significa solo sommare e sottrarre numeri ai puntatori.

631
00:39:41,790 --> 00:39:43,660
Ma questo funziona realmente.

632
00:39:43,660 --> 00:39:49,170
Questo programma stampa apparentemente la stringa s 1 carattere per riga in modo tale che il risultato finale -

633
00:39:49,170 --> 00:39:54,920
Solo così siamo in grado di rovinare dove questo sta andando, fare puntatori, puntatori correre, lasciami Immagine

634
00:39:54,920 --> 00:39:58,940
Ora mi consentono di digitare qualcosa come CIAO e il tipo di Invio

635
00:39:58,940 --> 00:40:01,080
e stampa 1 carattere per riga.

636
00:40:01,080 --> 00:40:04,730
Fino a un secondo fa, avremmo fatto con la notazione parentesi quadra.

637
00:40:04,730 --> 00:40:09,760
Avremmo un ciclo for e ci piacerebbe fare printf di s [i] e ci piacerebbe farlo di nuovo e ancora e ancora

638
00:40:09,760 --> 00:40:11,950
con n backslash alla fine di ogni riga.

639
00:40:11,950 --> 00:40:16,800
Ma questo programma è diverso. Questo programma utilizza, letteralmente, l'aritmetica.

640
00:40:16,800 --> 00:40:18,860
Così che cosa sta succedendo qui?

641
00:40:18,860 --> 00:40:24,720
Prima di tutto, prima di questo ciclo viene eseguito, anche quello, tanto per essere chiari, è s in realtà?

642
00:40:24,720 --> 00:40:27,270
S è? >> [Studente] Un indirizzo. Un indirizzo >>.

643
00:40:27,270 --> 00:40:32,980
>> Ed è l'indirizzo, nel caso del ciao, il primo carattere in quella parola, che è h.

644
00:40:32,980 --> 00:40:37,370
Quindi s è, in questo particolare esempio, l'indirizzo di h.

645
00:40:37,370 --> 00:40:41,850
Che cosa vuol dire fare s + i?

646
00:40:41,850 --> 00:40:46,280
Beh, i inizia a 0 in questo ciclo for. Abbiamo fatto molte volte.

647
00:40:46,280 --> 00:40:49,760
Mi sta per andare fino alla lunghezza della stringa, a quanto pare.

648
00:40:49,760 --> 00:40:53,950
Così la prima iterazione del ciclo, i è ovviamente 0.

649
00:40:53,950 --> 00:41:01,740
Quindi questa espressione sta dicendo s + i - piuttosto, s +0-che è, ovviamente, solo s.

650
00:41:01,740 --> 00:41:04,320
Allora, qual è * s qui?

651
00:41:04,320 --> 00:41:08,530
Ora stiamo usando la stella in un modo leggermente diverso.

652
00:41:08,530 --> 00:41:13,080
Lasciatemi andare avanti e di sbarazzarsi di t perché abbiamo finito parlando di t e copie di s.

653
00:41:13,080 --> 00:41:15,540
Ora vogliamo solo raccontare una storia che coinvolge s.

654
00:41:15,540 --> 00:41:20,090
E così, in questo momento, dopo aver tipo string, il nostro mondo sembra abbastanza come prima

655
00:41:20,090 --> 00:41:26,630
con solo s memorizzare l'indirizzo di h e più in generale indicando la stringa ciao.

656
00:41:26,630 --> 00:41:33,170
Se ora fare una linea come * (s + i), cerchiamo di provare questo fuori.

657
00:41:33,170 --> 00:41:40,140
Quindi * (s + i). Vorrei semplificare questo perché questo è 0, quindi questo è * (s +0).

658
00:41:40,140 --> 00:41:43,790
Beh, aspetta un attimo. Semplificare ulteriormente. Questo è * (s).

659
00:41:43,790 --> 00:41:47,020
Bene, ora le parentesi sono un po 'stupido, quindi ora limitiamoci a fare * s.

660
00:41:47,020 --> 00:41:50,540
Così nella prima iterazione del ciclo, quella linea che è evidenziata, 26,

661
00:41:50,540 --> 00:41:53,650
è più o meno equivalente alla stampa di questo.

662
00:41:53,650 --> 00:41:56,040
Qual è il tipo di dati di * s?

663
00:41:56,040 --> 00:42:00,770
In questo contesto, perché la stella sembra essere vicino alla stessa s,

664
00:42:00,770 --> 00:42:04,930
ma più specificamente, perché non siamo più dichiarando s,

665
00:42:04,930 --> 00:42:09,730
non stiamo creando una variabile di più, non c'è alcuna menzione di char * in linea 26,

666
00:42:09,730 --> 00:42:14,280
non c'è alcuna menzione della stringa parola chiave, ci sono solo utilizzando una variabile chiamata s,

667
00:42:14,280 --> 00:42:19,650
si scopre ora la stella è leggermente diverso e, certamente, confondendo significato.

668
00:42:19,650 --> 00:42:26,590
* S qui significa aprire l'indirizzo in s e stampa tutto ciò che è lì.

669
00:42:26,590 --> 00:42:33,750
Così s è qui, * s è - un po 'come Chutes and Ladders, seguite la freccia - qui.

670
00:42:33,750 --> 00:42:35,850
Quindi questo è * s.

671
00:42:35,850 --> 00:42:39,060
>> Quindi, ciò che viene stampato sulla prima iterazione di questo ciclo in linea 26?

672
00:42:39,060 --> 00:42:42,170
Ho stampare% c, che è il segnaposto per un carattere,

673
00:42:42,170 --> 00:42:48,520
poi un \ n per una nuova linea. * (S + i) dove i è 0 è proprio questo.

674
00:42:48,520 --> 00:42:53,670
Allora, cosa char devo posizionare in per c%? H.

675
00:42:53,670 --> 00:42:56,900
Nella prossima iterazione del ciclo - probabilmente si può vedere dove questo sta andando -

676
00:42:56,900 --> 00:43:01,350
la prossima iterazione i è ovviamente 1, quindi questo significa s +1,

677
00:43:01,350 --> 00:43:05,580
e poi ora ho bisogno delle parentesi, perché ora la stella deve dire

678
00:43:05,580 --> 00:43:08,620
vai a indirizzo di memoria s +1.

679
00:43:08,620 --> 00:43:14,170
Che cosa è s? Facciamo rotolare indietro nel tempo e dire la freccia ora non è in realtà ci fa un favore.

680
00:43:14,170 --> 00:43:18,450
Che è più specificamente dire che questa è la memorizzazione del numero 123

681
00:43:18,450 --> 00:43:25,110
poiché l'inizio di questa stringa ciao, questo è l'indirizzo 123, questo è 124, e così via.

682
00:43:25,110 --> 00:43:30,550
Così il seconda iterazione quando dico s +1, è come dire 123 +1,

683
00:43:30,550 --> 00:43:35,340
altrimenti noto come 124, quindi cosa char viene stampato sulla seconda iterazione?

684
00:43:35,340 --> 00:43:37,850
E in indirizzo di memoria 124.

685
00:43:37,850 --> 00:43:44,440
Poi di nuovo +, 125, 126, 127, e questo ciclo si ferma per fortuna prima di arrivare qui

686
00:43:44,440 --> 00:43:49,040
perché sto utilizzando strlen per assicurarsi che io non conta troppo alto.

687
00:43:49,040 --> 00:43:50,810
In modo che esso è troppo.

688
00:43:50,810 --> 00:43:55,000
Ancora una volta, questo è come se avessimo fatto una settimana fa.

689
00:43:55,000 --> 00:43:59,200
Lascia che te lo scrivi sulla riga sotto, anche se non vogliamo fare entrambe le cose.

690
00:43:59,200 --> 00:44:02,500
Questo è identico a questo momento.

691
00:44:02,500 --> 00:44:08,310
>> Così, anche se s è una stringa, come abbiamo chiamando da settimane, s è davvero un char *.

692
00:44:08,310 --> 00:44:13,270
Quindi, se vogliamo essere anale super, è davvero giusto per scrivere il carattere specifico

693
00:44:13,270 --> 00:44:17,490
nella posizione esima utilizzando questi indirizzi numerici e di questo operatore stelle,

694
00:44:17,490 --> 00:44:20,470
ma, francamente, questo è più pulita così tanto. Quindi questo non è male.

695
00:44:20,470 --> 00:44:26,720
Non c'è ragione di smettere di fare la linea 27 qui, ma 26 è funzionalmente lo stesso,

696
00:44:26,720 --> 00:44:31,570
ed è funzionalmente uguale esattamente per i motivi che abbiamo discusso finora.

697
00:44:31,570 --> 00:44:33,650
E, infine, 29 è solo una buona pratica.

698
00:44:33,650 --> 00:44:38,420
Chiamare gratis s significa che ora si sta dando indietro la memoria che ti ha dato GetString

699
00:44:38,420 --> 00:44:41,630
perché ancora una volta, come ho già detto Lunedi, GetString per settimane

700
00:44:41,630 --> 00:44:44,180
ha introdotto un bug nel codice.

701
00:44:44,180 --> 00:44:46,490
Il codice per settimane ha avuto perdite di memoria

702
00:44:46,490 --> 00:44:49,970
in base al quale si è chiesto GetString per la memoria, ma non sei mai stato dando indietro.

703
00:44:49,970 --> 00:44:53,410
E che è stata scelta da noi pedagogicamente

704
00:44:53,410 --> 00:44:55,880
perché è davvero troppo per pensare presto.

705
00:44:55,880 --> 00:44:57,710
Ma ora abbiamo bisogno di più simmetria.

706
00:44:57,710 --> 00:45:00,830
Se si chiede il computer per la memoria, come è il caso per GetString,

707
00:45:00,830 --> 00:45:02,820
come nel caso apparentemente per malloc,

708
00:45:02,820 --> 00:45:07,970
è necessario ora per pset 4 e successivi anche liberi la memoria del genere.

709
00:45:07,970 --> 00:45:11,650
Si noti che questo è diverso dal dire n int.

710
00:45:11,650 --> 00:45:15,040
Non è necessario per liberare questo perché tu non abbia chiamato GetString

711
00:45:15,040 --> 00:45:16,890
e che non hai chiamato malloc.

712
00:45:16,890 --> 00:45:20,610
>> E anche se si chiama GetInt come vedremo finalmente vedere,

713
00:45:20,610 --> 00:45:25,520
GetInt non alloca la memoria per voi, perché si può effettivamente passare in giro interi

714
00:45:25,520 --> 00:45:29,430
e carri allegorici e salmerini solo il modo in cui abbiamo fatto per settimane.

715
00:45:29,430 --> 00:45:33,960
Strings, però, sono speciali perché in realtà sono la concatenazione di caratteri multipli.

716
00:45:33,960 --> 00:45:37,450
Quindi, sono solo diversi da caratteri e carri allegorici e int e simili.

717
00:45:37,450 --> 00:45:39,980
Ma torneremo a che tra non molto.

718
00:45:39,980 --> 00:45:44,920
Tutte le domande poi su questo inizio di puntatori? Gia '.

719
00:45:44,920 --> 00:45:49,690
[Domanda studente incomprensibile]

720
00:45:49,690 --> 00:45:51,440
Ah, bella domanda.

721
00:45:51,440 --> 00:45:55,790
Una delle poche cose C fa realmente per voi, che è comodo,

722
00:45:55,790 --> 00:46:00,110
si capisce che per ciò che si è la dimensione del tipo di dati

723
00:46:00,110 --> 00:46:03,060
e poi fa quel tipo di moltiplicazione per voi.

724
00:46:03,060 --> 00:46:06,610
Questo non è pertinente nel caso di caratteri perché quasi sempre un char è 1 byte,

725
00:46:06,610 --> 00:46:08,150
quindi questo funziona.

726
00:46:08,150 --> 00:46:11,220
Ma per il bene della discussione, se si stesse effettivamente stampando interi

727
00:46:11,220 --> 00:46:15,500
e si stava tentando di stampare un valore s che stava indicando un numero intero,

728
00:46:15,500 --> 00:46:20,720
allo stesso modo non si avrebbe bisogno di fare + 4 * i solo perché un int è di 4 byte.

729
00:46:20,720 --> 00:46:25,780
Aritmetica dei puntatori significa che il compilatore C e fare tutto ciò che la matematica per voi.

730
00:46:25,780 --> 00:46:29,190
Tutto quello che dovete interessa è il conteggio in una sorta di senso umano. Gia '.

731
00:46:29,190 --> 00:46:35,200
[Studente] Se si dichiara una stringa all'interno di un ciclo for, devi liberare in un secondo momento?

732
00:46:35,200 --> 00:46:36,760
Bella domanda.

733
00:46:36,760 --> 00:46:41,390
>> Se si dichiara una stringa all'interno del ciclo for, hai bisogno di liberare in un secondo momento?

734
00:46:41,390 --> 00:46:47,520
Hai solo bisogno di liberare la memoria che viene allocata con GetString o con malloc.

735
00:46:47,520 --> 00:46:53,110
Quindi, se hai appena detto una cosa del genere - mi permetta di mettere le parentesi graffe ora così tutto il codice è associato.

736
00:46:53,110 --> 00:46:58,580
Se hai fatto qualcosa, anche se buggily, in questo modo, char * t = s,

737
00:46:58,580 --> 00:47:03,450
non c'è bisogno di t t liberi, perché non ha comportato alcuna menzione di malloc o GetString.

738
00:47:03,450 --> 00:47:08,960
Se invece avete fatto questo, GetString, allora sì, si avrebbe bisogno di t liberi.

739
00:47:08,960 --> 00:47:14,350
E infatti, l'unica possibilità per farlo è ora all'interno di questo ciclo, per lo stesso problema di portata

740
00:47:14,350 --> 00:47:16,060
che abbiamo discusso in passato.

741
00:47:16,060 --> 00:47:18,830
In caso contrario, si sarebbe l'allocazione di memoria, l'allocazione di memoria, l'allocazione di memoria,

742
00:47:18,830 --> 00:47:21,230
e alla fine del programma perché sei fuori di tale ciclo,

743
00:47:21,230 --> 00:47:24,240
t non esiste, ma non hai mai detto che il sistema operativo

744
00:47:24,240 --> 00:47:26,750
che non hai bisogno di quel ricordo più.

745
00:47:26,750 --> 00:47:30,430
E in poco tempo, per pset 4 o 5 ti equipaggiare con un programma chiamato Valgrind,

746
00:47:30,430 --> 00:47:34,160
che è simile nello spirito a GDB in quanto è ottenuto un po 'di un'interfaccia arcano,

747
00:47:34,160 --> 00:47:35,750
ma il suo scopo nella vita è quello di aiutarvi.

748
00:47:35,750 --> 00:47:39,380
E Valgrind è un programma che in futuro la ricerca dei programmi

749
00:47:39,380 --> 00:47:42,550
alla ricerca di perdite di memoria, sia da GetString o malloc,

750
00:47:42,550 --> 00:47:47,800
che vedremo iniziare a utilizzare sempre più come smettere di usare il CS50 libreria di tanto.

751
00:47:47,800 --> 00:47:53,030
Finalmente ora abbiamo una sorta di vocabolario e il tipo di modello mentale in teoria

752
00:47:53,030 --> 00:47:55,170
con cui risolvere questo programma danneggiato.

753
00:47:55,170 --> 00:47:59,410
>> Quindi, in questo programma danneggiato, scambio lavora all'interno di swap,

754
00:47:59,410 --> 00:48:05,280
ma non è mai effettivamente lavorato in passato principale perché principale di x e y, richiamo,

755
00:48:05,280 --> 00:48:07,260
e quelle sono state approvate in dai valori, per così dire.

756
00:48:07,260 --> 00:48:09,330
Copie di loro sono stati dati da scambiare.

757
00:48:09,330 --> 00:48:12,520
Entro la fine di swap, a e b era stata effettivamente scambiati,

758
00:48:12,520 --> 00:48:16,120
ma, naturalmente, x e y, come abbiamo detto il Lunedi, non era stato.

759
00:48:16,120 --> 00:48:19,940
Quindi propongo in verde qui che questo è in realtà la soluzione qui.

760
00:48:19,940 --> 00:48:22,640
E in realtà, vorrei muovere le stelle solo per essere coerenti

761
00:48:22,640 --> 00:48:24,440
anche se, ancora una volta, funzionalmente questo non importa.

762
00:48:24,440 --> 00:48:28,730
Nelle settimane successive spiegheremo quando e perché è importante.

763
00:48:28,730 --> 00:48:30,600
Quindi, in verde ora è una soluzione.

764
00:48:30,600 --> 00:48:33,700
Francamente, sembra un bel po 'incasinato perché ho tutte queste stelle.

765
00:48:33,700 --> 00:48:35,380
Vorrei sottolineare una cosa.

766
00:48:35,380 --> 00:48:40,040
La riga superiore qui dove dice int * a, int * b

767
00:48:40,040 --> 00:48:42,820
è fondamentalmente facendo la stessa cosa come ha sempre fatto.

768
00:48:42,820 --> 00:48:47,070
Si dichiara 2 argomenti o parametri di scambiare,

769
00:48:47,070 --> 00:48:49,940
il primo dei quali è un puntatore int chiamato,

770
00:48:49,940 --> 00:48:53,100
il secondo dei quali è un puntatore int chiamato b.

771
00:48:53,100 --> 00:48:55,770
L'unica cosa che c'è di nuovo a questo punto è il fatto che c'è una stella là.

772
00:48:55,770 --> 00:48:59,340
>> Che cosa vuol dire? A non è un int, b non è un int.

773
00:48:59,340 --> 00:49:04,100
A è l'indirizzo di un int e b è l'indirizzo di un altro int.

774
00:49:04,100 --> 00:49:06,980
Qui sotto, questo è dove devo ammettere C si confonde.

775
00:49:06,980 --> 00:49:09,790
Ora stiamo usando una stella, ma ha un significato diverso in questo contesto.

776
00:49:09,790 --> 00:49:13,150
Perché non stiamo dichiarare puntatori come noi siamo qui,

777
00:49:13,150 --> 00:49:15,500
qui stiamo dereferenziazione cose.

778
00:49:15,500 --> 00:49:21,520
Tecnicamente, quindi, la stella in questo contesto della linea di primo, secondo, e il terzo all'interno di swap

779
00:49:21,520 --> 00:49:24,560
è l'operatore dereference, che significa semplicemente andare lì.

780
00:49:24,560 --> 00:49:27,400
Così come il mio dito seguì la freccia h,

781
00:49:27,400 --> 00:49:31,100
* Un mezzo vai a questo indirizzo e trovare me la int che c'è.

782
00:49:31,100 --> 00:49:34,250
* Mezzi b aprire l'indirizzo e mi passi quello che c'è.

783
00:49:34,250 --> 00:49:40,730
Quindi cerchiamo di ridisegnare l'immagine da Lunedi ora utilizzando una pila di frame,

784
00:49:40,730 --> 00:49:43,130
il cui fondo sarà principale,

785
00:49:43,130 --> 00:49:47,600
quella superiore del quale sarà swap,

786
00:49:47,600 --> 00:49:50,880
in modo che il nostro mondo sembra, proprio come Lunedi, come questo.

787
00:49:50,880 --> 00:49:53,620
Ecco un pezzo di memoria che si sta per utilizzare.

788
00:49:53,620 --> 00:49:56,520
>> Ricordiamo dal Lunedi che il programma appena avuto 2 variabili,

789
00:49:56,520 --> 00:50:01,930
uno chiamato x e uno chiamato y, e avevo messo i numeri 1 e 2 lì.

790
00:50:01,930 --> 00:50:06,580
Ora, quando chiamo scambiare come ho fatto il Lunedi,

791
00:50:06,580 --> 00:50:11,000
in precedenza, quando ho usato la versione rossa di questo programma, che si presenta come tale,

792
00:50:11,000 --> 00:50:17,470
Ho ottenuto 2 parametri, a e b, e che cosa si scrive qui e qui?

793
00:50:17,470 --> 00:50:21,160
Solo 1 e 2, letteralmente copie di x e y.

794
00:50:21,160 --> 00:50:23,070
Oggi cambiare questa situazione.

795
00:50:23,070 --> 00:50:28,510
Oggi, invece di passare in interi a e b che andremo a passare in 2 indirizzi.

796
00:50:28,510 --> 00:50:34,290
Tali indirizzi capita di puntare a int, ma tali indirizzi non si stanno int.

797
00:50:34,290 --> 00:50:37,330
Sono indirizzi. E 'come un indirizzo postale, invece.

798
00:50:37,330 --> 00:50:40,580
Così ora abbiamo bisogno di dare me stessa dettaglio in più sullo schermo.

799
00:50:40,580 --> 00:50:43,250
Questa è la memoria del mio computer come è stato per tutto il giorno.

800
00:50:43,250 --> 00:50:45,120
Ora abbiamo bisogno di uno schema di numerazione arbitraria.

801
00:50:45,120 --> 00:50:50,580
Quindi, diciamo solo che, per caso, che questo è l'indirizzo di memoria 123, 124.

802
00:50:50,580 --> 00:50:55,660
Diciamo solo che questo è 125, questo è 126, e così via, ma questo è del tutto arbitraria.

803
00:50:55,660 --> 00:50:58,590
Abbiamo solo bisogno di un po 'di schema di numerazione nella mia memoria.

804
00:50:58,590 --> 00:51:04,030
Così ora quando ho effettivamente passano in x e y, io non ho intenzione di passare in x e y;

805
00:51:04,030 --> 00:51:08,400
Ho intenzione di passare l'indirizzo postale, per così dire, di x e di y

806
00:51:08,400 --> 00:51:11,870
in modo che ciò che viene memorizzato qui e qui non è 1 e 2,

807
00:51:11,870 --> 00:51:16,030
ma se si può vedere il mio testo di piccole dimensioni, ciò che viene passato qui e qui?

808
00:51:16,030 --> 00:51:23,340
[Risposta degli studenti incomprensibile] >> Esattamente. 123 viene messo qui e 124 viene messo qui.

809
00:51:23,340 --> 00:51:28,910
>> Ora, perché ho usato la stella in questo modo primissima linea qui in alto,

810
00:51:28,910 --> 00:51:34,340
il mio programma sa solo che 123 e 124, anche se sono ovviamente numeri interi

811
00:51:34,340 --> 00:51:40,160
che un essere umano possa notare, devono essere interpretati come indirizzi, indirizzi numerici.

812
00:51:40,160 --> 00:51:43,250
Essi non sono in sé e per sé interi, sono gli indirizzi,

813
00:51:43,250 --> 00:51:46,120
e questo perché ho esplicitamente messo le stelle lì.

814
00:51:46,120 --> 00:51:51,360
Così ora la mia prima linea, secondo e terzo di codice vero e proprio quello che succede qui?

815
00:51:51,360 --> 00:51:53,380
Facciamo disegnare il resto del quadro.

816
00:51:53,380 --> 00:51:56,980
Tmp è proprio come è stato il Lunedi. Niente di speciale tmp.

817
00:51:56,980 --> 00:52:03,060
E 'solo un locale variabile a 32 bit, e dentro di che sto a quanto pare la memorizzazione del valore di * a.

818
00:52:03,060 --> 00:52:08,580
Ora, se ho appena detto tmp = a, che cosa ho messo qui? >> [Studente] 123.

819
00:52:08,580 --> 00:52:10,370
123. Ma non è quello che sto facendo.

820
00:52:10,370 --> 00:52:13,670
Sto dicendo tmp = * a. Mezzi Stelle andare lì.

821
00:52:13,670 --> 00:52:19,370
Così qui è una, 123. Come ci vado? Finta come se ci fosse una freccia.

822
00:52:19,370 --> 00:52:24,460
Beh, eccolo, 1. Quindi, ciò che viene memorizzato in tmp, a quanto pare? Situato a solo 1.

823
00:52:24,460 --> 00:52:29,620
In altre parole, è tmp * a *, un mezzo aprire l'indirizzo che è attualmente in uno,

824
00:52:29,620 --> 00:52:31,320
che apparentemente è 123.

825
00:52:31,320 --> 00:52:33,910
>> Ok, qui siamo nella posizione 123, vedo il numero 1,

826
00:52:33,910 --> 00:52:35,670
così ho intenzione di mettere il numero 1 lì.

827
00:52:35,670 --> 00:52:39,020
Ora cosa faccio nella riga 2, * a * b =?

828
00:52:39,020 --> 00:52:44,570
Questo è un po 'più complicato perché ora quello che è un? È 123.

829
00:52:44,570 --> 00:52:50,220
Quindi * a è dove? Proprio dove ero prima. Quindi, andare lì. Va bene.

830
00:52:50,220 --> 00:52:53,420
Ora, infine, e poi finalmente questa inizierà ad avere un senso, si spera,

831
00:52:53,420 --> 00:53:00,280
* B significa ciò che è in b? 124. Quindi ho bisogno di andare lì, che è 2.

832
00:53:00,280 --> 00:53:03,430
Quindi cosa ho messo dove?

833
00:53:03,430 --> 00:53:10,100
2 va in questa sede in quanto va in * b * a. Quindi lo farò.

834
00:53:10,100 --> 00:53:13,120
E si può già vedere, forse, che siamo così molto più vicini

835
00:53:13,120 --> 00:53:17,710
per risolvere questo stupido, semplice problema corretto per la prima volta

836
00:53:17,710 --> 00:53:20,920
perché ora abbiamo ancora un ricordo di ciò che era x,

837
00:53:20,920 --> 00:53:23,230
abbiamo 2 copie, è vero, di y,

838
00:53:23,230 --> 00:53:25,850
ma la linea 3 ora dice * b.

839
00:53:25,850 --> 00:53:31,080
Quindi, ecco b. * Mezzi b andarci. Allora, dove è la posizione 124?

840
00:53:31,080 --> 00:53:35,560
E 'a quanto pare qui. Quindi cosa ho messo qui? Ovviamente, tmp.

841
00:53:35,560 --> 00:53:39,600
Così ora lo faccio. Così ho uno qui e 2 qui.

842
00:53:39,600 --> 00:53:43,560
E ora che dire di tutto questo, la 123, la 124, e il 1?

843
00:53:43,560 --> 00:53:47,910
Non appena ritorna swap, questa memoria è buono come perdita

844
00:53:47,910 --> 00:53:51,070
perché non appena ritorni di swap, il sistema operativo

845
00:53:51,070 --> 00:53:54,190
è libera di utilizzare la memoria di nuovo in futuro.

846
00:53:54,190 --> 00:53:58,870
Solo memoria principale in fondo questo cosiddetto stack di bastoni intorno.

847
00:53:58,870 --> 00:54:01,470
>> E così finalmente abbiamo ora una versione funzionante.

848
00:54:01,470 --> 00:54:06,310
Lasciami andare in swap.c, e notare quanto segue.

849
00:54:06,310 --> 00:54:11,280
Nella parte superiore del programma che ho cambiato il mio prototipo di essere int * a, int * b.

850
00:54:11,280 --> 00:54:15,000
Quindi l'unica cosa che ho cambiato per andare dal rosso, che era male, al verde, che è buono,

851
00:54:15,000 --> 00:54:17,350
si ho aggiunto queste stelle oggi.

852
00:54:17,350 --> 00:54:21,520
Ma poi qui in sé scambiare ho dovuto copiare, incollare quello che era solo nella diapositiva.

853
00:54:21,520 --> 00:54:24,140
Ho qui una stella, stella qui - che corrisponde al prototipo -

854
00:54:24,140 --> 00:54:27,930
e poi tutte queste cose hanno ora stelle tranne per tmp

855
00:54:27,930 --> 00:54:30,680
perché l'uso di una variabile temporanea, non c'è nulla di nuovo lì.

856
00:54:30,680 --> 00:54:33,040
Ho solo bisogno di stoccaggio temporaneo per un int.

857
00:54:33,040 --> 00:54:34,820
Quindi non abbiamo bisogno di una stella là.

858
00:54:34,820 --> 00:54:39,310
Abbiamo solo bisogno la stella in modo da poter attraversare questo tipo di limite arbitrario

859
00:54:39,310 --> 00:54:42,900
tra questi 2 fotogrammi nella memoria del mio computer.

860
00:54:42,900 --> 00:54:45,630
Ma un'ultima cosa deve cambiare, e si potrebbe averlo già intravisto.

861
00:54:45,630 --> 00:54:48,810
Che altra linea è ovviamente diverso ora? >> [Studente] e x.

862
00:54:48,810 --> 00:54:53,270
>> Si ', quindi 25 è l'ultima riga di codice che ho bisogno di cambiare per far funzionare tutto.

863
00:54:53,270 --> 00:54:58,360
Una settimana fa e anche il Lunedi linea 25 si presentava così, scambiare x e y,

864
00:54:58,360 --> 00:55:02,020
e questo è stato appena rotto, perché se si dice swap (x, y)

865
00:55:02,020 --> 00:55:05,660
si stanno dando copie di x e y per scambiare, poi che sta facendo il suo dovere,

866
00:55:05,660 --> 00:55:09,080
ma non si è mai realmente cambiando x e y se stesso.

867
00:55:09,080 --> 00:55:12,880
Quindi, anche se non hai mai visto questo personaggio prima con la e commerciale nel codice,

868
00:55:12,880 --> 00:55:15,860
basta prendere una supposizione. Cosa fa il commerciale fare, a quanto pare?

869
00:55:15,860 --> 00:55:17,890
[Studente] prende l'indirizzo. >> Prende l'indirizzo.

870
00:55:17,890 --> 00:55:21,160
Così la e commerciale sta dicendo darmi l'indirizzo di x.

871
00:55:21,160 --> 00:55:25,590
Chi sa dove si trova? Capita di essere 123. Non mi interessa. Dammi l'indirizzo di x.

872
00:55:25,590 --> 00:55:28,340
& Y significa darmi l'indirizzo di y.

873
00:55:28,340 --> 00:55:34,450
E a quel punto la storia è perfettamente coerente con l'immagine che ha un momento fa.

874
00:55:34,450 --> 00:55:38,310
>> Quindi devo ammettere che i puntatori, certamente per me quando ho iniziato a imparare questo,

875
00:55:38,310 --> 00:55:40,570
erano sicuramente una delle cose più difficili da avvolgere la mia mente intorno.

876
00:55:40,570 --> 00:55:43,760
Ma rendersi conto, tanto più che continuare a giocare con questo tipo di cose,

877
00:55:43,760 --> 00:55:48,030
se si scomposizione di questo genere super semplice di intellettualmente interessante problemi

878
00:55:48,030 --> 00:55:52,270
di soli numeri in movimento in giro, la risposta a un sacco di confusione con i puntatori

879
00:55:52,270 --> 00:55:56,590
davvero può essere derivata da queste meccaniche di base.

880
00:55:56,590 --> 00:55:59,070
Ecco un indirizzo. Andateci con la stella.

881
00:55:59,070 --> 00:56:03,830
O al contrario, ecco una e commerciale. Capire che cosa è in realtà l'indirizzo.

882
00:56:03,830 --> 00:56:06,270
Bene.

883
00:56:06,270 --> 00:56:09,000
Allora, dove è tutto di questa memoria viene?

884
00:56:09,000 --> 00:56:12,360
Abbiamo disegnato questa immagine un paio di volte, e continuo promettente torneremo ad esso,

885
00:56:12,360 --> 00:56:14,920
ma qui è la rappresentazione della memoria del computer

886
00:56:14,920 --> 00:56:17,420
che è un po 'più marcato della nostra lavagna è qui.

887
00:56:17,420 --> 00:56:21,590
Il segmento di testo in alto rappresenta ciò che in rapporto al tuo programma?

888
00:56:21,590 --> 00:56:26,090
[Risposta degli studenti incomprensibile] >> Scusa? Dillo di nuovo.

889
00:56:26,090 --> 00:56:28,660
[Studente] Il programma vero e proprio. >> Il programma vero e proprio.

890
00:56:28,660 --> 00:56:32,430
>> Così il Clang 0 e 1 che sono stati compilati dopo la scrittura di codice C e quindi eseguire

891
00:56:32,430 --> 00:56:35,910
e generando estremità 0s e 1s sull'ottenere nascosto lì in memoria

892
00:56:35,910 --> 00:56:38,570
perché quando si fa doppio clic su un'icona sul vostro Mac o PC

893
00:56:38,570 --> 00:56:43,010
o eseguire un comando come mario al tuo prompt, il vostro 0 e 1 dal disco

894
00:56:43,010 --> 00:56:45,700
vengono caricati in memoria in modo che il computer possa manipolare

895
00:56:45,700 --> 00:56:47,540
e li eseguire più rapidamente.

896
00:56:47,540 --> 00:56:50,880
Quindi, i dati inizializzati e dati non inizializzati, non parla molto di quelli,

897
00:56:50,880 --> 00:56:52,420
ma questi sono solo variabili globali.

898
00:56:52,420 --> 00:56:54,710
Inizializzato significa variabili globali che hanno dato valori;

899
00:56:54,710 --> 00:56:59,300
inizializzate le variabili globali significa che non hai ancora dare valori.

900
00:56:59,300 --> 00:57:01,900
Poi ci sono queste variabili d'ambiente che verrà completamente agitano la mia mano a,

901
00:57:01,900 --> 00:57:04,860
ma ci sono e che le cose grandi come il vostro nome utente

902
00:57:04,860 --> 00:57:08,090
ed altro tipo di informazioni di livello inferiore.

903
00:57:08,090 --> 00:57:12,880
Ma i più succosi pezzi di layout di memoria è questa cosa chiamata lo stack e l'heap.

904
00:57:12,880 --> 00:57:17,470
Lo stack di nuovo, per essere chiari, è la memoria che viene utilizzata ogni volta che le funzioni sono chiamate,

905
00:57:17,470 --> 00:57:19,710
quando ci sono le variabili locali

906
00:57:19,710 --> 00:57:22,120
e ogni volta che ci sono parametri passati in giro.

907
00:57:22,120 --> 00:57:24,490
Tutto questo avviene nella pila.

908
00:57:24,490 --> 00:57:29,570
L'heap non abbiamo parlato, ma prendere una congettura che usa l'heap.

909
00:57:31,120 --> 00:57:32,690
Solo un pezzo diverso di memoria.

910
00:57:32,690 --> 00:57:36,620
Succede da trarre qui in alto, ma questa è una convenzione arbitraria pittorica.

911
00:57:36,620 --> 00:57:41,670
Chi apparentemente usando la memoria dal mucchio per settimane?

912
00:57:41,670 --> 00:57:44,830
E 'tecnicamente si, ma indirettamente. >> [Studente] GetString.

913
00:57:44,830 --> 00:57:47,950
GetString e malloc. Quindi, ecco la differenza fondamentale.

914
00:57:47,950 --> 00:57:51,300
>> Sai per le ultime settimane che, se avete bisogno di memoria, ma soltanto dichiarare una variabile.

915
00:57:51,300 --> 00:57:54,560
Se avete bisogno di un sacco di memoria, dichiarare un array proprio all'interno della vostra funzione.

916
00:57:54,560 --> 00:57:59,620
Ma il problema che abbiamo di fronte è tenuto, se si dichiarano delle variabili locali all'interno di funzioni,

917
00:57:59,620 --> 00:58:05,340
non appena la funzione ritorna, cosa succede alla memoria e quelle variabili?

918
00:58:05,340 --> 00:58:09,620
Solo una sorta di non è più tuo, giusto? Scompare appena sorta di concettualmente.

919
00:58:09,620 --> 00:58:13,950
E 'ancora fisicamente lì, ovviamente, ma non è più il diritto di usare.

920
00:58:13,950 --> 00:58:17,160
Questo è ovviamente un problema se si desidera scrivere funzioni della vita

921
00:58:17,160 --> 00:58:20,440
che in realtà allocare la memoria e non restituire immediatamente.

922
00:58:20,440 --> 00:58:24,180
Caso in questione: GetString scopo nella vita è di non avere idea in anticipo

923
00:58:24,180 --> 00:58:26,390
quanto grande di una stringa ho intenzione di scrivere alla tastiera,

924
00:58:26,390 --> 00:58:30,390
ma è avuto modo di essere in grado di allocare memoria per contenere David o ciao

925
00:58:30,390 --> 00:58:32,860
o un saggio intero che l'utente potrebbe aver digitato trovi

926
00:58:32,860 --> 00:58:35,280
Così GetString ha utilizzato malloc.

927
00:58:35,280 --> 00:58:38,910
Malloc quindi deve essere utilizzata non la pila;

928
00:58:38,910 --> 00:58:40,770
invece che sta utilizzando questa cosa chiamata heap.

929
00:58:40,770 --> 00:58:44,430
Non c'è niente di diverso la memoria. Non è più veloce o più lento o qualcosa di simile.

930
00:58:44,430 --> 00:58:46,570
E 'solo fisicamente in una posizione diversa.

931
00:58:46,570 --> 00:58:50,120
>> Ma la regola è che la memoria che viene allocata nell'heap

932
00:58:50,120 --> 00:58:56,180
non potrà mai essere portato via da te finché non viene chiamato - prendere una congettura - libero.

933
00:58:56,180 --> 00:59:00,510
Al contrario, la memoria si chiede in pila da solo dichiarando un array

934
00:59:00,510 --> 00:59:03,320
o la dichiarazione di una variabile come abbiamo fatto per settimane,

935
00:59:03,320 --> 00:59:05,640
che di default finisce in pila.

936
00:59:05,640 --> 00:59:09,550
E che funziona grande 90% del tempo, ma in quelle occasioni rare

937
00:59:09,550 --> 00:59:12,470
in cui si desidera allocare la memoria e tenerlo in giro,

938
00:59:12,470 --> 00:59:14,730
allora avete bisogno di usare una funzione come malloc.

939
00:59:14,730 --> 00:59:19,370
Oppure, abbiamo utilizzato una funzione come GetString, che a sua volta usa malloc.

940
00:59:19,370 --> 00:59:23,300
Vediamo dove questo potrebbe rompersi e quindi dare uno sguardo a Binky.

941
00:59:23,300 --> 00:59:25,820
Torneremo a quella del futuro.

942
00:59:25,820 --> 00:59:29,270
Ecco un programma super semplice che nelle prime 2 righe fa che cosa?

943
00:59:29,270 --> 00:59:33,460
In inglese, che cosa queste prime 2 righe di codice all'interno del principale?

944
00:59:33,460 --> 00:59:35,600
[Risposta degli studenti incomprensibile]

945
00:59:35,600 --> 00:59:37,880
Attento. Non mi dà l'indirizzo di x o y.

946
00:59:37,880 --> 00:59:41,840
[Studente] Dà puntatori a int. Good >>. Dammi due puntatori a interi.

947
00:59:41,840 --> 00:59:45,130
In altre parole, mi ha regalato due pezzi di memoria che tengo disegno oggi,

948
00:59:45,130 --> 00:59:46,950
anche se l'ho cancellato ora, come quadrati.

949
00:59:46,950 --> 00:59:50,000
Dammi due blocchi di memoria, uno chiamato x, uno chiamato y -

950
00:59:50,000 --> 00:59:54,320
prima li ho chiamati s e t - e qual è il tipo di quel pezzo di memoria?

951
00:59:54,320 --> 00:59:57,160
E 'intenzione di memorizzare un indirizzo.

952
00:59:57,160 --> 00:59:59,110
E 'di tipo int *.

953
00:59:59,110 --> 01:00:01,630
>> Quindi, l'indirizzo di un int alla fine vivere in x,

954
01:00:01,630 --> 01:00:03,860
l'indirizzo di un int alla fine vivere in y,

955
01:00:03,860 --> 01:00:08,460
ma inizialmente, quello che c'è dentro di x e y? Chi lo sa? Garbage valori.

956
01:00:08,460 --> 01:00:10,180
Non ha nulla a che fare con i puntatori.

957
01:00:10,180 --> 01:00:12,720
Se non abbiamo messo qualcosa lì, chissà cosa c'è in realtà c'è?

958
01:00:12,720 --> 01:00:18,950
Ora, x. Quello che succede qui? Questo è legittimo perché ora x è un puntatore. E 'un int *.

959
01:00:18,950 --> 01:00:21,870
Questo significa che posso mettere in x l'indirizzo di qualche pezzo di memoria.

960
01:00:21,870 --> 01:00:25,120
Cosa fa malloc ritorna? Perfetto, restituisce gli indirizzi,

961
01:00:25,120 --> 01:00:28,510
l'indirizzo del primo byte in un pezzo intero di memoria.

962
01:00:28,510 --> 01:00:31,140
Quanti byte è questo apparentemente ripartisce, per esempio, nel dispositivo?

963
01:00:31,140 --> 01:00:33,510
Qual è la dimensione di un int? 4.

964
01:00:33,510 --> 01:00:36,600
Se si pensa di nuovo a settimana 1, non è super importante ricordare sempre che,

965
01:00:36,600 --> 01:00:38,870
ma in questo caso è utile sapere, 4 byte.

966
01:00:38,870 --> 01:00:41,770
Quindi questo è l'allocazione sul mucchio 4 byte

967
01:00:41,770 --> 01:00:46,110
e sta restituendo l'indirizzo del primo che me arbitrariamente.

968
01:00:46,110 --> 01:00:47,700
Ora, che cosa sta facendo x?

969
01:00:47,700 --> 01:00:52,200
A * x = 42 sta facendo cosa?

970
01:00:52,200 --> 01:00:57,150
Se a questo punto della storia si ha x, che si presenta così con un certo valore di spazzatura,

971
01:00:57,150 --> 01:01:04,120
questo è ora y con un certo valore di immondizia, ora nella riga 3 ho assegnato 4 byte.

972
01:01:04,120 --> 01:01:06,950
Questa foto appare essenzialmente come questo.

973
01:01:06,950 --> 01:01:12,010
O, più precisamente, se questo è l'indirizzo arbitrario 123, questo è ciò che la nostra storia appare così.

974
01:01:12,010 --> 01:01:23,940
* X = 42, ora che cosa? Questo significa andare a 123 indirizzo e inserire il numero 42 c'è.

975
01:01:23,940 --> 01:01:26,220
Non ho bisogno di disegnare queste linee, perché non stiamo facendo le stringhe.

976
01:01:26,220 --> 01:01:29,480
>> Avrei dovuto scritto come questo, e solo per amor di dimostrazione,

977
01:01:29,480 --> 01:01:33,240
42 come di tipo int occupa molto spazio, 4 byte.

978
01:01:33,240 --> 01:01:35,960
Ecco, questo è quello che è successo lì, ma c'è un problema ora.

979
01:01:35,960 --> 01:01:40,580
* Y = 13. Che cosa sta per succedere qui?

980
01:01:40,580 --> 01:01:46,470
Il problema è y * nel nostro mondo semplificato significa semplicemente aprire l'indirizzo in y.

981
01:01:46,470 --> 01:01:48,590
Cosa c'è in y? È certo valore immondizia.

982
01:01:48,590 --> 01:01:53,150
Quindi supponiamo che tale valore è 5551212 spazzatura, qualcosa di pazzo del genere.

983
01:01:53,150 --> 01:01:56,750
* Mezzi y andare ad affrontare 5551212.

984
01:01:56,750 --> 01:02:00,450
E 'come qui. Non esiste, per esempio.

985
01:02:00,450 --> 01:02:05,310
Così * y diventa 13 mezzi che sto cercando di disegnare 13 qui. Non esiste.

986
01:02:05,310 --> 01:02:08,790
Ho superato il segmento della lavagna. Quali sono i vantaggi?

987
01:02:08,790 --> 01:02:14,930
Questo messaggio di errore criptico segmentazione perché sto cercando di mettere in memoria

988
01:02:14,930 --> 01:02:19,470
un valore come 13 in un luogo che non esiste.

989
01:02:19,470 --> 01:02:23,900
Il resto del programma potrebbe funzionare bene, ma fino a quel momento non è così.

990
01:02:23,900 --> 01:02:25,350
Quindi, cerchiamo di raccontare questa storia.

991
01:02:25,350 --> 01:02:27,830
Torneremo a che una volta che abbiamo parlato di esagono.

992
01:02:27,830 --> 01:02:30,290
Torniamo a questa e concludere con questa cosa chiamata Binky,

993
01:02:30,290 --> 01:02:33,710
che richiamo è un professore di Stanford seduto a casa a giocare con claymation,

994
01:02:33,710 --> 01:02:36,380
per raccontare la storia del proprio questo stesso programma.

995
01:02:36,380 --> 01:02:40,580
E 'solo circa 3 minuti. Qui abbiamo Binky.

996
01:02:40,580 --> 01:02:45,030
[Altoparlante maschio in video] Hey Binky, svegliati. E 'tempo per il divertimento puntatore.

997
01:02:45,030 --> 01:02:50,080
[Binky] Che cos'è? Ulteriori informazioni sui puntatori? Oh, goody!

998
01:02:50,080 --> 01:02:53,700
[Altoparlante maschio] Beh, per iniziare, credo che avremo bisogno di un paio di puntatori.

999
01:02:53,700 --> 01:02:57,890
>> [Binky] Ok. Questo codice assegna 2 puntatori che può puntare a numeri interi.

1000
01:02:57,890 --> 01:03:02,220
[Speaker maschile] Ok. Bene, vedo che i 2 puntatori, ma non sembrano puntare a nulla.

1001
01:03:02,220 --> 01:03:05,550
[Binky] Proprio così. Inizialmente, i puntatori non indicano nulla.

1002
01:03:05,550 --> 01:03:09,270
Le cose a cui puntano sono chiamati pointees, e crearle è una fase separata.

1003
01:03:09,270 --> 01:03:12,330
[Altoparlante maschio] Oh, giusto, giusto. Sapevo che. Le pointees sono separati.

1004
01:03:12,330 --> 01:03:15,630
Er, così come si fa assegnare un pointee?

1005
01:03:15,630 --> 01:03:21,510
[Binky] Ok. Questo codice assegna un pointee nuovo intero, e questa parte imposta x per puntare ad esso.

1006
01:03:21,510 --> 01:03:23,500
[Altoparlante maschio] Ehi, che sembra migliore.

1007
01:03:23,500 --> 01:03:26,030
Così ne fanno fare qualcosa. >> [Binky] Ok.

1008
01:03:26,030 --> 01:03:30,300
Torno dereference x il puntatore per memorizzare il numero 42 nella sua pointee.

1009
01:03:30,300 --> 01:03:34,410
Per questo trucco ho bisogno la mia bacchetta magica di dereferenziazione.

1010
01:03:34,410 --> 01:03:38,610
[Altoparlante maschio] La tua bacchetta magica di dereferenziazione? E 'fantastico.

1011
01:03:38,610 --> 01:03:44,230
[Binky] Questo è ciò che il codice sorgente. Mi limiterò a impostare il numero e la ... [Popping sound]

1012
01:03:44,230 --> 01:03:46,100
[Altoparlante maschio] Ehi, guarda, non ci va.

1013
01:03:46,100 --> 01:03:50,990
Così facendo una dereference sul x segue la freccia per accedere al suo pointee,

1014
01:03:50,990 --> 01:03:53,230
in questo caso per memorizzare 42 dentro.

1015
01:03:53,230 --> 01:03:57,630
Ehi, provare a utilizzare per memorizzare il numero 13 attraverso l'altro puntatore, y.

1016
01:03:57,630 --> 01:04:03,250
[Binky] Ok. Vado qui a y e di ottenere il numero 13 creato

1017
01:04:03,250 --> 01:04:08,360
e poi prendere la bacchetta di dereference e solo ... [Ronzio] Whoa!

1018
01:04:08,360 --> 01:04:10,980
[Maschio altoparlante] Oh, hey, che non ha funzionato.

1019
01:04:10,980 --> 01:04:14,870
>> Dire, Binky, non credo che dereferenziazione y è una buona idea

1020
01:04:14,870 --> 01:04:17,880
Poiché l'installazione di pointee è una fase separata

1021
01:04:17,880 --> 01:04:19,850
e non credo che abbiamo mai fatto.

1022
01:04:19,850 --> 01:04:21,770
[Binky] Hmm, buon punto.

1023
01:04:21,770 --> 01:04:26,640
[Speaker maschile] Si '. Abbiamo assegnato il puntatore y ma non abbiamo mai impostato per puntare a un pointee.

1024
01:04:26,640 --> 01:04:28,780
[Binky] Hmm, molto attento.

1025
01:04:28,780 --> 01:04:30,690
[Altoparlante maschio] Ehi, stai cercando bene lì, Binky.

1026
01:04:30,690 --> 01:04:34,160
Si può risolvere il problema in modo che i punti y al pointee stesso x? >> [Binky] Certo.

1027
01:04:34,160 --> 01:04:37,100
Userò la mia bacchetta magica di assegnazione puntatore.

1028
01:04:37,100 --> 01:04:39,070
[Speaker maschile] è che sarà un problema come prima?

1029
01:04:39,070 --> 01:04:40,840
[Binky] No, questo non tocca i pointees.

1030
01:04:40,840 --> 01:04:44,780
Cambia solo un puntatore per puntare la stessa cosa di un altro. [Popping sound]

1031
01:04:44,780 --> 01:04:48,570
[Altoparlante maschio] Oh, capisco. Ora i punti y al posto stesso x.

1032
01:04:48,570 --> 01:04:51,140
Quindi aspetta. Ora y è fissa. Ha un pointee.

1033
01:04:51,140 --> 01:04:54,520
Così si può provare la bacchetta di dereference di nuovo per inviare i 13 più.

1034
01:04:54,520 --> 01:04:58,130
[Binky] Uh, va bene. Qui va. [Popping sound]

1035
01:04:58,130 --> 01:05:01,250
[Altoparlante maschio] Ehi, guarda un po '. Ora dereferencing opere su y.

1036
01:05:01,250 --> 01:05:05,200
E poiché i puntatori sono la condivisione che si pointee, entrambi vedere la 13.

1037
01:05:05,200 --> 01:05:06,910
[Binky] Sì, la condivisione. Qualunque cosa.

1038
01:05:06,910 --> 01:05:08,880
>> Quindi, abbiamo intenzione di cambiare posti ora?

1039
01:05:08,880 --> 01:05:11,420
[Altoparlante maschio] Oh, guarda, siamo fuori tempo. >> [Binky] Ma -

1040
01:05:11,420 --> 01:05:13,880
[Altoparlante maschio] Basta ricordare le 3 regole del puntatore.

1041
01:05:13,880 --> 01:05:18,630
Numero 1, la struttura di base è che si dispone di un puntatore che punta verso un pointee.

1042
01:05:18,630 --> 01:05:23,120
Ma il puntatore e pointee sono separati, e l'errore comune è quello di creare un puntatore

1043
01:05:23,120 --> 01:05:25,680
ma dimenticare di dare un pointee.

1044
01:05:25,680 --> 01:05:29,580
Numero 2, dereferenziazione puntatore inizia il puntatore e segue la sua freccia sopra

1045
01:05:29,580 --> 01:05:31,060
per accedere alla pointee.

1046
01:05:31,060 --> 01:05:34,340
Come tutti sappiamo, questo funziona solo se c'è un pointee,

1047
01:05:34,340 --> 01:05:36,460
che tipo di torna alla regola numero 1.

1048
01:05:36,460 --> 01:05:39,870
Numero 3, l'assegnazione puntatore assume un puntatore e la cambia

1049
01:05:39,870 --> 01:05:42,390
per puntare alla stessa pointee altro puntatore.

1050
01:05:42,390 --> 01:05:45,890
Così, dopo l'assegnazione, i 2 puntatori punterà alla pointee stesso.

1051
01:05:45,890 --> 01:05:47,800
A volte che si chiama condivisione.

1052
01:05:47,800 --> 01:05:50,910
>> E questo è tutto ciò che devi fare davvero. Bye-bye adesso.

1053
01:05:50,910 --> 01:05:55,840
Questo è Binky. Questo è CS50. Ci vediamo la prossima settimana. [Applausi]

1054
01:05:55,840 --> 01:05:59,000
>> [CS50.TV]