SSTD FILESYSYM C ++

Un file system mantiene e classifica i file su un mezzo, spesso uno o più dischi di archiviazione, in un modo che li rende accessibili per il recupero. La maggior parte dei file system moderni mantiene i file organizzati in una forma simile a un albero (o gerarchico). Uno o più nodi radicali si trovano nella parte superiore dell'albero. Il filesystem è una libreria nello standard C ++ 17 che ci consente di lavorare con il percorso del file, le directory, lo stato ed errori dei file in un filesystem gerarchico. La spinta.La libreria del filesystem funge da base per la creazione di questa libreria standard. Con questa libreria, esploreremo le diverse funzioni del filesystem e le loro prestazioni in C ++ 17 e accederemo alle loro proprietà e alla ricerca. Lo spazio dei nomi STD :: Filesystem dell'intestazione del filesystem offre la libreria del filesystem. Useremo l'alias dello spazio dei nomi indicato nei seguenti esempi in tutte le istanze per mantenere il codice più semplice.

Esempio 1: usando std :: filesystem :: esiste

STD :: filesystem fornisce la funzione utilizzata per determinare se un file o una directory con il percorso o lo stato specificato già esiste. Per questo, implementiamo un programma in cui importa il "filesystem" della libreria e creiamo una funzione vuota "demo". Per la funzione demo, forniamo il percorso e la funzione di stato dal filesystem di classe. Quindi, utilizziamo la condizione IF-ELSE per restituire l'istruzione dell'esistenza del file.

All'interno della clausola IF, invochiamo la funzione "FS :: esiste" e passiamo la variabile "S" per lo stato del file e "PTH" per il percorso del file. Se esiste lo stato del file ed esiste il percorso del file, stampare "trovato". E se il file non esiste, l'istruzione "non trovata" viene stampata. La funzione principale è implementata con il percorso del file e la creazione di directory.

Innanzitutto, specifichiamo il percorso del file. Quindi, creiamo la directory e il collegamento simbolico per la directory per collegare i due file. Tutte le funzioni che utilizziamo sono supportate dalla libreria del filesystem. Per iterare le voci della directory, utilizziamo la funzione Directory_iterator.

#includere
#includere
#includere
#includere
Space names fs = std :: filesystem;
void demo (const fs :: path & pth, fs :: file_status s = fs :: file_status )

std :: cout << pth;
if (fs :: status_noknow (s) ? fs :: esiste (s): fs :: esiste (PTH))
std :: cout << " Found\n";
altro
std :: cout << "Not Found\n";

int main ()

const fs :: path filebox "filebox";
fs :: create_directory (filebox);
std :: ofstream filebox/"file";
fs :: create_symlink ("non esiste", filebox/"symlink");
demo (filebox);
per (const auto e voce: fs :: directory_iterator (filebox))
Demo (voce, voce.stato());
fs :: remok_all (filebox);

Per una raccolta di funzioni e codici C ++ 17, utilizziamo i seguenti comandi. Quindi, possiamo vedere l'esistenza del percorso del file e dello stato del file nella schermata di output:

Esempio 2: Utilizzo di std :: filesystem :: file_size

STD :: filesystem :: file_size è una funzione fornita dalla libreria STD :: filesystem di C++. Consideriamo l'esempio in cui viene superato il percorso del file e viene creato l'oggetto associato, insieme alla dimensione del file da recuperare. Poiché tutte le funzioni del filesystem sono supportate dalla libreria del filesystem, aggiungiamo la libreria "" al nostro programma. Quindi, con lo spazio dei nomi, etichettiamo la "STD :: FILESYSTEM" come "FS".

Quindi, utilizziamo la funzione FS :: Path e specifichiamo il percorso del file “Main.C". Quindi, chiamiamo std :: ofstream e passiamo l'oggetto del percorso del file al suo interno. Inoltre, utilizziamo la funzione put () che prende il carattere "A" per un uso normale. Successivamente, prendiamo la dimensione del file utilizzando la funzione filesystem :: file_size. Con il filesystem :: Rimuovi la funzione, rimuoviamo il percorso del file. Alla fine, abbiamo un blocco di try-catch per catturare e lanciare l'errore se si verifica.

#includere
#includere
#includere
Space names fs = std :: filesystem;
int main ()

