STD -filsystem C ++

Et filsystem holder og klassifiserer filene på et medium, ofte en eller flere lagringsdisker, på en måte som gjør dem tilgjengelige for henting. De fleste moderne filsystemer holder filene organisert i en trelignende (eller hierarkisk) form. En eller flere rotnoder er plassert på treets topp. Filsystemet er et bibliotek i C ++ 17 -standard som gjør oss i stand til å jobbe med filstien, kataloger, status og feil i filene i et hierarkisk filsystem. Boostet.Filesystem Library fungerer som grunnlaget for opprettelsen av dette standardbiblioteket. Med dette biblioteket vil vi utforske de forskjellige funksjonene til filsystemet og deres ytelse i C ++ 17 og få tilgang til egenskapene deres og søk. Filesystem Headers STD :: Filesystem Namespace tilbyr FilSystem -biblioteket. Vi vil bruke navneområdet alias gitt i følgende eksempler i alle tilfeller for å holde koden enklere.

Eksempel 1: Bruke std :: filsystem :: eksisterer

STD :: Filsystem gir funksjonen som brukes til å bestemme om en fil eller katalog med den spesifiserte banen eller statusen allerede eksisterer. For dette implementerer vi et program der vi importerer biblioteket “Filsystem” og lager en tomromfunksjon “Demo”. For demo -funksjonen gir vi banen og statusfunksjonen fra klassefilsystemet. Deretter bruker vi IF-Else-tilstanden for å returnere uttalelsen om filens eksistens.

Inne. Hvis filstatusen eksisterer og banen til filen eksisterer, skriver den ut "funnet". Og hvis filen ikke eksisterer, skrives uttalelsen "ikke funnet". Hovedfunksjonen implementeres med filstien og katalogopprettelsen.

Først spesifiserer vi filstien. Deretter oppretter vi katalogen og symlink for katalogen for å koble de to filene. Alle funksjonene vi bruker støttes av Filsystem -biblioteket. For å iterere over katalogoppføringene, bruker vi DIRECTORY_ITERATOR -funksjonen.

#inkludere
#inkludere
#inkludere
#inkludere
namespace fs = std :: filsystem;
void demo (const fs :: path & pth, fs :: file_status s = fs :: file_status )

std :: cout << pth;
if (fs :: status_neknede (er) ? fs :: eksisterer (er): fs :: eksisterer (PTH))
std :: cout << " Found\n";
ellers
std :: cout << "Not Found\n";

int main ()

const fs :: path filebox "filebox";
fs :: create_directory (filebox);
std :: ofStream filebox/"fil";
fs :: create_symlink ("ikke eksisterer", filebox/"symlink");
demo (filebox);
for (Const Auto & Entry: FS :: Directory_Iterator (FileBox)))
Demo (oppføring, oppføring.status());
fs :: remove_all (filebox);

For en samling av C ++ 17 -funksjoner og koder, bruker vi følgende kommandoer. Derfor kan vi se eksistensen av filstien og filstatusen på utgangsskjermen:

Eksempel 2: Bruke std :: filsystem :: File_Size

Std :: Filesystem :: File_Size er en funksjon levert av STD :: Filesystem Library of C++. La oss vurdere eksemplet der filstien blir bestått og det tilhørende objektet opprettes, sammen med filstørrelsen som skal hentes. Siden alle funksjonene til filsystemet støttes av Filesystem -biblioteket, legger vi til “” -biblioteket til programmet vårt. Deretter, med navneområdet, merker vi "STD :: Filsystem" som "FS".

Deretter bruker vi FS :: PATH -funksjonen og spesifiserer filstien “Main.C ”. Deretter kaller vi std :: ofstream og passerer filstiobjektet inni det. Vi bruker også Put () -funksjonen som tar karakteren "A" for normal bruk. Etter det henter vi filstørrelsen ved å bruke Filesystem :: File_Size -funksjonen. Med filsystemet :: Fjern funksjonen, fjerner vi filstien. Til slutt har vi en prøvefangsblokk for å fange og kaste feilen hvis den oppstår.

