1
00:00:00,000 --> 00:00:11,320

2
00:00:11,320 --> 00:00:13,260
>> DAVID MALAN: Ciao, e
bentornato CS50.

3
00:00:13,260 --> 00:00:14,860
Quindi questa è la fine della quarta settimana.

4
00:00:14,860 --> 00:00:16,680
Solo un annuncio prima.

5
00:00:16,680 --> 00:00:19,600
Così il cosiddetto quinto Lunedi è
in arrivo il prossimo Lunedi.

6
00:00:19,600 --> 00:00:22,800
Questa è l'occasione per passare da
SAT / UNSAT a una lettera di grado, o da

7
00:00:22,800 --> 00:00:24,130
grade lettera SAT / UNSAT.

8
00:00:24,130 --> 00:00:27,130
Fastidiosamente, questo processo richiede un
firma, perché si deve riempire

9
00:00:27,130 --> 00:00:28,770
fuori uno di quei add / drop forme rosa.

10
00:00:28,770 --> 00:00:31,680
>> Perché tecnicamente, la SAT / UNSAT
versione e la versione in lettere

11
00:00:31,680 --> 00:00:33,320
hanno numeri di catalogo distinte.

12
00:00:33,320 --> 00:00:34,240
Ma niente di grave.

13
00:00:34,240 --> 00:00:36,620
Basta venire da me o a Rob
oa Lauren in qualsiasi punto.

14
00:00:36,620 --> 00:00:39,550
O con la posta elettronica se non si ha il tipo
di lavoro di ufficio che serve oggi, e noi

15
00:00:39,550 --> 00:00:43,410
sarà certo per aiutarvi a prendere
cura che prima di Lunedi.

16
00:00:43,410 --> 00:00:45,780
>> Va bene, così oggi -

17
00:00:45,780 --> 00:00:47,630
In realtà, c'è un po 'di eco.

18
00:00:47,630 --> 00:00:51,070
Possiamo tono mi giù un po '?

19
00:00:51,070 --> 00:00:51,730
OK.

20
00:00:51,730 --> 00:00:54,850
Così oggi, si introduce un argomento
noto come puntatori.

21
00:00:54,850 --> 00:00:57,770
E devo ammettere che questo è uno dei
argomenti più complessi che tendiamo a

22
00:00:57,770 --> 00:01:00,960
coprire in questa classe, o davvero qualsiasi
corso introduttivo che utilizza C.

23
00:01:00,960 --> 00:01:05,510
>> Ma prendere la mia parola per esso, in particolare
Se la tua mente si sente un po 'più curvo

24
00:01:05,510 --> 00:01:07,100
oggi e nelle settimane a venire.

25
00:01:07,100 --> 00:01:10,340
Non è rappresentativo di voi ottenere
peggio a questo significa solo che

26
00:01:10,340 --> 00:01:13,360
si tratta di un argomento particolarmente sofisticato
che prometto, un paio di settimane

27
00:01:13,360 --> 00:01:17,610
quindi, vi sembrerà fin troppo sconvolgente
semplice in retrospettiva.

28
00:01:17,610 --> 00:01:18,720
>> Ricordo ancora a questo giorno.

29
00:01:18,720 --> 00:01:22,190
Ero seduto in Elliott Dining Hall,
seduto accanto al mio TF Nishat Mehta,

30
00:01:22,190 --> 00:01:24,070
che è stato un residente della casa di Elliott.

31
00:01:24,070 --> 00:01:26,340
E per qualche ragione, questo
argomento scatta solo.

32
00:01:26,340 --> 00:01:29,430
Il che vuol dire che ho faticato troppo
con esso per un certo periodo di tempo, ma ho

33
00:01:29,430 --> 00:01:33,610
Farò il mio meglio per contribuire ad evitare qualsiasi
lotta con un argomento che in ultima analisi,

34
00:01:33,610 --> 00:01:34,580
è abbastanza potente.

35
00:01:34,580 --> 00:01:37,350
>> In effetti, uno dei temi che discuteremo
nelle settimane a venire è che

36
00:01:37,350 --> 00:01:41,130
di sicurezza, e di come in realtà si può
sfruttare macchine in modi

37
00:01:41,130 --> 00:01:42,320
che non erano destinate.

38
00:01:42,320 --> 00:01:45,850
E questi sfruttamenti sono tipicamente
il risultato di bug, errori che abbiamo

39
00:01:45,850 --> 00:01:49,740
le persone fanno da non capire un po 'di
dall'implementazione sottostante

40
00:01:49,740 --> 00:01:52,250
Dettagli mediante cui vengono effettuati programmi.

41
00:01:52,250 --> 00:01:55,410
>> Ora per fare questo sembrare più user
amichevole, ho pensato di giocare a 10

42
00:01:55,410 --> 00:01:59,680
secondi di anteprima di un po 'di claymation
figura di nome Binky che è stato portato a

43
00:01:59,680 --> 00:02:03,020
vita da un nostro amico a Stanford,
professore Nick Parlante.

44
00:02:03,020 --> 00:02:06,753
Quindi, mi permetta di darle questo
teaser del Binky qui.

45
00:02:06,753 --> 00:02:09,520
>> [RIPRODUZIONE VIDEO]

46
00:02:09,520 --> 00:02:10,380
>> -Ehi, Binky.

47
00:02:10,380 --> 00:02:11,050
Svegliati.

48
00:02:11,050 --> 00:02:13,610
E 'tempo per il divertimento puntatore.

49
00:02:13,610 --> 00:02:14,741
>> -Che cosa?

50
00:02:14,741 --> 00:02:16,440
Ulteriori informazioni su puntatori?

51
00:02:16,440 --> 00:02:17,928
Oh, goodie.

52
00:02:17,928 --> 00:02:18,920
>> [FINE RIPRODUZIONE VIDEO]

53
00:02:18,920 --> 00:02:20,670
>> DAVID MALAN: Cioè Stanford
informatica.

54
00:02:20,670 --> 00:02:23,194
Quindi, più su quello a venire.

55
00:02:23,194 --> 00:02:24,930
>> [Applausi]

56
00:02:24,930 --> 00:02:26,660
>> DAVID MALAN: Ci dispiace, Nick.

57
00:02:26,660 --> 00:02:30,680
>> Quindi, ricordare che l'ultima volta abbiamo finito il
questo davvero emozionante Cliffhanger

58
00:02:30,680 --> 00:02:32,960
per cui questa funzione
semplicemente non ha funzionato.

59
00:02:32,960 --> 00:02:34,960
Almeno intuitivamente, si sentiva
come dovrebbe funzionare.

60
00:02:34,960 --> 00:02:37,600
Semplicemente sostituendo i valori
di due numeri interi.

61
00:02:37,600 --> 00:02:40,915
Ma ricordo che quando abbiamo stampato il
valori originali nella principale, uno e

62
00:02:40,915 --> 00:02:44,210
due, erano ancora uno e
due e non due e uno.

63
00:02:44,210 --> 00:02:46,070
>> Così mi permetta effettivamente passare
oltre all'apparecchio.

64
00:02:46,070 --> 00:02:50,180
E ho scritto un po 'di codice scheletrico in
avanzare qui, dove io sostengo che x

65
00:02:50,180 --> 00:02:52,500
sarà 1, y sarà 2.

66
00:02:52,500 --> 00:02:54,810
Ho poi stampare le due di loro
valori con stampa f.

67
00:02:54,810 --> 00:02:57,540
>> Allora io sostengo qui che
stiamo andando a scambiarle.

68
00:02:57,540 --> 00:03:00,800
Ho lasciato un posto vuoto qui per noi
compila oggi in un attimo.

69
00:03:00,800 --> 00:03:03,380
Poi, ho intenzione di sostenere che il
due variabili sono state scambiate.

70
00:03:03,380 --> 00:03:04,770
Poi ho intenzione di stampare
li di nuovo.

71
00:03:04,770 --> 00:03:07,090
E così si spera, dovrei vedere 1, 2.

72
00:03:07,090 --> 00:03:07,380
2, 1.

73
00:03:07,380 --> 00:03:09,830
Questo è il super semplice
obiettivo al momento.

74
00:03:09,830 --> 00:03:12,430
>> Quindi, come facciamo a scambiare
due variabili?

75
00:03:12,430 --> 00:03:17,220
Beh, se vi propongo qui che queste tazze
potrebbero rappresentare memoria in un computer.

76
00:03:17,220 --> 00:03:19,070
Si tratta di un paio di morsi, questo
è un altro paio di morsi.

77
00:03:19,070 --> 00:03:23,260
Avremmo potuto un volontario vieni su e
mescolare qualcosa da bere, se familiare?

78
00:03:23,260 --> 00:03:23,920
Andiamo su.

79
00:03:23,920 --> 00:03:24,815
Qual è il tuo nome?

80
00:03:24,815 --> 00:03:25,260
>> JESS: Jess.

81
00:03:25,260 --> 00:03:25,690
>> DAVID MALAN: Jess?

82
00:03:25,690 --> 00:03:26,540
Vieni su, Jess.

83
00:03:26,540 --> 00:03:29,180
Se non ti dispiace, dobbiamo mettere il
Google Glass su di voi in modo che possiamo

84
00:03:29,180 --> 00:03:30,430
immortalare questo.

85
00:03:30,430 --> 00:03:32,800

86
00:03:32,800 --> 00:03:34,670
OK, vetro.

87
00:03:34,670 --> 00:03:37,250
Registrare un video.

88
00:03:37,250 --> 00:03:43,103
E OK, siamo bravi a
andare con Jess qui.

89
00:03:43,103 --> 00:03:43,810
D'accordo.

90
00:03:43,810 --> 00:03:45,120
Lieto di vederla.

91
00:03:45,120 --> 00:03:47,720
>> Quindi quello che vorrei fare qui -
se si potesse, abbastanza rapidamente -

92
00:03:47,720 --> 00:03:51,040
solo noi versa mezzo bicchiere d'arancio
succo e mezzo bicchiere di latte,

93
00:03:51,040 --> 00:03:55,710
che rappresenta in modo efficace i numeri 1
in una tazza e 2 nell'altra tazza.

94
00:03:55,710 --> 00:04:01,380

95
00:04:01,380 --> 00:04:02,630
>> Questo sta per essere buoni filmati.

96
00:04:02,630 --> 00:04:04,910

97
00:04:04,910 --> 00:04:05,860
>> JESS: Mi dispiace.

98
00:04:05,860 --> 00:04:06,330
>> DAVID MALAN: No, no.

99
00:04:06,330 --> 00:04:08,703
E 'OK.

100
00:04:08,703 --> 00:04:10,120
Nizza.

101
00:04:10,120 --> 00:04:12,950
Va bene, così abbiamo quattro byte
vale la pena di succo d'arancia.

102
00:04:12,950 --> 00:04:14,460
Ci chiamavamo il valore 1.

103
00:04:14,460 --> 00:04:16,579
Ora altri quattro byte di valore di latte.

104
00:04:16,579 --> 00:04:18,519
Chiameremo valore 2.

105
00:04:18,519 --> 00:04:20,440
Così xey, rispettivamente.

106
00:04:20,440 --> 00:04:23,450
>> Bene, così ora se il compito a portata di mano -
per te, Jess, davanti a tutti

107
00:04:23,450 --> 00:04:24,270
dei tuoi compagni di classe -

108
00:04:24,270 --> 00:04:28,510
è quello di scambiare i valori di x e y tali
che vogliamo che il succo d'arancia in

109
00:04:28,510 --> 00:04:32,070
altra tazza e il latte in questa coppa, come
si potrebbe - in realtà prima di fare

110
00:04:32,070 --> 00:04:34,020
esso - andare a fare questo?

111
00:04:34,020 --> 00:04:35,220
>> OK, saggia decisione.

112
00:04:35,220 --> 00:04:36,340
Allora avete bisogno di un po 'più di memoria.

113
00:04:36,340 --> 00:04:38,190
Quindi cerchiamo di allocare un temporaneo
tazza, se si vuole.

114
00:04:38,190 --> 00:04:40,540
E ora procedere a scambiare x e y.

115
00:04:40,540 --> 00:04:52,950

116
00:04:52,950 --> 00:04:53,530
>> Eccellente.

117
00:04:53,530 --> 00:04:54,420
Quindi, molto ben fatto.

118
00:04:54,420 --> 00:04:55,670
Grazie mille, Jess.

119
00:04:55,670 --> 00:04:59,520

120
00:04:59,520 --> 00:05:00,020
Ecco.

121
00:05:00,020 --> 00:05:01,950
Un piccolo souvenir.

122
00:05:01,950 --> 00:05:04,350
>> OK, quindi ovviamente, super semplice idea.

123
00:05:04,350 --> 00:05:07,500
Completamente intuitivo che abbiamo bisogno di un po '
più spazio di archiviazione - in questa forma,

124
00:05:07,500 --> 00:05:09,750
una tazza - se vogliamo davvero
scambiare queste due variabili.

125
00:05:09,750 --> 00:05:11,110
Quindi cerchiamo di fare esattamente questo.

126
00:05:11,110 --> 00:05:14,330
Quassù tra cui io sostengo che sono
intenzione di fare qualche scambio, io

127
00:05:14,330 --> 00:05:15,720
andare avanti e dichiarare temperatura.

128
00:05:15,720 --> 00:05:17,980
E mi misi pari a, diciamo, x.

129
00:05:17,980 --> 00:05:21,110
>> Poi ho intenzione di cambiare il valore di
x come Jess ha fatto qui con il

130
00:05:21,110 --> 00:05:23,200
latte e succo d'arancia
per essere uguale a y.

131
00:05:23,200 --> 00:05:27,460
E ho intenzione di cambiare y per essere uguale
a non x, perché ora saremmo

132
00:05:27,460 --> 00:05:29,530
bloccato in un circolo, ma piuttosto temp.

133
00:05:29,530 --> 00:05:33,170
Dove temporaneamente - o dove Jess
mettere temporaneamente il succo d'arancia

134
00:05:33,170 --> 00:05:35,460
prima di sovrascrivere quello
tazza con il latte.

135
00:05:35,460 --> 00:05:37,250
>> Quindi, mi permetta di andare avanti ora e faccio questo.

136
00:05:37,250 --> 00:05:39,210
Si chiama noswap.c.

137
00:05:39,210 --> 00:05:41,190
E adesso lasciatemi correre senza swap.

138
00:05:41,190 --> 00:05:43,910
E infatti lo vedo, se mi espando la
finestra un po ', che

139
00:05:43,910 --> 00:05:45,160
x è 1, y è 2.

140
00:05:45,160 --> 00:05:47,230
E allora x è 2, y è 1.

141
00:05:47,230 --> 00:05:51,910
>> Ma ricordiamo che il Lunedi abbiamo fatto le cose
un po 'diverso per cui ho

142
00:05:51,910 --> 00:05:56,760
invece implementato una funzione di supporto,
se si vuole, che era in realtà vuoto.

