Tip:
Highlight text to annotate it
X
>> SPEAKER 1: Ciao a tutti.
Stiamo per iniziare.
Penso che le persone sono ancora in corso da filtrare dentro
Ma nell'interesse di tempo, in modo che possiamo ottenere voi ragazzi fuori di qui in tempo,
stiamo per iniziare.
Così, benvenuto alla CS50 Quiz 0 recensione.
Per quelli di voi che non hanno capito Eppure, hai una domanda su Mercoledì.
Woo-hoo.
>> Se non hai ancora iniziato a studiare o Non hanno capito che questo esiste ancora,
quiz del passato e tutte le informazioni il quiz sono su cs50.net/quizzes.
C'è un po 'di roba abbastanza buona in là, quiz ultimi degli ultimi 10
anni nonché informazioni su questo quiz e gli argomenti
che saranno coperti.
Quindi cerchiamo di iniziare.
>> Quindi voi ragazzi potrebbe ricordare, la prima giorno di lezione David ha avuto queste lampade su.
Quindi, in sostanza, tutto ciò che va sotto il cofano di un computer è
fatto in binario.
Binary significa quello che sembra come, 0 e 1 di.
Essa ha due valori che può essere rappresentato.
>> Così come nel primo giorno di sezione quando David acceso una luce
lampadina a rappresentare su, o 1, il nostro computer capisce come binario 0 e
1 di, acceso o spento.
Nozioni di base di Binary.
Ogni luogo è rappresentata in base due.
Quindi si aggiunge 2 al 0 al 1 alla 2 tutta la strada fino.
>> Per calcolare ciò che il binario è a decimale, basta seguire questa equazione
tipo cosa.
Se avete un 1 in uno qualsiasi di questi luoghi, si moltiplica per qualunque
basare che è, inserirlo, e si ottiene il decimale.
Quindi questo è come si conta a 5 in binario.
Proprio come quello che stavamo facendo sul ultima diapositiva, questo è come si farebbe
rappresentare da 1 a 5.
>> Allo stesso modo, proprio come è possibile aggiungere e sottrarre in decimale o base 10, o
davvero qualsiasi base, il grado di aggiungere e sottrarre in binario.
Esattamente quello che ci si aspetta quando si aggiungere i due su, se è uguale maggiore
di 1, si portano a 1, fanno un 0, e fare l'aggiunta che modo, basta
come ci si aspetterebbe, con regolare decimale o qualsiasi altra base.
Freddo.
>> Così come ho detto prima, tutto ciò che va sotto il cofano del nostro computer
avviene in 0 e di 1, o binario.
Così come esprimiamo, per esempio, lettere o numeri o caratteri?
E la risposta è ASCII.
>> ASCII è un mapping tra i caratteri che avremmo normalmente vedere nel
Lingua inglese come A, il B di, C di, sottolineano, trattini, e
qualcosa di simile.
E le mappe che, per un valore ASCII.
Un valore ASCII è solo un numero che può essere compreso dal computer.
E proprio come si può fare addizioni e sottrazione con i numeri, si può fare
loro con valori ASCII.
>> Quindi, in questo esempio, ciò sarà questo stampare?
Sì, così solo uno spazio space B space C D. Dove ha il mio mouse andare?
Si noti che si può definire un int a 65.
E quando si stampa che utilizzando cento C, sarà interpretare che come un
carattere e stamperà A.
>> Allo stesso modo, è possibile dichiarare come un char.
E quando si stampa utilizzando per cento C, sarà interpretare che, come
cento D. E proprio come è possibile aggiungere un numero, è possibile aggiungere i personaggi sono
Valori ASCII, in questo caso.
>> Quindi un po 'di puntatore per tutti.
5, come una stringa, non effettivamente uguale 5.
Così come potremmo convertire il stringa 5 al numero intero 5?
Tutte le idee?
Già.
>> Quindi, se abbiamo 5 come una stringa, possiamo sottrarre 0.
E che ci darà 5.
E allo stesso modo, se abbiamo 5 come integer, aggiungere che alla stringa 0.
E che ci dà la stringa 5.
Freddo.
>> Ora, ricordo torna a lezione da quello in cui abbiamo parlato di algoritmi.
Quindi, come possiamo effettivamente vogliamo un computer per fare cose interessanti?
Sai, solo aggiungendo e sottraendo numeri e cose da stampa fuori non è
così eccitante.
Di solito, vogliamo che il nostro computer per eseguire qualche tipo di algoritmo.
Qualcosa di un po 'più complessa di una semplice aritmetica.
>> Un algoritmo è solo un passo per passo insieme di istruzioni su come eseguire
un determinato compito -
proprio come una ricetta.
Si potrebbe ricordare il primo giorno di classe in cui David ci aveva contare una camera
di persone e quante persone erano in camera.
Si potrebbe essere utilizzato per il conteggio uno per uno.
1, 2, 3, 4.
In tal caso, un algoritmo tempo lineare.
>> Ma David illustra un algoritmo per di contare le persone in sala
dove ognuno si alza in piedi, dici la tua numero ad un altro soggetto, aggiungere che
numero fino, e una persona si siede.
E si ripete quello.
Questo è un tipo di algoritmo.
Possiamo analizzare quanto sia efficiente un algoritmo si basa su di essa la fase di esecuzione.
Ma parleremo un po ' parleremo più avanti.
>> Quindi, tutti gli algoritmi possono anche essere scritto in pseudocodice.
Pseudocodice è solo un inglese come sintassi utilizzata per rappresentare
un linguaggio di programmazione.
Ad esempio, se volessimo chiedere all'utente di indovinare il mio numero preferito, abbiamo
potrebbe avere pseudocodice come tali.
>> Ricevi un utente indovinare.
Se l'ipotesi è corretta, dire loro siano corrette, altrimenti dire loro
non sono corrette.
E pseudocodice è un modo di facile che rappresenta un'idea o un algoritmo.
Così ora potremmo voler effettivamente scrivere questo nella lingua che il computer
potrebbe capire.
Così potremmo scrivere il nostro pseudocodice e interpretare che in codice sorgente.
>> Finora, codice sorgente deve aderire ad un certo sintassi
un linguaggio di programmazione.
E finora, in CS50, abbiamo state utilizzando per lo più c.
Quindi questo potrebbe essere il codice sorgente per il c.
Più tardi nel corso, la notte arriva in contatto con altri programmazione
linguaggi come PHP.
O se ancora di prendere altre classi, voi potrebbe fare Java, Python, o anche OCML.
Ma nel nostro linguaggio di programmazione C, questo è come potremmo scrivere il codice sorgente per
l'algoritmo pseudocodice che Ho appena descritto in precedenza.
>> Così come fa il computer effettivamente capire che?
Come ho detto prima, è veramente solo capisce zero e uno.
Così come si ottiene dalla sorgente codice di qualcosa che può essere
capito?
Beh, abbiamo qualcosa chiamato un compilatore.
>> Se vi ricordate indietro nel maggior parte del vostro pset, hai avuto qualche tipo di programma
scritto in un file dot c.
E poi digitare make.
Così che cosa è fa fare?
>> È possibile digitare make per compilare il programma perché qualcuno -
chi ha scritto il vostro p set; Probabilmente David -
creato un make file.
E che racconta far conoscere per eseguire il compilatore, chiamato clang, che la volontà
quindi compilare il codice sorgente per oggetto codice, che è zero e uno
che il computer capisce.
Ma un po 'più tardi, andremo più in profondità su compilatori.
>> Quindi ricordare pset 0, dove - sì, hai una domanda?
>> AUDIENCE: [incomprensibile]?
>> SPEAKER 1: sì.
Penso che in realtà dovrebbe essere online.
Già.
>> PUBBLICO: E 'come [incomprensibile]?
>> SPEAKER 1: Non è.
Non sono in cs50.net/quizzes.
>> AUDIENCE: Slash quiz, tagliare il 2013, tagliare 0, e basta cliccare attraverso
quiz 2013 e quiz 0, rivedere la sezione diapositive.
>> SPEAKER 1: Sì, così se voi ragazzi volete tirarlo su e guardare sul vostro
proprio computer, va bene anche.
Dire ancora una volta che.
>> AUDIENCE: [incomprensibile].
>> SPEAKER 1: Sì, [incomprensibile] è la variabile dummy.
Ah, sì?
>> AUDIENCE: [incomprensibile]?
>> SPEAKER 1: No, scioperi non sono in esame.
Siamo spiacenti, la sua domanda era stata scioperi l'esame.
E non è.
Così pset 0, voi ragazzi dovrebbe avere tutti implementato qualcosa usando zero.
E abbiamo imparato un po 'di programmazione di base blocchi utilizzando zero.
>> Quindi, diamo uno sguardo ad alcuni di questi blocchi
che compongono un programma.
Il primo è espressione booleana.
Espressioni booleane sono quelli e 0 di o qualsiasi cosa che ha
due valori possibili.
In questo caso, vero o falso, on o off, e sì o no.
Un esempio di una semplice, molto semplice, programma che utilizza un booleano
espressione qui.
>> Quindi, al fine di espressioni booleane per essere utile, abbiamo operatori booleani.
Si tratta di operatori che possono essere utilizzati confrontare certi valori.
Così abbiamo e non o uguale a meno o uguale a, maggiore o
uguale, e meno o superiore.
Ma questi operatori non sono molto utili a meno che non li possiamo combinare in
condizioni.
>> Quindi voi ragazzi potrebbe ricordare da zero e verso il p imposta che
avuto condizioni.
Essi sono, essenzialmente, come forchette la logica del programma che
esegue a seconda che una condizione è soddisfatta.
Così una delle condizioni che avevamo usato molte volte in questo corso è la
if, else, se le condizioni, e altro.
>> Ecco un esempio di come si potrebbe usare quella.
Qualcuno sa la differenza tra usando solo se le dichiarazioni tutti
il modo in versi giù if, else, se, e altro combinato?
Sì?
>> AUDIENCE: [incomprensibile].
>> SPEAKER 1: Esattamente.
Quindi, se ho avuto, se fino in fondo questa modo, anche se la condizione ritorna
vero, continuerà ancora testare i due successivi.
Considerando che, con un altro-se, un altro dichiarazione, se quello restituisce true,
gli altri non sono testati.
Hai domande su questo?
Freddo.
>> Quindi si utilizza un altro, se-di un altro dichiarazione se si sa che può solo
uno di questi casi.
Così sappiamo se x è minore di 0, è sicuramente non sta per essere
maggiore di 0.
>> Successivamente, un altro mattone che abbiamo imparato siamo loop.
Abbiamo tre tipi di cicli.
Per i cicli, cicli while, e fare while.
E, in generale, quando ci si siede a scrivere qualcosa, si deve decidere
quale dei tre che si desidera utilizzare.
Quindi, come facciamo a decidere quale?
>> Generalmente usiamo un ciclo for se sappiamo quante volte vogliamo iterare
attraverso qualcosa o quante volte vogliamo eseguire un compito.
Usiamo i cicli while, se abbiamo bisogno di qualche condizione di essere fedeli a continuare a correre.
E usiamo fare, mentre molto simile a mentre, ma vogliamo che il nostro codice di funzionare a
almeno una volta.
>> Quindi fare mentre, tutto ciò che è nel fare la volontà eseguito sempre almeno una volta.
Considerando che, con il tempo, si potrebbe non funzionare affatto se il
condizione non è soddisfatta.
Tutte le domande con quella?
>> Quindi la struttura di un ciclo for.
Voi ragazzi avete visto tutti questo.
Si inizializzato.
Avete qualche tipo di condizione.
Così, per esempio, potremmo inizializzare per quanto riguarda i è uguale a 0.
i è inferiore a 10.
E i + +.
Uno molto semplice che abbiamo fatto.
>> Per un ciclo while, allo stesso modo, si ha avere un qualche tipo di inizializzazione,
qualche tipo di condizione, e qualche tipo di aggiornamento.
Così possiamo implementare il nostro ciclo for anche come un ciclo durante l'utilizzo di questo.
E allo stesso modo con un do while, potremmo avere qualche inizializzazione,
eseguire qualcosa, aggiornarlo, e quindi controllare la condizione.
>> Così ora funzioni.
Abbiamo messo insieme tutto.
Potremmo voler scrivere qualche tipo di funzione.
Funzione comune che si potrebbe hanno visto già è principale.
Principale è una funzione.
Ha un tipo di ritorno, int.
Ha un nome di funzione, principale.
E ha argomenti argc e argv.
Quindi principale è solo una funzione.
>> Altre funzioni eventualmente utilizzate, printf - printf è una funzione -
GetInt, toupper.
Ma questi capita di essere stato attuata per noi da
qualche tipo di libreria.
Se voi ragazzi ricordare compreso questa biblioteca CS50.h o il
libreria di I / O standard.
Sì, in discussione?
>> AUDIENCE: è il principale appena inerente c?
Lo fa solo tipo di [incomprensibile]?
>> SPEAKER 1: La domanda è se principale è inerente c.
E sì, tutte le funzioni avere una funzione principale.
È genere necessario al computer sapere da dove cominciare
l'esecuzione del codice.
>> AUDIENCE: Quindi non sarebbe [incomprensibile]?
>> SPEAKER 1: No.
Tutte le altre domande?
Freddo.
Così come è possibile utilizzare una funzione che è scritto per te, è anche possibile
scrivere la propria funzione.
Questa è una funzione che qualcuno potrebbe hanno scritto per calcolare il volume
di un q, per esempio.
C'è un tipo di ritorno qui, in questo caso, int, il nostro nome e la nostra funzione q
elenco di parametri.
>> E notare che si deve scrivere i dati tipo di parametro che si desidera
utilizzare altrimenti la funzione non sapere che tipo di
parametro dovrei essere accettare.
Quindi, in questo caso, vogliamo un intero come nostro ingresso.
Allora perché potremmo desiderare di utilizzare le funzioni?
>> Prima di tutto, ottimo per l'organizzazione.
Aiutano a spezzare il codice in più organizzata pezzi e fare
più facile da leggere.
Semplificazione.
Questo è un bene per il design.
Quando stai leggendo un pezzo di codice e la funzione principale è veramente,
davvero lunga, potrebbe essere più difficile da ragionare su quello che sta succedendo.
Quindi, se si scomposizione in funzioni, potrebbe essere più facile da leggere.
E il riutilizzo-abilità.
Se hai un pezzo di codice che viene chiamato o eseguire più volte,
Invece di riscrivere quel codice 10 volte nella funzione principale, si potrebbe
voglia di riutilizzarlo.
E poi ogni volta che avete bisogno di usare quel pezzo di codice, chiamare la funzione.
>> Così ora se ci ricordiamo di nuovo a zero, abbiamo anche parlato di alcuni concetti,
uno dei quali è filettatura.
La discussione è il concetto di molteplici sequenze di codice
esecuzione allo stesso tempo.
Quindi, pensare di nuovo al giorno in cui David ha avuto voi conterete il numero di
persone nella stanza.
>> In sostanza, che cosa stava succedendo è su tutti voi ragazzi erano
esecuzione di thread separati.
E quei fili stavano arrivando insieme di ottenere qualche tipo di risposta.
Allo stesso modo, in Scratch, quando si ha più sprites, si potrebbe
avere un gatto e un cane.
E sarebbero contemporaneamente correre i propri script.
Questo è un esempio di filettatura.
>> E l'altro concetto che è stato introdotto nel scratch è stato eventi.
E quando gli eventi sono più parti di il codice di comunicare con l'altro.
In Scratch, questo è stato quando è stato utilizzato il trasmesso controllo e il Quando
Ricevere blocchi.
>> E anche, nel set Problema 4, abbiamo visto un po 'di eventi così.
Voi ragazzi avrebbe potuto usare biblioteca Gevent.
E c'era una funzione waitForClick in cui stavate aspettando
per l'utente di cliccare.
E il clic, in questo caso, sarebbe l'evento e attendere per click è il tuo
gestore di eventi.
>> E anche, in tutta esecuzione i pset e lavorando sul vostro pset, è
potrebbe venire a contatto con alcuni di questi comandi.
Questo è ciò che hai digitato nella vostra finestra di terminale o qualunque finestra
che mostra sul vostro g di modifica a, in sostanza, passare il computer.
>> Così, per esempio, LS elenca l' contenuto di una directory.
Fai directory creata una nuova cartella.
CD, change directory.
RM, rimuovere, cancella un file o qualche directory.
E poi rimuovere la directory rimuove una directory.
>> AUDIENCE: [incomprensibile]?
>> SPEAKER 1: Sì, certo.
Spiacenti, la domanda era se si suggerirebbe mettere questo
sul foglietto.
Potrebbe aiutare.
Se avete spazio, si può mettere su.
E 'anche solo generalmente abbastanza buono da ricordare perché quando lo si utilizza
si potrebbe desiderare di appena lo hanno memorizzato.
Questo renderà la vita molto più facile.
Ho risposto alla tua domanda?
>> Così ora, abbiamo parlato un po ' brevemente librerie.
Ma i due principali che siamo stati utilizzando finora in corso sono
I / O e CS50 standard.
Che tipo di cose sono inclusi nella libreria di I / O standard?
>> Sì, finora abbiamo usato printf.
In CS50, abbiamo usato GetInt e GetString.
E la stringa tipo di dati avviene anche essere dichiarati in questa biblioteca CS50.
Parleremo un po 'più a fondo come le biblioteche funzionano e come
interagire con il resto del codice.
Ma quelli sono i due principali che noi sono venuti a contatto con finora
corso.
>> Tipi.
Questi sono buoni per ricordare quanto ogni tipo è rappresentato da o come
molti byte ciascuno di tipo richiede -
int 4 byte, char, 1 byte.
Float è 4 byte.
Che cosa è un doppio?
>> AUDIENCE: [incomprensibile].
>> SPEAKER 1: Sì, quindi un galleggiante ma raddoppiare le dimensioni.
Che dire di un tempo?
>> AUDIENCE: [incomprensibile].
>> SPEAKER 1: OK.
Che cosa è un lungo?
>> AUDIENCE: [incomprensibile].
>> SPEAKER 1: Sì, doppio int.
Sì.
>> AUDIENCE: [incomprensibile].
>> SPEAKER 1: Lungo [incomprensibile].
E poi un lungo lungo è il doppio.
>> PUBBLICO: No, no.
Un lungo è solo un int.
Essa dipende dall'architettura prima che il [incomprensibile]
e int hanno la stessa dimensione.
[Incomprensibile].
>> SPEAKER 1: Quindi un lungo e un int sono gli stessi.
E poi un lungo lungo è il doppio del int.
Freddo.
E allora, qual è l'ultimo tipo?
>> AUDIENCE: Pointer.
>> SPEAKER 1: Sì, così abbiamo imparato un po 'di puntatori.
E indipendentemente da ciò che un puntatore è indicando - potrebbe essere una stella char
o un int stella -
è sempre 4 byte per un puntatore.
Domande su questo?
Sì?
>> AUDIENCE: [incomprensibile]?
>> SPEAKER 1: Quindi un lungo e un int sono lo stesso in questo apparecchio CS50.
>> PUBBLICO: L'apparecchio sono completamente intercambiabili.
>> SPEAKER 1: Già.
Allora un lungo lungo è il doppio un int.
>> AUDIENCE: Questa è la 32 bit?
>> SPEAKER 1: 32 bit, sì.
>> AUDIENCE: Così [incomprensibile]?
>> SPEAKER 1: Sì, se non esplicitamente dici,
dovrebbe assumere un po '32.
>> AUDIENCE: Sarebbe dire qualcosa come nell'ipotesi di un
all'architettura come l'apparecchio.
Per 64 bit, le uniche cose che cambiamento sono lunghi e puntatori.
Entrambi [incomprensibile].
>> SPEAKER 1: Sì?
>> AUDIENCE: Domanda.
Così su uno dei quiz di pratica, si chiede un unsigned int.
Così come vorrei che essere determinato da un int [incomprensibile]?
>> SPEAKER 1: Un unsigned in è anche 4 byte.
Ma che cosa è diverso su un firmata int e unsigned int?
>> AUDIENCE: [incomprensibile].
>> SPEAKER 1: Giusto.
Si può rappresentare valori negativi.
Ma come fa a farlo?
>> AUDIENCE: [incomprensibile].
>> SPEAKER 1: Sì, salva 1 bit per rappresentare il segno.
Il sottoscritto ha un bit che rappresenta il segno.
E unsigned solo è tutti positivi.
>> AUDIENCE: OK.
Quindi lei dice che una doppia è il doppio di un galleggiante?
>> SPEAKER 1: Double è due volte le dimensioni di un galleggiante, sì.
>> AUDIENCE: Come fa un puntatore per un lungo lungo [incomprensibile]?
>> SPEAKER 1: Quindi la domanda è come fa il puntatore di un lungo lungo -
come è che solo quattro byte quando un tempo lungo i suoi 8 byte.
Quindi ricorda che cosa è un puntatore, in sostanza, al valore base molto.
>> AUDIENCE: [incomprensibile].
>> SPEAKER 1: Sì, così un puntatore è solo una locazione di memoria.
Quindi non importa quanto spazio che il puntatore sta puntando.
Ha solo bisogno di 4 byte per tenere traccia di quella posizione di memoria.
Tutte le altre domande?
Freddo.
>> Quindi l'ultima cosa che ho è uscita standard.
Si consiglia di usarli frequentemente sufficiente che si può ricordare.
Ma questo è quando usiamo printf, per esempio.
E abbiamo questi segnaposto sono stati chiamati codici di formato.
>> Quindi per cento c char, cento i per int, e possiamo anche usare per cento d.
E 'la stessa cosa.
Ma, in generale, in CS50 noi provare a utilizzare per cento i.
Percentuale f per float.
Percentuale ld per molto tempo e cento s per stringa.
>> Allo stesso modo, abbiamo usato un paio di di queste sequenze di escape.
Ad esempio, backslash n per la nuova linea.
Questo è solo per quando si sta formattando il codice per la stampa f.
Sì?
>> AUDIENCE: Qual è la percentuale d per?
>> SPEAKER 1: Quindi la domanda è ciò che è cento per d?
Percentuale d è per int.
D cento e cento i sono uguali.
>> AUDIENCE: Qual è la differenza tra backslash n e backslash r?
>> SPEAKER 1: Quindi la domanda è: qual è il differenza tra contraccolpo n e
reazione r?
Penso backslash r è -
>> AUDIENCE: r Così backslash implica solo ritorna all'inizio della linea
senza realmente andare ad una nuova linea.
Quindi, se si stampa un backslash r e tornare all'inizio della riga
allora si stampa più roba, si sovrascrive la roba che è già sul
[Incomprensibile].
Considerando che, n realtà va a un nuovo linea e va a [incomprensibile].
>> SPEAKER 1: Beh, tutte le altre domande?
Bene.
Ho intenzione di darlo ad Dan che continuerà.
>> [Applausi]
>> DAN: Tutto righty.
Così sarò parlando di un altro livello gamma di idee dalla classe che sono
circa rappresentante della settimana due e l'inizio di tre settimane partendo
con il casting, che è solo un modo di trattamento di un valore di un certo tipo
un valore di tipo diverso.
Così possiamo fare questo con caratteri a interi, galleggianti a int, e
long long per raddoppiare.
>> Tutte queste cose possono essere usati come modi di trattare un certo valore numerico
meno char come qualche altro valore numerico.
Quindi ci sono alcuni problemi con questo, di Naturalmente, che viene quando si esegue il cast
cose come float a int.
Quindi questo è un po 'strano.
Abbiamo un float che è 1,31.
Ci moltiplichiamo per 10.000.
E poi stampiamo come un int.
Cosa fa questa uscita?
10.000 volte 1.31.
Quindi 13.000, è che la congettura?
>> PUBBLICO: Penso che sia 10.000.
>> DAN: Così sto moltiplicandolo per 10.000 prima che io sto cast.
>> AUDIENCE: Oh.
Non ci sarebbe un 9 e alcune 0 numeri?
>> DAN: si potrebbe avere alcune cifre strane.
Quindi a destra, è 1,3 volte 10.000.
Ecco, questo è 13.000.
E questo extra strano -
>> PUBBLICO: 13.100.
>> DAN: 13.100.
Grazie, Rob.
E questa stranezza in più -
questo 9,9 -
è semplicemente perché questo casting finito arrotondamento dove
non dovrebbe avere.
Già.
>> PUBBLICO: Il casting avviene dopo qualcos'altro?
>> DAN: Allora, perché ho questo in stampa, funziona la moltiplicazione prima
fa questo casting.
>> AUDIENCE: [incomprensibile].
>> DAN: Penso che sarebbe gettato in primo luogo, sì, che sarebbe 10.000.
Qualcos'altro?
Freddo.
Quindi questo è 13.099.
Perché accade questo?
Imprecisione.
>> I galleggianti non sono perfetti.
Essi possono rappresentare solo numeri per un certo numero di cifre significative.
Quindi, se stampiamo su 8 fichi sig su questo galleggiante, si ottiene una sorta di
brutto numero guardando.
E questo perché non si può con precisione 1.31 essere rappresentate da semplici
potenze di due in macchina.
Così si finisce per prendere la più vicina indovinare, che finisce
essendo un po 'bassa.
Dare un senso?
OK.
>> Ora, passati sono un modo diverso di facendo istruzioni condizionali dove tutti
ci preoccupiamo è una singola variabile.
Quindi, in questo particolare esempio, siamo ottenere un numero intero da parte dell'utente.
E poi stiamo guardando che cosa intero è.
Presumibilmente, il suo numero tra uno e quattro.
Questo è quello che stiamo chiedendo.
>> Così si fa un interruttore di il nome della variabile.
Poi si imposta casi di possibile Valori che potrebbe essere.
Così caso uno, dicono che è basso.
E poi si rompe di uscire della condizione interruttore così
non andare avanti.
>> Nel caso successivo -
così caso due e tre casi -
se è caso due appena scende a la prima riga di codice che considera con
maiuscole e tre fino a quando non vede una pausa.
Quindi la ragione si arriva caso uno di solo a partire stampa è perché io
avere questa pausa qui.
Se io, per esempio, ignorato questa rottura - se ho buttato questo breakaway -
sarebbe stampare basso, e allora sarebbe la stampa di mezzo, e poi si spezzerebbe.
>> Così le pause sono una parte importante di cambiare le condizioni e
dovrebbero essere lì.
I casi che non sono esplicitamente sono gestiti dal predefinita
Caso in switch e deve essere gettato.
>> AUDIENCE: Allora 1, 2, 3, e 4 sarebbero n?
>> DAN: Valori che possono essere n.
Sì.
Sì?
>> AUDIENCE: Quindi, quando si ha che [incomprensibile]?
>> DAN: Si potrebbe stampare basso, e quindi sarebbe la stampa di mezzo, e
poi si spezzerebbe.
>> AUDIENCE: Perché sarebbe stampare mezzo se [incomprensibile]?
>> DAN: Quindi tutto sotto un caso prima di una pausa rientra.
Così caso si stampa è caso sotto uno come è il seguente stampa.
Sì?
>> AUDIENCE: [incomprensibile]?
>> DAN: Quindi questo numero è solo un particolare valore che questa variabile
può prendere, giusto?
Ritiene che senso?
Già.
>> AUDIENCE: [incomprensibile]?
>> DAN: Sì, caso due sarebbe stampare centro e poi rompere.
>> AUDIENCE: [incomprensibile]?
>> DAN: Penso che qualsiasi?
Quali altri tipi di dati si può passare?
>> PUBBLICO: È possibile passare più di qualsiasi tipo di dati.
Ma significa solo nulla più caratteri e int e cose del genere, perché
Se stai passando sopra un puntatore che in realtà non ha senso,
commutazione di carichi, se non addirittura permesso di fate che, a causa di virgola mobile
in precisione, si farebbe in realtà non voglia di farlo comunque.
Quindi praticamente, solo int e caratteri e cose del genere.
>> DAN: Sì, è quando hai esplicito I valori che si sa, credo, possono essere
che il sensore è effettivamente utile.
Buono?
OK.
>> Scope è l'intervallo che un dichiarato variabile si estende.
Quindi, in questo piccolo pezzo di codice che ho, sarebbe pieno di errori.
E il motivo è che ha dichiarato questo int i nell'ambito di questo ciclo for.
E poi sto cercando di riferimento che i di fuori di tale portata per ciclo.
>> Quindi, fondamentalmente, si può pensare di applicazione come tutto ciò che si dichiara
con al suo interno una serie di parentesi graffe solo esiste all'interno di queste parentesi graffe.
E se si cerca di utilizzare tale variabile al di fuori di quelle parentesi graffe, ti
un errore del compilatore.
Sì?
>> AUDIENCE: Quindi questo non funziona?
>> DAN: Questo non funziona, sì.
Strings.
String a char *.
Sono esattamente lo stesso.
Sono solo puntatori a caratteri.
E tutte le stringhe che avete dovrebbe terminare con backslash zero, che è solo
una convenzione c.
>> Si chiama terminatore NULL.
E NULL -
capitale N, U capitale, il capitale L, L maiuscola -
non è lo stesso del Terminatore NULL.
Questo è un puntatore.
Questo è un carattere.
Essi sono molto distinte.
Ricordalo.
Sarà il quiz, probabilmente.
Non ho visto il quiz.
Sì?
>> AUDIENCE: Così NULL è, diciamo, il puntatore?
>> DAN: sì.
>> AUDIENCE: Cosa fa [incomprensibile]?
>> DAN: Se, per esempio, malloc viene chiamata quando si non hanno memoria sufficiente per ottenere
qualsiasi dimensione che stai chiedendo, malloc ritorna NULL.
E ', fondamentalmente, ogni volta che una funzione è suppone per restituire un puntatore, è
necessario verificare contro NULL perché NULL è abbastanza buono -
è, una sorta di, il valore spazzatura.
E 'uno zero per quanto riguarda puntatori andare.
>> Ogni volta che si chiama una funzione, che restituisce un puntatore.
Stai andando a voler verificare di essere Assicurarsi che tale puntatore non è NULL
perché NULL è molto comune.
E 'una sorta di ritorno spazzatura.
Quindi, se qualcosa non è andato bene, semplicemente restituire NULL invece.
>> AUDIENCE: [incomprensibile]?
>> DAN: Sì, ed è questo.
>> AUDIENCE: [incomprensibile]?
>> DAN: Spell come questo.
E 'il terminatore NULL.
E 'minuscolo N-U-L-L se stai ortografia esso.
>> PUBBLICO: E ho appena andato indietro e testato.
E se si tenta di mettere una virgola mobile valore in un interruttore, che sarà urlare a voi
dicendo, dichiarazione richiede espressione di tipo integer.
>> DAN: Ci si va.
Ma sì, qual era la domanda?
>> AUDIENCE: [incomprensibile]?
>> DAN: Così capitale N, U capitale, il capitale L, L maiuscola è un vero e proprio c cosa.
E 'il puntatore NULL e la volontà essere trattati solo come tali.
Non sarà mai cercare di precisare la Carattere NULL e vedere qualsiasi
altra via che questa.
Sì?
>> AUDIENCE: Quindi tornando a char max o qualcosa nelle note, è vero
incarnano la stessa funzione come [incomprensibile]?
>> AUDIENCE: Così ti riferisci ritorno char max da getchar, o
qualunque essa sia?
>> AUDIENCE: Già.
>> PUBBLICO: Sì, così il generale termine per tutte quelle cose
sono valori sentinella.
Così come ritornare int max da GetInt e char max da getchar, è
dovrebbe essere come, tutto bene, se queste cose stanno tornando a noi,
qualcosa è andato storto.
>> Per i puntatori, dobbiamo solo capita di avere questo valore sentinella che tutti
concorda.
E questa è la cosa che si torna quando le cose vanno male.
Max Così char è quello che stiamo usando rappresentare qualcosa
come NULL o getchar.
>> AUDIENCE: Quindi, se si sta testando getchar, potrebbe solo mettere NULL?
Vorrei che fare la differenza?
>> DAN: Non potevi controllare NULL.
Dovreste controllare max char perché il valore restituito dalla funzione è
un personaggio non un puntatore.
Sì?
>> AUDIENCE: Questa domanda si chiede per la lunghezza della stringa.
Ritiene che includono il carattere NULL?
>> DAN: No.
E questo è in realtà come la lunghezza della stringa sa di fermarsi perché passa attraverso
l'array di caratteri fino vede un carattere NULL.
E poi è come tutti a destra, ho finito.
>> AUDIENCE: [incomprensibile] cinque?
>> DAN: Ciao sarebbe cinque.
Yep.
Così array sono continue blocchi di memoria.
Essi hanno accesso immediato pronunciando il nome della matrice e poi, in riccio
bretelle, qualunque sia l'indice che si desidera andare a, sono indicizzati da zero attraverso
la lunghezza della matrice meno 1.
>> E sono dichiarati dal tipo di cosa che stai memorizzare nella
matrice, il nome della matrice, e poi qualunque sia la dimensione è di tale matrice.
Quindi questo è un array di caratteri di lunghezza sei che ha questi valori.
Sì?
>> AUDIENCE: [incomprensibile]?
>> DAN: Già.
>> AUDIENCE: [incomprensibile]?
>> DAN: Se si dispone di ciò che sta accadendo nella già fatto la matrice.
Così si potrebbe specificare questo invece come, dire, char, qualunque sia il nome del vostro
array è, parentesi vuote uguale a riccio brace H virgola e virgola L virgola L virgola
Carattere O virgola NULL e la parentesi graffa.
Che sarebbe anche funzionare come una dichiarazione.
>> AUDIENCE: [incomprensibile]?
>> DAN: Allora avete bisogno di avere la dimensione già fatto.
>> AUDIENCE: [incomprensibile]?
>> DAN: sì.
Tutti righty.
Argomenti della riga di comando sono un modo di ricevendo input dall'utente come
argomenti di principale.
Principale accetta due argomenti.
Il numero di argomenti che si sta passato lungo la linea di comando e una
vettore stringa o un array di stringhe di tutti gli argomenti.
>> Quindi se io, per esempio, chiamai una funzione come Un punto fuori 1 posto, 2 space, tre,
argc sarebbe 4.
E il argv 0 sarebbe un punto fuori.
Argv1 sarebbe 1.
argv2 sarebbe 2. argv3 sarebbe 3, in questo caso particolare.
Sì?
>> AUDIENCE: [incomprensibile]?
>> DAN: L'ultimo elemento dell'array perché la matrice è la lunghezza argc più
uno dei argb, l'ultimo elemento è il puntatore NULL.
E 'argc più 1.
Quindi, nel caso che ho appena detto, sarebbe argv 0 è un punto fuori.
argv 1 è 1. argv2 è 2. argv 3 è 3.
argv 4, che è una grande di argc sarebbe NULL.
>> E questo è il puntatore NULL.
Sì.
E questo perché stringa è una stella char è un puntatore.
Quindi deve essere dello stesso tipo.
Sì?
>> AUDIENCE: Due domande.
Allora uno, qual è la differenza tra questo e GetString diverso da un tipo
nel motore uso?
E due, viene memorizzato all'interno la memoria recente?
Così come, GetString sarebbe essere [incomprensibile]?
>> DAN: Dove è memorizzato?
Non so da dove sono archiviati.
>> PUBBLICO: Quindi, in realtà, si sa come qualsiasi funzione a cui avete Call It di argomenti
sono memorizzati nello stack?
Così argc e argv sono argomenti principali e sono in pila, o realmente
appena sopra quello che pensi come l'inizio della pila.
Qual è stata l'altra parte della questione?
>> AUDIENCE: Che cosa è il [incomprensibile]?
>> DAN: Sì, è solo un modo diverso di avere un input da parte dell'utente.
Questo suo leggermente più efficiente e è più maneggevole per gli script, perché si
può solo passare gli argomenti al tuo principale funzione piuttosto che dover attendere
per gli utenti, se non si dispone di alcun utente.
>> PUBBLICO: E sì, ottenere stringhe sarebbe [incomprensibile].
Sarebbe memorizzare le cose avete bisogno.
>> DAN: Sì?
>> AUDIENCE: [incomprensibile]?
>> DAN: Sì, argv 0 include sempre il barra puntino della chiamata di funzione.
Sì?
>> AUDIENCE: [incomprensibile]?
>> DAN: Sì, tutti gli argomenti sono conclusa nel carattere NULL perché
sono stringhe.
>> AUDIENCE: [incomprensibile]?
>> DAN: Sì, argv argc è un puntatore NULL.
>> AUDIENCE: [incomprensibile]?
>> DAN: Oh yeah.
Sì, mi dispiace.
>> AUDIENCE: Così [incomprensibile]?
>> DAN: Quindi la domanda è se avete avuto la linea di punti di comando ridurre drasticamente un puntino su 1, 2,
sarebbe il numero di riga di comando argomenti siano due o sarebbe tre?
>> PUBBLICO: Penso che non lo fa molta importanza.
Io tendo a dire, oh, hai non passa eventuali argomenti della riga di comando quando,
ovviamente, hai chiamato la funzione.
Quindi tendo ad escludere vocalmente l' funzione dalla riga di comando
argomenti anche se è incluso in argv.
>> DAN: Ma se era sul test -
sì - e anche se dici qualcosa come uguale argc 3,
sei in piedi al sicuro.
Sì?
>> AUDIENCE: [incomprensibile]?
>> DAN: Penso che se invece di chiamare questo in argc e argv stringa staffe
ma mantenuto gli stessi tipi e appena chiamato loro qualcosa di diverso come un
e b, sarebbe ancora funzionare?
E sarebbe ancora funzionare, si sarebbe solo -
invece di usare argc - usereste a e b.
Sì?
>> AUDIENCE: [incomprensibile]?
>> DAN: Quindi la domanda è GetString è andando a conservare la memoria nella heap
perché GetString è char *.
Memorizza memoria nel mucchio perché chiede ora malloc entro l'attuale
attuazione di GetString.
OK, andare avanti.
>> Sicurezza.
Quindi, per essere veramente sicuro, si basano su alcun uno e permettete che nessuno l'accesso a qualsiasi
delle vostre informazioni, che è il motivo per ognuno costruisce le proprie macchine,
propri sistemi operativi, tutti i loro programmi da zero, e ovviamente
non collegare a qualsiasi altre macchine via Internet.
Così i computer sono insicuri.
Sono davvero.
Dobbiamo fidarci altre persone.
>> E l'idea di sicurezza è che sei cercando di limitare la quantità di
fidi di cui avete bisogno.
E uno dei mezzi che fai che è attraverso la crittografia.
La crittografia è, in sostanza, abbiamo segreti.
>> A volte dobbiamo passare i nostri segreti lungo attraverso, per esempio, Internet o
altre cose.
E noi non vogliamo che la gente per conoscere questi segreti.
Quindi noi codifichiamo i nostri segreti in un modo che speriamo non si riesce a capire.
>> Così abbiamo utilizzato -
attraverso il corso di questa classe -
cose come Cesare cifratura e [Incomprensibile], che sono entrambi molto, molto
insicure vie criptando cose.
Sono facili da capire cosa sono e quali sono i vostri segreti sono.
Il mondo reale usa molto di più sistemi di crittografia complicate.
E noi non entreremo in molto di più.
>> Debugging.
GDB è il migliore.
Io vado a sottolineare di nuovo.
Utilizzare GDB tutto il tempo ogni volta che hai un problema.
I comandi che sono utili in GDB sono rompere, che si passa sia una linea
numero, un nome di funzione, in sostanza, dove nel codice si vuole fermare,
ed essere in grado di prendere il controllo.
>> Stampa prende una variabile e stampa tutto ciò che è variabile in quel
puntare in esecuzione.
Prossimo muove tua esecuzione lungo un passo.
E punti punto all'interno di una funzione in esecuzione.
>> Altre cose sono gestite, che è come in realtà esegue il codice.
Continuare prende tutte le misure necessarie per arrivare al prossimo punto di rottura.
E ci sono molti, molti altri.
Guardare in su.
Sono grandi.
Sì?
>> AUDIENCE: [incomprensibile]?
>> DAN: Sì, che è un debugger.
Quindi un debugger è un programma che consente di eseguire il debug del programma.
Non è un programma che trova i bug per si, però che sarebbe grande.
>> E per ultimo per me è la ricerca.
Così i tipi di ricerca di cui abbiamo parlato circa in questa classe sono ricerca lineare,
che è solo che si guarda attraverso ogni elemento dello spazio di ricerca, una
elemento alla volta, fino a trovare quello stai cercando o fino a raggiungere
la fine del vostro spazio di ricerca in cui punto dici che non si poteva trovare
l'elemento che stavi cercando.
E questo richiede al miglior tempo costante, che è 0 a 1 e nella peggiore lineare
tempo, che è 0 di n.
>> La ricerca binaria, che ha bisogno di elementi sordidi.
Si va al centro dei vostri elementi, vedere se l'elemento che stai cercando
è maggiore o minore rispetto all'elemento che siete a metà.
Si è più grande, tu dici che il fondo del vostro spazio di ricerca è tua
posizione attuale, al centro, e si riavvia il processo.
Se è più piccolo, si guarda dire che - sì, cosa succede?
>> AUDIENCE: [incomprensibile]?
>> DAN: sì.
Qualsiasi tipo di genere che è stato insegnato in la classe è un gioco equo per il test.
>> [Risate]
>> DAN: E il fatto che non hai avuto di farlo per un problema di set, è giusto
gioco per il test.
>> AUDIENCE: Possiamo andare su di esso come -
>> DAN: Sarà andato oltre.
>> SPEAKER 2: il codice effettivo per [Incomprensibile] è su study.cs50.net.
Quindi, se si guarda al problema prassi nella pagina merge sort di
study.cs50.net, c'è il codice per l'attuazione di merge sort.
Quindi non c'è bisogno di attuare te stasera.
Ma assicuratevi di capire piuttosto che semplicemente memorizzare esso.
>> AUDIENCE: [incomprensibile]?
>> SPEAKER 2: La pagina di merge sort su study.cs50.net, esiste una pratica
problema che, se si fa clic con il problema, alla fine c'è una
soluzione, che è l'unione attuazione ordinamento.
Ma assicurarsi di aver compreso che piuttosto che solo memorizzarlo
o la copia giù.
>> PUBBLICO: E perfettamente valido problema per l'esame sarebbe
qualcosa di simile ecco una lista.
Che cosa significa questo elenco sembra dopo un passo delle selezioni tipo o
insertion sort o qualsiasi altra cosa.
Un'iterazione completa della lista.
Quindi, anche se non si finisce per dover codice per esso, è necessario capire
abbastanza per sapere come sta andando da modificare questa matrice.
>> DAN: Questo è tutto per me.
>> [Applausi]
>> LUCAS: Ciao a tutti.
Il mio nome è Lucas.
Ho intenzione di parlare di ricorsione, tutti il genere che abbiamo imparato, e un
po 'di tutti i puntatori.
OK?
Quindi, prima di tutto, ricorsione.
Che cosa significa dire che una funzione è ricorsiva?
>> AUDIENCE: si chiama.
>> LUCAS: OK, si chiama, sì.
Quindi ti piace questa immagine, per esempio.
E 'come l'immagine all'interno di una immagine e così via.
Così, per esempio, si può avere - come Dan che stava parlando di ricerca binaria.
Un modo in cui la ricerca binaria è ricorsiva è il fatto che sei
cercando di trovare un numero.
Così si va al centro.
E poi di controllare se i numeri ci nella sinistra e nella destra.
>> E poi se si trova il numero è andando sulla sinistra, è la stessa
cosa fare di nuovo la ricerca, ma appena sulla sinistra della lista.
Ecco come suona come è ricorsivo.
Ecco perché voi ragazzi avete ricorsiva soluzione per merge sort.
>> Ok, ecco un esempio.
Quindi diciamo che voglio scegliere tutti i numeri da 1 a n.
Posso capire che la somma degli n numero è n più n meno 1 fino a 1.
Ma allora, se guardo n meno 1 plus n meno 2 più 1, che è la stessa
cosa sommando i numeri fino a n meno 1.
Quindi posso dire che la somma di una somma pari n è uguale più la somma di n meno 1.
Ritiene che senso?
>> E anche io avrei qualcosa d'altro chiamato il caso base, che è quella
la somma dei numeri fino a zero sarebbe zero.
Quindi, non appena ottengo il numero zero, mi fermo a contare.
Ritiene che senso?
>> Quindi, ecco un esempio di come Posso attuare tale.
Così ho questa funzione in alcuni.
Questo richiede un numero intero n.
Così qui ho controllare se n è minore o uguale a zero.
Quindi, se è inferiore o uguale a zero, ho restituire zero, che è il nostro caso base.
In caso contrario, posso solo tornare n più la somma dei numeri da
uno di n meno uno.
Dare un senso?
OK.
>> Quindi, ecco quello che sembra.
Hai somma di 2 pari 2 più la somma di 1.
E alcuni di 1 è 1 più la somma di 0, che è 0.
Dare un senso?
Quindi, se guardiamo lo stack del tuo programma, questo è quello che sembra.
>> In primo luogo, abbiamo la funzione principale.
E quindi la funzione principale chiamato somma 2.
E poi somma 2 sta per dire, oh, somma 2 uguale 2 più la somma di uno.
Quindi aggiungo somma di 1 allo stack.
E la somma di 1 sta per chiamare somma di 0, che è anche andando da aggiungere
allo stack.
E poi ciascuno di questi quelli che sono sopra l'altro deve restituire
prima che gli altri possono andare avanti.
>> Così, per esempio, qui, somma di 0, in primo luogo, sta per restituire 0.
E poi scegliere somma di 1.
Poi somma di 1 sta per ritorno 1 a somma di 2.
E, infine, somma di 2 sta andando di ritorno da 3 a principale.
Ritiene che senso?
>> E 'molto importante capire come lo stack funziona e cercare di
vedere se ha senso.
OK, così ordinamento.
Allora perché è classificare importante, prima di tutto?
Perché dovremmo preoccuparci?
Chiunque?
Fammi un esempio?
Sì?
>> AUDIENCE: [incomprensibile].
>> LUCAS: Sì, OK.
Così si può cercare in modo più efficiente.
Questo è un buon modo.
Così, per esempio, abbiamo un sacco di cose, in realtà, nelle nostre vite che
sono allineati.
Ad esempio, i dizionari.
>> E 'molto importante avere tutti i parole in un qualche tipo di ordine che abbiamo
può accedere facilmente.
Ecco, questo è quello che stava dicendo.
È possibile cercare in modo più efficiente.
Pensate a come sarebbe stato difficile avere un dizionario in cui le parole sono in
ordine casuale.
Dovrete guardare, più o meno, ogni singola parola fino a trovare il
parola che stai cercando.
>> Se stai usando anche Facebook, quando stai guardando i tuoi amici, sei
andando a vedere che Facebook ha messo il vostro più stretta amica di sopra di quelli
che non si parli più di tanto.
Se si va tutta la strada fino in fondo la vostra lista di amici, si sta andando a vedere
persone che probabilmente non hanno nemmeno ricordate che siete amici con.
E questo perché Facebook tipi i tuoi amici in base a come
sei vicino a loro.
>> Così organizzazione dei dati.
Anche Pokemon.
Così si vede che tutti i Pokemon avere numeri.
E questo è come un facile modo di accesso ai dati.
>> AUDIENCE: Accesso Pokemon.
>> LUCAS: Già.
>> AUDIENCE: [incomprensibile].
>> LUCAS: Yep.
OK, ordinamento per selezione.
Selection sort sta per selezionare la minimo valore indifferenziato di un elenco ogni
tempo in ogni iterazione.
E 'un po' come il tipo che si fa nella tua testa quando si sta cercando di
ordinare un elenco a portata di mano.
>> Fondamentalmente, tutto ciò che fai è si guarda per il numero più piccolo.
Hai messo nella lista ordinata.
E allora si cerca il prossimo numero più piccolo.
E poi si continua a fare che e così via.
>> Così selection sort è fondamentalmente si selezionare ogni volta la più piccola
valore indifferenziati.
Mettere alla fine del ordinato parte della lista.
E continueremo a farlo.
Quindi cerchiamo di vedere rapidamente cosa questo sembra.
Quindi, ecco l'ordinato e la lista non ordinata.
>> Così, per la ordinato di lista, è inizialmente vuoto.
E poi ho intenzione di selezionare la numero più piccolo qui, che è 2.
Così ottengo il numero 2 e ho messo nella parte anteriore della lista.
E poi guardo a quello immediatamente inferiore elemento, che è 3.
Così ho messo alla fine della lista ordinata.
E poi continuo a farlo.
Trovo 4 e metto alla fine.
Trova 5 e metterlo alla fine.
>> E guarda come tutte quelle volte in cui Sto dicendo messo alla fine è,
fondamentalmente, scambiando due valori.
OK?
E poi l'ultimo, appena avere un elemento in più.
Quindi è già ordinato.
>> OK, insertion sort.
Insertion sort si sta andando ad avere anche quella cosa di avere un ordinato e
una lista non ordinata.
L'unica cosa è che ogni volta che si aggiunge un elemento alla ordinato
lista, basta scegliere l'elemento che è in testa alla lista non ordinata.
E allora si sta andando a trovare ciò che posizionare dovrebbe essere nel filtrate
parte della lista.
>> Vediamo cosa è così questo ha più senso.
Così, inizialmente, per esempio, sto cercando per inserire il numero tre del
filtrate parte della lista.
Quindi la lista non ha nulla.
Quindi posso solo mettere il numero 3.
>> Ora, voglio aggiungere il numero 5 per la parte ordinata della lista.
Così guardo il numero 5.
Mi accorgo che è maggiore di 3.
Quindi so che deve essere successiva 3.
Così ho messo 3 e 5.
>> Poi voglio inserire il numero 2.
Ho notato che il numero 2 è in realtà durare poi sia 3 e 5.
Quindi io in realtà devo mettere tutto il modo all'inizio della lista.
Quindi devo, tipo di, spostare tutto il elementi della lista ordinata in modo che posso
fare spazio per il numero 2.
>> Poi vedo il numero 6.
Vedo che dovrebbe essere dopo 5.
Così ho messo lì.
E, infine, guardo il numero 4.
E ho notato che dovrebbe essere compresa tra 3 e 5.
E poi ho messo lì e lo spostamento tutti gli altri elementi.
Dare un senso?
>> Bubble Sort.
Così bubble sort è fondamentalmente ciò che sei intenzione di fare - noi lo chiamiamo bolla
sorta perché si passa attraverso la lista - in realtà è meglio se mi limito a mostrare
ti piace questo -
e si sta andando a confrontare numeri adiacenti.
E avete intenzione di scambiare la loro posizioni se non sono
nel giusto ordine.
>> Quindi, fondamentalmente, quello che sta per succedere è qui, per esempio,
si hanno 8 e 6.
Voi sapete che l'ordine sarà ordinato effettivamente 6 e 5, giusto?
Quindi stai andando a scambiare gli ordini.
Poi vedo 8 e 4 qui.
E io faccio la stessa cosa.
I Swap di nuovo.
E, infine, 2 e 8.
Ho anche scambiarli.
>> Si chiama Bubble Sort perché dopo ciascuna di queste iterazioni, in realtà,
il maggior numero nell'elenco ottiene tutto fino alla fine della lista.
Ritiene che senso?
Perché mantiene scambiandolo e lo spostamento verso destra.
>> OK, questa è la seconda iterazione.
Sarebbe la stessa cosa.
Farò uno swap e poi l'ultimo.
Io che non esistono swap e l'elenco è ordinato.
Quindi, in Bubble Sort, abbiamo praticamente manteniamo passare attraverso la lista e scambiando
cose fino a quando mi accorgo che non ho fatto eventuali swaps facendo quello iterazione, che
significa che la lista è già ordinato.
Dare un senso?
>> Parliamo un po ' in merito a tempo di esecuzione.
Quindi voi ragazzi ricordare Big O, Omega e Theta?
Sì?
OK, qual è Big O, innanzitutto?
>> AUDIENCE: [incomprensibile].
>> LUCAS: Sì, si chiama un caso peggiore runtime, il che significa solo che è
quanto ci si aspetta il programma prendere a correre.
Come, in termini di -
in questo caso - n.
Il numero di elementi nella elencare nel caso peggiore.
Come, nel caso peggiore possibile.
>> Così per Bubble ordine, per esempio, abbiamo Big O di piazza n.
Perché abbiamo fatto?
Perché Bubble Sort Big O n piazza?
>> AUDIENCE: [incomprensibile].
>> LUCAS: Sì, così il caso peggiore sarà che dovrò fare n iterazioni.
Così ciascuno dei iterazioni sta per portare l'elemento più grande alla fine
dell'elenco.
Così il caso peggiore è che ho di fare quella cosa n volte.
E per ciascuno di quei tempi, devo fare n swaps perchè devo confrontare
ogni due elementi.
Ecco perché è n al quadrato perché è n volte n.
>> Poi, ordinamento per selezione è anche n piazza perché, per ogni iterazione, devo
guardare ogni singolo elemento nell'elenco.
E poi trovare il più piccolo, il che significa che devo
guardare attraverso n elementi.
E devo farlo n volte perché Devo selezionare tutti gli elementi n.
>> Un insertion sort è anche n piazza perché lo scenario peggiore sarà
essere, uno, devo inserire n numeri, giusto?
Quindi io già so che sto andando di avere n iterazioni.
Ma per ognuno di quei numeri, se avessi per guardare tutti i numeri in
l'elenco ordinato e messo tutto il senso nella parte anteriore, che sarà n piazza
perché sarà n volte ancora, n.
Dare un senso?
Che dire di omega?
>> AUDIENCE: [incomprensibile].
>> LUCAS: E 'la migliore delle ipotesi.
Così è come, in un sacco di volte per l'ordinamento, la migliore delle ipotesi è
quando la lista è già ordinato.
Quindi in realtà non hanno di fare nulla.
Bubble Sort ha la migliore scenario di n.
Voi ragazzi sapete perché?
>> AUDIENCE: [incomprensibile].
>> LUCAS: Sì, se si tiene traccia di se razione dati avesse qualche swap o
non, se avete qualcosa come set per vero se ci fosse una iterazione, se la
la lista è già ordinato, in fondo, cosa sta per accadere è che ho intenzione di
provare a sostituire ogni due elementi adiacenti.
Io vado a vedere che non ci sono swap.
E ho appena torno subito.
>> Quindi vuol dire che ho dovuto passare attraverso la lista una volta.
Quindi è n perché guardo a n elementi.
Perché ordinamento per selezione n Square?
>> Sì, anche se la lista è ordinata, per ogni iterazione di ordinamento per selezione, ho
necessario selezionare l'elemento minimo.
In modo che significa che ho fuori a guardare a tutti gli elementi della indifferenziati
elencare e trovare il minimo per ogni iterazione.
Ritiene che senso?
>> E l'inserimento spada è n perché nel caso che io sto cercando di inserire il
numeri e tutti i numeri, quando cercare di inserirli, vedo che
sono nella giusta posizione.
Non devo andare a controllare tutte le altre numeri nella lista non ordinata.
Ecco perché sarà n.
Dare un senso?
E che cosa è theta?
>> AUDIENCE: [incomprensibile].
>> LUCAS: Che cosa, scusa?
Dillo di nuovo.
>> AUDIENCE: [incomprensibile].
>> LUCAS: Esattamente.
Così si può vedere che solo la selezione memorizzato in merge sort avere Theta.
E questo è perché hai solo theta se entrambi Big O e Omega sono gli stessi.
OK.
E, infine, merge sort è in log n.
>> E poi, come diceva Dan, merge sort è un po 'come allo stesso modo che
fate la ricerca binaria.
Così si ottiene la lista.
E si sta andando a tagliare a metà.
E poi li taglia nella metà più piccole.
E poi li uniscono.
Voi ragazzi Ricordo che, giusto?
OK, come egli diceva.
>> OK, puntatori.
Così che cosa è un puntatore?
>> AUDIENCE: [incomprensibile].
>> LUCAS: Un indirizzo.
OK.
So che David si presenta con un mazzo di video di binky e le cose di puntamento
vicenda.
Ma mi piace pensare di puntatori come un semplice indirizzo.
Quindi è una variabile che sta andando Per memorizzare un indirizzo.
>> Quindi è solo questa variabile speciale cioè lungo quattro byte.
Ricordate che il puntatore a nulla è sempre quattro byte lunghi per il nostro 32-bit
macchina così il caso l'apparecchio.
E ha solo la posizione di una variabile all'interno di esso.
>> OK, quindi non c'è questa memoria, in fondo.
Quindi ogni blocco di memoria è in realtà un etichetta, che è l'indirizzo del
memoria Slotty.
Quindi, questo significa che posso avere un puntatore che punta a
qualsiasi di questi indirizzi.
Quindi la ragione per cui useremo i puntatori è se devo ricordare la posizione
che una variabile specifica è una memoria.
>> E voi ragazzi ricordo che uno di quelli casi era se ho una funzione
se ho effettivamente si vuole swap per reali, in realtà ho
rivolgere puntatore.
Non è la variabile.
Voi ragazzi lo ricordi?
La differenza tra -
qual è il nome?
Chiamata per valore e chiamando per riferimento, giusto?
>> OK, sì.
Così chiamata per valore.
Quando basta inviare una variabile funzione che si sta solo l'invio di un valore.
Quindi, si sta effettivamente inviando una copia della variabile.
E il programma non poteva fregare di meno dire se la stessa variabile realtà
fa una copia.
>> E che chiama dal riferimento significa che In realtà sto inviando una copia della
puntatore a quella variabile.
Quindi vuol dire che sto inviando l' posizione di tale variabile.
Così senso che ho la posizione del variabile, quando chiamo la funzione
con i puntatori, sono in grado di effettivamente modificare i dati che era in principale.
Dare un senso?
>> Sebbene, il puntatore è una copia, la puntatore ha ancora il vero indirizzo di
la variabile che voglio cambiare.
Dare un senso?
>> Quindi la creazione di puntatori.
Ricordate, il puntatore hanno sempre il tipo che sta puntando
a e poi una stella.
E poi si mette il nome.
Quindi ricorda che ogni volta che avete qualunque stella, è come un puntatore a
che qualunque variabile tipo che hai avuto.
>> Così qui a stella, ad esempio, è un puntatore e un intero.
E poi stella char è un puntatore char stella e così via.
Sì?
>> AUDIENCE: cosa succede se abbiamo un puntatore a n a stella x.
So che crea un puntatore a x.
Ha dichiarare anche x un intero?
>> LUCAS: OK, quindi quando dici n stella x, non si sta creando un puntatore ad una
variabile x.
Si sta creando un puntatore chiamato x.
>> AUDIENCE: [incomprensibile].
>> LUCAS: Quindi, quando dico n stella x, sono dicendo, hey, nella memoria, ho intenzione di
ottenere uno di questi tre caselle.
E ho intenzione di dire che tale sta per essere x, che è
sarà un puntatore.
E qualcosa di interessante su puntatori è che noi dire che hanno
4 byte per una macchina a 32-bit.
E la ragione di ciò è perché 4 byte sono 32 bit.
>> E le macchine che sono 64 bit realtà avere indirizzi puntatori
che sono lunghi 64 bit.
Quindi significa semplicemente che la dimensione del indirizzi nella macchina è differente.
>> Così Riferimento e Dereferenziare.
Ci sono due operatori che voi ragazzi dovreste ricordare.
Il primo è commerciale.
Il secondo è stella.
Non fatevi confondere da quella stella e questo stella perché ricordare che, in
questo caso, hai n stella.
>> E 'come una cosa tutta insieme.
Non c'è spazio stella n.
Quindi significa che è il tipo.
Ricordate, che quando si hanno la stella variabile, sei
parlando del tipo.
>> Quando hai appena stella e quindi l' nome della variabile, significa che
stai dereferencing il puntatore, che significa che si sta guardando l'
puntatore, trovare l'indirizzo è indicando, andando a questo indirizzo,
e guardando ogni qualvolta hai lì.
Quindi io dico ai miei studenti che quando si ha stella, si dovrebbe pensare che è
l'abbreviazione di contenuto.
>> Quindi, se avete un puntatore e fare puntatore stella, è l'
contenuto del puntatore.
Quindi si va a tutto ciò che sta puntando a e guardare il contenuto costante.
E la commerciale è la stessa cosa come indirizzo.
>> Quindi, se ho una variabile a - come, diamo Dico che ho fatto int a è uguale a 3 -
se voglio trovare l'indirizzo di quella una memoria variabile, posso solo fare
Ampersand a.
Quindi è l'indirizzo di un.
Dare un senso?
>> Quindi, ecco un esempio.
Questo è mancante int b, int c.
Così int a è uguale a 3 significa che Ho intenzione di andare a memoria.
E ho intenzione di trovare una fessura e mettere il numero 3 qui.
>> E poi int b è uguale a 4.
Ho intenzione di fare la stessa cosa.
Vai a memoria e mettere un numero 4 in una delle scatole.
E int uguale a 5.
Trova un altro box e mettere un numero di 5.
>> Così che cosa è questa linea facendo fuori? n stella pa equivale commerciale a.
Quindi, prima di tutto, n stella pa.
Che cosa sta facendo?
>> AUDIENCE: [incomprensibile].
>> LUCAS: Sì, così n stella pa, in primo luogo, dichiara un puntatore chiamato pa.
E allora è assegnare il valore di tale puntatore per essere l'indirizzo di una.
Così Ampersand a.
Poi, se faccio stella pb, quello che è un pb stella?
>> Oh, mi dispiace.
Questo è anche mancante. n pb stella.
Voglio dire pc stelle.
Mi dispiace tanto.
E 'la stessa cosa.
Ma ora sto bene ar creazione di un puntatore a B e poi un puntatore a c.
Sì?
>> AUDIENCE: [incomprensibile]?
>> LUCAS: sì.
Quindi, se si va a memoria e si va a la scatola che è designatore per la pa,
si sta effettivamente andando a vedere l'indirizzo di un.
OK?
Sì?
>> AUDIENCE: [incomprensibile]?
>> LUCAS: Sì, puntatore è un indirizzo.
Non dimenticate mai che.
E 'come il più importante parte dei puntatori.
C'è la conservazione e l'indirizzo certa variabile.
Qualcos'altro?
Tutte le altre domande?
OK.
>> Così Puntatori e Array.
Ricordate che quando faccio int matrice 3, in fondo, quello che sto facendo è che io sono, gentile
di, dichiarando in un puntatore.
Quindi array è un po 'come un puntatore a una luogo specifico in memoria in cui
assegnati tre slot per gli interi.
Ritiene che senso?
>> Così, quando faccio int matrice 3, quello che sto facendo, in fondo, è la creazione di tre
slot di memoria.
Così ho appena trovato tre slot di memoria.
Quindi, se lo faccio, quindi, una matrice stelle, significa sostanzialmente il contenuto della matrice,
il che significa che cancello il puntatore, vado a quel luogo che sta indicando,
e ho messo il numero uno.
>> E poi, se faccio matrice stella più 1, che è la stessa cosa di fare di matrice
Staffe uno, il che significa semplicemente che vado a il posto che è punta a.
E poi il più 1 marche Mi sposto di una posizione.
Così vado a questa posizione, in realtà, e mettere il numero due.
>> E poi, finalmente, quando faccio matrice più 2, vado dove
punta di array.
E poi mi trasferisco in blocchi di memoria.
E poi ho messo il numero tre qui.
Sì?
>> AUDIENCE: array Così stella è semplicemente dicendo che il primo punto.
E si può aggiungere 1, proprio perché siamo veramente solo
riferimento a quel primo indirizzo.
>> LUCAS: Già.
Perché, per esempio, diciamo matrice 0, serie 1 e serie 2?
Sto dicendo, perché fai 0, 1, 2, 3 invece di 1, 2, 3?
Uno dei motivi è, uno, calcolatore programmatori preferiscono iniziare
contare da 0.
Due è perché quando lo fai matrice 0, è la stessa cosa che farlo matrice
oltre a 0, il che significa che vado a quella posizione, e io non lo fanno
saltare tutti i blocchi di memoria.
Quindi non mi muovo tutti i blocchi di memoria.
Sì?
>> AUDIENCE: [incomprensibile]?
>> LUCAS: Quindi lei sta chiedendo che cosa è la differenza tra fare
questo o fare malloc.
Una delle differenze è che int matrice 3 è la creazione di un
matrice in pila.
E quando lo faccio malloc, si crea sul mucchio.
Ritiene che senso?
>> Così come malloc realmente funzionano?
Quindi perché abbiamo ancora bisogno di usare malloc?
Il compilatore tipo di figure fuori tutto le variabili che sono stati dichiarati.
E si crea spazio per tutti Di loro nello stack.
Quindi, tutte le variabili stanno andando essere da qualche parte in pila.
Quindi, ecco le variabili di ambiente.
>> Quindi, fondamentalmente, lo spazio per le variabili in memoria viene allocata a
tempo di compilazione.
Quindi significa che il computer ha sapere tutte queste variabili
anticipo.
Non ha bisogno di sapere quale valore si sta andando a mettere in loro.
Ma ha bisogno di sapere come quanta memoria avete bisogno.
>> Ma ora diciamo che, per esempio, si sta creando un array o di prendere una
stringa che si sta prendendo dall'utente.
Tu non sai quanto tempo la stringa sta per essere, per esempio.
Quindi non si sa esattamente quanti blocchi di memoria che si allocano, giusto?
>> Quindi in realtà non ha senso per di dire mettere 100 caratteri.
E poi cosa succede se l'utente scrive 150?
Si sta andando ad essere avvitato.
>> Quindi, fondamentalmente, non si può essere sicuri di come quantità di memoria è necessario allocare
quando si compila il programma.
Si sa solo che in fase di esecuzione.
Allora è per questo che avete il mucchio.
Così l'heap sta per avere memoria che si sta assegnando durante la
durata del programma in esecuzione.
>> Quindi, fondamentalmente, quando si fa malloc, cosa si sta facendo memoria è destinando
runtime, il che significa che sei decidendo proprio in quel momento che si
dovrebbe avere quella memoria.
Ecco, questo è quando si sta assegnazione.
Ritiene che senso?
>> Quindi ricorda, lo stack ha variabili che vengono creati in fase di compilazione.
E poi il mucchio ha variabili che vengono creati, come si va
con malloc, per esempio.
>> AUDIENCE: [incomprensibile]?
>> LUCAS: Così GetString è andando a chiamare malloc.
Lasciatemi parlare malloc, e Mi spiego GetString.
Così malloc è la stessa cosa come allocazione della memoria.
Così sta andando a destinare memoria heap.
E sta andando a restituire un puntatore a dove che la memoria è stato assegnato a.
>> Così, quando si fa -
qui per esempio -
n puntatore stella.
E poi puntatore uguale malloc dimensione di volte 10 pollici.
Sto creando un puntatore.
E poi io sto assegnando tale puntatore a il valore del puntatore che malloc
mi sta dando.
>> Così sto chiedendo malloc può allocare spazio per 10 interi.
Questo è ciò che sta dicendo.
E malloc mi restituisce un puntatore a quel luogo.
Dare un senso?
OK.
Io E GetString è, in fondo, facendo un chiamata a malloc in modo da poter allocare
memoria durante il runtime.
>> Ricordatevi sempre di controllare nulla perché malloc sta per restituire null
se non può assegnare memoria.
Diciamo che si chiede un ridicolo quantità di memoria.
Il computer non sta per essere in grado di allocare più di tanto.
>> Così malloc è solo andare a restituire null.
Quindi ricordatevi sempre di verificare se la puntatore che avete ottenuto da malloc è
null o non, perché, se lo è, si potrebbe essere dereferencing un puntatore e
causando guasti laterali.
E, infine, non dimenticare la memoria libera.
>> Malloc sta creando memoria nel mucchio.
E si deve liberare la memoria prima che il programma termina.
OK, questo è tutto per me.
Siamo spiacenti, Rob.
Grazie.
>> [Applausi]
>> LUCAS: Tutte le ultime domande prima di Rob arriva?
No?
Sì?
>> PUBBLICO: non ho visto questa linea.
Hai caricato ancora?
>> LUCAS: Penso che Dave è caricarlo presto.
>> DAVE: Sarà pubblicato.
>> LUCAS: Sarà online.
>> AUDIENCE: Tocca.
>> LUCAS: Tocca?
OK.
Sì?
>> AUDIENCE: [incomprensibile]?
>> LUCAS: Sì, si dovrebbe liberare tutto il memoria che viene messo nel mucchio.
>> AUDIENCE: [incomprensibile]?
>> LUCAS: sì.
Ogni volta che avete una malloc cultura, si dovrebbe avere una cultura libera
dopo aver smesso di usare quella variabile.
Così malloc e gratuito sono sempre insieme.
I loro migliori amici.
Già.
Rob?
>> ROB: Vado in fretta.
E anche il video sarà messo.
Ho il microfono acceso.
>> OK, così la settimana di cinque roba.
La prima cosa che abbiamo è lo stack.
Quindi ricorda che c'è solo una pila frame per chiamata di funzione attiva.
Vedremo che in un secondo.
E anche ricordare ciò che in realtà va in ogni stack frame stanno per essere
le variabili locali delle nostre funzioni, gli argomenti che vengono passati nel nostro
funzioni, insieme a una coppia altre cose che realmente non
bisogno di preoccuparsi.
>> Quindi, ecco un esempio di programma in cui, avviso, principale printfing il ritorno
valore di foo 4.
foo è solo andare a restituire il valore del bar 4 comma 6.
E bar sta per impostare alcuni locali variabile n pari a 4 volte 6.
E poi tornare n.
>> Quindi cerchiamo di guardare al camino tutto l'iterazione attuale del programma.
Quindi c'è la parte inferiore del nostro stack.
Ricordate che lo stack cresce.
Così nella parte inferiore del nostro stack, abbiamo avere uno stack frame per main.
Quando il programma viene avviato, principale sta andando sempre essere al
fondo del nostro stack.
>> E ciò che è dentro la nostra impilare cornice per principale?
Quindi, anche se non ci sono locali variabili a principale, come ho detto prima,
abbiamo argc e RGV occupare spazio all'interno di stack frame principale.
Così principale sta ora per chiamare la funzione foo.
E questo significa che foo sta per ottenere il proprio stack frame.
>> Così ora siamo dentro la funzione foo.
E ciò che deve andare in stack frame di pippo?
Beh, foo ha un argomento n.
E n è pari a 4 dato che è quello che principale sta passando come argomento di foo.
>> Così ora foo sta per chiamare bar.
Che cosa è il bar sta per avere all'interno della sua 'stack frame?
Ha x uguale a 4 y uguale a sei.
Ma non è tutto che stiamo andando ad avere in stack frame perché bar
ha anche una variabile locale n.
E n stiamo andando a impostare uguale a 24.
>> Così ora bar sta per tornare n.
Quindi bar sta tornando da 24 a il telaio foo stack.
E poiché bar torna ora, che significa che stiamo popping stack frame
per bar fuori della pila.
Così tutta la memoria che bar era stato utilizzando è ora dallo stack.
>> Ora, foo è anche andare di ritorno da 24 a principale.
Quindi, ora che foo sta tornando, la memoria che foo usava nella sua '
stack frame è anche andato.
E ora, principale sta per chiamare printf.
Quindi printf è solo un'altra funzione.
Quando chiamiamo printf, che sta per essere un altro stack frame per printf
chiamata di funzione.
>> Che cosa stiamo passando printf?
Questo è ciò che sta per andare sul suo stack frame.
Per lo meno, stiamo passando che cento i backslash n e
l'argomento 24.
Si potrebbe avere più in esso stack cornice se printf sembra essere utilizzando alcuni
variabili locali.
Non lo sappiamo.
>> Ma tutto ciò che va in printf di impilare telaio.
E 'intenzione di eseguire la printf.
Poi printf è fatto.
Si tornerà.
Infine, principale è fatto.
Principale tornerà.
E poi il nostro programma è fatto.
Sì?
>> AUDIENCE: Stai vedendo [incomprensibile]
argomenti [incomprensibile]
parametri?
>> ROB: Quindi c'è una sottile differenza tra argomenti e parametri.
E davvero, nel parlare comune, le persone tendono per mescolare solo tutto il tempo.
Ma parametri sono formali il nome delle cose.
>> Così argc e argv sono la parametri principale.
Gli argomenti sono quello che effettivamente passare come tali parametri.
Quindi non quando chiamo foo di 4, 4 è l'argomento che sto passando dentro
E il parametro n, all'interno di foo, assume il valore 4
dal 4 era l'argomento.
>> AUDIENCE: [incomprensibile]?
>> ROB: n è una variabile locale al bar.
n è ancora locale foo, ma è un parametro a foo.
Non è una variabile locale.
Sì?
>> AUDIENCE: [incomprensibile]?
>> ROB: foo è solo chiamando bar e tornando qualsiasi bar ritorni.
>> AUDIENCE: [incomprensibile]?
>> ROB: Si, solo per vedere di più impilare fotogrammi.
Sì?
>> AUDIENCE: Perché è stato chiamato foo prima printf?
>> ROB: Perché foo chiamato prima printf?
Così ho potuto, invece, fatto qualcosa come int x è uguale a foo di 4
e poi stampato x.
Ma invece, ho unito la funzione rimettere in discussione la printf.
>> Ma si noti che non possiamo realmente eseguire la chiamata a printf finché noi
capire cosa foo di 4 è.
Quindi stiamo andando a valutare questa.
E solo una volta fatto stanno andando di tornare e valutare questa.
Sì?
>> PUBBLICO: Dal momento che entrambi bar [incomprensibile]
valore, perché non ci abbiamo [incomprensibile]?
>> ROB: Sono totalmente dovrebbero essere int.
Che non è stato catturato nel corso più passaggi.
Quindi dovrebbe essere int bar e int foo poiché sia di quelli
stanno tornando interi.
Void è solo se non stanno andando per restituire i valori reali.
Sì?
>> AUDIENCE: Se tu avessi una linea sopra il ritorno, [incomprensibile]?
>> ROB: una linea sopra il cambio?
>> AUDIENCE: Già.
Come se hai printf e [incomprensibile], sarebbe stampare due volte?
>> ROB: Così dentro di pippo?
Se avessimo un printf proprio qui?
>> AUDIENCE: Già.
>> ROB: Quindi, se avessimo un diritto printf qui, sarebbe stampare una volta.
Dal momento che stiamo chiamando foo una volta a destra qui, poi ci ha colpito la printf.
Poi chiameremo bar.
E poi foo torneranno.
E questo è tutto.
Abbiamo sempre e solo incontriamo printf volta.
Sì?
>> AUDIENCE: [incomprensibile]
printf chiamando foo perché siamo prima chiamata printf e poi stiamo passando
gli argomenti.
>> ROB: Quindi, in teoria, non è printf chiamando foo?
Quindi non.
Proprio l'ordine che c sta per esecuzione di queste cose è, prima di poter
chiamare una funzione, tutti gli argomenti alla funzione dover
essere completamente valutata.
Quindi è questo completamente valutata?
Sì, è solo una stringa.
E 'solo un valore.
>> Poi dobbiamo completamente valutare questa.
Una volta fatto questo, ora tutti i suoi argomenti vengono valutati.
E ora possiamo fare il chiamata a printf.
Sì?
>> AUDIENCE: Una domanda.
Se avete una funzione void, deve avete ritorno punto e virgola?
>> ROB: Non fare un punto e virgola ritorno se avete una funzione void.
OK.
Così ora alcune cose heap.
Così heap è come stiamo andando a trattare con la gestione della memoria dinamica.
E questo contrasta direttamente con la di stack noi chiameremmo automatico
gestione della memoria.
>> Quindi sulla pila, non hai mai veramente avere per affrontare come le variabili locali
vengono spinti e spuntato fuori tutto questi stack frame e tutta quella roba.
Non dovete preoccuparvi di questo.
È automatico.
Così l'heap è manuale.
E il [incomprensibile]
proviene da queste funzioni malloc e gratuito.
>> Quindi, ecco un altro programma.
Tutto quello che stiamo facendo è mallocing un numero intero.
Stiamo riporlo in stella x.
Naturalmente, dobbiamo controllare per vedere se x è null.
Poi andremo a impostare solo quello x sta indicando a 50.
Stampa quello che x sta puntando, print x, e quindi libero x.
>> Così come è questo in realtà andando a guardare se guardiamo il nostro stack e heap?
Quindi inizieremo di nuovo.
La parte inferiore di una pila come prima.
Ricorda che ti mucchio direttamente oppone la pila?
Quindi stiamo andando ad avere la all'inizio della nostra mucchio lassù.
>> Modo che il fondo del nostro stack, disponiamo il nostro stack frame per principale.
Essa ha lo spazio per argc, argv, e noi ora hanno una variabile x locale, che
è un int stella.
Quindi stiamo andando a scorrere attraverso questo programma.
La prima cosa che abbiamo è una chiamata a malloc.
>> Quindi stiamo facendo una chiamata a malloc.
Malloc è una funzione.
E 'intenzione di ottenere uno stack frame.
Che cosa stiamo passando a malloc?
Che sta per entrare dello stack frame.
Stiamo passando dimensione n, che è 4.
In modo che è passato da malloc.
>> Cosa fa malloc fare?
Ci prende un po 'di spazio sul mucchio.
Quindi stiamo per andare al mucchio.
E stiamo andando a prendere 4 byte dal mucchio.
Così facciamo solo dare quel un indirizzo arbitrario.
0x123 Basta finta che è un indirizzo che è sul mucchio.
>> Così che cosa è in realtà all'interno di tale regione di memoria all'indirizzo Ox123?
Garbage.
Quindi non abbiamo conservato qualche cosa in esso.
Quindi, per quanto ne sappiamo, potrebbe essere qualsiasi cosa.
Non si deve presumere che sia zero.
E 'più probabile non zero.
>> Ritorna così ora malloc.
E cosa facciamo quando torna malloc?
Abbiamo impostato cosa restituisce.
Abbiamo impostato x uguale a quello che si sta tornando.
Allora che cosa è che tornando?
Sta tornando 0x123 dato che questo è l' indirizzo del blocco di memoria che
appena stanziato nel mucchio.
>> Quindi ritorno 0x123 x ora sta per essere impostato pari a 0x123 che, pittoricamente,
abbiamo spesso traiamo come x avere un reale freccia che punta a quel blocco.
Ma x è solo memorizzando tale indirizzo.
Quindi ora dobbiamo verificare se x è null.
Non è nullo.
Facciamo finta che questo malloc riuscito.
>> Così ora stella x è uguale a 50.
Così stella ricorda che significa vai a questo indirizzo.
Così 0x123 stiamo andando a vai a questo indirizzo.
In modo che ci porta lassù.
Cosa stiamo facendo a questo indirizzo?
Stiamo memorizzazione 50.
>> Così, dopo questa linea, questo è ciò che le cose stanno andando a guardare come.
Così ora non è più immondizia lì.
Ora sappiamo che il 50 è in tale particolare indirizzo perché
abbiamo impostato a questo.
OK?
Così ora stiamo andando a stampare f.
>> Quindi, prima che andremo a stampare stella x.
Così che cosa è stella x?
Ancora una volta, stella X significa andare al cosa che x sta puntando.
Quindi x sta memorizzando 0x123 Vai a questo.
Otteniamo 50.
Così la stampa f che.
E questo significa che sta andando a stampare 50.
E allora che restituisce.
>> E poi abbiamo la seconda printf.
Siamo ora per cento p.
Se non lo avete visto, che è proprio come si stampa un puntatore.
Così abbiamo i cento, cento f, e tutti quelli già.
Quindi per cento p, stampare un puntatore.
>> Quindi x è un puntatore.
Quindi, se abbiamo intenzione di stampare x se stessa, stiamo stampando ciò che è in realtà dentro
x, che è 0x123 Quindi la prima stampa f sta per stampare 50.
La seconda stampa f sta stampare 0x123 Sì?
>> AUDIENCE: Usi per cento x per stampare un puntatore?
>> ROB: Così si usa per cento x per stampare un puntatore?
Così è possibile, ma cento x è solo, in generale, per come se avete qualche
intero e si desidera stampare come esadecimale.
Questo è solo come farlo.
>> Considerando che, per cento d sarebbe stampare come decimale.
Ecco dove abbiamo otteniamo per cento d. i è appena intero.
cento p è specificamente per i puntatori.
>> Quindi x è un puntatore.
Vogliamo usare per cento p.
Ma cento x potrebbe funzionare.
Sì?
>> AUDIENCE: [incomprensibile]?
>> ROB: Già.
Almeno per questa chiamata - così ho non includere qui.
Ma questi due argomenti sono necessariamente All'interno di questo stack frame
insieme a eventuali variabili locali printf capita di utilizzare.
E poi la successiva chiamata a printf ora all'interno di printf stack frame è
cento p backslash n e qualunque sia il valore di x è, che è 0x123.
Sì?
>> AUDIENCE: [incomprensibile]?
>> ROB: Sarà stampare qualcosa che assomiglia a questo.
>> AUDIENCE: [incomprensibile].
>> ROB: Così la stampa in forma di indirizzo.
Sembra un indirizzo.
Sì?
>> AUDIENCE: [incomprensibile]?
>> ROB: Perché è ciò?
>> AUDIENCE: [incomprensibile]?
>> ROB: Perché è questo puntatore 4 byte?
Quindi ci sono un sacco di 0 di fronte a questo.
Quindi è davvero 0x0000000123.
In un sistema a 64 bit, non ci sarebbe un sacco di più zeri.
Sì?
>> AUDIENCE: [incomprensibile].
>> ROB: Quindi il primo printf sta per la stampa -
>> AUDIENCE: [incomprensibile].
>> ROB: Sì, sta andando a stampa cosa x sta indicando.
Stella dice che cosa è questo cosa che punta a.
Afferrarlo.
Così che cosa è che punta a?
50.
Afferrarlo.
Questo è quello che andremo a stampare.
Considerando che, il prossimo, siamo solo x la stampa stessa.
Ciò che è dentro di f?
0x123.
OK.
>> E poi, finalmente, abbiamo il libero.
Che cosa stiamo passando a liberare?
Stiamo passando x.
Quella volta ho effettivamente visualizzato nel frame dello stack.
>> Quindi stiamo passando il valore 0x123 per liberare.
Così ora libero sa, va bene, Devo andare fino al mucchio
e senza che la memoria.
Non è più con quello che è all'indirizzo 0x123.
>> Così libero sta per rilasciare che dal mucchio.
Ora la nostra heap è di nuovo vuota.
Noi non abbiamo perdite di memoria.
Ora gratuito tornerà.
Si noti che x è ancora 0x123.
Ma che ora è la memoria non valido.
Non abbiamo più voglia dereferenziamento x.
Sì?
>> AUDIENCE: è il ritorno 0 ridondante?
>> ROB: E 'Returen 0 ridondante?
Sì.
Abbiamo appena messo che lì perché abbiamo uno di ritorno per l'aria.
Così è come, sì, lascia includere il return 0.
Sì?
>> AUDIENCE: [incomprensibile]?
>> ROB: Così, dopo libero x, cosa succede se cerchiamo di dereference il puntatore?
E 'possibile che niente vada storto.
E 'possibile che avremo ancora ottenere 50.
>> E 'possibile, inoltre, che tale memoria è ora utilizzato per qualcos'altro.
Quindi è un comportamento indefinito.
E undefined significa qualcosa può accadere.
Sì?
>> AUDIENCE: [incomprensibile]?
>> ROB: No, quindi se si assegna x a qualcos'altro.
Quindi, se proprio qui abbiamo detto x è uguale qualcosa di malloc altro -
evento di dimensioni malloc -
poi che blocco originale di memoria non viene liberata.
E abbiamo ufficialmente perso.
Questa è una perdita di memoria.
Abbiamo perso tutti i riferimenti a tale blocco di memoria.
Quindi non c'è modo possiamo mai liberarlo.
OK, così poi ritornare 0 significa fatto.
>> Va bene, troppo pieno così stack.
Qual è l'idea?
Quindi ricordate, heap sta andando giù.
Stack sta salendo.
Quindi questo era l'esempio da lezione, Penso, in cui principale è solo andare a
chiamare questa funzione foo, che sta di chiamarsi ricorsivamente più e
di nuovo.
>> Così impilare fotogrammi stanno per lavorare esattamente lo stesso.
Quindi stiamo per iniziare con principale come lo stack frame inferiore.
Poi principale sta per chiamare foo, che sta per arrivare uno stack frame.
>> Poi foo sta per chiamare foo ancora una volta, che sta per arrivare
un altro stack frame.
E poi ancora, e ancora, e ancora, e ancora fino a quando, alla fine, corriamo
nel mucchio.
Quindi questo è come si ottiene un overflow dello stack.
E a questo punto, si Seg colpa.
Oppure avresti davvero Seg errore prima questo punto, ma sì.
>> PUBBLICO: E 'core dump del stessa colpa seg?
>> ROB: Così vedrete la segmentazione nucleo guasto dumping.
Si ottiene un core dump quando si Seg colpa.
E 'come una discarica di tutto quanto contenuto della memoria corrente in modo
che si può provare e identificare perché si Seg errore.
Sì?
>> AUDIENCE: [incomprensibile]?
>> ROB: Quindi un errore di segmentazione significa c'è un overflow dello stack.
Quindi non necessariamente.
Un errore di segmentazione significa che sei ricordo commovente in un modo
Non si dovrebbe essere.
Quindi un modo che ciò accada è, quando si Stack Overflow, iniziamo toccante
memoria in un modo che non dovremmo essere.
Sì?
>> AUDIENCE: [incomprensibile]?
>> ROB: Quindi, all'interno di un ciclo infinito.
Come, questo è come un infinito ricorsiva loop e così otteniamo un altro
pila di inquadrare ogni volta.
Ma appena all'interno di un normale infinito mentre uno -
bene, cerchiamo di non stampare anche f -
fare qualcosa.
Qualunque cosa.
>> Non abbiamo intenzione di essere sempre un altro stack frame.
Stiamo solo andando a mantenere looping su questa singola istruzione.
Lo stack non è in crescita.
È il fatto che ogni ricorsiva chiamata ci sta dando uno stack frame.
Ecco perché otteniamo un overflow dello stack.
Sì?
>> AUDIENCE: Quindi, se lei ha detto per ottenere il mentre loop e poi [incomprensibile]?
>> ROB: Quindi, se all'interno del ciclo while c'era una printf, si farebbe ancora
Non seg colpa.
Io non volevo confondere le cose.
Sarebbe loop.
Si otterrebbe un unico stack cornice per la printf.
>> Poi printf sarebbe tornato.
Allora faresti nuovo ciclo.
Si otterrebbe un unico stack cornice per la printf.
Sarebbe ritorno.
Fotogramma singolo stack.
Quindi non stai ricevendo questo infinito accumulando stack frame.
>> AUDIENCE: [incomprensibile]?
>> ROB: sì.
Quindi questo overflow dello stack accade perché nessuno di questi
chiamate a foo stanno tornando.
Quindi, se ci ritorno, allora avremmo iniziare a perdere stack frame.
E poi non avremmo overflow dello stack.
Ed è per questo che avete bisogno di un caso base per le funzioni personali.
Sì?
>> PUBBLICO: E 'la dimensione potenziale e impilare per l'heap lo stesso per
tutti i programmi?
>> ROB: Circa.
È la dimensione potenziale della pila e mucchio lo stesso per tutti i programmi?
Circa.
C'è qualche randomizzazione dove inizia la pila e
dove inizia l'heap.
Se vi capita di avere un sacco di variabili globali e le cose, si potrebbe
togliere un pò di spazio per il vostro heap.
>> In un sistema a 64 bit, è praticamente avere memoria infinita.
C'è solo così tanto.
Tra 32 bit e 64 bit, che è una differenza significativa.
>> Stai andando a ottenere molto di più impilare e lo spazio di heap su un 64 bit
sistema perché non c'è solo più indirizzi che possono usare.
Ma su un sistema individuale, sarà essere all'incirca la stessa quantità di pila
e lo spazio heap.
Bene.
>> Quindi ultima cosa è la compilazione.
Così si dovrebbe sapere questo processo.
Ci sono quattro grandi passi.
Quindi il primo dovrebbe essere facile da ricordare.
Pre-elaborazione.
Ha la pre prefisso in esso.
Quindi viene prima di tutto.
>> La cosa da ricordare è l'hash.
Definisce così hash e hash include in ciascuno di questi.
Quelli sono tutti pre-processore direttive.
Queste sono le cose che il pre-processore si prende cura di.
>> Che cosa fa un pre-processore fare?
E 'una cosa davvero stupida.
Tutto è capace di sono tutti questi operazioni di copia, e tagliare e incollare.
>> Così hash include la norma i0 punto h.
Che cosa è che facendo?
E 'afferrando la norma I0 dot h file e incollarlo nella top
ovunque si dice hash include standard di I0 dot h.
>> E qualsiasi hash definire che abbiamo visto, che cosa è che facendo?
Il suo copiando il valore che l'hash definito è definita come e incollare che
ovunque si utilizza il valore.
Così il preprocessore non solo molto semplice testo operazioni basate.
Non fa nulla intelligente.
Quindi, tutto il resto è più complicato.
>> Quindi, ora che preprocessore è fatto, abbiamo effettivamente compilare.
Così che cosa alla compilazione significa?
Stiamo andando dal codice c al codice assembly.
Sì?
>> AUDIENCE: [incomprensibile]?
>> ROB: Sì, abbiamo preso quello.
Così la compilazione.
Stiamo andando da c per il montaggio.
Quindi questo è un cambiamento di linguaggio vero e proprio.
Compilazione di sé significa che va da un linguaggio di alto livello per
un linguaggio di livello inferiore.
>> E c è un linguaggio ad alto livello rispetto al montaggio.
Che cosa è l'Assemblea?
Le sue istruzioni che sono, piuttosto molto, realizzato per la CPU.
Ma il computer fa ancora Non capisco il montaggio.
Si capisce solo uno e zero.
Quindi il passo successivo è l'assemblaggio, che ci porta da queste istruzioni
la CPU capisce e realtà li traduce, a
gli uni e zeri.
>> Quindi C per montaggio a binario.
Ma non ho ancora un eseguibile.
Quindi, pensare della biblioteca CS50.
Vi abbiamo fornito con un binario per questa biblioteca CS50, che ha GetString
e GetInt e tutto il resto.
>> Ma la biblioteca CS50 -
in sé e per sé - non è eseguibile.
Non ha una funzione principale.
E 'solo un mucchio di binario che è possibile utilizzare.
Così collegamento è il modo in cui riunire tutti di questi diversi file binari
in un eseguibile effettivo.
Uno che è possibile digitare dot ridurre drasticamente un punto fuori.
>> Quindi questo è come il file che si ha scritto, - qualunque sia il vostro programma -
Caesar dot c.
Ma ora è stato compilato fino al binario.
Così Cesare dot o.
E questo è il nostro biblioteche CS50 binario.
E sono stati combinati in un unico eseguibile.
Sì?
>> AUDIENCE: [incomprensibile]?
>> ROB: Quindi prima comprendere, ricordare, l'hash comprendono è in realtà un
fase di pre-processore.
Ma questo è separato.
Se non stai usando le funzioni che sono al di fuori del singolo file, allora,
no, non è necessario collegare nulla visto che hai tutto.
>> Detto questo, printf viene collegato dentro
Se avete mai usato printf, è già qualcosa che deve essere collegato in
perché non hai scritto che.
E, infatti, printf è automaticamente legato dentro
Sapete come nella riga di comando o quando digiti fare, si vede che hanno
dash l CS50, che abbia un collegamento in biblioteca CS50?
Printf, e cose del genere, sta andando collegati, in modo automatico.
Tutte le altre domande su qualsiasi cosa?
>> AUDIENCE: [incomprensibile]?
>> ROB: Collegamento?
Abbiamo un sacco di diversi file binari.
Questo è l'esempio canonico che usiamo è la libreria CS50.
Abbiamo compilato e dato a voi il binario per questa libreria CS50.
>> Si desidera utilizzare GetString nel programma.
Così si va e utilizzare GetString.
Ma senza il mio codice binario per GetString, quando si compila il codice
verso il basso, non si può effettivamente eseguire il programma perché GetString String è
non ancora del tutto definito.
>> E 'solo quando si collega a mio binario che contiene GetString che ora, tutti
a destra, posso effettivamente eseguire GetString.
Il mio file è completo.
E posso correre questo.
Sì?
>> AUDIENCE: Fa collega convertire il binario eseguibile?
Quindi, anche se non si dispone di altri biblioteche, non sarebbe ancora
necessario tradurre il [incomprensibile]?
>> ROB: Quindi un eseguibile è ancora in binario.
E 'solo che unisce un intero mazzo di binari.
>> AUDIENCE: Grazie mille.
>> ROB: Nessun problema.
Tutte le altre domande?
In caso contrario, siamo tutti insieme.
Bene.
Grazie.
>> [Applausi]
>> AUDIENCE: Grazie.
>> ROB: Già.