Come creare un file di lettura in c. Immissione dei dati dal file e dall'uscita al file. Lavorare con i file in SI

La meccanizzazione I / O progettata non è conforme allo stile generalmente accettato degli elementi di programmazione orientati agli oggetti, inoltre, utilizza attivamente le operazioni con i puntatori, che sono considerati potenzialmente pericolosi nei moderni supporti protetti. Un'alternativa allo sviluppo delle applicazioni applicazioni è le classi I / O standard fornite dallo standard linguistico C ++.

Apertura dei file

Le classi IFSleam più utilizzate per la lettura, di Ofstream per la registrazione e la FStream per modificare i file.

Tutte le lezioni di streaming I / O sono derivati \u200b\u200bindiretti del General Antenator Ios, ereditamente eredita la sua funzionalità. Pertanto, la modalità di apertura dei file imposta un tipo Data Datative Open_Mode, che è definito come segue:

Enum open_mode (app, binary, in, out, trunc, mangiato);

Di seguito sono possibili valori di bandiera e il loro scopo.

Ad esempio, per aprire il file denominato Test.txt per leggere i dati nel modulo binario, dovresti scrivere:

File IFSleam; file.open ("test.txt", ios :: in | ios :: binario);

L'operatore logico o (|) consente di creare una modalità con qualsiasi combinazione di flag. In modo che, aprendo il file registrando, accidentalmente non spazzare il file esistente con lo stesso nome, è necessario utilizzare il seguente modulo:

File di ofstream; file.open ("test.txt", ios :: out | ios :: app);

Si presume che un file di intestazione appropriato sia collegato al progetto:

#Includere.

Per verificare se il file è riuscito ad aprire, è possibile applicare la progettazione