143
00:05:56,760 --> 00:05:58,010
Ho chiamato lo swap.

144
00:05:58,010 --> 00:06:01,600
Ho dato due parametri, e ho chiamato
loro una e li ho chiamati b.

145
00:06:01,600 --> 00:06:04,380
>> Francamente, ho potuto chiamarli x e y.

146
00:06:04,380 --> 00:06:06,040
Non c'è niente di arresto
me di farlo.

147
00:06:06,040 --> 00:06:08,140
Ma direi che è poi
un po ambiguo.

148
00:06:08,140 --> 00:06:11,910
Perché richiamo per Lunedi che abbiamo
hanno sostenuto che questi parametri sono stati

149
00:06:11,910 --> 00:06:13,650
copie dei valori passati dentro

150
00:06:13,650 --> 00:06:15,640
Così appena pasticci con la tua
mente, penso che, se si utilizza

151
00:06:15,640 --> 00:06:17,370
esattamente le stesse variabili.

152
00:06:17,370 --> 00:06:20,150
>> Così io, invece loro una chiamata
e B, solo per chiarezza.

153
00:06:20,150 --> 00:06:21,840
Ma potremmo chiamarli più
tutto ciò che vogliamo.

154
00:06:21,840 --> 00:06:26,280
E ho intenzione di copiare e incollare
efficacemente questo codice da lassù

155
00:06:26,280 --> 00:06:27,170
giù in qui.

156
00:06:27,170 --> 00:06:29,110
Perché ho appena visto che funziona.

157
00:06:29,110 --> 00:06:30,790
Ecco, questo è in buona forma.

158
00:06:30,790 --> 00:06:37,390
E io cambierò x un mio x
ad una, la mia y per B e la mia y per b.

159
00:06:37,390 --> 00:06:39,130
>> Quindi, in altre parole, esatto stessa logica.

160
00:06:39,130 --> 00:06:40,850
La stessa identica cosa che Jess ha fatto.

161
00:06:40,850 --> 00:06:44,350
E allora l'unica cosa che devo fare up
qui, naturalmente, è ora invocare questa

162
00:06:44,350 --> 00:06:45,990
funzione, oppure chiamare questa funzione.

163
00:06:45,990 --> 00:06:50,430
Quindi mi chiamare questa funzione con due
ingressi, x e y, e ha colpito Salva.

164
00:06:50,430 --> 00:06:52,300
>> Va bene, quindi fondamentalmente
la stessa cosa.

165
00:06:52,300 --> 00:06:55,570
In realtà, probabilmente ho fatto il programma
inutilmente complesso da

166
00:06:55,570 --> 00:07:00,820
scrivere una funzione che sta solo prendendo
circa sei righe di codice, mentre io

167
00:07:00,820 --> 00:07:02,970
in precedenza aveva implementato
questo in solo tre.

168
00:07:02,970 --> 00:07:06,230
>> Quindi, mi permetta di andare avanti ora e rifare
questo, non fare swap.

169
00:07:06,230 --> 00:07:07,920
Va bene, ho fatto un casino qui.

170
00:07:07,920 --> 00:07:11,290
Questo dovrebbe essere un errore che si potrebbe
vedere sempre più comunemente come il tuo

171
00:07:11,290 --> 00:07:12,380
programmi diventano più complessi.

172
00:07:12,380 --> 00:07:13,470
Ma c'è una soluzione semplice.

173
00:07:13,470 --> 00:07:15,650
Lasciate scorrere indietro fino qui.

174
00:07:15,650 --> 00:07:18,190
>> E qual è il primo errore che sto vedendo?

175
00:07:18,190 --> 00:07:19,520
Dichiarazione implicita.

176
00:07:19,520 --> 00:07:21,466
Che cosa indicano in genere?

177
00:07:21,466 --> 00:07:22,830
Oh, ho dimenticato il prototipo.

178
00:07:22,830 --> 00:07:26,900
Ho dimenticato di insegnare al compilatore che di swap
è andare a esistere anche se lui

179
00:07:26,900 --> 00:07:28,920
non esiste proprio all'inizio
del programma.

180
00:07:28,920 --> 00:07:35,780
Così sto solo andando a dire nulla, swap,
int, int b, punto e virgola.

181
00:07:35,780 --> 00:07:37,280
>> Quindi io non ho intenzione di implementare di nuovo esso.

182
00:07:37,280 --> 00:07:39,140
Ma ora che corrisponda a ciò che è quaggiù.

183
00:07:39,140 --> 00:07:42,530
E comunicazione, l'assenza di una virgola
qui, che non è necessaria quando

184
00:07:42,530 --> 00:07:43,200
attuazione.

185
00:07:43,200 --> 00:07:46,010
>> Quindi, mi permetta di rifare questo, non fare swap.

186
00:07:46,010 --> 00:07:46,910
Molto più in forma.

187
00:07:46,910 --> 00:07:48,130
Esegui senza swap.

188
00:07:48,130 --> 00:07:48,740
E dannazione.

189
00:07:48,740 --> 00:07:51,650
Ora siamo tornati dove eravamo il Lunedi,
dove la cosa non scambiare.

190
00:07:51,650 --> 00:07:55,410
>> E qual è la spiegazione intuitiva
per cui questo è il caso?

191
00:07:55,410 --> 00:07:56,380
Sì?

192
00:07:56,380 --> 00:07:57,630
>> STUDENTE: [incomprensibile].

193
00:07:57,630 --> 00:08:04,140

194
00:08:04,140 --> 00:08:05,230
>> DAVID MALAN: Esattamente.

195
00:08:05,230 --> 00:08:07,330
Quindi a e b sono le copie di x e y.

196
00:08:07,330 --> 00:08:10,680
E infatti, ogni volta che sono stato
chiamare una funzione finora che

197
00:08:10,680 --> 00:08:12,540
passa variabili come int -

198
00:08:12,540 --> 00:08:14,470
proprio come swap si aspetta qui -

199
00:08:14,470 --> 00:08:16,270
voi ragazzi sono stati passando copie.

200
00:08:16,270 --> 00:08:19,150
>> Ora che significa che ci vuole un po '
di tempo, una frazione di secondo, per l'

201
00:08:19,150 --> 00:08:23,270
computer per copiare i bit da un
variabile nei bit di un altro.

202
00:08:23,270 --> 00:08:24,610
Ma non è un grande affare.

203
00:08:24,610 --> 00:08:25,920
Ma sono comunque una copia.

204
00:08:25,920 --> 00:08:30,020
>> E così ora, nel contesto di swap,
Sono infatti con successo

205
00:08:30,020 --> 00:08:31,180
cambiando ae b.

206
00:08:31,180 --> 00:08:33,000
In realtà, cerchiamo di fare un rapido
controllo di integrità.

207
00:08:33,000 --> 00:08:36,830
Stampa f a è% i, nuova linea.

208
00:08:36,830 --> 00:08:38,770
E spina andiamo in un.

209
00:08:38,770 --> 00:08:41,830
Ora facciamo la stessa cosa con b.

210
00:08:41,830 --> 00:08:43,640
E cerchiamo di fare la stessa cosa qui.

211
00:08:43,640 --> 00:08:47,260
>> E ora, mi permetta di copiare queste stesse linee
nuovamente al fondo della funzione

212
00:08:47,260 --> 00:08:51,250
dopo le mie tre linee di interessante
avrebbe eseguito, e

213
00:08:51,250 --> 00:08:53,270
stampare ancora una volta a e b.

214
00:08:53,270 --> 00:08:56,030
Così ora facciamo questo, non fare swap.

215
00:08:56,030 --> 00:08:58,430
Permettetemi di fare la finestra del terminale di un
po 'più alto, in modo che possiamo vedere

216
00:08:58,430 --> 00:08:59,520
più di esso in una volta.

217
00:08:59,520 --> 00:09:00,860
>> E correre senza swap.

218
00:09:00,860 --> 00:09:04,000
x è 1, y è 2. a è 1, b è 2.

219
00:09:04,000 --> 00:09:06,070
E poi, a è 2, b è 1.

220
00:09:06,070 --> 00:09:09,390
Quindi si sta lavorando, proprio come Jess
fatto qui dentro di swap.

221
00:09:09,390 --> 00:09:13,090
Ma, naturalmente, non sta avendo alcun effetto
sulle variabili principali.

222
00:09:13,090 --> 00:09:15,360
>> Così abbiamo visto un trucco con cui abbiamo
potrebbe risolvere questo problema, giusto?

223
00:09:15,360 --> 00:09:19,560
Quando sei di fronte a questo scoping
problema, si può solo punt e fare x

224
00:09:19,560 --> 00:09:22,400
ed y che tipo di variabili invece?

225
00:09:22,400 --> 00:09:23,390
>> Si potrebbe fare di loro globale.

226
00:09:23,390 --> 00:09:27,560
Metterli in cima del file
come abbiamo fatto, anche nel gioco del 15.

227
00:09:27,560 --> 00:09:28,890
Usiamo una variabile globale.

228
00:09:28,890 --> 00:09:32,420
Ma nel contesto del gioco a 15,
è ragionevole avere un globale

229
00:09:32,420 --> 00:09:37,170
variabile che rappresenta il bordo, perché
l'interezza di 15.c è tutto

230
00:09:37,170 --> 00:09:38,650
circa l'attuazione di quel gioco.

231
00:09:38,650 --> 00:09:41,470
Questo è ciò che esiste il file per farlo.

232
00:09:41,470 --> 00:09:44,170
>> Ma in questo caso qui, sono
chiamando una funzione di swap.

233
00:09:44,170 --> 00:09:45,380
Vorrei scambiare due variabili.

234
00:09:45,380 --> 00:09:48,950
E dovrebbe iniziare a sentire solo sciatta
se la soluzione a tutti i nostri

235
00:09:48,950 --> 00:09:51,300
problemi quando ci imbattiamo in ambito
problemi è renderlo globale.

236
00:09:51,300 --> 00:09:54,730
Perché molto rapidamente il nostro programma è
sta per diventare un bel pasticcio.

237
00:09:54,730 --> 00:09:57,760
E lo abbiamo fatto con molta parsimonia
di conseguenza in 15.c.

238
00:09:57,760 --> 00:10:00,470
>> Ma si scopre c'è un
migliore modo del tutto.

239
00:10:00,470 --> 00:10:05,600
Lasciatemi in realtà tornare indietro e cancellare la
stampare f di, solo per semplificare il codice.

240
00:10:05,600 --> 00:10:09,160
E lasciatemi propongo
questo, infatti, è un male.

241
00:10:09,160 --> 00:10:15,990
Ma se io invece aggiungo in alcuni asterischi
e le stelle, posso invece trasformare questo

242
00:10:15,990 --> 00:10:18,670
funzione in uno che è
effettivamente operativa.

243
00:10:18,670 --> 00:10:25,020
>> Così mi permetta di tornare qui e ammetto dicendo
asterischi è sempre difficile,

244
00:10:25,020 --> 00:10:26,170
quindi mi dico stelle.

245
00:10:26,170 --> 00:10:27,660
Mi limiterò a confessare a quella.

246
00:10:27,660 --> 00:10:28,190
D'accordo.

247
00:10:28,190 --> 00:10:30,190
E ora, che cosa sono io che vado
fare, invece?

248
00:10:30,190 --> 00:10:34,130
>> Quindi, prima di tutto, ho intenzione di specificare
che invece di passare un int in

249
00:10:34,130 --> 00:10:37,980
la funzione swap, sono invece
di andare a dire int stella.

250
00:10:37,980 --> 00:10:39,170
Ora, che cosa indica la stella?

251
00:10:39,170 --> 00:10:41,970
Questa è quella nozione di un puntatore che
Binky, il personaggio claymation, era

252
00:10:41,970 --> 00:10:43,465
riferimento a un momento fa.

253
00:10:43,465 --> 00:10:47,610
>> Quindi, se diciamo int stella, il significato di
questo ora è che una non sta per essere

254
00:10:47,610 --> 00:10:49,110
passata in dal suo valore.

255
00:10:49,110 --> 00:10:50,350
Non sta andando da copiare dentro

256
00:10:50,350 --> 00:10:54,700
Piuttosto, l'indirizzo di a è
sta per essere passata dentro

257
00:10:54,700 --> 00:10:57,840
>> Così ricordare che all'interno del vostro computer
è un sacco di memoria, altrimenti

258
00:10:57,840 --> 00:10:58,760
noto come RAM.

259
00:10:58,760 --> 00:11:00,520
E che la RAM è solo un
mucchio di byte.

260
00:11:00,520 --> 00:11:03,320
Quindi, se il tuo Mac o il PC ha
due gigabyte, si hanno 2

261
00:11:03,320 --> 00:11:05,760
miliardi di byte di memoria.

262
00:11:05,760 --> 00:11:08,440
>> Ora facciamo solo supporre che proprio per
mantenere le cose belle e ordinato, abbiamo

263
00:11:08,440 --> 00:11:09,450
assegnare un indirizzo -

264
00:11:09,450 --> 00:11:10,170
un numero -

265
00:11:10,170 --> 00:11:12,270
per ogni byte di RAM presente nel computer.

266
00:11:12,270 --> 00:11:15,410
Il primo byte di quelli 2
miliardi sono in numero pari a zero.

267
00:11:15,410 --> 00:11:18,572
Il prossimo è il numero di byte uno, numero
due, tutta la strada in su, punto punto

268
00:11:18,572 --> 00:11:20,530
dot, a circa 2 miliardi di euro.

269
00:11:20,530 --> 00:11:23,640
>> Così si può certo numero di byte
della memoria del computer.

270
00:11:23,640 --> 00:11:26,460
Quindi supponiamo che questo è ciò che
intendiamo per un indirizzo.

271
00:11:26,460 --> 00:11:31,360
Così, quando vedo una stella int, che cosa sta succedendo
per essere passato in scambio ora è il

272
00:11:31,360 --> 00:11:32,830
indirizzo di una.

273
00:11:32,830 --> 00:11:37,150
Non è il suo valore, ma qualunque sia la sua postali
indirizzo è, per così dire -

274
00:11:37,150 --> 00:11:38,810
la sua posizione nella RAM.

275
00:11:38,810 --> 00:11:41,250
>> E similmente per b, io vado
per dire la stessa cosa.

276
00:11:41,250 --> 00:11:42,720
Int, stella, b.

277
00:11:42,720 --> 00:11:46,350
Per inciso, tecnicamente la stella
potrebbe andare in altri luoghi.

278
00:11:46,350 --> 00:11:50,140
Ma faremo standardizzare la stella essendo
proprio accanto al tipo di dati.

279
00:11:50,140 --> 00:11:54,080
>> Così scambiare firma ora significa, dammi
l'indirizzo di un int, e chiamata

280
00:11:54,080 --> 00:11:55,400
che l'indirizzo a.

281
00:11:55,400 --> 00:11:58,690
E dammi un altro indirizzo di un
INT e chiamare tale indirizzo b.

282
00:11:58,690 --> 00:12:01,120
>> Ma ora il mio codice qui deve cambiare.

