Per facilità di consultazione, le informazioni nei dispositivi di archiviazione sono archiviate sotto forma di file.
File - area denominata memoria esterna dedicato per memorizzare l'array di dati. I dati contenuti nei file sono della più varia natura: programmi in linguaggio algoritmico o macchina; dati iniziali per il funzionamento di programmi o risultati dell'esecuzione di programmi; testi arbitrari; immagini grafiche eccetera.
Directory (cartella, directory): una raccolta denominata di byte su un supporto di memorizzazione, contenente il nome di sottodirectory e file, viene utilizzata nel file system per semplificare l'organizzazione dei file.
File system chiamato parte funzionale sistema operativo, che prevede l'esecuzione di operazioni sui file. Esempi di file system sono FAT (FAT - File Allocation Table), NTFS, UDF (usato sui CD).
Esistono tre versioni principali di FAT: FAT12, FAT16 e FAT32. Si differenziano per la profondità di bit dei record nella struttura del disco, ad es. il numero di bit allocati per la memorizzazione del numero del cluster. FAT12 viene utilizzato principalmente per floppy disk (fino a 4 KB), FAT16 per piccoli dischi, FAT32 per unità FLASH ad alta capacità (fino a 32 GB).
Considera la struttura file system usando FAT32 come esempio.
Struttura del file FAT32
I dispositivi di memoria esterna nel sistema FAT32 non dispongono di byte, ma di indirizzamento a blocchi. Le informazioni vengono scritte sul dispositivo di memoria esterno in blocchi o settori.
Un settore è la più piccola unità indirizzabile di archiviazione delle informazioni su dispositivi di archiviazione esterni. In genere, la dimensione del settore è fissata a 512 byte. Per aumentare lo spazio degli indirizzi dei dispositivi di memoria esterni, i settori vengono combinati in gruppi chiamati cluster.
Un cluster è un'unione di più settori, che può essere considerato come un'unità indipendente con determinate proprietà. La proprietà principale di un cluster è la sua dimensione, misurata nel numero di settori o nel numero di byte.
Il file system FAT32 ha la struttura seguente.
I cluster utilizzati per la registrazione dei file sono numerati a partire da 2. Di norma, il cluster n. 2 viene utilizzato dalla directory principale e, a partire dal cluster n. 3, viene archiviato un array di dati. I settori utilizzati per memorizzare le informazioni presentate sopra la directory principale non sono raggruppati.
La dimensione minima del file su disco è 1 cluster.
Il settore di avvio inizia con le seguenti informazioni:
- EB 58 90 - ramo e firma incondizionati;
- 4D 53 44 4F 53 35 2E 30 MSDOS5.0;
- 00 02 - il numero di byte nel settore (solitamente 512);
- 1 byte - il numero di settori nel cluster;
- 2 byte - il numero di settori di riserva.
Inoltre, il settore di avvio contiene le seguenti informazioni importanti:
- 0x10 (1 byte) - numero di tabelle FAT (solitamente 2);
- 0x20 (4 byte) - il numero di settori sul disco;
- 0x2С (4 byte) - numero del cluster della directory principale;
- 0x47 (11 byte) - etichetta del volume;
- 0x1FE (2 byte) - firma del settore di avvio (55 AA).
Il settore delle informazioni sul filesystem contiene:
- 0x00 (4 byte) - firma (52 52 61 41);
- 0x1E4 (4 byte) - firma (72 72 41 61);
- 0x1E8 (4 byte) - numero di cluster liberi, -1 se non noto;
- 0x1EC (4 byte) - numero dell'ultimo cluster registrato;
- 0x1FE (2 byte) - firma (55 AA).
La FAT contiene informazioni sullo stato di ciascun cluster su disco. I 2 byte inferiori dell'archivio FAT F8 FF FF 0F FF FF FF FF (che corrisponde allo stato dei cluster 0 e 1, che sono fisicamente assenti). Inoltre, lo stato di ogni cluster contiene il numero del cluster in cui continua il file corrente o le seguenti informazioni:
- 00 00 00 00 - il cluster è libero;
- FF FF FF 0F - fine del file corrente.
- 8 byte - nome file;
- 3 byte - estensione del file;
La directory principale contiene un set di record di informazioni a 32 bit per ciascun file, contenente le seguenti informazioni:
Quando si lavora con nomi di file lunghi (compresi i nomi russi), il nome del file è codificato nel sistema di codifica UTF-16. In questo caso vengono allocati 2 byte per la codifica di ogni carattere. In questo caso, il nome del file viene scritto nella forma della seguente struttura:
- 1 byte di sequenza;
- 10 byte contengono i 5 caratteri meno significativi del nome del file;
- attributo da 1 byte;
- 1 byte riservato;
- 1 byte - somma di controllo nome DOS;
- 12 byte contengono i 3 caratteri meno significativi del nome del file;
- 2 byte - numero del primo cluster;
- altri caratteri del nome lungo.
Lavorare con file in linguaggio C
Per un programmatore apri il fileè rappresentato come una sequenza di dati letti o scritti. Quando un file viene aperto, viene associato a Flusso di I/O... Le informazioni di output vengono scritte nel flusso, le informazioni di input vengono lette dal flusso.
Quando un flusso viene aperto per l'I/O, si associa a una struttura standard di tipo FILE, definita in stdio.h. La struttura FILE contiene informazione necessaria sul file.
Il file viene aperto utilizzando la funzione fopen(), che restituisce un puntatore a una struttura FILE, che può essere utilizzata per operazioni successive con il file.
FILE * fopen (nome, tipo);
nome - il nome del file da aprire (incluso il percorso),
type è un puntatore a una stringa di caratteri che determina come accedere al file:
- "r" - apre un file per la lettura (il file deve esistere);
- "w" - apre un file vuoto per la scrittura; se il file esiste, il suo contenuto viene perso;
- "a" - apre il file per scrivere fino alla fine (per aggiungere); il file viene creato se non esiste;
- "r +" - apre un file per la lettura e la scrittura (il file deve esistere);
- "w +" - apre un file vuoto per leggere e scrivere; se il file esiste, il suo contenuto viene perso;
- "a +" - apre il file per la lettura e l'aggiunta, se il file non esiste, viene creato.
Il valore restituito è un puntatore al flusso aperto. Se si verifica un errore, viene restituito NULL.
La funzione fclose() chiude il flusso o i flussi associati ai file aperti con fopen(). Il flusso da chiudere è determinato dall'argomento della funzione fclose().
Valore restituito: valore 0, se il flusso è stato chiuso correttamente; EOF costante se si è verificato un errore.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#includere
int principale () (
FILE * fp;
nome carattere = "mio.txt";
if ((fp = fopen (nome, "r")) == NULL)
{
printf ( "Impossibile aprire il file");
getchar ();
restituire 0;
}
// apri il file con successo
... // azioni richieste sui dati
fclose (fp);
getchar ();
restituire 0;
}
Lettura di un carattere da un file:
char fgetc (flusso);
L'argomento della funzione è un puntatore a un flusso di tipo FILE. La funzione restituisce il codice del carattere letto. Se viene raggiunta la fine del file o si verifica un errore, viene restituita la costante EOF.
Scrivere un carattere in un file:
fputc (carattere, flusso);
Gli argomenti della funzione sono un carattere e un puntatore a un flusso di tipo FILE. La funzione restituisce il codice del carattere letto.
Le funzioni fscanf() e fprintf() sono simili alle funzioni scanf() e printf(), ma funzionano con i file di dati e hanno un puntatore al file come primo argomento.
fscanf (flusso, "Formato di input", argomenti);
In questo articolo impareremo come leggere i dati dai file e scrivere informazioni sui file nei programmi C. File in si vengono utilizzati per salvare il risultato del programma C e utilizzarlo quando il programma viene riavviato. Ad esempio, puoi salvare i risultati dei calcoli, le statistiche di gioco.
Per lavorare con i file in C, devi connettere la libreria stdio.h
#includere
Lavorare con file in siè necessario impostare un puntatore al file in base all'esempio
FILE * il nome del puntatore del file;
ad esempio
FILE * pinna;
Imposta un puntatore a pinna su un file
Successivamente, è necessario aprire il file e associarlo al puntatore del file. Per aprire un file in C per la lettura, utilizzare il comando
Nome puntatore file = fopen ("percorso file", "r");
Ad esempio il seguente comando
fin = fopen ("C: \\ Utenti \\ utente \\ Desktop \\ data.txt", "r");
si aprirà il file data.txt che si trova sul desktop lungo il percorso C: \\ Users \\ user \\ Desktop Per conoscere il percorso del file, è possibile selezionare il file con il clic del mouse su bottone giusto mouse e selezionare le proprietà del file. Nella sezione Posizione, verrà elencato il percorso del file. Si noti che in C, il percorso è indicato con due barre.
Dopo aver lavorato con un file in C, devi chiuderlo usando il comando
fclose (nome del puntatore del file)
Lettura di informazioni da un file di testo in C
Per poter leggere i caratteri russi da un file, devi impostare il lavoro con il cirillico usando il comando
setlocale (LC_ALL, "Russo");
In questo caso, devi includere #include all'inizio del programma
Operatore Fscanf()
Per leggere una parola da file in si viene utilizzato il comando fscanf(). Questo comando è simile al comando per inserire le informazioni dalla tastiera, solo il primo parametro è un puntatore a un file
fscanf (puntatore al file, "% data input format1% data input format2 ...", & variabile1, & variabile2 ...);
Ad esempio il comando
fscanf (fin, "% d% d% d", & a, & b, & c);
legge dal file, che è legato alla pinna del puntatore del file, una riga di tre variabili intere
Diamo un'occhiata a un programma di esempio che legge da file di testo data.txt in cui tre colonne di cifre vengono scritte informazioni e le scrive negli array. Ogni colonna di informazioni ha il proprio array. Dettagli su.
#includere
#includere
principale ()
(int a;
int b;
int c;
int io;
// definisce un puntatore a un file
FILE * pinna;
// apre il file per la lettura
fin = fopen ("C: \\ Utenti \\ utente \\ Desktop \\ data.txt", "r");
// legge riga per riga dal file
per (i = 0; io<3;i++)
{
// leggi una stringa di tre valori di file e scrivi negli array
fscanf (fin, "% d% d% d", & a [i], & b [i], & c [i]);
}
// visualizza gli array sullo schermo
per (i = 0; io<3;i++)
{
printf ("% d% d% d", a [i], b [i], c [i]);
}
getch ();
// chiudi il file
fclose (pinna);
}
Lettura di informazioni da un file riga per riga nella funzione C. Fgets ().
L'operatore fscanf() legge una parola da un file, ad es. fino al primo spazio in arrivo.
Per leggere l'intera riga da un file da un file, C usa la costruzione
if (NULL! = fgets (variabile stringa, lunghezza della stringa, puntatore del file))
{
azioni durante la lettura di una riga
}
Ad esempio, un programma C che legge due righe da un file e le visualizza sullo schermo
#includere
#includere
#includere
principale ()
{
// imposta le variabili stringa
carattere st1;
carattere st2;
// definisce un puntatore a un file
FILE * pinna;
// imposta il lavoro con il cirillico
setlocale (LC_ALL, "Russo");
// apre il file per la lettura
fin = fopen ("C: \\ data.txt", "r");
// legge la prima riga del file
if (NULL! = fgets (st1, 100, fin))
{
// visualizza la stringa sullo schermo
printf ("% s", st1);)
// legge la seconda riga del file
if (NULL! = fgets (st2, 100, fin))
{
// visualizza la stringa sullo schermo
printf ("% s", st2);)
// chiude il file per la lettura
fclose (pinna);
}
Scrivere informazioni su un file di testo in C
Per scrivere dati depositare in C, è necessario aprire il file in modalità di scrittura
Nome puntatore file = fopen ("percorso file", "w");
Per scrivere su una riga di un file di testo, usa il comando fprnitf(), che è simile al comando C, solo il primo parametro è un puntatore a un file
fprintf (nome puntatore file, "% formato input", variabili);
Ad esempio, scrivendo il valore della variabile a nel file out.txt
a = 10;
fout = fopen ("C: \\ Utenti \\ utente \\ Desktop \\ out.txt", "w");
fprintf (fout, ”% d”, a);
Un esempio di programma C che richiede due numeri e scrive entrambi questi numeri e la loro somma nel file out.txt
#includere
#includere
principale ()
(int a;
int b;
int c;
FILE * fout;
fout = fopen ("C: \\ Utenti \\ utente \\ Desktop \\ out.txt", "w");
printf ("inserisci il primo numero");
scanf ("% d", & a);
printf ("inserisci il secondo numero");
scanf ("% d", & b);
c = a + b;
fprintf (fout, "% d% d% d", a, b, c);
getch ();
fclose (fout);
}
Prima di allora, durante l'I/O dei dati, lavoravamo con flussi standard: una tastiera e un monitor. Ora diamo un'occhiata a come il linguaggio C implementa la ricezione di dati dai file e la loro scrittura lì. Prima di eseguire queste operazioni, è necessario aprire il file e accedervi.
Nel linguaggio di programmazione C, un puntatore a un file è di tipo FILE e la sua dichiarazione è simile a questa:
FILE * miofile;
D'altra parte, la funzione fopen() apre il file all'indirizzo specificato come primo argomento in modalità read ("r"), write ("w") o append ("a") e restituisce un puntatore ad esso nel programma. Pertanto, il processo di apertura di un file e di connessione al programma è simile al seguente:
miofile = fopen ("ciao.txt", "r");
Durante la lettura o la scrittura di dati in un file, vi si accede tramite un puntatore a file (in questo caso, myfile).
Se per qualche motivo (non c'è un file all'indirizzo specificato, l'accesso ad esso è negato) la funzione fopen() non può aprire il file, allora restituisce NULL. Nei programmi reali, l'errore di aprire un file nel ramo if viene quasi sempre gestito, ma lo ometteremo ulteriormente.
La dichiarazione della funzione fopen() è contenuta nel file di intestazione stdio.h, quindi deve essere inclusa. Il tipo di struttura FILE viene dichiarato anche in stdio.h.
Al termine del lavoro con il file, è consuetudine chiuderlo per liberare il buffer di dati e per altri motivi. Ciò è particolarmente importante se il programma continua a essere eseguito dopo aver lavorato con il file. L'interruzione della connessione tra un file esterno e un puntatore ad esso dal programma viene eseguita utilizzando la funzione fclose(). Gli viene passato un puntatore a un file come parametro:
fclose (il mio file);
Più di un file può essere aperto nel programma. In questo caso, ogni file deve essere associato al proprio puntatore di file. Tuttavia, se il programma prima funziona con un file, quindi lo chiude, è possibile utilizzare il puntatore per aprire il secondo file.
Leggere e scrivere su un file di testo
fscan ()
La funzione fscanf() ha un significato simile alla funzione scanf(), ma a differenza di essa, riceve l'input formattato da un file anziché l'input standard. La funzione fscanf() accetta parametri: un puntatore a un file, una stringa di formato, indirizzi di aree di memoria per la scrittura dei dati:
fscanf (myfile, "% s% d", str e a);
Restituisce la quantità di dati letti correttamente o EOF. Gli spazi, i caratteri di nuova riga vengono conteggiati come separatori di dati.
Supponiamo di avere un file contenente la seguente descrizione degli oggetti:
Mele 10 23,4 banane 5 25,0 pane 1 10,3
#includere
In questo caso vengono dichiarate una struttura e un array di strutture. Ogni riga del file corrisponde a un elemento dell'array; un elemento array è una struttura contenente una stringa e due campi numerici. Il ciclo legge una riga per iterazione. Quando viene rilevata la fine del file, fscanf() restituisce EOF e il ciclo termina.
fgets ()
La funzione fgets() è simile alla funzione gets() e prende l'input riga per riga da un file. Una chiamata fgets() leggerà una riga. In questo caso, puoi leggere non l'intera riga, ma solo una parte di essa dall'inizio. I parametri Fgets() sono simili a questo:
fgets (array_caratteri, numero di caratteri da leggere, puntatore_ al file)
Ad esempio:
fgets (str, 50, miofile)
Tale chiamata di funzione leggerà dal file associato al puntatore myfile un'intera riga di testo se la sua lunghezza è inferiore a 50 caratteri, tenendo conto del carattere "\ n", che la funzione memorizzerà anche nell'array. L'ultimo (50°) elemento nell'array str sarà il carattere "\ 0" aggiunto da fgets(). Se la stringa è più lunga, la funzione leggerà 49 caratteri e scriverà "\ 0" alla fine. In questo caso, "\ n" non sarà contenuto nella riga di lettura.
#includere
In questo programma, a differenza del precedente, i dati vengono letti riga per riga nell'array arr. Quando viene letta la riga successiva, la precedente viene persa. La funzione fgets() restituisce NULL se non riesce a leggere la riga successiva.
getc() o fgetc()
La funzione getc() o fgetc() (funzionano entrambe) consente di ottenere il carattere successivo dal file.
while ((arr [i] = fgetc (file))! = EOF) (se (arr [i] == " \ n ") (arr [i] = " \0 " ; printf ("% s \ n ", arr); io = 0; ) altrimenti io ++; ) arr [i] = " \0 " ; printf ("% s \ n ", arr);
Il codice di esempio visualizza i dati da un file sullo schermo.
Scrivere su un file di testo
Oltre all'input, l'output del file può essere diverso.
- Output formattato. Funzione Fprintf (puntatore_file, stringa_formato, variabili).
- Uscita riga per riga. Funzione fput (stringa, puntatore_file).
- Output carattere per carattere. Fputc() o putc (char, file_pointer).
Di seguito sono riportati esempi di codice che utilizzano tre modi per generare dati in un file.
Scrivendo campi di una struttura su ogni riga del file:
file = fopen ("fprintf.txt", "w"); while (scanf ("% s% u% f", negozio [i] .name, & (negozio [i] .qty), & (negozio [i] .prezzo)))! = EOF) (fprintf (file, " % s% u% .2f \ n ", negozio [i] .nome, negozio [i] .qty, negozio [i] .prezzo); io ++; )
L'output riga per riga in un file (fputs(), a differenza di puts() stesso non inserisce "\ n" alla fine della riga):
while (ottiene (arr)! = NULL) (fputs (arr, file); fputs (" \ n ", file); )
Un esempio di output carattere per carattere:
while ((i = getchar())! = EOF) putc (i, file);
Lettura e scrittura da un file binario
Puoi lavorare con un file non come una sequenza di caratteri, ma come una sequenza di byte. In linea di principio, è impossibile lavorare in modo diverso con file non di testo. Tuttavia, puoi leggere e scrivere su file di testo in questo modo. Il vantaggio di questo modo di accedere a un file è la velocità di lettura-scrittura: un accesso può leggere/scrivere un blocco di informazioni significativo.
Quando si apre un file per l'accesso binario, il secondo parametro da fopen() è la stringa "rb" o "wb".
L'argomento del lavoro con i binari è piuttosto complesso e richiede una lezione separata per impararlo. Qui noteremo solo le peculiarità delle funzioni di lettura e scrittura su un file, che è considerato come un flusso di byte.
Le funzioni fread() e fwrite() prendono come parametri:
- l'indirizzo dell'area di memoria da cui vengono scritti o letti i dati,
- la dimensione di un dato tipo,
- la quantità di dati da leggere della dimensione specificata,
- puntatore di file.
Queste funzioni restituiscono il numero di dati letti o scritti correttamente. Quelli. puoi "ordinare" la lettura di 50 dati e riceverne solo 10. Non ci saranno errori.
Un esempio di utilizzo delle funzioni fread() e fwrite():
#includere
Qui si tenta di leggere 50 caratteri dal primo file. N memorizza il numero di caratteri effettivamente letti. N può essere 50 o meno. I dati vengono inseriti in una stringa. La stessa cosa accade con il secondo file. Successivamente, la prima riga viene aggiunta alla seconda e i dati vengono scaricati nel terzo file.
Risolvere problemi
- Scrivete un programma che chieda all'utente il nome (indirizzo) di un file di testo, quindi lo apra e ne conteggi il numero di caratteri e righe.
- Scrivere un programma che scriva dati su un file ricevuto da un altro file e modificato in un modo o nell'altro prima di scrivere. Ogni riga di dati ricevuta da un file deve rientrare in una struttura.
Ultimo aggiornamento: 31.10.2015
Esistono due classi per lavorare con le directory nello spazio dei nomi System.IO: Directory e DirectoryInfo.
Classe di directory
La classe Directory fornisce una serie di metodi statici per la gestione delle directory. Alcuni di questi metodi sono:
CreateDirectory (percorso): crea una directory nel percorso specificato
Elimina (percorso): elimina la directory nel percorso specificato
Esiste (percorso): determina se esiste una directory nel percorso specificato. Se esiste restituisce true, se non esiste false
GetDirectories (percorso): ottiene un elenco di directory nella directory del percorso
GetFiles (percorso): ottiene un elenco di file nella directory del percorso
Sposta (sourceDirName, destDirName): sposta la directory
GetParent (percorso): ottieni la directory principale
Classe DirectoryInfo
Questa classe fornisce funzionalità per la creazione, l'eliminazione, lo spostamento e altre operazioni con le directory. In molti modi, è simile a Directory. Alcune delle sue proprietà e metodi:
Crea (): crea una directory
CreateSubdirectory (percorso): crea una sottodirectory nel percorso specificato
Elimina (): elimina una directory
Proprietà Exists: determina se la directory esiste
GetDirectories(): ottiene un elenco di directory
GetFiles(): ottiene un elenco di file
MoveTo (destDirName): sposta la directory
Proprietà padre: ottiene la directory padre
Proprietà radice: ottiene la directory principale
Diamo un'occhiata agli esempi dell'uso di queste classi.
Ottenere un elenco di file e sottodirectory
stringa dirName = "C: \\"; if (Directory.Exists (dirName)) (Console.WriteLine ("Subdirectory:"); string dirs = Directory.GetDirectories (dirName); foreach (string s in dirs) (Console.WriteLine (s);) Console.WriteLine ( ); Console.WriteLine ("Files:"); string files = Directory.GetFiles (dirName); foreach (string s nei file) (Console.WriteLine (s;))Nota l'uso delle barre nei nomi dei file. O usiamo una doppia barra: "C: \\", o una singola, ma poi mettiamo il segno @ davanti all'intero percorso: @ "C: \ Programmi"
Crea una directory
percorso della stringa = @ "C: \ SomeDir"; stringa sottopercorso = @ "programma \ avalon"; DirectoryInfo dirInfo = nuovo DirectoryInfo (percorso); if (! dirInfo.Exists) (dirInfo.Create ();) dirInfo.CreateSubdirectory (sottopercorso);Innanzitutto, controlliamo se esiste una tale directory, poiché se esiste, non sarà possibile crearla e l'applicazione genererà un errore. Di conseguenza, otteniamo il seguente percorso: "C: \ SomeDir \ program \ avalon"
Recupero delle informazioni sulla directory
string dirName = "C: \\ Programmi"; DirectoryInfo dirInfo = nuovo DirectoryInfo (dirName); Console.WriteLine ($ "Nome directory: (dirInfo.Name)"); Console.WriteLine ($ "Nome completo della directory: (dirInfo.FullName)"); Console.WriteLine ($ "Ora di creazione della directory: (dirInfo.CreationTime)"); Console.WriteLine ($ "Cartella radice: (dirInfo.Root)");Eliminazione di una directory
Se applichiamo semplicemente il metodo Elimina a una cartella non vuota che contiene alcuni file o sottodirectory, l'applicazione genererà un errore. Pertanto, dobbiamo passare un parametro booleano aggiuntivo al metodo Delete, che indicherà che la cartella deve essere eliminata con tutto il suo contenuto:
String dirName = @ "C: \ SomeFolder"; try (DirectoryInfo dirInfo = new DirectoryInfo (dirName); dirInfo.Delete (true); Console.WriteLine ("Directory eliminata");) catch (Eccezione ex) (Console.WriteLine (ex.Message);)
String dirName = @ "C: \ SomeFolder"; Directory.Delete (dirName, true);
Spostamento di una directory
string oldPath = @ "C: \ SomeFolder"; stringa nuovoPercorso = @ "C: \ SomeDir"; DirectoryInfo dirInfo = nuovo DirectoryInfo (vecchio percorso); if (dirInfo.Exists && Directory.Exists (newPath) == false) (dirInfo.MoveTo (newPath);)Durante lo spostamento, va tenuto presente che la nuova directory, in cui vogliamo spostare tutto il contenuto della vecchia directory, non dovrebbe esistere.
Il lavoro di I/O di file in C++ è quasi lo stesso del normale (ma con alcune sfumature).
Classi di file I/O
C'è le tre classi principali di file I/O in C++:
di corrente(è figlio della classe);
fstream(è un figlio della classe iostream).
È possibile utilizzare queste classi per eseguire l'input di file unidirezionale, l'output di file unidirezionale e l'I/O di file bidirezionale. Per usarli, devi solo connettere fstream.
A differenza dei flussi cout, cin, cerr e clog, che possono essere utilizzati immediatamente, i flussi di file devono essere impostati esplicitamente dal programmatore. Ovvero, per aprire un file in lettura e/o scrittura, è necessario creare un oggetto della classe I/O file corrispondente, specificando come parametro il nome del file. Quindi, utilizzando gli operatori di inserimento (<<) или извлечения (>>), è possibile scrivere dati su un file o leggere il contenuto di un file. Dopodiché, il finale è: è necessario chiudere il file: chiamare esplicitamente metodo close() o semplicemente lasciare che la variabile I/O del file esca dall'ambito (la classe I/O del file chiuderà automaticamente questo file per noi).
Uscita file
La classe ofstream viene utilizzata per scrivere su un file. Ad esempio:
#includere
#includere #includere #includere int principale () usando lo spazio dei nomi std; // ofstream viene utilizzato per scrivere dati in un file // Crea un file SomeText.txt fuori flusso ("SomeText.txt"); // Se non riusciamo ad aprire questo file per scriverci i dati se (! fuori) // Quindi visualizziamo un messaggio di errore ed eseguiamo exit() cerr<< << endl ; uscita (1); // Scrivi le seguenti due righe nel file fuori<< "See line #1!" << endl ; fuori<< "See line #2!" << endl ; restituire 0; // Quando outf esce dall'ambito, il distruttore della classe ofstream chiuderà automaticamente il nostro file |
Se guardi nella directory del tuo progetto ( Fare clic con il pulsante destro del mouse sulla scheda con il nome del file .cpp in Visual Studio > "Apri la cartella contenente"), vedrai un file chiamato SomeText.txt, che contiene le seguenti righe:
Vedi la riga n. 1!
Vedi la riga n. 2!
Si prega di notare, possiamo anche usare metodo put() per scrivere un carattere in un file.
Inserimento file
#includere
#includere #includere #includere #includere int principale () usando lo spazio dei nomi std; // ifstream viene utilizzato per leggere il contenuto del file // Se non riusciamo ad aprire questo file per leggerne il contenuto se (! inf) // Quindi visualizziamo il seguente messaggio di errore ed eseguiamo exit() cerr<< << endl ; uscita (1); // Mentre ci sono dati che possiamo leggere mentre (inf) // Quindi spostiamo questi dati in una riga, che poi visualizziamo sullo schermo stringa strInput; inf >> strInput; cout<< strInput << endl ; restituire 0; // Quando inf esce dall'ambito, il distruttore della classe ifstream chiuderà automaticamente il nostro file |
Vedere
linea
#1!
Vedere
linea
#2!
Hmm, non è esattamente quello che volevamo. Come già sappiamo dalle lezioni precedenti, l'operatore di estrazione lavora con "dati formattati", cioè ignora tutti gli spazi, le tabulazioni e le nuove righe. Per leggere l'intero contenuto così com'è, senza scomporlo in parti (come nell'esempio sopra), dobbiamo usare getline() metodo:
#includere
#includere #includere #includere #includere int principale () usando lo spazio dei nomi std; // ifstream viene utilizzato per leggere il contenuto dei file ifstream inf ("SomeText.txt"); // Se non riusciamo ad aprire il file per leggerne il contenuto se (! inf) // Quindi visualizziamo il seguente messaggio di errore ed eseguiamo exit() cerr<< "Uh oh, SomeText.txt non può essere aperto per la lettura!"<< endl ; uscita (1); mentre (inf) stringa strInput; getline (inf, strInput); cout<< strInput << endl ; restituire 0; // Quando inf esce dall'ambito, il distruttore della classe ifstream chiuderà automaticamente il nostro file |
Il risultato dell'esecuzione del programma sopra:
Uscita bufferizzata
L'output C++ può essere memorizzato nel buffer. Ciò significa che tutto ciò che viene emesso nel flusso di file non può essere scritto immediatamente su disco (in un file specifico). Questo viene fatto principalmente per motivi di prestazioni. Quando i dati del buffer vengono scritti su disco, vengono chiamati svuotare il tampone... Un modo per cancellare il buffer è chiudere il file. In questo caso, l'intero contenuto del buffer verrà spostato su disco e quindi il file verrà chiuso.
Il buffering dell'output di solito non è un problema, ma in determinate circostanze può causare problemi ai principianti incauti. Ad esempio, quando i dati vengono archiviati in un buffer e il programma termina la sua esecuzione prematuramente (a causa di un errore o di una chiamata). In questi casi, i distruttori di classi di I/O di file non vengono eseguiti, i file non vengono mai chiusi, i buffer non vengono svuotati e i nostri dati vengono persi per sempre. Questo è il motivo per cui è una buona idea chiudere in modo esplicito tutti i file aperti prima di chiamare exit().
Anche il buffer può essere svuotato manualmente utilizzando ostream :: flush() metodo o inviando std :: a filo al flusso di uscita. Ognuno di questi metodi può essere utile per garantire che il contenuto del buffer venga scritto immediatamente su disco in caso di arresto anomalo del programma.
Una sfumatura interessante: Dal momento che std :: endl; cancella anche il flusso di output, il suo uso eccessivo (che porta a svuotamenti del buffer non necessari) può influire sulle prestazioni del programma (poiché lo svuotamento del buffer in alcuni casi può essere un'operazione costosa). Per questo motivo, i programmatori che si preoccupano delle prestazioni del proprio codice usano spesso \ n invece di std :: endl per inserire una nuova riga nel flusso di output per evitare inutili svuotamenti del buffer.
Modalità di apertura dei file
Cosa succede se proviamo a scrivere dati su un file esistente? Il riavvio del programma sopra (il primo) mostra che il file originale viene completamente sovrascritto al riavvio del programma. E se avessimo bisogno di aggiungere i dati alla fine del file? Si scopre che il flusso di file richiede un secondo parametro opzionale che consente al programmatore di dire al programmatore come aprire il file. Come questo parametro, puoi passare seguenti bandiere(che sono nella classe ios):
app- apre il file in modalità aggiunta;
mangiò- va alla fine del file prima della lettura/scrittura;
binario- apre il file in modalità binaria (anziché in modalità testo);
in- apre il file in modalità lettura (di default per ifstream);
fuori- apre il file in modalità registrazione (default per ofstream);
troncare- cancella il file se esiste già.
È possibile specificare più flag contemporaneamente utilizzando.
ifstream funziona in ios :: in modalità per impostazione predefinita;
ofstream funziona in ios :: modalità out per impostazione predefinita;
fstream per impostazione predefinita viene eseguito in ios :: in OR ios :: out mode, il che significa che puoi leggere il contenuto di un file e scrivere dati su un file.
Ora scriviamo un programma che aggiunga due righe al file SomeText.txt precedentemente creato:
#includere
#includere #includere #includere int principale () usando lo spazio dei nomi std; // Passa il flag ios: app per dire a fstream che aggiungeremo i nostri dati ai dati del file esistente, // non sovrascriveremo il file. Non abbiamo bisogno di passare il flag ios :: out, // poiché ofstream funziona in modalità ios :: out per impostazione predefinita ofstream outf ("SomeText.txt", ios :: app); // Se non riusciamo ad aprire il file per scrivere i dati se (! fuori) // Quindi visualizziamo il seguente messaggio di errore ed eseguiamo exit() cerr<< "Uh oh, SomeText.txt non può essere aperto per la scrittura!"<< endl ; uscita (1); |