Se (! File) (// Elaborazione dell'errore di apertura del file)

Operatori per accendere ed estrarre

Soprattutto in classi di lavoro di classe inclusione dell'operatore (<<) записывает данные в файловый поток. Как только вы открыли файл для записи, можно записывать в него текстовую строку целиком:

File<< "Это строка текста";

Puoi anche registrare una stringa di testo in parti:

File<< "Это " << "строка " << "текста";

L'istruzione ENDL completa la voce della stringa con il simbolo "ritorno del carrello":

File<< "Это строка текста" << endl;

Usando l'istruzione Power, è facile da scrivere al valore dei valori delle variabili o degli elementi di array:

File ofstream ("temp.txt"); Char Buff \u003d "L'array di testo contiene variabili"; int vx \u003d 100; float pi \u003d 3.14159; File<< buff << endl << vx << endl << pi << endl;

Come risultato dell'esecuzione del codice, sono formate tre righe del file di testo TEMP.TXT:

L'array di testo contiene variabili 100 3.14159

Si noti che i valori numerici sono registrati in un file sotto forma di stringhe di testo, non valori binari.

Operatore di estrazione (\u003e\u003e) produce un'azione inversa. Sembrerebbe estrarre personaggi dal file TEMP.TXT registrato in precedenza, è necessario scrivere codice come quanto segue:

File IFSleam ("Temp.txt"); Char Buff; int vx; Float pi; File \u003e\u003e Buff \u003e\u003e VX \u003e\u003e PI;

Tuttavia, l'operatore di estrazione si fermerà sul primo separatore che è caduto (uno spazio, una scheda o un nuovo simbolo di stringa). Pertanto, quando si analizza la frase, la "array di testo contiene le variabili" solo la parola "testo" verrà registrata nell'array buff, lo spazio viene ignorato e la parola "array" sarà il valore dell'intera variabile VX e L'esecuzione del codice "verrà ruotata" con una violazione inevitabile della struttura dei dati. Successivamente, quando si discute la classe IFSleam, verrà mostrato come organizzare correttamente il file di lettura dall'esempio precedente.

Classe IFSleam: file di lettura

Come segue dalla decrittografia del nome, la classe IFSleam è progettata per inserire il flusso di file. La seguente elenca i principali metodi della classe. La maggior parte di loro è ereditata dalla classe di ISTREAM e sopraffatta con l'espansione delle funzionalità dei genitori. Ad esempio, la funzione Ottieni, a seconda del parametro di chiamata, è in grado di leggere non solo un singolo carattere, ma anche il blocco di simboli.

Ora è chiaro come modificare l'esempio precedente per utilizzare l'operatore di estrazione dei dati ha dato il risultato atteso:

File IFSleam ("Temp.txt"); Char Buff; int vx; Float pi; File.getline (buff, sizeof (buff)); File \u003e\u003e VX \u003e\u003e PI:

Il metodo Getline leggerà la prima riga del file alla fine e l'istruzione \u003e\u003e assegna i valori della variabile.

L'esempio seguente mostra l'aggiunta di dati a un file di testo con la seguente lettura dell'intero file. Il ciclo while (1) viene utilizzato al posto di while (! File2.eof ()) per ragioni che sono state discusse in.

#Includere. #Includere. Usando il namespace std; int main () (file offstream; file.open ("test.txt", ios :: out | ios :: app); if (! file) (cout<< "File error - can"t open to write data!"; cin.sync(); cin.get(); return 1; } for (int i=0; i<10; i++) file << i << endl; file.close(); ifstream file2; file2.open("test.txt", ios::in); if (!file2) { cout << "File error - can"t open to read data!"; cin.sync(); cin.get(); return 2; } int a,k=0; while (1) { file2 >\u003e A; se (file2.eof ()) pausa; Cout.<< a << " "; k++; } cout << endl << "K=" << k << endl; file2.close(); cin.sync(); cin.get(); return 0; }

L'esempio seguente mostra un ciclo di lettura del loop dal file Test.txt e il loro display sulla console.

#Includere. #Includere. Usando il namespace std; int Main () (file IFSleam; // Creare un file file file.Open ("test.txt"); // Aprire il file per la lettura se (! file) return 1; // restituisce l'errore di errore Char Str; / / Static Row Buffer // Leggere e visualizzare linee in un loop fino a EOF while (! File.Getline (STR, Sizeof (STR)). EOF ()) cout<< str << endl; // вывод прочитанной строки на экран cin.sync(); cin.get(); return 0; }

Questo codice sotto Windows dipende anche dalla presenza di un file simbolo di traduzione stringa nell'ultima riga, sarebbe più affidabile farlo:

While (1) (se (file.eof ()) break; file.getline (str, sizeof (str)); cout<< str << endl; }

Chiamate esplicite I metodi aperti e chiusi non sono richiesti. Infatti, la chiamata del costruttore con l'argomento consente di immediatamente, al momento della creazione di un flusso di file, aprire il file:

File ifstream ("test.txt");

Invece del metodo di chiusura, è possibile utilizzare l'istruzione Elimina, che causerà automaticamente il distruttore dell'oggetto file e chiuderà il file. Il codice del ciclo mentre fornisce un corretto controllo della configurazione della fine del file.

Classe OSSTREAM: file record

La classe OFSStream è progettata per generare i dati dal flusso di file. Elenca ulteriormente i metodi di base di questa classe.

L'operatore di inclusione precedentemente descritto è conveniente per l'organizzazione della registrazione a un file di testo:

File ofstream ("temp.txt"); Se (! file) ritorno; per (int i \u003d 1; io<=3; i++) file << "Строка " << i << endl; file.close();

File binari

In linea di principio, i dati binari sono serviti come testi. La differenza è che se i dati binari sono scritti in una specifica struttura logica, devono essere letti dal file alla variabile dello stesso tipo strutturale.

Il primo parametro dei metodi di scrittura e lettura (indirizzo di scrittura / lettura del blocco) deve avere il tipo di puntatore simbolo Char *, quindi è necessario eseguire una conversione esplicita dell'indirizzo della struttura Void *. Il secondo parametro indica che i blocchi di file binari hanno una dimensione costante di byte, indipendentemente dalla durata della registrazione effettiva. La seguente applicazione fornisce un esempio di creazione e visualizzazione di questo semplice notebook. I record dei file vengono quindi letti e visualizzati sulla console.

#Includere. #Includere. #Includere. Usando il namespace std; Struct Notes (// Struttura dati Nome Char; // Nome completo Charph Phone; // Phone Int Age; // Età); Int Main () (Setlocale (LC_All, "Russo"); Note Nota1 \u003d ("Grozny John Vasilyevich", "Non installato", 60); Note Nota2 \u003d ("Godunov Boris Fedorovich", "095-111-2233", 30); Note Nota3 \u003d ("Romanov Peter Mikhailovich", "812-333-2211", "812-333-2211", 20); OFSTREAM OFFERTE ("Notebook.dat", iOS :: Binary); OFER.Write ((Char *) & Note1, Sizeof (Note)); // 1st Block OFILE.Write ((Char *) & Note2, Sizeof (Note)); // 2 ° blocco OFILE.Write ((Char *) & Note3, Sizeof (Notes)); / / / 3rd Block OFILE.Close (); // Chiudi il file IFSleam IFSILE registrato ("Notebook.dat", iOS :: Binary); Nota Nota; // ha studiato Variabile Char Str; // Statistic Row Buffer // Leggere e leggere Display linee nel ciclo fino a EOF while (! IFILE.Read ((Char *) & Note, Sizeof (Note)). EOF ()) (Sprintf (STR, "% s \\ Tel:% s \\ consegna:% D", Nota.Name, nota.Phone, Note.age); cout<< str << endl; } ifile.close(); // закрыть прочитанный файл cin.sync(); cin.get(); return 0; }

Come risultato dell'esecuzione di questo codice, un file notebook binario.dat è formato da tre blocchi di 80 byte ciascuno (a condizione che i caratteri siano single-way). Naturalmente, è possibile utilizzare altri metodi di streaming e apportare qualsiasi operazione sui campi di una specifica struttura dei dati.

Classe fstream: accesso al file arbitrario

Supponiamo che 100 voci accumulate nel nostro notebook e vogliamo contare gli anni '50. Naturalmente, è possibile organizzare un loop e leggere tutti i record dal primo specificato. Ovviamente, una soluzione più focalizzata è quella di stabilire un puntatore di posizionamento positivo POS direttamente per scrivere 50 e leggerlo:

IFSleam IFILE ("noTook.dat", ios :: binary); Int POS \u003d 49 * Sizeof (Notes); IFILE.Seekg (POS); // cerca per il 50 ° record Note Nota; // Note: la struttura "record" "Registra" IFILE.Leggi sopra descritto sopra ((Char *) e Nota, Sizeof (Notes));

Tali operazioni di ricerca sono efficaci se il file è composto dai record della dimensione ben nota e costante. Per sostituire il contenuto di un record arbitrario, è necessario aprire il flusso di uscita in modalità modifica:

OFSTREAM OFFILE ("notebook.dat", ios :: binary | ios :: mangiato); Int POS \u003d 49 * Sizeof (Notes); OFILE Seekp (POS); // cerca per il 50 ° record note note50 \u003d ("Yeltsin Boris Nikolaevich", "095-222-3322", 64); OFILE.Write ((Char *) & Note, Sizeof (Notes)); // sostituzione

Se non si specifica l'iOS :: ATE flag (o iOS :: App), quindi quando si apre il file binario notebook.dat. Sarà cancellato!

Infine, è possibile aprire il file contemporaneamente a leggere / scrivere, usando i metodi ereditati dalla classe flusso fstream dai suoi predecessori. Poiché la classe FStream è prodotta da ISTREAM e OSTREAM (iFstream e i genitori di ostream, rispettivamente), tutti i metodi menzionati in precedenza diventano disponibili nell'applicazione.

L'esempio seguente mostra la permuta del primo e del terzo record del file notebook.dat.

#Includere. #Includere. #Includere. Usando il namespace std; Note di struttura (nome del char, telefono char; Int Age;); Int Main () (Setlocale (LC_All, "Russo); Note Nota1, Note3; // Apri file Leggi / scrivi simultaneamente file fstream (" notebook.dat ", ios :: binary | ios :: in | ios :: out) ; file.seekg (2 * Sizeof (Notes)); // Trova e Conta Note3 File.Read ((Char *) & Note3, Sizeof (Notes)); file.seekg (0); // Trova e conta il file Note1 .Read ((Char *) & Note1, Sizeof (Notes)); file.seekg (0); // nota1<== Note3 file.write((char*)&Note3, sizeof(Notes)); file.seekg(2 * sizeof(Notes)); // Note3 <== Note1 file.write((char*)&Note1, sizeof(Notes)); char str; // Считывать и отображать записи в цикле, пока не eof file.seekg(0); // вернуться к началу файла while (!file.read((char*)&Note1, sizeof(Notes)).eof()) { sprintf(str, "%s\tТел: %s\tВозраст: %d", Note1.Name, Note1.Phone, Note1.Age); cout << str << endl; } file.close(); cin.sync(); cin.get(); return 0; }

Nel progettista di file, è necessario specificare i flag IOS :: IN e IOS :: OUT, consentendo l'esecuzione simultanea delle operazioni di lettura e scrittura. Come risultato dell'esecuzione di questo codice, il primo e il terzo record del file binario notebook.dat verrà modificato in luoghi.

Esempi aggiuntivi sull'argomento sono.

Prima di questo, quando si inserisce l'output dei dati, abbiamo lavorato con flussi standard - tastiera e monitor. Ora considera come in lingua i dati implementati da file e registrarli lì. Prima di eseguire queste operazioni, è necessario aprire il file e accedervi.

Nel linguaggio di programmazione, il puntatore al file ha il file di tipo e il suo annuncio come:
File * myfile;

D'altra parte, la funzione FOPEN () apre il file all'indirizzo specificato come primo argomento in modalità di lettura ("R"), registrazione ("w") o aggiunta ("A") e restituisce un puntatore al programma . Pertanto, il processo di apertura di un file e collegarlo al programma è simile a questo:
Myfile \u003d fopen ("hello.txt", "r");

Durante la lettura o la scrittura di dati su un file, l'accesso ad esso viene eseguito tramite un puntatore di file (in questo caso, myfile).

Se, in virtù di determinati motivi (non vi è alcun file all'indirizzo specificato, è vietato accedervi) FOPEN () La funzione non può aprire il file, restituisce NULL. In programmi reali, maneggia quasi sempre l'errore dell'apertura del file nel ramo IF, lo omettiamo ulteriormente.

L'annuncio FOPEN () La funzione è contenuta nel file di intestazione STDIO.H, quindi è necessario connettersi. Anche in Stdio.h ha dichiarato il file di struttura di tipo.

Dopo aver lavorato con il file, è consuetudine chiuderlo per liberare il buffer dai dati e per altri motivi. Questo è particolarmente importante se il programma continua ad essere eseguito dopo aver lavorato con il file. La rottura di comunicazione tra il file esterno e il puntatore dal programma viene eseguito utilizzando la funzione FCLose (). Il puntatore al file viene trasmesso come parametro:
Fclose (myfile);

Nel programma può essere aperto non un file. In questo caso, ogni file deve essere associato al suo puntatore del file. Tuttavia, se il programma funziona per primi con un file, si chiude, il puntatore può essere utilizzato per aprire il secondo file.

Leggere da un file di testo e scrivi ad esso

fscanf ()

La funzione FSCanF () è simile nel significato della funzione Scanf (), ma in contrasto con essa esegue l'ingresso formattato dal file, e non un flusso di ingresso standard. FSCANF () Caratteristica Prende i parametri: Puntatore file, formato stringa, indirizzi indirizzi di memoria per la registrazione dei dati:
Fscanf (myfile, "% s% d", str e a);

Restituisce il numero di set di dati o EOF con successo. Gli spazi, i simboli di transizione a una nuova stringa sono presi in considerazione come separatori dati.

Supponiamo di avere un file contenente tale descrizione di oggetti:

Mele 10 23.4 Banane 5 25.0 Pane 1 10.3

#Includere. Principale () (file * file * Struct food (char nome [20]; qty non firmato; prezzo del galleggiante;); struttura negozio di alimenti [10]; char i \u003d 0; file \u003d fopen ("fscanf.txt", "r" ); Mentre (fscanf (file,% s% u% f ", negozio [i] .name, & (negozio [i] .qty), & (negozio [i] .price)! \u003d EOF) (printf "% s% u% .2f \\ n ", Negozio [i] .name, negozio [i] .qty, negozio [i] .price); I ++; ))

In questo caso, la struttura e la serie di strutture sono dichiarate. Ogni riga dal file corrisponde a un elemento dell'array; Un elemento di array è una struttura contenente struttura e due campi numerici. In un'aterazione, il ciclo legge una linea. Quando si verifica la fine del file FScanF, restituisce il valore EOF e il ciclo è completato.

fgets ()

La funzione FGet () è simile alle funzioni GETS () e prende l'ingresso LINE dal file. Una chiamata PIGS () ti consentirà di leggere una riga. In questo caso, puoi leggere l'intera linea, ma solo la sua parte dell'inizio. I parametri fgets () sembrano:
Fgets (array_simvolov, number_name_simvolws, puntatore__fail)

Per esempio:
Fgets (str, 50, myfile)

Questa chiamata funzione leggerà dal file associato al puntatore MyFile, una riga del testo è completamente, se la sua lunghezza è inferiore a 50 caratteri, tenendo conto del simbolo "\\ n", che la funzione verrà salvata anche nel Vettore. L'ultimo (50 °) elemento dello STR array sarà il carattere "\\ 0", ha aggiunto i fgets (). Se la stringa è più lunga, la funzione leggerà 49 caratteri e recollerà "\\ 0" alla fine. In questo caso, "\\ n" in una linea di lettura contiene non sarà.

#Includere. #Define N 80 Main () (file * file *; char arr [n]; file \u003d fopen ("fscanf.txt", "r"); mentre (fgets (arr, n, file)! \u003d Null) printf (" % s ", arr); printf (" \\ n "); Fclose (file); )

In questo programma, in contrasto con i dati precedenti, viene letta una stringa per riga in un array ARR. Quando viene letta la stringa successiva, il precedente è perso. Fgets () restituisce NULL se non è possibile leggere la seguente stringa.

getc () o fgetac ()

La funzione GETC () o FGetC () (funziona anche) consente di ottenere un altro simbolo dal file.

while ((ARR [I] \u003d FGetC (file))! \u003d EOF) (se (ARR [I] \u003d\u003d " \\ n ") (ARR [I] \u003d " \0 " ; Printf ("% s \\ n ", arr); I \u003d 0; ) Altrimenti I ++; ) ARR [I] \u003d " \0 " ; Printf ("% s \\ n ", arr);

Il codice descritto come esempio visualizza i dati dal file sullo schermo.

Inserimento nel file di testo

Oltre ad ingresso, l'uscita del file potrebbe essere diversa.

Formato Uscita. Funzione FRINTF (file_Le indicatore, formato linea_, variabili).
Conclusione del ritorno. Caratteristica FUPSS (stringa, file_dactor).
Conclusione del suono. Funzione FUPTC () o PUTC (simbolo, file di ricerca file).

Di seguito sono riportati esempi del codice che utilizza tre modi per emettere i dati in un file.

Registrare ogni riga del file di campo di una struttura:

file \u003d fopen ("fprintf.txt", "w"); While (scanf ("% s% u% f", negozio [i] .name, & (shop [i] .qty), & (shop [i] .price))! \u003d EOF) (FRINTF (file " % s% u% .2f \\ n ", Negozio [i] .name, negozio [i] .qty, negozio [i] .price); I ++; )

L'uscita finale al file (Fputs (), in contrasto con i messaggi () non si posiziona alla fine della linea "\\ n"):

mentre (ottiene (ARR)! \u003d NULL) (FUTIS (FUPS (ARR, FILE); FUPSS (" \\ n ", File); )

Un esempio di un'uscita da pipì:

while ((i \u003d getchar ())! \u003d Eof) putc (i, file);

Leggere dal file binario e scrivi ad esso

Non è possibile lavorare con il file come una sequenza di caratteri, ma come con la sequenza di byte. In linea di principio, non è possibile lavorare con i file Neetstic. Tuttavia, è possibile leggere e scrivere in file di testo. Il vantaggio di questo metodo di accesso al file è la velocità di lettura-scrittura: per un ricorso, è possibile leggere un blocco significativo di informazioni.

Quando si apre un file per l'accesso binario, il secondo parametro della funzione FOPEN () è la stringa "RB" o "WB".

L'argomento di lavorare con file binari è abbastanza complicato, richiede una lezione separata da studiare. Qui verranno registrati solo caratteristiche di funzioni di lettura-scrittura a un file considerato come un flusso di byte.

Le funzioni Frite () e Fwrite () sono ricevute come parametri:

l'indirizzo dell'area di memoria in cui i dati sono scritti o da dove vengono letti,
la dimensione di un tipo di qualsiasi tipo
il numero di dimensioni specificate dei dati,
puntatore del file.

Queste funzioni restituiscono il numero di dati di lettura o registrati con successo. Quelli. Puoi "ordinare" lettura di 50 voci di dati e ottenere solo 10. Gli errori non si insorgono.

Esempio di utilizzo delle funzioni di Frite () e Fwrite ():

#Includere. #Includere. principale () (file * file *; char shelf1 [50], shelf2 [100]; int n, m; file \u003d fopen ("shelf1.txt", "rb"); n \u003d fright (shelf1, sizeof (char), 50, file); fclose (file); file \u003d fopen ("shelf2.txt", "rb"); m \u003d flard (shelf2, sizeof (char), 50, file); fclose (file); shelf1 [n] \u003d " \0 " ; Shelf2 [m] \u003d " \\ n "; SHELF2 [M + 1] \u003d " \0 " ; File \u003d fopen ("shop.txt", "wb"); Fwrite (shelf2, shelf1), sizeof (char), n + m, file); FClose (file); )

C'è un tentativo di lettura dal primo file di 50 caratteri. In N, il numero di effettivamente leggi i caratteri viene salvato. N Il valore può essere uguale a 50 o meno. I dati sono posizionati nella stringa. La stessa cosa accade con il secondo file. Successivamente, la prima stringa è collegata al secondo e i dati vengono ripristinati al terzo file.

Risolvere le attività

Scrivi un programma che richiede un nome file di testo (indirizzo) di un file di testo, apre ulteriormente e ritiene inoltre il numero di caratteri e linee.
Scrivi il programma che registra i dati ricevuti da un altro file al file e comunque modificato prima del record. Ogni riga di dati ricevuta dal file deve essere posizionata nella struttura.

Ultimo aggiornamento: 10/31/2015

Per lavorare con le directory nello spazio dei nomi System.io, due classi sono previste immediatamente: directory e directoryInFO.

Classe di directory.

La classe directory fornisce una serie di metodi statici per la gestione delle directory. Alcuni di questi metodi:

CREECIRECTORY: crea una directory sul percorso del percorso specificato

Elimina (percorso): Elimina la directory sul percorso del percorso specificato

Esiste (percorso): determina se c'è una directory sul percorso del percorso specificato. Se c'è, viene restituito vero se non c'è, allora falso

GetDirectories (percorso): ottiene un elenco di directory nel catalogo del percorso

GetFiles (percorso): ottiene un elenco di file nel catalogo del percorso

Mossa (SournirnirName, DesdiRName): Sposta il catalogo

GetParent (percorso): ottenere un catalogo genitore

Directory di classeInfo.

Questa classe fornisce funzionalità per creare, eliminare, spostare e altre operazioni di directory. In molti modi sembrano una directory. Alcune delle sue proprietà e metodi:

Crea (): crea un catalogo

CreateSubDirectory (percorso): crea un sottodirector per il percorso del percorso specificato

Elimina (): Elimina catalogo

Esiste la proprietà: determina se c'è un catalogo

GetDirectories (): ottiene un elenco di directory

GetFiles (): ottiene un elenco di file

MOVETTO (DESTINAME): Sposta il catalogo

Proprietà dei genitori: ottenere un catalogo genitore

Proprietà root: ottenere un catalogo root

Diamo un'occhiata agli esempi dell'applicazione di queste classi

Ottenere un elenco di file e sottodirectory

Stringa dirname \u003d "c: \\\\"; se (directory.exists (dirname)) (console.writeline ("subdatalogues:"); stringa dir \u003d directory.getdirectories (dirname); foreach (stringa s in territori) (console.writelline (s);) console.writeline ( ); Console.Writelline ("Files:"); file stringa \u003d directory.GetFiles (dirname); foreach (stringa s in file) (console.writeline (s);))

Prestare attenzione all'uso degli armadietti nei nomi dei file. O usiamo una doppia laica: "C: \\\\", singolo, ma poi prima di mettere il segno @: @ "c: \\ Programmi"

Creazione di cataloghi

String Path \u003d @ "C: \\ Somedir"; Stringa subpath \u003d @ "programma \\ avalon"; DirectoryInfo DiinfO \u003d New DirectoryInfo (percorso); se (! DiinFo.Create ();) DiinFo.CreaSubDirectory (Subpath);

Per prima cosa controlli, e non esiste una tale directory, poiché se esiste, sarà impossibile crearlo, e l'applicazione lancerà un errore. Di conseguenza, avremo il seguente modo: "C: \\ Somedir \\ Program \\ Avalon"

Ricevere informazioni sul catalogo

Stringa dirname \u003d "c: \\\\ file di programma"; DirectoryInfo DiinFo \u003d New DirectoryInfo (dirname); Console.Writeline ($ "Nome del catalogo: (DiinFo.name)"); Console.Writeline ($ "Nome catalogo completo: (DiinFo.fullname)"); Console.Writeline ($ "Catalogo Tempo di creazione del catalogo: (DiinFo.CreationTime)"); Console.Writeline ($ "directory root: (DiinFo.root)");

Rimozione del catalogo

Se applichiamo semplicemente il metodo Elimina a una cartella non vuota, in cui ci sono file o sottodirectory, l'applicazione ci avrebbe ci verrà emesso un errore. Pertanto, dobbiamo trasferire l'opzione Tipo Booleano aggiuntivo al metodo Elimina, che indicherà che la cartella deve essere eliminata con tutti i contenuti:

Stringa dirname \u003d @ "c: \\ somefolder"; Prova (DirectoryInfo DiinFo \u003d New DirectoryInfo (Dirname); DiinFo.Delete (TRUE); console.Writelline ("Catalogo remoto");) Catch (Exception Ex) (console.Writelline (ex.sessage);)

Stringa dirname \u003d @ "c: \\ somefolder"; Directory.Delete (dirname, true);

Catalogo in movimento

Stringa oldpath \u003d @ "c: \\ somefolder"; String NewPath \u003d @ "C: \\ Somedir"; DirectoryInfo DiinInfo \u003d New DirectoryInfo (Oldpath); if (DiinFo.Exists && Directory.exists (NewPath) \u003d\u003d False) (DiinFo.Moveto (NewPath);)

Quando si muove, si dovrebbe tenere presente che la nuova directory in cui vogliamo effettuare tutti i contenuti della vecchia directory non dovrebbe esistere.

La maggior parte dei programmi per computer funziona con i file, e quindi è necessario creare, eliminare, scrivere per leggere, aprire file. Qual è il file? Il file è un set di byte denominato, che può essere salvato su qualche unità. Bene, ora è chiaro che sotto il file è inteso come una sequenza di byte, che ha il proprio nome univoco, ad esempio file.txt. In una directory ci possono essere file con gli stessi nomi. Sotto il nome del file non è inteso non solo dal suo nome, ma anche l'espansione, ad esempio: file.txt e file.dat — diversi file, anche se hanno gli stessi nomi. Esiste una cosa come il nome completo dei file è l'indirizzo completo alla directory dei file con il nome del nome del file, ad esempio: D: \\ docs \\ file.txt. È importante capire questi concetti di base, altrimenti sarà difficile lavorare con i file.

Per lavorare con i file, è necessario collegare il file di intestazione . NEL Sono collegate diverse classi e file di intestazione. — file Input I. — uscita file.

L'ingresso / uscita del file è simile all'ingresso / uscita standard, l'unica differenza è che l'ingresso / uscita non è sullo schermo, ma al file. Se l'immissione / uscita su dispositivi standard viene eseguita utilizzando oggetti CIN e COUT, è sufficiente creare oggetti personali che possono essere utilizzati in modo simile agli operatori CIN e COUT.

Ad esempio, è necessario creare un file di testo e scrivere nella stringa per funzionare con i file in C ++. Per fare ciò, è necessario effettuare le seguenti operazioni:

creare un oggetto di classe di una classe ;
legare un oggetto di classe con un file a cui verrà effettuato il record;
registrare una stringa in un file;
chiudi file.

Perché è necessario creare un oggetto di classe di classe, non classe IFstream? Poiché è necessario registrare il file e, se fosse necessario leggere i dati dal file, verrà creato l'oggetto classe IFSleam.

// Creare un oggetto per scrivere al nome del file ofstream / * * /; // Classe oggetto di ObjectStream

Chiamiamo l'oggetto - Fout, è quello che succede:

Ofstream Fout;

Qual è l'oggetto per noi? L'oggetto è necessario che puoi scrivere sul file. L'oggetto è già creato, ma non è associato al file in cui la stringa deve essere registrata.

Fout.open ("cppstudio.txt"); // associamo un oggetto con il file

Attraverso l'operazione, otteniamo l'accesso al metodo di classe Open (), nelle staffe rotonde del quale si specifica il nome del file. Il file specificato verrà creato nella directory corrente con il programma. Se il file con lo stesso nome esiste, il file esistente verrà sostituito dal nuovo. Quindi, il file è aperto, resta per scrivere ad esso la stringa desiderata. Questo è fatto così:

Fout.<< "Работа с файлами в С++"; // запись строки в файл

Utilizzando la trasmissione della trasmissione sul flusso, insieme all'oggetto Fout, il lavoro con i file in C ++ è scritto nel file. Poiché non è più necessario modificare il contenuto del file, deve essere chiuso, cioè, per separare l'oggetto dal file.

Fout.close (); // Chiudi file

Risultato - ha creato un file con un lavoro di stringa con i file in C ++.

I passaggi 1 e 2 possono essere combinati, cioè in una riga, crea un oggetto e collegarlo al file. Questo è fatto così:

Ofstream Fout ("cppstudio.txt"); // Creare un oggetto della classe di ostream e collegalo al file cppstudio.txt

Combiniamo l'intero codice e ottiamo il seguente programma.

// file.cpp: Determina il punto di ingresso per l'applicazione della console. #Include "stdafx.h" #include Usando il namespace std; Int Main (OFS ARGC, CHAR * ARGV) (OFASTREAM FOUT); // Creare un oggetto della classe OSTREAM per scrivere e collegarlo al file CPPStudio.txt Fout<< "Работа с файлами в С++"; // запись строки в файл fout.close(); // закрываем файл system("pause"); return 0; }

Resta per verificare la correttezza del programma e per questo aprire il file Cppstudio.txt. E guardiamo il suo contenuto, dovrebbe essere - Lavorare con i file in C ++.

creare un oggetto di classe IFSleam e collegalo al file da cui verrà controllata la lettura;
leggi il file;
chiudi file.

// file_read.cpp: specifica il punto di ingresso per l'applicazione della console. #Include "stdafx.h" #include #Includere. Usando il namespace std; Int Main (INT ARGC, CHAR * ARGV) (Setlocale); // Colillic Cirillico Visualizza Char Buff; // BUFFER STOCCAGGIO INTERMEDIATO LEGGI DA TESTO IFSTREAM FIN ("CPPStudio.txt"); // file aperto per la lettura pinna \u003e\u003e<< buff << endl; // напечатали это слово fin.getline(buff, 50); // считали строку из файла fin.close(); // закрываем файл cout << buff << endl; // напечатали эту строку system("pause"); return 0; }

Il programma mostra due modi di leggere dal file, il primo - utilizzando l'operazione di trasmissione al flusso, il secondo - utilizzando la funzione Getline () . Nel primo caso, viene letta solo la prima parola, e nel secondo caso la stringa viene letto, lungo 50 caratteri. Ma dal momento che ci sono meno caratteri rimasti nel file, i caratteri vengono letti compresi per l'ultimo. Si noti che leggendo una seconda volta (riga 17.) Continua dopo la prima parola, e non fin dall'inizio, dal momento che la prima parola è stata lettariga 14.. Il risultato del programma è mostrato nella figura 1.

Lavorare con i file in C ++ per continuare, premere qualsiasi tasto. . .

Figura 1 - Lavorare con i file in C ++

Il programma ha funzionato correttamente, ma non succede sempre, anche se va bene con il codice. Ad esempio, il programma trasmesso il nome di un file inesistente o di un errore viene effettuato nel nome. Cosa poi? In questo caso, nulla accade affatto. Il file non sarà trovato, e quindi non è possibile leggerlo. Pertanto, il compilatore ignora le linee in cui il lavoro è in esecuzione con il file. Di conseguenza, il programma sarà completato correttamente, ma non verrà visualizzato nulla sullo schermo. Sembrerebbe che questa sia una reazione completamente normale a tale situazione. Ma il semplice utente non sarà chiaro qual è il problema e perché la linea non appare sullo schermo dal file. Quindi, in modo che tutto sia estremamente chiaro in C ++ fornisce una tale funzione - IS_OPEN (), che restituisce i valori Integer: 1 - Se il file è stato aperto correttamente, 0 - se il file non è aperto. Compiniamo il programma con l'apertura del file, in modo che se il file non è aperto, è stato visualizzato il messaggio corrispondente.

// file_read.cpp: specifica il punto di ingresso per l'applicazione della console. #Include "stdafx.h" #include #Includere. Usando il namespace std; Int Main (INT ARGC, CHAR * ARGV) (Setlocale); // correzione Display cortillico cirillico; // tampone di archiviazione intermedio Leggere dal file del file IFstream FIN ("CPPStudio.doc"); // (inserito il nome del file errato) se (! Fin.is_open ()) // Se il file non è aperto cout<< "Файл не может быть открыт!\n"; // сообщить об этом else { fin >\u003e Buff; // considerata la prima parola dal file cout<< buff << endl; // напечатали это слово fin.getline(buff, 50); // считали строку из файла fin.close(); // закрываем файл cout << buff << endl; // напечатали эту строку } system("pause"); return 0; }

Il risultato del programma è mostrato nella figura 2.

Il file non può essere aperto! Per continuare, premere qualsiasi tasto. . .

Figura 2 - Lavorare con i file in C ++

Come puoi vedere dalla figura 2, il programma segnalato sull'incapacità di aprire il file. Pertanto, se il programma funziona con i file, si consiglia di utilizzare questa funzione, is_open (), anche se si è sicuri che il file esista.

Modalità di apertura dei file

Le modalità di apertura dei file hanno impostato l'uso dei file. Per impostare la modalità nella classe iOS_BASE, ci sono costanti che determinano la modalità di apertura dei file (vedere la Tabella 1).

Le modalità di apertura dei file possono essere installate direttamente quando si crea un oggetto o quando si chiama la funzione aperta () .

Ofstream Fout ("cppstudio.txt", ios_base :: app); // Aprire il file per aggiungere informazioni alla fine del file fout.open ("cppstudio.txt", ios_base :: app); // Aprire il file per aggiungere informazioni alla fine del file

Le modalità di apertura dei file possono essere combinate utilizzando un'operazione di logica Biddly. o | , ad esempio: ios_base :: out | ios_base :: TRUNC - Apertura di un file per la registrazione, in precedenza Cancellarlo.

Oggetti della classe di ostream, quando è vincolante con i file per impostazione predefinita, contiene modalità di apertura del file ios_base :: OUT | ios_base :: TRUNC. . Cioè, il file verrà creato se non esiste. Se il file esiste, il suo contenuto verrà eliminato e il file stesso sarà pronto per la registrazione. Gli oggetti di classe IFSleam associati al file, hanno la modalità di apertura predefinita del file ios_base :: In - il file è aperto solo per leggere. La modalità di apertura del file è anche chiamata la bandiera, per la leggibilità in futuro useremo questo particolare termine. Tabella 1 Elenchi Non tutte le bandiere, ma per iniziare questi dovrebbero essere sufficienti.

Si prega di notare che le bandiere ATE e APP sono molto simili alla descrizione, entrambi spostano il puntatore alla fine del file, ma il flag dell'app consente di registrare, solo alla fine del file, e il bandiera ATE semplicemente riarrangia la bandiera alla fine del file e non limita le posizioni dei record.

Svilupperemo un programma che, utilizzando l'operazione Sizeof (), calcolerà le caratteristiche dei principali tipi di dati in C ++ e scriverli al file. Caratteristiche:

numero di byte assicurato dal tipo di dati
il valore massimo che può essere memorizzato un tipo di dati specifico.

La voce del file deve essere eseguita in tale formato:

/ * Tipo di dati Byte Valore massimo BOOL \u003d 1 255.00 Char \u003d 1 255.00 breve int \u003d 2 32767.00 Unsigned breve int \u003d 2 65535.00 int \u003d 4 2147483647.00 Unsigned int \u003d 4 4294967295.00 lungo int \u003d 4 214748364.00 Unsigned Long Int \u003d 4 4294967295.00 float \u003d 4 214748364.00 Lungo float \u003d 8 9223372036854775800.00 Double \u003d 8 9223372036854775800.00 * /

Tale programma è già stato sviluppato in precedenza nella sezione, ma qui tutte le informazioni sui tipi di dati sono state visualizzate su un dispositivo di output standard e dobbiamo rifare il programma in modo che le informazioni siano scritte nel file. Per fare ciò, è necessario aprire il file in modalità di registrazione, con il protagonista preliminare delle informazioni del file corrente ( riga 14.). Non appena il file viene creato e aperto con successo (stringhe 16 - 20), invece dell'operatore di cout, in riga 22.usa l'oggetto Fout. Pertanto, anziché lo schermo, le informazioni sui tipi di dati sono registrate in un file.

// write_file.cpp: Determina il punto di ingresso per l'applicazione della console. #Include "stdafx.h" #include #Includere. // funziona con #include file // usando i manipolatori di ingresso / output std del namespace; Int Main (INT ARGC, CHAR * ARGV) (Setlocale); // associamo l'oggetto con il file, mentre si apre il file nella modalità di registrazione, dopo aver eliminato tutti i dati da ItStream Fout ("data_types.txt", ios_base :: out | ios_base :: trunc); if (! Fout.is_open ()) // Se il file non è stato aperto (cout<< "Файл не может быть открыт или создан\n"; // напечатать соответствующее сообщение return 1; // выполнить выход из программы } fout << " data type " << "byte" << " " << " max value " \u003c\u003c Intestazioni della colonna ENDL // \u003c\u003c"bool = " << sizeof(bool) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных bool*/ << (pow(2,sizeof(bool) * 8.0) - 1) << endl << "char = " << sizeof(char) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных char*/ << (pow(2,sizeof(char) * 8.0) - 1) << endl << "short int = " << sizeof(short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных short int*/ << (pow(2,sizeof(short int) * 8.0 - 1) - 1) << endl << "unsigned short int = " << sizeof(unsigned short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned short int*/ << (pow(2,sizeof(unsigned short int) * 8.0) - 1) << endl << "int = " << sizeof(int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных int*/ << (pow(2,sizeof(int) * 8.0 - 1) - 1) << endl << "unsigned int = " << sizeof(unsigned int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned int*/ << (pow(2,sizeof(unsigned int) * 8.0) - 1) << endl << "long int = " << sizeof(long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных long int*/ << (pow(2,sizeof(long int) * 8.0 - 1) - 1) << endl << "unsigned long int = " << sizeof(unsigned long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных undigned long int*/ << (pow(2,sizeof(unsigned long int) * 8.0) - 1) << endl << "float = " << sizeof(float) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных float*/ << (pow(2,sizeof(float) * 8.0 - 1) - 1) << endl << "long float = " << sizeof(long float) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных long float*/ << (pow(2,sizeof(long float) * 8.0 - 1) - 1) << endl << "double = " << sizeof(double) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных double*/ << (pow(2,sizeof(double) * 8.0 - 1) - 1) << endl; fout.close(); // программа больше не использует файл, поэтому его нужно закрыть cout << "Данные успешно записаны в файл data_types.txt\n"; system("pause"); return 0; }

È impossibile notare che i cambiamenti nel programma sono minimi e tutti dovuti al fatto che l'ingresso standard / uscita e ingresso / uscita del file sono utilizzati assolutamente simili. Alla fine del programma, inriga 45. Abbiamo chiaramente chiuso il file, anche se non è necessariamente, ma è considerato un buon tono di programmazione. Vale la pena notare che tutte le funzioni e i manipolatori utilizzati per formattare l'ingresso / uscita standard sono rilevanti per l'ingresso / uscita del file. Pertanto, nessun errore si è verificato quando l'operatore Cout. È stato sostituito dall'oggetto Fout.

In questo articolo impariamo come leggere i dati da file e registrare informazioni sui file nei programmi SI. File in SI.utilizzato per salvare il risultato del programma SI e utilizzarlo con un nuovo inizio del programma. Ad esempio, è possibile salvare i risultati dei calcoli, statistiche di gioco.
Per lavorare con i file in C, è necessario collegare la libreria STDIO.H
#Includere.
Lavorare s. file in Si. È necessario specificare un puntatore al file di esempio.
File * Nome puntatore al file;
per esempio
File * pinna;
Specifica il puntatore FIN al file
Successivamente, è necessario aprire il file e legarlo al puntatore del file. Per aprire il file nel lettore, utilizzare il comando
Nome puntatore da file \u003d fopen ("percorso al file", "r");
Ad esempio, la seguente squadra
fIN \u003d FOTON ("C: \\\\ Utenti \\\\ User \\\\ Desktop \\\\ data.txt", "r");
Aprirà il file data.txt sul desktop lungo il percorso C: \\\\ Utenti \\\\ User \\\\ Desktop per scoprire il percorso del file, è possibile selezionare il file con il mouse per fare clic sul pulsante destro del mouse e Seleziona le proprietà del file. Nella sezione Posizione, verrà specificato il percorso verso il file. Si prega di notare che il percorso è specificato utilizzando due letti.
Dopo aver lavorato con il file SI, è necessario chiuderlo utilizzando il comando.
fclose (nome puntatore da file)

Lettura delle informazioni da un file di testo in SI

Per leggere i caratteri russi dal file, è necessario configurare il lavoro con Cirillico utilizzando il comando
setlocale (lc_all, "russo");

Allo stesso tempo, è necessario connettersi #include all'inizio del programma

FSCANF () Operatore

Leggere la parola da file in Si. Il comando fscanf () viene utilizzato. Questo comando è simile al comando di immissione delle informazioni dall'interruttore a chiave solo il primo parametro è un puntatore al file.
fScanf (puntatore al file, "% Data Input Format1% Data Format2 ...", & Permenic1, & Variable2 ...);
Ad esempio, la squadra
fScanF (FIN, "% D% D% D", & A, & B, & C);
crede dal file che è legato al puntatore al file fin di tre variabili interi
Analizzeremo l'esempio di un programma che legge dal file di testo dati.txt a cui vengono registrate le colonne a tre cifre e scrive in array. Per ogni colonna informativa, la sua matrice. Dettaglio di.
#Includere.
#Includere.
Principale ()
(int a;
int b;
int c;
int i;
// Determina il puntatore al file
File * pinna;
// Apri il file da leggere
FIN \u003d FOTON ("C: \\\\ Utenti \\\\ User \\\\ Desktop \\\\ data.txt", "r");
// Lettura del grado dal file
per (i \u003d 0; io<3;i++)
{
// Leggere una stringa di tre valori di file e un record di array
FScanf (FIN, "% D% D% D", & A [I], & B [I], & C [I]);
}
// Conclusione di array sullo schermo
per (i \u003d 0; io<3;i++)
{
Printf ("% d% d% d", a [i], b [i], c [i]);
}
Getch ();
// chiudendo il file
FClose (FIN);
}

Posizione Lettura Informazioni dal file in C. Function Fets ()

L'istruzione FSCanf () legge la parola dal file, I.e. prima del primo spazio in arrivo.
Per leggere l'intera riga dal file dal file nel sistema.
iF (NULL! \u003d FGETS (variabile stringa, lunghezza della stringa, puntatore al file))
{
Azioni durante la lettura della linea
}
Ad esempio, un programma su SI che legge due righe dal file e li visualizza sullo schermo
#Includere.
#Includere.
#Includere.
Principale ()
{
// imposta stringa permanente
Char st1;
char st2;
// Determina il puntatore al file
File * pinna;
// Nast work con cirillico
Setlocale (lc_all, "russo");
// Apri il file da leggere
Fin \u003d fopen ("c: \\\\ data.txt", "r");
// Leggi la prima stringa dal file
IF (NULL! \u003d FETS (ST1, 100, FIN))
{
// Visualizza la stringa sullo schermo
Printf ("% s", st1);)
// Leggi la seconda stringa dal file
IF (NULL! \u003d FETS (ST2, 100, FIN))
{
// Visualizza la stringa sullo schermo
Printf ("% s", st2);)
// Chiudi il file per la lettura
FClose (FIN);
}

Registrare le informazioni in un file di testo in SI

Per la registrazione dei dati per file in si, è necessario aprire il file in modalità di registrazione
Il nome del puntatore al file \u003d fopen ("percorso al file", "w");
Per scrivere sulla stringa di file di testo, utilizzare il comando fprnitf (), che è simile al comando nel secondo parametro. Questo puntatore al file
fPRINTF (nome puntatore da file, "% input formato", variabili);
Ad esempio, scrivi alla variabile di valore di file out.txt a
a \u003d 10;
Fout \u003d fopen ("c: \\\\ Users \\\\ User \\\\ Desktop \\\\ out.txt", "w");
Fprintf (Fout, "% d", a);
Un esempio di un programma su SI che richiede due numeri e scrive al file out.txt sia questi numeri che la loro somma

#Includere.
#Includere.

principale ()
(int a;
int b;
int c;
File * Fout;
Fout \u003d fopen ("c: \\\\ Users \\\\ User \\\\ Desktop \\\\ out.txt", "w");
Printf ("Inserisci il primo numero");
Scanf ("% D", & a);
Printf ("Inserisci il secondo numero");
Scanf ("% d", & b);
c \u003d A + B;
Fprintf (Fout, "% d% d% d", a, b, c);
Getch ();
FClose (Fout);
}