283
00:12:01,120 --> 00:12:03,470
Perché se io dichiaro int temp -

284
00:12:03,470 --> 00:12:05,580
che è ancora di tipo int -

285
00:12:05,580 --> 00:12:08,700
ma devo conservare in esso una,
che tipo di valore?

286
00:12:08,700 --> 00:12:12,870
Per essere chiari, sto mettendo a con
il codice come scritto in questo momento?

287
00:12:12,870 --> 00:12:14,360
>> Sto mettendo la posizione in una.

288
00:12:14,360 --> 00:12:16,500
Ma non mi preoccupo per il
posizione ora, giusto?

289
00:12:16,500 --> 00:12:21,940
Temp esiste solo terza coppa Jess '
esistito, per quale scopo?

290
00:12:21,940 --> 00:12:23,090
Per memorizzare un valore.

291
00:12:23,090 --> 00:12:24,830
Latte o succo d'arancia.

292
00:12:24,830 --> 00:12:28,520
Non quello di archiviare l'indirizzo del
una di quelle cose, che si sente un

293
00:12:28,520 --> 00:12:31,200
poco senza senso in questo vero e proprio
contesto mondiale comunque.

294
00:12:31,200 --> 00:12:34,990
>> Quindi, in realtà, quello che voglio mettere in temperatura
non è l'indirizzo di una, ma l'

295
00:12:34,990 --> 00:12:36,180
contenuto di un.

296
00:12:36,180 --> 00:12:41,930
Quindi se a è un numero come 123, questo è
il byte 123 di memoria che un solo

297
00:12:41,930 --> 00:12:45,090
sembra essere occupante, che il valore
in una sembra essere occupante.

298
00:12:45,090 --> 00:12:49,040
>> Se voglio andare a tale indirizzo,
Ho bisogno di dire una stella.

299
00:12:49,040 --> 00:12:52,610
Allo stesso modo, se dovessi cambiare ciò che è
presso l'indirizzo di una, io cambio

300
00:12:52,610 --> 00:12:53,570
questo per iniziare una.

301
00:12:53,570 --> 00:12:58,185
Se voglio conservare in ciò che è al
posizione una con ciò che è nella posizione

302
00:12:58,185 --> 00:13:02,180
in b, b stella stella.

303
00:13:02,180 --> 00:13:05,340
>> Così, in breve, anche se questo non è abbastanza
affondando in ancora - e non mi aspetto

304
00:13:05,340 --> 00:13:06,560
che sarebbe così veloce -

305
00:13:06,560 --> 00:13:11,100
si rendono conto che tutto quello che sto facendo è prefisso
queste stelle ai miei variabili,

306
00:13:11,100 --> 00:13:13,350
dicendo di non prendere i valori.

307
00:13:13,350 --> 00:13:14,520
Non modificare i valori.

308
00:13:14,520 --> 00:13:17,600
Ma piuttosto, andare a questi indirizzi
e ottenere il valore.

309
00:13:17,600 --> 00:13:21,430
Vai a questo indirizzo e il cambiamento
il valore lì.

310
00:13:21,430 --> 00:13:25,500
>> Così ora mi permetta di scorrere indietro fino alla cima,
solo per risolvere questa linea qui, per

311
00:13:25,500 --> 00:13:27,690
modificare il prototipo in modo che corrisponda.

312
00:13:27,690 --> 00:13:30,280
Ma ora ho bisogno di fare un'altra cosa.

313
00:13:30,280 --> 00:13:35,500
Intuitivamente, se ho cambiato i tipi
di argomenti che di swap si aspetta,

314
00:13:35,500 --> 00:13:37,245
che altro ho bisogno di
cambiare nel mio codice?

315
00:13:37,245 --> 00:13:39,750

316
00:13:39,750 --> 00:13:40,840
>> Quando chiamo swap.

317
00:13:40,840 --> 00:13:43,340
Perché in questo momento, che cosa sono
Ho passando per scambiare ancora?

318
00:13:43,340 --> 00:13:47,450
Il valore x e il valore di y, o
il latte e il succo d'arancia.

319
00:13:47,450 --> 00:13:48,510
Ma io non voglio farlo.

320
00:13:48,510 --> 00:13:51,060
Io invece voglio passare a cosa?

321
00:13:51,060 --> 00:13:53,050
La posizione di x e
la posizione di y.

322
00:13:53,050 --> 00:13:55,300
Quali sono i loro indirizzi postali,
per così dire.

323
00:13:55,300 --> 00:13:57,600
>> Quindi, per fare questo, c'è una e commerciale.

324
00:13:57,600 --> 00:13:59,260
Ampersand tipo di suoni come indirizzo.

325
00:13:59,260 --> 00:14:03,240
quindi n, e commerciale, l'indirizzo
di x, e l'indirizzo di y.

326
00:14:03,240 --> 00:14:06,790
Quindi è deliberato che usiamo
ampersands al richiamo della funzione,

327
00:14:06,790 --> 00:14:10,230
e le stelle quando si dichiarano e quando
realizzazione della funzione.

328
00:14:10,230 --> 00:14:14,220
>> E basta pensare e commerciale come il
indirizzo dell'operatore, e la stella come il

329
00:14:14,220 --> 00:14:15,490
andare là operatore -

330
00:14:15,490 --> 00:14:18,640
o, più correttamente, l'
operatore di risoluzione del riferimento.

331
00:14:18,640 --> 00:14:23,480
Ecco, questo è un bel po 'di parole solo per
dire che ora, si spera, di swap sta

332
00:14:23,480 --> 00:14:24,440
di essere corretto.

333
00:14:24,440 --> 00:14:26,550
>> Lasciatemi andare avanti e fare -

334
00:14:26,550 --> 00:14:30,940
diamo effettivamente rinominare il file, per timore
questo programma ancora essere chiamato senza swap.

335
00:14:30,940 --> 00:14:33,240
Io sostengo che noi chiameremo swap.c ora.

336
00:14:33,240 --> 00:14:35,670
Quindi, fare, invertire.

337
00:14:35,670 --> 00:14:37,520
Dot, slash, scambiare.

338
00:14:37,520 --> 00:14:40,210
>> E ora infatti, x è 1, y è 2.

339
00:14:40,210 --> 00:14:44,040
E poi, è x 2, y è uno.

340
00:14:44,040 --> 00:14:46,500
Bene vediamo se non siamo in grado di fare questo un
po 'diverso da ciò che è

341
00:14:46,500 --> 00:14:47,180
succedendo qui.

342
00:14:47,180 --> 00:14:51,250
In primo luogo, permettetemi di zoomare su un nostro
schermo di disegno qui.

343
00:14:51,250 --> 00:14:54,160
E mi permetta di proporre un momento - e
ogni volta che disegno qui si rifletterà

344
00:14:54,160 --> 00:14:58,660
lassù ora - lasciatemi propongo
qui c'è un sacco di memoria, o

345
00:14:58,660 --> 00:15:00,540
RAM, all'interno del mio computer.

346
00:15:00,540 --> 00:15:04,140
>> E questo sarà il numero morso,
diciamo, 1.

347
00:15:04,140 --> 00:15:05,720
Questo sarà il byte numero 2.

348
00:15:05,720 --> 00:15:08,220
E farò un sacco di più, e
poi un po 'di punti puntini puntino a

349
00:15:08,220 --> 00:15:10,880
indicano che ci sono 2 miliardi
di queste cose.

350
00:15:10,880 --> 00:15:13,520
4, 5, e così via.

351
00:15:13,520 --> 00:15:17,055
>> Così ci sono i primi cinque byte
della memoria del mio computer.

352
00:15:17,055 --> 00:15:17,560
D'accordo?

353
00:15:17,560 --> 00:15:19,060
Pochissimi di 2 miliardi di euro.

354
00:15:19,060 --> 00:15:21,120
Ma ora ho intenzione di proporre
il seguente.

355
00:15:21,120 --> 00:15:27,490
Ho intenzione di proporre che x sta per
memorizzare il numero 1, ed y è andare

356
00:15:27,490 --> 00:15:29,690
per memorizzare il numero 2.

357
00:15:29,690 --> 00:15:35,000
E mi permetta di andare avanti ora e rappresenta
questi valori come segue.

358
00:15:35,000 --> 00:15:41,510
>> Facciamo questo come segue.

359
00:15:41,510 --> 00:15:42,870
Dammi solo un secondo.

360
00:15:42,870 --> 00:15:44,150
Un secondo.

361
00:15:44,150 --> 00:15:45,680
OK.

362
00:15:45,680 --> 00:15:47,560
Voglio fare questo un po '-

363
00:15:47,560 --> 00:15:50,440
cerchiamo di farlo di nuovo.

364
00:15:50,440 --> 00:15:53,250
In caso contrario, ho intenzione di e con il
stessi numeri, involontariamente,

365
00:15:53,250 --> 00:15:54,230
più volte.

366
00:15:54,230 --> 00:15:57,320
>> Quindi, solo così abbiamo numeri diversi
per parlare di, chiamiamola questo byte

367
00:15:57,320 --> 00:16:03,391
numero 123, 124, 125, 126,
e puntini puntini.

368
00:16:03,391 --> 00:16:08,400
E lasciatemi pretendo ora che ho intenzione di
mettere il valore 1 qui, e il valore 2

369
00:16:08,400 --> 00:16:11,990
qui, altrimenti noto come x e y.

370
00:16:11,990 --> 00:16:15,300
Così si da il caso che
questo è x, questo è y.

371
00:16:15,300 --> 00:16:18,180
>> E solo per un caso a caso, il
computer, il sistema operativo,

372
00:16:18,180 --> 00:16:21,890
successo a mettere in posizione x
numero 123.

373
00:16:21,890 --> 00:16:25,590
E Y è finito in posizione 124 -

374
00:16:25,590 --> 00:16:26,330
dannazione.

375
00:16:26,330 --> 00:16:28,700
Avrei risolto questo.

376
00:16:28,700 --> 00:16:34,040
Oh uomo, voglio davvero fare questo?

377
00:16:34,040 --> 00:16:37,340
Sì, voglio risolvere questo problema e
b adeguata di questo oggi.

378
00:16:37,340 --> 00:16:39,950
Siamo spiacenti, nuovo a questo.

379
00:16:39,950 --> 00:16:45,020
>> 127, 131, e io non volevo essere presente
complesso, ma perché ho cambiato il

380
00:16:45,020 --> 00:16:46,340
numeri lì?

381
00:16:46,340 --> 00:16:48,360
Perché voglio che gli INT a
effettivamente essere quattro byte.

382
00:16:48,360 --> 00:16:49,810
Quindi cerchiamo di essere super anale su questo.

383
00:16:49,810 --> 00:16:53,800
In modo che se uno sembra essere affrontati
123, il 2 sta per essere all 'indirizzo

384
00:16:53,800 --> 00:16:55,730
127 perché è a soli 4 addii di distanza.

385
00:16:55,730 --> 00:16:56,210
Questo è tutto.

386
00:16:56,210 --> 00:16:58,640
E ci dimentichiamo di tutto il
altri indirizzi del mondo.

387
00:16:58,640 --> 00:17:03,320
>> Quindi x è in posizione 123,
y è in posizione 127.

388
00:17:03,320 --> 00:17:05,770
E adesso, che cosa faccio io in realtà
vogliono fare?

389
00:17:05,770 --> 00:17:10,099
Quando chiamo di swap ora, ciò che è
realmente succedendo?

390
00:17:10,099 --> 00:17:14,920
Beh, quando chiamo swap, sto passando in
l'indirizzo di x e l'indirizzo di y.

391
00:17:14,920 --> 00:17:18,540
Così, per esempio, se questi due pezzi
di carta ormai rappresentano i due

392
00:17:18,540 --> 00:17:23,510
argomenti a e b di swap, che cosa sono io
andando a scrivere il primo di questi,

393
00:17:23,510 --> 00:17:27,720
che ho intenzione di chiamare fare riferimento a come?

394
00:17:27,720 --> 00:17:30,610
>> Esattamente, 123.

395
00:17:30,610 --> 00:17:31,905
Quindi questo io sostengo è un.

396
00:17:31,905 --> 00:17:32,955
Questo è il parametro a.

397
00:17:32,955 --> 00:17:35,856
Sto mettendo l'indirizzo di x in là.

398
00:17:35,856 --> 00:17:38,152
>> Che cos'è?

399
00:17:38,152 --> 00:17:40,890
>> Che cos'è?

400
00:17:40,890 --> 00:17:41,190
>> No, no.

401
00:17:41,190 --> 00:17:41,720
Questo è OK.

402
00:17:41,720 --> 00:17:42,570
Ancora buona, ancora buono.

403
00:17:42,570 --> 00:17:43,530
Quindi questo è un.

404
00:17:43,530 --> 00:17:46,240
E ora sul secondo pezzo di carta,
questo sta per essere B, e che cosa sono io

405
00:17:46,240 --> 00:17:49,010
intenzione di scrivere su
questo pezzo di carta?

406
00:17:49,010 --> 00:17:50,080
127.

407
00:17:50,080 --> 00:17:53,720
>> Quindi l'unica cosa che è cambiata da allora
nostro precedente racconto di questa storia è,

408
00:17:53,720 --> 00:17:58,590
piuttosto che letteralmente 1 e 2, sono
andando a passare in 123 e 127.

409
00:17:58,590 --> 00:18:02,130
E ora sto andando a mettere questi all'interno
di questa scatola, va bene?

410
00:18:02,130 --> 00:18:04,640
In modo che la scatola nera rappresenta oggi
la funzione di swap.

411
00:18:04,640 --> 00:18:07,230
>> Nel frattempo, diamo ora hanno qualcuno
implementare la funzione swap.

412
00:18:07,230 --> 00:18:09,090
Qualcuno qui
come volontario?

413
00:18:09,090 --> 00:18:09,560
Andiamo su.

414
00:18:09,560 --> 00:18:11,080
Qual è il tuo nome?

415
00:18:11,080 --> 00:18:11,460
Charlie.

416
00:18:11,460 --> 00:18:12,080
Va bene, Charlie.

417
00:18:12,080 --> 00:18:14,810
Andiamo su.

418
00:18:14,810 --> 00:18:17,310
>> Così Charlie sta per giocare
il ruolo della nostra scatola nera.

419
00:18:17,310 --> 00:18:21,460
E Charlie, quello che mi piacerebbe che tu faccia
Ora è implementare scambio in modo tale

420
00:18:21,460 --> 00:18:25,320
che, date queste due indirizzi,
che sono stati effettivamente andando

421
00:18:25,320 --> 00:18:26,330
per modificare i valori.

422
00:18:26,330 --> 00:18:28,290
E ti sussurro all'orecchio
come far funzionare la TV qui.

423
00:18:28,290 --> 00:18:29,930
>> Quindi, andare avanti, e tu sei la scatola nera.

424
00:18:29,930 --> 00:18:30,920
Raggiungere in là.

