>> DAVID MALAN: Ciao, e bentornato CS50.
Quindi questa è la fine della quarta settimana.
Solo un annuncio prima.
Così il cosiddetto quinto Lunedi è in arrivo il prossimo Lunedi.
Questa è l'occasione per passare da SAT / UNSAT a una lettera di grado, o da
grade lettera SAT / UNSAT.
Fastidiosamente, questo processo richiede un firma, perché si deve riempire
fuori uno di quei add / drop forme rosa.
>> Perché tecnicamente, la SAT / UNSAT versione e la versione in lettere
hanno numeri di catalogo distinte.
Ma niente di grave.
Basta venire da me o a Rob oa Lauren in qualsiasi punto.
O con la posta elettronica se non si ha il tipo di lavoro di ufficio che serve oggi, e noi
sarà certo per aiutarvi a prendere cura che prima di Lunedi.
>> Va bene, così oggi -
In realtà, c'è un po 'di eco.
Possiamo tono mi giù un po '?
OK.
Così oggi, si introduce un argomento noto come puntatori.
E devo ammettere che questo è uno dei argomenti più complessi che tendiamo a
coprire in questa classe, o davvero qualsiasi corso introduttivo che utilizza C.
>> Ma prendere la mia parola per esso, in particolare Se la tua mente si sente un po 'più curvo
oggi e nelle settimane a venire.
Non è rappresentativo di voi ottenere peggio a questo significa solo che
si tratta di un argomento particolarmente sofisticato che prometto, un paio di settimane
quindi, vi sembrerà fin troppo sconvolgente semplice in retrospettiva.
>> Ricordo ancora a questo giorno.
Ero seduto in Elliott Dining Hall, seduto accanto al mio TF Nishat Mehta,
che è stato un residente della casa di Elliott.
E per qualche ragione, questo argomento scatta solo.
Il che vuol dire che ho faticato troppo con esso per un certo periodo di tempo, ma ho
Farò il mio meglio per contribuire ad evitare qualsiasi lotta con un argomento che in ultima analisi,
è abbastanza potente.
>> In effetti, uno dei temi che discuteremo nelle settimane a venire è che
di sicurezza, e di come in realtà si può sfruttare macchine in modi
che non erano destinate.
E questi sfruttamenti sono tipicamente il risultato di bug, errori che abbiamo
le persone fanno da non capire un po 'di dall'implementazione sottostante
Dettagli mediante cui vengono effettuati programmi.
>> Ora per fare questo sembrare più user amichevole, ho pensato di giocare a 10
secondi di anteprima di un po 'di claymation figura di nome Binky che è stato portato a
vita da un nostro amico a Stanford, professore Nick Parlante.
Quindi, mi permetta di darle questo teaser del Binky qui.
>> [RIPRODUZIONE VIDEO]
>> -Ehi, Binky.
Svegliati.
E 'tempo per il divertimento puntatore.
>> -Che cosa?
Ulteriori informazioni su puntatori?
Oh, goodie.
>> [FINE RIPRODUZIONE VIDEO]
>> DAVID MALAN: Cioè Stanford informatica.
Quindi, più su quello a venire.
>> [Applausi]
>> DAVID MALAN: Ci dispiace, Nick.
>> Quindi, ricordare che l'ultima volta abbiamo finito il questo davvero emozionante Cliffhanger
per cui questa funzione semplicemente non ha funzionato.
Almeno intuitivamente, si sentiva come dovrebbe funzionare.
Semplicemente sostituendo i valori di due numeri interi.
Ma ricordo che quando abbiamo stampato il valori originali nella principale, uno e
due, erano ancora uno e due e non due e uno.
>> Così mi permetta effettivamente passare oltre all'apparecchio.
E ho scritto un po 'di codice scheletrico in avanzare qui, dove io sostengo che x
sarà 1, y sarà 2.
Ho poi stampare le due di loro valori con stampa f.
>> Allora io sostengo qui che stiamo andando a scambiarle.
Ho lasciato un posto vuoto qui per noi compila oggi in un attimo.
Poi, ho intenzione di sostenere che il due variabili sono state scambiate.
Poi ho intenzione di stampare li di nuovo.
E così si spera, dovrei vedere 1, 2.
2, 1.
Questo è il super semplice obiettivo al momento.
>> Quindi, come facciamo a scambiare due variabili?
Beh, se vi propongo qui che queste tazze potrebbero rappresentare memoria in un computer.
Si tratta di un paio di morsi, questo è un altro paio di morsi.
Avremmo potuto un volontario vieni su e mescolare qualcosa da bere, se familiare?
Andiamo su.
Qual è il tuo nome?
>> JESS: Jess.
>> DAVID MALAN: Jess?
Vieni su, Jess.
Se non ti dispiace, dobbiamo mettere il Google Glass su di voi in modo che possiamo
immortalare questo.
OK, vetro.
Registrare un video.
E OK, siamo bravi a andare con Jess qui.
D'accordo.
Lieto di vederla.
>> Quindi quello che vorrei fare qui - se si potesse, abbastanza rapidamente -
solo noi versa mezzo bicchiere d'arancio succo e mezzo bicchiere di latte,
che rappresenta in modo efficace i numeri 1 in una tazza e 2 nell'altra tazza.
>> Questo sta per essere buoni filmati.
>> JESS: Mi dispiace.
>> DAVID MALAN: No, no.
E 'OK.
Nizza.
Va bene, così abbiamo quattro byte vale la pena di succo d'arancia.
Ci chiamavamo il valore 1.
Ora altri quattro byte di valore di latte.
Chiameremo valore 2.
Così xey, rispettivamente.
>> Bene, così ora se il compito a portata di mano - per te, Jess, davanti a tutti
dei tuoi compagni di classe -
è quello di scambiare i valori di x e y tali che vogliamo che il succo d'arancia in
altra tazza e il latte in questa coppa, come si potrebbe - in realtà prima di fare
esso - andare a fare questo?
>> OK, saggia decisione.
Allora avete bisogno di un po 'più di memoria.
Quindi cerchiamo di allocare un temporaneo tazza, se si vuole.
E ora procedere a scambiare x e y.
>> Eccellente.
Quindi, molto ben fatto.
Grazie mille, Jess.
Ecco.
Un piccolo souvenir.
>> OK, quindi ovviamente, super semplice idea.
Completamente intuitivo che abbiamo bisogno di un po ' più spazio di archiviazione - in questa forma,
una tazza - se vogliamo davvero scambiare queste due variabili.
Quindi cerchiamo di fare esattamente questo.
Quassù tra cui io sostengo che sono intenzione di fare qualche scambio, io
andare avanti e dichiarare temperatura.
E mi misi pari a, diciamo, x.
>> Poi ho intenzione di cambiare il valore di x come Jess ha fatto qui con il
latte e succo d'arancia per essere uguale a y.
E ho intenzione di cambiare y per essere uguale a non x, perché ora saremmo
bloccato in un circolo, ma piuttosto temp.
Dove temporaneamente - o dove Jess mettere temporaneamente il succo d'arancia
prima di sovrascrivere quello tazza con il latte.
>> Quindi, mi permetta di andare avanti ora e faccio questo.
Si chiama noswap.c.
E adesso lasciatemi correre senza swap.
E infatti lo vedo, se mi espando la finestra un po ', che
x è 1, y è 2.
E allora x è 2, y è 1.
>> Ma ricordiamo che il Lunedi abbiamo fatto le cose un po 'diverso per cui ho
invece implementato una funzione di supporto, se si vuole, che era in realtà vuoto.
Ho chiamato lo swap.
Ho dato due parametri, e ho chiamato loro una e li ho chiamati b.
>> Francamente, ho potuto chiamarli x e y.
Non c'è niente di arresto me di farlo.
Ma direi che è poi un po ambiguo.
Perché richiamo per Lunedi che abbiamo hanno sostenuto che questi parametri sono stati
copie dei valori passati dentro
Così appena pasticci con la tua mente, penso che, se si utilizza
esattamente le stesse variabili.
>> Così io, invece loro una chiamata e B, solo per chiarezza.
Ma potremmo chiamarli più tutto ciò che vogliamo.
E ho intenzione di copiare e incollare efficacemente questo codice da lassù
giù in qui.
Perché ho appena visto che funziona.
Ecco, questo è in buona forma.
E io cambierò x un mio x ad una, la mia y per B e la mia y per b.
>> Quindi, in altre parole, esatto stessa logica.
La stessa identica cosa che Jess ha fatto.
E allora l'unica cosa che devo fare up qui, naturalmente, è ora invocare questa
funzione, oppure chiamare questa funzione.
Quindi mi chiamare questa funzione con due ingressi, x e y, e ha colpito Salva.
>> Va bene, quindi fondamentalmente la stessa cosa.
In realtà, probabilmente ho fatto il programma inutilmente complesso da
scrivere una funzione che sta solo prendendo circa sei righe di codice, mentre io
in precedenza aveva implementato questo in solo tre.
>> Quindi, mi permetta di andare avanti ora e rifare questo, non fare swap.
Va bene, ho fatto un casino qui.
Questo dovrebbe essere un errore che si potrebbe vedere sempre più comunemente come il tuo
programmi diventano più complessi.
Ma c'è una soluzione semplice.
Lasciate scorrere indietro fino qui.
>> E qual è il primo errore che sto vedendo?
Dichiarazione implicita.
Che cosa indicano in genere?
Oh, ho dimenticato il prototipo.
Ho dimenticato di insegnare al compilatore che di swap è andare a esistere anche se lui
non esiste proprio all'inizio del programma.
Così sto solo andando a dire nulla, swap, int, int b, punto e virgola.
>> Quindi io non ho intenzione di implementare di nuovo esso.
Ma ora che corrisponda a ciò che è quaggiù.
E comunicazione, l'assenza di una virgola qui, che non è necessaria quando
attuazione.
>> Quindi, mi permetta di rifare questo, non fare swap.
Molto più in forma.
Esegui senza swap.
E dannazione.
Ora siamo tornati dove eravamo il Lunedi, dove la cosa non scambiare.
>> E qual è la spiegazione intuitiva per cui questo è il caso?
Sì?
>> STUDENTE: [incomprensibile].
>> DAVID MALAN: Esattamente.
Quindi a e b sono le copie di x e y.
E infatti, ogni volta che sono stato chiamare una funzione finora che
passa variabili come int -
proprio come swap si aspetta qui -
voi ragazzi sono stati passando copie.
>> Ora che significa che ci vuole un po ' di tempo, una frazione di secondo, per l'
computer per copiare i bit da un variabile nei bit di un altro.
Ma non è un grande affare.
Ma sono comunque una copia.
>> E così ora, nel contesto di swap, Sono infatti con successo
cambiando ae b.
In realtà, cerchiamo di fare un rapido controllo di integrità.
Stampa f a è% i, nuova linea.
E spina andiamo in un.
Ora facciamo la stessa cosa con b.
E cerchiamo di fare la stessa cosa qui.
>> E ora, mi permetta di copiare queste stesse linee nuovamente al fondo della funzione
dopo le mie tre linee di interessante avrebbe eseguito, e
stampare ancora una volta a e b.
Così ora facciamo questo, non fare swap.
Permettetemi di fare la finestra del terminale di un po 'più alto, in modo che possiamo vedere
più di esso in una volta.
>> E correre senza swap.
x è 1, y è 2. a è 1, b è 2.
E poi, a è 2, b è 1.
Quindi si sta lavorando, proprio come Jess fatto qui dentro di swap.
Ma, naturalmente, non sta avendo alcun effetto sulle variabili principali.
>> Così abbiamo visto un trucco con cui abbiamo potrebbe risolvere questo problema, giusto?
Quando sei di fronte a questo scoping problema, si può solo punt e fare x
ed y che tipo di variabili invece?
>> Si potrebbe fare di loro globale.
Metterli in cima del file come abbiamo fatto, anche nel gioco del 15.
Usiamo una variabile globale.
Ma nel contesto del gioco a 15, è ragionevole avere un globale
variabile che rappresenta il bordo, perché l'interezza di 15.c è tutto
circa l'attuazione di quel gioco.
Questo è ciò che esiste il file per farlo.
>> Ma in questo caso qui, sono chiamando una funzione di swap.
Vorrei scambiare due variabili.
E dovrebbe iniziare a sentire solo sciatta se la soluzione a tutti i nostri
problemi quando ci imbattiamo in ambito problemi è renderlo globale.
Perché molto rapidamente il nostro programma è sta per diventare un bel pasticcio.
E lo abbiamo fatto con molta parsimonia di conseguenza in 15.c.
>> Ma si scopre c'è un migliore modo del tutto.
Lasciatemi in realtà tornare indietro e cancellare la stampare f di, solo per semplificare il codice.
E lasciatemi propongo questo, infatti, è un male.
Ma se io invece aggiungo in alcuni asterischi e le stelle, posso invece trasformare questo
funzione in uno che è effettivamente operativa.
>> Così mi permetta di tornare qui e ammetto dicendo asterischi è sempre difficile,
quindi mi dico stelle.
Mi limiterò a confessare a quella.
D'accordo.
E ora, che cosa sono io che vado fare, invece?
>> Quindi, prima di tutto, ho intenzione di specificare che invece di passare un int in
la funzione swap, sono invece di andare a dire int stella.
Ora, che cosa indica la stella?
Questa è quella nozione di un puntatore che Binky, il personaggio claymation, era
riferimento a un momento fa.
>> Quindi, se diciamo int stella, il significato di questo ora è che una non sta per essere
passata in dal suo valore.
Non sta andando da copiare dentro
Piuttosto, l'indirizzo di a è sta per essere passata dentro
>> Così ricordare che all'interno del vostro computer è un sacco di memoria, altrimenti
noto come RAM.
E che la RAM è solo un mucchio di byte.
Quindi, se il tuo Mac o il PC ha due gigabyte, si hanno 2
miliardi di byte di memoria.
>> Ora facciamo solo supporre che proprio per mantenere le cose belle e ordinato, abbiamo
assegnare un indirizzo -
un numero -
per ogni byte di RAM presente nel computer.
Il primo byte di quelli 2 miliardi sono in numero pari a zero.
Il prossimo è il numero di byte uno, numero due, tutta la strada in su, punto punto
dot, a circa 2 miliardi di euro.
>> Così si può certo numero di byte della memoria del computer.
Quindi supponiamo che questo è ciò che intendiamo per un indirizzo.
Così, quando vedo una stella int, che cosa sta succedendo per essere passato in scambio ora è il
indirizzo di una.
Non è il suo valore, ma qualunque sia la sua postali indirizzo è, per così dire -
la sua posizione nella RAM.
>> E similmente per b, io vado per dire la stessa cosa.
Int, stella, b.
Per inciso, tecnicamente la stella potrebbe andare in altri luoghi.
Ma faremo standardizzare la stella essendo proprio accanto al tipo di dati.
>> Così scambiare firma ora significa, dammi l'indirizzo di un int, e chiamata
che l'indirizzo a.
E dammi un altro indirizzo di un INT e chiamare tale indirizzo b.
>> Ma ora il mio codice qui deve cambiare.
Perché se io dichiaro int temp -
che è ancora di tipo int -
ma devo conservare in esso una, che tipo di valore?
Per essere chiari, sto mettendo a con il codice come scritto in questo momento?
>> Sto mettendo la posizione in una.
Ma non mi preoccupo per il posizione ora, giusto?
Temp esiste solo terza coppa Jess ' esistito, per quale scopo?
Per memorizzare un valore.
Latte o succo d'arancia.
Non quello di archiviare l'indirizzo del una di quelle cose, che si sente un
poco senza senso in questo vero e proprio contesto mondiale comunque.
>> Quindi, in realtà, quello che voglio mettere in temperatura non è l'indirizzo di una, ma l'
contenuto di un.
Quindi se a è un numero come 123, questo è il byte 123 di memoria che un solo
sembra essere occupante, che il valore in una sembra essere occupante.
>> Se voglio andare a tale indirizzo, Ho bisogno di dire una stella.
Allo stesso modo, se dovessi cambiare ciò che è presso l'indirizzo di una, io cambio
questo per iniziare una.
Se voglio conservare in ciò che è al posizione una con ciò che è nella posizione
in b, b stella stella.
>> Così, in breve, anche se questo non è abbastanza affondando in ancora - e non mi aspetto
che sarebbe così veloce -
si rendono conto che tutto quello che sto facendo è prefisso queste stelle ai miei variabili,
dicendo di non prendere i valori.
Non modificare i valori.
Ma piuttosto, andare a questi indirizzi e ottenere il valore.
Vai a questo indirizzo e il cambiamento il valore lì.
>> Così ora mi permetta di scorrere indietro fino alla cima, solo per risolvere questa linea qui, per
modificare il prototipo in modo che corrisponda.
Ma ora ho bisogno di fare un'altra cosa.
Intuitivamente, se ho cambiato i tipi di argomenti che di swap si aspetta,
che altro ho bisogno di cambiare nel mio codice?
>> Quando chiamo swap.
Perché in questo momento, che cosa sono Ho passando per scambiare ancora?
Il valore x e il valore di y, o il latte e il succo d'arancia.
Ma io non voglio farlo.
Io invece voglio passare a cosa?
La posizione di x e la posizione di y.
Quali sono i loro indirizzi postali, per così dire.
>> Quindi, per fare questo, c'è una e commerciale.
Ampersand tipo di suoni come indirizzo.
quindi n, e commerciale, l'indirizzo di x, e l'indirizzo di y.
Quindi è deliberato che usiamo ampersands al richiamo della funzione,
e le stelle quando si dichiarano e quando realizzazione della funzione.
>> E basta pensare e commerciale come il indirizzo dell'operatore, e la stella come il
andare là operatore -
o, più correttamente, l' operatore di risoluzione del riferimento.
Ecco, questo è un bel po 'di parole solo per dire che ora, si spera, di swap sta
di essere corretto.
>> Lasciatemi andare avanti e fare -
diamo effettivamente rinominare il file, per timore questo programma ancora essere chiamato senza swap.
Io sostengo che noi chiameremo swap.c ora.
Quindi, fare, invertire.
Dot, slash, scambiare.
>> E ora infatti, x è 1, y è 2.
E poi, è x 2, y è uno.
Bene vediamo se non siamo in grado di fare questo un po 'diverso da ciò che è
succedendo qui.
In primo luogo, permettetemi di zoomare su un nostro schermo di disegno qui.
E mi permetta di proporre un momento - e ogni volta che disegno qui si rifletterà
lassù ora - lasciatemi propongo qui c'è un sacco di memoria, o
RAM, all'interno del mio computer.
>> E questo sarà il numero morso, diciamo, 1.
Questo sarà il byte numero 2.
E farò un sacco di più, e poi un po 'di punti puntini puntino a
indicano che ci sono 2 miliardi di queste cose.
4, 5, e così via.
>> Così ci sono i primi cinque byte della memoria del mio computer.
D'accordo?
Pochissimi di 2 miliardi di euro.
Ma ora ho intenzione di proporre il seguente.
Ho intenzione di proporre che x sta per memorizzare il numero 1, ed y è andare
per memorizzare il numero 2.
E mi permetta di andare avanti ora e rappresenta questi valori come segue.
>> Facciamo questo come segue.
Dammi solo un secondo.
Un secondo.
OK.
Voglio fare questo un po '-
cerchiamo di farlo di nuovo.
In caso contrario, ho intenzione di e con il stessi numeri, involontariamente,
più volte.
>> Quindi, solo così abbiamo numeri diversi per parlare di, chiamiamola questo byte
numero 123, 124, 125, 126, e puntini puntini.
E lasciatemi pretendo ora che ho intenzione di mettere il valore 1 qui, e il valore 2
qui, altrimenti noto come x e y.
Così si da il caso che questo è x, questo è y.
>> E solo per un caso a caso, il computer, il sistema operativo,
successo a mettere in posizione x numero 123.
E Y è finito in posizione 124 -
dannazione.
Avrei risolto questo.
Oh uomo, voglio davvero fare questo?
Sì, voglio risolvere questo problema e b adeguata di questo oggi.
Siamo spiacenti, nuovo a questo.
>> 127, 131, e io non volevo essere presente complesso, ma perché ho cambiato il
numeri lì?
Perché voglio che gli INT a effettivamente essere quattro byte.
Quindi cerchiamo di essere super anale su questo.
In modo che se uno sembra essere affrontati 123, il 2 sta per essere all 'indirizzo
127 perché è a soli 4 addii di distanza.
Questo è tutto.
E ci dimentichiamo di tutto il altri indirizzi del mondo.
>> Quindi x è in posizione 123, y è in posizione 127.
E adesso, che cosa faccio io in realtà vogliono fare?
Quando chiamo di swap ora, ciò che è realmente succedendo?
Beh, quando chiamo swap, sto passando in l'indirizzo di x e l'indirizzo di y.
Così, per esempio, se questi due pezzi di carta ormai rappresentano i due
argomenti a e b di swap, che cosa sono io andando a scrivere il primo di questi,
che ho intenzione di chiamare fare riferimento a come?
>> Esattamente, 123.
Quindi questo io sostengo è un.
Questo è il parametro a.
Sto mettendo l'indirizzo di x in là.
>> Che cos'è?
>> No, no.
Questo è OK.
Ancora buona, ancora buono.
Quindi questo è un.
E ora sul secondo pezzo di carta, questo sta per essere B, e che cosa sono io
intenzione di scrivere su questo pezzo di carta?
127.
>> Quindi l'unica cosa che è cambiata da allora nostro precedente racconto di questa storia è,
piuttosto che letteralmente 1 e 2, sono andando a passare in 123 e 127.
E ora sto andando a mettere questi all'interno di questa scatola, va bene?
In modo che la scatola nera rappresenta oggi la funzione di swap.
>> Nel frattempo, diamo ora hanno qualcuno implementare la funzione swap.
Qualcuno qui come volontario?
Andiamo su.
Qual è il tuo nome?
Charlie.
Va bene, Charlie.
Andiamo su.
>> Così Charlie sta per giocare il ruolo della nostra scatola nera.
E Charlie, quello che mi piacerebbe che tu faccia Ora è implementare scambio in modo tale
che, date queste due indirizzi, che sono stati effettivamente andando
per modificare i valori.
E ti sussurro all'orecchio come far funzionare la TV qui.
>> Quindi, andare avanti, e tu sei la scatola nera.
Raggiungere in là.
Quali valori vede per una, e quali valori si vede per la b?
>> CHARLIE: a è 123 e B è 127.
>> DAVID MALAN: OK, esattamente.
Ora, mettere in pausa lì solo per un momento.
La prima cosa che hai intenzione di fare ora, secondo il codice - che
Io ora tiro su sullo schermo -
sta per essere di destinare un po ' po 'di memoria chiamato temperatura.
Quindi ho intenzione di andare avanti e dare che la memoria.
>> Quindi questo sta andando essere una terza variabile che si deve accessibile a
hai chiamato temperatura.
E che cosa hai intenzione di scrivere sul pezzo temperatura di carta?
>> CHARLIE: Puntatori, giusto?
>> DAVID MALAN: OK, bene non necessariamente puntatori.
Così la linea di codice che ho evidenziata sul lato destro,
cerchiamo di cominciare da lì.
Si dice che una stella.
Quindi una sta attualmente memorizzando il numero 123.
E proprio intuitivamente, ciò ha stella 123 significa?
>> Ma specificamente, se a è 123, una stella significa che cosa?
Il valore di a.
O più casualmente, andare lì.
Quindi lasciatemi propongo, tenendo il a in la tua mano, andare avanti e trattare che
come se fosse una mappa.
E camminare da soli verso il computer di memoria, e noi trovare ciò che è
a posizione 123.
Esattamente.
>> Così vediamo in posizione 123 è ciò che, ovviamente?
OK, in modo che valore ora sei tu andando a mettere in temperatura?
Esattamente.
Quindi, andare avanti e farlo.
E scrivere il numero 1 sul pezzo di carta che è attualmente intitolato temperatura.
>> E ora il passo successivo che si sta andando ad implementare
sta per essere quello.
Ebbene, sul lato destro della successiva riga di codice è stella b. b, del
Naturalmente, memorizza un indirizzo.
Che gli indirizzi 127.
Stella b significa quello che, casualmente parlando?
>> Vai a quella posizione.
Quindi, andare avanti e noi trovare ciò che è a posizione 127.
OK.
Naturalmente, in posizione 127, è ancora il valore 2.
Allora, cosa stai andando adesso conservare a tutto ciò è la posizione in un?
Così stella un mezzo vanno alla posizione una.
Qual è la posizione di un?
>> Esattamente.
Così ora, se si desidera modificare ciò che è in quella posizione -
Io vado avanti e corro la gomma è qui.
E ora rimetterlo sulla spazzola.
Che numero hai intenzione di scrivere in quella scatola vuota adesso?
>> Esattamente.
Quindi, questa riga di codice, per essere chiari - lascia Mi soffermo cosa Charlie sta facendo e
sottolineare qui, quello che ha appena fatto è scrivere in quella casella alla posizione 123
il valore che era precedentemente in b.
E così ora abbiamo implementato infatti questa seconda linea di codice.
>> Ora, purtroppo, non c'è ancora una riga rimanente.
Ora, ciò che è in temperatura, letteralmente?
E 'ovviamente il numero uno.
Questo non è un indirizzo.
E 'solo un numero, una sorta di una variabile da una settimana.
>> E ora quando si dice stella b, che significa andare all'indirizzo B, che è di
Naturalmente qui.
Quindi, una volta arrivati ​​lì -
Io vado avanti e cancellare quello che in realtà è lì - e che cosa sei
intenzione di scrivere ora a posizione 127?
>> CHARLIE: Temp, che è uno.
>> DAVID MALAN: Temp, che è uno.
E cosa succede alla temperatura, alla fine?
Beh, in realtà non lo sappiamo.
Noi in realtà non importa.
Ogni volta che abbiamo implementato una funzione Finora, tutte le variabili locali che hanno
sono davvero locale.
E hanno appena scompaiono.
Sono recuperati dalla operativo sistema alla fine.
>> Quindi il fatto che ha ancora la temperatura valore 1 è una sorta di fondamentalmente
poco interessante per noi.
Va bene, quindi un applauso se potessimo per Charlie.
Molto ben fatto.
>> Va bene, allora cosa fa più questo significa che possiamo fare?
Così si scopre che siamo stati raccontare qualche bugia bianca
per un bel po 'di tempo.
In effetti, si scopre che una stringa, tutto questo tempo, non è un vero
sequenza di caratteri per sé.
E 'sorta di è che intuitivamente.
>> Ma tecnicamente parlando, è una stringa tipo di dati che abbiamo dichiarato all'interno di
la libreria CS50 di semplificare il mondo per le prime settimane di lezione.
Che una stringa è veramente è l'indirizzo di un personaggio qualche parte in RAM.
Una stringa è in realtà un numero, come 123 o 127, che succede a delimitare
in cui una stringa inizia in memoria del computer.
>> Ma non rappresenta il stringa di per sé stessa.
E possiamo vedere questo come segue.
Lasciami andare avanti e di aprire del codice che è tra
esempi di codice sorgente di oggi.
E ho intenzione di andare avanti e di aprire fino, diciamo, confrontare-0.C.
Questo è un programma bacato che sta andando essere attuato come segue.
>> Primo.
Sto per dire qualcosa.
Poi ho intenzione di andare avanti e ottenere una stringa dall'utente
in quella riga successiva.
Poi ho intenzione di dire di nuovo.
Poi ho intenzione di ottenere un altro stringa dall'utente.
>> E notate, sto mostrando uno dei stringhe in una variabile chiamata s, e
un'altra di queste stringhe in una variabile chiamata t.
E ora ho intenzione di rivendicare, molto ragionevolmente, che se s è uguale uguale t,
le stringhe sono uguali.
Si digita la stessa cosa.
Altrimenti, le stringhe sono non è la stessa cosa.
>> Dopo tutto, se abbiamo ingresso due interi, due caratteri, due galleggianti, due doppie, tutte di
i tipi di dati di cui abbiamo parlato finora per confrontarli -
Richiamo abbiamo fatto molto chiaro qualche tempo fa che non si fa questo, perché un
unico segno di uguale è naturalmente l'operatore di assegnazione.
In modo che sarebbe un bug.
>> Usiamo il segno di uguale uguale, che si confronta infatti
cose per una vera uguaglianza.
Ma io rivendico questo è bacato.
Se vado avanti e fare confrontare a zero, e poi fare dot barra confrontare zero.
E scrivo a, diciamo, ciao.
E poi diciamo ciao di nuovo.
Letteralmente la stessa cosa, il computer RECLAMI ho digitato cose diverse.
>> Ora forse ho solo scritto male qualcosa.
Io digito il mio nome questa volta.
Voglio dire, ciao.
Ciao.
E 'diverso ogni volta.
>> Beh, perché?
Che cosa sta realmente accadendo sotto il cofano?
Ebbene, che cosa sta realmente accadendo sotto il cofano è la stringa allora
Ho digitato in quella prima volta, ad esempio, è la parola ciao, naturalmente.
Ma se noi rappresentiamo questo sotto il cofano, si ricordi che un
stringa è in un array.
E abbiamo detto tanto in passato.
>> Quindi, se io traggo tale array come questo, io sono andando a rappresentare qualcosa di molto
simile a quello che abbiamo fatto poco fa.
E c'è in realtà qualcosa speciale qui, anche.
Cosa abbiamo determiniamo era al Alla fine di ogni stringa?
Sì, questo backslash zero, che è solo il modo di rappresentare,
letteralmente, 00000000.
Otto bit 0 di fila.
>> Non lo so, francamente, cosa c'è dopo questo.
Questo è solo un mucchio di più RAM all'interno del mio computer.
Ma questo è un array.
Abbiamo parlato di array prima.
E noi di solito parla di array come posizione di zero,
poi uno, poi due.
Ma questo è solo per convenienza.
E questo è del tutto relativa.
>> Quando si sta effettivamente ricevendo memoria da il computer, è, naturalmente, qualsiasi
2 miliardi di alcuni byte dispari, potenzialmente.
Così realmente sotto la cappa, tutto questo tempo, sì.
Questo potrebbe benissimo essere staffa zero.
Ma se si scava ancora più a fondo sotto il cofano, che è davvero
affrontare il numero 123.
Questo è l'indirizzo 124.
Questo è l'indirizzo 125.
>> E io non rovinare questo momento.
Questi sono ora uno byte a parte per quale motivo?
Quanto grande è un char?
Un char è solo un byte.
Un int è tipicamente quattro byte.
Quindi è per questo che ho fatto 123, 127, 131 e così via.
Ora posso tenere la matematica semplice e fare solo più 1.
E questo è ora che cosa sta realmente accadendo sul sotto la cappa.
>> Quindi, quando si dichiara qualcosa come questo, stringa s, questo è in realtà -
si scopre -
stella char.
Stella, naturalmente, significa indirizzo, puntatore aka.
Quindi è l'indirizzo di qualcosa.
Che cosa è l'indirizzo di?
>> Bene -
Sono l'unico che può vedere il molto punto importante che sto facendo, o pensare
Sto facendo.
Così stringa -
la cosa triste è che ho un monitor proprio lì dove ho
potrebbe aver visto questo.
>> Va bene, quindi stringa s è ciò che Ho dichiarato in precedenza.
Ma si scopre, grazie a un po 'di magia in biblioteca CS50, tutto questo
stringa di tempo ha letteralmente stato stella char.
La stella indica di nuovo puntatore o indirizzo.
Il fatto che è fiancheggiante l' carattere di parola significa che è il
indirizzo di un carattere.
>> Quindi, se ti stringa è chiamato, e digito in H-E-L-L-O, proporre ora quello che è ottenere
stringa letteralmente state tornando tutti questa volta, anche se abbiamo piuttosto
semplicistica del mondo?
Che cosa significa avere stringa effettivamente restituire come valore di ritorno?
>> 123 in questo caso, per esempio.
Abbiamo detto in precedenza che ottenere stringa restituisce semplicemente una stringa, una sequenza di
personaggi.
Ma questo è un po 'una bugia.
Il modo in cui ottenere stringa funziona davvero sotto il cofano si ottiene un
stringa dall'utente.
E plops i caratteri che lui o lei i tipi di memoria.
Si mette uno zero backslash alla fine Di quelli sequenza di caratteri.
>> Ma allora che cosa significa ottenere stringa letteralmente tornare?
Si letteralmente restituisce l'indirizzo del primi byte nella RAM che
ha usato per quella forza.
E si scopre che solo con il ritorno un singolo indirizzo della
primo carattere della stringa, che è sufficiente per stabilire la totalità di
la stringa.
>> In altre parole, ottenere stringa non ha per tornare 123 e 124 e 125.
Non deve darmi una lunga elenco di tutti i byte che
la mia stringa sta usando.
Perché uno, sono tutti back to back.
E due, sulla base del primo indirizzo, ho può capire dove finisce la stringa.
Come?
>> Lo speciale carattere null, il backslash zero al termine.
Quindi, in altre parole, se si passa in giro -
all'interno di variabili -
l'indirizzo di un char, e si assume che al termine di qualsiasi stringa, qualsiasi
sequenza di caratteri come noi esseri umani pensare di stringhe, se si assume che
al termine di tale stringa c'è uno zero backslash, sei d'oro.
Perché si può sempre trovare la fine di una stringa.
>> Ora che cosa sta realmente andando poi in questo programma?
Perché è questo programma, confronto-0.C, buggy?
Ciò che è in realtà a confronto?
Sì?
>> STUDENTE: [incomprensibile].
>> DAVID MALAN: Esattamente.
Si confrontano le posizioni delle corde.
Quindi, se l'utente ha digitato ciao una volta, come ho fatto io, la memoria potrebbe finire
cercando in questo modo.
Se poi l'utente digita in Ciao di nuovo, ma chiamando ottenere nuovamente stringa, c è
non particolarmente intelligente se non si insegna che sia furbo da scrivere codice.
>> C -
e computer più in generale -
se si digita la parola ciao di nuovo, si sa cosa si vuole ottenere.
Stai solo andando a prendere un secondo array di memoria che, sì, succede essere
memorizzare H-E-L-L-O e così via.
>> Sta andando a guardare la stessa per noi esseri umani, ma questo indirizzo
potrebbe non essere 123.
Potrebbe così accadere che la sistema operativo dispone di alcuni di
spazio, ad esempio, a posizione -
diciamo qualcosa di arbitrario, come questa è la posizione 200.
E questa è la posizione 201.
E questa è la posizione 202.
Non abbiamo idea di dove questo è andando ad essere in memoria.
>> Ma che cosa questo significa è che ciò che è sta per essere immagazzinata in ultima analisi, in s?
Il numero 123.
Che cosa sta per essere conservati in t, in questo esempio arbitrario?
Il numero 200.
E tutto questo significa che poi è ovviamente, 123 non è uguale a 200.
E così questa condizione se mai restituisce true.
Perché stringa get utilizza diversi blocchi di memoria ogni volta.
>> Ora siamo in grado di vedere questo nuovo In un altro esempio.
Lasciami andare avanti e di aprire copia-0.C.
Io sostengo che questo esempio sta per provare - ma non riescono - di copiare due stringhe
come segue.
>> Sto per dire qualcosa per l'utente.
Ho poi intenzione di ottenere un stringa e chiamare s.
E ora, sto facendo questo controllo qui.
Lo abbiamo detto un po 'indietro.
Ma quando potrebbe ottenere stringa di ritorno null, un altro carattere speciale, o speciali
simbolo diciamo.
Se è la memoria.
>> Ad esempio, se l'utente è veramente essere difficile e tipi un atroce
numero di caratteri al tastiera e colpi Invio.
Se il numero di caratteri proprio non posso contenuta in RAM per qualsiasi pazzo
ragione, anche ottenere stringa potrebbe molto bene restituire null.
>> Oppure, se il programma si sta facendo molto di altre cose e non c'è proprio
non sufficiente memoria per la stringa get per avere successo, potrebbe finire
fino restituendo null.
Ma cerchiamo di essere più precisi su ciò che questo è.
Qual è il tipo di dati di s davvero?
Char stella.
>> Così si scopre ora possiamo buccia lo strato di null.
Risulta, nulla è - sì, ovviamente un simbolo speciale.
Ma di cosa si tratta veramente?
In realtà, nulla è solo un simbolo che gli esseri umani usano per rappresentare lo zero pure.
>> Così gli autori di C e computer più in generale, ha deciso anni fa
che, si sa che cosa.
Perché non possiamo garantire che nessun utente dati è mai, mai, mai
conservato a bye a zero?
Infatti, anche nel mio esempio arbitrario prima, non ho cominciato la numerazione
byte a zero.
Ho cominciato a uno.
Perché sapevo che le persone in tutto il mondo hanno deciso di riservare lo zero
byte nella RAM di nessuno come qualcosa di speciale.
>> La ragione è che, in qualsiasi momento si desidera segnale che qualcosa è andato storto
per quanto riguarda gli indirizzi, è tornato null - altrimenti noto come zero -
e perché sai che non c'è legit dati all'indirizzo zero chiaramente
che significa un errore.
Ed è per questo che, per convenzione, controlliamo per nulla e ritorno qualcosa
come uno in quei casi.
>> Quindi, se noi scorriamo ora, questo è solo poi un po 'di controllo degli errori, nel caso in cui
qualcosa è andato storto con [? cauzione?]
del tutto e chiudere il programma restituendo presto.
Questa linea ora potrebbe essere riscritto come questo, che cosa significa?
Sul lato sinistro, dammi un altro puntatore a un carattere, e lo chiamano t.
Che cosa sono io la memorizzazione all'interno di t, basata su questa linea di codice?
>> Sto memorizzare una posizione.
Specificamente la posizione che era in s.
Quindi, se l'utente ha digitato ciao, e che accade prima ciao a finire
qui, allora il numero 123 è sta per tornare da ottenere
stringa e conservati -
come abbiamo detto prima -
in s.
>> Quando io ora dichiaro un altro puntatore a un char e lo chiamano t, che numero è
letteralmente andando a finire in t secondo la storia?
Così 123.
>> Quindi tecnicamente ora sia s e t stanno indicando l'esatta
stessi blocchi di memoria.
Così accorgo che cosa ho intenzione di fare ora per dimostrare che questo programma è bacato.
>> In primo luogo ho intenzione di rivendicare, con una stampa f, capitalizzando
la copia della stringa.
Poi ho intenzione di fare un po ' Controllo errori.
Ho intenzione di assicurarsi.
Facciamo in modo che la stringa t è a almeno maggiore di zero in lunghezza,
quindi c'è un po 'di carattere non di capitalizzare realmente.
>> E allora si potrebbe ricordare questo da esempi precedenti.
2 superiori - che è in il file ctype.h.
T staffa a zero mi dà lo zero carattere della stringa t.
2 e superiore dello stesso valore, di Naturalmente, lo converte in maiuscolo.
>> Così intuitivamente, la riga evidenziata del codice è maiuscola la prima
lettera t.
Ma non è capitalizzando, intuitivamente, la prima lettera di s.
Ma se stai pensando al futuro, che cosa sono io per vedere quando eseguo questo programma
e stampare sia l'originale, s, e la cosiddetta copia, t?
>> Stanno in realtà sta per essere lo stesso.
E perché hanno intenzione di essere la stessa cosa?
Stanno entrambi indicando esattamente la stessa cosa.
Quindi cerchiamo di fare questo.
>> Fai la copia zero.
Compila OK.
Lasciami correre copia zero.
Permettetemi di digitare qualcosa di simile ciao in tutto minuscolo quindi premere Invio.
E sostiene che sia la s originale e la copia sono effettivamente identici.
>> Così che cosa è realmente accaduto qui?
Permettetemi di ridisegnare questa immagine solo per raccontare la storia in un
modo leggermente diverso.
Che cosa sta realmente accadendo sotto il cappa quando dichiaro qualcosa come
char inizio s, o una stringa s, Sto ottenendo un puntatore -
che risulta essere quattro byte nell'apparecchio CS50
e in molti computer.
E ho intenzione di chiamare questo s.
E questo ha attualmente qualche valore sconosciuto.
>> Quando si dichiara una variabile, a meno che non metti un valore lì, che
sa cosa c'è.
Potrebbe essere una sequenza casuale di bit dal precedente esecuzione.
Così, quando io, nella mia linea di codice faccio arrivare stringa, e quindi memorizzare il ritorno
valore nella stringa s ottiene in qualche modo -
E faremo eventualmente staccare come arrivare opere di stringa, in qualche modo alloca un
matrice che sembra probabilmente un po 'come questo.
H-E-L-L-O, backslash zero.
>> Supponiamo che questo è l'indirizzo 123 appena prima coerenza.
Così ottenere rendimenti di stringa, nel linea evidenziata lì, restituisce il
numero abbiamo detto, 123.
Così che cosa realmente accade all'interno di s qui?
>> Beh, quello che succede veramente all'interno di s è 123.
Ma, francamente, mi sto un po ' confuso da tutti questi indirizzi,
tutti questi numeri arbitrari.
123, 124, 127.
Quindi cerchiamo di semplificare effettivamente il mondo un po '.
>> Quando si parla di puntatori, francamente, a noi esseri umani, che il diavolo se ne frega dove
le cose sono in memoria?
Questo è del tutto arbitraria.
Sta andando a dipendere da come di RAM l'utente ha.
Sta andando a dipendere da quando nel corso della giornata si esegue il programma, forse, e
quello di ingresso l'utente che si dà.
Siamo soffermarsi su dettagli insignificanti.
>> Così astratto andiamo lontano e dire che, quando si esegue una riga di codice come questo,
char stella s ottiene il ritorno valore della stringa GET.
Perché non invece solo disegnare quello che abbiamo continuare ad invocare un puntatore come se fosse
che punta a qualcosa?
Quindi io pretendo ora che s up vi è un puntatore -
sotto il cofano è un indirizzo.
Ma è solo indicando il primo byte nel
stringa che è stato restituito.
>> Se ora torno al codice qui, quello che sta succedendo a questa linea?
Ebbene, in questa riga evidenziata ora, Sto dichiarando quanto pare un altro
variabile chiamata t.
Ma è anche un puntatore, quindi ho intenzione a disegnare come, in teoria, l'esatta
stessa scatola dimensioni.
E ho intenzione di chiamarlo t.
>> E ora se torniamo al codice nuovo, quando devo conservare dentro di s t,
cosa sono tecnicamente mettendo dentro di t?
Beh tecnicamente, questo era il numero 123.
Quindi, in realtà dovrei scrivere il numero 123 lì.
Ma Prendiamolo livello superiore.
t, se è solo un puntatore, intuitivamente, è proprio questo.
Questo è tutto ciò che viene archiviati.
>> Così ora nelle ultime righe interessanti del codice, quando io in realtà vado circa
capitalizzando il carattere zero in t, che cosa sta succedendo?
Beh, t staffa a zero è ora punta a quale personaggio, presumibilmente?
>> Si punta a h.
Perché t staffa a zero -
ricordare, questa è la sintassi vecchia. t Staffa pari a zero significa solo se t è una stringa, t
Staffa a zero significa ottenere lo zero personaggio in quella forza.
Quindi che cosa significa veramente è andare a questo array -
e sì, questo potrebbe essere 123, questo potrebbe essere 124.
Ma è tutto relativo, ricordare.
Ogni volta che si parla di un array, abbiamo il vantaggio di parlare di
relativi indici.
>> E così ora possiamo solo supporre che t staffa zero è h.
Quindi se chiamo 2 superiore su di essa, cosa che è realmente facendo è capitalizzando
la h minuscola a maiuscola H. Ma, naturalmente, ciò che è s?
Si punta alla stessa stringa maledettamente.
>> Quindi questo è tutto quello che sta succedendo in questo codice finora.
Allora, qual è allora l'implicazione?
Come possiamo risolvere questi due problemi?
Come ci confrontiamo in stringhe reali?
>> Beh intuitivamente, come sarebbe si va a confrontare due
stringhe per una vera parità?
>> Che cosa vuol dire se due stringhe sono uguali?
Chiaramente non è che i loro indirizzi sono uguale nella memoria, perché questo è un basso
dettaglio implementativo livello.
Tutti i caratteri sono uguali.
Quindi lasciatemi propongo, e mi presento in versione uno di compare.c
qui, in modo da confrontare-1.c.
>> Lasciatemi Propongo ancora ottenere un puntatore chiamato s, e conservare in esso il
valore della stringa get tornare.
Facciamo la stessa cosa con t.
Quindi, nessuna parte di codice è diverso.
Ho intenzione di aggiungere un po 'di controllo degli errori adesso.
Quindi, ora che siamo sorta di peeling indietro questo layer in CS50 di ciò che una stringa
in realtà, abbiamo bisogno di essere più anale di fare in modo che non abusino
valori non validi come nullo.
>> Così sto solo andando a controllare.
Se s non è uguale a nulla e T non pari nullo, il che significa che siamo OK.
Ottieni stringa non rovinare ottenere una di queste stringhe.
E si può forse intuire adesso, che cosa Non STR CMP presumibilmente fare?
Confronta stringa.
>> Quindi, se avete in programma java prima, questo è come il metodo è uguale al
classe string.
Ma per quelli di voi che non ha programmato prima,
questa è solo una funzione di c.
Succede a venire in una file chiamato string.h.
Ecco dove è dichiarata.
>> E stringa confronto -
In realtà ho dimenticato il suo utilizzo, ma non importa.
Ricordiamo che possiamo fare uomo, mescolare confrontare.
E questo sta per aprire la Manuale programmatori Linux.
Ed è, francamente, un po 'criptico.
Ma vedo che qui, sì.
Devo includere string.h.
>> E dice qui sotto descrizione, "il funzione di confronto di stringa confronta
le due stringhe S1 e S2. «E S1 e S2 sono a quanto pare le due
argomenti passati dentro
Non mi ricordo cosa const è, ma ora di gara -
e si può avere visto questo già quando hai utilizzato le pagine man se si
avere tutto -
quella stella char è solo sinonimo con lo spago.
>> Quindi confronta le due stringhe, S1 e S2, e restituisce un intero minore
o uguale o superiore a zero se S1 è trovato, rispettivamente, di essere
inferiore, o la partita, o essere maggiore di S2.
Questo è solo un modo di dire molto complessa Confronta stringa che restituisce
zero se due stringhe sono intuitivamente identico, carattere per
carattere per carattere.
>> Esso restituisce un numero negativo se s, in ordine alfabetico, si suppone
venire prima di t.
O restituisce un numero positivo se s dovrebbe venire dopo t
ordine alfabetico.
Quindi, con questa semplice funzione, potrebbe te, per esempio, ordinare un
mucchio di parole?
>> Quindi, in questa nuova versione, io vado di andare avanti e fare Confronto1.
Dot barra confrontare uno.
Io digito ciao in minuscolo.
Io vado a digitare ciao di nuovo tutto in minuscolo.
E per fortuna ora realizza Ho scritto la stessa cosa.
>> Nel frattempo, se digito ciao in basso caso e CIAO in maiuscolo e
confrontarli, ho digitato cose diverse.
Perché non solo sono gli indirizzi diverso, ma ci stiamo confrontando
caratteri ancora e ancora diversi.
>> Bene andiamo a fissare uno altro problema ora.
Lasciatemi apro versione uno di copia, che ora affronta
questo problema come segue.
E questo sta andando a guardare un po 'più complessa.
Ma se si pensa a cosa problema che abbiamo necessità di risolvere, spero che questo sarà
cancellare in un attimo ora.
>> Quindi questa prima linea, char inizio t, in parole povere qualcuno potrebbe proporre
cosa questa linea qui significa?
Char stella t, che cosa è che facendo?
>> Buono.
Creare un puntatore per alcuni posto in memoria.
E mi permetta di perfezionare un po '.
Dichiarare una variabile che memorizzerà il indirizzo di qualche char in memoria, basta
per essere un po 'più corretta.
>> OK, ora sul lato destro, ho mai visto una di queste funzioni
prima, malloc.
Ma che cosa potrebbe significare?
Dotazione di memoria.
Allocazione della memoria.
>> Così si scopre, fino ad ora, abbiamo non hanno davvero avuto un modo potente di
richiedendo al sistema operativo, dammi un po 'di memoria.
Piuttosto, ora abbiamo una funzione chiamata malloc che fa esattamente questo.
Anche se questo è un po 'un distrazione in questo momento, si noti che in
tra le due parentesi risulta solo andando a essere un numero.
Dove ho digitato in questione segni possono essere un numero.
>> E quel numero significa, dammi 10 byte.
Dammi 20 byte.
Dammi 100 byte.
E malloc farà del suo meglio per chiedere al sistema operativo -
Linux, in questo caso -
hey, sono i loro 100 byte di RAM disponibile?
Se è così, restituire tali byte a me da restituendo il cui indirizzo di
quei byte, forse?
Il primo in assoluto.
>> Quindi, anche in questo caso - e questo è predominante in C, ogni volta che sei
trattare con gli indirizzi?
E 'quasi sempre a che fare con la primo tale indirizzo, non importa quanto grande
un pezzo di memoria che sono in corso di restituita, per così dire.
>> Quindi Tuffiamoci qui.
Sto cercando di destinare come molti byte, esattamente?
Bene.
Lunghezza della stringa di s - ti permette di fare un esempio concreto.
Se s è ciao, H-E-L-L-O, che cosa è la lunghezza della stringa di s, ovviamente?
Quindi è cinque.
Ma io sto facendo un più 1 su quello, perché?
Perché voglio sei byte invece di cinque?
Il carattere null.
>> Io non voglio lasciare fuori questo speciale carattere null.
Perché se faccio una copia di Ciao e faccio solo H-E-L-L-O, ma non metto
tale carattere speciale, il computer potrebbero non avere, per caso, una barra rovesciata
azzerare lì per me.
E così, se sto cercando di capire il lunghezza della copia, potrei pensare che
è lungo 20 caratteri, o un milione caratteri se ho mai capita
per colpire uno zero backslash.
>> Quindi abbiamo bisogno di sei byte per memorizzare H-E-L-L-O, backslash zero.
E poi questo è solo di essere super anale.
Suppongo che mi dimentico cosa la dimensione di un char è.
Noi continuiamo a dire si tratta di un byte.
E di solito è.
In teoria, potrebbe essere qualcosa di diversa, su un altro Mac o un
PC diversi.
>> Così si scopre c'è questo operatore chiamato sizeof che se si passa il
nome di un tipo di dati - come char, o int o float -
vi dirà, in modo dinamico, come molti byte a char occupa in questo
particolare computer.
>> Quindi questo è efficace solo come volte 1 o dire
volte nulla.
Ma lo faccio solo per essere super-anal, che nel caso in cui un carattere diverso
sul vostro computer contro la mia, in questo modo la matematica è sempre andare a controllare.
>> Infine, qui posso controllare per nulla, che è sempre buona prassi - ancora una volta,
ogni volta che abbiamo a che fare con i puntatori.
Se malloc non è stato in grado di dare mi sei addii - che è
improbabile, ma nel caso in cui -
restituire immediatamente uno.
Ed ora, andare avanti e copiare la stringa come segue.
E questa è la sintassi familiare, anche se in un ruolo diverso.
>> Ho intenzione di andare avanti e ottenere la stringa lunghezza s e conservarla in n.
Sto andando poi a iterare da i è uguale a azzerare fino al n,
maggiore di o uguale a.
In modo che ad ogni iterazione, ho messo l' carattere i-esimo di s nel esimo
carattere di t.
>> Così che cosa sta realmente accadendo sotto il cofano qui?
Beh, se questo, per esempio, è s -
e ho digitato la parola H-E-L-L-O e c'è uno zero backslash.
E di nuovo, questo è s puntamento qui.
Ed ecco ora è t.
>> E questo sta puntando ora a una copia della memoria, giusto?
Malloc mi ha dato un tutto pezzo di memoria.
Non so che cosa è inizialmente in uno di questi luoghi.
Quindi ho intenzione di pensare a questi come un sacco di punti interrogativi.
>> Ma appena comincio looping da zero in su attraverso la lunghezza s, t
Staffa zero e t staffa 1 -
e metterò questa ora sulla testa -
t Staffa zero e s staffa media zero che ho intenzione di essere la copia
iterativamente h in qui, E-L-L-O. In più, perché ho fatto il più
1, barra rovesciata zero.
>> Così ora nel caso di confronto-1.c, alla fine, se stampo il
capitalizzazione delle t, dovremmo vedere che s è invariato.
Lasciami andare avanti ora e faccio questo.
Quindi, fare copy1.
Dot barra copy1.
Io vado a digitare ciao, Enter.
E ora notare, solo la copia è stato capitalizzato.
Perché io veramente ho due blocchi di memoria.
>> Purtroppo, si può fare qualche bella cattivi e piuttosto pericoloso cose qui.
Permettetemi di tirare su un esempio qui ora, che ci dà un esempio di alcuni
linee diverse.
Quindi, solo intuitivamente qui, la prima linea di codice, int x stella, sta dichiarando
una variabile chiamata x.
E qual è il tipo di dati di quella variabile?
Qual è il tipo di dati di tale variabile?
Quello non era il colpo di scena.
>> Il tipo di dati è int stelle.
Allora, cosa vuol dire? x volontà memorizzare l'indirizzo di un int.
Semplice come quello.
Y sta per memorizzare l' indirizzo di un int.
Qual è la terza linea di codice facendo lì?
E 'assegnazione quanti byte, più probabile?
Quattro.
A causa delle dimensioni di un int è generalmente quattro, malloc di quattro dà
mi restituì l'indirizzo di un pezzo di memoria, il primo byte di cui è
memorizzati ora in x.
>> Ora ci stiamo muovendo un po 'di fretta.
Stella x significa che cosa?
Significa andare a questo indirizzo e mettere ciò che numero c'è?
Mettere il numero 42 lì.
Stella y significa andare a quello che è in y e mettere il numero 13 lì.
>> Ma aspettate un minuto.
Ciò che è in y al momento?
Quale indirizzo è y memorizzazione?
Non lo sappiamo, vero?
Non abbiamo mai una volta utilizzare l'assegnazione operatore che coinvolge y.
Quindi y come dichiarato sulla seconda riga del il codice è solo un po 'di valore spazzatura, un grande
punto di domanda per così dire.
Potrebbe essere rivolta in modo casuale per nulla in memoria, che
è generalmente male.
>> Quindi, non appena ci ha colpito quella linea lì, stella y è uguale a 13, qualcosa di brutto,
qualcosa di molto brutto è circa a succedere a Binky.
Quindi cerchiamo di vedere quello che sta per finire succedendo a Binky qui in questo momento
o in modo da guardare.
>> [RIPRODUZIONE VIDEO]
>> -Ehi, Binky.
Svegliati.
E 'tempo per il divertimento puntatore.
>> -Che cosa?
Ulteriori informazioni su puntatori?
Oh, goodie.
>> -Beh, per iniziare, direi che siamo avrà bisogno di un paio di puntatori.
>> -OK.
Questo codice assegna due puntatori che può puntare a numeri interi.
>> -OK, bene, vedo i due puntatori.
Ma loro non sembrano essere che punta a nulla.
>> -Esatto.
Inizialmente, i puntatori non puntare a qualche cosa.
Le cose a cui puntano sono chiamati pointees, e la loro istituzione è un
fase separata.
>> -Oh, giusto, giusto.
Sapevo che.
Le pointees sono separati.
Così come si alloca un pointee?
>> -OK.
Beh, questo codice alloca un nuovo interi pointee, e questa parte imposta x
per puntare a esso.
>> -Ehi, che sembra migliore.
Così ne fanno fare qualcosa.
>> -OK.
Io dereferenziare il puntatore x per memorizzare il numero 42 nella sua pointee.
Per questo trucco, ho bisogno la mia magia bacchetta di dereferenziazione.
>> -La bacchetta magica di dereferencing?
Uh, che è grande.
>> -Questo è ciò che il codice è simile.
Mi limiterò a impostare il numero, e -
>> -Ehi, guarda.
Ci si va.
Quindi, facendo un dereferenziazione su x segue la freccia per accedere alla pointee.
In questo caso, per immagazzinare 42 in là.
Ehi, provare a utilizzarlo per memorizzare il numero 13 attraverso l'altro puntatore, y.
>> -OK.
Vado qui a y e Prendi il numero 13 ha istituito.
E poi prendere la bacchetta di dereferencing e basta -
Whoa!
>> -Oh, ciao.
Che non ha funzionato.
Dire, Binky, non credo che il dereferencing y è una buona idea,
Poiché l'installazione di pointee è una fase separata.
E non credo che abbiamo mai fatto.
>> -Hmm.
Buon punto.
>> -Sì, abbiamo assegnato la y del puntatore.
Ma non abbiamo mai impostiamo a puntare a una pointee.
>> -Hmm.
Molto attento.
>> -Ehi, che stai cercando bene lì, Binky.
Riesci a risolvere il problema in modo che i punti di y allo stesso pointee come x?
>> -Certo.
Userò la mia bacchetta magica di assegnazione puntatore.
>> -È che sarà un problema come prima?
>> -No.
Questo non tocca i pointees.
Cambia solo un puntatore per puntare per la stessa cosa di un altro.
>> -Oh, capisco.
Ora i punti y per lo stesso posto come x.
Quindi aspettare.
Ora y è fissa.
Ha un pointee.
Così si può provare la bacchetta di dereferencing nuovo
per inviare il 13 sopra.
>> -OK.
Qui va.
>> -Ehi, guarda un po '.
Ora dereferencing opere su y.
E poiché i puntatori sono la condivisione che uno pointee, essi
sia per vedere la 13.
>> -Già.
Condivisione.
Qualunque sia.
Quindi stiamo andando scambiano di posto adesso?
>> -Oh, guarda.
Siamo fuori tempo.
>> -Ma -
>> -Basta ricordare i tre regole puntatore.
Numero uno, la struttura di base è che si dispone di un puntatore.
E che punti verso un pointee.
Ma il puntatore e pointee sono separate.
E l'errore comune è quello di impostare un puntatore, ma a
dimenticare di dato un pointee.
>> Numero due, puntatore dereferenziazione inizia presso il puntatore e segue la sua
freccia sopra per accedere alla pointee.
Come tutti sappiamo, questo funziona solo se ci è un pointee, che torna a
regola numero uno.
>> Numero tre, l'assegnazione puntatore assume un puntatore e modifiche che per puntare a
la stessa pointee come un altro puntatore.
Così, dopo l'assegnazione, i due puntatori
puntare allo stesso pointee.
A volte che chiama condivisione.
E questo è tutto ciò che devi fare, davvero.
Bye bye ora.
>> [FINE RIPRODUZIONE VIDEO]
>> DAVID MALAN: Quindi più su puntatori, di più su Binky prossima settimana.
Ci vediamo il Lunedi.