[Powered by Google Translate] Problema Sezione Set 2: Edizione Hacker
Rob Bowden, l'Università di Harvard
Questo è CS50. CS50.TV
Quindi, io sono Rob. Sono un anziano a Kirkland. Questo è il mio terzo anno TFing CS50.
E 'la prima volta che stiamo cambiando dalla tradizionale lezione in stile sezione,
dove abbiamo solo tipo di revisione ciò che è accaduto in aula e poi voi ragazzi fare domande,
ora ad essere molto più problem-based, in cui si usa Spaces, e -
Oh, quindi l'idea è di andare a quel link che ti ho mandato e poi sarai nel mio spazio.
Non Qualcuno ha un computer portatile? Va bene.
Quindi abbiamo intenzione di utilizzare questo, e stiamo andando a fare problemi vivere in sezione
e discutere di loro e capire cosa c'è che non va
e potrei tirare su un po 'di codice, e potrei discutere le vostre idee.
Quindi qualcuno ha avuto difficoltà?
Puoi chattare sul lato, io non so se avremo ragione per questo.
Ora, come la supersection precedente, se si fosse a quella classe, sapete di cosa si tratta.
Su tutti insiemi P ci sarà queste sezioni.
Quindi P-set 2, le specifiche, penso che visto il P-set 1 già.
Ma possiamo guardare P-set 2 per quello che abbiamo intenzione di andare oltre oggi.
E vedrete una sezione di domande.
Quindi questo sarà in tutti i P-set, ci sarà una sezione di domande.
Finora abbiamo detto: "Consideriamo questo l'opportunità di praticare."
Non ti verrà chiesto di presentare questo programma.
L'idea è che questi dovrebbero tipo di aiutarvi a iniziare con il problema proposto.
Credo che l'edizione Hacker, molti di loro dovrebbero essere solo nuove, cose interessanti da imparare.
Essi non possono essere direttamente applicabile al problema proposto.
E in questo momento non stiamo avendo di inviarli, ma in teoria,
per i set di problemi successivi, è possibile inviarli, e quindi si potrà venire alla sezione
o guardare la sezione per ottenere le risposte, o si può semplicemente farli da soli
se non avete voglia di godere la mia presenza.
Così il - credo che questo sia il primo.
Oh. Inoltre, in queste sezioni di domande abbiamo anche fare domande sui pantaloncini.
Quindi credo che, in teoria, dovresti guardare questi prima di venire al punto,
ma va bene se non lo fai, noi andremo su di loro in ogni caso.
Così possiamo iniziare con questi: "Come fa un ciclo while differisce da un ciclo do-while?
Quando è quest'ultima particolarmente utile? "
Così qualcuno ha qualche -?
[Studente] Il ciclo do-while viene sempre eseguito almeno una volta.
Sì. Così che è la differenza. Un ciclo while - I'Ll fatelo qui - while, abbiamo la condizione
proprio qui, mentre un do-po ', non si dispone di una condizione fino ad arrivare qui.
E così, quando il programma è in esecuzione, e si arriva al ciclo while,
controlla immediatamente se la condizione è vera.
Se questa condizione non è vera, sarà solo saltare il ciclo del tutto.
Do-while, in quanto il programma è in esecuzione, si arriva al "fare".
Non accade nulla, a questo punto, continua solo l'esecuzione.
Poi, quando colpisce il "po '", se la condizione è vera, sarà Ripeti avanti e farlo di nuovo
e ancora e ancora fino a quando la condizione non è vera e poi cade solo attraverso.
Così, con la differenza che questa può passare direttamente fin dall'inizio.
Esegue necessariamente una volta e poi possono eseguire più volte se la condizione è ancora vera.
Quindi il ciclo while sarà solo fare una volta, o - il ciclo while - non aver bisogno di farlo a tutti,
poiché non appena si arriva ad essa, se la condizione è falsa, ci limiteremo a saltare su di esso.
Considerando che, do-while, noi lo esegue una volta, necessariamente.
Poi, quando si arriva alla condizione, controlliamo se è vero o falso.
Se è vero, lo faremo di nuovo, se è falso, dobbiamo solo continuare ad andare.
Così, quando quest'ultimo è particolarmente utile?
Quindi posso dire che la totalità dei 4 anni, 3 anni, qualunque sia,
che sono stato di programmazione, ho usato questo, come, meno di 10 volte.
E probabilmente 5 di loro sono in CS50 quando stiamo introducendo do-while.
Allora, quando hai usato do-while?
Quando è il - yeah?
[Studente] Quando si sta cercando di ottenere l'input dell'utente, o qualcosa che si desidera controllare -
Gia '. Quindi, do-while, l'input dell'utente è quello grande.
Ecco perché le prime serie di problemi di coppia, quando si vuole chiedere all'utente, come,
"Dammi una stringa," non si può continuare fino ad ottenere quella stringa.
E così, necessariamente, bisogno di chiedere per la stringa di almeno una volta.
Ma poi se rispondono qualcosa di brutto, allora avete bisogno di loop indietro e chiedere di nuovo.
Ma a parte l'input dell'utente, è molto raro che ho incontrato un caso
dove voglio loop "almeno una volta", ma forse di più.
Domande o -? Qualcuno ha usato un ciclo do-while altrove?
Va bene. Quindi il prossimo è: "Che cosa non dichiarati identificatore
di solito indicano se in uscita dal clang? "
Quindi, che tipo di codice potrei scrivere per ottenere 'identificatore non dichiarato?'
[Studente] che x = 2?
Così possiamo solo provare qui, x = 2.
Faremo questo - oh, non l'ho fatto clic. Così qui otteniamo - tutti i diritti.
"L'uso di x identificatore non dichiarato".
Ecco, questo è l'identificatore non dichiarato, una variabile.
Sarà spesso chiamare una variabile un identificatore.
Quindi potrebbe non sapere che in realtà è una variabile, ma non sa cosa sia.
Quindi è un identificatore.
Allora perché è sommerso? Gia '.
Quindi, per essere chiari sulla terminologia, la dichiarazione di una variabile
è quando si dice "int x" o "y", stringa qualunque.
L'inizializzazione della variabile, o l'assegnazione della variabile,
è ogni volta che si dice "x = 2."
Così siamo in grado di eseguire le operazioni in fasi separate, int x, x = 2, e fino a quando - siamo in grado di avere un sacco di roba qui dentro -
ma fino a questa linea accade, x è ancora inizializzato, ma è stato dichiarato.
E così possiamo ovviamente fare a 1 linea, e ora stiamo dichiarazione e l'inizializzazione.
Domande?
E infine: "Perché non è il cifrario di Cesare molto sicuro?"
Quindi, prima, qualcuno vuole dire ciò che il cifrario di Cesare è?
[Studente] Caesar Cipher è proprio questo si associa, si sposta ogni lettera,
un certo numero di lettere andare oltre, e tornare sopra, e non è molto sicuro perché
ci sono solo 26 le possibili opzioni e non resta che provare ogni uno di quelli fino ad arrivare.
Oh. Quindi, devo ripetere?
Il cifrario di Cesare, E'- voglio dire, ti a che fare con essa i problemi che voi -
o credo che l'edizione standard del set di problema che non e 'l'edizione hacker.
Così il l'edizione standard per il problema proposto, viene visualizzato un messaggio del tipo: "Ciao, mondo"
e hai anche un numero come 6, e si prende quel messaggio, e ogni singolo carattere,
lo si ruota di 6 posizioni in alfabeto.
Così la 'h' in ciao diventerebbe h-i-j-k-l-m-n.
Quindi la prima lettera sarebbe n. Facciamo la stessa cosa con l'e.
Se abbiamo una, come, z o qualcosa del genere, poi avvolgere indietro intorno a 'a.'
Ma ogni personaggio ha pedalato 6 caratteri in seguito l'alfabeto, e non è molto sicuro
dato che ci sono solo 26 possibilità per quanti modi si può avvolgere una singola lettera.
Così si può solo provare tutte le 26 di loro e, presumibilmente, per un messaggio abbastanza a lungo,
solo 1 di queste cose possibili 26 sta per essere leggibile,
e quello leggibile sarà il messaggio originale.
Quindi non è un ottimo modo per crittografare nulla.
Estranei a quei pantaloncini, "Che cos'è una funzione?"
Così che cosa è una funzione? Sì.
[Studente] E 'come un foglio di codice che è possibile chiamare per passare il turno e quindi ottenere il valore di ritorno di qualsiasi altra cosa.
Gia '. Quindi ti risponderò anche dal rispondere alla prossima - o la ripetizione di anche solo rispondendo alla successiva.
È possibile utilizzare funzioni invece di copiare e incollare il codice più e più volte.
Basta prendere il codice, inserirlo in una fuction, e poi si può solo chiamare la funzione
dove siete stati copia e incolla.
Quindi le funzioni sono utili.
Così ora faremo problemi reali.
La prima. Così l'idea del primo è, si passa una stringa, e indipendentemente dal -
o lo dice tutto in minuscolo? Non dice tutto in minuscolo.
Quindi, il messaggio può essere qualsiasi cosa, e - oh no. Lo fa.
"Per semplicità, si può presumere che l'utente sarà solo ingresso lettere minuscole e spazi."
Quindi passare un messaggio con solo lettere minuscole e poi alternare
tra capitale e minuscole - si cambia la stringa di essere capitale e minuscole, alternando.
Quindi, prima di dare un secondo per immergersi anche nel problema,
qual è la prima cosa che dobbiamo fare?
Oh, quello che ho appena fare clic su? Oh, ho appena cliccato su una e-mail qui.
Quindi la prima cosa che dobbiamo fare - sto guardando quello sbagliato?
E 'questa parte di questo?
No, quelli sono ancora lì, però.
Ok, ancora qui.
Ora non possiamo pensare -? Sì. Qui non si può pensare che è solo minuscole e spazi.
Così ora abbiamo a che fare con il fatto che le lettere possono essere tutto ciò che vogliamo che siano.
E così la prima cosa che vogliamo fare è semplicemente il messaggio.
Abbiamo solo bisogno di ottenere una stringa, string s = GetString, va bene.
Ora questo problema, ci sono un paio di modi per farlo.
Ma stiamo andando a voler utilizzare gli operatori bit a bit qui.
Ci sono persone che o non erano al supersection,
o qualcosa del genere, e non so che cosa operatori bit a bit sono?
O come si riferiscono alla ASCII in qualche modo?
[Studente] non ero al supersection, ma so quello che sono operatori bit a bit.
Va bene. Allora non c'è bisogno di andare oltre le nozioni di base, ma ti spiego
quello che stiamo andando a voler usare qui.
Così 'A': rappresentazione binaria del capitale A, il numero è 65.
Sto solo andando a guardare - 41 sta per essere 01000001.
Quindi, che dovrebbe essere 65 in decimale, quindi questa è la rappresentazione binaria del carattere capitale A.
Ora, la rappresentazione binaria del carattere minuscolo 'a'
sarà la stessa cosa, o quasi. E '- 6, si'. Questo è giusto.
Così capitale binario A, minuscolo binario 'a.'
Così notare che la differenza fra A e 'a' è tale singolo bit.
E questo sembra essere il 32 bit, il bit che rappresenta il numero 32.
E questo ha un senso in quanto A è 65; 'a' è 97.
La differenza tra loro è 32.
Così ora sappiamo che siamo in grado di convertire da A 'a' prendendo un
OR bit per bit e che, con - che sembra un 1.
Si tratta di un OR bit per bit, con 00100000, e che ti ci danno 'a.'
E siamo in grado di ottenere da 'a' ad A AND bit per bit
con 11, 0 in quel luogo, 11111.
Quindi questo poi ci darà esattamente quello che 'a' è stata, ma cancellare questo bit individuale,
quindi dovremo 01000001, io non so se ho contato bene.
Ma questa tecnica di OR bit a bit per ottenere dal capitale in lettere minuscole,
e bit per bit AND per passare da minuscole al capitale non è esclusiva di A.
Tutte le lettere, K vs k, Z vs z,
tutti sono solo andando a differire da questo singolo bit.
E così è possibile utilizzare questo per passare da tutte le lettere minuscole a qualsiasi lettera maiuscola e viceversa.
Va bene. Quindi, un modo semplice di ottenere da questo - così invece di dover
scrivere tutto ciò che è 1011111 - un modo semplice di rappresentare questo numero, e questo non è uno
che sono andato oltre nella supersection, ma tilde (~) è un altro operatore bit a bit.
Che cosa ~ fa è che guarda la rappresentazione bit.
Prendiamo un numero qualsiasi.
Questo è solo un certo numero binario, e ciò non è ~ si ribalta appena tutti i bit.
Quindi questo era un 1, ora a 0, questo è uno 0, 1 ora, 010.100.
Ecco, questo è tutto ~ fa. Quindi 32 è sarà il numero - sbarazzarsi di quel -
32 è così sarà il numero 00100000, e quindi ~ di tutto questo sta per essere
questo numero qui che ho AND 'a' con.
Ritiene vedere a tutti che? Questo è abbastanza comune, come quando si vuole capire
per le cose dopo che si potrebbe vedere, se vogliamo vedere se -
o vogliamo che tutto, ogni insieme singolo bit, tranne per 1
si tende a fare ~ del bit che non si desidera impostare.
Quindi non vogliamo che il set a 32 bit, in modo da fare ~ di 32.
Va bene. Così siamo in grado di utilizzare tutti quei qui.
Va bene, allora va bene se non si è fatto, si lentamente camminare sopra insieme,
o camminare su questo, quindi - attraverso questo. Passeggiata attraverso questo.
Così abbiamo la nostra stringa, e vogliamo un ciclo su ogni carattere all'interno della stringa e fare qualcosa per esso.
Quindi, come facciamo un ciclo su una stringa? Che cosa dovremmo usare?
Non ho intenzione di farlo qui. Gia '.
Così ho il mio iteratore, e lo disse, ma come faccio a sapere quanti caratteri sono nella stringa?
Strlen (s), allora i + +.
Quindi quello che ho fatto qui non è il modo migliore di fare le cose.
Qualcuno sa perché?
Perché stai controllando la lingua della stringa ogni volta.
Così stiamo andando a voler spostare strlen, potrei dire qui, int lunghezza = strlen (s),
e poi faccio <lunghezza, e nel caso in cui non l'avete mai visto prima,
Potrei anche fare int i = 0, lunghezza = strlen (s).
E così questo è un po 'preferibile, dato che ora ho ristretto il campo di applicazione
della lunghezza variabile a proprio questo ciclo 'for', invece di dichiararla prima
e che esiste sempre, e nel caso in cui non ho capito perché questo è male,
o perché l'originale era male, E'- iniziare dal ciclo for.
Ho controllato la condizione. E 'I <la lunghezza di s?
Quindi la lunghezza di s, cerchiamo di lavorare con "ciao" per tutto il tempo.
Così lunghezza s, h-e-l-l-o. La lunghezza è 5.
Quindi, i = 0, la lunghezza è di 5, quindi non è <5, in modo che il ciclo continua.
Poi ci risiamo. Verifichiamo la condizione. È i <lunghezza del ciao?
Quindi cerchiamo di verificare la lunghezza del ciao. H-e-l-l-o. Ecco 5; i non è <5, in modo da continuare ancora.
Quindi stiamo calcolando, contiamo ciao, per ogni iterazione del ciclo,
anche pensato che non cambierà, ma sta andando sempre essere 5.
Quindi abbiamo ricordate 5 davanti, e ora tutto va meglio.
Così scorrendo l'intera stringa.
Che cosa vogliamo fare per ogni carattere della stringa?
[Parlando Studente, incomprensibile]
Gia '. Quindi, se il carattere non è alfabetico, allora vuole solo saltare su di esso.
Perché ci preoccupiamo soltanto lettere alfabetiche, non possiamo capitalizzare un numero.
Quindi, come possiamo fare questo? Quindi la nostra condizione, quindi se vogliamo qualcosa - controllare se è alfabetico.
Quindi, come possiamo controllare questo?
[Studente] Si può semplicemente utilizzare la funzione alfa.
E 'incluso in uno di questi, o sono simili, char.h o qualcosa del genere?
Cerchiamo di non utilizzare la funzione alfa è, e usare la esplicita - quindi abbiamo s [i],
che è l'ottavo carattere di s, ricordate che una stringa è un array di caratteri,
così l'ottavo carattere di s.
Ora, se si tratta di una lettera maiuscola, sappiamo che deve essere in un intervallo specifico.
E che cosa è che vanno?
Gia '. Quindi, se s [i] è ≥ 65, e s [i] è ≤ 90, cosa devo fare, invece?
Gia '. Così si dovrebbe assolutamente mai nemmeno bisogno di conoscere i valori ASCII di qualsiasi cosa mai.
Non pensare ai numeri 65, 90, 97 e 102, o quello che è.
Non avete bisogno di - 112 - non c'è bisogno di sapere chi a tutti. Questo è sbagliato troppo.
Utilizzare solo le virgolette singole, costanti virgolette singole. Così 'A' e meno di 90 è 'Z'
E questo è molto meglio - non saprei la parte superiore della mia testa che Z è 90.
So la parte superiore della mia testa che 'Z' è il capitale Z.
Quindi, fintanto che questo è nel range di capitale dalla A alla Z capitale, o siamo in grado di verificare la presenza di minuscole,
Oppure, se è nel range ≥ 'a' e ≤ z.
Ecco, questo è la nostra condizione.
Lo stile su dove mettere queste cose varia.
Lo farò in questo modo.
Ora, che cosa vogliamo fare?
Sappiamo che questa lettera è un carattere, un carattere alfabetico.
Quindi abbiamo bisogno di alternare se questa dovrebbe essere una lettera maiuscola o una lettera minuscola.
Come si fa a tenere traccia di quali quello che volete che sia?
[Voci degli studenti, incomprensibili]
Quindi sì, ma fammi controllare.
Modulo 0-2 è stato detto, è stato un suggerimento buttato fuori, e sono d'accordo con questo.
Salvo avviso che, come - è questo il caso? Gia '.
Si tratta di tutti gli altri, ma non possiamo modulo 2 di i, oppure i mod 2, dal momento che
E notare che è il capitale e 'a' è minuscolo? Ma c'è uno spazio che li separa?
Così si sta andando ad essere mod stesso 2, ma sono casi diversi.
[Domanda Studente, incomprensibile]
Gia '. Quindi stiamo solo andando a tenere il conto.
Potremmo anche farlo qui dentro, se volevamo, che potrebbe avere un po 'ingombrante
nel ciclo per le dichiarazioni, mi metterò qui.
Quindi, int count = inizia da 0.
E così ora, ho intenzione di contare il numero di caratteri alfabetici che abbiamo avuto.
Quindi stiamo andando inevitabilmente a contare + + da quando abbiamo trovato un altro carattere alfabetico.
Ma, così ora stai dicendo che se mod numero 2.
E se conta mod 2? Oh. Farò == 0 per ora.
Ci recheremo anche su quella. Quindi, se mod conteggio 2 == 0, e poi?
[Gli studenti risposta, incomprensibili]
Quindi vogliamo che finire maiuscolo.
Ci sono 2 casi, lettere maiuscole e minuscole sono i 2 casi.
Quindi, se siamo in minuscolo abbiamo bisogno di rendere maiuscolo.
Se è maiuscola non abbiamo bisogno di fare nulla.
Ma, c'è un modo - shouldn't sono ribaltate -
che non abbiamo nemmeno bisogno di controllare se è maiuscolo o minuscolo?
Cosa possiamo fare per fare sempre in modo che si finisce sempre in maiuscolo?
Quindi notare ciò che abbiamo fatto per minuscole 'a'; cosa succede se abbiamo fatto la stessa cosa esatta in maiuscolo A?
Fa maiuscolo Un cambiamento, o cambia il valore?
Gia '. Quindi, qualsiasi lettera maiuscola bit per bit AND con ~ 32 sarà quel carattere maiuscolo stesso
perché per ogni carattere maiuscolo il 32-esimo bit non è impostato.
Quindi, se vogliamo portare il carattere s [i], vogliamo che diventi minuscolo o maiuscolo.
Quindi, se era minuscolo, ora è in maiuscolo, se era maiuscola, è ancora maiuscolo, e questo è tutto.
Ho detto questo nel supersection: È possibile utilizzare 32 se vuoi, ma io tendo a preferire fare 'a' - A,
anziché semplicemente 32, perché può essere qualsiasi altro bit.
Dopo il bit 32, ma può essere qualsiasi di questi, o non sarebbe sufficiente
numeri per rappresentare tutti i caratteri.
Quindi, se si ottiene il 32 bit, potrebbe essere il 64 bit, potrebbe essere il bit 128.
Una di queste potrebbe essere il bit bit che distingue tra maiuscole e minuscole.
Non avrei bisogno di sapere che è il bit 32.
Posso usare questo 'a' - A per ottenere il bit che differisce tra i due
senza che sia necessario ricorrere al numero magico che è 32.
E così ora, il resto conta era strano, e quindi che cosa voglio fare?
[Le risposte degli studenti, incomprensibile]
[Studente] Che cos'è?
Lo farò in 1 secondo.
Così ora se voglio - voglio essere sicuro che il personaggio è ormai minuscolo,
e così posso O del 32, e 32 significa 'a' - A.
Ma notate, dallo stesso ragionamento della precedente, che se
la lettera era già minuscolo, poi OR del 32 mantiene semplicemente minuscolo.
Non è cambiato il carattere.
Ma ora non c'è bisogno di evitare di dire: "Se è minuscolo, basta non pensarci più,
se è maiuscolo, quindi sostituirla. "
E 'molto più conveniente per farlo.
[Studente] Vorrei che la strategia della sottrazione del maiuscola dal lavoro in minuscolo, se non fosse 32?
Se fosse, come, 34 o qualcosa del genere?
Quindi, è necessario sapere che la differenza tra i 2 è -? >> 1 bit.
Potrebbe essere più di 1 bit, finché tutti i bit sotto questa posizione sono uguali.
Quindi abbiamo bisogno di almeno 26 caratteri - o, ci sono 26 caratteri.
Quindi abbiamo bisogno di almeno 26 numeri per rappresentare la differenza -
La differenza fra A e 'a' deve essere almeno 26,
altrimenti non avrebbe rappresentato tutti i numeri di capitale.
Ciò significa che A, se cominciamo a 1, sta andando a utilizzare tutti questi bit,
tutti questi primi 5 bit, per rappresentare tutto attraverso Z.
Ecco perché il bit successivo, o questo bit, il bit successivo è quello che ha scelto di distinguere tra A e 'a.'
Questo è anche il motivo per cui, nella tabella ASCII, ci sono 5 simboli che separano le lettere maiuscole dalle lettere minuscole.
Dal momento che questi sono i simboli, il supplemento 5 che porta in primo piano il 32 è la differenza tra loro.
[Studente] Così abbiamo potuto farlo, perché ASCII è progettato in quel modo.
Sì. Ma ASCII - la differenza potrebbe anche essere sia di questi bit.
Come, se A fosse 10000001, e 'un' era 11100001 - non ricordo, a prescindere.
Ma se si trattasse di questo, allora possiamo ancora utilizzare 'a' - A.
E 'solo ora la differenza fra A e' a 'è ancora questi 2 bit.
Credo che sia scritto 48. E '32 + 64? Penso che sia?
Sarebbe ancora 2 bit; ogni singolo carattere, come, Z e z, K e K,
avrebbero ancora gli stessi bit esatte ad eccezione di quelli di cui 2 bit.
Quindi, fintanto che questo è sempre vero, a prescindere se si sta utilizzando ASCII o qualche altro sistema,
finché c'è solo un determinato numero di bit che sono differenti per ciascun carattere,
poi che funziona bene.
E 'solo che il 32 è stato istituito perché è il primo che potevamo usare. >> Cool.
Io tendo a preferire, nel caso in cui non avete visto, se il blocco è solo una singola riga,
è possibile eliminare le parentesi graffe, così io tendo a preferire fare questo.
Inoltre, come possiamo fare le cose come s [i] + = 1?
È anche possibile fare s [i] = 32 AND bit per bit.
E OR bit per bit = 32.
Inoltre, conta mod 2 == 0.
Quindi ricorda che - non lo scrivere - qualsiasi valore diverso da zero è vero, e 0 è falso.
Quindi, "se mod conteggio 2 == 0" è lo stesso che dire "se non contano mod 2."
Probabilmente avrei solo invertito le linee e disse: "Se count mod 2,
fare l'OR 1, cos'altro AND 1, "in modo che non ho bisogno del" no ".
Ma questo funziona altrettanto bene.
E che altro posso fare qui?
Si potrebbe combinarsi con ternario se si voleva, ma poi che aveva appena le cose messier
e probabilmente più difficile da leggere, in modo da non farlo.
Qualcuno ha altri suggerimenti?
E 'tutto il problema ha chiesto? Oh yeah.
Così sbarazzarsi di queste linee vuote, ora ci occuperemo della stampa f,% s essere quella per le stringhe,
Noi stampa f, s.
Ora cerchiamo di farlo funzionare. Ho fatto qualcosa di sbagliato?
Questo è un \ ", voglio un n.
Va bene. Ora si che si avvii. E 'probabilmente urlare contro di me.
Strlen è in string.h.
Quindi questa è la cosa bella è Clang ci dice che cosa è in,
invece di GCC che dice solo: "Ehi, hai dimenticato qualcosa, non so cosa fosse."
Ma questo mi dirà: "Tu lo scopo di includere string.h."
Così non richiede per niente, quindi non sta dicendo niente.
Ma faremo il loro esempio, "Grazie 4 the add".
Che guarda a destra. Evviva.
Quindi, tornando alla tua principale, ho quasi mai farlo.
E 'opzionale. E la funzione principale è solo per cui è facoltativo.
Se non si restituisce nulla da principale, si presume che si vuole restituire 0.
Domande?
Va bene. Così ora il secondo problema.
"Si ricordi dalla seconda lezione due settimane che lo scambio di valori 2 variabili" passando
le 2 variabili a una funzione (anche se chiamato swap) non è esattamente funziona, almeno non senza 'puntatori' ".
E ignorare puntatori fino ad arrivare a loro.
Vogliamo scambiare 2 variabili, non stiamo utilizzando una funzione per farlo.
Stiamo ancora intenzione di farlo in main come si dice.
Ma per usare questi 2 variabili, che non si desidera utilizzare una variabile temporanea.
Ci sono 2 modi per farlo.
È possibile farlo utilizzando i tradizionali operatori binari.
Quindi, qualcuno conosce un modo rapido e sporco di fare che?
Si potrebbe effettivamente prendere un minuto di pensare. Se ho -
Ti posto il problema su come chiedono. Quindi, se ho 2 variabili, A, che è solo un numero intero
che mi danno, e la variabile B somma, che è un altro intero che ho dato.
Quindi, se ho questi 2 variabili, ora voglio per scambiarle.
Il tradizionale, utilizzando i normali operatori binari, voglio dire, come +, -, ÷.
Non operatori bit a bit che agiscono sul binario.
Quindi, utilizzando -, +, ÷, e tutti coloro che.
Potremmo scambiare facendo qualcosa di simile a = a + b, e b = a - b, a = a - b.
Quindi, verifica di integrità, e poi vedremo perché funziona.
Diciamo che a = 7, b = 3, allora a + b sta per essere 10.
Così ora stiamo impostando una = 10, e poi stiamo facendo b = a - b.
Quindi stiamo facendo b = a - b, che sta per essere 7, e b = a - b nuovo,
o = a - b. Che sta per essere di 10 - 7, che è 3.
Così ora, giustamente, 'a' è stato di 7, b era di 3, ed ora è 7 e b 'a' è 3.
Modo che tipo di senso, 'a' è la combinazione dei due numeri.
A questo punto, 'a' è la combinazione, e poi stiamo sottraendo l'originale b,
e poi stiamo sottraendo cosa era l'originale 'a.'
Ma questo non funziona per tutti i numeri.
Per vedere questo, consideriamo un sistema, così di solito si pensa di interi come 32 bit.
Facciamo lavorare su qualcosa che è solo come 4 bit.
Spero di trovare un buon esempio in questo momento.
Così, lo so, questo sarà facile.
Diciamo che i nostri 2 numeri sono 1111, e 1111, così siamo in binario in questo momento.
In decimali reali, se si vuole pensare in questo modo, a = 15 e b = 15.
E quindi ci aspettiamo, dopo che li abbiamo scambiare - non hanno nemmeno bisogno di essere gli stessi numeri,
ma l'ho fatto in questo modo.
Facciamo in modo che non li stessi numeri. Facciamo 1111 e 0001.
Quindi a = 15 e b = 1.
Dopo li scambiare, ci aspettiamo 'a' a 1 e b di essere 15.
Così il nostro primo passo è a = a + b.
I nostri numeri sono solo 4 bit, in modo da 'a', che è 1111, + b, che è 0001,
sta per finire per essere 10000, ma abbiamo solo 4 bit.
Così ora a = 0.
E ora vogliamo impostare b = a - b - in realtà, questo funziona ancora alla perfezione.
a = a - b - vediamo se questo funziona alla perfezione.
Allora b = 0 - 1, che sarebbe ancora 15, e quindi a = a - b, che sarebbe 1.
Forse questo funziona.
Mi sento come se ci fosse un motivo per non funziona con normale.
Ok, quindi sul presupposto che non funziona con operazioni binarie regolari,
e io lo guarderò per - io Google per vedere se questo è vero.
Quindi vogliamo farlo utilizzando operatori bit a bit, e l'indizio qui è XOR.
Quindi, l'introduzione di XOR (^) se non l'avete ancora visto.
E ', ancora una volta, un operatore bit per bit in modo che agisce poco a poco, e E'-
Se hai i bit 0 e 1, allora questo sarà 1.
Se hai i bit 1 e 0, sarà 1, si ha i bit 0 e 0 sarà 0,
e se si hanno i bit 1 e 1 sarà 0.
Così è come OR. Se uno dei bit sono vere, è 1, ma a differenza di O, non possono essere entrambi i bit che sono vere.
O sarebbe questo essere di 1, XOR avrebbe questo a 0.
Quindi stiamo andando a voler utilizzare XOR qui.
Pensateci per un minuto, ho intenzione di Google.
Beh, non si può leggere che, io sono attualmente sulla pagina algoritmo XOR swap.
Speriamo che questo spiega perché Io non posso -
Questo è esattamente l'algoritmo che abbiamo appena fatto.
Non riesco ancora a capire perché - devo aver appena preso un cattivo esempio,
ma questo caso, dove 'a' è successo a divenire 0, dopo aver ottenuto a 5 bit, così ora 'a' è pari a 0,
questo è ciò che si chiama "integer overflow".
Secondo Wikipedia, "A differenza dello swap XOR, questa variante è necessario che esso utilizza alcuni metodi
garantire che x + y non causa un overflow ".
Quindi questo ha problemi, questo era integer overflow, ma ho fatto qualcosa di sbagliato.
Non ne sono sicuro. Cercherò di venire con un altro.
[Studente] Beh, non è integer overflow quando si sta cercando di mettere un numero in là
più grande la quantità di bit che hai assegnato?
Gia '. Abbiamo 4 bit. That's - avevamo 4 bit, che quindi si tenta di aggiungere 1 ad esso, così si finisce con 5 bit.
Ma il quinto bit appena viene tagliato fuori, si '.
Si potrebbe in realtà -
[Studente] Questo ti genera un errore, o lo fa - vorrei che genera un errore?
No. Quindi non c'è alcun errore. Quando si arriva al livello di assieme, un po 'speciale
da qualche parte si trova che ha detto che c'era un overflow, ma in C è di tipo semplicemente non fare con questo.
In realtà non si può fare con esso a meno di usare le istruzioni di montaggio speciali in C.
Pensiamo di swap XOR.
E credo che l'articolo di Wikipedia potrebbe essere anche stato detto che -
Così anche portato aritmetica modulare, quindi credo che era, in teoria, fare aritmetica modulare
quando ho detto che 0-1 è il 15 di nuovo.
In modo che potrebbe in realtà - su un processore regolare che fa 0 - 1 = 15.
Dal momento che si finisce a 0, sottraiamo 1, così poi si avvolge appena tornato intorno al 1111.
Quindi questo algoritmo potrebbe effettivamente funzionare, l'a + b, l'a - b, b - a, che potrebbe andare bene.
Ma ci sono alcuni processori che non farlo, e quindi non sarebbe bene in quelli specifici.
Di swap XOR funziona su qualsiasi processore. Va bene.
L'idea è che si suppone essere la stessa, però.
Dove stiamo usando XOR per ottenere in qualche modo l'informazione, sia in 1 delle variabili,
e quindi estrarre le informazioni delle singole variabili di nuovo.
Così qualcuno ha idee / la risposta?
[Risposta studente, incomprensibile]
Quindi questo dovrebbe funzionare, e anche, XOR è commutativo.
Indipendentemente da quale ordine questi 2 numeri capita di essere qui,
questo risultato sarà lo stesso.
Quindi, a ^ b è b ^ a.
Si potrebbe anche vedere questo scritto come a ^ = b, b ^ = a, a ^ = b di nuovo.
Quindi questo è giusto, e capire perché questo funziona, pensate dei bit.
Utilizzando un numero piuttosto piccolo, diciamo 11001, e 01100.
Quindi questo è 'a', questo è b.
Quindi, a ^ = b.
Stiamo per essere l'impostazione 'a' = a XOR di queste 2 cose.
Così 1 ^ 0 è 1; 1 ^ 1 è 0; 0 ^ 1 è 1, e 0 ^ 0 è 0, 1 ^ 0 è 1.
So 'un,' se si guarda al numero decimale, che sta per essere -
non si sta andando a vedere molto di una relazione tra l'originale 'a' e il nuovo 'a,'
ma guardando i bit, 'a' è ora come una rete di informazioni
sia l'originale 'a' e il b originale.
Quindi, se prendiamo b ^ a, vediamo che finiremo in originale 'a.'
E se prendiamo l'originale 'a' ^ il nuovo 'a,' vediamo finiamo in b originale.
Quindi (a ^ b) ^ b = l'originale 'a.'
E (a ^ b) ^ a = b l'originale.
Vi è - un altro modo di vedere questo è XOR nulla per sé è sempre 0.
Quindi 1101 ^ 1101, tutti i bit saranno uguali.
Quindi c'è mai sarà un caso in cui 1 è uno 0 e l'altro è 1.
Quindi questo è 0000.
Lo stesso con questo. (A ^ b) ^ b è come a ^ (b ^ b).
(B ^ b) sta per essere 0, a ^ 0 è solo andare a essere 'una,' dal momento che tutti i bit sono 0.
Quindi gli unici che stanno per essere dove 'a' era in origine un 1 - aveva quelle.
E la stessa idea: ecco, io sono abbastanza sicuro che sia anche commutativa.
Gia '. Ho detto prima che era commutativa.
Il ^ 'a,' ed è associativa, così ora (b ^ a) ^ a.
E possiamo farlo b ^ (a ^ a).
E così ancora una volta, si ottiene il b originale.
Quindi 'a' è ora la combinazione di 'A' e B insieme.
Utilizzando il nostro nuovo combo 'a' diciamo b = combo 'a' ^ il b originale, si ottiene l'originale 'a.'
E ora un combo = 'a' ^ la nuova b, che era l'originale - e che ora è quello che era 'a' o b.
Questo è il caso qui. Questo è = b, b vecchio.
Così ora tutto è tornato in ordine scambiati.
Se effettivamente guardato i bit, b = a ^ b, sta per XOR questi 2,
e la risposta sarà questa, e poi a = a ^ b è XOR questi 2 e la risposta è questa.
Domande? Va bene. Così l'ultimo è alquanto significativamente più difficile.
[Studente] Credo che abbia una domanda su di esso. >> Oh, mi dispiace.
[Studente] Che in realtà è più veloce? Se si utilizza questo XOR, o è, se si dichiara una nuova variabile?
Allora, qual è il più veloce, che dichiara una nuova variabile o utilizzando XOR per scambiare?
La risposta è, con ogni probabilità, una variabile temporanea.
E questo è perché una volta che è compilato fino - in modo a livello di assembly,
non c'è una cosa come le variabili locali o altre variabili temporanee o qualsiasi di queste cose.
Sono come - c'è la memoria, e ci sono registri.
I registri sono dove le cose sono attivamente accadendo.
Non aggiungere 2 cose a memoria, si aggiungono 2 cose nei registri.
E si mettono le cose dalla memoria nei registri per poi aggiungere,
e allora si potrebbe metterli di nuovo in memoria, ma tutta l'azione avviene in registri.
Così, quando si sta utilizzando il metodo variabile temporanea, di solito quello che succede è
questi 2 numeri sono già in registri.
E poi da quel momento in poi, dopo averli scambiati,
ti basta iniziare a utilizzare il registro altro.
Ovunque tu fossi stato con b, sarà sufficiente utilizzare il registro che già l'archiviazione 'a.'
Quindi non ha bisogno di fare niente a che fare effettivamente la swap. Si '?
[Studente] Ma ci vuole anche più memoria, giusto?
Ci vorrà solo più memoria se è necessario per memorizzare la variabile temporanea.
Come se in seguito utilizzare tale variabile temporanea di nuovo da qualche parte,
allora - o si assegna qualcosa a quella variabile temporanea.
Quindi, se in qualsiasi punto nel tempo 'a,' b in temperatura hanno valori distinti o qualcosa del genere,
poi sta andando ad avere posizioni distinte nella memoria, ma è vero che
ci sono molte variabili locali che esistono solo nei registri.
In questo caso, non è mai messa in memoria, e così non si è mai spreco di memoria.
Va bene. L'ultima domanda è un po 'di più.
Ecco, in questo apparecchio CS50, c'è un dizionario.
E la ragione di questo è perché [?? B66] è un correttore ortografico in cui sarete scrittura
utilizzo di tabelle hash o cerca o qualche struttura dei dati.
Hai intenzione di scrivere un correttore ortografico, e avete intenzione di utilizzare questo dizionario per farlo.
Ma per questo problema, stiamo solo andando a guardare per vedere se una parola nel dizionario.
Così, invece di memorizzare l'intero dizionario in qualche struttura dati
e poi guardando su un intero documento per vedere se qualcosa è errato,
vogliamo solo trovare 1 parola. Quindi possiamo solo eseguire la scansione su l'intero dizionario
e se non si trova la parola nel dizionario intero, allora non era lì.
Se eseguire la scansione su l'intero dizionario e si vede la parola, allora siamo a posto, abbiamo trovato.
Qui si dice che vogliamo iniziare a guardare di C file di funzione di gestione,
dal momento che vuole leggere il dizionario,
ma darò il suggerimento qui per quali funzioni si dovrebbe pensare.
Io li scriverai sugli spazi.
Quindi i principali ti consigliamo di guardare sono f aperta e poi, inevitabilmente, f chiuso,
che andrà alla fine del programma, e f f scansione.
Si potrebbe anche usare f leggere, ma probabilmente non si vuole
perché - non si finisce per dover tale.
F scansione f è quello che si sta andando ad essere utilizzata per la scansione sul dizionario.
E così non c'è bisogno di codificare la soluzione, basta provare e come pseudo-codice la tua strada
ad una soluzione, e poi ne discuteremo.
E in realtà, dal momento che già ti ha dato questi, se si va in un qualsiasi terminale o shell del vostro apparecchio,
Vorrei - di solito - se non l'avete ancora visto, non so se l'avete fatto in classe,
ma l'uomo, in modo che le pagine man, sono piuttosto utili per guardare praticamente qualsiasi funzione.
Così posso fare, come, f uomo, scansione f.
Questo è ora le informazioni sulla famiglia di funzioni f scansione.
Potrei anche fare f uomo, aperti, e che mi darà i dettagli di quella.
Quindi, se si sa cosa si sta utilizzando la funzione, o stai leggendo il codice
e si vede un po 'di funzione e siete come, "Cosa fare?"
Solo l'uomo che la funzione nome.
Ci sono un paio di esempi bizzarri in cui si potrebbe dire
piace. man 2 che nome della funzione, o uomo 3 che nome della funzione,
ma hai solo da fare che l'uomo se il nome di funzione non è capitato di lavorare per la prima volta.
[Studente] Così sto leggendo la pagina di manuale di aperto, ma io sono ancora confuso su come usarlo e il programma.
Va bene. Un sacco di pagine di manuale sono meno disponibile.
Sono più utili se già sanno quello che fanno
e poi basta ricordare l'ordine degli argomenti o qualcosa del genere.
Oppure possono darvi una panoramica generale, ma alcuni di loro sono molto travolgente.
Come f f scansione, anche. Ti dà le informazioni per tutte queste funzioni,
e 1 riga giù succede qui per dire, "F scansione f legge dal punto di stringa o un flusso."
Ma f aprire. Quindi, come si usa f aperto?
L'idea di un programma che ha bisogno di fare file di I / O che
è necessario prima di aprire il file che si desidera fare le cose con, e, inevitabilmente,
leggere le cose da quel file e fare cose con loro.
F aperto è quello che usiamo per aprire il file.
La cosa torniamo, quindi quale file vogliamo aprire, ci dà la -
qui si dice "/ user / share / dict / words."
Questo è il file che si desidera aprire, e vogliamo aprire -
dobbiamo specificare esplicitamente se vogliamo aprirlo per leggere o se vogliamo aprirlo per scrivere.
Ci sono un paio di combinazioni e roba del genere, ma vogliamo aprire questo per la lettura.
Vogliamo leggere dal file.
Che cosa significa questo ritorno? Esso restituisce un file di stelle (*),
e mi limiterò a mostrare tutto nella variabile f, così *,
ancora una volta, si tratta di un puntatore, ma non vogliono trattare con i puntatori.
Si può pensare di f come, f è la variabile che si vuole utilizzare per rappresentare il file.
Quindi, se si desidera leggere dal file, si legge da f.
Se si desidera chiudere il file, si chiude f.
Così, alla fine del programma quando inevitabilmente vuole chiudere il file, cosa dobbiamo fare?
Vogliamo chiudere f.
Così ora la funzione di ultimo file che stiamo andando a voler utilizzare è la scansione f, f f scansione.
E che cosa è che fa la scansione sul file alla ricerca di un modello da abbinare.
Guardando la pagina man di qui, vediamo int f f scansione, ignorare il valore restituito per il momento.
Il primo argomento è il flusso di file *, in modo che il primo argomento che stiamo andando a voler passare è f.
Stiamo scansione su f.
Il secondo argomento è una stringa di formato.
Vi darò una stringa di formato in questo momento.
Penso che ci capita di dire, 127S \ n, un sacco di che è inutile.
L'idea di ciò che è stringa di formato, è che si può pensare di f scansione come l'opposto di f stampa.
Quindi f stampa, stampa f usiamo anche questo tipo di parametro format,
ma in f stampa quello che stiamo facendo è - diamo un'occhiata a un equivalente.
Quindi stampare f, e c'è in realtà anche f f stampa, in cui il primo argomento sarà f.
Quando si stampa f, si potrebbe dire qualcosa come: "127S stampa \ n" e poi se la passa un po 'di spago,
sta andando a stampare questa stringa e poi una nuova linea.
Che cosa significa 127, sono abbastanza sicuro, ma non ho mai sono limitato ad esso,
Non sarebbe nemmeno bisogno di dire '127 'nel f stampa,
ma cosa vuol dire è stampare i primi 127 caratteri.
Quindi sono abbastanza sicuro che è il caso. Potete Google per questo.
Ma nel prossimo Sono quasi positivo significa che.
Quindi questo è stampare i primi 127 caratteri, seguito da una nuova riga.
F scansione f ora, invece di guardare una variabile e la stampa,
sta andando a guardare un po 'di spago, e memorizzare il pattern nella variabile.
Facciamo effettivamente utilizzare f scansione in un esempio diverso.
Quindi diciamo che abbiamo avuto un po 'di int, x = 4,
e abbiamo deciso di creare una stringa in - ha voluto creare la stringa
che era come, ciò avverrà molto più tardi,
qualcosa che è proprio come 4.jpg.
Quindi questo potrebbe essere un programma in cui si avrà contatore somma,
Riassumendo contrastare i, e si desidera salvare un gruppo di immagini.
Così si vuole salvare i.jpg, dove i è un po 'iterazione del ciclo.
Quindi, come possiamo rendere questa stringa per quella JPEG?
Se si voleva stampare 4.jpg, potremmo semplicemente dire f stampa, d.jpg%,
e allora sarebbe stampare per che JPEG.
Ma se vogliamo salvare il 4.jpg stringa, usiamo f scansione.
Quindi la stringa s - in realtà abbiamo Can '- carattere, char s, andiamo 100.
Così ho dichiarato alcuni array di 100 caratteri,
e questo è quello che stiamo inevitabilmente sarà la memorizzazione JPEG che trovi
Così abbiamo intenzione di utilizzare f scansione e il formato, come si direbbe d.jpg%
per stampare 4.jpg, il formato di questo sta per essere d.jpg%.
Quindi il formato è d.jpg%, ciò che vogliamo sostituire d con% è x,
e ora abbiamo bisogno di memorizzare la stringa da qualche parte.
E dove andremo a memorizzare la stringa è in s la matrice.
Così, dopo questa riga di codice, s, se stampiamo f, s% della variabile s,
sta andando a stampare 4.jpg.
Quindi f f scansione è la stessa scansione f, solo che adesso sta guardando oltre questo file
per quello di memorizzare in s.
Questo è ciò che l'ultimo argomento sarà.
Vogliamo archiviare - "famiglia f scansione delle scansioni delle funzioni sia in base al formato, come ha cercato di seguito.
Se sono memorizzati nei punti di locazione che potrebbe restituire - "
No, potrebbe essere buono. Fammi pensare per un secondo.
Quindi scansione f non - cosa diavolo è la funzione che fa questo?
Quindi scansione f non sta andando a prendere un numero intero e fare punti jpg.
E 'intenzione di [borbotta].
Salva variabile int in stringa int C.
Che cosa è questa variabile, o che cosa è questa funzione si chiama?
Sì. That's - sì. Quindi quello che è stato la definizione di a te prima era s f stampa,
che - che rende molto più senso, perché ho detto che era molto più simile f stampa.
Scan f è ancora un po 'come f stampa, ma f stampa s sta per eseguire la scansione sopra
e sostituire le variabili e ora memorizzare in una stringa.
Invece di stamparlo, lo memorizza in una stringa.
Così ignorarlo del tutto. È ancora possibile pensare a come l'identificatore di formato simile a quello di f stampa.
Così ora, se volessimo fare la cosa 4.jpg, faremmo stampa f s, x di questo.
Così che cosa sta facendo la scansione f - ciò che è stato la tua domanda sarebbe?
[Studente] Sono solo confuso su quello che stiamo cercando di fare qui
con tale JPEG. Può spiegare che il tempo altri 1?
Quindi questo è stato - è meno relevent di scansione f f ora, si spera, sarà legare indietro in qualche modo.
Ma quello che inizialmente aveva intenzione di mostrare era - questo è in realtà direttamente rilevante per questi [?? F5]
Si sta andando ad utilizzare f stampa s, dove, dire che abbiamo 100 immagini,
e si desidera leggere immagine 1.jpg, 2.jpg, 3.jpg.
Quindi, per fare questo, è necessario f aperto, e poi si deve passare la stringa che si desidera aprire.
Quindi, vorremmo aprire 1.jpg, al fine di creare la stringa che è 1.jpg,
facciamo s f stampa di% d.jpg--non abbiamo fatto per int i = 0.
i <40, i + +.
Quindi stampa% s f d.jpg di i.
Così, dopo questa linea, ora la variabile o l'array s sta per 1.jpg.
In alternativa, 0.jpg, 1.jpg, 2.jpg. E così siamo in grado di aprire, a sua volta, ogni immagine per la lettura.
Quindi, questo è ciò che s stampare f fa. Vedete quello che s stampare f sta facendo?
[Studente] Ok, quindi è tenuto - si crea una stringa, something.jpg, e quindi lo memorizza.
Sì. Si crea - questa è un'altra stringa di formato, proprio come f f scansione e di stampa,
in cui inserisce tutte le variabili nel secondo argomento, potrebbe essere s in contrasto con i.
Forse - Voglio dire, questo è il caso. Ma qualunque sia l'ordine degli argomenti è.
E 'intenzione di inserire tutte le variabili nella stringa di formato
e quindi memorizzare nel nostro buffer; lo chiamiamo un buffer, e 'dove stiamo memorizzare la stringa.
Così abbiamo memorizzato all'interno di s della stringa formattato correttamente, d% e sono state sostituite con 4.
[Studente] Quindi, se abbiamo fatto questo, è la variabile f solo andando a essere riassegnati?
Sì. Quindi dovremmo chiudere il f originale prima di fare questo.
Ma - e poi anche, se non ci fosse un f aprire qui, allora ci sarebbe bisogno di dire -
Gia '. Ma sarebbe aprire un centinaio di file diversi.
[Studente] Ma non sarebbe in grado di accedere o - bene.
Va bene. Così scansione f, f f scansione, è una specie della stessa idea,
ma invece di, invece di memorizzare in una stringa, è più come sei ora
andare oltre una puntura e pattern matching contro quella stringa e memorizzare i risultati in variabili.
È possibile utilizzare f scansione per analizzare una cosa del genere 4.jpg, e memorizzare i 4 intero in x int somma.
Questo è ciò che siamo in grado di usare f scansione per.
F scansione f sta per farlo a riga di comando.
In realtà sono abbastanza sicuro che questo è ciò che la biblioteca CS50 fa.
Quindi, quando si dice, "get int", è scan f-zione over - f scansione è il modo in cui si ottiene l'input dell'utente.
F scansione f sta per fare la stessa cosa ma utilizzando un file per la scansione su.
Così qui, ci sta eseguendo la scansione su questo file.
Il modello che stiamo cercando di abbinare è una stringa che è di 127 caratteri
seguita da una nuova linea
Quindi sono abbastanza sicuro che si potrebbe anche solo dire "match s", poiché nel dizionario
ci capita di avere, abbiamo garantito nessuna parola è che a lungo,
e anche f f scansione, credo, si ferma alla nuova linea non importa quale.
Ma ci sono la nuova linea nella partita, e -
[Studente] Se non abbiamo incluso la nuova linea, non sarebbe trovare le parti di una parola?
It - ciascuno - guardando il dizionario -
Così nel dizionario, queste sono tutte le nostre parole.
Ognuno è su una nuova riga.
La scansione f sta per prendere questa parola.
Se non si include la nuova linea, allora è possibile che il f scansione successiva sarà solo leggere la nuova linea.
Ma anche la nuova linea allora ignorare la nuova linea.
Ma non arriveremo mai parte di una parola, dal momento che siamo sempre di lettura fino a una nuova linea, non importa quale.
[Studente] Ma cosa succede se si cerca la parola "Cissa", come Cissa.
Sarà essa ritiene che, e dire che è una partita?
Ecco allora - si legge in - questo è in realtà un buon punto.
Non abbiamo mai sta usando la corrente - la parola che stiamo cercando è il primo argomento della riga di comando.
Così stringa, parola = argv 1.
Quindi la stringa che stiamo cercando è argv 1.
Non stiamo cercando una parola a tutti nel nostro f scansione.
Quello che stavamo facendo con scansione f sta diventando ogni parola nel dizionario,
e poi una volta che abbiamo questa parola che andremo a utilizzare strcmp per confrontare i loro.
Stiamo andando a confrontare la nostra parola e quello che abbiamo appena letto trovi
Così, inevitabilmente, stiamo andando a finire per fare un po 'di scansione fs
fino a quando si da il caso che f scansione tornerà -
restituisca uno, finché ha trovato una nuova parola,
e sarà tornare qualcosa di diverso non appena è riuscito a corrispondere alla parola.
Stiamo rileggendo l'intero dizionario, la memorizzazione riga per riga ogni parola nella variabile s.
Allora stiamo confrontando parola con s, e se il confronto == 0,
strcmp capita di portare 0 se una partita è stata fatta.
Quindi, se fosse 0, allora siamo in grado di stampare f, abbinato,
o parola è nel dizionario, o qualsiasi altra cosa che si desidera stampare f.
E poi - non vogliamo chiudere f più e più volte.
Questo è il genere di cose che vogliamo fare, e non sono solo in cerca di parola nel dizionario.
Così abbiamo potuto farlo, se volessimo cercare il loro modello, Cissa, come hai detto tu prima,
se volessimo cercare quel modello, allora fallirebbe nel caso
perché non è in realtà una parola, ma una delle parole nel dizionario che succede ad avere in esso.
Quindi sarebbe abbinare a questa parola, ma questo sottoinsieme della parola non è una parola stessa.
Ma non è il modo in cui lo si utilizza, stiamo leggendo in ogni parola
e quindi confrontando la parola che abbiamo con quella parola.
Quindi stiamo sempre confrontando parole piene.
Posso inviare le soluzioni finalizzate tardi.
Questa è una specie di quasi la risposta giusta, credo.
[Commento Studente, incomprensibile]
Oh, ho sbarazzarsi di quella prima? Char s, credo che abbiamo detto 127 - ho dimenticato quello che il più grande è.
Non ci resta che fare 128, così ora s è abbastanza lunga.
Non abbiamo bisogno di stampare nulla.
Stiamo anche andando a voler avere a chiudere il nostro file, e che dovrebbe essere di circa la risposta giusta.
CS50.TV