425
00:18:30,920 --> 00:18:34,054
Quali valori vede per una, e
quali valori si vede per la b?

426
00:18:34,054 --> 00:18:36,740
>> CHARLIE: a è 123 e B è 127.

427
00:18:36,740 --> 00:18:37,530
>> DAVID MALAN: OK, esattamente.

428
00:18:37,530 --> 00:18:38,940
Ora, mettere in pausa lì solo per un momento.

429
00:18:38,940 --> 00:18:41,680
La prima cosa che hai intenzione di fare ora,
secondo il codice - che

430
00:18:41,680 --> 00:18:43,220
Io ora tiro su sullo schermo -

431
00:18:43,220 --> 00:18:46,750
sta per essere di destinare un po '
po 'di memoria chiamato temperatura.

432
00:18:46,750 --> 00:18:48,850
Quindi ho intenzione di andare avanti e
dare che la memoria.

433
00:18:48,850 --> 00:18:52,210
>> Quindi questo sta andando essere una terza variabile
che si deve accessibile a

434
00:18:52,210 --> 00:18:54,080
hai chiamato temperatura.

435
00:18:54,080 --> 00:18:57,120
E che cosa hai intenzione di scrivere
sul pezzo temperatura di carta?

436
00:18:57,120 --> 00:19:02,524

437
00:19:02,524 --> 00:19:03,470
>> CHARLIE: Puntatori, giusto?

438
00:19:03,470 --> 00:19:04,790
>> DAVID MALAN: OK, bene non
necessariamente puntatori.

439
00:19:04,790 --> 00:19:07,230
Così la linea di codice che ho
evidenziata sul lato destro,

440
00:19:07,230 --> 00:19:07,900
cerchiamo di cominciare da lì.

441
00:19:07,900 --> 00:19:08,890
Si dice che una stella.

442
00:19:08,890 --> 00:19:11,670
Quindi una sta attualmente memorizzando
il numero 123.

443
00:19:11,670 --> 00:19:16,660
E proprio intuitivamente, ciò
ha stella 123 significa?

444
00:19:16,660 --> 00:19:21,630
>> Ma specificamente, se a è
123, una stella significa che cosa?

445
00:19:21,630 --> 00:19:22,560
Il valore di a.

446
00:19:22,560 --> 00:19:24,580
O più casualmente, andare lì.

447
00:19:24,580 --> 00:19:28,620
Quindi lasciatemi propongo, tenendo il a in
la tua mano, andare avanti e trattare che

448
00:19:28,620 --> 00:19:29,430
come se fosse una mappa.

449
00:19:29,430 --> 00:19:32,940
E camminare da soli verso il computer di
memoria, e noi trovare ciò che è

450
00:19:32,940 --> 00:19:36,520
a posizione 123.

451
00:19:36,520 --> 00:19:37,720
Esattamente.

452
00:19:37,720 --> 00:19:41,100
>> Così vediamo in posizione 123
è ciò che, ovviamente?

453
00:19:41,100 --> 00:19:44,240
OK, in modo che valore ora sei tu
andando a mettere in temperatura?

454
00:19:44,240 --> 00:19:44,750
Esattamente.

455
00:19:44,750 --> 00:19:45,600
Quindi, andare avanti e farlo.

456
00:19:45,600 --> 00:19:51,280
E scrivere il numero 1 sul pezzo di
carta che è attualmente intitolato temperatura.

457
00:19:51,280 --> 00:19:53,540
>> E ora il passo successivo che
si sta andando ad implementare

458
00:19:53,540 --> 00:19:54,310
sta per essere quello.

459
00:19:54,310 --> 00:19:57,820
Ebbene, sul lato destro della
successiva riga di codice è stella b. b, del

460
00:19:57,820 --> 00:19:59,260
Naturalmente, memorizza un indirizzo.

461
00:19:59,260 --> 00:20:02,270
Che gli indirizzi 127.

462
00:20:02,270 --> 00:20:06,620
Stella b significa quello che, casualmente parlando?

463
00:20:06,620 --> 00:20:08,700
>> Vai a quella posizione.

464
00:20:08,700 --> 00:20:14,988
Quindi, andare avanti e noi trovare ciò che è
a posizione 127.

465
00:20:14,988 --> 00:20:15,480
OK.

466
00:20:15,480 --> 00:20:19,170
Naturalmente, in posizione 127,
è ancora il valore 2.

467
00:20:19,170 --> 00:20:24,060
Allora, cosa stai andando adesso conservare a
tutto ciò è la posizione in un?

468
00:20:24,060 --> 00:20:26,860
Così stella un mezzo vanno alla posizione una.

469
00:20:26,860 --> 00:20:29,770
Qual è la posizione di un?

470
00:20:29,770 --> 00:20:30,430
>> Esattamente.

471
00:20:30,430 --> 00:20:34,190
Così ora, se si desidera modificare
ciò che è in quella posizione -

472
00:20:34,190 --> 00:20:36,470
Io vado avanti e corro
la gomma è qui.

473
00:20:36,470 --> 00:20:37,760
E ora rimetterlo sulla spazzola.

474
00:20:37,760 --> 00:20:42,190
Che numero hai intenzione di scrivere
in quella scatola vuota adesso?

475
00:20:42,190 --> 00:20:42,850
>> Esattamente.

476
00:20:42,850 --> 00:20:46,470
Quindi, questa riga di codice, per essere chiari - lascia
Mi soffermo cosa Charlie sta facendo e

477
00:20:46,470 --> 00:20:51,730
sottolineare qui, quello che ha appena fatto è
scrivere in quella casella alla posizione 123

478
00:20:51,730 --> 00:20:55,150
il valore che era precedentemente in b.

479
00:20:55,150 --> 00:20:59,140
E così ora abbiamo implementato infatti
questa seconda linea di codice.

480
00:20:59,140 --> 00:21:01,920
>> Ora, purtroppo, non c'è
ancora una riga rimanente.

481
00:21:01,920 --> 00:21:04,900
Ora, ciò che è in temperatura, letteralmente?

482
00:21:04,900 --> 00:21:06,200
E 'ovviamente il numero uno.

483
00:21:06,200 --> 00:21:07,020
Questo non è un indirizzo.

484
00:21:07,020 --> 00:21:09,380
E 'solo un numero, una sorta di
una variabile da una settimana.

485
00:21:09,380 --> 00:21:13,520
>> E ora quando si dice stella b, che significa
andare all'indirizzo B, che è di

486
00:21:13,520 --> 00:21:15,090
Naturalmente qui.

487
00:21:15,090 --> 00:21:16,020
Quindi, una volta arrivati ​​lì -

488
00:21:16,020 --> 00:21:18,320
Io vado avanti e cancellare quello che in realtà è
lì - e che cosa sei

489
00:21:18,320 --> 00:21:20,820
intenzione di scrivere ora a posizione 127?

490
00:21:20,820 --> 00:21:22,010
>> CHARLIE: Temp, che è uno.

491
00:21:22,010 --> 00:21:23,430
>> DAVID MALAN: Temp, che è uno.

492
00:21:23,430 --> 00:21:25,670
E cosa succede alla temperatura, alla fine?

493
00:21:25,670 --> 00:21:26,600
Beh, in realtà non lo sappiamo.

494
00:21:26,600 --> 00:21:27,420
Noi in realtà non importa.

495
00:21:27,420 --> 00:21:31,090
Ogni volta che abbiamo implementato una funzione
Finora, tutte le variabili locali che hanno

496
00:21:31,090 --> 00:21:31,890
sono davvero locale.

497
00:21:31,890 --> 00:21:33,060
E hanno appena scompaiono.

498
00:21:33,060 --> 00:21:35,040
Sono recuperati dalla operativo
sistema alla fine.

499
00:21:35,040 --> 00:21:39,800
>> Quindi il fatto che ha ancora la temperatura
valore 1 è una sorta di fondamentalmente

500
00:21:39,800 --> 00:21:41,150
poco interessante per noi.

501
00:21:41,150 --> 00:21:43,100
Va bene, quindi un applauso
se potessimo per Charlie.

502
00:21:43,100 --> 00:21:46,400
Molto ben fatto.

503
00:21:46,400 --> 00:21:51,520
>> Va bene, allora cosa fa più
questo significa che possiamo fare?

504
00:21:51,520 --> 00:21:54,400
Così si scopre che siamo stati
raccontare qualche bugia bianca

505
00:21:54,400 --> 00:21:55,540
per un bel po 'di tempo.

506
00:21:55,540 --> 00:21:59,990
In effetti, si scopre che una stringa,
tutto questo tempo, non è un vero

507
00:21:59,990 --> 00:22:02,190
sequenza di caratteri per sé.

508
00:22:02,190 --> 00:22:03,980
E 'sorta di è che intuitivamente.

509
00:22:03,980 --> 00:22:08,270
>> Ma tecnicamente parlando, è una stringa
tipo di dati che abbiamo dichiarato all'interno di

510
00:22:08,270 --> 00:22:12,170
la libreria CS50 di semplificare il mondo
per le prime settimane di lezione.

511
00:22:12,170 --> 00:22:20,130
Che una stringa è veramente è l'indirizzo
di un personaggio qualche parte in RAM.

512
00:22:20,130 --> 00:22:25,530
Una stringa è in realtà un numero, come 123
o 127, che succede a delimitare

513
00:22:25,530 --> 00:22:28,420
in cui una stringa inizia in
memoria del computer.

514
00:22:28,420 --> 00:22:31,870
>> Ma non rappresenta il
stringa di per sé stessa.

515
00:22:31,870 --> 00:22:33,460
E possiamo vedere questo come segue.

516
00:22:33,460 --> 00:22:35,980
Lasciami andare avanti e di aprire
del codice che è tra

517
00:22:35,980 --> 00:22:38,340
esempi di codice sorgente di oggi.

518
00:22:38,340 --> 00:22:42,225
E ho intenzione di andare avanti e di aprire
fino, diciamo, confrontare-0.C.

519
00:22:42,225 --> 00:22:44,830

520
00:22:44,830 --> 00:22:48,790
Questo è un programma bacato che sta andando
essere attuato come segue.

521
00:22:48,790 --> 00:22:49,040
>> Primo.

522
00:22:49,040 --> 00:22:50,420
Sto per dire qualcosa.

523
00:22:50,420 --> 00:22:52,660
Poi ho intenzione di andare avanti e
ottenere una stringa dall'utente

524
00:22:52,660 --> 00:22:53,750
in quella riga successiva.

525
00:22:53,750 --> 00:22:55,370
Poi ho intenzione di dire di nuovo.

526
00:22:55,370 --> 00:22:57,540
Poi ho intenzione di ottenere un altro
stringa dall'utente.

527
00:22:57,540 --> 00:23:00,390
>> E notate, sto mostrando uno dei
stringhe in una variabile chiamata s, e

528
00:23:00,390 --> 00:23:03,040
un'altra di queste stringhe
in una variabile chiamata t.

529
00:23:03,040 --> 00:23:07,480
E ora ho intenzione di rivendicare, molto
ragionevolmente, che se s è uguale uguale t,

530
00:23:07,480 --> 00:23:08,940
le stringhe sono uguali.

531
00:23:08,940 --> 00:23:09,970
Si digita la stessa cosa.

532
00:23:09,970 --> 00:23:11,830
Altrimenti, le stringhe sono
non è la stessa cosa.

533
00:23:11,830 --> 00:23:15,440
>> Dopo tutto, se abbiamo ingresso due interi, due
caratteri, due galleggianti, due doppie, tutte di

534
00:23:15,440 --> 00:23:18,400
i tipi di dati di cui abbiamo parlato
finora per confrontarli -

535
00:23:18,400 --> 00:23:22,070
Richiamo abbiamo fatto molto chiaro qualche tempo fa
che non si fa questo, perché un

536
00:23:22,070 --> 00:23:25,840
unico segno di uguale è naturalmente
l'operatore di assegnazione.

537
00:23:25,840 --> 00:23:26,820
In modo che sarebbe un bug.

538
00:23:26,820 --> 00:23:29,260
>> Usiamo il segno di uguale uguale,
che si confronta infatti

539
00:23:29,260 --> 00:23:31,050
cose per una vera uguaglianza.

540
00:23:31,050 --> 00:23:32,275
Ma io rivendico questo è bacato.

541
00:23:32,275 --> 00:23:37,400
Se vado avanti e fare confrontare a zero,
e poi fare dot barra confrontare zero.

542
00:23:37,400 --> 00:23:39,700
E scrivo a, diciamo, ciao.

543
00:23:39,700 --> 00:23:41,590
E poi diciamo ciao di nuovo.

544
00:23:41,590 --> 00:23:46,040
Letteralmente la stessa cosa, il computer
RECLAMI ho digitato cose diverse.

545
00:23:46,040 --> 00:23:47,640
>> Ora forse ho solo scritto male qualcosa.

546
00:23:47,640 --> 00:23:49,910
Io digito il mio nome questa volta.

547
00:23:49,910 --> 00:23:52,580
Voglio dire, ciao.

548
00:23:52,580 --> 00:23:54,770
Ciao.

549
00:23:54,770 --> 00:23:57,360
E 'diverso ogni volta.

550
00:23:57,360 --> 00:23:58,430
>> Beh, perché?

551
00:23:58,430 --> 00:24:00,140
Che cosa sta realmente accadendo
sotto il cofano?

552
00:24:00,140 --> 00:24:03,270
Ebbene, che cosa sta realmente accadendo sotto
il cofano è la stringa allora

553
00:24:03,270 --> 00:24:07,410
Ho digitato in quella prima volta, ad esempio,
è la parola ciao, naturalmente.

554
00:24:07,410 --> 00:24:11,660
Ma se noi rappresentiamo questo sotto
il cofano, si ricordi che un

555
00:24:11,660 --> 00:24:13,470
stringa è in un array.

556
00:24:13,470 --> 00:24:15,040
E abbiamo detto tanto in passato.

557
00:24:15,040 --> 00:24:20,200
>> Quindi, se io traggo tale array come questo, io sono
andando a rappresentare qualcosa di molto

558
00:24:20,200 --> 00:24:23,030
simile a quello che abbiamo fatto poco fa.

559
00:24:23,030 --> 00:24:25,390
E c'è in realtà qualcosa
speciale qui, anche.

560
00:24:25,390 --> 00:24:28,090
Cosa abbiamo determiniamo era al
Alla fine di ogni stringa?

561
00:24:28,090 --> 00:24:30,760
Sì, questo backslash zero, che è
solo il modo di rappresentare,

562
00:24:30,760 --> 00:24:33,610
letteralmente, 00000000.

563
00:24:33,610 --> 00:24:35,680
Otto bit 0 di fila.

564
00:24:35,680 --> 00:24:37,610
>> Non lo so, francamente,
cosa c'è dopo questo.

565
00:24:37,610 --> 00:24:40,090
Questo è solo un mucchio di più RAM
all'interno del mio computer.

566
00:24:40,090 --> 00:24:40,970
Ma questo è un array.

