Ciao e bentornato.
In questa conferenza, mi piacerebbe per
parlare di come leggere il testo da un file.
Per ora, lo faremo concentrarsi sulla lettura di file di testo.
Quindi, se vogliamo leggere il carattere da un file di testo,
utilizzeremo un paio di funzioni.
Il primo sarà fgetc.
Questo leggerà un personaggio da un testo file che è stato aperto per la lettura.
Ricorda, dobbiamo sempre aprire il file prima di poter eseguire qualsiasi operazione su
di esso a meno che è una ridenominazione o una cancellazione e
quindi il file non può essere aperto.
Ma se vuoi leggere e scrivendo o aggiungendo,
dobbiamo aprire quel file.
Sappiamo che possiamo aprirci file con modalità diverse.
In questo caso per la lettura, avremmo per aprire con una r o una r
plus, e quindi possiamo iniziare a chiamare fgetc.
La funzione fgetc accetta il puntatore al file come
unico argomento e restituirà il carattere letto come tipo int.
Quindi qui un esempio, creiamo un mchar digita int e diciamo fgetc pfile.
Leggerà un personaggio nella variabile mchar con pfile come
puntatore di file.
Pensa a pfile già stato aperto torna al puntatore del file.
Il mchar è di tipo perché e di cui è il nostro carattere speciale
la nostra fine del file, che viene restituito se è stata raggiunta la fine del file.
Quindi possiamo sempre verificarlo intero per vedere se è eof.
E se lo è, non lo vogliamo per
leggere più, non vogliamo più chiamare fgetc.
La funzione fgetc, che è è disponibile anche equivalente a fgetc.
Quindi getc è quasi uguale a fgetc, vuoi solo usare fgetc.
Penso che ne abbia alcuni più protezione in esso.
Con getc, richiede un argomento di tipo file star e restituisce e
restituisce il carattere rosso come tipo int.
È praticamente identico a fgetc.
L'unica differenza tra loro è che getc può essere implementato come macro
e non lo facciamo nemmeno sapere cos'è una macro ora.
Quindi continueremo con usando fgetc come nostra funzione per leggere
i caratteri.
Puoi leggere il contenuto di un file.
Di nuovo, quando necessario, puoi usare questa funzione di riavvolgimento che posiziona
il file specificato dal file puntatore all'inizio del file.
Quindi puoi usare rewind if vuoi leggere di nuovo.
Dì solo riavvolgi e poi il puntatore di file, piuttosto semplice.
Quindi ecco un esempio.
Devi includere il file intestazione io standard ogni volta
che eseguiamo operazioni sui file.
Nella nostra funzione principale, siamo andando a creare il nostro puntatore di file.
Se voglio inizializzarlo su null e creeremo un numero intero.
La prima cosa che faremo è lo siamo apriremo
il file usando la chiamata f open, e specificheremo il nome del file e specificheremo
che è in lettura.
Ciò restituirà il nostro puntatore al file.
Quindi ora il nostro puntatore fp è che punta a un file valido.
Se non è stato possibile aprire il file. TXT non è
nel percorso giusto o altro, restituirà null.
Quindi vuoi verificare la presenza di null, assicurati che fp non sia nullo.
Se è nullo, esci dal programma.
Altrimenti, quando di solito leggi i caratteri, li avrai all'interno
di un ciclo.
Quindi qui stiamo dicendo mentre c è uguale a fgetc fp, questo sta leggendo un carattere
dal nostro file, passando il puntatore del file a fgetc, che restituisce
un numero intero.
Ricorda, possiamo saltare fuori dal giro se quel numero intero restituito è la fine del file
perché non lo vogliamo per leggere oltre la fine del file.
Altrimenti, possiamo semplicemente stampare il nostro carattere usando le percentuali c e c.
L'ultima cosa che vogliamo fare è noi vogliamo chiudere il file, quindi vogliamo
impostare il nostro puntatore al file a null e possiamo tornare.
Proviamo a utilizzarlo, creando questo all'interno di blocchi di codice.
Ecco il nostro programma all'interno di blocchi di codice.
Dice che questo programma non funzionerà funziona a meno che non abbiamo un file su disco ovunque
sia in esecuzione il programma.
Quindi prima se lo costruiamo, dovrebbe essere compilato correttamente, dovrebbe creare
un eseguibile da qualche parte sul tuo disco rigido.
Ho messo tutti i miei progetti all'interno della mia directory di prestiti dot.
Quindi se vado ai miei download directory e vado al nome
del progetto, che è solo un test progetto quindi ovunque tu stia memorizzando i tuoi progetti, i
miei sono in prova.
Se vado a fare un test, vedrai quello all'interno della directory bin, all'interno di
debug è il tuo eseguibile.
Qui è dove crei il tuo file file se avevi un parente.
Percorso quindi qui potrei semplicemente creare un file nuovo file e possiamo averlo come file di
testo, quindi posso semplicemente crearlo come testo document e deve essere denominato file.
E poi vado a mettere alcune informazioni in esso.
Inserirò solo alcuni dati come ciao questo è il line feed di Jason.
Va bene, no, così via, e lo salverò.
Questo file deve esistere in fare in modo che questo programma funzioni.
Quindi ho creato il file.
Ora, quando lo eseguo, si spera leggerà ciò che ho
appena aggiunto e lo stamperà.
Dice errore e apertura del file file nessuna directory di file
di questo tipo, e probabilmente è perché io averlo nella cartella di debug.
E questo non è in esecuzione nel debug.
Quindi proviamo a eseguirlo in debug e Penso che probabilmente funzionerebbe ora.
Possiamo dire debug, start.
Questo cercherà l'eseguibile si spera nella directory di debug.
Vogliamo assicurarci che venga eseguito.
Ancora non c'è, quindi devi fare sicuro di sapere dove si trova l'eseguibile.
Proviamo da qualche altra parte o meglio ancora potrei semplicemente eseguire l'eseguibile all'interno
del debug directory e dovrebbe trovarlo lì.
Quindi se faccio doppio clic qui, in realtà um non si ferma.
Salta fuori.
Quindi quello che puoi fare per
questo è invece di tornare indietro puoi dire pausa di sistema e non uscirà il programma finché non lo si esegue.
Quindi proviamolo ora.
Quindi ora in pausa, no eseguire il programma.
E quello che hai visto è stato ciao questo è Jason.
È stato in grado di trovare il file, stampato bene, stampato
no e poi si è fermato.
Altrimenti, quando esegui il programma, stampa i dati così velocemente
ed esce dal file programma che hai finito.
Quindi è così che puoi testarlo.
Deve essere memorizzato dove si trova l'eseguibile è archiviato da dove viene eseguito.
Deve essere in esecuzione da qualche parte altro nella directory del progetto.
Non sono sicuro da dove stia scappando.
Potremmo provare a spostare il file dove si trova il codice sorgente.
Potrebbe eseguirlo da qui.
Quindi qui lo metteremo qui.
E ora proveremo a eseguirlo da l'ID e forse funzionerà.
Non costruiamo.
Lo abbiamo eseguito ed è stato in grado di trovarlo.
Quindi sembra che l'abbiamo fatto per mettere il file all'interno di dove si trova
il codice sorgente.
Quindi finché mettiamo quel file file. testo all'interno del file
di progetto, sarai in grado di vederlo.
Quindi rapido esempio di come puoi apri un file e leggi singoli caratteri, non
il più efficiente modo di leggere da un file perché di solito
vuoi leggere le stringhe.
Ma questo lo aprirà.
Vedi la chiamata aperta f, e noti il ciclo while.
È importante.
Torniamo indietro e parliamo di come possiamo leggere le stringhe da un file che
è molto più efficiente.
Quindi questa è la lettura di un singolo carattere.
Che ne dici di leggere una stringa?
Puoi usare la funzione fgets per leggere da qualsiasi file o flusso.
Questo leggerà una stringa.
Ci vuole una stringa di caratteri ha il primo parametro.
Il numero di caratteri che desideri read e quindi il puntatore del file effettivo.
Quindi questa funzione sta per legge una stringa nell'area
di memoria indicata dallo str.
Quindi devi davvero passare nel buffer in cui
verranno archiviati i dati.
E questo è un puntatore, quindi dovresti devo allocare memoria per questo.
E poi leggerà da il file specificato come terzo parametro che
è il puntatore del file.
E poi il nchar sta andando per dire quanti dati leggere.
Quindi, se metti nchars come 10, leggerà in 10 caratteri a meno che
non colpisca prima un avanzamento riga.
Quindi leggerà un file l'intera riga o leggerà il numero di
caratteri che hai specificare nel secondo parametro.
La fine della riga è specificata da barra rovesciata n a seconda di quale si verifica per prima.
Se un carattere di nuova riga è rosso, viene mantenuto
nella stringa e sarà un terminatore nullo aggiunto alla fine della stringa.
Quindi, se hai effettivamente specificato più caratteri, verrebbe letto fino all'avanzamento riga, e
poi salta fuori e poi ottiene quel nuovo carattere
di linea e inserisce un carattere null alla fine di esso.
Se non ci sono errori, fgets lo è restituirà il puntatore,
che è il primo parametro.
Restituirà un puntatore che viene restituito dalla funzione.
E poi sta anche andando per popolare il puntatore
str come primo parametro.
In caso di errore viene restituito null.
E poi leggendo la fine del file fa sì che venga restituito null, il che significa
che leggi tutte le tue stringhe.
Quindi diamo un'occhiata a un esempio.
Qui abbiamo il nostro principale, e stiamo creando il nostro puntatore al file creando
una stringa di caratteri.
Ecco un puntatore che non abbiamo fatto mallocate tutti i dati per esso, creiamo solo
un array di caratteri.
Apriamo il file per la lettura, leggendo solo perché è r.
Abbiamo detto che se è nullo, salta fuori.
Altrimenti, diciamo solo fgets, leggiamo in 60 caratteri.
O se l'avanzamento riga è prima che, verrà visualizzato un
avanzamento riga e quindi lo stamperà e cosa c'è mai nel buffer str.
Quindi str è il primo personaggio che è passato.
E poi chiudiamo il puntatore del file, impostalo su null e restituisci zero.
Quindi diamo di nuovo un'occhiata a questo all'interno del nostro codice blocca IDE.
L'unica cosa che è cambiata in questo il programma è in realtà dalle righe dalla 14 alla 17.
Stiamo usando fgets per leggere la nostra stringa in, e quindi abbiamo un buffer str.
Quindi dobbiamo anche creare un file array
di caratteri qui sopra che è il nostro str, e vogliamo che contenga 60.
Stiamo leggendo in 60.
Aggiungeremo un avanzamento riga, quindi è leggerà 59 e poi aggiungerà un avanzamento riga alla
fine di esso.
Quindi potremmo dire 61.
E poi entreranno gli fgets un'istruzione if, e leggerà in ogni
stringa fino a quando non sarà una delle due colpisce 60 caratteri o una nuova riga
e stamperà quella stringa.
Noterai che non è così un ciclo while, quindi non stiamo
leggendo fino alla fine del file.
Leggiamo la fine di file, otteniamo un null.
Quindi, se lo costruiamo, vogliamo farlo certo che abbiamo le nostre citazioni correttamente.
Ogni volta che si copia da PowerPoint rovina le virgolette.
E vogliamo essere sicuri abbiamo creato la nostra variabile c non viene
utilizzata va bene.
Quindi andiamo avanti ed eseguiamo questo.
E vedi ciao, questo è Jason.
Quindi in realtà leggi in un intero riga di testo dal file.
Si leggeva nella prima riga.
Quindi lo chiameresti di nuovo e leggi nella seconda riga.
Se modifichi il numero di byte leggi, diciamo che
vogliamo solo leggere 10, leggerebbe in 10 e poi restituirebbe quei
10 invece di leggere l'intera riga.
Quindi qui ce l'abbiamo solo ciao questo io.
Quindi leggerà in numero di caratteri il
secondo parametro o finché non ottiene una riga feed e lo memorizza in str.
Str è un array di caratteri.
Lo stampiamo fgets.
Fgets è molto di più efficiente per la lettura.
Perché non stiamo leggendo un personaggio e alla
volta, stiamo leggendo più dati.
Leggere un personaggio in un file il tempo non è così efficiente.
Quindi ora sappiamo leggere in singolo caratteri, sappiamo leggere in
stringhe fino a quando non leggono un nuovo riga o un numero di caratteri.
Ma puoi anche leggere input formattato da un file.
Quindi abbiamo getc, fgetc, fgets.
E ora ne abbiamo un altro funzione chiamata fscanf.
Questo è un input formattato.
L'input formattato è dato specificato da like ha un delimitatore o ha un formato
specifico ad esso associato.
Questa funzione fscanf accetta un file dal flusso e quindi un formato.
Il formato è proprio come il printf identificatori di formato che utilizzi.
Quindi, se vuoi leggere in numeri interi o raddoppia, è possibile specificare i dati
all'interno del file che vengono introdotti in
doppio e lo leggerà finché non vedrà proprio come lo scanf finché non vede uno spazio vuoto.
Quindi il primo argomento per fscanf funzione è un puntatore a un oggetto
file che identifica il flusso.
Dobbiamo sapere cosa file da cui stiamo leggendo.
Il secondo argomento per il la funzione è il formato.
Questa è una stringa c che contiene uno o più dei seguenti elementi.
Carattere spazio bianco, non spazio bianco carattere, specificatori di formato.
L'utilizzo è lo stesso di scanf e il in printf, ma invece
è da un file.
Quindi tra virgolette doppie, puoi mettere nel testo, puoi inserire spazi bianchi o caratteri
non bianchi, ma gli specificatori di formato sono davvero è il
modo in cui leggerete i dati.
E poi specifichi le variabili in cui vuoi leggerlo.
Quindi la funzione ritorna il numero di
elementi di input abbinati e assegnati con successo.
Quindi ecco come appare.
Noterai che il principale è creando tre array di caratteri, str1, str2 e
str3, di soli dieci byte ciascuno.
Creiamo un intero chiamato anno, abbiamo colpito un puntatore di file.
La prima cosa che facciamo apriamo il file.
In questo caso, stiamo aprendo pronto per la lettura e la scrittura.
Ma non scriveremo davvero qualsiasi cosa, mostreremo solo ciò che
stiamo leggendo da esso.
Controlliamo per assicurarci che il file pointer non è uguale a null.
E poi eccoci qui, in realtà mettere qualcosa nel file fputs.
Non ne abbiamo ancora parlato ma questo è scrivere qualcosa.
Concentrati qui su fscanf.
Il fscanf sta per leggere in dati formattati.
E quindi cosa farà leggerà in
tre stringhe separate da spazi.
E così vedi la percentuale come percentuale di spazio come percentuale di spazio
s percentuale di spazio d.
Allora stiamo dicendo dove siamo andando a leggerli nel nostro array
di tre caratteri e poi nel nostro anno e dobbiamo specificare l'operatore
dell'indirizzo per il nostro anno.
Ma i dati sono formattati in modo specifico quando è scritto.
E quando leggi qualcosa che è formattato, devi capire il formato
del file come è scritto.
Qui sappiamo che il file è stato scritto separando le stringhe con spazi bianchi.
Quindi è così che siamo andando a leggerlo.
E così possiamo leggerlo con una chiamata fscanf.
Possiamo usare il nostro modulo come specificatori come secondo argomento e quindi
numero variabile di argomenti per ciascuno separato da ogni virgola per specificare i dati
in cui vogliamo leggerlo.
E poi lo stampiamo dati, le tre stringhe nell'anno e poi di
nuovo chiudiamo il file.
E quindi questi sono i tre modi puoi leggere i dati da un file.
Puoi leggere i caratteri, puoi leggere in stringhe o puoi
leggere dati formattati.
E noterai il modo formattato farlo è molto simile a scanf.
Utilizzi specificatori di formato, variabili in cui leggere.
Avremo una sfida leggere i dati che ti aiuteranno a
familiarizzare con questo.
È piuttosto semplice.
Stai per fare la tua apertura chiamate, userete
i puntatori dei file e procedete per utilizzare queste tre funzioni.
Grazie.