STD -Dateisystem C ++

Ein Dateisystem behält und klassifiziert die Dateien auf einem Medium, oft eine oder mehrere Speicherplatten, sodass sie zum Abrufen zugänglich sind. Die meisten modernen Dateisysteme halten die Dateien in einem baumartigen (oder hierarchischen) Formular organisiert. Ein oder mehrere Wurzelknoten befinden sich an der Oberseite des Baumes. Das Dateisystem ist eine Bibliothek in C ++ 17 Standard, mit der wir mit dem Dateipfad, den Verzeichnissen, dem Status und den Fehlern der Dateien in einem hierarchischen Dateisystem arbeiten können. Der Schub.Die Dateisystembibliothek dient als Grundlage für die Erstellung dieser Standardbibliothek. Mit dieser Bibliothek werden wir die verschiedenen Funktionen des Dateisystems und ihre Leistung in C ++ 17 untersuchen und auf ihre Eigenschaften und Suche zugreifen. Der Dateisystem -Header STD :: Dateisystem -Namespace bietet die Dateisystembibliothek an. Wir werden den in den folgenden Beispielen angegebenen Namespace -Alias ​​in allen Instanzen verwenden, um den Code einfacher zu halten.

Beispiel 1: Verwenden von STD :: Dateisystem :: existiert

Das STD :: Dateisystem enthält die Funktion, mit der festgestellt wird, ob eine Datei oder ein Verzeichnis mit dem angegebenen Pfad oder Status bereits vorhanden ist. Zu diesem Zweck implementieren wir ein Programm, in dem wir die Bibliothek „Dateisystem“ importieren und eine void -Funktion „Demo“ erstellen. Für die Demo -Funktion geben wir den Pfad und die Statusfunktion aus dem Klassendateisystem an. Anschließend verwenden wir die IF-ELSE-Bedingung, um die Anweisung der Datei-Existenz zurückzugeben.

In der IF -Klausel rufen wir die Funktion „fs :: existiert“ auf und übergeben die Variable "S" für den Dateistatus und "PTH" für den Dateipfad. Wenn der Dateistatus vorhanden ist und der Pfad der Datei existiert, druckt er "gefunden" "gefunden". Und wenn die Datei nicht vorhanden ist, wird die Anweisung „Nicht gefunden“ gedruckt. Die Hauptfunktion wird mit der Erstellung von Dateipfad und Verzeichnis implementiert.

Zunächst geben wir den Dateipfad an. Anschließend erstellen wir das Verzeichnis und das Symlink für das Verzeichnis, um die beiden Dateien zu verknüpfen. Alle von uns verwendeten Funktionen werden von der Dateisystembibliothek unterstützt. Um die Verzeichniseinträge zu iterieren, verwenden wir die Funktion Directory_iterator.

#enthalten
#enthalten
#enthalten
#enthalten
Namespace fs = std :: Dateisystem;
void Demo (const fs :: path & pth, fs :: file_status s = fs :: file_status )

std :: Cout << pth;
if (fs :: status_know (s) ? fs :: existiert (s): fs :: existiert (PTH))
std :: Cout << " Found\n";
anders
std :: Cout << "Not Found\n";

int main ()

const fs :: Path -Dateibox "Dateibox";
fs :: create_directory (Dateibox);
std :: Ofstream Dateibox/"Datei";
FS :: CREATE_SYMLINK ("Nicht existiert", FileBox/"Symlink");
Demo (Dateibox);
für (const automatisch & Eintrag: fs :: Directory_iterator (Dateibox))
Demo (Eintrag, Eintrag.Status());
FS :: REMED_ALL (Dateibox);

Für eine Zusammenstellung von C ++ 17 -Funktionen und -Codes verwenden wir die folgenden Befehle. Daher können wir die Existenz des Dateipfads und des Dateistatus auf dem Ausgabebildschirm sehen:

Beispiel 2: Verwenden von STD :: Dateisystem :: File_Size

Das STD :: Dateisystem :: File_Size ist eine Funktion, die von der STD :: Dateisystembibliothek von C bereitgestellt wird++. Betrachten wir das Beispiel, in dem der Dateipfad übergeben und das zugehörige Objekt erstellt wird, zusammen mit der zu abgerufenen Dateigröße. Da alle Funktionen des Dateisystems von der Dateisystembibliothek unterstützt werden, fügen wir unserem Programm die Bibliothek "" hinzu. Dann kennzeichnen wir mit dem Namespace das "std :: faterSystem" als "fs".

Anschließend verwenden wir die Funktion FS :: Pfad und geben den Dateipfad „Main an.C". Dann nennen wir das std :: Ofstream und übergeben das Dateipfadobjekt darin. Außerdem verwenden wir die Put () -Funktion, die das Zeichen „A“ für den normalen Gebrauch nimmt. Danach holen wir die Dateigröße mit der Dateisystem :: File_Size -Funktion. Mit der Dateisystem :: Entfernen Sie den Dateipfad entfernen. Am Ende haben wir einen Try-Catch-Block zum Fangen und Werfen des Fehlers, wenn er auftritt.