567
00:24:40,970 --> 00:24:42,260
Abbiamo parlato di array prima.

568
00:24:42,260 --> 00:24:45,010
E noi di solito parla di array
come posizione di zero,

569
00:24:45,010 --> 00:24:46,580
poi uno, poi due.

570
00:24:46,580 --> 00:24:47,950
Ma questo è solo per convenienza.

571
00:24:47,950 --> 00:24:49,380
E questo è del tutto relativa.

572
00:24:49,380 --> 00:24:53,010
>> Quando si sta effettivamente ricevendo memoria da
il computer, è, naturalmente, qualsiasi

573
00:24:53,010 --> 00:24:55,450
2 miliardi di alcuni byte dispari, potenzialmente.

574
00:24:55,450 --> 00:24:59,100
Così realmente sotto la cappa,
tutto questo tempo, sì.

575
00:24:59,100 --> 00:25:01,670
Questo potrebbe benissimo essere staffa zero.

576
00:25:01,670 --> 00:25:04,780
Ma se si scava ancora più a fondo sotto
il cofano, che è davvero

577
00:25:04,780 --> 00:25:07,000
affrontare il numero 123.

578
00:25:07,000 --> 00:25:09,150
Questo è l'indirizzo 124.

579
00:25:09,150 --> 00:25:11,040
Questo è l'indirizzo 125.

580
00:25:11,040 --> 00:25:12,540
>> E io non rovinare questo momento.

581
00:25:12,540 --> 00:25:15,840
Questi sono ora uno byte
a parte per quale motivo?

582
00:25:15,840 --> 00:25:17,930
Quanto grande è un char?

583
00:25:17,930 --> 00:25:19,170
Un char è solo un byte.

584
00:25:19,170 --> 00:25:20,570
Un int è tipicamente quattro byte.

585
00:25:20,570 --> 00:25:24,850
Quindi è per questo che ho fatto 123,
127, 131 e così via.

586
00:25:24,850 --> 00:25:27,560
Ora posso tenere la matematica semplice
e fare solo più 1.

587
00:25:27,560 --> 00:25:30,510
E questo è ora che cosa sta realmente accadendo
sul sotto la cappa.

588
00:25:30,510 --> 00:25:37,760
>> Quindi, quando si dichiara qualcosa come questo,
stringa s, questo è in realtà -

589
00:25:37,760 --> 00:25:39,170
si scopre -

590
00:25:39,170 --> 00:25:41,190
stella char.

591
00:25:41,190 --> 00:25:44,640
Stella, naturalmente, significa
indirizzo, puntatore aka.

592
00:25:44,640 --> 00:25:46,200
Quindi è l'indirizzo di qualcosa.

593
00:25:46,200 --> 00:25:47,510
Che cosa è l'indirizzo di?

594
00:25:47,510 --> 00:25:47,760
>> Bene -

595
00:25:47,760 --> 00:25:51,680
Sono l'unico che può vedere il molto
punto importante che sto facendo, o pensare

596
00:25:51,680 --> 00:25:52,560
Sto facendo.

597
00:25:52,560 --> 00:25:55,270
Così stringa -

598
00:25:55,270 --> 00:25:57,180
la cosa triste è che ho un monitor
proprio lì dove ho

599
00:25:57,180 --> 00:25:58,100
potrebbe aver visto questo.

600
00:25:58,100 --> 00:26:00,990
>> Va bene, quindi stringa s è ciò che
Ho dichiarato in precedenza.

601
00:26:00,990 --> 00:26:04,600
Ma si scopre, grazie a un po 'di
magia in biblioteca CS50, tutto questo

602
00:26:04,600 --> 00:26:08,780
stringa di tempo ha letteralmente
stato stella char.

603
00:26:08,780 --> 00:26:11,310
La stella indica di nuovo
puntatore o indirizzo.

604
00:26:11,310 --> 00:26:14,180
Il fatto che è fiancheggiante l'
carattere di parola significa che è il

605
00:26:14,180 --> 00:26:15,970
indirizzo di un carattere.

606
00:26:15,970 --> 00:26:23,100
>> Quindi, se ti stringa è chiamato, e digito
in H-E-L-L-O, proporre ora quello che è ottenere

607
00:26:23,100 --> 00:26:27,330
stringa letteralmente state tornando tutti
questa volta, anche se abbiamo piuttosto

608
00:26:27,330 --> 00:26:29,980
semplicistica del mondo?

609
00:26:29,980 --> 00:26:33,310
Che cosa significa avere stringa effettivamente
restituire come valore di ritorno?

610
00:26:33,310 --> 00:26:35,830

611
00:26:35,830 --> 00:26:38,720
>> 123 in questo caso, per esempio.

612
00:26:38,720 --> 00:26:42,630
Abbiamo detto in precedenza che ottenere stringa
restituisce semplicemente una stringa, una sequenza di

613
00:26:42,630 --> 00:26:43,300
personaggi.

614
00:26:43,300 --> 00:26:44,790
Ma questo è un po 'una bugia.

615
00:26:44,790 --> 00:26:48,010
Il modo in cui ottenere stringa funziona davvero
sotto il cofano si ottiene un

616
00:26:48,010 --> 00:26:48,930
stringa dall'utente.

617
00:26:48,930 --> 00:26:51,530
E plops i caratteri che
lui o lei i tipi di memoria.

618
00:26:51,530 --> 00:26:54,680
Si mette uno zero backslash alla fine
Di quelli sequenza di caratteri.

619
00:26:54,680 --> 00:26:57,310
>> Ma allora che cosa significa ottenere stringa
letteralmente tornare?

620
00:26:57,310 --> 00:27:02,710
Si letteralmente restituisce l'indirizzo del
primi byte nella RAM che

621
00:27:02,710 --> 00:27:04,130
ha usato per quella forza.

622
00:27:04,130 --> 00:27:07,500
E si scopre che solo con il ritorno
un singolo indirizzo della

623
00:27:07,500 --> 00:27:12,120
primo carattere della stringa, che è
sufficiente per stabilire la totalità di

624
00:27:12,120 --> 00:27:12,630
la stringa.

625
00:27:12,630 --> 00:27:16,930
>> In altre parole, ottenere stringa non ha
per tornare 123 e 124 e 125.

626
00:27:16,930 --> 00:27:19,950
Non deve darmi una lunga
elenco di tutti i byte che

627
00:27:19,950 --> 00:27:20,740
la mia stringa sta usando.

628
00:27:20,740 --> 00:27:22,670
Perché uno, sono tutti back to back.

629
00:27:22,670 --> 00:27:28,160
E due, sulla base del primo indirizzo, ho
può capire dove finisce la stringa.

630
00:27:28,160 --> 00:27:29,910
Come?

631
00:27:29,910 --> 00:27:33,490
>> Lo speciale carattere null, il
backslash zero al termine.

632
00:27:33,490 --> 00:27:35,430
Quindi, in altre parole, se
si passa in giro -

633
00:27:35,430 --> 00:27:36,530
all'interno di variabili -

634
00:27:36,530 --> 00:27:41,300
l'indirizzo di un char, e si assume
che al termine di qualsiasi stringa, qualsiasi

635
00:27:41,300 --> 00:27:45,040
sequenza di caratteri come noi esseri umani
pensare di stringhe, se si assume che

636
00:27:45,040 --> 00:27:48,600
al termine di tale stringa c'è
uno zero backslash, sei d'oro.

637
00:27:48,600 --> 00:27:52,430
Perché si può sempre trovare
la fine di una stringa.

638
00:27:52,430 --> 00:27:54,870
>> Ora che cosa sta realmente andando poi
in questo programma?

639
00:27:54,870 --> 00:27:59,990
Perché è questo programma,
confronto-0.C, buggy?

640
00:27:59,990 --> 00:28:01,690
Ciò che è in realtà a confronto?

641
00:28:01,690 --> 00:28:02,420
Sì?

642
00:28:02,420 --> 00:28:05,000
>> STUDENTE: [incomprensibile].

643
00:28:05,000 --> 00:28:05,730
>> DAVID MALAN: Esattamente.

644
00:28:05,730 --> 00:28:08,350
Si confrontano le posizioni
delle corde.

645
00:28:08,350 --> 00:28:12,420
Quindi, se l'utente ha digitato ciao una volta,
come ho fatto io, la memoria potrebbe finire

646
00:28:12,420 --> 00:28:13,430
cercando in questo modo.

647
00:28:13,430 --> 00:28:18,210
Se poi l'utente digita in Ciao di nuovo,
ma chiamando ottenere nuovamente stringa, c è

648
00:28:18,210 --> 00:28:21,800
non particolarmente intelligente se non si insegna
che sia furbo da scrivere codice.

649
00:28:21,800 --> 00:28:22,430
>> C -

650
00:28:22,430 --> 00:28:23,860
e computer più in generale -

651
00:28:23,860 --> 00:28:27,370
se si digita la parola ciao di nuovo,
si sa cosa si vuole ottenere.

652
00:28:27,370 --> 00:28:31,480
Stai solo andando a prendere un secondo array
di memoria che, sì, succede essere

653
00:28:31,480 --> 00:28:35,510
memorizzare H-E-L-L-O e così via.

654
00:28:35,510 --> 00:28:38,240
>> Sta andando a guardare la stessa per
noi esseri umani, ma questo indirizzo

655
00:28:38,240 --> 00:28:39,460
potrebbe non essere 123.

656
00:28:39,460 --> 00:28:42,470
Potrebbe così accadere che la
sistema operativo dispone di alcuni di

657
00:28:42,470 --> 00:28:45,430
spazio, ad esempio, a posizione -

658
00:28:45,430 --> 00:28:49,820
diciamo qualcosa di arbitrario,
come questa è la posizione 200.

659
00:28:49,820 --> 00:28:51,620
E questa è la posizione 201.

660
00:28:51,620 --> 00:28:53,060
E questa è la posizione 202.

661
00:28:53,060 --> 00:28:55,730
Non abbiamo idea di dove questo è
andando ad essere in memoria.

662
00:28:55,730 --> 00:28:59,110
>> Ma che cosa questo significa è che ciò che è
sta per essere immagazzinata in ultima analisi, in s?

663
00:28:59,110 --> 00:29:00,750
Il numero 123.

664
00:29:00,750 --> 00:29:04,860
Che cosa sta per essere conservati in t,
in questo esempio arbitrario?

665
00:29:04,860 --> 00:29:06,300
Il numero 200.

666
00:29:06,300 --> 00:29:11,410
E tutto questo significa che poi è ovviamente,
123 non è uguale a 200.

667
00:29:11,410 --> 00:29:14,940
E così questa condizione se mai
restituisce true.

668
00:29:14,940 --> 00:29:18,430
Perché stringa get utilizza diversi
blocchi di memoria ogni volta.

669
00:29:18,430 --> 00:29:20,360
>> Ora siamo in grado di vedere questo nuovo
In un altro esempio.

670
00:29:20,360 --> 00:29:23,764
Lasciami andare avanti e di aprire copia-0.C.

671
00:29:23,764 --> 00:29:28,770
Io sostengo che questo esempio sta per
provare - ma non riescono - di copiare due stringhe

672
00:29:28,770 --> 00:29:29,910
come segue.

673
00:29:29,910 --> 00:29:31,730
>> Sto per dire qualcosa
per l'utente.

674
00:29:31,730 --> 00:29:34,490
Ho poi intenzione di ottenere un
stringa e chiamare s.

675
00:29:34,490 --> 00:29:36,400
E ora, sto facendo questo controllo qui.

676
00:29:36,400 --> 00:29:37,990
Lo abbiamo detto un po 'indietro.

677
00:29:37,990 --> 00:29:42,490
Ma quando potrebbe ottenere stringa di ritorno null,
un altro carattere speciale, o speciali

678
00:29:42,490 --> 00:29:45,050
simbolo diciamo.

679
00:29:45,050 --> 00:29:45,900
Se è la memoria.

680
00:29:45,900 --> 00:29:48,970
>> Ad esempio, se l'utente è veramente
essere difficile e tipi un atroce

681
00:29:48,970 --> 00:29:51,220
numero di caratteri al
tastiera e colpi Invio.

682
00:29:51,220 --> 00:29:54,580
Se il numero di caratteri proprio non posso
contenuta in RAM per qualsiasi pazzo

683
00:29:54,580 --> 00:29:57,820
ragione, anche ottenere stringa potrebbe
molto bene restituire null.

684
00:29:57,820 --> 00:30:01,080
>> Oppure, se il programma si sta facendo molto
di altre cose e non c'è proprio

685
00:30:01,080 --> 00:30:03,790
non sufficiente memoria per la stringa get
per avere successo, potrebbe finire

686
00:30:03,790 --> 00:30:05,240
fino restituendo null.

687
00:30:05,240 --> 00:30:07,160
Ma cerchiamo di essere più precisi
su ciò che questo è.

688
00:30:07,160 --> 00:30:10,280
Qual è il tipo di dati di s davvero?

689
00:30:10,280 --> 00:30:11,610
Char stella.

690
00:30:11,610 --> 00:30:14,560
>> Così si scopre ora possiamo buccia
lo strato di null.

691
00:30:14,560 --> 00:30:17,500
Risulta, nulla è - sì, ovviamente
un simbolo speciale.

692
00:30:17,500 --> 00:30:19,190
Ma di cosa si tratta veramente?

693
00:30:19,190 --> 00:30:25,220
In realtà, nulla è solo un simbolo che
gli esseri umani usano per rappresentare lo zero pure.

694
00:30:25,220 --> 00:30:29,010
>> Così gli autori di C e computer
più in generale, ha deciso anni fa

695
00:30:29,010 --> 00:30:30,010
che, si sa che cosa.

696
00:30:30,010 --> 00:30:34,850
Perché non possiamo garantire che nessun utente
dati è mai, mai, mai

697
00:30:34,850 --> 00:30:36,730
conservato a bye a zero?

698
00:30:36,730 --> 00:30:39,610
Infatti, anche nel mio esempio arbitrario
prima, non ho cominciato la numerazione

699
00:30:39,610 --> 00:30:40,390
byte a zero.

700
00:30:40,390 --> 00:30:41,540
Ho cominciato a uno.

701
00:30:41,540 --> 00:30:44,950
Perché sapevo che le persone in tutto il mondo
hanno deciso di riservare lo zero

702
00:30:44,950 --> 00:30:47,970
byte nella RAM di nessuno come
qualcosa di speciale.

703
00:30:47,970 --> 00:30:52,020
>> La ragione è che, in qualsiasi momento si desidera
segnale che qualcosa è andato storto

704
00:30:52,020 --> 00:30:55,960
per quanto riguarda gli indirizzi, è tornato
null - altrimenti noto come zero -

705
00:30:55,960 --> 00:30:59,410
e perché sai che non c'è
legit dati all'indirizzo zero chiaramente

706
00:30:59,410 --> 00:31:00,400
che significa un errore.

707
00:31:00,400 --> 00:31:04,080
Ed è per questo che, per convenzione, controlliamo
per nulla e ritorno qualcosa