#inkludere
#inkludere
#inkludere
namespace fs = std :: filsystem;
int main ()

fs :: sti filepath = fs :: current_path () / "main.c ";
std :: ofstream (filepath).put ('a');
std :: cout << "File size = " << fs::file_size(filepath) << '\n';
FS :: Fjern (FilePath);
prøv
fs :: file_size ("/dev");
fangst (fs :: filesystem_error & e)
std :: cout << e.what() << '\n';

Vi hentet størrelsen på filen ved å implementere programmet med Filesystem :: File_Size -funksjonen. Vi fikk filsystemfeilen ved ikke å få filstørrelsen.

Eksempel 3: Bruke STD :: Filesystem :: Filesystem_error -funksjonen

Når kasteoverbelastningen til filsystembibliotekfunksjonene mislykkes, kastes et feilobjekt spesifisert av klassen STD :: Filsystem :: FilSystem -feilen. Vi bruker systemfeilmodulen som håndterer feilen i programmet. Vi identifiserer banene til de ikke-eksisterende filene i den påfølgende koden. Fangstblokken tar STD :: Filesystem :: Filesystem_error inni den for å kaste filsystemets unntak.

Her bruker vi de forskjellige funksjonssamtalene for å skrive ut unntakene for filer som ikke er funnet. Vi bruker STD :: What () -funksjonen for å oppdage unntaket som returnerer en null-endt karaktersekvens. Deretter bruker vi Path () -funksjonen med File_Error -objektet “E”. Til slutt skriver vi ut verdien, meldingen og kategorien generert fra filsystemfeilfunksjonen. Vi genererer også en feilkodeoppgave fra STD :: FEIL_CODE -funksjonen.

#inkludere
#inkludere
#inkludere
int main ()

const std :: filesystem :: sti fra "/nofile1/a", til "/nofile2/b";
prøv
std :: filsystem :: copy_file (fra, til);

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 feil;
std :: filsystem :: copy_file (fra, til, feil);
std :: cout << "\nerror_code has non-throwing sets: " << err.message() << '\n';

Feilene genereres av File_Error -funksjonen som ingen slik fil eller katalog er funnet.

Eksempel 4: Bruke STD :: Filsystem :: Absolutt funksjon

Vi har en annen funksjon Whis er “Std :: Filsystem :: Absolute” som gir den absolutte banen til filen. En bane er absolutt som alltid inkluderer grunnkomponenten og hele kataloglisten som er nødvendig for å finne filen. Her, inne i hovedfunksjonen, bruker vi STD :: Filsystem :: Path -funksjonen og oppretter objektet som "FP". Deretter gir vi banen til filen som "Main.C ”. Vi viser den gjeldende banen til filen og den absolutte banen til den spesifiserte filen med COUT -kommandoen. Den absolutte banen vises ved å passere filstiobjektet "FP" i "Std :: Filsystem :: Absolute" -funksjonen ".

#inkludere
#inkludere
namespace fs = std :: filsystem;
int main ()

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

Vi kan se den gjeldende banen til filen i vårt system og den absolutte banen til filen som er hentet fra filsystemet Absolute Function.

Konklusjon

STD :: Filesystem Library, som har en rekke funksjonaliteter, introduseres i C ++ 17. Men vi dekket bare noen få funksjoner av filsystemet. Et standardbibliotek inneholder svært fordelaktige og gjennomtenkte bygde klasser og funksjoner å håndtere, og den operasjonssystemspesifikke håndteringen er abstrahert bort. Vi implementerte filsystemfunksjonen File_Exist for å vite eksistensen av filen i vårt første eksempel. Deretter brukte vi filstørrelsesfunksjonen for å få filstørrelsen. Videre benyttet vi filesystemfeilfunksjonen for å vise hvordan unntakene genereres i en fil. Vi brukte også den absolutte funksjonen til filsystemet for å hente den absolutte banen til filen.