#enthalten
#enthalten
#enthalten
Namespace fs = std :: Dateisystem;
int main ()

fs :: Pfad filepath = fs :: current_path () / "Haupt.C";
std :: Ofstream (Filepath).put ('a');
std :: Cout << "File size = " << fs::file_size(filepath) << '\n';
fs :: entfernen (filepath);
versuchen
fs :: file_size ("/dev");
catch (fs :: fileSystem_error & e)
std :: Cout << e.what() << '\n';

Wir haben die Größe der Datei abgerufen, indem wir das Programm mit der Dateisystem :: File_Size -Funktion implementiert haben. Wir haben den Fehler des Dateisystems erhalten, die Dateigröße nicht zu erhalten.

Beispiel 3: Verwenden von STD :: Dateisystem :: fileSystem_error -Funktion

Wenn die Überladungen der Dateisystembibliotheksfunktionen fehlschlagen. Wir verwenden das Systemfehlermodul, das den Fehler des Programms behandelt. Wir identifizieren die Pfade der nicht existierenden Dateien im nachfolgenden Code. Der Catch -Block nimmt das std :: fileSystem :: fileSystem_error darin, um die Ausnahme des Dateisystems zu werfen.

Hier verwenden wir die verschiedenen Funktionsaufrufe, um die Ausnahmen für nicht gefundene Dateien zu drucken. Wir verwenden die STD :: What () -Funktion, um die Ausnahme zu erkennen, die eine Null-End-Zeichensequenz zurückgibt. Anschließend verwenden wir die Funktion path () mit dem File_Error -Objekt "E". Zuletzt drucken wir den Wert, die Nachricht und die Kategorie, die aus der Dateisystemfehlerfunktion generiert wurden. Wir generieren auch eine Fehlercode -Anweisung aus der Funktion STD :: ERROR_CODE.

#enthalten
#enthalten
#enthalten
int main ()

const
versuchen
std :: fileSystem :: Copy_file (von, bis);

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 (von, bis, err);
std :: Cout << "\nerror_code has non-throwing sets: " << err.message() << '\n';

Die Fehler werden durch die Funktion "File_error" generiert, da keine solche Datei oder Verzeichnis gefunden wird.

Beispiel 4: Verwenden von STD :: Dateisystem :: Absolute Funktion

Wir haben eine andere Funktion Whis ist das „std :: fileSystem :: Absolute“, das den absoluten Pfad der Datei verleiht. Ein Pfad ist absolut, der immer die Basiskomponente und die gesamte Verzeichnisliste enthält, die für die Suche nach der Datei benötigt wird. In der Hauptfunktion verwenden wir die Funktion STD :: Dateisystem :: Path und erstellen sein Objekt als „FP“. Dann geben wir den Pfad der Datei als „Haupt.C". Wir zeigen den aktuellen Pfad der Datei und den absoluten Pfad der angegebenen Datei mit dem COUT -Befehl an. Der absolute Pfad wird angezeigt, indem das Dateipfadobjekt „FP“ in der Funktion „std :: fileSystem :: Absolute“ übergeben wird.

#enthalten
#enthalten
Namespace fs = std :: Dateisystem;
int main ()

STD :: Dateisystem :: Path fp = "Main.C";
std :: Cout << "Current path " << fs::current_path() << '\n';
std :: Cout << "Absolute path of" << fp << " is "
<< std::filesystem::absolute(fp) << '\n';

Wir können den aktuellen Pfad der Datei in unserem System und den absoluten Pfad der Datei sehen, die aus der Absolutenfunktion des Dateisystems erhalten wird.

Abschluss

Die STD :: Dateisystembibliothek mit einer Reihe von Funktionen wird in C ++ 17 eingeführt. Aber wir haben nur einige Funktionen des Dateisystems behandelt. Eine Standardbibliothek enthält hoch vorteilhafte und sorgfältig erstellte Klassen und Funktionen, mit denen sich die operativen systemspezifischen Handhabung abstrahieren können. Wir haben die Dateisystemfunktionsdatei_Exist implementiert, um die Existenz der Datei in unserem ersten Beispiel zu kennen. Anschließend haben wir die Funktion der Dateigröße verwendet, um die Dateigröße zu erhalten. Darüber hinaus haben wir die Funktion "Dateisystemfehler" verwendet, um anzuzeigen, wie die Ausnahmen in einer Datei generiert werden. Außerdem haben wir die absolute Funktion des Dateisystems verwendet, um den absoluten Pfad der Datei abzurufen.