708
00:31:04,080 --> 00:31:06,260
come uno in quei casi.

709
00:31:06,260 --> 00:31:09,300
>> Quindi, se noi scorriamo ora, questo è solo
poi un po 'di controllo degli errori, nel caso in cui

710
00:31:09,300 --> 00:31:10,610
qualcosa è andato storto con [? cauzione?]

711
00:31:10,610 --> 00:31:13,470
del tutto e chiudere il programma
restituendo presto.

712
00:31:13,470 --> 00:31:19,030
Questa linea ora potrebbe essere riscritto
come questo, che cosa significa?

713
00:31:19,030 --> 00:31:23,155
Sul lato sinistro, dammi un altro
puntatore a un carattere, e lo chiamano t.

714
00:31:23,155 --> 00:31:26,935
Che cosa sono io la memorizzazione all'interno di t, basata
su questa linea di codice?

715
00:31:26,935 --> 00:31:30,950

716
00:31:30,950 --> 00:31:32,170
>> Sto memorizzare una posizione.

717
00:31:32,170 --> 00:31:34,742
Specificamente la posizione
che era in s.

718
00:31:34,742 --> 00:31:39,000
Quindi, se l'utente ha digitato ciao, e
che accade prima ciao a finire

719
00:31:39,000 --> 00:31:42,567
qui, allora il numero 123 è
sta per tornare da ottenere

720
00:31:42,567 --> 00:31:43,810
stringa e conservati -

721
00:31:43,810 --> 00:31:44,780
come abbiamo detto prima -

722
00:31:44,780 --> 00:31:45,440
in s.

723
00:31:45,440 --> 00:31:50,560
>> Quando io ora dichiaro un altro puntatore a
un char e lo chiamano t, che numero è

724
00:31:50,560 --> 00:31:53,940
letteralmente andando a finire in
t secondo la storia?

725
00:31:53,940 --> 00:31:55,420
Così 123.

726
00:31:55,420 --> 00:32:00,310
>> Quindi tecnicamente ora sia s e
t stanno indicando l'esatta

727
00:32:00,310 --> 00:32:02,410
stessi blocchi di memoria.

728
00:32:02,410 --> 00:32:06,140
Così accorgo che cosa ho intenzione di fare ora per
dimostrare che questo programma è bacato.

729
00:32:06,140 --> 00:32:08,820
>> In primo luogo ho intenzione di rivendicare, con
una stampa f, capitalizzando

730
00:32:08,820 --> 00:32:10,080
la copia della stringa.

731
00:32:10,080 --> 00:32:11,660
Poi ho intenzione di fare un po '
Controllo errori.

732
00:32:11,660 --> 00:32:12,160
Ho intenzione di assicurarsi.

733
00:32:12,160 --> 00:32:16,710
Facciamo in modo che la stringa t è a
almeno maggiore di zero in lunghezza,

734
00:32:16,710 --> 00:32:19,190
quindi c'è un po 'di carattere non
di capitalizzare realmente.

735
00:32:19,190 --> 00:32:22,840
>> E allora si potrebbe ricordare questo
da esempi precedenti.

736
00:32:22,840 --> 00:32:25,630
2 superiori - che è in
il file ctype.h.

737
00:32:25,630 --> 00:32:30,800
T staffa a zero mi dà lo zero
carattere della stringa t.

738
00:32:30,800 --> 00:32:34,360
2 e superiore dello stesso valore, di
Naturalmente, lo converte in maiuscolo.

739
00:32:34,360 --> 00:32:38,230
>> Così intuitivamente, la riga evidenziata
del codice è maiuscola la prima

740
00:32:38,230 --> 00:32:40,250
lettera t.

741
00:32:40,250 --> 00:32:44,485
Ma non è capitalizzando, intuitivamente,
la prima lettera di s.

742
00:32:44,485 --> 00:32:48,130
Ma se stai pensando al futuro, che cosa sono io
per vedere quando eseguo questo programma

743
00:32:48,130 --> 00:32:54,220
e stampare sia l'originale,
s, e la cosiddetta copia, t?

744
00:32:54,220 --> 00:32:55,350
>> Stanno in realtà sta per essere lo stesso.

745
00:32:55,350 --> 00:32:56,600
E perché hanno intenzione di essere la stessa cosa?

746
00:32:56,600 --> 00:32:58,970

747
00:32:58,970 --> 00:33:01,020
Stanno entrambi indicando
esattamente la stessa cosa.

748
00:33:01,020 --> 00:33:01,610
Quindi cerchiamo di fare questo.

749
00:33:01,610 --> 00:33:03,160
>> Fai la copia zero.

750
00:33:03,160 --> 00:33:04,070
Compila OK.

751
00:33:04,070 --> 00:33:06,500
Lasciami correre copia zero.

752
00:33:06,500 --> 00:33:10,110
Permettetemi di digitare qualcosa di simile ciao in
tutto minuscolo quindi premere Invio.

753
00:33:10,110 --> 00:33:16,520
E sostiene che sia la s originale
e la copia sono effettivamente identici.

754
00:33:16,520 --> 00:33:17,920
>> Così che cosa è realmente accaduto qui?

755
00:33:17,920 --> 00:33:20,100
Permettetemi di ridisegnare questa immagine solo
per raccontare la storia in un

756
00:33:20,100 --> 00:33:21,340
modo leggermente diverso.

757
00:33:21,340 --> 00:33:26,060
Che cosa sta realmente accadendo sotto il
cappa quando dichiaro qualcosa come

758
00:33:26,060 --> 00:33:30,410
char inizio s, o una stringa s,
Sto ottenendo un puntatore -

759
00:33:30,410 --> 00:33:33,090
che risulta essere quattro byte
nell'apparecchio CS50

760
00:33:33,090 --> 00:33:34,410
e in molti computer.

761
00:33:34,410 --> 00:33:36,008
E ho intenzione di chiamare questo s.

762
00:33:36,008 --> 00:33:39,810
E questo ha attualmente
qualche valore sconosciuto.

763
00:33:39,810 --> 00:33:43,900
>> Quando si dichiara una variabile, a meno che non
metti un valore lì, che

764
00:33:43,900 --> 00:33:44,570
sa cosa c'è.

765
00:33:44,570 --> 00:33:48,110
Potrebbe essere una sequenza casuale di
bit dal precedente esecuzione.

766
00:33:48,110 --> 00:33:52,490
Così, quando io, nella mia linea di codice faccio arrivare
stringa, e quindi memorizzare il ritorno

767
00:33:52,490 --> 00:33:54,800
valore nella stringa s ottiene in qualche modo -

768
00:33:54,800 --> 00:33:58,520
E faremo eventualmente staccare come arrivare
opere di stringa, in qualche modo alloca un

769
00:33:58,520 --> 00:34:00,480
matrice che sembra probabilmente
un po 'come questo.

770
00:34:00,480 --> 00:34:05,390
H-E-L-L-O, backslash zero.

771
00:34:05,390 --> 00:34:09,510
>> Supponiamo che questo è l'indirizzo
123 appena prima coerenza.

772
00:34:09,510 --> 00:34:13,000
Così ottenere rendimenti di stringa, nel
linea evidenziata lì, restituisce il

773
00:34:13,000 --> 00:34:15,000
numero abbiamo detto, 123.

774
00:34:15,000 --> 00:34:17,420
Così che cosa realmente accade all'interno di s qui?

775
00:34:17,420 --> 00:34:26,590
>> Beh, quello che succede veramente
all'interno di s è 123.

776
00:34:26,590 --> 00:34:29,250
Ma, francamente, mi sto un po '
confuso da tutti questi indirizzi,

777
00:34:29,250 --> 00:34:30,320
tutti questi numeri arbitrari.

778
00:34:30,320 --> 00:34:32,290
123, 124, 127.

779
00:34:32,290 --> 00:34:34,570
Quindi cerchiamo di semplificare effettivamente
il mondo un po '.

780
00:34:34,570 --> 00:34:38,800
>> Quando si parla di puntatori, francamente, a
noi esseri umani, che il diavolo se ne frega dove

781
00:34:38,800 --> 00:34:39,870
le cose sono in memoria?

782
00:34:39,870 --> 00:34:41,080
Questo è del tutto arbitraria.

783
00:34:41,080 --> 00:34:43,370
Sta andando a dipendere da come
di RAM l'utente ha.

784
00:34:43,370 --> 00:34:46,590
Sta andando a dipendere da quando nel corso della giornata
si esegue il programma, forse, e

785
00:34:46,590 --> 00:34:48,250
quello di ingresso l'utente che si dà.

786
00:34:48,250 --> 00:34:50,060
Siamo soffermarsi su dettagli insignificanti.

787
00:34:50,060 --> 00:34:54,230
>> Così astratto andiamo lontano e dire che,
quando si esegue una riga di codice come questo,

788
00:34:54,230 --> 00:34:57,320
char stella s ottiene il ritorno
valore della stringa GET.

789
00:34:57,320 --> 00:35:02,720
Perché non invece solo disegnare quello che abbiamo
continuare ad invocare un puntatore come se fosse

790
00:35:02,720 --> 00:35:04,140
che punta a qualcosa?

791
00:35:04,140 --> 00:35:07,000
Quindi io pretendo ora che s up
vi è un puntatore -

792
00:35:07,000 --> 00:35:08,480
sotto il cofano è un indirizzo.

793
00:35:08,480 --> 00:35:11,330
Ma è solo indicando
il primo byte nel

794
00:35:11,330 --> 00:35:12,780
stringa che è stato restituito.

795
00:35:12,780 --> 00:35:16,710
>> Se ora torno al codice qui,
quello che sta succedendo a questa linea?

796
00:35:16,710 --> 00:35:20,020
Ebbene, in questa riga evidenziata ora,
Sto dichiarando quanto pare un altro

797
00:35:20,020 --> 00:35:21,070
variabile chiamata t.

798
00:35:21,070 --> 00:35:25,700
Ma è anche un puntatore, quindi ho intenzione
a disegnare come, in teoria, l'esatta

799
00:35:25,700 --> 00:35:26,710
stessa scatola dimensioni.

800
00:35:26,710 --> 00:35:28,160
E ho intenzione di chiamarlo t.

801
00:35:28,160 --> 00:35:33,500
>> E ora se torniamo al codice nuovo,
quando devo conservare dentro di s t,

802
00:35:33,500 --> 00:35:36,920
cosa sono tecnicamente
mettendo dentro di t?

803
00:35:36,920 --> 00:35:39,350
Beh tecnicamente, questo
era il numero 123.

804
00:35:39,350 --> 00:35:42,270
Quindi, in realtà dovrei scrivere
il numero 123 lì.

805
00:35:42,270 --> 00:35:43,900
Ma Prendiamolo livello superiore.

806
00:35:43,900 --> 00:35:48,090
t, se è solo un puntatore,
intuitivamente, è proprio questo.

807
00:35:48,090 --> 00:35:49,800
Questo è tutto ciò che viene
archiviati.

808
00:35:49,800 --> 00:35:54,970
>> Così ora nelle ultime righe interessanti
del codice, quando io in realtà vado circa

809
00:35:54,970 --> 00:36:00,680
capitalizzando il carattere zero
in t, che cosa sta succedendo?

810
00:36:00,680 --> 00:36:06,310
Beh, t staffa a zero è ora punta
a quale personaggio, presumibilmente?

811
00:36:06,310 --> 00:36:07,460
>> Si punta a h.

812
00:36:07,460 --> 00:36:08,870
Perché t staffa a zero -

813
00:36:08,870 --> 00:36:12,490
ricordare, questa è la sintassi vecchia. t Staffa
pari a zero significa solo se t è una stringa, t

814
00:36:12,490 --> 00:36:15,590
Staffa a zero significa ottenere lo zero
personaggio in quella forza.

815
00:36:15,590 --> 00:36:18,650
Quindi che cosa significa veramente
è andare a questo array -

816
00:36:18,650 --> 00:36:21,520
e sì, questo potrebbe essere 123,
questo potrebbe essere 124.

817
00:36:21,520 --> 00:36:22,790
Ma è tutto relativo, ricordare.

818
00:36:22,790 --> 00:36:25,640
Ogni volta che si parla di un array, abbiamo
il vantaggio di parlare di

819
00:36:25,640 --> 00:36:27,000
relativi indici.

820
00:36:27,000 --> 00:36:31,120
>> E così ora possiamo solo supporre
che t staffa zero è h.

821
00:36:31,120 --> 00:36:35,090
Quindi se chiamo 2 superiore su di essa, cosa che è
realmente facendo è capitalizzando

822
00:36:35,090 --> 00:36:38,290
la h minuscola a maiuscola H.
Ma, naturalmente, ciò che è s?

823
00:36:38,290 --> 00:36:41,010
Si punta alla stessa stringa maledettamente.

824
00:36:41,010 --> 00:36:44,200
>> Quindi questo è tutto quello che sta succedendo
in questo codice finora.

825
00:36:44,200 --> 00:36:45,960
Allora, qual è allora l'implicazione?

826
00:36:45,960 --> 00:36:48,300
Come possiamo risolvere questi due problemi?

827
00:36:48,300 --> 00:36:50,870
Come ci confrontiamo in stringhe reali?

828
00:36:50,870 --> 00:36:53,720
>> Beh intuitivamente, come sarebbe
si va a confrontare due

829
00:36:53,720 --> 00:36:55,090
stringhe per una vera parità?

830
00:36:55,090 --> 00:36:58,920

831
00:36:58,920 --> 00:37:00,750
>> Che cosa vuol dire se due
stringhe sono uguali?

832
00:37:00,750 --> 00:37:04,330
Chiaramente non è che i loro indirizzi sono
uguale nella memoria, perché questo è un basso

833
00:37:04,330 --> 00:37:06,590
dettaglio implementativo livello.

834
00:37:06,590 --> 00:37:08,360
Tutti i caratteri sono uguali.

835
00:37:08,360 --> 00:37:12,810
Quindi lasciatemi propongo, e mi presento
in versione uno di compare.c

836
00:37:12,810 --> 00:37:14,970
qui, in modo da confrontare-1.c.

837
00:37:14,970 --> 00:37:19,590
>> Lasciatemi Propongo ancora ottenere un
puntatore chiamato s, e conservare in esso il

838
00:37:19,590 --> 00:37:20,610
valore della stringa get tornare.

839
00:37:20,610 --> 00:37:21,750
Facciamo la stessa cosa con t.

840
00:37:21,750 --> 00:37:23,230
Quindi, nessuna parte di codice è diverso.

841
00:37:23,230 --> 00:37:25,420
Ho intenzione di aggiungere un po 'di
controllo degli errori adesso.

842
00:37:25,420 --> 00:37:29,390
Quindi, ora che siamo sorta di peeling indietro
questo layer in CS50 di ciò che una stringa

843
00:37:29,390 --> 00:37:33,520
in realtà, abbiamo bisogno di essere più anale
di fare in modo che non abusino