FS :: Path FilePath = FS :: Current_Path () / "Main.C";
std :: ofstream (FilePath).put ('a');
std :: cout << "File size = " << fs::file_size(filepath) << '\n';
FS :: Rimuovi (FilePath);
Tentativo
fs :: file_size ("/dev");
catch (fs :: filesystem_error & e)
std :: cout << e.what() << '\n';

Abbiamo recuperato la dimensione del file implementando il programma con la funzione filesystem :: file_size. Abbiamo ricevuto l'errore del file system di non ottenere la dimensione del file.

Esempio 3: Utilizzo di std :: filesystem :: filesystem_error

Quando i sovraccarichi di lancio della libreria del filesystem non riescono, viene lanciato un oggetto di errore specificato dalla classe std :: filesystem :: filesystem. Usiamo il modulo di errore di sistema che gestisce l'errore del programma. Identifichiamo i percorsi dei file inesistenti nel codice successivo. Il blocco catch prende Std :: filesystem :: filesystem_error al suo interno per aver lanciato l'eccezione del filesystem.

Qui, utilizziamo le diverse chiamate di funzione per stampare le eccezioni per i file non trovati. Utilizziamo la funzione Std :: What () per rilevare l'eccezione che restituisce una sequenza di caratteri null. Quindi, utilizziamo la funzione Path () con l'oggetto File_error "E". Infine, stampiamo il valore, il messaggio e la categoria generati dalla funzione di errore del file system. Generiamo anche un'istruzione di codice di errore dalla funzione std :: error_code.

#includere
#includere
#includere
int main ()

const std :: filesystem :: percorso da "/nofile1/a", a "/nofile2/b";
Tentativo
std :: filesystem :: copy_file (da, a);

catch (std :: filesystem :: filesystem_error const & e)
std :: cout
<< "what(): " << e.what() << '\n'
<< "path1(): " << e.path1() << '\n'
<< "path2(): " << e.path2() << '\n'
<< "code().value(): " << e.code().value() << '\n'
<< "code().message(): " << e.code().message() << '\n'
<< "code().category(): " << e.code().category().name() << '\n';

std :: error_code err;
std :: filesystem :: copy_file (da, a, err);
std :: cout << "\nerror_code has non-throwing sets: " << err.message() << '\n';

Gli errori sono generati dalla funzione file_error in quanto non viene trovato tale file o directory.

Esempio 4: Utilizzo di std :: filesystem :: assoluta

Abbiamo un'altra funzione whis è la "std :: filesystem :: assolute" che fornisce il percorso assoluto del file. Un percorso è assoluto che include sempre il componente base e l'intero elenco di directory necessari per trovare il file. Qui, all'interno della funzione principale, utilizziamo la funzione STD :: filesystem :: e creiamo il suo oggetto come "fp". Quindi, diamo il percorso del file come "principale.C". Visualizziamo il percorso corrente del file e il percorso assoluto del file specificato con il comando cout. Il percorso assoluto viene visualizzato passando l'oggetto del percorso del file "FP" nella funzione "std :: filesystem :: assolute".

#includere
#includere
Space names fs = std :: filesystem;
int main ()

std :: filesystem :: path fp = "main.C";
std :: cout << "Current path " << fs::current_path() << '\n';
std :: cout << "Absolute path of" << fp << " is "
<< std::filesystem::absolute(fp) << '\n';

Possiamo vedere il percorso corrente del file nel nostro sistema e il percorso assoluto del file ottenuto dalla funzione assoluta del filesystem.

Conclusione

La libreria STD :: Filesystem, che ha una gamma di funzionalità, è introdotta in C ++ 17. Ma abbiamo trattato solo alcune funzioni del filesystem. Una libreria standard contiene classi e funzioni altamente vantaggiose e costruite da affrontare, e la gestione specifica del sistema operativo è astratta. Abbiamo implementato la funzione file system file_exist per conoscere l'esistenza del file nel nostro primo esempio. Quindi, abbiamo usato la funzione Dimensione del file per ottenere la dimensione del file. Inoltre, abbiamo utilizzato la funzione di errore del filesystem per mostrare come vengono generate le eccezioni in un file. Inoltre, abbiamo usato la funzione assoluta del filesystem per recuperare il percorso assoluto del file.