844
00:37:33,520 --> 00:37:35,330
valori non validi come nullo.

845
00:37:35,330 --> 00:37:36,440
>> Così sto solo andando a controllare.

846
00:37:36,440 --> 00:37:41,490
Se s non è uguale a nulla e T non
pari nullo, il che significa che siamo OK.

847
00:37:41,490 --> 00:37:44,460
Ottieni stringa non rovinare ottenere
una di queste stringhe.

848
00:37:44,460 --> 00:37:51,270
E si può forse intuire adesso, che cosa
Non STR CMP presumibilmente fare?

849
00:37:51,270 --> 00:37:52,000
Confronta stringa.

850
00:37:52,000 --> 00:37:55,470
>> Quindi, se avete in programma java prima,
questo è come il metodo è uguale al

851
00:37:55,470 --> 00:37:56,490
classe string.

852
00:37:56,490 --> 00:37:57,890
Ma per quelli di voi che non ha
programmato prima,

853
00:37:57,890 --> 00:37:59,320
questa è solo una funzione di c.

854
00:37:59,320 --> 00:38:02,180
Succede a venire in una
file chiamato string.h.

855
00:38:02,180 --> 00:38:03,830
Ecco dove è dichiarata.

856
00:38:03,830 --> 00:38:05,110
>> E stringa confronto -

857
00:38:05,110 --> 00:38:07,530
In realtà ho dimenticato il suo utilizzo,
ma non importa.

858
00:38:07,530 --> 00:38:10,470
Ricordiamo che possiamo fare
uomo, mescolare confrontare.

859
00:38:10,470 --> 00:38:12,590
E questo sta per aprire la
Manuale programmatori Linux.

860
00:38:12,590 --> 00:38:14,060
Ed è, francamente, un po 'criptico.

861
00:38:14,060 --> 00:38:15,270
Ma vedo che qui, sì.

862
00:38:15,270 --> 00:38:17,570
Devo includere string.h.

863
00:38:17,570 --> 00:38:20,590
>> E dice qui sotto descrizione, "il
funzione di confronto di stringa confronta

864
00:38:20,590 --> 00:38:24,560
le due stringhe S1 e S2. «E S1
e S2 sono a quanto pare le due

865
00:38:24,560 --> 00:38:26,120
argomenti passati dentro

866
00:38:26,120 --> 00:38:28,650
Non mi ricordo cosa
const è, ma ora di gara -

867
00:38:28,650 --> 00:38:31,480
e si può avere visto questo già quando
hai utilizzato le pagine man se si

868
00:38:31,480 --> 00:38:32,390
avere tutto -

869
00:38:32,390 --> 00:38:36,220
quella stella char è solo sinonimo
con lo spago.

870
00:38:36,220 --> 00:38:40,440
>> Quindi confronta le due stringhe, S1 e
S2, e restituisce un intero minore

871
00:38:40,440 --> 00:38:44,930
o uguale o superiore a zero
se S1 è trovato, rispettivamente, di essere

872
00:38:44,930 --> 00:38:47,450
inferiore, o la partita, o
essere maggiore di S2.

873
00:38:47,450 --> 00:38:51,220
Questo è solo un modo di dire molto complessa
Confronta stringa che restituisce

874
00:38:51,220 --> 00:38:55,760
zero se due stringhe sono intuitivamente
identico, carattere per

875
00:38:55,760 --> 00:38:57,120
carattere per carattere.

876
00:38:57,120 --> 00:38:59,970
>> Esso restituisce un numero negativo se
s, in ordine alfabetico, si suppone

877
00:38:59,970 --> 00:39:01,010
venire prima di t.

878
00:39:01,010 --> 00:39:05,300
O restituisce un numero positivo se
s dovrebbe venire dopo t

879
00:39:05,300 --> 00:39:06,170
ordine alfabetico.

880
00:39:06,170 --> 00:39:08,360
Quindi, con questa semplice funzione, potrebbe
te, per esempio, ordinare un

881
00:39:08,360 --> 00:39:09,770
mucchio di parole?

882
00:39:09,770 --> 00:39:13,984
>> Quindi, in questa nuova versione, io vado
di andare avanti e fare Confronto1.

883
00:39:13,984 --> 00:39:15,750
Dot barra confrontare uno.

884
00:39:15,750 --> 00:39:18,030
Io digito ciao in minuscolo.

885
00:39:18,030 --> 00:39:20,300
Io vado a digitare ciao
di nuovo tutto in minuscolo.

886
00:39:20,300 --> 00:39:23,340
E per fortuna ora realizza
Ho scritto la stessa cosa.

887
00:39:23,340 --> 00:39:27,520
>> Nel frattempo, se digito ciao in basso
caso e CIAO in maiuscolo e

888
00:39:27,520 --> 00:39:29,710
confrontarli, ho digitato
cose diverse.

889
00:39:29,710 --> 00:39:32,530
Perché non solo sono gli indirizzi
diverso, ma ci stiamo confrontando

890
00:39:32,530 --> 00:39:35,350
caratteri ancora e ancora diversi.

891
00:39:35,350 --> 00:39:37,320
>> Bene andiamo a fissare uno
altro problema ora.

892
00:39:37,320 --> 00:39:41,590
Lasciatemi apro versione uno di
copia, che ora affronta

893
00:39:41,590 --> 00:39:42,900
questo problema come segue.

894
00:39:42,900 --> 00:39:45,650
E questo sta andando a guardare
un po 'più complessa.

895
00:39:45,650 --> 00:39:49,320
Ma se si pensa a cosa problema che abbiamo
necessità di risolvere, spero che questo sarà

896
00:39:49,320 --> 00:39:51,870
cancellare in un attimo ora.

897
00:39:51,870 --> 00:39:57,280
>> Quindi questa prima linea, char inizio t, in
parole povere qualcuno potrebbe proporre

898
00:39:57,280 --> 00:39:59,450
cosa questa linea qui significa?

899
00:39:59,450 --> 00:40:01,050
Char stella t, che cosa è che facendo?

900
00:40:01,050 --> 00:40:06,660

901
00:40:06,660 --> 00:40:07,210
>> Buono.

902
00:40:07,210 --> 00:40:09,500
Creare un puntatore per alcuni
posto in memoria.

903
00:40:09,500 --> 00:40:10,930
E mi permetta di perfezionare un po '.

904
00:40:10,930 --> 00:40:17,180
Dichiarare una variabile che memorizzerà il
indirizzo di qualche char in memoria, basta

905
00:40:17,180 --> 00:40:18,480
per essere un po 'più corretta.

906
00:40:18,480 --> 00:40:21,210
>> OK, ora sul lato destro, ho
mai visto una di queste funzioni

907
00:40:21,210 --> 00:40:22,660
prima, malloc.

908
00:40:22,660 --> 00:40:26,980
Ma che cosa potrebbe significare?

909
00:40:26,980 --> 00:40:28,050
Dotazione di memoria.

910
00:40:28,050 --> 00:40:29,410
Allocazione della memoria.

911
00:40:29,410 --> 00:40:33,050
>> Così si scopre, fino ad ora, abbiamo
non hanno davvero avuto un modo potente di

912
00:40:33,050 --> 00:40:36,210
richiedendo al sistema operativo,
dammi un po 'di memoria.

913
00:40:36,210 --> 00:40:39,980
Piuttosto, ora abbiamo una funzione chiamata
malloc che fa esattamente questo.

914
00:40:39,980 --> 00:40:42,960
Anche se questo è un po 'un
distrazione in questo momento, si noti che in

915
00:40:42,960 --> 00:40:46,200
tra le due parentesi risulta
solo andando a essere un numero.

916
00:40:46,200 --> 00:40:48,510
Dove ho digitato in questione
segni possono essere un numero.

917
00:40:48,510 --> 00:40:51,020
>> E quel numero significa,
dammi 10 byte.

918
00:40:51,020 --> 00:40:52,320
Dammi 20 byte.

919
00:40:52,320 --> 00:40:53,820
Dammi 100 byte.

920
00:40:53,820 --> 00:40:56,500
E malloc farà del suo meglio per
chiedere al sistema operativo -

921
00:40:56,500 --> 00:40:57,630
Linux, in questo caso -

922
00:40:57,630 --> 00:40:59,630
hey, sono i loro 100 byte
di RAM disponibile?

923
00:40:59,630 --> 00:41:04,320
Se è così, restituire tali byte a me da
restituendo il cui indirizzo di

924
00:41:04,320 --> 00:41:06,610
quei byte, forse?

925
00:41:06,610 --> 00:41:07,610
Il primo in assoluto.

926
00:41:07,610 --> 00:41:10,460
>> Quindi, anche in questo caso - e questo è predominante
in C, ogni volta che sei

927
00:41:10,460 --> 00:41:11,680
trattare con gli indirizzi?

928
00:41:11,680 --> 00:41:15,830
E 'quasi sempre a che fare con la
primo tale indirizzo, non importa quanto grande

929
00:41:15,830 --> 00:41:19,490
un pezzo di memoria che sono in corso di
restituita, per così dire.

930
00:41:19,490 --> 00:41:20,880
>> Quindi Tuffiamoci qui.

931
00:41:20,880 --> 00:41:23,940
Sto cercando di destinare come
molti byte, esattamente?

932
00:41:23,940 --> 00:41:24,080
Bene.

933
00:41:24,080 --> 00:41:26,090
Lunghezza della stringa di s - ti permette di
fare un esempio concreto.

934
00:41:26,090 --> 00:41:30,700
Se s è ciao, H-E-L-L-O, che cosa è la
lunghezza della stringa di s, ovviamente?

935
00:41:30,700 --> 00:41:32,010
Quindi è cinque.

936
00:41:32,010 --> 00:41:34,590
Ma io sto facendo un più 1 su quello, perché?

937
00:41:34,590 --> 00:41:37,700
Perché voglio sei byte
invece di cinque?

938
00:41:37,700 --> 00:41:38,790
Il carattere null.

939
00:41:38,790 --> 00:41:41,210
>> Io non voglio lasciare fuori questo
speciale carattere null.

940
00:41:41,210 --> 00:41:45,160
Perché se faccio una copia di Ciao e
faccio solo H-E-L-L-O, ma non metto

941
00:41:45,160 --> 00:41:50,160
tale carattere speciale, il computer
potrebbero non avere, per caso, una barra rovesciata

942
00:41:50,160 --> 00:41:51,730
azzerare lì per me.

943
00:41:51,730 --> 00:41:55,570
E così, se sto cercando di capire il
lunghezza della copia, potrei pensare che

944
00:41:55,570 --> 00:41:59,360
è lungo 20 caratteri, o un milione
caratteri se ho mai capita

945
00:41:59,360 --> 00:42:01,050
per colpire uno zero backslash.

946
00:42:01,050 --> 00:42:05,780
>> Quindi abbiamo bisogno di sei byte per memorizzare
H-E-L-L-O, backslash zero.

947
00:42:05,780 --> 00:42:07,870
E poi questo è solo
di essere super anale.

948
00:42:07,870 --> 00:42:10,700
Suppongo che mi dimentico cosa
la dimensione di un char è.

949
00:42:10,700 --> 00:42:12,020
Noi continuiamo a dire si tratta di un byte.

950
00:42:12,020 --> 00:42:12,860
E di solito è.

951
00:42:12,860 --> 00:42:15,425
In teoria, potrebbe essere qualcosa di
diversa, su un altro Mac o un

952
00:42:15,425 --> 00:42:16,250
PC diversi.

953
00:42:16,250 --> 00:42:19,650
>> Così si scopre c'è questo operatore
chiamato sizeof che se si passa il

954
00:42:19,650 --> 00:42:22,680
nome di un tipo di dati - come
char, o int o float -

955
00:42:22,680 --> 00:42:26,930
vi dirà, in modo dinamico, come molti
byte a char occupa in questo

956
00:42:26,930 --> 00:42:28,090
particolare computer.

957
00:42:28,090 --> 00:42:31,360
>> Quindi questo è efficace solo
come volte 1 o dire

958
00:42:31,360 --> 00:42:32,440
volte nulla.

959
00:42:32,440 --> 00:42:36,340
Ma lo faccio solo per essere super-anal,
che nel caso in cui un carattere diverso

960
00:42:36,340 --> 00:42:40,610
sul vostro computer contro la mia, in questo modo
la matematica è sempre andare a controllare.

961
00:42:40,610 --> 00:42:43,720
>> Infine, qui posso controllare per nulla,
che è sempre buona prassi - ancora una volta,

962
00:42:43,720 --> 00:42:44,920
ogni volta che abbiamo a che fare con i puntatori.

963
00:42:44,920 --> 00:42:47,520
Se malloc non è stato in grado di dare
mi sei addii - che è

964
00:42:47,520 --> 00:42:49,210
improbabile, ma nel caso in cui -

965
00:42:49,210 --> 00:42:50,730
restituire immediatamente uno.

966
00:42:50,730 --> 00:42:53,290
Ed ora, andare avanti e copiare
la stringa come segue.

967
00:42:53,290 --> 00:42:57,240
E questa è la sintassi familiare,
anche se in un ruolo diverso.

968
00:42:57,240 --> 00:43:01,210
>> Ho intenzione di andare avanti e ottenere la stringa
lunghezza s e conservarla in n.

969
00:43:01,210 --> 00:43:06,620
Sto andando poi a iterare da i è uguale a
azzerare fino al n,

970
00:43:06,620 --> 00:43:08,410
maggiore di o uguale a.

971
00:43:08,410 --> 00:43:13,540
In modo che ad ogni iterazione, ho messo l'
carattere i-esimo di s nel esimo

972
00:43:13,540 --> 00:43:15,380
carattere di t.

973
00:43:15,380 --> 00:43:18,190
>> Così che cosa sta realmente accadendo sotto
il cofano qui?

974
00:43:18,190 --> 00:43:22,140
Beh, se questo, per esempio, è s -

975
00:43:22,140 --> 00:43:26,400
e ho digitato la parola H-E-L-L-O
e c'è uno zero backslash.

976
00:43:26,400 --> 00:43:29,020
E di nuovo, questo è s puntamento qui.

977
00:43:29,020 --> 00:43:30,830
Ed ecco ora è t.

978
00:43:30,830 --> 00:43:34,860
>> E questo sta puntando ora a
una copia della memoria, giusto?

979
00:43:34,860 --> 00:43:37,340
Malloc mi ha dato un tutto
pezzo di memoria.

980
00:43:37,340 --> 00:43:41,440
Non so che cosa è inizialmente
in uno di questi luoghi.

981
00:43:41,440 --> 00:43:44,340
Quindi ho intenzione di pensare a questi come
un sacco di punti interrogativi.

982
00:43:44,340 --> 00:43:50,190
>> Ma appena comincio looping da zero
in su attraverso la lunghezza s, t

983
00:43:50,190 --> 00:43:52,790
Staffa zero e t staffa 1 -

984
00:43:52,790 --> 00:43:55,080
e metterò questa ora
sulla testa -

985
00:43:55,080 --> 00:44:04,190
t Staffa zero e s staffa media zero
che ho intenzione di essere la copia

986
00:44:04,190 --> 00:44:09,875
iterativamente h in qui, E-L-L-O.
In più, perché ho fatto il più

987
00:44:09,875 --> 00:44:12,370
1, barra rovesciata zero.

988
00:44:12,370 --> 00:44:19,060
>> Così ora nel caso di confronto-1.c,
alla fine, se stampo il

989
00:44:19,060 --> 00:44:24,760
capitalizzazione delle t, dovremmo
vedere che s è invariato.

990
00:44:24,760 --> 00:44:26,090
Lasciami andare avanti ora e faccio questo.

991
00:44:26,090 --> 00:44:28,630
Quindi, fare copy1.

992
00:44:28,630 --> 00:44:30,860
Dot barra copy1.

993
00:44:30,860 --> 00:44:33,670
Io vado a digitare ciao, Enter.

994
00:44:33,670 --> 00:44:37,430
E ora notare, solo la copia
è stato capitalizzato.

995
00:44:37,430 --> 00:44:40,890
Perché io veramente ho due
blocchi di memoria.

996
00:44:40,890 --> 00:44:44,390
>> Purtroppo, si può fare qualche bella
cattivi e piuttosto pericoloso cose qui.

997
00:44:44,390 --> 00:44:49,290
Permettetemi di tirare su un esempio qui ora,
che ci dà un esempio di alcuni

998
00:44:49,290 --> 00:44:51,540
linee diverse.

999
00:44:51,540 --> 00:44:56,040
Quindi, solo intuitivamente qui, la prima linea
di codice, int x stella, sta dichiarando

1000
00:44:56,040 --> 00:44:57,340
una variabile chiamata x.

1001
00:44:57,340 --> 00:44:58,810
E qual è il tipo di dati
di quella variabile?

1002
00:44:58,810 --> 00:45:01,820

1003
00:45:01,820 --> 00:45:04,290
Qual è il tipo di dati di tale variabile?

1004
00:45:04,290 --> 00:45:06,980
Quello non era il colpo di scena.

1005
00:45:06,980 --> 00:45:08,350
>> Il tipo di dati è int stelle.

1006
00:45:08,350 --> 00:45:12,600
Allora, cosa vuol dire? x volontà
memorizzare l'indirizzo di un int.

1007
00:45:12,600 --> 00:45:13,520
Semplice come quello.

1008
00:45:13,520 --> 00:45:16,220
Y sta per memorizzare l'
indirizzo di un int.

1009
00:45:16,220 --> 00:45:18,390
Qual è la terza linea
di codice facendo lì?

1010
00:45:18,390 --> 00:45:21,850
E 'assegnazione quanti
byte, più probabile?

1011
00:45:21,850 --> 00:45:22,350
Quattro.

1012
00:45:22,350 --> 00:45:25,460
A causa delle dimensioni di un int è
generalmente quattro, malloc di quattro dà

1013
00:45:25,460 --> 00:45:29,950
mi restituì l'indirizzo di un pezzo di
memoria, il primo byte di cui è

1014
00:45:29,950 --> 00:45:32,110
memorizzati ora in x.

1015
00:45:32,110 --> 00:45:34,410
>> Ora ci stiamo muovendo un po 'di fretta.

1016
00:45:34,410 --> 00:45:35,760
Stella x significa che cosa?

1017
00:45:35,760 --> 00:45:38,480

1018
00:45:38,480 --> 00:45:42,590
Significa andare a questo indirizzo
e mettere ciò che numero c'è?

1019
00:45:42,590 --> 00:45:43,870
Mettere il numero 42 lì.

1020
00:45:43,870 --> 00:45:47,590
Stella y significa andare a quello che è in y
e mettere il numero 13 lì.

1021
00:45:47,590 --> 00:45:48,600
>> Ma aspettate un minuto.

1022
00:45:48,600 --> 00:45:51,640
Ciò che è in y al momento?

1023
00:45:51,640 --> 00:45:54,950
Quale indirizzo è y memorizzazione?

1024
00:45:54,950 --> 00:45:55,770
Non lo sappiamo, vero?

1025
00:45:55,770 --> 00:45:59,230
Non abbiamo mai una volta utilizzare l'assegnazione
operatore che coinvolge y.

1026
00:45:59,230 --> 00:46:03,370
Quindi y come dichiarato sulla seconda riga del
il codice è solo un po 'di valore spazzatura, un grande

1027
00:46:03,370 --> 00:46:04,760
punto di domanda per così dire.

1028
00:46:04,760 --> 00:46:07,230
Potrebbe essere rivolta in modo casuale
per nulla in memoria, che

1029
00:46:07,230 --> 00:46:08,340
è generalmente male.

1030
00:46:08,340 --> 00:46:13,540
>> Quindi, non appena ci ha colpito quella linea lì,
stella y è uguale a 13, qualcosa di brutto,

1031
00:46:13,540 --> 00:46:17,220
qualcosa di molto brutto è circa
a succedere a Binky.

1032
00:46:17,220 --> 00:46:25,810
Quindi cerchiamo di vedere quello che sta per finire
succedendo a Binky qui in questo momento

1033
00:46:25,810 --> 00:46:26,200
o in modo da guardare.

1034
00:46:26,200 --> 00:46:26,490
>> [RIPRODUZIONE VIDEO]

1035
00:46:26,490 --> 00:46:26,745
>> -Ehi, Binky.

1036
00:46:26,745 --> 00:46:27,000
Svegliati.

1037
00:46:27,000 --> 00:46:29,296
E 'tempo per il divertimento puntatore.

1038
00:46:29,296 --> 00:46:30,680
>> -Che cosa?

1039
00:46:30,680 --> 00:46:31,980
Ulteriori informazioni su puntatori?

1040
00:46:31,980 --> 00:46:34,010
Oh, goodie.

1041
00:46:34,010 --> 00:46:37,220
>> -Beh, per iniziare, direi che siamo
avrà bisogno di un paio di puntatori.

1042
00:46:37,220 --> 00:46:37,930
>> -OK.

1043
00:46:37,930 --> 00:46:41,650
Questo codice assegna due puntatori
che può puntare a numeri interi.

1044
00:46:41,650 --> 00:46:43,760
>> -OK, bene, vedo i due puntatori.

1045
00:46:43,760 --> 00:46:45,850
Ma loro non sembrano essere
che punta a nulla.

1046
00:46:45,850 --> 00:46:46,490
>> -Esatto.

1047
00:46:46,490 --> 00:46:48,630
Inizialmente, i puntatori non
puntare a qualche cosa.

1048
00:46:48,630 --> 00:46:51,700
Le cose a cui puntano sono chiamati
pointees, e la loro istituzione è un

1049
00:46:51,700 --> 00:46:52,850
fase separata.

1050
00:46:52,850 --> 00:46:53,740
>> -Oh, giusto, giusto.

1051
00:46:53,740 --> 00:46:54,500
Sapevo che.

1052
00:46:54,500 --> 00:46:56,270
Le pointees sono separati.

1053
00:46:56,270 --> 00:46:58,553
Così come si alloca un pointee?

1054
00:46:58,553 --> 00:46:59,480
>> -OK.

1055
00:46:59,480 --> 00:47:03,707
Beh, questo codice alloca un nuovo interi
pointee, e questa parte imposta x

1056
00:47:03,707 --> 00:47:05,520
per puntare a esso.

1057
00:47:05,520 --> 00:47:06,760
>> -Ehi, che sembra migliore.

1058
00:47:06,760 --> 00:47:08,520
Così ne fanno fare qualcosa.

1059
00:47:08,520 --> 00:47:09,530
>> -OK.

1060
00:47:09,530 --> 00:47:14,110
Io dereferenziare il puntatore x per memorizzare
il numero 42 nella sua pointee.

1061
00:47:14,110 --> 00:47:17,660
Per questo trucco, ho bisogno la mia magia
bacchetta di dereferenziazione.

1062
00:47:17,660 --> 00:47:20,695
>> -La bacchetta magica di dereferencing?

1063
00:47:20,695 --> 00:47:22,632
Uh, che è grande.

1064
00:47:22,632 --> 00:47:24,620
>> -Questo è ciò che il codice è simile.

1065
00:47:24,620 --> 00:47:27,526
Mi limiterò a impostare il numero, e -

1066
00:47:27,526 --> 00:47:28,250
>> -Ehi, guarda.

1067
00:47:28,250 --> 00:47:29,680
Ci si va.

1068
00:47:29,680 --> 00:47:34,520
Quindi, facendo un dereferenziazione su x segue
la freccia per accedere alla pointee.

1069
00:47:34,520 --> 00:47:36,690
In questo caso, per immagazzinare 42 in là.

1070
00:47:36,690 --> 00:47:40,890
Ehi, provare a utilizzarlo per memorizzare il numero
13 attraverso l'altro puntatore, y.

1071
00:47:40,890 --> 00:47:42,125
>> -OK.

1072
00:47:42,125 --> 00:47:46,810
Vado qui a y e
Prendi il numero 13 ha istituito.

1073
00:47:46,810 --> 00:47:50,890
E poi prendere la bacchetta di
dereferencing e basta -

1074
00:47:50,890 --> 00:47:52,430
Whoa!

1075
00:47:52,430 --> 00:47:53,030
>> -Oh, ciao.

1076
00:47:53,030 --> 00:47:54,610
Che non ha funzionato.

1077
00:47:54,610 --> 00:47:58,200
Dire, Binky, non credo che il
dereferencing y è una buona idea,

1078
00:47:58,200 --> 00:48:01,370
Poiché l'installazione di pointee
è una fase separata.

1079
00:48:01,370 --> 00:48:03,460
E non credo che abbiamo mai fatto.

1080
00:48:03,460 --> 00:48:03,810
>> -Hmm.

1081
00:48:03,810 --> 00:48:05,160
Buon punto.

1082
00:48:05,160 --> 00:48:07,410
>> -Sì, abbiamo assegnato la y del puntatore.

1083
00:48:07,410 --> 00:48:10,045
Ma non abbiamo mai impostiamo a
puntare a una pointee.

1084
00:48:10,045 --> 00:48:10,490
>> -Hmm.

1085
00:48:10,490 --> 00:48:12,170
Molto attento.

1086
00:48:12,170 --> 00:48:13,790
>> -Ehi, che stai cercando
bene lì, Binky.

1087
00:48:13,790 --> 00:48:16,920
Riesci a risolvere il problema in modo che i punti di y
allo stesso pointee come x?

1088
00:48:16,920 --> 00:48:17,810
>> -Certo.

1089
00:48:17,810 --> 00:48:20,300
Userò la mia bacchetta magica di
assegnazione puntatore.

1090
00:48:20,300 --> 00:48:22,240
>> -È che sarà un
problema come prima?

1091
00:48:22,240 --> 00:48:22,665
>> -No.

1092
00:48:22,665 --> 00:48:24,300
Questo non tocca i pointees.

1093
00:48:24,300 --> 00:48:27,880
Cambia solo un puntatore per puntare
per la stessa cosa di un altro.

1094
00:48:27,880 --> 00:48:28,970
>> -Oh, capisco.

1095
00:48:28,970 --> 00:48:31,730
Ora i punti y per lo stesso posto come x.

1096
00:48:31,730 --> 00:48:32,450
Quindi aspettare.

1097
00:48:32,450 --> 00:48:33,490
Ora y è fissa.

1098
00:48:33,490 --> 00:48:34,630
Ha un pointee.

1099
00:48:34,630 --> 00:48:36,520
Così si può provare la bacchetta
di dereferencing nuovo

1100
00:48:36,520 --> 00:48:39,200
per inviare il 13 sopra.

1101
00:48:39,200 --> 00:48:39,840
>> -OK.

1102
00:48:39,840 --> 00:48:41,570
Qui va.

1103
00:48:41,570 --> 00:48:42,870
>> -Ehi, guarda un po '.

1104
00:48:42,870 --> 00:48:44,320
Ora dereferencing opere su y.

1105
00:48:44,320 --> 00:48:47,020
E poiché i puntatori sono la condivisione
che uno pointee, essi

1106
00:48:47,020 --> 00:48:48,585
sia per vedere la 13.

1107
00:48:48,585 --> 00:48:49,040
>> -Già.

1108
00:48:49,040 --> 00:48:49,670
Condivisione.

1109
00:48:49,670 --> 00:48:50,380
Qualunque sia.

1110
00:48:50,380 --> 00:48:52,290
Quindi stiamo andando scambiano di posto adesso?

1111
00:48:52,290 --> 00:48:52,970
>> -Oh, guarda.

1112
00:48:52,970 --> 00:48:54,150
Siamo fuori tempo.

1113
00:48:54,150 --> 00:48:55,200
>> -Ma -

1114
00:48:55,200 --> 00:48:57,060
>> -Basta ricordare i tre
regole puntatore.

1115
00:48:57,060 --> 00:49:00,100
Numero uno, la struttura di base
è che si dispone di un puntatore.

1116
00:49:00,100 --> 00:49:02,170
E che punti verso un pointee.

1117
00:49:02,170 --> 00:49:04,160
Ma il puntatore e pointee
sono separate.

1118
00:49:04,160 --> 00:49:06,460
E l'errore comune è quello di
impostare un puntatore, ma a

1119
00:49:06,460 --> 00:49:08,540
dimenticare di dato un pointee.

1120
00:49:08,540 --> 00:49:12,460
>> Numero due, puntatore dereferenziazione inizia
presso il puntatore e segue la sua

1121
00:49:12,460 --> 00:49:14,570
freccia sopra per accedere alla pointee.

1122
00:49:14,570 --> 00:49:18,640
Come tutti sappiamo, questo funziona solo se ci
è un pointee, che torna a

1123
00:49:18,640 --> 00:49:19,790
regola numero uno.

1124
00:49:19,790 --> 00:49:23,670
>> Numero tre, l'assegnazione puntatore assume
un puntatore e modifiche che per puntare a

1125
00:49:23,670 --> 00:49:25,850
la stessa pointee come un altro puntatore.

1126
00:49:25,850 --> 00:49:27,840
Così, dopo l'assegnazione,
i due puntatori

1127
00:49:27,840 --> 00:49:29,430
puntare allo stesso pointee.

1128
00:49:29,430 --> 00:49:31,600
A volte che chiama condivisione.

1129
00:49:31,600 --> 00:49:33,430
E questo è tutto ciò che devi fare, davvero.

1130
00:49:33,430 --> 00:49:33,840
Bye bye ora.

1131
00:49:33,840 --> 00:49:34,300
>> [FINE RIPRODUZIONE VIDEO]

1132
00:49:34,300 --> 00:49:36,940
>> DAVID MALAN: Quindi più su puntatori,
di più su Binky prossima settimana.

1133
00:49:36,940 --> 00:49:38,190
Ci vediamo il Lunedi.

1134
00:49:38,190 --> 00:49:42,187